1use anyhow::Result;
2
3use crate::Client;
4#[derive(Clone, Debug)]
5pub struct TracksAndLevels {
6 pub client: Client,
7}
8
9impl TracksAndLevels {
10 #[doc(hidden)]
11 pub fn new(client: Client) -> Self {
12 Self { client }
13 }
14
15 #[doc = "List levels\n\nA List of levels\n- Requires: `API Tier 2`\n- Expandable fields: `parent`, `track`\n- Sortable fields: `id`, `created_at`, `updated_at`\n\n**Parameters:**\n\n- `cursor: Option<String>`\n- `expand: Option<String>`\n- `order_by: Option<String>`\n\n```rust,no_run\nuse futures_util::TryStreamExt;\nasync fn example_tracks_and_levels_list_levels_stream() -> anyhow::Result<()> {\n let client = rippling_api::Client::new_from_env();\n let mut tracks_and_levels = client.tracks_and_levels();\n let mut stream = tracks_and_levels.list_levels_stream(\n Some(\"some-string\".to_string()),\n Some(\"some-string\".to_string()),\n );\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_levels<'a>(
18 &'a self,
19 cursor: Option<String>,
20 expand: Option<String>,
21 order_by: Option<String>,
22 ) -> Result<crate::types::ListLevelsResponse, crate::types::error::Error> {
23 let mut req = self.client.client.request(
24 http::Method::GET,
25 format!("{}/{}", self.client.base_url, "levels"),
26 );
27 req = req.bearer_auth(&self.client.token);
28 let mut query_params = vec![];
29 if let Some(p) = cursor {
30 query_params.push(("cursor", p));
31 }
32
33 if let Some(p) = expand {
34 query_params.push(("expand", p));
35 }
36
37 if let Some(p) = order_by {
38 query_params.push(("order_by", p));
39 }
40
41 req = req.query(&query_params);
42 let resp = req.send().await?;
43 let status = resp.status();
44 if status.is_success() {
45 let text = resp.text().await.unwrap_or_default();
46 serde_json::from_str(&text).map_err(|err| {
47 crate::types::error::Error::from_serde_error(
48 format_serde_error::SerdeError::new(text.to_string(), err),
49 status,
50 )
51 })
52 } else {
53 let text = resp.text().await.unwrap_or_default();
54 Err(crate::types::error::Error::Server {
55 body: text.to_string(),
56 status,
57 })
58 }
59 }
60
61 #[doc = "List levels\n\nA List of levels\n- Requires: `API Tier 2`\n- Expandable fields: `parent`, `track`\n- Sortable fields: `id`, `created_at`, `updated_at`\n\n**Parameters:**\n\n- `cursor: Option<String>`\n- `expand: Option<String>`\n- `order_by: Option<String>`\n\n```rust,no_run\nuse futures_util::TryStreamExt;\nasync fn example_tracks_and_levels_list_levels_stream() -> anyhow::Result<()> {\n let client = rippling_api::Client::new_from_env();\n let mut tracks_and_levels = client.tracks_and_levels();\n let mut stream = tracks_and_levels.list_levels_stream(\n Some(\"some-string\".to_string()),\n Some(\"some-string\".to_string()),\n );\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```"]
62 #[tracing::instrument]
63 #[cfg(not(feature = "js"))]
64 pub fn list_levels_stream<'a>(
65 &'a self,
66 expand: Option<String>,
67 order_by: Option<String>,
68 ) -> impl futures::Stream<Item = Result<crate::types::Level, crate::types::error::Error>> + Unpin + '_
69 {
70 use futures::{StreamExt, TryFutureExt, TryStreamExt};
71
72 use crate::types::paginate::Pagination;
73 self.list_levels(None, expand, order_by)
74 .map_ok(move |result| {
75 let items = futures::stream::iter(result.items().into_iter().map(Ok));
76 let next_pages = futures::stream::try_unfold(
77 (None, result),
78 move |(prev_page_token, new_result)| async move {
79 if new_result.has_more_pages()
80 && !new_result.items().is_empty()
81 && prev_page_token != new_result.next_page_token()
82 {
83 async {
84 let mut req = self.client.client.request(
85 http::Method::GET,
86 format!("{}/{}", self.client.base_url, "levels"),
87 );
88 req = req.bearer_auth(&self.client.token);
89 let mut request = req.build()?;
90 request = new_result.next_page(request)?;
91 let resp = self.client.client.execute(request).await?;
92 let status = resp.status();
93 if status.is_success() {
94 let text = resp.text().await.unwrap_or_default();
95 serde_json::from_str(&text).map_err(|err| {
96 crate::types::error::Error::from_serde_error(
97 format_serde_error::SerdeError::new(
98 text.to_string(),
99 err,
100 ),
101 status,
102 )
103 })
104 } else {
105 let text = resp.text().await.unwrap_or_default();
106 Err(crate::types::error::Error::Server {
107 body: text.to_string(),
108 status,
109 })
110 }
111 }
112 .map_ok(|result: crate::types::ListLevelsResponse| {
113 Some((
114 futures::stream::iter(result.items().into_iter().map(Ok)),
115 (new_result.next_page_token(), result),
116 ))
117 })
118 .await
119 } else {
120 Ok(None)
121 }
122 },
123 )
124 .try_flatten();
125 items.chain(next_pages)
126 })
127 .try_flatten_stream()
128 .boxed()
129 }
130
131 #[doc = "Retrieve a specific level\n\nRetrieve a specific level\n\n**Parameters:**\n\n- \
132 `expand: Option<String>`\n- `id: &'astr`: ID of the resource to return \
133 (required)\n\n```rust,no_run\nasync fn example_tracks_and_levels_get_levels() -> \
134 anyhow::Result<()> {\n let client = rippling_api::Client::new_from_env();\n let \
135 result: rippling_api::types::GetLevelsResponse = client\n \
136 .tracks_and_levels()\n .get_levels(\n \
137 Some(\"some-string\".to_string()),\n \
138 \"d9797f8d-9ad6-4e08-90d7-2ec17e13471c\",\n )\n .await?;\n \
139 println!(\"{:?}\", result);\n Ok(())\n}\n```"]
140 #[tracing::instrument]
141 pub async fn get_levels<'a>(
142 &'a self,
143 expand: Option<String>,
144 id: &'a str,
145 ) -> Result<crate::types::GetLevelsResponse, crate::types::error::Error> {
146 let mut req = self.client.client.request(
147 http::Method::GET,
148 format!(
149 "{}/{}",
150 self.client.base_url,
151 "levels/{id}".replace("{id}", id)
152 ),
153 );
154 req = req.bearer_auth(&self.client.token);
155 let mut query_params = vec![];
156 if let Some(p) = expand {
157 query_params.push(("expand", p));
158 }
159
160 req = req.query(&query_params);
161 let resp = req.send().await?;
162 let status = resp.status();
163 if status.is_success() {
164 let text = resp.text().await.unwrap_or_default();
165 serde_json::from_str(&text).map_err(|err| {
166 crate::types::error::Error::from_serde_error(
167 format_serde_error::SerdeError::new(text.to_string(), err),
168 status,
169 )
170 })
171 } else {
172 let text = resp.text().await.unwrap_or_default();
173 Err(crate::types::error::Error::Server {
174 body: text.to_string(),
175 status,
176 })
177 }
178 }
179
180 #[doc = "List tracks\n\nA List of tracks\n- Requires: `API Tier 2`\n- Sortable fields: `id`, `created_at`, `updated_at`\n\n**Parameters:**\n\n- `cursor: Option<String>`\n- `order_by: Option<String>`\n\n```rust,no_run\nuse futures_util::TryStreamExt;\nasync fn example_tracks_and_levels_list_tracks_stream() -> anyhow::Result<()> {\n let client = rippling_api::Client::new_from_env();\n let mut tracks_and_levels = client.tracks_and_levels();\n let mut stream = tracks_and_levels.list_tracks_stream(Some(\"some-string\".to_string()));\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```"]
181 #[tracing::instrument]
182 pub async fn list_tracks<'a>(
183 &'a self,
184 cursor: Option<String>,
185 order_by: Option<String>,
186 ) -> Result<crate::types::ListTracksResponse, crate::types::error::Error> {
187 let mut req = self.client.client.request(
188 http::Method::GET,
189 format!("{}/{}", self.client.base_url, "tracks"),
190 );
191 req = req.bearer_auth(&self.client.token);
192 let mut query_params = vec![];
193 if let Some(p) = cursor {
194 query_params.push(("cursor", p));
195 }
196
197 if let Some(p) = order_by {
198 query_params.push(("order_by", p));
199 }
200
201 req = req.query(&query_params);
202 let resp = req.send().await?;
203 let status = resp.status();
204 if status.is_success() {
205 let text = resp.text().await.unwrap_or_default();
206 serde_json::from_str(&text).map_err(|err| {
207 crate::types::error::Error::from_serde_error(
208 format_serde_error::SerdeError::new(text.to_string(), err),
209 status,
210 )
211 })
212 } else {
213 let text = resp.text().await.unwrap_or_default();
214 Err(crate::types::error::Error::Server {
215 body: text.to_string(),
216 status,
217 })
218 }
219 }
220
221 #[doc = "List tracks\n\nA List of tracks\n- Requires: `API Tier 2`\n- Sortable fields: `id`, `created_at`, `updated_at`\n\n**Parameters:**\n\n- `cursor: Option<String>`\n- `order_by: Option<String>`\n\n```rust,no_run\nuse futures_util::TryStreamExt;\nasync fn example_tracks_and_levels_list_tracks_stream() -> anyhow::Result<()> {\n let client = rippling_api::Client::new_from_env();\n let mut tracks_and_levels = client.tracks_and_levels();\n let mut stream = tracks_and_levels.list_tracks_stream(Some(\"some-string\".to_string()));\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```"]
222 #[tracing::instrument]
223 #[cfg(not(feature = "js"))]
224 pub fn list_tracks_stream<'a>(
225 &'a self,
226 order_by: Option<String>,
227 ) -> impl futures::Stream<Item = Result<crate::types::Track, crate::types::error::Error>> + Unpin + '_
228 {
229 use futures::{StreamExt, TryFutureExt, TryStreamExt};
230
231 use crate::types::paginate::Pagination;
232 self.list_tracks(None, order_by)
233 .map_ok(move |result| {
234 let items = futures::stream::iter(result.items().into_iter().map(Ok));
235 let next_pages = futures::stream::try_unfold(
236 (None, result),
237 move |(prev_page_token, new_result)| async move {
238 if new_result.has_more_pages()
239 && !new_result.items().is_empty()
240 && prev_page_token != new_result.next_page_token()
241 {
242 async {
243 let mut req = self.client.client.request(
244 http::Method::GET,
245 format!("{}/{}", self.client.base_url, "tracks"),
246 );
247 req = req.bearer_auth(&self.client.token);
248 let mut request = req.build()?;
249 request = new_result.next_page(request)?;
250 let resp = self.client.client.execute(request).await?;
251 let status = resp.status();
252 if status.is_success() {
253 let text = resp.text().await.unwrap_or_default();
254 serde_json::from_str(&text).map_err(|err| {
255 crate::types::error::Error::from_serde_error(
256 format_serde_error::SerdeError::new(
257 text.to_string(),
258 err,
259 ),
260 status,
261 )
262 })
263 } else {
264 let text = resp.text().await.unwrap_or_default();
265 Err(crate::types::error::Error::Server {
266 body: text.to_string(),
267 status,
268 })
269 }
270 }
271 .map_ok(|result: crate::types::ListTracksResponse| {
272 Some((
273 futures::stream::iter(result.items().into_iter().map(Ok)),
274 (new_result.next_page_token(), result),
275 ))
276 })
277 .await
278 } else {
279 Ok(None)
280 }
281 },
282 )
283 .try_flatten();
284 items.chain(next_pages)
285 })
286 .try_flatten_stream()
287 .boxed()
288 }
289
290 #[doc = "Retrieve a specific track\n\nRetrieve a specific track\n\n**Parameters:**\n\n- `id: &'astr`: ID of the resource to return (required)\n\n```rust,no_run\nasync fn example_tracks_and_levels_get_tracks() -> anyhow::Result<()> {\n let client = rippling_api::Client::new_from_env();\n let result: rippling_api::types::GetTracksResponse = client\n .tracks_and_levels()\n .get_tracks(\"d9797f8d-9ad6-4e08-90d7-2ec17e13471c\")\n .await?;\n println!(\"{:?}\", result);\n Ok(())\n}\n```"]
291 #[tracing::instrument]
292 pub async fn get_tracks<'a>(
293 &'a self,
294 id: &'a str,
295 ) -> Result<crate::types::GetTracksResponse, crate::types::error::Error> {
296 let mut req = self.client.client.request(
297 http::Method::GET,
298 format!(
299 "{}/{}",
300 self.client.base_url,
301 "tracks/{id}".replace("{id}", id)
302 ),
303 );
304 req = req.bearer_auth(&self.client.token);
305 let resp = req.send().await?;
306 let status = resp.status();
307 if status.is_success() {
308 let text = resp.text().await.unwrap_or_default();
309 serde_json::from_str(&text).map_err(|err| {
310 crate::types::error::Error::from_serde_error(
311 format_serde_error::SerdeError::new(text.to_string(), err),
312 status,
313 )
314 })
315 } else {
316 let text = resp.text().await.unwrap_or_default();
317 Err(crate::types::error::Error::Server {
318 body: text.to_string(),
319 status,
320 })
321 }
322 }
323}