Skip to main content

basaltic/services/
queue.rs

1//! Generated API methods; do not edit.
2#![allow(unused_imports)]
3use crate::models::queue as m;
4use crate::transport::{Core, Operation, Payload, QueryEncoding};
5use crate::{BinaryRequest, Client, EmptyRequest, PagedRequest, Request, WebSocketRequest};
6const ENDPOINT: &str = "https://queue.{region}.basaltic.sh";
7static OP_0: Operation = Operation {
8    id: "changeMessageVisibility",
9    method: "POST",
10    path: "/v1/queues/{queue_id}/messages/visibility",
11    authenticated: true,
12    required_query: &[],
13    required_headers: &[],
14    content_type: "application/json",
15    accept: "application/json",
16    query_encoding: &[],
17};
18static OP_1: Operation = Operation {
19    id: "changeMessageVisibilityBatch",
20    method: "POST",
21    path: "/v1/queues/{queue_id}/messages/visibility-batch",
22    authenticated: true,
23    required_query: &[],
24    required_headers: &[],
25    content_type: "application/json",
26    accept: "application/json",
27    query_encoding: &[],
28};
29static OP_2: Operation = Operation {
30    id: "createQueue",
31    method: "POST",
32    path: "/v1/queues",
33    authenticated: true,
34    required_query: &[],
35    required_headers: &[],
36    content_type: "application/json",
37    accept: "application/json",
38    query_encoding: &[],
39};
40static OP_3: Operation = Operation {
41    id: "deleteMessage",
42    method: "DELETE",
43    path: "/v1/queues/{queue_id}/messages",
44    authenticated: true,
45    required_query: &["receipt_handle"],
46    required_headers: &[],
47    content_type: "",
48    accept: "application/json",
49    query_encoding: &[QueryEncoding {
50        name: "receipt_handle",
51        style: "form",
52        explode: true,
53    }],
54};
55static OP_4: Operation = Operation {
56    id: "deleteMessageBatch",
57    method: "POST",
58    path: "/v1/queues/{queue_id}/messages/delete-batch",
59    authenticated: true,
60    required_query: &[],
61    required_headers: &[],
62    content_type: "application/json",
63    accept: "application/json",
64    query_encoding: &[],
65};
66static OP_5: Operation = Operation {
67    id: "deleteQueue",
68    method: "DELETE",
69    path: "/v1/queues/{queue_id}",
70    authenticated: true,
71    required_query: &[],
72    required_headers: &[],
73    content_type: "",
74    accept: "application/json",
75    query_encoding: &[],
76};
77static OP_6: Operation = Operation {
78    id: "describeQueue",
79    method: "GET",
80    path: "/v1/queues/{queue_id}",
81    authenticated: true,
82    required_query: &[],
83    required_headers: &[],
84    content_type: "",
85    accept: "application/json",
86    query_encoding: &[],
87};
88static OP_7: Operation = Operation {
89    id: "listQueues",
90    method: "GET",
91    path: "/v1/queues",
92    authenticated: true,
93    required_query: &[],
94    required_headers: &[],
95    content_type: "",
96    accept: "application/json",
97    query_encoding: &[
98        QueryEncoding {
99            name: "name",
100            style: "form",
101            explode: true,
102        },
103        QueryEncoding {
104            name: "crn",
105            style: "form",
106            explode: true,
107        },
108        QueryEncoding {
109            name: "marker",
110            style: "form",
111            explode: true,
112        },
113        QueryEncoding {
114            name: "limit",
115            style: "form",
116            explode: true,
117        },
118    ],
119};
120static OP_8: Operation = Operation {
121    id: "peekMessages",
122    method: "GET",
123    path: "/v1/queues/{queue_id}/messages",
124    authenticated: true,
125    required_query: &[],
126    required_headers: &[],
127    content_type: "",
128    accept: "application/json",
129    query_encoding: &[
130        QueryEncoding {
131            name: "crn",
132            style: "form",
133            explode: true,
134        },
135        QueryEncoding {
136            name: "visibility",
137            style: "form",
138            explode: true,
139        },
140        QueryEncoding {
141            name: "marker",
142            style: "form",
143            explode: true,
144        },
145        QueryEncoding {
146            name: "limit",
147            style: "form",
148            explode: true,
149        },
150    ],
151};
152static OP_9: Operation = Operation {
153    id: "purgeQueue",
154    method: "POST",
155    path: "/v1/queues/{queue_id}/purge",
156    authenticated: true,
157    required_query: &[],
158    required_headers: &[],
159    content_type: "",
160    accept: "application/json",
161    query_encoding: &[],
162};
163static OP_10: Operation = Operation {
164    id: "receiveMessages",
165    method: "POST",
166    path: "/v1/queues/{queue_id}/messages/receive",
167    authenticated: true,
168    required_query: &[],
169    required_headers: &[],
170    content_type: "application/json",
171    accept: "application/json",
172    query_encoding: &[],
173};
174static OP_11: Operation = Operation {
175    id: "sendMessage",
176    method: "POST",
177    path: "/v1/queues/{queue_id}/messages",
178    authenticated: true,
179    required_query: &[],
180    required_headers: &[],
181    content_type: "application/json",
182    accept: "application/json",
183    query_encoding: &[],
184};
185static OP_12: Operation = Operation {
186    id: "sendMessageBatch",
187    method: "POST",
188    path: "/v1/queues/{queue_id}/messages/batch",
189    authenticated: true,
190    required_query: &[],
191    required_headers: &[],
192    content_type: "application/json",
193    accept: "application/json",
194    query_encoding: &[],
195};
196static OP_13: Operation = Operation {
197    id: "updateQueue",
198    method: "PATCH",
199    path: "/v1/queues/{queue_id}",
200    authenticated: true,
201    required_query: &[],
202    required_headers: &[],
203    content_type: "application/json",
204    accept: "application/json",
205    query_encoding: &[],
206};
207#[derive(Clone, Debug)]
208pub struct QueueService {
209    pub(crate) client: Client,
210}
211impl QueueService {
212    /// Extend or shorten a lease
213    pub fn change_message_visibility(
214        &self,
215        queue_id: &str,
216        body: &m::ChangeMessageVisibilityBody,
217    ) -> EmptyRequest {
218        EmptyRequest::new(Core::new(
219            self.client.clone(),
220            "queue",
221            ENDPOINT,
222            &OP_0,
223            &[("queue_id", queue_id)],
224            Payload::json(body),
225            Ok(serde_json::json!({})),
226        ))
227    }
228    /// Extend or shorten up to ten leases
229    pub fn change_message_visibility_batch(
230        &self,
231        queue_id: &str,
232        body: &m::ChangeMessageVisibilityBatchBody,
233    ) -> Request<m::ChangeMessageVisibilityBatchResponse> {
234        Request::new(Core::new(
235            self.client.clone(),
236            "queue",
237            ENDPOINT,
238            &OP_1,
239            &[("queue_id", queue_id)],
240            Payload::json(body),
241            Ok(serde_json::json!({})),
242        ))
243    }
244    /// Create a queue
245    pub fn create_queue(&self, body: &m::CreateQueueBody) -> Request<m::CreateQueueResponse> {
246        Request::new(Core::new(
247            self.client.clone(),
248            "queue",
249            ENDPOINT,
250            &OP_2,
251            &[],
252            Payload::json(body),
253            Ok(serde_json::json!({})),
254        ))
255    }
256    /// Delete a leased message
257    pub fn delete_message(&self, queue_id: &str, query: &m::DeleteMessageQuery) -> EmptyRequest {
258        EmptyRequest::new(Core::new(
259            self.client.clone(),
260            "queue",
261            ENDPOINT,
262            &OP_3,
263            &[("queue_id", queue_id)],
264            Ok(Payload::Empty),
265            serde_json::to_value(query).map_err(crate::Error::from),
266        ))
267    }
268    /// Delete up to ten leased messages
269    pub fn delete_message_batch(
270        &self,
271        queue_id: &str,
272        body: &m::DeleteMessageBatchBody,
273    ) -> Request<m::DeleteMessageBatchResponse> {
274        Request::new(Core::new(
275            self.client.clone(),
276            "queue",
277            ENDPOINT,
278            &OP_4,
279            &[("queue_id", queue_id)],
280            Payload::json(body),
281            Ok(serde_json::json!({})),
282        ))
283    }
284    /// Delete a queue
285    pub fn delete_queue(&self, queue_id: &str) -> EmptyRequest {
286        EmptyRequest::new(Core::new(
287            self.client.clone(),
288            "queue",
289            ENDPOINT,
290            &OP_5,
291            &[("queue_id", queue_id)],
292            Ok(Payload::Empty),
293            Ok(serde_json::json!({})),
294        ))
295    }
296    /// Describe a queue
297    pub fn describe_queue(&self, queue_id: &str) -> Request<m::DescribeQueueResponse> {
298        Request::new(Core::new(
299            self.client.clone(),
300            "queue",
301            ENDPOINT,
302            &OP_6,
303            &[("queue_id", queue_id)],
304            Ok(Payload::Empty),
305            Ok(serde_json::json!({})),
306        ))
307    }
308    /// List queues
309    pub fn list_queues(
310        &self,
311        query: &m::ListQueuesQuery,
312    ) -> PagedRequest<m::ListQueuesResponse, m::ListQueuesItem> {
313        PagedRequest::new(
314            Core::new(
315                self.client.clone(),
316                "queue",
317                ENDPOINT,
318                &OP_7,
319                &[],
320                Ok(Payload::Empty),
321                serde_json::to_value(query).map_err(crate::Error::from),
322            ),
323            "queues",
324        )
325    }
326    /// Peek at a queue's messages
327    pub fn peek_messages(
328        &self,
329        queue_id: &str,
330        query: &m::PeekMessagesQuery,
331    ) -> Request<m::PeekMessagesResponse> {
332        Request::new(Core::new(
333            self.client.clone(),
334            "queue",
335            ENDPOINT,
336            &OP_8,
337            &[("queue_id", queue_id)],
338            Ok(Payload::Empty),
339            serde_json::to_value(query).map_err(crate::Error::from),
340        ))
341    }
342    /// Delete every message on a queue
343    pub fn purge_queue(&self, queue_id: &str) -> Request<m::PurgeQueueResponse> {
344        Request::new(Core::new(
345            self.client.clone(),
346            "queue",
347            ENDPOINT,
348            &OP_9,
349            &[("queue_id", queue_id)],
350            Ok(Payload::Empty),
351            Ok(serde_json::json!({})),
352        ))
353    }
354    /// Lease messages
355    pub fn receive_messages(
356        &self,
357        queue_id: &str,
358        body: Option<&m::ReceiveMessagesBody>,
359    ) -> Request<m::ReceiveMessagesResponse> {
360        Request::new(Core::new(
361            self.client.clone(),
362            "queue",
363            ENDPOINT,
364            &OP_10,
365            &[("queue_id", queue_id)],
366            body.map(Payload::json).unwrap_or(Ok(Payload::Empty)),
367            Ok(serde_json::json!({})),
368        ))
369    }
370    /// Send a message
371    pub fn send_message(
372        &self,
373        queue_id: &str,
374        body: &m::SendMessageBody,
375    ) -> Request<m::SendMessageResponse> {
376        Request::new(Core::new(
377            self.client.clone(),
378            "queue",
379            ENDPOINT,
380            &OP_11,
381            &[("queue_id", queue_id)],
382            Payload::json(body),
383            Ok(serde_json::json!({})),
384        ))
385    }
386    /// Send up to ten messages
387    pub fn send_message_batch(
388        &self,
389        queue_id: &str,
390        body: &m::SendMessageBatchBody,
391    ) -> Request<m::SendMessageBatchResponse> {
392        Request::new(Core::new(
393            self.client.clone(),
394            "queue",
395            ENDPOINT,
396            &OP_12,
397            &[("queue_id", queue_id)],
398            Payload::json(body),
399            Ok(serde_json::json!({})),
400        ))
401    }
402    /// Update queue attributes
403    pub fn update_queue(
404        &self,
405        queue_id: &str,
406        body: &m::UpdateQueueBody,
407    ) -> Request<m::UpdateQueueResponse> {
408        Request::new(Core::new(
409            self.client.clone(),
410            "queue",
411            ENDPOINT,
412            &OP_13,
413            &[("queue_id", queue_id)],
414            Payload::json(body),
415            Ok(serde_json::json!({})),
416        ))
417    }
418}