main
use models::users::user_reports::{self, ReportStatus};
use models::users::{user_recent_mentions, user_saved_messages};
use sea_orm::{
ActiveModelTrait, ColumnTrait, EntityTrait, PaginatorTrait, QueryFilter, QueryOrder,
QuerySelect, Set,
};
use serde::{Deserialize, Serialize};
use time::OffsetDateTime;
use utoipa::ToSchema;
use uuid::Uuid;
use crate::errors::UserError;
use crate::services::service::UserService;
use crate::share::page::{Page, PageQuery};
#[derive(Debug, Clone, Serialize, Deserialize, ToSchema)]
pub struct RecentMentionDto {
pub id: Uuid,
pub channel_id: Uuid,
pub message_id: Uuid,
pub created_at: OffsetDateTime,
}
impl From<user_recent_mentions::Model> for RecentMentionDto {
fn from(m: user_recent_mentions::Model) -> Self {
Self {
id: m.id,
channel_id: m.channel_id,
message_id: m.message_id,
created_at: m.created_at,
}
}
}
#[derive(Debug, Clone, Serialize, Deserialize, ToSchema)]
pub struct UserReportDto {
pub id: Uuid,
pub reported_id: i64,
pub reason: String,
pub evidence: Option<String>,
pub status: ReportStatus,
pub resolution_note: Option<String>,
pub created_at: OffsetDateTime,
pub updated_at: OffsetDateTime,
}
impl From<user_reports::Model> for UserReportDto {
fn from(m: user_reports::Model) -> Self {
Self {
id: m.id,
reported_id: m.reported_uid,
reason: m.reason,
evidence: m.evidence,
status: m.status,
resolution_note: m.resolution_note,
created_at: m.created_at,
updated_at: m.updated_at,
}
}
}
#[derive(Debug, Clone, Serialize, Deserialize, ToSchema)]
pub struct SavedMessageDto {
pub id: Uuid,
pub channel_id: Uuid,
pub message_id: Uuid,
pub saved_at: OffsetDateTime,
}
impl From<user_saved_messages::Model> for SavedMessageDto {
fn from(m: user_saved_messages::Model) -> Self {
Self {
id: m.id,
channel_id: m.channel_id,
message_id: m.message_id,
saved_at: m.saved_at,
}
}
}
#[derive(Debug, Clone, Deserialize, ToSchema)]
pub struct SaveMessageCmd {
pub channel_id: Uuid,
pub message_id: Uuid,
}
impl UserService {
pub async fn recent_mentions(
&self,
uid: i64,
limit: Option<u64>,
) -> Result<Vec<RecentMentionDto>, UserError> {
let lim = limit.unwrap_or(50).clamp(1, 50);
let rows = user_recent_mentions::Entity::find()
.filter(user_recent_mentions::Column::UserId.eq(uid))
.order_by_desc(user_recent_mentions::Column::CreatedAt)
.limit(Some(lim))
.all(self.database.read())
.await?;
Ok(rows.into_iter().map(RecentMentionDto::from).collect())
}
pub async fn my_reports(
&self,
uid: i64,
q: PageQuery,
) -> Result<Page<UserReportDto>, UserError> {
let (limit, offset) = q.bounds()?;
let select =
user_reports::Entity::find().filter(user_reports::Column::ReporterUid.eq(Some(uid)));
let total = select.clone().count(self.database.read()).await?;
let rows = select
.order_by_desc(user_reports::Column::CreatedAt)
.limit(limit)
.offset(offset)
.all(self.database.read())
.await?;
let items = rows.into_iter().map(UserReportDto::from).collect();
Ok(Page::new(items, total, limit, offset))
}
pub async fn list_saved_messages(
&self,
uid: i64,
q: PageQuery,
) -> Result<Page<SavedMessageDto>, UserError> {
let (limit, offset) = q.bounds()?;
let select =
user_saved_messages::Entity::find().filter(user_saved_messages::Column::UserId.eq(uid));
let total = select.clone().count(self.database.read()).await?;
let rows = select
.order_by_desc(user_saved_messages::Column::SavedAt)
.limit(limit)
.offset(offset)
.all(self.database.read())
.await?;
let items = rows.into_iter().map(SavedMessageDto::from).collect();
Ok(Page::new(items, total, limit, offset))
}
#[tracing::instrument(name = "user.save_message", skip_all, fields(uid = %uid))]
pub async fn save_message(
&self,
uid: i64,
cmd: SaveMessageCmd,
) -> Result<SavedMessageDto, UserError> {
let existing = user_saved_messages::Entity::find()
.filter(user_saved_messages::Column::UserId.eq(uid))
.filter(user_saved_messages::Column::ChannelId.eq(cmd.channel_id))
.filter(user_saved_messages::Column::MessageId.eq(cmd.message_id))
.one(self.database.read())
.await?;
if let Some(row) = existing {
return Ok(SavedMessageDto::from(row));
}
let now = OffsetDateTime::now_utc();
let active = user_saved_messages::ActiveModel {
id: Set(Uuid::now_v7()),
user_id: Set(uid),
channel_id: Set(cmd.channel_id),
message_id: Set(cmd.message_id),
saved_at: Set(now),
};
let saved = active.insert(self.database.write()).await?;
Ok(SavedMessageDto::from(saved))
}
#[tracing::instrument(
name = "user.unsave_message",
skip_all,
fields(uid = %uid, message_id = %message_id)
)]
pub async fn unsave_message(&self, uid: i64, message_id: Uuid) -> Result<(), UserError> {
user_saved_messages::Entity::delete_many()
.filter(user_saved_messages::Column::UserId.eq(uid))
.filter(user_saved_messages::Column::MessageId.eq(message_id))
.exec(self.database.write())
.await?;
Ok(())
}
}