Struct AccountsReceivable 

pub struct AccountsReceivable { /* private fields */ }

Accounts Receivable interface.

Implementations

impl AccountsReceivable

pub fn get_aging_summary(&self) -> Result<ArAgingSummary>

Get overall AR aging summary.

Example

use stateset_embedded::Commerce;

let commerce = Commerce::new(":memory:")?;

let aging = commerce.accounts_receivable().get_aging_summary()?;
println!("Current: ${}", aging.current);
println!("1-30 days: ${}", aging.days_1_30);
println!("31-60 days: ${}", aging.days_31_60);
println!("61-90 days: ${}", aging.days_61_90);
println!("90+ days: ${}", aging.days_over_90);
println!("Total: ${}", aging.total);

pub fn get_customer_aging( &self, customer_id: Uuid, ) -> Result<Option<CustomerArAging>>

Get AR aging for a specific customer.

pub fn get_aging_report( &self, filter: ArAgingFilter, ) -> Result<Vec<CustomerArAging>>

Get detailed AR aging report with filtering.

pub fn log_collection_activity( &self, input: CreateCollectionActivity, ) -> Result<CollectionActivity>

Log a collection activity (call, email, dunning letter, etc.).

Example

use stateset_embedded::{Commerce, CreateCollectionActivity, CollectionActivityType};
use uuid::Uuid;

let commerce = Commerce::new(":memory:")?;

let activity = commerce.accounts_receivable().log_collection_activity(
    CreateCollectionActivity {
        invoice_id: Uuid::new_v4(),
        activity_type: CollectionActivityType::PhoneCall,
        notes: Some("Spoke with customer, promised to pay by Friday".into()),
        contact_method: Some("Phone".into()),
        contact_result: Some("Promise to pay".into()),
        performed_by: Some("John Collector".into()),
        ..Default::default()
    }
)?;

pub fn list_collection_activities( &self, filter: CollectionActivityFilter, ) -> Result<Vec<CollectionActivity>>

List collection activities with filtering.

pub fn update_collection_status( &self, invoice_id: Uuid, status: CollectionStatus, ) -> Result<()>

Update the collection status of an invoice.

pub fn get_invoices_due_for_dunning(&self) -> Result<Vec<Invoice>>

Get invoices that are due for dunning letters.

pub fn send_dunning_letter( &self, invoice_id: Uuid, letter_type: DunningLetterType, sent_by: Option<&str>, ) -> Result<CollectionActivity>

Send a dunning letter and log the activity.

Example

use stateset_embedded::{Commerce, DunningLetterType};
use uuid::Uuid;

let commerce = Commerce::new(":memory:")?;

let activity = commerce.accounts_receivable().send_dunning_letter(
    Uuid::new_v4(), // invoice_id
    DunningLetterType::Reminder1,
    Some("ar_system"),
)?;

pub fn create_write_off(&self, input: CreateWriteOff) -> Result<WriteOff>

Create a write-off for an uncollectable invoice.

Example

use stateset_embedded::{Commerce, CreateWriteOff, WriteOffReason};
use rust_decimal_macros::dec;
use uuid::Uuid;

let commerce = Commerce::new(":memory:")?;

let write_off = commerce.accounts_receivable().create_write_off(CreateWriteOff {
    invoice_id: Uuid::new_v4(),
    amount: dec!(500.00),
    reason: WriteOffReason::Uncollectable,
    notes: Some("Customer bankruptcy".into()),
    approved_by: Some("CFO".into()),
})?;

pub fn get_write_off(&self, id: Uuid) -> Result<Option<WriteOff>>

Get a write-off by ID.

pub fn list_write_offs(&self, filter: WriteOffFilter) -> Result<Vec<WriteOff>>

List write-offs with filtering.

pub fn reverse_write_off(&self, id: Uuid) -> Result<WriteOff>

Reverse a write-off (restore invoice to collections).

pub fn create_credit_memo(&self, input: CreateCreditMemo) -> Result<CreditMemo>

Create a credit memo for a customer.

Example

use stateset_embedded::{Commerce, CreateCreditMemo, CreditMemoReason};
use rust_decimal_macros::dec;
use uuid::Uuid;

let commerce = Commerce::new(":memory:")?;

let memo = commerce.accounts_receivable().create_credit_memo(CreateCreditMemo {
    customer_id: Uuid::new_v4(),
    original_invoice_id: Some(Uuid::new_v4()),
    reason: CreditMemoReason::ReturnCredit,
    amount: dec!(150.00),
    notes: Some("Credit for returned merchandise".into()),
})?;

pub fn get_credit_memo(&self, id: Uuid) -> Result<Option<CreditMemo>>

Get a credit memo by ID.

pub fn get_credit_memo_by_number( &self, number: &str, ) -> Result<Option<CreditMemo>>

Get a credit memo by number.

pub fn list_credit_memos( &self, filter: CreditMemoFilter, ) -> Result<Vec<CreditMemo>>

List credit memos with filtering.

pub fn apply_credit_memo(&self, input: ApplyCreditMemo) -> Result<CreditMemo>

Apply a credit memo to an invoice.

pub fn void_credit_memo(&self, id: Uuid) -> Result<CreditMemo>

Void a credit memo (only if not yet applied).

pub fn get_unapplied_credits( &self, customer_id: Uuid, ) -> Result<Vec<CreditMemo>>

Get unapplied credit memos for a customer.

pub fn apply_payment_to_invoices( &self, input: ApplyPaymentToInvoices, ) -> Result<Vec<ArPaymentApplication>>

Apply a payment to one or more invoices.

Example

use stateset_embedded::{Commerce, ApplyPaymentToInvoices, InvoicePaymentApplication};
use rust_decimal_macros::dec;
use uuid::Uuid;

let commerce = Commerce::new(":memory:")?;

let applications = commerce.accounts_receivable().apply_payment_to_invoices(
    ApplyPaymentToInvoices {
        payment_id: Uuid::new_v4(),
        applications: vec![
            InvoicePaymentApplication {
                invoice_id: Uuid::new_v4(),
                amount: dec!(500.00),
            },
            InvoicePaymentApplication {
                invoice_id: Uuid::new_v4(),
                amount: dec!(250.00),
            },
        ],
    }
)?;

pub fn get_payment_applications( &self, payment_id: Uuid, ) -> Result<Vec<ArPaymentApplication>>

Get all payment applications for a payment.

pub fn unapply_payment(&self, application_id: Uuid) -> Result<()>

Unapply a payment application (remove application, restore invoice balance).

pub fn get_customer_summary( &self, customer_id: Uuid, ) -> Result<Option<CustomerArSummary>>

Get AR summary for a customer.

pub fn generate_statement( &self, request: GenerateStatementRequest, ) -> Result<CustomerStatement>

Generate a customer statement.

Example

use stateset_embedded::{Commerce, GenerateStatementRequest};
use chrono::Utc;
use uuid::Uuid;

let commerce = Commerce::new(":memory:")?;

let statement = commerce.accounts_receivable().generate_statement(
    GenerateStatementRequest {
        customer_id: Uuid::new_v4(),
        period_start: None, // defaults to 30 days ago
        period_end: None,   // defaults to now
        include_paid_invoices: Some(false),
    }
)?;

println!("Statement for: {}", statement.customer_name);
println!("Closing balance: ${}", statement.closing_balance);

pub fn get_total_outstanding(&self) -> Result<Decimal>

Get total outstanding receivables.

pub fn get_dso(&self, days: i32) -> Result<Decimal>

Calculate Days Sales Outstanding (DSO).

pub fn get_average_days_to_pay(&self, customer_id: Uuid) -> Result<Option<i32>>

Get average days to pay for a customer.

pub fn get_customers_batch( &self, ids: Vec<Uuid>, ) -> Result<Vec<CustomerArSummary>>

Get AR summary for multiple customers.

Trait Implementations

impl Debug for AccountsReceivable

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

Formats the value using the given formatter.