a06673b
use db::conn::sea_orm::*;
use db::repo::repo_topic as topic_entity;
use time::OffsetDateTime;
use uuid::Uuid;
use crate::error::{RepoError, RepoResult};
use crate::features::RepoService;
use crate::path::{normalize_topic, sanitize_topics};
use super::types::{RepoTopicOptions, TopicList, TopicSearchQuery, TopicSearchResult, TopicView};
fn require_authenticated(actor: Uuid) -> RepoResult<()> {
if actor.is_nil() {
return Err(RepoError::Unauthorized("authentication required".into()));
}
Ok(())
}
async fn ensure_topic(svc: &RepoService, topic_name: &str) -> RepoResult<topic_entity::Model> {
let db = svc.db.writer();
if let Some(t) = topic_entity::Entity::find()
.filter(topic_entity::Column::Name.eq(topic_name))
.one(&db)
.await?
{
return Ok(t);
}
let now = OffsetDateTime::now_utc();
let active: topic_entity::ActiveModel = topic_entity::ActiveModel {
id: Set(Uuid::new_v4()),
name: Set(topic_name.to_string()),
created_at: Set(now),
updated_at: Set(now),
};
Ok(active.insert(&db).await?)
}
pub async fn list_repo_topics(
svc: &RepoService,
actor: Uuid,
repo_id: Uuid,
) -> RepoResult<TopicList> {
let _ = actor;
let db = svc.db.reader();
let links = db::repo::repo_relation_topic::Entity::find()
.filter(db::repo::repo_relation_topic::Column::RepoId.eq(repo_id))
.all(&db)
.await?;
let mut names: Vec<String> = Vec::with_capacity(links.len());
for link in links {
if let Some(t) = topic_entity::Entity::find_by_id(link.topic_id)
.one(&db)
.await?
{
names.push(t.name);
}
}
names.sort();
names.dedup();
Ok(TopicList { topics: names })
}
pub async fn update_repo_topics(
svc: &RepoService,
actor: Uuid,
repo_id: Uuid,
input: RepoTopicOptions,
) -> RepoResult<()> {
require_authenticated(actor)?;
let normalized = sanitize_topics(&input.topics, svc.config.max_topics_per_repo)?;
let db = svc.db.writer();
let existing = db::repo::repo_relation_topic::Entity::find()
.filter(db::repo::repo_relation_topic::Column::RepoId.eq(repo_id))
.all(&db)
.await?;
for r in existing {
if let Some(t) = topic_entity::Entity::find_by_id(r.topic_id)
.one(&db)
.await?
{
if !normalized.contains(&t.name) {
db::repo::repo_relation_topic::Entity::delete_by_id(r.id)
.exec(&db)
.await?;
}
}
}
for name in &normalized {
let topic = ensure_topic(svc, name).await?;
let exists = db::repo::repo_relation_topic::Entity::find()
.filter(db::repo::repo_relation_topic::Column::RepoId.eq(repo_id))
.filter(db::repo::repo_relation_topic::Column::TopicId.eq(topic.id))
.one(&db)
.await?;
if exists.is_none() {
let active: db::repo::repo_relation_topic::ActiveModel =
db::repo::repo_relation_topic::ActiveModel {
id: Set(Uuid::new_v4()),
repo_id: Set(repo_id),
topic_id: Set(topic.id),
created_at: Set(OffsetDateTime::now_utc()),
};
active.insert(&db).await?;
}
}
Ok(())
}
pub async fn add_repo_topic(
svc: &RepoService,
actor: Uuid,
repo_id: Uuid,
topic: &str,
) -> RepoResult<()> {
require_authenticated(actor)?;
let name = normalize_topic(topic)?;
let current = db::repo::repo_relation_topic::Entity::find()
.filter(db::repo::repo_relation_topic::Column::RepoId.eq(repo_id))
.count(&svc.db.reader())
.await?;
if current >= svc.config.max_topics_per_repo as u64 {
return Err(RepoError::BadRequest(format!(
"too many topics (max {})",
svc.config.max_topics_per_repo
)));
}
let topic_model = ensure_topic(svc, &name).await?;
let db = svc.db.writer();
let exists = db::repo::repo_relation_topic::Entity::find()
.filter(db::repo::repo_relation_topic::Column::RepoId.eq(repo_id))
.filter(db::repo::repo_relation_topic::Column::TopicId.eq(topic_model.id))
.one(&db)
.await?;
if exists.is_some() {
return Ok(());
}
let active: db::repo::repo_relation_topic::ActiveModel =
db::repo::repo_relation_topic::ActiveModel {
id: Set(Uuid::new_v4()),
repo_id: Set(repo_id),
topic_id: Set(topic_model.id),
created_at: Set(OffsetDateTime::now_utc()),
};
active.insert(&db).await?;
Ok(())
}
pub async fn delete_repo_topic(
svc: &RepoService,
actor: Uuid,
repo_id: Uuid,
topic: &str,
) -> RepoResult<()> {
require_authenticated(actor)?;
let name = normalize_topic(topic)?;
let db = svc.db.writer();
let topic_model = topic_entity::Entity::find()
.filter(topic_entity::Column::Name.eq(&name))
.one(&db)
.await?
.ok_or_else(|| RepoError::NotFound(format!("topic {name}")))?;
db::repo::repo_relation_topic::Entity::delete_many()
.filter(db::repo::repo_relation_topic::Column::RepoId.eq(repo_id))
.filter(db::repo::repo_relation_topic::Column::TopicId.eq(topic_model.id))
.exec(&db)
.await?;
Ok(())
}
pub async fn search_topics(
svc: &RepoService,
actor: Uuid,
q: TopicSearchQuery,
) -> RepoResult<TopicSearchResult> {
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 = topic_entity::Entity::find();
if let Some(s) = q.q.as_deref() {
if !s.is_empty() {
query = query.filter(topic_entity::Column::Name.contains(s));
}
}
let items = query
.order_by_asc(topic_entity::Column::Name)
.limit(Some(limit))
.offset(Some(offset))
.all(&db)
.await?
.into_iter()
.map(|t| TopicView {
id: t.id,
name: t.name.clone(),
repo_count: 0,
created_at: super::types::fmt_ts_pub(t.created_at),
updated_at: super::types::fmt_ts_pub(t.updated_at),
})
.collect();
Ok(TopicSearchResult { topics: items })
}