init

src/routes/channel/handlers.rs

@@ -1,9 +1,10 @@
 use crate::core::state::AppState;
-use crate::http::context::Superuser;
+use crate::http::context::{CurrentUser, Superuser};
 use crate::http::error::HTTPError;
 use crate::domain::dto::channel::{
     ChannelQueryParams, ChannelResponse, ChannelPermissionsResponse, ChannelRolePermissionResponse,
-    ChannelUserPermissionResponse, CreateChannelRequest, SetChannelPermissionRequest,
+    ChannelUserPermissionResponse, CreateChannelRequest, ReadStateResponse,
+    SetChannelPermissionRequest, SetReadStateRequest,
     UpdateChannelRequest,
 };
 use crate::routes::channel::mapper;
@@ -41,6 +42,91 @@ pub async fn get_all(
     ))
 }
 
+#[utoipa::path(
+    get,
+    path = "/channels/{channel_id}/read-state",
+    params(("channel_id" = Uuid, Path, description = "ID du canal")),
+    responses((status = 200, body = ReadStateResponse), (status = 404, description = "Canal non trouvé")),
+    tag = "Channels",
+    security(("bearerAuth" = []))
+)]
+pub async fn get_read_state(
+    user: CurrentUser,
+    State(state): State<AppState>,
+    Path(channel_id): Path<Uuid>,
+) -> Result<Json<ReadStateResponse>, HTTPError> {
+    state.repositories.channel.get_by_id(channel_id).await?.ok_or(HTTPError::NotFound)?;
+    let read_state = state.repositories.read_state.get(channel_id, user.id).await?;
+    let unread_count = state
+        .repositories
+        .read_state
+        .unread_counts(&[channel_id], user.id)
+        .await?
+        .get(&channel_id)
+        .copied()
+        .unwrap_or(0);
+
+    Ok(Json(ReadStateResponse {
+        channel_id,
+        last_read_message_id: read_state.as_ref().and_then(|value| value.last_read_message_id),
+        updated_at: read_state.map(|value| value.updated_at),
+        unread_count,
+    }))
+}
+
+#[utoipa::path(
+    put,
+    path = "/channels/{channel_id}/read-state",
+    request_body = SetReadStateRequest,
+    params(("channel_id" = Uuid, Path, description = "ID du canal")),
+    responses((status = 200, body = ReadStateResponse), (status = 400, description = "Message invalide"), (status = 404, description = "Canal non trouvé")),
+    tag = "Channels",
+    security(("bearerAuth" = []))
+)]
+pub async fn set_read_state(
+    user: CurrentUser,
+    State(state): State<AppState>,
+    Path(channel_id): Path<Uuid>,
+    Json(payload): Json<SetReadStateRequest>,
+) -> Result<Json<ReadStateResponse>, HTTPError> {
+    state.repositories.channel.get_by_id(channel_id).await?.ok_or(HTTPError::NotFound)?;
+
+    if let Some(message_id) = payload.last_read_message_id {
+        let message = state
+            .repositories
+            .message
+            .get_by_id(message_id)
+            .await?
+            .ok_or(HTTPError::BadRequest("Message not found".to_string()))?;
+        if message.channel_id != channel_id {
+            return Err(HTTPError::BadRequest(
+                "Message does not belong to this channel".to_string(),
+            ));
+        }
+    }
+
+    let read_state = state
+        .repositories
+        .read_state
+        .set(channel_id, user.id, payload.last_read_message_id)
+        .await?;
+    let unread_count = state
+        .repositories
+        .read_state
+        .unread_counts(&[channel_id], user.id)
+        .await?
+        .get(&channel_id)
+        .copied()
+        .unwrap_or(0);
+
+    Ok(Json(ReadStateResponse {
+        channel_id,
+        last_read_message_id: read_state.last_read_message_id,
+        updated_at: Some(read_state.updated_at),
+        unread_count,
+    }))
+}
+
 /// Récupère un channel par son ID
 #[utoipa::path(
     get,

src/routes/channel/mapper.rs

@@ -23,6 +23,7 @@ pub fn channel_model_to_channel_response_with_permission(
         name: model.name,
         created_at: model.created_at,
         updated_at: model.updated_at,
+        unread_count: None,
         permission,
     }
 }

src/routes/channel/routes.rs

@@ -27,4 +27,8 @@ pub fn router() -> Router<AppState> {
                 .put(handlers::set_role_permission)
                 .delete(handlers::remove_role_permission),
         )
+        .route(
+            "/channels/{channel_id}/read-state",
+            get(handlers::get_read_state).put(handlers::set_read_state),
+        )
 }

src/routes/openapi.rs

@@ -60,6 +60,8 @@ use utoipa::{Modify, OpenApi};
             crate::domain::dto::channel::ChannelResponse,
             crate::domain::dto::channel::CreateChannelRequest,
             crate::domain::dto::channel::UpdateChannelRequest,
+            crate::domain::dto::channel::ReadStateResponse,
+            crate::domain::dto::channel::SetReadStateRequest,
             crate::domain::dto::role::RoleResponse,
             crate::domain::dto::role::CreateRoleRequest,
             crate::domain::dto::role::UpdateRoleRequest,

src/routes/server/handlers.rs

@@ -43,16 +43,29 @@ async fn require_server_permission(
         (status = 200, description = "Liste des serveurs récupérée avec succès", body = [ServerResponse]),
         (status = 500, description = "Erreur interne du serveur")
     ),
+    security(("bearerAuth" = [])),
     tag = "Servers"
 )]
 pub async fn get_all(
+    user: CurrentUser,
     State(state): State<AppState>,
 ) -> Result<Json<Vec<ServerResponse>>, HTTPError> {
     let servers = state.repositories.server.get_all().await?;
+    let unread_counts = state
+        .repositories
+        .read_state
+        .unread_counts_by_server(user.id)
+        .await?;
     Ok(Json(
         servers
             .into_iter()
-            .map(mapper::server_model_to_server_response)
+            .map(|server| {
+                let server_id = server.id;
+                mapper::server_model_to_server_response_with_unread_count(
+                    server,
+                    unread_counts.get(&server_id).copied().unwrap_or(0),
+                )
+            })
             .collect(),
     ))
 }
@@ -456,5 +469,6 @@ pub async fn get_tree(
         tree.orders,
         tree.channels,
         tree.categories,
+        tree.unread_counts,
     )))
 }

src/routes/server/mapper.rs

@@ -17,9 +17,19 @@ pub fn server_model_to_server_response(model: server::Model) -> ServerResponse {
         is_default: model.is_default,
         created_at: model.created_at,
         updated_at: model.updated_at,
+        unread_count: None,
     }
 }
 
+pub fn server_model_to_server_response_with_unread_count(
+    model: server::Model,
+    unread_count: u64,
+) -> ServerResponse {
+    let mut response = server_model_to_server_response(model);
+    response.unread_count = Some(unread_count);
+    response
+}
+
 pub fn create_request_to_am(req: CreateServerRequest) -> server::ActiveModel {
     server::ActiveModel {
         id: Set(Uuid::new_v4()),
@@ -66,6 +76,7 @@ pub fn build_server_tree(
     orders: Vec<server_item_order::Model>,
     channels: Vec<ChannelWithPermissions>,
     categories: Vec<CategoryWithPermissions>,
+    unread_counts: HashMap<Uuid, u64>,
 ) -> ServerTreeResponse {
     let order_map: HashMap<(Option<Uuid>, Uuid), i64> = orders
         .into_iter()
@@ -119,7 +130,9 @@ pub fn build_server_tree(
             .into_iter()
             .map(|c| {
                 let chan_perm_bits = c.permissions.map(|p| p.bits()).unwrap_or(0);
-                channel_model_to_channel_response_with_permission(c.channel, Some(chan_perm_bits))
+                let mut response = channel_model_to_channel_response_with_permission(c.channel, Some(chan_perm_bits));
+                response.unread_count = Some(*unread_counts.get(&response.id).unwrap_or(&0));
+                response
             })
             .collect();
 
@@ -135,10 +148,11 @@ pub fn build_server_tree(
             .copied()
             .unwrap_or(i64::MAX);
         let chan_perm_bits = chan_with_perm.permissions.map(|p| p.bits()).unwrap_or(0);
-        let chan_response = channel_model_to_channel_response_with_permission(
+        let mut chan_response = channel_model_to_channel_response_with_permission(
             chan_with_perm.channel,
             Some(chan_perm_bits),
         );
+        chan_response.unread_count = Some(*unread_counts.get(&chan_response.id).unwrap_or(&0));
         root_items.push((
             ServerExplorerItemResponse::Channel(chan_response),
             order_key,
@@ -232,6 +246,7 @@ mod tests {
                 channel(second_id, Some(category_id), "first"),
             ],
             vec![category],
+            HashMap::new(),
         );
 
         let ServerExplorerItemResponse::Category(_, channels) = &response.items[0] else {