a06673b
use db::conn::sea_orm::*;
use db::space::space_members as member_entity;
use db::space::spaces as space_entity;
use time::OffsetDateTime;
use uuid::Uuid;
use crate::error::{SpaceError, SpaceResult};
use crate::features::SpaceService;
use super::types::{AddMemberCmd, SpaceMemberPage, SpaceMemberView, UpdateMemberCmd};
async fn space(caller: Uuid, space_id: Uuid, svc: &SpaceService) -> SpaceResult<space_entity::Model> {
let db = svc.db.reader();
let space = space_entity::Entity::find_by_id(space_id)
.one(&db)
.await?
.ok_or_else(|| SpaceError::NotFound(format!("space {space_id}")))?;
if space.owner_id == caller {
Ok(space)
} else {
Err(SpaceError::Forbidden(
"only the owner can manage members".to_string(),
))
}
}
pub async fn add_member(
svc: &SpaceService,
caller: Uuid,
space_id: Uuid,
cmd: AddMemberCmd,
) -> SpaceResult<SpaceMemberView> {
space(caller, space_id, svc).await?;
let db = svc.db.writer();
let now = OffsetDateTime::now_utc();
let existing = member_entity::Entity::find_by_id((space_id, cmd.user_id))
.one(&db)
.await?;
if existing.is_some() {
return Err(SpaceError::Conflict(format!(
"user {} is already a member of space {space_id}",
cmd.user_id
)));
}
let mute_until = parse_mute_until(cmd.mute_until.as_deref())?;
let active: member_entity::ActiveModel = member_entity::ActiveModel::builder()
.set_space_id(space_id)
.set_user_id(cmd.user_id)
.set_alias_name(cmd.alias_name)
.set_alias_avatar_url(cmd.alias_avatar_url)
.set_status(member_entity::MemberStatus::Active)
.set_invited_at(Option::<OffsetDateTime>::None)
.set_invited_by(Option::<Uuid>::None)
.set_joined_at(now)
.set_created_at(now)
.set_updated_at(Option::<OffsetDateTime>::Some(now))
.set_message_notifications(member_entity::MessageNotifications::from(
cmd.message_notifications.unwrap_or_default(),
))
.set_muted(cmd.muted.unwrap_or(false))
.set_mute_until(mute_until)
.set_mobile_push(cmd.mobile_push.unwrap_or(false))
.set_suppress_everyone(cmd.suppress_everyone.unwrap_or(false))
.set_suppress_roles(cmd.suppress_roles.unwrap_or(false))
.set_hide_muted_channels(cmd.hide_muted_channels.unwrap_or(false))
.into();
let saved: member_entity::Model = active.insert(&db).await?;
Ok(saved.into())
}
pub async fn get_member(
svc: &SpaceService,
caller: Uuid,
space_id: Uuid,
user_id: Uuid,
) -> SpaceResult<SpaceMemberView> {
space(caller, space_id, svc).await?;
let db = svc.db.reader();
let m = member_entity::Entity::find_by_id((space_id, user_id))
.one(&db)
.await?
.ok_or_else(|| SpaceError::NotFound(format!("member {user_id} in space {space_id}")))?;
Ok(m.into())
}
fn parse_mute_until(s: Option<&str>) -> SpaceResult<Option<OffsetDateTime>> {
match s {
None => Ok(None),
Some("") => Ok(None),
Some(v) => OffsetDateTime::parse(v, &time::format_description::well_known::Rfc3339)
.map(Some)
.map_err(|_| SpaceError::BadRequest("invalid mute_until timestamp".to_string())),
}
}
pub async fn update_member(
svc: &SpaceService,
caller: Uuid,
space_id: Uuid,
user_id: Uuid,
cmd: UpdateMemberCmd,
) -> SpaceResult<SpaceMemberView> {
space(caller, space_id, svc).await?;
let db = svc.db.writer();
let txn = db.begin().await?;
let m = member_entity::Entity::find_by_id((space_id, user_id))
.one(&txn)
.await?
.ok_or_else(|| SpaceError::NotFound(format!("member {user_id} in space {space_id}")))?;
let mut active: member_entity::ActiveModel = m.into();
if let Some(v) = cmd.alias_name {
match v {
None => active.alias_name = Set(None),
Some(s) => {
if s.chars().count() > svc.config.max_alias_name_len {
return Err(SpaceError::BadRequest(format!(
"alias_name exceeds {} characters",
svc.config.max_alias_name_len
)));
}
active.alias_name = Set(Some(s));
}
}
}
if let Some(v) = cmd.alias_avatar_url {
active.alias_avatar_url = Set(v);
}
if let Some(v) = cmd.message_notifications {
active.message_notifications = Set(v.into());
}
if let Some(v) = cmd.muted {
active.muted = Set(v);
}
if let Some(v) = cmd.mute_until {
active.mute_until = Set(parse_mute_until(v.as_deref())?);
}
if let Some(v) = cmd.mobile_push {
active.mobile_push = Set(v);
}
if let Some(v) = cmd.suppress_everyone {
active.suppress_everyone = Set(v);
}
if let Some(v) = cmd.suppress_roles {
active.suppress_roles = Set(v);
}
if let Some(v) = cmd.hide_muted_channels {
active.hide_muted_channels = Set(v);
}
active.updated_at = Set(Some(OffsetDateTime::now_utc()));
let saved = active.update(&txn).await?;
txn.commit().await?;
Ok(saved.into())
}
pub async fn remove_member(
svc: &SpaceService,
caller: Uuid,
space_id: Uuid,
user_id: Uuid,
) -> SpaceResult<()> {
space(caller, space_id, svc).await?;
if caller == user_id {
return Err(SpaceError::BadRequest(
"owner cannot remove themselves".to_string(),
));
}
let db = svc.db.writer();
let txn = db.begin().await?;
let m = member_entity::Entity::find_by_id((space_id, user_id))
.one(&txn)
.await?
.ok_or_else(|| SpaceError::NotFound(format!("member {user_id} in space {space_id}")))?;
let mut active: member_entity::ActiveModel = m.into();
active.status = Set(member_entity::MemberStatus::Removed);
active.left_at = Set(Some(OffsetDateTime::now_utc()));
active.updated_at = Set(Some(OffsetDateTime::now_utc()));
active.update(&txn).await?;
txn.commit().await?;
Ok(())
}
pub async fn list_members(
svc: &SpaceService,
caller: Uuid,
space_id: Uuid,
limit: u64,
offset: u64,
) -> SpaceResult<SpaceMemberPage> {
space(caller, space_id, svc).await?;
let db = svc.db.reader();
let limit = std::cmp::max(std::cmp::min(limit, svc.config.max_pagination), 1) as u64;
let items = member_entity::Entity::find()
.filter(member_entity::Column::SpaceId.eq(space_id))
.order_by_asc(member_entity::Column::JoinedAt)
.limit(Some(limit))
.offset(Some(offset))
.all(&db)
.await?;
let total = member_entity::Entity::find()
.filter(member_entity::Column::SpaceId.eq(space_id))
.count(&db)
.await?;
Ok(SpaceMemberPage {
items: items.into_iter().map(SpaceMemberView::from).collect(),
total: total as i64,
})
}