casdoor_sdk/apis/
resource_api.rs

1
2
3use reqwest;
4
5use crate::{apis::ResponseContent, models};
6use super::{Error, configuration};
7
8/// struct for passing parameters to the method [`add_resource`]
9#[derive(Clone, Debug)]
10pub struct ApiControllerAddResourceParams {
11    /// Resource object
12    pub resource: models::Resource
13}
14
15/// struct for passing parameters to the method [`delete_resource`]
16#[derive(Clone, Debug)]
17pub struct ApiControllerDeleteResourceParams {
18    /// Resource object
19    pub resource: models::Resource
20}
21
22/// struct for passing parameters to the method [`get_resource`]
23#[derive(Clone, Debug)]
24pub struct ApiControllerGetResourceParams {
25    /// The id ( owner/name ) of resource
26    pub id: String
27}
28
29/// struct for passing parameters to the method [`get_resources`]
30#[derive(Clone, Debug)]
31pub struct ApiControllerGetResourcesParams {
32    /// Owner
33    pub owner: String,
34    /// User
35    pub user: String,
36    /// Page Size
37    pub page_size: Option<i32>,
38    /// Page Number
39    pub p: Option<i32>,
40    /// Field
41    pub field: Option<String>,
42    /// Value
43    pub value: Option<String>,
44    /// Sort Field
45    pub sort_field: Option<String>,
46    /// Sort Order
47    pub sort_order: Option<String>
48}
49
50/// struct for passing parameters to the method [`update_resource`]
51#[derive(Clone, Debug)]
52pub struct ApiControllerUpdateResourceParams {
53    /// The id ( owner/name ) of resource
54    pub id: String,
55    /// The resource object
56    pub resource: models::Resource
57}
58
59/// struct for passing parameters to the method [`upload_resource`]
60#[derive(Clone, Debug)]
61pub struct ApiControllerUploadResourceParams {
62    /// Owner
63    pub owner: String,
64    /// User
65    pub user: String,
66    /// Application
67    pub application: String,
68    /// Full File Path
69    pub full_file_path: String,
70    /// Resource file
71    pub file: std::path::PathBuf,
72    /// Tag
73    pub tag: Option<String>,
74    /// Parent
75    pub parent: Option<String>,
76    /// Created Time
77    pub created_time: Option<String>,
78    /// Description
79    pub description: Option<String>
80}
81
82
83/// struct for typed errors of method [`add_resource`]
84#[derive(Debug, Clone, Serialize, Deserialize)]
85#[serde(untagged)]
86pub enum ApiControllerAddResourceError {
87    UnknownValue(serde_json::Value),
88}
89
90/// struct for typed errors of method [`delete_resource`]
91#[derive(Debug, Clone, Serialize, Deserialize)]
92#[serde(untagged)]
93pub enum ApiControllerDeleteResourceError {
94    UnknownValue(serde_json::Value),
95}
96
97/// struct for typed errors of method [`get_resource`]
98#[derive(Debug, Clone, Serialize, Deserialize)]
99#[serde(untagged)]
100pub enum ApiControllerGetResourceError {
101    UnknownValue(serde_json::Value),
102}
103
104/// struct for typed errors of method [`get_resources`]
105#[derive(Debug, Clone, Serialize, Deserialize)]
106#[serde(untagged)]
107pub enum ApiControllerGetResourcesError {
108    UnknownValue(serde_json::Value),
109}
110
111/// struct for typed errors of method [`update_resource`]
112#[derive(Debug, Clone, Serialize, Deserialize)]
113#[serde(untagged)]
114pub enum ApiControllerUpdateResourceError {
115    UnknownValue(serde_json::Value),
116}
117
118/// struct for typed errors of method [`upload_resource`]
119#[derive(Debug, Clone, Serialize, Deserialize)]
120#[serde(untagged)]
121pub enum ApiControllerUploadResourceError {
122    UnknownValue(serde_json::Value),
123}
124
125
126pub async fn add_resource(configuration: &configuration::Configuration, params: ApiControllerAddResourceParams) -> Result<models::ControllersResponse, Error<ApiControllerAddResourceError>> {
127    let local_var_configuration = configuration;
128
129    // unbox the parameters
130    let resource = params.resource;
131
132
133    let local_var_client = &local_var_configuration.client;
134
135    let local_var_uri_str = format!("{}/api/add-resource", local_var_configuration.base_path);
136    let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
137
138    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
139        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
140    }
141    local_var_req_builder = local_var_req_builder.json(&resource);
142
143    let local_var_req = local_var_req_builder.build()?;
144    let local_var_resp = local_var_client.execute(local_var_req).await?;
145
146    let local_var_status = local_var_resp.status();
147    let local_var_content = local_var_resp.text().await?;
148
149    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
150        serde_json::from_str(&local_var_content).map_err(Error::from)
151    } else {
152        let local_var_entity: Option<ApiControllerAddResourceError> = serde_json::from_str(&local_var_content).ok();
153        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
154        Err(Error::ResponseError(local_var_error))
155    }
156}
157
158pub async fn delete_resource(configuration: &configuration::Configuration, params: ApiControllerDeleteResourceParams) -> Result<models::ControllersResponse, Error<ApiControllerDeleteResourceError>> {
159    let local_var_configuration = configuration;
160
161    // unbox the parameters
162    let resource = params.resource;
163
164
165    let local_var_client = &local_var_configuration.client;
166
167    let local_var_uri_str = format!("{}/api/delete-resource", local_var_configuration.base_path);
168    let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
169
170    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
171        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
172    }
173    local_var_req_builder = local_var_req_builder.json(&resource);
174
175    let local_var_req = local_var_req_builder.build()?;
176    let local_var_resp = local_var_client.execute(local_var_req).await?;
177
178    let local_var_status = local_var_resp.status();
179    let local_var_content = local_var_resp.text().await?;
180
181    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
182        serde_json::from_str(&local_var_content).map_err(Error::from)
183    } else {
184        let local_var_entity: Option<ApiControllerDeleteResourceError> = serde_json::from_str(&local_var_content).ok();
185        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
186        Err(Error::ResponseError(local_var_error))
187    }
188}
189
190/// get resource
191pub async fn get_resource(configuration: &configuration::Configuration, params: ApiControllerGetResourceParams) -> Result<models::Resource, Error<ApiControllerGetResourceError>> {
192    let local_var_configuration = configuration;
193
194    // unbox the parameters
195    let id = params.id;
196
197
198    let local_var_client = &local_var_configuration.client;
199
200    let local_var_uri_str = format!("{}/api/get-resource", local_var_configuration.base_path);
201    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
202
203    local_var_req_builder = local_var_req_builder.query(&[("id", &id.to_string())]);
204    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
205        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
206    }
207
208    let local_var_req = local_var_req_builder.build()?;
209    let local_var_resp = local_var_client.execute(local_var_req).await?;
210
211    let local_var_status = local_var_resp.status();
212    let local_var_content = local_var_resp.text().await?;
213
214    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
215        serde_json::from_str(&local_var_content).map_err(Error::from)
216    } else {
217        let local_var_entity: Option<ApiControllerGetResourceError> = serde_json::from_str(&local_var_content).ok();
218        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
219        Err(Error::ResponseError(local_var_error))
220    }
221}
222
223/// get resources
224pub async fn get_resources(configuration: &configuration::Configuration, params: ApiControllerGetResourcesParams) -> Result<Vec<models::Resource>, Error<ApiControllerGetResourcesError>> {
225    let local_var_configuration = configuration;
226
227    // unbox the parameters
228    let owner = params.owner;
229    let user = params.user;
230    let page_size = params.page_size;
231    let p = params.p;
232    let field = params.field;
233    let value = params.value;
234    let sort_field = params.sort_field;
235    let sort_order = params.sort_order;
236
237
238    let local_var_client = &local_var_configuration.client;
239
240    let local_var_uri_str = format!("{}/api/get-resources", local_var_configuration.base_path);
241    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
242
243    local_var_req_builder = local_var_req_builder.query(&[("owner", &owner.to_string())]);
244    local_var_req_builder = local_var_req_builder.query(&[("user", &user.to_string())]);
245    if let Some(ref local_var_str) = page_size {
246        local_var_req_builder = local_var_req_builder.query(&[("pageSize", &local_var_str.to_string())]);
247    }
248    if let Some(ref local_var_str) = p {
249        local_var_req_builder = local_var_req_builder.query(&[("p", &local_var_str.to_string())]);
250    }
251    if let Some(ref local_var_str) = field {
252        local_var_req_builder = local_var_req_builder.query(&[("field", &local_var_str.to_string())]);
253    }
254    if let Some(ref local_var_str) = value {
255        local_var_req_builder = local_var_req_builder.query(&[("value", &local_var_str.to_string())]);
256    }
257    if let Some(ref local_var_str) = sort_field {
258        local_var_req_builder = local_var_req_builder.query(&[("sortField", &local_var_str.to_string())]);
259    }
260    if let Some(ref local_var_str) = sort_order {
261        local_var_req_builder = local_var_req_builder.query(&[("sortOrder", &local_var_str.to_string())]);
262    }
263    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
264        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
265    }
266
267    let local_var_req = local_var_req_builder.build()?;
268    let local_var_resp = local_var_client.execute(local_var_req).await?;
269
270    let local_var_status = local_var_resp.status();
271    let local_var_content = local_var_resp.text().await?;
272
273    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
274        serde_json::from_str(&local_var_content).map_err(Error::from)
275    } else {
276        let local_var_entity: Option<ApiControllerGetResourcesError> = serde_json::from_str(&local_var_content).ok();
277        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
278        Err(Error::ResponseError(local_var_error))
279    }
280}
281
282/// get resource
283pub async fn update_resource(configuration: &configuration::Configuration, params: ApiControllerUpdateResourceParams) -> Result<models::ControllersResponse, Error<ApiControllerUpdateResourceError>> {
284    let local_var_configuration = configuration;
285
286    // unbox the parameters
287    let id = params.id;
288    let resource = params.resource;
289
290
291    let local_var_client = &local_var_configuration.client;
292
293    let local_var_uri_str = format!("{}/api/update-resource", local_var_configuration.base_path);
294    let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
295
296    local_var_req_builder = local_var_req_builder.query(&[("id", &id.to_string())]);
297    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
298        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
299    }
300    local_var_req_builder = local_var_req_builder.json(&resource);
301
302    let local_var_req = local_var_req_builder.build()?;
303    let local_var_resp = local_var_client.execute(local_var_req).await?;
304
305    let local_var_status = local_var_resp.status();
306    let local_var_content = local_var_resp.text().await?;
307
308    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
309        serde_json::from_str(&local_var_content).map_err(Error::from)
310    } else {
311        let local_var_entity: Option<ApiControllerUpdateResourceError> = serde_json::from_str(&local_var_content).ok();
312        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
313        Err(Error::ResponseError(local_var_error))
314    }
315}
316
317pub async fn upload_resource(configuration: &configuration::Configuration, params: ApiControllerUploadResourceParams) -> Result<models::Resource, Error<ApiControllerUploadResourceError>> {
318    let local_var_configuration = configuration;
319
320    // unbox the parameters
321    let owner = params.owner;
322    let user = params.user;
323    let application = params.application;
324    let full_file_path = params.full_file_path;
325    let file = params.file;
326    let tag = params.tag;
327    let parent = params.parent;
328    let created_time = params.created_time;
329    let description = params.description;
330
331
332    let local_var_client = &local_var_configuration.client;
333
334    let local_var_uri_str = format!("{}/api/upload-resource", local_var_configuration.base_path);
335    let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
336
337    local_var_req_builder = local_var_req_builder.query(&[("owner", &owner.to_string())]);
338    local_var_req_builder = local_var_req_builder.query(&[("user", &user.to_string())]);
339    local_var_req_builder = local_var_req_builder.query(&[("application", &application.to_string())]);
340    if let Some(ref local_var_str) = tag {
341        local_var_req_builder = local_var_req_builder.query(&[("tag", &local_var_str.to_string())]);
342    }
343    if let Some(ref local_var_str) = parent {
344        local_var_req_builder = local_var_req_builder.query(&[("parent", &local_var_str.to_string())]);
345    }
346    local_var_req_builder = local_var_req_builder.query(&[("fullFilePath", &full_file_path.to_string())]);
347    if let Some(ref local_var_str) = created_time {
348        local_var_req_builder = local_var_req_builder.query(&[("createdTime", &local_var_str.to_string())]);
349    }
350    if let Some(ref local_var_str) = description {
351        local_var_req_builder = local_var_req_builder.query(&[("description", &local_var_str.to_string())]);
352    }
353    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
354        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
355    }
356    let mut local_var_form = reqwest::multipart::Form::new();
357    // TODO: support file upload for 'file' parameter
358    local_var_req_builder = local_var_req_builder.multipart(local_var_form);
359
360    let local_var_req = local_var_req_builder.build()?;
361    let local_var_resp = local_var_client.execute(local_var_req).await?;
362
363    let local_var_status = local_var_resp.status();
364    let local_var_content = local_var_resp.text().await?;
365
366    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
367        serde_json::from_str(&local_var_content).map_err(Error::from)
368    } else {
369        let local_var_entity: Option<ApiControllerUploadResourceError> = serde_json::from_str(&local_var_content).ok();
370        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
371        Err(Error::ResponseError(local_var_error))
372    }
373}
374