Struct doublecount::Transaction

pub struct Transaction {
    pub description: Option<String>,
    pub date: NaiveDate,
    pub elements: Vec<TransactionElement>,
}

A movement of Commodity between two or more accounts on a given date. Implements Action so it can be applied to change AccountStates.

The sum of the Commodity amounts contained within a transaction's TransactionElements needs to be equal to zero, or one of the elements needs to have a None value amount.

Fields

description: Option<String>

Description of this transaction.

date: NaiveDate

The date that the transaction occurred.

elements: Vec<TransactionElement>

Elements which compose this transaction.

See Transaction for more information about the constraints which apply to this field.

Implementations

impl Transaction

pub fn new<S: Into<String>>(
    description: Option<S>,
    date: NaiveDate,
    elements: Vec<TransactionElement>
) -> Transaction

Create a new Transaction.

pub fn new_simple<S: Into<String>>(
    description: Option<S>,
    date: NaiveDate,
    from_account: AccountID,
    to_account: AccountID,
    amount: Commodity,
    exchange_rate: Option<ExchangeRate>
) -> Transaction

Create a new simple Transaction, containing only two elements, transfering an amount from from_account to to_account on the given date, with the given exchange_rate (required if the currencies of the accounts are different).

Example

use doublecount::Account;
use commodity::{CommodityType, Commodity};
use chrono::Local;
use std::str::FromStr;

let aud = Rc::from(CommodityType::from_currency_alpha3("AUD").unwrap());

let account1 = Rc::from(Account::new_with_id(Some("Account 1"), aud.id, None));
let account2 = Rc::from(Account::new_with_id(Some("Account 2"), aud.id, None));

let transaction = Transaction::new_simple(
   Some("balancing"),
   Local::today().naive_local(),
   account1.id,
   account2.id,
   Commodity::from_str("100.0 AUD").unwrap(),
   None,
);

assert_eq!(2, transaction.elements.len());
let element0 = transaction.elements.get(0).unwrap();
let element1 = transaction.elements.get(1).unwrap();
assert_eq!(Some(Commodity::from_str("-100.0 AUD").unwrap()), element0.amount);
assert_eq!(account1.id, element0.account_id);
assert_eq!(account2.id, element1.account_id);
assert_eq!(None, element1.amount);

pub fn get_element(&self, account_id: &AccountID) -> Option<&TransactionElement>

Get the TransactionElement associated with the given Account's id.

Trait Implementations

impl Action for Transaction

fn date(&self) -> NaiveDate

The date/time (in the account history) that the action was performed.

fn perform(
    &self,
    program_state: &mut ProgramState
) -> Result<(), AccountingError>

Perform the action to mutate the ProgramState.

fn action_type(&self) -> ActionType

What type of action is being performed.

impl Clone for Transaction

fn clone(&self) -> Transaction

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Transaction

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Transaction

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl Display for Transaction

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

Formats the value using the given formatter.

impl From<Transaction> for ActionTypeValue

fn from(action: Transaction) -> Self

Performs the conversion.

impl PartialEq<Transaction> for Transaction

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=.

impl Serialize for Transaction

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 Transaction