Add base for emoji reactions

src/bot.rs

@@ -6,6 +6,7 @@ use matrix_sdk::EventHandler;
 use matrix_sdk::RoomMember;
 use matrix_sdk::SyncSettings;
 use matrix_sdk_common::uuid::Uuid;
+use ruma::events::reaction::ReactionEventContent;
 use ruma::events::SyncMessageEvent;
 use ruma::EventId;
 use ruma::RoomId;
@@ -101,21 +102,39 @@ struct EventCallback(Bot);
 impl EventHandler for EventCallback {
     async fn on_room_message(&self, room: Room, event: &SyncMessageEvent<MessageEventContent>) {
         if let Room::Joined(ref _joined) = room {
-            if let Some(text) = utils::get_text_msg_body(event) {
+            // Standard text message
+            if let Some(text) = utils::get_message_event_text(event) {
                 let member = utils::get_msg_sender(&room, event).await;
 
                 // Reporting room
                 if room.room_id() == self.0.reporting_room.room_id() {
                     let id = &event.event_id;
                     self.on_reporting_room_msg(text.clone(), &member, id).await;
                 }
+
                 // Admin room
                 if room.room_id() == self.0.admin_room.room_id() {
                     self.on_admin_room_message(text, &member).await;
                 }
             }
         }
     }
+
+    async fn on_room_reaction(&self, room: Room, event: &SyncMessageEvent<ReactionEventContent>) {
+        if let Room::Joined(ref _joined) = room {
+            // Standard text message
+            if let Some(reaction_relation) = utils::get_message_event_reaction(event) {
+                let member = utils::get_msg_sender(&room, event).await;
+
+                // Reporting room
+                if room.room_id() == self.0.reporting_room.room_id() {
+                    let id = &reaction_relation.event_id;
+                    let emoji = &reaction_relation.emoji;
+                    self.on_reporting_room_reaction(&member, emoji, id).await;
+                }
+            }
+        }
+    }
 }
 
 impl EventCallback {
@@ -129,7 +148,27 @@ impl EventCallback {
         let member_name = utils::get_member_display_name(&member);
         debug!("received {:?} {:?}", msg, event_id.to_string());
 
-        let msg = format!("Hello {} I received your message!", member_name);
+        let msg = format!("Hello {}, we received your message!", member_name);
+        self.0.send_message(&msg, false).await;
+    }
+
+    async fn on_reporting_room_reaction(
+        &self,
+        member: &RoomMember,
+        emoji: &String,
+        event_id: &EventId,
+    ) {
+        // Check if the sender is a editor (= has the permission to use emoji commands)
+        if !self.is_editor(&member).await {
+            return;
+        }
+
+        let member_name = utils::get_member_display_name(&member);
+
+        let msg = format!(
+            "Hello {}, we received your {} reaction!",
+            member_name, emoji
+        );
         self.0.send_message(&msg, false).await;
     }
 
@@ -140,8 +179,7 @@ impl EventCallback {
         }
 
         // Check if the sender is a editor (= has the permission to use commands)
-        let user_id = member.user_id().to_string();
-        if !self.0.config.editors.contains(&user_id) {
+        if !self.is_editor(&member).await {
             let msg = "You don't have the permission to use commands.";
             self.0.send_message(msg, true).await;
             return;
@@ -183,4 +221,9 @@ impl EventCallback {
         let msg = "Unrecognized command. Use !help to list available commands.";
         self.0.send_message(msg, true).await;
     }
+
+    async fn is_editor(&self, member: &RoomMember) -> bool {
+        let user_id = member.user_id().to_string();
+        self.0.config.editors.contains(&user_id)
+    }
 }

src/utils.rs

@@ -2,13 +2,15 @@ use matrix_sdk::events::room::message::MessageEventContent;
 use matrix_sdk::room::Room;
 use matrix_sdk::BaseRoomMember;
 use matrix_sdk::RoomMember;
+use ruma::events::reaction::ReactionEventContent;
+use ruma::events::reaction::Relation;
 use ruma::events::room::message::MessageType;
 use ruma::events::room::message::TextMessageEventContent;
 use ruma::events::SyncMessageEvent;
 use ruma::UserId;
 
-/// A simplified way of getting a the acutal message from text message event
-pub fn get_text_msg_body(event: &SyncMessageEvent<MessageEventContent>) -> Option<String> {
+/// A simplified way of getting the text from a message event
+pub fn get_message_event_text(event: &SyncMessageEvent<MessageEventContent>) -> Option<String> {
     if let SyncMessageEvent {
         content:
             MessageEventContent {
@@ -23,10 +25,24 @@ pub fn get_text_msg_body(event: &SyncMessageEvent<MessageEventContent>) -> Optio
     None
 }
 
+/// A simplified way of getting the reaction from a message event
+pub fn get_message_event_reaction(
+    event: &SyncMessageEvent<ReactionEventContent>,
+) -> Option<Relation> {
+    if let SyncMessageEvent {
+        content: ReactionEventContent { relation, .. },
+        ..
+    } = event
+    {
+        return Some(relation.to_owned());
+    }
+    None
+}
+
 /// Gets the sender RoomMember from a message event
-pub async fn get_msg_sender(
+pub async fn get_msg_sender<T: ruma::events::MessageEventContent>(
     room: &Room,
-    event: &SyncMessageEvent<MessageEventContent>,
+    event: &SyncMessageEvent<T>,
 ) -> RoomMember {
     room.get_member(&event.sender).await.unwrap().unwrap()
 }