thunkmetrc_wrapper/services/
processing_job_service.rs

1use thunkmetrc_client::MetrcClient;
2use serde_json::Value;
3use std::error::Error;
4use std::sync::Arc;
5#[allow(unused_imports)]
6use futures::Stream;
7use crate::ratelimiter::MetrcRateLimiter;
8#[allow(unused_imports)]
9use crate::utils::iterate_pages;
10#[allow(unused_imports)]
11use crate::models::*;
12
13pub struct ProcessingJobService {
14    client: MetrcClient,
15    rate_limiter: Arc<MetrcRateLimiter>,
16}
17
18impl ProcessingJobService {
19    pub fn new(client: MetrcClient, rate_limiter: Arc<MetrcRateLimiter>) -> Self {
20        Self {
21            client,
22            rate_limiter,
23        }
24    }
25
26    /// POST CreateAdjustProcessingJob
27    /// Adjusts the details of existing processing jobs at a Facility, including units of measure and associated packages.
28    /// Permissions Required:
29    /// - Manage Processing Job
30    /// Parameters:
31    /// - body (Option<&Value>): Request body
32    /// - license_number (Option<String>): Filter by licenseNumber
33    pub async fn create_adjust_processing_job(&self, license_number: Option<String>, body: Option<Vec<CreateAdjustProcessingJobRequestItem>>) -> std::result::Result<Option<WriteResponse>, Box<dyn Error + Send + Sync>> {
34        let body_val = if let Some(b) = body { Some(serde_json::to_value(b)?) } else { None };
35        let client = self.client.clone();
36        
37        let body_val = body_val.clone();
38
39        let resp_val = self.rate_limiter.execute(None,false,
40            move || {
41                let client = client.clone();
42                let license_number = license_number.clone();
43                let body_val = body_val.clone();
44
45                async move {
46                    client.processing_job().create_adjust_processing_job(license_number, body_val.as_ref()
47                    ).await.map_err(|e| e as Box<dyn Error + Send + Sync>)
48                }
49            }
50        ).await?;
51
52        if let Some(v) = resp_val {
53            let typed: WriteResponse = serde_json::from_value(v)?;
54            Ok(Some(typed))
55        } else {
56            Ok(None)
57        }
58    }
59
60    /// POST CreateJobTypes
61    /// Creates new processing job types for a Facility, including name, category, description, steps, and attributes.
62    /// Permissions Required:
63    /// - Manage Processing Job
64    /// Parameters:
65    /// - body (Option<&Value>): Request body
66    /// - license_number (Option<String>): Filter by licenseNumber
67    pub async fn create_processing_job_job_types(&self, license_number: Option<String>, body: Option<Vec<CreateJobTypesRequestItem>>) -> std::result::Result<Option<WriteResponse>, Box<dyn Error + Send + Sync>> {
68        let body_val = if let Some(b) = body { Some(serde_json::to_value(b)?) } else { None };
69        let client = self.client.clone();
70        
71        let body_val = body_val.clone();
72
73        let resp_val = self.rate_limiter.execute(None,false,
74            move || {
75                let client = client.clone();
76                let license_number = license_number.clone();
77                let body_val = body_val.clone();
78
79                async move {
80                    client.processing_job().create_processing_job_job_types(license_number, body_val.as_ref()
81                    ).await.map_err(|e| e as Box<dyn Error + Send + Sync>)
82                }
83            }
84        ).await?;
85
86        if let Some(v) = resp_val {
87            let typed: WriteResponse = serde_json::from_value(v)?;
88            Ok(Some(typed))
89        } else {
90            Ok(None)
91        }
92    }
93
94    /// POST CreateProcessingJobPackages
95    /// Creates packages from processing jobs at a Facility, including optional location and note assignments.
96    /// Permissions Required:
97    /// - Manage Processing Job
98    /// Parameters:
99    /// - body (Option<&Value>): Request body
100    /// - license_number (Option<String>): Filter by licenseNumber
101    pub async fn create_processing_job_packages(&self, license_number: Option<String>, body: Option<Vec<CreateProcessingJobPackagesRequestItem>>) -> std::result::Result<Option<WriteResponse>, Box<dyn Error + Send + Sync>> {
102        let body_val = if let Some(b) = body { Some(serde_json::to_value(b)?) } else { None };
103        let client = self.client.clone();
104        
105        let body_val = body_val.clone();
106
107        let resp_val = self.rate_limiter.execute(None,false,
108            move || {
109                let client = client.clone();
110                let license_number = license_number.clone();
111                let body_val = body_val.clone();
112
113                async move {
114                    client.processing_job().create_processing_job_packages(license_number, body_val.as_ref()
115                    ).await.map_err(|e| e as Box<dyn Error + Send + Sync>)
116                }
117            }
118        ).await?;
119
120        if let Some(v) = resp_val {
121            let typed: WriteResponse = serde_json::from_value(v)?;
122            Ok(Some(typed))
123        } else {
124            Ok(None)
125        }
126    }
127
128    /// DELETE DeleteJobTypeById
129    /// Archives a Processing Job Type at a Facility, making it inactive for future use.
130    /// Permissions Required:
131    /// - Manage Processing Job
132    /// Parameters:
133    /// - id (str): Path parameter id
134    /// - license_number (Option<String>): Filter by licenseNumber
135    pub async fn delete_processing_job_job_type_by_id(&self, id: &str, license_number: Option<String>, body: Option<&Value>) -> std::result::Result<Option<serde_json::Value>, Box<dyn Error + Send + Sync>> {
136        let body_val = if let Some(b) = body { Some(serde_json::to_value(b)?) } else { None };
137        let id = id.to_string();
138        let client = self.client.clone();
139        
140        let body_val = body_val.clone();
141
142        let resp_val = self.rate_limiter.execute(None,false,
143            move || {
144                let client = client.clone();
145                let id = id.clone();
146                let license_number = license_number.clone();
147                let body_val = body_val.clone();
148
149                async move {
150                    client.processing_job().delete_processing_job_job_type_by_id(&id, license_number, body_val.as_ref()
151                    ).await.map_err(|e| e as Box<dyn Error + Send + Sync>)
152                }
153            }
154        ).await?;
155
156        if let Some(v) = resp_val {
157            let typed: serde_json::Value = serde_json::from_value(v)?;
158            Ok(Some(typed))
159        } else {
160            Ok(None)
161        }
162    }
163
164    /// DELETE DeleteProcessingJobById
165    /// Archives a Processing Job at a Facility by marking it as inactive and removing it from active use.
166    /// Permissions Required:
167    /// - Manage Processing Job
168    /// Parameters:
169    /// - id (str): Path parameter id
170    /// - license_number (Option<String>): Filter by licenseNumber
171    pub async fn delete_processing_job_by_id(&self, id: &str, license_number: Option<String>, body: Option<&Value>) -> std::result::Result<Option<serde_json::Value>, Box<dyn Error + Send + Sync>> {
172        let body_val = if let Some(b) = body { Some(serde_json::to_value(b)?) } else { None };
173        let id = id.to_string();
174        let client = self.client.clone();
175        
176        let body_val = body_val.clone();
177
178        let resp_val = self.rate_limiter.execute(None,false,
179            move || {
180                let client = client.clone();
181                let id = id.clone();
182                let license_number = license_number.clone();
183                let body_val = body_val.clone();
184
185                async move {
186                    client.processing_job().delete_processing_job_by_id(&id, license_number, body_val.as_ref()
187                    ).await.map_err(|e| e as Box<dyn Error + Send + Sync>)
188                }
189            }
190        ).await?;
191
192        if let Some(v) = resp_val {
193            let typed: serde_json::Value = serde_json::from_value(v)?;
194            Ok(Some(typed))
195        } else {
196            Ok(None)
197        }
198    }
199
200    /// PUT FinishProcessingJob
201    /// Completes processing jobs at a Facility by recording final notes and waste measurements.
202    /// Permissions Required:
203    /// - Manage Processing Job
204    /// Parameters:
205    /// - body (Option<&Value>): Request body
206    /// - license_number (Option<String>): Filter by licenseNumber
207    pub async fn finish_processing_job_processing_job(&self, license_number: Option<String>, body: Option<Vec<FinishProcessingJobRequestItem>>) -> std::result::Result<Option<serde_json::Value>, Box<dyn Error + Send + Sync>> {
208        let body_val = if let Some(b) = body { Some(serde_json::to_value(b)?) } else { None };
209        let client = self.client.clone();
210        
211        let body_val = body_val.clone();
212
213        let resp_val = self.rate_limiter.execute(None,false,
214            move || {
215                let client = client.clone();
216                let license_number = license_number.clone();
217                let body_val = body_val.clone();
218
219                async move {
220                    client.processing_job().finish_processing_job_processing_job(license_number, body_val.as_ref()
221                    ).await.map_err(|e| e as Box<dyn Error + Send + Sync>)
222                }
223            }
224        ).await?;
225
226        if let Some(v) = resp_val {
227            let typed: serde_json::Value = serde_json::from_value(v)?;
228            Ok(Some(typed))
229        } else {
230            Ok(None)
231        }
232    }
233
234    /// GET GetActiveJobTypes
235    /// Retrieves a list of all active processing job types defined within a Facility.
236    /// Permissions Required:
237    /// - Manage Processing Job
238    /// Parameters:
239    /// - last_modified_end (Option<String>): Filter by lastModifiedEnd
240    /// - last_modified_start (Option<String>): Filter by lastModifiedStart
241    /// - license_number (Option<String>): Filter by licenseNumber
242    /// - page_number (Option<String>): Filter by pageNumber
243    /// - page_size (Option<String>): Filter by pageSize
244    pub async fn get_processing_job_active_job_types(&self, last_modified_end: Option<String>, last_modified_start: Option<String>, license_number: Option<String>, page_number: Option<String>, page_size: Option<String>, body: Option<&Value>) -> std::result::Result<Option<PaginatedResponse<ActiveJobType>>, Box<dyn Error + Send + Sync>> {
245        let body_val = if let Some(b) = body { Some(serde_json::to_value(b)?) } else { None };
246        let client = self.client.clone();
247        
248        let body_val = body_val.clone();
249
250        let resp_val = self.rate_limiter.execute(None,true,
251            move || {
252                let client = client.clone();
253                let last_modified_end = last_modified_end.clone();
254                let last_modified_start = last_modified_start.clone();
255                let license_number = license_number.clone();
256                let page_number = page_number.clone();
257                let page_size = page_size.clone();
258                let body_val = body_val.clone();
259
260                async move {
261                    client.processing_job().get_processing_job_active_job_types(last_modified_end, last_modified_start, license_number, page_number, page_size, body_val.as_ref()
262                    ).await.map_err(|e| e as Box<dyn Error + Send + Sync>)
263                }
264            }
265        ).await?;
266
267        if let Some(v) = resp_val {
268            let typed: PaginatedResponse<ActiveJobType> = serde_json::from_value(v)?;
269            Ok(Some(typed))
270        } else {
271            Ok(None)
272        }
273    }
274
275    /// GET GetActiveProcessingJob
276    /// Retrieves active processing jobs at a specified Facility.
277    /// Permissions Required:
278    /// - Manage Processing Job
279    /// Parameters:
280    /// - last_modified_end (Option<String>): Filter by lastModifiedEnd
281    /// - last_modified_start (Option<String>): Filter by lastModifiedStart
282    /// - license_number (Option<String>): Filter by licenseNumber
283    /// - page_number (Option<String>): Filter by pageNumber
284    /// - page_size (Option<String>): Filter by pageSize
285    pub async fn get_active_processing_job(&self, last_modified_end: Option<String>, last_modified_start: Option<String>, license_number: Option<String>, page_number: Option<String>, page_size: Option<String>, body: Option<&Value>) -> std::result::Result<Option<PaginatedResponse<ProcessingJob>>, Box<dyn Error + Send + Sync>> {
286        let body_val = if let Some(b) = body { Some(serde_json::to_value(b)?) } else { None };
287        let client = self.client.clone();
288        
289        let body_val = body_val.clone();
290
291        let resp_val = self.rate_limiter.execute(None,true,
292            move || {
293                let client = client.clone();
294                let last_modified_end = last_modified_end.clone();
295                let last_modified_start = last_modified_start.clone();
296                let license_number = license_number.clone();
297                let page_number = page_number.clone();
298                let page_size = page_size.clone();
299                let body_val = body_val.clone();
300
301                async move {
302                    client.processing_job().get_active_processing_job(last_modified_end, last_modified_start, license_number, page_number, page_size, body_val.as_ref()
303                    ).await.map_err(|e| e as Box<dyn Error + Send + Sync>)
304                }
305            }
306        ).await?;
307
308        if let Some(v) = resp_val {
309            let typed: PaginatedResponse<ProcessingJob> = serde_json::from_value(v)?;
310            Ok(Some(typed))
311        } else {
312            Ok(None)
313        }
314    }
315
316    /// GET GetInactiveJobTypes
317    /// Retrieves a list of all inactive processing job types defined within a Facility.
318    /// Permissions Required:
319    /// - Manage Processing Job
320    /// Parameters:
321    /// - last_modified_end (Option<String>): Filter by lastModifiedEnd
322    /// - last_modified_start (Option<String>): Filter by lastModifiedStart
323    /// - license_number (Option<String>): Filter by licenseNumber
324    /// - page_number (Option<String>): Filter by pageNumber
325    /// - page_size (Option<String>): Filter by pageSize
326    pub async fn get_processing_job_inactive_job_types(&self, last_modified_end: Option<String>, last_modified_start: Option<String>, license_number: Option<String>, page_number: Option<String>, page_size: Option<String>, body: Option<&Value>) -> std::result::Result<Option<PaginatedResponse<InactiveJobType>>, Box<dyn Error + Send + Sync>> {
327        let body_val = if let Some(b) = body { Some(serde_json::to_value(b)?) } else { None };
328        let client = self.client.clone();
329        
330        let body_val = body_val.clone();
331
332        let resp_val = self.rate_limiter.execute(None,true,
333            move || {
334                let client = client.clone();
335                let last_modified_end = last_modified_end.clone();
336                let last_modified_start = last_modified_start.clone();
337                let license_number = license_number.clone();
338                let page_number = page_number.clone();
339                let page_size = page_size.clone();
340                let body_val = body_val.clone();
341
342                async move {
343                    client.processing_job().get_processing_job_inactive_job_types(last_modified_end, last_modified_start, license_number, page_number, page_size, body_val.as_ref()
344                    ).await.map_err(|e| e as Box<dyn Error + Send + Sync>)
345                }
346            }
347        ).await?;
348
349        if let Some(v) = resp_val {
350            let typed: PaginatedResponse<InactiveJobType> = serde_json::from_value(v)?;
351            Ok(Some(typed))
352        } else {
353            Ok(None)
354        }
355    }
356
357    /// GET GetInactiveProcessingJob
358    /// Retrieves inactive processing jobs at a specified Facility.
359    /// Permissions Required:
360    /// - Manage Processing Job
361    /// Parameters:
362    /// - last_modified_end (Option<String>): Filter by lastModifiedEnd
363    /// - last_modified_start (Option<String>): Filter by lastModifiedStart
364    /// - license_number (Option<String>): Filter by licenseNumber
365    /// - page_number (Option<String>): Filter by pageNumber
366    /// - page_size (Option<String>): Filter by pageSize
367    pub async fn get_inactive_processing_job(&self, last_modified_end: Option<String>, last_modified_start: Option<String>, license_number: Option<String>, page_number: Option<String>, page_size: Option<String>, body: Option<&Value>) -> std::result::Result<Option<PaginatedResponse<ProcessingJob>>, Box<dyn Error + Send + Sync>> {
368        let body_val = if let Some(b) = body { Some(serde_json::to_value(b)?) } else { None };
369        let client = self.client.clone();
370        
371        let body_val = body_val.clone();
372
373        let resp_val = self.rate_limiter.execute(None,true,
374            move || {
375                let client = client.clone();
376                let last_modified_end = last_modified_end.clone();
377                let last_modified_start = last_modified_start.clone();
378                let license_number = license_number.clone();
379                let page_number = page_number.clone();
380                let page_size = page_size.clone();
381                let body_val = body_val.clone();
382
383                async move {
384                    client.processing_job().get_inactive_processing_job(last_modified_end, last_modified_start, license_number, page_number, page_size, body_val.as_ref()
385                    ).await.map_err(|e| e as Box<dyn Error + Send + Sync>)
386                }
387            }
388        ).await?;
389
390        if let Some(v) = resp_val {
391            let typed: PaginatedResponse<ProcessingJob> = serde_json::from_value(v)?;
392            Ok(Some(typed))
393        } else {
394            Ok(None)
395        }
396    }
397
398    /// GET GetJobTypesAttributes
399    /// Retrieves all processing job attributes available for a Facility.
400    /// Permissions Required:
401    /// - Manage Processing Job
402    /// Parameters:
403    /// - license_number (Option<String>): Filter by licenseNumber
404    pub async fn get_processing_job_job_types_attributes(&self, license_number: Option<String>, body: Option<&Value>) -> std::result::Result<Option<PaginatedResponse<JobTypesAttribute>>, Box<dyn Error + Send + Sync>> {
405        let body_val = if let Some(b) = body { Some(serde_json::to_value(b)?) } else { None };
406        let client = self.client.clone();
407        
408        let body_val = body_val.clone();
409
410        let resp_val = self.rate_limiter.execute(None,true,
411            move || {
412                let client = client.clone();
413                let license_number = license_number.clone();
414                let body_val = body_val.clone();
415
416                async move {
417                    client.processing_job().get_processing_job_job_types_attributes(license_number, body_val.as_ref()
418                    ).await.map_err(|e| e as Box<dyn Error + Send + Sync>)
419                }
420            }
421        ).await?;
422
423        if let Some(v) = resp_val {
424            let typed: PaginatedResponse<JobTypesAttribute> = serde_json::from_value(v)?;
425            Ok(Some(typed))
426        } else {
427            Ok(None)
428        }
429    }
430
431    /// GET GetJobTypesCategories
432    /// Retrieves all processing job categories available for a specified Facility.
433    /// Permissions Required:
434    /// - Manage Processing Job
435    /// Parameters:
436    /// - license_number (Option<String>): Filter by licenseNumber
437    pub async fn get_processing_job_job_types_categories(&self, license_number: Option<String>, body: Option<&Value>) -> std::result::Result<Option<PaginatedResponse<JobTypesCategory>>, Box<dyn Error + Send + Sync>> {
438        let body_val = if let Some(b) = body { Some(serde_json::to_value(b)?) } else { None };
439        let client = self.client.clone();
440        
441        let body_val = body_val.clone();
442
443        let resp_val = self.rate_limiter.execute(None,true,
444            move || {
445                let client = client.clone();
446                let license_number = license_number.clone();
447                let body_val = body_val.clone();
448
449                async move {
450                    client.processing_job().get_processing_job_job_types_categories(license_number, body_val.as_ref()
451                    ).await.map_err(|e| e as Box<dyn Error + Send + Sync>)
452                }
453            }
454        ).await?;
455
456        if let Some(v) = resp_val {
457            let typed: PaginatedResponse<JobTypesCategory> = serde_json::from_value(v)?;
458            Ok(Some(typed))
459        } else {
460            Ok(None)
461        }
462    }
463
464    /// GET GetProcessingJobById
465    /// Retrieves a ProcessingJob by Id.
466    /// Permissions Required:
467    /// - Manage Processing Job
468    /// Parameters:
469    /// - id (str): Path parameter id
470    /// - license_number (Option<String>): Filter by licenseNumber
471    pub async fn get_processing_job_by_id(&self, id: &str, license_number: Option<String>, body: Option<&Value>) -> std::result::Result<Option<ProcessingJob>, Box<dyn Error + Send + Sync>> {
472        let body_val = if let Some(b) = body { Some(serde_json::to_value(b)?) } else { None };
473        let id = id.to_string();
474        let client = self.client.clone();
475        
476        let body_val = body_val.clone();
477
478        let resp_val = self.rate_limiter.execute(None,true,
479            move || {
480                let client = client.clone();
481                let id = id.clone();
482                let license_number = license_number.clone();
483                let body_val = body_val.clone();
484
485                async move {
486                    client.processing_job().get_processing_job_by_id(&id, license_number, body_val.as_ref()
487                    ).await.map_err(|e| e as Box<dyn Error + Send + Sync>)
488                }
489            }
490        ).await?;
491
492        if let Some(v) = resp_val {
493            let typed: ProcessingJob = serde_json::from_value(v)?;
494            Ok(Some(typed))
495        } else {
496            Ok(None)
497        }
498    }
499
500    /// POST StartProcessingJob
501    /// Initiates new processing jobs at a Facility, including job details and associated packages.
502    /// Permissions Required:
503    /// - Manage Processing Job
504    /// Parameters:
505    /// - body (Option<&Value>): Request body
506    /// - license_number (Option<String>): Filter by licenseNumber
507    pub async fn start_processing_job_processing_job(&self, license_number: Option<String>, body: Option<Vec<StartProcessingJobRequestItem>>) -> std::result::Result<Option<WriteResponse>, Box<dyn Error + Send + Sync>> {
508        let body_val = if let Some(b) = body { Some(serde_json::to_value(b)?) } else { None };
509        let client = self.client.clone();
510        
511        let body_val = body_val.clone();
512
513        let resp_val = self.rate_limiter.execute(None,false,
514            move || {
515                let client = client.clone();
516                let license_number = license_number.clone();
517                let body_val = body_val.clone();
518
519                async move {
520                    client.processing_job().start_processing_job_processing_job(license_number, body_val.as_ref()
521                    ).await.map_err(|e| e as Box<dyn Error + Send + Sync>)
522                }
523            }
524        ).await?;
525
526        if let Some(v) = resp_val {
527            let typed: WriteResponse = serde_json::from_value(v)?;
528            Ok(Some(typed))
529        } else {
530            Ok(None)
531        }
532    }
533
534    /// PUT UnfinishProcessingJob
535    /// Reopens previously completed processing jobs at a Facility to allow further updates or corrections.
536    /// Permissions Required:
537    /// - Manage Processing Job
538    /// Parameters:
539    /// - body (Option<&Value>): Request body
540    /// - license_number (Option<String>): Filter by licenseNumber
541    pub async fn unfinish_processing_job_processing_job(&self, license_number: Option<String>, body: Option<Vec<UnfinishProcessingJobRequestItem>>) -> std::result::Result<Option<serde_json::Value>, Box<dyn Error + Send + Sync>> {
542        let body_val = if let Some(b) = body { Some(serde_json::to_value(b)?) } else { None };
543        let client = self.client.clone();
544        
545        let body_val = body_val.clone();
546
547        let resp_val = self.rate_limiter.execute(None,false,
548            move || {
549                let client = client.clone();
550                let license_number = license_number.clone();
551                let body_val = body_val.clone();
552
553                async move {
554                    client.processing_job().unfinish_processing_job_processing_job(license_number, body_val.as_ref()
555                    ).await.map_err(|e| e as Box<dyn Error + Send + Sync>)
556                }
557            }
558        ).await?;
559
560        if let Some(v) = resp_val {
561            let typed: serde_json::Value = serde_json::from_value(v)?;
562            Ok(Some(typed))
563        } else {
564            Ok(None)
565        }
566    }
567
568    /// PUT UpdateJobTypes
569    /// Updates existing processing job types at a Facility, including their name, category, description, steps, and attributes.
570    /// Permissions Required:
571    /// - Manage Processing Job
572    /// Parameters:
573    /// - body (Option<&Value>): Request body
574    /// - license_number (Option<String>): Filter by licenseNumber
575    pub async fn update_processing_job_job_types(&self, license_number: Option<String>, body: Option<Vec<UpdateJobTypesRequestItem>>) -> std::result::Result<Option<WriteResponse>, Box<dyn Error + Send + Sync>> {
576        let body_val = if let Some(b) = body { Some(serde_json::to_value(b)?) } else { None };
577        let client = self.client.clone();
578        
579        let body_val = body_val.clone();
580
581        let resp_val = self.rate_limiter.execute(None,false,
582            move || {
583                let client = client.clone();
584                let license_number = license_number.clone();
585                let body_val = body_val.clone();
586
587                async move {
588                    client.processing_job().update_processing_job_job_types(license_number, body_val.as_ref()
589                    ).await.map_err(|e| e as Box<dyn Error + Send + Sync>)
590                }
591            }
592        ).await?;
593
594        if let Some(v) = resp_val {
595            let typed: WriteResponse = serde_json::from_value(v)?;
596            Ok(Some(typed))
597        } else {
598            Ok(None)
599        }
600    }
601}
602
thunkmetrc_wrapper/services/processing_job_service.rs

thunkmetrc_wrapper/services/
processing_job_service.rs
