feat: init

2026-06-07 11:30:56 +08:00
commit 563381c1ca
361 changed files with 41327 additions and 0 deletions
@@ -0,0 +1,158 @@
+use uuid::Uuid;
+
+use crate::error::AppError;
+use crate::models::common::Role;
+use crate::models::issues::IssueTemplate;
+use crate::service::IssueService;
+use crate::session::Session;
+
+use super::util::{clamp_limit_offset, ensure_affected, required_text};
+
+#[derive(serde::Deserialize, serde::Serialize, Clone, Debug, utoipa::ToSchema)]
+pub struct CreateTemplateParams {
+    pub name: String,
+    pub description: Option<String>,
+    pub title_template: Option<String>,
+    pub body_template: String,
+    pub labels: Vec<String>,
+}
+
+#[derive(serde::Deserialize, serde::Serialize, Clone, Debug, utoipa::ToSchema)]
+pub struct UpdateTemplateParams {
+    pub name: Option<String>,
+    pub description: Option<String>,
+    pub title_template: Option<String>,
+    pub body_template: Option<String>,
+    pub labels: Option<Vec<String>>,
+    pub active: Option<bool>,
+}
+
+impl IssueService {
+    pub async fn issue_templates(
+        &self,
+        ctx: &Session,
+        wk_name: &str,
+        repo_name: &str,
+        limit: i64,
+        offset: i64,
+    ) -> Result<Vec<IssueTemplate>, AppError> {
+        let user_uid = ctx.user().ok_or(AppError::Unauthorized)?;
+        let repo_id = self.resolve_repo_id(wk_name, repo_name).await?;
+        let repo = crate::models::repos::Repo::find_by_id(self.ctx.db.reader(), repo_id)
+            .await
+            .map_err(AppError::Database)?
+            .ok_or(AppError::NotFound("repo not found".into()))?;
+        self.ensure_repo_readable(user_uid, &repo).await?;
+        let (limit, offset) = clamp_limit_offset(limit, offset);
+        sqlx::query_as::<_, IssueTemplate>(
+            "SELECT id, repo_id, name, description, title_template, body_template, labels, \
+             active, created_by, created_at, updated_at \
+             FROM issue_template WHERE repo_id = $1 AND active = true \
+             ORDER BY name ASC LIMIT $2 OFFSET $3",
+        )
+        .bind(repo_id)
+        .bind(limit)
+        .bind(offset)
+        .fetch_all(self.ctx.db.reader())
+        .await
+        .map_err(AppError::Database)
+    }
+
+    pub async fn issue_create_template(
+        &self,
+        ctx: &Session,
+        wk_name: &str,
+        repo_name: &str,
+        params: CreateTemplateParams,
+    ) -> Result<IssueTemplate, AppError> {
+        let user_uid = ctx.user().ok_or(AppError::Unauthorized)?;
+        let repo_id = self.resolve_repo_id(wk_name, repo_name).await?;
+        self.ensure_repo_role(repo_id, user_uid, Role::Member)
+            .await?;
+        let name = required_text(params.name, "name")?;
+        let body_template = required_text(params.body_template, "body_template")?;
+        let now = chrono::Utc::now();
+        sqlx::query_as::<_, IssueTemplate>(
+            "INSERT INTO issue_template (id, repo_id, name, description, title_template, body_template, \
+             labels, active, created_by, created_at, updated_at) \
+             VALUES ($1, $2, $3, $4, $5, $6, $7, true, $8, $9, $9) \
+             RETURNING id, repo_id, name, description, title_template, body_template, labels, \
+             active, created_by, created_at, updated_at",
+        )
+        .bind(Uuid::now_v7()).bind(repo_id).bind(&name).bind(params.description.as_deref())
+        .bind(params.title_template.as_deref()).bind(&body_template)
+        .bind(sqlx::types::Json(&params.labels)).bind(user_uid).bind(now)
+        .fetch_one(self.ctx.db.writer()).await.map_err(AppError::Database)
+    }
+
+    pub async fn issue_update_template(
+        &self,
+        ctx: &Session,
+        wk_name: &str,
+        repo_name: &str,
+        template_id: Uuid,
+        params: UpdateTemplateParams,
+    ) -> Result<IssueTemplate, AppError> {
+        let user_uid = ctx.user().ok_or(AppError::Unauthorized)?;
+        let repo_id = self.resolve_repo_id(wk_name, repo_name).await?;
+        self.ensure_repo_role(repo_id, user_uid, Role::Admin)
+            .await?;
+        let current = sqlx::query_as::<_, IssueTemplate>(
+            "SELECT id, repo_id, name, description, title_template, body_template, labels, \
+             active, created_by, created_at, updated_at \
+             FROM issue_template WHERE id = $1 AND repo_id = $2",
+        )
+        .bind(template_id)
+        .bind(repo_id)
+        .fetch_optional(self.ctx.db.reader())
+        .await
+        .map_err(AppError::Database)?
+        .ok_or(AppError::NotFound("template not found".into()))?;
+
+        let name = params.name.unwrap_or(current.name);
+        let description = params.description.or(current.description);
+        let title_template = params.title_template.or(current.title_template);
+        let body_template = params.body_template.unwrap_or(current.body_template);
+        let labels = params.labels.unwrap_or(current.labels);
+        let active = params.active.unwrap_or(current.active);
+        let now = chrono::Utc::now();
+
+        sqlx::query_as::<_, IssueTemplate>(
+            "UPDATE issue_template SET name = $1, description = $2, title_template = $3, \
+             body_template = $4, labels = $5, active = $6, updated_at = $7 WHERE id = $8 \
+             RETURNING id, repo_id, name, description, title_template, body_template, labels, \
+             active, created_by, created_at, updated_at",
+        )
+        .bind(&name)
+        .bind(&description)
+        .bind(&title_template)
+        .bind(&body_template)
+        .bind(sqlx::types::Json(&labels))
+        .bind(active)
+        .bind(now)
+        .bind(template_id)
+        .fetch_one(self.ctx.db.writer())
+        .await
+        .map_err(AppError::Database)
+    }
+
+    pub async fn issue_delete_template(
+        &self,
+        ctx: &Session,
+        wk_name: &str,
+        repo_name: &str,
+        template_id: Uuid,
+    ) -> Result<(), AppError> {
+        let user_uid = ctx.user().ok_or(AppError::Unauthorized)?;
+        let repo_id = self.resolve_repo_id(wk_name, repo_name).await?;
+        self.ensure_repo_role(repo_id, user_uid, Role::Admin)
+            .await?;
+        let result = sqlx::query("DELETE FROM issue_template WHERE id = $1 AND repo_id = $2")
+            .bind(template_id)
+            .bind(repo_id)
+            .execute(self.ctx.db.writer())
+            .await
+            .map_err(AppError::Database)?;
+        ensure_affected(result.rows_affected(), "template not found")
+    }
+}