bitwarden_api_api/apis/
policies_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 PoliciesApi: Send + Sync {
29 async fn get<'a>(
31 &self,
32 org_id: uuid::Uuid,
33 r#type: models::PolicyType,
34 ) -> Result<models::PolicyStatusResponseModel, Error>;
35
36 async fn get_all<'a>(
38 &self,
39 org_id: &'a str,
40 ) -> Result<models::PolicyStatusResponseModelListResponseModel, Error>;
41
42 async fn get_by_token<'a>(
44 &self,
45 org_id: uuid::Uuid,
46 email: Option<&'a str>,
47 token: Option<&'a str>,
48 organization_user_id: Option<uuid::Uuid>,
49 ) -> Result<models::PolicyResponseModelListResponseModel, Error>;
50
51 async fn get_master_password_policy<'a>(
53 &self,
54 org_id: uuid::Uuid,
55 ) -> Result<models::PolicyResponseModel, Error>;
56
57 async fn put<'a>(
59 &self,
60 org_id: uuid::Uuid,
61 r#type: models::PolicyType,
62 save_policy_request: Option<models::SavePolicyRequest>,
63 ) -> Result<models::PolicyResponseModel, Error>;
64}
65
66pub struct PoliciesApiClient {
67 configuration: Arc<configuration::Configuration>,
68}
69
70impl PoliciesApiClient {
71 pub fn new(configuration: Arc<configuration::Configuration>) -> Self {
72 Self { configuration }
73 }
74}
75
76#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
77#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
78impl PoliciesApi for PoliciesApiClient {
79 async fn get<'a>(
80 &self,
81 org_id: uuid::Uuid,
82 r#type: models::PolicyType,
83 ) -> Result<models::PolicyStatusResponseModel, Error> {
84 let local_var_configuration = &self.configuration;
85
86 let local_var_client = &local_var_configuration.client;
87
88 let local_var_uri_str = format!("{}/organizations/{orgId}/policies/{type}", local_var_configuration.base_path, orgId=org_id, type=r#type.to_string());
89 let mut local_var_req_builder =
90 local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
91
92 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
93
94 bitwarden_api_base::process_with_json_response(local_var_req_builder).await
95 }
96
97 async fn get_all<'a>(
98 &self,
99 org_id: &'a str,
100 ) -> Result<models::PolicyStatusResponseModelListResponseModel, Error> {
101 let local_var_configuration = &self.configuration;
102
103 let local_var_client = &local_var_configuration.client;
104
105 let local_var_uri_str = format!(
106 "{}/organizations/{orgId}/policies",
107 local_var_configuration.base_path,
108 orgId = crate::apis::urlencode(org_id)
109 );
110 let mut local_var_req_builder =
111 local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
112
113 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
114
115 bitwarden_api_base::process_with_json_response(local_var_req_builder).await
116 }
117
118 async fn get_by_token<'a>(
119 &self,
120 org_id: uuid::Uuid,
121 email: Option<&'a str>,
122 token: Option<&'a str>,
123 organization_user_id: Option<uuid::Uuid>,
124 ) -> Result<models::PolicyResponseModelListResponseModel, Error> {
125 let local_var_configuration = &self.configuration;
126
127 let local_var_client = &local_var_configuration.client;
128
129 let local_var_uri_str = format!(
130 "{}/organizations/{orgId}/policies/token",
131 local_var_configuration.base_path,
132 orgId = org_id
133 );
134 let mut local_var_req_builder =
135 local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
136
137 if let Some(ref param_value) = email {
138 local_var_req_builder =
139 local_var_req_builder.query(&[("email", ¶m_value.to_string())]);
140 }
141 if let Some(ref param_value) = token {
142 local_var_req_builder =
143 local_var_req_builder.query(&[("token", ¶m_value.to_string())]);
144 }
145 if let Some(ref param_value) = organization_user_id {
146 local_var_req_builder =
147 local_var_req_builder.query(&[("organizationUserId", ¶m_value.to_string())]);
148 }
149 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
150
151 bitwarden_api_base::process_with_json_response(local_var_req_builder).await
152 }
153
154 async fn get_master_password_policy<'a>(
155 &self,
156 org_id: uuid::Uuid,
157 ) -> Result<models::PolicyResponseModel, Error> {
158 let local_var_configuration = &self.configuration;
159
160 let local_var_client = &local_var_configuration.client;
161
162 let local_var_uri_str = format!(
163 "{}/organizations/{orgId}/policies/master-password",
164 local_var_configuration.base_path,
165 orgId = org_id
166 );
167 let mut local_var_req_builder =
168 local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
169
170 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
171
172 bitwarden_api_base::process_with_json_response(local_var_req_builder).await
173 }
174
175 async fn put<'a>(
176 &self,
177 org_id: uuid::Uuid,
178 r#type: models::PolicyType,
179 save_policy_request: Option<models::SavePolicyRequest>,
180 ) -> Result<models::PolicyResponseModel, Error> {
181 let local_var_configuration = &self.configuration;
182
183 let local_var_client = &local_var_configuration.client;
184
185 let local_var_uri_str = format!("{}/organizations/{orgId}/policies/{type}", local_var_configuration.base_path, orgId=org_id, type=r#type.to_string());
186 let mut local_var_req_builder =
187 local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
188
189 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
190 local_var_req_builder = local_var_req_builder.json(&save_policy_request);
191
192 bitwarden_api_base::process_with_json_response(local_var_req_builder).await
193 }
194}