aiforge/services/tech/tech.go

package tech

import (
	"code.gitea.io/gitea/models"
	"code.gitea.io/gitea/services/repository"
)

func FindTech(opt models.FindTechOpt) ([]*models.TechConvergeBrief, error) {
	techList, err := models.FindTech(opt)
	if err != nil {
		return nil, err
	}
	r := make([]*models.TechConvergeBrief, len(techList))
	for i := 0; i < len(techList); i++ {
		r[i] = techList[i].Brief()
	}
	return r, nil
}

func SearchRepoInfoWithInstitution(opt *models.SearchRepoOpt) ([]*models.RepoWithInstitution, int64, error) {
	infos, err := models.GetAvailableRepoConvergeInfo(opt)
	if err != nil {
		return nil, 0, err
	}
	repoIds, institutionMap := getRepoIdAndInstitutionMap(infos)

	result, err := repository.FindRepos(repository.FindReposOptions{
		ListOptions: models.ListOptions{Page: opt.Page, PageSize: opt.PageSize},
		Sort:        opt.OrderBy,
		Keyword:     opt.Q,
		Topic:       opt.Topic,
		RepoIds:     repoIds,
	})

	if err != nil {
		return nil, 0, err
	}
	repoResult := make([]*models.RepoWithInstitution, 0, len(result.Repos))

	for _, repo := range result.Repos {
		repoResult = append(repoResult, &models.RepoWithInstitution{
			ID:            repo.ID,
			OwnerID:       repo.OwnerID,
			OwnerName:     repo.OwnerName,
			Name:          repo.Name,
			Topics:        repo.Topics,
			Description:   repo.Description,
			Institution:   institutionMap[repo.ID],
			RelAvatarLink: repo.RelAvatarLink,
			UpdatedUnix:   repo.UpdatedUnix,
		})
	}

	return repoResult, result.Total, nil

}

func getRepoIdAndInstitutionMap(infos []*models.RepoConvergeInfo) ([]int64, map[int64]string) {
	repoIds := make([]int64, 0, len(infos))
	institutionMap := make(map[int64]string, 0)
	// We only need the keys
	for _, info := range infos {
		repoIds = append(repoIds, info.RepoID)
		institutionMap[info.RepoID] = info.Institution
	}
	return repoIds, institutionMap
}


func IsValidRepoConvergeExists(repoId, baseInfoId int64) (bool, error) {
	list, err := models.GetRepoConverge(models.GetRepoConvergeOpts{
		Status:     []int{models.TechHide, models.TechShow, models.TechMigrating},
		RepoId:     repoId,
		BaseInfoId: baseInfoId,
	})
	if err != nil {
		return false, err
	}
	return len(list) > 0, nil
}

func UpdateTechMigrateStatus() error {
	migratingRepos, err := models.GetRepoConverge(models.GetRepoConvergeOpts{
		Status: []int{models.TechMigrating},
	})
	if err != nil {
		return err
	}
	for _, r := range migratingRepos {
		repo, err := models.GetRepositoryByID(r.RepoID)
		if err != nil {
			if models.IsErrRepoNotExist(err) {
				models.UpdateRepoConvergeStatus(r.ID, models.TechMigrateFailed)
				continue
			}
			continue
		}
		if repo.Status == models.RepositoryReady {
			models.UpdateRepoConvergeStatus(r.ID, models.DefaultTechApprovedStatus)
			continue
		}
	}
	return nil
}