gitks/service/repo/git/repository_extras.rs

use crate::error::AppError;
use crate::service::RepoService;
use crate::session::Session;

impl RepoService {
    pub async fn git_get_default_branch(
        &self,
        ctx: &Session,
        wk_name: &str,
        repo_name: &str,
    ) -> Result<String, AppError> {
        let user_uid = ctx.user().ok_or(AppError::Unauthorized)?;
        let repo = self.resolve_repo(wk_name, repo_name).await?;
        self.ensure_repo_readable(user_uid, &repo).await?;
        let ws = self.resolve_workspace(wk_name).await?;
        let header = self.repo_header(&repo, &ws);
        let mut svc = self.git_client(&repo)?.repository;
        let resp = svc
            .get_default_branch(tonic::Request::new(
                crate::pb::repo::GetDefaultBranchRequest {
                    repository: Some(header),
                },
            ))
            .await
            .map_err(|e| AppError::InternalServerError(e.to_string()))?;
        Ok(resp.into_inner().name)
    }

    pub async fn git_get_object_format(
        &self,
        ctx: &Session,
        wk_name: &str,
        repo_name: &str,
    ) -> Result<i32, AppError> {
        let user_uid = ctx.user().ok_or(AppError::Unauthorized)?;
        let repo = self.resolve_repo(wk_name, repo_name).await?;
        self.ensure_repo_readable(user_uid, &repo).await?;
        let ws = self.resolve_workspace(wk_name).await?;
        let header = self.repo_header(&repo, &ws);
        let mut svc = self.git_client(&repo)?.repository;
        let resp = svc
            .get_object_format(tonic::Request::new(
                crate::pb::repo::RepositoryObjectFormatRequest {
                    repository: Some(header),
                },
            ))
            .await
            .map_err(|e| AppError::InternalServerError(e.to_string()))?;
        Ok(resp.into_inner().object_format)
    }

    pub async fn git_objects_size(
        &self,
        ctx: &Session,
        wk_name: &str,
        repo_name: &str,
        oids: Vec<String>,
    ) -> Result<crate::pb::repo::ObjectsSizeResponse, AppError> {
        let user_uid = ctx.user().ok_or(AppError::Unauthorized)?;
        let repo = self.resolve_repo(wk_name, repo_name).await?;
        self.ensure_repo_readable(user_uid, &repo).await?;
        let ws = self.resolve_workspace(wk_name).await?;
        let header = self.repo_header(&repo, &ws);
        let mut svc = self.git_client(&repo)?.repository;
        let resp = svc
            .objects_size(tonic::Request::new(crate::pb::repo::ObjectsSizeRequest {
                repository: Some(header),
                oids,
            }))
            .await
            .map_err(|e| AppError::InternalServerError(e.to_string()))?;
        Ok(resp.into_inner())
    }

    pub async fn git_repository_size(
        &self,
        ctx: &Session,
        wk_name: &str,
        repo_name: &str,
    ) -> Result<crate::pb::repo::RepositorySizeResponse, AppError> {
        let user_uid = ctx.user().ok_or(AppError::Unauthorized)?;
        let repo = self.resolve_repo(wk_name, repo_name).await?;
        self.ensure_repo_readable(user_uid, &repo).await?;
        let ws = self.resolve_workspace(wk_name).await?;
        let header = self.repo_header(&repo, &ws);
        let mut svc = self.git_client(&repo)?.repository;
        let resp = svc
            .repository_size(tonic::Request::new(
                crate::pb::repo::RepositorySizeRequest {
                    repository: Some(header),
                },
            ))
            .await
            .map_err(|e| AppError::InternalServerError(e.to_string()))?;
        Ok(resp.into_inner())
    }

    pub async fn git_find_merge_base(
        &self,
        ctx: &Session,
        wk_name: &str,
        repo_name: &str,
        revisions: Vec<String>,
    ) -> Result<crate::pb::repo::FindMergeBaseResponse, AppError> {
        let user_uid = ctx.user().ok_or(AppError::Unauthorized)?;
        let repo = self.resolve_repo(wk_name, repo_name).await?;
        self.ensure_repo_readable(user_uid, &repo).await?;
        let ws = self.resolve_workspace(wk_name).await?;
        let header = self.repo_header(&repo, &ws);
        let mut svc = self.git_client(&repo)?.repository;
        let resp = svc
            .find_merge_base(tonic::Request::new(crate::pb::repo::FindMergeBaseRequest {
                repository: Some(header),
                revisions: revisions
                    .into_iter()
                    .map(|s| hex::decode(&s).unwrap_or_default())
                    .collect(),
            }))
            .await
            .map_err(|e| AppError::InternalServerError(e.to_string()))?;
        Ok(resp.into_inner())
    }

    pub async fn git_list_archive_entries(
        &self,
        ctx: &Session,
        wk_name: &str,
        repo_name: &str,
        treeish: &str,
        page_size: u32,
    ) -> Result<crate::pb::repo::ListArchiveEntriesResponse, AppError> {
        let user_uid = ctx.user().ok_or(AppError::Unauthorized)?;
        let repo = self.resolve_repo(wk_name, repo_name).await?;
        self.ensure_repo_readable(user_uid, &repo).await?;
        let ws = self.resolve_workspace(wk_name).await?;
        let header = self.repo_header(&repo, &ws);
        let mut svc = self.git_client(&repo)?.archive;
        let resp = svc
            .list_archive_entries(tonic::Request::new(
                crate::pb::repo::ListArchiveEntriesRequest {
                    repository: Some(header),
                    treeish: Some(crate::pb::repo::ObjectSelector {
                        selector: Some(crate::pb::repo::object_selector::Selector::Revision(
                            crate::pb::repo::ObjectName {
                                revision: treeish.to_string(),
                            },
                        )),
                    }),
                    pathspec: vec![],
                    pagination: Some(crate::pb::repo::Pagination {
                        page_size,
                        page_token: String::new(),
                    }),
                },
            ))
            .await
            .map_err(|e| AppError::InternalServerError(e.to_string()))?;
        Ok(resp.into_inner())
    }

    pub async fn git_check_objects_exist(
        &self,
        ctx: &Session,
        wk_name: &str,
        repo_name: &str,
        revisions: Vec<String>,
    ) -> Result<crate::pb::repo::CheckObjectsExistResponse, AppError> {
        let user_uid = ctx.user().ok_or(AppError::Unauthorized)?;
        let repo = self.resolve_repo(wk_name, repo_name).await?;
        self.ensure_repo_readable(user_uid, &repo).await?;
        let ws = self.resolve_workspace(wk_name).await?;
        let header = self.repo_header(&repo, &ws);
        let mut svc = self.git_client(&repo)?.commit;
        let resp = svc
            .check_objects_exist(tonic::Request::new(
                crate::pb::repo::CheckObjectsExistRequest {
                    repository: Some(header),
                    revisions,
                },
            ))
            .await
            .map_err(|e| AppError::InternalServerError(e.to_string()))?;
        Ok(resp.into_inner())
    }
}