zarinpal 0.1.2

Zarinpal Payment Gateway 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

use serde::Deserialize;

use super::{result_code::ResultCode, verify::FeeType, RequestResult};

/// The result type of a successful [`crate::methods::request::RequestPayment`] request.
#[derive(Debug, Clone, Deserialize)]
pub struct Request {
    code: ResultCode,
    message: String,

    /// Unique authority of the payment request.
    authority: String,

    /// Fee type. Indicates if the [`FeeType::Merchant`] is responsible for payment fee or [`FeeType::Payer`].
    fee_type: FeeType,

    /// Fee amount.
    fee: u64,
}

impl Request {
    /// Returns a url to the zarinpal payment gateway for this payment request (`authority` attached.)
    ///
    /// _This is the url that user should be redirected to, after a successful payment request._
    pub fn gateway_url(&self) -> reqwest::Url {
        format!("https://www.zarinpal.com/pg/StartPay/{}", self.authority())
            .parse()
            .unwrap()
    }
}

impl Request {
    /// Unique authority of the payment request.
    pub fn authority(&self) -> &str {
        self.authority.as_ref()
    }

    /// Fee type. Indicates if the [`FeeType::Merchant`] is responsible for payment fee or [`FeeType::Payer`].
    pub fn fee_type(&self) -> FeeType {
        self.fee_type
    }

    /// Fee amount.
    pub fn fee(&self) -> u64 {
        self.fee
    }
}

impl RequestResult for Request {
    fn code(&self) -> ResultCode {
        self.code
    }

    fn message(&self) -> &str {
        &self.message
    }
}

#[cfg(test)]
mod tests {

    use super::*;

    #[test]
    fn test_deserialization() {
        let inner_model = Request {
            code: ResultCode::Success,
            message: "Success".to_string(),
            authority: "A00000000000000000000000000217885159".to_string(),
            fee_type: FeeType::Merchant,
            fee: 100,
        };

        let from_json = serde_json::from_value::<crate::results::__private::ApiResult<Request>>(
            serde_json::json!({
                "data": {
                    "code": 100,
                    "message": "Success",
                    "authority": "A00000000000000000000000000217885159",
                    "fee_type": "Merchant",
                    "fee": 100,
                },
                "errors": [],
            }),
        )
        .unwrap();

        let data: Option<Request> = from_json.data.into();
        let data = data.unwrap();

        assert_eq!(data.authority, inner_model.authority);
        assert_eq!(data.code, inner_model.code);
        assert_eq!(data.message, inner_model.message);
        assert_eq!(data.fee, inner_model.fee);
        assert_eq!(data.fee_type, inner_model.fee_type);
    }
}