africastalking 0.1.0

Unofficial Rust SDK for Africa's Talking 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

//! SMS module implementation

use crate::{client::AfricasTalkingClient, error::Result};
use serde::{Deserialize, Serialize};

/// SMS module for sending and managing SMS messages
#[derive(Debug, Clone)]
pub struct SmsModule {
    client: AfricasTalkingClient,
}

impl SmsModule {
    pub(crate) fn new(client: AfricasTalkingClient) -> Self {
        Self { client }
    }

    /// Send SMS to one or more recipients
    pub async fn send(&self, request: SendSmsRequest) -> Result<SendSmsResponse> {
        self.client.post("/version1/messaging", &request).await
    }

    /// Fetch SMS messages
    pub async fn fetch_messages(
        &self,
        last_received_id: Option<u32>,
    ) -> Result<FetchMessagesResponse> {
        let endpoint = if let Some(id) = last_received_id {
            format!("/version1/messaging?lastReceivedId={id}")
        } else {
            "/version1/messaging".to_string()
        };

        self.client.get(&endpoint).await
    }
}

#[derive(Debug, Serialize)]
pub struct SendSmsRequest {
    pub to: String,
    pub message: String,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub from: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(rename = "bulkSMSMode")]
    pub bulk_sms_mode: Option<u32>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub enqueue: Option<u32>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub keyword: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(rename = "linkId")]
    pub link_id: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(rename = "retryDurationInHours")]
    pub retry_duration_in_hours: Option<u32>,
}

impl SendSmsRequest {
    pub fn new<S: Into<String>>(to: Vec<S>, message: S) -> Self {
        Self {
            to: to.into_iter().map(|s| s.into()).collect(),
            message: message.into(),
            from: None,
            bulk_sms_mode: None,
            enqueue: None,
            keyword: None,
            link_id: None,
            retry_duration_in_hours: None,
        }
    }

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

    pub fn bulk_mode(mut self, enabled: bool) -> Self {
        self.bulk_sms_mode = Some(if enabled { 1 } else { 0 });
        self
    }
}

#[derive(Debug, Deserialize)]
pub struct SendSmsResponse {
    #[serde(rename = "SMSMessageData")]
    pub sms_message_data: SmsMessageData,
}

#[derive(Debug, Deserialize)]
pub struct SmsMessageData {
    #[serde(rename = "Message")]
    pub message: String,
    #[serde(rename = "Recipients")]
    pub recipients: Vec<SmsRecipient>,
}

#[derive(Debug, Deserialize)]
pub struct SmsRecipient {
    #[serde(rename = "statusCode")]
    pub status_code: u32,
    #[serde(rename = "number")]
    pub number: String,
    #[serde(rename = "status")]
    pub status: String,
    #[serde(rename = "cost")]
    pub cost: String,
    #[serde(rename = "messageId")]
    pub message_id: String,
}

#[derive(Debug, Deserialize)]
pub struct FetchMessagesResponse {
    #[serde(rename = "SMSMessageData")]
    pub sms_message_data: FetchSmsMessageData,
}

#[derive(Debug, Deserialize)]
pub struct FetchSmsMessageData {
    #[serde(rename = "Messages")]
    pub messages: Vec<SmsMessage>,
}

#[derive(Debug, Deserialize)]
pub struct SmsMessage {
    #[serde(rename = "id")]
    pub id: u32,
    #[serde(rename = "text")]
    pub text: String,
    #[serde(rename = "from")]
    pub from: String,
    #[serde(rename = "to")]
    pub to: String,
    #[serde(rename = "date")]
    pub date: String,
    #[serde(rename = "linkId")]
    pub link_id: Option<String>,
}