main
use models::chat::{messages, reactions};
use sea_orm::{ColumnTrait, EntityTrait, QueryFilter, QueryOrder, Set};
use serde::{Deserialize, Serialize};
use time::OffsetDateTime;
use utoipa::ToSchema;
use uuid::Uuid;
use crate::errors::ChatError;
use crate::services::service::ChatService;
use crate::share::lookup;
use crate::share::realtime::RoomEvent;
#[derive(Debug, Clone, Serialize, Deserialize, ToSchema)]
pub struct ReactionAggDto {
pub emoji: String,
pub count: i64,
pub me: bool,
}
#[derive(Debug, Clone, Serialize, ToSchema)]
pub struct ReactionUserDto {
pub emoji: String,
pub user: api::users::UserDto,
pub created_at: OffsetDateTime,
}
#[derive(Debug, Clone, Deserialize, ToSchema)]
pub struct ReactionCmd {
pub emoji: String,
}
impl ChatService {
pub async fn add_reaction(
&self,
caller: i64,
room_id: Uuid,
message_id: Uuid,
cmd: ReactionCmd,
) -> Result<Vec<ReactionAggDto>, ChatError> {
let emoji = cmd.emoji.trim().to_string();
if emoji.is_empty() || emoji.chars().count() > self.settings.chat.max_reaction_emoji_len {
return Err(ChatError::BadRequest("invalid emoji".to_string()));
}
let _ctx = lookup::require_room_readable(self, room_id, caller).await?;
let message = messages::Entity::find_by_id(message_id)
.filter(messages::Column::RoomId.eq(room_id))
.one(self.database.read())
.await?
.filter(|m| m.deleted_at.is_none())
.ok_or(ChatError::NotFound)?;
let _ = message;
let now = OffsetDateTime::now_utc();
let result = reactions::Entity::insert(reactions::ActiveModel {
message_id: Set(message_id),
emoji: Set(emoji.clone()),
user_id: Set(caller),
created_at: Set(now),
})
.exec(self.database.write())
.await;
match result {
Ok(_) => {}
Err(err) => {
let msg = err.to_string().to_lowercase();
if !(msg.contains("unique") || msg.contains("duplicate")) {
return Err(ChatError::from(err));
}
}
}
self.publish_reactions(room_id, message_id, caller).await
}
pub async fn remove_reaction(
&self,
caller: i64,
room_id: Uuid,
message_id: Uuid,
cmd: ReactionCmd,
) -> Result<Vec<ReactionAggDto>, ChatError> {
let emoji = cmd.emoji.trim().to_string();
let _ctx = lookup::require_room_readable(self, room_id, caller).await?;
reactions::Entity::delete_many()
.filter(reactions::Column::MessageId.eq(message_id))
.filter(reactions::Column::Emoji.eq(&emoji))
.filter(reactions::Column::UserId.eq(caller))
.exec(self.database.write())
.await?;
self.publish_reactions(room_id, message_id, caller).await
}
pub async fn list_message_reactions(
&self,
caller: i64,
room_id: Uuid,
message_id: Uuid,
) -> Result<Vec<ReactionUserDto>, ChatError> {
let _ctx = lookup::require_room_readable(self, room_id, caller).await?;
let rows = reactions::Entity::find()
.filter(reactions::Column::MessageId.eq(message_id))
.order_by_asc(reactions::Column::Emoji)
.order_by_asc(reactions::Column::CreatedAt)
.all(self.database.read())
.await?;
let uids: Vec<i64> = rows.iter().map(|r| r.user_id).collect();
let user_map = self.audience.load_user_briefs(&uids).await?;
Ok(rows
.into_iter()
.filter_map(|r| {
user_map.get(&r.user_id).map(|u| ReactionUserDto {
emoji: r.emoji,
user: u.clone(),
created_at: r.created_at,
})
})
.collect())
}
async fn publish_reactions(
&self,
room_id: Uuid,
message_id: Uuid,
viewer: i64,
) -> Result<Vec<ReactionAggDto>, ChatError> {
let rows = reactions::Entity::find()
.filter(reactions::Column::MessageId.eq(message_id))
.all(self.database.read())
.await?;
let mut agg: std::collections::HashMap<String, (i64, bool)> =
std::collections::HashMap::new();
for r in rows {
let entry = agg.entry(r.emoji).or_insert((0, false));
entry.0 += 1;
if r.user_id == viewer {
entry.1 = true;
}
}
let mut result: Vec<ReactionAggDto> = agg
.clone()
.into_iter()
.map(|(emoji, (count, me))| ReactionAggDto { emoji, count, me })
.collect();
result.sort_by(|a, b| a.emoji.cmp(&b.emoji));
// The room-wide event must be viewer-neutral: `me` is per-recipient
// state and only belongs in the HTTP response above.
let shared: Vec<serde_json::Value> = agg
.into_iter()
.map(|(emoji, (count, _))| serde_json::json!({ "emoji": emoji, "count": count }))
.collect();
let value = serde_json::to_value(&shared)?;
let event = RoomEvent::ReactionUpdated {
room_id,
user_id: viewer,
message_id,
reactions: value,
};
self.audience.realtime.publish_room(&event).await;
Ok(result)
}
}