1use reqwest;
12
13use super::{configuration, Error};
14use crate::apis::ResponseContent;
15
16#[derive(Debug, Clone, Serialize, Deserialize)]
18#[serde(untagged)]
19pub enum GetPortfolioMembershipError {
20 Status400(crate::models::ErrorResponse),
21 Status401(crate::models::ErrorResponse),
22 Status403(crate::models::ErrorResponse),
23 Status404(crate::models::ErrorResponse),
24 Status500(crate::models::ErrorResponse),
25 UnknownValue(serde_json::Value),
26}
27
28#[derive(Debug, Clone, Serialize, Deserialize)]
30#[serde(untagged)]
31pub enum GetPortfolioMembershipsError {
32 Status400(crate::models::ErrorResponse),
33 Status401(crate::models::ErrorResponse),
34 Status403(crate::models::ErrorResponse),
35 Status404(crate::models::ErrorResponse),
36 Status500(crate::models::ErrorResponse),
37 UnknownValue(serde_json::Value),
38}
39
40#[derive(Debug, Clone, Serialize, Deserialize)]
42#[serde(untagged)]
43pub enum GetPortfolioMembershipsForPortfolioError {
44 Status400(crate::models::ErrorResponse),
45 Status401(crate::models::ErrorResponse),
46 Status403(crate::models::ErrorResponse),
47 Status404(crate::models::ErrorResponse),
48 Status500(crate::models::ErrorResponse),
49 UnknownValue(serde_json::Value),
50}
51
52pub async fn get_portfolio_membership(
54 configuration: &configuration::Configuration,
55 portfolio_membership_gid: &str,
56 opt_pretty: Option<bool>,
57 opt_fields: Option<Vec<String>>,
58) -> Result<crate::models::InlineResponse2009, Error<GetPortfolioMembershipError>>
59{
60 let local_var_client = &configuration.client;
61
62 let local_var_uri_str = format!(
63 "{}/portfolio_memberships/{portfolio_membership_gid}",
64 configuration.base_path,
65 portfolio_membership_gid =
66 crate::apis::urlencode(portfolio_membership_gid)
67 );
68 let mut local_var_req_builder =
69 local_var_client.get(local_var_uri_str.as_str());
70
71 if let Some(ref local_var_str) = opt_pretty {
72 local_var_req_builder = local_var_req_builder
73 .query(&[("opt_pretty", &local_var_str.to_string())]);
74 }
75 if let Some(ref local_var_str) = opt_fields {
76 local_var_req_builder = local_var_req_builder.query(&[(
77 "opt_fields",
78 &local_var_str
79 .into_iter()
80 .map(|p| p.to_string())
81 .collect::<Vec<String>>()
82 .join(",")
83 .to_string(),
84 )]);
85 }
86 if let Some(ref local_var_user_agent) = configuration.user_agent {
87 local_var_req_builder = local_var_req_builder
88 .header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
89 }
90 if let Some(ref local_var_token) = configuration.oauth_access_token {
91 local_var_req_builder =
92 local_var_req_builder.bearer_auth(local_var_token.to_owned());
93 };
94 if let Some(ref local_var_token) = configuration.bearer_access_token {
95 local_var_req_builder =
96 local_var_req_builder.bearer_auth(local_var_token.to_owned());
97 };
98
99 let local_var_req = local_var_req_builder.build()?;
100 let local_var_resp = local_var_client.execute(local_var_req).await?;
101
102 let local_var_status = local_var_resp.status();
103 let local_var_content = local_var_resp.text().await?;
104
105 if !local_var_status.is_client_error()
106 && !local_var_status.is_server_error()
107 {
108 serde_json::from_str(&local_var_content).map_err(Error::from)
109 } else {
110 let local_var_entity: Option<GetPortfolioMembershipError> =
111 serde_json::from_str(&local_var_content).ok();
112 let local_var_error = ResponseContent {
113 status: local_var_status,
114 content: local_var_content,
115 entity: local_var_entity,
116 };
117 Err(Error::ResponseError(local_var_error))
118 }
119}
120
121pub async fn get_portfolio_memberships(
123 configuration: &configuration::Configuration,
124 portfolio: Option<&str>,
125 workspace: Option<&str>,
126 user: Option<&str>,
127 opt_pretty: Option<bool>,
128 opt_fields: Option<Vec<String>>,
129 limit: Option<i32>,
130 offset: Option<&str>,
131) -> Result<
132 crate::models::InlineResponse2008,
133 Error<GetPortfolioMembershipsError>,
134> {
135 let local_var_client = &configuration.client;
136
137 let local_var_uri_str =
138 format!("{}/portfolio_memberships", configuration.base_path);
139 let mut local_var_req_builder =
140 local_var_client.get(local_var_uri_str.as_str());
141
142 if let Some(ref local_var_str) = portfolio {
143 local_var_req_builder = local_var_req_builder
144 .query(&[("portfolio", &local_var_str.to_string())]);
145 }
146 if let Some(ref local_var_str) = workspace {
147 local_var_req_builder = local_var_req_builder
148 .query(&[("workspace", &local_var_str.to_string())]);
149 }
150 if let Some(ref local_var_str) = user {
151 local_var_req_builder = local_var_req_builder
152 .query(&[("user", &local_var_str.to_string())]);
153 }
154 if let Some(ref local_var_str) = opt_pretty {
155 local_var_req_builder = local_var_req_builder
156 .query(&[("opt_pretty", &local_var_str.to_string())]);
157 }
158 if let Some(ref local_var_str) = opt_fields {
159 local_var_req_builder = local_var_req_builder.query(&[(
160 "opt_fields",
161 &local_var_str
162 .into_iter()
163 .map(|p| p.to_string())
164 .collect::<Vec<String>>()
165 .join(",")
166 .to_string(),
167 )]);
168 }
169 if let Some(ref local_var_str) = limit {
170 local_var_req_builder = local_var_req_builder
171 .query(&[("limit", &local_var_str.to_string())]);
172 }
173 if let Some(ref local_var_str) = offset {
174 local_var_req_builder = local_var_req_builder
175 .query(&[("offset", &local_var_str.to_string())]);
176 }
177 if let Some(ref local_var_user_agent) = configuration.user_agent {
178 local_var_req_builder = local_var_req_builder
179 .header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
180 }
181 if let Some(ref local_var_token) = configuration.oauth_access_token {
182 local_var_req_builder =
183 local_var_req_builder.bearer_auth(local_var_token.to_owned());
184 };
185 if let Some(ref local_var_token) = configuration.bearer_access_token {
186 local_var_req_builder =
187 local_var_req_builder.bearer_auth(local_var_token.to_owned());
188 };
189
190 let local_var_req = local_var_req_builder.build()?;
191 let local_var_resp = local_var_client.execute(local_var_req).await?;
192
193 let local_var_status = local_var_resp.status();
194 let local_var_content = local_var_resp.text().await?;
195
196 if !local_var_status.is_client_error()
197 && !local_var_status.is_server_error()
198 {
199 serde_json::from_str(&local_var_content).map_err(Error::from)
200 } else {
201 let local_var_entity: Option<GetPortfolioMembershipsError> =
202 serde_json::from_str(&local_var_content).ok();
203 let local_var_error = ResponseContent {
204 status: local_var_status,
205 content: local_var_content,
206 entity: local_var_entity,
207 };
208 Err(Error::ResponseError(local_var_error))
209 }
210}
211
212pub async fn get_portfolio_memberships_for_portfolio(
214 configuration: &configuration::Configuration,
215 portfolio_gid: &str,
216 user: Option<&str>,
217 opt_pretty: Option<bool>,
218 opt_fields: Option<Vec<String>>,
219 limit: Option<i32>,
220 offset: Option<&str>,
221) -> Result<
222 crate::models::InlineResponse2008,
223 Error<GetPortfolioMembershipsForPortfolioError>,
224> {
225 let local_var_client = &configuration.client;
226
227 let local_var_uri_str = format!(
228 "{}/portfolios/{portfolio_gid}/portfolio_memberships",
229 configuration.base_path,
230 portfolio_gid = crate::apis::urlencode(portfolio_gid)
231 );
232 let mut local_var_req_builder =
233 local_var_client.get(local_var_uri_str.as_str());
234
235 if let Some(ref local_var_str) = user {
236 local_var_req_builder = local_var_req_builder
237 .query(&[("user", &local_var_str.to_string())]);
238 }
239 if let Some(ref local_var_str) = opt_pretty {
240 local_var_req_builder = local_var_req_builder
241 .query(&[("opt_pretty", &local_var_str.to_string())]);
242 }
243 if let Some(ref local_var_str) = opt_fields {
244 local_var_req_builder = local_var_req_builder.query(&[(
245 "opt_fields",
246 &local_var_str
247 .into_iter()
248 .map(|p| p.to_string())
249 .collect::<Vec<String>>()
250 .join(",")
251 .to_string(),
252 )]);
253 }
254 if let Some(ref local_var_str) = limit {
255 local_var_req_builder = local_var_req_builder
256 .query(&[("limit", &local_var_str.to_string())]);
257 }
258 if let Some(ref local_var_str) = offset {
259 local_var_req_builder = local_var_req_builder
260 .query(&[("offset", &local_var_str.to_string())]);
261 }
262 if let Some(ref local_var_user_agent) = configuration.user_agent {
263 local_var_req_builder = local_var_req_builder
264 .header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
265 }
266 if let Some(ref local_var_token) = configuration.oauth_access_token {
267 local_var_req_builder =
268 local_var_req_builder.bearer_auth(local_var_token.to_owned());
269 };
270 if let Some(ref local_var_token) = configuration.bearer_access_token {
271 local_var_req_builder =
272 local_var_req_builder.bearer_auth(local_var_token.to_owned());
273 };
274
275 let local_var_req = local_var_req_builder.build()?;
276 let local_var_resp = local_var_client.execute(local_var_req).await?;
277
278 let local_var_status = local_var_resp.status();
279 let local_var_content = local_var_resp.text().await?;
280
281 if !local_var_status.is_client_error()
282 && !local_var_status.is_server_error()
283 {
284 serde_json::from_str(&local_var_content).map_err(Error::from)
285 } else {
286 let local_var_entity: Option<GetPortfolioMembershipsForPortfolioError> =
287 serde_json::from_str(&local_var_content).ok();
288 let local_var_error = ResponseContent {
289 status: local_var_status,
290 content: local_var_content,
291 entity: local_var_entity,
292 };
293 Err(Error::ResponseError(local_var_error))
294 }
295}