bitwarden_api_api/apis/
access_rules_api.rs1use std::sync::Arc;
12
13use async_trait::async_trait;
14#[cfg(feature = "mockall")]
15use mockall::automock;
16use reqwest;
17use serde::{Deserialize, Serialize, de::Error as _};
18
19use super::{Error, configuration};
20use crate::{
21 apis::{AuthRequired, ContentType, ResponseContent},
22 models,
23};
24
25#[cfg_attr(feature = "mockall", automock)]
26#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
27#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
28pub trait AccessRulesApi: Send + Sync {
29 async fn delete<'a>(&self, org_id: uuid::Uuid, id: uuid::Uuid) -> Result<(), Error>;
31
32 async fn get<'a>(
34 &self,
35 org_id: uuid::Uuid,
36 id: uuid::Uuid,
37 ) -> Result<models::AccessRuleResponseModel, Error>;
38
39 async fn get_all<'a>(
41 &self,
42 org_id: uuid::Uuid,
43 ) -> Result<models::AccessRuleResponseModelListResponseModel, Error>;
44
45 async fn post<'a>(
47 &self,
48 org_id: uuid::Uuid,
49 access_rule_request_model: models::AccessRuleRequestModel,
50 ) -> Result<models::AccessRuleResponseModel, Error>;
51
52 async fn put<'a>(
54 &self,
55 org_id: uuid::Uuid,
56 id: uuid::Uuid,
57 access_rule_request_model: models::AccessRuleRequestModel,
58 ) -> Result<models::AccessRuleResponseModel, Error>;
59}
60
61pub struct AccessRulesApiClient {
62 configuration: Arc<configuration::Configuration>,
63}
64
65impl AccessRulesApiClient {
66 pub fn new(configuration: Arc<configuration::Configuration>) -> Self {
67 Self { configuration }
68 }
69}
70
71#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
72#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
73impl AccessRulesApi for AccessRulesApiClient {
74 async fn delete<'a>(&self, org_id: uuid::Uuid, id: uuid::Uuid) -> Result<(), Error> {
75 let local_var_configuration = &self.configuration;
76
77 let local_var_client = &local_var_configuration.client;
78
79 let local_var_uri_str = format!(
80 "{}/organizations/{orgId}/access-rules/{id}",
81 local_var_configuration.base_path,
82 orgId = org_id,
83 id = id
84 );
85 let mut local_var_req_builder =
86 local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
87
88 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
89
90 bitwarden_api_base::process_with_empty_response(local_var_req_builder).await
91 }
92
93 async fn get<'a>(
94 &self,
95 org_id: uuid::Uuid,
96 id: uuid::Uuid,
97 ) -> Result<models::AccessRuleResponseModel, Error> {
98 let local_var_configuration = &self.configuration;
99
100 let local_var_client = &local_var_configuration.client;
101
102 let local_var_uri_str = format!(
103 "{}/organizations/{orgId}/access-rules/{id}",
104 local_var_configuration.base_path,
105 orgId = org_id,
106 id = id
107 );
108 let mut local_var_req_builder =
109 local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
110
111 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
112
113 bitwarden_api_base::process_with_json_response(local_var_req_builder).await
114 }
115
116 async fn get_all<'a>(
117 &self,
118 org_id: uuid::Uuid,
119 ) -> Result<models::AccessRuleResponseModelListResponseModel, Error> {
120 let local_var_configuration = &self.configuration;
121
122 let local_var_client = &local_var_configuration.client;
123
124 let local_var_uri_str = format!(
125 "{}/organizations/{orgId}/access-rules",
126 local_var_configuration.base_path,
127 orgId = org_id
128 );
129 let mut local_var_req_builder =
130 local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
131
132 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
133
134 bitwarden_api_base::process_with_json_response(local_var_req_builder).await
135 }
136
137 async fn post<'a>(
138 &self,
139 org_id: uuid::Uuid,
140 access_rule_request_model: models::AccessRuleRequestModel,
141 ) -> Result<models::AccessRuleResponseModel, Error> {
142 let local_var_configuration = &self.configuration;
143
144 let local_var_client = &local_var_configuration.client;
145
146 let local_var_uri_str = format!(
147 "{}/organizations/{orgId}/access-rules",
148 local_var_configuration.base_path,
149 orgId = org_id
150 );
151 let mut local_var_req_builder =
152 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
153
154 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
155 local_var_req_builder = local_var_req_builder.json(&access_rule_request_model);
156
157 bitwarden_api_base::process_with_json_response(local_var_req_builder).await
158 }
159
160 async fn put<'a>(
161 &self,
162 org_id: uuid::Uuid,
163 id: uuid::Uuid,
164 access_rule_request_model: models::AccessRuleRequestModel,
165 ) -> Result<models::AccessRuleResponseModel, Error> {
166 let local_var_configuration = &self.configuration;
167
168 let local_var_client = &local_var_configuration.client;
169
170 let local_var_uri_str = format!(
171 "{}/organizations/{orgId}/access-rules/{id}",
172 local_var_configuration.base_path,
173 orgId = org_id,
174 id = id
175 );
176 let mut local_var_req_builder =
177 local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
178
179 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
180 local_var_req_builder = local_var_req_builder.json(&access_rule_request_model);
181
182 bitwarden_api_base::process_with_json_response(local_var_req_builder).await
183 }
184}