Start work on spam detection

src/bot.rs

@@ -24,7 +24,8 @@ pub mod bot {
         info: BotUserInfo,
         joined_room: Joined,
         swear_list: Vec<String>,
-        database_handle: sled::Db
+        database_handle: sled::Db,
+        spam_info: SpamInfo
     }
 
     impl Bot {
@@ -110,7 +111,8 @@ pub mod bot {
                 info: creds,
                 joined_room,
                 swear_list,
-                database_handle: db
+                database_handle: db,
+                spam_info: SpamInfo::new()
             };
 
             bot.send_message("Sucessfully started Matrix-Modbot").await;
@@ -132,7 +134,7 @@ pub mod bot {
                     let id = &event.event_id;
 
                     if bot.info.allow_swear && detect_swear_from_message(&bot.swear_list, &text) {
-                            bot.delete_swear_from_room(id, &member).await;
+                            bot.delete_message_from_room(id, &member, "Swearing").await;
                         };
                     }
                 }
@@ -141,19 +143,19 @@ pub mod bot {
                 if let Some((edited_msg_event_id, text)) = get_edited_message_event_text(&event){
                     if bot.info.allow_swear && detect_swear_from_message(&bot.swear_list, &text) {
                             let member = room.get_member(&event.sender).await.unwrap().unwrap();
-                            bot.delete_swear_from_room(&edited_msg_event_id, &member).await;
+                            bot.delete_message_from_room(&edited_msg_event_id, &member, "Swearing").await;
                         };
 
 
                     }
                 }
 
-        async fn delete_swear_from_room(&self, event_id: &OwnedEventId, member: &RoomMember) {
+        async fn delete_message_from_room(&self, event_id: &OwnedEventId, member: &RoomMember, reason: &str) {
-            let result = self.joined_room.redact(event_id, Some("Swearing"), None).await;
+            let result = self.joined_room.redact(event_id, Some(reason), None).await;
             if result.is_err() {
                 self.send_message("Error deleting message").await;
             };
-            self.send_message("Swearing is not permitted on this server").await;
+            self.send_message(&format!("{} is not permitted on this server", reason)).await;
             self.subtract_reputation_from_member(member).await.expect("Failed to subtract reputation from member");
         }
 
@@ -162,23 +164,30 @@ pub mod bot {
             let member_id: &str = member.user_id().as_str();
             let mut current_reputation = dbg!(self.database_handle.get(member_id).unwrap().unwrap().first().unwrap().to_owned());
             if current_reputation == 0 {
-                self.joined_room.kick_user(member.user_id(), Some("Reputation lower than zero")).await.expect("Cannot kick user");
+                if let Some(_) = self.joined_room.kick_user(member.user_id(), Some("Reputation lower than zero")).await.ok() {
+                    dbg!(self.database_handle.remove(member_id).unwrap());
+                    self.send_message(&format!("Member {} has been kicked.", member_id)).await;
+                };
                 return Ok(())
             }
             else {
                 current_reputation -= 1;
                 dbg!(self.database_handle.insert(member_id, &current_reputation.to_be_bytes()).unwrap());
+                self.send_message(&format!("{}'s current reputation is {}", member_id, current_reputation)).await;
                 return Ok(())
             }
         }
             
-        pub async fn send_message(&self, message: &str) {
+        async fn send_message(&self, message: &str) {
             debug!("Send message ({:?}): {}", &self.joined_room, message);
             let content = RoomMessageEventContent::text_plain(message);
             let _ = &self.joined_room.send(content, None)
                 .await
                 .expect("Unable to send message");
+        }
 
+        async fn detect_spam(&self, event_id: &OwnedEventId) -> bool {
+            todo!()
         }
 
     }

src/utils.rs

@@ -7,10 +7,23 @@ pub mod utils {
     use matrix_sdk::ruma::OwnedEventId;
     use std::{
         fs::File,
-        io::{copy, BufReader, BufRead, Result},
+        io::{copy, BufReader, BufRead, Result}, collections::HashMap,
     };
     use reqwest;
 
+    #[derive(Clone)]
+    pub struct SpamInfo {
+        pub detection_window: i32,
+        pub max_msg_per_window: i32,
+        pub author_msg_times: HashMap<String, Vec<i32>>,
+    }
+
+    impl SpamInfo {
+        pub fn new() -> Self {
+            SpamInfo { detection_window: 7, max_msg_per_window: 5, author_msg_times: HashMap::new() }
+        }
+    }
+
     pub fn get_message_event_text(event: &OriginalSyncRoomMessageEvent) -> Option<String> {
         if let MessageType::Text(TextMessageEventContent { body, .. }) = &event.content.msgtype {
             Some(body.to_owned())