bitwarden_api_api/apis/
provider_organizations_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 ProviderOrganizationsApi: Send + Sync {
29 async fn add<'a>(
31 &self,
32 provider_id: uuid::Uuid,
33 provider_organization_add_request_model: Option<
34 models::ProviderOrganizationAddRequestModel,
35 >,
36 ) -> Result<(), Error<AddError>>;
37
38 async fn delete<'a>(
40 &self,
41 provider_id: uuid::Uuid,
42 id: uuid::Uuid,
43 ) -> Result<(), Error<DeleteError>>;
44
45 async fn get<'a>(
47 &self,
48 provider_id: uuid::Uuid,
49 ) -> Result<
50 models::ProviderOrganizationOrganizationDetailsResponseModelListResponseModel,
51 Error<GetError>,
52 >;
53
54 async fn post<'a>(
56 &self,
57 provider_id: uuid::Uuid,
58 provider_organization_create_request_model: Option<
59 models::ProviderOrganizationCreateRequestModel,
60 >,
61 ) -> Result<models::ProviderOrganizationResponseModel, Error<PostError>>;
62}
63
64pub struct ProviderOrganizationsApiClient {
65 configuration: Arc<configuration::Configuration>,
66}
67
68impl ProviderOrganizationsApiClient {
69 pub fn new(configuration: Arc<configuration::Configuration>) -> Self {
70 Self { configuration }
71 }
72}
73
74#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
75#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
76impl ProviderOrganizationsApi for ProviderOrganizationsApiClient {
77 async fn add<'a>(
78 &self,
79 provider_id: uuid::Uuid,
80 provider_organization_add_request_model: Option<
81 models::ProviderOrganizationAddRequestModel,
82 >,
83 ) -> Result<(), Error<AddError>> {
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!(
89 "{}/providers/{providerId}/organizations/add",
90 local_var_configuration.base_path,
91 providerId = provider_id
92 );
93 let mut local_var_req_builder =
94 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
95
96 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
97 local_var_req_builder =
98 local_var_req_builder.json(&provider_organization_add_request_model);
99
100 bitwarden_api_base::process_with_empty_response(local_var_req_builder).await
101 }
102
103 async fn delete<'a>(
104 &self,
105 provider_id: uuid::Uuid,
106 id: uuid::Uuid,
107 ) -> Result<(), Error<DeleteError>> {
108 let local_var_configuration = &self.configuration;
109
110 let local_var_client = &local_var_configuration.client;
111
112 let local_var_uri_str = format!(
113 "{}/providers/{providerId}/organizations/{id}",
114 local_var_configuration.base_path,
115 providerId = provider_id,
116 id = id
117 );
118 let mut local_var_req_builder =
119 local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
120
121 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
122
123 bitwarden_api_base::process_with_empty_response(local_var_req_builder).await
124 }
125
126 async fn get<'a>(
127 &self,
128 provider_id: uuid::Uuid,
129 ) -> Result<
130 models::ProviderOrganizationOrganizationDetailsResponseModelListResponseModel,
131 Error<GetError>,
132 > {
133 let local_var_configuration = &self.configuration;
134
135 let local_var_client = &local_var_configuration.client;
136
137 let local_var_uri_str = format!(
138 "{}/providers/{providerId}/organizations",
139 local_var_configuration.base_path,
140 providerId = provider_id
141 );
142 let mut local_var_req_builder =
143 local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
144
145 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
146
147 bitwarden_api_base::process_with_json_response(local_var_req_builder).await
148 }
149
150 async fn post<'a>(
151 &self,
152 provider_id: uuid::Uuid,
153 provider_organization_create_request_model: Option<
154 models::ProviderOrganizationCreateRequestModel,
155 >,
156 ) -> Result<models::ProviderOrganizationResponseModel, Error<PostError>> {
157 let local_var_configuration = &self.configuration;
158
159 let local_var_client = &local_var_configuration.client;
160
161 let local_var_uri_str = format!(
162 "{}/providers/{providerId}/organizations",
163 local_var_configuration.base_path,
164 providerId = provider_id
165 );
166 let mut local_var_req_builder =
167 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
168
169 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
170 local_var_req_builder =
171 local_var_req_builder.json(&provider_organization_create_request_model);
172
173 bitwarden_api_base::process_with_json_response(local_var_req_builder).await
174 }
175}
176
177#[derive(Debug, Clone, Serialize, Deserialize)]
179#[serde(untagged)]
180pub enum AddError {
181 UnknownValue(serde_json::Value),
182}
183#[derive(Debug, Clone, Serialize, Deserialize)]
185#[serde(untagged)]
186pub enum DeleteError {
187 UnknownValue(serde_json::Value),
188}
189#[derive(Debug, Clone, Serialize, Deserialize)]
191#[serde(untagged)]
192pub enum GetError {
193 UnknownValue(serde_json::Value),
194}
195#[derive(Debug, Clone, Serialize, Deserialize)]
197#[serde(untagged)]
198pub enum PostError {
199 UnknownValue(serde_json::Value),
200}