a06673b
use db::conn::sea_orm::*;
use db::repo::repo_release as release_entity;
use time::OffsetDateTime;
use uuid::Uuid;
use crate::error::{RepoError, RepoResult};
use crate::features::RepoService;
use crate::path::validate_tag_name;
use super::types::{
CreateReleaseOption, EditReleaseOption, ListReleaseQuery, ReleasePage, ReleaseView,
};
fn require_authenticated(actor: Uuid) -> RepoResult<()> {
if actor.is_nil() {
return Err(RepoError::Unauthorized("authentication required".into()));
}
Ok(())
}
async fn load_release(
svc: &RepoService,
repo_id: Uuid,
release_id: Uuid,
) -> RepoResult<release_entity::Model> {
let db = svc.db.reader();
let release = release_entity::Entity::find_by_id(release_id)
.one(&db)
.await?
.ok_or_else(|| RepoError::NotFound(format!("release {release_id}")))?;
if release.repo_id != repo_id {
return Err(RepoError::NotFound(format!("release {release_id}")));
}
Ok(release)
}
pub async fn list_releases(
svc: &RepoService,
actor: Uuid,
repo_id: Uuid,
q: ListReleaseQuery,
) -> RepoResult<ReleasePage> {
let _ = actor;
let limit = q.limit.unwrap_or(svc.config.default_pagination);
let offset = q.page.unwrap_or(0).saturating_mul(limit);
let limit = std::cmp::min(limit, svc.config.max_pagination);
let db = svc.db.reader();
let mut query = release_entity::Entity::find()
.filter(release_entity::Column::RepoId.eq(repo_id))
.filter(release_entity::Column::IsTag.eq(false));
if let Some(d) = q.draft {
query = query.filter(release_entity::Column::IsDraft.eq(d));
}
if let Some(p) = q.prerelease {
query = query.filter(release_entity::Column::IsPrerelease.eq(p));
}
let total = query.clone().count(&db).await?;
let items = query
.order_by_desc(release_entity::Column::CreatedAt)
.limit(Some(limit))
.offset(Some(offset))
.all(&db)
.await?
.into_iter()
.map(ReleaseView::from)
.collect();
Ok(ReleasePage {
items,
total: total as i64,
})
}
pub async fn get_release(
svc: &RepoService,
actor: Uuid,
repo_id: Uuid,
release_id: Uuid,
) -> RepoResult<ReleaseView> {
let _ = actor;
let release = load_release(svc, repo_id, release_id).await?;
Ok(ReleaseView::from(release))
}
pub async fn get_latest_release(
svc: &RepoService,
actor: Uuid,
repo_id: Uuid,
) -> RepoResult<ReleaseView> {
let _ = actor;
let db = svc.db.reader();
let release = release_entity::Entity::find()
.filter(release_entity::Column::RepoId.eq(repo_id))
.filter(release_entity::Column::IsTag.eq(false))
.filter(release_entity::Column::IsDraft.eq(false))
.order_by_desc(release_entity::Column::CreatedAt)
.one(&db)
.await?
.ok_or_else(|| RepoError::NotFound("no published release".into()))?;
Ok(ReleaseView::from(release))
}
pub async fn get_release_by_tag(
svc: &RepoService,
actor: Uuid,
repo_id: Uuid,
tag: &str,
) -> RepoResult<ReleaseView> {
let _ = actor;
let db = svc.db.reader();
let release = release_entity::Entity::find()
.filter(release_entity::Column::RepoId.eq(repo_id))
.filter(release_entity::Column::TagName.eq(tag))
.one(&db)
.await?
.ok_or_else(|| RepoError::NotFound(format!("release for tag {tag}")))?;
if release.is_tag {
return Err(RepoError::NotFound(format!("release for tag {tag}")));
}
Ok(ReleaseView::from(release))
}
pub async fn create_release(
svc: &RepoService,
actor: Uuid,
repo_id: Uuid,
input: CreateReleaseOption,
) -> RepoResult<ReleaseView> {
require_authenticated(actor)?;
let tag = validate_tag_name(&input.tag_name, svc.config.max_tag_name_len)?;
if let Some(ref c) = input.content {
if c.len() > svc.config.max_release_body_len {
return Err(RepoError::BadRequest(format!(
"release content too long (max {})",
svc.config.max_release_body_len
)));
}
}
let _ = input.tag_message;
let db = svc.db.writer();
let now = OffsetDateTime::now_utc();
let active: release_entity::ActiveModel = release_entity::ActiveModel {
id: Set(Uuid::new_v4()),
repo_id: Set(repo_id),
publisher_id: Set(actor),
publisher_name: Set(String::new()),
tag_name: Set(tag.clone()),
lower_tag_name: Set(tag.to_lowercase()),
target: Set(input.target.unwrap_or_else(|| "main".to_string())),
title: Set(input.title),
content: Set(input.content),
sha: Set(String::new()),
num_commits: Set(0),
is_draft: Set(input.is_draft.unwrap_or(false)),
is_prerelease: Set(input.is_prerelease.unwrap_or(false)),
is_tag: Set(false),
created_at: Set(now),
updated_at: Set(now),
};
let saved = active.insert(&db).await?;
Ok(ReleaseView::from(saved))
}
pub async fn edit_release(
svc: &RepoService,
actor: Uuid,
repo_id: Uuid,
release_id: Uuid,
input: EditReleaseOption,
) -> RepoResult<ReleaseView> {
require_authenticated(actor)?;
let release = load_release(svc, repo_id, release_id).await?;
let db = svc.db.writer();
let mut active: release_entity::ActiveModel = release.into();
if let Some(t) = input.tag_name {
let validated = validate_tag_name(&t, svc.config.max_tag_name_len)?;
active.tag_name = Set(validated.clone());
active.lower_tag_name = Set(validated.to_lowercase());
}
if let Some(t) = input.target {
active.target = Set(t);
}
if let Some(t) = input.title {
active.title = Set(t);
}
if let Some(c) = input.content {
if let Some(ref body) = c {
if body.len() > svc.config.max_release_body_len {
return Err(RepoError::BadRequest(format!(
"release content too long (max {})",
svc.config.max_release_body_len
)));
}
}
active.content = Set(c);
}
if let Some(d) = input.is_draft {
active.is_draft = Set(d);
}
if let Some(p) = input.is_prerelease {
active.is_prerelease = Set(p);
}
active.updated_at = Set(OffsetDateTime::now_utc());
let saved = active.update(&db).await?;
Ok(ReleaseView::from(saved))
}
pub async fn delete_release(
svc: &RepoService,
actor: Uuid,
repo_id: Uuid,
release_id: Uuid,
) -> RepoResult<()> {
require_authenticated(actor)?;
let _ = load_release(svc, repo_id, release_id).await?;
let db = svc.db.writer();
release_entity::Entity::delete_by_id(release_id)
.exec(&db)
.await?;
Ok(())
}
pub async fn delete_release_by_tag(
svc: &RepoService,
actor: Uuid,
repo_id: Uuid,
tag: &str,
) -> RepoResult<()> {
require_authenticated(actor)?;
let db = svc.db.writer();
release_entity::Entity::delete_many()
.filter(release_entity::Column::RepoId.eq(repo_id))
.filter(release_entity::Column::TagName.eq(tag))
.filter(release_entity::Column::IsTag.eq(false))
.exec(&db)
.await?;
Ok(())
}