update

models/cloudbrain_static.go

@@ -38,6 +38,16 @@ type TaskDetail struct {
 	WorkServerNum   int64              `json:"WorkServerNum"`
 	Spec            *Specification     `json:"Spec"`
 }
+type CardTypeAndNum struct {
+	CardType        string `json:"CardType"`
+	Num             int    `json:"Num"`
+	ComputeResource string `json:"computeResource"`
+}
+type ResourceOverview struct {
+	Cluster        string           `json:"cluster"`
+	AiCenterCode   string           `json:"aiCenterCode"`
+	CardTypeAndNum []CardTypeAndNum `json:"cardTypeAndNum"`
+}
 
 type CloudbrainDurationStatistic struct {
 	ID              int64 `xorm:"pk autoincr"`
@@ -69,17 +79,24 @@ type DurationRateStatistic struct {
 	AiCenterUsageDurationStat map[string]int `json:"aiCenterUsageDurationStat"`
 	TotalUsageRate            float64        `json:"totalUsageRate"`
 }
-type DateCloudbrainStatistic struct {
-	Date                  string             `json:"date"`
-	AiCenterUsageDuration map[string]int     `json:"aiCenterUsageDuration"`
-	AiCenterTotalDuration map[string]int     `json:"aiCenterTotalDuration"`
-	AiCenterUsageRate     map[string]float64 `json:"aiCenterUsageRate"`
+
+// type DateCloudbrainStatistic struct {
+// 	Date                  string             `json:"date"`
+// 	AiCenterUsageDuration map[string]int     `json:"aiCenterUsageDuration"`
+// 	AiCenterTotalDuration map[string]int     `json:"aiCenterTotalDuration"`
+// 	AiCenterUsageRate     map[string]float64 `json:"aiCenterUsageRate"`
+// }
+type DateUsageStatistic struct {
+	Date          string  `json:"date"`
+	UsageDuration int     `json:"usageDuration"`
+	TotalDuration int     `json:"totalDuration"`
+	UsageRate     float64 `json:"usageRate"`
 }
 
 type HourTimeStatistic struct {
-	HourTimeUsageDuration map[int]int     `json:"hourTimeUsageDuration"`
-	HourTimeTotalDuration map[int]int     `json:"hourTimeTotalDuration"`
-	HourTimeUsageRate     map[int]float64 `json:"hourTimeUsageRate"`
+	HourTimeUsageDuration map[string]int     `json:"hourTimeUsageDuration"`
+	HourTimeTotalDuration map[string]int     `json:"hourTimeTotalDuration"`
+	HourTimeUsageRate     map[string]float64 `json:"hourTimeUsageRate"`
 }
 
 func GetTodayCreatorCount(beginTime time.Time, endTime time.Time) (int64, error) {

routers/api/v1/api.go

@@ -601,8 +601,9 @@ func RegisterRoutes(m *macaron.Macaron) {
 				m.Get("/running_top_data", repo.GetRunningTop)
 
 				m.Get("/overview_resource", repo.GetCloudbrainResourceOverview)
-				m.Get("/resource_usage", repo.GetCloudbrainResourceUsage)
-				m.Get("/resource_usage_detail", repo.GetCloudbrainResourceUsageDetail)
+				m.Get("/resource_usage_statistic", repo.GetDurationRateStatistic)
+				m.Get("/resource_usage_rate", repo.GetCloudbrainResourceUsage)
+				m.Get("/resource_usage_rate_detail", repo.GetCloudbrainResourceUsageDetail)
 			})
 		}, operationReq)
 

routers/api/v1/repo/cloudbrain_dashboard.go

@@ -4,6 +4,7 @@ import (
 	"fmt"
 	"net/http"
 	"net/url"
+	"strconv"
 	"strings"
 	"time"
 
@@ -532,17 +533,17 @@ func getPageDateCloudbrainInfo(dateCloudbrainInfo []DateCloudbrainInfo, page int
 
 }
 
-func getPageDateCloudbrainDuration(dateCloudbrainDuration []models.DateCloudbrainStatistic, page int, pagesize int) []models.DateCloudbrainStatistic {
+func getPageDateCloudbrainDuration(dateUsageStatistic []models.DateUsageStatistic, page int, pagesize int) []models.DateUsageStatistic {
 	begin := (page - 1) * pagesize
 	end := (page) * pagesize
 
-	if begin > len(dateCloudbrainDuration)-1 {
+	if begin > len(dateUsageStatistic)-1 {
 		return nil
 	}
-	if end > len(dateCloudbrainDuration)-1 {
-		return dateCloudbrainDuration[begin:]
+	if end > len(dateUsageStatistic)-1 {
+		return dateUsageStatistic[begin:]
 	} else {
-		return dateCloudbrainDuration[begin:end]
+		return dateUsageStatistic[begin:end]
 	}
 
 }
@@ -1425,9 +1426,53 @@ func GetCloudbrainResourceOverview(ctx *context.Context) {
 		log.Info("GetCanUseCardInfo err: %v", err)
 		return
 	}
+	// ResourceAiCenterRes, err := models.GetResourceAiCenters()
+	// if err != nil {
+	// 	log.Error("Can not get ResourceAiCenterRes.", err)
+	// 	return
+	// }
+	resourceOverviews := []models.ResourceOverview{}
+	resourceOpenIOne := models.ResourceOverview{}
+	resourceOpenITwo := models.ResourceOverview{}
+	// resourceChengdu := models.ResourceOverview{}
+
+	for _, resourceQueue := range resourceQueues {
+		if resourceQueue.Cluster == models.OpenICluster {
+			if resourceQueue.AiCenterCode == models.AICenterOfCloudBrainOne {
+				resourceOpenIOne.Cluster = models.OpenICluster
+				resourceOpenIOne.AiCenterCode = models.AICenterOfCloudBrainOne
+				cardTypeNum := models.CardTypeAndNum{}
+				cardTypeNum.CardType = resourceQueue.AccCardType
+				cardTypeNum.Num = resourceQueue.CardsTotalNum
+				cardTypeNum.ComputeResource = resourceQueue.ComputeResource
+				resourceOpenIOne.CardTypeAndNum = append(resourceOpenIOne.CardTypeAndNum, cardTypeNum)
+			}
+			if resourceQueue.AiCenterCode == models.AICenterOfCloudBrainTwo {
+				resourceOpenITwo.Cluster = models.OpenICluster
+				resourceOpenITwo.AiCenterCode = models.AICenterOfCloudBrainTwo
+				cardTypeNum := models.CardTypeAndNum{}
+				cardTypeNum.CardType = resourceQueue.AccCardType
+				cardTypeNum.Num = resourceQueue.CardsTotalNum
+				cardTypeNum.ComputeResource = resourceQueue.ComputeResource
+				resourceOpenITwo.CardTypeAndNum = append(resourceOpenITwo.CardTypeAndNum, cardTypeNum)
+			}
+			// if resourceQueue.AiCenterCode == models.AICenterOfChengdu {
+			// 	resourceChengdu.Cluster = models.OpenICluster
+			// 	resourceChengdu.AiCenterCode = models.AICenterOfChengdu
+			// 	cardTypeNum := models.CardTypeAndNum{}
+			// 	cardTypeNum.CardType = resourceQueue.AccCardType
+			// 	cardTypeNum.Num = resourceQueue.CardsTotalNum
+			// 	cardTypeNum.ComputeResource = resourceQueue.ComputeResource
+			// 	resourceChengdu.CardTypeAndNum = append(resourceChengdu.CardTypeAndNum, cardTypeNum)
+			// }
+		}
+	}
+	resourceOverviews = append(resourceOverviews, resourceOpenIOne)
+	resourceOverviews = append(resourceOverviews, resourceOpenITwo)
+	// resourceOverviews = append(resourceOverviews, resourceChengdu)
 
 	ctx.JSON(http.StatusOK, map[string]interface{}{
-		"resourceQueues": resourceQueues,
+		"resourceOverviews": resourceOverviews,
 	})
 
 }
@@ -1485,119 +1530,96 @@ func GetCloudbrainResourceUsage(ctx *context.Context) {
 }
 
 func GetCloudbrainResourceUsageDetail(ctx *context.Context) {
+	aiCenterCode := ctx.QueryTrim("aiCenterCode")
+	log.Info("aiCenterCode: %v", aiCenterCode)
+	if aiCenterCode == "" {
+		aiCenterCode = "OpenIOne"
+	}
+	beginTime, endTime := getBeginAndEndTime(ctx)
+	dayCloudbrainDuration, count, err := getDayCloudbrainDuration(beginTime, endTime, aiCenterCode)
+	if err != nil {
+		log.Error("Can not query dayCloudbrainDuration.", err)
+		return
+	}
+	hourCloudbrainDuration, err := getHourCloudbrainDuration(beginTime, endTime, aiCenterCode)
+	if err != nil {
+		log.Error("Can not query hourCloudbrainDuration.", err)
+		return
+	}
+	page := ctx.QueryInt("page")
+	if page <= 0 {
+		page = 1
+	}
+	pagesize := ctx.QueryInt("pagesize")
+	if pagesize <= 0 {
+		pagesize = 36500
+	}
+	pageDateCloudbrainDuration := getPageDateCloudbrainDuration(dayCloudbrainDuration, page, pagesize)
+	ctx.JSON(http.StatusOK, map[string]interface{}{
+		"totalCount":                 count,
+		"pageDateCloudbrainDuration": pageDateCloudbrainDuration,
+		"hourCloudbrainDuration":     hourCloudbrainDuration,
+	})
+}
+
+func GetDurationRateStatistic(ctx *context.Context) {
+	beginTime, endTime := getBeginAndEndTime(ctx)
+	durationRateStatistic := getDurationStatistic(beginTime, endTime)
+
+	ctx.JSON(http.StatusOK, map[string]interface{}{
+		"durationRateStatistic": durationRateStatistic,
+	})
+
+}
+
+func getBeginAndEndTime(ctx *context.Context) (time.Time, time.Time) {
 	queryType := ctx.QueryTrim("type")
 	now := time.Now()
 	beginTimeStr := ctx.QueryTrim("beginTime")
 	endTimeStr := ctx.QueryTrim("endTime")
-	aiCenterCode := ctx.QueryTrim("aiCenterCode")
 
 	var beginTime time.Time
 	var endTime time.Time
-	var endTimeTemp time.Time
-	dayCloudbrainDuration := make([]models.DateCloudbrainStatistic, 0)
-	hourCloudbrainDuration := models.HourTimeStatistic{}
 	var err error
-	var count int
 	if queryType != "" {
 		if queryType == "all" {
 			recordCloudbrainDuration, err := models.GetDurationRecordBeginTime()
 			if err != nil {
 				log.Error("Can not get GetDurationRecordBeginTime", err)
 				ctx.Error(http.StatusBadRequest, ctx.Tr("repo.record_begintime_get_err"))
-				return
+				return beginTime, endTime
 			}
 			brainRecordBeginTime := recordCloudbrainDuration[0].CreatedUnix.AsTime()
-			log.Info("recordCloudbrainDuration:", recordCloudbrainDuration)
-			log.Info("brainRecordBeginTime:", brainRecordBeginTime)
 			beginTime = brainRecordBeginTime
 			endTime = now
-			dayCloudbrainDuration, count, err = getDayCloudbrainDuration(beginTime, endTime)
-			if err != nil {
-				log.Error("Can not query dayCloudbrainDuration.", err)
-				ctx.Error(http.StatusBadRequest, ctx.Tr("getDayCloudbrainInfo_get_error"))
-				return
-			}
-			hourCloudbrainDuration = getHourCloudbrainDuration(beginTime, endTime, aiCenterCode)
-			if err != nil {
-				log.Error("Can not query hourCloudbrainDuration.", err)
-				ctx.Error(http.StatusBadRequest, ctx.Tr("getDayCloudbrainInfo_get_error"))
-				return
-			}
 		} else if queryType == "today" {
 			beginTime = now.AddDate(0, 0, 0)
 			beginTime = time.Date(beginTime.Year(), beginTime.Month(), beginTime.Day(), 0, 0, 0, 0, now.Location())
 			endTime = now
-			dayCloudbrainDuration, count, err = getDayCloudbrainDuration(beginTime, endTime)
-			if err != nil {
-				log.Error("Can not query dayCloudbrainDuration.", err)
-				ctx.Error(http.StatusBadRequest, ctx.Tr("getDayCloudbrainInfo_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())
 			endTime = time.Date(now.Year(), now.Month(), now.Day(), 0, 0, 0, 0, now.Location())
-			dayCloudbrainDuration, count, err = getDayCloudbrainDuration(beginTime, endTime)
-			if err != nil {
-				log.Error("Can not query dayCloudbrainDuration.", err)
-				ctx.Error(http.StatusBadRequest, ctx.Tr("getDayCloudbrainInfo_get_error"))
-				return
-			}
-
 		} else if queryType == "last_7day" {
 			beginTime = now.AddDate(0, 0, -6)
 			beginTime = time.Date(beginTime.Year(), beginTime.Month(), beginTime.Day(), 0, 0, 0, 0, now.Location())
 			endTime = now
-			endTimeTemp = time.Date(endTimeTemp.Year(), endTimeTemp.Month(), endTimeTemp.Day(), 0, 0, 0, 0, now.Location())
-			dayCloudbrainDuration, count, err = getDayCloudbrainDuration(beginTime, endTime)
-			if err != nil {
-				log.Error("Can not query dayCloudbrainDuration.", err)
-				ctx.Error(http.StatusBadRequest, ctx.Tr("getDayCloudbrainInfo_get_error"))
-				return
-			}
 		} else if queryType == "last_30day" {
 			beginTime = now.AddDate(0, 0, -29)
 			beginTime = time.Date(beginTime.Year(), beginTime.Month(), beginTime.Day(), 0, 0, 0, 0, now.Location())
 			endTime = now
-			dayCloudbrainDuration, count, err = getDayCloudbrainDuration(beginTime, endTime)
-			if err != nil {
-				log.Error("Can not query dayCloudbrainDuration.", err)
-				ctx.Error(http.StatusBadRequest, ctx.Tr("getDayCloudbrainInfo_get_error"))
-				return
-			}
 		} else if queryType == "current_month" {
 			endTime = now
 			beginTime = time.Date(endTime.Year(), endTime.Month(), 1, 0, 0, 0, 0, now.Location())
-			dayCloudbrainDuration, count, err = getDayCloudbrainDuration(beginTime, endTime)
-			if err != nil {
-				log.Error("Can not query dayCloudbrainDuration.", err)
-				ctx.Error(http.StatusBadRequest, ctx.Tr("getDayCloudbrainInfo_get_error"))
-				return
-			}
 
 		} else if queryType == "current_year" {
 			endTime = now
 			beginTime = time.Date(endTime.Year(), 1, 1, 0, 0, 0, 0, now.Location())
-			dayCloudbrainDuration, count, err = getDayCloudbrainDuration(beginTime, endTime)
-			if err != nil {
-				log.Error("Can not query dayCloudbrainDuration.", err)
-				ctx.Error(http.StatusBadRequest, ctx.Tr("getDayCloudbrainInfo_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(), 1, 0, 0, 0, 0, now.Location())
-			dayCloudbrainDuration, count, err = getDayCloudbrainDuration(beginTime, endTime)
-			if err != nil {
-				log.Error("Can not query dayCloudbrainDuration.", err)
-				ctx.Error(http.StatusBadRequest, ctx.Tr("getDayCloudbrainInfo_get_error"))
-				return
-			}
-
 		}
 
 	} else {
@@ -1607,105 +1629,81 @@ func GetCloudbrainResourceUsageDetail(ctx *context.Context) {
 			if err != nil {
 				log.Error("Can not get recordCloudbrain", err)
 				ctx.Error(http.StatusBadRequest, ctx.Tr("repo.record_begintime_get_err"))
-				return
+				return beginTime, endTime
 			}
 			brainRecordBeginTime := recordCloudbrainDuration[0].CreatedUnix.AsTime()
 			beginTime = brainRecordBeginTime
 			endTime = now
-			dayCloudbrainDuration, count, err = getDayCloudbrainDuration(beginTime, endTime)
-			if err != nil {
-				log.Error("Can not query dayCloudbrainDuration.", err)
-				ctx.Error(http.StatusBadRequest, ctx.Tr("getDayCloudbrainInfo_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
+				return beginTime, endTime
 			}
 			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
+				return beginTime, endTime
 			}
 			if endTime.After(time.Now()) {
 				endTime = time.Now()
 			}
-			endTimeTemp = beginTime.AddDate(0, 0, 1)
-			dayCloudbrainDuration, count, err = getDayCloudbrainDuration(beginTime, endTime)
-			if err != nil {
-				log.Error("Can not query dayCloudbrainDuration.", err)
-				ctx.Error(http.StatusBadRequest, ctx.Tr("getDayCloudbrainInfo_get_error"))
-				return
-			}
 		}
 
 	}
-
-	page := ctx.QueryInt("page")
-	if page <= 0 {
-		page = 1
-	}
-	pagesize := ctx.QueryInt("pagesize")
-	if pagesize <= 0 {
-		pagesize = 5
-	}
-	pageDateCloudbrainDuration := getPageDateCloudbrainDuration(dayCloudbrainDuration, page, pagesize)
-	durationRateStatistic := getDurationStatistic(beginTime, endTime)
-
-	ctx.JSON(http.StatusOK, map[string]interface{}{
-		"totalCount":                 count,
-		"pageDateCloudbrainDuration": pageDateCloudbrainDuration,
-		"durationRateStatistic":      durationRateStatistic,
-		"hourCloudbrainDuration":     hourCloudbrainDuration,
-	})
-
+	return beginTime, endTime
 }
 
-func getAiCenterUsageDuration(beginTime time.Time, endTime time.Time, cloudbrainStatistics []*models.CloudbrainDurationStatistic) (map[string]int, map[string]int, map[string]float64) {
-	aiCenterTotalDuration := make(map[string]int)
-	aiCenterUsageDuration := make(map[string]int)
-	aiCenterUsageRate := make(map[string]float64)
+func getAiCenterUsageDuration(beginTime time.Time, endTime time.Time, cloudbrainStatistics []*models.CloudbrainDurationStatistic) (int, int, float64) {
+	totalDuration := int(0)
+	usageDuration := int(0)
+	usageRate := float64(0)
+
 	for _, cloudbrainStatistic := range cloudbrainStatistics {
 		if int64(cloudbrainStatistic.CreatedUnix) >= beginTime.Unix() && int64(cloudbrainStatistic.CreatedUnix) < endTime.Unix() {
 			if cloudbrainStatistic.TotalCanUse {
-				if _, ok := aiCenterTotalDuration[cloudbrainStatistic.AiCenterCode]; !ok {
-					aiCenterTotalDuration[cloudbrainStatistic.AiCenterCode] = cloudbrainStatistic.CardsTotalDuration
-				} else {
-					aiCenterTotalDuration[cloudbrainStatistic.AiCenterCode] += cloudbrainStatistic.CardsTotalDuration
-				}
+				totalDuration += cloudbrainStatistic.CardsTotalDuration
 			} else {
-				if _, ok := aiCenterUsageDuration[cloudbrainStatistic.AiCenterCode]; !ok {
-					aiCenterUsageDuration[cloudbrainStatistic.AiCenterCode] = cloudbrainStatistic.CardsTotalDuration
-				} else {
-					aiCenterUsageDuration[cloudbrainStatistic.AiCenterCode] += cloudbrainStatistic.CardsTotalDuration
-				}
-			}
-		}
-	}
-	ResourceAiCenterRes, err := models.GetResourceAiCenters()
-	if err != nil {
-		log.Error("Can not get ResourceAiCenterRes.", err)
-		return nil, nil, nil
-	}
-	for _, v := range ResourceAiCenterRes {
-		if _, ok := aiCenterUsageDuration[v.AiCenterCode]; !ok {
-			aiCenterUsageDuration[v.AiCenterCode] = 0
+				usageDuration += cloudbrainStatistic.CardsTotalDuration
+			}
+			// if cloudbrainStatistic.TotalCanUse {
+			// 	if _, ok := aiCenterTotalDuration[Date]; !ok {
+			// 		aiCenterTotalDuration[Date] = cloudbrainStatistic.CardsTotalDuration
+			// 	} else {
+			// 		aiCenterTotalDuration[Date] += cloudbrainStatistic.CardsTotalDuration
+			// 	}
+			// } else {
+			// 	if _, ok := aiCenterUsageDuration[Date]; !ok {
+			// 		aiCenterUsageDuration[Date] = cloudbrainStatistic.CardsTotalDuration
+			// 	} else {
+			// 		aiCenterUsageDuration[Date] += cloudbrainStatistic.CardsTotalDuration
+			// 	}
+			// }
 		}
 	}
-
-	for k, v := range aiCenterTotalDuration {
-		for i, j := range aiCenterUsageDuration {
-			if k == i {
-				aiCenterUsageRate[k] = float64(j) / float64(v)
-			}
-		}
-	}
-
-	return aiCenterUsageDuration, aiCenterTotalDuration, aiCenterUsageRate
+	// ResourceAiCenterRes, err := models.GetResourceAiCenters()
+	// if err != nil {
+	// 	log.Error("Can not get ResourceAiCenterRes.", err)
+	// 	return nil, nil, nil
+	// }
+	// for _, v := range ResourceAiCenterRes {
+	// 	if _, ok := aiCenterUsageDuration[v.AiCenterCode]; !ok {
+	// 		aiCenterUsageDuration[v.AiCenterCode] = 0
+	// 	}
+	// }
+
+	// for k, v := range aiCenterTotalDuration {
+	// 	for i, j := range aiCenterUsageDuration {
+	// 		if k == i {
+	// 			aiCenterUsageRate[k] = float64(j) / float64(v)
+	// 		}
+	// 	}
+	// }
+	// usageRate = float64(usageDuration) / float64(totalDuration)
+
+	return totalDuration, usageDuration, usageRate
 }
 
 func getDurationStatistic(beginTime time.Time, endTime time.Time) models.DurationRateStatistic {
@@ -1763,30 +1761,31 @@ func getDurationStatistic(beginTime time.Time, endTime time.Time) models.Duratio
 	return durationRateStatistic
 }
 
-func getDayCloudbrainDuration(beginTime time.Time, endTime time.Time) ([]models.DateCloudbrainStatistic, int, error) {
+func getDayCloudbrainDuration(beginTime time.Time, endTime time.Time, aiCenterCode string) ([]models.DateUsageStatistic, int, error) {
 	now := time.Now()
 	endTimeTemp := time.Date(endTime.Year(), endTime.Month(), endTime.Day(), 0, 0, 0, 0, now.Location())
 	if endTimeTemp.Equal(endTime) {
 		endTimeTemp = endTimeTemp.AddDate(0, 0, -1)
 	}
 	cardDurationStatistics, err := models.GetCardDurationStatistics(&models.DurationStatisticOptions{
-		BeginTime: beginTime,
-		EndTime:   endTime,
+		BeginTime:    beginTime,
+		EndTime:      endTime,
+		AiCenterCode: aiCenterCode,
 	})
 	if err != nil {
 		log.Error("GetCardDurationStatistics error:", err)
 		return nil, 0, err
 	}
 
-	dayCloudbrainInfo := make([]models.DateCloudbrainStatistic, 0)
+	dayCloudbrainInfo := make([]models.DateUsageStatistic, 0)
 	count := 0
 	for beginTime.Before(endTimeTemp) || beginTime.Equal(endTimeTemp) {
-		aiCenterUsageDuration, aiCenterTotalDuration, aiCenterUsageRate := getAiCenterUsageDuration(endTimeTemp, endTime, cardDurationStatistics)
-		dayCloudbrainInfo = append(dayCloudbrainInfo, models.DateCloudbrainStatistic{
-			Date:                  endTimeTemp.Format("2006/01/02"),
-			AiCenterUsageDuration: aiCenterUsageDuration,
-			AiCenterTotalDuration: aiCenterTotalDuration,
-			AiCenterUsageRate:     aiCenterUsageRate,
+		TotalDuration, UsageDuration, UsageRate := getAiCenterUsageDuration(endTimeTemp, endTime, cardDurationStatistics)
+		dayCloudbrainInfo = append(dayCloudbrainInfo, models.DateUsageStatistic{
+			Date:          endTimeTemp.Format("2006/01/02"),
+			UsageDuration: UsageDuration,
+			TotalDuration: TotalDuration,
+			UsageRate:     UsageRate,
 		})
 		endTime = endTimeTemp
 		endTimeTemp = endTimeTemp.AddDate(0, 0, -1)
@@ -1798,10 +1797,10 @@ func getDayCloudbrainDuration(beginTime time.Time, endTime time.Time) ([]models.
 	return dayCloudbrainInfo, count, nil
 }
 
-func getHourCloudbrainDuration(beginTime time.Time, endTime time.Time, aiCenterCode string) models.HourTimeStatistic {
-	hourTimeTotalDuration := make(map[int]int)
-	hourTimeUsageDuration := make(map[int]int)
-	hourTimeUsageRate := make(map[int]float64)
+func getHourCloudbrainDuration(beginTime time.Time, endTime time.Time, aiCenterCode string) (models.HourTimeStatistic, error) {
+	hourTimeTotalDuration := make(map[string]int)
+	hourTimeUsageDuration := make(map[string]int)
+	hourTimeUsageRate := make(map[string]float64)
 	hourTimeStatistic := models.HourTimeStatistic{}
 
 	cardDurationStatistics, err := models.GetCardDurationStatistics(&models.DurationStatisticOptions{
@@ -1810,44 +1809,49 @@ func getHourCloudbrainDuration(beginTime time.Time, endTime time.Time, aiCenterC
 	})
 	if err != nil {
 		log.Error("GetCardDurationStatistics error:", err)
-		return hourTimeStatistic
+		return hourTimeStatistic, err
 	}
 	for _, cloudbrainStatistic := range cardDurationStatistics {
 		if cloudbrainStatistic.AiCenterCode == aiCenterCode {
 			if cloudbrainStatistic.TotalCanUse {
-				if _, ok := hourTimeTotalDuration[cloudbrainStatistic.HourTime]; !ok {
-					hourTimeTotalDuration[cloudbrainStatistic.HourTime] = cloudbrainStatistic.CardsTotalDuration
+				if _, ok := hourTimeTotalDuration[strconv.Itoa(cloudbrainStatistic.HourTime)]; !ok {
+					hourTimeTotalDuration[strconv.Itoa(cloudbrainStatistic.HourTime)] = cloudbrainStatistic.CardsTotalDuration
 				} else {
-					hourTimeTotalDuration[cloudbrainStatistic.HourTime] += cloudbrainStatistic.CardsTotalDuration
+					hourTimeTotalDuration[strconv.Itoa(cloudbrainStatistic.HourTime)] += cloudbrainStatistic.CardsTotalDuration
 				}
 			} else {
-				if _, ok := hourTimeUsageDuration[cloudbrainStatistic.HourTime]; !ok {
-					hourTimeUsageDuration[cloudbrainStatistic.HourTime] = cloudbrainStatistic.CardsTotalDuration
+				if _, ok := hourTimeUsageDuration[strconv.Itoa(cloudbrainStatistic.HourTime)]; !ok {
+					hourTimeUsageDuration[strconv.Itoa(cloudbrainStatistic.HourTime)] = cloudbrainStatistic.CardsTotalDuration
 				} else {
-					hourTimeUsageDuration[cloudbrainStatistic.HourTime] += cloudbrainStatistic.CardsTotalDuration
-				}
-			}
-			hourTimeList := []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 _, v := range hourTimeList {
-				if _, ok := hourTimeUsageDuration[v]; !ok {
-					hourTimeUsageDuration[v] = 0
-				}
-				if _, ok := hourTimeTotalDuration[v]; !ok {
-					hourTimeTotalDuration[v] = 0
-				}
-			}
-
-			for k, v := range hourTimeTotalDuration {
-				for i, j := range hourTimeUsageDuration {
-					if k == i {
-						hourTimeUsageRate[k] = float64(j) / float64(v)
-					}
+					hourTimeUsageDuration[strconv.Itoa(cloudbrainStatistic.HourTime)] += cloudbrainStatistic.CardsTotalDuration
 				}
 			}
 		}
 	}
+	hourTimeList := []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 hourTimeList {
+		if _, ok := hourTimeUsageDuration[v]; !ok {
+			hourTimeUsageDuration[v] = 0
+		}
+		if _, ok := hourTimeTotalDuration[v]; !ok {
+			hourTimeTotalDuration[v] = 0
+		}
+		// if _, ok := hourTimeUsageRate[v]; !ok {
+		// 	hourTimeUsageRate[v] = 0
+		// }
+
+	}
+
+	// for k, v := range hourTimeTotalDuration {
+	// 	for i, j := range hourTimeUsageDuration {
+	// 		if k == i {
+	// 			hourTimeUsageRate[k] = float64(j) / float64(v)
+	// 		}
+	// 	}
+	// }
+
 	hourTimeStatistic.HourTimeTotalDuration = hourTimeTotalDuration
 	hourTimeStatistic.HourTimeUsageDuration = hourTimeUsageDuration
 	hourTimeStatistic.HourTimeUsageRate = hourTimeUsageRate
-	return hourTimeStatistic
+	return hourTimeStatistic, nil
 }