aiforge/models/tech_converge_info.go

package models

import (
	"strconv"
	"strings"
	"time"

	"code.gitea.io/gitea/modules/timeutil"
	"xorm.io/builder"
)

const (
	TechShow          = 1
	TechHide          = 2
	TechMigrating     = 3
	TechMigrateFailed = 4
	TechNotExist      = 5
)

const DefaultTechApprovedStatus = TechShow

type TechConvergeBaseInfo struct {
	ID               int64  `xorm:"pk autoincr"`
	ProjectNumber    string `xorm:"UNIQUE NOT NULL"` //项目立项编号
	ProjectName      string //科技项目名称
	Institution      string //项目承担单位
	ApplyYear        int    //申报年度
	Province         string //所属省（省市）
	Category         string //单位性质
	Recommend        string //推荐单位
	Owner            string //项目负责人
	Phone            string //负责人电话
	Email            string //负责人邮箱
	Contact          string //项目联系人
	ContactPhone     string //联系人电话
	ContactEmail     string //联系人邮箱
	ExecuteMonth     int    //执行周期(月)
	ExecuteStartYear int    //执行开始年份
	ExecuteEndYear   int    //执行结束年份
	ExecutePeriod    string //执行期限
	Type             string //项目类型
	StartUp          string //启动会时间
	NumberTopic      int
	Topic1           string
	Topic2           string
	Topic3           string
	Topic4           string
	Topic5           string
	Topic6           string
	Topic7           string
	AllInstitution   string             `xorm:"TEXT"`
	CreatedUnix      timeutil.TimeStamp `xorm:"INDEX created"`
	UpdatedUnix      timeutil.TimeStamp `xorm:"INDEX updated"`
}

func (t *TechConvergeBaseInfo) Brief() *TechConvergeBrief {
	return &TechConvergeBrief{
		ProjectNumber:  t.ProjectNumber,
		ProjectName:    t.ProjectName,
		Institution:    t.Institution,
		AllInstitution: t.AllInstitution,
	}
}
func (t *TechConvergeBaseInfo) IsValidInstitution(institution string) bool {
	if t.AllInstitution == "" && t.Institution == "" {
		return false
	}

	allInstitution := make([]string, 0)
	if t.AllInstitution != "" {
		allInstitution = strings.Split(t.AllInstitution, ",")
	}
	if t.Institution != "" {
		allInstitution = append(allInstitution, t.Institution)
	}

	newInstitution := strings.Split(institution, ",")
	total := len(newInstitution)
	matched := 0
	for _, n := range newInstitution {
		for _, s := range allInstitution {
			if s == n {
				matched++
				break
			}
		}
	}
	if matched == total {
		return true
	}
	return false
}

type RepoConvergeInfo struct {
	ID          int64 `xorm:"pk autoincr"`
	RepoID      int64
	Url         string
	BaseInfoID  int64
	Institution string
	UID         int64
	Status      int
	CreatedUnix timeutil.TimeStamp    `xorm:"INDEX created"`
	UpdatedUnix timeutil.TimeStamp    `xorm:"INDEX updated"`
	User        *User                 `xorm:"-"`
	Repo        *Repository           `xorm:"-"`
	BaseInfo    *TechConvergeBaseInfo `xorm:"-"`
}

func (r *RepoConvergeInfo) InsertOrUpdate() error {
	if r.ID != 0 {
		_, err := x.ID(r.ID).Update(r)
		return err
	} else {
		_, err := x.InsertOne(r)
		return err
	}
}

func GetTechConvergeBaseInfoByProjectNumber(projectNumber string) (*TechConvergeBaseInfo, error) {
	tb := &TechConvergeBaseInfo{ProjectNumber: projectNumber}
	return getTechConvergeBaseInfo(tb)
}
func (baseInfo *TechConvergeBaseInfo) InsertOrUpdate() error {
	if baseInfo.ID != 0 {
		_, err := x.ID(baseInfo.ID).Update(baseInfo)
		return err
	} else {
		_, err := x.InsertOne(baseInfo)
		return err
	}
}

type ErrTechConvergeBaseInfoNotExist struct {
	ID string
}

func (err ErrTechConvergeBaseInfoNotExist) Error() string {
	return "tech.tech_not_exist"
}

func IsErrTechConvergeBaseInfoNotExist(err error) bool {
	_, ok := err.(ErrTechConvergeBaseInfoNotExist)
	return ok
}

func getTechConvergeBaseInfo(tb *TechConvergeBaseInfo) (*TechConvergeBaseInfo, error) {
	has, err := x.Get(tb)
	if err != nil {
		return nil, err
	} else if !has {
		if tb.ProjectNumber != "" {
			return nil, ErrTechConvergeBaseInfoNotExist{tb.ProjectNumber}
		} else {
			return nil, ErrTechConvergeBaseInfoNotExist{strconv.FormatInt(tb.ID, 10)}
		}
	}
	return tb, nil
}

func GetProjectNames() []string {
	var names []string
	x.Table("tech_converge_base_info").Distinct("project_name").Find(&names)
	return names
}
func GetIdByProjectName(name string) []string {
	var ids []int64
	x.Table("tech_converge_base_info").Cols("id").Where("project_name=?", name).Find(&ids)

	idStrs := make([]string, 0, len(ids))
	for _, id := range ids {
		idStrs = append(idStrs, strconv.FormatInt(id, 10))
	}
	return idStrs
}
func GetSummitRepoIds() []int64 {
	var ids []int64
	x.Table("repo_converge_info").Cols("repo_id").Find(&ids)
	return ids
}

func GetTechRepoTopics(limit int) []string {

	repoIds := GetSummitRepoIds()
	if len(repoIds) == 0 {
		return []string{}
	}

	//select name, repo_count from topic a, repo_topic b
	//where a.id=b.topic_id and repo_id in (1,3) order by repo_count desc
	inCondition := "repo_id in ("

	const MaxINItems = 1000
	for i := 0; i < len(repoIds); i++ {
		if i == len(repoIds)-1 {
			inCondition += strconv.FormatInt(repoIds[i], 10)
		} else if (i+1)%MaxINItems == 0 {
			inCondition += strconv.FormatInt(repoIds[i], 10) + ") or repo_id in ("
		} else {
			inCondition += strconv.FormatInt(repoIds[i], 10) + ","
		}

	}
	inCondition += ")"

	sql := "select name, repo_count from topic a, repo_topic b where a.id=b.topic_id and (" + inCondition + ") order by repo_count desc"
	if limit > 0 {
		sql += "limit " + strconv.Itoa(limit)
	}

	result, err := x.QueryString(sql)
	if err != nil {
		return []string{}
	}
	var topics []string
	for _, record := range result {
		topics = append(topics, record["name"])
	}
	return topics

}

func GetProjectTypes() []string {

	sql := "SELECT COUNT(id) AS theCount, type from tech_converge_base_info GROUP BY type ORDER BY theCount DESC"
	result, err := x.QueryString(sql)
	if err != nil {
		return []string{}
	}
	var projectTypes []string
	for _, record := range result {
		projectTypes = append(projectTypes, record["type"])
	}
	return projectTypes

}
func GetApplyExecuteYears() ([]int, []int) {
	apply, executeStart, executeEnd := GetYearInfos()
	applyEnd := time.Now().Year()

	var applyArray []int
	var executeArray []int

	for i := apply; i <= applyEnd; i++ {
		applyArray = append(applyArray, i)

	}
	for i := executeStart; i <= executeEnd; i++ {
		executeArray = append(executeArray, i)

	}
	return applyArray, executeArray
}
func GetYearInfos() (int, int, int) {

	sql := "select min(apply_year) as apply_year,min(CASE  WHEN execute_start_year != 0 THEN execute_start_year END) as execute_start_year,max(execute_end_year) as execute_end_year from tech_converge_base_info"
	result, err := x.QueryString(sql)
	if err != nil {
		return 2018, 2019, 2024
	}

	for _, record := range result {
		apply, _ := strconv.Atoi(record["apply_year"])
		executeStart, _ := strconv.Atoi(record["execute_start_year"])
		executeEnd, _ := strconv.Atoi(record["execute_end_year"])
		return apply, executeStart, executeEnd
	}
	return 2018, 2019, 2024
}

func GetAllInstitutions() []string {
	var names []string
	x.Table("tech_converge_base_info").Cols("all_institution").Find(&names)
	var allNames []string
	for _, name := range names {
		singleNames := strings.Split(name, ",")
		for _, singleName := range singleNames {
			if singleName != "" {
				if !contains(allNames, singleName) {
					allNames = append(allNames, singleName)
				}
			}
		}

	}
	return allNames
}

func contains(s []string, e string) bool {
	for _, a := range s {
		if a == e {
			return true
		}
	}
	return false
}

type SearchTechOpt struct {
	Q           string //科技项目名称
	ProjectType string
	Institution string
	ApplyYear   int
	ExecuteYear int
	OrderBy     string
	ListOptions
}

type SearchRepoOpt struct {
	Q           string //项目名称，简介
	ProjectName string
	Topic       string
	Institution string
	OrderBy     string
	ListOptions
}

type RepoWithInstitution struct {
	ID          int64              `json:"id"`
	OwnerID     int64              `json:"owner_id"`
	OwnerName   string             `json:"owner_name"`
	Name        string             `json:"name"`
	Alias       string             `json:"alias"`
	Topics      []string           `json:"topics"`
	Description string             `json:"description"`
	Institution string             `json:"institution"`
	UpdatedUnix timeutil.TimeStamp `json:"updated_unix"`
}

type TechRepoInfo struct {
	ID             int64  `json:"id"`
	ProjectName    string `json:"project_name"`
	Institution    string `json:"institution"`
	Type           string `json:"type"`
	ApplyYear      int    `json:"apply_year"`
	ExecutePeriod  string `json:"execute_period"`
	AllInstitution string `json:"all_institution"`
	RepoCount      int    `json:"repo_numer"`
	Repos          []*RepoWithInstitution
}

func GetAvailableRepoConvergeInfo(opt *SearchRepoOpt) ([]*RepoConvergeInfo, error) {

	repos := make([]*RepoConvergeInfo, 0)
	err := x.Table("repo_converge_info").Where(buildRepoFilterCond(opt)).Find(&repos)
	return repos, err

}

func buildRepoFilterCond(opt *SearchRepoOpt) string {

	sql := ""

	if opt.Institution != "" {
		sql += getPrefixWithoutWhere(sql) + " (institution like '%" + opt.Institution + ",%'" + " or institution like '%," + opt.Institution + "%'" + " or institution = '" + opt.Institution + "')"
	}

	if opt.ProjectName != "" {
		baseInfoIds := GetIdByProjectName(opt.ProjectName)
		if len(baseInfoIds) > 0 {

			sql += getPrefixWithoutWhere(sql) + " id in (" + strings.Join(baseInfoIds, ",") + ")"
		}

	}
	return sql
}

func SearchTechRepoInfo(opt *SearchTechOpt) ([]*TechRepoInfo, int64, error) {

	sql := `select a.*,COALESCE(b.count,0) as repo_count,  COALESCE(b.max,0) as max from tech_converge_base_info a left join
		(select base_info_id,count(id),max(updated_unix) from repo_converge_info where status=` + strconv.Itoa(TechShow) + ` GROUP BY base_info_id ) b
			on a.id=b.base_info_id`
	totalSql := "select count(*) from (" + sql + ") c" + buildTechFilterCond(opt)
	total, err := x.SQL(totalSql).Count(new(TechConvergeBaseInfo))
	resultList := make([]*TechRepoInfo, 0)
	if err != nil {
		return resultList, total, err

	}
	resultSql := "select id,project_name, institution,type,apply_year,execute_period,all_institution,repo_count from (" +
		sql + ") c " + buildTechFilterCond(opt) + opt.OrderBy + " offset " + strconv.Itoa((opt.Page-1)*opt.PageSize) + " limit " + strconv.Itoa(opt.PageSize)

	resultMap, err := x.QueryInterface(resultSql)
	if err == nil {
		for _, record := range resultMap {
			resultList = append(resultList, &TechRepoInfo{
				ID:             record["id"].(int64),
				ProjectName:    record["project_name"].(string),
				Institution:    record["institution"].(string),
				Type:           record["type"].(string),
				ApplyYear:      int(record["apply_year"].(int64)),
				ExecutePeriod:  record["execute_period"].(string),
				AllInstitution: record["all_institution"].(string),
				RepoCount:      int(record["repo_count"].(int64)),
			})
		}
	}

	loadRepoInfoForTech(resultList)

	return resultList, total, err

}

func buildTechFilterCond(opt *SearchTechOpt) string {

	sql := ""

	if opt.Q != "" {
		sql += getWherePrefix(sql) + " project_name like '%" + opt.Q + "%'"

	}
	if opt.ProjectType != "" {
		sql += getWherePrefix(sql) + " type ='" + opt.ProjectType + "'"
	}
	if opt.ApplyYear != 0 {
		sql += getWherePrefix(sql) + " apply_year =" + strconv.Itoa(opt.ApplyYear)
	}
	if opt.Institution != "" {
		sql += getWherePrefix(sql) + " (all_institution like '%" + opt.Institution + ",%'" + " or all_institution like '%," + opt.Institution + "%'"
	}

	if opt.ExecuteYear != 0 {
		sql += getWherePrefix(sql) + " execute_start_year <=" + strconv.Itoa(opt.ExecuteYear) + " and execute_end_year >=" + strconv.Itoa(opt.ExecuteYear)
	}
	return sql
}

func getWherePrefix(sql string) string {
	if sql == "" {
		return " where "
	}
	return " and "
}

func getPrefixWithoutWhere(sql string) string {
	if sql == "" {
		return ""
	}
	return " and "
}

func loadRepoInfoForTech(list []*TechRepoInfo) {

	for _, techRepo := range list {
		techRepo.Repos = []*RepoWithInstitution{}
		if techRepo.RepoCount > 0 {
			var repoIds []int64
			x.Table("repo_converge_info").Cols("repo_id").Where("base_info_id=?", techRepo.ID).Desc("updated_unix").Find(&repoIds)

			resultMap, err := GetRepositoriesMapByIDs(repoIds)

			if err == nil {

				for _, repoId := range repoIds {
					repo, ok := resultMap[repoId]
					if ok {
						techRepo.Repos = append(techRepo.Repos, &RepoWithInstitution{
							ID:          repo.ID,
							Institution: techRepo.Institution,
							OwnerID:     repo.OwnerID,
							OwnerName:   repo.OwnerName,
							Name:        repo.Name,
							Alias:       repo.Alias,
							Topics:      repo.Topics,
							Description: repo.Description,
							UpdatedUnix: repo.UpdatedUnix,
						})
					}

				}

			}
		}
	}

}

type TechConvergeBrief struct {
	ProjectNumber  string `json:"no"`          //项目立项编号
	ProjectName    string `json:"name"`        //科技项目名称
	Institution    string `json:"institution"` //项目承担单位
	AllInstitution string `json:"all_institution"`
}

type FindTechOpt struct {
	TechNo      string
	ProjectName string
	Institution string
}

func FindTech(opt FindTechOpt) ([]*TechConvergeBaseInfo, error) {
	var cond = builder.NewCond()
	if opt.TechNo != "" {
		cond = cond.And(builder.Like{"project_number", opt.TechNo})
	}
	if opt.ProjectName != "" {
		cond = cond.And(builder.Like{"project_name", opt.ProjectName})
	}
	if opt.Institution != "" {
		cond = cond.And(builder.Like{"institution", opt.Institution}.Or(builder.Like{"all_institution", opt.Institution}))
	}

	r := make([]*TechConvergeBaseInfo, 0)
	err := x.Where(cond).OrderBy("updated_unix desc").Find(&r)
	if err != nil {
		return nil, err
	}
	return r, nil
}

func GetTechByTechNo(techNo string) (*TechConvergeBaseInfo, error) {
	var tech = &TechConvergeBaseInfo{}
	has, err := x.Where("project_number = ?", techNo).Get(tech)
	if err != nil {
		return nil, err
	} else if !has {
		return nil, ErrTechConvergeBaseInfoNotExist{}
	}
	return tech, nil

}

type GetRepoConvergeOpts struct {
	RepoId     int64
	BaseInfoId int64
	Status     []int
}

func GetRepoConverge(opts GetRepoConvergeOpts) ([]*RepoConvergeInfo, error) {
	r := make([]*RepoConvergeInfo, 0)
	cond := builder.NewCond()
	if opts.RepoId > 0 {
		cond = cond.And(builder.Eq{"repo_id": opts.RepoId})
	}
	if opts.BaseInfoId > 0 {
		cond = cond.And(builder.Eq{"base_info_id": opts.BaseInfoId})
	}
	if len(opts.Status) > 0 {
		cond = cond.And(builder.In("status", opts.Status))
	}
	err := x.Where(cond).Find(&r)
	if err != nil {
		return nil, err
	}
	return r, nil

}

func UpdateRepoConvergeStatus(id int64, status int) (int64, error) {
	return x.ID(id).Update(&RepoConvergeInfo{
		Status: status,
	})
}