aiforge/routers/api/v1/repo/cloudbrain_dashboard.go

package repo

import (
	"fmt"
	"net/http"
	"net/url"
	"strings"
	"time"

	"code.gitea.io/gitea/models"
	"code.gitea.io/gitea/modules/context"
	"code.gitea.io/gitea/modules/log"
	"code.gitea.io/gitea/modules/modelarts"
	"github.com/360EntSecGroup-Skylar/excelize/v2"

	"code.gitea.io/gitea/modules/setting"
)

type CloudbrainsPeriodData struct {
	DebugOnePeriodCount      int64 `json:"debugOnePeriodCount"`
	BenchmarkOnePeriodCount  int64 `json:"benchmarkOnePeriodCount"`
	TrainOnePeriodCount      int64 `json:"trainOnePeriodCount"`
	DebugTwoPeriodCount      int64 `json:"debugTwoPeriodCount"`
	TrainTwoPeriodCount      int64 `json:"trainTwoPeriodCount"`
	InferenceTwoPeriodCount  int64 `json:"inferenceTwoPeriodCount"`
	JobWaitingPeriodCount    int64 `json:"jobWaitingPeriodCount"`
	JobRunningPeriodCount    int64 `json:"jobRunningPeriodCount"`
	JobSucceededPeriodCount  int64 `json:"jobRunningPeriodCount"`
	CloudBrainOnePeriodCount int64 `json:"cloudBrainOnePeriodCount"`
	CloudBrainTwoPeriodCount int64 `json:"cloudBrainTwoPeriodCount"`
}
type CloudbrainsOverviewData struct {
	JobWaitingPeriodCount   int64 `json:"jobWaitingPeriodCount"`
	JobRunningPeriodCount   int64 `json:"jobRunningPeriodCount"`
	JobStoppedPeriodCount   int64 `json:"jobStoppedPeriodCount"`
	JobSucceededPeriodCount int64 `json:"jobSucceededPeriodCount"`
	JobFailedPeriodCount    int64 `json:"jobFailedPeriodCount"`
	CloudBrainOneCount      int64 `json:"cloudBrainOneCount"`
	CloudBrainTwoCount      int64 `json:"cloudBrainTwoCount"`
	CloudBrainOneDuration   int64 `json:"cloudBrainOneDuration"`
	CloudBrainTwoDuration   int64 `json:"cloudBrainTwoDuration"`
	CreatorPeriodCount      int64 `json:"creatorPeriodCount"`
	CreatorCount            int64 `json:"creatorCount"`
}

type CloudbrainsStatusAnalysis struct {
	JobWaitingCount   int64 `json:"jobWaitingCount"`
	JobRunningCount   int64 `json:"jobRunningCount"`
	JobStoppedCount   int64 `json:"jobStoppedCount"`
	JobSucceededCount int64 `json:"jobSucceededCount"`
	JobFailedCount    int64 `json:"jobFailedCount"`
}
type TimeCloudbrainsNum struct {
	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 GetAllCloudbrainsOverview(ctx *context.Context) {
	now := time.Now()
	//today overview
	beginTime := now.AddDate(0, 0, 0)
	beginTime = time.Date(beginTime.Year(), beginTime.Month(), beginTime.Day(), 0, 0, 0, 0, now.Location())
	endTime := now
	jobWaitingPeriodCount, err := models.GetJobWaitingPeriodCount(beginTime, endTime)
	if err != nil {
		log.Error("Can not query jobWaitingCount.", err)
		return
	}
	jobRunningPeriodCount, err := models.GetJobRunningPeriodCount(beginTime, endTime)
	if err != nil {
		log.Error("Can not query jobRunningCount.", err)
		return
	}
	jobStoppedPeriodCount, err := models.GetJobStoppedPeriodCount(beginTime, endTime)
	if err != nil {
		log.Error("Can not query jobStoppedCount.", err)
		return
	}
	jobSucceededPeriodCount, err := models.GetJobSucceededPeriodCount(beginTime, endTime)
	if err != nil {
		log.Error("Can not query jobSucceededCount.", err)
		return
	}
	jobFailedPeriodCount, err := models.GetJobFailedPeriodCount(beginTime, endTime)
	if err != nil {
		log.Error("Can not query jobFailedCount.", err)
		return
	}
	cloudBrainOneCount, err := models.GetCloudBrainOneCount()
	if err != nil {
		log.Error("Can not query cloudBrainOneCount.", err)
		return
	}
	cloudBrainOneDuration, err := models.GetCloudBrainOneDuration()
	if err != nil {
		log.Error("Can not query cloudBrainOneDuration.", err)
		return
	}
	cloudBrainTwoCount, err := models.GetCloudBrainTwoCount()
	if err != nil {
		log.Error("Can not query cloudBrainTwoCount.", err)
		return
	}
	cloudBrainTwoDuration, err := models.GetCloudBrainTwoDuration()
	if err != nil {
		log.Error("Can not query cloudBrainTwoDuration.", err)
		return
	}
	creatorPeriodCount, err := models.GetCreatorPeriodCount(beginTime, endTime)
	if err != nil {
		log.Error("Can not query creatorPeriodCount.", err)
		return
	}
	creatorCount, err := models.GetCreatorCount()
	if err != nil {
		log.Error("Can not query creatorCount.", err)
		return
	}

	CloudbrainsOverviewData := CloudbrainsOverviewData{
		JobWaitingPeriodCount:   jobWaitingPeriodCount,
		JobRunningPeriodCount:   jobRunningPeriodCount,
		JobStoppedPeriodCount:   jobStoppedPeriodCount,
		JobSucceededPeriodCount: jobSucceededPeriodCount,
		JobFailedPeriodCount:    jobFailedPeriodCount,
		CloudBrainOneCount:      cloudBrainOneCount,
		CloudBrainTwoCount:      cloudBrainTwoCount,
		CloudBrainOneDuration:   cloudBrainOneDuration,
		CloudBrainTwoDuration:   cloudBrainTwoDuration,
		CreatorPeriodCount:      creatorPeriodCount,
		CreatorCount:            creatorCount,
	}

	ctx.JSON(http.StatusOK, CloudbrainsOverviewData)
}

func GetAllCloudbrainsTrend(ctx *context.Context) {
	brainRecordBeginTime, err := getBrainRecordBeginTime()
	if err != nil {
		log.Error("Can not get brain record begin time", err)
		ctx.Error(http.StatusBadRequest, ctx.Tr("repo.brain_record_begintime_get_err"))
		return
	}
	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: dateCloudbrainNum,
	}

	ctx.JSON(http.StatusOK, cloudbrainsPeriodData)

}

func GetAllCloudbrainsPeriodDistribution(ctx *context.Context) {

	recordBeginTime, 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"))
		return
	}
	beginTime, endTime, err := getTimePeroid(ctx, recordBeginTime)
	if err != nil {
		log.Error("Parameter is wrong", err)
		ctx.Error(http.StatusBadRequest, ctx.Tr("repo.parameter_is_wrong"))
		return
	}
	debugOnePeriodCount, err := models.GetDebugOnePeriodCount(beginTime, endTime)
	if err != nil {
		log.Error("Can not query debugOneCount.", err)
		ctx.Error(http.StatusBadRequest, ctx.Tr("debugOneCount_get_error"))
		return
	}
	benchmarkOnePeriodCount, err := models.GetBenchmarkOnePeriodCount(beginTime, endTime)
	if err != nil {
		log.Error("Can not query benchmarkCount.", err)
		ctx.Error(http.StatusBadRequest, ctx.Tr("benchmarkOneCount_get_error"))
		return
	}
	trainOnePeriodCount, err := models.GetTrainOnePeriodCount(beginTime, endTime)
	if err != nil {
		log.Error("Can not query trainOneCount.", err)
		ctx.Error(http.StatusBadRequest, ctx.Tr("trainOneCount_get_error"))
		return
	}
	debugTwoPeriodCount, err := models.GetDebugTwoPeriodCount(beginTime, endTime)
	if err != nil {
		log.Error("Can not query debugTwoCount.", err)
		ctx.Error(http.StatusBadRequest, ctx.Tr("debugTwoCount_get_error"))
		return
	}
	trainTwoPeriodCount, err := models.GetTrainTwoPeriodCount(beginTime, endTime)
	if err != nil {
		log.Error("Can not query DebugOneTotal count.", err)
		ctx.Error(http.StatusBadRequest, ctx.Tr("total_count_get_error"))
		return
	}
	inferenceTwoPeriodCount, err := models.GetInferenceTwoPeriodCount(beginTime, endTime)
	if err != nil {
		log.Error("Can not query inferenceTwoCount.", err)
		ctx.Error(http.StatusBadRequest, ctx.Tr("inferenceTwoCount_get_error"))
		return
	}
	cloudBrainOnePeriodCount, err := models.GetCloudBrainOnePeriodCount(beginTime, endTime)
	if err != nil {
		log.Error("Can not query cloudBrainOnePeriodCount.", err)
		ctx.Error(http.StatusBadRequest, ctx.Tr("cloudBrainOnePeriodCount_get_error"))
		return
	}
	cloudBrainTwoPeriodCount, err := models.GetCloudBrainTwoPeriodCount(beginTime, endTime)
	if err != nil {
		log.Error("Can not query cloudBrainTwoPeriodCount.", err)
		ctx.Error(http.StatusBadRequest, ctx.Tr("cloudBrainTwoPeriodCount_get_error"))
		return
	}

	cloudbrainsPeriodData := CloudbrainsPeriodData{
		DebugOnePeriodCount:      debugOnePeriodCount,
		BenchmarkOnePeriodCount:  benchmarkOnePeriodCount,
		TrainOnePeriodCount:      trainOnePeriodCount,
		DebugTwoPeriodCount:      debugTwoPeriodCount,
		TrainTwoPeriodCount:      trainTwoPeriodCount,
		InferenceTwoPeriodCount:  inferenceTwoPeriodCount,
		CloudBrainOnePeriodCount: cloudBrainOnePeriodCount,
		CloudBrainTwoPeriodCount: cloudBrainTwoPeriodCount,
	}

	ctx.JSON(http.StatusOK, cloudbrainsPeriodData)
}

func GetCloudbrainsStatusAnalysis(ctx *context.Context) {
	jobWaitingCount, err := models.GetJobWaitingCount()
	if err != nil {
		log.Error("Can not query jobWaitingCount.", err)
		return
	}
	jobRunningCount, err := models.GetJobRunningCount()
	if err != nil {
		log.Error("Can not query jobRunningCount.", err)
		return
	}
	jobStoppedCount, err := models.GetJobStoppedCount()
	if err != nil {
		log.Error("Can not query jobStoppedCount.", err)
		return
	}
	jobSucceededCount, err := models.GetJobSucceededCount()
	if err != nil {
		log.Error("Can not query jobSucceededCount.", err)
		return
	}
	jobFailedCount, err := models.GetJobFailedCount()
	if err != nil {
		log.Error("Can not query jobFailedCount.", err)
		return
	}

	cloudbrainsStatusAnalysis := CloudbrainsStatusAnalysis{
		JobWaitingCount:   jobWaitingCount,
		JobRunningCount:   jobRunningCount,
		JobStoppedCount:   jobStoppedCount,
		JobSucceededCount: jobSucceededCount,
		JobFailedCount:    jobFailedCount,
	}
	ctx.JSON(http.StatusOK, cloudbrainsStatusAnalysis)
}

func GetCloudbrainsDetailData(ctx *context.Context) {

	listType := ctx.Query("listType")
	jobType := ctx.Query("jobType")
	jobStatus := ctx.Query("jobStatus")

	page := ctx.QueryInt("page")
	if page <= 0 {
		page = 1
	}
	debugType := models.TypeCloudBrainAll
	if listType == models.GPUResource {
		debugType = models.TypeCloudBrainOne
	} else if listType == models.NPUResource {
		debugType = models.TypeCloudBrainTwo
	}

	var jobTypes []string
	jobTypeNot := false
	if jobType == string(models.JobTypeDebug) {
		jobTypes = append(jobTypes, string(models.JobTypeSnn4imagenet), string(models.JobTypeBrainScore), string(models.JobTypeDebug))
	} else if jobType != "all" && jobType != "" {
		jobTypes = append(jobTypes, jobType)
	}

	var jobStatuses []string
	jobStatusNot := false
	if jobStatus == "other" {
		jobStatusNot = true
		jobStatuses = append(jobStatuses, string(models.ModelArtsTrainJobWaiting), string(models.ModelArtsTrainJobFailed), string(models.ModelArtsRunning), string(models.ModelArtsTrainJobCompleted),
			string(models.ModelArtsStarting), string(models.ModelArtsRestarting), string(models.ModelArtsStartFailed),
			string(models.ModelArtsStopping), string(models.ModelArtsStopped), string(models.JobSucceeded))
	} else if jobStatus != "all" && jobStatus != "" {
		jobStatuses = append(jobStatuses, jobStatus)
	}

	keyword := strings.Trim(ctx.Query("q"), " ")

	ciTasks, count, err := models.Cloudbrains(&models.CloudbrainsOptions{
		ListOptions: models.ListOptions{
			Page:     page,
			PageSize: setting.UI.IssuePagingNum,
		},
		Keyword:         keyword,
		Type:            debugType,
		JobTypeNot:      jobTypeNot,
		JobStatusNot:    jobStatusNot,
		JobStatus:       jobStatuses,
		JobTypes:        jobTypes,
		NeedRepoInfo:    true,
		IsLatestVersion: modelarts.IsLatestVersion,
	})
	if err != nil {
		ctx.ServerError("Get job failed:", err)
		return
	}

	for i, task := range ciTasks {
		ciTasks[i].CanDebug = true
		ciTasks[i].CanDel = true
		ciTasks[i].Cloudbrain.ComputeResource = task.ComputeResource
	}

	pager := context.NewPagination(int(count), setting.UI.IssuePagingNum, page, getTotalPage(count, setting.UI.IssuePagingNum))
	pager.SetDefaultParams(ctx)
	pager.AddParam(ctx, "listType", "ListType")

	ctx.JSON(http.StatusOK, map[string]interface{}{
		"Title":     ctx.Tr("kanban.cloudBrains"),
		"Tasks":     ciTasks,
		"CanCreate": true,
		"Keyword":   keyword,
	})
}

func GetCloudbrainsCreateHoursData(ctx *context.Context) {
	createHourPeriodCount := make(map[string]interface{})
	brainRecordBeginTime, err := getBrainRecordBeginTime()
	if err != nil {
		log.Error("Can not get brain record begin time", err)
		ctx.Error(http.StatusBadRequest, ctx.Tr("repo.brain_record_begintime_get_err"))
		return
	}
	queryType := ctx.QueryTrim("type")
	beginTimeStr := ctx.QueryTrim("beginTime")
	endTimeStr := ctx.QueryTrim("endTime")
	now := time.Now()
	var beginTime time.Time
	var endTime time.Time
	if queryType != "" {
		if queryType == "all" {
			beginTime = brainRecordBeginTime
			endTime = now
		} else if queryType == "yesterday" {
			beginTime = now.AddDate(0, 0, -1)
			endTime = time.Date(now.Year(), now.Month(), now.Day(), 0, 0, 0, 0, now.Location())
		} else if queryType == "current_week" {
			beginTime = now.AddDate(0, 0, -int(time.Now().Weekday())+1) //begin from monday
			endTime = now
		} else if queryType == "current_month" {
			endTime = now
			beginTime = time.Date(endTime.Year(), endTime.Month(), 1, 0, 0, 0, 0, now.Location())
		} 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())
		} else if queryType == "current_year" {
			endTime = now
			beginTime = time.Date(endTime.Year(), 1, 1, 0, 0, 0, 0, now.Location())
		} 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())
		}
	} else {
		if beginTimeStr == "" || endTimeStr == "" {
			//如果查询类型和开始时间结束时间都未设置，按queryType=all处理
			beginTime = brainRecordBeginTime
			endTime = now
		} 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
			}
		}
	}
	dateBeginTime := beginTime.Format("2006-01-02")
	dateEndTime := endTime.Format("2006-01-02")
	createHourPeriodCount, err = models.GetCreateHourPeriodCount(dateBeginTime, dateEndTime)
	if err != nil {
		log.Error("Can not query hourPeriodCount.", err)
		ctx.Error(http.StatusBadRequest, ctx.Tr("hourPeriodCount_get_error"))
		return
	}
	ctx.JSON(http.StatusOK, map[string]interface{}{
		"createHourPeriodCount": createHourPeriodCount,
	})

}
func GetCloudbrainsRunHoursData(ctx *context.Context) {
	runHourPeriodCount := make(map[string]interface{})
	brainRecordBeginTime, err := getBrainRecordBeginTime()
	if err != nil {
		log.Error("Can not get brain record begin time", err)
		ctx.Error(http.StatusBadRequest, ctx.Tr("repo.brain_record_begintime_get_err"))
		return
	}
	queryType := ctx.QueryTrim("type")
	beginTimeStr := ctx.QueryTrim("beginTime")
	endTimeStr := ctx.QueryTrim("endTime")
	now := time.Now()
	var beginTime time.Time
	var endTime time.Time
	if queryType != "" {
		if queryType == "all" {
			beginTime = brainRecordBeginTime
			endTime = now
		} else if queryType == "yesterday" {
			beginTime = now.AddDate(0, 0, -1)
			endTime = time.Date(now.Year(), now.Month(), now.Day(), 0, 0, 0, 0, now.Location())
		} else if queryType == "current_week" {
			beginTime = now.AddDate(0, 0, -int(time.Now().Weekday())+1) //begin from monday
			endTime = now
		} else if queryType == "current_month" {
			endTime = now
			beginTime = time.Date(endTime.Year(), endTime.Month(), 1, 0, 0, 0, 0, now.Location())
		} 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())
		} else if queryType == "current_year" {
			endTime = now
			beginTime = time.Date(endTime.Year(), 1, 1, 0, 0, 0, 0, now.Location())
		} 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())
		}
	} else {
		if beginTimeStr == "" || endTimeStr == "" {
			//如果查询类型和开始时间结束时间都未设置，按queryType=all处理
			beginTime = brainRecordBeginTime
			endTime = now
		} 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
			}
		}
	}
	dateBeginTime := beginTime.Format("2006-01-02")
	dateEndTime := endTime.Format("2006-01-02")
	runHourPeriodCount, err = models.GetRunHourPeriodCount(dateBeginTime, dateEndTime)
	if err != nil {
		log.Error("Can not query runHourPeriodCount.", err)
		ctx.Error(http.StatusBadRequest, ctx.Tr("runHourPeriodCount_get_error"))
		return
	}
	ctx.JSON(http.StatusOK, map[string]interface{}{
		"runHourPeriodCount": runHourPeriodCount,
	})

}

func getCloudbrainCount(beginTime time.Time, endTime time.Time) (int64, int64, int64, int64, int64, int64, int64, int64, int64, error) {
	debugOneCount, err := models.GetDebugOnePeriodCount(beginTime, endTime)
	if err != nil {
		log.Error("Can not query debugOneCount.", err)
		return 0, 0, 0, 0, 0, 0, 0, 0, 0, err
	}
	benchmarkOneCount, err := models.GetBenchmarkOnePeriodCount(beginTime, endTime)
	if err != nil {
		log.Error("Can not query benchmarkCount.", err)
		return 0, 0, 0, 0, 0, 0, 0, 0, 0, err
	}
	trainOneCount, err := models.GetTrainOnePeriodCount(beginTime, endTime)
	if err != nil {
		log.Error("Can not query trainOneCount.", err)
		return 0, 0, 0, 0, 0, 0, 0, 0, 0, err
	}
	debugTwoCount, err := models.GetDebugTwoPeriodCount(beginTime, endTime)
	if err != nil {
		log.Error("Can not query debugTwoCount.", err)
		return 0, 0, 0, 0, 0, 0, 0, 0, 0, err
	}
	trainTwoCount, err := models.GetTrainTwoPeriodCount(beginTime, endTime)
	if err != nil {
		log.Error("Can not query DebugOneTotal count.", err)
		return 0, 0, 0, 0, 0, 0, 0, 0, 0, err
	}
	inferenceTwoCount, err := models.GetInferenceTwoPeriodCount(beginTime, endTime)
	if err != nil {
		log.Error("Can not query inferenceTwoCount.", err)
		return 0, 0, 0, 0, 0, 0, 0, 0, 0, err
	}
	cloudbrainOneCount, err := models.GetCloudBrainOnePeriodCount(beginTime, endTime)
	if err != nil {
		log.Error("Can not query cloudbrainOneCount.", err)
		return 0, 0, 0, 0, 0, 0, 0, 0, 0, err
	}
	cloudbrainTwoCount, err := models.GetCloudBrainTwoPeriodCount(beginTime, endTime)
	if err != nil {
		log.Error("Can not query cloudbrainOneCount.", err)
		return 0, 0, 0, 0, 0, 0, 0, 0, 0, err
	}
	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 DownloadCloudBrainBoard(ctx *context.Context) {

	page := 1

	pageSize := 300

	var cloudBrain = ctx.Tr("repo.cloudbrain")
	fileName := getCloudbrainFileName(cloudBrain)

	_, total, err := models.CloudbrainAll(&models.CloudbrainsOptions{
		ListOptions: models.ListOptions{
			Page:     page,
			PageSize: pageSize,
		},
		Type:         models.TypeCloudBrainAll,
		NeedRepoInfo: false,
	})

	if err != nil {
		log.Warn("Can not get cloud brain info", err)
		ctx.Error(http.StatusBadRequest, ctx.Tr("repo.cloudbrain_query_fail"))
		return
	}

	totalPage := getTotalPage(total, pageSize)
	fmt.Printf("total:%v", total)
	fmt.Printf("totalPage:%v", totalPage)

	f := excelize.NewFile()

	index := f.NewSheet(cloudBrain)
	f.DeleteSheet("Sheet1")

	for k, v := range allCloudbrainHeader(ctx) {
		f.SetCellValue(cloudBrain, k, v)
	}

	var row = 2
	for i := 0; i < totalPage; i++ {

		pageRecords, _, err := models.CloudbrainAll(&models.CloudbrainsOptions{
			ListOptions: models.ListOptions{
				Page:     page,
				PageSize: pageSize,
			},
			Type:         models.TypeCloudBrainAll,
			NeedRepoInfo: true,
		})
		if err != nil {
			log.Warn("Can not get cloud brain info", err)
			continue
		}
		for _, record := range pageRecords {

			for k, v := range allCloudbrainValues(row, record, ctx) {
				f.SetCellValue(cloudBrain, k, v)
			}
			row++

		}

		page++
	}
	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 getCloudbrainFileName(baseName string) string {
	return baseName + "_" + time.Now().Format(EXCEL_DATE_FORMAT) + ".xlsx"

}
func allCloudbrainHeader(ctx *context.Context) map[string]string {

	return map[string]string{"A1": ctx.Tr("repo.cloudbrain_task"), "B1": ctx.Tr("repo.cloudbrain_task_type"), "C1": ctx.Tr("repo.modelarts.status"),
		"D1": ctx.Tr("repo.modelarts.createtime"), "E1": ctx.Tr("repo.modelarts.train_job.wait_time"), "F1": ctx.Tr("repo.modelarts.train_job.dura_time"),
		"G1": ctx.Tr("repo.modelarts.train_job.start_time"),
		"H1": ctx.Tr("repo.modelarts.train_job.end_time"), "I1": ctx.Tr("repo.modelarts.computing_resources"),
		"J1": ctx.Tr("repo.cloudbrain_creator"), "K1": ctx.Tr("repo.repo_name"), "L1": ctx.Tr("repo.cloudbrain_task_name")}

}
func allCloudbrainValues(row int, rs *models.CloudbrainInfo, ctx *context.Context) map[string]string {
	return map[string]string{getCellName("A", row): rs.DisplayJobName, getCellName("B", row): rs.JobType, getCellName("C", row): rs.Status,
		getCellName("D", row): time.Unix(int64(rs.Cloudbrain.CreatedUnix), 0).Format(CREATE_TIME_FORMAT), getCellName("E", row): getBrainWaitTime(rs),
		getCellName("F", row): rs.TrainJobDuration, getCellName("G", row): getBrainStartTime(rs),
		getCellName("H", row): getBrainEndTime(rs),
		getCellName("I", row): rs.ComputeResource, getCellName("J", row): rs.Name, getCellName("K", row): getBrainRepo(rs),
		getCellName("L", row): rs.JobName,
	}
}
func getBrainRepo(rs *models.CloudbrainInfo) string {
	if rs.Repo != nil {
		return rs.Repo.OwnerName + "/" + rs.Repo.Alias
	}
	return ""
}
func getBrainStartTime(rs *models.CloudbrainInfo) string {
	timeString := time.Unix(int64(rs.Cloudbrain.StartTime), 0).Format(CREATE_TIME_FORMAT)
	if timeString != "1970/01/01 08:00:00" {
		return timeString
	} else {
		return "0"
	}

}
func getBrainEndTime(rs *models.CloudbrainInfo) string {
	timeString := time.Unix(int64(rs.Cloudbrain.EndTime), 0).Format(CREATE_TIME_FORMAT)
	if timeString != "1970/01/01 08:00:00" {
		return timeString
	} else {
		return "0"
	}

}
func getBrainWaitTime(rs *models.CloudbrainInfo) string {
	waitTime := rs.Cloudbrain.StartTime - rs.Cloudbrain.CreatedUnix
	if waitTime <= 0 {
		return "0"
	} else {
		return models.ConvertDurationToStr(int64(waitTime))
	}
}