1// Copyright (c) 2017 Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
2//
3// This Source Code Form is subject to the terms of the Mozilla Public
4// License, v. 2.0. If a copy of the MPL was not distributed with this
5// file, You can obtain one at http://mozilla.org/MPL/2.0/.
6
7use try_from::TryFrom;
8
9use minidom::{Element, IntoAttributeValue};
10use jid::Jid;
11use date::DateTime;
12
13use error::Error;
14
15use ns;
16
17use data_forms::DataForm;
18
19generate_id!(NodeName);
20generate_id!(ItemId);
21generate_id!(SubscriptionId);
22
23#[derive(Debug, Clone)]
24pub struct Item {
25 payload: Option<Element>,
26 node: Option<NodeName>,
27 id: Option<ItemId>,
28 publisher: Option<Jid>,
29}
30
31impl TryFrom<Element> for Item {
32 type Err = Error;
33
34 fn try_from(elem: Element) -> Result<Item, Error> {
35 check_self!(elem, "item", ns::PUBSUB_EVENT);
36 check_no_unknown_attributes!(elem, "item", ["id", "node", "publisher"]);
37 let mut payloads = elem.children().cloned().collect::<Vec<_>>();
38 let payload = payloads.pop();
39 if !payloads.is_empty() {
40 return Err(Error::ParseError("More than a single payload in item element."));
41 }
42 Ok(Item {
43 payload,
44 id: get_attr!(elem, "id", optional),
45 node: get_attr!(elem, "node", optional),
46 publisher: get_attr!(elem, "publisher", optional),
47 })
48 }
49}
50
51impl From<Item> for Element {
52 fn from(item: Item) -> Element {
53 Element::builder("item")
54 .ns(ns::PUBSUB_EVENT)
55 .attr("id", item.id)
56 .attr("node", item.node)
57 .attr("publisher", item.publisher)
58 .append(item.payload)
59 .build()
60 }
61}
62
63generate_attribute!(Subscription, "subscription", {
64 None => "none",
65 Pending => "pending",
66 Subscribed => "subscribed",
67 Unconfigured => "unconfigured",
68}, Default = None);
69
70#[derive(Debug, Clone)]
71pub enum PubSubEvent {
72 /*
73 Collection {
74 },
75 */
76 Configuration {
77 node: NodeName,
78 form: Option<DataForm>,
79 },
80 Delete {
81 node: NodeName,
82 redirect: Option<String>,
83 },
84 EmptyItems {
85 node: NodeName,
86 },
87 PublishedItems {
88 node: NodeName,
89 items: Vec<Item>,
90 },
91 RetractedItems {
92 node: NodeName,
93 items: Vec<ItemId>,
94 },
95 Purge {
96 node: NodeName,
97 },
98 Subscription {
99 node: NodeName,
100 expiry: Option<DateTime>,
101 jid: Option<Jid>,
102 subid: Option<SubscriptionId>,
103 subscription: Option<Subscription>,
104 },
105}
106
107fn parse_items(elem: Element, node: NodeName) -> Result<PubSubEvent, Error> {
108 let mut is_retract = None;
109 let mut items = vec!();
110 let mut retracts = vec!();
111 for child in elem.children() {
112 if child.is("item", ns::PUBSUB_EVENT) {
113 match is_retract {
114 None => is_retract = Some(false),
115 Some(false) => (),
116 Some(true) => return Err(Error::ParseError("Mix of item and retract in items element.")),
117 }
118 items.push(Item::try_from(child.clone())?);
119 } else if child.is("retract", ns::PUBSUB_EVENT) {
120 match is_retract {
121 None => is_retract = Some(true),
122 Some(true) => (),
123 Some(false) => return Err(Error::ParseError("Mix of item and retract in items element.")),
124 }
125 check_no_children!(child, "retract");
126 check_no_unknown_attributes!(child, "retract", ["id"]);
127 let id = get_attr!(child, "id", required);
128 retracts.push(id);
129 } else {
130 return Err(Error::ParseError("Invalid child in items element."));
131 }
132 }
133 Ok(match is_retract {
134 None => PubSubEvent::EmptyItems { node },
135 Some(false) => PubSubEvent::PublishedItems { node, items },
136 Some(true) => PubSubEvent::RetractedItems { node, items: retracts },
137 })
138}
139
140impl TryFrom<Element> for PubSubEvent {
141 type Err = Error;
142
143 fn try_from(elem: Element) -> Result<PubSubEvent, Error> {
144 check_self!(elem, "event", ns::PUBSUB_EVENT);
145 check_no_attributes!(elem, "event");
146
147 let mut payload = None;
148 for child in elem.children() {
149 let node = get_attr!(child, "node", required);
150 if child.is("configuration", ns::PUBSUB_EVENT) {
151 let mut payloads = child.children().cloned().collect::<Vec<_>>();
152 let item = payloads.pop();
153 if !payloads.is_empty() {
154 return Err(Error::ParseError("More than a single payload in configuration element."));
155 }
156 let form = match item {
157 None => None,
158 Some(payload) => Some(DataForm::try_from(payload)?),
159 };
160 payload = Some(PubSubEvent::Configuration { node, form });
161 } else if child.is("delete", ns::PUBSUB_EVENT) {
162 let mut redirect = None;
163 for item in child.children() {
164 if item.is("redirect", ns::PUBSUB_EVENT) {
165 if redirect.is_some() {
166 return Err(Error::ParseError("More than one redirect in delete element."));
167 }
168 let uri = get_attr!(item, "uri", required);
169 redirect = Some(uri);
170 } else {
171 return Err(Error::ParseError("Unknown child in delete element."));
172 }
173 }
174 payload = Some(PubSubEvent::Delete { node, redirect });
175 } else if child.is("items", ns::PUBSUB_EVENT) {
176 payload = Some(parse_items(child.clone(), node)?);
177 } else if child.is("purge", ns::PUBSUB_EVENT) {
178 for _ in child.children() {
179 return Err(Error::ParseError("Unknown child in purge element."));
180 }
181 payload = Some(PubSubEvent::Purge { node });
182 } else if child.is("subscription", ns::PUBSUB_EVENT) {
183 for _ in child.children() {
184 return Err(Error::ParseError("Unknown child in purge element."));
185 }
186 payload = Some(PubSubEvent::Subscription {
187 node: node,
188 expiry: get_attr!(child, "expiry", optional),
189 jid: get_attr!(child, "jid", optional),
190 subid: get_attr!(child, "subid", optional),
191 subscription: get_attr!(child, "subscription", optional),
192 });
193 } else {
194 return Err(Error::ParseError("Unknown child in event element."));
195 }
196 }
197 Ok(payload.ok_or(Error::ParseError("No payload in event element."))?)
198 }
199}
200
201impl From<PubSubEvent> for Element {
202 fn from(event: PubSubEvent) -> Element {
203 let payload = match event {
204 PubSubEvent::Configuration { node, form } => {
205 Element::builder("configuration")
206 .ns(ns::PUBSUB_EVENT)
207 .attr("node", node)
208 .append(form)
209 .build()
210 },
211 PubSubEvent::Delete { node, redirect } => {
212 Element::builder("purge")
213 .ns(ns::PUBSUB_EVENT)
214 .attr("node", node)
215 .append(redirect.map(|redirect| {
216 Element::builder("redirect")
217 .ns(ns::PUBSUB_EVENT)
218 .attr("uri", redirect)
219 .build()
220 }))
221 .build()
222 },
223 PubSubEvent::EmptyItems { node } => {
224 Element::builder("items")
225 .ns(ns::PUBSUB_EVENT)
226 .attr("node", node)
227 .build()
228 },
229 PubSubEvent::PublishedItems { node, items } => {
230 Element::builder("items")
231 .ns(ns::PUBSUB_EVENT)
232 .attr("node", node)
233 .append(items)
234 .build()
235 },
236 PubSubEvent::RetractedItems { node, items } => {
237 Element::builder("items")
238 .ns(ns::PUBSUB_EVENT)
239 .attr("node", node)
240 .append(items.into_iter().map(|id| {
241 Element::builder("retract")
242 .ns(ns::PUBSUB_EVENT)
243 .attr("id", id)
244 .build()
245 }).collect::<Vec<_>>())
246 .build()
247 },
248 PubSubEvent::Purge { node } => {
249 Element::builder("purge")
250 .ns(ns::PUBSUB_EVENT)
251 .attr("node", node)
252 .build()
253 },
254 PubSubEvent::Subscription { node, expiry, jid, subid, subscription } => {
255 Element::builder("subscription")
256 .ns(ns::PUBSUB_EVENT)
257 .attr("node", node)
258 .attr("expiry", expiry)
259 .attr("jid", jid)
260 .attr("subid", subid)
261 .attr("subscription", subscription)
262 .build()
263 },
264 };
265 Element::builder("event")
266 .ns(ns::PUBSUB_EVENT)
267 .append(payload)
268 .build()
269 }
270}
271
272#[cfg(test)]
273mod tests {
274 use super::*;
275 use std::str::FromStr;
276 use compare_elements::NamespaceAwareCompare;
277
278 #[test]
279 fn test_simple() {
280 let elem: Element = "<event xmlns='http://jabber.org/protocol/pubsub#event'><items node='coucou'/></event>".parse().unwrap();
281 let event = PubSubEvent::try_from(elem).unwrap();
282 match event {
283 PubSubEvent::EmptyItems { node } => assert_eq!(node, NodeName(String::from("coucou"))),
284 _ => panic!(),
285 }
286 }
287
288 #[test]
289 fn test_simple_items() {
290 let elem: Element = "<event xmlns='http://jabber.org/protocol/pubsub#event'><items node='coucou'><item id='test' node='huh?' publisher='test@coucou'/></items></event>".parse().unwrap();
291 let event = PubSubEvent::try_from(elem).unwrap();
292 match event {
293 PubSubEvent::PublishedItems { node, items } => {
294 assert_eq!(node, NodeName(String::from("coucou")));
295 assert_eq!(items[0].id, Some(ItemId(String::from("test"))));
296 assert_eq!(items[0].node, Some(NodeName(String::from("huh?"))));
297 assert_eq!(items[0].publisher, Some(Jid::from_str("test@coucou").unwrap()));
298 assert_eq!(items[0].payload, None);
299 },
300 _ => panic!(),
301 }
302 }
303
304 #[test]
305 fn test_simple_pep() {
306 let elem: Element = "<event xmlns='http://jabber.org/protocol/pubsub#event'><items node='something'><item><foreign xmlns='example:namespace'/></item></items></event>".parse().unwrap();
307 let event = PubSubEvent::try_from(elem).unwrap();
308 match event {
309 PubSubEvent::PublishedItems { node, items } => {
310 assert_eq!(node, NodeName(String::from("something")));
311 assert_eq!(items[0].id, None);
312 assert_eq!(items[0].node, None);
313 assert_eq!(items[0].publisher, None);
314 match items[0].payload {
315 Some(ref elem) => assert!(elem.is("foreign", "example:namespace")),
316 _ => panic!(),
317 }
318 },
319 _ => panic!(),
320 }
321 }
322
323 #[test]
324 fn test_simple_retract() {
325 let elem: Element = "<event xmlns='http://jabber.org/protocol/pubsub#event'><items node='something'><retract id='coucou'/><retract id='test'/></items></event>".parse().unwrap();
326 let event = PubSubEvent::try_from(elem).unwrap();
327 match event {
328 PubSubEvent::RetractedItems { node, items } => {
329 assert_eq!(node, NodeName(String::from("something")));
330 assert_eq!(items[0], ItemId(String::from("coucou")));
331 assert_eq!(items[1], ItemId(String::from("test")));
332 },
333 _ => panic!(),
334 }
335 }
336
337 #[test]
338 fn test_simple_delete() {
339 let elem: Element = "<event xmlns='http://jabber.org/protocol/pubsub#event'><delete node='coucou'><redirect uri='hello'/></delete></event>".parse().unwrap();
340 let event = PubSubEvent::try_from(elem).unwrap();
341 match event {
342 PubSubEvent::Delete { node, redirect } => {
343 assert_eq!(node, NodeName(String::from("coucou")));
344 assert_eq!(redirect, Some(String::from("hello")));
345 },
346 _ => panic!(),
347 }
348 }
349
350 #[test]
351 fn test_simple_purge() {
352 let elem: Element = "<event xmlns='http://jabber.org/protocol/pubsub#event'><purge node='coucou'/></event>".parse().unwrap();
353 let event = PubSubEvent::try_from(elem).unwrap();
354 match event {
355 PubSubEvent::Purge { node } => {
356 assert_eq!(node, NodeName(String::from("coucou")));
357 },
358 _ => panic!(),
359 }
360 }
361
362 #[test]
363 fn test_simple_configure() {
364 let elem: Element = "<event xmlns='http://jabber.org/protocol/pubsub#event'><configuration node='coucou'><x xmlns='jabber:x:data' type='result'><field var='FORM_TYPE' type='hidden'><value>http://jabber.org/protocol/pubsub#node_config</value></field></x></configuration></event>".parse().unwrap();
365 let event = PubSubEvent::try_from(elem).unwrap();
366 match event {
367 PubSubEvent::Configuration { node, form: _ } => {
368 assert_eq!(node, NodeName(String::from("coucou")));
369 //assert_eq!(form.type_, Result_);
370 },
371 _ => panic!(),
372 }
373 }
374
375 #[test]
376 fn test_invalid() {
377 let elem: Element = "<event xmlns='http://jabber.org/protocol/pubsub#event'><coucou node='test'/></event>".parse().unwrap();
378 let error = PubSubEvent::try_from(elem).unwrap_err();
379 let message = match error {
380 Error::ParseError(string) => string,
381 _ => panic!(),
382 };
383 assert_eq!(message, "Unknown child in event element.");
384 }
385
386 #[test]
387 fn test_invalid_attribute() {
388 let elem: Element = "<event xmlns='http://jabber.org/protocol/pubsub#event' coucou=''/>".parse().unwrap();
389 let error = PubSubEvent::try_from(elem).unwrap_err();
390 let message = match error {
391 Error::ParseError(string) => string,
392 _ => panic!(),
393 };
394 assert_eq!(message, "Unknown attribute in event element.");
395 }
396
397 #[test]
398 fn test_ex221_subscription() {
399 let elem: Element = r#"
400<event xmlns='http://jabber.org/protocol/pubsub#event'>
401 <subscription
402 expiry='2006-02-28T23:59:59+00:00'
403 jid='francisco@denmark.lit'
404 node='princely_musings'
405 subid='ba49252aaa4f5d320c24d3766f0bdcade78c78d3'
406 subscription='subscribed'/>
407</event>
408"#.parse().unwrap();
409 let event = PubSubEvent::try_from(elem.clone()).unwrap();
410 match event.clone() {
411 PubSubEvent::Subscription { node, expiry, jid, subid, subscription } => {
412 assert_eq!(node, NodeName(String::from("princely_musings")));
413 assert_eq!(subid, Some(SubscriptionId(String::from("ba49252aaa4f5d320c24d3766f0bdcade78c78d3"))));
414 assert_eq!(subscription, Some(Subscription::Subscribed));
415 assert_eq!(jid, Some(Jid::from_str("francisco@denmark.lit").unwrap()));
416 assert_eq!(expiry, Some("2006-02-28T23:59:59Z".parse().unwrap()));
417 },
418 _ => panic!(),
419 }
420
421 let elem2: Element = event.into();
422 assert!(elem.compare_to(&elem2));
423 }
424}