post services integrations

src/services/server.rs

@@ -0,0 +1,153 @@
+use crate::repositories::Repositories;
+use crate::services::ServicesContext;
+use crate::models::{role, server};
+use sea_orm::{ActiveModelTrait, ColumnTrait, EntityTrait, QueryFilter, QuerySelect, QueryOrder, TransactionTrait, Set};
+use std::sync::Arc;
+use uuid::Uuid;
+
+#[derive(Debug, Clone)]
+pub struct ServerService {
+    service_context: Arc<ServicesContext>,
+}
+
+impl ServerService {
+    pub fn new(service_context: Arc<ServicesContext>) -> Self {
+        Self { service_context }
+    }
+
+    pub async fn create_server(
+        &self,
+        name: String,
+        is_default: bool,
+    ) -> Result<server::Model, anyhow::Error> {
+        let db = &self.service_context.repositories.server.context.db;
+        let event_bus = &self.service_context.event_bus;
+
+        let txn = db.begin().await?;
+
+        let active = server::ActiveModel {
+            name: Set(name),
+            is_default: Set(is_default),
+            ..Default::default()
+        };
+        let srv = active.insert(&txn).await?;
+
+        let default_group = role::ActiveModel {
+            server_id: Set(srv.id),
+            name: Set("Member".to_string()),
+            is_default: Set(true),
+            ..Default::default()
+        };
+        default_group.insert(&txn).await?;
+
+        txn.commit().await?;
+
+        event_bus.emit("server_created", srv.clone());
+
+        Ok(srv)
+    }
+
+    pub async fn update_server(
+        &self,
+        id: Uuid,
+        name: String,
+        is_default: bool,
+    ) -> Result<server::Model, anyhow::Error> {
+        let db = &self.service_context.repositories.server.context.db;
+        let event_bus = &self.service_context.event_bus;
+
+        let txn = db.begin().await?;
+
+        let existing = server::Entity::find_by_id(id)
+            .one(&txn)
+            .await?
+            .ok_or_else(|| anyhow::anyhow!("Server not found"))?;
+
+        let mut active: server::ActiveModel = existing.into();
+        active.name = Set(name);
+        active.is_default = Set(is_default);
+
+        let srv = active.update(&txn).await?;
+
+        txn.commit().await?;
+
+        event_bus.emit("server_updated", srv.clone());
+
+        Ok(srv)
+    }
+
+    pub async fn delete_server(&self, id: Uuid) -> Result<bool, anyhow::Error> {
+        let db = &self.service_context.repositories.server.context.db;
+        let event_bus = &self.service_context.event_bus;
+
+        let txn = db.begin().await?;
+
+        let res = server::Entity::delete_by_id(id)
+            .exec(&txn)
+            .await?;
+
+        let deleted = res.rows_affected > 0;
+
+        txn.commit().await?;
+
+        if deleted {
+            event_bus.emit("server_deleted", id);
+        }
+
+        Ok(deleted)
+    }
+
+    pub async fn add_user(&self, server_id: Uuid, user_id: Uuid) -> Result<bool, anyhow::Error> {
+        let db = &self.service_context.repositories.server.context.db;
+        let event_bus = &self.service_context.event_bus;
+
+        let txn = db.begin().await?;
+
+        crate::models::server_user::ActiveModel {
+            server_id: Set(server_id),
+            user_id: Set(user_id),
+            ..Default::default()
+        }
+        .insert(&txn)
+        .await?;
+
+        let role_id: Uuid = role::Entity::find()
+            .filter(role::Column::ServerId.eq(server_id))
+            .filter(role::Column::IsDefault.eq(true))
+            .select_only()
+            .column(role::Column::Id)
+            .into_tuple::<Uuid>()
+            .one(&txn)
+            .await?
+            .ok_or_else(|| anyhow::anyhow!("Rôle par défaut introuvable"))?;
+
+        txn.commit().await?;
+
+        event_bus.emit("server_user_created", (server_id, user_id));
+
+        Ok(true)
+    }
+
+    pub async fn remove_user(&self, server_id: Uuid, user_id: Uuid) -> Result<bool, anyhow::Error> {
+        let db = &self.service_context.repositories.server.context.db;
+        let event_bus = &self.service_context.event_bus;
+
+        let txn = db.begin().await?;
+
+        let res = crate::models::server_user::Entity::delete_many()
+            .filter(crate::models::server_user::Column::ServerId.eq(server_id))
+            .filter(crate::models::server_user::Column::UserId.eq(user_id))
+            .exec(&txn)
+            .await?;
+
+        let deleted = res.rows_affected > 0;
+
+        txn.commit().await?;
+
+        if deleted {
+            event_bus.emit("server_user_deleted", (server_id, user_id));
+        }
+
+        Ok(deleted)
+    }
+}