a06673b
use db::conn::sea_orm::*;
use db::space::spaces as space_entity;
use time::OffsetDateTime;
use uuid::Uuid;
use crate::error::{SpaceError, SpaceResult};
use crate::features::authz;
use crate::features::SpaceService;
use super::types::{
CreateSpaceCmd, SpaceAllowJoinLevel, SpacePage, SpaceView, UpdateSpaceCmd,
};
pub async fn create_space(
svc: &SpaceService,
caller: Uuid,
cmd: CreateSpaceCmd,
) -> SpaceResult<SpaceView> {
let name = cmd.name.trim();
if name.is_empty() || name.len() > svc.config.max_space_name_len {
return Err(SpaceError::BadRequest(format!(
"invalid space name (length 1..={})",
svc.config.max_space_name_len
)));
}
if let Some(desc) = cmd.description.as_deref()
&& desc.len() > svc.config.max_space_desc_len {
return Err(SpaceError::BadRequest("description too long".into()));
}
let writer = svc.db.writer();
let now = OffsetDateTime::now_utc();
let id = Uuid::new_v4();
let active: space_entity::ActiveModel = space_entity::ActiveModel::builder()
.set_id(id)
.set_lower_name(name.to_lowercase())
.set_name(name.to_string())
.set_description(cmd.description)
.set_owner_id(caller)
.set_avatar_url(cmd.avatar_url)
.set_public(cmd.public)
.set_is_active(true)
.set_allow_join(cmd.allow_join)
.set_allow_invite(cmd.allow_invite)
.set_invite_sort_url_hash(None)
.set_member_count(0)
.set_banner_url(None)
.set_banner_width(None)
.set_banner_height(None)
.set_invite_banner_url(None)
.set_invite_banner_width(None)
.set_invite_banner_height(None)
.set_embed_splash_url(None)
.set_embed_splash_width(None)
.set_embed_splash_height(None)
.set_welcome_message(cmd.welcome_message)
.set_allow_join_level(space_entity::AllowJoinLevel::from(
cmd.allow_join_level.unwrap_or(SpaceAllowJoinLevel::None),
))
.set_member_must_enable_2fa(cmd.member_must_enable_2fa)
.set_created_at(now)
.set_updated_at(now)
.into();
let saved = active.insert(&writer).await?;
Ok(saved.into())
}
pub async fn get_space(
svc: &SpaceService,
caller: Option<Uuid>,
id: Uuid,
) -> SpaceResult<SpaceView> {
let db = svc.db.reader();
let space = space_entity::Entity::find_by_id(id)
.one(&db)
.await?
.ok_or_else(|| SpaceError::NotFound(format!("space {id}")))?;
if !space.is_active {
return Err(SpaceError::NotFound(format!("space {id}")));
}
if space.public {
return Ok(space.into());
}
let uid = caller.ok_or_else(|| SpaceError::NotFound(format!("space {id}")))?;
match authz::effective_permissions(&db, id, uid).await {
Ok(_) => Ok(space.into()),
Err(SpaceError::Forbidden(_)) => Err(SpaceError::NotFound(format!("space {id}"))),
Err(e) => Err(e),
}
}
pub async fn update_space(
svc: &SpaceService,
caller: Uuid,
id: Uuid,
cmd: UpdateSpaceCmd,
) -> SpaceResult<SpaceView> {
let writer = svc.db.writer();
let txn = writer.begin().await?;
let space = space_entity::Entity::find_by_id(id)
.one(&txn)
.await?
.ok_or_else(|| SpaceError::NotFound(format!("space {id}")))?;
if space.owner_id != caller {
return Err(SpaceError::Forbidden("only the owner can update the space".into()));
}
let mut active: space_entity::ActiveModel = space.into();
if let Some(name) = cmd.name {
let name = name.trim();
if name.is_empty() || name.len() > svc.config.max_space_name_len {
return Err(SpaceError::BadRequest("invalid space name".into()));
}
active.name = Set(name.to_string());
active.lower_name = Set(name.to_lowercase());
}
if let Some(desc) = cmd.description {
if desc.as_deref().is_some_and(|d| d.len() > svc.config.max_space_desc_len) {
return Err(SpaceError::BadRequest("description too long".into()));
}
active.description = Set(desc);
}
if let Some(avatar) = cmd.avatar_url {
active.avatar_url = Set(avatar);
}
if let Some(public) = cmd.public {
active.public = Set(public);
}
if let Some(allow_join) = cmd.allow_join {
active.allow_join = Set(allow_join);
}
if let Some(allow_invite) = cmd.allow_invite {
active.allow_invite = Set(allow_invite);
}
if let Some(welcome) = cmd.welcome_message {
if welcome.as_deref().is_some_and(|w| w.len() > svc.config.max_space_desc_len) {
return Err(SpaceError::BadRequest("welcome message too long".into()));
}
active.welcome_message = Set(welcome);
}
if let Some(level) = cmd.allow_join_level {
active.allow_join_level = Set(level.into());
}
if let Some(twofa) = cmd.member_must_enable_2fa {
active.member_must_enable_2fa = Set(twofa);
}
active.updated_at = Set(OffsetDateTime::now_utc());
let saved = active.update(&txn).await?;
txn.commit().await?;
Ok(saved.into())
}
pub async fn delete_space(svc: &SpaceService, caller: Uuid, id: Uuid) -> SpaceResult<()> {
let writer = svc.db.writer();
let txn = writer.begin().await?;
let space = space_entity::Entity::find_by_id(id)
.one(&txn)
.await?
.ok_or_else(|| SpaceError::NotFound(format!("space {id}")))?;
if space.owner_id != caller {
return Err(SpaceError::Forbidden("only the owner can delete the space".into()));
}
let mut active: space_entity::ActiveModel = space.into();
active.is_active = Set(false);
active.updated_at = Set(OffsetDateTime::now_utc());
active.update(&txn).await?;
txn.commit().await?;
Ok(())
}
pub async fn list_spaces(
svc: &SpaceService,
caller: Uuid,
limit: u64,
offset: u64,
) -> SpaceResult<SpacePage> {
let limit = std::cmp::max(std::cmp::min(limit, svc.config.max_pagination), 1) as u64;
let db = svc.db.reader();
let (items, total) = futures::join!(
space_entity::Entity::find()
.filter(space_entity::Column::OwnerId.eq(caller))
.limit(Some(limit))
.offset(Some(offset))
.all(&db),
space_entity::Entity::find()
.filter(space_entity::Column::OwnerId.eq(caller))
.count(&db),
);
let items = items?;
let total = total? as i64;
Ok(SpacePage {
items: items.into_iter().map(Into::into).collect(),
total,
})
}