1 files changed, 358 insertions, 0 deletions
diff --git a/stanza/src/xep_0060/owner.rs b/stanza/src/xep_0060/owner.rs
new file mode 100644
index 0000000..1fedc60
--- /dev/null
+++ b/stanza/src/xep_0060/owner.rs
@@ -0,0 +1,358 @@
+use std::str::FromStr;
+
+use jid::JID;
+use peanuts::{
+    element::{FromElement, IntoElement},
+    DeserializeError, Element,
+};
+
+use crate::xep_0004::X;
+
+pub const XMLNS: &str = "http://jabber.org/protocol/pubsub#owner";
+
+#[derive(Clone, Debug)]
+pub enum Pubsub {
+    Affiliations(Affiliations),
+    Configure(Configure),
+    Default(Default),
+    Delete(Delete),
+    Purge(Purge),
+    Subscriptions(Subscriptions),
+}
+
+impl FromElement for Pubsub {
+    fn from_element(mut element: peanuts::Element) -> peanuts::element::DeserializeResult<Self> {
+        element.check_name("pubsub")?;
+        element.check_namespace(XMLNS)?;
+
+        let child = element.pop_child_one::<Element>()?;
+
+        match child.identify() {
+            (Some(XMLNS), "affiliations") => {
+                Ok(Self::Affiliations(Affiliations::from_element(child)?))
+            }
+            (Some(XMLNS), "configure") => Ok(Self::Configure(Configure::from_element(child)?)),
+            (Some(XMLNS), "default") => Ok(Self::Default(Default::from_element(child)?)),
+            (Some(XMLNS), "delete") => Ok(Self::Delete(Delete::from_element(child)?)),
+            (Some(XMLNS), "purge") => Ok(Self::Purge(Purge::from_element(child)?)),
+            (Some(XMLNS), "subscriptions") => {
+                Ok(Self::Subscriptions(Subscriptions::from_element(child)?))
+            }
+            _ => Err(DeserializeError::UnexpectedElement(child)),
+        }
+    }
+}
+
+impl IntoElement for Pubsub {
+    fn builder(&self) -> peanuts::element::ElementBuilder {
+        let builder = Element::builder("pubsub", Some(XMLNS));
+
+        match self {
+            Pubsub::Affiliations(affiliations) => builder.push_child(affiliations.clone()),
+            Pubsub::Configure(configure) => builder.push_child(configure.clone()),
+            Pubsub::Default(default) => builder.push_child(default.clone()),
+            Pubsub::Delete(delete) => builder.push_child(delete.clone()),
+            Pubsub::Purge(purge) => builder.push_child(purge.clone()),
+            Pubsub::Subscriptions(subscriptions) => builder.push_child(subscriptions.clone()),
+        }
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct Affiliations {
+    node: String,
+    affiliations: Vec<Affiliation>,
+}
+
+impl FromElement for Affiliations {
+    fn from_element(mut element: Element) -> peanuts::element::DeserializeResult<Self> {
+        element.check_name("affiliations")?;
+        element.check_namespace(XMLNS)?;
+
+        let node = element.attribute("node")?;
+
+        let affiliations = element.pop_children()?;
+
+        Ok(Self { node, affiliations })
+    }
+}
+
+impl IntoElement for Affiliations {
+    fn builder(&self) -> peanuts::element::ElementBuilder {
+        Element::builder("affiliations", Some(XMLNS))
+            .push_attribute("node", self.node.clone())
+            .push_children(self.affiliations.clone())
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct Affiliation {
+    affiliation: AffiliationType,
+    jid: JID,
+}
+
+impl FromElement for Affiliation {
+    fn from_element(mut element: Element) -> peanuts::element::DeserializeResult<Self> {
+        element.check_name("affiliation")?;
+        element.check_namespace(XMLNS)?;
+
+        let affiliation = element.attribute("affiliation")?;
+        let jid = element.attribute("jid")?;
+
+        Ok(Self { affiliation, jid })
+    }
+}
+
+impl IntoElement for Affiliation {
+    fn builder(&self) -> peanuts::element::ElementBuilder {
+        Element::builder("affiliation", Some(XMLNS))
+            .push_attribute("affiliation", self.affiliation.clone())
+            .push_attribute("jid", self.jid.clone())
+    }
+}
+
+#[derive(Clone, Debug)]
+pub enum AffiliationType {
+    Member,
+    None,
+    Outcast,
+    Owner,
+    Publisher,
+    PublishOnly,
+}
+
+impl FromStr for AffiliationType {
+    type Err = DeserializeError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s {
+            "member" => Ok(Self::Member),
+            "none" => Ok(Self::None),
+            "outcast" => Ok(Self::Outcast),
+            "owner" => Ok(Self::Owner),
+            "publisher" => Ok(Self::Publisher),
+            "publish-only" => Ok(Self::PublishOnly),
+            s => Err(DeserializeError::FromStr(s.to_owned())),
+        }
+    }
+}
+
+impl ToString for AffiliationType {
+    fn to_string(&self) -> String {
+        match self {
+            AffiliationType::Member => "member",
+            AffiliationType::None => "none",
+            AffiliationType::Outcast => "outcast",
+            AffiliationType::Owner => "owner",
+            AffiliationType::Publisher => "publisher",
+            AffiliationType::PublishOnly => "publish-only",
+        }
+        .to_owned()
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct Configure {
+    node: Option<String>,
+    configure: Option<X>,
+}
+
+impl FromElement for Configure {
+    fn from_element(mut element: Element) -> peanuts::element::DeserializeResult<Self> {
+        element.check_name("configure")?;
+        element.check_namespace(XMLNS)?;
+
+        let node = element.attribute_opt("node")?;
+
+        let configure = element.pop_child_opt()?;
+
+        Ok(Self { node, configure })
+    }
+}
+
+impl IntoElement for Configure {
+    fn builder(&self) -> peanuts::element::ElementBuilder {
+        Element::builder("configure", Some(XMLNS))
+            .push_attribute_opt("node", self.node.clone())
+            .push_child_opt(self.configure.clone())
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct Default(Option<X>);
+
+impl FromElement for Default {
+    fn from_element(mut element: Element) -> peanuts::element::DeserializeResult<Self> {
+        element.check_name("default")?;
+        element.check_namespace(XMLNS)?;
+
+        Ok(Self(element.pop_child_opt()?))
+    }
+}
+
+impl IntoElement for Default {
+    fn builder(&self) -> peanuts::element::ElementBuilder {
+        Element::builder("default", Some(XMLNS)).push_child_opt(self.0.clone())
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct Delete {
+    node: String,
+    redirect: Option<Redirect>,
+}
+
+impl FromElement for Delete {
+    fn from_element(mut element: Element) -> peanuts::element::DeserializeResult<Self> {
+        element.check_name("delete")?;
+        element.check_namespace(XMLNS)?;
+
+        let node = element.attribute("node")?;
+
+        let redirect = element.pop_child_opt()?;
+
+        Ok(Self { node, redirect })
+    }
+}
+
+impl IntoElement for Delete {
+    fn builder(&self) -> peanuts::element::ElementBuilder {
+        Element::builder("delete", Some(XMLNS))
+            .push_attribute("node", self.node.clone())
+            .push_child_opt(self.redirect.clone())
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct Purge {
+    node: String,
+}
+
+impl FromElement for Purge {
+    fn from_element(mut element: Element) -> peanuts::element::DeserializeResult<Self> {
+        element.check_name("purge")?;
+        element.check_namespace(XMLNS)?;
+
+        let node = element.attribute("node")?;
+
+        Ok(Self { node })
+    }
+}
+
+impl IntoElement for Purge {
+    fn builder(&self) -> peanuts::element::ElementBuilder {
+        Element::builder("purge", Some(XMLNS)).push_attribute("node", self.node.clone())
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct Redirect {
+    uri: String,
+}
+
+impl FromElement for Redirect {
+    fn from_element(mut element: Element) -> peanuts::element::DeserializeResult<Self> {
+        element.check_name("redirect")?;
+        element.check_namespace(XMLNS)?;
+
+        let uri = element.attribute("uri")?;
+
+        Ok(Self { uri })
+    }
+}
+
+impl IntoElement for Redirect {
+    fn builder(&self) -> peanuts::element::ElementBuilder {
+        Element::builder("redirect", Some(XMLNS)).push_attribute("uri", self.uri.clone())
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct Subscriptions {
+    node: String,
+    subscriptions: Vec<Subscription>,
+}
+
+impl FromElement for Subscriptions {
+    fn from_element(mut element: Element) -> peanuts::element::DeserializeResult<Self> {
+        element.check_name("subscriptions")?;
+        element.check_namespace(XMLNS)?;
+
+        let node = element.attribute("node")?;
+
+        let subscriptions = element.pop_children()?;
+
+        Ok(Self {
+            node,
+            subscriptions,
+        })
+    }
+}
+
+impl IntoElement for Subscriptions {
+    fn builder(&self) -> peanuts::element::ElementBuilder {
+        Element::builder("subscriptions", Some(XMLNS))
+            .push_attribute("node", self.node.clone())
+            .push_children(self.subscriptions.clone())
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct Subscription {
+    subscription: SubscriptionState,
+    jid: JID,
+}
+
+impl FromElement for Subscription {
+    fn from_element(mut element: Element) -> peanuts::element::DeserializeResult<Self> {
+        element.check_name("subscription")?;
+        element.check_namespace(XMLNS)?;
+
+        let subscription = element.attribute("subscription")?;
+        let jid = element.attribute("jid")?;
+
+        Ok(Self { subscription, jid })
+    }
+}
+
+impl IntoElement for Subscription {
+    fn builder(&self) -> peanuts::element::ElementBuilder {
+        Element::builder("subscription", Some(XMLNS))
+            .push_attribute("subscription", self.subscription.clone())
+            .push_attribute("jid", self.jid.clone())
+    }
+}
+
+#[derive(Clone, Debug)]
+pub enum SubscriptionState {
+    None,
+    Pending,
+    Subscribed,
+    Unconfigured,
+}
+
+impl FromStr for SubscriptionState {
+    type Err = DeserializeError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s {
+            "none" => Ok(Self::None),
+            "pending" => Ok(Self::Pending),
+            "subscribed" => Ok(Self::Subscribed),
+            "unconfigured" => Ok(Self::Unconfigured),
+            s => Err(DeserializeError::FromStr(s.to_owned())),
+        }
+    }
+}
+
+impl ToString for SubscriptionState {
+    fn to_string(&self) -> String {
+        match self {
+            SubscriptionState::None => "none",
+            SubscriptionState::Pending => "pending",
+            SubscriptionState::Subscribed => "subscribed",
+            SubscriptionState::Unconfigured => "unconfigured",
+        }
+        .to_owned()
+    }
+}