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.
1791 lines
51 KiB
1791 lines
51 KiB
package customChartes
|
|
|
|
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"
|
|
switch x.TimeType {
|
|
case "year":
|
|
yearVal := publicmethod.UnixTimeToDay(tayTime, 16)
|
|
charData.XAxis.Data = []string{yearVal}
|
|
charData.CalculateNumericalValues(y, val, x.Field, chartType, "all", 12)
|
|
case "month":
|
|
var timeList []string
|
|
tayTime := int(time.Now().Month())
|
|
for i := 1; i <= tayTime; i++ {
|
|
timeList = append(timeList, fmt.Sprintf("%v月", i))
|
|
}
|
|
charData.XAxis.Data = timeList
|
|
charData.CalculateNumericalValues(y, val, x.Field, chartType, "month", tayTime)
|
|
case "day":
|
|
// tayTime := int(time.Now().Day())
|
|
yearVal := publicmethod.UnixTimeToDay(tayTime, 4)
|
|
charData.XAxis.Data = []string{yearVal}
|
|
charData.CalculateNumericalValues(y, val, x.Field, chartType, "day", 1)
|
|
|
|
case "hour":
|
|
var timeList []string
|
|
yearVal := publicmethod.UnixTimeToDay(tayTime, 7)
|
|
ymd := publicmethod.UnixTimeToDay(tayTime, 4)
|
|
hourInt, _ := strconv.Atoi(yearVal)
|
|
for i := 1; i <= hourInt; i++ {
|
|
timeList = append(timeList, fmt.Sprintf("%v 时", ymd, i))
|
|
}
|
|
charData.XAxis.Data = timeList
|
|
charData.CalculateNumericalValues(y, val, x.Field, chartType, "hour", hourInt)
|
|
case "minute":
|
|
var timeList []string
|
|
yearVal := publicmethod.UnixTimeToDay(tayTime, 9)
|
|
ymd := publicmethod.UnixTimeToDay(tayTime, 3)
|
|
hourInt, _ := strconv.Atoi(yearVal)
|
|
for i := 1; i <= hourInt; i++ {
|
|
timeList = append(timeList, fmt.Sprintf("%v", ymd, i))
|
|
}
|
|
charData.XAxis.Data = timeList
|
|
charData.CalculateNumericalValues(y, val, x.Field, chartType, "minute", hourInt)
|
|
case "second":
|
|
var timeList []string
|
|
yearVal := publicmethod.UnixTimeToDay(tayTime, 10)
|
|
ymd := publicmethod.UnixTimeToDay(tayTime, 2)
|
|
hourInt, _ := strconv.Atoi(yearVal)
|
|
for i := 1; i <= hourInt; i++ {
|
|
timeList = append(timeList, fmt.Sprintf("%v", ymd, i))
|
|
}
|
|
charData.XAxis.Data = timeList
|
|
charData.CalculateNumericalValues(y, val, x.Field, chartType, "second", hourInt)
|
|
default:
|
|
var timeList []string
|
|
tayTime := int(time.Now().Month())
|
|
for i := 1; i <= tayTime; i++ {
|
|
timeList = append(timeList, fmt.Sprintf("%v月", i))
|
|
}
|
|
charData.XAxis.Data = timeList
|
|
charData.CalculateNumericalValues(y, val, x.Field, chartType, "month", tayTime)
|
|
}
|
|
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) {
|
|
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)
|
|
case 3:
|
|
seriesInfo.StatisticalQuantity(xField, v.Field, types, val, v.Format, lenght)
|
|
case 4:
|
|
seriesInfo.RemoveDuplicateCounts(xField, v.Field, types, val, v.Format, lenght)
|
|
case 5:
|
|
seriesInfo.maxData(xField, v.Field, types, val, v.Format, lenght)
|
|
case 6:
|
|
seriesInfo.minData(xField, v.Field, types, val, v.Format, lenght)
|
|
default:
|
|
seriesInfo.sumData(xField, v.Field, types, val, v.Format, lenght)
|
|
}
|
|
|
|
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) {
|
|
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) {
|
|
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) {
|
|
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) {
|
|
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, 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 = 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) {
|
|
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) {
|
|
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
|
|
}
|
|
|