chore: use UserUnwrapped in channels

src/channels.rs

@@ -2,20 +2,24 @@ use std::collections::BTreeSet;
 
 use tokio::{io::BufWriter, net::TcpStream};
 
-use crate::{error_structs::SenderError, sender::IrcResponseCodes, user::User};
+use crate::{
+    error_structs::SenderError,
+    sender::IrcResponseCodes,
+    user::{User, UserUnwrapped},
+};
 
 #[derive(Clone, Debug, Hash, Eq, PartialEq)]
 pub struct Channel {
     pub name: String,
-    pub joined_users: BTreeSet<User>,
+    pub joined_users: BTreeSet<UserUnwrapped>,
 }
 
 impl Channel {
-    pub fn add_user(&mut self, user: User) {
+    pub fn add_user(&mut self, user: UserUnwrapped) {
         self.joined_users.insert(user);
     }
 
-    pub fn new_channel(name: String, user: User) -> Self {
+    pub fn new_channel(name: String, user: UserUnwrapped) -> Self {
         Channel {
             name,
             joined_users: BTreeSet::from([user]),
@@ -24,7 +28,7 @@ impl Channel {
 
     pub async fn names_list_send(
         &self,
-        user: User,
+        user: UserUnwrapped,
         channel: &Channel,
         writer: &mut BufWriter<TcpStream>,
         hostname: &str,
@@ -32,11 +36,11 @@ impl Channel {
         let mut members = Vec::new();
 
         for member in self.clone().joined_users {
-            members.push(member.nickname.unwrap());
+            members.push(member.nickname);
         }
 
         for member in channel.joined_users.clone() {
-            members.push(member.nickname.unwrap());
+            members.push(member.nickname);
         }
 
         members.sort();
@@ -44,14 +48,14 @@ impl Channel {
 
         IrcResponseCodes::NameReply
             .into_irc_response(
-                user.nickname.clone().unwrap(),
+                user.nickname.clone(),
                 format!("= {} :{}", self.name.clone(), members.join(" ")),
             )
             .send(hostname, writer, false)
             .await?;
         IrcResponseCodes::EndOfNames
             .into_irc_response(
-                user.nickname.clone().unwrap(),
+                user.nickname.clone(),
                 format!("{} :End of /NAMES list", self.name.clone()),
             )
             .send(hostname, writer, false)
@@ -62,13 +66,13 @@ impl Channel {
 
     pub async fn send_topic(
         &self,
-        user: User,
+        user: UserUnwrapped,
         writer: &mut BufWriter<TcpStream>,
         hostname: &str,
     ) -> Result<(), SenderError> {
         IrcResponseCodes::NoTopic
             .into_irc_response(
-                user.nickname.clone().unwrap(),
+                user.nickname.clone(),
                 format!("{} :No topic is set", self.name.clone()),
             )
             .send(hostname, writer, false)

src/client/commands/join.rs

@@ -18,6 +18,7 @@ impl ClientHandler for Join {
     ) -> Vec<super::ClientAction> {
         let mut joined_channels = JOINED_CHANNELS.lock().await;
         let mut channels = Vec::new();
+        let user_unwrapped = user_state.clone().unwrap_all();
 
         for channel in arguments[0].clone().split(',') {
             let mut maybe_existing_channel: Option<Channel> = None;
@@ -37,14 +38,14 @@ impl ClientHandler for Join {
             }
 
             if let Some(mut new_channel) = maybe_existing_channel.clone() {
-                new_channel.joined_users.insert(user_state.clone());
+                new_channel.joined_users.insert(user_unwrapped.clone());
 
                 joined_channels.remove(&maybe_existing_channel.clone().unwrap());
                 joined_channels.insert(new_channel.clone());
 
                 channels.push(new_channel.clone());
             } else {
-                let new_channel = Channel::new_channel(channel.into(), user_state.clone());
+                let new_channel = Channel::new_channel(channel.into(), user_unwrapped.clone());
 
                 joined_channels.insert(new_channel.clone());
 

src/client/mod.rs

@@ -147,7 +147,7 @@ impl Client {
                 for channel in joined_channels.clone() {
                     if let MsgReceiver::ChannelName(channelname) = message.clone().receiver
                         && channelname == channel.name
-                        && channel.joined_users.contains(user_wrapped)
+                        && channel.joined_users.contains(&user)
                     {
                         channel_name = Some(channel.name.clone());
                     }
@@ -194,7 +194,7 @@ impl Client {
             }
 
             Message::ChanJoinMessage(message) => {
-                if message.channel.joined_users.contains(user_wrapped) || message.sender == user {
+                if message.channel.joined_users.contains(&user) || message.sender == user {
                     let channel = message.channel.clone();
 
                     IrcResponse {
@@ -208,12 +208,12 @@ impl Client {
                     .await?;
 
                     channel
-                        .send_topic(user_wrapped.clone(), writer, hostname)
+                        .send_topic(user.clone(), writer, hostname)
                         .await
                         .unwrap();
 
                     channel
-                        .names_list_send(user_wrapped.clone(), &channel, writer, hostname)
+                        .names_list_send(user.clone(), &channel, writer, hostname)
                         .await
                         .unwrap();
                 }

src/user.rs

@@ -21,7 +21,7 @@ pub struct User {
     // pub hostname: Option<String>,
 }
 
-#[derive(Clone, Debug, Eq, PartialEq, Hash)]
+#[derive(Clone, Debug, Eq, PartialEq, Hash, PartialOrd, Ord)]
 pub struct UserUnwrapped {
     pub nickname: String,
     pub username: String,