update

models/cloudbrain_static.go

@@ -36,16 +36,6 @@ type CloudbrainStatistic struct {
 	UpdatedUnix timeutil.TimeStamp `xorm:"INDEX updated" json:"-"`
 }
 
-type TimeCloudbrainNum struct {
-	Time              time.Time `json:"time"`
-	DebugOneCount     int64     `json:"debugOneCount"`
-	BenchmarkOneCount int64     `json:"benchmarkOneCount"`
-	TrainOneCount     int64     `json:"trainOneCount"`
-	DebugTwoCount     int64     `json:"debugTwoCount"`
-	TrainTwoCount     int64     `json:"trainTwoCount"`
-	InferenceTwoCount int64     `json:"inferenceTwoCount"`
-}
-
 func GenerateDebugOneCount(beginTime time.Time, endTime time.Time) (int64, error) {
 	countSql := "SELECT count(*) FROM  " +
 		"public.cloudbrain where created_unix >=" + strconv.FormatInt(beginTime.Unix(), 10) +

modules/setting/setting.go

@@ -452,18 +452,19 @@ var (
 	DecompressOBSTaskName   string
 
 	//cloudbrain config
-	CBAuthUser         string
-	CBAuthPassword     string
-	RestServerHost     string
-	JobPath            string
-	CBCodePathPrefix   string
-	JobType            string
-	GpuTypes           string
-	DebugServerHost    string
-	ResourceSpecs      string
-	MaxDuration        int64
-	TrainGpuTypes      string
-	TrainResourceSpecs string
+	CBAuthUser           string
+	CBAuthPassword       string
+	RestServerHost       string
+	JobPath              string
+	CBCodePathPrefix     string
+	JobType              string
+	GpuTypes             string
+	DebugServerHost      string
+	ResourceSpecs        string
+	MaxDuration          int64
+	TrainGpuTypes        string
+	TrainResourceSpecs   string
+	BrainRecordBeginTime string
 
 	//benchmark config
 	IsBenchmarkEnabled     bool
@@ -1290,6 +1291,7 @@ func NewContext() {
 	MaxDuration = sec.Key("MAX_DURATION").MustInt64(14400)
 	TrainGpuTypes = sec.Key("TRAIN_GPU_TYPES").MustString("")
 	TrainResourceSpecs = sec.Key("TRAIN_RESOURCE_SPECS").MustString("")
+	BrainRecordBeginTime = sec.Key("brain_record_beigin_time").MustString("2021-01-01")
 
 	sec = Cfg.Section("benchmark")
 	IsBenchmarkEnabled = sec.Key("ENABLED").MustBool(false)

routers/api/v1/repo/cloudbrain_dashboard.go

@@ -9,6 +9,7 @@ import (
 	"code.gitea.io/gitea/models"
 	"code.gitea.io/gitea/modules/context"
 	"code.gitea.io/gitea/modules/log"
+	"code.gitea.io/gitea/modules/setting"
 	"github.com/360EntSecGroup-Skylar/excelize/v2"
 )
 
@@ -21,42 +22,172 @@ type CloudbrainsPeriodData struct {
 	InferenceTwoCount int64 `json:"inferenceTwoCount"`
 }
 type TimeCloudbrainsNum struct {
-	TimeCloudbrainNum []models.TimeCloudbrainNum `json:"imeCloudbrainNum"`
+	TimeCloudbrainNum []DateCloudbrainNum `json:"dateCloudbrainNum"`
+}
+type DateCloudbrainNum struct {
+	Date               string `json:"date"`
+	DebugOneCount      int64  `json:"debugOneCount"`
+	BenchmarkOneCount  int64  `json:"benchmarkOneCount"`
+	TrainOneCount      int64  `json:"trainOneCount"`
+	DebugTwoCount      int64  `json:"debugTwoCount"`
+	TrainTwoCount      int64  `json:"trainTwoCount"`
+	InferenceTwoCount  int64  `json:"inferenceTwoCount"`
+	CloudbrainOneCount int64  `json:"cloudbrainOneCount"`
+	CloudbrainTwoCount int64  `json:"cloudbrainTwoCount"`
+	CloudbrainCount    int64  `json:"cloudbrainCount"`
 }
 
 func GetAllCloudbrainsTrend(ctx *context.Context) {
-
-	recordBeginTime, err := getRecordBeginTime()
+	brainRecordBeginTime, err := getBrainRecordBeginTime()
 	if err != nil {
-		log.Error("Can not get record begin time", err)
-		ctx.Error(http.StatusBadRequest, ctx.Tr("repo.record_begintime_get_err"))
+		log.Error("Can not get brain record begin time", err)
+		ctx.Error(http.StatusBadRequest, ctx.Tr("repo.brain_record_begintime_get_err"))
 		return
 	}
-	timeCloudbrainNum, beginTime, endTime, err := getCloudbrainTrendTime(ctx, recordBeginTime)
-	if err != nil {
-		log.Error("Parameter is wrong", err)
-		ctx.Error(http.StatusBadRequest, ctx.Tr("repo.parameter_is_wrong"))
-		return
-	}
-	page := ctx.QueryInt("page")
-	if page <= 0 {
-		page = 1
-	}
-	pageSize := ctx.QueryInt("pagesize")
-	if pageSize <= 0 {
-		pageSize = DEFAULT_PAGE_SIZE
-	}
+	queryType := ctx.QueryTrim("type")
+	now := time.Now()
+
+	beginTimeStr := ctx.QueryTrim("beginTime")
+	endTimeStr := ctx.QueryTrim("endTime")
+	var beginTime time.Time
+	var endTime time.Time
+	var endTimeTemp time.Time
+	dateCloudbrainNum := make([]DateCloudbrainNum, 0)
+	if queryType != "" {
+		if queryType == "all" {
+			beginTime = brainRecordBeginTime
+			endTime = now
+			endTimeTemp = beginTime.AddDate(0, 1, 0)
+			dateCloudbrainNum, err = getYearCloudbrainNum(beginTime, endTimeTemp, endTime)
+			if err != nil {
+				log.Error("Can not query getYearCloudbrainNum.", err)
+				ctx.Error(http.StatusBadRequest, ctx.Tr("getYearCloudbrainNum_get_error"))
+				return
+			}
+		} else if queryType == "yesterday" {
+			beginTime = now.AddDate(0, 0, -1)
+			beginTime = time.Date(beginTime.Year(), beginTime.Month(), beginTime.Day(), 0, 0, 0, 0, now.Location())
+			endTimeTemp = beginTime.Add(time.Hour)
+			endTime = time.Date(now.Year(), now.Month(), now.Day(), 0, 0, 0, 0, now.Location())
+			dateCloudbrainNum, err = getHourCloudbrainNum(beginTime, endTimeTemp, endTime)
+			if err != nil {
+				log.Error("Can not query getHourCloudbrainNum.", err)
+				ctx.Error(http.StatusBadRequest, ctx.Tr("getYearCloudbrainNum_get_error"))
+				return
+			}
+
+		} else if queryType == "current_week" {
+			beginTime = now.AddDate(0, 0, -int(time.Now().Weekday())+1) //begin from monday
+			beginTime = time.Date(beginTime.Year(), beginTime.Month(), beginTime.Day(), 0, 0, 0, 0, now.Location())
+			endTime = now
+			endTimeTemp = beginTime.AddDate(0, 0, 1)
+			dateCloudbrainNum, err = getDayCloudbrainNum(beginTime, endTimeTemp, endTime)
+			if err != nil {
+				log.Error("Can not query getDayCloudbrainNum.", err)
+				ctx.Error(http.StatusBadRequest, ctx.Tr("getDayCloudbrainNum_get_error"))
+				return
+			}
+		} else if queryType == "current_month" {
+			endTime = now
+			beginTime = time.Date(endTime.Year(), endTime.Month(), 1, 0, 0, 0, 0, now.Location())
+			endTimeTemp = beginTime.AddDate(0, 0, 1)
+			dateCloudbrainNum, err = getDayCloudbrainNum(beginTime, endTimeTemp, endTime)
+			if err != nil {
+				log.Error("Can not query getDayCloudbrainNum.", err)
+				ctx.Error(http.StatusBadRequest, ctx.Tr("getDayCloudbrainNum_get_error"))
+				return
+			}
+
+		} else if queryType == "monthly" {
+			endTime = now
+			beginTime = now.AddDate(0, -1, 0)
+			beginTime = time.Date(beginTime.Year(), beginTime.Month(), beginTime.Day(), 0, 0, 0, 0, now.Location())
+			endTimeTemp = beginTime.AddDate(0, 0, 1)
+			dateCloudbrainNum, err = getDayCloudbrainNum(beginTime, endTimeTemp, endTime)
+			if err != nil {
+				log.Error("Can not query getDayCloudbrainNum.", err)
+				ctx.Error(http.StatusBadRequest, ctx.Tr("getDayCloudbrainNum_get_error"))
+				return
+			}
+
+		} else if queryType == "current_year" {
+			endTime = now
+			beginTime = time.Date(endTime.Year(), 1, 1, 0, 0, 0, 0, now.Location())
+			endTimeTemp = beginTime.AddDate(0, 1, 0)
+			dateCloudbrainNum, err = getYearCloudbrainNum(beginTime, endTimeTemp, endTime)
+			if err != nil {
+				log.Error("Can not query getDayCloudbrainNum.", err)
+				ctx.Error(http.StatusBadRequest, ctx.Tr("getYearCloudbrainNum_get_error"))
+				return
+			}
+
+		} else if queryType == "last_month" {
+
+			lastMonthTime := now.AddDate(0, -1, 0)
+			beginTime = time.Date(lastMonthTime.Year(), lastMonthTime.Month(), 1, 0, 0, 0, 0, now.Location())
+			endTime = time.Date(now.Year(), now.Month(), 2, 0, 0, 0, 0, now.Location())
+			endTimeTemp = beginTime.AddDate(0, 0, 1)
+			dateCloudbrainNum, err = getDayCloudbrainNum(beginTime, endTimeTemp, endTime)
+			if err != nil {
+				log.Error("Can not query getDayCloudbrainNum.", err)
+				ctx.Error(http.StatusBadRequest, ctx.Tr("getDayCloudbrainNum_get_error"))
+				return
+			}
+
+		}
+
+	} else {
+		if beginTimeStr == "" || endTimeStr == "" {
+			//如果查询类型和开始时间结束时间都未设置，按queryType=all处理
+			beginTime = brainRecordBeginTime
+			endTime = now
+			endTimeTemp = beginTime.AddDate(0, 1, 0)
+			dateCloudbrainNum, err = getYearCloudbrainNum(beginTime, endTimeTemp, endTime)
+			if err != nil {
+				log.Error("Can not query getDayCloudbrainNum.", err)
+				ctx.Error(http.StatusBadRequest, ctx.Tr("getYearCloudbrainNum_get_error"))
+				return
+			}
+		} else {
+			beginTime, err = time.ParseInLocation("2006-01-02", beginTimeStr, time.Local)
+			if err != nil {
+				log.Error("Can not ParseInLocation.", err)
+				ctx.Error(http.StatusBadRequest, ctx.Tr("ParseInLocation_get_error"))
+				return
+			}
+			endTime, err = time.ParseInLocation("2006-01-02", endTimeStr, time.Local)
+			if err != nil {
+				log.Error("Can not ParseInLocation.", err)
+				ctx.Error(http.StatusBadRequest, ctx.Tr("ParseInLocation_get_error"))
+				return
+			}
+			days := (endTime.Unix() - beginTime.Unix()) / 3600 / 24
+			if 1 < days {
+				endTimeTemp = beginTime.AddDate(0, 0, 1)
+				endTime = endTime.AddDate(0, 0, 2)
+				dateCloudbrainNum, err = getDayCloudbrainNum(beginTime, endTimeTemp, endTime)
+				if err != nil {
+					log.Error("Can not query getDayCloudbrainNum.", err)
+					ctx.Error(http.StatusBadRequest, ctx.Tr("getDayCloudbrainNum_get_error"))
+					return
+				}
+			} else if 0 < days || days <= 1 {
+				endTimeTemp = beginTime.Add(time.Hour)
+				dateCloudbrainNum, err = getHourCloudbrainNum(beginTime, endTimeTemp, endTime)
+				if err != nil {
+					log.Error("Can not query getHourCloudbrainNum.", err)
+					ctx.Error(http.StatusBadRequest, ctx.Tr("getHourCloudbrainNum_get_error"))
+					return
+				}
+			} else {
+				return
+			}
+		}
 
+	}
 	cloudbrainsPeriodData := TimeCloudbrainsNum{
-		TimeCloudbrainNum: timeCloudbrainNum,
+		TimeCloudbrainNum: dateCloudbrainNum,
 	}
-	now := time.Now()
-	endTime = now
-	beginTime = time.Date(endTime.Year(), endTime.Month(), 2, 0, 0, 0, 0, now.Location())
-	testtime := now.AddDate(0, -1, 1)
-	fmt.Printf("beginTime is: %s", beginTime)
-	fmt.Printf("endTime is: %s", endTime)
-	fmt.Printf("testtime is:%s", testtime)
 
 	ctx.JSON(http.StatusOK, cloudbrainsPeriodData)
 
@@ -141,79 +272,6 @@ func GetAllCloudbrainsPeriodStatistics(ctx *context.Context) {
 	ctx.JSON(http.StatusOK, cloudbrainsPeriodData)
 
 }
-func ServeCloudbrainPeriodStatisticsFile(ctx *context.Context) {
-
-	recordBeginTime, err := getRecordBeginTime()
-	if err != nil {
-		log.Error("Can not get record begin time", err)
-		ctx.Error(http.StatusBadRequest, ctx.Tr("repo.record_begintime_get_err"))
-		return
-	}
-	beginTime, endTime, err := getCloudbrainTimePeroid(ctx, recordBeginTime)
-	if err != nil {
-		log.Error("Parameter is wrong", err)
-		ctx.Error(http.StatusBadRequest, ctx.Tr("repo.parameter_is_wrong"))
-		return
-	}
-	q := ctx.QueryTrim("q")
-	page := ctx.QueryInt("page")
-	if page <= 0 {
-		page = 1
-	}
-	pageSize := 1000
-	orderBy := getOrderBy(ctx)
-
-	_, latestDate, err := models.GetRepoStatLastUpdatedTime()
-	if err != nil {
-		log.Error("Can not query the last updated time.", err)
-		ctx.Error(http.StatusBadRequest, ctx.Tr("repo.last_update_time_error"))
-		return
-	}
-
-	countSql := generateCountSql(beginTime, endTime, latestDate, q)
-	total, err := models.CountRepoStatByRawSql(countSql)
-	if err != nil {
-		log.Error("Can not query total count.", err)
-		ctx.Error(http.StatusBadRequest, ctx.Tr("repo.total_count_get_error"))
-		return
-	}
-	var projectAnalysis = ctx.Tr("repo.repo_stat_inspect")
-	fileName := getFileName(ctx, beginTime, endTime, projectAnalysis)
-
-	totalPage := getTotalPage(total, pageSize)
-
-	f := excelize.NewFile()
-
-	index := f.NewSheet(projectAnalysis)
-	f.DeleteSheet("Sheet1")
-
-	for k, v := range allProjectsPeroidHeader(ctx) {
-		f.SetCellValue(projectAnalysis, k, v)
-	}
-
-	var row = 2
-	for i := 0; i <= totalPage; i++ {
-
-		pageRecords := models.GetRepoStatisticByRawSql(generateSqlByType(ctx, beginTime, endTime, latestDate, q, orderBy, i+1, pageSize))
-		for _, record := range pageRecords {
-
-			for k, v := range allProjectsPeroidValues(row, record, ctx) {
-				f.SetCellValue(projectAnalysis, k, v)
-			}
-			row++
-
-		}
-
-	}
-	f.SetActiveSheet(index)
-
-	ctx.Resp.Header().Set("Content-Disposition", "attachment; filename="+url.QueryEscape(fileName))
-	ctx.Resp.Header().Set("Content-Type", "application/octet-stream")
-
-	f.WriteTo(ctx.Resp)
-
-}
-
 func getCloudbrainTimePeroid(ctx *context.Context, recordBeginTime time.Time) (time.Time, time.Time, error) {
 	queryType := ctx.QueryTrim("type")
 	now := time.Now()
@@ -292,136 +350,190 @@ func getCloudbrainTimePeroid(ctx *context.Context, recordBeginTime time.Time) (t
 
 }
 
-func getCloudbrainTrendTime(ctx *context.Context, recordBeginTime time.Time) ([]models.TimeCloudbrainNum, time.Time, time.Time, error) {
-	queryType := ctx.QueryTrim("type")
-	now := time.Now()
-	recordBeginTimeTemp := recordBeginTime.AddDate(0, 0, 1)
-
-	beginTimeStr := ctx.QueryTrim("beginTime")
-	endTimeStr := ctx.QueryTrim("endTime")
-	var beginTime time.Time
-	var endTime time.Time
-	var err error
-	timeCloudbrainNum := make([]models.TimeCloudbrainNum, 0)
-	if queryType != "" {
-
-		if queryType == "all" {
-			beginTime = recordBeginTimeTemp
-			endTime = now
-		} else if queryType == "yesterday" {
-			endTime = now
-			beginTime = time.Date(endTime.Year(), endTime.Month(), endTime.Day(), 0, 0, 0, 0, now.Location())
-
-		} else if queryType == "current_week" {
-			beginTime = now.AddDate(0, 0, -int(time.Now().Weekday())+2) //begin from monday
-			beginTime = time.Date(beginTime.Year(), beginTime.Month(), beginTime.Day(), 0, 0, 0, 0, now.Location())
-			endTime = now
-		} else if queryType == "current_month" {
-			endTime = now
-			beginTime = time.Date(endTime.Year(), endTime.Month(), 1, 0, 0, 0, 0, now.Location())
-			endTime1 := beginTime.AddDate(0, 0, 1)
-			for endTime1.Before(endTime) {
-				debugOneCount, benchmarkOneCount, trainOneCount, debugTwoCount, trainTwoCount, inferenceTwoCount, err := getCloudbrainCount(beginTime, endTime1)
-				if err != nil {
-					log.Error("Can not query debugOneCount.", err)
-					ctx.Error(http.StatusBadRequest, ctx.Tr("debugOneCount_get_error"))
-				}
-				timeCloudbrainNum = append(timeCloudbrainNum, models.TimeCloudbrainNum{
-					Time:              beginTime,
-					DebugOneCount:     debugOneCount,
-					BenchmarkOneCount: benchmarkOneCount,
-					TrainOneCount:     trainOneCount,
-					DebugTwoCount:     debugTwoCount,
-					TrainTwoCount:     trainTwoCount,
-					InferenceTwoCount: inferenceTwoCount,
-				})
-				beginTime = endTime1
-				endTime1 = beginTime.AddDate(0, 0, 1)
-			}
-			return timeCloudbrainNum, beginTime, endTime, nil
-
-		} else if queryType == "monthly" {
-			endTime = now
-			beginTime = now.AddDate(0, -1, 1)
-			beginTime = time.Date(beginTime.Year(), beginTime.Month(), beginTime.Day(), 0, 0, 0, 0, now.Location())
-
-		} else if queryType == "current_year" {
-			endTime = now
-			beginTime = time.Date(endTime.Year(), 1, 2, 0, 0, 0, 0, now.Location())
-
-		} else if queryType == "last_month" {
-
-			lastMonthTime := now.AddDate(0, -1, 0)
-			beginTime = time.Date(lastMonthTime.Year(), lastMonthTime.Month(), 2, 0, 0, 0, 0, now.Location())
-			endTime = time.Date(now.Year(), now.Month(), 2, 0, 0, 0, 0, now.Location())
-
-		} else {
-			return timeCloudbrainNum, now, now, fmt.Errorf("The value of type parameter is wrong.")
-
-		}
-
-	} else {
-		if beginTimeStr == "" || endTimeStr == "" {
-			//如果查询类型和开始时间结束时间都未设置，按queryType=all处理
-			beginTime = recordBeginTimeTemp
-			endTime = now
-
-		} else {
-
-			beginTime, err = time.ParseInLocation("2006-01-02", beginTimeStr, time.Local)
-			if err != nil {
-				return timeCloudbrainNum, now, now, err
-			}
-
-			endTime, err = time.ParseInLocation("2006-01-02", endTimeStr, time.Local)
-			if err != nil {
-				return timeCloudbrainNum, now, now, err
-			}
-
-			beginTime = beginTime.AddDate(0, 0, 1)
-			endTime = endTime.AddDate(0, 0, 1)
-		}
-
-	}
-
-	if beginTime.Before(recordBeginTimeTemp) {
-		beginTime = recordBeginTimeTemp
-	}
-
-	return timeCloudbrainNum, beginTime, endTime, nil
-
-}
-
-func getCloudbrainCount(beginTime time.Time, endTime time.Time) (int64, int64, int64, int64, int64, int64, error) {
+func getCloudbrainCount(beginTime time.Time, endTime time.Time) (int64, int64, int64, int64, int64, int64, int64, int64, int64, error) {
 	debugOneCount, err := models.GenerateDebugOneCount(beginTime, endTime)
 	if err != nil {
 		log.Error("Can not query debugOneCount.", err)
-		return 0, 0, 0, 0, 0, 0, err
+		return 0, 0, 0, 0, 0, 0, 0, 0, 0, err
 	}
 	benchmarkOneCount, err := models.GenerateBenchmarkOneCount(beginTime, endTime)
 	if err != nil {
 		log.Error("Can not query benchmarkCount.", err)
-		return 0, 0, 0, 0, 0, 0, err
+		return 0, 0, 0, 0, 0, 0, 0, 0, 0, err
 	}
 	trainOneCount, err := models.GenerateTrainOneCount(beginTime, endTime)
 	if err != nil {
 		log.Error("Can not query trainOneCount.", err)
-		return 0, 0, 0, 0, 0, 0, err
+		return 0, 0, 0, 0, 0, 0, 0, 0, 0, err
 	}
 	debugTwoCount, err := models.GenerateDebugTwoCount(beginTime, endTime)
 	if err != nil {
 		log.Error("Can not query debugTwoCount.", err)
-		return 0, 0, 0, 0, 0, 0, err
+		return 0, 0, 0, 0, 0, 0, 0, 0, 0, err
 	}
 	trainTwoCount, err := models.GenerateTrainTwoCount(beginTime, endTime)
 	if err != nil {
 		log.Error("Can not query DebugOneTotal count.", err)
-		return 0, 0, 0, 0, 0, 0, err
+		return 0, 0, 0, 0, 0, 0, 0, 0, 0, err
 	}
 	inferenceTwoCount, err := models.GenerateInferenceTwoCount(beginTime, endTime)
 	if err != nil {
 		log.Error("Can not query inferenceTwoCount.", err)
-		return 0, 0, 0, 0, 0, 0, err
+		return 0, 0, 0, 0, 0, 0, 0, 0, 0, err
 	}
-	return debugOneCount, benchmarkOneCount, trainOneCount, debugTwoCount, trainTwoCount, inferenceTwoCount, err
+	cloudbrainOneCount := debugOneCount + benchmarkOneCount + trainOneCount
+	cloudbrainTwoCount := debugTwoCount + trainTwoCount + inferenceTwoCount
+	cloudbrainCount := cloudbrainOneCount + cloudbrainTwoCount
+	return debugOneCount, benchmarkOneCount, trainOneCount, debugTwoCount, trainTwoCount, inferenceTwoCount, cloudbrainOneCount, cloudbrainTwoCount, cloudbrainCount, err
+}
+func getHourCloudbrainNum(beginTime time.Time, endTimeTemp time.Time, endTime time.Time) ([]DateCloudbrainNum, error) {
+	dayCloudbrainNum := make([]DateCloudbrainNum, 0)
+	for endTimeTemp.Before(endTime) || endTimeTemp.Equal(endTime) {
+		debugOneCount, benchmarkOneCount, trainOneCount, debugTwoCount, trainTwoCount, inferenceTwoCount, cloudbrainOneCount, cloudbrainTwoCount, cloudbrainCount, err := getCloudbrainCount(beginTime, endTimeTemp)
+		if err != nil {
+			log.Error("Can not query getCloudbrainCount.", err)
+			return nil, err
+		}
+		dayCloudbrainNum = append(dayCloudbrainNum, DateCloudbrainNum{
+			Date:               beginTime.Format(time.RFC3339),
+			DebugOneCount:      debugOneCount,
+			BenchmarkOneCount:  benchmarkOneCount,
+			TrainOneCount:      trainOneCount,
+			DebugTwoCount:      debugTwoCount,
+			TrainTwoCount:      trainTwoCount,
+			InferenceTwoCount:  inferenceTwoCount,
+			CloudbrainOneCount: cloudbrainOneCount,
+			CloudbrainTwoCount: cloudbrainTwoCount,
+			CloudbrainCount:    cloudbrainCount,
+		})
+		beginTime = endTimeTemp
+		endTimeTemp = beginTime.Add(time.Hour)
+	}
+	return dayCloudbrainNum, nil
+}
+func getDayCloudbrainNum(beginTime time.Time, endTimeTemp time.Time, endTime time.Time) ([]DateCloudbrainNum, error) {
+	dayCloudbrainNum := make([]DateCloudbrainNum, 0)
+	for endTimeTemp.Before(endTime) {
+		debugOneCount, benchmarkOneCount, trainOneCount, debugTwoCount, trainTwoCount, inferenceTwoCount, cloudbrainOneCount, cloudbrainTwoCount, cloudbrainCount, err := getCloudbrainCount(beginTime, endTimeTemp)
+		if err != nil {
+			log.Error("Can not query getCloudbrainCount.", err)
+			return nil, err
+		}
+		dayCloudbrainNum = append(dayCloudbrainNum, DateCloudbrainNum{
+			Date:               beginTime.Format("2006-01-02"),
+			DebugOneCount:      debugOneCount,
+			BenchmarkOneCount:  benchmarkOneCount,
+			TrainOneCount:      trainOneCount,
+			DebugTwoCount:      debugTwoCount,
+			TrainTwoCount:      trainTwoCount,
+			InferenceTwoCount:  inferenceTwoCount,
+			CloudbrainOneCount: cloudbrainOneCount,
+			CloudbrainTwoCount: cloudbrainTwoCount,
+			CloudbrainCount:    cloudbrainCount,
+		})
+		beginTime = endTimeTemp
+		endTimeTemp = beginTime.AddDate(0, 0, 1)
+	}
+	return dayCloudbrainNum, nil
+}
+func getYearCloudbrainNum(beginTime time.Time, endTimeTemp time.Time, endTime time.Time) ([]DateCloudbrainNum, error) {
+	yearCloudbrainNum := make([]DateCloudbrainNum, 0)
+	for endTimeTemp.Before(endTime) {
+		debugOneCount, benchmarkOneCount, trainOneCount, debugTwoCount, trainTwoCount, inferenceTwoCount, cloudbrainOneCount, cloudbrainTwoCount, cloudbrainCount, err := getCloudbrainCount(beginTime, endTimeTemp)
+		if err != nil {
+			log.Error("Can not query getCloudbrainCount.", err)
+			return nil, err
+		}
+		yearCloudbrainNum = append(yearCloudbrainNum, DateCloudbrainNum{
+			Date:               beginTime.Format("2006-01"),
+			DebugOneCount:      debugOneCount,
+			BenchmarkOneCount:  benchmarkOneCount,
+			TrainOneCount:      trainOneCount,
+			DebugTwoCount:      debugTwoCount,
+			TrainTwoCount:      trainTwoCount,
+			InferenceTwoCount:  inferenceTwoCount,
+			CloudbrainOneCount: cloudbrainOneCount,
+			CloudbrainTwoCount: cloudbrainTwoCount,
+			CloudbrainCount:    cloudbrainCount,
+		})
+		beginTime = endTimeTemp
+		endTimeTemp = beginTime.AddDate(0, 1, 0)
+	}
+	return yearCloudbrainNum, nil
+}
+func getBrainRecordBeginTime() (time.Time, error) {
+	return time.ParseInLocation(DATE_FORMAT, setting.BrainRecordBeginTime, time.Local)
+}
+
+func ServeCloudbrainPeriodStatisticsFile(ctx *context.Context) {
+
+	recordBeginTime, err := getRecordBeginTime()
+	if err != nil {
+		log.Error("Can not get record begin time", err)
+		ctx.Error(http.StatusBadRequest, ctx.Tr("repo.record_begintime_get_err"))
+		return
+	}
+	beginTime, endTime, err := getCloudbrainTimePeroid(ctx, recordBeginTime)
+	if err != nil {
+		log.Error("Parameter is wrong", err)
+		ctx.Error(http.StatusBadRequest, ctx.Tr("repo.parameter_is_wrong"))
+		return
+	}
+	q := ctx.QueryTrim("q")
+	page := ctx.QueryInt("page")
+	if page <= 0 {
+		page = 1
+	}
+	pageSize := 1000
+	orderBy := getOrderBy(ctx)
+
+	_, latestDate, err := models.GetRepoStatLastUpdatedTime()
+	if err != nil {
+		log.Error("Can not query the last updated time.", err)
+		ctx.Error(http.StatusBadRequest, ctx.Tr("repo.last_update_time_error"))
+		return
+	}
+
+	countSql := generateCountSql(beginTime, endTime, latestDate, q)
+	total, err := models.CountRepoStatByRawSql(countSql)
+	if err != nil {
+		log.Error("Can not query total count.", err)
+		ctx.Error(http.StatusBadRequest, ctx.Tr("repo.total_count_get_error"))
+		return
+	}
+	var projectAnalysis = ctx.Tr("repo.repo_stat_inspect")
+	fileName := getFileName(ctx, beginTime, endTime, projectAnalysis)
+
+	totalPage := getTotalPage(total, pageSize)
+
+	f := excelize.NewFile()
+
+	index := f.NewSheet(projectAnalysis)
+	f.DeleteSheet("Sheet1")
+
+	for k, v := range allProjectsPeroidHeader(ctx) {
+		f.SetCellValue(projectAnalysis, k, v)
+	}
+
+	var row = 2
+	for i := 0; i <= totalPage; i++ {
+
+		pageRecords := models.GetRepoStatisticByRawSql(generateSqlByType(ctx, beginTime, endTime, latestDate, q, orderBy, i+1, pageSize))
+		for _, record := range pageRecords {
+
+			for k, v := range allProjectsPeroidValues(row, record, ctx) {
+				f.SetCellValue(projectAnalysis, k, v)
+			}
+			row++
+
+		}
+
+	}
+	f.SetActiveSheet(index)
+
+	ctx.Resp.Header().Set("Content-Disposition", "attachment; filename="+url.QueryEscape(fileName))
+	ctx.Resp.Header().Set("Content-Type", "application/octet-stream")
+
+	f.WriteTo(ctx.Resp)
+
 }