69f12aa
use crate::context::facade::GitContext;
use export::pagination::Page;
use models::repo::repo_release;
use sea_orm::{
ActiveModelTrait, ActiveValue::Set, ColumnTrait, EntityTrait, PaginatorTrait, QueryFilter,
QueryOrder, QuerySelect,
};
use serde::{Deserialize, Serialize};
use space::services::spaces::UserDto;
use time::OffsetDateTime;
use utoipa::{IntoParams, ToSchema};
use uuid::Uuid;
use crate::share::errors::GitError;
const MAX_TITLE_LEN: usize = 255;
const MAX_CONTENT_LEN: usize = 65_536;
#[derive(Debug, Clone, Serialize, Deserialize, ToSchema)]
pub struct ReleaseDto {
pub id: Uuid,
pub repo_id: Uuid,
pub tag_name: String,
pub target: String,
pub title: String,
pub content: Option<String>,
pub sha: String,
pub num_commits: i32,
pub is_draft: bool,
pub is_prerelease: bool,
pub publisher: Option<UserDto>,
pub publisher_name: String,
pub created_at: OffsetDateTime,
pub updated_at: OffsetDateTime,
}
pub type ReleasePage = Page<ReleaseDto>;
#[derive(Debug, Clone, Deserialize, IntoParams)]
pub struct ListReleasesQuery {
#[serde(default)]
pub limit: Option<u64>,
#[serde(default)]
pub offset: Option<u64>,
/// 仅返回草稿（true）或仅返回已发布（false）；缺省返回全部。
#[serde(default)]
pub draft: Option<bool>,
}
#[derive(Debug, Clone, Deserialize, ToSchema)]
pub struct CreateReleaseCmd {
pub tag_name: String,
pub target: Option<String>,
#[serde(default)]
pub title: Option<String>,
#[serde(default)]
pub content: Option<String>,
#[serde(default)]
pub is_draft: Option<bool>,
#[serde(default)]
pub is_prerelease: Option<bool>,
}
#[derive(Debug, Clone, Deserialize, ToSchema)]
pub struct UpdateReleaseCmd {
#[serde(default)]
pub title: Option<String>,
#[serde(default)]
pub content: Option<String>,
#[serde(default)]
pub is_draft: Option<bool>,
#[serde(default)]
pub is_prerelease: Option<bool>,
}
impl super::GitService {
pub async fn list_releases(
&self,
space_name: String,
repo_name: String,
query: ListReleasesQuery,
) -> Result<ReleasePage, GitError> {
let ctx = self.context(space_name, repo_name).await?;
let limit = query.limit.unwrap_or(20).clamp(1, 100);
let offset = query.offset.unwrap_or(0);
let mut select =
repo_release::Entity::find().filter(repo_release::Column::RepoId.eq(ctx.model.id));
if let Some(draft) = query.draft {
select = select.filter(repo_release::Column::IsDraft.eq(draft));
}
let total = select.clone().count(self.db_read()).await? as i64;
let rows = select
.order_by_desc(repo_release::Column::CreatedAt)
.offset(offset)
.limit(limit)
.all(self.db_read())
.await?;
let items = self.releases_dto(&rows).await?;
Ok(Page {
items,
total,
limit,
offset,
})
}
pub async fn get_release(
&self,
space_name: String,
repo_name: String,
tag: String,
) -> Result<ReleaseDto, GitError> {
let ctx = self.context(space_name, repo_name).await?;
let row = self.find_release(ctx.model.id, &tag).await?;
let mut out = self.releases_dto(std::slice::from_ref(&row)).await?;
out.pop().ok_or(GitError::NotFound)
}
pub async fn create_release(
&self,
space_name: String,
repo_name: String,
publisher: i64,
cmd: CreateReleaseCmd,
) -> Result<ReleaseDto, GitError> {
let tag = cmd.tag_name.trim();
if tag.is_empty() || tag.contains(['\0', '\n', '\r', ' ']) {
return Err(GitError::InvalidArgument("invalid tag name".to_string()));
}
let title = cmd.title.unwrap_or_else(|| tag.to_string());
validate_len(&title, MAX_TITLE_LEN, "release title")?;
if let Some(content) = cmd.content.as_deref() {
validate_len(content, MAX_CONTENT_LEN, "release content")?;
}
let ctx = self.context(space_name, repo_name).await?;
if self
.find_release_optional(ctx.model.id, tag)
.await?
.is_some()
{
return Err(GitError::Conflict(format!(
"release for tag `{tag}` already exists"
)));
}
// 目标提交必须存在；缺省取同名标签指向的提交。
let target = match cmd.target.filter(|value| !value.trim().is_empty()) {
Some(target) => self
.baby(&ctx)
.rev_parse(&target)
.await
.map_err(crate::share::errors::map_baby)?
.to_string(),
None => self
.baby(&ctx)
.rev_parse(&format!("refs/tags/{tag}"))
.await
.map_err(crate::share::errors::map_baby)?
.to_string(),
};
let publisher_row = models::users::user::Entity::find_by_id(publisher)
.one(self.db_read())
.await?
.ok_or(GitError::Unauthorized)?;
let now = OffsetDateTime::now_utc();
let row = repo_release::ActiveModel {
id: Set(Uuid::now_v7()),
repo_id: Set(ctx.model.id),
publisher_id: Set(publisher),
publisher_name: Set(publisher_row.display_name.clone()),
tag_name: Set(tag.to_string()),
lower_tag_name: Set(tag.to_lowercase()),
target: Set(target.clone()),
title: Set(title),
content: Set(cmd.content),
sha: Set(target),
num_commits: Set(0),
is_draft: Set(cmd.is_draft.unwrap_or(true)),
is_prerelease: Set(cmd.is_prerelease.unwrap_or(false)),
is_tag: Set(true),
created_at: Set(now),
updated_at: Set(now),
}
.insert(self.db_write())
.await?;
let mut out = self.releases_dto(std::slice::from_ref(&row)).await?;
out.pop().ok_or(GitError::NotFound)
}
pub async fn update_release(
&self,
space_name: String,
repo_name: String,
tag: String,
actor: i64,
admin: bool,
cmd: UpdateReleaseCmd,
) -> Result<ReleaseDto, GitError> {
let ctx = self.context(space_name, repo_name).await?;
let row = self.find_release(ctx.model.id, &tag).await?;
if row.publisher_id != actor && !admin {
return Err(GitError::Forbidden);
}
// 已发布的 release 只允许改发布状态标记，正文不可再被改写。
let published = !row.is_draft;
if published && (cmd.title.is_some() || cmd.content.is_some()) {
return Err(GitError::Conflict(
"published release content is immutable".to_string(),
));
}
if let Some(title) = cmd.title.as_deref() {
validate_len(title, MAX_TITLE_LEN, "release title")?;
}
if let Some(content) = cmd.content.as_deref() {
validate_len(content, MAX_CONTENT_LEN, "release content")?;
}
let actor_row = models::users::user::Entity::find_by_id(actor)
.one(self.db_read())
.await?
.ok_or(GitError::Unauthorized)?;
let mut model: repo_release::ActiveModel = row.into();
if let Some(title) = cmd.title {
model.title = Set(title);
}
if let Some(content) = cmd.content {
model.content = Set(Some(content));
}
if let Some(is_draft) = cmd.is_draft {
model.is_draft = Set(is_draft);
// 首次发布时记录实际发布人。
if !is_draft {
model.publisher_id = Set(actor);
model.publisher_name = Set(actor_row.display_name.clone());
}
}
if let Some(is_prerelease) = cmd.is_prerelease {
model.is_prerelease = Set(is_prerelease);
}
model.updated_at = Set(OffsetDateTime::now_utc());
let updated = model.update(self.db_write()).await?;
let mut out = self.releases_dto(std::slice::from_ref(&updated)).await?;
out.pop().ok_or(GitError::NotFound)
}
pub async fn delete_release(
&self,
space_name: String,
repo_name: String,
tag: String,
actor: i64,
admin: bool,
) -> Result<(), GitError> {
let ctx = self.context(space_name, repo_name).await?;
let row = self.find_release(ctx.model.id, &tag).await?;
if row.publisher_id != actor && !admin {
return Err(GitError::Forbidden);
}
repo_release::Entity::delete_by_id(row.id)
.exec(self.db_write())
.await?;
Ok(())
}
async fn find_release(
&self,
repo_id: Uuid,
tag: &str,
) -> Result<repo_release::Model, GitError> {
self.find_release_optional(repo_id, tag)
.await?
.ok_or(GitError::NotFound)
}
async fn find_release_optional(
&self,
repo_id: Uuid,
tag: &str,
) -> Result<Option<repo_release::Model>, GitError> {
Ok(repo_release::Entity::find()
.filter(repo_release::Column::RepoId.eq(repo_id))
.filter(repo_release::Column::LowerTagName.eq(tag.trim().to_lowercase()))
.one(self.db_read())
.await?)
}
async fn releases_dto(
&self,
rows: &[repo_release::Model],
) -> Result<Vec<ReleaseDto>, GitError> {
let uids: Vec<i64> = rows.iter().map(|row| row.publisher_id).collect();
let users = self.user_dto_map(&uids).await?;
Ok(rows
.iter()
.map(|row| ReleaseDto {
id: row.id,
repo_id: row.repo_id,
tag_name: row.tag_name.clone(),
target: row.target.clone(),
title: row.title.clone(),
content: row.content.clone(),
sha: row.sha.clone(),
num_commits: row.num_commits,
is_draft: row.is_draft,
is_prerelease: row.is_prerelease,
publisher: users.get(&row.publisher_id).cloned(),
publisher_name: row.publisher_name.clone(),
created_at: row.created_at,
updated_at: row.updated_at,
})
.collect())
}
}
fn validate_len(value: &str, max: usize, label: &str) -> Result<(), GitError> {
if value.chars().count() > max {
return Err(GitError::InvalidArgument(format!(
"{label} exceeds {max} characters"
)));
}
Ok(())
}