oxpanel/oxspeak_server
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

add event_bus_typed

Browse Source
This commit is contained in:
Nell
2026-09-23 10:36:14 +02:00
parent 3780092fa6
commit ab97dcc8d9
35 changed files with 1376 additions and 3228 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/services/category.rs
+10 -3
View File
@@ -1,3 +1,6 @@
use crate::domain::events::category::{
CategoryCreatedEvent, CategoryDeletedEvent, CategoryUpdatedEvent,
};
use crate::models::category;
use crate::models::server_item_order::OrderedResourceType;
use crate::services::ServicesContext;
@@ -49,7 +52,9 @@ impl CategoryService {
})
.await?;
event_bus.emit("category_created", cat.clone());
event_bus.emit(CategoryCreatedEvent {
category: cat.clone(),
});
Ok(cat)
}
@@ -76,7 +81,9 @@ impl CategoryService {
txn.commit().await?;
event_bus.emit("category_updated", cat.clone());
event_bus.emit(CategoryUpdatedEvent {
category: cat.clone(),
});
Ok(cat)
}
@@ -107,7 +114,7 @@ impl CategoryService {
txn.commit().await?;
if deleted {
event_bus.emit("category_deleted", existing);
event_bus.emit(CategoryDeletedEvent { category: existing });
}
Ok(deleted)
src/services/channel.rs
+44 -21
View File
@@ -2,6 +2,10 @@ use crate::domain::dto::channel::{CreateChannelRequest, UpdateChannelRequest};
use crate::domain::events::channel::{
ChannelCreatedEvent, ChannelDeletedEvent, ChannelUpdatedEvent,
};
use crate::domain::events::channel_permission::{
ChannelRolePermissionUpdatedEvent, ChannelUserPermissionCreatedEvent,
ChannelUserPermissionDeletedEvent,
};
use crate::models::server_item_order::OrderedResourceType;
use crate::models::{channel, role};
use crate::permissions::PermissionSet;
@@ -91,12 +95,9 @@ impl ChannelService {
.await?;
// Post-commit event emission
event_bus.emit(
"channel_created",
ChannelCreatedEvent {
channel: channel.clone(),
},
);
event_bus.emit(ChannelCreatedEvent {
channel: channel.clone(),
});
Ok(channel)
}
@@ -141,13 +142,10 @@ impl ChannelService {
txn.commit().await?;
event_bus.emit(
"channel_updated",
ChannelUpdatedEvent {
previous,
channel: channel.clone(),
},
);
event_bus.emit(ChannelUpdatedEvent {
previous,
channel: channel.clone(),
});
Ok(channel)
}
@@ -178,7 +176,7 @@ impl ChannelService {
txn.commit().await?;
if deleted {
event_bus.emit("channel_deleted", ChannelDeletedEvent { channel: existing });
event_bus.emit(ChannelDeletedEvent { channel: existing });
}
Ok(deleted)
@@ -214,12 +212,15 @@ impl ChannelService {
.exec(&txn)
.await?;
let permission = crate::models::channel_user_permission::Entity::find()
.filter(crate::models::channel_user_permission::Column::ChannelId.eq(channel_id))
.filter(crate::models::channel_user_permission::Column::UserId.eq(user_id))
.one(&txn)
.await?
.ok_or_else(|| anyhow::anyhow!("Permission not found"))?;
txn.commit().await?;
event_bus.emit(
"channel_user_permission_created",
(channel_id, user_id, permissions),
);
event_bus.emit(ChannelUserPermissionCreatedEvent { permission });
Ok(())
}
@@ -234,6 +235,11 @@ impl ChannelService {
let txn = db.begin().await?;
let existing = crate::models::channel_user_permission::Entity::find()
.filter(crate::models::channel_user_permission::Column::ChannelId.eq(channel_id))
.filter(crate::models::channel_user_permission::Column::UserId.eq(user_id))
.one(&txn)
.await?;
crate::models::channel_user_permission::Entity::delete_many()
.filter(crate::models::channel_user_permission::Column::ChannelId.eq(channel_id))
.filter(crate::models::channel_user_permission::Column::UserId.eq(user_id))
@@ -242,7 +248,9 @@ impl ChannelService {
txn.commit().await?;
event_bus.emit("channel_user_permission_deleted", (channel_id, user_id));
if let Some(permission) = existing {
event_bus.emit(ChannelUserPermissionDeletedEvent { permission });
}
Ok(())
}
@@ -285,9 +293,19 @@ impl ChannelService {
.exec(&txn)
.await?;
let permission = crate::models::channel_role_permission::Entity::find()
.filter(crate::models::channel_role_permission::Column::ChannelId.eq(channel_id))
.filter(crate::models::channel_role_permission::Column::RoleId.eq(role_id))
.one(&txn)
.await?;
txn.commit().await?;
event_bus.emit("channel_role_permission_updated", (role_id, server_id));
event_bus.emit(ChannelRolePermissionUpdatedEvent {
channel_id,
server_id,
role_id,
permission,
});
Ok(())
}
@@ -318,7 +336,12 @@ impl ChannelService {
txn.commit().await?;
event_bus.emit("channel_role_permission_updated", (role_id, server_id));
event_bus.emit(ChannelRolePermissionUpdatedEvent {
channel_id,
server_id,
role_id,
permission: None,
});
Ok(())
}
src/services/message.rs
+20 -56
View File
@@ -3,7 +3,6 @@ use crate::domain::events::message::{
};
use crate::models::{attachment, channel, message};
use crate::services::ServicesContext;
use event_bus::Scope;
use sea_orm::{
ActiveModelTrait, ColumnTrait, EntityTrait, QueryFilter, QuerySelect, Set, TransactionTrait,
};
@@ -41,9 +40,6 @@ impl MessageService {
txn.commit().await?;
let mut scopes: Vec<Scope> = Vec::new();
scopes.push(Scope::uuid("channel", msg.channel_id));
let server_id: Option<Uuid> = channel::Entity::find_by_id(msg.channel_id)
.select_only()
.column(channel::Column::ServerId)
@@ -52,19 +48,11 @@ impl MessageService {
.await?
.flatten();
if let Some(server_id) = server_id {
scopes.push(Scope::uuid("server", server_id));
}
event_bus.emit_scoped(
"message_created",
scopes,
MessageCreatedEvent {
server_id,
channel_id: msg.channel_id,
message: msg.clone(),
},
);
event_bus.emit(MessageCreatedEvent {
server_id,
channel_id: msg.channel_id,
message: msg.clone(),
});
Ok(msg)
}
@@ -119,19 +107,11 @@ impl MessageService {
.one(db)
.await?
.flatten();
let mut scopes = vec![Scope::uuid("channel", msg.channel_id)];
if let Some(server_id) = server_id {
scopes.push(Scope::uuid("server", server_id));
}
event_bus.emit_scoped(
"message_created",
scopes,
MessageCreatedEvent {
server_id,
channel_id: msg.channel_id,
message: msg.clone(),
},
);
event_bus.emit(MessageCreatedEvent {
server_id,
channel_id: msg.channel_id,
message: msg.clone(),
});
Ok(msg)
}
@@ -165,19 +145,11 @@ impl MessageService {
.await?
.flatten();
let mut scopes = vec![Scope::uuid("channel", msg.channel_id)];
if let Some(server_id) = server_id {
scopes.push(Scope::uuid("server", server_id));
}
event_bus.emit_scoped(
"message_updated",
scopes,
MessageUpdatedEvent {
server_id,
channel_id: msg.channel_id,
message: msg.clone(),
},
);
event_bus.emit(MessageUpdatedEvent {
server_id,
channel_id: msg.channel_id,
message: msg.clone(),
});
Ok(msg)
}
@@ -208,19 +180,11 @@ impl MessageService {
txn.commit().await?;
if deleted {
let mut scopes = vec![Scope::uuid("channel", existing.channel_id)];
if let Some(server_id) = server_id {
scopes.push(Scope::uuid("server", server_id));
}
event_bus.emit_scoped(
"message_deleted",
scopes,
MessageDeletedEvent {
server_id,
channel_id: existing.channel_id,
message: existing,
},
);
event_bus.emit(MessageDeletedEvent {
server_id,
channel_id: existing.channel_id,
message: existing,
});
}
Ok(deleted)
src/services/message_reaction.rs
+10 -27
View File
@@ -3,7 +3,6 @@ use crate::domain::events::message::{MessageReactionAddedEvent, MessageReactionR
use crate::http::error::HTTPError;
use crate::models::{emoji, message_reaction};
use crate::services::ServicesContext;
use event_bus::Scope;
use sea_orm::{ColumnTrait, EntityTrait, QueryFilter, Set};
use std::collections::HashMap;
use std::sync::Arc;
@@ -117,19 +116,11 @@ impl MessageReactionService {
})
.await?;
let mut scopes = vec![Scope::uuid("channel", message.channel_id)];
if let Some(server_id) = server_id {
scopes.push(Scope::uuid("server", server_id));
}
self.context.event_bus.emit_scoped(
"message_reaction_added",
scopes,
MessageReactionAddedEvent {
server_id,
channel_id: message.channel_id,
reaction: reaction.clone(),
},
);
self.context.event_bus.emit(MessageReactionAddedEvent {
server_id,
channel_id: message.channel_id,
reaction: reaction.clone(),
});
Ok((reaction, true))
}
@@ -151,19 +142,11 @@ impl MessageReactionService {
.await?
.ok_or(HTTPError::NotFound)?;
let mut scopes = vec![Scope::uuid("channel", message.channel_id)];
if let Some(server_id) = server_id {
scopes.push(Scope::uuid("server", server_id));
}
self.context.event_bus.emit_scoped(
"message_reaction_removed",
scopes,
MessageReactionRemovedEvent {
server_id,
channel_id: message.channel_id,
reaction: reaction.clone(),
},
);
self.context.event_bus.emit(MessageReactionRemovedEvent {
server_id,
channel_id: message.channel_id,
reaction: reaction.clone(),
});
Ok(reaction)
}
src/services/permission_sync.rs
+73 -50
View File
@@ -1,6 +1,16 @@
use crate::domain::events::channel::{ChannelCreatedEvent, ChannelDeletedEvent};
use crate::domain::events::channel_permission::{
ChannelRolePermissionUpdatedEvent, ChannelUserPermissionCreatedEvent,
ChannelUserPermissionDeletedEvent, ChannelUserPermissionUpdatedEvent,
};
use crate::domain::events::role::{RoleUserCreatedEvent, RoleUserDeletedEvent};
use crate::domain::events::server::{
ServerCreatedEvent, ServerUserCreatedEvent, ServerUserDeletedEvent,
};
use crate::domain::events::server_permission::{
ServerRolePermissionUpdatedEvent, ServerUserPermissionUpdatedEvent,
};
use crate::domain::events::server_tree::ServerTreeInvalidatedEvent;
use crate::models::server;
use crate::repositories::Repositories;
use crate::services::ServicesContext;
use event_bus::EventBus;
@@ -60,13 +70,10 @@ pub struct PermissionSyncService {
impl PermissionSyncService {
fn invalidate_tree(event_bus: &Arc<EventBus>, server_id: Uuid, user_ids: Option<Vec<Uuid>>) {
event_bus.emit(
"server_tree_invalidated",
ServerTreeInvalidatedEvent {
server_id,
user_ids,
},
);
event_bus.emit(ServerTreeInvalidatedEvent {
server_id,
user_ids,
});
}
pub fn new(service_context: Arc<ServicesContext>) -> Self {
@@ -83,18 +90,18 @@ impl PermissionSyncService {
// Événements Serveur & Membres Serveur
// ---------------------------------------------------------------------
let notify = event_bus.clone();
event_bus.on_async_with(
"server_created",
event_bus.on_async_with::<ServerCreatedEvent, _>(
repositories.clone(),
move |repositories, server: server::Model| async move {
Self::sync_server(repositories, server.id).await;
move |repositories, event| async move {
Self::sync_server(repositories, event.server.id).await;
},
);
event_bus.on_async_with(
"server_user_created",
event_bus.on_async_with::<ServerUserCreatedEvent, _>(
repositories.clone(),
move |repositories, (server_id, user_id): (Uuid, Uuid)| {
move |repositories, event| {
let server_id = event.server_user.server_id;
let user_id = event.server_user.user_id;
let notify = notify.clone();
async move {
Self::sync_user(repositories, user_id, server_id).await;
@@ -104,10 +111,11 @@ impl PermissionSyncService {
);
let notify = event_bus.clone();
event_bus.on_async_with(
"server_user_deleted",
event_bus.on_async_with::<ServerUserDeletedEvent, _>(
repositories.clone(),
move |repositories, (server_id, user_id): (Uuid, Uuid)| {
move |repositories, event| {
let server_id = event.server_user.server_id;
let user_id = event.server_user.user_id;
let notify = notify.clone();
async move {
Self::sync_user(repositories, user_id, server_id).await;
@@ -121,10 +129,11 @@ impl PermissionSyncService {
// ---------------------------------------------------------------------
let notify = event_bus.clone();
event_bus.on_async_with(
"role_user_created",
event_bus.on_async_with::<RoleUserCreatedEvent, _>(
repositories.clone(),
move |repositories, (_role_id, user_id, server_id): (Uuid, Uuid, Uuid)| {
move |repositories, event| {
let server_id = event.server_id;
let user_id = event.role_user.user_id;
let notify = notify.clone();
async move {
Self::sync_user(repositories, user_id, server_id).await;
@@ -134,10 +143,11 @@ impl PermissionSyncService {
);
let notify = event_bus.clone();
event_bus.on_async_with(
"role_user_deleted",
event_bus.on_async_with::<RoleUserDeletedEvent, _>(
repositories.clone(),
move |repositories, (_role_id, user_id, server_id): (Uuid, Uuid, Uuid)| {
move |repositories, event| {
let server_id = event.server_id;
let user_id = event.role_user.user_id;
let notify = notify.clone();
async move {
Self::sync_user(repositories, user_id, server_id).await;
@@ -151,10 +161,11 @@ impl PermissionSyncService {
// ---------------------------------------------------------------------
let notify = event_bus.clone();
event_bus.on_async_with(
"server_role_permission_updated",
event_bus.on_async_with::<ServerRolePermissionUpdatedEvent, _>(
repositories.clone(),
move |repositories, (role_id, server_id): (Uuid, Uuid)| {
move |repositories, event| {
let role_id = event.role_id;
let server_id = event.server_id;
let notify = notify.clone();
async move {
Self::sync_role_members(repositories, role_id, server_id).await;
@@ -164,10 +175,11 @@ impl PermissionSyncService {
);
let notify = event_bus.clone();
event_bus.on_async_with(
"server_user_permission_updated",
event_bus.on_async_with::<ServerUserPermissionUpdatedEvent, _>(
repositories.clone(),
move |repositories, (server_id, user_id): (Uuid, Uuid)| {
move |repositories, event| {
let server_id = event.server_id;
let user_id = event.user_id;
let notify = notify.clone();
async move {
Self::sync_user(repositories, user_id, server_id).await;
@@ -181,10 +193,9 @@ impl PermissionSyncService {
// ---------------------------------------------------------------------
let notify = event_bus.clone();
event_bus.on_async_with(
"channel_created",
event_bus.on_async_with::<ChannelCreatedEvent, _>(
repositories.clone(),
move |repositories, event: ChannelCreatedEvent| {
move |repositories, event| {
let notify = notify.clone();
async move {
if let Some(server_id) = event.channel.server_id {
@@ -196,10 +207,9 @@ impl PermissionSyncService {
);
let notify = event_bus.clone();
event_bus.on_async_with(
"channel_deleted",
event_bus.on_async_with::<ChannelDeletedEvent, _>(
repositories.clone(),
move |repositories, event: ChannelDeletedEvent| {
move |repositories, event| {
let notify = notify.clone();
async move {
if let Some(server_id) = event.channel.server_id {
@@ -211,10 +221,11 @@ impl PermissionSyncService {
);
let notify = event_bus.clone();
event_bus.on_async_with(
"channel_role_permission_updated",
event_bus.on_async_with::<ChannelRolePermissionUpdatedEvent, _>(
repositories.clone(),
move |repositories, (role_id, server_id): (Uuid, Uuid)| {
move |repositories, event| {
let role_id = event.role_id;
let server_id = event.server_id;
let notify = notify.clone();
async move {
Self::sync_role_members(repositories, role_id, server_id).await;
@@ -224,23 +235,34 @@ impl PermissionSyncService {
);
let notify = event_bus.clone();
event_bus.on_async_with(
"channel_user_permission_updated",
event_bus.on_async_with::<ChannelUserPermissionUpdatedEvent, _>(
repositories.clone(),
move |repositories, (server_id, user_id): (Uuid, Uuid)| {
move |repositories, event| {
let user_id = event.user_id;
let notify = notify.clone();
async move {
Self::sync_user(repositories, user_id, server_id).await;
Self::invalidate_tree(&notify, server_id, Some(vec![user_id]));
if let Some(channel) = repositories
.channel
.get_by_id(event.channel_id)
.await
.ok()
.flatten()
{
if let Some(server_id) = channel.server_id {
Self::sync_user(repositories, user_id, server_id).await;
Self::invalidate_tree(&notify, server_id, Some(vec![user_id]));
}
}
}
},
);
let notify = event_bus.clone();
event_bus.on_async_with(
"channel_user_permission_created",
event_bus.on_async_with::<ChannelUserPermissionCreatedEvent, _>(
repositories.clone(),
move |repositories, (channel_id, user_id, _permissions): (Uuid, Uuid, u64)| {
move |repositories, event| {
let channel_id = event.permission.channel_id;
let user_id = event.permission.user_id;
let notify = notify.clone();
async move {
if let Some(channel) = repositories
@@ -260,10 +282,11 @@ impl PermissionSyncService {
);
let notify = event_bus.clone();
event_bus.on_async_with(
"channel_user_permission_deleted",
event_bus.on_async_with::<ChannelUserPermissionDeletedEvent, _>(
repositories,
move |repositories, (channel_id, user_id): (Uuid, Uuid)| {
move |repositories, event| {
let channel_id = event.permission.channel_id;
let user_id = event.permission.user_id;
let notify = notify.clone();
async move {
if let Some(channel) = repositories
src/services/realtime_registry.rs
+17 -12
View File
@@ -1,3 +1,8 @@
use crate::domain::events::channel_permission::{
ChannelUserPermissionCreatedEvent, ChannelUserPermissionDeletedEvent,
ChannelUserPermissionUpdatedEvent,
};
use crate::domain::events::server_permission::ServerUserPermissionUpdatedEvent;
use crate::models::{channel, channel_user, computed_permission::PermissionScopeType};
use crate::permissions::ChannelPermission;
use crate::repositories::Repositories;
@@ -204,10 +209,10 @@ impl RealtimeRegistry {
event_bus: Arc<EventBus>,
) {
let registry = Arc::clone(self);
event_bus.on_async_with(
"channel_user_permission_updated",
event_bus.on_async_with::<ChannelUserPermissionUpdatedEvent, _>(
repositories.clone(),
move |repositories, (_channel_id, user_id, _permissions): (Uuid, Uuid, u64)| {
move |repositories, event| {
let user_id = event.user_id;
let registry = Arc::clone(&registry);
async move {
if let Err(error) = registry.refresh_user(&repositories, user_id).await {
@@ -218,10 +223,10 @@ impl RealtimeRegistry {
);
let registry = Arc::clone(self);
event_bus.on_async_with(
"channel_user_permission_created",
event_bus.on_async_with::<ChannelUserPermissionCreatedEvent, _>(
repositories.clone(),
move |repositories, (_channel_id, user_id, _permissions): (Uuid, Uuid, u64)| {
move |repositories, event| {
let user_id = event.permission.user_id;
let registry = Arc::clone(&registry);
async move {
if let Err(error) = registry.refresh_user(&repositories, user_id).await {
@@ -232,10 +237,10 @@ impl RealtimeRegistry {
);
let registry = Arc::clone(self);
event_bus.on_async_with(
"channel_user_permission_deleted",
event_bus.on_async_with::<ChannelUserPermissionDeletedEvent, _>(
repositories.clone(),
move |repositories, (_channel_id, user_id): (Uuid, Uuid)| {
move |repositories, event| {
let user_id = event.permission.user_id;
let registry = Arc::clone(&registry);
async move {
if let Err(error) = registry.refresh_user(&repositories, user_id).await {
@@ -247,10 +252,10 @@ impl RealtimeRegistry {
let registry = Arc::clone(self);
let repositories = repositories.clone();
event_bus.on_async_with(
"server_user_permission_updated",
event_bus.on_async_with::<ServerUserPermissionUpdatedEvent, _>(
repositories,
move |repositories, (_server_id, user_id): (Uuid, Uuid)| {
move |repositories, event| {
let user_id = event.user_id;
let registry = Arc::clone(&registry);
async move {
if let Err(error) = registry.refresh_user(&repositories, user_id).await {
src/services/role.rs
+26 -12
View File
@@ -1,4 +1,8 @@
use crate::models::role;
use crate::domain::events::role::{
RoleCreatedEvent, RoleDeletedEvent, RoleUpdatedEvent, RoleUserCreatedEvent,
RoleUserDeletedEvent,
};
use crate::models::{role, role_user};
use crate::services::ServicesContext;
use sea_orm::{ActiveModelTrait, EntityTrait, TransactionTrait};
use std::sync::Arc;
@@ -27,7 +31,7 @@ impl RoleService {
txn.commit().await?;
event_bus.emit("role_created", role.clone());
event_bus.emit(RoleCreatedEvent { role: role.clone() });
Ok(role)
}
@@ -45,7 +49,7 @@ impl RoleService {
txn.commit().await?;
event_bus.emit("role_updated", role.clone());
event_bus.emit(RoleUpdatedEvent { role: role.clone() });
Ok(role)
}
@@ -56,14 +60,15 @@ impl RoleService {
let txn = db.begin().await?;
let existing = role::Entity::find_by_id(id).one(&txn).await?;
let res = role::Entity::delete_by_id(id).exec(&txn).await?;
let deleted = res.rows_affected > 0;
txn.commit().await?;
if deleted {
event_bus.emit("role_deleted", id);
if let Some(role) = existing.filter(|_| deleted) {
event_bus.emit(RoleDeletedEvent { role });
}
Ok(deleted)
@@ -82,9 +87,14 @@ impl RoleService {
.add_member(role_id, user_id)
.await?;
if added {
self.service_context
.event_bus
.emit("role_user_created", (role_id, user_id, server_id));
let role_user = role_user::Entity::find_by_id((role_id, user_id))
.one(&self.service_context.repositories.server.context.db)
.await?
.ok_or_else(|| anyhow::anyhow!("Role membership not found"))?;
self.service_context.event_bus.emit(RoleUserCreatedEvent {
role_user,
server_id,
});
}
Ok(added)
}
@@ -95,16 +105,20 @@ impl RoleService {
user_id: Uuid,
server_id: Uuid,
) -> Result<bool, anyhow::Error> {
let existing = role_user::Entity::find_by_id((role_id, user_id))
.one(&self.service_context.repositories.server.context.db)
.await?;
let removed = self
.service_context
.repositories
.role
.remove_member(role_id, user_id)
.await?;
if removed {
self.service_context
.event_bus
.emit("role_user_deleted", (role_id, user_id, server_id));
if let Some(role_user) = existing.filter(|_| removed) {
self.service_context.event_bus.emit(RoleUserDeletedEvent {
role_user,
server_id,
});
}
Ok(removed)
}
src/services/server.rs
+29 -9
View File
@@ -1,3 +1,7 @@
use crate::domain::events::server::{
ServerCreatedEvent, ServerDeletedEvent, ServerUpdatedEvent, ServerUserCreatedEvent,
ServerUserDeletedEvent,
};
use crate::models::{role, role_user, server, server_user};
use crate::services::ServicesContext;
use sea_orm::{
@@ -63,7 +67,9 @@ impl ServerService {
txn.commit().await?;
event_bus.emit("server_created", srv.clone());
event_bus.emit(ServerCreatedEvent {
server: srv.clone(),
});
Ok(srv)
}
@@ -97,7 +103,7 @@ impl ServerService {
return Ok(srv);
}
server_user::ActiveModel {
let membership = server_user::ActiveModel {
server_id: Set(server_id),
user_id: Set(user_id),
..Default::default()
@@ -119,7 +125,9 @@ impl ServerService {
.await?;
txn.commit().await?;
event_bus.emit("server_user_created", (server_id, user_id));
event_bus.emit(ServerUserCreatedEvent {
server_user: membership,
});
self.service_context
.repositories
.read_state
@@ -152,7 +160,9 @@ impl ServerService {
txn.commit().await?;
event_bus.emit("server_updated", srv.clone());
event_bus.emit(ServerUpdatedEvent {
server: srv.clone(),
});
Ok(srv)
}
@@ -182,7 +192,10 @@ impl ServerService {
txn.commit().await?;
if deleted {
event_bus.emit("server_deleted", (existing, audience));
event_bus.emit(ServerDeletedEvent {
server: existing,
audience,
});
}
Ok(deleted)
@@ -194,7 +207,7 @@ impl ServerService {
let txn = db.begin().await?;
crate::models::server_user::ActiveModel {
let membership = crate::models::server_user::ActiveModel {
server_id: Set(server_id),
user_id: Set(user_id),
..Default::default()
@@ -214,7 +227,9 @@ impl ServerService {
txn.commit().await?;
event_bus.emit("server_user_created", (server_id, user_id));
event_bus.emit(ServerUserCreatedEvent {
server_user: membership,
});
Ok(true)
}
@@ -225,6 +240,11 @@ impl ServerService {
let txn = db.begin().await?;
let membership = server_user::Entity::find()
.filter(server_user::Column::ServerId.eq(server_id))
.filter(server_user::Column::UserId.eq(user_id))
.one(&txn)
.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))
@@ -235,8 +255,8 @@ impl ServerService {
txn.commit().await?;
if deleted {
event_bus.emit("server_user_deleted", (server_id, user_id));
if let Some(server_user) = membership.filter(|_| deleted) {
event_bus.emit(ServerUserDeletedEvent { server_user });
}
Ok(deleted)
src/services/user.rs
+9 -5
View File
@@ -1,4 +1,7 @@
use crate::auth::password;
use crate::domain::events::user::{
UserChangedEvent, UserCreatedEvent, UserDeletedEvent, UserUpdatedEvent,
};
use crate::models::{role, user};
use crate::services::ServicesContext;
use sea_orm::{
@@ -30,7 +33,7 @@ impl UserService {
txn.commit().await?;
event_bus.emit("user_created", usr.clone());
event_bus.emit(UserCreatedEvent { user: usr.clone() });
Ok(usr)
}
@@ -48,7 +51,7 @@ impl UserService {
txn.commit().await?;
event_bus.emit("user_updated", usr.clone());
event_bus.emit(UserUpdatedEvent { user: usr.clone() });
Ok(usr)
}
@@ -79,7 +82,7 @@ impl UserService {
txn.commit().await?;
event_bus.emit("user_changed", usr);
event_bus.emit(UserChangedEvent { user: usr });
Ok(())
}
@@ -90,14 +93,15 @@ impl UserService {
let txn = db.begin().await?;
let existing = user::Entity::find_by_id(id).one(&txn).await?;
let res = user::Entity::delete_by_id(id).exec(&txn).await?;
let deleted = res.rows_affected > 0;
txn.commit().await?;
if deleted {
event_bus.emit("user_deleted", id);
if let Some(user) = existing.filter(|_| deleted) {
event_bus.emit(UserDeletedEvent { user });
}
Ok(deleted)