oxpanel/oxspeak_server
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

init

Browse Source
This commit is contained in:
Nell
2026-07-18 00:49:23 +02:00
parent 94b012465a
commit 23998b9ea9
11 changed files with 688 additions and 10 deletions
Download Patch File Download Diff File Expand all files Collapse all files
migration/src/m20220101_000001_create_table.rs
+6
View File
@@ -481,6 +481,12 @@ impl MigrationTrait for Migration {
Table::create()
.table(Alias::new("server_user_permission"))
.if_not_exists()
.col(
ColumnDef::new(Alias::new("id"))
.uuid()
.not_null()
.primary_key(),
)
.col(ColumnDef::new(Alias::new("server_id")).uuid().not_null())
.col(ColumnDef::new(Alias::new("user_id")).uuid().not_null())
.col(
src/repositories/channel.rs
+106 -4
View File
@@ -1,7 +1,9 @@
use crate::models::channel;
use crate::models::{channel, channel_role_permission, channel_user_permission};
use crate::repositories::{AnyResult, RepositoryContext};
use sea_orm::{ActiveModelTrait, EntityTrait};
use sea_orm::sea_query::OnConflict;
use sea_orm::{ActiveModelTrait, ColumnTrait, EntityTrait, QueryFilter, Set};
use std::sync::Arc;
use uuid::Uuid;
#[derive(Clone, Debug)]
pub struct ChannelRepository {
@@ -9,7 +11,7 @@ pub struct ChannelRepository {
}
impl ChannelRepository {
pub async fn get_by_id(&self, id: uuid::Uuid) -> AnyResult<Option<channel::Model>> {
pub async fn get_by_id(&self, id: Uuid) -> AnyResult<Option<channel::Model>> {
Ok(channel::Entity::find_by_id(id)
.one(&self.context.db)
.await?)
@@ -31,11 +33,111 @@ impl ChannelRepository {
Ok(channel)
}
pub async fn delete(&self, id: uuid::Uuid) -> AnyResult<bool> {
pub async fn delete(&self, id: Uuid) -> AnyResult<bool> {
let res = channel::Entity::delete_by_id(id)
.exec(&self.context.db)
.await?;
self.context.events.emit("channel_deleted", id);
Ok(res.rows_affected > 0)
}
pub async fn get_user_permission(
&self,
channel_id: Uuid,
user_id: Uuid,
) -> AnyResult<Option<channel_user_permission::Model>> {
Ok(channel_user_permission::Entity::find()
.filter(channel_user_permission::Column::ChannelId.eq(channel_id))
.filter(channel_user_permission::Column::UserId.eq(user_id))
.one(&self.context.db)
.await?)
}
pub async fn set_user_permission(
&self,
channel_id: Uuid,
user_id: Uuid,
permissions: u64,
) -> AnyResult<()> {
let permission = channel_user_permission::ActiveModel {
channel_id: Set(channel_id),
user_id: Set(user_id),
permissions: Set(permissions as i64),
..Default::default()
};
channel_user_permission::Entity::insert(permission)
.on_conflict(
OnConflict::columns([
channel_user_permission::Column::ChannelId,
channel_user_permission::Column::UserId,
])
.update_columns([channel_user_permission::Column::Permissions])
.to_owned(),
)
.exec(&self.context.db)
.await?;
Ok(())
}
pub async fn remove_user_permission(&self, channel_id: Uuid, user_id: Uuid) -> AnyResult<()> {
channel_user_permission::Entity::delete_many()
.filter(channel_user_permission::Column::ChannelId.eq(channel_id))
.filter(channel_user_permission::Column::UserId.eq(user_id))
.exec(&self.context.db)
.await?;
Ok(())
}
pub async fn get_role_permission(
&self,
channel_id: Uuid,
role_id: Uuid,
) -> AnyResult<Option<channel_role_permission::Model>> {
Ok(channel_role_permission::Entity::find()
.filter(channel_role_permission::Column::ChannelId.eq(channel_id))
.filter(channel_role_permission::Column::RoleId.eq(role_id))
.one(&self.context.db)
.await?)
}
pub async fn set_role_permission(
&self,
channel_id: Uuid,
role_id: Uuid,
permissions: u64,
) -> AnyResult<()> {
let permission = channel_role_permission::ActiveModel {
channel_id: Set(channel_id),
role_id: Set(role_id),
permissions: Set(permissions as i64),
..Default::default()
};
channel_role_permission::Entity::insert(permission)
.on_conflict(
OnConflict::columns([
channel_role_permission::Column::ChannelId,
channel_role_permission::Column::RoleId,
])
.update_columns([channel_role_permission::Column::Permissions])
.to_owned(),
)
.exec(&self.context.db)
.await?;
Ok(())
}
pub async fn remove_role_permission(&self, channel_id: Uuid, role_id: Uuid) -> AnyResult<()> {
channel_role_permission::Entity::delete_many()
.filter(channel_role_permission::Column::ChannelId.eq(channel_id))
.filter(channel_role_permission::Column::RoleId.eq(role_id))
.exec(&self.context.db)
.await?;
Ok(())
}
}
src/repositories/server.rs
+24
View File
@@ -104,6 +104,18 @@ impl ServerRepository {
Ok(res as usize)
}
pub async fn get_user_permission(
&self,
server_id: Uuid,
user_id: Uuid,
) -> AnyResult<Option<server_user_permission::Model>> {
Ok(server_user_permission::Entity::find()
.filter(server_user_permission::Column::ServerId.eq(server_id))
.filter(server_user_permission::Column::UserId.eq(user_id))
.one(&self.context.db)
.await?)
}
pub async fn set_user_permission(
&self,
server_id: Uuid,
@@ -140,6 +152,18 @@ impl ServerRepository {
Ok(())
}
pub async fn get_role_permission(
&self,
server_id: Uuid,
role_id: Uuid,
) -> AnyResult<Option<server_role_permission::Model>> {
Ok(server_role_permission::Entity::find()
.filter(server_role_permission::Column::ServerId.eq(server_id))
.filter(server_role_permission::Column::RoleId.eq(role_id))
.one(&self.context.db)
.await?)
}
pub async fn set_role_permission(
&self,
server_id: Uuid,
src/routes/channel/dto.rs
+23
View File
@@ -35,3 +35,26 @@ pub struct ChannelResponse {
pub created_at: DateTime<Utc>,
pub updated_at: DateTime<Utc>,
}
#[derive(Debug, Serialize, Deserialize, ToSchema)]
pub struct SetChannelPermissionRequest {
/// Bitmask des permissions à appliquer.
#[schema(example = 15)]
pub permissions: u64,
}
#[derive(Debug, Serialize, ToSchema)]
pub struct ChannelUserPermissionResponse {
pub id: Uuid,
pub channel_id: Uuid,
pub user_id: Uuid,
pub permissions: u64,
}
#[derive(Debug, Serialize, ToSchema)]
pub struct ChannelRolePermissionResponse {
pub id: Uuid,
pub channel_id: Uuid,
pub role_id: Uuid,
pub permissions: u64,
}
src/routes/channel/handlers.rs
+218 -1
View File
@@ -1,7 +1,10 @@
use crate::core::state::AppState;
use crate::http::context::Superuser;
use crate::http::error::HTTPError;
use crate::routes::channel::dto::{ChannelResponse, CreateChannelRequest, UpdateChannelRequest};
use crate::routes::channel::dto::{
ChannelResponse, ChannelRolePermissionResponse, ChannelUserPermissionResponse,
CreateChannelRequest, SetChannelPermissionRequest, UpdateChannelRequest,
};
use crate::routes::channel::mapper;
use axum::{
extract::{Path, State},
@@ -195,3 +198,217 @@ pub async fn delete(
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
.repositories
.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
.repositories
.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
.repositories
.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
.repositories
.channel
.remove_role_permission(channel_id, role_id)
.await?;
Ok(StatusCode::NO_CONTENT)
}
src/routes/channel/mapper.rs
+27 -2
View File
@@ -1,5 +1,8 @@
use crate::models::channel;
use crate::routes::channel::dto::{ChannelResponse, CreateChannelRequest, UpdateChannelRequest};
use crate::models::{channel, channel_role_permission, channel_user_permission};
use crate::routes::channel::dto::{
ChannelResponse, ChannelRolePermissionResponse, ChannelUserPermissionResponse,
CreateChannelRequest, UpdateChannelRequest,
};
use sea_orm::Set;
use uuid::Uuid;
@@ -39,3 +42,25 @@ pub fn update_request_to_am(id: Uuid, req: UpdateChannelRequest) -> channel::Act
..Default::default()
}
}
pub fn channel_user_permission_to_response(
model: channel_user_permission::Model,
) -> ChannelUserPermissionResponse {
ChannelUserPermissionResponse {
id: model.id,
channel_id: model.channel_id,
user_id: model.user_id,
permissions: model.permissions as u64,
}
}
pub fn channel_role_permission_to_response(
model: channel_role_permission::Model,
) -> ChannelRolePermissionResponse {
ChannelRolePermissionResponse {
id: model.id,
channel_id: model.channel_id,
role_id: model.role_id,
permissions: model.permissions as u64,
}
}
src/routes/channel/routes.rs
+12
View File
@@ -11,4 +11,16 @@ pub fn router() -> Router<AppState> {
.put(handlers::update)
.delete(handlers::delete),
)
.route(
"/channels/{channel_id}/permissions/users/{user_id}",
get(handlers::get_user_permission)
.put(handlers::set_user_permission)
.delete(handlers::remove_user_permission),
)
.route(
"/channels/{channel_id}/permissions/roles/{role_id}",
get(handlers::get_role_permission)
.put(handlers::set_role_permission)
.delete(handlers::remove_role_permission),
)
}
src/routes/server/dto.rs
+23
View File
@@ -27,3 +27,26 @@ pub struct ServerResponse {
pub created_at: DateTime<Utc>,
pub updated_at: DateTime<Utc>,
}
#[derive(Debug, Serialize, Deserialize, ToSchema)]
pub struct SetServerPermissionRequest {
/// Bitmask des permissions à appliquer.
#[schema(example = 7)]
pub permissions: u64,
}
#[derive(Debug, Serialize, ToSchema)]
pub struct ServerUserPermissionResponse {
pub id: Uuid,
pub server_id: Uuid,
pub user_id: Uuid,
pub permissions: u64,
}
#[derive(Debug, Serialize, ToSchema)]
pub struct ServerRolePermissionResponse {
pub id: Uuid,
pub server_id: Uuid,
pub role_id: Uuid,
pub permissions: u64,
}
src/routes/server/handlers.rs
+210 -1
View File
@@ -1,7 +1,10 @@
use crate::core::state::AppState;
use crate::http::context::Superuser;
use crate::http::error::HTTPError;
use crate::routes::server::dto::{CreateServerRequest, ServerResponse, UpdateServerRequest};
use crate::routes::server::dto::{
CreateServerRequest, ServerResponse, ServerRolePermissionResponse,
ServerUserPermissionResponse, SetServerPermissionRequest, UpdateServerRequest,
};
use crate::routes::server::mapper;
use axum::{
extract::{Path, State},
@@ -153,3 +156,209 @@ pub async fn delete(
Err(HTTPError::NotFound)
}
}
/// Récupère les permissions directes d'un utilisateur sur un serveur.
#[utoipa::path(
get,
path = "/servers/{server_id}/permissions/users/{user_id}",
params(
("server_id" = Uuid, Path, description = "ID du serveur"),
("user_id" = Uuid, Path, description = "ID de l'utilisateur")
),
responses(
(status = 200, body = ServerUserPermissionResponse),
(status = 404, description = "Permission introuvable"),
(status = 500, description = "Erreur interne du serveur")
),
tag = "Server Permissions"
)]
pub async fn get_user_permission(
State(state): State<AppState>,
Path((server_id, user_id)): Path<(Uuid, Uuid)>,
) -> Result<Json<ServerUserPermissionResponse>, HTTPError> {
let permission = state
.repositories
.server
.get_user_permission(server_id, user_id)
.await?
.ok_or(HTTPError::NotFound)?;
Ok(Json(mapper::server_user_permission_to_response(permission)))
}
/// Définit ou remplace les permissions directes d'un utilisateur sur un serveur.
#[utoipa::path(
put,
path = "/servers/{server_id}/permissions/users/{user_id}",
request_body = SetServerPermissionRequest,
params(
("server_id" = Uuid, Path, description = "ID du serveur"),
("user_id" = Uuid, Path, description = "ID de l'utilisateur")
),
responses(
(status = 200, body = ServerUserPermissionResponse),
(status = 500, description = "Erreur interne du serveur")
),
tag = "Server Permissions"
)]
pub async fn set_user_permission(
State(state): State<AppState>,
Path((server_id, user_id)): Path<(Uuid, Uuid)>,
Json(payload): Json<SetServerPermissionRequest>,
) -> Result<Json<ServerUserPermissionResponse>, HTTPError> {
state
.repositories
.server
.set_user_permission(server_id, user_id, payload.permissions)
.await?;
let permission = state
.repositories
.server
.get_user_permission(server_id, user_id)
.await?
.ok_or(HTTPError::NotFound)?;
Ok(Json(mapper::server_user_permission_to_response(permission)))
}
/// Supprime les permissions directes d'un utilisateur sur un serveur.
#[utoipa::path(
delete,
path = "/servers/{server_id}/permissions/users/{user_id}",
params(
("server_id" = Uuid, Path, description = "ID du serveur"),
("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 = "Server Permissions"
)]
pub async fn remove_user_permission(
State(state): State<AppState>,
Path((server_id, user_id)): Path<(Uuid, Uuid)>,
) -> Result<StatusCode, HTTPError> {
if state
.repositories
.server
.get_user_permission(server_id, user_id)
.await?
.is_none()
{
return Err(HTTPError::NotFound);
}
state
.repositories
.server
.remove_user_permission(server_id, user_id)
.await?;
Ok(StatusCode::NO_CONTENT)
}
/// Récupère les permissions d'un rôle sur un serveur.
#[utoipa::path(
get,
path = "/servers/{server_id}/permissions/roles/{role_id}",
params(
("server_id" = Uuid, Path, description = "ID du serveur"),
("role_id" = Uuid, Path, description = "ID du rôle")
),
responses(
(status = 200, body = ServerRolePermissionResponse),
(status = 404, description = "Permission introuvable"),
(status = 500, description = "Erreur interne du serveur")
),
tag = "Server Permissions"
)]
pub async fn get_role_permission(
State(state): State<AppState>,
Path((server_id, role_id)): Path<(Uuid, Uuid)>,
) -> Result<Json<ServerRolePermissionResponse>, HTTPError> {
let permission = state
.repositories
.server
.get_role_permission(server_id, role_id)
.await?
.ok_or(HTTPError::NotFound)?;
Ok(Json(mapper::server_role_permission_to_response(permission)))
}
/// Définit ou remplace les permissions d'un rôle sur un serveur.
#[utoipa::path(
put,
path = "/servers/{server_id}/permissions/roles/{role_id}",
request_body = SetServerPermissionRequest,
params(
("server_id" = Uuid, Path, description = "ID du serveur"),
("role_id" = Uuid, Path, description = "ID du rôle")
),
responses(
(status = 200, body = ServerRolePermissionResponse),
(status = 500, description = "Erreur interne du serveur")
),
tag = "Server Permissions"
)]
pub async fn set_role_permission(
State(state): State<AppState>,
Path((server_id, role_id)): Path<(Uuid, Uuid)>,
Json(payload): Json<SetServerPermissionRequest>,
) -> Result<Json<ServerRolePermissionResponse>, HTTPError> {
state
.repositories
.server
.set_role_permission(server_id, role_id, payload.permissions)
.await?;
let permission = state
.repositories
.server
.get_role_permission(server_id, role_id)
.await?
.ok_or(HTTPError::NotFound)?;
Ok(Json(mapper::server_role_permission_to_response(permission)))
}
/// Supprime les permissions d'un rôle sur un serveur.
#[utoipa::path(
delete,
path = "/servers/{server_id}/permissions/roles/{role_id}",
params(
("server_id" = Uuid, Path, description = "ID du serveur"),
("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 = "Server Permissions"
)]
pub async fn remove_role_permission(
State(state): State<AppState>,
Path((server_id, role_id)): Path<(Uuid, Uuid)>,
) -> Result<StatusCode, HTTPError> {
if state
.repositories
.server
.get_role_permission(server_id, role_id)
.await?
.is_none()
{
return Err(HTTPError::NotFound);
}
state
.repositories
.server
.remove_role_permission(server_id, role_id)
.await?;
Ok(StatusCode::NO_CONTENT)
}
src/routes/server/mapper.rs
+27 -2
View File
@@ -1,5 +1,8 @@
use crate::models::server;
use crate::routes::server::dto::{CreateServerRequest, ServerResponse, UpdateServerRequest};
use crate::models::{server, server_role_permission, server_user_permission};
use crate::routes::server::dto::{
CreateServerRequest, ServerResponse, ServerRolePermissionResponse,
ServerUserPermissionResponse, UpdateServerRequest,
};
use sea_orm::Set;
use uuid::Uuid;
@@ -32,3 +35,25 @@ pub fn update_request_to_am(id: Uuid, req: UpdateServerRequest) -> server::Activ
..Default::default()
}
}
pub fn server_user_permission_to_response(
model: server_user_permission::Model,
) -> ServerUserPermissionResponse {
ServerUserPermissionResponse {
id: model.id,
server_id: model.server_id,
user_id: model.user_id,
permissions: model.permissions as u64,
}
}
pub fn server_role_permission_to_response(
model: server_role_permission::Model,
) -> ServerRolePermissionResponse {
ServerRolePermissionResponse {
id: model.id,
server_id: model.server_id,
role_id: model.role_id,
permissions: model.permissions as u64,
}
}
src/routes/server/routes.rs
+12
View File
@@ -11,4 +11,16 @@ pub fn router() -> Router<AppState> {
.put(handlers::update)
.delete(handlers::delete),
)
.route(
"/servers/{server_id}/permissions/users/{user_id}",
get(handlers::get_user_permission)
.put(handlers::set_user_permission)
.delete(handlers::remove_user_permission),
)
.route(
"/servers/{server_id}/permissions/roles/{role_id}",
get(handlers::get_role_permission)
.put(handlers::set_role_permission)
.delete(handlers::remove_role_permission),
)
}