zenmoney-rs 0.3.0

Rust client library for the ZenMoney 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
137
138
139
140
141
142
143
144

//! Recurring transaction reminder model.

use chrono::{DateTime, NaiveDate, Utc};
use serde::{Deserialize, Serialize};

use super::{AccountId, InstrumentId, Interval, MerchantId, ReminderId, TagId, UserId};

/// A recurring transaction template.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Reminder {
    /// Unique identifier (UUID).
    pub id: ReminderId,
    /// Last modification timestamp.
    #[serde(with = "chrono::serde::ts_seconds")]
    pub changed: DateTime<Utc>,
    /// Owner user identifier.
    pub user: UserId,
    /// Income currency instrument.
    pub income_instrument: InstrumentId,
    /// Income destination account.
    pub income_account: AccountId,
    /// Income amount (>= 0).
    pub income: f64,
    /// Outcome currency instrument.
    pub outcome_instrument: InstrumentId,
    /// Outcome source account.
    pub outcome_account: AccountId,
    /// Outcome amount (>= 0).
    pub outcome: f64,
    /// Associated category tags.
    pub tag: Option<Vec<TagId>>,
    /// Associated merchant.
    pub merchant: Option<MerchantId>,
    /// Payee name.
    pub payee: Option<String>,
    /// User comment.
    pub comment: Option<String>,
    /// Recurrence interval unit.
    pub interval: Option<Interval>,
    /// Recurrence step count.
    pub step: Option<i32>,
    /// Specific day points within the interval.
    pub points: Option<Vec<i32>>,
    /// First occurrence date.
    pub start_date: NaiveDate,
    /// Last occurrence date.
    pub end_date: Option<NaiveDate>,
    /// Whether to send notifications.
    pub notify: bool,
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn deserialize_monthly_reminder() {
        let json = r#"{
            "id": "rem-001",
            "changed": 1700000000,
            "user": 123,
            "incomeInstrument": 1,
            "incomeAccount": "acc-001",
            "income": 0,
            "outcomeInstrument": 1,
            "outcomeAccount": "acc-001",
            "outcome": 5000.0,
            "tag": ["tag-rent"],
            "merchant": null,
            "payee": "Landlord",
            "comment": "Monthly rent",
            "interval": "month",
            "step": 1,
            "points": [1],
            "startDate": "2024-01-01",
            "endDate": "2025-01-01",
            "notify": true
        }"#;
        let reminder: Reminder = serde_json::from_str(json).unwrap();
        assert_eq!(reminder.id, ReminderId::new("rem-001".to_owned()));
        assert_eq!(reminder.interval, Some(Interval::Month));
        assert_eq!(reminder.step, Some(1));
        assert_eq!(reminder.points, Some(vec![1]));
        assert!(reminder.notify);
    }

    #[test]
    fn deserialize_one_time_reminder() {
        let json = r#"{
            "id": "rem-002",
            "changed": 1700000000,
            "user": 123,
            "incomeInstrument": 1,
            "incomeAccount": "acc-001",
            "income": 0,
            "outcomeInstrument": 1,
            "outcomeAccount": "acc-001",
            "outcome": 1000.0,
            "tag": null,
            "merchant": null,
            "payee": null,
            "comment": null,
            "interval": null,
            "step": null,
            "points": null,
            "startDate": "2024-06-15",
            "endDate": null,
            "notify": false
        }"#;
        let reminder: Reminder = serde_json::from_str(json).unwrap();
        assert!(reminder.interval.is_none());
        assert!(reminder.step.is_none());
        assert!(!reminder.notify);
    }

    #[test]
    fn serialize_roundtrip() {
        let reminder = Reminder {
            id: ReminderId::new("r-1".to_owned()),
            changed: DateTime::from_timestamp(1_700_000_000, 0).unwrap(),
            user: UserId::new(1),
            income_instrument: InstrumentId::new(1),
            income_account: AccountId::new("a-1".to_owned()),
            income: 0.0,
            outcome_instrument: InstrumentId::new(1),
            outcome_account: AccountId::new("a-1".to_owned()),
            outcome: 500.0,
            tag: None,
            merchant: None,
            payee: None,
            comment: None,
            interval: Some(Interval::Week),
            step: Some(2),
            points: Some(vec![0, 1]),
            start_date: NaiveDate::from_ymd_opt(2024, 1, 1).unwrap(),
            end_date: None,
            notify: true,
        };
        let json = serde_json::to_string(&reminder).unwrap();
        let deserialized: Reminder = serde_json::from_str(&json).unwrap();
        assert_eq!(deserialized, reminder);
    }
}