diff options
Diffstat (limited to 'src/message/signalproxy/objects')
| -rw-r--r-- | src/message/signalproxy/objects/aliasmanager.rs | 156 | ||||
| -rw-r--r-- | src/message/signalproxy/objects/ircchannel.rs | 289 | ||||
| -rw-r--r-- | src/message/signalproxy/objects/ircuser.rs | 201 | ||||
| -rw-r--r-- | src/message/signalproxy/objects/mod.rs | 6 | ||||
| -rw-r--r-- | src/message/signalproxy/objects/network.rs | 369 | ||||
| -rw-r--r-- | src/message/signalproxy/objects/networkinfo.rs | 169 |
6 files changed, 1162 insertions, 28 deletions
diff --git a/src/message/signalproxy/objects/aliasmanager.rs b/src/message/signalproxy/objects/aliasmanager.rs index 828caaa..b816778 100644 --- a/src/message/signalproxy/objects/aliasmanager.rs +++ b/src/message/signalproxy/objects/aliasmanager.rs @@ -1,4 +1,6 @@ -use crate::primitive::{Variant, VariantMap}; +use crate::primitive::{StringList, Variant, VariantList, VariantMap}; + +use crate::message::signalproxy::Network; #[derive(Clone, Debug, std::cmp::PartialEq)] pub struct AliasManager { @@ -11,36 +13,134 @@ pub struct Alias { expansion: String, } -impl AliasManager { - /// Client to Server - /// - /// Replaces all properties of the object with the content of the - /// "properties" parameter. This parameter is in network representation. - /// - fn request_update(self: &mut Self, properties: VariantMap) { - self.update(properties); +impl Network for AliasManager { + type Item = VariantList; + + fn to_network(&self) -> VariantList { + let mut res = VariantList::new(); + + res.push(Variant::ByteArray(s!("Aliases"))); + + let (names, expansions) = self.aliases.iter().fold( + (StringList::new(), StringList::new()), + |(mut names, mut expansions), alias| { + names.push(alias.name.clone()); + expansions.push(alias.expansion.clone()); + return (names, expansions); + }, + ); + + let mut map = VariantMap::new(); + map.insert(s!("names"), Variant::StringList(names)); + map.insert(s!("expansions"), Variant::StringList(expansions)); + + res.push(Variant::VariantMap(map)); + + return res; + } + + fn from_network(input: crate::primitive::VariantList) -> Self { + let input = match &input[1] { + Variant::VariantMap(input) => input, + _ => unimplemented!(), + }; + + let names = match_variant!(input.get("names").unwrap(), Variant::StringList); + let expansions = match_variant!(input.get("expansions").unwrap(), Variant::StringList); + + AliasManager { + aliases: names + .iter() + .zip(expansions) + .map(|(name, expansion)| Alias { + name: name.clone(), + expansion, + }) + .collect(), + } + } +} + +#[cfg(test)] +mod tests { + use super::*; + + fn get_src() -> AliasManager { + AliasManager { + aliases: vec![ + Alias { + name: s!("j"), + expansion: s!("/join $0"), + }, + Alias { + name: s!("ns"), + expansion: s!("/msg nickserv $0"), + }, + ], + } + } + + fn get_dest() -> VariantList { + vec![ + Variant::ByteArray(s!("Aliases")), + Variant::VariantMap(map! { + s!("names") => Variant::StringList( + vec![ + s!("j"), + s!("ns"), + ], + ), + s!("expansions") => Variant::StringList( + vec![ + s!("/join $0"), + s!("/msg nickserv $0"), + ], + ), + }), + ] } - /// Server to Client - fn add_alias(self: &mut Self, name: String, expansion: String) { - self.aliases.push(Alias { name, expansion }); + #[test] + fn aliasmanager_to_network() { + assert_eq!(get_src().to_network(), get_dest()) } - /// Server to Client - /// - /// Replaces all properties of the object with the content of the - /// "properties" parameter. This parameter is in network representation. - /// - fn update(self: &mut Self, properties: VariantMap) { - let mut alias: Vec<Alias> = Vec::new(); - - // for (i, name) in match_variant!(properties[&"Aliases".to_string()], Variant::String) { - // alias.push(Alias { - // name, - // expansion: match_variant!(properties["Aliases"], Variant::String)["expansions"][i], - // }) - // } - - self.aliases = alias + #[test] + fn aliasmanager_from_network() { + assert_eq!(AliasManager::from_network(get_dest()), get_src()) } } + +// impl AliasManager { +// /// Client to Server +// /// +// /// Replaces all properties of the object with the content of the +// /// "properties" parameter. This parameter is in network representation. +// /// +// fn request_update(self: &mut Self, properties: VariantMap) { +// self.update(properties); +// } + +// /// Server to Client +// fn add_alias(self: &mut Self, name: String, expansion: String) { +// self.aliases.push(Alias { name, expansion }); +// } + +// /// Server to Client +// /// +// /// Replaces all properties of the object with the content of the +// /// "properties" parameter. This parameter is in network representation. +// /// +// fn update(self: &mut Self, properties: VariantMap) { +// let mut alias: Vec<Alias> = Vec::new(); + +// // for (i, name) in match_variant!(properties[&"Aliases".to_string()], Variant::String) { +// // alias.push(Alias { +// // name, +// // expansion: match_variant!(properties["Aliases"], Variant::String)["expansions"][i], +// // }) +// // } + +// self.aliases = alias +// } +// } diff --git a/src/message/signalproxy/objects/ircchannel.rs b/src/message/signalproxy/objects/ircchannel.rs new file mode 100644 index 0000000..cd5cd3e --- /dev/null +++ b/src/message/signalproxy/objects/ircchannel.rs @@ -0,0 +1,289 @@ +use std::collections::HashMap; + +use crate::primitive::{StringList, Variant, VariantMap}; + +#[allow(unused_imports)] +use crate::message::signalproxy::Network; + +#[allow(dead_code)] +#[derive(Debug, Clone, PartialEq)] +pub struct IrcChannel { + channel_modes_a: HashMap<char, StringList>, + channel_modes_b: HashMap<char, String>, + channel_modes_c: HashMap<char, String>, + channel_modes_d: String, + user_modes: HashMap<String, String>, + name: String, + topic: String, + password: String, + encrypted: bool, +} + +impl Network for IrcChannel { + type Item = VariantMap; + + fn to_network(&self) -> Self::Item { + let mut res = VariantMap::new(); + + res.insert( + s!("ChanModes"), + Variant::VariantList({ + let mut map = VariantMap::new(); + + map.insert( + s!("A"), + Variant::VariantMap( + self.channel_modes_a + .iter() + .map(|(k, v)| (k.to_string(), Variant::StringList(v.clone()))) + .collect(), + ), + ); + map.insert( + s!("B"), + Variant::VariantMap( + self.channel_modes_b + .iter() + .map(|(k, v)| (k.to_string(), Variant::String(v.clone()))) + .collect(), + ), + ); + map.insert( + s!("C"), + Variant::VariantMap( + self.channel_modes_c + .iter() + .map(|(k, v)| (k.to_string(), Variant::String(v.clone()))) + .collect(), + ), + ); + map.insert(s!("D"), Variant::String(self.channel_modes_d.clone())); + + vec![Variant::VariantMap(map)] + }), + ); + + res.insert( + s!("UserModes"), + Variant::VariantList(vec![Variant::VariantMap( + self.user_modes + .iter() + .map(|(k, v)| (k.clone(), Variant::String(v.clone()))) + .collect(), + )]), + ); + res.insert( + s!("name"), + Variant::VariantList(vec![Variant::String(self.name.clone())]), + ); + res.insert( + s!("topic"), + Variant::VariantList(vec![Variant::String(self.topic.clone())]), + ); + res.insert( + s!("password"), + Variant::VariantList(vec![Variant::String(self.password.clone())]), + ); + res.insert( + s!("encrypted"), + Variant::VariantList(vec![Variant::bool(self.encrypted.clone())]), + ); + + res + } + fn from_network(input: Self::Item) -> Self { + Self { + channel_modes_a: match_variant!( + match_variant!( + match_variant!(input.get("ChanModes").unwrap(), Variant::VariantList)[0], + Variant::VariantMap + ) + .get("B") + .unwrap(), + Variant::VariantMap + ) + .iter() + .map(|(k, v)| { + ( + k.chars().nth(0).unwrap(), + match_variant!(v, Variant::StringList), + ) + }) + .collect(), + channel_modes_b: match_variant!( + match_variant!( + match_variant!(input.get("ChanModes").unwrap(), Variant::VariantList)[0], + Variant::VariantMap + ) + .get("B") + .unwrap(), + Variant::VariantMap + ) + .iter() + .map(|(k, v)| { + ( + k.chars().nth(0).unwrap(), + match_variant!(v, Variant::String), + ) + }) + .collect(), + channel_modes_c: match_variant!( + match_variant!( + match_variant!(input.get("ChanModes").unwrap(), Variant::VariantList)[0], + Variant::VariantMap + ) + .get("C") + .unwrap(), + Variant::VariantMap + ) + .iter() + .map(|(k, v)| { + ( + k.chars().nth(0).unwrap(), + match_variant!(v, Variant::String), + ) + }) + .collect(), + channel_modes_d: match_variant!( + match_variant!( + match_variant!(input.get("ChanModes").unwrap(), Variant::VariantList)[0], + Variant::VariantMap + ) + .get("D") + .unwrap(), + Variant::String + ), + user_modes: match_variant!( + match_variant!(input.get("UserModes").unwrap(), Variant::VariantList)[0], + Variant::VariantMap + ) + .iter() + .map(|(k, v)| (k.clone(), match_variant!(v, Variant::String))) + .collect(), + name: match_variant!( + match_variant!(input.get("name").unwrap(), Variant::VariantList)[0], + Variant::String + ), + topic: match_variant!( + match_variant!(input.get("topic").unwrap(), Variant::VariantList)[0], + Variant::String + ), + password: match_variant!( + match_variant!(input.get("password").unwrap(), Variant::VariantList)[0], + Variant::String + ), + encrypted: match_variant!( + match_variant!(input.get("encrypted").unwrap(), Variant::VariantList)[0], + Variant::bool + ), + } + } +} + +#[cfg(test)] +mod tests { + use super::*; + + fn get_network() -> VariantMap { + VariantMap::from(map! { + s!("encrypted") => Variant::VariantList( + vec![ + Variant::bool( + false, + ), + ], + ), + s!("topic") => Variant::VariantList( + vec![ + Variant::String( + s!(""), + ), + ], + ), + s!("password") => Variant::VariantList( + vec![ + Variant::String( + s!(""), + ), + ], + ), + s!("ChanModes") => Variant::VariantList( + vec![ + Variant::VariantMap(map! + { + s!("B") => Variant::VariantMap(map! + {}, + ), + s!("D") => Variant::String( + s!("tCnT"), + ), + s!("C") => Variant::VariantMap(map! + { + s!("j") => Variant::String( + s!("5:1"), + ), + s!("x") => Variant::String( + s!("10:5"), + ), + s!("f") => Variant::String( + s!("30:5"), + ), + s!("F") => Variant::String( + s!("5:60"), + ), + }, + ), + s!("A") => Variant::VariantMap(map! + {}, + ), + }, + ), + ], + ), + s!("UserModes") => Variant::VariantList( + vec![ + Variant::VariantMap(map! + { + s!("audron") => Variant::String( + s!("o"), + ), + s!("audron_") => Variant::String( + s!(""), + ), + }, + ), + ], + ), + s!("name") => Variant::VariantList( + vec![ + Variant::String( + s!("#audron-test"), + ), + ], + ) + }) + } + fn get_runtime() -> IrcChannel { + IrcChannel { + channel_modes_a: map! {}, + channel_modes_b: map! {}, + channel_modes_c: map! { 'j' => s!("5:1"), 'x' => s!("10:5"), 'f' => s!("30:5"), 'F' => s!("5:60") }, + channel_modes_d: s!("tCnT"), + user_modes: map! { s!("audron") => s!("o"), s!("audron_") => s!("") }, + name: s!("#audron-test"), + topic: s!(""), + password: s!(""), + encrypted: false, + } + } + + #[test] + fn ircchannel_to_network() { + assert_eq!(get_runtime().to_network(), get_network()) + } + + #[test] + fn ircchannel_from_network() { + assert_eq!(IrcChannel::from_network(get_network()), get_runtime()) + } +} diff --git a/src/message/signalproxy/objects/ircuser.rs b/src/message/signalproxy/objects/ircuser.rs new file mode 100644 index 0000000..0ce597f --- /dev/null +++ b/src/message/signalproxy/objects/ircuser.rs @@ -0,0 +1,201 @@ +use crate::primitive::{DateTime, StringList}; + +#[allow(unused_imports)] +use crate::message::signalproxy::Network; +use libquassel_derive::Network; + +#[allow(dead_code)] +#[derive(Debug, Clone, PartialEq, Network)] +#[network(repr = "maplist")] +pub struct IrcUser { + user: String, + host: String, + nick: String, + #[network(rename = "realName")] + real_name: String, + account: String, + away: bool, + #[network(rename = "awayMessage")] + away_message: String, + #[network(rename = "idleTime")] + idle_time: DateTime, + #[network(rename = "loginTime")] + login_time: DateTime, + server: String, + #[network(rename = "ircOperator")] + irc_operator: String, + #[network(rename = "lastAwayMessageTime")] + last_away_message_time: DateTime, + #[network(rename = "whoisServiceReply")] + whois_service_reply: String, + #[network(rename = "suserHost")] + suser_host: String, + encrypted: bool, + channels: StringList, + #[network(rename = "userModes")] + user_modes: String, +} + +#[cfg(test)] +mod tests { + use crate::primitive::{Variant, VariantMap}; + use time::OffsetDateTime; + + use super::*; + + fn get_runtime() -> IrcUser { + IrcUser { + user: s!("NickServ"), + host: s!("services"), + nick: s!("NickServ"), + real_name: s!(""), + account: s!(""), + away: false, + away_message: s!(""), + idle_time: OffsetDateTime::unix_epoch(), + login_time: OffsetDateTime::unix_epoch(), + server: s!(""), + irc_operator: s!(""), + last_away_message_time: OffsetDateTime::unix_epoch(), + whois_service_reply: s!(""), + suser_host: s!(""), + encrypted: false, + channels: StringList::new(), + user_modes: s!(""), + } + } + + fn get_network() -> VariantMap { + map! { + s!("suserHost") => Variant::VariantList(vec! + [ + Variant::String( + s!(""), + ), + ], + ), + s!("lastAwayMessageTime") => Variant::VariantList(vec! + [ + Variant::DateTime( + OffsetDateTime::unix_epoch() , + ), + ], + ), + s!("away") => Variant::VariantList(vec! + [ + Variant::bool( + false, + ), + ], + ), + s!("ircOperator") => Variant::VariantList(vec! + [ + Variant::String( + s!(""), + ), + ], + ), + s!("account") => Variant::VariantList(vec! + [ + Variant::String( + s!(""), + ), + ], + ), + s!("loginTime") => Variant::VariantList(vec! + [ + Variant::DateTime( + OffsetDateTime::unix_epoch() + ), + ], + ), + s!("userModes") => Variant::VariantList(vec! + [ + Variant::String( + s!(""), + ), + ], + ), + s!("host") => Variant::VariantList(vec! + [ + Variant::String( + s!("services"), + ), + ], + ), + s!("whoisServiceReply") => Variant::VariantList(vec! + [ + Variant::String( + s!(""), + ), + ], + ), + s!("channels") => Variant::VariantList(vec! + [ + Variant::StringList(vec! + [], + ), + ], + ), + s!("realName") => Variant::VariantList(vec! + [ + Variant::String( + s!(""), + ), + ], + ), + s!("nick") => Variant::VariantList(vec! + [ + Variant::String( + s!("NickServ"), + ), + ], + ), + s!("idleTime") => Variant::VariantList(vec! + [ + Variant::DateTime( + OffsetDateTime::unix_epoch() + ), + ], + ), + s!("encrypted") => Variant::VariantList(vec! + [ + Variant::bool( + false, + ), + ], + ), + s!("awayMessage") => Variant::VariantList(vec! + [ + Variant::String( + s!(""), + ), + ], + ), + s!("user") => Variant::VariantList(vec! + [ + Variant::String( + s!("NickServ"), + ), + ], + ), + s!("server") => Variant::VariantList(vec! + [ + Variant::String( + s!(""), + ), + ], + ), + } + } + + #[test] + fn ircuser_to_network() { + assert_eq!(get_runtime().to_network(), get_network()) + } + + #[test] + fn ircuser_from_network() { + assert_eq!(IrcUser::from_network(get_network()), get_runtime()) + } +} diff --git a/src/message/signalproxy/objects/mod.rs b/src/message/signalproxy/objects/mod.rs index a84f6fa..a313312 100644 --- a/src/message/signalproxy/objects/mod.rs +++ b/src/message/signalproxy/objects/mod.rs @@ -1,9 +1,15 @@ // mod aliasmanager; // mod backlogmanager; +mod aliasmanager; mod buffersyncer; mod identity; +mod ircchannel; +mod ircuser; +mod network; +mod networkinfo; +pub use aliasmanager::*; pub use buffersyncer::*; pub use identity::*; diff --git a/src/message/signalproxy/objects/network.rs b/src/message/signalproxy/objects/network.rs new file mode 100644 index 0000000..cb1edd2 --- /dev/null +++ b/src/message/signalproxy/objects/network.rs @@ -0,0 +1,369 @@ +use crate::primitive::{StringList, Variant, VariantList, VariantMap}; + +#[allow(unused_imports)] +use libquassel_derive::Network; + +use std::collections::HashMap; + +use num_derive::{FromPrimitive, ToPrimitive}; +use num_traits::{FromPrimitive, ToPrimitive}; + +use super::{ircchannel::IrcChannel, ircuser::IrcUser, networkinfo::NetworkInfo}; + +#[derive(Debug, Clone)] +pub struct Network { + my_nick: String, + latency: i32, + current_server: String, + is_connected: bool, + connection_state: ConnectionState, + // prefixes: Vec<char>, + // prefix_modes: Vec<char>, + // channel_modes: HashMap<ChannelModeType, Vec<char>>, + irc_users: HashMap<String, IrcUser>, + irc_channels: HashMap<String, IrcChannel>, + supports: HashMap<String, String>, + caps: HashMap<String, String>, + caps_enabled: Vec<String>, + network_info: NetworkInfo, +} + +// impl crate::message::signalproxy::Network for Network { +// type Item = VariantList; + +// fn to_network(&self) -> Self::Item { +// let mut res = Self::Item::new(); + +// res.push(Variant::ByteArray(s!("myNick"))); +// res.push(Variant::String(self.my_nick.clone())); +// res.push(Variant::ByteArray(s!("latency"))); +// res.push(Variant::i32(self.latency)); +// res.push(Variant::ByteArray(s!("currentServer"))); +// res.push(Variant::String(self.current_server.clone())); +// res.push(Variant::ByteArray(s!("isConnected"))); +// res.push(Variant::bool(self.is_connected)); +// res.push(Variant::ByteArray(s!("connectionState"))); +// res.push(Variant::i32(self.connection_state.clone() as i32)); + +// res.push(Variant::ByteArray(s!("Supports"))); +// res.push(Variant::VariantMap( +// self.supports +// .iter() +// .map(|(k, v)| (k.clone(), Variant::String(v.clone()))) +// .collect(), +// )); + +// res.push(Variant::ByteArray(s!("Caps"))); +// res.push(Variant::VariantMap( +// self.caps +// .iter() +// .map(|(k, v)| (k.clone(), Variant::String(v.clone()))) +// .collect(), +// )); + +// res.push(Variant::ByteArray(s!("CapsEnabled"))); +// res.push(Variant::VariantList( +// self.caps_enabled +// .iter() +// .map(|v| Variant::String(v.clone())) +// .collect(), +// )); + +// { +// let mut map = VariantMap::new(); + +// map.insert( +// s!("Users"), +// Variant::VariantMap(self.irc_users.iter().fold( +// HashMap::new(), +// |mut res, (_, v)| { +// res.extend(v.to_network()); + +// res +// }, +// )), +// ); + +// let channels = self +// .irc_channels +// .iter() +// .fold(HashMap::new(), |mut res, (_, v)| { +// res.extend(v.to_network()); + +// res +// }); + +// map.insert(s!("Channels"), Variant::VariantMap(channels)); + +// res.push(Variant::ByteArray(s!("IrcUsersAndChannels"))); +// res.push(Variant::VariantMap(map)); +// } + +// res.extend(self.network_info.to_network()); + +// res +// } + +// fn from_network(input: Self::Item) -> Self { +// let users_and_channels = match_variant!( +// input +// .iter() +// .nth( +// input +// .iter() +// .position(|x| *x == Variant::ByteArray(s!("IrcUsersAndChannels"))) +// .unwrap() +// ) +// .unwrap(), +// Variant::VariantMap +// ); + +// let res = Self { +// my_nick: match_variant!( +// input +// .iter() +// .nth( +// input +// .iter() +// .position(|x| *x == Variant::ByteArray(s!("myNick"))) +// .unwrap() +// ) +// .unwrap(), +// Variant::String +// ), +// latency: match_variant!( +// input +// .iter() +// .nth( +// input +// .iter() +// .position(|x| *x == Variant::ByteArray(s!("latency"))) +// .unwrap() +// ) +// .unwrap(), +// Variant::i32 +// ), +// current_server: match_variant!( +// input +// .iter() +// .nth( +// input +// .iter() +// .position(|x| *x == Variant::ByteArray(s!("currentServer"))) +// .unwrap() +// ) +// .unwrap(), +// Variant::String +// ), +// is_connected: match_variant!( +// input +// .iter() +// .nth( +// input +// .iter() +// .position(|x| *x == Variant::ByteArray(s!("isConnected"))) +// .unwrap() +// ) +// .unwrap(), +// Variant::bool +// ), +// connection_state: ConnectionState::from_i32(match_variant!( +// input +// .iter() +// .nth( +// input +// .iter() +// .position(|x| *x == Variant::ByteArray(s!("connectionState"))) +// .unwrap() +// ) +// .unwrap(), +// Variant::i32 +// )) +// .unwrap(), +// irc_users: match_variant!( +// users_and_channels.get("Users").unwrap(), +// Variant::VariantMap +// ) +// .iter() +// .map(|(k, v)| (k, IrcUser::from_network(v))), +// irc_channels: match_variant!( +// users_and_channels.get("Channels").unwrap(), +// Variant::VariantMap +// ) +// .iter() +// .map(|(k, v)| (k, match_variant!(v, Variant::VariantList))), +// supports: match_variant!( +// input +// .iter() +// .nth( +// input +// .iter() +// .position(|x| *x == Variant::ByteArray(s!("Supports"))) +// .unwrap() +// ) +// .unwrap(), +// Variant::VariantMap +// ) +// .iter() +// .map(|(k, v)| (k.clone(), match_variant!(v, Variant::String))) +// .collect(), +// caps: match_variant!( +// input +// .iter() +// .nth( +// input +// .iter() +// .position(|x| *x == Variant::ByteArray(s!("Caps"))) +// .unwrap() +// ) +// .unwrap(), +// Variant::VariantMap +// ) +// .iter() +// .map(|(k, v)| (k.clone(), match_variant!(v, Variant::String))) +// .collect(), +// caps_enabled: match_variant!( +// input +// .iter() +// .nth( +// input +// .iter() +// .position(|x| *x == Variant::ByteArray(s!("CapsEnabled"))) +// .unwrap() +// ) +// .unwrap(), +// Variant::VariantList +// ) +// .iter() +// .map(|v| match_variant!(v, Variant::String)) +// .collect(), +// network_info: NetworkInfo::from_network(input), +// }; + +// todo!() +// } +// } + +#[allow(dead_code)] +#[derive(Debug, Clone, PartialEq, Network)] +#[network(repr = "map")] +pub struct NetworkServer { + #[network(rename = "Host")] + pub host: String, + #[network(rename = "Port")] + pub port: u32, + #[network(rename = "Password")] + pub password: String, + #[network(rename = "UseSSL")] + pub use_ssl: bool, + #[network(rename = "sslVerify")] + pub ssl_verify: bool, + #[network(rename = "sslVersion")] + pub ssl_version: i32, + #[network(rename = "UseProxy")] + pub use_proxy: bool, + #[network(rename = "ProxyType")] + pub proxy_type: i32, + #[network(rename = "ProxyHost")] + pub proxy_host: String, + #[network(rename = "ProxyPort")] + pub proxy_port: u32, + #[network(rename = "ProxyUser")] + pub proxy_user: String, + #[network(rename = "ProxyPass")] + pub proxy_pass: String, +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::message::signalproxy::translation::Network; + + fn networkserver_get_network() -> VariantMap { + map! { + s!("ProxyHost") => Variant::String( + s!("localhost"), + ), + s!("sslVerify") => Variant::bool( + true, + ), + s!("UseSSL") => Variant::bool( + true, + ), + s!("Port") => Variant::u32( + 6697, + ), + s!("Password") => Variant::String( + s!(""), + ), + s!("ProxyType") => Variant::i32( + 1, + ), + s!("sslVersion") => Variant::i32( + 0, + ), + s!("ProxyUser") => Variant::String( + s!(""), + ), + s!("ProxyPass") => Variant::String( + s!(""), + ), + s!("Host") => Variant::String( + s!("irc.snoonet.org"), + ), + s!("ProxyPort") => Variant::u32( + 8080, + ), + s!("UseProxy") => Variant::bool( + false, + ), + } + } + fn networkserver_get_runtime() -> NetworkServer { + NetworkServer { + host: s!("irc.snoonet.org"), + port: 6697, + password: s!(""), + use_ssl: true, + ssl_verify: true, + ssl_version: 0, + use_proxy: false, + proxy_type: 1, + proxy_host: s!("localhost"), + proxy_port: 8080, + proxy_user: s!(""), + proxy_pass: s!(""), + } + } + + #[test] + fn network_server_to_network() { + assert_eq!( + networkserver_get_runtime().to_network(), + networkserver_get_network() + ) + } +} + +#[allow(dead_code)] +#[derive(Debug, Clone, PartialEq, FromPrimitive, ToPrimitive)] +#[repr(C)] +enum ConnectionState { + Disconnected = 0x00, + Connecting = 0x01, + Initializing = 0x02, + Initialized = 0x03, + Reconnecting = 0x04, + Disconnecting = 0x05, +} + +#[allow(dead_code)] +#[derive(Debug, Clone, PartialEq, FromPrimitive, ToPrimitive)] +#[repr(C)] +enum ChannelModeType { + NotAChanmode = 0x00, + AChanmode = 0x01, + BChanmode = 0x02, + CChanmode = 0x04, + DChanmode = 0x08, +} diff --git a/src/message/signalproxy/objects/networkinfo.rs b/src/message/signalproxy/objects/networkinfo.rs new file mode 100644 index 0000000..a7f0a3c --- /dev/null +++ b/src/message/signalproxy/objects/networkinfo.rs @@ -0,0 +1,169 @@ +use crate::primitive::{StringList, Variant}; + +#[allow(unused_imports)] +use libquassel_derive::Network; + +use crate::message::objects::network::NetworkServer; + +#[allow(dead_code)] +#[derive(Debug, Clone, PartialEq, Network)] +#[network(repr = "list")] +pub struct NetworkInfo { + #[network(rename = "networkName")] + pub network_name: String, + + #[network( + rename = "ServerList", + override_type = "VariantList", + to_map = "|server| Variant::VariantMap(server.to_network())", + from_map = "|server| NetworkServer::from_network(match_variant!(server, Variant::VariantMap))" + )] + pub server_list: Vec<NetworkServer>, + #[network(rename = "perform")] + pub perform: StringList, + + #[network(rename = "autoIdentifyService")] + pub auto_identify_service: String, + #[network(rename = "autoIdentifyPassword")] + pub auto_identify_password: String, + + #[network(rename = "saslAccount")] + pub sasl_account: String, + #[network(rename = "saslPassword")] + pub sasl_password: String, + + // ByteArray + #[network(rename = "codecForServer", override_type = "ByteArray")] + pub codec_for_server: String, + #[network(rename = "codecForEncoding", override_type = "ByteArray")] + pub codec_for_encoding: String, + #[network(rename = "codecForDecoding", override_type = "ByteArray")] + pub codec_for_decoding: String, + + // TODO add these type aliases or usertypes in variants + // pub network_id: NetworkId, + // pub identity_id: IdentityId, + #[network(rename = "msgRateBurstSize")] + pub msg_rate_burst_size: u32, + #[network(rename = "msgRateMessageDelay")] + pub msg_rate_message_delay: u32, + + #[network(rename = "autoReconnectInterval")] + pub auto_reconnect_interval: u32, + #[network(rename = "autoReconnectRetries")] + pub auto_reconnect_retries: u16, + + #[network(rename = "rejoinChannels")] + pub rejoin_channels: bool, + #[network(rename = "useRandomServer")] + pub use_random_server: bool, + #[network(rename = "useAutoIdentify")] + pub use_auto_identify: bool, + #[network(rename = "useSasl")] + pub use_sasl: bool, + #[network(rename = "useAutoReconnect")] + pub use_auto_reconnect: bool, + #[network(rename = "unlimitedReconnectRetries")] + pub unlimited_reconnect_retries: bool, + #[network(rename = "useCustomMessageRate")] + pub use_custom_message_rate: bool, + #[network(rename = "unlimitedMessageRate")] + pub unlimited_message_rate: bool, + // #[network(rename = "autoAwayActive")] + // pub auto_away_active: bool, +} + +#[cfg(test)] +mod tests { + use crate::{ + message::objects::network::NetworkServer, + primitive::{Variant, VariantList}, + }; + + use super::*; + use crate::message::signalproxy::translation::Network; + + use pretty_assertions::{assert_eq, assert_ne}; + + fn get_network() -> VariantList { + vec![ + Variant::ByteArray(s!("networkName")), + Variant::String(s!("snoonet")), + Variant::ByteArray(s!("ServerList")), + Variant::VariantList(vec![]), + Variant::ByteArray(s!("perform")), + Variant::StringList(vec![s!("")]), + Variant::ByteArray(s!("autoIdentifyService")), + Variant::String(s!("NickServ")), + Variant::ByteArray(s!("autoIdentifyPassword")), + Variant::String(s!("")), + Variant::ByteArray(s!("saslAccount")), + Variant::String(s!("")), + Variant::ByteArray(s!("saslPassword")), + Variant::String(s!("")), + Variant::ByteArray(s!("codecForServer")), + Variant::ByteArray(s!("")), + Variant::ByteArray(s!("codecForEncoding")), + Variant::ByteArray(s!("")), + Variant::ByteArray(s!("codecForDecoding")), + Variant::ByteArray(s!("")), + Variant::ByteArray(s!("msgRateBurstSize")), + Variant::u32(5), + Variant::ByteArray(s!("msgRateMessageDelay")), + Variant::u32(2200), + Variant::ByteArray(s!("autoReconnectInterval")), + Variant::u32(60), + Variant::ByteArray(s!("autoReconnectRetries")), + Variant::u16(20), + Variant::ByteArray(s!("rejoinChannels")), + Variant::bool(true), + Variant::ByteArray(s!("useRandomServer")), + Variant::bool(false), + Variant::ByteArray(s!("useAutoIdentify")), + Variant::bool(false), + Variant::ByteArray(s!("useSasl")), + Variant::bool(false), + Variant::ByteArray(s!("useAutoReconnect")), + Variant::bool(true), + Variant::ByteArray(s!("unlimitedReconnectRetries")), + Variant::bool(false), + Variant::ByteArray(s!("useCustomMessageRate")), + Variant::bool(false), + Variant::ByteArray(s!("unlimitedMessageRate")), + Variant::bool(false), + ] + } + + fn get_runtime() -> NetworkInfo { + NetworkInfo { + network_name: s!("snoonet"), + server_list: vec![], + perform: vec![s!("")], + auto_identify_service: s!("NickServ"), + auto_identify_password: s!(""), + sasl_account: s!(""), + sasl_password: s!(""), + codec_for_server: s!(""), + codec_for_encoding: s!(""), + codec_for_decoding: s!(""), + msg_rate_burst_size: 5, + msg_rate_message_delay: 2200, + auto_reconnect_interval: 60, + auto_reconnect_retries: 20, + rejoin_channels: true, + use_random_server: false, + use_auto_identify: false, + use_sasl: false, + use_auto_reconnect: true, + unlimited_reconnect_retries: false, + use_custom_message_rate: false, + unlimited_message_rate: false, + // auto_away_active: (), + } + } + + #[test] + fn networkinfo_to_network() { + assert_eq!(get_runtime().to_network(), get_network()) + } +} |