Can get information about rooms

matrixgw_backend/src/broadcast_messages.rs

@@ -11,7 +11,7 @@ pub type BroadcastSender = tokio::sync::broadcast::Sender<BroadcastMessage>;
 #[derive(Debug, Clone)]
 pub struct BxRoomEvent<E> {
     pub user: UserEmail,
-    pub event: Box<E>,
+    pub data: Box<E>,
     pub room: Room,
 }
 

matrixgw_backend/src/controllers/matrix/matrix_room_controller.rs

@@ -0,0 +1,58 @@
+use crate::controllers::HttpResult;
+use crate::extractors::matrix_client_extractor::MatrixClientExtractor;
+use actix_web::{HttpResponse, web};
+use futures_util::{StreamExt, stream};
+use matrix_sdk::ruma::{OwnedRoomId, OwnedUserId};
+use matrix_sdk::{Room, RoomMemberships};
+
+#[derive(serde::Serialize)]
+pub struct APIRoomInfo {
+    id: OwnedRoomId,
+    name: Option<String>,
+    members: Vec<OwnedUserId>,
+    has_avatar: bool,
+}
+
+impl APIRoomInfo {
+    async fn from_room(r: &Room) -> anyhow::Result<Self> {
+        Ok(Self {
+            id: r.room_id().to_owned(),
+            name: r.name(),
+            members: r
+                .members(RoomMemberships::ACTIVE)
+                .await?
+                .into_iter()
+                .map(|r| r.user_id().to_owned())
+                .collect::<Vec<_>>(),
+            has_avatar: r.avatar_url().is_some(),
+        })
+    }
+}
+
+/// Get the list of joined rooms of the user
+pub async fn joined_rooms(client: MatrixClientExtractor) -> HttpResult {
+    let list = stream::iter(client.client.client.joined_rooms())
+        .then(async |room| APIRoomInfo::from_room(&room).await)
+        .collect::<Vec<_>>()
+        .await
+        .into_iter()
+        .collect::<Result<Vec<_>, _>>()?;
+
+    Ok(HttpResponse::Ok().json(list))
+}
+
+#[derive(serde::Deserialize)]
+pub struct RoomIdInPath {
+    id: OwnedRoomId,
+}
+
+/// Get the list of joined rooms of the user
+pub async fn single_room_info(
+    client: MatrixClientExtractor,
+    path: web::Path<RoomIdInPath>,
+) -> HttpResult {
+    Ok(match client.client.client.get_room(&path.id) {
+        None => HttpResponse::NotFound().json("Room not found"),
+        Some(r) => HttpResponse::Ok().json(APIRoomInfo::from_room(&r).await?),
+    })
+}

matrixgw_backend/src/controllers/matrix/mod.rs

@@ -0,0 +1 @@
+pub mod matrix_room_controller;

matrixgw_backend/src/controllers/mod.rs

@@ -3,6 +3,7 @@ use actix_web::{HttpResponse, ResponseError};
 use std::error::Error;
 
 pub mod auth_controller;
+pub mod matrix;
 pub mod matrix_link_controller;
 pub mod matrix_sync_thread_controller;
 pub mod server_controller;

matrixgw_backend/src/controllers/ws_controller.rs

@@ -10,10 +10,10 @@ use actix_web::dev::Payload;
 use actix_web::{FromRequest, HttpRequest, HttpResponse, web};
 use actix_ws::Message;
 use futures_util::StreamExt;
-use matrix_sdk::ruma::OwnedRoomId;
 use matrix_sdk::ruma::events::reaction::ReactionEventContent;
 use matrix_sdk::ruma::events::room::message::RoomMessageEventContent;
 use matrix_sdk::ruma::events::room::redaction::RoomRedactionEventContent;
+use matrix_sdk::ruma::{MilliSecondsSinceUnixEpoch, OwnedEventId, OwnedRoomId, OwnedUserId};
 use ractor::ActorRef;
 use std::time::Instant;
 use tokio::sync::broadcast;
@@ -22,8 +22,11 @@ use tokio::time::interval;
 
 #[derive(Debug, serde::Serialize)]
 pub struct WsRoomEvent<E> {
-    pub event: Box<E>,
     pub room_id: OwnedRoomId,
+    pub event_id: OwnedEventId,
+    pub sender: OwnedUserId,
+    pub origin_server_ts: MilliSecondsSinceUnixEpoch,
+    pub data: Box<E>,
 }
 
 /// Messages sent to the client
@@ -45,20 +48,29 @@ impl WsMessage {
         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(),
+                    event_id: evt.data.event_id.clone(),
+                    sender: evt.data.sender.clone(),
+                    origin_server_ts: evt.data.origin_server_ts,
+                    data: Box::new(evt.data.content.clone()),
                 }))
             }
             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(),
+                    event_id: evt.data.event_id.clone(),
+                    sender: evt.data.sender.clone(),
+                    origin_server_ts: evt.data.origin_server_ts,
+                    data: Box::new(evt.data.content.clone()),
                 }))
             }
             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(),
+                    event_id: evt.data.event_id.clone(),
+                    sender: evt.data.sender.clone(),
+                    origin_server_ts: evt.data.origin_server_ts,
+                    data: Box::new(evt.data.content.clone()),
                 }))
             }
             _ => None,

matrixgw_backend/src/main.rs

@@ -9,6 +9,7 @@ use actix_web::{App, HttpServer, web};
 use matrixgw_backend::app_config::AppConfig;
 use matrixgw_backend::broadcast_messages::BroadcastMessage;
 use matrixgw_backend::constants;
+use matrixgw_backend::controllers::matrix::matrix_room_controller;
 use matrixgw_backend::controllers::{
     auth_controller, matrix_link_controller, matrix_sync_thread_controller, server_controller,
     tokens_controller, ws_controller,
@@ -134,6 +135,15 @@ async fn main() -> std::io::Result<()> {
                 web::get().to(matrix_sync_thread_controller::status),
             )
             .service(web::resource("/api/ws").route(web::get().to(ws_controller::ws)))
+            // Matrix room controller
+            .route(
+                "/api/matrix/room/joined",
+                web::get().to(matrix_room_controller::joined_rooms),
+            )
+            .route(
+                "/api/matrix/room/{id}",
+                web::get().to(matrix_room_controller::single_room_info),
+            )
     })
     .workers(4)
     .bind(&AppConfig::get().listen_address)?

matrixgw_backend/src/matrix_connection/matrix_client.rs

@@ -91,7 +91,7 @@ pub struct FinishMatrixAuth {
 pub struct MatrixClient {
     manager: ActorRef<MatrixManagerMsg>,
     pub email: UserEmail,
-    client: Client,
+    pub client: Client,
 }
 
 impl MatrixClient {

matrixgw_backend/src/matrix_connection/sync_thread.rs

@@ -58,7 +58,7 @@ async fn sync_thread_task(
         async move |event: OriginalSyncRoomMessageEvent, room: Room| {
             if let Err(e) = tx_msg_handle.send(BroadcastMessage::RoomMessageEvent(BxRoomEvent {
                 user: user_msg_handle.clone(),
-                event: Box::new(event),
+                data: Box::new(event),
                 room,
             })) {
                 log::warn!("Failed to forward room message event! {e}");
@@ -72,7 +72,7 @@ async fn sync_thread_task(
         async move |event: OriginalSyncReactionEvent, room: Room| {
             if let Err(e) = tx_reac_handle.send(BroadcastMessage::ReactionEvent(BxRoomEvent {
                 user: user_reac_handle.clone(),
-                event: Box::new(event),
+                data: Box::new(event),
                 room,
             })) {
                 log::warn!("Failed to forward reaction event! {e}");
@@ -87,7 +87,7 @@ async fn sync_thread_task(
             if let Err(e) =
                 tx_redac_handle.send(BroadcastMessage::RoomRedactionEvent(BxRoomEvent {
                     user: user_redac_handle.clone(),
-                    event: Box::new(event),
+                    data: Box::new(event),
                     room,
                 }))
             {