Can get room messages

matrixgw_backend/src/controllers/matrix/matrix_event_controller.rs

@@ -0,0 +1,91 @@
+use crate::controllers::HttpResult;
+use crate::controllers::matrix::matrix_room_controller::RoomIdInPath;
+use crate::extractors::matrix_client_extractor::MatrixClientExtractor;
+use actix_web::{HttpResponse, web};
+use futures_util::{StreamExt, stream};
+use matrix_sdk::Room;
+use matrix_sdk::deserialized_responses::{TimelineEvent, TimelineEventKind};
+use matrix_sdk::room::MessagesOptions;
+use matrix_sdk::ruma::{MilliSecondsSinceUnixEpoch, OwnedEventId, OwnedUserId, RoomId, UInt};
+use serde::{Deserialize, Serialize};
+use serde_json::value::RawValue;
+
+#[derive(Serialize)]
+pub struct APIEvent {
+    id: OwnedEventId,
+    time: MilliSecondsSinceUnixEpoch,
+    sender: OwnedUserId,
+    data: Box<RawValue>,
+}
+
+impl APIEvent {
+    pub async fn from_evt(msg: TimelineEvent, room_id: &RoomId) -> anyhow::Result<Self> {
+        let (event, raw) = match &msg.kind {
+            TimelineEventKind::Decrypted(d) => (d.event.deserialize()?, d.event.json()),
+            TimelineEventKind::UnableToDecrypt { event, .. }
+            | TimelineEventKind::PlainText { event } => (
+                event.deserialize()?.into_full_event(room_id.to_owned()),
+                event.json(),
+            ),
+        };
+
+        Ok(Self {
+            id: event.event_id().to_owned(),
+            time: event.origin_server_ts(),
+            sender: event.sender().to_owned(),
+            data: raw.to_owned(),
+        })
+    }
+}
+
+#[derive(Serialize)]
+pub struct APIEventsList {
+    pub start: String,
+    pub end: Option<String>,
+    pub messages: Vec<APIEvent>,
+}
+
+/// Get messages for a given room
+pub(super) async fn get_events(
+    room: &Room,
+    limit: u32,
+    from: Option<&str>,
+) -> anyhow::Result<APIEventsList> {
+    let mut msg_opts = MessagesOptions::backward();
+    msg_opts.from = from.map(str::to_string);
+    msg_opts.limit = UInt::from(limit);
+
+    let messages = room.messages(msg_opts).await?;
+    Ok(APIEventsList {
+        start: messages.start,
+        end: messages.end,
+        messages: stream::iter(messages.chunk)
+            .then(async |msg| APIEvent::from_evt(msg, room.room_id()).await)
+            .collect::<Vec<_>>()
+            .await
+            .into_iter()
+            .collect::<Result<Vec<_>, _>>()?,
+    })
+}
+
+#[derive(Deserialize)]
+pub struct GetRoomEventsQuery {
+    #[serde(default)]
+    limit: Option<u32>,
+    #[serde(default)]
+    from: Option<String>,
+}
+
+/// Get the events for a room
+pub async fn get_for_room(
+    client: MatrixClientExtractor,
+    path: web::Path<RoomIdInPath>,
+    query: web::Query<GetRoomEventsQuery>,
+) -> HttpResult {
+    let Some(room) = client.client.client.get_room(&path.id) else {
+        return Ok(HttpResponse::NotFound().json("Room not found!"));
+    };
+
+    Ok(HttpResponse::Ok()
+        .json(get_events(&room, query.limit.unwrap_or(500), query.from.as_deref()).await?))
+}

matrixgw_backend/src/controllers/matrix/matrix_room_controller.rs

@@ -1,4 +1,5 @@
 use crate::controllers::HttpResult;
+use crate::controllers::matrix::matrix_event_controller::{APIEvent, get_events};
 use crate::controllers::matrix::matrix_media_controller;
 use crate::extractors::matrix_client_extractor::MatrixClientExtractor;
 use actix_web::{HttpRequest, HttpResponse, web};
@@ -15,10 +16,13 @@ pub struct APIRoomInfo {
     avatar: Option<OwnedMxcUri>,
     is_space: bool,
     parents: Vec<OwnedRoomId>,
+    number_unread_messages: u64,
+    latest_event: Option<APIEvent>,
 }
 
 impl APIRoomInfo {
     async fn from_room(r: &Room) -> anyhow::Result<Self> {
+        // Get parent spaces
         let parent_spaces = r
             .parent_spaces()
             .await?
@@ -47,6 +51,8 @@ impl APIRoomInfo {
             avatar: r.avatar_url(),
             is_space: r.is_space(),
             parents: parent_spaces,
+            number_unread_messages: r.num_unread_messages(),
+            latest_event: get_events(r, 1, None).await?.messages.into_iter().next(),
         })
     }
 }
@@ -77,7 +83,7 @@ pub async fn get_joined_spaces(client: MatrixClientExtractor) -> HttpResult {
 
 #[derive(serde::Deserialize)]
 pub struct RoomIdInPath {
-    id: OwnedRoomId,
+    pub(crate) id: OwnedRoomId,
 }
 
 /// Get the list of joined rooms of the user

matrixgw_backend/src/controllers/matrix/mod.rs

@@ -1,3 +1,4 @@
+pub mod matrix_event_controller;
 pub mod matrix_media_controller;
 pub mod matrix_profile_controller;
 pub mod matrix_room_controller;

matrixgw_backend/src/main.rs

@@ -10,7 +10,8 @@ use matrixgw_backend::app_config::AppConfig;
 use matrixgw_backend::broadcast_messages::BroadcastMessage;
 use matrixgw_backend::constants;
 use matrixgw_backend::controllers::matrix::{
-    matrix_media_controller, matrix_profile_controller, matrix_room_controller,
+    matrix_event_controller, matrix_media_controller, matrix_profile_controller,
+    matrix_room_controller,
 };
 use matrixgw_backend::controllers::{
     auth_controller, matrix_link_controller, matrix_sync_thread_controller, server_controller,
@@ -163,6 +164,11 @@ async fn main() -> std::io::Result<()> {
                 "/api/matrix/profile/get_multiple",
                 web::post().to(matrix_profile_controller::get_multiple),
             )
+            // Matrix events controller
+            .route(
+                "/api/matrix/room/{id}/events",
+                web::get().to(matrix_event_controller::get_for_room),
+            )
             // Matrix media controller
             .route(
                 "/api/matrix/media/{mxc}",