jpush 0.4.0

集成极光App推送
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

use base64::Engine;
use base64::engine::general_purpose;
use crate::config::JPushConfig;
use crate::msg::{JPushMessage, JPushMessageResp};
#[cfg(feature = "spring")]
use spring::tracing;

const AUTHORIZATION_HEADER: &str = "Authorization";

#[derive(Debug, Clone)]
pub struct JPushClient {
    pub config: JPushConfig,
}

impl JPushClient {
    pub fn new(config: JPushConfig) -> Self {
        JPushClient {
            config
        }
    }
    pub async fn send(&self, message: JPushMessage) -> Result<JPushMessageResp, Box<dyn std::error::Error>> {
        let resp = self.request(message).await;
        match resp {
            Ok(resp) => {
                if resp.is_empty() {
                    #[cfg(feature = "spring")]
                    tracing::error!("JPush Send Response Empty");

                    return Err("JPush Send Response Empty".into());
                }

                let msg_resp = serde_json::from_str::<JPushMessageResp>(&resp);
                match msg_resp {
                    Ok(msg_resp) => Ok(msg_resp),
                    Err(e) => {
                        #[cfg(feature = "spring")]
                        tracing::error!("JPushMessageResp Deserialize Error: {:?}", e);
                        #[cfg(feature = "spring")]
                        tracing::error!("JPushMessageResp Deserialize String: {}", resp);

                        Err(e.into())
                    }
                }
            },
            Err(e) => {
                #[cfg(feature = "spring")]
                tracing::error!("JPush Send Error: {:?}", e);

                Err(e.into())
            }
        }
    }
    fn authorization(&self) -> String {
        format!("Basic {}", general_purpose::STANDARD.encode(&format!("{}:{}", self.config.app_key, self.config.secret)))
    }
    async fn request(&self, msg: JPushMessage) -> Result<String, Box<dyn std::error::Error>> {
        let client = reqwest::Client::new();
        let res = client.post(&self.config.url)
            .header(AUTHORIZATION_HEADER, self.authorization())
            .body(msg)
            .send()
            .await?
            .text()
            .await?;
        Ok(res)
    }
}