aiforge/routers/repo/repo_statistic.go

package repo

import (
	"time"

	"code.gitea.io/gitea/models"
	"code.gitea.io/gitea/modules/log"
	"code.gitea.io/gitea/modules/repository"
)

//auto daily or manually
func RepoStatisticAuto() {
	log.Info("", time.Now())
	yesterday := time.Now().AddDate(0, 0, -1).Format("2006-01-02")
	RepoStatisticDaily(yesterday)
}

func RepoStatisticDaily(date string) {
	log.Info("%s", date)
	if err := models.DeleteRepoStatDaily(date); err != nil {
		log.Error("DeleteRepoStatDaily failed: %v", err.Error())
		return
	}

	repos, err := models.GetAllRepositories()
	if err != nil {
		log.Error("GetAllRepositories failed: %v", err.Error())
		return
	}

	for _, repo := range repos {
		log.Info("start statistic: %s", repo.Name)
		var numDevMonths,numWikiViews,numContributor,numKeyContributor int64
		repoGitStat, err := models.GetRepoKPIStats(repo)
		if err != nil {
			log.Error("GetRepoKPIStats failed: %s", repo.Name)
		} else {
			numDevMonths = repoGitStat.DevelopAge
			numKeyContributor = repoGitStat.KeyContributors
			numWikiViews = repoGitStat.WikiPages
			numContributor = repoGitStat.Contributors
		}

		var issueFixedRate float32
		if repo.NumIssues != 0 {
			issueFixedRate = float32(repo.NumClosedIssues) / float32(repo.NumIssues)
		}

		 var numVersions int64
		numVersions, err = models.GetReleaseCountByRepoID(repo.ID, models.FindReleasesOptions{})
		if err != nil {
			log.Error("GetReleaseCountByRepoID failed(%s): %v", repo.Name, err)
		}

		var datasetSize int64
		datasetSize, err = getDatasetSize(repo)
		if err != nil {
			log.Error("getDatasetSize failed(%s): %v", repo.Name, err)
		}

		var numComments int64
		numComments, err = models.GetCommentCountByRepoID(repo.ID)
		if err != nil {
			log.Error("GetCommentCountByRepoID failed(%s): %v", repo.Name, err)
		}

		beginTime, endTime := getStatTime(date)
		var numVisits int
		numVisits, err = repository.AppointProjectView(repo.OwnerName, repo.Name, beginTime, endTime)
		if err != nil {
			log.Error("AppointProjectView failed(%s): %v", repo.Name, err)
		}

		repoStat := models.RepoStatistic{
			RepoID:            repo.ID,
			Date:              date,
			NumWatches:        int64(repo.NumWatches),
			NumStars:          int64(repo.NumStars),
			NumDownloads:      repo.CloneCnt,
			NumComments:       numComments,
			NumVisits:         int64(numVisits),
			NumClosedIssues:   int64(repo.NumClosedIssues),
			NumVersions:       numVersions,
			NumDevMonths:      numDevMonths,
			RepoSize:          repo.Size,
			DatasetSize:       datasetSize,
			NumModels:         0,
			NumWikiViews:      numWikiViews,
			NumCommits:        repo.NumCommit,
			NumIssues:         int64(repo.NumIssues),
			NumPulls:          int64(repo.NumPulls),
			IssueFixedRate:    issueFixedRate,
			NumContributor:    numContributor,
			NumKeyContributor: numKeyContributor,
		}

		if _, err = models.InsertRepoStat(&repoStat); err != nil {
			log.Error("InsertRepoStat failed(%s): %v", repo.Name, err)
			log.Error("failed statistic: %s", repo.Name)
			continue
		}

		log.Info("finish statistic: %s", repo.Name)
	}

}

func getDatasetSize(repo *models.Repository) (int64, error) {
	dataset, err := models.GetDatasetByRepo(repo)
	if err != nil {
		return 0, err
	}

	return models.GetAttachmentSizeByDatasetID(dataset.ID)
}

func getStatTime(timeStr string) (string, string) {
	t, _ := time.Parse("2006-01-02", timeStr)
	timeNumber := t.Unix()
	beginTimeNumber := timeNumber - 8*60*60
	endTimeNumber := timeNumber + 16*60*60
	beginTime := time.Unix(beginTimeNumber, 0).Format(time.RFC3339)
	endTime := time.Unix(endTimeNumber, 0).Format(time.RFC3339)
	log.Info("%s, %s", beginTime, endTime)

	return beginTime, endTime
}