ef0b83a
use std::collections::HashMap;
use export::AppState;
use models::space::space_extras::{self, Entity as SpaceExtras};
use models::space::space_member_extras::{self, Entity as MemberExtras};
use models::space::space_members::{self, Entity as Members};
use models::space::spaces::{self, Entity as Spaces};
use models::space::{AllowJoinLevel, SpaceJoinPolicy, SpaceStatus};
use sea_orm::{ActiveModelTrait, ColumnTrait, DbErr, EntityTrait, QueryFilter, QuerySelect, Set};
use time::OffsetDateTime;
use uuid::Uuid;
use crate::errors::SpaceError;
use crate::services::dto::{MemberDto, SpaceDto, UserDto, resolve_space_image_url};
use crate::services::service::SpaceService;
pub const RPC_KEY: &str = "kenoauth is not configured";
pub fn client(state: &AppState) -> Result<&dyn export::AuthApi, SpaceError> {
state
.kenauth
.as_deref()
.ok_or_else(|| SpaceError::Internal(RPC_KEY.to_string()))
}
pub fn to_time(value: chrono::DateTime<chrono::Utc>) -> OffsetDateTime {
OffsetDateTime::from_unix_timestamp(value.timestamp())
.map(|row| {
row.replace_nanosecond(value.timestamp_subsec_nanos())
.unwrap_or(row)
})
.unwrap_or_else(|_| OffsetDateTime::now_utc())
}
pub fn to_time_opt(value: Option<chrono::DateTime<chrono::Utc>>) -> Option<OffsetDateTime> {
value.map(to_time)
}
pub fn space_dto(
record: &spaces::Model,
extras: Option<&space_extras::Model>,
nums_members: i64,
owners: &HashMap<i64, UserDto>,
) -> SpaceDto {
SpaceDto {
id: record.id,
lower_name: record.slug.clone(),
name: record.name.clone(),
description: record.description.clone(),
owner: owners.get(&record.owner_user_id).cloned(),
avatar_url: resolve_space_image_url(
&record.slug,
"avatar",
extras
.and_then(|row| row.avatar_url.clone())
.or_else(|| record.avatar_url.clone()),
),
is_private: record.join_policy == SpaceJoinPolicy::Private,
is_active: record.status == SpaceStatus::Active && record.archived_at.is_none(),
allow_join: record.allow_join,
allow_invite: record.allow_invite,
members_count: nums_members,
welcome_message: record.welcome_message.clone(),
allow_join_level: AllowJoinLevel::from_i16(record.allow_join_level),
member_must_enable_2fa: record.member_must_enable_2fa,
welcome_object: extras.and_then(|row| row.welcome_object),
created_at: to_time(record.created_at),
updated_at: to_time(record.updated_at),
}
}
pub fn space_is_active(space: &spaces::Model) -> bool {
space.status == SpaceStatus::Active && space.archived_at.is_none()
}
pub fn member_dto(
record: &space_members::Model,
extras: Option<&space_member_extras::Model>,
users: &HashMap<i64, UserDto>,
) -> MemberDto {
MemberDto {
space_id: record.organization_id,
user: users.get(&record.user_id).cloned(),
alias_name: record.alias_name.clone(),
alias_avatar_url: record.alias_avatar_url.clone(),
status: record.status(),
last_active_at: to_time_opt(record.last_active_at),
left_at: to_time_opt(record.left_at),
invited_at: extras.and_then(|row| row.invited_at),
invited_by: record.invited_by.and_then(|uid| users.get(&uid).cloned()),
joined_at: to_time(record.joined_at),
created_at: extras
.map(|row| row.created_at)
.unwrap_or_else(|| to_time(record.joined_at)),
updated_at: extras.map(|row| row.updated_at),
message_notifications: record.message_notifications,
muted: record.muted,
mute_until: to_time_opt(record.mute_until),
mobile_push: record.mobile_push,
suppress_everyone: record.suppress_everyone,
suppress_roles: record.suppress_roles,
hide_muted_channels: record.hide_muted_channels,
}
}
pub async fn extras(
state: &AppState,
space_id: Uuid,
) -> Result<Option<space_extras::Model>, SpaceError> {
Ok(SpaceExtras::find_by_id(space_id)
.one(state.database.read())
.await?)
}
pub async fn member_extras(
state: &AppState,
space_id: Uuid,
user_id: i64,
) -> Result<Option<space_member_extras::Model>, SpaceError> {
Ok(MemberExtras::find_by_id((space_id, user_id))
.one(state.database.read())
.await?)
}
pub async fn space_avatar(
state: &AppState,
space: &spaces::Model,
) -> Result<Option<String>, SpaceError> {
Ok(extras(state, space.id)
.await?
.and_then(|row| row.avatar_url)
.or_else(|| space.avatar_url.clone()))
}
pub async fn member_count(state: &AppState, space_id: Uuid) -> Result<i64, SpaceError> {
use sea_orm::PaginatorTrait;
let count = Members::find()
.filter(space_members::Column::OrganizationId.eq(space_id))
.filter(space_members::Column::LeftAt.is_null())
.filter(space_members::Column::BannedAt.is_null())
.count(state.database.read())
.await?;
Ok(count as i64)
}
pub async fn space_by_id(
state: &AppState,
_actor: i64,
space_id: Uuid,
) -> Result<spaces::Model, SpaceError> {
Spaces::find_by_id(space_id)
.filter(spaces::Column::DeletedAt.is_null())
.one(state.database.read())
.await?
.ok_or(SpaceError::NotFound)
}
pub async fn space_by_slug(
state: &AppState,
_actor: i64,
slug: &str,
) -> Result<spaces::Model, SpaceError> {
Spaces::find()
.filter(spaces::Column::Slug.eq(slug.trim().to_lowercase()))
.filter(spaces::Column::DeletedAt.is_null())
.one(state.database.read())
.await?
.ok_or(SpaceError::NotFound)
}
pub async fn member(
state: &AppState,
_actor: i64,
space_id: Uuid,
user_id: i64,
) -> Result<Option<space_members::Model>, SpaceError> {
Ok(Members::find()
.filter(space_members::Column::OrganizationId.eq(space_id))
.filter(space_members::Column::UserId.eq(user_id))
.one(state.database.read())
.await?)
}
pub async fn require_member(
state: &AppState,
space_id: Uuid,
user_id: i64,
) -> Result<space_members::Model, SpaceError> {
match member(state, user_id, space_id, user_id).await? {
Some(member) if member.status() == models::space::MemberStatus::Active => Ok(member),
_ => Err(SpaceError::Forbidden),
}
}
pub async fn list_members(
state: &AppState,
_actor: i64,
space_id: Uuid,
include_inactive: bool,
include_banned: bool,
) -> Result<Vec<space_members::Model>, SpaceError> {
let mut query = Members::find().filter(space_members::Column::OrganizationId.eq(space_id));
if !include_inactive {
query = query.filter(space_members::Column::LeftAt.is_null());
}
if !include_banned {
query = query.filter(space_members::Column::BannedAt.is_null());
}
Ok(query.all(state.database.read()).await?)
}
pub async fn list_user_spaces(
state: &AppState,
_actor: i64,
user_id: i64,
) -> Result<Vec<spaces::Model>, SpaceError> {
let space_ids: Vec<Uuid> = Members::find()
.filter(space_members::Column::UserId.eq(user_id))
.filter(space_members::Column::LeftAt.is_null())
.filter(space_members::Column::BannedAt.is_null())
.select_only()
.column(space_members::Column::OrganizationId)
.into_tuple()
.all(state.database.read())
.await?;
spaces_by_ids(state, space_ids).await
}
/// Public directory (ACTIVE, joinable). Presentation fields come from the extras row.
pub async fn list_public_spaces(
state: &AppState,
query: &str,
) -> Result<Vec<spaces::Model>, SpaceError> {
use sea_orm::Condition;
let mut select = Spaces::find()
.filter(spaces::Column::Status.eq(SpaceStatus::Active))
.filter(spaces::Column::DeletedAt.is_null())
.filter(
spaces::Column::JoinPolicy.is_in([SpaceJoinPolicy::Open, SpaceJoinPolicy::Approval]),
);
let needle = query.trim();
if !needle.is_empty() {
select = select.filter(
Condition::any()
.add(spaces::Column::Name.contains(needle))
.add(spaces::Column::Slug.contains(needle)),
);
}
Ok(select.limit(1_000).all(state.database.read()).await?)
}
async fn spaces_by_ids(state: &AppState, ids: Vec<Uuid>) -> Result<Vec<spaces::Model>, SpaceError> {
if ids.is_empty() {
return Ok(Vec::new());
}
Ok(Spaces::find()
.filter(spaces::Column::Id.is_in(ids))
.filter(spaces::Column::DeletedAt.is_null())
.all(state.database.read())
.await?)
}
pub async fn account_created_at(
state: &AppState,
user_id: i64,
) -> Result<Option<OffsetDateTime>, SpaceError> {
let user = client(state)?.get_authority_user(user_id).await?;
let Some(created) = user.created_at else {
return Ok(None);
};
Ok(OffsetDateTime::from_unix_timestamp(created.seconds)
.ok()
.map(|row| {
row.replace_nanosecond(created.nanos.clamp(0, 999_999_999) as u32)
.unwrap_or(row)
}))
}
pub async fn mfa_enabled(state: &AppState, user_id: i64) -> Result<bool, SpaceError> {
let status = client(state)?.get_user_status(user_id).await?;
Ok(status.active_mfa_factors > 0)
}
pub async fn has_verified_email(state: &AppState, user_id: i64) -> Result<bool, SpaceError> {
let status = client(state)?.get_user_status(user_id).await?;
Ok(status.email_verified_at.is_some())
}
pub async fn permissions(
state: &AppState,
space_id: Uuid,
user_id: i64,
actions: &[String],
) -> Result<Vec<bool>, SpaceError> {
let service = SpaceService::new(state.clone());
let checks = service
.check_permissions(user_id, space_id, user_id, actions, None)
.await?;
Ok(checks.into_iter().map(|check| check.allowed).collect())
}
pub async fn upsert_extras(
state: &AppState,
space_id: Uuid,
avatar_url: Option<Option<String>>,
welcome_object: Option<Option<Uuid>>,
banner_url: Option<Option<String>>,
banner_width: Option<Option<i32>>,
banner_height: Option<Option<i32>>,
invite_banner_url: Option<Option<String>>,
invite_banner_width: Option<Option<i32>>,
invite_banner_height: Option<Option<i32>>,
embed_splash_url: Option<Option<String>>,
embed_splash_width: Option<Option<i32>>,
embed_splash_height: Option<Option<i32>>,
invite_sort_url_hash: Option<Option<String>>,
) -> Result<space_extras::Model, SpaceError> {
let now = OffsetDateTime::now_utc();
let existing = extras(state, space_id).await?;
let row = match existing {
Some(row) => {
let mut active: space_extras::ActiveModel = row.into();
if let Some(value) = avatar_url {
active.avatar_url = Set(value);
}
if let Some(value) = welcome_object {
active.welcome_object = Set(value);
}
if let Some(value) = banner_url {
active.banner_url = Set(value);
}
if let Some(value) = banner_width {
active.banner_width = Set(value);
}
if let Some(value) = banner_height {
active.banner_height = Set(value);
}
if let Some(value) = invite_banner_url {
active.invite_banner_url = Set(value);
}
if let Some(value) = invite_banner_width {
active.invite_banner_width = Set(value);
}
if let Some(value) = invite_banner_height {
active.invite_banner_height = Set(value);
}
if let Some(value) = embed_splash_url {
active.embed_splash_url = Set(value);
}
if let Some(value) = embed_splash_width {
active.embed_splash_width = Set(value);
}
if let Some(value) = embed_splash_height {
active.embed_splash_height = Set(value);
}
if let Some(value) = invite_sort_url_hash {
active.invite_sort_url_hash = Set(value);
}
active.updated_at = Set(now);
active.update(state.database.write()).await?
}
None => {
space_extras::ActiveModel {
space_id: Set(space_id),
avatar_url: Set(avatar_url.unwrap_or(None)),
invite_sort_url_hash: Set(invite_sort_url_hash.unwrap_or(None)),
banner_url: Set(banner_url.unwrap_or(None)),
banner_width: Set(banner_width.unwrap_or(None)),
banner_height: Set(banner_height.unwrap_or(None)),
invite_banner_url: Set(invite_banner_url.unwrap_or(None)),
invite_banner_width: Set(invite_banner_width.unwrap_or(None)),
invite_banner_height: Set(invite_banner_height.unwrap_or(None)),
embed_splash_url: Set(embed_splash_url.unwrap_or(None)),
embed_splash_width: Set(embed_splash_width.unwrap_or(None)),
embed_splash_height: Set(embed_splash_height.unwrap_or(None)),
welcome_object: Set(welcome_object.unwrap_or(None)),
created_at: Set(now),
updated_at: Set(now),
}
.insert(state.database.write())
.await?
}
};
Ok(row)
}
pub async fn upsert_member_extras(
state: &AppState,
space_id: Uuid,
user_id: i64,
invited_at: Option<OffsetDateTime>,
) -> Result<(), SpaceError> {
let now = OffsetDateTime::now_utc();
let existing = member_extras(state, space_id, user_id).await?;
match existing {
Some(row) => {
let mut active: space_member_extras::ActiveModel = row.into();
if invited_at.is_some() {
active.invited_at = Set(invited_at);
}
active.updated_at = Set(now);
active.update(state.database.write()).await?;
}
None => {
space_member_extras::ActiveModel {
space_id: Set(space_id),
user_id: Set(user_id),
invited_at: Set(invited_at),
created_at: Set(now),
updated_at: Set(now),
}
.insert(state.database.write())
.await?;
}
}
Ok(())
}
pub async fn remove_extras(state: &AppState, space_id: Uuid) -> Result<(), SpaceError> {
SpaceExtras::delete_by_id(space_id)
.exec(state.database.write())
.await?;
MemberExtras::delete_many()
.filter(space_member_extras::Column::SpaceId.eq(space_id))
.exec(state.database.write())
.await?;
Ok(())
}
pub async fn remove_member_extras(
state: &AppState,
space_id: Uuid,
user_id: i64,
) -> Result<(), SpaceError> {
MemberExtras::delete_by_id((space_id, user_id))
.exec(state.database.write())
.await?;
Ok(())
}
pub fn db_error(error: DbErr) -> SpaceError {
SpaceError::from(error)
}