a06673b
use db::conn::sea_orm::*;
use db::repo::repo_collaborations as collab_entity;
use db::repo::repo_collaborations::CollaborationMode;
use time::OffsetDateTime;
use uuid::Uuid;
use crate::error::{RepoError, RepoResult};
use crate::features::RepoService;
use super::types::{
AddCollaboratorOption, CollaboratorPage, CollaboratorView, RepoCollaboratorPermission,
UserSummary,
};
fn parse_mode(s: &str) -> RepoResult<CollaborationMode> {
match s {
"read" | "Read" | "READ" => Ok(CollaborationMode::Read),
"write" | "Write" | "WRITE" => Ok(CollaborationMode::Write),
"admin" | "Admin" | "ADMIN" => Ok(CollaborationMode::Admin),
_ => Err(RepoError::BadRequest(format!("invalid permission: {s}"))),
}
}
fn mode_to_str(m: CollaborationMode) -> String {
match m {
CollaborationMode::Read => "read".to_string(),
CollaborationMode::Write => "write".to_string(),
CollaborationMode::Admin => "admin".to_string(),
}
}
fn require_admin(actor: Uuid) -> RepoResult<()> {
if actor.is_nil() {
return Err(RepoError::Unauthorized("authentication required".into()));
}
Ok(())
}
pub async fn list_collaborators(
svc: &RepoService,
actor: Uuid,
repo_id: Uuid,
page: Option<u64>,
limit: Option<u64>,
) -> RepoResult<CollaboratorPage> {
let _ = actor;
let limit = limit.unwrap_or(svc.config.default_pagination);
let offset = page.unwrap_or(0).saturating_mul(limit);
let limit = std::cmp::min(limit, svc.config.max_pagination);
let db = svc.db.reader();
let query = collab_entity::Entity::find().filter(collab_entity::Column::RepoId.eq(repo_id));
let total = query.clone().count(&db).await?;
let items = query
.limit(Some(limit))
.offset(Some(offset))
.all(&db)
.await?
.into_iter()
.map(CollaboratorView::from)
.collect();
Ok(CollaboratorPage {
items,
total: total as i64,
})
}
pub async fn is_collaborator(
svc: &RepoService,
actor: Uuid,
repo_id: Uuid,
user_id: Uuid,
) -> RepoResult<bool> {
let _ = actor;
let db = svc.db.reader();
let hit = collab_entity::Entity::find()
.filter(collab_entity::Column::RepoId.eq(repo_id))
.filter(collab_entity::Column::UserId.eq(user_id))
.one(&db)
.await?;
Ok(hit.is_some())
}
pub async fn add_collaborator(
svc: &RepoService,
actor: Uuid,
repo_id: Uuid,
user_id: Uuid,
input: AddCollaboratorOption,
) -> RepoResult<()> {
require_admin(actor)?;
let mode = parse_mode(&input.permission)?;
let db = svc.db.writer();
let now = OffsetDateTime::now_utc();
let existing = collab_entity::Entity::find()
.filter(collab_entity::Column::RepoId.eq(repo_id))
.filter(collab_entity::Column::UserId.eq(user_id))
.one(&db)
.await?;
if let Some(current) = existing {
let mut active: collab_entity::ActiveModel = current.into();
active.mode = Set(mode);
active.updated_at = Set(now);
active.update(&db).await?;
} else {
let active: collab_entity::ActiveModel = collab_entity::ActiveModel {
id: Set(Uuid::new_v4()),
repo_id: Set(repo_id),
user_id: Set(user_id),
mode: Set(mode),
created_at: Set(now),
updated_at: Set(now),
};
active.insert(&db).await?;
}
Ok(())
}
pub async fn delete_collaborator(
svc: &RepoService,
actor: Uuid,
repo_id: Uuid,
user_id: Uuid,
) -> RepoResult<()> {
require_admin(actor)?;
let db = svc.db.writer();
collab_entity::Entity::delete_many()
.filter(collab_entity::Column::RepoId.eq(repo_id))
.filter(collab_entity::Column::UserId.eq(user_id))
.exec(&db)
.await?;
Ok(())
}
pub async fn get_repo_permissions(
svc: &RepoService,
actor: Uuid,
repo_id: Uuid,
user_id: Uuid,
) -> RepoResult<RepoCollaboratorPermission> {
let _ = actor;
let db = svc.db.reader();
let collab = collab_entity::Entity::find()
.filter(collab_entity::Column::RepoId.eq(repo_id))
.filter(collab_entity::Column::UserId.eq(user_id))
.one(&db)
.await?;
let permission = match collab {
Some(c) => mode_to_str(c.mode),
None => "none".to_string(),
};
Ok(RepoCollaboratorPermission {
permission,
role: "collaborator".to_string(),
user: UserSummary {
id: user_id,
name: String::new(),
login: String::new(),
email: None,
},
})
}