adobe 0.1.0

Adobe Document Services API client 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

//! https://developer.adobe.com/document-services/docs/apis/#tag/Generate-Token/operation/authentication.generatetoken

use std::collections::HashMap;
use std::fmt::Debug;

use reqwest::{Client, Url};

use serde::{Deserialize, Serialize};

use crate::{ApiHttpRequest, Error, Result};

#[derive(Clone, Deserialize, Serialize)]
pub struct Token {
    pub access_token: String,
    pub token_type: String,
    pub expires_in: u32,
}

impl Debug for Token {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("Token")
            .field("access_token", &"***REDACTED***")
            .field("token_type", &self.token_type)
            .field("expires_in", &self.expires_in)
            .finish()
    }
}

#[derive(Clone, Debug, Deserialize, Serialize)]
pub struct TokenParams {
    pub client_id: String,
    pub client_secret: String,
}

impl ApiHttpRequest for Token {
    type Response = Token;
    type Params = TokenParams;

    async fn send(base_url: &Url, params: Self::Params) -> Result<Self::Response> {
        let url = base_url.join("/token")?;
        let mut form = HashMap::new();

        form.insert("client_id", params.client_id);
        form.insert("client_secret", params.client_secret);

        let client = Client::new();
        let resp = client.post(url).form(&form).send().await?;

        if resp.status().is_success() {
            let token: Self = resp.json().await?;
            return Ok(token);
        }

        let status = resp.status();
        let text = resp.text().await.unwrap_or_default();

        Err(Error::ApiError(format!(
            "Failed to get token: {} - {}",
            status, text
        )))
    }
}