tencent_sdk/services/ssl/
check.rs

1use crate::{
2    client::{TencentCloudAsync, TencentCloudBlocking},
3    core::{Endpoint, TencentCloudResult},
4};
5use serde::{Deserialize, Serialize};
6use serde_json::Value;
7use std::borrow::Cow;
8use std::collections::HashMap;
9
10#[derive(Debug, Deserialize)]
11pub struct CheckCertificateResponse {
12    #[serde(rename = "Response")]
13    pub response: CheckCertificateResult,
14}
15
16#[derive(Debug, Deserialize)]
17pub struct CheckCertificateResult {
18    #[serde(rename = "OwnerUin")]
19    pub owner_uin: Option<String>,
20    #[serde(rename = "ProjectId")]
21    pub project_id: Option<String>,
22    #[serde(rename = "From")]
23    pub from: Option<String>,
24    #[serde(rename = "CertificateType")]
25    pub certificate_type: Option<String>,
26    #[serde(rename = "PackageType")]
27    pub package_type: Option<String>,
28    #[serde(rename = "ProductZhName")]
29    pub product_zh_name: Option<String>,
30    #[serde(rename = "Domain")]
31    pub domain: Option<String>,
32    #[serde(rename = "Alias")]
33    pub alias: Option<String>,
34    #[serde(rename = "Status")]
35    pub status: Option<i32>,
36    #[serde(rename = "StatusMsg")]
37    pub status_msg: Option<String>,
38    #[serde(rename = "VerifyType")]
39    pub verify_type: Option<String>,
40    #[serde(rename = "VulnerabilityStatus")]
41    pub vulnerability_status: Option<String>,
42    #[serde(rename = "CertBeginTime")]
43    pub cert_begin_time: Option<String>,
44    #[serde(rename = "CertEndTime")]
45    pub cert_end_time: Option<String>,
46    #[serde(rename = "ValidityPeriod")]
47    pub validity_period: Option<String>,
48    #[serde(rename = "InsertTime")]
49    pub insert_time: Option<String>,
50    #[serde(rename = "OrderId")]
51    pub order_id: Option<String>,
52    #[serde(rename = "CertificateExtra")]
53    pub certificate_extra: Option<CertificateExtra>,
54    #[serde(rename = "DvAuthDetail")]
55    pub dv_auth_detail: Option<DvAuthDetail>,
56    #[serde(rename = "VulnerabilityReport")]
57    pub vulnerability_report: Option<String>,
58    #[serde(rename = "CertificateId")]
59    pub certificate_id: Option<String>,
60    #[serde(rename = "PackageTypeName")]
61    pub package_type_name: Option<String>,
62    #[serde(rename = "StatusName")]
63    pub status_name: Option<String>,
64    #[serde(rename = "SubjectAltName")]
65    pub subject_alt_name: Option<Vec<String>>,
66    #[serde(rename = "IsVip")]
67    pub is_vip: Option<bool>,
68    #[serde(rename = "IsWildcard")]
69    pub is_wildcard: Option<bool>,
70    #[serde(rename = "IsDv")]
71    pub is_dv: Option<bool>,
72    #[serde(rename = "IsVulnerability")]
73    pub is_vulnerability: Option<bool>,
74    #[serde(rename = "RenewAble")]
75    pub renew_able: Option<bool>,
76    #[serde(rename = "SubmittedData")]
77    pub submitted_data: Option<SubmittedData>,
78    #[serde(rename = "Deployable")]
79    pub deployable: Option<bool>,
80    #[serde(rename = "Tags")]
81    pub tags: Option<Vec<Tags>>,
82    #[serde(rename = "CAEncryptAlgorithms")]
83    pub ca_encrypt_algorithms: Option<Vec<String>>,
84    #[serde(rename = "CACommonNames")]
85    pub ca_common_names: Option<Vec<String>>,
86    #[serde(rename = "CAEndTimes")]
87    pub ca_end_times: Option<Vec<String>>,
88    #[serde(rename = "DvRevokeAuthDetail")]
89    pub dv_revoke_auth_detail: Option<Vec<DvAuths>>,
90    #[serde(rename = "RequestId")]
91    pub request_id: String,
92}
93
94#[derive(Debug, Deserialize)]
95pub struct CertificateExtra {
96    // Flexible blob for API-specific fields returned by the service
97    #[serde(flatten, default)]
98    pub extra: HashMap<String, Value>,
99}
100
101#[derive(Debug, Serialize, Deserialize)]
102#[serde(rename_all = "PascalCase")]
103pub struct DvAuthDetail {
104    /// DNS validation record key; may be null when absent.
105    #[serde(skip_serializing_if = "Option::is_none")]
106    pub dv_auth_key: Option<String>,
107
108    /// DNS validation record value; may be null when absent.
109    #[serde(skip_serializing_if = "Option::is_none")]
110    pub dv_auth_value: Option<String>,
111
112    /// DNS validation record domain; may be null when absent.
113    #[serde(skip_serializing_if = "Option::is_none")]
114    pub dv_auth_domain: Option<String>,
115
116    /// File validation path (FILE/FILE_PROXY only); may be null when absent.
117    #[serde(skip_serializing_if = "Option::is_none")]
118    pub dv_auth_path: Option<String>,
119
120    /// DNS validation subdomain; may be null when absent.
121    #[serde(skip_serializing_if = "Option::is_none")]
122    pub dv_auth_key_sub_domain: Option<String>,
123
124    /// Validation info when multiple domains are validated; may be null when absent.
125    #[serde(skip_serializing_if = "Option::is_none")]
126    pub dv_auths: Option<Vec<DvAuths>>,
127}
128
129#[derive(Debug, Serialize, Deserialize)]
130#[serde(rename_all = "PascalCase")]
131pub struct DvAuths {
132    /// DNS validation record key
133    pub dv_auth_key: String,
134
135    /// DNS validation record value
136    pub dv_auth_value: String,
137
138    /// DNS validation record domain
139    pub dv_auth_domain: String,
140
141    /// File validation path (FILE/FILE_PROXY only)
142    #[serde(skip_serializing_if = "Option::is_none")]
143    pub dv_auth_path: Option<String>,
144
145    /// DNS validation subdomain
146    pub dv_auth_sub_domain: String,
147
148    /// DNS validation type: TXT (DNS TXT), FILE (file), or CNAME (DNS CNAME)
149    pub dv_auth_verify_type: String,
150}
151
152#[derive(Debug, Deserialize)]
153pub struct SubmittedData {
154    // Flexible blob for API-specific fields returned by the service
155    #[serde(flatten, default)]
156    pub extra: HashMap<String, Value>,
157}
158
159#[derive(Debug, Deserialize)]
160pub struct Tags {
161    #[serde(rename = "TagKey")]
162    pub tag_key: Option<String>,
163    #[serde(rename = "TagValue")]
164    pub tag_value: Option<String>,
165}
166
167#[derive(Serialize)]
168#[serde(rename_all = "PascalCase")]
169struct CheckCertificatePayload<'a> {
170    certificate_id: &'a str,
171}
172
173/// Request payload for `CheckCertificate`.
174pub struct CheckCertificate<'a> {
175    pub certificate_id: &'a str,
176}
177
178impl<'a> CheckCertificate<'a> {
179    /// Create a new certificate description request
180    pub fn new(certificate_id: &'a str) -> Self {
181        Self { certificate_id }
182    }
183}
184
185impl<'a> Endpoint for CheckCertificate<'a> {
186    type Output = CheckCertificateResponse;
187
188    fn service(&self) -> Cow<'static, str> {
189        Cow::Borrowed("ssl")
190    }
191
192    fn action(&self) -> Cow<'static, str> {
193        Cow::Borrowed("DescribeCertificate")
194    }
195
196    fn version(&self) -> Cow<'static, str> {
197        Cow::Borrowed("2019-12-05")
198    }
199
200    fn region(&self) -> Option<Cow<'_, str>> {
201        // SSL APIs do not require a region parameter
202        None
203    }
204
205    fn payload(&self) -> Value {
206        serde_json::to_value(CheckCertificatePayload {
207            certificate_id: self.certificate_id,
208        })
209        .expect("serialize CheckCertificate payload")
210    }
211}
212
213/// Call SSL `DescribeCertificate` with the async client.
214pub async fn check_certificate_async(
215    client: &TencentCloudAsync,
216    request: &CheckCertificate<'_>,
217) -> TencentCloudResult<CheckCertificateResponse> {
218    client.request(request).await
219}
220
221/// Call SSL `DescribeCertificate` with the blocking client.
222pub fn check_certificate_blocking(
223    client: &TencentCloudBlocking,
224    request: &CheckCertificate<'_>,
225) -> TencentCloudResult<CheckCertificateResponse> {
226    client.request(request)
227}
228
229#[cfg(test)]
230mod tests {
231    use super::*;
232    use serde_json::json;
233
234    #[test]
235    fn check_certificate_payload_serialization() {
236        let request = CheckCertificate::new("cert-abc123");
237        let payload = request.payload();
238        assert_eq!(payload["CertificateId"], json!("cert-abc123"));
239    }
240
241    #[test]
242    fn check_certificate_response() {
243        let payload = r#"{
244            "Response": {
245                "OwnerUin": "1234567890",
246                "ProjectId": "10086",
247                "From": "trustasia",
248                "CertificateType": "SVR",
249                "PackageType": "83",
250                "ProductZhName": "TrustAsia C1 DV Free",
251                "Domain": "example.com",
252                "Status": 1,
253                "StatusMsg": "Issued",
254                "VerifyType": "DNS_AUTO",
255                "CertBeginTime": "2024-01-01 00:00:00",
256                "CertEndTime": "2024-04-01 23:59:59",
257                "ValidityPeriod": "3",
258                "InsertTime": "2023-12-31 10:30:00",
259                "CertificateId": "cert-abc123",
260                "PackageTypeName": "TrustAsia C1 DV Free",
261                "StatusName": "Issued",
262                "SubjectAltName": ["www.example.com"],
263                "IsVip": false,
264                "IsWildcard": false,
265                "IsDv": true,
266                "RenewAble": true,
267                "Deployable": true,
268                "RequestId": "req-xyz-789"
269            }
270        }"#;
271        let parsed: CheckCertificateResponse =
272            serde_json::from_str(payload).expect("deserialize CheckCertificateResponse");
273        let resp = &parsed.response;
274        assert_eq!(resp.owner_uin, Some("1234567890".to_string()));
275        assert_eq!(resp.project_id, Some("10086".to_string()));
276        assert_eq!(resp.from, Some("trustasia".to_string()));
277        assert_eq!(resp.certificate_type, Some("SVR".to_string()));
278        assert_eq!(resp.package_type, Some("83".to_string()));
279        assert_eq!(
280            resp.product_zh_name,
281            Some("TrustAsia C1 DV Free".to_string())
282        );
283        assert_eq!(resp.domain, Some("example.com".to_string()));
284        assert_eq!(resp.status, Some(1));
285        assert_eq!(resp.status_msg, Some("Issued".to_string()));
286        assert_eq!(resp.verify_type, Some("DNS_AUTO".to_string()));
287        assert_eq!(
288            resp.cert_begin_time,
289            Some("2024-01-01 00:00:00".to_string())
290        );
291        assert_eq!(resp.cert_end_time, Some("2024-04-01 23:59:59".to_string()));
292        assert_eq!(resp.validity_period, Some("3".to_string()));
293        assert_eq!(resp.insert_time, Some("2023-12-31 10:30:00".to_string()));
294        assert_eq!(resp.certificate_id, Some("cert-abc123".to_string()));
295        assert_eq!(resp.status_name, Some("Issued".to_string()));
296        assert_eq!(resp.is_vip, Some(false));
297        assert_eq!(resp.is_wildcard, Some(false));
298        assert_eq!(resp.is_dv, Some(true));
299        assert_eq!(resp.renew_able, Some(true));
300        assert_eq!(resp.deployable, Some(true));
301        assert_eq!(resp.request_id, "req-xyz-789");
302    }
303}
tencent_sdk/services/ssl/check.rs

tencent_sdk/services/ssl/
check.rs
