330 lines
11 KiB
Rust
330 lines
11 KiB
Rust
use crate::AppService;
|
|
use crate::error::AppError;
|
|
use chrono::{DateTime, Utc};
|
|
use models::projects::project;
|
|
use models::projects::project_activity;
|
|
use models::users::user;
|
|
use models::workspaces::workspace;
|
|
use models::workspaces::workspace_membership;
|
|
use sea_orm::*;
|
|
use serde::{Deserialize, Serialize};
|
|
use session::Session;
|
|
use utoipa::IntoParams;
|
|
|
|
#[derive(Debug, Clone, Serialize, Deserialize, utoipa::ToSchema)]
|
|
pub struct WorkspaceInfoResponse {
|
|
pub id: Uuid,
|
|
pub slug: String,
|
|
pub name: String,
|
|
pub description: Option<String>,
|
|
pub avatar_url: Option<String>,
|
|
pub plan: String,
|
|
pub billing_email: Option<String>,
|
|
pub member_count: i64,
|
|
pub my_role: Option<String>,
|
|
pub created_at: chrono::DateTime<Utc>,
|
|
pub updated_at: chrono::DateTime<Utc>,
|
|
}
|
|
|
|
#[derive(Debug, Clone, Serialize, Deserialize, utoipa::ToSchema)]
|
|
pub struct WorkspaceListItem {
|
|
pub id: Uuid,
|
|
pub slug: String,
|
|
pub name: String,
|
|
pub description: Option<String>,
|
|
pub avatar_url: Option<String>,
|
|
pub plan: String,
|
|
pub my_role: String,
|
|
pub created_at: chrono::DateTime<Utc>,
|
|
}
|
|
|
|
#[derive(Debug, Clone, Serialize, Deserialize, utoipa::ToSchema)]
|
|
pub struct WorkspaceListResponse {
|
|
pub workspaces: Vec<WorkspaceListItem>,
|
|
pub total: u64,
|
|
}
|
|
|
|
#[derive(Debug, Clone, Serialize, Deserialize, utoipa::ToSchema, IntoParams)]
|
|
pub struct WorkspaceProjectsQuery {
|
|
pub page: Option<u64>,
|
|
pub per_page: Option<u64>,
|
|
}
|
|
|
|
#[derive(Debug, Clone, Serialize, Deserialize, utoipa::ToSchema)]
|
|
pub struct WorkspaceProjectItem {
|
|
pub uid: Uuid,
|
|
pub name: String,
|
|
pub display_name: String,
|
|
pub avatar_url: Option<String>,
|
|
pub description: Option<String>,
|
|
pub is_public: bool,
|
|
pub created_at: DateTime<Utc>,
|
|
pub updated_at: DateTime<Utc>,
|
|
}
|
|
|
|
#[derive(Debug, Clone, Serialize, Deserialize, utoipa::ToSchema)]
|
|
pub struct WorkspaceProjectsResponse {
|
|
pub projects: Vec<WorkspaceProjectItem>,
|
|
pub total: u64,
|
|
pub page: u64,
|
|
pub per_page: u64,
|
|
}
|
|
|
|
#[derive(Debug, Clone, Serialize, Deserialize, utoipa::ToSchema)]
|
|
pub struct WorkspaceActivityItem {
|
|
pub id: i64,
|
|
pub project_name: String,
|
|
pub event_type: String,
|
|
pub title: String,
|
|
pub content: Option<String>,
|
|
pub actor_name: String,
|
|
pub actor_avatar: Option<String>,
|
|
pub created_at: DateTime<Utc>,
|
|
}
|
|
|
|
#[derive(Debug, Clone, Serialize, Deserialize, utoipa::ToSchema)]
|
|
pub struct WorkspaceStatsResponse {
|
|
pub project_count: i64,
|
|
pub member_count: i64,
|
|
pub my_role: Option<String>,
|
|
pub recent_activities: Vec<WorkspaceActivityItem>,
|
|
}
|
|
|
|
impl AppService {
|
|
/// Get workspace info by slug. Returns error if user is not a member.
|
|
pub async fn workspace_info(
|
|
&self,
|
|
ctx: &Session,
|
|
slug: String,
|
|
) -> Result<WorkspaceInfoResponse, AppError> {
|
|
let user_uid = ctx.user();
|
|
let ws = self.utils_find_workspace_by_slug(slug.clone()).await?;
|
|
|
|
let my_role = if let Some(uid) = user_uid {
|
|
workspace_membership::Entity::find()
|
|
.filter(workspace_membership::Column::WorkspaceId.eq(ws.id))
|
|
.filter(workspace_membership::Column::UserId.eq(uid))
|
|
.filter(workspace_membership::Column::Status.eq("active"))
|
|
.one(&self.db)
|
|
.await?
|
|
.map(|m| m.role)
|
|
} else {
|
|
None
|
|
};
|
|
|
|
let member_count = workspace_membership::Entity::find()
|
|
.filter(workspace_membership::Column::WorkspaceId.eq(ws.id))
|
|
.filter(workspace_membership::Column::Status.eq("active"))
|
|
.count(&self.db)
|
|
.await?;
|
|
|
|
Ok(WorkspaceInfoResponse {
|
|
id: ws.id,
|
|
slug: ws.slug,
|
|
name: ws.name,
|
|
description: ws.description,
|
|
avatar_url: ws.avatar_url,
|
|
plan: ws.plan,
|
|
billing_email: ws.billing_email,
|
|
member_count: member_count as i64,
|
|
my_role,
|
|
created_at: ws.created_at,
|
|
updated_at: ws.updated_at,
|
|
})
|
|
}
|
|
|
|
/// List all workspaces the current user is a member of.
|
|
pub async fn workspace_list(&self, ctx: &Session) -> Result<WorkspaceListResponse, AppError> {
|
|
let user_uid = ctx.user().ok_or(AppError::Unauthorized)?;
|
|
|
|
let memberships = workspace_membership::Entity::find()
|
|
.filter(workspace_membership::Column::UserId.eq(user_uid))
|
|
.filter(workspace_membership::Column::Status.eq("active"))
|
|
.all(&self.db)
|
|
.await?;
|
|
|
|
let workspace_ids: Vec<Uuid> = memberships.iter().map(|m| m.workspace_id).collect();
|
|
let total = workspace_ids.len() as u64;
|
|
|
|
let workspaces = workspace::Entity::find()
|
|
.filter(workspace::Column::Id.is_in(workspace_ids.clone()))
|
|
.filter(workspace::Column::DeletedAt.is_null())
|
|
.all(&self.db)
|
|
.await?;
|
|
|
|
let items: Vec<WorkspaceListItem> = workspaces
|
|
.into_iter()
|
|
.map(|ws| {
|
|
let membership = memberships
|
|
.iter()
|
|
.find(|m| m.workspace_id == ws.id)
|
|
.cloned()
|
|
.unwrap();
|
|
WorkspaceListItem {
|
|
id: ws.id,
|
|
slug: ws.slug,
|
|
name: ws.name,
|
|
description: ws.description,
|
|
avatar_url: ws.avatar_url,
|
|
plan: ws.plan,
|
|
my_role: membership.role,
|
|
created_at: ws.created_at,
|
|
}
|
|
})
|
|
.collect();
|
|
|
|
Ok(WorkspaceListResponse {
|
|
workspaces: items,
|
|
total,
|
|
})
|
|
}
|
|
|
|
/// List projects belonging to a workspace.
|
|
pub async fn workspace_projects(
|
|
&self,
|
|
ctx: &Session,
|
|
workspace_slug: String,
|
|
query: WorkspaceProjectsQuery,
|
|
) -> Result<WorkspaceProjectsResponse, AppError> {
|
|
let user_uid = ctx.user().ok_or(AppError::Unauthorized)?;
|
|
let ws = self.utils_find_workspace_by_slug(workspace_slug).await?;
|
|
let _ = workspace_membership::Entity::find()
|
|
.filter(workspace_membership::Column::WorkspaceId.eq(ws.id))
|
|
.filter(workspace_membership::Column::UserId.eq(user_uid))
|
|
.filter(workspace_membership::Column::Status.eq("active"))
|
|
.one(&self.db)
|
|
.await?
|
|
.ok_or(AppError::NotWorkspaceMember)?;
|
|
|
|
let page = std::cmp::max(query.page.unwrap_or(1), 1);
|
|
let per_page = query.per_page.unwrap_or(20).clamp(1, 200);
|
|
|
|
let paginator = project::Entity::find()
|
|
.filter(project::Column::WorkspaceId.eq(ws.id))
|
|
.order_by_desc(project::Column::CreatedAt)
|
|
.paginate(&self.db, per_page);
|
|
let total = paginator.num_items().await?;
|
|
let rows = paginator.fetch_page(page - 1).await?;
|
|
|
|
let projects = rows
|
|
.into_iter()
|
|
.map(|p| WorkspaceProjectItem {
|
|
uid: p.id,
|
|
name: p.name,
|
|
display_name: p.display_name,
|
|
avatar_url: p.avatar_url,
|
|
description: p.description,
|
|
is_public: p.is_public,
|
|
created_at: p.created_at,
|
|
updated_at: p.updated_at,
|
|
})
|
|
.collect();
|
|
|
|
Ok(WorkspaceProjectsResponse {
|
|
projects,
|
|
total,
|
|
page,
|
|
per_page,
|
|
})
|
|
}
|
|
|
|
/// Get workspace stats: project count, member count, recent activities.
|
|
pub async fn workspace_stats(
|
|
&self,
|
|
ctx: &Session,
|
|
workspace_slug: String,
|
|
) -> Result<WorkspaceStatsResponse, AppError> {
|
|
let user_uid = ctx.user().ok_or(AppError::Unauthorized)?;
|
|
let ws = self.utils_find_workspace_by_slug(workspace_slug).await?;
|
|
|
|
let membership = workspace_membership::Entity::find()
|
|
.filter(workspace_membership::Column::WorkspaceId.eq(ws.id))
|
|
.filter(workspace_membership::Column::UserId.eq(user_uid))
|
|
.filter(workspace_membership::Column::Status.eq("active"))
|
|
.one(&self.db)
|
|
.await?;
|
|
|
|
let member_count = workspace_membership::Entity::find()
|
|
.filter(workspace_membership::Column::WorkspaceId.eq(ws.id))
|
|
.filter(workspace_membership::Column::Status.eq("active"))
|
|
.count(&self.db)
|
|
.await?;
|
|
|
|
let project_count = project::Entity::find()
|
|
.filter(project::Column::WorkspaceId.eq(ws.id))
|
|
.count(&self.db)
|
|
.await?;
|
|
|
|
// Get recent activities across all workspace projects
|
|
let workspace_projects = project::Entity::find()
|
|
.filter(project::Column::WorkspaceId.eq(ws.id))
|
|
.all(&self.db)
|
|
.await?;
|
|
let project_ids: Vec<Uuid> = workspace_projects.iter().map(|p| p.id).collect();
|
|
let project_names: std::collections::HashMap<Uuid, String> = workspace_projects
|
|
.into_iter()
|
|
.map(|p| (p.id, p.name))
|
|
.collect();
|
|
|
|
let recent_activities = if project_ids.is_empty() {
|
|
Vec::new()
|
|
} else {
|
|
let activities = project_activity::Entity::find()
|
|
.filter(project_activity::Column::Project.is_in(project_ids.clone()))
|
|
.filter(project_activity::Column::IsPrivate.eq(false))
|
|
.order_by_desc(project_activity::Column::CreatedAt)
|
|
.limit(10)
|
|
.all(&self.db)
|
|
.await?;
|
|
|
|
// Collect actor IDs
|
|
let actor_ids: Vec<Uuid> = activities.iter().map(|a| a.actor).collect();
|
|
let actors = user::Entity::find()
|
|
.filter(user::Column::Uid.is_in(actor_ids))
|
|
.all(&self.db)
|
|
.await?;
|
|
let actor_map: std::collections::HashMap<Uuid, (String, Option<String>)> = actors
|
|
.into_iter()
|
|
.map(|u| {
|
|
(
|
|
u.uid,
|
|
(
|
|
u.display_name.or(Some(u.username)).unwrap_or_default(),
|
|
u.avatar_url,
|
|
),
|
|
)
|
|
})
|
|
.collect();
|
|
|
|
activities
|
|
.into_iter()
|
|
.map(|a| {
|
|
let (actor_name, actor_avatar) = actor_map
|
|
.get(&a.actor)
|
|
.cloned()
|
|
.unwrap_or_else(|| ("Unknown".to_string(), None));
|
|
WorkspaceActivityItem {
|
|
id: a.id,
|
|
project_name: project_names.get(&a.project).cloned().unwrap_or_default(),
|
|
event_type: a.event_type,
|
|
title: a.title,
|
|
content: a.content,
|
|
actor_name,
|
|
actor_avatar,
|
|
created_at: a.created_at,
|
|
}
|
|
})
|
|
.collect()
|
|
};
|
|
|
|
Ok(WorkspaceStatsResponse {
|
|
project_count: project_count as i64,
|
|
member_count: member_count as i64,
|
|
my_role: membership.map(|m| m.role),
|
|
recent_activities,
|
|
})
|
|
}
|
|
}
|
|
|
|
use uuid::Uuid;
|