1use reqwest;
13use serde::{Deserialize, Serialize};
14use crate::{apis::ResponseContent, models};
15use super::{Error, configuration};
16
17
18#[derive(Debug, Clone, Serialize, Deserialize)]
20#[serde(untagged)]
21pub enum BatchCheckPermissionError {
22 Status400(models::ErrorGeneric),
23 DefaultResponse(models::ErrorGeneric),
24 UnknownValue(serde_json::Value),
25}
26
27#[derive(Debug, Clone, Serialize, Deserialize)]
29#[serde(untagged)]
30pub enum CheckPermissionError {
31 Status400(models::ErrorGeneric),
32 DefaultResponse(models::ErrorGeneric),
33 UnknownValue(serde_json::Value),
34}
35
36#[derive(Debug, Clone, Serialize, Deserialize)]
38#[serde(untagged)]
39pub enum CheckPermissionOrErrorError {
40 Status400(models::ErrorGeneric),
41 Status403(models::CheckPermissionResult),
42 DefaultResponse(models::ErrorGeneric),
43 UnknownValue(serde_json::Value),
44}
45
46#[derive(Debug, Clone, Serialize, Deserialize)]
48#[serde(untagged)]
49pub enum ExpandPermissionsError {
50 Status400(models::ErrorGeneric),
51 Status404(models::ErrorGeneric),
52 DefaultResponse(models::ErrorGeneric),
53 UnknownValue(serde_json::Value),
54}
55
56#[derive(Debug, Clone, Serialize, Deserialize)]
58#[serde(untagged)]
59pub enum PostCheckPermissionError {
60 Status400(models::ErrorGeneric),
61 DefaultResponse(models::ErrorGeneric),
62 UnknownValue(serde_json::Value),
63}
64
65#[derive(Debug, Clone, Serialize, Deserialize)]
67#[serde(untagged)]
68pub enum PostCheckPermissionOrErrorError {
69 Status400(models::ErrorGeneric),
70 Status403(models::CheckPermissionResult),
71 DefaultResponse(models::ErrorGeneric),
72 UnknownValue(serde_json::Value),
73}
74
75
76pub async fn batch_check_permission(configuration: &configuration::Configuration, max_depth: Option<i64>, batch_check_permission_body: Option<models::BatchCheckPermissionBody>) -> Result<models::BatchCheckPermissionResult, Error<BatchCheckPermissionError>> {
78 let local_var_configuration = configuration;
79
80 let local_var_client = &local_var_configuration.client;
81
82 let local_var_uri_str = format!("{}/relation-tuples/batch/check", local_var_configuration.base_path);
83 let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
84
85 if let Some(ref local_var_str) = max_depth {
86 local_var_req_builder = local_var_req_builder.query(&[("max-depth", &local_var_str.to_string())]);
87 }
88 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
89 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
90 }
91 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
92 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
93 };
94 local_var_req_builder = local_var_req_builder.json(&batch_check_permission_body);
95
96 let local_var_req = local_var_req_builder.build()?;
97 let local_var_resp = local_var_client.execute(local_var_req).await?;
98
99 let local_var_status = local_var_resp.status();
100 let local_var_content = local_var_resp.text().await?;
101
102 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
103 serde_json::from_str(&local_var_content).map_err(Error::from)
104 } else {
105 let local_var_entity: Option<BatchCheckPermissionError> = serde_json::from_str(&local_var_content).ok();
106 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
107 Err(Error::ResponseError(local_var_error))
108 }
109}
110
111pub async fn check_permission(configuration: &configuration::Configuration, namespace: Option<&str>, object: Option<&str>, relation: Option<&str>, subject_id: Option<&str>, subject_set_period_namespace: Option<&str>, subject_set_period_object: Option<&str>, subject_set_period_relation: Option<&str>, max_depth: Option<i64>) -> Result<models::CheckPermissionResult, Error<CheckPermissionError>> {
113 let local_var_configuration = configuration;
114
115 let local_var_client = &local_var_configuration.client;
116
117 let local_var_uri_str = format!("{}/relation-tuples/check/openapi", local_var_configuration.base_path);
118 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
119
120 if let Some(ref local_var_str) = namespace {
121 local_var_req_builder = local_var_req_builder.query(&[("namespace", &local_var_str.to_string())]);
122 }
123 if let Some(ref local_var_str) = object {
124 local_var_req_builder = local_var_req_builder.query(&[("object", &local_var_str.to_string())]);
125 }
126 if let Some(ref local_var_str) = relation {
127 local_var_req_builder = local_var_req_builder.query(&[("relation", &local_var_str.to_string())]);
128 }
129 if let Some(ref local_var_str) = subject_id {
130 local_var_req_builder = local_var_req_builder.query(&[("subject_id", &local_var_str.to_string())]);
131 }
132 if let Some(ref local_var_str) = subject_set_period_namespace {
133 local_var_req_builder = local_var_req_builder.query(&[("subject_set.namespace", &local_var_str.to_string())]);
134 }
135 if let Some(ref local_var_str) = subject_set_period_object {
136 local_var_req_builder = local_var_req_builder.query(&[("subject_set.object", &local_var_str.to_string())]);
137 }
138 if let Some(ref local_var_str) = subject_set_period_relation {
139 local_var_req_builder = local_var_req_builder.query(&[("subject_set.relation", &local_var_str.to_string())]);
140 }
141 if let Some(ref local_var_str) = max_depth {
142 local_var_req_builder = local_var_req_builder.query(&[("max-depth", &local_var_str.to_string())]);
143 }
144 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
145 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
146 }
147 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
148 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
149 };
150
151 let local_var_req = local_var_req_builder.build()?;
152 let local_var_resp = local_var_client.execute(local_var_req).await?;
153
154 let local_var_status = local_var_resp.status();
155 let local_var_content = local_var_resp.text().await?;
156
157 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
158 serde_json::from_str(&local_var_content).map_err(Error::from)
159 } else {
160 let local_var_entity: Option<CheckPermissionError> = serde_json::from_str(&local_var_content).ok();
161 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
162 Err(Error::ResponseError(local_var_error))
163 }
164}
165
166pub async fn check_permission_or_error(configuration: &configuration::Configuration, namespace: Option<&str>, object: Option<&str>, relation: Option<&str>, subject_id: Option<&str>, subject_set_period_namespace: Option<&str>, subject_set_period_object: Option<&str>, subject_set_period_relation: Option<&str>, max_depth: Option<i64>) -> Result<models::CheckPermissionResult, Error<CheckPermissionOrErrorError>> {
168 let local_var_configuration = configuration;
169
170 let local_var_client = &local_var_configuration.client;
171
172 let local_var_uri_str = format!("{}/relation-tuples/check", local_var_configuration.base_path);
173 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
174
175 if let Some(ref local_var_str) = namespace {
176 local_var_req_builder = local_var_req_builder.query(&[("namespace", &local_var_str.to_string())]);
177 }
178 if let Some(ref local_var_str) = object {
179 local_var_req_builder = local_var_req_builder.query(&[("object", &local_var_str.to_string())]);
180 }
181 if let Some(ref local_var_str) = relation {
182 local_var_req_builder = local_var_req_builder.query(&[("relation", &local_var_str.to_string())]);
183 }
184 if let Some(ref local_var_str) = subject_id {
185 local_var_req_builder = local_var_req_builder.query(&[("subject_id", &local_var_str.to_string())]);
186 }
187 if let Some(ref local_var_str) = subject_set_period_namespace {
188 local_var_req_builder = local_var_req_builder.query(&[("subject_set.namespace", &local_var_str.to_string())]);
189 }
190 if let Some(ref local_var_str) = subject_set_period_object {
191 local_var_req_builder = local_var_req_builder.query(&[("subject_set.object", &local_var_str.to_string())]);
192 }
193 if let Some(ref local_var_str) = subject_set_period_relation {
194 local_var_req_builder = local_var_req_builder.query(&[("subject_set.relation", &local_var_str.to_string())]);
195 }
196 if let Some(ref local_var_str) = max_depth {
197 local_var_req_builder = local_var_req_builder.query(&[("max-depth", &local_var_str.to_string())]);
198 }
199 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
200 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
201 }
202 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
203 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
204 };
205
206 let local_var_req = local_var_req_builder.build()?;
207 let local_var_resp = local_var_client.execute(local_var_req).await?;
208
209 let local_var_status = local_var_resp.status();
210 let local_var_content = local_var_resp.text().await?;
211
212 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
213 serde_json::from_str(&local_var_content).map_err(Error::from)
214 } else {
215 let local_var_entity: Option<CheckPermissionOrErrorError> = serde_json::from_str(&local_var_content).ok();
216 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
217 Err(Error::ResponseError(local_var_error))
218 }
219}
220
221pub async fn expand_permissions(configuration: &configuration::Configuration, namespace: &str, object: &str, relation: &str, max_depth: Option<i64>) -> Result<models::ExpandedPermissionTree, Error<ExpandPermissionsError>> {
223 let local_var_configuration = configuration;
224
225 let local_var_client = &local_var_configuration.client;
226
227 let local_var_uri_str = format!("{}/relation-tuples/expand", local_var_configuration.base_path);
228 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
229
230 local_var_req_builder = local_var_req_builder.query(&[("namespace", &namespace.to_string())]);
231 local_var_req_builder = local_var_req_builder.query(&[("object", &object.to_string())]);
232 local_var_req_builder = local_var_req_builder.query(&[("relation", &relation.to_string())]);
233 if let Some(ref local_var_str) = max_depth {
234 local_var_req_builder = local_var_req_builder.query(&[("max-depth", &local_var_str.to_string())]);
235 }
236 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
237 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
238 }
239 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
240 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
241 };
242
243 let local_var_req = local_var_req_builder.build()?;
244 let local_var_resp = local_var_client.execute(local_var_req).await?;
245
246 let local_var_status = local_var_resp.status();
247 let local_var_content = local_var_resp.text().await?;
248
249 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
250 serde_json::from_str(&local_var_content).map_err(Error::from)
251 } else {
252 let local_var_entity: Option<ExpandPermissionsError> = serde_json::from_str(&local_var_content).ok();
253 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
254 Err(Error::ResponseError(local_var_error))
255 }
256}
257
258pub async fn post_check_permission(configuration: &configuration::Configuration, max_depth: Option<i64>, post_check_permission_body: Option<models::PostCheckPermissionBody>) -> Result<models::CheckPermissionResult, Error<PostCheckPermissionError>> {
260 let local_var_configuration = configuration;
261
262 let local_var_client = &local_var_configuration.client;
263
264 let local_var_uri_str = format!("{}/relation-tuples/check/openapi", local_var_configuration.base_path);
265 let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
266
267 if let Some(ref local_var_str) = max_depth {
268 local_var_req_builder = local_var_req_builder.query(&[("max-depth", &local_var_str.to_string())]);
269 }
270 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
271 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
272 }
273 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
274 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
275 };
276 local_var_req_builder = local_var_req_builder.json(&post_check_permission_body);
277
278 let local_var_req = local_var_req_builder.build()?;
279 let local_var_resp = local_var_client.execute(local_var_req).await?;
280
281 let local_var_status = local_var_resp.status();
282 let local_var_content = local_var_resp.text().await?;
283
284 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
285 serde_json::from_str(&local_var_content).map_err(Error::from)
286 } else {
287 let local_var_entity: Option<PostCheckPermissionError> = serde_json::from_str(&local_var_content).ok();
288 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
289 Err(Error::ResponseError(local_var_error))
290 }
291}
292
293pub async fn post_check_permission_or_error(configuration: &configuration::Configuration, max_depth: Option<i64>, post_check_permission_or_error_body: Option<models::PostCheckPermissionOrErrorBody>) -> Result<models::CheckPermissionResult, Error<PostCheckPermissionOrErrorError>> {
295 let local_var_configuration = configuration;
296
297 let local_var_client = &local_var_configuration.client;
298
299 let local_var_uri_str = format!("{}/relation-tuples/check", local_var_configuration.base_path);
300 let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
301
302 if let Some(ref local_var_str) = max_depth {
303 local_var_req_builder = local_var_req_builder.query(&[("max-depth", &local_var_str.to_string())]);
304 }
305 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
306 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
307 }
308 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
309 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
310 };
311 local_var_req_builder = local_var_req_builder.json(&post_check_permission_or_error_body);
312
313 let local_var_req = local_var_req_builder.build()?;
314 let local_var_resp = local_var_client.execute(local_var_req).await?;
315
316 let local_var_status = local_var_resp.status();
317 let local_var_content = local_var_resp.text().await?;
318
319 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
320 serde_json::from_str(&local_var_content).map_err(Error::from)
321 } else {
322 let local_var_entity: Option<PostCheckPermissionOrErrorError> = serde_json::from_str(&local_var_content).ok();
323 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
324 Err(Error::ResponseError(local_var_error))
325 }
326}
327