130 lines
4.1 KiB
Rust
130 lines
4.1 KiB
Rust
use crate::domain::dto::server::{
|
|
CreateServerRequest, ServerExplorerItemResponse, ServerResponse, ServerRolePermissionResponse,
|
|
ServerTreeResponse, ServerUserPermissionResponse, UpdateServerRequest,
|
|
};
|
|
use crate::models::{
|
|
category, channel, server, server_item_order, server_role_permission, server_user_permission,
|
|
};
|
|
use crate::routes::category::mapper::category_model_to_category_response;
|
|
use crate::routes::channel::mapper::channel_model_to_channel_response;
|
|
use sea_orm::Set;
|
|
use std::collections::HashMap;
|
|
use uuid::Uuid;
|
|
|
|
pub fn server_model_to_server_response(model: server::Model) -> ServerResponse {
|
|
ServerResponse {
|
|
id: model.id,
|
|
name: model.name,
|
|
is_default: model.is_default,
|
|
created_at: model.created_at,
|
|
updated_at: model.updated_at,
|
|
}
|
|
}
|
|
|
|
pub fn create_request_to_am(req: CreateServerRequest) -> server::ActiveModel {
|
|
server::ActiveModel {
|
|
id: Set(Uuid::new_v4()),
|
|
name: Set(req.name),
|
|
password: Set(req.password),
|
|
is_default: Set(req.is_default),
|
|
..Default::default()
|
|
}
|
|
}
|
|
|
|
pub fn update_request_to_am(id: Uuid, req: UpdateServerRequest) -> server::ActiveModel {
|
|
server::ActiveModel {
|
|
id: Set(id),
|
|
name: Set(req.name),
|
|
password: Set(req.password),
|
|
is_default: Set(req.is_default),
|
|
..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,
|
|
}
|
|
}
|
|
|
|
pub fn build_server_tree(
|
|
orders: Vec<server_item_order::Model>,
|
|
channels: Vec<channel::Model>,
|
|
categories: Vec<category::Model>,
|
|
) -> ServerTreeResponse {
|
|
// Map d'accès rapide : resource_id -> order_key
|
|
let order_map: HashMap<Uuid, i64> = orders
|
|
.into_iter()
|
|
.map(|o| (o.resource_id, o.order_key))
|
|
.collect();
|
|
|
|
// Regrouper les canaux par catégorie ou orphelins
|
|
let mut category_channels: HashMap<Uuid, Vec<channel::Model>> = HashMap::new();
|
|
let mut orphan_channels: Vec<channel::Model> = Vec::new();
|
|
|
|
for chan in channels {
|
|
if let Some(cat_id) = chan.category_id {
|
|
category_channels.entry(cat_id).or_default().push(chan);
|
|
} else {
|
|
orphan_channels.push(chan);
|
|
}
|
|
}
|
|
|
|
// Trier les canaux dans chaque catégorie par leur order_key
|
|
for chans in category_channels.values_mut() {
|
|
chans.sort_by_key(|c| order_map.get(&c.id).copied().unwrap_or(i64::MAX));
|
|
}
|
|
|
|
// Préparer les éléments racine (catégories & canaux orphelins) avec leur order_key
|
|
let mut root_items: Vec<(ServerExplorerItemResponse, i64)> = Vec::new();
|
|
|
|
for cat in categories {
|
|
let cat_id = cat.id;
|
|
let order_key = order_map.get(&cat_id).copied().unwrap_or(i64::MAX);
|
|
let chans = category_channels.remove(&cat_id).unwrap_or_default();
|
|
|
|
let cat_response = category_model_to_category_response(cat);
|
|
let chan_responses = chans
|
|
.into_iter()
|
|
.map(channel_model_to_channel_response)
|
|
.collect();
|
|
|
|
root_items.push((
|
|
ServerExplorerItemResponse::Category(cat_response, chan_responses),
|
|
order_key,
|
|
));
|
|
}
|
|
|
|
for chan in orphan_channels {
|
|
let order_key = order_map.get(&chan.id).copied().unwrap_or(i64::MAX);
|
|
let chan_response = channel_model_to_channel_response(chan);
|
|
root_items.push((
|
|
ServerExplorerItemResponse::Channel(chan_response),
|
|
order_key,
|
|
));
|
|
}
|
|
|
|
// Tri du niveau racine par order_key
|
|
root_items.sort_by_key(|(_, order_key)| *order_key);
|
|
|
|
let items = root_items.into_iter().map(|(item, _)| item).collect();
|
|
|
|
ServerTreeResponse { items }
|
|
}
|