wave-api 0.1.0

Typed Rust client for the Wave Accounting GraphQL API
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136

use chrono::NaiveDate;
use rust_decimal::Decimal;
use serde::Serialize;

use crate::enums::{BalanceType, TransactionDirection};

/// Anchor account input for a money transaction.
#[derive(Debug, Clone, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct MoneyTransactionAnchorInput {
    pub account_id: String,
    pub amount: Decimal,
    pub direction: TransactionDirection,
}

/// Line item input for a money transaction.
#[derive(Debug, Clone, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct MoneyTransactionLineItemInput {
    pub account_id: String,
    pub amount: Decimal,
    pub balance: BalanceType,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub customer_id: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub taxes: Option<Vec<MoneyTransactionSalesTaxInput>>,
}

impl MoneyTransactionLineItemInput {
    pub fn new(
        account_id: impl Into<String>,
        amount: Decimal,
        balance: BalanceType,
    ) -> Self {
        Self {
            account_id: account_id.into(),
            amount,
            balance,
            customer_id: None,
            description: None,
            taxes: None,
        }
    }

    pub fn description(mut self, v: impl Into<String>) -> Self {
        self.description = Some(v.into());
        self
    }
    pub fn customer_id(mut self, v: impl Into<String>) -> Self {
        self.customer_id = Some(v.into());
        self
    }
}

/// Sales tax input for a money transaction line item.
#[derive(Debug, Clone, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct MoneyTransactionSalesTaxInput {
    pub sales_tax_id: String,
    pub amount: Decimal,
}

/// Input for creating a single money transaction.
#[derive(Debug, Clone, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct MoneyTransactionCreateInput {
    pub business_id: String,
    pub external_id: String,
    pub date: NaiveDate,
    pub description: String,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub notes: Option<String>,
    pub anchor: MoneyTransactionAnchorInput,
    pub line_items: Vec<MoneyTransactionLineItemInput>,
}

impl MoneyTransactionCreateInput {
    pub fn new(
        business_id: impl Into<String>,
        external_id: impl Into<String>,
        date: NaiveDate,
        description: impl Into<String>,
        anchor: MoneyTransactionAnchorInput,
        line_items: Vec<MoneyTransactionLineItemInput>,
    ) -> Self {
        Self {
            business_id: business_id.into(),
            external_id: external_id.into(),
            date,
            description: description.into(),
            notes: None,
            anchor,
            line_items,
        }
    }

    pub fn notes(mut self, v: impl Into<String>) -> Self {
        self.notes = Some(v.into());
        self
    }
}

/// Transaction details for bulk creation.
#[derive(Debug, Clone, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct MoneyTransactionDetails {
    pub external_id: String,
    pub date: NaiveDate,
    pub description: String,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub notes: Option<String>,
    pub anchor: MoneyTransactionAnchorInput,
    pub line_items: Vec<MoneyTransactionLineItemInput>,
}

/// Input for bulk creating money transactions.
#[derive(Debug, Clone, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct MoneyTransactionsCreateInput {
    pub business_id: String,
    pub transactions: Vec<MoneyTransactionDetails>,
}

impl MoneyTransactionsCreateInput {
    pub fn new(
        business_id: impl Into<String>,
        transactions: Vec<MoneyTransactionDetails>,
    ) -> Self {
        Self {
            business_id: business_id.into(),
            transactions,
        }
    }
}