thunkmetrc_wrapper/services/
lab_tests_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 LabTestsService {
14    client: MetrcClient,
15    rate_limiter: Arc<MetrcRateLimiter>,
16}
17
18impl LabTestsService {
19    pub fn new(client: MetrcClient, rate_limiter: Arc<MetrcRateLimiter>) -> Self {
20        Self {
21            client,
22            rate_limiter,
23        }
24    }
25
26    /// POST CreateRecord
27    /// Submits Lab Test results for one or more packages. NOTE: This endpoint allows only PDF files, and uploaded files can be no more than 5 MB in size. The Label element in the request is a Package Label.
28    /// Permissions Required:
29    /// - View Packages
30    /// - Manage Packages Inventory
31    /// Parameters:
32    /// - body (Option<&Value>): Request body
33    /// - license_number (Option<String>): Filter by licenseNumber
34    pub async fn create_lab_tests_record(&self, license_number: Option<String>, body: Option<Vec<CreateRecordRequestItem>>) -> std::result::Result<Option<WriteResponse>, Box<dyn Error + Send + Sync>> {
35        let body_val = if let Some(b) = body { Some(serde_json::to_value(b)?) } else { None };
36        let client = self.client.clone();
37        
38        let body_val = body_val.clone();
39
40        let resp_val = self.rate_limiter.execute(None,false,
41            move || {
42                let client = client.clone();
43                let license_number = license_number.clone();
44                let body_val = body_val.clone();
45
46                async move {
47                    client.lab_tests().create_lab_tests_record(license_number, body_val.as_ref()
48                    ).await.map_err(|e| e as Box<dyn Error + Send + Sync>)
49                }
50            }
51        ).await?;
52
53        if let Some(v) = resp_val {
54            let typed: WriteResponse = serde_json::from_value(v)?;
55            Ok(Some(typed))
56        } else {
57            Ok(None)
58        }
59    }
60
61    /// GET GetBatches
62    /// Retrieves a list of Lab Test batches.
63    /// Parameters:
64    /// - page_number (Option<String>): Filter by pageNumber
65    /// - page_size (Option<String>): Filter by pageSize
66    pub async fn get_lab_tests_batches(&self, page_number: Option<String>, page_size: Option<String>, body: Option<&Value>) -> std::result::Result<Option<PaginatedResponse<Batch>>, Box<dyn Error + Send + Sync>> {
67        let body_val = if let Some(b) = body { Some(serde_json::to_value(b)?) } else { None };
68        let client = self.client.clone();
69        
70        let body_val = body_val.clone();
71
72        let resp_val = self.rate_limiter.execute(None,true,
73            move || {
74                let client = client.clone();
75                let page_number = page_number.clone();
76                let page_size = page_size.clone();
77                let body_val = body_val.clone();
78
79                async move {
80                    client.lab_tests().get_lab_tests_batches(page_number, page_size, 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: PaginatedResponse<Batch> = serde_json::from_value(v)?;
88            Ok(Some(typed))
89        } else {
90            Ok(None)
91        }
92    }
93
94    /// GET GetLabTestDocumentById
95    /// Retrieves a specific Lab Test result document by its Id for a given Facility.
96    /// Permissions Required:
97    /// - View Packages
98    /// - Manage Packages Inventory
99    /// Parameters:
100    /// - id (str): Path parameter id
101    /// - license_number (Option<String>): Filter by licenseNumber
102    pub async fn get_lab_tests_lab_test_document_by_id(&self, id: &str, license_number: Option<String>, body: Option<&Value>) -> std::result::Result<Option<serde_json::Value>, Box<dyn Error + Send + Sync>> {
103        let body_val = if let Some(b) = body { Some(serde_json::to_value(b)?) } else { None };
104        let id = id.to_string();
105        let client = self.client.clone();
106        
107        let body_val = body_val.clone();
108
109        let resp_val = self.rate_limiter.execute(None,true,
110            move || {
111                let client = client.clone();
112                let id = id.clone();
113                let license_number = license_number.clone();
114                let body_val = body_val.clone();
115
116                async move {
117                    client.lab_tests().get_lab_tests_lab_test_document_by_id(&id, license_number, body_val.as_ref()
118                    ).await.map_err(|e| e as Box<dyn Error + Send + Sync>)
119                }
120            }
121        ).await?;
122
123        if let Some(v) = resp_val {
124            let typed: serde_json::Value = serde_json::from_value(v)?;
125            Ok(Some(typed))
126        } else {
127            Ok(None)
128        }
129    }
130
131    /// GET GetLabTestsTypes
132    /// Returns a list of Lab Test types.
133    /// Parameters:
134    /// - page_number (Option<String>): Filter by pageNumber
135    /// - page_size (Option<String>): Filter by pageSize
136    pub async fn get_lab_tests_types(&self, page_number: Option<String>, page_size: Option<String>, body: Option<&Value>) -> std::result::Result<Option<PaginatedResponse<LabTestsType>>, Box<dyn Error + Send + Sync>> {
137        let body_val = if let Some(b) = body { Some(serde_json::to_value(b)?) } else { None };
138        let client = self.client.clone();
139        
140        let body_val = body_val.clone();
141
142        let resp_val = self.rate_limiter.execute(None,true,
143            move || {
144                let client = client.clone();
145                let page_number = page_number.clone();
146                let page_size = page_size.clone();
147                let body_val = body_val.clone();
148
149                async move {
150                    client.lab_tests().get_lab_tests_types(page_number, page_size, 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: PaginatedResponse<LabTestsType> = serde_json::from_value(v)?;
158            Ok(Some(typed))
159        } else {
160            Ok(None)
161        }
162    }
163
164    /// GET GetResults
165    /// Retrieves Lab Test results for a specified Package.
166    /// Permissions Required:
167    /// - View Packages
168    /// - Manage Packages Inventory
169    /// Parameters:
170    /// - license_number (Option<String>): Filter by licenseNumber
171    /// - package_id (Option<String>): Filter by packageId
172    /// - page_number (Option<String>): Filter by pageNumber
173    /// - page_size (Option<String>): Filter by pageSize
174    pub async fn get_lab_tests_results(&self, license_number: Option<String>, package_id: Option<String>, page_number: Option<String>, page_size: Option<String>, body: Option<&Value>) -> std::result::Result<Option<PaginatedResponse<Result>>, Box<dyn Error + Send + Sync>> {
175        let body_val = if let Some(b) = body { Some(serde_json::to_value(b)?) } else { None };
176        let client = self.client.clone();
177        
178        let body_val = body_val.clone();
179
180        let resp_val = self.rate_limiter.execute(None,true,
181            move || {
182                let client = client.clone();
183                let license_number = license_number.clone();
184                let package_id = package_id.clone();
185                let page_number = page_number.clone();
186                let page_size = page_size.clone();
187                let body_val = body_val.clone();
188
189                async move {
190                    client.lab_tests().get_lab_tests_results(license_number, package_id, page_number, page_size, body_val.as_ref()
191                    ).await.map_err(|e| e as Box<dyn Error + Send + Sync>)
192                }
193            }
194        ).await?;
195
196        if let Some(v) = resp_val {
197            let typed: PaginatedResponse<Result> = serde_json::from_value(v)?;
198            Ok(Some(typed))
199        } else {
200            Ok(None)
201        }
202    }
203
204    /// GET GetStates
205    /// Returns a list of all lab testing states.
206    /// Parameters:
207    pub async fn get_lab_tests_states(&self, body: Option<&Value>) -> 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,true,
214            move || {
215                let client = client.clone();
216                let body_val = body_val.clone();
217
218                async move {
219                    client.lab_tests().get_lab_tests_states(body_val.as_ref()
220                    ).await.map_err(|e| e as Box<dyn Error + Send + Sync>)
221                }
222            }
223        ).await?;
224
225        if let Some(v) = resp_val {
226            let typed: serde_json::Value = serde_json::from_value(v)?;
227            Ok(Some(typed))
228        } else {
229            Ok(None)
230        }
231    }
232
233    /// PUT UpdateLabTestDocument
234    /// Updates one or more documents for previously submitted lab tests.
235    /// Permissions Required:
236    /// - View Packages
237    /// - Manage Packages Inventory
238    /// Parameters:
239    /// - body (Option<&Value>): Request body
240    /// - license_number (Option<String>): Filter by licenseNumber
241    pub async fn update_lab_tests_lab_test_document(&self, license_number: Option<String>, body: Option<Vec<UpdateLabTestDocumentRequestItem>>) -> std::result::Result<Option<WriteResponse>, Box<dyn Error + Send + Sync>> {
242        let body_val = if let Some(b) = body { Some(serde_json::to_value(b)?) } else { None };
243        let client = self.client.clone();
244        
245        let body_val = body_val.clone();
246
247        let resp_val = self.rate_limiter.execute(None,false,
248            move || {
249                let client = client.clone();
250                let license_number = license_number.clone();
251                let body_val = body_val.clone();
252
253                async move {
254                    client.lab_tests().update_lab_tests_lab_test_document(license_number, body_val.as_ref()
255                    ).await.map_err(|e| e as Box<dyn Error + Send + Sync>)
256                }
257            }
258        ).await?;
259
260        if let Some(v) = resp_val {
261            let typed: WriteResponse = serde_json::from_value(v)?;
262            Ok(Some(typed))
263        } else {
264            Ok(None)
265        }
266    }
267
268    /// PUT UpdateResultsRelease
269    /// Releases Lab Test results for one or more packages.
270    /// Permissions Required:
271    /// - View Packages
272    /// - Manage Packages Inventory
273    /// Parameters:
274    /// - body (Option<&Value>): Request body
275    /// - license_number (Option<String>): Filter by licenseNumber
276    pub async fn update_lab_tests_results_release(&self, license_number: Option<String>, body: Option<Vec<UpdateResultsReleaseRequestItem>>) -> std::result::Result<Option<WriteResponse>, Box<dyn Error + Send + Sync>> {
277        let body_val = if let Some(b) = body { Some(serde_json::to_value(b)?) } else { None };
278        let client = self.client.clone();
279        
280        let body_val = body_val.clone();
281
282        let resp_val = self.rate_limiter.execute(None,false,
283            move || {
284                let client = client.clone();
285                let license_number = license_number.clone();
286                let body_val = body_val.clone();
287
288                async move {
289                    client.lab_tests().update_lab_tests_results_release(license_number, body_val.as_ref()
290                    ).await.map_err(|e| e as Box<dyn Error + Send + Sync>)
291                }
292            }
293        ).await?;
294
295        if let Some(v) = resp_val {
296            let typed: WriteResponse = serde_json::from_value(v)?;
297            Ok(Some(typed))
298        } else {
299            Ok(None)
300        }
301    }
302}
303
thunkmetrc_wrapper/services/lab_tests_service.rs

thunkmetrc_wrapper/services/
lab_tests_service.rs
