Refactor messages propagation

matrixgw_backend/src/controllers/ws_controller.rs

@@ -5,6 +5,7 @@ use crate::extractors::auth_extractor::{AuthExtractor, AuthenticatedMethod};
 use crate::extractors::matrix_client_extractor::MatrixClientExtractor;
 use crate::matrix_connection::matrix_client::MatrixClient;
 use crate::matrix_connection::matrix_manager::MatrixManagerMsg;
+use crate::users::UserEmail;
 use actix_web::dev::Payload;
 use actix_web::{FromRequest, HttpRequest, HttpResponse, web};
 use actix_ws::Message;
@@ -19,27 +20,50 @@ use tokio::sync::broadcast;
 use tokio::sync::broadcast::Receiver;
 use tokio::time::interval;
 
+#[derive(Debug, serde::Serialize)]
+pub struct WsRoomEvent<E> {
+    pub event: Box<E>,
+    pub room_id: OwnedRoomId,
+}
+
 /// Messages sent to the client
 #[derive(Debug, serde::Serialize)]
 #[serde(tag = "type")]
 pub enum WsMessage {
     /// Room message event
-    RoomMessageEvent {
-        event: Box<RoomMessageEventContent>,
-        room_id: OwnedRoomId,
-    },
+    RoomMessageEvent(WsRoomEvent<RoomMessageEventContent>),
 
     /// Room reaction event
-    RoomReactionEvent {
-        event: Box<ReactionEventContent>,
-        room_id: OwnedRoomId,
-    },
+    RoomReactionEvent(WsRoomEvent<ReactionEventContent>),
 
     /// Room reaction event
-    RoomRedactionEvent {
-        event: Box<RoomRedactionEventContent>,
-        room_id: OwnedRoomId,
-    },
+    RoomRedactionEvent(WsRoomEvent<RoomRedactionEventContent>),
+}
+
+impl WsMessage {
+    pub fn from_bx_message(msg: &BroadcastMessage, user: &UserEmail) -> Option<Self> {
+        match msg {
+            BroadcastMessage::RoomMessageEvent(evt) if &evt.user == user => {
+                Some(Self::RoomMessageEvent(WsRoomEvent {
+                    event: Box::new(evt.event.content.clone()),
+                    room_id: evt.room.room_id().to_owned(),
+                }))
+            }
+            BroadcastMessage::ReactionEvent(evt) if &evt.user == user => {
+                Some(Self::RoomReactionEvent(WsRoomEvent {
+                    event: Box::new(evt.event.content.clone()),
+                    room_id: evt.room.room_id().to_owned(),
+                }))
+            }
+            BroadcastMessage::RoomRedactionEvent(evt) if &evt.user == user => {
+                Some(Self::RoomRedactionEvent(WsRoomEvent {
+                    event: Box::new(evt.event.content.clone()),
+                    room_id: evt.room.room_id().to_owned(),
+                }))
+            }
+            _ => None,
+        }
+    }
 }
 
 /// Main WS route
@@ -108,8 +132,8 @@ pub async fn ws_handler(
                     Err(broadcast::error::RecvError::Lagged(_)) => continue,
                 };
 
-                match msg {
-                    BroadcastMessage::APITokenDeleted(t)  => {
+                match (&msg, WsMessage::from_bx_message(&msg, &auth.user.email)) {
+                    (BroadcastMessage::APITokenDeleted(t), _)  => {
                         match &auth.method{
                             AuthenticatedMethod::Token(tok) if tok.id == t.id => {
                                 log::info!(
@@ -123,39 +147,17 @@ pub async fn ws_handler(
                         }
 
                     },
-                    BroadcastMessage::UserDisconnectedFromMatrix(mail) if mail == auth.user.email => {
+                    (BroadcastMessage::UserDisconnectedFromMatrix(mail), _) if mail == &auth.user.email => {
                         log::info!(
                             "closing WS session of user {mail:?} as user was disconnected from Matrix"
                         );
                         break None;
                     }
 
-                    BroadcastMessage::RoomMessageEvent{user, event, room} if user == auth.user.email => {
+                    (_, Some(message)) => {
                         // Send the message to the websocket
-                        if let Ok(msg) = serde_json::to_string(&WsMessage::RoomMessageEvent {
-                            event: Box::new(event.content),
-                            room_id: room.room_id().to_owned(),
-                        }) && let Err(e) = session.text(msg).await {
-                            log::error!("Failed to send SyncEvent: {e}");
-                        }
-                    }
-
-                    BroadcastMessage::ReactionEvent{user, event, room} if user == auth.user.email => {
-                        // Send the message to the websocket
-                        if let Ok(msg) = serde_json::to_string(&WsMessage::RoomReactionEvent {
-                            event: Box::new(event.content),
-                            room_id: room.room_id().to_owned(),
-                        }) && let Err(e) = session.text(msg).await {
-                            log::error!("Failed to send SyncEvent: {e}");
-                        }
-                    }
-
-                    BroadcastMessage::RoomRedactionEvent{user, event, room} if user == auth.user.email => {
-                        // Send the message to the websocket
-                        if let Ok(msg) = serde_json::to_string(&WsMessage::RoomRedactionEvent {
-                            event: Box::new(event.content),
-                            room_id: room.room_id().to_owned(),
-                        }) && let Err(e) = session.text(msg).await {
+                        if let Ok(msg) = serde_json::to_string(&message)
+                            && let Err(e) = session.text(msg).await {
                             log::error!("Failed to send SyncEvent: {e}");
                         }
                     }