561 lines
17 KiB
Rust
561 lines
17 KiB
Rust
use crate::core::state::AppState;
|
|
use crate::domain::dto::channel::{
|
|
ChannelPermissionsResponse, ChannelQueryParams, ChannelResponse, ChannelRolePermissionResponse,
|
|
ChannelUserPermissionResponse, CreateChannelRequest, ReadStateResponse,
|
|
SetChannelPermissionRequest, SetReadStateRequest, UpdateChannelRequest,
|
|
};
|
|
use crate::http::context::{CurrentUser, Superuser};
|
|
use crate::http::error::HTTPError;
|
|
use crate::models::{channel, channel_user};
|
|
use crate::routes::channel::mapper;
|
|
use axum::{
|
|
Json,
|
|
extract::{Path, Query, State},
|
|
http::StatusCode,
|
|
};
|
|
use sea_orm::{ColumnTrait, EntityTrait, QueryFilter};
|
|
use uuid::Uuid;
|
|
|
|
async fn require_channel_member(
|
|
state: &AppState,
|
|
channel_id: Uuid,
|
|
user_id: Uuid,
|
|
) -> Result<(), HTTPError> {
|
|
let channel = state
|
|
.repositories
|
|
.channel
|
|
.get_by_id(channel_id)
|
|
.await?
|
|
.ok_or(HTTPError::NotFound)?;
|
|
if channel.channel_type == channel::ChannelType::DM
|
|
&& channel_user::Entity::find()
|
|
.filter(channel_user::Column::ChannelId.eq(channel_id))
|
|
.filter(channel_user::Column::UserId.eq(user_id))
|
|
.one(&state.db)
|
|
.await?
|
|
.is_none()
|
|
{
|
|
return Err(HTTPError::Forbidden);
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
/// Liste tous les channels
|
|
#[utoipa::path(
|
|
get,
|
|
path = "/channels",
|
|
responses(
|
|
(status = 200, description = "Liste des channels récupérée avec succès", body = [ChannelResponse]),
|
|
(status = 500, description = "Erreur interne du serveur")
|
|
),
|
|
params(
|
|
ChannelQueryParams
|
|
),
|
|
tag = "Channels"
|
|
)]
|
|
pub async fn get_all(
|
|
State(state): State<AppState>,
|
|
Query(filters): Query<ChannelQueryParams>,
|
|
) -> Result<Json<Vec<ChannelResponse>>, HTTPError> {
|
|
let params = mapper::query_params_to_channel_filter(filters);
|
|
let channels = state.repositories.channel.filter(params).await?;
|
|
Ok(Json(
|
|
channels
|
|
.into_iter()
|
|
.map(mapper::channel_model_to_channel_response)
|
|
.collect(),
|
|
))
|
|
}
|
|
|
|
#[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> {
|
|
require_channel_member(&state, channel_id, user.id).await?;
|
|
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> {
|
|
require_channel_member(&state, channel_id, user.id).await?;
|
|
|
|
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,
|
|
path = "/channels/{id}",
|
|
responses(
|
|
(status = 200, description = "Channel trouvé", body = ChannelResponse),
|
|
(status = 404, description = "Channel non trouvé"),
|
|
(status = 500, description = "Erreur interne du serveur")
|
|
),
|
|
params(
|
|
("id" = Uuid, Path, description = "ID du channel")
|
|
),
|
|
tag = "Channels"
|
|
)]
|
|
pub async fn get_by_id(
|
|
State(state): State<AppState>,
|
|
Path(id): Path<Uuid>,
|
|
) -> Result<Json<ChannelResponse>, HTTPError> {
|
|
let channel = state
|
|
.repositories
|
|
.channel
|
|
.get_by_id(id)
|
|
.await?
|
|
.ok_or(HTTPError::NotFound)?;
|
|
|
|
Ok(Json(mapper::channel_model_to_channel_response(channel)))
|
|
}
|
|
|
|
/// Liste les permissions directes configurées pour un canal.
|
|
#[utoipa::path(
|
|
get,
|
|
path = "/channels/{channel_id}/permissions",
|
|
params(("channel_id" = Uuid, Path, description = "ID du canal")),
|
|
responses((status = 200, body = ChannelPermissionsResponse), (status = 404, description = "Canal non trouvé")),
|
|
tag = "Channel Permissions"
|
|
)]
|
|
pub async fn list_permissions(
|
|
State(state): State<AppState>,
|
|
Path(channel_id): Path<Uuid>,
|
|
) -> Result<Json<ChannelPermissionsResponse>, HTTPError> {
|
|
state
|
|
.repositories
|
|
.channel
|
|
.get_by_id(channel_id)
|
|
.await?
|
|
.ok_or(HTTPError::NotFound)?;
|
|
let (users, roles) = tokio::try_join!(
|
|
state.repositories.channel.list_user_permissions(channel_id),
|
|
state.repositories.channel.list_role_permissions(channel_id),
|
|
)?;
|
|
Ok(Json(mapper::channel_permissions_to_response(users, roles)))
|
|
}
|
|
|
|
/// Crée un nouveau channel
|
|
#[utoipa::path(
|
|
post,
|
|
path = "/channels",
|
|
request_body = CreateChannelRequest,
|
|
responses(
|
|
(status = 201, description = "Channel créé avec succès", body = ChannelResponse),
|
|
(status = 400, description = "Données invalides (Serveur ou Catégorie non trouvée)"),
|
|
(status = 500, description = "Erreur interne du serveur")
|
|
),
|
|
tag = "Channels",
|
|
security(
|
|
("bearerAuth" = [])
|
|
)
|
|
)]
|
|
pub async fn create(
|
|
_admin: Superuser,
|
|
State(state): State<AppState>,
|
|
Json(payload): Json<CreateChannelRequest>,
|
|
) -> Result<(StatusCode, Json<ChannelResponse>), HTTPError> {
|
|
// Vérifier que le serveur existe si fourni
|
|
if let Some(server_id) = payload.server_id {
|
|
state
|
|
.repositories
|
|
.server
|
|
.get_by_id(server_id)
|
|
.await?
|
|
.ok_or(HTTPError::BadRequest("Server not found".to_string()))?;
|
|
}
|
|
|
|
// Vérifier que la catégorie existe si fournie
|
|
if let Some(category_id) = payload.category_id {
|
|
state
|
|
.repositories
|
|
.category
|
|
.get_by_id(category_id)
|
|
.await?
|
|
.ok_or(HTTPError::BadRequest("Category not found".to_string()))?;
|
|
}
|
|
|
|
let channel = state.services.channel.create_channel(payload).await?;
|
|
Ok((
|
|
StatusCode::CREATED,
|
|
Json(mapper::channel_model_to_channel_response(channel)),
|
|
))
|
|
}
|
|
|
|
/// Met à jour un channel existant
|
|
#[utoipa::path(
|
|
put,
|
|
path = "/channels/{id}",
|
|
request_body = UpdateChannelRequest,
|
|
responses(
|
|
(status = 200, description = "Channel mis à jour avec succès", body = ChannelResponse),
|
|
(status = 404, description = "Channel non trouvé"),
|
|
(status = 400, description = "Données invalides (Serveur ou Catégorie non trouvée)"),
|
|
(status = 500, description = "Erreur interne du serveur")
|
|
),
|
|
params(
|
|
("id" = Uuid, Path, description = "ID du channel")
|
|
),
|
|
tag = "Channels",
|
|
security(
|
|
("bearerAuth" = [])
|
|
)
|
|
)]
|
|
pub async fn update(
|
|
_admin: Superuser,
|
|
State(state): State<AppState>,
|
|
Path(id): Path<Uuid>,
|
|
Json(payload): Json<UpdateChannelRequest>,
|
|
) -> Result<Json<ChannelResponse>, HTTPError> {
|
|
// Vérifier l'existence
|
|
state
|
|
.repositories
|
|
.channel
|
|
.get_by_id(id)
|
|
.await?
|
|
.ok_or(HTTPError::NotFound)?;
|
|
|
|
// Vérifier que le serveur existe si fourni
|
|
if let Some(server_id) = payload.server_id {
|
|
state
|
|
.repositories
|
|
.server
|
|
.get_by_id(server_id)
|
|
.await?
|
|
.ok_or(HTTPError::BadRequest("Server not found".to_string()))?;
|
|
}
|
|
|
|
// Vérifier que la catégorie existe si fournie
|
|
if let Some(category_id) = payload.category_id {
|
|
state
|
|
.repositories
|
|
.category
|
|
.get_by_id(category_id)
|
|
.await?
|
|
.ok_or(HTTPError::BadRequest("Category not found".to_string()))?;
|
|
}
|
|
|
|
let channel = state.services.channel.update_channel(id, payload).await?;
|
|
|
|
Ok(Json(mapper::channel_model_to_channel_response(channel)))
|
|
}
|
|
|
|
/// Supprime un channel
|
|
#[utoipa::path(
|
|
delete,
|
|
path = "/channels/{id}",
|
|
responses(
|
|
(status = 204, description = "Channel supprimé avec succès"),
|
|
(status = 404, description = "Channel non trouvé"),
|
|
(status = 500, description = "Erreur interne du serveur")
|
|
),
|
|
params(
|
|
("id" = Uuid, Path, description = "ID du channel")
|
|
),
|
|
tag = "Channels",
|
|
security(
|
|
("bearerAuth" = [])
|
|
)
|
|
)]
|
|
pub async fn delete(
|
|
_admin: Superuser,
|
|
State(state): State<AppState>,
|
|
Path(id): Path<Uuid>,
|
|
) -> Result<StatusCode, HTTPError> {
|
|
if state.services.channel.delete_channel(id).await? {
|
|
Ok(StatusCode::NO_CONTENT)
|
|
} else {
|
|
Err(HTTPError::NotFound)
|
|
}
|
|
}
|
|
|
|
/// Récupère les permissions directes d'un utilisateur dans un canal.
|
|
#[utoipa::path(
|
|
get,
|
|
path = "/channels/{channel_id}/permissions/users/{user_id}",
|
|
params(
|
|
("channel_id" = Uuid, Path, description = "ID du canal"),
|
|
("user_id" = Uuid, Path, description = "ID de l'utilisateur")
|
|
),
|
|
responses(
|
|
(status = 200, body = ChannelUserPermissionResponse),
|
|
(status = 404, description = "Permission introuvable"),
|
|
(status = 500, description = "Erreur interne du serveur")
|
|
),
|
|
tag = "Channel Permissions"
|
|
)]
|
|
pub async fn get_user_permission(
|
|
State(state): State<AppState>,
|
|
Path((channel_id, user_id)): Path<(Uuid, Uuid)>,
|
|
) -> Result<Json<ChannelUserPermissionResponse>, HTTPError> {
|
|
let permission = state
|
|
.repositories
|
|
.channel
|
|
.get_user_permission(channel_id, user_id)
|
|
.await?
|
|
.ok_or(HTTPError::NotFound)?;
|
|
|
|
Ok(Json(mapper::channel_user_permission_to_response(
|
|
permission,
|
|
)))
|
|
}
|
|
|
|
/// Définit ou remplace les permissions directes d'un utilisateur dans un canal.
|
|
#[utoipa::path(
|
|
put,
|
|
path = "/channels/{channel_id}/permissions/users/{user_id}",
|
|
request_body = SetChannelPermissionRequest,
|
|
params(
|
|
("channel_id" = Uuid, Path, description = "ID du canal"),
|
|
("user_id" = Uuid, Path, description = "ID de l'utilisateur")
|
|
),
|
|
responses(
|
|
(status = 200, body = ChannelUserPermissionResponse),
|
|
(status = 500, description = "Erreur interne du serveur")
|
|
),
|
|
tag = "Channel Permissions"
|
|
)]
|
|
pub async fn set_user_permission(
|
|
State(state): State<AppState>,
|
|
Path((channel_id, user_id)): Path<(Uuid, Uuid)>,
|
|
Json(payload): Json<SetChannelPermissionRequest>,
|
|
) -> Result<Json<ChannelUserPermissionResponse>, HTTPError> {
|
|
state
|
|
.services
|
|
.channel
|
|
.set_user_permission(channel_id, user_id, payload.permissions)
|
|
.await?;
|
|
|
|
let permission = state
|
|
.repositories
|
|
.channel
|
|
.get_user_permission(channel_id, user_id)
|
|
.await?
|
|
.ok_or(HTTPError::NotFound)?;
|
|
|
|
Ok(Json(mapper::channel_user_permission_to_response(
|
|
permission,
|
|
)))
|
|
}
|
|
|
|
/// Supprime les permissions directes d'un utilisateur dans un canal.
|
|
#[utoipa::path(
|
|
delete,
|
|
path = "/channels/{channel_id}/permissions/users/{user_id}",
|
|
params(
|
|
("channel_id" = Uuid, Path, description = "ID du canal"),
|
|
("user_id" = Uuid, Path, description = "ID de l'utilisateur")
|
|
),
|
|
responses(
|
|
(status = 204, description = "Permission supprimée"),
|
|
(status = 404, description = "Permission introuvable"),
|
|
(status = 500, description = "Erreur interne du serveur")
|
|
),
|
|
tag = "Channel Permissions"
|
|
)]
|
|
pub async fn remove_user_permission(
|
|
State(state): State<AppState>,
|
|
Path((channel_id, user_id)): Path<(Uuid, Uuid)>,
|
|
) -> Result<StatusCode, HTTPError> {
|
|
if state
|
|
.repositories
|
|
.channel
|
|
.get_user_permission(channel_id, user_id)
|
|
.await?
|
|
.is_none()
|
|
{
|
|
return Err(HTTPError::NotFound);
|
|
}
|
|
|
|
state
|
|
.services
|
|
.channel
|
|
.remove_user_permission(channel_id, user_id)
|
|
.await?;
|
|
|
|
Ok(StatusCode::NO_CONTENT)
|
|
}
|
|
|
|
/// Récupère les permissions d'un rôle dans un canal.
|
|
#[utoipa::path(
|
|
get,
|
|
path = "/channels/{channel_id}/permissions/roles/{role_id}",
|
|
params(
|
|
("channel_id" = Uuid, Path, description = "ID du canal"),
|
|
("role_id" = Uuid, Path, description = "ID du rôle")
|
|
),
|
|
responses(
|
|
(status = 200, body = ChannelRolePermissionResponse),
|
|
(status = 404, description = "Permission introuvable"),
|
|
(status = 500, description = "Erreur interne du serveur")
|
|
),
|
|
tag = "Channel Permissions"
|
|
)]
|
|
pub async fn get_role_permission(
|
|
State(state): State<AppState>,
|
|
Path((channel_id, role_id)): Path<(Uuid, Uuid)>,
|
|
) -> Result<Json<ChannelRolePermissionResponse>, HTTPError> {
|
|
let permission = state
|
|
.repositories
|
|
.channel
|
|
.get_role_permission(channel_id, role_id)
|
|
.await?
|
|
.ok_or(HTTPError::NotFound)?;
|
|
|
|
Ok(Json(mapper::channel_role_permission_to_response(
|
|
permission,
|
|
)))
|
|
}
|
|
|
|
/// Définit ou remplace les permissions d'un rôle dans un canal.
|
|
#[utoipa::path(
|
|
put,
|
|
path = "/channels/{channel_id}/permissions/roles/{role_id}",
|
|
request_body = SetChannelPermissionRequest,
|
|
params(
|
|
("channel_id" = Uuid, Path, description = "ID du canal"),
|
|
("role_id" = Uuid, Path, description = "ID du rôle")
|
|
),
|
|
responses(
|
|
(status = 200, body = ChannelRolePermissionResponse),
|
|
(status = 500, description = "Erreur interne du serveur")
|
|
),
|
|
tag = "Channel Permissions"
|
|
)]
|
|
pub async fn set_role_permission(
|
|
State(state): State<AppState>,
|
|
Path((channel_id, role_id)): Path<(Uuid, Uuid)>,
|
|
Json(payload): Json<SetChannelPermissionRequest>,
|
|
) -> Result<Json<ChannelRolePermissionResponse>, HTTPError> {
|
|
state
|
|
.services
|
|
.channel
|
|
.set_role_permission(channel_id, role_id, payload.permissions)
|
|
.await?;
|
|
|
|
let permission = state
|
|
.repositories
|
|
.channel
|
|
.get_role_permission(channel_id, role_id)
|
|
.await?
|
|
.ok_or(HTTPError::NotFound)?;
|
|
|
|
Ok(Json(mapper::channel_role_permission_to_response(
|
|
permission,
|
|
)))
|
|
}
|
|
|
|
/// Supprime les permissions d'un rôle dans un canal.
|
|
#[utoipa::path(
|
|
delete,
|
|
path = "/channels/{channel_id}/permissions/roles/{role_id}",
|
|
params(
|
|
("channel_id" = Uuid, Path, description = "ID du canal"),
|
|
("role_id" = Uuid, Path, description = "ID du rôle")
|
|
),
|
|
responses(
|
|
(status = 204, description = "Permission supprimée"),
|
|
(status = 404, description = "Permission introuvable"),
|
|
(status = 500, description = "Erreur interne du serveur")
|
|
),
|
|
tag = "Channel Permissions"
|
|
)]
|
|
pub async fn remove_role_permission(
|
|
State(state): State<AppState>,
|
|
Path((channel_id, role_id)): Path<(Uuid, Uuid)>,
|
|
) -> Result<StatusCode, HTTPError> {
|
|
if state
|
|
.repositories
|
|
.channel
|
|
.get_role_permission(channel_id, role_id)
|
|
.await?
|
|
.is_none()
|
|
{
|
|
return Err(HTTPError::NotFound);
|
|
}
|
|
|
|
state
|
|
.services
|
|
.channel
|
|
.remove_role_permission(channel_id, role_id)
|
|
.await?;
|
|
|
|
Ok(StatusCode::NO_CONTENT)
|
|
}
|