Struct FinancialTransaction 

pub struct FinancialTransaction {
    pub instructed_amount: Option<MonetaryAmount>,
    pub debtor_account: Option<BankAccount>,
    pub creditor_account: Option<BankAccount>,
    pub execution_date: Option<String>,
    pub end_to_end_id: Option<String>,
}

A financial transaction. Schema.org base type: MoneyTransfer.

Authors typically supply instructed_amount plus debtor/creditor accounts; the resulting JSON-LD exposes a Schema.org-shaped amount field alongside the namespaced iso20022:*Account references.

Fields

instructed_amount: Option<MonetaryAmount>

Amount being transferred.

debtor_account: Option<BankAccount>

Account being debited.

creditor_account: Option<BankAccount>

Account being credited.

execution_date: Option<String>

ISO 8601 timestamp.

end_to_end_id: Option<String>

Optional unique identifier (EndToEndId / MessageId).

Implementations

impl FinancialTransaction

pub fn to_jsonld(&self) -> Value

Builds the JSON-LD blob for this transaction.

Examples

use ssg::seo::jsonld::iso20022::{FinancialTransaction, MonetaryAmount};
let tx = FinancialTransaction {
    instructed_amount: Some(MonetaryAmount {
        currency: "EUR".into(),
        amount: 50.0,
    }),
    ..FinancialTransaction::default()
};
let v = tx.to_jsonld();
assert_eq!(v["@type"], "MoneyTransfer");
assert_eq!(v["amount"]["currency"], "EUR");

Trait Implementations

impl Clone for FinancialTransaction

fn clone(&self) -> FinancialTransaction

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for FinancialTransaction

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for FinancialTransaction

fn default() -> FinancialTransaction

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for FinancialTransaction

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for FinancialTransaction

fn eq(&self, other: &FinancialTransaction) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for FinancialTransaction

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for FinancialTransaction