fix-3578

models/cloudbrain.go

@@ -463,32 +463,33 @@ type GetImagesPayload struct {
 
 type CloudbrainsOptions struct {
 	ListOptions
-	RepoID           int64 // include all repos if empty
-	UserID           int64
-	JobID            string
-	SortType         string
-	CloudbrainIDs    []int64
-	JobStatus        []string
-	JobStatusNot     bool
-	Keyword          string
-	Type             int
-	JobTypes         []string
-	VersionName      string
-	IsLatestVersion  string
-	JobTypeNot       bool
-	NeedRepoInfo     bool
-	RepoIDList       []int64
-	BeginTime        time.Time
-	EndTime          time.Time
-	ComputeResource  string
-	BeginTimeUnix    int64
-	EndTimeUnix      int64
-	AiCenter         string
-	NeedDeleteInfo   string
-	Cluster          string
-	AccCardType      string
-	AccCardsNum      int
-	WorkServerNumber int
+	RepoID            int64 // include all repos if empty
+	UserID            int64
+	JobID             string
+	SortType          string
+	CloudbrainIDs     []int64
+	JobStatus         []string
+	JobStatusNot      bool
+	Keyword           string
+	Type              int
+	JobTypes          []string
+	VersionName       string
+	IsLatestVersion   string
+	JobTypeNot        bool
+	NeedRepoInfo      bool
+	RepoIDList        []int64
+	BeginTime         time.Time
+	EndTime           time.Time
+	ComputeResource   string
+	BeginTimeUnix     int64
+	EndTimeUnix       int64
+	DateBeginTimeUnix int64
+	AiCenter          string
+	NeedDeleteInfo    string
+	Cluster           string
+	AccCardType       string
+	AccCardsNum       int
+	WorkServerNumber  int
 }
 
 type TaskPod struct {
@@ -2545,6 +2546,12 @@ func CloudbrainAllStatic(opts *CloudbrainsOptions) ([]*CloudbrainInfo, int64, er
 			builder.And(builder.Gte{"cloudbrain.created_unix": opts.BeginTimeUnix}, builder.Lte{"cloudbrain.created_unix": opts.EndTimeUnix}),
 		)
 	}
+	if opts.DateBeginTimeUnix > 0 {
+		cond = cond.And(builder.Or(
+			builder.Gte{"cloudbrain.end_time": opts.DateBeginTimeUnix},
+			builder.IsNull{"cloudbrain.end_time"},
+		))
+	}
 	var count int64
 	var err error
 	count, err = sess.Unscoped().Where(cond).Count(new(Cloudbrain))

models/cloudbrain_static.go

@@ -235,7 +235,7 @@ func GetRunningTop() ([]*CloudbrainInfo, error) {
 }
 
 func getCreatePeriodCount(dateBeginTime string, dateEndTime string, hourBeginTime string, hourEndTime string) (int64, error) {
-	countSql := "SELECT count(*) FROM  " +
+	countSql := "SET TIME ZONE 'PRC'; SELECT count(*) FROM  " +
 		"public.cloudbrain where to_char(to_timestamp(created_unix), 'YYYY-MM-DD') >= '" + dateBeginTime +
 		"' and to_char(to_timestamp(created_unix), 'YYYY-MM-DD') < '" + dateEndTime +
 		"' and to_char(to_timestamp(created_unix), 'HH24:MI:SS') >= '" + hourBeginTime +
@@ -243,15 +243,18 @@ func getCreatePeriodCount(dateBeginTime string, dateEndTime string, hourBeginTim
 	return x.SQL(countSql).Count()
 }
 
-//SELECT * FROM xxx WHERE NOT ((endTime < hourBeginTime) OR (startTime > hourEndTime))
 func getRunPeriodCount(dateBeginTime string, dateEndTime string, hourBeginTime string, hourEndTime string) (int64, error) {
-	countSql := "SELECT count(*) FROM  " +
-		"public.cloudbrain where not ((to_char(to_timestamp(start_time), ' HH24:MI:SS') > '" + hourEndTime +
-		"') or (to_char(to_timestamp(end_time), 'HH24:MI:SS') < '" + hourBeginTime + "'))" +
-		" and (to_char(to_timestamp(start_time), 'YYYY-MM-DD') >= '" + dateBeginTime +
-		"' and to_char(to_timestamp(start_time), 'YYYY-MM-DD') < '" + dateEndTime + "')"
+	countSql := "SET TIME ZONE 'PRC'; SELECT count(*) FROM  " +
+		"public.cloudbrain where ((to_char(to_timestamp(start_time), ' HH24:MI:SS') < '" + hourEndTime +
+		"') and (to_char(to_timestamp(CASE WHEN start_time is not null AND end_time isnull  THEN COALESCE(end_time,EXTRACT(epoch FROM now())) ELSE end_time END), 'HH24:MI:SS') >= '" + hourBeginTime + "'))" +
+		" and (to_char(to_timestamp(start_time), 'YYYY-MM-DD') < '" + dateEndTime +
+		"' and to_char(to_timestamp(end_time), 'YYYY-MM-DD') >= '" + dateBeginTime + "')"
 	return x.SQL(countSql).Count()
+}
 
+func getRunPeriodCountTest(hourBeginTime string, hourEndTime string) (int64, error) {
+	countSql := " SELECT count(*) FROM " + "public.cloudbrain where start_time <" + hourEndTime + " and end_time >= " + hourBeginTime
+	return x.SQL(countSql).Count()
 }
 
 func GetCreateHourPeriodCount(dateBeginTime string, dateEndTime string) (map[string]interface{}, error) {
@@ -271,8 +274,8 @@ func GetCreateHourPeriodCount(dateBeginTime string, dateEndTime string) (map[str
 	return dateHourMap, nil
 }
 
-func GetRunHourPeriodCount(dateBeginTime string, dateEndTime string) (map[string]interface{}, error) {
-	dateHourMap := make(map[string]interface{})
+func GetRunHourPeriodCount(dateBeginTime string, dateEndTime string) (map[string]int64, error) {
+	dateHourMap := make(map[string]int64)
 	var slice = []int64{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23}
 	for key, value := range slice {
 		hourBeginHour := util.AddZero(value) + ":00:00"
@@ -287,6 +290,21 @@ func GetRunHourPeriodCount(dateBeginTime string, dateEndTime string) (map[string
 	return dateHourMap, nil
 }
 
+func GetRunHourPeriodCountTest(cloudbrain Cloudbrain, dateBeginTime time.Time, dateEndTime time.Time) (map[string]int64, error) {
+	var runHourPeriodCount = make(map[string]int64)
+	if dateBeginTime.Before(dateEndTime) {
+		var slice = []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23}
+		for _, hour := range slice {
+			hourBeginTime := dateBeginTime
+			hourEndTime := dateBeginTime.Unix() + int64(3600*(hour+1))
+			if cloudbrain.StartTime.AsTime().Unix() < hourEndTime && cloudbrain.EndTime.AsTime().Unix() > hourBeginTime.Unix() {
+				runHourPeriodCount[strconv.Itoa(hour)] = runHourPeriodCount[strconv.Itoa(hour)] + 1
+			}
+		}
+	}
+	return runHourPeriodCount, nil
+}
+
 func GetCloudbrainRunning() ([]*CloudbrainInfo, error) {
 	sess := x.NewSession()
 	defer sess.Close()

routers/api/v1/repo/cloudbrain_dashboard.go

@@ -872,11 +872,13 @@ func GetCloudbrainsCreateHoursData(ctx *context.Context) {
 	if queryType != "" {
 		if queryType == "all" {
 			beginTime = recordBeginTime
+			beginTime = time.Date(beginTime.Year(), beginTime.Month(), beginTime.Day(), 0, 0, 0, 0, now.Location())
 			endTime = now.AddDate(0, 0, 1)
 			endTime = time.Date(endTime.Year(), endTime.Month(), endTime.Day(), 0, 0, 0, 0, now.Location())
 		} else if queryType == "today" {
 			beginTime = time.Date(now.Year(), now.Month(), now.Day(), 0, 0, 0, 0, now.Location())
 			endTime = now.AddDate(0, 0, 1)
+			endTime = time.Date(endTime.Year(), endTime.Month(), endTime.Day(), 0, 0, 0, 0, now.Location())
 		} 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())
@@ -941,18 +943,73 @@ func GetCloudbrainsCreateHoursData(ctx *context.Context) {
 		ctx.Error(http.StatusBadRequest, ctx.Tr("hourPeriodCount_get_error"))
 		return
 	}
-
-	runHourPeriodCount, err := models.GetRunHourPeriodCount(dateBeginTime, dateEndTime)
+	dataPeriodCount := make(map[string]int64)
+	// days := (endTime.Unix() - beginTime.Unix()) / 3600 / 24
+	// for i := 0; i < int(days); i++ {
+	// 	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
+	// 	}
+	// 	var slice = []string{"0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13", "14", "15", "16", "17", "18", "19", "20", "21", "22", "23"}
+	// 	for _, v := range slice {
+	// 		dataPeriodCount[v] = dataPeriodCount[v] + runHourPeriodCount[v]
+	// 	}
+	// 	beginTime = endTime
+	// 	endTime = endTime.AddDate(0, 0, 1)
+	// 	dateBeginTime = beginTime.Format("2006-01-02")
+	// 	dateEndTime = endTime.Format("2006-01-02")
+	// }
+
+	// var runHourPeriodCount map[string]int64
+	page := 1
+	pagesize := 1000
+	// count := pagesize
+	cloudbrains, _, err := models.CloudbrainAllStatic(&models.CloudbrainsOptions{
+		ListOptions: models.ListOptions{
+			Page:     page,
+			PageSize: pagesize,
+		},
+		Type:              models.TypeCloudBrainAll,
+		DateBeginTimeUnix: beginTime.Unix(),
+	})
+	log.Info("len(cloudbrains):", len(cloudbrains))
 	if err != nil {
-		log.Error("Can not query runHourPeriodCount.", err)
-		ctx.Error(http.StatusBadRequest, ctx.Tr("runHourPeriodCount_get_error"))
+		log.Error("Can not query cloudbrain.", err)
+		ctx.Error(http.StatusBadRequest, ctx.Tr("cloudbrain_get_error"))
 		return
 	}
+	for _, cloudbrain := range cloudbrains {
+		if cloudbrain.StartTime != 0 && cloudbrain.EndTime == 0 {
+			cloudbrain.EndTime = timeutil.TimeStamp(time.Now().Unix())
+		}
+
+		days := (endTime.Unix() - beginTime.Unix()) / 3600 / 24
+		beginTime = endTime.AddDate(0, 0, -1)
+		endTime = endTime
+		for i := 0; i < int(days); i++ {
+			runHourPeriodCount, err := models.GetRunHourPeriodCountTest(cloudbrain.Cloudbrain, beginTime, endTime)
+			if err != nil {
+				log.Error("Can not query runHourPeriodCount.", err)
+				ctx.Error(http.StatusBadRequest, ctx.Tr("runHourPeriodCount_get_error"))
+				return
+			}
+			log.Info("runHourPeriodCount:", runHourPeriodCount)
+			var slice = []string{"0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13", "14", "15", "16", "17", "18", "19", "20", "21", "22", "23"}
+			for _, v := range slice {
+				dataPeriodCount[v] = dataPeriodCount[v] + runHourPeriodCount[v]
+			}
+			endTime = beginTime
+			beginTime = beginTime.AddDate(0, 0, -1)
+		}
+	}
+
 	ctx.JSON(http.StatusOK, map[string]interface{}{
 		"recordBeginTime":       recordCloudbrain[0].Cloudbrain.CreatedUnix,
 		"updateTime":            now.Unix(),
 		"createHourPeriodCount": createHourPeriodCount,
-		"runHourPeriodCount":    runHourPeriodCount,
+		"runHourPeriodCount":    dataPeriodCount,
 	})
 
 }