1#![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 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 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 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 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 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 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 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 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 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 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 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 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 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 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}