init

src/repositories/mod.rs

@@ -3,8 +3,8 @@ pub type AnyResult<T> = anyhow::Result<T>;
 use crate::repositories::category::CategoryRepository;
 use crate::repositories::channel::ChannelRepository;
 use crate::repositories::computed_permission::ComputedPermissionRepository;
-use crate::repositories::group::GroupRepository;
 use crate::repositories::message::MessageRepository;
+use crate::repositories::role::RoleRepository;
 use crate::repositories::server::ServerRepository;
 use crate::repositories::server_item_order::ServerItemOrderRepository;
 use crate::repositories::user::UserRepository;
@@ -15,8 +15,8 @@ use std::sync::Arc;
 mod category;
 mod channel;
 mod computed_permission;
-mod group;
 mod message;
+mod role;
 mod server;
 mod server_item_order;
 pub mod types;
@@ -33,7 +33,7 @@ pub struct Repositories {
     pub server: ServerRepository,
     pub category: CategoryRepository,
     pub channel: ChannelRepository,
-    pub group: GroupRepository,
+    pub role: RoleRepository,
     pub message: MessageRepository,
     pub user: UserRepository,
     pub computed_permission: ComputedPermissionRepository,
@@ -54,7 +54,7 @@ impl Repositories {
             channel: ChannelRepository {
                 context: context.clone(),
             },
-            group: GroupRepository {
+            role: RoleRepository {
                 context: context.clone(),
             },
             message: MessageRepository {

src/repositories/role.rs

@@ -1,15 +1,15 @@
-use crate::models::role;
+use crate::models::{role, role_user};
 use crate::repositories::{AnyResult, RepositoryContext};
-use sea_orm::{ActiveModelTrait, ColumnTrait, EntityTrait, QueryFilter};
+use sea_orm::{ActiveModelTrait, ColumnTrait, EntityTrait, QueryFilter, Set};
 use std::sync::Arc;
 use uuid::Uuid;
 
 #[derive(Clone, Debug)]
-pub struct GroupRepository {
+pub struct RoleRepository {
     pub context: Arc<RepositoryContext>,
 }
 
-impl GroupRepository {
+impl RoleRepository {
     pub async fn get_all_by_server(&self, server_id: Uuid) -> AnyResult<Vec<role::Model>> {
         Ok(role::Entity::find()
             .filter(role::Column::ServerId.eq(server_id))
@@ -17,6 +17,28 @@ impl GroupRepository {
             .await?)
     }
 
+    pub async fn get_default_by_server(&self, server_id: Uuid) -> AnyResult<Option<role::Model>> {
+        Ok(role::Entity::find()
+            .filter(role::Column::ServerId.eq(server_id))
+            .filter(role::Column::IsDefault.eq(true))
+            .one(&self.context.db)
+            .await?)
+    }
+
+    pub async fn add_to_default(&self, user_id: Uuid, server_id: Uuid) -> AnyResult<()> {
+        let default_role = self.get_default_by_server(server_id).await?;
+        if let Some(default_role) = default_role {
+            role_user::ActiveModel {
+                role_id: Set(default_role.id),
+                user_id: Set(user_id),
+                ..Default::default()
+            }
+            .insert(&self.context.db)
+            .await?;
+        }
+        Ok(())
+    }
+
     pub async fn get_all(&self) -> AnyResult<Vec<role::Model>> {
         Ok(role::Entity::find().all(&self.context.db).await?)
     }

src/routes/core/handlers.rs

@@ -52,11 +52,16 @@ pub async fn join(
         *init_token_lock = None;
     }
 
-    state
-        .repositories
-        .server
-        .add_user(state.default_server.id, user.id)
-        .await?;
+    tokio::try_join!(
+        state
+            .repositories
+            .server
+            .add_user(state.default_server.id, user.id),
+        state
+            .repositories
+            .role
+            .add_to_default(user.id, state.default_server.id)
+    )?;
 
     Ok(StatusCode::CREATED)
 }

src/routes/mod.rs

@@ -1,6 +1,6 @@
-use crate::http::middleware;
 use crate::http::OxRouter;
-use axum::{middleware as axum_middleware, Router};
+use crate::http::middleware;
+use axum::{Router, middleware as axum_middleware};
 use utoipa::OpenApi;
 use utoipa_swagger_ui::SwaggerUi;
 
@@ -10,9 +10,9 @@ pub mod category;
 pub mod channel;
 pub mod core;
 pub mod gateway;
-pub mod group;
 pub mod message;
 pub mod openapi;
+pub mod role;
 pub mod server;
 pub mod user;
 
@@ -22,7 +22,7 @@ pub fn router() -> OxRouter {
         .merge(server::routes::router())
         .merge(category::routes::router())
         .merge(channel::routes::router())
-        .merge(group::routes::router())
+        .merge(role::routes::router())
         .merge(message::routes::router())
         .merge(user::routes::router())
         .layer(axum_middleware::from_fn(middleware::require_auth));

src/routes/openapi.rs

@@ -30,11 +30,11 @@ use utoipa::{Modify, OpenApi};
         channel::handlers::create,
         channel::handlers::update,
         channel::handlers::delete,
-        group::handlers::get_all,
-        group::handlers::get_by_id,
-        group::handlers::create,
-        group::handlers::update,
-        group::handlers::delete,
+        role::handlers::get_all,
+        role::handlers::get_by_id,
+        role::handlers::create,
+        role::handlers::update,
+        role::handlers::delete,
         message::handlers::get_all,
         message::handlers::get_by_id,
         message::handlers::create,
@@ -59,9 +59,9 @@ use utoipa::{Modify, OpenApi};
             channel::dto::ChannelResponse,
             channel::dto::CreateChannelRequest,
             channel::dto::UpdateChannelRequest,
-            group::dto::GroupResponse,
-            group::dto::CreateGroupRequest,
-            group::dto::UpdateGroupRequest,
+            role::dto::RoleResponse,
+            role::dto::CreateRoleRequest,
+            role::dto::UpdateRoleRequest,
             message::dto::MessageResponse,
             message::dto::CreateMessageRequest,
             message::dto::UpdateMessageRequest,
@@ -76,7 +76,7 @@ use utoipa::{Modify, OpenApi};
         (name = "Servers", description = "Gestion des serveurs"),
         (name = "Categories", description = "Gestion des catégories"),
         (name = "Channels", description = "Gestion des salons"),
-        (name = "Groups", description = "Gestion des groupes"),
+        (name = "roles", description = "Gestion des rolees"),
         (name = "Messages", description = "Gestion des messages"),
         (name = "Core", description = "Endpoints de base (enregistrement, etc.)"),
     )

src/routes/role/dto.rs

@@ -4,7 +4,7 @@ use utoipa::ToSchema;
 use uuid::Uuid;
 
 #[derive(Debug, Serialize, Deserialize, ToSchema)]
-pub struct CreateGroupRequest {
+pub struct CreateRoleRequest {
     pub server_id: Uuid,
     #[schema(example = "Modérateurs")]
     pub name: String,
@@ -13,14 +13,14 @@ pub struct CreateGroupRequest {
 }
 
 #[derive(Debug, Serialize, Deserialize, ToSchema)]
-pub struct UpdateGroupRequest {
+pub struct UpdateRoleRequest {
     #[schema(example = "Modérateurs (MAJ)")]
     pub name: String,
     pub is_default: bool,
 }
 
 #[derive(Debug, Serialize, Deserialize, ToSchema)]
-pub struct GroupResponse {
+pub struct RoleResponse {
     pub id: Uuid,
     pub server_id: Uuid,
     pub name: String,

src/routes/role/handlers.rs

@@ -1,12 +1,12 @@
 use crate::core::state::AppState;
 use crate::http::context::Superuser;
 use crate::http::error::HTTPError;
-use crate::routes::group::dto::{CreateGroupRequest, GroupResponse, UpdateGroupRequest};
-use crate::routes::group::mapper;
+use crate::routes::role::dto::{CreateRoleRequest, RoleResponse, UpdateRoleRequest};
+use crate::routes::role::mapper;
 use axum::{
+    Json,
     extract::{Path, State},
     http::StatusCode,
-    Json,
 };
 use uuid::Uuid;
 
@@ -15,13 +15,13 @@ use uuid::Uuid;
     get,
     path = "/groups",
     responses(
-        (status = 200, description = "Liste des groupes récupérée avec succès", body = [GroupResponse]),
+        (status = 200, description = "Liste des groupes récupérée avec succès", body = [RoleResponse]),
         (status = 500, description = "Erreur interne du serveur")
     ),
-    tag = "Groups"
+    tag = "Roles"
 )]
-pub async fn get_all(State(state): State<AppState>) -> Result<Json<Vec<GroupResponse>>, HTTPError> {
-    let groups = state.repositories.group.get_all().await?;
+pub async fn get_all(State(state): State<AppState>) -> Result<Json<Vec<RoleResponse>>, HTTPError> {
+    let groups = state.repositories.role.get_all().await?;
     Ok(Json(
         groups
             .into_iter()
@@ -35,22 +35,22 @@ pub async fn get_all(State(state): State<AppState>) -> Result<Json<Vec<GroupResp
     get,
     path = "/groups/{id}",
     responses(
-        (status = 200, description = "Groupe trouvé", body = GroupResponse),
-        (status = 404, description = "Groupe non trouvé"),
+        (status = 200, description = "Rolee trouvé", body = RoleResponse),
+        (status = 404, description = "Rolee non trouvé"),
         (status = 500, description = "Erreur interne du serveur")
     ),
     params(
         ("id" = Uuid, Path, description = "ID du groupe")
     ),
-    tag = "Groups"
+    tag = "Roles"
 )]
 pub async fn get_by_id(
     State(state): State<AppState>,
     Path(id): Path<Uuid>,
-) -> Result<Json<GroupResponse>, HTTPError> {
+) -> Result<Json<RoleResponse>, HTTPError> {
     let group = state
         .repositories
-        .group
+        .role
         .get_by_id(id)
         .await?
         .ok_or(HTTPError::NotFound)?;
@@ -62,13 +62,13 @@ pub async fn get_by_id(
 #[utoipa::path(
     post,
     path = "/groups",
-    request_body = CreateGroupRequest,
+    request_body = CreateRoleRequest,
     responses(
-        (status = 201, description = "Groupe créé avec succès", body = GroupResponse),
+        (status = 201, description = "Role créé avec succès", body = RoleResponse),
         (status = 404, description = "Serveur non trouvé"),
         (status = 500, description = "Erreur interne du serveur")
     ),
-    tag = "Groups",
+    tag = "Roles",
     security(
         ("bearerAuth" = [])
     )
@@ -76,8 +76,8 @@ pub async fn get_by_id(
 pub async fn create(
     _admin: Superuser,
     State(state): State<AppState>,
-    Json(payload): Json<CreateGroupRequest>,
-) -> Result<(StatusCode, Json<GroupResponse>), HTTPError> {
+    Json(payload): Json<CreateRoleRequest>,
+) -> Result<(StatusCode, Json<RoleResponse>), HTTPError> {
     // Vérifier que le serveur existe
     state
         .repositories
@@ -87,7 +87,7 @@ pub async fn create(
         .ok_or(HTTPError::BadRequest("Server not found".to_string()))?;
 
     let active_model = mapper::create_request_to_am(payload);
-    let group = state.repositories.group.create(active_model).await?;
+    let group = state.repositories.role.create(active_model).await?;
     Ok((
         StatusCode::CREATED,
         Json(mapper::group_model_to_group_response(group)),
@@ -98,16 +98,16 @@ pub async fn create(
 #[utoipa::path(
     put,
     path = "/groups/{id}",
-    request_body = UpdateGroupRequest,
+    request_body = UpdateRoleRequest,
     responses(
-        (status = 200, description = "Groupe mis à jour avec succès", body = GroupResponse),
-        (status = 404, description = "Groupe non trouvé"),
+        (status = 200, description = "Role mis à jour avec succès", body = RoleResponse),
+        (status = 404, description = "Role non trouvé"),
         (status = 500, description = "Erreur interne du serveur")
     ),
     params(
         ("id" = Uuid, Path, description = "ID du groupe")
     ),
-    tag = "Groups",
+    tag = "Roles",
     security(
         ("bearerAuth" = [])
     )
@@ -116,18 +116,18 @@ pub async fn update(
     _admin: Superuser,
     State(state): State<AppState>,
     Path(id): Path<Uuid>,
-    Json(payload): Json<UpdateGroupRequest>,
-) -> Result<Json<GroupResponse>, HTTPError> {
+    Json(payload): Json<UpdateRoleRequest>,
+) -> Result<Json<RoleResponse>, HTTPError> {
     // Vérifier l'existence
     let group = state
         .repositories
-        .group
+        .role
         .get_by_id(id)
         .await?
         .ok_or(HTTPError::NotFound)?;
 
     let active_model = mapper::update_request_to_am(group.id, group.server_id, payload);
-    let group = state.repositories.group.update(active_model).await?;
+    let group = state.repositories.role.update(active_model).await?;
 
     Ok(Json(mapper::group_model_to_group_response(group)))
 }
@@ -137,14 +137,14 @@ pub async fn update(
     delete,
     path = "/groups/{id}",
     responses(
-        (status = 204, description = "Groupe supprimé avec succès"),
-        (status = 404, description = "Groupe non trouvé"),
+        (status = 204, description = "Role supprimé avec succès"),
+        (status = 404, description = "Role non trouvé"),
         (status = 500, description = "Erreur interne du serveur")
     ),
     params(
         ("id" = Uuid, Path, description = "ID du groupe")
     ),
-    tag = "Groups",
+    tag = "Roles",
     security(
         ("bearerAuth" = [])
     )
@@ -154,7 +154,7 @@ pub async fn delete(
     State(state): State<AppState>,
     Path(id): Path<Uuid>,
 ) -> Result<StatusCode, HTTPError> {
-    if state.repositories.group.delete(id).await? {
+    if state.repositories.role.delete(id).await? {
         Ok(StatusCode::NO_CONTENT)
     } else {
         Err(HTTPError::NotFound)

src/routes/role/mapper.rs

@@ -1,10 +1,10 @@
 use crate::models::role;
-use crate::routes::group::dto::{CreateGroupRequest, GroupResponse, UpdateGroupRequest};
+use crate::routes::role::dto::{CreateRoleRequest, RoleResponse, UpdateRoleRequest};
 use sea_orm::Set;
 use uuid::Uuid;
 
-pub fn group_model_to_group_response(model: role::Model) -> GroupResponse {
-    GroupResponse {
+pub fn group_model_to_group_response(model: role::Model) -> RoleResponse {
+    RoleResponse {
         id: model.id,
         server_id: model.server_id,
         name: model.name,
@@ -13,7 +13,7 @@ pub fn group_model_to_group_response(model: role::Model) -> GroupResponse {
     }
 }
 
-pub fn create_request_to_am(req: CreateGroupRequest) -> role::ActiveModel {
+pub fn create_request_to_am(req: CreateRoleRequest) -> role::ActiveModel {
     role::ActiveModel {
         id: Set(Uuid::new_v4()),
         server_id: Set(req.server_id),
@@ -26,7 +26,7 @@ pub fn create_request_to_am(req: CreateGroupRequest) -> role::ActiveModel {
 pub fn update_request_to_am(
     id: Uuid,
     server_id: Uuid,
-    req: UpdateGroupRequest,
+    req: UpdateRoleRequest,
 ) -> role::ActiveModel {
     role::ActiveModel {
         id: Set(id),