rework handshakemessage parsing

1 files changed, 119 insertions, 0 deletions

diff --git a/src/message/signalproxy/objects/identity.rs b/src/message/signalproxy/objects/identity.rs
new file mode 100644
index 0000000..a710e5d
--- /dev/null
+++ b/src/message/signalproxy/objects/identity.rs
@@ -0,0 +1,119 @@
+use crate::primitive::{Variant, VariantMap};
+
+#[derive(Debug, Clone)]
+pub struct Identity {
+    identity_id: i32,
+    identity_name: String,
+    real_name: String,
+    nicks: Vec<String>,
+    away_nick: String,
+    away_nick_enabled: bool,
+    away_reason: String,
+    away_reason_enabled: bool,
+    auto_away_enabled: bool,
+    auto_away_time: i32,
+    auto_away_reason: String,
+    auto_away_reason_enabled: bool,
+    detach_away_enabled: bool,
+    detach_away_reason: String,
+    detach_away_reason_enabled: bool,
+    ident: String,
+    kick_reason: String,
+    part_reason: String,
+    quit_reason: String,
+}
+
+impl From<VariantMap> for Identity {
+    fn from(input: VariantMap) -> Self {
+        Identity {
+            identity_id: match_variant!(input.get("identityId").unwrap(), Variant::i32),
+            identity_name: match_variant!(input.get("identityName").unwrap(), Variant::String),
+            real_name: match_variant!(input.get("realName").unwrap(), Variant::String),
+            nicks: match_variant!(input.get("nicks").unwrap(), Variant::StringList),
+            away_nick: match_variant!(input.get("awayNick").unwrap(), Variant::String),
+            away_nick_enabled: match_variant!(input.get("awayNickEnabled").unwrap(), Variant::bool),
+            away_reason: match_variant!(input.get("awayReason").unwrap(), Variant::String),
+            away_reason_enabled: match_variant!(
+                input.get("awayReasonEnabled").unwrap(),
+                Variant::bool
+            ),
+            auto_away_enabled: match_variant!(input.get("autoAwayEnabled").unwrap(), Variant::bool),
+            auto_away_time: match_variant!(input.get("autoAwayTime").unwrap(), Variant::i32),
+            auto_away_reason: match_variant!(input.get("autoAwayReason").unwrap(), Variant::String),
+            auto_away_reason_enabled: match_variant!(
+                input.get("autoAwayReasonEnabled").unwrap(),
+                Variant::bool
+            ),
+            detach_away_enabled: match_variant!(
+                input.get("detachAwayEnabled").unwrap(),
+                Variant::bool
+            ),
+            detach_away_reason: match_variant!(
+                input.get("detachAwayReason").unwrap(),
+                Variant::String
+            ),
+            detach_away_reason_enabled: match_variant!(
+                input.get("detachAwayReasonEnabled").unwrap(),
+                Variant::bool
+            ),
+            ident: match_variant!(input.get("ident").unwrap(), Variant::String),
+            kick_reason: match_variant!(input.get("kickReason").unwrap(), Variant::String),
+            part_reason: match_variant!(input.get("partReason").unwrap(), Variant::String),
+            quit_reason: match_variant!(input.get("quitReason").unwrap(), Variant::String),
+        }
+    }
+}
+
+impl Into<std::collections::HashMap<String, Variant>> for Identity {
+    fn into(self) -> VariantMap {
+        let mut res = VariantMap::with_capacity(19);
+
+        res.insert("identityId".to_string(), Variant::i32(self.identity_id));
+        res.insert(
+            "identityName".to_string(),
+            Variant::String(self.identity_name),
+        );
+        res.insert("realName".to_string(), Variant::String(self.real_name));
+        res.insert("nicks".to_string(), Variant::StringList(self.nicks));
+        res.insert("awayNick".to_string(), Variant::String(self.away_nick));
+        res.insert(
+            "awayNickEnabled".to_string(),
+            Variant::bool(self.away_nick_enabled),
+        );
+        res.insert("awayReason".to_string(), Variant::String(self.away_reason));
+        res.insert(
+            "awayReasonEnabled".to_string(),
+            Variant::bool(self.away_reason_enabled),
+        );
+        res.insert(
+            "autoAwayEnabled".to_string(),
+            Variant::bool(self.auto_away_enabled),
+        );
+        res.insert(
+            "autoAwayTime".to_string(),
+            Variant::i32(self.auto_away_time),
+        );
+        res.insert(
+            "autoAwayReason".to_string(),
+            Variant::String(self.auto_away_reason),
+        );
+        res.insert(
+            "detachAwayEnabled".to_string(),
+            Variant::bool(self.detach_away_enabled),
+        );
+        res.insert(
+            "detachAwayReason".to_string(),
+            Variant::String(self.detach_away_reason),
+        );
+        res.insert(
+            "detachAwayReasonEnabled".to_string(),
+            Variant::bool(self.detach_away_reason_enabled),
+        );
+        res.insert("ident".to_string(), Variant::String(self.ident));
+        res.insert("kickReason".to_string(), Variant::String(self.kick_reason));
+        res.insert("partReason".to_string(), Variant::String(self.part_reason));
+        res.insert("quitReason".to_string(), Variant::String(self.quit_reason));
+
+        res
+    }
+}