mercury-rust 0.1.0

Library that interacts with Mercury Bank 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
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160

use chrono::{DateTime, Utc};
use crate::resources::{Address, List};
use crate::client::Client;
// use serde::{Serialize, Deserialize};

#[derive(Deserialize, Serialize, Debug, Clone, PartialEq)]
#[serde(rename_all="camelCase")]
pub struct Transaction {
    pub amount: f32,
    pub bank_description: Option<String>,
    pub counterparty_id: String,
    pub counterparty_name: String,
    pub counterparty_nickname: Option<String>,
    pub created_at: DateTime<Utc>,
    pub dashboard_link: String,
    pub details: TransactionDetails,
    pub estimated_delivery_date: DateTime<Utc>,
    pub failed_at: Option<DateTime<Utc>>,
    pub id: String,
    pub kind: TransactionDetailKind,
    pub note: Option<String>,
    pub external_memo: Option<String>,
    pub posted_at: Option<DateTime<Utc>>,
    pub reason_for_failure: Option<String>,
    pub status: TransactionDetailStatus,
    pub fee_id: Option<String>
}

#[derive(Deserialize, Serialize, Debug, Clone, PartialEq)]
#[serde(rename_all="camelCase")]
pub struct TransactionDetails {
    pub address: Option<Address>,
    pub domestic_wire_routing_info: Option<DomesticWireRoutingInfo>,
    pub electronic_routing_info: Option<ElectronicRoutingInfo>,
    pub international_wire_routing_info: Option<InternationalWireRoutingInfo>,

}

#[derive(Deserialize, Serialize, Debug, Clone, PartialEq, Eq)]
#[serde(rename_all="camelCase")]
pub enum TransactionDetailStatus {
    Pending,
    Sent,
    Cancelled,
    Failed,
}

#[derive(Deserialize, Serialize, Debug, Clone, PartialEq, Eq)]
#[serde(rename_all="camelCase")]
pub enum TransactionDetailKind {
    ExternalTransfer,
    InternalTransfer,
    OutgoingPayment,
    DebitCardTransaction,
    IncomingDomesticWire,
    CheckDeposit,
    IncomingInternationalWire,
    Fee,
    Other
}

#[derive(Deserialize, Serialize, Debug, Clone, PartialEq)]
#[serde(rename_all="camelCase")]
pub struct DomesticWireRoutingInfo {
    pub bank_name: Option<String>,
    pub account_number: String,
    pub routing_number: String,
    pub address: Option<Address>,
}

#[derive(Deserialize, Serialize, Debug, Clone, PartialEq)]
#[serde(rename_all="camelCase")]
pub struct ElectronicRoutingInfo {
    pub account_number: String,
    pub routing_number: String,
    pub bank_name: Option<String>,
}

#[derive(Deserialize, Serialize, Debug, Clone, PartialEq)]
#[serde(rename_all="camelCase")]
pub struct InternationalWireRoutingInfo {
    pub iban: String,
    pub swift_code: String,
    pub correspondent_info: Option<CorrespondentInfo>,
    pub bank_details: Option<BankDetails>,
    pub address: Option<Address>,
    pub phone_number: Option<String>,
    pub country_specific: Option<CountrySpecific>,
}

#[derive(Deserialize, Serialize, Debug, Clone, PartialEq)]
#[serde(rename_all="camelCase")]
pub struct CorrespondentInfo {
    pub routing_number: Option<String>,
    pub swift_code: Option<String>,
    pub bank_name: Option<String>,
}

#[derive(Deserialize, Serialize, Debug, Clone, PartialEq)]
#[serde(rename_all="camelCase")]
pub struct BankDetails {
    pub bank_name: String,
    pub city_state: String,
    pub country: Option<String>,
}

#[derive(Deserialize, Serialize, Debug, Clone, PartialEq)]
#[serde(rename_all="camelCase")]
pub struct CountrySpecific {
    pub country_specific_data_canada: Option<CountrySpecificData>,
    pub country_specific_data_australia: Option<CountrySpecificData>,
    pub country_specific_data_india: Option<CountrySpecificData>,
    pub country_specific_data_russia: Option<CountrySpecificData>,
    pub country_specific_data_philippines: Option<CountrySpecificData>,
    pub country_specific_data_south_africa: Option<CountrySpecificData>
}

#[derive(Deserialize, Serialize, Debug, Clone, PartialEq, Eq)]
#[serde(rename_all="camelCase")]
pub enum CountrySpecificData {
    Canada { bank_code: String, transit_number: String },
    Australia { bsb_code: String },
    India { ifsc_code: String },
    Russia { inn: String },
    Philippines { routing_number: String },
    SouthAfrica { branch_code: String }
}

#[derive(Deserialize, Serialize, Debug, Clone, PartialEq)]
#[serde(rename_all="camelCase")]
pub struct TransactionParam<'a> {
    pub recipient_id: &'a str,
    pub amount: f32,
    pub payment_method: TransactionPaymentMethod,
    pub note: Option<&'a str>,
    pub external_memo: Option<&'a str>,
    pub idempotency_key: &'a str
}

#[derive(Deserialize, Serialize, Debug, Clone, PartialEq, Eq)]
#[serde(rename_all="lowercase")]
pub enum TransactionPaymentMethod {
    ACH
}

impl Transaction {

    pub async fn list(client: &Client, id: &str) -> crate::Result<List<Self>> {
        client.get("/account", vec![id, "transactions"], serde_json::Map::new()).await
    }

    pub async fn retrieve(client: &Client, aid: &str, tid: &str) -> crate::Result<List<Self>> {
        client.get("/account", vec![aid, "transactions", tid], serde_json::Map::new()).await
    }

    pub async fn create<B: serde::Serialize>(client: &Client, aid: &str, param: B) -> crate::Result<Self> {
        client.get("/account", vec![aid, "transactions"], param).await
    }

}