Merge branch 'V20211115' into liuzx_trainjob

models/user_business_analysis.go

@@ -5,7 +5,9 @@ import (
 	"time"
 
 	"code.gitea.io/gitea/modules/log"
+	"code.gitea.io/gitea/modules/setting"
 	"code.gitea.io/gitea/modules/timeutil"
+	"xorm.io/builder"
 )
 
 type UserBusinessAnalysis struct {
@@ -71,6 +73,14 @@ type UserBusinessAnalysis struct {
 	Name string `xorm:"NOT NULL"`
 }
 
+type UserBusinessAnalysisQueryOptions struct {
+	ListOptions
+	UserName  string
+	SortType  string
+	StartTime int64
+	EndTime   int64
+}
+
 func QueryUserStaticData(startTime int64, endTime int64) []*UserBusinessAnalysis {
 	log.Info("query startTime =" + fmt.Sprint(startTime) + " endTime=" + fmt.Sprint(endTime))
 	statictisSess := xStatistic.NewSession()
@@ -114,11 +124,114 @@ func QueryUserStaticData(startTime int64, endTime int64) []*UserBusinessAnalysis
 	return userBusinessAnalysisReturnList
 }
 
+func QueryUserStaticDataPage(opts *UserBusinessAnalysisQueryOptions) ([]*UserBusinessAnalysis, int64) {
+
+	log.Info("query startTime =" + fmt.Sprint(opts.StartTime) + " endTime=" + fmt.Sprint(opts.EndTime))
+	statictisSess := xStatistic.NewSession()
+	defer statictisSess.Close()
+
+	currentTimeNow := time.Now()
+	pageStartTime := time.Date(currentTimeNow.Year(), currentTimeNow.Month(), currentTimeNow.Day(), 0, 0, 0, 0, currentTimeNow.Location())
+	pageEndTime := time.Date(currentTimeNow.Year(), currentTimeNow.Month(), currentTimeNow.Day(), 23, 59, 59, 0, currentTimeNow.Location())
+
+	var cond = builder.NewCond()
+	if len(opts.UserName) > 0 {
+		cond = cond.And(
+			builder.Eq{"name": opts.UserName},
+		)
+	}
+	cond = cond.And(
+		builder.Gte{"count_date": fmt.Sprint(pageStartTime)},
+	)
+	cond = cond.And(
+		builder.Lte{"count_date": fmt.Sprint(pageEndTime)},
+	)
+
+	count, err := statictisSess.Where(cond).Count(new(UserBusinessAnalysis))
+	if err != nil {
+		log.Info("query error." + err.Error())
+		return nil, 0
+	}
+
+	if opts.Page >= 0 && opts.PageSize > 0 {
+		var start int
+		if opts.Page == 0 {
+			start = 0
+		} else {
+			start = (opts.Page - 1) * opts.PageSize
+		}
+		statictisSess.Limit(opts.PageSize, start)
+	}
+	statictisSess.OrderBy("count_date desc")
+
+	userBusinessAnalysisList := make([]*UserBusinessAnalysis, 0, setting.UI.IssuePagingNum)
+	if err := statictisSess.Table("user_business_analysis").Where(cond).
+		Find(&userBusinessAnalysisList); err != nil {
+		return nil, 0
+	}
+
+	resultMap := make(map[int64]*UserBusinessAnalysis)
+
+	var newAndCond = builder.NewCond()
+	var newOrCond = builder.NewCond()
+	for _, userRecord := range userBusinessAnalysisList {
+		newOrCond.Or(
+			builder.Eq{"id": userRecord.ID},
+		)
+	}
+	newAndCond = newAndCond.And(
+		newOrCond,
+	)
+	newAndCond = newAndCond.And(
+		builder.Gte{"count_date": fmt.Sprint(opts.StartTime)},
+	)
+	newAndCond = newAndCond.And(
+		builder.Lte{"count_date": fmt.Sprint(opts.EndTime)},
+	)
+
+	userBusinessAnalysisList = make([]*UserBusinessAnalysis, 0)
+	if err := statictisSess.Table("user_business_analysis").Where(newAndCond).
+		Find(&userBusinessAnalysisList); err != nil {
+		return nil, 0
+	}
+
+	log.Info("query result size=" + fmt.Sprint(len(userBusinessAnalysisList)))
+	for _, userRecord := range userBusinessAnalysisList {
+		if _, ok := resultMap[userRecord.ID]; !ok {
+			resultMap[userRecord.ID] = userRecord
+		} else {
+			resultMap[userRecord.ID].CodeMergeCount += userRecord.CodeMergeCount
+			resultMap[userRecord.ID].CommitCount += userRecord.CommitCount
+			resultMap[userRecord.ID].IssueCount += userRecord.IssueCount
+			resultMap[userRecord.ID].CommentCount += userRecord.CommentCount
+			resultMap[userRecord.ID].FocusRepoCount += userRecord.FocusRepoCount
+			resultMap[userRecord.ID].StarRepoCount += userRecord.StarRepoCount
+			resultMap[userRecord.ID].WatchedCount += userRecord.WatchedCount
+			resultMap[userRecord.ID].CommitCodeSize += userRecord.CommitCodeSize
+			resultMap[userRecord.ID].CommitDatasetSize += userRecord.CommitDatasetSize
+			resultMap[userRecord.ID].CommitModelCount += userRecord.CommitModelCount
+			resultMap[userRecord.ID].SolveIssueCount += userRecord.SolveIssueCount
+			resultMap[userRecord.ID].EncyclopediasCount += userRecord.EncyclopediasCount
+			resultMap[userRecord.ID].CreateRepoCount += userRecord.CreateRepoCount
+			resultMap[userRecord.ID].LoginCount += userRecord.LoginCount
+		}
+	}
+
+	userBusinessAnalysisReturnList := make([]*UserBusinessAnalysis, len(resultMap))
+	index := 0
+	for _, v := range resultMap {
+		userBusinessAnalysisReturnList[index] = v
+		index += 1
+	}
+	log.Info("return size=" + fmt.Sprint(len(userBusinessAnalysisReturnList)))
+	return userBusinessAnalysisReturnList, count
+}
+
 func CounDataByDate(wikiCountMap map[string]int, startTime time.Time, endTime time.Time) {
 	log.Info("start to count other user info data")
 	sess := x.NewSession()
 	defer sess.Close()
-	sess.Select("`user`.*").Table("user")
+	sess.Select("`user`.*").Table("user").Where("type=1 and is_active=true")
 	userList := make([]*User, 0)
 	sess.Find(&userList)
 

routers/repo/user_data_analysis.go

@@ -9,6 +9,7 @@ import (
 	"code.gitea.io/gitea/modules/context"
 	"code.gitea.io/gitea/modules/git"
 	"code.gitea.io/gitea/modules/log"
+	"code.gitea.io/gitea/modules/setting"
 )
 
 func QueryUserStaticData(ctx *context.Context) {
@@ -19,7 +20,36 @@ func QueryUserStaticData(ctx *context.Context) {
 	endTime, _ := time.Parse("2006-01-02", endDate)
 	log.Info("startTime=" + fmt.Sprint(startTime.Unix()) + "  endDate=" + fmt.Sprint(endTime.Unix()))
 	ctx.JSON(http.StatusOK, models.QueryUserStaticData(startTime.Unix(), endTime.Unix()))
+}
+
+func QueryUserStaticDataPage(ctx *context.Context) {
+	startDate := ctx.Query("startDate")
+	endDate := ctx.Query("endDate")
+	page := ctx.QueryInt("page")
+	if page <= 0 {
+		page = 1
+	}
+	userName := ctx.Query("userName")
 
+	log.Info("startDate=" + startDate + "  endDate=" + endDate + " userName=" + userName + " page=" + fmt.Sprint(page))
+	startTime, _ := time.Parse("2006-01-02", startDate)
+	endTime, _ := time.Parse("2006-01-02", endDate)
+	log.Info("startTime=" + fmt.Sprint(startTime.Unix()) + "  endDate=" + fmt.Sprint(endTime.Unix()))
+
+	pageOpts := &models.UserBusinessAnalysisQueryOptions{
+		ListOptions: models.ListOptions{
+			Page:     page,
+			PageSize: setting.UI.IssuePagingNum,
+		},
+		UserName:  userName,
+		StartTime: startTime.Unix(),
+		EndTime:   endTime.Unix(),
+	}
+	mapInterface := make(map[string]interface{})
+	re, count := models.QueryUserStaticDataPage(pageOpts)
+	mapInterface["data"] = re
+	mapInterface["count"] = count
+	ctx.JSON(http.StatusOK, mapInterface)
 }
 
 func TimingCountDataByDate(date string) {

routers/routes/routes.go

@@ -793,6 +793,7 @@ func RegisterRoutes(m *macaron.Macaron) {
 
 	m.Post("/:username/:reponame/action/:action", reqSignIn, context.RepoAssignment(), context.UnitTypes(), repo.Action)
 	m.Get("/tool/query_user_static", repo.QueryUserStaticData)
+	m.Get("/tool/query_user_static_page", repo.QueryUserStaticDataPage)
 	// Grouping for those endpoints not requiring authentication
 	m.Group("/:username/:reponame", func() {
 		m.Get("/contributors", repo.Contributors)