openiap_proto/
queue.rs

1#![warn(missing_docs)]
2use super::openiap::{Envelope, RegisterQueueRequest, UnRegisterQueueRequest, RegisterExchangeRequest, 
3    WatchRequest, UnWatchRequest, QueueMessageRequest
4};
5
6impl RegisterQueueRequest {
7    /// Creates a new `RegisterQueueRequest` with the given `queuename`.
8    pub fn byqueuename(queuename: &str) -> Self {
9        Self {
10            queuename: queuename.to_string()
11        }
12    }
13    /// Converts the `RegisterQueueRequest` to an `Envelope`.
14    pub fn to_envelope(&self) -> Envelope {
15        let any_message = prost_types::Any {
16            type_url: "type.googleapis.com/openiap.RegisterQueueRequest".to_string(),
17            value: {
18                let mut buf = Vec::new();
19                prost::Message::encode(self, &mut buf).unwrap_or(());
20                buf
21            },
22        };
23        Envelope {
24            command: "registerqueue".into(),
25            data: Some(any_message.clone()),
26            ..Default::default() 
27        }
28    }
29}
30impl RegisterExchangeRequest {
31    /// Creates a new `RegisterExchangeRequest` with the given `exchangename`.
32    pub fn byexchangename(exchangename: &str) -> Self {
33        Self {
34            exchangename: exchangename.to_string(),
35            addqueue: true,
36            ..Default::default()
37        }
38    }
39    /// Converts the `RegisterExchangeRequest` to an `Envelope`.
40    pub fn to_envelope(&self) -> Envelope {
41        let any_message = prost_types::Any {
42            type_url: "type.googleapis.com/openiap.RegisterExchangeRequest".to_string(),
43            value: {
44                let mut buf = Vec::new();
45                prost::Message::encode(self, &mut buf).unwrap_or(());
46                buf
47            },
48        };
49        Envelope {
50            command: "registerexchange".into(),
51            data: Some(any_message.clone()),
52            ..Default::default() 
53        }
54    }
55}
56impl  UnRegisterQueueRequest {
57    /// Creates a new `UnRegisterQueueRequest` with the given `queuename`.
58    pub fn byqueuename(queuename: &str) -> Self {
59        Self {
60            queuename: queuename.to_string()
61        }
62    }
63    /// Converts the `UnRegisterQueueRequest` to an `Envelope`.
64    pub fn to_envelope(&self) -> Envelope {
65        let any_message = prost_types::Any {
66            type_url: "type.googleapis.com/openiap.UnRegisterQueueRequest".to_string(),
67            value: {
68                let mut buf = Vec::new();
69                prost::Message::encode(self, &mut buf).unwrap_or(());
70                buf
71            },
72        };
73        Envelope {
74            command: "unregisterqueue".into(),
75            data: Some(any_message.clone()),
76            ..Default::default() 
77        }
78    }
79    
80}
81impl WatchRequest {
82    /// Creates a new `WatchRequest` with the given `collectionname` and `paths`.
83    pub fn new(collectionname: &str, paths: Vec<String>) -> Self {
84        Self {
85            collectionname: collectionname.to_string(),
86            paths
87        }
88    }
89    /// Converts the `WatchRequest` to an `Envelope`.
90    pub fn to_envelope(&self) -> Envelope {
91        let any_message = prost_types::Any {
92            type_url: "type.googleapis.com/openiap.WatchRequest".to_string(),
93            value: {
94                let mut buf = Vec::new();
95                prost::Message::encode(self, &mut buf).unwrap_or(());
96                buf
97            },
98        };
99        Envelope {
100            command: "watch".into(),
101            data: Some(any_message.clone()),
102            ..Default::default() 
103        }
104    }
105}
106impl UnWatchRequest {
107    /// Creates a new `UnWatchRequest` with the given `id`.
108    pub fn byid(id: &str) -> Self {
109        Self {
110            id: id.to_string()
111        }
112    }
113    /// Converts the `UnWatchRequest` to an `Envelope`.
114    pub fn to_envelope(&self) -> Envelope {
115        let any_message = prost_types::Any {
116            type_url: "type.googleapis.com/openiap.UnWatchRequest".to_string(),
117            value: {
118                let mut buf = Vec::new();
119                prost::Message::encode(self, &mut buf).unwrap_or(());
120                buf
121            },
122        };
123        Envelope {
124            command: "unwatch".into(),
125            data: Some(any_message.clone()),
126            ..Default::default() 
127        }
128    }
129}
130impl  QueueMessageRequest {
131    /// Creates a new `QueueMessageRequest` with the given `queuename`, `data` and `striptoken`.
132    pub fn byqueuename(queuename: &str, data: &str, striptoken: bool) -> Self {
133        Self {
134            queuename: queuename.to_string(),
135            data: data.to_string(),
136            striptoken,
137            ..Default::default()
138        }
139    }
140    /// Creates a new `QueueMessageRequest` with the given `queuename`, `correlation_id`, `data` and `striptoken`.
141    pub fn replyto(queuename: &str, correlation_id: &str, data: &str, striptoken: bool) -> Self {
142        Self {
143            queuename: queuename.to_string(),
144            data: data.to_string(),
145            correlation_id: correlation_id.to_string(),
146            striptoken,
147            ..Default::default()
148        }
149    }
150    /// Creates a new `QueueMessageRequest` with the given `exchangename`, `data` and `striptoken`.
151    pub fn byexchangename(exchangename: &str, data: &str, striptoken: bool) -> Self {
152        Self {
153            exchangename: exchangename.to_string(),
154            data: data.to_string(),
155            striptoken,
156            ..Default::default()
157        }
158    }
159    /// Converts the `QueueMessageRequest` to an `Envelope`.
160    pub fn to_envelope(&self) -> Envelope {
161        let any_message = prost_types::Any {
162            type_url: "type.googleapis.com/openiap.QueueMessageRequest".to_string(),
163            value: {
164                let mut buf = Vec::new();
165                prost::Message::encode(self, &mut buf).unwrap_or(());
166                buf
167            },
168        };
169        Envelope {
170            command: "queuemessage".into(),
171            data: Some(any_message.clone()),
172            ..Default::default() 
173        }
174    }    
175}