194c44c
use std::collections::HashMap;
use models::dir::dirs::{self, DirKind};
use models::issue::issue_item;
use models::issue::issue_pin;
use models::issue::issues;
use models::issue::milestone;
use sea_orm::{
ActiveModelTrait, ColumnTrait, EntityTrait, PaginatorTrait, QueryFilter, QueryOrder,
QuerySelect, Set, TransactionTrait, Unchanged,
};
use serde::{Deserialize, Serialize};
use time::OffsetDateTime;
use utoipa::{IntoParams, ToSchema};
use uuid::Uuid;
use crate::errors::IssueError;
use crate::services::issues::delete_issue_cascade_in_txn;
use crate::services::service::IssueService;
use crate::share::authz::require_board_manage;
use crate::share::lookup::{board_context, lookup_board, space_context};
#[derive(Debug, Clone, Serialize, Deserialize, ToSchema)]
pub struct BoardDto {
pub id: Uuid,
pub dir_id: Uuid,
pub name: String,
/// Number prefix for the board's issues (`CAD` renders as `CAD-12`).
pub prefix: Option<String>,
pub icon: Option<String>,
pub description: Option<String>,
pub open_issues_count: i64,
pub closed_issues_count: i64,
pub created_at: OffsetDateTime,
pub updated_at: Option<OffsetDateTime>,
}
pub type BoardPage = export::pagination::Page<BoardDto>;
#[derive(Debug, Clone, Deserialize, ToSchema)]
pub struct CreateBoardCmd {
pub name: String,
#[serde(default, alias = "dir_id")]
pub parent_dir_id: Option<Uuid>,
#[serde(default)]
pub prefix: Option<String>,
#[serde(default)]
pub icon: Option<String>,
#[serde(default)]
pub description: Option<String>,
}
#[derive(Debug, Clone, Deserialize, ToSchema)]
pub struct UpdateBoardCmd {
#[serde(default)]
pub name: Option<String>,
#[serde(default, deserialize_with = "export::serde_patch::deserialize_opt_opt")]
pub prefix: Option<Option<String>>,
#[serde(default, deserialize_with = "export::serde_patch::deserialize_opt_opt")]
pub icon: Option<Option<String>>,
#[serde(default, deserialize_with = "export::serde_patch::deserialize_opt_opt")]
pub description: Option<Option<String>>,
}
#[derive(Debug, Clone, Deserialize, IntoParams, ToSchema)]
pub struct ListBoardQuery {
pub dir_id: Option<Uuid>,
pub q: Option<String>,
pub limit: Option<u64>,
pub offset: Option<u64>,
}
#[derive(Debug, Clone, Deserialize, IntoParams, ToSchema)]
pub struct BoardPath {
pub space_name: String,
pub board_id: Uuid,
}
impl IssueService {
/// `None`/blank clears the prefix; anything else is upper-cased and must
/// look like a GitLab-style project key (letter first, alphanumeric only).
fn normalize_board_prefix(&self, raw: &str) -> Result<Option<String>, IssueError> {
let trimmed = raw.trim();
if trimmed.is_empty() {
return Ok(None);
}
let prefix = trimmed.to_ascii_uppercase();
let first_is_letter = prefix.starts_with(|c: char| c.is_ascii_alphabetic());
let valid = first_is_letter
&& prefix.chars().count() <= self.config().issues.max_board_prefix_len
&& prefix.chars().all(|c| c.is_ascii_alphanumeric());
if !valid {
return Err(IssueError::BadRequest(
"board prefix must start with a letter and contain only letters and digits"
.to_string(),
));
}
Ok(Some(prefix))
}
/// Prefixes address issues (`CAD-12`), so two boards of one space must not
/// share one — the ambiguity would be permanent in every pasted link.
async fn board_prefix_taken(
&self,
space_id: Uuid,
prefix: &str,
exclude_board: Option<Uuid>,
) -> Result<bool, IssueError> {
let dir_ids: Vec<Uuid> = dirs::Entity::find()
.filter(dirs::Column::SpaceId.eq(Some(space_id)))
.filter(dirs::Column::Kind.eq(DirKind::Object))
.all(self.db().read())
.await?
.into_iter()
.map(|d| d.id)
.collect();
if dir_ids.is_empty() {
return Ok(false);
}
let mut select = issues::Entity::find()
.filter(issues::Column::DirId.is_in(dir_ids))
.filter(issues::Column::Prefix.eq(prefix));
if let Some(board_id) = exclude_board {
select = select.filter(issues::Column::Id.ne(board_id));
}
Ok(select.one(self.db().read()).await?.is_some())
}
fn board_dto(
board: issues::Model,
open_issues_count: i64,
closed_issues_count: i64,
) -> BoardDto {
BoardDto {
id: board.id,
dir_id: board.dir_id,
name: board.name,
prefix: board.prefix,
icon: board.icon,
description: board.description,
open_issues_count,
closed_issues_count,
created_at: board.created_at,
updated_at: board.updated_at,
}
}
async fn issue_counts_by_board(
&self,
board_ids: &[Uuid],
) -> Result<(HashMap<Uuid, i64>, HashMap<Uuid, i64>), IssueError> {
let mut total_counts = HashMap::new();
let mut closed_counts = HashMap::new();
if board_ids.is_empty() {
return Ok((total_counts, closed_counts));
}
let total_rows: Vec<(Uuid, i64)> = issue_item::Entity::find()
.select_only()
.column(issue_item::Column::CollectionId)
.column_as(issue_item::Column::CollectionId.count(), "cnt")
.filter(issue_item::Column::CollectionId.is_in(board_ids.to_vec()))
.group_by(issue_item::Column::CollectionId)
.into_tuple()
.all(self.db().read())
.await?;
for (collection_id, cnt) in total_rows {
total_counts.insert(collection_id, cnt);
}
let closed_rows: Vec<(Uuid, i64)> = issue_item::Entity::find()
.select_only()
.column(issue_item::Column::CollectionId)
.column_as(issue_item::Column::CollectionId.count(), "cnt")
.filter(issue_item::Column::CollectionId.is_in(board_ids.to_vec()))
.filter(issue_item::Column::ClosedAt.is_not_null())
.group_by(issue_item::Column::CollectionId)
.into_tuple()
.all(self.db().read())
.await?;
for (collection_id, cnt) in closed_rows {
closed_counts.insert(collection_id, cnt);
}
Ok((total_counts, closed_counts))
}
async fn build_board_dto(&self, board: issues::Model) -> Result<BoardDto, IssueError> {
let (total_counts, closed_counts) = self.issue_counts_by_board(&[board.id]).await?;
let closed_count = closed_counts.get(&board.id).copied().unwrap_or(0);
let open_count = total_counts.get(&board.id).copied().unwrap_or(0) - closed_count;
Ok(Self::board_dto(board, open_count, closed_count))
}
#[tracing::instrument(name = "issues.create_board", skip_all, fields(caller = %caller, space = %space_name))]
pub async fn create_board(
&self,
caller: i64,
space_name: &str,
cmd: CreateBoardCmd,
) -> Result<BoardDto, IssueError> {
let space = space_context(self, caller, space_name).await?;
require_board_manage(self, &space, caller).await?;
let name = cmd.name.trim();
if name.is_empty() || name.chars().count() > self.config().issues.max_board_name_len {
return Err(IssueError::BadRequest(
"board name is empty or too long".to_string(),
));
}
let prefix = match cmd.prefix.as_deref() {
Some(raw) => self.normalize_board_prefix(raw)?,
None => None,
};
if let Some(ref prefix) = prefix
&& self.board_prefix_taken(space.id, prefix, None).await?
{
return Err(IssueError::BadRequest(
"board prefix is already used by another board".to_string(),
));
}
if let Some(p) = cmd.parent_dir_id {
let parent = dirs::Entity::find_by_id(p)
.filter(dirs::Column::SpaceId.eq(Some(space.id)))
.one(self.db().read())
.await?
.ok_or(IssueError::NotFound)?;
if parent.kind != DirKind::Dir {
return Err(IssueError::BadRequest(
"parent node must be a dir".to_string(),
));
}
}
let (_dir, board) = {
let txn = self.db().write().begin().await?;
let position = {
let max_node = dirs::Entity::find()
.filter(dirs::Column::SpaceId.eq(Some(space.id)))
.filter(dirs::Column::ParentDirId.eq(cmd.parent_dir_id))
.order_by_desc(dirs::Column::Position)
.lock(sea_orm::sea_query::LockType::Update)
.one(&txn)
.await?;
max_node.map(|n| n.position + 1).unwrap_or(0)
};
let now = OffsetDateTime::now_utc();
let dir_row = dirs::ActiveModel {
id: Set(Uuid::now_v7()),
space_id: Set(Some(space.id)),
name: Set(name.to_string()),
kind: Set(DirKind::Object),
parent_dir_id: Set(cmd.parent_dir_id),
color: Set(None),
position: Set(position),
icon: Set(cmd.icon.clone()),
topic: Set(None),
purpose: Set(cmd.description.clone()),
is_archived: Set(false),
archived_at: Set(None),
archived_by: Set(None),
created_at: Set(now),
updated_at: Set(now),
created_by_uid: Set(caller),
};
let dir = dir_row.insert(&txn).await?;
let board_row = issues::ActiveModel {
id: Set(Uuid::now_v7()),
dir_id: Set(dir.id),
name: Set(name.to_string()),
prefix: Set(prefix),
icon: Set(cmd.icon),
description: Set(cmd.description),
created_at: Set(now),
updated_at: Set(None),
};
let board = board_row.insert(&txn).await?;
txn.commit().await?;
(dir, board)
};
Ok(BoardDto {
id: board.id,
dir_id: board.dir_id,
name: board.name,
prefix: board.prefix,
icon: board.icon,
description: board.description,
open_issues_count: 0,
closed_issues_count: 0,
created_at: board.created_at,
updated_at: board.updated_at,
})
}
pub async fn list_boards(
&self,
caller: i64,
space_name: &str,
q: ListBoardQuery,
) -> Result<BoardPage, IssueError> {
let space = space_context(self, caller, space_name).await?;
let (limit, offset) = self.paginate(q.limit, q.offset);
let dirs_in_space = dirs::Entity::find()
.filter(dirs::Column::SpaceId.eq(Some(space.id)))
.filter(dirs::Column::Kind.eq(DirKind::Object))
.all(self.db().read())
.await?;
if dirs_in_space.is_empty() {
return Ok(BoardPage {
items: Vec::new(),
total: 0,
limit,
offset,
});
}
let dir_ids: Vec<Uuid> = if let Some(target_dir) = q.dir_id {
dirs_in_space
.into_iter()
.filter(|d| d.parent_dir_id == Some(target_dir) || d.id == target_dir)
.map(|d| d.id)
.collect()
} else {
dirs_in_space.into_iter().map(|d| d.id).collect()
};
if dir_ids.is_empty() {
return Ok(BoardPage {
items: Vec::new(),
total: 0,
limit,
offset,
});
}
let mut select = issues::Entity::find().filter(issues::Column::DirId.is_in(dir_ids));
if let Some(ref search) = q.q {
let kw = search.trim();
if !kw.is_empty() {
select = select.filter(issues::Column::Name.contains(kw));
}
}
select = select.order_by_desc(issues::Column::CreatedAt);
let total = select.clone().count(self.db().read()).await? as i64;
let rows = select
.limit(limit)
.offset(offset)
.all(self.db().read())
.await?;
let board_ids: Vec<Uuid> = rows.iter().map(|b| b.id).collect();
let (total_counts, closed_counts) = self.issue_counts_by_board(&board_ids).await?;
let items = rows
.into_iter()
.map(|board| {
let closed_count = closed_counts.get(&board.id).copied().unwrap_or(0);
let open_count = total_counts.get(&board.id).copied().unwrap_or(0) - closed_count;
Self::board_dto(board, open_count, closed_count)
})
.collect();
Ok(BoardPage {
items,
total,
limit,
offset,
})
}
pub async fn get_board(
&self,
caller: i64,
space_name: &str,
board_id: Uuid,
) -> Result<BoardDto, IssueError> {
let (_, board) = board_context(self, caller, space_name, board_id).await?;
self.build_board_dto(board).await
}
#[tracing::instrument(name = "issues.update_board", skip_all, fields(caller = %caller, space = %space_name, board_id = %board_id))]
pub async fn update_board(
&self,
caller: i64,
space_name: &str,
board_id: Uuid,
cmd: UpdateBoardCmd,
) -> Result<BoardDto, IssueError> {
let space = space_context(self, caller, space_name).await?;
require_board_manage(self, &space, caller).await?;
let board = lookup_board(self, &space, board_id, caller).await?;
let now = OffsetDateTime::now_utc();
let mut am: issues::ActiveModel = board.clone().into();
let mut dir_am = dirs::ActiveModel {
id: Unchanged(board.dir_id),
..Default::default()
};
let mut dir_changed = false;
if let Some(new_name) = cmd.name {
let name = new_name.trim();
if name.is_empty() || name.chars().count() > self.config().issues.max_board_name_len {
return Err(IssueError::BadRequest(
"board name is empty or too long".to_string(),
));
}
am.name = Set(name.to_string());
dir_am.name = Set(name.to_string());
dir_changed = true;
}
if let Some(raw_prefix) = cmd.prefix {
let prefix = match raw_prefix.as_deref() {
Some(raw) => self.normalize_board_prefix(raw)?,
None => None,
};
if let Some(ref prefix) = prefix
&& self
.board_prefix_taken(space.id, prefix, Some(board_id))
.await?
{
return Err(IssueError::BadRequest(
"board prefix is already used by another board".to_string(),
));
}
am.prefix = Set(prefix);
}
if let Some(icon) = cmd.icon {
am.icon = Set(icon.clone());
dir_am.icon = Set(icon);
dir_changed = true;
}
if let Some(desc) = cmd.description {
am.description = Set(desc.clone());
dir_am.purpose = Set(desc);
dir_changed = true;
}
am.updated_at = Set(Some(now));
let updated = {
let txn = self.db().write().begin().await?;
if dir_changed {
dir_am.updated_at = Set(now);
dir_am.update(&txn).await?;
}
let updated = am.update(&txn).await?;
txn.commit().await?;
updated
};
self.build_board_dto(updated).await
}
#[tracing::instrument(name = "issues.delete_board", skip_all, fields(caller = %caller, space = %space_name, board_id = %board_id))]
pub async fn delete_board(
&self,
caller: i64,
space_name: &str,
board_id: Uuid,
) -> Result<(), IssueError> {
let space = space_context(self, caller, space_name).await?;
require_board_manage(self, &space, caller).await?;
let board = lookup_board(self, &space, board_id, caller).await?;
self.db()
.primary()
.transaction::<_, (), IssueError>(|txn| {
Box::pin(async move {
let issue_rows = issue_item::Entity::find()
.filter(issue_item::Column::CollectionId.eq(board.id))
.all(txn)
.await?;
issue_pin::Entity::delete_many()
.filter(issue_pin::Column::CollectionId.eq(board.id))
.exec(txn)
.await?;
for item in issue_rows {
delete_issue_cascade_in_txn(txn, item.id).await?;
}
milestone::Entity::delete_many()
.filter(milestone::Column::CollectionId.eq(board.id))
.exec(txn)
.await?;
issues::Entity::delete_by_id(board.id).exec(txn).await?;
dirs::Entity::delete_by_id(board.dir_id).exec(txn).await?;
Ok(())
})
})
.await?;
Ok(())
}
}