silamoney 0.1.3

A rust library for interacting with the Sila Banking API (https://silamoney.com)
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

use log::error;
use serde::{Deserialize, Serialize};

use crate::{header_message, Header, HeaderMessage, SignedMessageParams, Status};

#[derive(Deserialize, Serialize)]
pub struct TransferSilaMessage {
    pub header: Header,
    pub amount: i32,
    pub message: String,
    pub destination_handle: String,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub descriptor: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub destination_address: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub destination_wallet: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub source_id: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub destination_id: Option<String>,
}

#[derive(Clone)]
pub struct TransferSilaMessageParams {
    pub sila_handle: String,
    pub amount: i32,
    pub descriptor: Option<String>,
    pub destination_handle: String,
    pub destination_address: Option<String>,
    pub destination_wallet: Option<String>,
    pub destination_id: Option<String>,
    pub source_id: Option<String>,
    pub reference: Option<String>,
}

impl Default for TransferSilaMessageParams {
    fn default() -> Self {
        TransferSilaMessageParams {
            sila_handle: String::new(),
            amount: 0,
            descriptor: Option::None,
            destination_handle: String::new(),
            destination_address: Option::None,
            destination_wallet: Option::None,
            destination_id: Option::None,
            source_id: Option::None,
            reference: Option::None,
        }
    }
}

impl From<TransferSilaMessageParams> for TransferSilaMessage {
    fn from(params: TransferSilaMessageParams) -> Self {
        let sila_params = &*crate::SILA_PARAMS;

        let mut header_message: HeaderMessage = header_message();
        header_message.header.user_handle = Option::from(params.sila_handle.clone());
        header_message.header.auth_handle = sila_params.app_handle.clone();

        if params.reference.is_some() {
            header_message.header.reference = params.reference.unwrap();
        }

        TransferSilaMessage {
            header: header_message.header,
            message: "transfer_msg".to_string(),
            amount: params.amount,
            descriptor: params.descriptor.clone(),
            destination_handle: params.destination_handle.clone(),
            destination_address: params.destination_address.clone(),
            destination_wallet: params.destination_wallet.clone(),
            destination_id: params.destination_id.clone(),
            source_id: params.source_id.clone(),
        }
    }
}

#[derive(Serialize, Deserialize)]
pub struct TransferSilaResponse {
    pub message: String,
    pub reference: Option<String>,
    pub status: Status,
    pub success: bool,
    pub transaction_id: Option<String>,
    pub descriptor: Option<String>,
}

impl std::fmt::Display for TransferSilaResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "TransferSilaResponse(message: {}, reference: {}, transaction_id: {}, status: {})",
            self.message,
            self.reference.as_ref().unwrap_or(&"none".to_string()),
            self.transaction_id.as_ref().unwrap_or(&"none".to_string()),
            self.status
        )
    }
}

pub async fn transfer_sila(
    params: &SignedMessageParams,
) -> Result<TransferSilaResponse, Box<dyn std::error::Error + Sync + Send>> {
    let sila_params = &*crate::SILA_PARAMS;
    let _url: String = format!("{}/transfer_sila", sila_params.gateway);

    let h: TransferSilaMessage = serde_json::from_str(&params.message.clone()).unwrap();

    let client = reqwest::Client::new();
    let resp: reqwest::Response = client
        .post(&_url.to_owned())
        .header("usersignature", &params.usersignature.clone().unwrap())
        .header("authsignature", &params.authsignature)
        .json(&h)
        .send()
        .await?;

    let response_text = resp.text().await?;
    let response: Result<TransferSilaResponse, serde_json::Error> =
        serde_json::from_str(&response_text);

    match response {
        Ok(x) if x.status == Status::FAILURE => {
            error!("transfer_sila error: {}", response_text);
            Ok(x)
        }
        Ok(x) => Ok(x),
        Err(e) => {
            error!("transfer_sila response error: {}", response_text);
            Err(Box::from(e))
        }
    }
}