post services integrations

src/routes/category/handlers.rs

@@ -94,8 +94,7 @@ pub async fn create(
         .await?
         .ok_or(HTTPError::BadRequest("Server not found".to_string()))?;
 
-    let active_model = mapper::create_request_to_am(payload);
-    let category = state.repositories.category.create(active_model).await?;
+    let category = state.services.category.create_category(payload.server_id, payload.name).await?;
     Ok((
         StatusCode::CREATED,
         Json(mapper::category_model_to_category_response(category)),
@@ -127,15 +126,14 @@ pub async fn update(
     Json(payload): Json<UpdateCategoryRequest>,
 ) -> Result<Json<CategoryResponse>, HTTPError> {
     // Vérifier l'existence
-    let category = state
+    let _category = state
         .repositories
         .category
         .get_by_id(id)
         .await?
         .ok_or(HTTPError::NotFound)?;
 
-    let active_model = mapper::update_request_to_am(category.id, category.server_id, payload);
-    let category = state.repositories.category.update(active_model).await?;
+    let category = state.services.category.update_category(id, payload.name).await?;
 
     Ok(Json(mapper::category_model_to_category_response(category)))
 }
@@ -162,7 +160,7 @@ pub async fn delete(
     State(state): State<AppState>,
     Path(id): Path<Uuid>,
 ) -> Result<StatusCode, HTTPError> {
-    if state.repositories.category.delete(id).await? {
+    if state.services.category.delete_category(id).await? {
         Ok(StatusCode::NO_CONTENT)
     } else {
         Err(HTTPError::NotFound)

src/routes/channel/handlers.rs

@@ -109,8 +109,7 @@ pub async fn create(
             .ok_or(HTTPError::BadRequest("Category not found".to_string()))?;
     }
 
-    let active_model = mapper::create_request_to_am(payload);
-    let channel = state.repositories.channel.create(active_model).await?;
+    let channel = state.services.channel.create_channel(payload).await?;
     Ok((
         StatusCode::CREATED,
         Json(mapper::channel_model_to_channel_response(channel)),
@@ -170,8 +169,7 @@ pub async fn update(
             .ok_or(HTTPError::BadRequest("Category not found".to_string()))?;
     }
 
-    let active_model = mapper::update_request_to_am(id, payload);
-    let channel = state.repositories.channel.update(active_model).await?;
+    let channel = state.services.channel.update_channel(id, payload).await?;
 
     Ok(Json(mapper::channel_model_to_channel_response(channel)))
 }
@@ -198,7 +196,7 @@ pub async fn delete(
     State(state): State<AppState>,
     Path(id): Path<Uuid>,
 ) -> Result<StatusCode, HTTPError> {
-    if state.repositories.channel.delete(id).await? {
+    if state.services.channel.delete_channel(id).await? {
         Ok(StatusCode::NO_CONTENT)
     } else {
         Err(HTTPError::NotFound)
@@ -257,7 +255,7 @@ pub async fn set_user_permission(
     Json(payload): Json<SetChannelPermissionRequest>,
 ) -> Result<Json<ChannelUserPermissionResponse>, HTTPError> {
     state
-        .repositories
+        .services
         .channel
         .set_user_permission(channel_id, user_id, payload.permissions)
         .await?;
@@ -304,7 +302,7 @@ pub async fn remove_user_permission(
     }
 
     state
-        .repositories
+        .services
         .channel
         .remove_user_permission(channel_id, user_id)
         .await?;
@@ -364,7 +362,7 @@ pub async fn set_role_permission(
     Json(payload): Json<SetChannelPermissionRequest>,
 ) -> Result<Json<ChannelRolePermissionResponse>, HTTPError> {
     state
-        .repositories
+        .services
         .channel
         .set_role_permission(channel_id, role_id, payload.permissions)
         .await?;
@@ -411,7 +409,7 @@ pub async fn remove_role_permission(
     }
 
     state
-        .repositories
+        .services
         .channel
         .remove_role_permission(channel_id, role_id)
         .await?;

src/routes/message/handlers.rs

@@ -105,8 +105,7 @@ pub async fn create(
             ))?;
     }
 
-    let active_model = mapper::create_request_to_am(user.id, payload);
-    let message = state.repositories.message.create(active_model).await?;
+    let message = state.services.message.create_message(payload.channel_id, user.id, payload.content).await?;
     Ok((
         StatusCode::CREATED,
         Json(mapper::message_model_to_message_response(message)),
@@ -151,8 +150,7 @@ pub async fn update(
         return Err(HTTPError::Forbidden);
     }
 
-    let active_model = mapper::update_request_to_am(message, payload);
-    let message = state.repositories.message.update(active_model).await?;
+    let message = state.services.message.update_message(id, payload.content).await?;
 
     Ok(Json(mapper::message_model_to_message_response(message)))
 }
@@ -188,12 +186,11 @@ pub async fn delete(
         .await?
         .ok_or(HTTPError::NotFound)?;
 
-    // Autoriser si auteur ou superuser
     if message.user_id != user.id && !user.is_superuser {
         return Err(HTTPError::Forbidden);
     }
 
-    if state.repositories.message.delete(id).await? {
+    if state.services.message.delete_message(id).await? {
         Ok(StatusCode::NO_CONTENT)
     } else {
         Err(HTTPError::NotFound)

src/routes/role/handlers.rs

@@ -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.role.create(active_model).await?;
+    let group = state.services.role.create_role(active_model).await?;
     Ok((
         StatusCode::CREATED,
         Json(mapper::group_model_to_group_response(group)),
@@ -127,7 +127,7 @@ pub async fn update(
         .ok_or(HTTPError::NotFound)?;
 
     let active_model = mapper::update_request_to_am(group.id, group.server_id, payload);
-    let group = state.repositories.role.update(active_model).await?;
+    let group = state.services.role.update_role(active_model).await?;
 
     Ok(Json(mapper::group_model_to_group_response(group)))
 }
@@ -154,7 +154,7 @@ pub async fn delete(
     State(state): State<AppState>,
     Path(id): Path<Uuid>,
 ) -> Result<StatusCode, HTTPError> {
-    if state.repositories.role.delete(id).await? {
+    if state.services.role.delete_role(id).await? {
         Ok(StatusCode::NO_CONTENT)
     } else {
         Err(HTTPError::NotFound)

src/routes/server/handlers.rs

@@ -83,8 +83,7 @@ pub async fn create(
     State(state): State<AppState>,
     Json(payload): Json<CreateServerRequest>,
 ) -> Result<(StatusCode, Json<ServerResponse>), HTTPError> {
-    let active_model = mapper::create_request_to_am(payload);
-    let server = state.repositories.server.create(active_model).await?;
+    let server = state.services.server.create_server(payload.name, payload.is_default).await?;
     Ok((
         StatusCode::CREATED,
         Json(mapper::server_model_to_server_response(server)),
@@ -116,15 +115,14 @@ pub async fn update(
     Json(payload): Json<UpdateServerRequest>,
 ) -> Result<Json<ServerResponse>, HTTPError> {
     // Vérifier l'existence
-    let server = state
+    let _server = state
         .repositories
         .server
         .get_by_id(id)
         .await?
         .ok_or(HTTPError::NotFound)?;
 
-    let active_model = mapper::update_request_to_am(server.id, payload);
-    let server = state.repositories.server.update(active_model).await?;
+    let server = state.services.server.update_server(id, payload.name, payload.is_default).await?;
 
     Ok(Json(mapper::server_model_to_server_response(server)))
 }
@@ -151,7 +149,7 @@ pub async fn delete(
     State(state): State<AppState>,
     Path(id): Path<Uuid>,
 ) -> Result<StatusCode, HTTPError> {
-    if state.repositories.server.delete(id).await? {
+    if state.services.server.delete_server(id).await? {
         Ok(StatusCode::NO_CONTENT)
     } else {
         Err(HTTPError::NotFound)

src/routes/user/handlers.rs

@@ -107,7 +107,7 @@ pub async fn create(
     let active_model = mapper::create_request_to_am(payload)
         .map_err(|e| HTTPError::InternalServerError(e.to_string()))?;
 
-    let user = state.repositories.user.create(active_model).await?;
+    let user = state.services.user.create_user(active_model).await?;
     Ok((
         StatusCode::CREATED,
         Json(mapper::user_model_to_user_response(user)),
@@ -160,7 +160,7 @@ pub async fn update(
     }
 
     let active_model = mapper::update_request_to_am(user.id, payload);
-    let user = state.repositories.user.update(active_model).await?;
+    let user = state.services.user.update_user(active_model).await?;
 
     Ok(Json(mapper::user_model_to_user_response(user)))
 }
@@ -189,7 +189,7 @@ pub async fn delete(
     State(state): State<AppState>,
     Path(id): Path<Uuid>,
 ) -> Result<StatusCode, HTTPError> {
-    if state.repositories.user.delete(id).await? {
+    if state.services.user.delete_user(id).await? {
         Ok(StatusCode::NO_CONTENT)
     } else {
         Err(HTTPError::NotFound)