wechat-mp-sdk 0.3.0

WeChat Mini Program SDK for Rust
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

//! Image and OCR API

use std::collections::HashMap;
use std::sync::Arc;

use serde::{Deserialize, Serialize};
use serde_json::Value;

use super::{WechatApi, WechatContext};
use crate::error::WechatError;

#[non_exhaustive]
#[derive(Debug, Clone, Serialize)]
pub struct OcrImageRequest {
    pub img_url: String,
}

impl OcrImageRequest {
    pub fn new(img_url: impl Into<String>) -> Self {
        Self {
            img_url: img_url.into(),
        }
    }
}

#[non_exhaustive]
#[derive(Debug, Clone, Serialize)]
pub struct IdCardOcrRequest {
    pub img_url: String,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub r#type: Option<String>,
}

#[non_exhaustive]
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct OcrResponse {
    #[serde(default)]
    pub(crate) errcode: i32,
    #[serde(default)]
    pub(crate) errmsg: String,
    #[serde(flatten)]
    pub extra: HashMap<String, Value>,
}

pub struct OcrApi {
    context: Arc<WechatContext>,
}

impl OcrApi {
    pub fn new(context: Arc<WechatContext>) -> Self {
        Self { context }
    }

    pub async fn ai_crop(&self, request: &OcrImageRequest) -> Result<OcrResponse, WechatError> {
        self.post_json("/cv/img/aicrop", request).await
    }

    pub async fn scan_qr_code(
        &self,
        request: &OcrImageRequest,
    ) -> Result<OcrResponse, WechatError> {
        self.post_json("/cv/img/qrcode", request).await
    }

    pub async fn printed_text_ocr(
        &self,
        request: &OcrImageRequest,
    ) -> Result<OcrResponse, WechatError> {
        self.post_json("/cv/ocr/comm", request).await
    }

    pub async fn vehicle_license_ocr(
        &self,
        request: &OcrImageRequest,
    ) -> Result<OcrResponse, WechatError> {
        self.post_json("/cv/ocr/driving", request).await
    }

    pub async fn bank_card_ocr(
        &self,
        request: &OcrImageRequest,
    ) -> Result<OcrResponse, WechatError> {
        self.post_json("/cv/ocr/bankcard", request).await
    }

    pub async fn business_license_ocr(
        &self,
        request: &OcrImageRequest,
    ) -> Result<OcrResponse, WechatError> {
        self.post_json("/cv/ocr/bizlicense", request).await
    }

    pub async fn driver_license_ocr(
        &self,
        request: &OcrImageRequest,
    ) -> Result<OcrResponse, WechatError> {
        self.post_json("/cv/ocr/drivinglicense", request).await
    }

    pub async fn id_card_ocr(
        &self,
        request: &IdCardOcrRequest,
    ) -> Result<OcrResponse, WechatError> {
        self.post_json("/cv/ocr/idcard", request).await
    }

    async fn post_json<B: Serialize>(
        &self,
        endpoint: &str,
        body: &B,
    ) -> Result<OcrResponse, WechatError> {
        let response: OcrResponse = self.context.authed_post(endpoint, body).await?;
        WechatError::check_api(response.errcode, &response.errmsg)?;
        Ok(response)
    }
}

impl WechatApi for OcrApi {
    fn context(&self) -> &WechatContext {
        &self.context
    }

    fn api_name(&self) -> &'static str {
        "ocr"
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn ocr_response_deserializes() {
        let json = r#"{"errcode":0,"errmsg":"ok","items":[{"text":"abc"}]}"#;
        let response: OcrResponse = serde_json::from_str(json).unwrap();
        assert_eq!(response.errcode, 0);
        assert!(response.extra.contains_key("items"));
    }
}