init

src/services/channel.rs

@@ -1,10 +1,11 @@
 use crate::domain::dto::channel::{CreateChannelRequest, UpdateChannelRequest};
+use crate::models::server_item_order::OrderedResourceType;
 use crate::models::{channel, role};
 use crate::permissions::PermissionSet;
 use crate::services::ServicesContext;
 use crate::services::permission::PermissionService;
 use sea_orm::{
-    ActiveModelTrait, ColumnTrait, EntityTrait, QueryFilter, QuerySelect, Set, TransactionTrait,
+    ActiveModelTrait, ColumnTrait, EntityTrait, QueryFilter, Set, TransactionTrait,
 };
 use std::sync::Arc;
 use uuid::Uuid;
@@ -25,6 +26,13 @@ impl ChannelService {
     ) -> Result<channel::Model, anyhow::Error> {
         let db = &self.service_context.repositories.server.context.db;
         let event_bus = &self.service_context.event_bus;
+        let server_order = self
+            .service_context
+            .services
+            .get()
+            .expect("services initialized")
+            .server_order
+            .clone();
 
         let channel = db
             .transaction::<_, channel::Model, anyhow::Error>(|txn| {
@@ -42,35 +50,15 @@ impl ChannelService {
 
                     // 2. Si server_id est présent, enregistrement de l'ordre d'affichage
                     if let Some(server_id) = payload.server_id {
-                        let max_order: Option<i64> =
-                            crate::models::server_item_order::Entity::find()
-                                .filter(
-                                    crate::models::server_item_order::Column::ServerId
-                                        .eq(server_id),
-                                )
-                                .select_only()
-                                .column_as(
-                                    crate::models::server_item_order::Column::OrderKey.max(),
-                                    "max_key",
-                                )
-                                .into_tuple::<Option<i64>>()
-                                .one(txn)
-                                .await?
-                                .flatten();
-
-                        let next_order = max_order.unwrap_or(0) + 1;
-
-                        let order_item = crate::models::server_item_order::ActiveModel {
-                            server_id: Set(server_id),
-                            resource_id: Set(channel.id),
-                            resource_type: Set(
-                                crate::models::server_item_order::OrderedResourceType::Channel,
-                            ),
-                            parent_category_id: Set(payload.category_id),
-                            order_key: Set(next_order),
-                            ..Default::default()
-                        };
-                        order_item.insert(txn).await?;
+                        server_order
+                            .append(
+                                txn,
+                                server_id,
+                                channel.id,
+                                OrderedResourceType::Channel,
+                                payload.category_id,
+                            )
+                            .await?;
 
                         // 3. Attribution des permissions par défaut au rôle par défaut
                         if let Some(default_role) = role::Entity::find()
@@ -130,17 +118,19 @@ impl ChannelService {
 
         let channel = active.update(&txn).await?;
 
-        // Update server_item_order parent_category_id or server_id if needed
-        if let Some(server_id) = channel.server_id {
-            crate::models::server_item_order::Entity::update_many()
-                .set(crate::models::server_item_order::ActiveModel {
-                    parent_category_id: Set(channel.category_id),
-                    ..Default::default()
-                })
-                .filter(crate::models::server_item_order::Column::ResourceId.eq(channel.id))
-                .exec(&txn)
-                .await?;
-        }
+        self.service_context
+            .services
+            .get()
+            .expect("services initialized")
+            .server_order
+            .sync(
+                &txn,
+                channel.id,
+                OrderedResourceType::Channel,
+                channel.server_id,
+                channel.category_id,
+            )
+            .await?;
 
         txn.commit().await?;
 
@@ -155,10 +145,12 @@ impl ChannelService {
 
         let txn = db.begin().await?;
 
-        // Delete associated order records
-        crate::models::server_item_order::Entity::delete_many()
-            .filter(crate::models::server_item_order::Column::ResourceId.eq(id))
-            .exec(&txn)
+        self.service_context
+            .services
+            .get()
+            .expect("services initialized")
+            .server_order
+            .remove(&txn, id, OrderedResourceType::Channel)
             .await?;
 
         let res = channel::Entity::delete_by_id(id).exec(&txn).await?;