b453d5d
use models::space::space_members::{self, MemberStatus, MessageNotifications};
use models::space::spaces;
use sea_orm::sea_query::{Expr, ExprTrait};
use sea_orm::{ActiveModelTrait, ColumnTrait, ConnectionTrait, EntityTrait, QueryFilter, Set};
use time::OffsetDateTime;
use uuid::Uuid;
use kenauth::proto;
fn timestamp(value: &Option<prost_types::Timestamp>) -> Option<OffsetDateTime> {
let value = value.as_ref()?;
OffsetDateTime::from_unix_timestamp(value.seconds)
.ok()?
.replace_nanosecond(value.nanos.clamp(0, 999_999_999) as u32)
.ok()
}
fn space_status(value: i32) -> proto::v1::OrganizationStatus {
proto::v1::OrganizationStatus::try_from(value).unwrap_or(proto::v1::OrganizationStatus::Active)
}
fn join_policy(value: i32) -> &'static str {
match proto::v1::OrganizationJoinPolicy::try_from(value)
.unwrap_or(proto::v1::OrganizationJoinPolicy::InviteOnly)
{
proto::v1::OrganizationJoinPolicy::Open => "open",
proto::v1::OrganizationJoinPolicy::Approval => "approval",
proto::v1::OrganizationJoinPolicy::Private => "private",
_ => "invite_only",
}
}
fn notifications(value: &str) -> MessageNotifications {
match value.trim() {
"mentions" => MessageNotifications::Mentions,
"nothing" => MessageNotifications::Nothing,
_ => MessageNotifications::All,
}
}
fn non_empty(value: &str) -> Option<String> {
let value = value.trim();
if value.is_empty() {
None
} else {
Some(value.to_string())
}
}
pub async fn upsert_space<C: ConnectionTrait>(
db: &C,
info: &proto::v1::OrganizationInfo,
) -> Result<spaces::Model, sea_orm::DbErr> {
let id = Uuid::parse_str(info.id.trim())
.map_err(|_| sea_orm::DbErr::Custom("organization id is not a uuid".into()))?;
let now = OffsetDateTime::now_utc();
let policy = join_policy(info.join_policy);
let active = space_status(info.status) == proto::v1::OrganizationStatus::Active;
let existing = spaces::Entity::find_by_id(id).one(db).await?;
let row = match existing {
Some(row) => {
let mut active_model: spaces::ActiveModel = row.into();
active_model.lower_name = Set(info.slug.clone());
active_model.name = Set(info.name.clone());
active_model.description = Set(non_empty(&info.description));
active_model.avatar_url = Set(non_empty(&info.avatar_url));
active_model.owner_id = Set(info.owner_user_id);
active_model.is_private = Set(policy == "private");
active_model.is_active = Set(active);
active_model.allow_join = Set(info.allow_join);
active_model.nums_members = Set(info.member_count as i64);
active_model.welcome_message = Set(non_empty(&info.welcome_message));
active_model.member_must_enable_2fa = Set(info.member_must_enable_2fa);
active_model.join_policy = Set(policy.to_string());
active_model.require_email_verified = Set(info.require_email_verified);
active_model.require_mfa = Set(info.require_mfa);
active_model.version = Set(info.version);
active_model.updated_at = Set(now);
active_model.update(db).await?
}
None => {
spaces::ActiveModel {
id: Set(id),
lower_name: Set(info.slug.clone()),
name: Set(info.name.clone()),
description: Set(non_empty(&info.description)),
owner_id: Set(info.owner_user_id),
avatar_url: Set(non_empty(&info.avatar_url)),
is_private: Set(policy == "private"),
is_active: Set(active),
allow_join: Set(info.allow_join),
allow_invite: Set(true),
invite_sort_url_hash: Set(None),
nums_members: Set(info.member_count as i64),
banner_url: Set(None),
banner_width: Set(None),
banner_height: Set(None),
invite_banner_url: Set(None),
invite_banner_width: Set(None),
invite_banner_height: Set(None),
embed_splash_url: Set(None),
embed_splash_width: Set(None),
embed_splash_height: Set(None),
welcome_message: Set(non_empty(&info.welcome_message)),
allow_join_level: Set(models::space::spaces::AllowJoinLevel::None),
member_must_enable_2fa: Set(info.member_must_enable_2fa),
welcome_object: Set(None),
join_policy: Set(policy.to_string()),
require_email_verified: Set(info.require_email_verified),
require_mfa: Set(info.require_mfa),
version: Set(info.version),
created_at: Set(timestamp(&info.created_at).unwrap_or(now)),
updated_at: Set(timestamp(&info.updated_at).unwrap_or(now)),
}
.insert(db)
.await?
}
};
Ok(row)
}
pub async fn remove_space<C: ConnectionTrait>(
db: &C,
organization_id: Uuid,
) -> Result<(), sea_orm::DbErr> {
spaces::Entity::delete_by_id(organization_id).exec(db).await?;
Ok(())
}
pub async fn upsert_member<C: ConnectionTrait>(
db: &C,
organization_id: Uuid,
member: &proto::v1::OrganizationMemberInfo,
) -> Result<space_members::Model, sea_orm::DbErr> {
let now = OffsetDateTime::now_utc();
let status = if member.banned_at.is_some() {
MemberStatus::Banned
} else if member.left_at.is_some() {
MemberStatus::Left
} else {
MemberStatus::Active
};
let invited_by = (member.invited_by > 0).then_some(member.invited_by);
let existing = space_members::Entity::find_by_id((organization_id, member.user_id))
.one(db)
.await?;
let row = match existing {
Some(row) => {
let mut active: space_members::ActiveModel = row.into();
active.status = Set(status);
active.alias_name = Set(non_empty(&member.alias_name));
active.alias_avatar_url = Set(non_empty(&member.alias_avatar_url));
active.message_notifications = Set(notifications(&member.message_notifications));
active.muted = Set(member.muted);
active.mute_until = Set(timestamp(&member.mute_until));
active.mobile_push = Set(member.mobile_push);
active.suppress_everyone = Set(member.suppress_everyone);
active.suppress_roles = Set(member.suppress_roles);
active.hide_muted_channels = Set(member.hide_muted_channels);
active.banned_at = Set(timestamp(&member.banned_at));
active.ban_reason = Set(non_empty(&member.ban_reason));
active.ban_expires_at = Set(timestamp(&member.ban_expires_at));
active.ban_allow_speak = Set(member.ban_allow_speak);
active.ban_allow_push_repo = Set(member.ban_allow_push_repo);
active.ban_allow_comment_any = Set(member.ban_allow_comment_any);
active.left_at = Set(timestamp(&member.left_at));
active.invited_by = Set(invited_by);
active.last_active_at = Set(timestamp(&member.last_active_at));
active.updated_at = Set(Some(now));
active.update(db).await?
}
None => {
space_members::ActiveModel {
space_id: Set(organization_id),
user_id: Set(member.user_id),
alias_name: Set(non_empty(&member.alias_name)),
alias_avatar_url: Set(non_empty(&member.alias_avatar_url)),
status: Set(status),
last_active_at: Set(timestamp(&member.last_active_at)),
left_at: Set(timestamp(&member.left_at)),
invited_at: Set(None),
invited_by: Set(invited_by),
joined_at: Set(timestamp(&member.joined_at).unwrap_or(now)),
created_at: Set(now),
updated_at: Set(Some(now)),
message_notifications: Set(notifications(&member.message_notifications)),
muted: Set(member.muted),
mute_until: Set(timestamp(&member.mute_until)),
mobile_push: Set(member.mobile_push),
suppress_everyone: Set(member.suppress_everyone),
suppress_roles: Set(member.suppress_roles),
hide_muted_channels: Set(member.hide_muted_channels),
banned_at: Set(timestamp(&member.banned_at)),
ban_reason: Set(non_empty(&member.ban_reason)),
ban_expires_at: Set(timestamp(&member.ban_expires_at)),
ban_allow_speak: Set(member.ban_allow_speak),
ban_allow_push_repo: Set(member.ban_allow_push_repo),
ban_allow_comment_any: Set(member.ban_allow_comment_any),
}
.insert(db)
.await?
}
};
Ok(row)
}
pub async fn remove_member<C: ConnectionTrait>(
db: &C,
organization_id: Uuid,
user_id: i64,
) -> Result<(), sea_orm::DbErr> {
space_members::Entity::delete_by_id((organization_id, user_id))
.exec(db)
.await?;
Ok(())
}
pub async fn bump_members<C: ConnectionTrait>(
db: &C,
organization_id: Uuid,
delta: i32,
) -> Result<(), sea_orm::DbErr> {
spaces::Entity::update_many()
.col_expr(
spaces::Column::NumsMembers,
Expr::col(spaces::Column::NumsMembers).add(delta),
)
.filter(spaces::Column::Id.eq(organization_id))
.exec(db)
.await?;
Ok(())
}