appPlatform/api/version1/customChartes/bar.go

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
}