feat: init

2026-06-07 11:30:56 +08:00
commit 563381c1ca
361 changed files with 41327 additions and 0 deletions
@@ -0,0 +1,554 @@
+use serde::{Deserialize, Serialize};
+use uuid::Uuid;
+
+use crate::error::AppError;
+use crate::models::channels::Channel;
+use crate::models::common::{ChannelKind, ChannelType, Role, Visibility};
+use crate::models::workspaces::Workspace;
+use crate::service::ImService;
+
+use super::session::ImSession;
+use super::util::*;
+use crate::immediate::{ChannelAction, ChannelEvent};
+use crate::service::im::events::ImEvent;
+
+#[derive(Deserialize, Serialize, Clone, Debug, utoipa::ToSchema)]
+pub struct CreateChannelParams {
+    pub name: String,
+    pub topic: Option<String>,
+    pub description: Option<String>,
+    pub channel_type: Option<String>,
+    pub channel_kind: Option<String>,
+    pub visibility: Option<String>,
+    pub category_id: Option<Uuid>,
+    pub parent_channel_id: Option<Uuid>,
+    pub nsfw: Option<bool>,
+    pub rate_limit_per_user: Option<i32>,
+}
+
+#[derive(Deserialize, Serialize, Clone, Debug, utoipa::ToSchema)]
+pub struct UpdateChannelParams {
+    pub name: Option<String>,
+    pub topic: Option<String>,
+    pub description: Option<String>,
+    pub visibility: Option<String>,
+    pub category_id: Option<Uuid>,
+    pub position: Option<i32>,
+    pub nsfw: Option<bool>,
+    pub rate_limit_per_user: Option<i32>,
+    pub archived: Option<bool>,
+    pub read_only: Option<bool>,
+}
+
+#[derive(Deserialize, Serialize, Clone, Debug, utoipa::ToSchema)]
+pub struct ChannelListFilters {
+    pub channel_type: Option<String>,
+    pub channel_kind: Option<String>,
+    pub category_id: Option<Uuid>,
+    pub archived: Option<bool>,
+}
+
+impl ImService {
+    pub async fn channel_list(
+        &self,
+        ctx: &ImSession,
+        wk_name: &str,
+        filters: ChannelListFilters,
+        limit: i64,
+        offset: i64,
+    ) -> Result<Vec<Channel>, AppError> {
+        let user_uid = ctx.user;
+        let ws = self.resolve_workspace(wk_name).await?;
+        self.ensure_workspace_readable(user_uid, &ws).await?;
+        let (limit, offset) = clamp_limit_offset(limit, offset);
+
+        let kind = filters
+            .channel_kind
+            .as_deref()
+            .and_then(|s| s.parse::<ChannelKind>().ok())
+            .filter(|k| *k != ChannelKind::Unknown);
+        let ch_type = filters
+            .channel_type
+            .as_deref()
+            .and_then(|s| s.parse::<ChannelType>().ok())
+            .filter(|t| *t != ChannelType::Unknown);
+
+        sqlx::query_as::<_, Channel>(
+            "SELECT id, workspace_id, repo_id, category_id, created_by, name, topic, description, \
+             channel_type, channel_kind, visibility, position, nsfw, archived, read_only, \
+             bitrate, user_limit, rtc_region, \
+             default_auto_archive_duration, default_reaction_emoji, default_sort_order, \
+             default_forum_layout, require_tag, available_tags, default_thread_rate_limit, \
+             rate_limit_per_user, parent_channel_id, \
+             last_message_id, last_message_at, archived_at, created_at, updated_at, deleted_at \
+             FROM channel \
+             WHERE workspace_id = $1 AND deleted_at IS NULL \
+             AND ($2::text IS NULL OR channel_kind::text = $2) \
+             AND ($3::text IS NULL OR channel_type::text = $3) \
+             AND ($4::uuid IS NULL OR category_id = $4) \
+             AND ($5::bool IS NULL OR archived = $5) \
+             ORDER BY position ASC NULLS LAST, name ASC \
+             LIMIT $6 OFFSET $7",
+        )
+        .bind(ws.id)
+        .bind(kind.map(|k| k.to_string()))
+        .bind(ch_type.map(|t| t.to_string()))
+        .bind(filters.category_id)
+        .bind(filters.archived)
+        .bind(limit)
+        .bind(offset)
+        .fetch_all(self.ctx.db.reader())
+        .await
+        .map_err(AppError::Database)
+    }
+
+    pub async fn channel_get(
+        &self,
+        ctx: &ImSession,
+        _wk_name: &str,
+        channel_id: Uuid,
+    ) -> Result<Channel, AppError> {
+        let user_uid = ctx.user;
+        let channel = self.resolve_channel(channel_id).await?;
+        self.ensure_channel_readable(user_uid, &channel).await?;
+        Ok(channel)
+    }
+
+    #[tracing::instrument(skip(self, ctx, params), fields(name = %params.name))]
+    pub async fn channel_create(
+        &self,
+        ctx: &ImSession,
+        wk_name: &str,
+        params: CreateChannelParams,
+        request_id: Uuid,
+    ) -> Result<Channel, AppError> {
+        let user_uid = ctx.user;
+        let name = required_text(params.name, "name")?;
+        if name.len() > MAX_CHANNEL_NAME {
+            return Err(AppError::BadRequest("channel name too long".into()));
+        }
+        let ws = self.resolve_workspace(wk_name).await?;
+        self.ensure_workspace_role_at_least(user_uid, &ws, Role::Member)
+            .await?;
+
+        if let Some(topic) = &params.topic
+            && topic.len() > MAX_CHANNEL_TOPIC
+        {
+            return Err(AppError::BadRequest("channel topic too long".into()));
+        }
+
+        let ch_kind = parse_enum(
+            params.channel_kind,
+            ChannelKind::Text,
+            ChannelKind::Unknown,
+            "channel_kind",
+        )?;
+        let ch_type = parse_enum(
+            params.channel_type,
+            ChannelType::Public,
+            ChannelType::Unknown,
+            "channel_type",
+        )?;
+        let visibility = parse_enum(
+            params.visibility,
+            Visibility::Public,
+            Visibility::Unknown,
+            "visibility",
+        )?;
+
+        let now = chrono::Utc::now();
+        let channel_id = Uuid::now_v7();
+
+        let channel = sqlx::query_as::<_, Channel>(
+            "INSERT INTO channel \
+             (id, workspace_id, repo_id, category_id, created_by, name, topic, description, \
+              channel_type, channel_kind, visibility, position, nsfw, archived, read_only, \
+              rate_limit_per_user, parent_channel_id, created_at, updated_at) \
+             VALUES ($1, $2, NULL, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, false, false, \
+              $13, $14, $15, $15) \
+             RETURNING id, workspace_id, repo_id, category_id, created_by, name, topic, description, \
+              channel_type, channel_kind, visibility, position, nsfw, archived, read_only, \
+              bitrate, user_limit, rtc_region, \
+              default_auto_archive_duration, default_reaction_emoji, default_sort_order, \
+              default_forum_layout, require_tag, available_tags, default_thread_rate_limit, \
+              rate_limit_per_user, parent_channel_id, \
+              last_message_id, last_message_at, archived_at, created_at, updated_at, deleted_at",
+        )
+        .bind(channel_id)
+        .bind(ws.id)
+        .bind(params.category_id)
+        .bind(user_uid)
+        .bind(&name)
+        .bind(params.topic.as_deref())
+        .bind(params.description.as_deref())
+        .bind(ch_type)
+        .bind(ch_kind)
+        .bind(visibility)
+        .bind(0_i32) // position
+        .bind(params.nsfw.unwrap_or(false))
+        .bind(params.rate_limit_per_user)
+        .bind(params.parent_channel_id)
+        .bind(now)
+        .fetch_one(self.ctx.db.writer())
+        .await
+        .map_err(AppError::Database)?;
+
+        // Auto-add creator as channel member with owner role
+        sqlx::query(
+            "INSERT INTO channel_member \
+             (id, channel_id, user_id, role, status, muted, pinned, created_at, updated_at) \
+             VALUES ($1, $2, $3, 'owner', 'active', false, false, $4, $4)",
+        )
+        .bind(Uuid::now_v7())
+        .bind(channel_id)
+        .bind(user_uid)
+        .bind(now)
+        .execute(self.ctx.db.writer())
+        .await
+        .map_err(AppError::Database)?;
+
+        tracing::info!(channel_id = %channel_id, name = %name, "Channel created");
+
+        let event = ChannelEvent {
+            channel_id: channel.id,
+            action: ChannelAction::Created,
+            workspace_name: Some(ws.name.clone()),
+        };
+        self.publish(&format!("im.channel.{}", ws.name), request_id, &event)
+            .await;
+        self.emit_event(ImEvent::Channel {
+            request_id,
+            data: event,
+        });
+
+        Ok(channel)
+    }
+
+    pub async fn channel_update(
+        &self,
+        ctx: &ImSession,
+        _wk_name: &str,
+        channel_id: Uuid,
+        params: UpdateChannelParams,
+        request_id: Uuid,
+    ) -> Result<Channel, AppError> {
+        let user_uid = ctx.user;
+        let channel = self.resolve_channel(channel_id).await?;
+        self.ensure_channel_editable(user_uid, &channel).await?;
+
+        if let Some(name) = &params.name
+            && name.len() > MAX_CHANNEL_NAME
+        {
+            return Err(AppError::BadRequest("channel name too long".into()));
+        }
+
+        let visibility = match params.visibility {
+            Some(ref v) => parse_enum(
+                Some(v.clone()),
+                channel.visibility,
+                Visibility::Unknown,
+                "visibility",
+            )?,
+            None => channel.visibility,
+        };
+
+        let now = chrono::Utc::now();
+        let new_name = merge_optional_text(params.name, Some(channel.name.clone()))
+            .map(|s| s.trim().to_string())
+            .unwrap_or(channel.name);
+        let new_topic = merge_optional_text(params.topic, channel.topic.clone());
+        let new_desc = merge_optional_text(params.description, channel.description.clone());
+
+        let updated = sqlx::query_as::<_, Channel>(
+            "UPDATE channel SET \
+             name = $1, topic = $2, description = $3, visibility = $4, \
+             category_id = COALESCE($5, category_id), position = COALESCE($6, position), \
+             nsfw = COALESCE($7, nsfw), archived = COALESCE($8, archived), \
+             read_only = COALESCE($9, read_only), \
+             rate_limit_per_user = COALESCE($10, rate_limit_per_user), \
+             updated_at = $11 \
+             WHERE id = $12 AND deleted_at IS NULL \
+             RETURNING id, workspace_id, repo_id, category_id, created_by, name, topic, description, \
+              channel_type, channel_kind, visibility, position, nsfw, archived, read_only, \
+              bitrate, user_limit, rtc_region, \
+              default_auto_archive_duration, default_reaction_emoji, default_sort_order, \
+              default_forum_layout, require_tag, available_tags, default_thread_rate_limit, \
+              rate_limit_per_user, parent_channel_id, \
+              last_message_id, last_message_at, archived_at, created_at, updated_at, deleted_at",
+        )
+        .bind(&new_name)
+        .bind(&new_topic)
+        .bind(&new_desc)
+        .bind(visibility)
+        .bind(params.category_id)
+        .bind(params.position)
+        .bind(params.nsfw)
+        .bind(params.archived)
+        .bind(params.read_only)
+        .bind(params.rate_limit_per_user)
+        .bind(now)
+        .bind(channel_id)
+        .fetch_one(self.ctx.db.writer())
+        .await
+        .map_err(AppError::Database)?;
+
+        let event = ChannelEvent {
+            channel_id,
+            action: ChannelAction::Updated,
+            workspace_name: None,
+        };
+        self.publish(&format!("im.channel.{}", channel_id), request_id, &event)
+            .await;
+        self.emit_event(ImEvent::Channel {
+            request_id,
+            data: event,
+        });
+
+        Ok(updated)
+    }
+
+    pub async fn channel_delete(
+        &self,
+        ctx: &ImSession,
+        _wk_name: &str,
+        channel_id: Uuid,
+        request_id: Uuid,
+    ) -> Result<(), AppError> {
+        let user_uid = ctx.user;
+        let channel = self.resolve_channel(channel_id).await?;
+        self.ensure_channel_admin(user_uid, &channel).await?;
+
+        let now = chrono::Utc::now();
+        let result = sqlx::query(
+            "UPDATE channel SET deleted_at = $1, updated_at = $1 \
+             WHERE id = $2 AND deleted_at IS NULL",
+        )
+        .bind(now)
+        .bind(channel_id)
+        .execute(self.ctx.db.writer())
+        .await
+        .map_err(AppError::Database)?;
+
+        ensure_affected(result.rows_affected(), "channel not found")?;
+
+        let event = ChannelEvent {
+            channel_id,
+            action: ChannelAction::Deleted,
+            workspace_name: None,
+        };
+        self.publish(&format!("im.channel.{}", channel_id), request_id, &event)
+            .await;
+        self.emit_event(ImEvent::Channel {
+            request_id,
+            data: event,
+        });
+
+        Ok(())
+    }
+
+    pub(crate) async fn resolve_workspace(&self, wk_name: &str) -> Result<Workspace, AppError> {
+        Workspace::find_by_name(self.ctx.db.reader(), wk_name)
+            .await
+            .map_err(AppError::Database)?
+            .ok_or(AppError::NotFound("workspace not found".into()))
+    }
+
+    pub(crate) async fn resolve_channel(&self, channel_id: Uuid) -> Result<Channel, AppError> {
+        sqlx::query_as::<_, Channel>(
+            "SELECT id, workspace_id, repo_id, category_id, created_by, name, topic, description, \
+             channel_type, channel_kind, visibility, position, nsfw, archived, read_only, \
+             bitrate, user_limit, rtc_region, \
+             default_auto_archive_duration, default_reaction_emoji, default_sort_order, \
+             default_forum_layout, require_tag, available_tags, default_thread_rate_limit, \
+             rate_limit_per_user, parent_channel_id, \
+             last_message_id, last_message_at, archived_at, created_at, updated_at, deleted_at \
+             FROM channel WHERE id = $1 AND deleted_at IS NULL",
+        )
+        .bind(channel_id)
+        .fetch_optional(self.ctx.db.reader())
+        .await
+        .map_err(AppError::Database)?
+        .ok_or(AppError::NotFound("channel not found".into()))
+    }
+
+    pub(crate) async fn ensure_workspace_readable(
+        &self,
+        user_uid: Uuid,
+        ws: &Workspace,
+    ) -> Result<(), AppError> {
+        if Workspace::is_readable(self.ctx.db.reader(), ws, user_uid)
+            .await
+            .map_err(AppError::Database)?
+        {
+            Ok(())
+        } else {
+            Err(AppError::Unauthorized)
+        }
+    }
+
+    pub(crate) async fn ensure_workspace_role_at_least(
+        &self,
+        user_uid: Uuid,
+        ws: &Workspace,
+        min_role: Role,
+    ) -> Result<Role, AppError> {
+        let role = Workspace::user_role(self.ctx.db.reader(), ws.id, user_uid, ws.owner_id)
+            .await
+            .map_err(AppError::Database)?
+            .unwrap_or(Role::Unknown);
+        if role_level(role) < role_level(min_role) {
+            return Err(AppError::Unauthorized);
+        }
+        Ok(role)
+    }
+
+    pub(crate) async fn ensure_channel_readable(
+        &self,
+        user_uid: Uuid,
+        channel: &Channel,
+    ) -> Result<(), AppError> {
+        if channel.created_by == user_uid {
+            return Ok(());
+        }
+        let is_member = self.is_channel_member(channel.id, user_uid).await?;
+        if is_member {
+            return Ok(());
+        }
+        if channel.visibility == Visibility::Public {
+            let ws = Workspace::find_by_id(self.ctx.db.reader(), channel.workspace_id)
+                .await
+                .map_err(AppError::Database)?
+                .ok_or(AppError::NotFound("workspace not found".into()))?;
+            if Workspace::is_readable(self.ctx.db.reader(), &ws, user_uid)
+                .await
+                .map_err(AppError::Database)?
+            {
+                return Ok(());
+            }
+        }
+        Err(AppError::Unauthorized)
+    }
+
+    pub(crate) async fn ensure_channel_member(
+        &self,
+        user_uid: Uuid,
+        channel: &Channel,
+    ) -> Result<(), AppError> {
+        if channel.created_by == user_uid {
+            return Ok(());
+        }
+        let is_member = self.is_channel_member(channel.id, user_uid).await?;
+        if is_member {
+            Ok(())
+        } else {
+            Err(AppError::Forbidden("not a channel member".into()))
+        }
+    }
+
+    pub(crate) async fn ensure_channel_editable(
+        &self,
+        user_uid: Uuid,
+        channel: &Channel,
+    ) -> Result<(), AppError> {
+        if channel.created_by == user_uid {
+            return Ok(());
+        }
+        let role = self.channel_member_role(channel.id, user_uid).await?;
+        if role_level(role) >= role_level(Role::Member) {
+            return Ok(());
+        }
+        self.ensure_workspace_role_at_least(
+            user_uid,
+            &Workspace::find_by_id(self.ctx.db.reader(), channel.workspace_id)
+                .await
+                .map_err(AppError::Database)?
+                .ok_or(AppError::NotFound("workspace not found".into()))?,
+            Role::Admin,
+        )
+        .await?;
+        Ok(())
+    }
+
+    pub(crate) async fn ensure_channel_admin(
+        &self,
+        user_uid: Uuid,
+        channel: &Channel,
+    ) -> Result<(), AppError> {
+        let role = self.channel_member_role(channel.id, user_uid).await?;
+        if role_level(role) >= role_level(Role::Admin) {
+            return Ok(());
+        }
+        self.ensure_workspace_role_at_least(
+            user_uid,
+            &Workspace::find_by_id(self.ctx.db.reader(), channel.workspace_id)
+                .await
+                .map_err(AppError::Database)?
+                .ok_or(AppError::NotFound("workspace not found".into()))?,
+            Role::Admin,
+        )
+        .await?;
+        Ok(())
+    }
+
+    pub(crate) async fn is_channel_member(
+        &self,
+        channel_id: Uuid,
+        user_uid: Uuid,
+    ) -> Result<bool, AppError> {
+        sqlx::query_scalar(
+            "SELECT EXISTS(SELECT 1 FROM channel_member \
+             WHERE channel_id = $1 AND user_id = $2 AND status = 'active')",
+        )
+        .bind(channel_id)
+        .bind(user_uid)
+        .fetch_one(self.ctx.db.reader())
+        .await
+        .map_err(AppError::Database)
+    }
+
+    pub(crate) async fn channel_member_role(
+        &self,
+        channel_id: Uuid,
+        user_uid: Uuid,
+    ) -> Result<Role, AppError> {
+        let role: Option<String> = sqlx::query_scalar(
+            "SELECT role::text FROM channel_member \
+             WHERE channel_id = $1 AND user_id = $2 AND status = 'active'",
+        )
+        .bind(channel_id)
+        .bind(user_uid)
+        .fetch_optional(self.ctx.db.reader())
+        .await
+        .map_err(AppError::Database)?;
+
+        Ok(role
+            .as_deref()
+            .and_then(|s| s.parse::<Role>().ok())
+            .unwrap_or(Role::Unknown))
+    }
+
+    pub(crate) async fn update_channel_stats(
+        &self,
+        channel_id: Uuid,
+        now: chrono::DateTime<chrono::Utc>,
+        txn: &mut sqlx::Transaction<'_, sqlx::Postgres>,
+    ) -> Result<(), AppError> {
+        sqlx::query(
+            "UPDATE channel_stats SET \
+             members_count = (SELECT COUNT(*) FROM channel_member WHERE channel_id = $1 AND status = 'active'), \
+             messages_count = (SELECT COUNT(*) FROM message WHERE channel_id = $1 AND deleted_at IS NULL), \
+             threads_count = (SELECT COUNT(*) FROM message_thread WHERE channel_id = $1), \
+             reactions_count = (SELECT COUNT(*) FROM message_reaction WHERE channel_id = $1), \
+             mentions_count = (SELECT COUNT(*) FROM message_mention WHERE channel_id = $1), \
+             files_count = (SELECT COUNT(*) FROM message_attachment WHERE channel_id = $1), \
+             last_activity_at = $2, updated_at = $2 \
+             WHERE channel_id = $1",
+        )
+        .bind(channel_id)
+        .bind(now)
+        .execute(&mut **txn)
+        .await
+        .map_err(AppError::Database)?;
+        Ok(())
+    }
+}