1use anyhow::Result;
2
3use crate::Client;
4#[derive(Clone, Debug)]
5pub struct ObjectCategories {
6 pub client: Client,
7}
8
9impl ObjectCategories {
10 #[doc(hidden)]
11 pub fn new(client: Client) -> Self {
12 Self { client }
13 }
14
15 #[doc = "List object categories\n\nA List of object categories\n- Requires: `API Tier 1`\n\n**Parameters:**\n\n- `cursor: Option<String>`\n\n```rust,no_run\nuse futures_util::TryStreamExt;\nasync fn example_object_categories_list_stream() -> anyhow::Result<()> {\n let client = rippling_api::Client::new_from_env();\n let mut object_categories = client.object_categories();\n let mut stream = object_categories.list_stream();\n loop {\n match stream.try_next().await {\n Ok(Some(item)) => {\n println!(\"{:?}\", item);\n }\n Ok(None) => {\n break;\n }\n Err(err) => {\n return Err(err.into());\n }\n }\n }\n\n Ok(())\n}\n```"]
16 #[tracing::instrument]
17 pub async fn list<'a>(
18 &'a self,
19 cursor: Option<String>,
20 ) -> Result<crate::types::ListObjectCategoriesResponse, crate::types::error::Error> {
21 let mut req = self.client.client.request(
22 http::Method::GET,
23 format!("{}/{}", self.client.base_url, "object-categories"),
24 );
25 req = req.bearer_auth(&self.client.token);
26 let mut query_params = vec![];
27 if let Some(p) = cursor {
28 query_params.push(("cursor", p));
29 }
30
31 req = req.query(&query_params);
32 let resp = req.send().await?;
33 let status = resp.status();
34 if status.is_success() {
35 let text = resp.text().await.unwrap_or_default();
36 serde_json::from_str(&text).map_err(|err| {
37 crate::types::error::Error::from_serde_error(
38 format_serde_error::SerdeError::new(text.to_string(), err),
39 status,
40 )
41 })
42 } else {
43 let text = resp.text().await.unwrap_or_default();
44 Err(crate::types::error::Error::Server {
45 body: text.to_string(),
46 status,
47 })
48 }
49 }
50
51 #[doc = "List object categories\n\nA List of object categories\n- Requires: `API Tier 1`\n\n**Parameters:**\n\n- `cursor: Option<String>`\n\n```rust,no_run\nuse futures_util::TryStreamExt;\nasync fn example_object_categories_list_stream() -> anyhow::Result<()> {\n let client = rippling_api::Client::new_from_env();\n let mut object_categories = client.object_categories();\n let mut stream = object_categories.list_stream();\n loop {\n match stream.try_next().await {\n Ok(Some(item)) => {\n println!(\"{:?}\", item);\n }\n Ok(None) => {\n break;\n }\n Err(err) => {\n return Err(err.into());\n }\n }\n }\n\n Ok(())\n}\n```"]
52 #[tracing::instrument]
53 #[cfg(not(feature = "js"))]
54 pub fn list_stream<'a>(
55 &'a self,
56 ) -> impl futures::Stream<Item = Result<crate::types::ObjectCategory, crate::types::error::Error>>
57 + Unpin
58 + '_ {
59 use futures::{StreamExt, TryFutureExt, TryStreamExt};
60
61 use crate::types::paginate::Pagination;
62 self.list(None)
63 .map_ok(move |result| {
64 let items = futures::stream::iter(result.items().into_iter().map(Ok));
65 let next_pages = futures::stream::try_unfold(
66 (None, result),
67 move |(prev_page_token, new_result)| async move {
68 if new_result.has_more_pages()
69 && !new_result.items().is_empty()
70 && prev_page_token != new_result.next_page_token()
71 {
72 async {
73 let mut req = self.client.client.request(
74 http::Method::GET,
75 format!("{}/{}", self.client.base_url, "object-categories"),
76 );
77 req = req.bearer_auth(&self.client.token);
78 let mut request = req.build()?;
79 request = new_result.next_page(request)?;
80 let resp = self.client.client.execute(request).await?;
81 let status = resp.status();
82 if status.is_success() {
83 let text = resp.text().await.unwrap_or_default();
84 serde_json::from_str(&text).map_err(|err| {
85 crate::types::error::Error::from_serde_error(
86 format_serde_error::SerdeError::new(
87 text.to_string(),
88 err,
89 ),
90 status,
91 )
92 })
93 } else {
94 let text = resp.text().await.unwrap_or_default();
95 Err(crate::types::error::Error::Server {
96 body: text.to_string(),
97 status,
98 })
99 }
100 }
101 .map_ok(|result: crate::types::ListObjectCategoriesResponse| {
102 Some((
103 futures::stream::iter(result.items().into_iter().map(Ok)),
104 (new_result.next_page_token(), result),
105 ))
106 })
107 .await
108 } else {
109 Ok(None)
110 }
111 },
112 )
113 .try_flatten();
114 items.chain(next_pages)
115 })
116 .try_flatten_stream()
117 .boxed()
118 }
119
120 #[doc = "Create a new object category\n\nCreate a new object category\n\n```rust,no_run\nasync \
121 fn example_object_categories_create() -> anyhow::Result<()> {\n let client = \
122 rippling_api::Client::new_from_env();\n let result: \
123 rippling_api::types::ObjectCategory = client\n .object_categories()\n \
124 .create(&rippling_api::types::CreateObjectCategoriesRequestBody {\n name: \
125 Some(\"some-string\".to_string()),\n description: \
126 Some(\"some-string\".to_string()),\n })\n .await?;\n \
127 println!(\"{:?}\", result);\n Ok(())\n}\n```"]
128 #[tracing::instrument]
129 pub async fn create<'a>(
130 &'a self,
131 body: &crate::types::CreateObjectCategoriesRequestBody,
132 ) -> Result<crate::types::ObjectCategory, crate::types::error::Error> {
133 let mut req = self.client.client.request(
134 http::Method::POST,
135 format!("{}/{}", self.client.base_url, "object-categories"),
136 );
137 req = req.bearer_auth(&self.client.token);
138 req = req.json(body);
139 let resp = req.send().await?;
140 let status = resp.status();
141 if status.is_success() {
142 let text = resp.text().await.unwrap_or_default();
143 serde_json::from_str(&text).map_err(|err| {
144 crate::types::error::Error::from_serde_error(
145 format_serde_error::SerdeError::new(text.to_string(), err),
146 status,
147 )
148 })
149 } else {
150 let text = resp.text().await.unwrap_or_default();
151 Err(crate::types::error::Error::Server {
152 body: text.to_string(),
153 status,
154 })
155 }
156 }
157
158 #[doc = "Retrieve a specific object category\n\nRetrieve a specific object \
159 category\n\n**Parameters:**\n\n- `id: &'astr` (required)\n\n```rust,no_run\nasync fn \
160 example_object_categories_get() -> anyhow::Result<()> {\n let client = \
161 rippling_api::Client::new_from_env();\n let result: \
162 rippling_api::types::ObjectCategory =\n \
163 client.object_categories().get(\"some-string\").await?;\n println!(\"{:?}\", \
164 result);\n Ok(())\n}\n```"]
165 #[tracing::instrument]
166 pub async fn get<'a>(
167 &'a self,
168 id: &'a str,
169 ) -> Result<crate::types::ObjectCategory, crate::types::error::Error> {
170 let mut req = self.client.client.request(
171 http::Method::GET,
172 format!(
173 "{}/{}",
174 self.client.base_url,
175 "object-categories/{id}".replace("{id}", id)
176 ),
177 );
178 req = req.bearer_auth(&self.client.token);
179 let resp = req.send().await?;
180 let status = resp.status();
181 if status.is_success() {
182 let text = resp.text().await.unwrap_or_default();
183 serde_json::from_str(&text).map_err(|err| {
184 crate::types::error::Error::from_serde_error(
185 format_serde_error::SerdeError::new(text.to_string(), err),
186 status,
187 )
188 })
189 } else {
190 let text = resp.text().await.unwrap_or_default();
191 Err(crate::types::error::Error::Server {
192 body: text.to_string(),
193 status,
194 })
195 }
196 }
197
198 #[doc = "Delete a object category\n\n**Parameters:**\n\n- `id: &'astr` \
199 (required)\n\n```rust,no_run\nasync fn example_object_categories_delete() -> \
200 anyhow::Result<()> {\n let client = rippling_api::Client::new_from_env();\n \
201 client.object_categories().delete(\"some-string\").await?;\n Ok(())\n}\n```"]
202 #[tracing::instrument]
203 pub async fn delete<'a>(&'a self, id: &'a str) -> Result<(), crate::types::error::Error> {
204 let mut req = self.client.client.request(
205 http::Method::DELETE,
206 format!(
207 "{}/{}",
208 self.client.base_url,
209 "object-categories/{id}".replace("{id}", id)
210 ),
211 );
212 req = req.bearer_auth(&self.client.token);
213 let resp = req.send().await?;
214 let status = resp.status();
215 if status.is_success() {
216 Ok(())
217 } else {
218 let text = resp.text().await.unwrap_or_default();
219 Err(crate::types::error::Error::Server {
220 body: text.to_string(),
221 status,
222 })
223 }
224 }
225
226 #[doc = "Update a object category\n\nUpdated a specific object \
227 category\n\n**Parameters:**\n\n- `id: &'astr` (required)\n\n```rust,no_run\nasync fn \
228 example_object_categories_update() -> anyhow::Result<()> {\n let client = \
229 rippling_api::Client::new_from_env();\n let result: \
230 rippling_api::types::ObjectCategory = client\n .object_categories()\n \
231 .update(\n \"some-string\",\n \
232 &rippling_api::types::UpdateObjectCategoriesRequestBody {\n name: \
233 Some(\"some-string\".to_string()),\n description: \
234 Some(\"some-string\".to_string()),\n },\n )\n .await?;\n \
235 println!(\"{:?}\", result);\n Ok(())\n}\n```"]
236 #[tracing::instrument]
237 pub async fn update<'a>(
238 &'a self,
239 id: &'a str,
240 body: &crate::types::UpdateObjectCategoriesRequestBody,
241 ) -> Result<crate::types::ObjectCategory, crate::types::error::Error> {
242 let mut req = self.client.client.request(
243 http::Method::PATCH,
244 format!(
245 "{}/{}",
246 self.client.base_url,
247 "object-categories/{id}".replace("{id}", id)
248 ),
249 );
250 req = req.bearer_auth(&self.client.token);
251 req = req.json(body);
252 let resp = req.send().await?;
253 let status = resp.status();
254 if status.is_success() {
255 let text = resp.text().await.unwrap_or_default();
256 serde_json::from_str(&text).map_err(|err| {
257 crate::types::error::Error::from_serde_error(
258 format_serde_error::SerdeError::new(text.to_string(), err),
259 status,
260 )
261 })
262 } else {
263 let text = resp.text().await.unwrap_or_default();
264 Err(crate::types::error::Error::Server {
265 body: text.to_string(),
266 status,
267 })
268 }
269 }
270}