You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2570 lines
80 KiB
2570 lines
80 KiB
package customChartesing
|
|
|
|
import (
|
|
"appPlatform/api/version1/customerform"
|
|
"appPlatform/overall/publicmethod"
|
|
"fmt"
|
|
"strconv"
|
|
"time"
|
|
)
|
|
|
|
/*
|
|
*
|
|
@ 作者: 秦东
|
|
@ 时间: 2025-07-17 09:18:12
|
|
@ 功能: 柱状图结果解析
|
|
*/
|
|
func (c *ChartInfo) zhuChart(val interface{}, untis []customerform.MasterStruct, chartType string) (snedMap interface{}) {
|
|
|
|
for _, v := range c.XAxis {
|
|
fmt.Printf("\n\nc.X ===1==> %v =====> %v\n\n", v.Type, v)
|
|
switch v.Type {
|
|
case 3:
|
|
snedMap = c.TimeDataAnaly(v, c.YAxis, val, chartType)
|
|
default:
|
|
snedMap = c.DataAnaly(v, c.YAxis, val, chartType, untis)
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
// 时间字段
|
|
func (c *ChartInfo) TimeDataAnaly(x XAxisInfo, y []YAxisInfo, val interface{}, chartType string) (charData BarDataInfo) {
|
|
tayTime := time.Now().Unix()
|
|
charData.XAxis.Types = "category"
|
|
charData.YAxis.Types = "value"
|
|
|
|
searchTime := c.JieXiSearchTime()
|
|
|
|
fmt.Printf("时间字段--->%v\n\n", x.TimeType)
|
|
|
|
switch x.TimeType {
|
|
case "year":
|
|
yearVal := publicmethod.UnixTimeToDay(tayTime, 16)
|
|
if len(searchTime) > 0 {
|
|
charData.XAxis.Data = searchTime
|
|
} else {
|
|
charData.XAxis.Data = []string{yearVal}
|
|
}
|
|
charData.CalculateNumericalValues(y, val, x.Field, chartType, "all", 12, charData.XAxis.Data)
|
|
case "month":
|
|
var timeList []string
|
|
yearVal := publicmethod.UnixTimeToDay(tayTime, 16)
|
|
tayTimeing := int(time.Now().Month())
|
|
for i := 1; i <= tayTimeing; i++ {
|
|
timeList = append(timeList, fmt.Sprintf("%v-%v", yearVal, i))
|
|
}
|
|
if len(searchTime) > 0 {
|
|
charData.XAxis.Data = searchTime
|
|
} else {
|
|
charData.XAxis.Data = timeList
|
|
}
|
|
|
|
charData.CalculateNumericalValues(y, val, x.Field, chartType, "month", tayTimeing, charData.XAxis.Data)
|
|
case "day":
|
|
tayTimeing := int(time.Now().Day())
|
|
yearVal := publicmethod.UnixTimeToDay(tayTime, 15)
|
|
fmt.Printf("时间字段-1-->%v\n\n", tayTimeing)
|
|
var timeList []string
|
|
for i := 1; i <= tayTimeing; i++ {
|
|
timeList = append(timeList, fmt.Sprintf("%v-%v", yearVal, i))
|
|
}
|
|
fmt.Printf("时间字段-1-->%v-->%v\n\n", len(searchTime), searchTime)
|
|
if len(searchTime) > 0 {
|
|
charData.XAxis.Data = searchTime
|
|
} else {
|
|
charData.XAxis.Data = timeList
|
|
}
|
|
charData.NewCalculateNumericalValues(y, val, x.Field, chartType, "day", tayTimeing, charData.XAxis.Data)
|
|
|
|
case "hour":
|
|
var timeList []string
|
|
yearVal := publicmethod.UnixTimeToDay(tayTime, 7)
|
|
ymd := publicmethod.UnixTimeToDay(tayTime, 14)
|
|
hourInt, _ := strconv.Atoi(yearVal)
|
|
for i := 1; i <= hourInt; i++ {
|
|
timeList = append(timeList, fmt.Sprintf("%v %v", ymd, i))
|
|
}
|
|
if len(searchTime) > 0 {
|
|
charData.XAxis.Data = searchTime
|
|
} else {
|
|
charData.XAxis.Data = timeList
|
|
}
|
|
charData.CalculateNumericalValues(y, val, x.Field, chartType, "hour", hourInt, charData.XAxis.Data)
|
|
case "minute":
|
|
var timeList []string
|
|
yearVal := publicmethod.UnixTimeToDay(tayTime, 9)
|
|
ymd := publicmethod.UnixTimeToDay(tayTime, 13)
|
|
hourInt, _ := strconv.Atoi(yearVal)
|
|
for i := 1; i <= hourInt; i++ {
|
|
timeList = append(timeList, fmt.Sprintf("%v %v", ymd, i))
|
|
}
|
|
if len(searchTime) > 0 {
|
|
charData.XAxis.Data = searchTime
|
|
} else {
|
|
charData.XAxis.Data = timeList
|
|
}
|
|
charData.CalculateNumericalValues(y, val, x.Field, chartType, "minute", hourInt, charData.XAxis.Data)
|
|
case "second":
|
|
var timeList []string
|
|
yearVal := publicmethod.UnixTimeToDay(tayTime, 10)
|
|
ymd := publicmethod.UnixTimeToDay(tayTime, 12)
|
|
hourInt, _ := strconv.Atoi(yearVal)
|
|
for i := 1; i <= hourInt; i++ {
|
|
timeList = append(timeList, fmt.Sprintf("%v %v", ymd, i))
|
|
}
|
|
if len(searchTime) > 0 {
|
|
charData.XAxis.Data = searchTime
|
|
} else {
|
|
charData.XAxis.Data = timeList
|
|
}
|
|
charData.CalculateNumericalValues(y, val, x.Field, chartType, "second", hourInt, charData.XAxis.Data)
|
|
default:
|
|
var timeList []string
|
|
yearVal := publicmethod.UnixTimeToDay(tayTime, 15)
|
|
tayTime := int(time.Now().Month())
|
|
for i := 1; i <= tayTime; i++ {
|
|
timeList = append(timeList, fmt.Sprintf("%v-%v", yearVal, i))
|
|
}
|
|
if len(searchTime) > 0 {
|
|
charData.XAxis.Data = searchTime
|
|
} else {
|
|
charData.XAxis.Data = timeList
|
|
}
|
|
charData.CalculateNumericalValues(y, val, x.Field, chartType, "month", tayTime, charData.XAxis.Data)
|
|
}
|
|
// xAxis := c.JieXiSearchTime()
|
|
// if len(xAxis) > 0 {
|
|
// charData.XAxis.Data = xAxis
|
|
// }
|
|
return
|
|
}
|
|
|
|
// 计算数值
|
|
// 1:求和；2:平均值；3:计数；4:去重计数；5:最大值；6:最小值
|
|
// 当字段为时间类型时. 1:自动（原始值）；2:整数；3:保留1位小数；4:保留2位小数；5:百分比；6:百分比1位小数；7:百分比2位小数；
|
|
func (b *BarDataInfo) NewCalculateNumericalValues(y []YAxisInfo, val interface{}, xField, chartType string, types string, lenght int, timeAry []string) {
|
|
|
|
for _, v := range y {
|
|
// if i == 0 {
|
|
var seriesInfo SeriesList
|
|
seriesInfo.Name = v.OldTitle
|
|
seriesInfo.Types = chartType
|
|
switch v.Method {
|
|
case 2:
|
|
seriesInfo.NewAverageValue(xField, v.Field, types, val, v.Format, timeAry)
|
|
case 3:
|
|
seriesInfo.NewStatisticalQuantity(xField, v.Field, types, val, v.Format, timeAry)
|
|
case 4:
|
|
seriesInfo.NewRemoveDuplicateCounts(xField, v.Field, types, val, v.Format, timeAry)
|
|
case 5:
|
|
seriesInfo.NewmaxData(xField, v.Field, types, val, v.Format, timeAry)
|
|
case 6:
|
|
seriesInfo.NewminData(xField, v.Field, types, val, v.Format, timeAry)
|
|
default:
|
|
seriesInfo.NewsumData(xField, v.Field, types, val, v.Format, timeAry)
|
|
}
|
|
|
|
if !publicmethod.IsInTrue[string](v.OldTitle, b.Legend.Data) {
|
|
b.Legend.Data = append(b.Legend.Data, v.OldTitle)
|
|
}
|
|
// if yVal, isOk := val.([]map[string]interface{}); isOk {
|
|
// for mi, mv := range yVal {
|
|
// fmt.Printf("\n\nyVal =====> %v =====> %v\n\n", mi, mv)
|
|
// }
|
|
// }
|
|
b.Series = append(b.Series, seriesInfo)
|
|
// }
|
|
|
|
}
|
|
}
|
|
|
|
/*
|
|
*
|
|
@ 作者: 秦东
|
|
@ 时间: 2025-07-25 14:51:33
|
|
@ 功能:
|
|
|
|
#xField X轴信息
|
|
#yField Y轴信息
|
|
#types 时间信息
|
|
#format 值约束
|
|
#timeAry 时间数组
|
|
*/
|
|
func (s *SeriesList) NewAverageValue(xField, yField, types string, val interface{}, format int, timeAry []string) {
|
|
var monthAry []interface{}
|
|
for _, v := range timeAry {
|
|
switch types {
|
|
case "year":
|
|
startTime := publicmethod.DateToTimeStampOld(fmt.Sprintf("%v-01-01 00:00:00", v))
|
|
endTime := publicmethod.DateToTimeStampOld(fmt.Sprintf("%v-12-31 23:59:59", v))
|
|
monthAry = append(monthAry, s.QuPingjunSumData(startTime, endTime, val, xField, yField, format))
|
|
case "month":
|
|
startTime := publicmethod.DateToTimeStampOld(fmt.Sprintf("%v-01 00:00:00", v))
|
|
yearValInt, _ := strconv.Atoi(publicmethod.UnixTimeToDay(startTime, 16))
|
|
monthValInt, _ := strconv.Atoi(publicmethod.UnixTimeToDay(startTime, 17))
|
|
endTime := publicmethod.GetDaysInMonth(yearValInt, monthValInt)
|
|
monthAry = append(monthAry, s.QuPingjunSumData(startTime, endTime.AllTime, val, xField, yField, format))
|
|
case "day":
|
|
startTime := publicmethod.DateToTimeStampOld(fmt.Sprintf("%v 00:00:00", v))
|
|
endTime := publicmethod.DateToTimeStampOld(fmt.Sprintf("%v 23:59:59", v))
|
|
monthAry = append(monthAry, s.QuPingjunSumData(startTime, endTime, val, xField, yField, format))
|
|
case "hour":
|
|
startTime := publicmethod.DateToTimeStampOld(fmt.Sprintf("%v:00:00", v))
|
|
endTime := publicmethod.DateToTimeStampOld(fmt.Sprintf("%v:59:59", v))
|
|
monthAry = append(monthAry, s.QuPingjunSumData(startTime, endTime, val, xField, yField, format))
|
|
case "minute":
|
|
startTime := publicmethod.DateToTimeStampOld(fmt.Sprintf("%v:00", v))
|
|
endTime := publicmethod.DateToTimeStampOld(fmt.Sprintf("%v:59", v))
|
|
monthAry = append(monthAry, s.QuPingjunSumData(startTime, endTime, val, xField, yField, format))
|
|
case "second":
|
|
startTime := publicmethod.DateToTimeStampOld(fmt.Sprintf("%v:00:00", v))
|
|
endTime := publicmethod.DateToTimeStampOld(fmt.Sprintf("%v:59:59", v))
|
|
monthAry = append(monthAry, s.QuPingjunSumData(startTime, endTime, val, xField, yField, format))
|
|
default:
|
|
}
|
|
}
|
|
s.Data = monthAry
|
|
}
|
|
func (s *SeriesList) QuPingjunSumData(startTime, endTime int64, val interface{}, xField, yField string, format int) (jieguo interface{}) {
|
|
if yVal, isOk := val.([]map[string]interface{}); isOk {
|
|
var sumVal float64
|
|
jibuqi := 0
|
|
for _, mv := range yVal {
|
|
if xVal, isOk := mv[xField]; isOk {
|
|
pageTime, _ := publicmethod.StringToInt64(xVal)
|
|
var begTime int64
|
|
var eldTime int64
|
|
if publicmethod.GetIntLength(pageTime) >= 13 {
|
|
begTime = startTime * 1000
|
|
eldTime = endTime * 1000
|
|
} else {
|
|
begTime = startTime
|
|
eldTime = startTime
|
|
}
|
|
// fmt.Printf("时间数组:\n\n%v==2====1==2=====>%v==2=====>%v\n\n", begTime, eldTime, pageTime)
|
|
// fmt.Printf("技术只:\n\n%v======3=======>%v\n\n", begTime <= pageTime, pageTime <= endTime)
|
|
if begTime <= pageTime && pageTime <= eldTime {
|
|
// fmt.Printf("技术只:\n\n%v======1=======>%v\n\n", yField, pageTime)
|
|
if yzVal, isOk := mv[yField]; isOk {
|
|
minVal, err := strconv.ParseFloat(publicmethod.TypeToInterface(yzVal), 64)
|
|
if err == nil {
|
|
sumVal = sumVal + minVal
|
|
jibuqi++
|
|
}
|
|
}
|
|
|
|
}
|
|
// fmt.Printf("时间数组:\n\n%v======1=======>%v\n\n", yField, pageTime)
|
|
}
|
|
}
|
|
// fmt.Printf("时间数组:\n\n%v======1=======>%v======1=======>%v======1=======>%v\n\n", publicmethod.UnixTimeToDay(startTime, 14), xField, yField, sumVal)
|
|
// jieguo = publicmethod.DataChuli(sumVal, format)
|
|
if jibuqi > 0 {
|
|
avgVal := sumVal / float64(jibuqi)
|
|
jieguo = publicmethod.DataChuli(avgVal, format)
|
|
|
|
} else {
|
|
jieguo = publicmethod.DataChuli(sumVal, format)
|
|
}
|
|
}
|
|
// if yVal, isOk := val.([]map[string]interface{}); isOk {
|
|
// var sumVal float64
|
|
// jibuqi := 0
|
|
// for _, mv := range yVal {
|
|
// if yVal, isOk := mv[yField]; isOk {
|
|
// if xVal, isOk := mv[xField]; isOk {
|
|
// pageTime, _ := publicmethod.StringToInt64(xVal)
|
|
// if publicmethod.GetIntLength(pageTime) >= 13 {
|
|
// startTime = startTime * 1000
|
|
// endTime = endTime * 1000
|
|
// }
|
|
// if startTime <= pageTime && pageTime <= endTime {
|
|
// minVal, err := strconv.ParseFloat(publicmethod.TypeToInterface(yVal), 64)
|
|
// if err == nil {
|
|
// sumVal = sumVal + minVal
|
|
// jibuqi++
|
|
// }
|
|
// }
|
|
// }
|
|
|
|
// }
|
|
|
|
// }
|
|
// if jibuqi > 0 {
|
|
// avgVal := sumVal / float64(jibuqi)
|
|
// jieguo = publicmethod.DataChuli(avgVal, format)
|
|
|
|
// } else {
|
|
// jieguo = publicmethod.DataChuli(sumVal, format)
|
|
// }
|
|
// }
|
|
return
|
|
}
|
|
|
|
/*
|
|
*
|
|
@ 作者: 秦东
|
|
@ 时间: 2025-07-25 14:51:33
|
|
@ 功能:
|
|
|
|
#xField X轴信息
|
|
#yField Y轴信息
|
|
#types 时间信息
|
|
#format 值约束
|
|
#timeAry 时间数组
|
|
*/
|
|
func (s *SeriesList) NewStatisticalQuantity(xField, yField, types string, val interface{}, format int, timeAry []string) {
|
|
var monthAry []interface{}
|
|
for _, v := range timeAry {
|
|
switch types {
|
|
case "year":
|
|
startTime := publicmethod.DateToTimeStampOld(fmt.Sprintf("%v-01-01 00:00:00", v))
|
|
endTime := publicmethod.DateToTimeStampOld(fmt.Sprintf("%v-12-31 23:59:59", v))
|
|
monthAry = append(monthAry, s.QuJishuData(startTime, endTime, val, xField, yField, format))
|
|
case "month":
|
|
startTime := publicmethod.DateToTimeStampOld(fmt.Sprintf("%v-01 00:00:00", v))
|
|
yearValInt, _ := strconv.Atoi(publicmethod.UnixTimeToDay(startTime, 16))
|
|
monthValInt, _ := strconv.Atoi(publicmethod.UnixTimeToDay(startTime, 17))
|
|
endTime := publicmethod.GetDaysInMonth(yearValInt, monthValInt)
|
|
monthAry = append(monthAry, s.QuJishuData(startTime, endTime.AllTime, val, xField, yField, format))
|
|
case "day":
|
|
startTime := publicmethod.DateToTimeStampOld(fmt.Sprintf("%v 00:00:00", v))
|
|
endTime := publicmethod.DateToTimeStampOld(fmt.Sprintf("%v 23:59:59", v))
|
|
monthAry = append(monthAry, s.QuJishuData(startTime, endTime, val, xField, yField, format))
|
|
case "hour":
|
|
startTime := publicmethod.DateToTimeStampOld(fmt.Sprintf("%v:00:00", v))
|
|
endTime := publicmethod.DateToTimeStampOld(fmt.Sprintf("%v:59:59", v))
|
|
monthAry = append(monthAry, s.QuJishuData(startTime, endTime, val, xField, yField, format))
|
|
case "minute":
|
|
startTime := publicmethod.DateToTimeStampOld(fmt.Sprintf("%v:00", v))
|
|
endTime := publicmethod.DateToTimeStampOld(fmt.Sprintf("%v:59", v))
|
|
monthAry = append(monthAry, s.QuJishuData(startTime, endTime, val, xField, yField, format))
|
|
case "second":
|
|
startTime := publicmethod.DateToTimeStampOld(fmt.Sprintf("%v:00:00", v))
|
|
endTime := publicmethod.DateToTimeStampOld(fmt.Sprintf("%v:59:59", v))
|
|
monthAry = append(monthAry, s.QuJishuData(startTime, endTime, val, xField, yField, format))
|
|
default:
|
|
}
|
|
}
|
|
s.Data = monthAry
|
|
}
|
|
func (s *SeriesList) QuJishuData(startTime, endTime int64, val interface{}, xField, yField string, format int) (jieguo interface{}) {
|
|
// if yVal, isOk := val.([]map[string]interface{}); isOk {
|
|
// var valAry []float64
|
|
// for _, mv := range yVal {
|
|
// if yVal, isOk := mv[yField]; isOk {
|
|
// if xVal, isOk := mv[xField]; isOk {
|
|
// pageTime, _ := publicmethod.StringToInt64(xVal)
|
|
// if publicmethod.GetIntLength(pageTime) >= 13 {
|
|
// startTime = startTime * 1000
|
|
// endTime = endTime * 1000
|
|
// }
|
|
// if startTime <= pageTime && pageTime <= endTime {
|
|
// minVal, err := strconv.ParseFloat(publicmethod.TypeToInterface(yVal), 64)
|
|
// if err == nil {
|
|
|
|
// valAry = append(valAry, minVal)
|
|
|
|
// }
|
|
// }
|
|
// }
|
|
|
|
// }
|
|
|
|
// }
|
|
// jieguo = len(valAry)
|
|
// }
|
|
if yVal, isOk := val.([]map[string]interface{}); isOk {
|
|
var valAry []float64
|
|
for _, mv := range yVal {
|
|
if xVal, isOk := mv[xField]; isOk {
|
|
pageTime, _ := publicmethod.StringToInt64(xVal)
|
|
var begTime int64
|
|
var eldTime int64
|
|
if publicmethod.GetIntLength(pageTime) >= 13 {
|
|
begTime = startTime * 1000
|
|
eldTime = endTime * 1000
|
|
} else {
|
|
begTime = startTime
|
|
eldTime = startTime
|
|
}
|
|
// fmt.Printf("时间数组:\n\n%v==2====1==2=====>%v==2=====>%v\n\n", begTime, eldTime, pageTime)
|
|
// fmt.Printf("技术只:\n\n%v======3=======>%v\n\n", begTime <= pageTime, pageTime <= endTime)
|
|
if begTime <= pageTime && pageTime <= eldTime {
|
|
// fmt.Printf("技术只:\n\n%v======1=======>%v\n\n", yField, pageTime)
|
|
if yzVal, isOk := mv[yField]; isOk {
|
|
minVal, err := strconv.ParseFloat(publicmethod.TypeToInterface(yzVal), 64)
|
|
if err == nil {
|
|
valAry = append(valAry, minVal)
|
|
}
|
|
}
|
|
|
|
}
|
|
// fmt.Printf("时间数组:\n\n%v======1=======>%v\n\n", yField, pageTime)
|
|
}
|
|
}
|
|
jieguo = len(valAry)
|
|
}
|
|
return
|
|
}
|
|
|
|
/*
|
|
*
|
|
@ 作者: 秦东
|
|
@ 时间: 2025-07-25 14:51:33
|
|
@ 功能:
|
|
|
|
#xField X轴信息
|
|
#yField Y轴信息
|
|
#types 时间信息
|
|
#format 值约束
|
|
#timeAry 时间数组
|
|
*/
|
|
func (s *SeriesList) NewRemoveDuplicateCounts(xField, yField, types string, val interface{}, format int, timeAry []string) {
|
|
var monthAry []interface{}
|
|
for _, v := range timeAry {
|
|
switch types {
|
|
case "year":
|
|
startTime := publicmethod.DateToTimeStampOld(fmt.Sprintf("%v-01-01 00:00:00", v))
|
|
endTime := publicmethod.DateToTimeStampOld(fmt.Sprintf("%v-12-31 23:59:59", v))
|
|
monthAry = append(monthAry, s.QuChongData(startTime, endTime, val, xField, yField, format))
|
|
case "month":
|
|
startTime := publicmethod.DateToTimeStampOld(fmt.Sprintf("%v-01 00:00:00", v))
|
|
yearValInt, _ := strconv.Atoi(publicmethod.UnixTimeToDay(startTime, 16))
|
|
monthValInt, _ := strconv.Atoi(publicmethod.UnixTimeToDay(startTime, 17))
|
|
endTime := publicmethod.GetDaysInMonth(yearValInt, monthValInt)
|
|
monthAry = append(monthAry, s.QuChongData(startTime, endTime.AllTime, val, xField, yField, format))
|
|
case "day":
|
|
startTime := publicmethod.DateToTimeStampOld(fmt.Sprintf("%v 00:00:00", v))
|
|
endTime := publicmethod.DateToTimeStampOld(fmt.Sprintf("%v 23:59:59", v))
|
|
monthAry = append(monthAry, s.QuChongData(startTime, endTime, val, xField, yField, format))
|
|
case "hour":
|
|
startTime := publicmethod.DateToTimeStampOld(fmt.Sprintf("%v:00:00", v))
|
|
endTime := publicmethod.DateToTimeStampOld(fmt.Sprintf("%v:59:59", v))
|
|
monthAry = append(monthAry, s.QuChongData(startTime, endTime, val, xField, yField, format))
|
|
case "minute":
|
|
startTime := publicmethod.DateToTimeStampOld(fmt.Sprintf("%v:00", v))
|
|
endTime := publicmethod.DateToTimeStampOld(fmt.Sprintf("%v:59", v))
|
|
monthAry = append(monthAry, s.QuChongData(startTime, endTime, val, xField, yField, format))
|
|
case "second":
|
|
startTime := publicmethod.DateToTimeStampOld(fmt.Sprintf("%v:00:00", v))
|
|
endTime := publicmethod.DateToTimeStampOld(fmt.Sprintf("%v:59:59", v))
|
|
monthAry = append(monthAry, s.QuChongData(startTime, endTime, val, xField, yField, format))
|
|
default:
|
|
}
|
|
}
|
|
s.Data = monthAry
|
|
}
|
|
func (s *SeriesList) QuChongData(startTime, endTime int64, val interface{}, xField, yField string, format int) (jieguo interface{}) {
|
|
// if yVal, isOk := val.([]map[string]interface{}); isOk {
|
|
// var valAry []float64
|
|
// for _, mv := range yVal {
|
|
// if yVal, isOk := mv[yField]; isOk {
|
|
// if xVal, isOk := mv[xField]; isOk {
|
|
// pageTime, _ := publicmethod.StringToInt64(xVal)
|
|
// if publicmethod.GetIntLength(pageTime) >= 13 {
|
|
// startTime = startTime * 1000
|
|
// endTime = endTime * 1000
|
|
// }
|
|
// if startTime <= pageTime && pageTime <= endTime {
|
|
// minVal, err := strconv.ParseFloat(publicmethod.TypeToInterface(yVal), 64)
|
|
// if err == nil {
|
|
// if !publicmethod.IsInTrue[float64](minVal, valAry) {
|
|
// valAry = append(valAry, minVal)
|
|
// }
|
|
// }
|
|
// }
|
|
// }
|
|
|
|
// }
|
|
|
|
// }
|
|
// jieguo = len(valAry)
|
|
// }
|
|
if yVal, isOk := val.([]map[string]interface{}); isOk {
|
|
var valAry []float64
|
|
for _, mv := range yVal {
|
|
if xVal, isOk := mv[xField]; isOk {
|
|
pageTime, _ := publicmethod.StringToInt64(xVal)
|
|
var begTime int64
|
|
var eldTime int64
|
|
if publicmethod.GetIntLength(pageTime) >= 13 {
|
|
begTime = startTime * 1000
|
|
eldTime = endTime * 1000
|
|
} else {
|
|
begTime = startTime
|
|
eldTime = startTime
|
|
}
|
|
// fmt.Printf("时间数组:\n\n%v==2====1==2=====>%v==2=====>%v\n\n", begTime, eldTime, pageTime)
|
|
// fmt.Printf("技术只:\n\n%v======3=======>%v\n\n", begTime <= pageTime, pageTime <= endTime)
|
|
if begTime <= pageTime && pageTime <= eldTime {
|
|
// fmt.Printf("技术只:\n\n%v======1=======>%v\n\n", yField, pageTime)
|
|
if yzVal, isOk := mv[yField]; isOk {
|
|
minVal, err := strconv.ParseFloat(publicmethod.TypeToInterface(yzVal), 64)
|
|
if err == nil {
|
|
if !publicmethod.IsInTrue[float64](minVal, valAry) {
|
|
valAry = append(valAry, minVal)
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
// fmt.Printf("时间数组:\n\n%v======1=======>%v\n\n", yField, pageTime)
|
|
}
|
|
}
|
|
jieguo = len(valAry)
|
|
}
|
|
return
|
|
}
|
|
|
|
/*
|
|
*
|
|
@ 作者: 秦东
|
|
@ 时间: 2025-07-25 14:51:33
|
|
@ 功能:
|
|
|
|
#xField X轴信息
|
|
#yField Y轴信息
|
|
#types 时间信息
|
|
#format 值约束
|
|
#timeAry 时间数组
|
|
*/
|
|
func (s *SeriesList) NewmaxData(xField, yField, types string, val interface{}, format int, timeAry []string) {
|
|
var monthAry []interface{}
|
|
for _, v := range timeAry {
|
|
switch types {
|
|
case "year":
|
|
startTime := publicmethod.DateToTimeStampOld(fmt.Sprintf("%v-01-01 00:00:00", v))
|
|
endTime := publicmethod.DateToTimeStampOld(fmt.Sprintf("%v-12-31 23:59:59", v))
|
|
monthAry = append(monthAry, s.QuMaxData(startTime, endTime, val, xField, yField, format))
|
|
case "month":
|
|
startTime := publicmethod.DateToTimeStampOld(fmt.Sprintf("%v-01 00:00:00", v))
|
|
yearValInt, _ := strconv.Atoi(publicmethod.UnixTimeToDay(startTime, 16))
|
|
monthValInt, _ := strconv.Atoi(publicmethod.UnixTimeToDay(startTime, 17))
|
|
endTime := publicmethod.GetDaysInMonth(yearValInt, monthValInt)
|
|
monthAry = append(monthAry, s.QuMaxData(startTime, endTime.AllTime, val, xField, yField, format))
|
|
case "day":
|
|
startTime := publicmethod.DateToTimeStampOld(fmt.Sprintf("%v 00:00:00", v))
|
|
endTime := publicmethod.DateToTimeStampOld(fmt.Sprintf("%v 23:59:59", v))
|
|
monthAry = append(monthAry, s.QuMaxData(startTime, endTime, val, xField, yField, format))
|
|
case "hour":
|
|
startTime := publicmethod.DateToTimeStampOld(fmt.Sprintf("%v:00:00", v))
|
|
endTime := publicmethod.DateToTimeStampOld(fmt.Sprintf("%v:59:59", v))
|
|
monthAry = append(monthAry, s.QuMaxData(startTime, endTime, val, xField, yField, format))
|
|
case "minute":
|
|
startTime := publicmethod.DateToTimeStampOld(fmt.Sprintf("%v:00", v))
|
|
endTime := publicmethod.DateToTimeStampOld(fmt.Sprintf("%v:59", v))
|
|
monthAry = append(monthAry, s.QuMaxData(startTime, endTime, val, xField, yField, format))
|
|
case "second":
|
|
startTime := publicmethod.DateToTimeStampOld(fmt.Sprintf("%v:00:00", v))
|
|
endTime := publicmethod.DateToTimeStampOld(fmt.Sprintf("%v:59:59", v))
|
|
monthAry = append(monthAry, s.QuMaxData(startTime, endTime, val, xField, yField, format))
|
|
default:
|
|
}
|
|
}
|
|
s.Data = monthAry
|
|
}
|
|
func (s *SeriesList) QuMaxData(startTime, endTime int64, val interface{}, xField, yField string, format int) (jieguo interface{}) {
|
|
// if yVal, isOk := val.([]map[string]interface{}); isOk {
|
|
// var sumVal float64
|
|
// for i, mv := range yVal {
|
|
// if yVal, isOk := mv[yField]; isOk {
|
|
// if xVal, isOk := mv[xField]; isOk {
|
|
// pageTime, _ := publicmethod.StringToInt64(xVal)
|
|
// if publicmethod.GetIntLength(pageTime) >= 13 {
|
|
// startTime = startTime * 1000
|
|
// endTime = endTime * 1000
|
|
// }
|
|
// if startTime <= pageTime && pageTime <= endTime {
|
|
// minVal, err := strconv.ParseFloat(publicmethod.TypeToInterface(yVal), 64)
|
|
// if err == nil {
|
|
// if i == 0 {
|
|
// sumVal = minVal
|
|
// } else {
|
|
// if sumVal <= minVal {
|
|
// sumVal = minVal
|
|
// }
|
|
// }
|
|
|
|
// }
|
|
// }
|
|
// }
|
|
|
|
// }
|
|
|
|
// }
|
|
// jieguo = publicmethod.DataChuli(sumVal, format)
|
|
// }
|
|
if yVal, isOk := val.([]map[string]interface{}); isOk {
|
|
var sumVal float64
|
|
for i, mv := range yVal {
|
|
if xVal, isOk := mv[xField]; isOk {
|
|
pageTime, _ := publicmethod.StringToInt64(xVal)
|
|
var begTime int64
|
|
var eldTime int64
|
|
if publicmethod.GetIntLength(pageTime) >= 13 {
|
|
begTime = startTime * 1000
|
|
eldTime = endTime * 1000
|
|
} else {
|
|
begTime = startTime
|
|
eldTime = startTime
|
|
}
|
|
// fmt.Printf("时间数组:\n\n%v==2====1==2=====>%v==2=====>%v\n\n", begTime, eldTime, pageTime)
|
|
// fmt.Printf("技术只:\n\n%v======3=======>%v\n\n", begTime <= pageTime, pageTime <= endTime)
|
|
if begTime <= pageTime && pageTime <= eldTime {
|
|
// fmt.Printf("技术只:\n\n%v======1=======>%v\n\n", yField, pageTime)
|
|
if yzVal, isOk := mv[yField]; isOk {
|
|
minVal, err := strconv.ParseFloat(publicmethod.TypeToInterface(yzVal), 64)
|
|
if err == nil {
|
|
if i == 0 {
|
|
sumVal = minVal
|
|
} else {
|
|
if sumVal <= minVal {
|
|
sumVal = minVal
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
// fmt.Printf("时间数组:\n\n%v======1=======>%v\n\n", yField, pageTime)
|
|
}
|
|
}
|
|
jieguo = publicmethod.DataChuli(sumVal, format)
|
|
}
|
|
return
|
|
}
|
|
|
|
/*
|
|
*
|
|
@ 作者: 秦东
|
|
@ 时间: 2025-07-25 14:51:33
|
|
@ 功能:
|
|
|
|
#xField X轴信息
|
|
#yField Y轴信息
|
|
#types 时间信息
|
|
#format 值约束
|
|
#timeAry 时间数组
|
|
*/
|
|
func (s *SeriesList) NewminData(xField, yField, types string, val interface{}, format int, timeAry []string) {
|
|
var monthAry []interface{}
|
|
for _, v := range timeAry {
|
|
switch types {
|
|
case "year":
|
|
startTime := publicmethod.DateToTimeStampOld(fmt.Sprintf("%v-01-01 00:00:00", v))
|
|
endTime := publicmethod.DateToTimeStampOld(fmt.Sprintf("%v-12-31 23:59:59", v))
|
|
monthAry = append(monthAry, s.QuMinData(startTime, endTime, val, xField, yField, format))
|
|
case "month":
|
|
startTime := publicmethod.DateToTimeStampOld(fmt.Sprintf("%v-01 00:00:00", v))
|
|
yearValInt, _ := strconv.Atoi(publicmethod.UnixTimeToDay(startTime, 16))
|
|
monthValInt, _ := strconv.Atoi(publicmethod.UnixTimeToDay(startTime, 17))
|
|
endTime := publicmethod.GetDaysInMonth(yearValInt, monthValInt)
|
|
monthAry = append(monthAry, s.QuMinData(startTime, endTime.AllTime, val, xField, yField, format))
|
|
case "day":
|
|
startTime := publicmethod.DateToTimeStampOld(fmt.Sprintf("%v 00:00:00", v))
|
|
endTime := publicmethod.DateToTimeStampOld(fmt.Sprintf("%v 23:59:59", v))
|
|
monthAry = append(monthAry, s.QuMinData(startTime, endTime, val, xField, yField, format))
|
|
case "hour":
|
|
startTime := publicmethod.DateToTimeStampOld(fmt.Sprintf("%v:00:00", v))
|
|
endTime := publicmethod.DateToTimeStampOld(fmt.Sprintf("%v:59:59", v))
|
|
monthAry = append(monthAry, s.QuMinData(startTime, endTime, val, xField, yField, format))
|
|
case "minute":
|
|
startTime := publicmethod.DateToTimeStampOld(fmt.Sprintf("%v:00", v))
|
|
endTime := publicmethod.DateToTimeStampOld(fmt.Sprintf("%v:59", v))
|
|
monthAry = append(monthAry, s.QuMinData(startTime, endTime, val, xField, yField, format))
|
|
case "second":
|
|
startTime := publicmethod.DateToTimeStampOld(fmt.Sprintf("%v:00:00", v))
|
|
endTime := publicmethod.DateToTimeStampOld(fmt.Sprintf("%v:59:59", v))
|
|
monthAry = append(monthAry, s.QuMinData(startTime, endTime, val, xField, yField, format))
|
|
default:
|
|
}
|
|
}
|
|
s.Data = monthAry
|
|
}
|
|
func (s *SeriesList) QuMinData(startTime, endTime int64, val interface{}, xField, yField string, format int) (jieguo interface{}) {
|
|
// if yVal, isOk := val.([]map[string]interface{}); isOk {
|
|
// var sumVal float64
|
|
// for i, mv := range yVal {
|
|
// if yVal, isOk := mv[yField]; isOk {
|
|
// if xVal, isOk := mv[xField]; isOk {
|
|
// pageTime, _ := publicmethod.StringToInt64(xVal)
|
|
// if publicmethod.GetIntLength(pageTime) >= 13 {
|
|
// startTime = startTime * 1000
|
|
// endTime = endTime * 1000
|
|
// }
|
|
// if startTime <= pageTime && pageTime <= endTime {
|
|
// minVal, err := strconv.ParseFloat(publicmethod.TypeToInterface(yVal), 64)
|
|
// if err == nil {
|
|
// if i == 0 {
|
|
// sumVal = minVal
|
|
// } else {
|
|
// if sumVal >= minVal {
|
|
// sumVal = minVal
|
|
// }
|
|
// }
|
|
|
|
// }
|
|
// }
|
|
// }
|
|
|
|
// }
|
|
|
|
// }
|
|
// jieguo = publicmethod.DataChuli(sumVal, format)
|
|
// }
|
|
if yVal, isOk := val.([]map[string]interface{}); isOk {
|
|
var sumVal float64
|
|
for i, mv := range yVal {
|
|
if xVal, isOk := mv[xField]; isOk {
|
|
pageTime, _ := publicmethod.StringToInt64(xVal)
|
|
var begTime int64
|
|
var eldTime int64
|
|
if publicmethod.GetIntLength(pageTime) >= 13 {
|
|
begTime = startTime * 1000
|
|
eldTime = endTime * 1000
|
|
} else {
|
|
begTime = startTime
|
|
eldTime = startTime
|
|
}
|
|
// fmt.Printf("时间数组:\n\n%v==2====1==2=====>%v==2=====>%v\n\n", begTime, eldTime, pageTime)
|
|
// fmt.Printf("技术只:\n\n%v======3=======>%v\n\n", begTime <= pageTime, pageTime <= endTime)
|
|
if begTime <= pageTime && pageTime <= eldTime {
|
|
// fmt.Printf("技术只:\n\n%v======1=======>%v\n\n", yField, pageTime)
|
|
if yzVal, isOk := mv[yField]; isOk {
|
|
minVal, err := strconv.ParseFloat(publicmethod.TypeToInterface(yzVal), 64)
|
|
if err == nil {
|
|
if i == 0 {
|
|
sumVal = minVal
|
|
} else {
|
|
if sumVal >= minVal {
|
|
sumVal = minVal
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
// fmt.Printf("时间数组:\n\n%v======1=======>%v\n\n", yField, pageTime)
|
|
}
|
|
}
|
|
jieguo = publicmethod.DataChuli(sumVal, format)
|
|
}
|
|
return
|
|
}
|
|
|
|
/*
|
|
*
|
|
@ 作者: 秦东
|
|
@ 时间: 2025-07-25 14:51:33
|
|
@ 功能:
|
|
|
|
#xField X轴信息
|
|
#yField Y轴信息
|
|
#types 时间信息
|
|
#format 值约束
|
|
#timeAry 时间数组
|
|
*/
|
|
func (s *SeriesList) NewsumData(xField, yField, types string, val interface{}, format int, timeAry []string) {
|
|
|
|
var monthAry []interface{}
|
|
for _, v := range timeAry {
|
|
// if i == 0 {
|
|
switch types {
|
|
case "year":
|
|
startTime := publicmethod.DateToTimeStampOld(fmt.Sprintf("%v-01-01 00:00:00", v))
|
|
endTime := publicmethod.DateToTimeStampOld(fmt.Sprintf("%v-12-31 23:59:59", v))
|
|
monthAry = append(monthAry, s.QuSumData(startTime, endTime, val, xField, yField, format))
|
|
case "month":
|
|
startTime := publicmethod.DateToTimeStampOld(fmt.Sprintf("%v-01 00:00:00", v))
|
|
yearValInt, _ := strconv.Atoi(publicmethod.UnixTimeToDay(startTime, 16))
|
|
monthValInt, _ := strconv.Atoi(publicmethod.UnixTimeToDay(startTime, 17))
|
|
endTime := publicmethod.GetDaysInMonth(yearValInt, monthValInt)
|
|
monthAry = append(monthAry, s.QuSumData(startTime, endTime.AllTime, val, xField, yField, format))
|
|
case "day":
|
|
startTime := publicmethod.DateToTimeStampOld(fmt.Sprintf("%v 00:00:00", v))
|
|
endTime := publicmethod.DateToTimeStampOld(fmt.Sprintf("%v 23:59:59", v))
|
|
monthAry = append(monthAry, s.QuSumData(startTime, endTime, val, xField, yField, format))
|
|
fmt.Printf("计算一天的数据:\n\n%v 到 %v 结果：%v\n\n", startTime, endTime, monthAry)
|
|
case "hour":
|
|
startTime := publicmethod.DateToTimeStampOld(fmt.Sprintf("%v:00:00", v))
|
|
endTime := publicmethod.DateToTimeStampOld(fmt.Sprintf("%v:59:59", v))
|
|
monthAry = append(monthAry, s.QuSumData(startTime, endTime, val, xField, yField, format))
|
|
case "minute":
|
|
startTime := publicmethod.DateToTimeStampOld(fmt.Sprintf("%v:00", v))
|
|
endTime := publicmethod.DateToTimeStampOld(fmt.Sprintf("%v:59", v))
|
|
monthAry = append(monthAry, s.QuSumData(startTime, endTime, val, xField, yField, format))
|
|
case "second":
|
|
startTime := publicmethod.DateToTimeStampOld(fmt.Sprintf("%v:00:00", v))
|
|
endTime := publicmethod.DateToTimeStampOld(fmt.Sprintf("%v:59:59", v))
|
|
monthAry = append(monthAry, s.QuSumData(startTime, endTime, val, xField, yField, format))
|
|
default:
|
|
}
|
|
// }
|
|
|
|
}
|
|
s.Data = monthAry
|
|
}
|
|
func (s *SeriesList) QuSumData(startTime, endTime int64, val interface{}, xField, yField string, format int) (jieguo interface{}) {
|
|
// if yVal, isOk := val.([]map[string]interface{}); isOk {
|
|
// var sumVal float64
|
|
// for _, mv := range yVal {
|
|
// if yVal, isOk := mv[yField]; isOk {
|
|
// fmt.Printf("要查询的字段：%v====y=====>%v\n", yField, yVal)
|
|
// if xVal, isOk := mv[xField]; isOk {
|
|
// fmt.Printf("要查询的字段：%v====x=====>%v\n", xField, xVal)
|
|
// pageTime, _ := publicmethod.StringToInt64(xVal)
|
|
// if publicmethod.GetIntLength(pageTime) >= 13 {
|
|
// startTime = startTime * 1000
|
|
// endTime = endTime * 1000
|
|
// }
|
|
// if startTime <= pageTime && pageTime <= endTime {
|
|
// minVal, err := strconv.ParseFloat(publicmethod.TypeToInterface(yVal), 64)
|
|
// if err == nil {
|
|
// sumVal = sumVal + minVal
|
|
// }
|
|
// }
|
|
// }
|
|
|
|
// }
|
|
|
|
// }
|
|
// jieguo = publicmethod.DataChuli(sumVal, format)
|
|
// }
|
|
// fmt.Printf("时间数组:\n\n%v======3=======>%v\n\n", startTime, endTime)
|
|
if yVal, isOk := val.([]map[string]interface{}); isOk {
|
|
var sumVal float64
|
|
for _, mv := range yVal {
|
|
if xVal, isOk := mv[xField]; isOk {
|
|
pageTime, _ := publicmethod.StringToInt64(xVal)
|
|
var begTime int64
|
|
var eldTime int64
|
|
if publicmethod.GetIntLength(pageTime) >= 13 {
|
|
begTime = startTime * 1000
|
|
eldTime = endTime * 1000
|
|
} else {
|
|
begTime = startTime
|
|
eldTime = endTime
|
|
}
|
|
// fmt.Printf("时间数组:\n\n%v==2====1==2=====>%v==2=====>%v\n\n", begTime, eldTime, pageTime)
|
|
// fmt.Printf("技术只:\n\n%v======3=======>%v\n\n", begTime <= pageTime, pageTime <= endTime)
|
|
if begTime <= pageTime && pageTime <= eldTime {
|
|
// fmt.Printf("技术只:\n\n%v======1=======>%v\n\n", yField, pageTime)
|
|
if yzVal, isOk := mv[yField]; isOk {
|
|
minVal, err := strconv.ParseFloat(publicmethod.TypeToInterface(yzVal), 64)
|
|
if err == nil {
|
|
sumVal = sumVal + minVal
|
|
}
|
|
}
|
|
|
|
}
|
|
// fmt.Printf("时间数组:\n\n%v======1=======>%v\n\n", yField, pageTime)
|
|
}
|
|
}
|
|
fmt.Printf("时间数组:\n\n%v======1=======>%v======1=======>%v======1=======>%v\n\n", publicmethod.UnixTimeToDay(startTime, 14), xField, yField, sumVal)
|
|
jieguo = publicmethod.DataChuli(sumVal, format)
|
|
}
|
|
return
|
|
}
|
|
|
|
// 计算数值
|
|
// 1:求和；2:平均值；3:计数；4:去重计数；5:最大值；6:最小值
|
|
// 当字段为时间类型时. 1:自动（原始值）；2:整数；3:保留1位小数；4:保留2位小数；5:百分比；6:百分比1位小数；7:百分比2位小数；
|
|
func (b *BarDataInfo) CalculateNumericalValues(y []YAxisInfo, val interface{}, xField, chartType string, types string, lenght int, timeAry []string) {
|
|
|
|
for _, v := range y {
|
|
var seriesInfo SeriesList
|
|
seriesInfo.Name = v.OldTitle
|
|
seriesInfo.Types = chartType
|
|
switch v.Method {
|
|
case 2:
|
|
seriesInfo.AverageValue(xField, v.Field, types, val, v.Format, lenght, timeAry)
|
|
case 3:
|
|
seriesInfo.StatisticalQuantity(xField, v.Field, types, val, v.Format, lenght, timeAry)
|
|
case 4:
|
|
seriesInfo.RemoveDuplicateCounts(xField, v.Field, types, val, v.Format, lenght, timeAry)
|
|
case 5:
|
|
seriesInfo.maxData(xField, v.Field, types, val, v.Format, lenght, timeAry)
|
|
case 6:
|
|
seriesInfo.minData(xField, v.Field, types, val, v.Format, lenght, timeAry)
|
|
default:
|
|
seriesInfo.sumData(xField, v.Field, types, val, v.Format, lenght, timeAry)
|
|
}
|
|
|
|
if !publicmethod.IsInTrue[string](v.OldTitle, b.Legend.Data) {
|
|
b.Legend.Data = append(b.Legend.Data, v.OldTitle)
|
|
}
|
|
// if yVal, isOk := val.([]map[string]interface{}); isOk {
|
|
// for mi, mv := range yVal {
|
|
// fmt.Printf("\n\nyVal =====> %v =====> %v\n\n", mi, mv)
|
|
// }
|
|
// }
|
|
b.Series = append(b.Series, seriesInfo)
|
|
}
|
|
}
|
|
|
|
// 求平均值
|
|
func (s *SeriesList) AverageValue(xField, yField, types string, val interface{}, format, lenght int, timeAry []string) {
|
|
tayTime := time.Now().Unix()
|
|
switch types {
|
|
case "month":
|
|
yearVal := publicmethod.UnixTimeToDay(tayTime, 16)
|
|
yearValInt, _ := strconv.Atoi(yearVal)
|
|
var monthAry []interface{}
|
|
for i := 1; i <= lenght; i++ {
|
|
var sumVal float64
|
|
createTime := fmt.Sprintf("%v-%v-01 00:00:00", yearVal, i)
|
|
if i < 10 {
|
|
createTime = fmt.Sprintf("%v-0%v-01 00:00:00", yearVal, i)
|
|
}
|
|
startTime := publicmethod.DateToTimeStampOld(createTime)
|
|
endTime := publicmethod.GetDaysInMonth(yearValInt, i)
|
|
|
|
if yVal, isOk := val.([]map[string]interface{}); isOk {
|
|
jibuqi := 1
|
|
for _, mv := range yVal {
|
|
if yVal, isOk := mv[yField]; isOk {
|
|
if xVal, isOk := mv[xField]; isOk {
|
|
pageTime, _ := publicmethod.StringToInt64(xVal)
|
|
if publicmethod.GetIntLength(pageTime) >= 13 {
|
|
startTime = startTime * 1000
|
|
endTime.AllTime = endTime.AllTime * 1000
|
|
}
|
|
if startTime <= pageTime && pageTime <= endTime.AllTime {
|
|
minVal, err := strconv.ParseFloat(publicmethod.TypeToInterface(yVal), 64)
|
|
if err == nil {
|
|
sumVal = sumVal + minVal
|
|
jibuqi++
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
if jibuqi > 0 {
|
|
avgVal := sumVal / float64(jibuqi)
|
|
jieguo := publicmethod.DataChuli(avgVal, format)
|
|
monthAry = append(monthAry, jieguo)
|
|
} else {
|
|
monthAry = append(monthAry, 0)
|
|
}
|
|
}
|
|
|
|
}
|
|
s.Data = monthAry
|
|
case "day":
|
|
var dayAry []interface{}
|
|
if lenght == 1 {
|
|
startTime, endTime := publicmethod.TimeUnixDayStartAndEnd(tayTime)
|
|
var sumVal float64
|
|
jibuqi := 0
|
|
if yVal, isOk := val.([]map[string]interface{}); isOk {
|
|
|
|
for _, mv := range yVal {
|
|
if yVal, isOk := mv[yField]; isOk {
|
|
if xVal, isOk := mv[xField]; isOk {
|
|
pageTime, _ := publicmethod.StringToInt64(xVal)
|
|
if publicmethod.GetIntLength(pageTime) >= 13 {
|
|
startTime = startTime * 1000
|
|
endTime = endTime * 1000
|
|
}
|
|
if startTime <= pageTime && pageTime <= endTime {
|
|
minVal, err := strconv.ParseFloat(publicmethod.TypeToInterface(yVal), 64)
|
|
if err == nil {
|
|
sumVal = sumVal + minVal
|
|
jibuqi++
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
if jibuqi > 0 {
|
|
avgVal := sumVal / float64(jibuqi)
|
|
jieguo := publicmethod.DataChuli(avgVal, format)
|
|
dayAry = append(dayAry, jieguo)
|
|
} else {
|
|
dayAry = append(dayAry, 0)
|
|
}
|
|
}
|
|
} else {
|
|
ymd := publicmethod.UnixTimeToDay(tayTime, 14)
|
|
for i := 1; i <= lenght; i++ {
|
|
createTime := fmt.Sprintf("%v %v:00:00", ymd, i)
|
|
if i < 10 {
|
|
createTime = fmt.Sprintf("%v 0%v:00:00", ymd, i)
|
|
}
|
|
startTime := publicmethod.DateToTimeStampOld(createTime)
|
|
endTimeStr := fmt.Sprintf("%v %v:59:59", ymd, i)
|
|
if i < 10 {
|
|
endTimeStr = fmt.Sprintf("%v 0%v:59:59", ymd, i)
|
|
}
|
|
endTime := publicmethod.DateToTimeStampOld(endTimeStr)
|
|
var sumVal float64
|
|
jibuqi := 0
|
|
if yVal, isOk := val.([]map[string]interface{}); isOk {
|
|
for _, mv := range yVal {
|
|
if yVal, isOk := mv[yField]; isOk {
|
|
if xVal, isOk := mv[xField]; isOk {
|
|
pageTime, _ := publicmethod.StringToInt64(xVal)
|
|
if publicmethod.GetIntLength(pageTime) >= 13 {
|
|
startTime = startTime * 1000
|
|
endTime = endTime * 1000
|
|
}
|
|
if startTime <= pageTime && pageTime <= endTime {
|
|
minVal, err := strconv.ParseFloat(publicmethod.TypeToInterface(yVal), 64)
|
|
if err == nil {
|
|
sumVal = sumVal + minVal
|
|
jibuqi++
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
if jibuqi > 0 {
|
|
avgVal := sumVal / float64(jibuqi)
|
|
jieguo := publicmethod.DataChuli(avgVal, format)
|
|
dayAry = append(dayAry, jieguo)
|
|
} else {
|
|
dayAry = append(dayAry, 0)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
s.Data = dayAry
|
|
case "hour":
|
|
var dayAry []interface{}
|
|
if lenght == 1 {
|
|
startTime, endTime := publicmethod.TimeUnixDayStartAndEnd(tayTime)
|
|
var sumVal float64
|
|
jibuqi := 0
|
|
if yVal, isOk := val.([]map[string]interface{}); isOk {
|
|
|
|
for _, mv := range yVal {
|
|
if yVal, isOk := mv[yField]; isOk {
|
|
if xVal, isOk := mv[xField]; isOk {
|
|
pageTime, _ := publicmethod.StringToInt64(xVal)
|
|
if publicmethod.GetIntLength(pageTime) >= 13 {
|
|
startTime = startTime * 1000
|
|
endTime = endTime * 1000
|
|
}
|
|
if startTime <= pageTime && pageTime <= endTime {
|
|
minVal, err := strconv.ParseFloat(publicmethod.TypeToInterface(yVal), 64)
|
|
if err == nil {
|
|
sumVal = sumVal + minVal
|
|
jibuqi++
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
}
|
|
if jibuqi > 0 {
|
|
avgVal := sumVal / float64(jibuqi)
|
|
jieguo := publicmethod.DataChuli(avgVal, format)
|
|
dayAry = append(dayAry, jieguo)
|
|
} else {
|
|
dayAry = append(dayAry, 0)
|
|
}
|
|
} else {
|
|
ymd := publicmethod.UnixTimeToDay(tayTime, 13)
|
|
for i := 1; i <= lenght; i++ {
|
|
createTime := fmt.Sprintf("%v:%v:00", ymd, i)
|
|
if i < 10 {
|
|
createTime = fmt.Sprintf("%v:0%v:00", ymd, i)
|
|
}
|
|
startTime := publicmethod.DateToTimeStampOld(createTime)
|
|
endTimeStr := fmt.Sprintf("%v:%v:59", ymd, i)
|
|
if i < 10 {
|
|
endTimeStr = fmt.Sprintf("%v:0%v:59", ymd, i)
|
|
}
|
|
endTime := publicmethod.DateToTimeStampOld(endTimeStr)
|
|
var sumVal float64
|
|
jibuqi := 0
|
|
if yVal, isOk := val.([]map[string]interface{}); isOk {
|
|
for _, mv := range yVal {
|
|
if yVal, isOk := mv[yField]; isOk {
|
|
if xVal, isOk := mv[xField]; isOk {
|
|
pageTime, _ := publicmethod.StringToInt64(xVal)
|
|
if publicmethod.GetIntLength(pageTime) >= 13 {
|
|
startTime = startTime * 1000
|
|
endTime = endTime * 1000
|
|
}
|
|
if startTime <= pageTime && pageTime <= endTime {
|
|
minVal, err := strconv.ParseFloat(publicmethod.TypeToInterface(yVal), 64)
|
|
if err == nil {
|
|
sumVal = sumVal + minVal
|
|
jibuqi++
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
}
|
|
if jibuqi > 0 {
|
|
avgVal := sumVal / float64(jibuqi)
|
|
jieguo := publicmethod.DataChuli(avgVal, format)
|
|
dayAry = append(dayAry, jieguo)
|
|
} else {
|
|
dayAry = append(dayAry, 0)
|
|
}
|
|
}
|
|
}
|
|
s.Data = dayAry
|
|
case "minute":
|
|
var dayAry []interface{}
|
|
if lenght == 1 {
|
|
startTime, endTime := publicmethod.TimeUnixDayStartAndEnd(tayTime)
|
|
var sumVal float64
|
|
jibuqi := 0
|
|
if yVal, isOk := val.([]map[string]interface{}); isOk {
|
|
|
|
for _, mv := range yVal {
|
|
if yVal, isOk := mv[yField]; isOk {
|
|
if xVal, isOk := mv[xField]; isOk {
|
|
pageTime, _ := publicmethod.StringToInt64(xVal)
|
|
if publicmethod.GetIntLength(pageTime) >= 13 {
|
|
startTime = startTime * 1000
|
|
endTime = endTime * 1000
|
|
}
|
|
if startTime <= pageTime && pageTime <= endTime {
|
|
minVal, err := strconv.ParseFloat(publicmethod.TypeToInterface(yVal), 64)
|
|
if err == nil {
|
|
sumVal = sumVal + minVal
|
|
jibuqi++
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
}
|
|
if jibuqi > 0 {
|
|
avgVal := sumVal / float64(jibuqi)
|
|
jieguo := publicmethod.DataChuli(avgVal, format)
|
|
dayAry = append(dayAry, jieguo)
|
|
} else {
|
|
dayAry = append(dayAry, 0)
|
|
}
|
|
} else {
|
|
ymd := publicmethod.UnixTimeToDay(tayTime, 12)
|
|
for i := 1; i <= lenght; i++ {
|
|
createTime := fmt.Sprintf("%v:%v", ymd, i)
|
|
if i < 10 {
|
|
createTime = fmt.Sprintf("%v:0%v", ymd, i)
|
|
}
|
|
startTime := publicmethod.DateToTimeStampOld(createTime)
|
|
endTimeStr := fmt.Sprintf("%v:%v", ymd, i)
|
|
if i < 10 {
|
|
endTimeStr = fmt.Sprintf("%v:0%v", ymd, i)
|
|
}
|
|
endTime := publicmethod.DateToTimeStampOld(endTimeStr)
|
|
var sumVal float64
|
|
jibuqi := 0
|
|
if yVal, isOk := val.([]map[string]interface{}); isOk {
|
|
for _, mv := range yVal {
|
|
if yVal, isOk := mv[yField]; isOk {
|
|
if xVal, isOk := mv[xField]; isOk {
|
|
pageTime, _ := publicmethod.StringToInt64(xVal)
|
|
if publicmethod.GetIntLength(pageTime) >= 13 {
|
|
startTime = startTime * 1000
|
|
endTime = endTime * 1000
|
|
}
|
|
if startTime <= pageTime && pageTime <= endTime {
|
|
minVal, err := strconv.ParseFloat(publicmethod.TypeToInterface(yVal), 64)
|
|
if err == nil {
|
|
sumVal = sumVal + minVal
|
|
jibuqi++
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
}
|
|
if jibuqi > 0 {
|
|
avgVal := sumVal / float64(jibuqi)
|
|
jieguo := publicmethod.DataChuli(avgVal, format)
|
|
dayAry = append(dayAry, jieguo)
|
|
} else {
|
|
dayAry = append(dayAry, 0)
|
|
}
|
|
}
|
|
}
|
|
s.Data = dayAry
|
|
case "second":
|
|
var dayAry []interface{}
|
|
|
|
startTime, endTime := publicmethod.TimeUnixDayStartAndEnd(tayTime)
|
|
var sumVal float64
|
|
jibuqi := 0
|
|
if yVal, isOk := val.([]map[string]interface{}); isOk {
|
|
|
|
for _, mv := range yVal {
|
|
if yVal, isOk := mv[yField]; isOk {
|
|
if xVal, isOk := mv[xField]; isOk {
|
|
pageTime, _ := publicmethod.StringToInt64(xVal)
|
|
if publicmethod.GetIntLength(pageTime) >= 13 {
|
|
startTime = startTime * 1000
|
|
endTime = endTime * 1000
|
|
}
|
|
if startTime <= pageTime && pageTime <= endTime {
|
|
minVal, err := strconv.ParseFloat(publicmethod.TypeToInterface(yVal), 64)
|
|
if err == nil {
|
|
sumVal = sumVal + minVal
|
|
jibuqi++
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
}
|
|
if jibuqi > 0 {
|
|
avgVal := sumVal / float64(jibuqi)
|
|
jieguo := publicmethod.DataChuli(avgVal, format)
|
|
dayAry = append(dayAry, jieguo)
|
|
} else {
|
|
dayAry = append(dayAry, 0)
|
|
}
|
|
|
|
s.Data = dayAry
|
|
case "ymdhms":
|
|
var dayAry []interface{}
|
|
jibuqi := 0
|
|
startTime, endTime := publicmethod.TimeUnixDayStartAndEnd(tayTime)
|
|
var sumVal float64
|
|
if yVal, isOk := val.([]map[string]interface{}); isOk {
|
|
|
|
for _, mv := range yVal {
|
|
if yVal, isOk := mv[yField]; isOk {
|
|
if xVal, isOk := mv[xField]; isOk {
|
|
pageTime, _ := publicmethod.StringToInt64(xVal)
|
|
if publicmethod.GetIntLength(pageTime) >= 13 {
|
|
startTime = startTime * 1000
|
|
endTime = endTime * 1000
|
|
}
|
|
if startTime <= pageTime && pageTime <= endTime {
|
|
minVal, err := strconv.ParseFloat(publicmethod.TypeToInterface(yVal), 64)
|
|
if err == nil {
|
|
sumVal = sumVal + minVal
|
|
jibuqi++
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
}
|
|
if jibuqi > 0 {
|
|
avgVal := sumVal / float64(jibuqi)
|
|
jieguo := publicmethod.DataChuli(avgVal, format)
|
|
dayAry = append(dayAry, jieguo)
|
|
} else {
|
|
dayAry = append(dayAry, 0)
|
|
}
|
|
|
|
s.Data = dayAry
|
|
|
|
default:
|
|
var sumVal float64
|
|
if yVal, isOk := val.([]map[string]interface{}); isOk {
|
|
for _, mv := range yVal {
|
|
if yVal, isOk := mv[yField]; isOk {
|
|
minVal, err := strconv.ParseFloat(publicmethod.TypeToInterface(yVal), 64)
|
|
if err == nil {
|
|
sumVal = sumVal + minVal
|
|
}
|
|
}
|
|
}
|
|
avgVal := sumVal / float64(len(yVal))
|
|
jieguo := publicmethod.DataChuli(avgVal, format)
|
|
s.Data = []interface{}{jieguo}
|
|
}
|
|
}
|
|
}
|
|
|
|
// 统计数量
|
|
func (s *SeriesList) StatisticalQuantity(xField, yField, types string, val interface{}, format, lenght int, timeAry []string) {
|
|
tayTime := time.Now().Unix()
|
|
switch types {
|
|
case "month":
|
|
yearVal := publicmethod.UnixTimeToDay(tayTime, 16)
|
|
yearValInt, _ := strconv.Atoi(yearVal)
|
|
var monthAry []interface{}
|
|
for i := 1; i <= lenght; i++ {
|
|
var sumVal []float64
|
|
createTime := fmt.Sprintf("%v-%v-01 00:00:00", yearVal, i)
|
|
if i < 10 {
|
|
createTime = fmt.Sprintf("%v-0%v-01 00:00:00", yearVal, i)
|
|
}
|
|
startTime := publicmethod.DateToTimeStampOld(createTime)
|
|
endTime := publicmethod.GetDaysInMonth(yearValInt, i)
|
|
|
|
if yVal, isOk := val.([]map[string]interface{}); isOk {
|
|
for _, mv := range yVal {
|
|
if yVal, isOk := mv[yField]; isOk {
|
|
if xVal, isOk := mv[xField]; isOk {
|
|
pageTime, _ := publicmethod.StringToInt64(xVal)
|
|
if publicmethod.GetIntLength(pageTime) >= 13 {
|
|
startTime = startTime * 1000
|
|
endTime.AllTime = endTime.AllTime * 1000
|
|
}
|
|
if startTime <= pageTime && pageTime <= endTime.AllTime {
|
|
minVal, err := strconv.ParseFloat(publicmethod.TypeToInterface(yVal), 64)
|
|
if err == nil {
|
|
sumVal = append(sumVal, minVal)
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
}
|
|
// jieguo := publicmethod.DataChuli(sumVal, format)
|
|
monthAry = append(monthAry, len(sumVal))
|
|
}
|
|
s.Data = monthAry
|
|
case "day":
|
|
var dayAry []interface{}
|
|
if lenght == 1 {
|
|
startTime, endTime := publicmethod.TimeUnixDayStartAndEnd(tayTime)
|
|
var sumVal []float64
|
|
if yVal, isOk := val.([]map[string]interface{}); isOk {
|
|
|
|
for _, mv := range yVal {
|
|
if yVal, isOk := mv[yField]; isOk {
|
|
if xVal, isOk := mv[xField]; isOk {
|
|
pageTime, _ := publicmethod.StringToInt64(xVal)
|
|
if publicmethod.GetIntLength(pageTime) >= 13 {
|
|
startTime = startTime * 1000
|
|
endTime = endTime * 1000
|
|
}
|
|
if startTime <= pageTime && pageTime <= endTime {
|
|
minVal, err := strconv.ParseFloat(publicmethod.TypeToInterface(yVal), 64)
|
|
if err == nil {
|
|
sumVal = append(sumVal, minVal)
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
}
|
|
// jieguo := publicmethod.DataChuli(sumVal, format)
|
|
dayAry = append(dayAry, len(sumVal))
|
|
} else {
|
|
ymd := publicmethod.UnixTimeToDay(tayTime, 14)
|
|
for i := 1; i <= lenght; i++ {
|
|
createTime := fmt.Sprintf("%v %v:00:00", ymd, i)
|
|
if i < 10 {
|
|
createTime = fmt.Sprintf("%v 0%v:00:00", ymd, i)
|
|
}
|
|
startTime := publicmethod.DateToTimeStampOld(createTime)
|
|
endTimeStr := fmt.Sprintf("%v %v:59:59", ymd, i)
|
|
if i < 10 {
|
|
endTimeStr = fmt.Sprintf("%v 0%v:59:59", ymd, i)
|
|
}
|
|
endTime := publicmethod.DateToTimeStampOld(endTimeStr)
|
|
var sumVal []float64
|
|
if yVal, isOk := val.([]map[string]interface{}); isOk {
|
|
for _, mv := range yVal {
|
|
if yVal, isOk := mv[yField]; isOk {
|
|
if xVal, isOk := mv[xField]; isOk {
|
|
pageTime, _ := publicmethod.StringToInt64(xVal)
|
|
if publicmethod.GetIntLength(pageTime) >= 13 {
|
|
startTime = startTime * 1000
|
|
endTime = endTime * 1000
|
|
}
|
|
if startTime <= pageTime && pageTime <= endTime {
|
|
minVal, err := strconv.ParseFloat(publicmethod.TypeToInterface(yVal), 64)
|
|
if err == nil {
|
|
sumVal = append(sumVal, minVal)
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
}
|
|
// jieguo := publicmethod.DataChuli(sumVal, format)
|
|
dayAry = append(dayAry, len(sumVal))
|
|
}
|
|
}
|
|
s.Data = dayAry
|
|
case "hour":
|
|
var dayAry []interface{}
|
|
if lenght == 1 {
|
|
startTime, endTime := publicmethod.TimeUnixDayStartAndEnd(tayTime)
|
|
var sumVal []float64
|
|
if yVal, isOk := val.([]map[string]interface{}); isOk {
|
|
|
|
for _, mv := range yVal {
|
|
if yVal, isOk := mv[yField]; isOk {
|
|
if xVal, isOk := mv[xField]; isOk {
|
|
pageTime, _ := publicmethod.StringToInt64(xVal)
|
|
if publicmethod.GetIntLength(pageTime) >= 13 {
|
|
startTime = startTime * 1000
|
|
endTime = endTime * 1000
|
|
}
|
|
if startTime <= pageTime && pageTime <= endTime {
|
|
minVal, err := strconv.ParseFloat(publicmethod.TypeToInterface(yVal), 64)
|
|
if err == nil {
|
|
sumVal = append(sumVal, minVal)
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
}
|
|
jieguo := len(sumVal)
|
|
dayAry = append(dayAry, jieguo)
|
|
} else {
|
|
ymd := publicmethod.UnixTimeToDay(tayTime, 13)
|
|
for i := 1; i <= lenght; i++ {
|
|
createTime := fmt.Sprintf("%v:%v:00", ymd, i)
|
|
if i < 10 {
|
|
createTime = fmt.Sprintf("%v:0%v:00", ymd, i)
|
|
}
|
|
startTime := publicmethod.DateToTimeStampOld(createTime)
|
|
endTimeStr := fmt.Sprintf("%v:%v:59", ymd, i)
|
|
if i < 10 {
|
|
endTimeStr = fmt.Sprintf("%v:0%v:59", ymd, i)
|
|
}
|
|
endTime := publicmethod.DateToTimeStampOld(endTimeStr)
|
|
var sumVal []float64
|
|
if yVal, isOk := val.([]map[string]interface{}); isOk {
|
|
for _, mv := range yVal {
|
|
if yVal, isOk := mv[yField]; isOk {
|
|
if xVal, isOk := mv[xField]; isOk {
|
|
pageTime, _ := publicmethod.StringToInt64(xVal)
|
|
if publicmethod.GetIntLength(pageTime) >= 13 {
|
|
startTime = startTime * 1000
|
|
endTime = endTime * 1000
|
|
}
|
|
if startTime <= pageTime && pageTime <= endTime {
|
|
minVal, err := strconv.ParseFloat(publicmethod.TypeToInterface(yVal), 64)
|
|
if err == nil {
|
|
sumVal = append(sumVal, minVal)
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
}
|
|
jieguo := len(sumVal)
|
|
dayAry = append(dayAry, jieguo)
|
|
}
|
|
}
|
|
s.Data = dayAry
|
|
case "minute":
|
|
var dayAry []interface{}
|
|
if lenght == 1 {
|
|
startTime, endTime := publicmethod.TimeUnixDayStartAndEnd(tayTime)
|
|
var valAry []float64
|
|
if yVal, isOk := val.([]map[string]interface{}); isOk {
|
|
|
|
for _, mv := range yVal {
|
|
if yVal, isOk := mv[yField]; isOk {
|
|
if xVal, isOk := mv[xField]; isOk {
|
|
pageTime, _ := publicmethod.StringToInt64(xVal)
|
|
if publicmethod.GetIntLength(pageTime) >= 13 {
|
|
startTime = startTime * 1000
|
|
endTime = endTime * 1000
|
|
}
|
|
if startTime <= pageTime && pageTime <= endTime {
|
|
minVal, err := strconv.ParseFloat(publicmethod.TypeToInterface(yVal), 64)
|
|
if err == nil {
|
|
valAry = append(valAry, minVal)
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
}
|
|
jieguo := len(valAry)
|
|
dayAry = append(dayAry, jieguo)
|
|
} else {
|
|
ymd := publicmethod.UnixTimeToDay(tayTime, 12)
|
|
for i := 1; i <= lenght; i++ {
|
|
createTime := fmt.Sprintf("%v:%v", ymd, i)
|
|
if i < 10 {
|
|
createTime = fmt.Sprintf("%v:0%v", ymd, i)
|
|
}
|
|
startTime := publicmethod.DateToTimeStampOld(createTime)
|
|
endTimeStr := fmt.Sprintf("%v:%v", ymd, i)
|
|
if i < 10 {
|
|
endTimeStr = fmt.Sprintf("%v:0%v", ymd, i)
|
|
}
|
|
endTime := publicmethod.DateToTimeStampOld(endTimeStr)
|
|
// var sumVal float64
|
|
var valAry []float64
|
|
if yVal, isOk := val.([]map[string]interface{}); isOk {
|
|
for _, mv := range yVal {
|
|
if yVal, isOk := mv[yField]; isOk {
|
|
if xVal, isOk := mv[xField]; isOk {
|
|
pageTime, _ := publicmethod.StringToInt64(xVal)
|
|
if publicmethod.GetIntLength(pageTime) >= 13 {
|
|
startTime = startTime * 1000
|
|
endTime = endTime * 1000
|
|
}
|
|
if startTime <= pageTime && pageTime <= endTime {
|
|
minVal, err := strconv.ParseFloat(publicmethod.TypeToInterface(yVal), 64)
|
|
if err == nil {
|
|
valAry = append(valAry, minVal)
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
}
|
|
jieguo := len(valAry)
|
|
dayAry = append(dayAry, jieguo)
|
|
}
|
|
}
|
|
s.Data = dayAry
|
|
case "second":
|
|
var dayAry []interface{}
|
|
|
|
startTime, endTime := publicmethod.TimeUnixDayStartAndEnd(tayTime)
|
|
var valAry []float64
|
|
if yVal, isOk := val.([]map[string]interface{}); isOk {
|
|
|
|
for _, mv := range yVal {
|
|
if yVal, isOk := mv[yField]; isOk {
|
|
if xVal, isOk := mv[xField]; isOk {
|
|
pageTime, _ := publicmethod.StringToInt64(xVal)
|
|
if publicmethod.GetIntLength(pageTime) >= 13 {
|
|
startTime = startTime * 1000
|
|
endTime = endTime * 1000
|
|
}
|
|
if startTime <= pageTime && pageTime <= endTime {
|
|
minVal, err := strconv.ParseFloat(publicmethod.TypeToInterface(yVal), 64)
|
|
if err == nil {
|
|
valAry = append(valAry, minVal)
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
}
|
|
jieguo := len(valAry)
|
|
dayAry = append(dayAry, jieguo)
|
|
|
|
s.Data = dayAry
|
|
case "ymdhms":
|
|
var dayAry []interface{}
|
|
|
|
startTime, endTime := publicmethod.TimeUnixDayStartAndEnd(tayTime)
|
|
var valAry []float64
|
|
if yVal, isOk := val.([]map[string]interface{}); isOk {
|
|
|
|
for _, mv := range yVal {
|
|
if yVal, isOk := mv[yField]; isOk {
|
|
if xVal, isOk := mv[xField]; isOk {
|
|
pageTime, _ := publicmethod.StringToInt64(xVal)
|
|
if publicmethod.GetIntLength(pageTime) >= 13 {
|
|
startTime = startTime * 1000
|
|
endTime = endTime * 1000
|
|
}
|
|
if startTime <= pageTime && pageTime <= endTime {
|
|
minVal, err := strconv.ParseFloat(publicmethod.TypeToInterface(yVal), 64)
|
|
if err == nil {
|
|
valAry = append(valAry, minVal)
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
}
|
|
jieguo := len(valAry)
|
|
dayAry = append(dayAry, jieguo)
|
|
|
|
s.Data = dayAry
|
|
|
|
default:
|
|
var valAry []float64
|
|
if yVal, isOk := val.([]map[string]interface{}); isOk {
|
|
for _, mv := range yVal {
|
|
if yVal, isOk := mv[yField]; isOk {
|
|
minVal, err := strconv.ParseFloat(publicmethod.TypeToInterface(yVal), 64)
|
|
if err == nil {
|
|
valAry = append(valAry, minVal)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
s.Data = []interface{}{len(valAry)}
|
|
}
|
|
}
|
|
|
|
// 去重计数
|
|
func (s *SeriesList) RemoveDuplicateCounts(xField, yField, types string, val interface{}, format, lenght int, timeAry []string) {
|
|
tayTime := time.Now().Unix()
|
|
switch types {
|
|
case "month":
|
|
yearVal := publicmethod.UnixTimeToDay(tayTime, 16)
|
|
yearValInt, _ := strconv.Atoi(yearVal)
|
|
var monthAry []interface{}
|
|
for i := 1; i <= lenght; i++ {
|
|
var sumVal []float64
|
|
createTime := fmt.Sprintf("%v-%v-01 00:00:00", yearVal, i)
|
|
if i < 10 {
|
|
createTime = fmt.Sprintf("%v-0%v-01 00:00:00", yearVal, i)
|
|
}
|
|
startTime := publicmethod.DateToTimeStampOld(createTime)
|
|
endTime := publicmethod.GetDaysInMonth(yearValInt, i)
|
|
|
|
if yVal, isOk := val.([]map[string]interface{}); isOk {
|
|
for _, mv := range yVal {
|
|
if yVal, isOk := mv[yField]; isOk {
|
|
if xVal, isOk := mv[xField]; isOk {
|
|
pageTime, _ := publicmethod.StringToInt64(xVal)
|
|
if publicmethod.GetIntLength(pageTime) >= 13 {
|
|
startTime = startTime * 1000
|
|
endTime.AllTime = endTime.AllTime * 1000
|
|
}
|
|
if startTime <= pageTime && pageTime <= endTime.AllTime {
|
|
minVal, err := strconv.ParseFloat(publicmethod.TypeToInterface(yVal), 64)
|
|
if err == nil {
|
|
if !publicmethod.IsInTrue[float64](minVal, sumVal) {
|
|
sumVal = append(sumVal, minVal)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
}
|
|
// jieguo := publicmethod.DataChuli(sumVal, format)
|
|
monthAry = append(monthAry, len(sumVal))
|
|
}
|
|
s.Data = monthAry
|
|
case "day":
|
|
var dayAry []interface{}
|
|
if lenght == 1 {
|
|
startTime, endTime := publicmethod.TimeUnixDayStartAndEnd(tayTime)
|
|
var sumVal []float64
|
|
if yVal, isOk := val.([]map[string]interface{}); isOk {
|
|
|
|
for _, mv := range yVal {
|
|
if yVal, isOk := mv[yField]; isOk {
|
|
if xVal, isOk := mv[xField]; isOk {
|
|
pageTime, _ := publicmethod.StringToInt64(xVal)
|
|
if publicmethod.GetIntLength(pageTime) >= 13 {
|
|
startTime = startTime * 1000
|
|
endTime = endTime * 1000
|
|
}
|
|
if startTime <= pageTime && pageTime <= endTime {
|
|
minVal, err := strconv.ParseFloat(publicmethod.TypeToInterface(yVal), 64)
|
|
if err == nil {
|
|
if !publicmethod.IsInTrue[float64](minVal, sumVal) {
|
|
sumVal = append(sumVal, minVal)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
}
|
|
// jieguo := publicmethod.DataChuli(sumVal, format)
|
|
dayAry = append(dayAry, len(sumVal))
|
|
} else {
|
|
ymd := publicmethod.UnixTimeToDay(tayTime, 14)
|
|
for i := 1; i <= lenght; i++ {
|
|
createTime := fmt.Sprintf("%v %v:00:00", ymd, i)
|
|
if i < 10 {
|
|
createTime = fmt.Sprintf("%v 0%v:00:00", ymd, i)
|
|
}
|
|
startTime := publicmethod.DateToTimeStampOld(createTime)
|
|
endTimeStr := fmt.Sprintf("%v %v:59:59", ymd, i)
|
|
if i < 10 {
|
|
endTimeStr = fmt.Sprintf("%v 0%v:59:59", ymd, i)
|
|
}
|
|
endTime := publicmethod.DateToTimeStampOld(endTimeStr)
|
|
var sumVal []float64
|
|
if yVal, isOk := val.([]map[string]interface{}); isOk {
|
|
for _, mv := range yVal {
|
|
if yVal, isOk := mv[yField]; isOk {
|
|
if xVal, isOk := mv[xField]; isOk {
|
|
pageTime, _ := publicmethod.StringToInt64(xVal)
|
|
if publicmethod.GetIntLength(pageTime) >= 13 {
|
|
startTime = startTime * 1000
|
|
endTime = endTime * 1000
|
|
}
|
|
if startTime <= pageTime && pageTime <= endTime {
|
|
minVal, err := strconv.ParseFloat(publicmethod.TypeToInterface(yVal), 64)
|
|
if err == nil {
|
|
if !publicmethod.IsInTrue[float64](minVal, sumVal) {
|
|
sumVal = append(sumVal, minVal)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
}
|
|
// jieguo := publicmethod.DataChuli(sumVal, format)
|
|
dayAry = append(dayAry, len(sumVal))
|
|
}
|
|
}
|
|
s.Data = dayAry
|
|
case "hour":
|
|
var dayAry []interface{}
|
|
if lenght == 1 {
|
|
startTime, endTime := publicmethod.TimeUnixDayStartAndEnd(tayTime)
|
|
var sumVal []float64
|
|
if yVal, isOk := val.([]map[string]interface{}); isOk {
|
|
|
|
for _, mv := range yVal {
|
|
if yVal, isOk := mv[yField]; isOk {
|
|
if xVal, isOk := mv[xField]; isOk {
|
|
pageTime, _ := publicmethod.StringToInt64(xVal)
|
|
if publicmethod.GetIntLength(pageTime) >= 13 {
|
|
startTime = startTime * 1000
|
|
endTime = endTime * 1000
|
|
}
|
|
if startTime <= pageTime && pageTime <= endTime {
|
|
minVal, err := strconv.ParseFloat(publicmethod.TypeToInterface(yVal), 64)
|
|
if err == nil {
|
|
if !publicmethod.IsInTrue[float64](minVal, sumVal) {
|
|
sumVal = append(sumVal, minVal)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
}
|
|
jieguo := len(sumVal)
|
|
dayAry = append(dayAry, jieguo)
|
|
} else {
|
|
ymd := publicmethod.UnixTimeToDay(tayTime, 13)
|
|
for i := 1; i <= lenght; i++ {
|
|
createTime := fmt.Sprintf("%v:%v:00", ymd, i)
|
|
if i < 10 {
|
|
createTime = fmt.Sprintf("%v:0%v:00", ymd, i)
|
|
}
|
|
startTime := publicmethod.DateToTimeStampOld(createTime)
|
|
endTimeStr := fmt.Sprintf("%v:%v:59", ymd, i)
|
|
if i < 10 {
|
|
endTimeStr = fmt.Sprintf("%v:0%v:59", ymd, i)
|
|
}
|
|
endTime := publicmethod.DateToTimeStampOld(endTimeStr)
|
|
var sumVal []float64
|
|
if yVal, isOk := val.([]map[string]interface{}); isOk {
|
|
for _, mv := range yVal {
|
|
if yVal, isOk := mv[yField]; isOk {
|
|
if xVal, isOk := mv[xField]; isOk {
|
|
pageTime, _ := publicmethod.StringToInt64(xVal)
|
|
if publicmethod.GetIntLength(pageTime) >= 13 {
|
|
startTime = startTime * 1000
|
|
endTime = endTime * 1000
|
|
}
|
|
if startTime <= pageTime && pageTime <= endTime {
|
|
minVal, err := strconv.ParseFloat(publicmethod.TypeToInterface(yVal), 64)
|
|
if err == nil {
|
|
if !publicmethod.IsInTrue[float64](minVal, sumVal) {
|
|
sumVal = append(sumVal, minVal)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
}
|
|
jieguo := len(sumVal)
|
|
dayAry = append(dayAry, jieguo)
|
|
}
|
|
}
|
|
s.Data = dayAry
|
|
case "minute":
|
|
var dayAry []interface{}
|
|
if lenght == 1 {
|
|
startTime, endTime := publicmethod.TimeUnixDayStartAndEnd(tayTime)
|
|
var valAry []float64
|
|
if yVal, isOk := val.([]map[string]interface{}); isOk {
|
|
|
|
for _, mv := range yVal {
|
|
if yVal, isOk := mv[yField]; isOk {
|
|
if xVal, isOk := mv[xField]; isOk {
|
|
pageTime, _ := publicmethod.StringToInt64(xVal)
|
|
if publicmethod.GetIntLength(pageTime) >= 13 {
|
|
startTime = startTime * 1000
|
|
endTime = endTime * 1000
|
|
}
|
|
if startTime <= pageTime && pageTime <= endTime {
|
|
minVal, err := strconv.ParseFloat(publicmethod.TypeToInterface(yVal), 64)
|
|
if err == nil {
|
|
if !publicmethod.IsInTrue[float64](minVal, valAry) {
|
|
valAry = append(valAry, minVal)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
}
|
|
jieguo := len(valAry)
|
|
dayAry = append(dayAry, jieguo)
|
|
} else {
|
|
ymd := publicmethod.UnixTimeToDay(tayTime, 12)
|
|
for i := 1; i <= lenght; i++ {
|
|
createTime := fmt.Sprintf("%v:%v", ymd, i)
|
|
if i < 10 {
|
|
createTime = fmt.Sprintf("%v:0%v", ymd, i)
|
|
}
|
|
startTime := publicmethod.DateToTimeStampOld(createTime)
|
|
endTimeStr := fmt.Sprintf("%v:%v", ymd, i)
|
|
if i < 10 {
|
|
endTimeStr = fmt.Sprintf("%v:0%v", ymd, i)
|
|
}
|
|
endTime := publicmethod.DateToTimeStampOld(endTimeStr)
|
|
// var sumVal float64
|
|
var valAry []float64
|
|
if yVal, isOk := val.([]map[string]interface{}); isOk {
|
|
for _, mv := range yVal {
|
|
if yVal, isOk := mv[yField]; isOk {
|
|
if xVal, isOk := mv[xField]; isOk {
|
|
pageTime, _ := publicmethod.StringToInt64(xVal)
|
|
if publicmethod.GetIntLength(pageTime) >= 13 {
|
|
startTime = startTime * 1000
|
|
endTime = endTime * 1000
|
|
}
|
|
if startTime <= pageTime && pageTime <= endTime {
|
|
minVal, err := strconv.ParseFloat(publicmethod.TypeToInterface(yVal), 64)
|
|
if err == nil {
|
|
if !publicmethod.IsInTrue[float64](minVal, valAry) {
|
|
valAry = append(valAry, minVal)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
}
|
|
jieguo := len(valAry)
|
|
dayAry = append(dayAry, jieguo)
|
|
}
|
|
}
|
|
s.Data = dayAry
|
|
case "second":
|
|
var dayAry []interface{}
|
|
|
|
startTime, endTime := publicmethod.TimeUnixDayStartAndEnd(tayTime)
|
|
var valAry []float64
|
|
if yVal, isOk := val.([]map[string]interface{}); isOk {
|
|
|
|
for _, mv := range yVal {
|
|
if yVal, isOk := mv[yField]; isOk {
|
|
if xVal, isOk := mv[xField]; isOk {
|
|
pageTime, _ := publicmethod.StringToInt64(xVal)
|
|
if publicmethod.GetIntLength(pageTime) >= 13 {
|
|
startTime = startTime * 1000
|
|
endTime = endTime * 1000
|
|
}
|
|
if startTime <= pageTime && pageTime <= endTime {
|
|
minVal, err := strconv.ParseFloat(publicmethod.TypeToInterface(yVal), 64)
|
|
if err == nil {
|
|
if !publicmethod.IsInTrue[float64](minVal, valAry) {
|
|
valAry = append(valAry, minVal)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
}
|
|
jieguo := len(valAry)
|
|
dayAry = append(dayAry, jieguo)
|
|
|
|
s.Data = dayAry
|
|
case "ymdhms":
|
|
var dayAry []interface{}
|
|
|
|
startTime, endTime := publicmethod.TimeUnixDayStartAndEnd(tayTime)
|
|
var valAry []float64
|
|
if yVal, isOk := val.([]map[string]interface{}); isOk {
|
|
|
|
for _, mv := range yVal {
|
|
if yVal, isOk := mv[yField]; isOk {
|
|
if xVal, isOk := mv[xField]; isOk {
|
|
pageTime, _ := publicmethod.StringToInt64(xVal)
|
|
if publicmethod.GetIntLength(pageTime) >= 13 {
|
|
startTime = startTime * 1000
|
|
endTime = endTime * 1000
|
|
}
|
|
if startTime <= pageTime && pageTime <= endTime {
|
|
minVal, err := strconv.ParseFloat(publicmethod.TypeToInterface(yVal), 64)
|
|
if err == nil {
|
|
if !publicmethod.IsInTrue[float64](minVal, valAry) {
|
|
valAry = append(valAry, minVal)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
}
|
|
jieguo := len(valAry)
|
|
dayAry = append(dayAry, jieguo)
|
|
|
|
s.Data = dayAry
|
|
|
|
default:
|
|
var valAry []float64
|
|
if yVal, isOk := val.([]map[string]interface{}); isOk {
|
|
for _, mv := range yVal {
|
|
if yVal, isOk := mv[yField]; isOk {
|
|
minVal, err := strconv.ParseFloat(publicmethod.TypeToInterface(yVal), 64)
|
|
if err == nil {
|
|
if !publicmethod.IsInTrue[float64](minVal, valAry) {
|
|
valAry = append(valAry, minVal)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
s.Data = []interface{}{len(valAry)}
|
|
}
|
|
}
|
|
|
|
// 求和
|
|
func (s *SeriesList) sumData(xField, yField, types string, val interface{}, format, lenght int, timeAry []string) {
|
|
fmt.Printf("求和------------>%v\n\n", lenght)
|
|
tayTime := time.Now().Unix()
|
|
switch types {
|
|
case "month":
|
|
yearVal := publicmethod.UnixTimeToDay(tayTime, 16)
|
|
yearValInt, _ := strconv.Atoi(yearVal)
|
|
var monthAry []interface{}
|
|
for i := 1; i <= lenght; i++ {
|
|
var sumVal float64
|
|
createTime := fmt.Sprintf("%v-%v-01 00:00:00", yearVal, i)
|
|
if i < 10 {
|
|
createTime = fmt.Sprintf("%v-0%v-01 00:00:00", yearVal, i)
|
|
}
|
|
startTime := publicmethod.DateToTimeStampOld(createTime)
|
|
endTime := publicmethod.GetDaysInMonth(yearValInt, i)
|
|
|
|
if yVal, isOk := val.([]map[string]interface{}); isOk {
|
|
for _, mv := range yVal {
|
|
if yVal, isOk := mv[yField]; isOk {
|
|
if xVal, isOk := mv[xField]; isOk {
|
|
pageTime, _ := publicmethod.StringToInt64(xVal)
|
|
if publicmethod.GetIntLength(pageTime) >= 13 {
|
|
startTime = startTime * 1000
|
|
endTime.AllTime = endTime.AllTime * 1000
|
|
}
|
|
if startTime <= pageTime && pageTime <= endTime.AllTime {
|
|
minVal, err := strconv.ParseFloat(publicmethod.TypeToInterface(yVal), 64)
|
|
if err == nil {
|
|
sumVal = sumVal + minVal
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
}
|
|
jieguo := publicmethod.DataChuli(sumVal, format)
|
|
monthAry = append(monthAry, jieguo)
|
|
}
|
|
s.Data = monthAry
|
|
case "day":
|
|
var dayAry []interface{}
|
|
if lenght == 1 {
|
|
startTime, endTime := publicmethod.TimeUnixDayStartAndEnd(tayTime)
|
|
var sumVal float64
|
|
if yVal, isOk := val.([]map[string]interface{}); isOk {
|
|
|
|
for _, mv := range yVal {
|
|
if yVal, isOk := mv[yField]; isOk {
|
|
if xVal, isOk := mv[xField]; isOk {
|
|
pageTime, _ := publicmethod.StringToInt64(xVal)
|
|
if publicmethod.GetIntLength(pageTime) >= 13 {
|
|
startTime = startTime * 1000
|
|
endTime = endTime * 1000
|
|
}
|
|
|
|
if startTime <= pageTime && pageTime <= endTime {
|
|
minVal, err := strconv.ParseFloat(publicmethod.TypeToInterface(yVal), 64)
|
|
if err == nil {
|
|
sumVal = sumVal + minVal
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
}
|
|
jieguo := publicmethod.DataChuli(sumVal, format)
|
|
dayAry = append(dayAry, jieguo)
|
|
} else {
|
|
ymd := publicmethod.UnixTimeToDay(tayTime, 15)
|
|
for i := 1; i <= lenght; i++ {
|
|
createTime := fmt.Sprintf("%v-%v 00:00:00", ymd, i)
|
|
if i < 10 {
|
|
createTime = fmt.Sprintf("%v-0%v 00:00:00", ymd, i)
|
|
}
|
|
startTime := publicmethod.DateToTimeStampOld(createTime)
|
|
endTimeStr := fmt.Sprintf("%v-%v 23:59:59", ymd, i)
|
|
if i < 10 {
|
|
endTimeStr = fmt.Sprintf("%v-0%v 23:59:59", ymd, i)
|
|
}
|
|
endTime := publicmethod.DateToTimeStampOld(endTimeStr)
|
|
var sumVal float64
|
|
if yVal, isOk := val.([]map[string]interface{}); isOk {
|
|
for _, mv := range yVal {
|
|
if yVal, isOk := mv[yField]; isOk {
|
|
if xVal, isOk := mv[xField]; isOk {
|
|
pageTime, _ := publicmethod.StringToInt64(xVal)
|
|
if publicmethod.GetIntLength(pageTime) >= 13 {
|
|
startTime = startTime * 1000
|
|
endTime = endTime * 1000
|
|
}
|
|
// fmt.Printf("startTime:%v====>pageTime%v=======endTime%v\n\n", startTime, pageTime, endTime)
|
|
if startTime <= pageTime && pageTime <= endTime {
|
|
|
|
minVal, err := strconv.ParseFloat(publicmethod.TypeToInterface(yVal), 64)
|
|
if err == nil {
|
|
sumVal = sumVal + minVal
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
}
|
|
jieguo := publicmethod.DataChuli(sumVal, format)
|
|
dayAry = append(dayAry, jieguo)
|
|
}
|
|
}
|
|
s.Data = dayAry
|
|
case "hour":
|
|
var dayAry []interface{}
|
|
if lenght == 1 {
|
|
startTime, endTime := publicmethod.TimeUnixDayStartAndEnd(tayTime)
|
|
var sumVal float64
|
|
if yVal, isOk := val.([]map[string]interface{}); isOk {
|
|
|
|
for _, mv := range yVal {
|
|
if yVal, isOk := mv[yField]; isOk {
|
|
if xVal, isOk := mv[xField]; isOk {
|
|
pageTime, _ := publicmethod.StringToInt64(xVal)
|
|
if publicmethod.GetIntLength(pageTime) >= 13 {
|
|
startTime = startTime * 1000
|
|
endTime = endTime * 1000
|
|
}
|
|
if startTime <= pageTime && pageTime <= endTime {
|
|
minVal, err := strconv.ParseFloat(publicmethod.TypeToInterface(yVal), 64)
|
|
if err == nil {
|
|
sumVal = sumVal + minVal
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
}
|
|
jieguo := publicmethod.DataChuli(sumVal, format)
|
|
dayAry = append(dayAry, jieguo)
|
|
} else {
|
|
ymd := publicmethod.UnixTimeToDay(tayTime, 13)
|
|
for i := 1; i <= lenght; i++ {
|
|
createTime := fmt.Sprintf("%v:%v:00", ymd, i)
|
|
if i < 10 {
|
|
createTime = fmt.Sprintf("%v:0%v:00", ymd, i)
|
|
}
|
|
startTime := publicmethod.DateToTimeStampOld(createTime)
|
|
endTimeStr := fmt.Sprintf("%v:%v:59", ymd, i)
|
|
if i < 10 {
|
|
endTimeStr = fmt.Sprintf("%v:0%v:59", ymd, i)
|
|
}
|
|
endTime := publicmethod.DateToTimeStampOld(endTimeStr)
|
|
var sumVal float64
|
|
if yVal, isOk := val.([]map[string]interface{}); isOk {
|
|
for _, mv := range yVal {
|
|
if yVal, isOk := mv[yField]; isOk {
|
|
if xVal, isOk := mv[xField]; isOk {
|
|
pageTime, _ := publicmethod.StringToInt64(xVal)
|
|
if publicmethod.GetIntLength(pageTime) >= 13 {
|
|
startTime = startTime * 1000
|
|
endTime = endTime * 1000
|
|
}
|
|
if startTime <= pageTime && pageTime <= endTime {
|
|
minVal, err := strconv.ParseFloat(publicmethod.TypeToInterface(yVal), 64)
|
|
if err == nil {
|
|
sumVal = sumVal + minVal
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
}
|
|
jieguo := publicmethod.DataChuli(sumVal, format)
|
|
dayAry = append(dayAry, jieguo)
|
|
}
|
|
}
|
|
s.Data = dayAry
|
|
case "minute":
|
|
var dayAry []interface{}
|
|
if lenght == 1 {
|
|
startTime, endTime := publicmethod.TimeUnixDayStartAndEnd(tayTime)
|
|
var sumVal float64
|
|
if yVal, isOk := val.([]map[string]interface{}); isOk {
|
|
|
|
for _, mv := range yVal {
|
|
if yVal, isOk := mv[yField]; isOk {
|
|
if xVal, isOk := mv[xField]; isOk {
|
|
pageTime, _ := publicmethod.StringToInt64(xVal)
|
|
if publicmethod.GetIntLength(pageTime) >= 13 {
|
|
startTime = startTime * 1000
|
|
endTime = endTime * 1000
|
|
}
|
|
if startTime <= pageTime && pageTime <= endTime {
|
|
minVal, err := strconv.ParseFloat(publicmethod.TypeToInterface(yVal), 64)
|
|
if err == nil {
|
|
sumVal = sumVal + minVal
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
}
|
|
jieguo := publicmethod.DataChuli(sumVal, format)
|
|
dayAry = append(dayAry, jieguo)
|
|
} else {
|
|
ymd := publicmethod.UnixTimeToDay(tayTime, 12)
|
|
for i := 1; i <= lenght; i++ {
|
|
createTime := fmt.Sprintf("%v:%v", ymd, i)
|
|
if i < 10 {
|
|
createTime = fmt.Sprintf("%v:0%v", ymd, i)
|
|
}
|
|
startTime := publicmethod.DateToTimeStampOld(createTime)
|
|
endTimeStr := fmt.Sprintf("%v:%v", ymd, i)
|
|
if i < 10 {
|
|
endTimeStr = fmt.Sprintf("%v:0%v", ymd, i)
|
|
}
|
|
endTime := publicmethod.DateToTimeStampOld(endTimeStr)
|
|
var sumVal float64
|
|
if yVal, isOk := val.([]map[string]interface{}); isOk {
|
|
for _, mv := range yVal {
|
|
if yVal, isOk := mv[yField]; isOk {
|
|
if xVal, isOk := mv[xField]; isOk {
|
|
pageTime, _ := publicmethod.StringToInt64(xVal)
|
|
if publicmethod.GetIntLength(pageTime) >= 13 {
|
|
startTime = startTime * 1000
|
|
endTime = endTime * 1000
|
|
}
|
|
if startTime <= pageTime && pageTime <= endTime {
|
|
minVal, err := strconv.ParseFloat(publicmethod.TypeToInterface(yVal), 64)
|
|
if err == nil {
|
|
sumVal = sumVal + minVal
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
}
|
|
jieguo := publicmethod.DataChuli(sumVal, format)
|
|
dayAry = append(dayAry, jieguo)
|
|
}
|
|
}
|
|
s.Data = dayAry
|
|
case "second":
|
|
var dayAry []interface{}
|
|
|
|
startTime, endTime := publicmethod.TimeUnixDayStartAndEnd(tayTime)
|
|
var sumVal float64
|
|
if yVal, isOk := val.([]map[string]interface{}); isOk {
|
|
|
|
for _, mv := range yVal {
|
|
if yVal, isOk := mv[yField]; isOk {
|
|
if xVal, isOk := mv[xField]; isOk {
|
|
pageTime, _ := publicmethod.StringToInt64(xVal)
|
|
if publicmethod.GetIntLength(pageTime) >= 13 {
|
|
startTime = startTime * 1000
|
|
endTime = endTime * 1000
|
|
}
|
|
if startTime <= pageTime && pageTime <= endTime {
|
|
minVal, err := strconv.ParseFloat(publicmethod.TypeToInterface(yVal), 64)
|
|
if err == nil {
|
|
sumVal = sumVal + minVal
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
}
|
|
jieguo := publicmethod.DataChuli(sumVal, format)
|
|
dayAry = append(dayAry, jieguo)
|
|
|
|
s.Data = dayAry
|
|
case "ymdhms":
|
|
var dayAry []interface{}
|
|
|
|
startTime, endTime := publicmethod.TimeUnixDayStartAndEnd(tayTime)
|
|
var sumVal float64
|
|
if yVal, isOk := val.([]map[string]interface{}); isOk {
|
|
|
|
for _, mv := range yVal {
|
|
if yVal, isOk := mv[yField]; isOk {
|
|
if xVal, isOk := mv[xField]; isOk {
|
|
pageTime, _ := publicmethod.StringToInt64(xVal)
|
|
if publicmethod.GetIntLength(pageTime) >= 13 {
|
|
startTime = startTime * 1000
|
|
endTime = endTime * 1000
|
|
}
|
|
if startTime <= pageTime && pageTime <= endTime {
|
|
minVal, err := strconv.ParseFloat(publicmethod.TypeToInterface(yVal), 64)
|
|
if err == nil {
|
|
sumVal = sumVal + minVal
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
}
|
|
jieguo := publicmethod.DataChuli(sumVal, format)
|
|
dayAry = append(dayAry, jieguo)
|
|
|
|
s.Data = dayAry
|
|
default:
|
|
var sumVal float64
|
|
if yVal, isOk := val.([]map[string]interface{}); isOk {
|
|
for _, mv := range yVal {
|
|
if yVal, isOk := mv[yField]; isOk {
|
|
minVal, err := strconv.ParseFloat(publicmethod.TypeToInterface(yVal), 64)
|
|
if err == nil {
|
|
sumVal = sumVal + minVal
|
|
}
|
|
}
|
|
}
|
|
}
|
|
jieguo := publicmethod.DataChuli(sumVal, format)
|
|
s.Data = []interface{}{jieguo}
|
|
}
|
|
}
|
|
|
|
// 求最小值
|
|
func (s *SeriesList) maxData(xField, yField, types string, val interface{}, format, lenght int, timeAry []string) {
|
|
var valData float64 = 1
|
|
tayTime := time.Now().Unix()
|
|
switch types {
|
|
case "month":
|
|
yearVal := publicmethod.UnixTimeToDay(tayTime, 16)
|
|
yearValInt, _ := strconv.Atoi(yearVal)
|
|
var monthAry []interface{}
|
|
for i := 1; i <= lenght; i++ {
|
|
createTime := fmt.Sprintf("%v-%v-01 00:00:00", yearVal, i)
|
|
if i < 10 {
|
|
createTime = fmt.Sprintf("%v-0%v-01 00:00:00", yearVal, i)
|
|
}
|
|
startTime := publicmethod.DateToTimeStampOld(createTime)
|
|
endTime := publicmethod.GetDaysInMonth(yearValInt, i)
|
|
|
|
if yVal, isOk := val.([]map[string]interface{}); isOk {
|
|
for _, mv := range yVal {
|
|
if yVal, isOk := mv[yField]; isOk {
|
|
if xVal, isOk := mv[xField]; isOk {
|
|
pageTime, _ := publicmethod.StringToInt64(xVal)
|
|
// pageTimeLen := publicmethod.GetIntLength(pageTime)
|
|
if publicmethod.GetIntLength(pageTime) >= 13 {
|
|
startTime = startTime * 1000
|
|
endTime.AllTime = endTime.AllTime * 1000
|
|
}
|
|
if startTime <= pageTime && pageTime <= endTime.AllTime {
|
|
minVal, err := strconv.ParseFloat(publicmethod.TypeToInterface(yVal), 64)
|
|
if err == nil {
|
|
if valData <= minVal {
|
|
valData = minVal
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
}
|
|
jieguo := publicmethod.DataChuli(valData, format)
|
|
monthAry = append(monthAry, jieguo)
|
|
}
|
|
s.Data = monthAry
|
|
case "day":
|
|
var dayAry []interface{}
|
|
if lenght == 1 {
|
|
startTime, endTime := publicmethod.TimeUnixDayStartAndEnd(tayTime)
|
|
if yVal, isOk := val.([]map[string]interface{}); isOk {
|
|
for _, mv := range yVal {
|
|
if yVal, isOk := mv[yField]; isOk {
|
|
if xVal, isOk := mv[xField]; isOk {
|
|
pageTime, _ := publicmethod.StringToInt64(xVal)
|
|
if publicmethod.GetIntLength(pageTime) >= 13 {
|
|
startTime = startTime * 1000
|
|
endTime = endTime * 1000
|
|
}
|
|
if startTime <= pageTime && pageTime <= endTime {
|
|
minVal, err := strconv.ParseFloat(publicmethod.TypeToInterface(yVal), 64)
|
|
if err == nil {
|
|
if valData <= minVal {
|
|
valData = minVal
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
}
|
|
jieguo := publicmethod.DataChuli(valData, format)
|
|
dayAry = append(dayAry, jieguo)
|
|
} else {
|
|
ymd := publicmethod.UnixTimeToDay(tayTime, 14)
|
|
for i := 1; i <= lenght; i++ {
|
|
createTime := fmt.Sprintf("%v %v:00:00", ymd, i)
|
|
if i < 10 {
|
|
createTime = fmt.Sprintf("%v 0%v:00:00", ymd, i)
|
|
}
|
|
startTime := publicmethod.DateToTimeStampOld(createTime)
|
|
endTimeStr := fmt.Sprintf("%v %v:59:59", ymd, i)
|
|
if i < 10 {
|
|
endTimeStr = fmt.Sprintf("%v 0%v:59:59", ymd, i)
|
|
}
|
|
endTime := publicmethod.DateToTimeStampOld(endTimeStr)
|
|
|
|
if yVal, isOk := val.([]map[string]interface{}); isOk {
|
|
for _, mv := range yVal {
|
|
if yVal, isOk := mv[yField]; isOk {
|
|
if xVal, isOk := mv[xField]; isOk {
|
|
pageTime, _ := publicmethod.StringToInt64(xVal)
|
|
if publicmethod.GetIntLength(pageTime) >= 13 {
|
|
startTime = startTime * 1000
|
|
endTime = endTime * 1000
|
|
}
|
|
if startTime <= pageTime && pageTime <= endTime {
|
|
minVal, err := strconv.ParseFloat(publicmethod.TypeToInterface(yVal), 64)
|
|
if err == nil {
|
|
if valData <= minVal {
|
|
valData = minVal
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
}
|
|
jieguo := publicmethod.DataChuli(valData, format)
|
|
dayAry = append(dayAry, jieguo)
|
|
}
|
|
}
|
|
s.Data = dayAry
|
|
default:
|
|
if yVal, isOk := val.([]map[string]interface{}); isOk {
|
|
for _, mv := range yVal {
|
|
if yVal, isOk := mv[yField]; isOk {
|
|
minVal, err := strconv.ParseFloat(publicmethod.TypeToInterface(yVal), 64)
|
|
if err == nil {
|
|
if valData <= minVal {
|
|
valData = minVal
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
}
|
|
jieguo := publicmethod.DataChuli(valData, format)
|
|
s.Data = []interface{}{jieguo}
|
|
}
|
|
return
|
|
}
|
|
|
|
// 求最小值
|
|
func (s *SeriesList) minData(xField, yField, types string, val interface{}, format, lenght int, timeAry []string) {
|
|
var valData float64 = 1
|
|
tayTime := time.Now().Unix()
|
|
switch types {
|
|
case "month":
|
|
yearVal := publicmethod.UnixTimeToDay(tayTime, 16)
|
|
yearValInt, _ := strconv.Atoi(yearVal)
|
|
var monthAry []interface{}
|
|
for i := 1; i <= lenght; i++ {
|
|
createTime := fmt.Sprintf("%v-%v-01 00:00:00", yearVal, i)
|
|
if i < 10 {
|
|
createTime = fmt.Sprintf("%v-0%v-01 00:00:00", yearVal, i)
|
|
}
|
|
startTime := publicmethod.DateToTimeStampOld(createTime)
|
|
endTime := publicmethod.GetDaysInMonth(yearValInt, i)
|
|
|
|
if yVal, isOk := val.([]map[string]interface{}); isOk {
|
|
for _, mv := range yVal {
|
|
if yVal, isOk := mv[yField]; isOk {
|
|
if xVal, isOk := mv[xField]; isOk {
|
|
pageTime, _ := publicmethod.StringToInt64(xVal)
|
|
if startTime <= pageTime && pageTime <= endTime.AllTime {
|
|
minVal, err := strconv.ParseFloat(publicmethod.TypeToInterface(yVal), 64)
|
|
if err == nil {
|
|
if valData >= minVal {
|
|
valData = minVal
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
}
|
|
jieguo := publicmethod.DataChuli(valData, format)
|
|
monthAry = append(monthAry, jieguo)
|
|
}
|
|
s.Data = monthAry
|
|
case "day":
|
|
var dayAry []interface{}
|
|
if lenght == 1 {
|
|
startTime, endTime := publicmethod.TimeUnixDayStartAndEnd(tayTime)
|
|
if yVal, isOk := val.([]map[string]interface{}); isOk {
|
|
for _, mv := range yVal {
|
|
if yVal, isOk := mv[yField]; isOk {
|
|
if xVal, isOk := mv[xField]; isOk {
|
|
pageTime, _ := publicmethod.StringToInt64(xVal)
|
|
if startTime <= pageTime && pageTime <= endTime {
|
|
minVal, err := strconv.ParseFloat(publicmethod.TypeToInterface(yVal), 64)
|
|
if err == nil {
|
|
if valData >= minVal {
|
|
valData = minVal
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
}
|
|
jieguo := publicmethod.DataChuli(valData, format)
|
|
dayAry = append(dayAry, jieguo)
|
|
} else {
|
|
ymd := publicmethod.UnixTimeToDay(tayTime, 14)
|
|
for i := 1; i <= lenght; i++ {
|
|
createTime := fmt.Sprintf("%v %v:00:00", ymd, i)
|
|
if i < 10 {
|
|
createTime = fmt.Sprintf("%v 0%v:00:00", ymd, i)
|
|
}
|
|
startTime := publicmethod.DateToTimeStampOld(createTime)
|
|
endTimeStr := fmt.Sprintf("%v %v:59:59", ymd, i)
|
|
if i < 10 {
|
|
endTimeStr = fmt.Sprintf("%v 0%v:59:59", ymd, i)
|
|
}
|
|
endTime := publicmethod.DateToTimeStampOld(endTimeStr)
|
|
|
|
if yVal, isOk := val.([]map[string]interface{}); isOk {
|
|
for _, mv := range yVal {
|
|
if yVal, isOk := mv[yField]; isOk {
|
|
if xVal, isOk := mv[xField]; isOk {
|
|
pageTime, _ := publicmethod.StringToInt64(xVal)
|
|
if startTime <= pageTime && pageTime <= endTime {
|
|
minVal, err := strconv.ParseFloat(publicmethod.TypeToInterface(yVal), 64)
|
|
if err == nil {
|
|
if valData >= minVal {
|
|
valData = minVal
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
}
|
|
jieguo := publicmethod.DataChuli(valData, format)
|
|
dayAry = append(dayAry, jieguo)
|
|
}
|
|
}
|
|
s.Data = dayAry
|
|
default:
|
|
if yVal, isOk := val.([]map[string]interface{}); isOk {
|
|
for _, mv := range yVal {
|
|
if yVal, isOk := mv[yField]; isOk {
|
|
minVal, err := strconv.ParseFloat(publicmethod.TypeToInterface(yVal), 64)
|
|
if err == nil {
|
|
if valData >= minVal {
|
|
valData = minVal
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
}
|
|
jieguo := publicmethod.DataChuli(valData, format)
|
|
s.Data = []interface{}{jieguo}
|
|
}
|
|
// fmt.Printf("\n\nyVal =====> %v =====> =====> %v =====> %v\n\n", yField, valData, valData)
|
|
return
|
|
}
|
|
|