194c44c
use models::chat::room_bookmarks;
use sea_orm::sea_query::Expr;
use sea_orm::{
ActiveModelTrait, ColumnTrait, EntityTrait, ExprTrait, QueryFilter, QueryOrder, QuerySelect,
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::require_room_readable;
#[derive(Debug, Clone, Serialize, ToSchema)]
pub struct BookmarkDto {
pub id: Uuid,
pub room_id: Uuid,
pub title: String,
pub url: Option<String>,
pub emoji: Option<String>,
pub position: i64,
pub created_by_id: i64,
pub created_at: OffsetDateTime,
}
#[derive(Debug, Clone, Deserialize, ToSchema)]
pub struct CreateBookmarkCmd {
pub title: String,
#[serde(default)]
pub url: Option<String>,
#[serde(default)]
pub emoji: Option<String>,
}
#[derive(Debug, Clone, Deserialize, ToSchema)]
pub struct UpdateBookmarkCmd {
#[serde(default)]
pub title: Option<String>,
#[serde(default)]
pub url: Option<String>,
#[serde(default)]
pub emoji: Option<String>,
#[serde(default)]
pub position: Option<i64>,
}
impl From<room_bookmarks::Model> for BookmarkDto {
fn from(b: room_bookmarks::Model) -> Self {
Self {
id: b.id,
room_id: b.room_id,
title: b.title,
url: b.url,
emoji: b.emoji,
position: b.position,
created_by_id: b.user_id,
created_at: b.created_at,
}
}
}
impl ChatService {
pub async fn list_bookmarks(
&self,
caller: i64,
room_id: Uuid,
) -> Result<Vec<BookmarkDto>, ChatError> {
let _ctx = require_room_readable(self, room_id, caller).await?;
let rows = room_bookmarks::Entity::find()
.filter(room_bookmarks::Column::RoomId.eq(room_id))
.order_by_asc(room_bookmarks::Column::Position)
.order_by_asc(room_bookmarks::Column::CreatedAt)
.all(self.db().read())
.await?;
Ok(rows.into_iter().map(BookmarkDto::from).collect())
}
pub async fn create_bookmark(
&self,
caller: i64,
room_id: Uuid,
cmd: CreateBookmarkCmd,
) -> Result<BookmarkDto, ChatError> {
let _ctx = require_room_readable(self, room_id, caller).await?;
let title = cmd.title.trim().to_string();
if title.is_empty() || title.chars().count() > self.config().chat.max_bookmark_title_len {
return Err(ChatError::BadRequest("invalid bookmark title".to_string()));
}
if cmd.url.is_none() && cmd.emoji.is_none() {
return Err(ChatError::BadRequest(
"bookmark requires url or emoji".to_string(),
));
}
let max_pos: i64 = room_bookmarks::Entity::find()
.filter(room_bookmarks::Column::RoomId.eq(room_id))
.select_only()
.column_as(Expr::col(room_bookmarks::Column::Position).max(), "max_pos")
.into_tuple::<Option<i64>>()
.one(self.db().read())
.await?
.flatten()
.unwrap_or(-1);
let now = OffsetDateTime::now_utc();
let row = room_bookmarks::ActiveModel {
id: Set(Uuid::now_v7()),
room_id: Set(room_id),
user_id: Set(caller),
title: Set(title),
url: Set(cmd.url),
emoji: Set(cmd.emoji),
position: Set(max_pos + 1),
created_at: Set(now),
updated_at: Set(now),
}
.insert(self.db().write())
.await?;
Ok(BookmarkDto::from(row))
}
pub async fn update_bookmark(
&self,
caller: i64,
room_id: Uuid,
bookmark_id: Uuid,
cmd: UpdateBookmarkCmd,
) -> Result<BookmarkDto, ChatError> {
let ctx = require_room_readable(self, room_id, caller).await?;
let row = room_bookmarks::Entity::find_by_id(bookmark_id)
.filter(room_bookmarks::Column::RoomId.eq(room_id))
.one(self.db().write())
.await?
.ok_or(ChatError::NotFound)?;
if row.user_id != caller && !self.bookmark_manager(&ctx, caller).await? {
return Err(ChatError::Forbidden);
}
let mut am: room_bookmarks::ActiveModel = row.into();
if let Some(title) = cmd.title {
let title = title.trim().to_string();
if title.is_empty() || title.chars().count() > self.config().chat.max_bookmark_title_len
{
return Err(ChatError::BadRequest("invalid bookmark title".to_string()));
}
am.title = Set(title);
}
if let Some(url) = cmd.url {
am.url = Set(Some(url));
}
if let Some(emoji) = cmd.emoji {
am.emoji = Set(Some(emoji));
}
if let Some(position) = cmd.position {
am.position = Set(position);
}
am.updated_at = Set(OffsetDateTime::now_utc());
let updated = am.update(self.db().write()).await?;
Ok(BookmarkDto::from(updated))
}
pub async fn delete_bookmark(
&self,
caller: i64,
room_id: Uuid,
bookmark_id: Uuid,
) -> Result<(), ChatError> {
let ctx = require_room_readable(self, room_id, caller).await?;
let row = room_bookmarks::Entity::find_by_id(bookmark_id)
.filter(room_bookmarks::Column::RoomId.eq(room_id))
.one(self.db().write())
.await?
.ok_or(ChatError::NotFound)?;
if row.user_id != caller && !self.bookmark_manager(&ctx, caller).await? {
return Err(ChatError::Forbidden);
}
room_bookmarks::Entity::delete_by_id(row.id)
.exec(self.db().write())
.await?;
Ok(())
}
async fn bookmark_manager(
&self,
ctx: &crate::share::lookup::RoomContext,
caller: i64,
) -> Result<bool, ChatError> {
match &ctx.space {
Some(space) => crate::share::authz::can_manage_space(self, space, caller).await,
None => Ok(false),
}
}
}