1use anyhow::Result;
2
3use crate::Client;
4#[derive(Clone, Debug)]
5pub struct Job {
6 pub client: Client,
7}
8
9impl Job {
10 #[doc(hidden)]
11 pub fn new(client: Client) -> Self {
12 Self { client }
13 }
14
15 #[doc = "List job codes\n\nA List of job codes\n- Requires: `API Tier 2`\n- Filterable fields: `job_dimension_id`, `group_id`\n- Expandable fields: `job_dimension`\n- Sortable fields: `id`, `created_at`, `updated_at`\n\n**Parameters:**\n\n- `cursor: Option<String>`\n- `expand: Option<String>`\n- `filter: Option<String>`\n- `order_by: Option<String>`\n\n```rust,no_run\nuse futures_util::TryStreamExt;\nasync fn example_job_list_codes_stream() -> anyhow::Result<()> {\n let client = rippling_api::Client::new_from_env();\n let mut job = client.job();\n let mut stream = job.list_codes_stream(\n Some(\"some-string\".to_string()),\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_codes<'a>(
18 &'a self,
19 cursor: Option<String>,
20 expand: Option<String>,
21 filter: Option<String>,
22 order_by: Option<String>,
23 ) -> Result<crate::types::ListJobCodesResponse, crate::types::error::Error> {
24 let mut req = self.client.client.request(
25 http::Method::GET,
26 format!("{}/{}", self.client.base_url, "job-codes"),
27 );
28 req = req.bearer_auth(&self.client.token);
29 let mut query_params = vec![];
30 if let Some(p) = cursor {
31 query_params.push(("cursor", p));
32 }
33
34 if let Some(p) = expand {
35 query_params.push(("expand", p));
36 }
37
38 if let Some(p) = filter {
39 query_params.push(("filter", p));
40 }
41
42 if let Some(p) = order_by {
43 query_params.push(("order_by", p));
44 }
45
46 req = req.query(&query_params);
47 let resp = req.send().await?;
48 let status = resp.status();
49 if status.is_success() {
50 let text = resp.text().await.unwrap_or_default();
51 serde_json::from_str(&text).map_err(|err| {
52 crate::types::error::Error::from_serde_error(
53 format_serde_error::SerdeError::new(text.to_string(), err),
54 status,
55 )
56 })
57 } else {
58 let text = resp.text().await.unwrap_or_default();
59 Err(crate::types::error::Error::Server {
60 body: text.to_string(),
61 status,
62 })
63 }
64 }
65
66 #[doc = "List job codes\n\nA List of job codes\n- Requires: `API Tier 2`\n- Filterable fields: `job_dimension_id`, `group_id`\n- Expandable fields: `job_dimension`\n- Sortable fields: `id`, `created_at`, `updated_at`\n\n**Parameters:**\n\n- `cursor: Option<String>`\n- `expand: Option<String>`\n- `filter: Option<String>`\n- `order_by: Option<String>`\n\n```rust,no_run\nuse futures_util::TryStreamExt;\nasync fn example_job_list_codes_stream() -> anyhow::Result<()> {\n let client = rippling_api::Client::new_from_env();\n let mut job = client.job();\n let mut stream = job.list_codes_stream(\n Some(\"some-string\".to_string()),\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```"]
67 #[tracing::instrument]
68 #[cfg(not(feature = "js"))]
69 pub fn list_codes_stream<'a>(
70 &'a self,
71 expand: Option<String>,
72 filter: Option<String>,
73 order_by: Option<String>,
74 ) -> impl futures::Stream<Item = Result<crate::types::JobCode, crate::types::error::Error>>
75 + Unpin
76 + '_ {
77 use futures::{StreamExt, TryFutureExt, TryStreamExt};
78
79 use crate::types::paginate::Pagination;
80 self.list_codes(None, expand, filter, order_by)
81 .map_ok(move |result| {
82 let items = futures::stream::iter(result.items().into_iter().map(Ok));
83 let next_pages = futures::stream::try_unfold(
84 (None, result),
85 move |(prev_page_token, new_result)| async move {
86 if new_result.has_more_pages()
87 && !new_result.items().is_empty()
88 && prev_page_token != new_result.next_page_token()
89 {
90 async {
91 let mut req = self.client.client.request(
92 http::Method::GET,
93 format!("{}/{}", self.client.base_url, "job-codes"),
94 );
95 req = req.bearer_auth(&self.client.token);
96 let mut request = req.build()?;
97 request = new_result.next_page(request)?;
98 let resp = self.client.client.execute(request).await?;
99 let status = resp.status();
100 if status.is_success() {
101 let text = resp.text().await.unwrap_or_default();
102 serde_json::from_str(&text).map_err(|err| {
103 crate::types::error::Error::from_serde_error(
104 format_serde_error::SerdeError::new(
105 text.to_string(),
106 err,
107 ),
108 status,
109 )
110 })
111 } else {
112 let text = resp.text().await.unwrap_or_default();
113 Err(crate::types::error::Error::Server {
114 body: text.to_string(),
115 status,
116 })
117 }
118 }
119 .map_ok(|result: crate::types::ListJobCodesResponse| {
120 Some((
121 futures::stream::iter(result.items().into_iter().map(Ok)),
122 (new_result.next_page_token(), result),
123 ))
124 })
125 .await
126 } else {
127 Ok(None)
128 }
129 },
130 )
131 .try_flatten();
132 items.chain(next_pages)
133 })
134 .try_flatten_stream()
135 .boxed()
136 }
137
138 #[doc = "Create a new job code\n\nCreate a new job code\n\n```rust,no_run\nasync fn \
139 example_job_create_codes() -> anyhow::Result<()> {\n let client = \
140 rippling_api::Client::new_from_env();\n let result: rippling_api::types::JobCode = \
141 client\n .job()\n .create_codes(&rippling_api::types::JobCodeRequest \
142 {\n name: \"some-string\".to_string(),\n job_dimension_id: \
143 \"some-string\".to_string(),\n external_id: \
144 Some(\"some-string\".to_string()),\n })\n .await?;\n \
145 println!(\"{:?}\", result);\n Ok(())\n}\n```"]
146 #[tracing::instrument]
147 pub async fn create_codes<'a>(
148 &'a self,
149 body: &crate::types::JobCodeRequest,
150 ) -> Result<crate::types::JobCode, crate::types::error::Error> {
151 let mut req = self.client.client.request(
152 http::Method::POST,
153 format!("{}/{}", self.client.base_url, "job-codes"),
154 );
155 req = req.bearer_auth(&self.client.token);
156 req = req.json(body);
157 let resp = req.send().await?;
158 let status = resp.status();
159 if status.is_success() {
160 let text = resp.text().await.unwrap_or_default();
161 serde_json::from_str(&text).map_err(|err| {
162 crate::types::error::Error::from_serde_error(
163 format_serde_error::SerdeError::new(text.to_string(), err),
164 status,
165 )
166 })
167 } else {
168 let text = resp.text().await.unwrap_or_default();
169 Err(crate::types::error::Error::Server {
170 body: text.to_string(),
171 status,
172 })
173 }
174 }
175
176 #[doc = "Retrieve a specific job code\n\nRetrieve a specific job code\n\n**Parameters:**\n\n- \
177 `expand: Option<String>`\n- `id: &'astr`: ID of the resource to return \
178 (required)\n\n```rust,no_run\nasync fn example_job_get_codes() -> anyhow::Result<()> \
179 {\n let client = rippling_api::Client::new_from_env();\n let result: \
180 rippling_api::types::GetJobCodesResponse = client\n .job()\n \
181 .get_codes(\n Some(\"some-string\".to_string()),\n \
182 \"d9797f8d-9ad6-4e08-90d7-2ec17e13471c\",\n )\n .await?;\n \
183 println!(\"{:?}\", result);\n Ok(())\n}\n```"]
184 #[tracing::instrument]
185 pub async fn get_codes<'a>(
186 &'a self,
187 expand: Option<String>,
188 id: &'a str,
189 ) -> Result<crate::types::GetJobCodesResponse, crate::types::error::Error> {
190 let mut req = self.client.client.request(
191 http::Method::GET,
192 format!(
193 "{}/{}",
194 self.client.base_url,
195 "job-codes/{id}".replace("{id}", id)
196 ),
197 );
198 req = req.bearer_auth(&self.client.token);
199 let mut query_params = vec![];
200 if let Some(p) = expand {
201 query_params.push(("expand", p));
202 }
203
204 req = req.query(&query_params);
205 let resp = req.send().await?;
206 let status = resp.status();
207 if status.is_success() {
208 let text = resp.text().await.unwrap_or_default();
209 serde_json::from_str(&text).map_err(|err| {
210 crate::types::error::Error::from_serde_error(
211 format_serde_error::SerdeError::new(text.to_string(), err),
212 status,
213 )
214 })
215 } else {
216 let text = resp.text().await.unwrap_or_default();
217 Err(crate::types::error::Error::Server {
218 body: text.to_string(),
219 status,
220 })
221 }
222 }
223
224 #[doc = "Delete a job code\n\n**Parameters:**\n\n- `id: &'astr`: ID of the resource to delete \
225 (required)\n\n```rust,no_run\nasync fn example_job_delete_codes() -> \
226 anyhow::Result<()> {\n let client = rippling_api::Client::new_from_env();\n \
227 client\n .job()\n \
228 .delete_codes(\"d9797f8d-9ad6-4e08-90d7-2ec17e13471c\")\n .await?;\n \
229 Ok(())\n}\n```"]
230 #[tracing::instrument]
231 pub async fn delete_codes<'a>(&'a self, id: &'a str) -> Result<(), crate::types::error::Error> {
232 let mut req = self.client.client.request(
233 http::Method::DELETE,
234 format!(
235 "{}/{}",
236 self.client.base_url,
237 "job-codes/{id}".replace("{id}", id)
238 ),
239 );
240 req = req.bearer_auth(&self.client.token);
241 let resp = req.send().await?;
242 let status = resp.status();
243 if status.is_success() {
244 Ok(())
245 } else {
246 let text = resp.text().await.unwrap_or_default();
247 Err(crate::types::error::Error::Server {
248 body: text.to_string(),
249 status,
250 })
251 }
252 }
253
254 #[doc = "Update a job code\n\nUpdated a specific job code\n\n**Parameters:**\n\n- `id: \
255 &'astr`: ID of the resource to patch (required)\n\n```rust,no_run\nasync fn \
256 example_job_update_codes() -> anyhow::Result<()> {\n let client = \
257 rippling_api::Client::new_from_env();\n let result: rippling_api::types::JobCode = \
258 client\n .job()\n .update_codes(\n \
259 \"d9797f8d-9ad6-4e08-90d7-2ec17e13471c\",\n \
260 &rippling_api::types::JobCodeRequest {\n name: \
261 \"some-string\".to_string(),\n job_dimension_id: \
262 \"some-string\".to_string(),\n external_id: \
263 Some(\"some-string\".to_string()),\n },\n )\n .await?;\n \
264 println!(\"{:?}\", result);\n Ok(())\n}\n```"]
265 #[tracing::instrument]
266 pub async fn update_codes<'a>(
267 &'a self,
268 id: &'a str,
269 body: &crate::types::JobCodeRequest,
270 ) -> Result<crate::types::JobCode, crate::types::error::Error> {
271 let mut req = self.client.client.request(
272 http::Method::PATCH,
273 format!(
274 "{}/{}",
275 self.client.base_url,
276 "job-codes/{id}".replace("{id}", id)
277 ),
278 );
279 req = req.bearer_auth(&self.client.token);
280 req = req.json(body);
281 let resp = req.send().await?;
282 let status = resp.status();
283 if status.is_success() {
284 let text = resp.text().await.unwrap_or_default();
285 serde_json::from_str(&text).map_err(|err| {
286 crate::types::error::Error::from_serde_error(
287 format_serde_error::SerdeError::new(text.to_string(), err),
288 status,
289 )
290 })
291 } else {
292 let text = resp.text().await.unwrap_or_default();
293 Err(crate::types::error::Error::Server {
294 body: text.to_string(),
295 status,
296 })
297 }
298 }
299
300 #[doc = "List job dimensions\n\nA List of job dimensions\n- Requires: `API Tier 2`\n- Filterable fields: `name`\n- Sortable fields: `id`, `created_at`, `updated_at`\n\n**Parameters:**\n\n- `cursor: Option<String>`\n- `filter: Option<String>`\n- `order_by: Option<String>`\n\n```rust,no_run\nuse futures_util::TryStreamExt;\nasync fn example_job_list_dimensions_stream() -> anyhow::Result<()> {\n let client = rippling_api::Client::new_from_env();\n let mut job = client.job();\n let mut stream = job.list_dimensions_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```"]
301 #[tracing::instrument]
302 pub async fn list_dimensions<'a>(
303 &'a self,
304 cursor: Option<String>,
305 filter: Option<String>,
306 order_by: Option<String>,
307 ) -> Result<crate::types::ListJobDimensionsResponse, crate::types::error::Error> {
308 let mut req = self.client.client.request(
309 http::Method::GET,
310 format!("{}/{}", self.client.base_url, "job-dimensions"),
311 );
312 req = req.bearer_auth(&self.client.token);
313 let mut query_params = vec![];
314 if let Some(p) = cursor {
315 query_params.push(("cursor", p));
316 }
317
318 if let Some(p) = filter {
319 query_params.push(("filter", p));
320 }
321
322 if let Some(p) = order_by {
323 query_params.push(("order_by", p));
324 }
325
326 req = req.query(&query_params);
327 let resp = req.send().await?;
328 let status = resp.status();
329 if status.is_success() {
330 let text = resp.text().await.unwrap_or_default();
331 serde_json::from_str(&text).map_err(|err| {
332 crate::types::error::Error::from_serde_error(
333 format_serde_error::SerdeError::new(text.to_string(), err),
334 status,
335 )
336 })
337 } else {
338 let text = resp.text().await.unwrap_or_default();
339 Err(crate::types::error::Error::Server {
340 body: text.to_string(),
341 status,
342 })
343 }
344 }
345
346 #[doc = "List job dimensions\n\nA List of job dimensions\n- Requires: `API Tier 2`\n- Filterable fields: `name`\n- Sortable fields: `id`, `created_at`, `updated_at`\n\n**Parameters:**\n\n- `cursor: Option<String>`\n- `filter: Option<String>`\n- `order_by: Option<String>`\n\n```rust,no_run\nuse futures_util::TryStreamExt;\nasync fn example_job_list_dimensions_stream() -> anyhow::Result<()> {\n let client = rippling_api::Client::new_from_env();\n let mut job = client.job();\n let mut stream = job.list_dimensions_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```"]
347 #[tracing::instrument]
348 #[cfg(not(feature = "js"))]
349 pub fn list_dimensions_stream<'a>(
350 &'a self,
351 filter: Option<String>,
352 order_by: Option<String>,
353 ) -> impl futures::Stream<Item = Result<crate::types::JobDimension, crate::types::error::Error>>
354 + Unpin
355 + '_ {
356 use futures::{StreamExt, TryFutureExt, TryStreamExt};
357
358 use crate::types::paginate::Pagination;
359 self.list_dimensions(None, filter, order_by)
360 .map_ok(move |result| {
361 let items = futures::stream::iter(result.items().into_iter().map(Ok));
362 let next_pages = futures::stream::try_unfold(
363 (None, result),
364 move |(prev_page_token, new_result)| async move {
365 if new_result.has_more_pages()
366 && !new_result.items().is_empty()
367 && prev_page_token != new_result.next_page_token()
368 {
369 async {
370 let mut req = self.client.client.request(
371 http::Method::GET,
372 format!("{}/{}", self.client.base_url, "job-dimensions"),
373 );
374 req = req.bearer_auth(&self.client.token);
375 let mut request = req.build()?;
376 request = new_result.next_page(request)?;
377 let resp = self.client.client.execute(request).await?;
378 let status = resp.status();
379 if status.is_success() {
380 let text = resp.text().await.unwrap_or_default();
381 serde_json::from_str(&text).map_err(|err| {
382 crate::types::error::Error::from_serde_error(
383 format_serde_error::SerdeError::new(
384 text.to_string(),
385 err,
386 ),
387 status,
388 )
389 })
390 } else {
391 let text = resp.text().await.unwrap_or_default();
392 Err(crate::types::error::Error::Server {
393 body: text.to_string(),
394 status,
395 })
396 }
397 }
398 .map_ok(|result: crate::types::ListJobDimensionsResponse| {
399 Some((
400 futures::stream::iter(result.items().into_iter().map(Ok)),
401 (new_result.next_page_token(), result),
402 ))
403 })
404 .await
405 } else {
406 Ok(None)
407 }
408 },
409 )
410 .try_flatten();
411 items.chain(next_pages)
412 })
413 .try_flatten_stream()
414 .boxed()
415 }
416
417 #[doc = "Create a new job dimension\n\nCreate a new job dimension\n\n```rust,no_run\nasync fn \
418 example_job_create_dimensions() -> anyhow::Result<()> {\n let client = \
419 rippling_api::Client::new_from_env();\n let result: \
420 rippling_api::types::JobDimension = client\n .job()\n \
421 .create_dimensions(&rippling_api::types::JobDimensionRequest {\n name: \
422 \"some-string\".to_string(),\n external_id: \
423 Some(\"some-string\".to_string()),\n })\n .await?;\n \
424 println!(\"{:?}\", result);\n Ok(())\n}\n```"]
425 #[tracing::instrument]
426 pub async fn create_dimensions<'a>(
427 &'a self,
428 body: &crate::types::JobDimensionRequest,
429 ) -> Result<crate::types::JobDimension, crate::types::error::Error> {
430 let mut req = self.client.client.request(
431 http::Method::POST,
432 format!("{}/{}", self.client.base_url, "job-dimensions"),
433 );
434 req = req.bearer_auth(&self.client.token);
435 req = req.json(body);
436 let resp = req.send().await?;
437 let status = resp.status();
438 if status.is_success() {
439 let text = resp.text().await.unwrap_or_default();
440 serde_json::from_str(&text).map_err(|err| {
441 crate::types::error::Error::from_serde_error(
442 format_serde_error::SerdeError::new(text.to_string(), err),
443 status,
444 )
445 })
446 } else {
447 let text = resp.text().await.unwrap_or_default();
448 Err(crate::types::error::Error::Server {
449 body: text.to_string(),
450 status,
451 })
452 }
453 }
454
455 #[doc = "Retrieve a specific job dimension\n\nRetrieve a specific job dimension\n\n**Parameters:**\n\n- `id: &'astr`: ID of the resource to return (required)\n\n```rust,no_run\nasync fn example_job_get_dimensions() -> anyhow::Result<()> {\n let client = rippling_api::Client::new_from_env();\n let result: rippling_api::types::GetJobDimensionsResponse = client\n .job()\n .get_dimensions(\"d9797f8d-9ad6-4e08-90d7-2ec17e13471c\")\n .await?;\n println!(\"{:?}\", result);\n Ok(())\n}\n```"]
456 #[tracing::instrument]
457 pub async fn get_dimensions<'a>(
458 &'a self,
459 id: &'a str,
460 ) -> Result<crate::types::GetJobDimensionsResponse, crate::types::error::Error> {
461 let mut req = self.client.client.request(
462 http::Method::GET,
463 format!(
464 "{}/{}",
465 self.client.base_url,
466 "job-dimensions/{id}".replace("{id}", id)
467 ),
468 );
469 req = req.bearer_auth(&self.client.token);
470 let resp = req.send().await?;
471 let status = resp.status();
472 if status.is_success() {
473 let text = resp.text().await.unwrap_or_default();
474 serde_json::from_str(&text).map_err(|err| {
475 crate::types::error::Error::from_serde_error(
476 format_serde_error::SerdeError::new(text.to_string(), err),
477 status,
478 )
479 })
480 } else {
481 let text = resp.text().await.unwrap_or_default();
482 Err(crate::types::error::Error::Server {
483 body: text.to_string(),
484 status,
485 })
486 }
487 }
488
489 #[doc = "Delete a job dimension\n\n**Parameters:**\n\n- `id: &'astr`: ID of the resource to \
490 delete (required)\n\n```rust,no_run\nasync fn example_job_delete_dimensions() -> \
491 anyhow::Result<()> {\n let client = rippling_api::Client::new_from_env();\n \
492 client\n .job()\n \
493 .delete_dimensions(\"d9797f8d-9ad6-4e08-90d7-2ec17e13471c\")\n .await?;\n \
494 Ok(())\n}\n```"]
495 #[tracing::instrument]
496 pub async fn delete_dimensions<'a>(
497 &'a self,
498 id: &'a str,
499 ) -> Result<(), crate::types::error::Error> {
500 let mut req = self.client.client.request(
501 http::Method::DELETE,
502 format!(
503 "{}/{}",
504 self.client.base_url,
505 "job-dimensions/{id}".replace("{id}", id)
506 ),
507 );
508 req = req.bearer_auth(&self.client.token);
509 let resp = req.send().await?;
510 let status = resp.status();
511 if status.is_success() {
512 Ok(())
513 } else {
514 let text = resp.text().await.unwrap_or_default();
515 Err(crate::types::error::Error::Server {
516 body: text.to_string(),
517 status,
518 })
519 }
520 }
521
522 #[doc = "Update a job dimension\n\nUpdated a specific job dimension\n\n**Parameters:**\n\n- `id: &'astr`: ID of the resource to patch (required)\n\n```rust,no_run\nasync fn example_job_update_dimensions() -> anyhow::Result<()> {\n let client = rippling_api::Client::new_from_env();\n let result: rippling_api::types::JobDimension = client\n .job()\n .update_dimensions(\n \"d9797f8d-9ad6-4e08-90d7-2ec17e13471c\",\n &rippling_api::types::JobDimensionRequest {\n name: \"some-string\".to_string(),\n external_id: Some(\"some-string\".to_string()),\n },\n )\n .await?;\n println!(\"{:?}\", result);\n Ok(())\n}\n```"]
523 #[tracing::instrument]
524 pub async fn update_dimensions<'a>(
525 &'a self,
526 id: &'a str,
527 body: &crate::types::JobDimensionRequest,
528 ) -> Result<crate::types::JobDimension, crate::types::error::Error> {
529 let mut req = self.client.client.request(
530 http::Method::PATCH,
531 format!(
532 "{}/{}",
533 self.client.base_url,
534 "job-dimensions/{id}".replace("{id}", id)
535 ),
536 );
537 req = req.bearer_auth(&self.client.token);
538 req = req.json(body);
539 let resp = req.send().await?;
540 let status = resp.status();
541 if status.is_success() {
542 let text = resp.text().await.unwrap_or_default();
543 serde_json::from_str(&text).map_err(|err| {
544 crate::types::error::Error::from_serde_error(
545 format_serde_error::SerdeError::new(text.to_string(), err),
546 status,
547 )
548 })
549 } else {
550 let text = resp.text().await.unwrap_or_default();
551 Err(crate::types::error::Error::Server {
552 body: text.to_string(),
553 status,
554 })
555 }
556 }
557}