02d8172
use models::repo::repo_license;
use sea_orm::{ActiveModelTrait, EntityTrait, QueryOrder, QuerySelect, Set};
use serde::{Deserialize, Serialize};
use time::OffsetDateTime;
use utoipa::ToSchema;
use crate::service::GitService;
use crate::share::errors::GitError;
#[derive(Debug, Clone, Serialize, ToSchema)]
pub struct LicenseDto {
pub name: String,
pub display_name: String,
pub description: Option<String>,
pub body: String,
pub url: Option<String>,
pub created_at: OffsetDateTime,
pub updated_at: OffsetDateTime,
}
impl From<repo_license::Model> for LicenseDto {
fn from(m: repo_license::Model) -> Self {
Self {
name: m.name,
display_name: m.display_name,
description: m.description,
body: m.body,
url: m.url,
created_at: m.created_at,
updated_at: m.updated_at,
}
}
}
#[derive(Debug, Clone, Deserialize, ToSchema)]
pub struct UpsertLicenseCmd {
pub display_name: String,
pub description: Option<String>,
pub body: String,
pub url: Option<String>,
}
impl GitService {
pub async fn get_license(&self, name: &str) -> Result<LicenseDto, GitError> {
let row = repo_license::Entity::find_by_id(name.to_string())
.one(self.db_read())
.await?
.ok_or(GitError::NotFound)?;
Ok(row.into())
}
pub async fn list_licenses(
&self,
limit: u64,
offset: u64,
) -> Result<Vec<LicenseDto>, GitError> {
let rows = repo_license::Entity::find()
.order_by_asc(repo_license::Column::Name)
.limit(limit)
.offset(offset)
.all(self.db_read())
.await?;
Ok(rows.into_iter().map(Into::into).collect())
}
pub async fn upsert_license(
&self,
name: &str,
cmd: UpsertLicenseCmd,
) -> Result<LicenseDto, GitError> {
if name.is_empty() {
return Err(GitError::InvalidArgument(
"license name must not be empty".to_string(),
));
}
if cmd.display_name.is_empty() {
return Err(GitError::InvalidArgument(
"license display_name must not be empty".to_string(),
));
}
if cmd.body.is_empty() {
return Err(GitError::InvalidArgument(
"license body must not be empty".to_string(),
));
}
let now = OffsetDateTime::now_utc();
let existing = repo_license::Entity::find_by_id(name.to_string())
.one(self.db_read())
.await?;
let saved = if let Some(row) = existing {
let mut am: repo_license::ActiveModel = row.into();
am.display_name = Set(cmd.display_name);
am.description = Set(cmd.description);
am.body = Set(cmd.body);
am.url = Set(cmd.url);
am.updated_at = Set(now);
am.update(self.db_write()).await?
} else {
let am = repo_license::ActiveModel {
name: Set(name.to_string()),
display_name: Set(cmd.display_name),
description: Set(cmd.description),
body: Set(cmd.body),
url: Set(cmd.url),
created_at: Set(now),
updated_at: Set(now),
};
am.insert(self.db_write()).await?
};
Ok(saved.into())
}
}