Struct DataFromDiskWithItemsOfKind 

pub struct DataFromDiskWithItemsOfKind<Items>
where
    Items: Serialize + MaybeIsExpenses,
{ /* private fields */ }

The input data for the invoice, which includes information about the invoice, the vendor, and the client and the products/services included in the invoice.

Implementations

impl<Items> DataFromDiskWithItemsOfKind<Items>

where Items: Serialize + MaybeIsExpenses,

pub fn builder() -> DataFromDiskWithItemsOfKindBuilder<Items>

Create an instance of DataFromDiskWithItemsOfKind using the builder syntax

impl<Items> DataFromDiskWithItemsOfKind<Items>

where Items: Serialize + MaybeIsExpenses,

pub fn information(&self) -> &InvoiceInfoFull

Information about this specific invoice.

pub fn vendor(&self) -> &CompanyInformation

The company that issued the invoice, the vendor/seller/supplier/issuer.

pub fn client(&self) -> &CompanyInformation

The company that pays the invoice, the customer/buyer.

pub fn line_items(&self) -> &Items

Services or expenses included in this invoice to be paid by the client.

pub fn payment_info(&self) -> &PaymentInformation

Payment information for the vendor, used for international transfers. This includes the IBAN, bank name, and BIC. This is used to ensure that the client can pay the invoice correctly.

impl<Items> DataFromDiskWithItemsOfKind<Items>

where Items: Serialize + MaybeIsExpenses,

pub fn absolute_path_and_name(&self) -> Result<PathAndName, Error>

Returns the absolute path where the invoice will be saved. If the path is relative, it will be created relative to the workspace root. If the path is absolute, it will be returned as is.

Errors

Returns an error if the path is relative and the folder cannot be created, or if the path is absolute but invalid.

Examples

extern crate klirr_core;
use klirr_core::prelude::*;
let data = DataWithItemsPricedInSourceCurrency::builder()
   .information(InvoiceInfoFull::sample())
  .vendor(CompanyInformation::sample())
  .client(CompanyInformation::sample())
  .line_items(LineItemsPricedInSourceCurrency::sample())
  .payment_info(PaymentInformation::sample())
  .output_path(OutputPath::Name("invoice.pdf".into()))
  .build();

let path_and_name = data.absolute_path_and_name().unwrap();
assert!(path_and_name.path().ends_with("invoice.pdf"));
assert_eq!(path_and_name.name(), "invoice.pdf");

impl DataFromDiskWithItemsOfKind<LineItemsPricedInSourceCurrency>

pub fn to_typst( self, exchange_rates: ExchangeRates, ) -> Result<DataFromDiskWithItemsOfKind<LineItemsFlat>, Error>

Converts the DataWithItemsPricedInSourceCurrency into a PreparedData which is compatible with Typst rendering. This method prepares the invoice data for rendering by creating an ExchangeRates object and converting the line items into a flat structure.

Errors

Returns an error if the line items cannot be converted to a flat structure.

Examples

extern crate klirr_core;
use klirr_core::prelude::*;
let data = DataWithItemsPricedInSourceCurrency::sample();
let exchange_rates = ExchangeRates::builder().rates(ExchangeRatesMap::from_iter([(Currency::GBP, UnitPrice::from(dec!(10.0))), (Currency::EUR, UnitPrice::from(dec!(8.0)))])).target_currency(Currency::EUR).build();
let result = data.to_typst(exchange_rates);
assert!(result.is_ok(), "Expected conversion to succeed, got: {:?}", result);

Trait Implementations

impl<Items> Clone for DataFromDiskWithItemsOfKind<Items>

where Items: Clone + Serialize + MaybeIsExpenses,

fn clone(&self) -> DataFromDiskWithItemsOfKind<Items>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<Items> Debug for DataFromDiskWithItemsOfKind<Items>

where Items: Debug + Serialize + MaybeIsExpenses,

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

Formats the value using the given formatter.

impl<'de, Items> Deserialize<'de> for DataFromDiskWithItemsOfKind<Items>

where Items: Serialize + MaybeIsExpenses + Deserialize<'de>,

fn deserialize<__D>( __deserializer: __D, ) -> Result<DataFromDiskWithItemsOfKind<Items>, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<Items> Eq for DataFromDiskWithItemsOfKind<Items>

where Items: Eq + Serialize + MaybeIsExpenses,

impl<Items> HasSample for DataFromDiskWithItemsOfKind<Items>

where Items: Serialize + MaybeIsExpenses + HasSample,

fn sample() -> DataFromDiskWithItemsOfKind<Items>

Returns a sample instance of the type.

fn sample_other() -> DataFromDiskWithItemsOfKind<Items>

impl<Items> Hash for DataFromDiskWithItemsOfKind<Items>

where Items: Hash + Serialize + MaybeIsExpenses,

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<Items> PartialEq for DataFromDiskWithItemsOfKind<Items>

where Items: PartialEq + Serialize + MaybeIsExpenses,

fn eq(&self, other: &DataFromDiskWithItemsOfKind<Items>) -> 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<Items> Serialize for DataFromDiskWithItemsOfKind<Items>

where Items: Serialize + MaybeIsExpenses,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<Items> StructuralPartialEq for DataFromDiskWithItemsOfKind<Items>

where Items: Serialize + MaybeIsExpenses,

impl ToTypst for DataFromDiskWithItemsOfKind<LineItemsFlat>