alipan 0.0.8

alipan 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

use crate::{
    AccessTokenLoader, AdriveClient, AdriveOpenFileType, CheckNameMode, LoadAccessToken,
    OptionParam,
};
use serde_derive::{Deserialize, Serialize};
use std::ops::Deref;
use std::sync::Arc;

impl AdriveClient {
    pub async fn adrive_open_file_update(&self) -> AdriveOpenFileUpdateRequest {
        AdriveOpenFileUpdateRequest {
            agent: self.clone_agent().await,
            api_host: self.clone_api_host().await,
            access_token: self.clone_access_token_loader().await,
            drive_id: None.into(),
            file_id: None.into(),
            name: None.into(),
            check_name_mode: None.into(),
            starred: None.into(),
        }
    }
}

#[derive(Debug)]
pub struct AdriveOpenFileUpdateRequest {
    pub agent: Arc<reqwest::Client>,
    pub api_host: Arc<String>,
    pub access_token: Arc<Box<dyn AccessTokenLoader>>,
    pub drive_id: OptionParam<String>,
    pub file_id: OptionParam<String>,
    pub name: OptionParam<String>,
    pub check_name_mode: OptionParam<CheckNameMode>,
    pub starred: OptionParam<bool>,
}

#[derive(Debug, Serialize, Deserialize, Clone, Eq, PartialEq, Default)]
pub struct AdriveOpenFileUpdateRequestPost {
    pub drive_id: String,
    pub file_id: String,
    pub name: Option<String>,
    pub check_name_mode: Option<CheckNameMode>,
    pub starred: Option<bool>,
}

impl AdriveOpenFileUpdateRequest {
    pub fn agent(mut self, agent: impl Into<Arc<reqwest::Client>>) -> Self {
        self.agent = agent.into();
        self
    }

    pub fn api_host(mut self, api_host: impl Into<Arc<String>>) -> Self {
        self.api_host = api_host.into();
        self
    }

    pub fn access_token(
        mut self,
        access_token: impl Into<Arc<Box<dyn AccessTokenLoader>>>,
    ) -> Self {
        self.access_token = access_token.into();
        self
    }

    pub fn drive_id(mut self, drive_id: impl Into<OptionParam<String>>) -> Self {
        self.drive_id = drive_id.into();
        self
    }

    pub fn file_id(mut self, file_id: impl Into<OptionParam<String>>) -> Self {
        self.file_id = file_id.into();
        self
    }

    pub fn name(mut self, name: impl Into<OptionParam<String>>) -> Self {
        self.name = name.into();
        self
    }

    pub fn check_name_mode(
        mut self,
        check_name_mode: impl Into<OptionParam<CheckNameMode>>,
    ) -> Self {
        self.check_name_mode = check_name_mode.into();
        self
    }

    pub fn starred(mut self, starred: impl Into<OptionParam<bool>>) -> Self {
        self.starred = starred.into();
        self
    }
}

impl AdriveOpenFileUpdateRequest {
    pub async fn request(&self) -> crate::Result<AdriveOpenFileUpdate> {
        let resp = self
            .agent
            .post(format!("{}/adrive/v1.0/openFile/update", self.api_host.as_str()).as_str())
            .load_access_token(self.access_token.clone())
            .await?
            .json(&AdriveOpenFileUpdateRequestPost {
                drive_id: if let Some(ref v) = self.drive_id.deref() {
                    v.clone()
                } else {
                    return Err(crate::Error::require_param_missing("drive_id"));
                },
                file_id: if let Some(ref v) = self.file_id.deref() {
                    v.clone()
                } else {
                    return Err(crate::Error::require_param_missing("file_id"));
                },
                name: self.name.clone(),
                check_name_mode: self.check_name_mode.clone(),
                starred: self.starred.clone(),
            })
            .send()
            .await?;
        let resp = resp.json::<AdriveOpenFileUpdate>().await?;
        Ok(resp)
    }
}

#[derive(Debug, Clone, Serialize, Deserialize, Eq, PartialEq)]
pub struct AdriveOpenFileUpdate {
    pub drive_id: String,
    pub file_id: String,
    pub name: String,
    pub size: i64,
    pub file_extension: String,
    pub content_hash: String,
    pub category: String,
    pub r#type: AdriveOpenFileType,
    pub created_at: String,
    pub updated_at: String,
}