eta_api/services/data/chart_info.go

package data

import (
	"encoding/json"
	"errors"
	"eta/eta_api/models"
	"eta/eta_api/models/company"
	"eta/eta_api/models/data_manage"
	"eta/eta_api/models/system"
	"eta/eta_api/services/alarm_msg"
	"eta/eta_api/services/data/data_manage_permission"
	"eta/eta_api/utils"
	"fmt"
	"github.com/shopspring/decimal"
	"math"
	"sort"
	"strconv"
	"strings"
	"time"
)

func ChartInfoRefreshV1(chartInfoId int) (err error) {
	var errmsg string
	defer func() {
		if err != nil {
			go alarm_msg.SendAlarmMsg("ChartInfoRefresh:"+errmsg, 3)
			//go utils.SendEmail(utils.APPNAME+"【"+utils.RunMode+"】"+"失败提醒", "ChartInfoRefresh:"+errmsg, utils.EmailSendToUsers)
			fmt.Println("ChartInfoRefresh Err:" + errmsg)
		}
	}()
	baseEdbInfoArr, calculateInfoArr, err := data_manage.GetChartInfoRefreshData(chartInfoId)
	if err != nil {
		errmsg = "获取需要刷新的指标失败:Err:" + err.Error()
		return
	}

	newBaseEdbInfoArr := make([]*data_manage.EdbInfo, 0)
	baseMap := make(map[int]*data_manage.EdbInfo)
	for _, bv := range baseEdbInfoArr {
		// 如果不是普通指标，那么过滤
		if bv.EdbInfoType != 0 {
			continue
		}
		if _, ok := baseMap[bv.EdbInfoId]; !ok {
			newBaseEdbInfoArr = append(newBaseEdbInfoArr, bv)
		}
		baseMap[bv.EdbInfoId] = bv
	}

	fmt.Println("calculateInfoArr:", len(calculateInfoArr))

	newCalculateInfoArr := make([]*data_manage.EdbInfo, 0)
	calculateMap := make(map[int]*data_manage.EdbInfo)
	var calculateArr []int
	for _, bv := range calculateInfoArr {
		if _, ok := calculateMap[bv.EdbInfoId]; !ok {
			newCalculateInfoArr = append(newCalculateInfoArr, bv)
			calculateArr = append(calculateArr, bv.EdbInfoId)
		}
		calculateMap[bv.EdbInfoId] = bv
	}
	sort.Ints(calculateArr)

	// 刷新相关基础指标
	for _, bv := range newBaseEdbInfoArr {
		err, errmsg = refreshBaseEdbInfo(bv)
		if err != nil {
			return
		}
	}

	// 刷新相关计算指标
	for _, v := range calculateArr {
		edbInfo := calculateMap[v]
		if edbInfo == nil {
			return err
		}
		err, errmsg = refreshCalculateEdbInfo(edbInfo)
		if err != nil {
			return
		}
	}
	return err
}

// BatchChartInfoRefresh 图表批量刷新
func BatchChartInfoRefresh(chartInfoList []*data_manage.ChartInfo) (err error) {
	if len(chartInfoList) <= 0 {
		return
	}
	chartInfoIdSlice := make([]string, 0)
	for _, chartInfo := range chartInfoList {
		chartInfoIdSlice = append(chartInfoIdSlice, strconv.Itoa(chartInfo.ChartInfoId))
	}

	var errmsg string
	defer func() {
		if err != nil {
			go alarm_msg.SendAlarmMsg("ChartInfoRefresh:"+errmsg, 3)
			//go utils.SendEmail(utils.APPNAME+"【"+utils.RunMode+"】"+"失败提醒", "ChartInfoRefresh:"+errmsg, utils.EmailSendToUsers)
			fmt.Println("ChartInfoRefresh Err:" + errmsg)
		}
	}()
	baseEdbInfoArr, calculateInfoArr, err := data_manage.GetChartInfoRefreshDataByChartInfoIdSlice(chartInfoIdSlice)
	if err != nil {
		errmsg = "获取需要刷新的指标失败:Err:" + err.Error()
		return
	}

	//基础指标去重
	newBaseEdbInfoArr := make([]*data_manage.EdbInfo, 0)
	baseMap := make(map[int]*data_manage.EdbInfo)
	for _, bv := range baseEdbInfoArr {
		fmt.Println(bv.UniqueCode)
		if _, ok := baseMap[bv.EdbInfoId]; !ok {
			newBaseEdbInfoArr = append(newBaseEdbInfoArr, bv)
		}
		baseMap[bv.EdbInfoId] = bv
	}

	fmt.Println("calculateInfoArr:", len(calculateInfoArr))

	//计算指标去重
	newCalculateInfoArr := make([]*data_manage.EdbInfo, 0)
	calculateMap := make(map[int]*data_manage.EdbInfo)
	var calculateArr []int
	for _, bv := range calculateInfoArr {
		if _, ok := calculateMap[bv.EdbInfoId]; !ok {
			newCalculateInfoArr = append(newCalculateInfoArr, bv)
			calculateArr = append(calculateArr, bv.EdbInfoId)
		}
		calculateMap[bv.EdbInfoId] = bv
	}
	sort.Ints(calculateArr)

	// 刷新相关基础指标
	for _, bv := range newBaseEdbInfoArr {
		err, errmsg = refreshBaseEdbInfo(bv)
		if err != nil {
			return
		}
	}

	// 刷新相关计算指标
	for _, v := range calculateArr {
		edbInfo := calculateMap[v]
		if edbInfo == nil {
			return err
		}
		err, errmsg = refreshCalculateEdbInfo(edbInfo)
		if err != nil {
			return
		}
	}

	return err
}

// refreshBaseEdbInfo 刷新基础指标
func refreshBaseEdbInfo(bv *data_manage.EdbInfo) (err error, errMsg string) {
	source := bv.Source
	subSource := bv.SubSource
	edbInfoId := bv.EdbInfoId
	edbCode := bv.EdbCode
	//startDate := bv.StartDate
	frequency := bv.Frequency
	if bv.StartDate == "0000-00-00" {
		return
	}
	sTime, err := time.Parse(utils.FormatDate, bv.EndDate)
	if err != nil {
		return
	}

	var limitDay int
	startDate := ""
	switch frequency {
	case "日度":
		limitDay = utils.DATA_START_REFRESH_LIMIT
	case "周度":
		limitDay = utils.DATA_START_REFRESH_LIMIT * 7
	case "月度":
		limitDay = utils.DATA_START_REFRESH_LIMIT * 30
	case "季度":
		limitDay = utils.DATA_START_REFRESH_LIMIT * 90
	case "年度":
		limitDay = utils.DATA_START_REFRESH_LIMIT * 365
	default:
		limitDay = utils.DATA_START_REFRESH_LIMIT
	}
	startDate = sTime.AddDate(0, 0, -limitDay).Format(utils.FormatDate)

	fmt.Println("source:", source)
	respItem, err := RefreshEdbData(edbInfoId, source, subSource, edbCode, startDate)
	if err != nil {
		errMsg = errors.New("RefreshEdbData Err:" + err.Error()).Error()
		return
	}
	if respItem.Ret != 200 {
		errMsg = errors.New(respItem.ErrMsg + ";EdbCode:" + edbCode).Error()
		return
	}

	maxAndMinItem, err := data_manage.GetEdbInfoMaxAndMinInfo(source, subSource, edbCode)
	if err != nil {
		return
	}
	if maxAndMinItem != nil {
		err = data_manage.ModifyEdbInfoMaxAndMinInfo(edbInfoId, maxAndMinItem)
		if err != nil {
			return
		}
	}
	return
}

// refreshCalculateEdbInfo 刷新计算指标
func refreshCalculateEdbInfo(edbInfo *data_manage.EdbInfo) (err error, errMsg string) {
	startDate := edbInfo.StartDate
	source := edbInfo.Source

	if source == utils.DATA_SOURCE_CALCULATE {
		startDate = edbInfo.StartDate
		sTime, tmpErr := time.Parse(utils.FormatDate, edbInfo.EndDate)
		if tmpErr != nil {
			err = tmpErr
			return
		}
		startDate = sTime.Format(utils.FormatDate)
	}

	result, err := RefreshEdbCalculateData(edbInfo.EdbInfoId, edbInfo.EdbCode, startDate)
	if err != nil {
		fmt.Println(edbInfo.EdbInfoId, "RefreshEdbCalculateData err", time.Now())
		errMsg = "RefreshEdbCalculateData Err:" + err.Error()
		return
	}
	if result.Ret != 200 {
		fmt.Println(edbInfo.EdbInfoId, "RefreshEdbCalculateData err;msg:", result.Msg, ";errMsg:", result.ErrMsg)
		errMsg = fmt.Sprint(edbInfo.EdbInfoId, "RefreshEdbCalculateData err;msg:", result.Msg, ";errMsg:", result.ErrMsg)
		err = errors.New("刷新失败")
		return
	}
	return
}

type ChartInfoReq struct {
	ChartInfoId int `description:"图表id,新增时传0"`
}

// DeleteChartInfoDataRedis 清除图表缓存
func DeleteChartInfoDataRedis(bodyByte []byte) (err error) {
	var req ChartInfoReq
	err = json.Unmarshal(bodyByte, &req)
	if err != nil {
		return
	}
	if req.ChartInfoId > 0 {
		err = utils.Rc.Delete(GetChartInfoDataKey(req.ChartInfoId))
	}
	return
}

// DeleteChartClassifyRedis 清除图表分类缓存
func DeleteChartClassifyRedis(bodyByte []byte) (err error) {
	err = utils.Rc.Delete(utils.CACHE_CHART_CLASSIFY)
	return
}

// GetChartInfoDataKey 获取图表缓存的key
func GetChartInfoDataKey(chartInfoId int) string {
	key := fmt.Sprint(utils.CACHE_CHART_INFO_DATA, chartInfoId)
	return key
}

// CheckOpChartPermission 判断图表操作权限
func CheckOpChartPermission(sysUser *system.Admin, createUserId int, haveOperaAuth bool) (ok bool) {
	// 没有数据权限，那么直接返回
	if !haveOperaAuth {
		return
	}
	if sysUser.RoleTypeCode == utils.ROLE_TYPE_CODE_ADMIN || sysUser.RoleTypeCode == utils.ROLE_TYPE_CODE_FICC_ADMIN {
		ok = true
	}
	// 如果图表创建人与当前操作人相同的话，那么就是允许操作
	if ok == false && createUserId == sysUser.AdminId {
		ok = true
	}
	// 如果图表权限id 是 1 ，那么允许编辑
	if ok == false && sysUser.ChartPermission == 1 {
		ok = true
	}
	return
}

// GetChartEdbData 获取图表的指标数据
func GetChartEdbData(chartInfoId, chartType int, calendar, startDate, endDate string, mappingList []*data_manage.ChartEdbInfoMapping, extraConfigStr string, seasonExtraConfig string) (edbList []*data_manage.ChartEdbInfoMapping, xEdbIdValue []int, yDataList []data_manage.YData, dataResp interface{}, err error, errMsg string) {
	edbList = make([]*data_manage.ChartEdbInfoMapping, 0)
	xEdbIdValue = make([]int, 0)
	yDataList = make([]data_manage.YData, 0)

	var extraConfig interface{}
	switch chartType {
	case 7: // 柱形图
		var barConfig data_manage.BarChartInfoReq
		if extraConfigStr == `` {
			errMsg = "柱方图未配置"
			err = errors.New(errMsg)
			return
		}
		err = json.Unmarshal([]byte(extraConfigStr), &barConfig)
		if err != nil {
			errMsg = "柱方图配置异常"
			err = errors.New(errMsg)
			return
		}
		extraConfig = barConfig
	case 10: // 截面散点图
		var tmpExtraConfig data_manage.SectionScatterReq
		if extraConfigStr == `` {
			errMsg = "截面散点图未配置"
			err = errors.New(errMsg)
			return
		}
		err = json.Unmarshal([]byte(extraConfigStr), &tmpExtraConfig)
		if err != nil {
			errMsg = "截面散点配置异常"
			err = errors.New(errMsg)
			return
		}

		extraConfig = tmpExtraConfig
	case utils.CHART_TYPE_RADAR:
		var barConfig data_manage.RadarChartInfoReq
		if extraConfigStr == `` {
			errMsg = "雷达图未配置"
			err = errors.New(errMsg)
			return
		}
		err = json.Unmarshal([]byte(extraConfigStr), &barConfig)
		if err != nil {
			errMsg = "雷达图配置异常"
			err = errors.New(errMsg)
			return
		}
		extraConfig = barConfig
	default:
		xEdbIdValue = make([]int, 0)
		yDataList = make([]data_manage.YData, 0)
	}

	// 指标对应的所有数据
	edbDataListMap, edbList, err := getEdbDataMapList(chartInfoId, chartType, calendar, startDate, endDate, mappingList, seasonExtraConfig)
	if err != nil {
		return
	}

	// 特殊图形数据处理
	switch chartType {
	case 2: // 季节性图
		if seasonExtraConfig != "" {
			dataResp, err = SeasonChartData(edbList, seasonExtraConfig)
		}
	case 7: // 柱形图
		barChartConf := extraConfig.(data_manage.BarChartInfoReq)
		xEdbIdValue, yDataList, err = BarChartData(mappingList, edbDataListMap, barChartConf.DateList, barChartConf.Sort)

		for k := range yDataList {
			yDataList[k].Unit = barChartConf.Unit
			yDataList[k].UnitEn = barChartConf.UnitEn
		}

		for _, v := range edbList {
			// 指标别名
			if barChartConf.EdbInfoIdList != nil && len(barChartConf.EdbInfoIdList) > 0 {
				for _, reqEdb := range barChartConf.EdbInfoIdList {
					if v.EdbInfoId == reqEdb.EdbInfoId {
						v.EdbAliasName = reqEdb.Name
					}
				}
			}
		}
	case 10: // 截面散点图
		sectionScatterConf := extraConfig.(data_manage.SectionScatterReq)
		xEdbIdValue, dataResp, err = GetSectionScatterChartData(chartInfoId, mappingList, edbDataListMap, sectionScatterConf)

		var tmpExtraConfig data_manage.SectionScatterReq
		if extraConfigStr == `` {
			errMsg = "截面散点图未配置"
			err = errors.New(errMsg)
			return
		}
		err = json.Unmarshal([]byte(extraConfigStr), &tmpExtraConfig)
		if err != nil {
			errMsg = "截面散点配置异常"
			err = errors.New(errMsg)
			return
		}

		// 这个数据没有必要返回给前端
		for _, v := range edbList {
			v.DataList = nil
		}
	case utils.CHART_TYPE_RADAR: //雷达图
		radarConf := extraConfig.(data_manage.RadarChartInfoReq)
		xEdbIdValue, dataResp, err = RadarChartData(mappingList, edbDataListMap, radarConf)
	}
	return
}

// GetEdbDataMapList 获取指标最后的基础数据
func GetEdbDataMapList(chartInfoId, chartType int, calendar, startDate, endDate string, mappingList []*data_manage.ChartEdbInfoMapping, seasonExtra string) (edbDataListMap map[int][]*data_manage.EdbDataList, edbList []*data_manage.ChartEdbInfoMapping, err error) {
	edbDataListMap, edbList, err = getEdbDataMapList(chartInfoId, chartType, calendar, startDate, endDate, mappingList, seasonExtra)
	return
}

// getEdbDataMapList 获取指标最后的基础数据
func getEdbDataMapList(chartInfoId, chartType int, calendar, startDate, endDate string, mappingList []*data_manage.ChartEdbInfoMapping, seasonExtraConfig string) (edbDataListMap map[int][]*data_manage.EdbDataList, edbList []*data_manage.ChartEdbInfoMapping, err error) {
	// 指标对应的所有数据
	edbDataListMap = make(map[int][]*data_manage.EdbDataList)

	for _, v := range mappingList {
		//fmt.Println("v:", v.EdbInfoId)
		item := new(data_manage.ChartEdbInfoMapping)
		item.EdbInfoId = v.EdbInfoId
		item.SourceName = v.SourceName
		item.Source = v.Source
		item.EdbCode = v.EdbCode
		item.EdbName = v.EdbName
		item.EdbNameEn = v.EdbNameEn
		item.Frequency = v.Frequency
		item.EdbType = v.EdbType
		item.FrequencyEn = GetFrequencyEn(v.Frequency)
		if v.Unit != `无` {
			item.Unit = v.Unit
		}
		item.UnitEn = v.UnitEn
		item.StartDate = v.StartDate
		item.EndDate = v.EndDate
		item.ModifyTime = v.ModifyTime
		item.EdbInfoCategoryType = v.EdbInfoCategoryType
		item.PredictChartColor = v.PredictChartColor
		item.ClassifyId = v.ClassifyId
		if chartInfoId <= 0 {
			item.IsAxis = 1
			item.LeadValue = 0
			item.LeadUnit = ""
			item.ChartEdbMappingId = 0
			item.ChartInfoId = 0
			item.IsOrder = false
			item.EdbInfoType = 1
			item.ChartStyle = ""
			item.ChartColor = ""
			item.ChartWidth = 0
			item.MaxData = v.MaxValue
			item.MinData = v.MinValue
		} else {
			item.IsAxis = v.IsAxis
			item.EdbInfoType = v.EdbInfoType
			item.LeadValue = v.LeadValue
			item.LeadUnit = v.LeadUnit
			item.LeadUnitEn = GetLeadUnitEn(v.LeadUnit)
			item.ChartEdbMappingId = v.ChartEdbMappingId
			item.ChartInfoId = v.ChartInfoId
			item.ChartStyle = v.ChartStyle
			item.ChartColor = v.ChartColor
			item.ChartWidth = v.ChartWidth
			item.IsOrder = v.IsOrder
			item.MaxData = v.MaxData
			item.MinData = v.MinData
		}
		item.LatestValue = v.LatestValue
		item.LatestDate = v.LatestDate
		item.UniqueCode = v.UniqueCode
		item.MoveLatestDate = v.LatestDate
		item.EdbAliasName = v.EdbAliasName
		item.IsConvert = v.IsConvert
		item.ConvertType = v.ConvertType
		item.ConvertValue = v.ConvertValue
		item.ConvertUnit = v.ConvertUnit
		item.ConvertEnUnit = v.ConvertEnUnit
		item.IsJoinPermission = v.IsJoinPermission

		var startDateReal string
		var diffSeconds int64
		if chartType == 2 { //季节性图
			startDateReal = startDate
			if len(mappingList) > 1 {
				item.IsAxis = v.IsAxis
			}
		} else {
			if v.EdbInfoType == 0 && v.LeadUnit != "" && v.LeadValue > 0 { //领先指标
				var startTimeRealTemp time.Time
				startDateParse, _ := time.Parse(utils.FormatDate, startDate)
				switch v.LeadUnit {
				case "天":
					startTimeRealTemp = startDateParse.AddDate(0, 0, -v.LeadValue)
				case "月":
					startTimeRealTemp = startDateParse.AddDate(0, -v.LeadValue, 0)
				case "季":
					startTimeRealTemp = startDateParse.AddDate(0, -3*v.LeadValue, 0)
				case "周":
					startTimeRealTemp = startDateParse.AddDate(0, 0, -7*v.LeadValue)
				case "年":
					startTimeRealTemp = startDateParse.AddDate(-v.LeadValue, 0, 0)
				}
				if startTimeRealTemp.Before(startDateParse) {
					startDateReal = startTimeRealTemp.Format(utils.FormatDate)
					diffSeconds = (int64(startTimeRealTemp.UnixNano()) - int64(startDateParse.UnixNano())) / 1e6
				} else {
					startDateReal = startDate
					diffSeconds = 0
				}

				// 预测指标的开始日期也要偏移
				{
					day, tmpErr := utils.GetDaysBetween2Date(utils.FormatDate, startDate, startDateReal)
					if tmpErr != nil {
						err = tmpErr
						return
					}
					moveLatestDateTime, tmpErr := time.ParseInLocation(utils.FormatDate, item.MoveLatestDate, time.Local)
					if tmpErr != nil {
						err = tmpErr
						return
					}
					item.MoveLatestDate = moveLatestDateTime.AddDate(0, 0, day).Format(utils.FormatDate)
				}
			} else {
				startDateReal = startDate
			}
		}
		//fmt.Println("line 1011 chart:", v.Source, v.EdbInfoId, startDateReal, endDate)
		calendarPreYear := 0
		if calendar == "农历" {
			newStartDateReal, err := time.Parse(utils.FormatDate, startDateReal)
			if err != nil {
				fmt.Println("time.Parse:" + err.Error())
			}
			calendarPreYear = newStartDateReal.Year() - 1
			newStartDateReal = newStartDateReal.AddDate(-1, 0, 0)
			startDateReal = newStartDateReal.Format(utils.FormatDate)
		}
		dataList := make([]*data_manage.EdbDataList, 0)
		//fmt.Println("chart:", v.Source, v.EdbInfoId, startDateReal, endDate)
		//fmt.Println("calendarPreYear:", calendarPreYear)
		//var newEdbInfo *data_manage.EdbInfo
		switch v.EdbInfoCategoryType {
		case 0:
			dataList, err = data_manage.GetEdbDataList(v.Source, v.SubSource, v.EdbInfoId, startDateReal, endDate)
		case 1:
			_, dataList, _, _, err, _ = GetPredictDataListByPredictEdbInfoId(v.EdbInfoId, startDateReal, endDate, true)
		default:
			err = errors.New(fmt.Sprint("获取失败,指标类型异常", v.EdbInfoCategoryType))
		}
		if err != nil {
			return
		}

		if v.IsConvert == 1 {
			switch v.ConvertType {
			case 1:
				for i, data := range dataList {
					dataList[i].Value = data.Value * v.ConvertValue
				}
				//item.MaxData = item.MaxData * v.ConvertValue
				//item.MinData = item.MinData * v.ConvertValue
			case 2:
				for i, data := range dataList {
					dataList[i].Value = data.Value / v.ConvertValue
				}
				//item.MaxData = item.MaxData / v.ConvertValue
				//item.MinData = item.MinData / v.ConvertValue
			case 3:
				for i, data := range dataList {
					if data.Value <= 0 {
						err = errors.New("数据中含有负数或0，无法对数运算")
						return
					}
					dataList[i].Value = math.Log(data.Value) / math.Log(v.ConvertValue)
				}
				//item.MaxData = math.Log(item.MaxData) / math.Log(v.ConvertValue)
				//item.MinData = math.Log(item.MinData) / math.Log(v.ConvertValue)
			}
		}

		edbDataListMap[v.EdbInfoId] = dataList

		if diffSeconds != 0 && v.EdbInfoType == 0 {
			dataListLen := len(dataList)
			for i := 0; i < dataListLen; i++ {
				dataList[i].DataTimestamp = dataList[i].DataTimestamp - diffSeconds
			}
		}

		if chartType == 2 && item.IsAxis == 1 {
			latestDate, tmpErr := time.Parse(utils.FormatDate, v.LatestDate)
			if tmpErr != nil {
				//item.DataList = dataList
				item.IsNullData = true
				edbList = append(edbList, item)
				continue
				err = errors.New(fmt.Sprint("获取最后实际数据的日期失败,Err:" + tmpErr.Error() + ";LatestDate:" + v.LatestDate))
				return
			}

			if calendar == "农历" {
				if len(dataList) <= 0 {
					result := new(data_manage.EdbDataResult)
					item.DataList = result
				} else {
					result, tmpErr := data_manage.AddCalculateQuarterV6(dataList)
					if tmpErr != nil {
						err = errors.New("获取农历数据失败,Err:" + tmpErr.Error())
						return
					}
					quarterDataList, tErr := GetSeasonEdbInfoDataListByXDateNong(result, latestDate, seasonExtraConfig, calendarPreYear)
					if tErr != nil {
						err = errors.New("获取季节性图表数据失败,Err:" + tErr.Error())
						return
					}
					item.DataList = quarterDataList
				}

			} else {
				quarterDataList, tErr := GetSeasonEdbInfoDataListByXDate(dataList, latestDate, seasonExtraConfig)
				if tErr != nil {
					err = errors.New("获取季节性图表数据失败,Err:" + tErr.Error())
					return
				}
				item.DataList = quarterDataList
			}

		} else if chartType == 2 && item.IsAxis == 0 {
			// 右轴数据处理
			xStartDate := "01-01"

			jumpYear := 0
			var seasonExtra data_manage.SeasonExtraItem
			if seasonExtraConfig != "" {
				err = json.Unmarshal([]byte(seasonExtraConfig), &seasonExtra)
				if err != nil {
					return
				}
			}

			if seasonExtra.XStartDate != "" {
				xStartDate = seasonExtra.XStartDate
				jumpYear = seasonExtra.JumpYear
			}

			length := len(dataList)
			if length == 0 {
				return
			}
			latestDate, tmpErr := time.Parse(utils.FormatDate, v.LatestDate)
			if tmpErr != nil {
				//item.DataList = dataList
				item.IsNullData = true
				edbList = append(edbList, item)
				continue
				err = errors.New(fmt.Sprint("获取最后实际数据的日期失败,Err:" + tmpErr.Error() + ";LatestDate:" + v.LatestDate))
				return
			}

			var rightAxisDate time.Time
			if jumpYear == 1 {
				latestDate = latestDate.AddDate(-1, 0, 0)
			}
			latestDateStr := fmt.Sprintf("%d-%s", latestDate.Year(), xStartDate)
			rightAxisDate, err = time.Parse(utils.FormatDate, latestDateStr)
			if err != nil {
				return
			}

			newDataList := make([]*data_manage.EdbDataList, 0)
			for _, v := range dataList {
				dataTime, e := time.Parse(utils.FormatDate, v.DataTime)
				if e != nil {
					err = errors.New("季节性图处理右轴指标数据转换日期失败,Err:" + e.Error())
					return
				}
				if dataTime.Equal(rightAxisDate) || dataTime.After(rightAxisDate) {
					newDataList = append(newDataList, v)
				}
			}
			item.DataList = newDataList
		} else if chartType == 7 || chartType == utils.CHART_TYPE_RADAR { //柱方图
			//item.DataList = dataList
		} else {
			item.DataList = dataList
		}
		edbList = append(edbList, item)
	}

	return
}

// GetSeasonEdbInfoDataListByXDate 季节性图的指标数据根据横轴展示
func GetSeasonEdbInfoDataListByXDate(dataList []*data_manage.EdbDataList, latestDate time.Time, seasonExtraConfig string) (quarterDataListSort data_manage.QuarterDataList, err error) {
	xStartDate := "01-01"
	xEndDate := "12-31"
	jumpYear := 0
	legends := make([]data_manage.SeasonChartLegend, 0)
	var seasonExtra data_manage.SeasonExtraItem
	if seasonExtraConfig != "" {
		err = json.Unmarshal([]byte(seasonExtraConfig), &seasonExtra)
		if err != nil {
			return
		}
	}

	if seasonExtra.XStartDate != "" {
		xStartDate = seasonExtra.XStartDate
		xEndDate = seasonExtra.XEndDate
		jumpYear = seasonExtra.JumpYear
		legends = seasonExtra.ChartLegend
	}

	length := len(dataList)
	if length == 0 {
		return
	}
	legendMap := make(map[string]string, 0)
	if len(legends) > 0 {
		for _, v := range legends {
			legendMap[v.Name] = v.Value
		}
	}
	latestDateStr := latestDate.Format(utils.FormatDate)

	//判断横轴的两个时间之间是不是跨年了，如果跨年了，则横轴截止年份比起始年份+1，如果不跨年，截止年份等于起始年份
	//根据数据确定最早的年份，和最近年份
	//根据横轴的日期，汇总所有的年份
	startDate := dataList[0].DataTime
	startDateT, tmpErr := time.Parse(utils.FormatDate, startDate)
	if tmpErr != nil {
		err = tmpErr
		return
	}
	startYear := startDateT.Year()
	//获取数据的最新日期
	lastDate := dataList[length-1].DataTime
	lastDateT, tmpErr := time.Parse(utils.FormatDate, lastDate)
	if tmpErr != nil {
		err = tmpErr
		return
	}
	endYear := lastDateT.Year()
	nowYear := time.Now().Year()
	dataMap := make(map[string]data_manage.QuarterXDateItem, 0)

	quarterDataList := make([]*data_manage.QuarterData, 0)
	quarterMap := make(map[string][]*data_manage.EdbDataList, 0)

	//整理出日期
	idx := 1
	chartLegendMap := make(map[string]int, 0)
	for currentStartYear := startYear; currentStartYear <= endYear; currentStartYear++ {
		startStr := fmt.Sprintf("%d-%s", currentStartYear, xStartDate)
		currentEndYear := currentStartYear
		if jumpYear == 1 {
			currentEndYear = currentStartYear + 1
		}
		endStr := fmt.Sprintf("%d-%s", currentEndYear, xEndDate)
		name := fmt.Sprintf("%s_%s", startStr, endStr)
		showName := fmt.Sprintf("%d_%d", currentStartYear, currentEndYear)

		startT, tEr := time.Parse(utils.FormatDate, startStr)
		if tEr != nil {
			err = tEr
			return
		}

		endT, tEr := time.Parse(utils.FormatDate, endStr)
		if tEr != nil {
			err = tEr
			return
		}

		if lastDateT.Before(startT) {
			//如果最新的日期在起始日之前，则跳出循环
			break
		}

		if endT.Year() > nowYear {
			//如果最新的日期比真实年份要大，则数据全部按照最大的年份补齐
			nowYear = endT.Year()
		}

		item := data_manage.QuarterXDateItem{
			StartDate: startT,
			EndDate:   endT,
			ShowName:  showName,
		}
		dataMap[name] = item
		chartLegendMap[name] = idx
		idx++
		fmt.Println("年份" + showName + "日期" + startStr + " " + endStr)
		if lastDateT.Before(endT) {
			//如果最新的日期在起始日之前，则跳出循环
			break
		}
	}
	lenYear := len(dataMap)
	for k, v := range dataMap {
		if i, ok := chartLegendMap[k]; ok {
			v.ChartLegend = strconv.Itoa(endYear - lenYear + i)
		}
		dataMap[k] = v
	}

	for _, v := range dataList {
		dataTimeT, _ := time.Parse(utils.FormatDate, v.DataTime)
		year := dataTimeT.Year()
		newItemDate := dataTimeT.AddDate(nowYear-year, 0, 0)
		for k, dateItem := range dataMap {
			tmpVal := data_manage.EdbDataList{
				EdbDataId:     v.EdbDataId,
				EdbInfoId:     v.EdbInfoId,
				DataTime:      v.DataTime,
				DataTimestamp: v.DataTimestamp,
				Value:         v.Value,
			}
			if (dateItem.StartDate.Before(dataTimeT) && dateItem.EndDate.After(dataTimeT)) || dateItem.StartDate == dataTimeT || dateItem.EndDate == dataTimeT {
				if jumpYear == 1 {
					//计算前一年最大的日期, 只补齐数据到去年
					beforeYearMaxDate := fmt.Sprintf("%d-12-31", dateItem.StartDate.Year())
					beforeYearMaxDateT, _ := time.Parse(utils.FormatDate, beforeYearMaxDate)
					if dataTimeT.Before(beforeYearMaxDateT) || dataTimeT == beforeYearMaxDateT {
						newItemDate = dataTimeT.AddDate(nowYear-year-1, 0, 0)
					} else {
						newItemDate = dataTimeT.AddDate(nowYear-year, 0, 0)
					}
				} else {
					newItemDate = dataTimeT.AddDate(nowYear-year, 0, 0)
				}
				timestamp := newItemDate.UnixNano() / 1e6
				tmpVal.DataTimestamp = timestamp
				tmpV := &tmpVal
				if findVal, ok := quarterMap[k]; !ok {
					findVal = append(findVal, tmpV)
					quarterMap[k] = findVal
				} else {
					findVal = append(findVal, tmpV)
					quarterMap[k] = findVal
				}

				if v.DataTime == latestDateStr {
					dateItem.CuttingDataTimestamp = timestamp
					dataMap[k] = dateItem
				}
				//break
			}
		}
	}
	for k, v := range dataMap {
		itemList := quarterMap[k]
		quarterItem := new(data_manage.QuarterData)
		quarterItem.Years = v.ShowName
		quarterItem.ChartLegend = v.ChartLegend
		if le, ok := legendMap[v.ShowName]; ok {
			if le != strconv.Itoa(v.StartDate.Year()) && le != strconv.Itoa(v.EndDate.Year()) {
				quarterItem.ChartLegend = le
			}
		}
		quarterItem.DataList = itemList
		quarterItem.CuttingDataTimestamp = v.CuttingDataTimestamp

		//如果等于最后的实际日期，那么将切割时间戳记录
		if quarterItem.CuttingDataTimestamp == 0 {
			//如果大于最后的实际日期，那么第一个点就是切割的时间戳
			if latestDate.Before(v.StartDate) && len(itemList) > 0 {
				quarterItem.CuttingDataTimestamp = itemList[0].DataTimestamp - 100
			}
		}
		quarterDataList = append(quarterDataList, quarterItem)
	}

	if len(quarterDataList) > 0 {
		quarterDataListSort = quarterDataList
		sort.Sort(quarterDataListSort)
	}
	return
}

// GetSeasonEdbInfoDataListByXDateNong 季节性图的指标数据根据横轴选择农历时展示
func GetSeasonEdbInfoDataListByXDateNong(result *data_manage.EdbDataResult, latestDate time.Time, seasonExtraConfig string, calendarPreYear int) (quarterDataListSort data_manage.QuarterDataList, err error) {
	xStartDate := "01-01"
	xEndDate := "12-31"
	jumpYear := 0
	legends := make([]data_manage.SeasonChartLegend, 0)
	var seasonExtra data_manage.SeasonExtraItem
	if seasonExtraConfig != "" {
		err = json.Unmarshal([]byte(seasonExtraConfig), &seasonExtra)
		if err != nil {
			return
		}
	}

	if seasonExtra.XStartDate != "" {
		xStartDate = seasonExtra.XStartDate
		xEndDate = seasonExtra.XEndDate
		jumpYear = seasonExtra.JumpYear
		legends = seasonExtra.ChartLegend
	}

	length := len(result.List)
	if length == 0 {
		return
	}
	legendMap := make(map[string]string, 0)
	if len(legends) > 0 {
		for _, v := range legends {
			legendMap[v.Name] = v.Value
		}
	}
	latestDateYear := latestDate.Year()
	//判断横轴的两个时间之间是不是跨年了，如果跨年了，则横轴截止年份比起始年份+1，如果不跨年，截止年份等于起始年份
	//根据数据确定最早的年份，和最近年份
	//根据横轴的日期，汇总所有的年份

	startYear := result.List[0].Year
	/*if jumpYear == 1 {
		if startYear != calendarPreYear {
			startYear = startYear - 1
		}
	}*/

	itemLength := len(result.List[length-1].Items)
	//获取数据的最新日期
	lastDate := result.List[length-1].Items[itemLength-1].DataTime
	maxY := result.List[length-1].Year
	lastDateT, tmpErr := time.Parse(utils.FormatDate, lastDate)
	if tmpErr != nil {
		err = tmpErr
		return
	}
	endYear := lastDateT.Year()
	nowYear := time.Now().Year()
	dataMap := make(map[string]data_manage.QuarterXDateItem, 0)

	quarterDataList := make([]*data_manage.QuarterData, 0)
	resultData := make([]*data_manage.QuarterData, 0)
	quarterMap := make(map[string][]*data_manage.EdbDataList, 0)

	//整理出日期
	var startTmpT, endTmpT time.Time
	idx := 1
	chartLegendMap := make(map[string]int, 0)
	for currentStartYear := startYear; currentStartYear <= endYear; currentStartYear++ {
		startStr := fmt.Sprintf("%d-%s", currentStartYear, xStartDate)
		currentEndYear := currentStartYear
		if jumpYear == 1 {
			currentEndYear = currentStartYear + 1
		}
		endStr := fmt.Sprintf("%d-%s", currentEndYear, xEndDate)
		showName := fmt.Sprintf("%d_%d", currentStartYear, currentEndYear)

		startT, tEr := time.Parse(utils.FormatDate, startStr)
		if tEr != nil {
			err = tEr
			return
		}

		endT, tEr := time.Parse(utils.FormatDate, endStr)
		if tEr != nil {
			err = tEr
			return
		}

		if lastDateT.Before(startT) {
			//如果最新的日期在起始日之前，则跳出循环
			break
		}
		if endT.Year() > nowYear {
			//如果最新的日期比真实年份要大，则数据全部按照最大的年份补齐
			nowYear = endT.Year()
		}
		item := data_manage.QuarterXDateItem{
			StartDate: startT,
			EndDate:   endT,
			ShowName:  showName,
		}
		dataMap[showName] = item
		fmt.Println("年份" + showName + "日期" + startStr + " " + endStr)
		startTmpT = startT
		endTmpT = endT
		chartLegendMap[showName] = idx
		idx++
		if lastDateT.Before(endT) {
			//如果最新的日期在起始日之前，则跳出循环
			break
		}
	}
	lenYear := len(dataMap)
	for k, v := range dataMap {
		if i, ok := chartLegendMap[k]; ok {
			v.ChartLegend = strconv.Itoa(endYear - lenYear + i)
		}
		dataMap[k] = v
	}

	yearDataListMap := make(map[int]*data_manage.EdbDataItems, 0)

	for _, lv := range result.List {
		yearDataListMap[lv.Year] = lv
	}

	//判断哪些点应该落在同一条时间线上
	/*maxY := lastDateT.Year()
	changeFlag := false
	if lastDateT.Month() >= 11 {
		maxY = maxY + 1
	}
	if maxY < nowYear {
		changeFlag = true
		maxY = nowYear
	}*/
	/*endTmp := fmt.Sprintf("%d-%s", maxY, xEndDate)
	endTmpT, _ := time.Parse(utils.FormatDate, endTmp)
	minY := maxY
	if jumpYear == 1 {
		minY = maxY - 1
	}
	startTmp := fmt.Sprintf("%d-%s", minY, xStartDate)
	startTmpT, _ := time.Parse(utils.FormatDate, startTmp)*/

	fmt.Println("横轴截取日" + startTmpT.Format(utils.FormatDate) + " " + endTmpT.Format(utils.FormatDate))
	fmt.Printf("lastDateT.Year() 为%d \n", lastDateT.Year())
	fmt.Printf("maxY 为%d \n", maxY)
	for name, dateItem := range dataMap {
		tY := dateItem.EndDate.Year()
		if lastDateT.Month() >= 11 {
			if maxY > endTmpT.Year() {
				tY = tY + 1
			}
		}
		lv, ok1 := yearDataListMap[tY]
		fmt.Printf("name %s yearDataListMap[%d]\n", name, tY)
		if !ok1 {
			continue
		}
		for _, item := range lv.Items {
			tmpVal := data_manage.EdbDataList{
				EdbDataId:     item.EdbDataId,
				EdbInfoId:     item.EdbInfoId,
				DataTime:      item.DataTime,
				DataTimestamp: item.DataTimestamp,
				Value:         item.Value,
			}
			dataTimeT, _ := time.Parse(utils.FormatDate, item.DataTime)
			if (startTmpT.Before(dataTimeT) && endTmpT.After(dataTimeT)) || startTmpT == dataTimeT || endTmpT == dataTimeT {
				tmpV := &tmpVal
				if findVal, ok := quarterMap[name]; !ok {
					findVal = append(findVal, tmpV)
					quarterMap[name] = findVal
				} else {
					findVal = append(findVal, tmpV)
					quarterMap[name] = findVal
				}
				if lv.Year >= latestDateYear {
					// 切割的日期时间字符串
					cuttingDataTimeStr := latestDate.AddDate(0, 0, lv.BetweenDay).Format(utils.FormatDate)
					if item.DataTime == cuttingDataTimeStr {
						dateItem.CuttingDataTimestamp = tmpVal.DataTimestamp
						dataMap[name] = dateItem
					}
				}
			}
		}
	}

	for k, v := range dataMap {
		itemList := quarterMap[k]
		quarterItem := new(data_manage.QuarterData)
		quarterItem.Years = v.ShowName
		quarterItem.ChartLegend = v.ChartLegend
		if le, ok := legendMap[v.ShowName]; ok {
			if le != strconv.Itoa(v.StartDate.Year()) && le != strconv.Itoa(v.EndDate.Year()) {
				quarterItem.ChartLegend = le
			}
		}
		quarterItem.DataList = itemList
		quarterItem.CuttingDataTimestamp = v.CuttingDataTimestamp
		//如果等于最后的实际日期，那么将切割时间戳记录
		if quarterItem.CuttingDataTimestamp == 0 {
			//如果大于最后的实际日期，那么第一个点就是切割的时间戳
			if latestDate.Before(v.StartDate) && len(itemList) > 0 {
				quarterItem.CuttingDataTimestamp = itemList[0].DataTimestamp - 100
			}
		}
		quarterDataList = append(quarterDataList, quarterItem)
	}

	if result.List[0].Year != calendarPreYear {
		itemList := make([]*data_manage.EdbDataList, 0)
		items := new(data_manage.QuarterData)
		//items.Year = calendarPreYear
		items.DataList = itemList

		newResult := make([]*data_manage.QuarterData, 0)
		newResult = append(newResult, items)
		newResult = append(newResult, quarterDataList...)
		resultData = newResult
	} else {
		resultData = quarterDataList
	}

	if len(quarterDataList) > 0 {
		quarterDataListSort = resultData
		sort.Sort(quarterDataListSort)
	}
	return
}

// BarChartData 柱方图的数据处理
func BarChartData(mappingList []*data_manage.ChartEdbInfoMapping, edbDataListMap map[int][]*data_manage.EdbDataList, barChartInfoDateList []data_manage.BarChartInfoDateReq, barChartInfoSort data_manage.BarChartInfoSortReq) (edbIdList []int, yDataList []data_manage.YData, err error) {
	// 指标数据数组（10086:{"2022-12-02":100.01,"2022-12-01":102.3}）
	edbDataMap := make(map[int]map[string]float64)
	for edbInfoId, edbDataList := range edbDataListMap {
		edbDateData := make(map[string]float64)
		for _, edbData := range edbDataList {
			edbDateData[edbData.DataTime] = edbData.Value
		}
		edbDataMap[edbInfoId] = edbDateData
	}

	// edbIdList 指标展示顺序；x轴的指标顺序
	edbIdList = make([]int, 0)
	//Sort int    `description:"排序类型，0：默认，1：升序，2：降序"`
	dateData := make(map[int]float64)
	if barChartInfoSort.Sort == 0 {
		for _, v := range mappingList {
			edbIdList = append(edbIdList, v.EdbInfoId)
		}
	} else {
		lenBarChartInfoDateList := len(barChartInfoDateList)
		if barChartInfoSort.DateIndex >= lenBarChartInfoDateList {
			err = errors.New("排序日期异常")
			return
		}

		notDataEdbIdList := make([]int, 0) //没有数据的指标id
		// 日期配置
		barChartInfoDate := barChartInfoDateList[barChartInfoSort.DateIndex]
		for edbInfoId, dataList := range edbDataListMap {
			if len(dataList) <= 0 {
				// 没有数据的指标id
				notDataEdbIdList = append(notDataEdbIdList, edbInfoId)
				continue
			}
			findDate := barChartInfoDate.Date
			switch barChartInfoDate.Type {
			case 1: //最新值
				findDate = dataList[len(dataList)-1].DataTime
			case 2: //近期几天
				findDateTime, tmpErr := time.ParseInLocation(utils.FormatDate, dataList[len(dataList)-1].DataTime, time.Local)
				if tmpErr != nil {
					err = tmpErr
					return
				}
				findDateTime = findDateTime.AddDate(0, 0, -barChartInfoDate.Value)

				lenData := len(dataList) - 1

				for i := lenData; i >= 0; i-- {
					currDateTime, tmpErr := time.ParseInLocation(utils.FormatDate, dataList[i].DataTime, time.Local)
					if tmpErr != nil {
						err = tmpErr
						return
					}
					if currDateTime.Equal(findDateTime) || currDateTime.Before(findDateTime) {
						findDate = dataList[i].DataTime
						break
					}
				}
			case 3: // 固定日期
				//最早的日期
				minDateTime, tmpErr := time.ParseInLocation(utils.FormatDate, dataList[0].DataTime, time.Local)
				if tmpErr != nil {
					err = tmpErr
					return
				}
				//寻找固定日期的数据
				findDateTime, tmpErr := time.ParseInLocation(utils.FormatDate, barChartInfoDate.Date, time.Local)
				if tmpErr != nil {
					err = tmpErr
					return
				}
				for tmpDateTime := findDateTime; tmpDateTime.After(minDateTime) || tmpDateTime.Equal(minDateTime); tmpDateTime = tmpDateTime.AddDate(0, 0, -1) {
					tmpDate := tmpDateTime.Format(utils.FormatDate)
					if _, ok := edbDataMap[edbInfoId][tmpDate]; ok { //如果能找到数据，那么就返回
						findDate = tmpDate
						break
					}
				}
			default:
				err = errors.New(fmt.Sprint("日期类型异常,Type:", barChartInfoDate.Type))
				return
			}
			if tmpValue, ok := edbDataMap[edbInfoId][findDate]; ok {
				dateData[edbInfoId] = tmpValue
			} else {
				// 没有数据的指标id
				notDataEdbIdList = append(notDataEdbIdList, edbInfoId)
			}
		}

		//Sort int    `description:"排序类型，0：默认，1：升序，2：降序"`
		// 排序
		dateDataSort := utils.NewMapSorter(dateData)
		sort.Sort(dateDataSort)
		if barChartInfoSort.Sort == 1 {
			// 先将没有数据的指标id放在最前面
			if len(notDataEdbIdList) > 0 {
				edbIdList = append(edbIdList, notDataEdbIdList...)
			}
			for _, v := range dateDataSort {
				edbIdList = append(edbIdList, v.Key)
			}
		} else {
			for i := len(dateDataSort) - 1; i >= 0; i-- {
				edbIdList = append(edbIdList, dateDataSort[i].Key)
			}
			// 再将没有数据的指标id放在最后面
			if len(notDataEdbIdList) > 0 {
				edbIdList = append(edbIdList, notDataEdbIdList...)
			}
		}
	}

	yDataList = make([]data_manage.YData, 0) //y轴的数据列表

	for _, barChartInfoDate := range barChartInfoDateList {
		var maxDate time.Time

		findDataList := make([]float64, 0) // 当前日期的数据值
		for _, edbInfoId := range edbIdList {
			findDate := barChartInfoDate.Date     //需要的日期值
			dataList := edbDataListMap[edbInfoId] //指标的所有数据值
			if len(dataList) <= 0 {
				// 没有数据的指标id
				findDataList = append(findDataList, 0)
				continue
			}
			switch barChartInfoDate.Type {
			case 1: //最新值
				dataList := edbDataListMap[edbInfoId]
				findDate = dataList[len(dataList)-1].DataTime
			case 2: //近期几天
				findDateTime, tmpErr := time.ParseInLocation(utils.FormatDate, dataList[len(dataList)-1].DataTime, time.Local)
				if tmpErr != nil {
					err = tmpErr
					return
				}
				findDateTime = findDateTime.AddDate(0, 0, -barChartInfoDate.Value)

				lenData := len(dataList) - 1
				for i := lenData; i >= 0; i-- {
					currDateTime, tmpErr := time.ParseInLocation(utils.FormatDate, dataList[i].DataTime, time.Local)
					if tmpErr != nil {
						err = tmpErr
						return
					}
					if currDateTime.Equal(findDateTime) || currDateTime.Before(findDateTime) {
						findDate = dataList[i].DataTime
						break
					}
				}
			case 3: // 固定日期
				//最早的日期
				minDateTime, tmpErr := time.ParseInLocation(utils.FormatDate, dataList[0].DataTime, time.Local)
				if tmpErr != nil {
					err = tmpErr
					return
				}
				//寻找固定日期的数据
				findDateTime, tmpErr := time.ParseInLocation(utils.FormatDate, barChartInfoDate.Date, time.Local)
				if tmpErr != nil {
					err = tmpErr
					return
				}
				for tmpDateTime := findDateTime; tmpDateTime.After(minDateTime) || tmpDateTime.Equal(minDateTime); tmpDateTime = tmpDateTime.AddDate(0, 0, -1) {
					tmpDate := tmpDateTime.Format(utils.FormatDate)
					if _, ok := edbDataMap[edbInfoId][tmpDate]; ok { //如果能找到数据，那么就返回
						findDate = tmpDate
						break
					}
				}
			default:
				err = errors.New(fmt.Sprint("日期类型异常,Type:", barChartInfoDate.Type))
				return
			}
			findDateTime, _ := time.ParseInLocation(utils.FormatDate, findDate, time.Local)
			if maxDate.IsZero() {
				maxDate = findDateTime
			} else {
				if findDateTime.After(maxDate) {
					maxDate = findDateTime
				}
			}
			if tmpValue, ok := edbDataMap[edbInfoId][findDate]; ok {
				tmpValue, _ = decimal.NewFromFloat(tmpValue).Round(4).Float64()
				findDataList = append(findDataList, tmpValue)
			} else {
				findDataList = append(findDataList, 0)
			}
		}

		yDate := "0000-00-00"
		if !maxDate.IsZero() {
			yDate = maxDate.Format(utils.FormatDate)
		}
		yDataList = append(yDataList, data_manage.YData{
			Date:  yDate,
			Value: findDataList,
			Color: barChartInfoDate.Color,
			Name:  barChartInfoDate.Name,
		})
	}

	return
}

// ChartInfoRefreshV2 图表刷新
// @author Roc
// @datetime 2022-09-16 10:15:38
// @description 将原来自己写的一套获取所有关联指标，然后刷新指标逻辑 改成  只获取使用的指标id，然后遍历去调用“指标刷新服务”
func ChartInfoRefreshV2(chartInfoId int) (err error, isAsync bool) {
	var errmsg string
	defer func() {
		if err != nil {
			go alarm_msg.SendAlarmMsg("ChartInfoRefresh:"+errmsg, 3)
			//go utils.SendEmail(utils.APPNAME+"【"+utils.RunMode+"】"+"失败提醒", "ChartInfoRefresh:"+errmsg, utils.EmailSendToUsers)
			fmt.Println("ChartInfoRefresh Err:" + errmsg)
		}
	}()
	edbMappingList, err := data_manage.GetChartEdbMappingList(chartInfoId)
	if err != nil {
		errmsg = "获取需要刷新的指标失败:Err:" + err.Error()
		return
	}

	edbIdList := make([]int, 0)
	for _, v := range edbMappingList {
		edbIdList = append(edbIdList, v.EdbInfoId)
	}

	// 批量刷新
	err, isAsync = EdbInfoRefreshAllFromBaseV3(edbIdList, false, false, false)

	if err != nil {
		return
	}

	return
}

// BatchChartInfoRefreshV2 图表批量刷新
// @author Roc
// @datetime 2022-09-16 10:15:38
// @description 将原来自己写的一套获取所有关联指标，然后刷新指标逻辑 改成  只获取使用的指标id，然后遍历去调用“指标刷新服务”
func BatchChartInfoRefreshV2(chartInfoList []*data_manage.ChartInfo, redisKey string) (err error, isAsync bool) {
	if len(chartInfoList) <= 0 {
		return
	}
	chartInfoIdSlice := make([]int, 0)
	for _, chartInfo := range chartInfoList {
		chartInfoIdSlice = append(chartInfoIdSlice, chartInfo.ChartInfoId)
	}

	var errMsg string
	defer func() {
		if err != nil {
			go alarm_msg.SendAlarmMsg("ChartInfoRefresh:"+errMsg, 3)
			//go utils.SendEmail(utils.APPNAME+"【"+utils.RunMode+"】"+"失败提醒", "ChartInfoRefresh:"+errmsg, utils.EmailSendToUsers)
			fmt.Println("ChartInfoRefresh Err:" + errMsg)
		}
	}()

	// 是否删除缓存
	isDeleteCache := true
	if redisKey != `` {
		//设置最多10分钟缓存
		utils.Rc.SetNX(redisKey, 1, time.Minute*10)
		defer func() {
			if isDeleteCache {
				utils.Rc.Delete(redisKey)
			}
		}()
	}

	// 获取需要刷新的指标信息
	edbIdList := make([]int, 0)
	edbInfoIdMap := make(map[int]int)
	edbMappingList, err := data_manage.GetChartEdbMappingListByIdList(chartInfoIdSlice)
	for _, v := range edbMappingList {
		if _, ok := edbInfoIdMap[v.EdbInfoId]; !ok {
			edbIdList = append(edbIdList, v.EdbInfoId)
			edbInfoIdMap[v.EdbInfoId] = v.EdbInfoId
		}
	}

	// 获取需要刷新的指标列表
	newBaseEdbInfoArr, newBasePredictEdbInfoArr, newCalculateMap, newPredictCalculateMap, calculateArr, predictCalculateArr := getEdbInfoIdList(edbIdList)

	// 需要刷新的指标数量
	totalEdbInfo := len(newBaseEdbInfoArr) + len(calculateArr) + len(predictCalculateArr)

	if totalEdbInfo > 20 { // 关联指标过多的时候，异步刷新
		isAsync = true
		isDeleteCache = false // 不删除缓存
		//go refreshChartEdbInfo(chartInfoList, redisKey, newBaseEdbInfoArr, newBasePredictEdbInfoArr, newCalculateMap, newPredictCalculateMap, calculateArr, predictCalculateArr)

		// 加入队列刷新
		var refreshItem EdbQueueRefreshReq
		refreshItem.RefreshKey = redisKey
		for _, v := range chartInfoList {
			key := utils.HZ_CHART_LIB_DETAIL + v.UniqueCode
			refreshItem.ItemRefreshKeys = append(refreshItem.ItemRefreshKeys, key)
		}
		refreshItem.BaseEdbInfoArr = newBaseEdbInfoArr
		refreshItem.BasePredictEdbInfoArr = newBasePredictEdbInfoArr
		refreshItem.CalculateMap = newCalculateMap
		refreshItem.PredictCalculateMap = newPredictCalculateMap
		refreshItem.CalculateArr = calculateArr
		refreshItem.PredictCalculateArr = predictCalculateArr
		go PushEdb2Refresh(refreshItem)
	} else {
		err = edbInfoRefreshAll(false, newBaseEdbInfoArr, newBasePredictEdbInfoArr, newCalculateMap, newPredictCalculateMap, calculateArr, predictCalculateArr)

		//清除图表缓存
		for _, v := range chartInfoList {
			key := utils.HZ_CHART_LIB_DETAIL + v.UniqueCode
			_ = utils.Rc.Delete(key)
		}
	}

	return
}

// refreshChartEdbInfo
// @Description: 刷新图表中的质保列表
// @author: Roc
// @datetime 2023-12-01 16:05:39
// @param chartInfoList []*data_manage.ChartInfo
// @param redisKey string
// @param newBaseEdbInfoArr []*data_manage.EdbInfo
// @param newBasePredictEdbInfoArr []*data_manage.EdbInfo
// @param newCalculateMap map[int]*data_manage.EdbInfo
// @param newPredictCalculateMap map[int]*data_manage.EdbInfo
// @param calculateArr []int
// @param predictCalculateArr []int
func refreshChartEdbInfo(chartInfoList []*data_manage.ChartInfo, redisKey string, newBaseEdbInfoArr, newBasePredictEdbInfoArr []*data_manage.EdbInfo, newCalculateMap, newPredictCalculateMap map[int]*data_manage.EdbInfo, calculateArr, predictCalculateArr []int) {
	edbInfoRefreshAll(false, newBaseEdbInfoArr, newBasePredictEdbInfoArr, newCalculateMap, newPredictCalculateMap, calculateArr, predictCalculateArr)

	//清除图表缓存
	for _, v := range chartInfoList {
		key := utils.HZ_CHART_LIB_DETAIL + v.UniqueCode
		_ = utils.Rc.Delete(key)
	}
	// 如果是有插入redisKey，那么刷新结束后就清除缓存
	if redisKey != `` {
		utils.Rc.Delete(redisKey)
	}
}

// GetBatchChartRefreshKey
// @Description: 获取批量刷新key
// @author: Roc
// @datetime 2023-11-30 13:30:26
// @param source string
// @param primaryId int
// @param subId int
// @return string
func GetBatchChartRefreshKey(source string, primaryId, subId int) string {
	if source == `` {
		return ``
	}

	return fmt.Sprint("batch_chart_refresh:", source, ":", primaryId, ":", subId)
}

// CheckBatchChartRefreshResult
// @Description: 判断报告中的图表是否刷新完成
// @author: Roc
// @datetime 2023-11-30 13:30:26
// @param source string
// @param primaryId int
// @param subId int
// @return string
func CheckBatchChartRefreshResult(source string, primaryId, subId int) (refreshResult bool) {
	refreshResult = true
	redisKey := GetBatchChartRefreshKey(source, primaryId, subId)
	if redisKey != `` {
		// 如果找到了key，那么就是还在更新中
		isOk := utils.Rc.IsExist(redisKey)
		if isOk {
			refreshResult = false
		}
	}

	return
}

func CheckIsEnChart(chartNameEn string, edbList []*data_manage.ChartEdbInfoMapping, source, chartType int) bool {
	// 相关性图表不判断指标
	if utils.InArrayByInt([]int{utils.CHART_SOURCE_CORRELATION, utils.CHART_SOURCE_ROLLING_CORRELATION, utils.CHART_SOURCE_LINE_EQUATION}, source) && chartNameEn != "" {
		return true
	}
	if chartNameEn != "" && len(edbList) <= 0 {
		return true
	}
	if chartNameEn == "" {
		return false
	}

	// 截面散点图的话，肯定是有英文配置的
	if chartType == utils.CHART_TYPE_SECTION_SCATTER {
		return true
	}

	for _, v := range edbList {
		if v.EdbNameEn == "" {
			return false
		}
		if v.Unit != "无" && v.Unit != "" && v.UnitEn == "" {
			return false
		}
	}
	return true
}

func CheckIsEnEdb(edbNameEn, unit, unitEn string) bool {
	if edbNameEn == "" {
		return false
	}
	if unit != "无" && unit != "" && unitEn == "" {
		return false
	}
	return true
}

// CheckIsDisableChart 根据指标Id判断是否是禁用图表
// return int 0:启用，1：禁用
func CheckIsDisableChart(edbInfoIdArr []int) (isDisable int) {
	crmConfig, err := company.GetConfigDetailByCode("chart_disabled_edb")
	if err != nil {
		return
	}
	//没有配置，立马返回
	if crmConfig.ConfigValue == `` {
		return
	}

	confEdbInfoIdList := strings.Split(crmConfig.ConfigValue, ",")

	for _, edbInfoId := range edbInfoIdArr {
		for _, confEdbInfoId := range confEdbInfoIdList {
			if strconv.Itoa(edbInfoId) == confEdbInfoId {
				isDisable = 1
				return
			}
		}
	}

	return
}

// CheckChartExtraConfig 校验图表额外配置的信息,并且获取相关联的指标id
func CheckChartExtraConfig(chartType int, extraConfigStr string) (edbIdList []int, err error, errMsg string) {
	switch chartType {
	case 10: //截面散点
		var extraConfig data_manage.SectionScatterReq
		err = json.Unmarshal([]byte(extraConfigStr), &extraConfig)
		if err != nil {
			return
		}

		// 判断是否有配置日期序列
		if len(extraConfig.SeriesList) <= 0 {
			errMsg = `请配置序列`
			err = errors.New(errMsg)
			return
		}

		// 判断是否有填写指标
		if len(extraConfig.SeriesList[0].EdbInfoList) <= 0 {
			errMsg = `请选择指标`
			err = errors.New(errMsg)
			return
		}

		// 遍历指标列表获取指标id
		edbIdMap := make(map[int]int)
		for _, v := range extraConfig.SeriesList[0].EdbInfoList {
			// X 轴的指标id
			if _, ok := edbIdMap[v.XEdbInfoId]; !ok {
				edbIdMap[v.XEdbInfoId] = v.XEdbInfoId
				edbIdList = append(edbIdList, v.XEdbInfoId)
			}

			// Y 轴的指标id
			if _, ok := edbIdMap[v.YEdbInfoId]; !ok {
				edbIdMap[v.YEdbInfoId] = v.YEdbInfoId
				edbIdList = append(edbIdList, v.YEdbInfoId)
			}
		}
	case utils.CHART_TYPE_RADAR:
		var extraConfig data_manage.RadarChartInfoReq
		if extraConfigStr == `` {
			errMsg = "雷达图未配置"
			err = errors.New(errMsg)
			return
		}
		err = json.Unmarshal([]byte(extraConfigStr), &extraConfig)
		if err != nil {
			errMsg = "雷达图配置异常"
			err = errors.New(errMsg)
			return
		}
	}
	return
}

// GetSectionScatterChartData 截面散点图的数据处理
func GetSectionScatterChartData(chartInfoId int, mappingList []*data_manage.ChartEdbInfoMapping, edbDataListMap map[int][]*data_manage.EdbDataList, extraConfig data_manage.SectionScatterReq) (edbIdList []int, chartDataResp data_manage.SectionScatterInfoResp, err error) {
	// 指标数据数组（10086:{"2022-12-02":100.01,"2022-12-01":102.3}）
	edbDataMap := make(map[int]map[string]float64)
	for edbInfoId, edbDataList := range edbDataListMap {
		edbDateData := make(map[string]float64)
		for _, edbData := range edbDataList {
			edbDateData[edbData.DataTime] = edbData.Value
		}
		edbDataMap[edbInfoId] = edbDateData
	}

	// edbIdList 指标展示顺序；x轴的指标顺序
	edbIdList = make([]int, 0)
	edbMappingMap := make(map[int]*data_manage.ChartEdbInfoMapping)
	for _, v := range mappingList {
		edbIdList = append(edbIdList, v.EdbInfoId)
		edbMappingMap[v.EdbInfoId] = v
	}
	//SectionScatterSeriesInfoResp

	dataListResp := make([]data_manage.SectionScatterSeriesItemResp, 0) //y轴的数据列表

	for _, seriesItem := range extraConfig.SeriesList {
		var maxDate time.Time
		// 系列中的指标数据
		tmpSeriesEdbInfoList := make([]data_manage.SectionScatterEdbItemResp, 0)

		var minXVal, maxXVal, minYVal, maxYVal float64
		for _, edbConf := range seriesItem.EdbInfoList {
			tmpItem := data_manage.SectionScatterEdbItemResp{
				IsShow: edbConf.IsShow,
				Name:   edbConf.Name,
				NameEn: edbConf.NameEn,
			} //单个坐标点的数据

			//X轴的数据
			{
				edbInfoId := edbConf.XEdbInfoId //X轴的指标
				edbMappingInfo, ok := edbMappingMap[edbInfoId]
				if !ok {
					continue
				}
				findDate := edbConf.XDate             //需要的日期值
				dataList := edbDataListMap[edbInfoId] //指标的所有数据值
				if len(dataList) <= 0 {
					// 没有数据的指标id
					//findDataList = append(findDataList, 0)
					continue
				}

				tmpItem.XEdbInfoId = edbInfoId
				tmpItem.XName = edbMappingInfo.EdbName
				tmpItem.XNameEn = edbMappingInfo.EdbNameEn

				switch edbConf.XDateType {
				case 1: //最新值
					findDate = dataList[len(dataList)-1].DataTime
				case 2: //近期几天
					findDateTime, tmpErr := time.ParseInLocation(utils.FormatDate, dataList[len(dataList)-1].DataTime, time.Local)
					if tmpErr != nil {
						err = tmpErr
						return
					}
					findDateTime = findDateTime.AddDate(0, 0, -edbConf.XDateValue)

					lenData := len(dataList) - 1
					for i := lenData; i >= 0; i-- {
						currDateTime, tmpErr := time.ParseInLocation(utils.FormatDate, dataList[i].DataTime, time.Local)
						if tmpErr != nil {
							err = tmpErr
							return
						}
						if currDateTime.Equal(findDateTime) || currDateTime.Before(findDateTime) {
							findDate = dataList[i].DataTime
							break
						}
					}
				case 3: // 固定日期
					//最早的日期
					minDateTime, tmpErr := time.ParseInLocation(utils.FormatDate, dataList[0].DataTime, time.Local)
					if tmpErr != nil {
						err = tmpErr
						return
					}
					//寻找固定日期的数据
					findDateTime, tmpErr := time.ParseInLocation(utils.FormatDate, edbConf.XDate, time.Local)
					if tmpErr != nil {
						err = tmpErr
						return
					}
					for tmpDateTime := findDateTime; tmpDateTime.After(minDateTime) || tmpDateTime.Equal(minDateTime); tmpDateTime = tmpDateTime.AddDate(0, 0, -1) {
						tmpDate := tmpDateTime.Format(utils.FormatDate)
						if _, ok := edbDataMap[edbInfoId][tmpDate]; ok { //如果能找到数据，那么就返回
							findDate = tmpDate
							break
						}
					}
				default:
					err = errors.New(fmt.Sprint("日期类型异常,Type:", edbConf.XDate))
					return
				}
				findDateTime, _ := time.ParseInLocation(utils.FormatDate, findDate, time.Local)
				if maxDate.IsZero() {
					maxDate = findDateTime
				} else {
					if findDateTime.After(maxDate) {
						maxDate = findDateTime
					}
				}
				if tmpValue, ok := edbDataMap[edbInfoId][findDate]; ok {
					tmpItem.XDate = findDate
					tmpItem.XValue = tmpValue
				} else {
					continue
				}
			}

			//Y轴的数据
			{
				edbInfoId := edbConf.YEdbInfoId //Y轴的指标
				edbMappingInfo, ok := edbMappingMap[edbInfoId]
				if !ok {
					continue
				}
				findDate := edbConf.YDate             //需要的日期值
				dataList := edbDataListMap[edbInfoId] //指标的所有数据值
				if len(dataList) <= 0 {
					// 没有数据的指标id
					//findDataList = append(findDataList, 0)
					continue
				}

				tmpItem.YEdbInfoId = edbInfoId
				tmpItem.YName = edbMappingInfo.EdbName
				tmpItem.YNameEn = edbMappingInfo.EdbNameEn

				switch edbConf.YDateType {
				case 1: //最新值
					findDate = dataList[len(dataList)-1].DataTime
				case 2: //近期几天
					findDateTime, tmpErr := time.ParseInLocation(utils.FormatDate, dataList[len(dataList)-1].DataTime, time.Local)
					if tmpErr != nil {
						err = tmpErr
						return
					}
					findDateTime = findDateTime.AddDate(0, 0, -edbConf.YDateValue)

					lenData := len(dataList) - 1
					for i := lenData; i >= 0; i-- {
						currDateTime, tmpErr := time.ParseInLocation(utils.FormatDate, dataList[i].DataTime, time.Local)
						if tmpErr != nil {
							err = tmpErr
							return
						}
						if currDateTime.Equal(findDateTime) || currDateTime.Before(findDateTime) {
							findDate = dataList[i].DataTime
							break
						}
					}
				case 3: // 固定日期
					//最早的日期
					minDateTime, tmpErr := time.ParseInLocation(utils.FormatDate, dataList[0].DataTime, time.Local)
					if tmpErr != nil {
						err = tmpErr
						return
					}
					//寻找固定日期的数据
					findDateTime, tmpErr := time.ParseInLocation(utils.FormatDate, edbConf.YDate, time.Local)
					if tmpErr != nil {
						err = tmpErr
						return
					}
					for tmpDateTime := findDateTime; tmpDateTime.After(minDateTime) || tmpDateTime.Equal(minDateTime); tmpDateTime = tmpDateTime.AddDate(0, 0, -1) {
						tmpDate := tmpDateTime.Format(utils.FormatDate)
						if _, ok := edbDataMap[edbInfoId][tmpDate]; ok { //如果能找到数据，那么就返回
							findDate = tmpDate
							break
						}
					}
				default:
					err = errors.New(fmt.Sprint("日期类型异常,Type:", edbConf.YDate))
					return
				}
				findDateTime, _ := time.ParseInLocation(utils.FormatDate, findDate, time.Local)
				if maxDate.IsZero() {
					maxDate = findDateTime
				} else {
					if findDateTime.After(maxDate) {
						maxDate = findDateTime
					}
				}
				if tmpValue, ok := edbDataMap[edbInfoId][findDate]; ok {
					tmpItem.YDate = findDate
					tmpItem.YValue = tmpValue
				} else {
					continue
				}
			}

			// 获取当前系列的X轴的最大最小值
			{
				if tmpItem.XValue < minXVal {
					minXVal = tmpItem.XValue
				}
				if tmpItem.XValue > maxXVal {
					maxXVal = tmpItem.XValue
				}
				if tmpItem.YValue < minYVal {
					minYVal = tmpItem.YValue
				}
				if tmpItem.YValue > maxYVal {
					maxYVal = tmpItem.YValue
				}
			}
			tmpSeriesEdbInfoList = append(tmpSeriesEdbInfoList, tmpItem)
		}

		trendLimitData := make([]data_manage.CoordinatePoint, 0) //趋势线的前后坐标点
		var trendLine, rSquare string
		// 生成线性方程式
		var a, b float64
		{
			coordinateData := make([]utils.Coordinate, 0)
			for _, tmpSeriesEdbInfo := range tmpSeriesEdbInfoList {
				tmpCoordinate1 := utils.Coordinate{
					X: tmpSeriesEdbInfo.XValue,
					Y: tmpSeriesEdbInfo.YValue,
				}
				coordinateData = append(coordinateData, tmpCoordinate1)
			}

			// 只有存在两个坐标点的时候,才能去计算线性方程和R平方
			if len(coordinateData) >= 2 {
				a, b = utils.GetLinearResult(coordinateData)
				if !math.IsNaN(a) && !math.IsNaN(b) {
					if b > 0 {
						trendLine = fmt.Sprintf("y=%sx+%s", utils.SubFloatToString(a, 4), utils.SubFloatToString(b, 4))
					} else {
						trendLine = fmt.Sprintf("y=%sx%s", utils.SubFloatToString(a, 4), utils.SubFloatToString(b, 4))
					}

					minYVal, _ = decimal.NewFromFloat(a).Mul(decimal.NewFromFloat(minXVal)).Add(decimal.NewFromFloat(b)).Round(4).Float64()
					maxYVal, _ = decimal.NewFromFloat(a).Mul(decimal.NewFromFloat(maxXVal)).Add(decimal.NewFromFloat(b)).Round(4).Float64()
				}

				// 计算R平方
				rSquare = fmt.Sprint(utils.CalculationDecisive(coordinateData))
			}

			trendLimitData = append(trendLimitData, data_manage.CoordinatePoint{
				X: minXVal,
				Y: minYVal,
			}, data_manage.CoordinatePoint{
				X: maxXVal,
				Y: maxYVal,
			})
		}

		dataListResp = append(dataListResp, data_manage.SectionScatterSeriesItemResp{
			Name:            seriesItem.Name,
			NameEn:          seriesItem.NameEn,
			IsNameDefault:   seriesItem.IsNameDefault,
			Color:           seriesItem.Color,
			EdbInfoList:     tmpSeriesEdbInfoList,
			ShowTrendLine:   seriesItem.ShowTrendLine,
			ShowFitEquation: seriesItem.ShowFitEquation,
			ShowRSquare:     seriesItem.ShowRSquare,
			TrendLine:       trendLine,
			RSquare:         rSquare,
			TrendLimitData:  trendLimitData,
		})
	}

	// 截面散点图点击详情时自动更新系列名
	if len(extraConfig.SeriesList) > 0 {
		// 默认名字的时候才自动更新
		if extraConfig.SeriesList[0].IsNameDefault {
			firstXEdbInfoId := extraConfig.SeriesList[0].EdbInfoList[0].XEdbInfoId
			needUpdate := false
			if v, ok := edbMappingMap[firstXEdbInfoId]; ok {
				extraConfig.SeriesList[0].Name = v.LatestDate
				extraConfig.SeriesList[0].NameEn = v.LatestDate
				dataListResp[0].Name = v.LatestDate
				dataListResp[0].NameEn = v.LatestDate
				needUpdate = true
			}

			extraConfigByte, e := json.Marshal(extraConfig)
			if e != nil {
				errMsg := "截面散点系列更新异常"
				err = errors.New(errMsg)
				return
			}
			extraConfigStr := string(extraConfigByte)

			if needUpdate {
				err = data_manage.EditChartInfoExtraConfig(chartInfoId, extraConfigStr)
				if err != nil {
					errMsg := "截面散点系列更新异常"
					err = errors.New(errMsg)
					return
				}
			}
		}
	}

	chartDataResp = data_manage.SectionScatterInfoResp{
		XName:       extraConfig.XName,
		XNameEn:     extraConfig.XNameEn,
		XUnitName:   extraConfig.XUnitName,
		XUnitNameEn: extraConfig.XUnitNameEn,
		YName:       extraConfig.YName,
		YNameEn:     extraConfig.YNameEn,
		YUnitName:   extraConfig.YUnitName,
		YUnitNameEn: extraConfig.YUnitNameEn,
		XMinValue:   extraConfig.XMinValue,
		XMaxValue:   extraConfig.XMaxValue,
		YMinValue:   extraConfig.YMinValue,
		YMaxValue:   extraConfig.YMaxValue,
		DataList:    dataListResp,
	}
	return
}

// AddChartInfo 添加图表
func AddChartInfo(req data_manage.AddChartInfoReq, sysUserId int, sysUserRealName, lang string) (chartInfo *data_manage.ChartInfo, err error, errMsg string, isSendEmail bool) {
	isSendEmail = true // 默认错误的时候要发送邮件

	req.ChartName = strings.Trim(req.ChartName, " ")
	if req.ChartName == "" {
		errMsg = "请填写图表名称！"
		err = errors.New(errMsg)
		isSendEmail = false
		return
	}
	if req.ChartClassifyId <= 0 {
		errMsg = "分类参数错误！"
		err = errors.New(errMsg)
		isSendEmail = false
		return
	}
	//if req.ChartThemeId <= 0 {
	//	errMsg = "请选择主题"
	//	err = errors.New(errMsg)
	//	isSendEmail = false
	//	return
	//}
	//
	//// 判断主题是否存在
	//_, err = chart_theme.GetChartThemeId(req.ChartThemeId)
	//if err != nil {
	//	if err.Error() == utils.ErrNoRow() {
	//		errMsg = "主题不存在"
	//		err = errors.New(errMsg)
	//		return
	//	}
	//	errMsg = "获取主题信息失败"
	//	return
	//}

	chartClassify, err := data_manage.GetChartClassifyById(req.ChartClassifyId)
	if err != nil {
		if err.Error() == utils.ErrNoRow() {
			errMsg = "分类不存在"
			err = errors.New(errMsg)
			return
		}
		errMsg = "获取分类信息失败"
		return
	}
	if chartClassify == nil {
		errMsg = "分类不存在"
		err = errors.New(errMsg)
		return
	}

	chartType := req.ChartType
	extraConfig := req.ExtraConfig
	var extraConfigEdbInfoIdArr []int
	extraConfigEdbInfoIdArr, err, errMsg = CheckChartExtraConfig(chartType, extraConfig)
	if err != nil {
		err = errors.New("添加失败:" + err.Error())
		return
	}
	// 季节性图表额外配置信息
	var seasonExtraConfig string
	// 关联指标
	var edbInfoIdArr []int
	chartEdbInfoList := req.ChartEdbInfoList
	if len(chartEdbInfoList) > 0 {
		for _, v := range chartEdbInfoList {
			edbInfoId := v.EdbInfoId
			edbInfo, tmpErr := data_manage.GetEdbInfoById(edbInfoId)
			if tmpErr != nil {
				if tmpErr.Error() == utils.ErrNoRow() {
					errMsg = "指标不存在！"
					err = errors.New("指标不存在，edbInfoId:" + strconv.Itoa(edbInfoId))
					return
				} else {
					errMsg = "获取指标信息失败！"
					err = errors.New("获取图表的指标信息失败，Err:" + tmpErr.Error())
					return
				}
			}

			if edbInfo == nil {
				errMsg = "指标已被删除，请重新选择！"
				err = errors.New("指标不存在，edbInfoId:" + strconv.Itoa(edbInfoId))
				return
			} else {
				if edbInfo.EdbInfoId <= 0 {
					errMsg = "指标已被删除，请重新选择！"
					err = errors.New("指标不存在，edbInfoId:" + strconv.Itoa(edbInfoId))
					return
				}
			}

			edbInfoIdArr = append(edbInfoIdArr, edbInfoId)
			edbInfo.EdbNameSource = edbInfo.EdbName
			//edbList = append(edbList, edbInfo)

			//新增季节性图表数据计算
			if chartType == 2 {
				existCount, tmpErr := data_manage.GetEdbDataQuarterCount(edbInfoId)
				if tmpErr != nil {
					errMsg = "保存失败"
					err = errors.New("判断季节性图表，指标数据是否存在失败，Err:" + tmpErr.Error())
					return
				}
				if existCount <= 0 {
					go data_manage.AddCalculateQuarter(edbInfoId, edbInfo.Source, edbInfo.EdbCode)
				}

				// 处理季节性图表横轴配置
				{
					if req.SeasonExtraConfig.XEndDate != "" {
						if req.SeasonExtraConfig.XStartDate > req.SeasonExtraConfig.XEndDate && req.SeasonExtraConfig.JumpYear != 1 {
							errMsg = "季节性图表配置信息异常：横坐标日期配置错误"
							err = errors.New("季节性图表配置信息异常： 横坐标日期配置错误")
							return
						}
						seasonExtra, tErr := json.Marshal(req.SeasonExtraConfig)
						if tErr != nil {
							errMsg = "季节性图表配置信息异常"
							err = errors.New("季节性图表配置信息异常,Err:" + tErr.Error())
							return
						}

						seasonExtraConfig = string(seasonExtra)
					}
				}
			}
		}
	} else {
		if extraConfig == `` {
			errMsg = "请选择指标！"
			err = errors.New(errMsg)
			return
		}
		edbInfoIdArr = extraConfigEdbInfoIdArr
		lenEdbInfoIdArr := len(edbInfoIdArr)
		if lenEdbInfoIdArr > 0 {
			tmpEdbList, tmpErr := data_manage.GetEdbInfoByIdList(edbInfoIdArr)
			if tmpErr != nil {
				errMsg = "指标异常！"
				err = errors.New("指标异常！Err:" + tmpErr.Error())
				return
			}
			if len(tmpEdbList) != lenEdbInfoIdArr {
				errMsg = "指标异常！"
				err = errors.New(fmt.Sprint("查找出来的指标数量与选择的指标数量不符！查找出来的指标数量:", len(tmpEdbList), ";用户选择的指标数量:", lenEdbInfoIdArr))
				return
			}
			for _, v := range tmpEdbList {
				chartEdbInfoList = append(chartEdbInfoList, &data_manage.ChartSaveItem{
					EdbInfoId:         v.EdbInfoId,
					MaxData:           0,
					MinData:           0,
					IsOrder:           false,
					IsAxis:            1,
					EdbInfoType:       1,
					LeadValue:         0,
					LeadUnit:          "",
					ChartStyle:        "",
					ChartColor:        "",
					PredictChartColor: "",
					ChartWidth:        0,
					Source:            utils.CHART_SOURCE_DEFAULT,
				})
			}

		}
	}
	if len(edbInfoIdArr) <= 0 {
		errMsg = "请选择指标！"
		err = errors.New(errMsg)
		return
	}

	// 图表额外配置
	extraConfig, err, errMsg = HandleExtraConfig(chartType, extraConfig)
	if err != nil {
		if errMsg == `` {
			errMsg = "指标异常！"
		}
		err = errors.New("指标异常！Err:" + err.Error())
		return
	}

	sort.Ints(edbInfoIdArr)
	var edbInfoIdArrStr []string
	for _, v := range edbInfoIdArr {
		edbInfoIdArrStr = append(edbInfoIdArrStr, strconv.Itoa(v))
	}
	edbInfoIdStr := strings.Join(edbInfoIdArrStr, ",")
	//count, err := data_manage.ChartInfoExist("", edbInfoIdStr)
	//if err != nil && err.Error() != utils.ErrNoRow() {
	//	br.Msg = "保存失败"
	//	br.ErrMsg = "判断图表名称是否存在失败,Err:" + err.Error()
	//	return
	//}
	//if count > 0 {
	//	br.Msg = "所选指标已存在相同指标"
	//	return
	//}

	{
		var count int // 同名指标数量
		//判断图表是否存在
		var condition string
		var pars []interface{}

		// 图表名称在不同图分类下不允许重复 需求调整时间：2022年11月07日09:47:07
		//condition += " AND chart_classify_id=? "
		//pars = append(pars, req.ChartClassifyId)

		switch lang {
		case utils.EnLangVersion:
			condition += " AND chart_name_en = ? AND source = ? "
		default:
			condition += " AND chart_name = ? AND source = ? "
		}
		pars = append(pars, req.ChartName, utils.CHART_SOURCE_DEFAULT)

		count, err = data_manage.GetChartInfoCountByCondition(condition, pars)
		if err != nil {
			errMsg = "判断图表名称是否存在失败"
			err = errors.New("判断图表名称是否存在失败,Err:" + err.Error())
			return
		}

		if count > 0 {
			errMsg = "图表已存在，请重新填写"
			err = errors.New(errMsg)
			isSendEmail = false
			return
		}
	}

	barChartConf := `` //柱方图的配置信息
	if chartType == 7 {
		barChartConfReq := req.BarChartInfo
		if len(barChartConfReq.EdbInfoIdList) <= 0 {
			errMsg = "请选择指标"
			err = errors.New(errMsg)
			isSendEmail = false
			return
		}
		if len(barChartConfReq.DateList) <= 0 {
			errMsg = "请选择日期"
			err = errors.New(errMsg)
			isSendEmail = false
			return
		}
		barChartConfByte, tmpErr := json.Marshal(barChartConfReq)
		if tmpErr != nil {
			errMsg = "柱方图信息异常"
			err = errors.New("柱方图信息异常,Err:" + tmpErr.Error())
			return
		}
		barChartConf = string(barChartConfByte)
	}

	disableVal := CheckIsDisableChart(edbInfoIdArr)

	chartInfo = new(data_manage.ChartInfo)
	chartInfo.ChartName = req.ChartName
	chartInfo.ChartNameEn = req.ChartName
	chartInfo.EdbInfoIds = edbInfoIdStr
	chartInfo.ChartClassifyId = req.ChartClassifyId
	chartInfo.SysUserId = sysUserId
	chartInfo.SysUserRealName = sysUserRealName
	chartInfo.CreateTime = time.Now()
	chartInfo.ModifyTime = time.Now()
	chartInfo.IsSetName = 0
	timestamp := strconv.FormatInt(time.Now().UnixNano(), 10)
	chartInfo.UniqueCode = utils.MD5(utils.CHART_PREFIX + "_" + timestamp)

	// todo 判断是否需要重新计算用户的start_date
	if req.DateType > 0 {
		chartInfo.DateType = req.DateType
	} else {
		chartInfo.DateType = 3
	}
	if chartType == 0 {
		chartType = 1
	}
	chartInfo.ChartType = chartType

	calendar := req.Calendar
	if calendar == "" {
		calendar = "公历"
	}

	chartInfo.Calendar = calendar
	chartInfo.StartDate = req.StartDate
	chartInfo.EndDate = req.EndDate
	chartInfo.SeasonStartDate = req.StartDate
	chartInfo.SeasonEndDate = req.EndDate
	chartInfo.LeftMin = req.LeftMin
	chartInfo.LeftMax = req.LeftMax
	chartInfo.RightMin = req.RightMin
	chartInfo.RightMax = req.RightMax
	chartInfo.Right2Min = req.Right2Min
	chartInfo.Right2Max = req.Right2Max
	chartInfo.MinMaxSave = req.MinMaxSave
	chartInfo.Disabled = disableVal
	chartInfo.BarConfig = barChartConf
	chartInfo.ExtraConfig = extraConfig
	chartInfo.SeasonExtraConfig = seasonExtraConfig
	chartInfo.StartYear = req.StartYear
	chartInfo.Source = utils.CHART_SOURCE_DEFAULT
	chartInfo.ChartThemeId = req.ChartThemeId
	chartInfo.SourcesFrom = req.SourcesFrom
	chartInfo.Instructions = req.Instructions
	chartInfo.MarkersLines = req.MarkersLines
	chartInfo.MarkersAreas = req.MarkersAreas
	chartInfo.Unit = req.Unit
	chartInfo.UnitEn = req.UnitEn
	newId, err := data_manage.AddChartInfo(chartInfo)
	if err != nil {
		errMsg = `保存失败`
		err = errors.New("保存失败，Err:" + err.Error())
		return
	}
	chartInfo.ChartInfoId = int(newId)

	mapList := make([]*data_manage.ChartEdbMapping, 0)
	for _, v := range chartEdbInfoList {
		mapItem := new(data_manage.ChartEdbMapping)
		mapItem.ChartInfoId = int(newId)
		mapItem.EdbInfoId = v.EdbInfoId
		mapItem.CreateTime = time.Now()
		mapItem.ModifyTime = time.Now()
		edbTimestamp := strconv.FormatInt(time.Now().UnixNano(), 10)
		mapItem.UniqueCode = utils.MD5(fmt.Sprint(utils.CHART_PREFIX, "_", v.EdbInfoId, "_", edbTimestamp))
		mapItem.MaxData = v.MaxData
		mapItem.MinData = v.MinData
		mapItem.IsOrder = v.IsOrder
		mapItem.IsAxis = v.IsAxis
		mapItem.EdbInfoType = v.EdbInfoType
		mapItem.LeadValue = v.LeadValue
		mapItem.LeadUnit = v.LeadUnit
		mapItem.ChartStyle = v.ChartStyle
		mapItem.ChartColor = v.ChartColor
		mapItem.PredictChartColor = v.PredictChartColor
		mapItem.ChartWidth = v.ChartWidth
		mapItem.Source = utils.CHART_SOURCE_DEFAULT
		mapItem.EdbAliasName = v.EdbAliasName
		mapItem.IsConvert = v.IsConvert
		mapItem.ConvertType = v.ConvertType
		mapItem.ConvertValue = v.ConvertValue
		mapItem.ConvertUnit = v.ConvertUnit
		mapItem.ConvertEnUnit = v.ConvertEnUnit
		mapList = append(mapList, mapItem)
	}
	err = data_manage.AddChartEdbMapping(mapList)
	if err != nil {
		errMsg = `保存失败`
		err = errors.New("保存失败，Err:" + err.Error())
		return
	}

	//添加es数据
	go EsAddOrEditChartInfo(chartInfo.ChartInfoId)

	return
}

// EditChartInfo 编辑图表
func EditChartInfo(req data_manage.EditChartInfoReq, sysUser *system.Admin, lang string) (chartItem *data_manage.ChartInfo, err error, errMsg string, isSendEmail bool) {
	isSendEmail = true // 默认错误的时候要发送邮件

	req.ChartName = strings.Trim(req.ChartName, " ")
	if req.ChartName == "" {
		errMsg = "请填写图表名称！"
		err = errors.New(errMsg)
		isSendEmail = false
		return
	}
	if req.ChartClassifyId <= 0 {
		errMsg = "分类参数错误！"
		err = errors.New(errMsg)
		isSendEmail = false
		return
	}
	//if req.ChartThemeId <= 0 {
	//	errMsg = "请选择主题！"
	//	err = errors.New(errMsg)
	//	isSendEmail = false
	//	return
	//}
	//
	//// 判断主题是否存在
	//_, err = chart_theme.GetChartThemeId(req.ChartThemeId)
	//if err != nil {
	//	if err.Error() == utils.ErrNoRow() {
	//		errMsg = "主题不存在"
	//		err = errors.New(errMsg)
	//		return
	//	}
	//	errMsg = "获取主题信息失败"
	//	return
	//}

	chartClassify, err := data_manage.GetChartClassifyById(req.ChartClassifyId)
	if err != nil {
		if err.Error() == utils.ErrNoRow() {
			errMsg = "分类不存在"
			err = errors.New(errMsg)
			return
		}
		errMsg = "获取分类信息失败"
		return
	}
	if chartClassify == nil {
		errMsg = "分类不存在"
		err = errors.New(errMsg)
		return
	}

	chartItem, err = data_manage.GetChartInfoById(req.ChartInfoId)
	if err != nil {
		if err.Error() == utils.ErrNoRow() {
			errMsg = "图表已被删除，请刷新页面"
			err = errors.New(errMsg)
			isSendEmail = false
			return
		}
		errMsg = "获取图表信息失败"
		err = errors.New("获取图表信息失败,Err:" + err.Error())
		return
	}

	var extraConfigEdbInfoIdArr []int
	extraConfigEdbInfoIdArr, err, errMsg = CheckChartExtraConfig(req.ChartType, req.ExtraConfig)
	if err != nil {
		err = errors.New("添加失败:" + err.Error())
		return
	}

	// 季节性图表额外配置信息
	var seasonExtraConfig string
	// 图表关联指标id
	chartEdbInfoList := make([]*data_manage.ChartSaveItem, 0)
	// 关联指标
	var edbInfoIdArr []int
	// 非散点截面图的直接通过前端获取,散点截面图需要额外从配置中获取
	if chartItem.ChartType != 10 {
		//edbList := make([]*data_manage.EdbInfo, 0)
		for _, v := range req.ChartEdbInfoList {
			edbInfoId := v.EdbInfoId
			edbInfo, tmpErr := data_manage.GetEdbInfoById(edbInfoId)
			if tmpErr != nil {
				if tmpErr.Error() == utils.ErrNoRow() {
					errMsg = "指标不存在！"
					err = errors.New("指标不存在，edbInfoId:" + strconv.Itoa(edbInfoId))
					return
				} else {
					errMsg = "获取指标信息失败！"
					err = errors.New("获取图表的指标信息失败，Err:" + tmpErr.Error())
					return
				}
			}

			if edbInfo == nil {
				errMsg = "指标已被删除，请重新选择！"
				err = errors.New("指标不存在，ChartInfoId:" + strconv.Itoa(edbInfoId))
				return
			} else {
				if edbInfo.EdbInfoId <= 0 {
					errMsg = "指标已被删除，请重新选择！"
					err = errors.New("指标不存在，ChartInfoId:" + strconv.Itoa(edbInfoId))
					return
				}
			}

			edbInfoIdArr = append(edbInfoIdArr, edbInfoId)
			edbInfo.EdbNameSource = edbInfo.EdbName
			//edbList = append(edbList, edbInfo)

			//新增季节性图表数据计算
			if req.ChartType == 2 {
				existCount, tmpErr := data_manage.GetEdbDataQuarterCount(edbInfoId)
				if tmpErr != nil {
					errMsg = "保存失败"
					err = errors.New("判断季节性图表，指标数据是否存在失败，Err:" + tmpErr.Error())
					return
				}
				if existCount <= 0 {
					go data_manage.AddCalculateQuarter(edbInfoId, edbInfo.Source, edbInfo.EdbCode)
				}

				// 处理季节性图表横轴配置
				{
					if req.SeasonExtraConfig.XEndDate != "" {
						if req.SeasonExtraConfig.XStartDate > req.SeasonExtraConfig.XEndDate && req.SeasonExtraConfig.JumpYear != 1 {
							errMsg = "季节性图表配置信息异常：横坐标日期配置错误"
							err = errors.New("季节性图表配置信息异常： 横坐标日期配置错误")
							return
						}
						seasonExtra, tErr := json.Marshal(req.SeasonExtraConfig)
						if tErr != nil {
							errMsg = "季节性图表配置信息异常"
							err = errors.New("季节性图表配置信息异常,Err:" + tErr.Error())
							return
						}

						seasonExtraConfig = string(seasonExtra)
					}
				}
			}
		}
		chartEdbInfoList = req.ChartEdbInfoList
	} else {
		if req.ExtraConfig == `` {
			errMsg = "请选择指标！"
			err = errors.New(errMsg)
			isSendEmail = false
			return
		}

		edbInfoIdArr = extraConfigEdbInfoIdArr
		lenEdbInfoIdArr := len(edbInfoIdArr)
		if lenEdbInfoIdArr > 0 {
			tmpEdbList, tmpErr := data_manage.GetEdbInfoByIdList(edbInfoIdArr)
			if tmpErr != nil {
				errMsg = "指标异常！"
				err = errors.New("指标异常！Err:" + tmpErr.Error())
				return
			}
			if len(tmpEdbList) != lenEdbInfoIdArr {
				errMsg = "指标异常！"
				err = errors.New(fmt.Sprint("查找出来的指标数量与选择的指标数量不符！查找出来的指标数量:", len(tmpEdbList), ";用户选择的指标数量:", lenEdbInfoIdArr))
				return
			}
			for _, v := range tmpEdbList {
				chartEdbInfoList = append(chartEdbInfoList, &data_manage.ChartSaveItem{
					EdbInfoId:         v.EdbInfoId,
					MaxData:           0,
					MinData:           0,
					IsOrder:           false,
					IsAxis:            1,
					EdbInfoType:       1,
					LeadValue:         0,
					LeadUnit:          "",
					ChartStyle:        "",
					ChartColor:        "",
					PredictChartColor: "",
					ChartWidth:        0,
					Source:            utils.CHART_SOURCE_DEFAULT,
				})
			}

		}
	}
	if len(edbInfoIdArr) <= 0 {
		errMsg = "请选择指标！"
		err = errors.New(errMsg)
		isSendEmail = false
		return
	}

	// 图表额外配置
	extraConfig, err, errMsg := HandleExtraConfig(req.ChartType, req.ExtraConfig)
	if err != nil {
		if errMsg == `` {
			errMsg = "指标异常！"
		}
		err = errors.New("指标异常！Err:" + err.Error())
		return
	}
	req.ExtraConfig = extraConfig

	// 权限
	var haveOperaAuth bool
	{
		// 已授权分类id
		permissionChartIdList, permissionClassifyIdList, tmpErr := data_manage_permission.GetUserChartAndClassifyPermissionList(sysUser.AdminId, chartItem.ChartInfoId, chartItem.ChartClassifyId)
		if tmpErr != nil {
			if errMsg == `` {
				errMsg = "获取失败！"
			}
			err = errors.New("获取已授权分类id数据失败，Err:" + tmpErr.Error())
			return
		}
		haveOperaAuth = data_manage_permission.CheckChartPermissionByPermissionIdList(chartItem.IsJoinPermission, chartClassify.IsJoinPermission, chartItem.ChartInfoId, chartItem.ChartClassifyId, permissionChartIdList, permissionClassifyIdList)

	}

	//图表操作权限
	ok := CheckOpChartPermission(sysUser, chartItem.SysUserId, haveOperaAuth)
	if !ok {
		errMsg = "没有该图表的操作权限"
		err = errors.New(errMsg)
		isSendEmail = false
		return
	}

	var calendar string
	var dateType int
	dateType = req.DateType
	if req.ChartType != chartItem.ChartType {
		if chartItem.ChartType != 2 && chartItem.Calendar == "" { //非季节性图
			calendar = "公历"
		}
		if chartItem.ChartType == 2 && chartItem.DateType <= 0 {
			dateType = 3
		}
	}
	sort.Ints(edbInfoIdArr)
	var edbInfoIdArrStr []string
	for _, v := range edbInfoIdArr {
		edbInfoIdArrStr = append(edbInfoIdArrStr, strconv.Itoa(v))
	}
	edbInfoIdStr := strings.Join(edbInfoIdArrStr, ",")
	//mappingCondition := ` AND chart_info_id<> ` + strconv.Itoa(req.ChartInfoId)
	//count, err := data_manage.ChartInfoExist(mappingCondition, edbInfoIdStr)
	//if err != nil && err.Error() != utils.ErrNoRow() {
	//	br.Msg = "保存失败"
	//	br.ErrMsg = "判断图表名称是否存在失败,Err:" + err.Error()
	//	return
	//}
	//if count > 0 {
	//	br.Msg = "所选指标已存在相同指标"
	//	return
	//}

	// 判断图表是否存在
	{
		var count int
		var condition string
		var pars []interface{}
		condition += " AND chart_info_id<>? "
		pars = append(pars, req.ChartInfoId)

		// 图表名称在不同图分类下不允许重复 需求调整时间：2022年11月07日09:47:07
		//condition += " AND chart_classify_id=? "
		//pars = append(pars, req.ChartClassifyId)

		switch lang {
		case utils.EnLangVersion:
			condition += " AND chart_name_en = ? AND source = ? "
		default:
			condition += " AND chart_name = ? AND source = ? "
		}
		pars = append(pars, req.ChartName, utils.CHART_SOURCE_DEFAULT)

		count, err = data_manage.GetChartInfoCountByCondition(condition, pars)
		if err != nil {
			errMsg = "判断图表名称是否存在失败"
			err = errors.New("判断图表名称是否存在失败,Err:" + err.Error())
			return
		}

		if count > 0 {
			errMsg = "图表已存在，请重新填写"
			err = errors.New(errMsg)
			isSendEmail = false
			return
		}
	}

	barChartConf := `` //柱方图的配置信息
	if req.ChartType == 7 {
		barChartConfReq := req.BarChartInfo
		if len(barChartConfReq.EdbInfoIdList) <= 0 {
			errMsg = "请选择指标"
			err = errors.New(errMsg)
			isSendEmail = false
			return
		}
		if len(barChartConfReq.DateList) <= 0 {
			errMsg = "请选择日期"
			err = errors.New(errMsg)
			isSendEmail = false
			return
		}
		barChartConfByte, tmpErr := json.Marshal(barChartConfReq)
		if tmpErr != nil {
			errMsg = "柱方图信息异常"
			err = errors.New("柱方图信息异常,Err:" + tmpErr.Error())
			return
		}
		barChartConf = string(barChartConfByte)
	}

	// 图表启用与否
	disableVal := CheckIsDisableChart(edbInfoIdArr)

	switch lang {
	case utils.EnLangVersion:
		req.ChartNameEn = req.ChartName
		req.ChartName = chartItem.ChartName

		if req.UnitEn == `` {
			req.UnitEn = req.Unit
		}
		req.Unit = chartItem.Unit
	default:
		req.ChartNameEn = chartItem.ChartNameEn
		req.UnitEn = chartItem.UnitEn
	}
	err = data_manage.EditChartInfoAndMapping(&req, edbInfoIdStr, calendar, dateType, disableVal, barChartConf, chartEdbInfoList, seasonExtraConfig)
	if err != nil {
		errMsg = "保存失败"
		err = errors.New("保存失败,Err:" + err.Error())
		return
	}
	resp := new(data_manage.AddChartInfoResp)
	resp.ChartInfoId = chartItem.ChartInfoId
	resp.UniqueCode = chartItem.UniqueCode
	resp.ChartType = req.ChartType

	//添加es数据
	go EsAddOrEditChartInfo(chartItem.ChartInfoId)
	//修改my eta es数据
	go EsAddOrEditMyChartInfoByChartInfoId(chartItem.ChartInfoId)

	return
}

// GetEdbSourceByEdbInfoIdList 获取关联指标的来源
func GetEdbSourceByEdbInfoIdList(chartEdbInfoMappingList []*data_manage.ChartEdbInfoMapping) (sourceNameList, sourceNameEnList []string) {
	sourceNameList = make([]string, 0)
	sourceNameEnList = make([]string, 0)
	sourceMap := make(map[int]string)
	for _, v := range chartEdbInfoMappingList {
		// 指标类型:1:基础指标,2:计算指标
		if v.EdbType == 2 || v.EdbInfoCategoryType == 1 {
			//sourceMap[0] = "弘则研究"
			baseEdbInfoArr, _, _ := data_manage.GetRefreshEdbInfoFromBase(v.EdbInfoId, v.Source)
			for _, baseEdbInfo := range baseEdbInfoArr {
				if baseEdbInfo.EdbInfoType == 0 { //普通指标才参与，预测指标不参与
					sourceMap[baseEdbInfo.Source] = baseEdbInfo.SourceName
				}
			}
		} else {
			sourceMap[v.Source] = v.SourceName
		}
	}

	for source, sourceName := range sourceMap {
		if utils.InArrayByInt([]int{utils.DATA_SOURCE_MANUAL, utils.DATA_SOURCE_MYSTEEL_CHEMICAL}, source) {
			continue
		}
		sourceNameList = append(sourceNameList, sourceName)

		sourceNameEn, ok := utils.DataSourceEnMap[source]
		if !ok {
			sourceNameEn = sourceName
		}
		sourceNameEnList = append(sourceNameEnList, sourceNameEn)
	}
	//sourceNameList = append(sourceNameList, utils.ChartDefaultNameCn)
	//sourceNameEnList = append(sourceNameEnList, utils.ChartDefaultNameEn)

	// 图表来源
	conf, e := models.GetBusinessConf()
	if e != nil {
		return
	}
	if conf[models.BusinessConfCompanyName] != "" {
		sourceNameList = append(sourceNameList, conf[models.BusinessConfCompanyName])
		sourceNameEnList = append(sourceNameEnList, conf[models.BusinessConfCompanyName])
	}
	return
}

// RadarChartData 雷达图的数据处理
func RadarChartData(mappingList []*data_manage.ChartEdbInfoMapping, edbDataListMap map[int][]*data_manage.EdbDataList, extraConfig data_manage.RadarChartInfoReq) (edbIdList []int, chartDataResp data_manage.RadarChartInfoResp, err error) {
	// 指标数据数组（10086:{"2022-12-02":100.01,"2022-12-01":102.3}）
	edbDataMap := make(map[int]map[string]float64)
	for edbInfoId, edbDataList := range edbDataListMap {
		edbDateData := make(map[string]float64)
		for _, edbData := range edbDataList {
			edbDateData[edbData.DataTime] = edbData.Value
		}
		edbDataMap[edbInfoId] = edbDateData
	}
	// edbIdList 指标展示顺序；x轴的指标顺序
	edbIdList = make([]int, 0)
	for _, v := range mappingList {
		edbIdList = append(edbIdList, v.EdbInfoId)
	}
	chartDateList := extraConfig.DateList

	yDataList := make([]data_manage.RadarYData, 0) //y轴的数据列表

	for _, chartDate := range chartDateList {
		var maxDate time.Time

		findDataList := make([]float64, 0) // 当前日期的数据值
		for _, edbInfoId := range edbIdList {
			findDate := chartDate.Date            //需要的日期值
			dataList := edbDataListMap[edbInfoId] //指标的所有数据值
			if len(dataList) <= 0 {
				// 没有数据的指标id
				findDataList = append(findDataList, 0)
				continue
			}
			switch chartDate.Type {
			case 1: //最新值
				findDate = dataList[len(dataList)-1].DataTime
			case 2: //近期几天
				findDateTime, tmpErr := time.ParseInLocation(utils.FormatDate, dataList[len(dataList)-1].DataTime, time.Local)
				if tmpErr != nil {
					err = tmpErr
					return
				}
				findDateTime = findDateTime.AddDate(0, 0, -chartDate.Value)

				lenData := len(dataList) - 1
				for i := lenData; i >= 0; i-- {
					currDateTime, e := time.ParseInLocation(utils.FormatDate, dataList[i].DataTime, time.Local)
					if e != nil {
						err = e
						return
					}
					if currDateTime.Equal(findDateTime) || currDateTime.Before(findDateTime) {
						findDate = dataList[i].DataTime
						break
					}
				}
			case 3: // 固定日期
				//最早的日期
				minDateTime, tmpErr := time.ParseInLocation(utils.FormatDate, dataList[0].DataTime, time.Local)
				if tmpErr != nil {
					err = tmpErr
					return
				}
				//寻找固定日期的数据
				findDateTime, tmpErr := time.ParseInLocation(utils.FormatDate, chartDate.Date, time.Local)
				if tmpErr != nil {
					err = tmpErr
					return
				}
				for tmpDateTime := findDateTime; tmpDateTime.After(minDateTime) || tmpDateTime.Equal(minDateTime); tmpDateTime = tmpDateTime.AddDate(0, 0, -1) {
					tmpDate := tmpDateTime.Format(utils.FormatDate)
					if _, ok := edbDataMap[edbInfoId][tmpDate]; ok { //如果能找到数据，那么就返回
						findDate = tmpDate
						break
					}
				}
			default:
				err = errors.New(fmt.Sprint("日期类型异常,Type:", chartDate.Type))
				return
			}
			findDateTime, _ := time.ParseInLocation(utils.FormatDate, findDate, time.Local)
			if maxDate.IsZero() {
				maxDate = findDateTime
			} else {
				if findDateTime.After(maxDate) {
					maxDate = findDateTime
				}
			}
			if tmpValue, ok := edbDataMap[edbInfoId][findDate]; ok {
				tmpValue, _ = decimal.NewFromFloat(tmpValue).Round(4).Float64()
				findDataList = append(findDataList, tmpValue)
			} else {
				findDataList = append(findDataList, 0)
			}
		}

		yDate := "0000-00-00"
		if !maxDate.IsZero() {
			yDate = maxDate.Format(utils.FormatDate)
		}
		yDataList = append(yDataList, data_manage.RadarYData{
			Date:  yDate,
			Value: findDataList,
			Color: chartDate.Color,
			Name:  chartDate.Name,
		})
	}

	chartDataResp = data_manage.RadarChartInfoResp{
		YDataList:   yDataList,
		XEdbIdValue: edbIdList,
	}
	return
}

// GetChartConvertEdbData 获取图表数据转换的指标数据
func GetChartConvertEdbData(chartInfoId, chartType int, calendar, startDate, endDate string, mappingList []*data_manage.ChartEdbInfoMapping, extraConfigStr string, seasonExtraConfig string, isAxis int) (edbList []*data_manage.ChartEdbInfoMapping, xEdbIdValue []int, yDataList []data_manage.YData, dataResp interface{}, err error, errMsg string) {
	edbList = make([]*data_manage.ChartEdbInfoMapping, 0)
	xEdbIdValue = make([]int, 0)
	yDataList = make([]data_manage.YData, 0)

	var extraConfig interface{}
	switch chartType {
	case 7: // 柱形图
		var barConfig data_manage.BarChartInfoReq
		if extraConfigStr == `` {
			errMsg = "柱方图未配置"
			err = errors.New(errMsg)
			return
		}
		err = json.Unmarshal([]byte(extraConfigStr), &barConfig)
		if err != nil {
			errMsg = "柱方图配置异常"
			err = errors.New(errMsg)
			return
		}
		extraConfig = barConfig
	case 10: // 截面散点图
		var tmpExtraConfig data_manage.SectionScatterReq
		if extraConfigStr == `` {
			errMsg = "截面散点图未配置"
			err = errors.New(errMsg)
			return
		}
		err = json.Unmarshal([]byte(extraConfigStr), &tmpExtraConfig)
		if err != nil {
			errMsg = "截面散点配置异常"
			err = errors.New(errMsg)
			return
		}

		extraConfig = tmpExtraConfig
	case utils.CHART_TYPE_RADAR:
		var barConfig data_manage.RadarChartInfoReq
		if extraConfigStr == `` {
			errMsg = "雷达图未配置"
			err = errors.New(errMsg)
			return
		}
		err = json.Unmarshal([]byte(extraConfigStr), &barConfig)
		if err != nil {
			errMsg = "雷达图配置异常"
			err = errors.New(errMsg)
			return
		}
		extraConfig = barConfig
	default:
		xEdbIdValue = make([]int, 0)
		yDataList = make([]data_manage.YData, 0)
	}

	// 指标对应的所有数据
	edbDataListMap, edbList, err := getEdbConvertDataMapList(chartInfoId, chartType, calendar, startDate, endDate, mappingList, seasonExtraConfig, isAxis)
	if err != nil {
		return
	}

	// 特殊图形数据处理
	switch chartType {
	case 2: // 季节性图
		if seasonExtraConfig != "" {
			dataResp, err = SeasonChartData(edbList, seasonExtraConfig)
		}
	case 7: // 柱形图
		barChartConf := extraConfig.(data_manage.BarChartInfoReq)
		xEdbIdValue, yDataList, err = BarChartData(mappingList, edbDataListMap, barChartConf.DateList, barChartConf.Sort)

		for k := range yDataList {
			yDataList[k].Unit = barChartConf.Unit
			yDataList[k].UnitEn = barChartConf.UnitEn
		}

		for _, v := range edbList {
			// 指标别名
			if barChartConf.EdbInfoIdList != nil && len(barChartConf.EdbInfoIdList) > 0 {
				for _, reqEdb := range barChartConf.EdbInfoIdList {
					if v.EdbInfoId == reqEdb.EdbInfoId {
						v.EdbAliasName = reqEdb.Name
					}
				}
			}
		}
	case 10: // 截面散点图
		sectionScatterConf := extraConfig.(data_manage.SectionScatterReq)
		xEdbIdValue, dataResp, err = GetSectionScatterChartData(chartInfoId, mappingList, edbDataListMap, sectionScatterConf)

		var tmpExtraConfig data_manage.SectionScatterReq
		if extraConfigStr == `` {
			errMsg = "截面散点图未配置"
			err = errors.New(errMsg)
			return
		}
		err = json.Unmarshal([]byte(extraConfigStr), &tmpExtraConfig)
		if err != nil {
			errMsg = "截面散点配置异常"
			err = errors.New(errMsg)
			return
		}

		// 这个数据没有必要返回给前端
		for _, v := range edbList {
			v.DataList = nil
		}
	case utils.CHART_TYPE_RADAR: //雷达图
		radarConf := extraConfig.(data_manage.RadarChartInfoReq)
		xEdbIdValue, dataResp, err = RadarChartData(mappingList, edbDataListMap, radarConf)
	}
	return
}

func getEdbConvertDataMapList(chartInfoId, chartType int, calendar, startDate, endDate string, mappingList []*data_manage.ChartEdbInfoMapping, seasonExtraConfig string, isAxis int) (edbDataListMap map[int][]*data_manage.EdbDataList, edbList []*data_manage.ChartEdbInfoMapping, err error) {
	// 指标对应的所有数据
	edbDataListMap = make(map[int][]*data_manage.EdbDataList)

	for _, v := range mappingList {
		//fmt.Println("v:", v.EdbInfoId)
		item := new(data_manage.ChartEdbInfoMapping)
		item.EdbInfoId = v.EdbInfoId
		item.SourceName = v.SourceName
		item.Source = v.Source
		item.EdbCode = v.EdbCode
		item.EdbName = v.EdbName
		item.EdbNameEn = v.EdbNameEn
		item.Frequency = v.Frequency
		item.EdbType = v.EdbType
		item.FrequencyEn = GetFrequencyEn(v.Frequency)
		if v.Unit != `无` {
			item.Unit = v.Unit
		}
		item.UnitEn = v.UnitEn
		item.StartDate = v.StartDate
		item.EndDate = v.EndDate
		item.ModifyTime = v.ModifyTime
		item.EdbInfoCategoryType = v.EdbInfoCategoryType
		item.PredictChartColor = v.PredictChartColor
		item.ClassifyId = v.ClassifyId
		if chartInfoId <= 0 {
			item.IsAxis = 1
			item.LeadValue = 0
			item.LeadUnit = ""
			item.ChartEdbMappingId = 0
			item.ChartInfoId = 0
			item.IsOrder = false
			item.EdbInfoType = 1
			item.ChartStyle = ""
			item.ChartColor = ""
			item.ChartWidth = 0
			item.MaxData = v.MaxValue
			item.MinData = v.MinValue
		} else {
			item.IsAxis = v.IsAxis
			item.EdbInfoType = v.EdbInfoType
			item.LeadValue = v.LeadValue
			item.LeadUnit = v.LeadUnit
			item.LeadUnitEn = GetLeadUnitEn(v.LeadUnit)
			item.ChartEdbMappingId = v.ChartEdbMappingId
			item.ChartInfoId = v.ChartInfoId
			item.ChartStyle = v.ChartStyle
			item.ChartColor = v.ChartColor
			item.ChartWidth = v.ChartWidth
			item.IsOrder = v.IsOrder
			item.MaxData = v.MaxData
			item.MinData = v.MinData
		}
		item.LatestValue = v.LatestValue
		item.LatestDate = v.LatestDate
		item.UniqueCode = v.UniqueCode
		item.MoveLatestDate = v.LatestDate
		item.EdbAliasName = v.EdbAliasName
		item.IsConvert = v.IsConvert
		item.ConvertType = v.ConvertType
		item.ConvertValue = v.ConvertValue
		item.ConvertUnit = v.ConvertUnit
		item.ConvertEnUnit = v.ConvertEnUnit

		var startDateReal string
		var diffSeconds int64
		if chartType == 2 { //季节性图
			startDateReal = startDate
			if len(mappingList) > 1 {
				item.IsAxis = v.IsAxis
			}
		} else {
			if v.EdbInfoType == 0 && v.LeadUnit != "" && v.LeadValue > 0 { //领先指标
				var startTimeRealTemp time.Time
				startDateParse, _ := time.Parse(utils.FormatDate, startDate)
				switch v.LeadUnit {
				case "天":
					startTimeRealTemp = startDateParse.AddDate(0, 0, -v.LeadValue)
				case "月":
					startTimeRealTemp = startDateParse.AddDate(0, -v.LeadValue, 0)
				case "季":
					startTimeRealTemp = startDateParse.AddDate(0, -3*v.LeadValue, 0)
				case "周":
					startTimeRealTemp = startDateParse.AddDate(0, 0, -7*v.LeadValue)
				case "年":
					startTimeRealTemp = startDateParse.AddDate(-v.LeadValue, 0, 0)
				}
				if startTimeRealTemp.Before(startDateParse) {
					startDateReal = startTimeRealTemp.Format(utils.FormatDate)
					diffSeconds = (int64(startTimeRealTemp.UnixNano()) - int64(startDateParse.UnixNano())) / 1e6
				} else {
					startDateReal = startDate
					diffSeconds = 0
				}

				// 预测指标的开始日期也要偏移
				{
					day, tmpErr := utils.GetDaysBetween2Date(utils.FormatDate, startDate, startDateReal)
					if tmpErr != nil {
						err = tmpErr
						return
					}
					moveLatestDateTime, tmpErr := time.ParseInLocation(utils.FormatDate, item.MoveLatestDate, time.Local)
					if tmpErr != nil {
						err = tmpErr
						return
					}
					item.MoveLatestDate = moveLatestDateTime.AddDate(0, 0, day).Format(utils.FormatDate)
				}
			} else {
				startDateReal = startDate
			}
		}
		//fmt.Println("line 1011 chart:", v.Source, v.EdbInfoId, startDateReal, endDate)
		calendarPreYear := 0
		if calendar == "农历" {
			newStartDateReal, err := time.Parse(utils.FormatDate, startDateReal)
			if err != nil {
				fmt.Println("time.Parse:" + err.Error())
			}
			calendarPreYear = newStartDateReal.Year() - 1
			newStartDateReal = newStartDateReal.AddDate(-1, 0, 0)
			startDateReal = newStartDateReal.Format(utils.FormatDate)
		}
		dataList := make([]*data_manage.EdbDataList, 0)
		//fmt.Println("chart:", v.Source, v.EdbInfoId, startDateReal, endDate)
		//fmt.Println("calendarPreYear:", calendarPreYear)
		//var newEdbInfo *data_manage.EdbInfo
		switch v.EdbInfoCategoryType {
		case 0:
			dataList, err = data_manage.GetEdbDataList(v.Source, v.SubSource, v.EdbInfoId, startDateReal, endDate)
		case 1:
			_, dataList, _, _, err, _ = GetPredictDataListByPredictEdbInfoId(v.EdbInfoId, startDateReal, endDate, true)
		default:
			err = errors.New(fmt.Sprint("获取失败,指标类型异常", v.EdbInfoCategoryType))
		}
		if err != nil {
			return
		}

		if v.IsConvert == 1 {
			switch v.ConvertType {
			case 1:
				for i, data := range dataList {
					dataList[i].Value = data.Value * v.ConvertValue
				}
				item.MaxData = item.MaxData * v.ConvertValue
				item.MinData = item.MinData * v.ConvertValue
			case 2:
				for i, data := range dataList {
					dataList[i].Value = data.Value / v.ConvertValue
				}
				item.MaxData = item.MaxData / v.ConvertValue
				item.MinData = item.MinData / v.ConvertValue
			case 3:
				for i, data := range dataList {
					dataList[i].Value = math.Log(data.Value) / math.Log(v.ConvertValue)
				}
				item.MaxData = math.Log(item.MaxData) / math.Log(v.ConvertValue)
				item.MinData = math.Log(item.MinData) / math.Log(v.ConvertValue)
			}
		}

		edbDataListMap[v.EdbInfoId] = dataList

		if diffSeconds != 0 && v.EdbInfoType == 0 {
			dataListLen := len(dataList)
			for i := 0; i < dataListLen; i++ {
				dataList[i].DataTimestamp = dataList[i].DataTimestamp - diffSeconds
			}
		}

		if chartType == 2 && isAxis == 1 {
			latestDate, tmpErr := time.Parse(utils.FormatDate, v.LatestDate)
			if tmpErr != nil {
				//item.DataList = dataList
				item.IsNullData = true
				edbList = append(edbList, item)
				continue
				err = errors.New(fmt.Sprint("获取最后实际数据的日期失败,Err:" + tmpErr.Error() + ";LatestDate:" + v.LatestDate))
				return
			}

			if calendar == "农历" {
				if len(dataList) <= 0 {
					result := new(data_manage.EdbDataResult)
					item.DataList = result
				} else {
					result, tmpErr := data_manage.AddCalculateQuarterV6(dataList)
					if tmpErr != nil {
						err = errors.New("获取农历数据失败,Err:" + tmpErr.Error())
						return
					}
					quarterDataList, tErr := GetSeasonEdbInfoDataListByXDateNong(result, latestDate, seasonExtraConfig, calendarPreYear)
					if tErr != nil {
						err = errors.New("获取季节性图表数据失败,Err:" + tErr.Error())
						return
					}
					item.DataList = quarterDataList
				}

			} else {
				quarterDataList, tErr := GetSeasonEdbInfoDataListByXDate(dataList, latestDate, seasonExtraConfig)
				if tErr != nil {
					err = errors.New("获取季节性图表数据失败,Err:" + tErr.Error())
					return
				}
				item.DataList = quarterDataList
			}

		} else if chartType == 2 && isAxis == 0 {
			// 右轴数据处理，只要最新一年
			latestDate, tmpErr := time.Parse(utils.FormatDate, v.LatestDate)
			if tmpErr != nil {
				//item.DataList = dataList
				item.IsNullData = true
				edbList = append(edbList, item)
				continue
				err = errors.New(fmt.Sprint("获取最后实际数据的日期失败,Err:" + tmpErr.Error() + ";LatestDate:" + v.LatestDate))
				return
			}
			newDataList := make([]*data_manage.EdbDataList, 0)
			for _, v := range dataList {
				dataTime, e := time.Parse(utils.FormatDate, v.DataTime)
				if e != nil {
					err = errors.New("季节性图处理右轴指标数据转换日期失败,Err:" + e.Error())
					return
				}
				if dataTime.Year() == latestDate.Year() {
					newDataList = append(newDataList, v)
				}
			}
			item.DataList = newDataList
		} else if chartType == 7 || chartType == utils.CHART_TYPE_RADAR { //柱方图
			//item.DataList = dataList
		} else {
			item.DataList = dataList
		}
		edbList = append(edbList, item)
	}

	return
}

// GetChartEdbDataV2 获取图表的指标数据
func GetChartEdbDataV2(chartInfoId, chartType int, calendar, startDate, endDate string, mappingList []*data_manage.ChartEdbInfoMapping, extraConfigStr string, seasonExtraConfig string, chartInfoData ChartInfoDataShow) (edbList []*data_manage.ChartEdbInfoMapping, xEdbIdValue []int, yDataList []data_manage.YData, dataResp interface{}, err error, errMsg string) {
	edbList = make([]*data_manage.ChartEdbInfoMapping, 0)
	xEdbIdValue = make([]int, 0)
	yDataList = make([]data_manage.YData, 0)

	var extraConfig interface{}
	switch chartType {
	case 7: // 柱形图
		var barConfig data_manage.BarChartInfoReq
		if extraConfigStr == `` {
			errMsg = "柱方图未配置"
			err = errors.New(errMsg)
			return
		}
		err = json.Unmarshal([]byte(extraConfigStr), &barConfig)
		if err != nil {
			errMsg = "柱方图配置异常"
			err = errors.New(errMsg)
			return
		}
		extraConfig = barConfig
	case 10: // 截面散点图
		var tmpExtraConfig data_manage.SectionScatterReq
		if extraConfigStr == `` {
			errMsg = "截面散点图未配置"
			err = errors.New(errMsg)
			return
		}
		err = json.Unmarshal([]byte(extraConfigStr), &tmpExtraConfig)
		if err != nil {
			errMsg = "截面散点配置异常"
			err = errors.New(errMsg)
			return
		}

		extraConfig = tmpExtraConfig
	case utils.CHART_TYPE_RADAR:
		var barConfig data_manage.RadarChartInfoReq
		if extraConfigStr == `` {
			errMsg = "雷达图未配置"
			err = errors.New(errMsg)
			return
		}
		err = json.Unmarshal([]byte(extraConfigStr), &barConfig)
		if err != nil {
			errMsg = "雷达图配置异常"
			err = errors.New(errMsg)
			return
		}
		extraConfig = barConfig
	default:
		xEdbIdValue = make([]int, 0)
		yDataList = make([]data_manage.YData, 0)
	}

	// 指标对应的所有数据
	edbDataListMap, edbList, err := chartInfoData.GetEdbDataMapList(chartInfoId, chartType, calendar, startDate, endDate, mappingList, seasonExtraConfig)
	if err != nil {
		return
	}

	// 特殊图形数据处理
	switch chartType {
	case 2: // 季节性图
		if seasonExtraConfig != "" {
			dataResp, err = SeasonChartData(edbList, seasonExtraConfig)
		}
	case 7: // 柱形图
		barChartConf := extraConfig.(data_manage.BarChartInfoReq)
		xEdbIdValue, yDataList, err = BarChartData(mappingList, edbDataListMap, barChartConf.DateList, barChartConf.Sort)

		for k := range yDataList {
			yDataList[k].Unit = barChartConf.Unit
			yDataList[k].UnitEn = barChartConf.UnitEn
		}

		for _, v := range edbList {
			// 指标别名
			if barChartConf.EdbInfoIdList != nil && len(barChartConf.EdbInfoIdList) > 0 {
				for _, reqEdb := range barChartConf.EdbInfoIdList {
					if v.EdbInfoId == reqEdb.EdbInfoId {
						v.EdbAliasName = reqEdb.Name
					}
				}
			}
		}
	case 10: // 截面散点图
		sectionScatterConf := extraConfig.(data_manage.SectionScatterReq)
		xEdbIdValue, dataResp, err = GetSectionScatterChartData(chartInfoId, mappingList, edbDataListMap, sectionScatterConf)

		var tmpExtraConfig data_manage.SectionScatterReq
		if extraConfigStr == `` {
			errMsg = "截面散点图未配置"
			err = errors.New(errMsg)
			return
		}
		err = json.Unmarshal([]byte(extraConfigStr), &tmpExtraConfig)
		if err != nil {
			errMsg = "截面散点配置异常"
			err = errors.New(errMsg)
			return
		}

		// 这个数据没有必要返回给前端
		for _, v := range edbList {
			v.DataList = nil
		}
	case utils.CHART_TYPE_RADAR: //雷达图
		radarConf := extraConfig.(data_manage.RadarChartInfoReq)
		xEdbIdValue, dataResp, err = RadarChartData(mappingList, edbDataListMap, radarConf)
	}
	return
}

// SeasonChartData 季节性图的数据处理
func SeasonChartData(dataList []*data_manage.ChartEdbInfoMapping, seasonExtraConfig string) (dataResp data_manage.SeasonChartResp, err error) {
	var seasonConfig data_manage.SeasonExtraItem
	err = json.Unmarshal([]byte(seasonExtraConfig), &seasonConfig)
	if err != nil {
		err = errors.New("季节性图配置异常, Err:" + err.Error())
		return
	}

	for _, mappingItem := range dataList {
		if mappingItem.IsAxis == 0 {
			continue
		}
		quarterDataList := mappingItem.DataList.(data_manage.QuarterDataList)
		// 上下限区间
		if seasonConfig.MaxMinLimits.Year > 0 {
			dataResp.MaxMinLimits.List = make([]*data_manage.MaxMinLimitsData, 0)
			dataTimeMap := make(map[time.Time]time.Time)
			dataTimeList := make([]string, 0)
			maxValueMap := make(map[time.Time]float64)
			minValueMap := make(map[time.Time]float64)

			maxMinDataList := make([]*data_manage.MaxMinLimitsData, 0)
			// 日度 周度插值
			for _, v := range quarterDataList {
				if mappingItem.Frequency == "日度" || mappingItem.Frequency == "周度" {
					handleDataMap := make(map[string]float64)
					dataTimeList, _, err = HandleDataByLinearRegressionToList(v.DataList, handleDataMap)
					if err != nil {
						err = errors.New("插值处理数据异常, Err:" + err.Error())
						return
					}
					for _, date := range dataTimeList {
						dateTime, e := time.Parse(utils.FormatDate, date)
						if e != nil {
							err = errors.New("时间格式化异常, Err:" + e.Error())
							return
						}
						newDate := dateTime.AddDate(time.Now().Year()-dateTime.Year(), 0, 0)
						// 处理上下限列表
						if value, ok := maxValueMap[newDate]; ok {
							if value < handleDataMap[date] {
								maxValueMap[newDate] = handleDataMap[date]
							}
						} else {
							maxValueMap[newDate] = handleDataMap[date]
						}

						if value, ok := minValueMap[newDate]; ok {
							if value > handleDataMap[date] {
								minValueMap[newDate] = handleDataMap[date]
							}
						} else {
							minValueMap[newDate] = handleDataMap[date]
						}

						dataTimeMap[newDate] = newDate
					}
				} else {
					// 旬度、月度、季度、半年度 不插值，需要先把日期列表和数据map取出来
					for _, vv := range v.DataList {
						dateTime, e := time.Parse(utils.FormatDate, vv.DataTime)
						if e != nil {
							err = errors.New("时间格式化异常, Err:" + e.Error())
							return
						}
						newDate := dateTime.AddDate(time.Now().Year()-dateTime.Year(), 0, 0)

						if value, ok := maxValueMap[newDate]; ok {
							if value < vv.Value {
								maxValueMap[newDate] = vv.Value
							}
						} else {
							maxValueMap[newDate] = vv.Value
						}

						if value, ok := minValueMap[newDate]; ok {
							if value > vv.Value {
								minValueMap[newDate] = vv.Value
							}
						} else {
							minValueMap[newDate] = vv.Value
						}
						dataTimeMap[newDate] = newDate
					}
				}
			}

			for _, v := range dataTimeMap {
				maxMinItem := &data_manage.MaxMinLimitsData{}
				if maxValue, ok := maxValueMap[v]; ok {
					maxMinItem.MaxValue = maxValue
				} else {
					maxMinItem.MaxValue = minValueMap[v]
				}

				if minValue, ok := minValueMap[v]; ok {
					maxMinItem.MinValue = minValue
				} else {
					maxMinItem.MinValue = maxValueMap[v]
				}
				maxMinItem.DataTime = v.Format(utils.FormatDate)
				maxMinItem.DataTimestamp = v.UnixNano() / 1e6

				maxMinDataList = append(maxMinDataList, maxMinItem)

			}

			// 排序
			sort.Slice(maxMinDataList, func(i, j int) bool {
				return maxMinDataList[i].DataTime < maxMinDataList[j].DataTime
			})

			dataResp.MaxMinLimits.List = maxMinDataList
			dataResp.MaxMinLimits.Color = seasonConfig.MaxMinLimits.Color
			dataResp.MaxMinLimits.Legend = seasonConfig.MaxMinLimits.Legend
			dataResp.MaxMinLimits.IsShow = seasonConfig.MaxMinLimits.IsShow
			dataResp.MaxMinLimits.IsAdd = seasonConfig.MaxMinLimits.IsAdd
			dataResp.MaxMinLimits.Year = seasonConfig.MaxMinLimits.Year
		}

		// 自定义同期均线
		if seasonConfig.SamePeriodAverage.Year > 0 {
			handleDataMap := make(map[string]float64)
			dataTimeMap := make(map[time.Time]time.Time)
			dataTimeList := make([]string, 0)
			valueMap := make(map[time.Time]float64)

			averageDataList := make([]*data_manage.SamePeriodAverageData, 0)
			for i := len(quarterDataList) - 1; i > len(quarterDataList)-seasonConfig.SamePeriodAverage.Year && i > 0; i-- {
				// 插值成日度
				dataTimeList, _, err = HandleDataByLinearRegressionToList(quarterDataList[i].DataList, handleDataMap)
				if err != nil {
					err = errors.New("插值处理数据异常, Err:" + err.Error())
					return
				}
				for _, date := range dataTimeList {
					dateTime, e := time.Parse(utils.FormatDate, date)
					if e != nil {
						err = errors.New("时间格式化异常, Err:" + e.Error())
						return
					}
					newDate := dateTime.AddDate(time.Now().Year()-dateTime.Year(), 0, 0)
					// 处理均值
					if value, ok := valueMap[newDate]; ok {
						valueMap[newDate] = (handleDataMap[date] + value) / 2
					} else {
						valueMap[newDate] = handleDataMap[date]
					}

					dataTimeMap[newDate] = newDate
				}
			}

			for _, v := range dataTimeMap {
				averageItem := &data_manage.SamePeriodAverageData{}
				if value, ok := valueMap[v]; ok {
					averageItem.Value = value
				}
				averageItem.DataTime = v.Format(utils.FormatDate)
				averageItem.DataTimestamp = v.UnixNano() / 1e6

				averageDataList = append(averageDataList, averageItem)

			}

			// 排序
			sort.Slice(averageDataList, func(i, j int) bool {
				return averageDataList[i].DataTime < averageDataList[j].DataTime
			})

			dataResp.SamePeriodAverage.List = averageDataList
			dataResp.SamePeriodAverage.Year = seasonConfig.SamePeriodAverage.Year
			dataResp.SamePeriodAverage.Color = seasonConfig.SamePeriodAverage.Color
			dataResp.SamePeriodAverage.Legend = seasonConfig.SamePeriodAverage.Legend
			dataResp.SamePeriodAverage.IsShow = seasonConfig.SamePeriodAverage.IsShow
			dataResp.SamePeriodAverage.LineType = seasonConfig.SamePeriodAverage.LineType
			dataResp.SamePeriodAverage.LineWidth = seasonConfig.SamePeriodAverage.LineWidth
			dataResp.SamePeriodAverage.IsAdd = seasonConfig.SamePeriodAverage.IsAdd

		}

		// 自定义同期标准差
		if seasonConfig.SamePeriodStandardDeviation.Year > 1 && seasonConfig.SamePeriodStandardDeviation.Multiple > 0 {
			// 先算均值，再算标准差
			handleDataMap := make(map[string]float64)
			dataTimeMap := make(map[time.Time]time.Time)
			dataTimeValueMap := make(map[time.Time][]float64)
			dataTimeList := make([]string, 0)
			valueMap := make(map[time.Time]float64)

			samePeriodStandardDeviationList := make([]*data_manage.MaxMinLimitsData, 0)
			for i := len(quarterDataList) - 1; i > len(quarterDataList)-seasonConfig.SamePeriodAverage.Year-1 && i > 0; i-- {
				// 插值成日度
				dataTimeList, _, err = HandleDataByLinearRegressionToListV2(quarterDataList[i].DataList, handleDataMap)
				if err != nil {
					err = errors.New("插值处理数据异常, Err:" + err.Error())
					return
				}
				for _, date := range dataTimeList {
					dateTime, e := time.Parse(utils.FormatDate, date)
					if e != nil {
						err = errors.New("时间格式化异常, Err:" + e.Error())
						return
					}
					newDate := dateTime.AddDate(time.Now().Year()-dateTime.Year(), 0, 0)
					// 处理均值
					if value, ok := valueMap[newDate]; ok {
						valueMap[newDate] = (handleDataMap[date] + value) / 2
					} else {
						valueMap[newDate] = handleDataMap[date]
					}

					dataTimeMap[newDate] = newDate
					valueList := dataTimeValueMap[newDate]
					valueList = append(valueList, handleDataMap[date])
					dataTimeValueMap[newDate] = valueList
				}
			}

			for _, v := range dataTimeMap {
				valueList := dataTimeValueMap[v]
				stdev := utils.CalculateStandardDeviation(valueList)
				stdev, _ = decimal.NewFromFloat(stdev).Round(4).Float64()

				maxMinItem := &data_manage.MaxMinLimitsData{}

				if value, ok := valueMap[v]; ok {
					maxMinItem.MaxValue = value + stdev*seasonConfig.SamePeriodStandardDeviation.Multiple
					maxMinItem.MinValue = value - stdev*seasonConfig.SamePeriodStandardDeviation.Multiple
				}

				maxMinItem.DataTime = v.Format(utils.FormatDate)
				maxMinItem.DataTimestamp = v.UnixNano() / 1e6

				samePeriodStandardDeviationList = append(samePeriodStandardDeviationList, maxMinItem)

			}

			// 排序
			sort.Slice(samePeriodStandardDeviationList, func(i, j int) bool {
				return samePeriodStandardDeviationList[i].DataTime < samePeriodStandardDeviationList[j].DataTime
			})

			dataResp.SamePeriodStandardDeviation.List = samePeriodStandardDeviationList
			dataResp.SamePeriodStandardDeviation.Color = seasonConfig.SamePeriodStandardDeviation.Color
			dataResp.SamePeriodStandardDeviation.Legend = seasonConfig.SamePeriodStandardDeviation.Legend
			dataResp.SamePeriodStandardDeviation.IsShow = seasonConfig.SamePeriodStandardDeviation.IsShow
			dataResp.SamePeriodStandardDeviation.Multiple = seasonConfig.SamePeriodStandardDeviation.Multiple
			dataResp.SamePeriodStandardDeviation.Year = seasonConfig.SamePeriodStandardDeviation.Year
			dataResp.SamePeriodStandardDeviation.IsAdd = seasonConfig.SamePeriodStandardDeviation.IsAdd
		}

		// 自定义右轴
		if seasonConfig.RightAxis.IndicatorType != 0 {
			if seasonConfig.RightAxis.IndicatorType == 1 {
				startTime, _ := time.Parse(utils.FormatDate, mappingItem.StartDate)
				for i := len(quarterDataList) - 1; i > len(quarterDataList)-2 && i > 0; i-- {
					var rightMappingItem data_manage.ChartEdbInfoMapping
					rightMappingItem = *mappingItem
					// 计算同比值
					tbzDataList, minValue, maxValue, e := GetEdbDataTbzForSeason(mappingItem.Frequency, quarterDataList[i].DataList, startTime)
					if e != nil {
						err = errors.New("计算同比值失败, Err:" + e.Error())
						return
					}
					rightMappingItem.DataList = tbzDataList
					rightMappingItem.MaxData = maxValue
					rightMappingItem.MinData = minValue
					dataResp.RightAxis.EdbInfoList = append(dataResp.RightAxis.EdbInfoList, &rightMappingItem)
				}
			}
			dataResp.RightAxis.SeasonRightAxis = seasonConfig.RightAxis
		}
	}

	return
}

// 计算百分位对应的值
func PercentileAlgorithm(x float64, data []float64) float64 {
	N := float64(len(data))
	n := (x / 100) * (N - 1)

	// 如果n是整数，则直接返回第n个数值
	if n == float64(int(n)) {
		return data[int(n)-1]
	}

	// 如果n是小数，执行插值
	nInt := int(n)
	e := n - float64(nInt)

	// 取出相邻的两个数值
	Sn := data[nInt-1]
	Sn1 := data[nInt]

	// 计算插值结果
	y := Sn + e*(Sn1-Sn)

	return y
}

func MarkerLineCalculate(markerLine data_manage.MarkersLine, dataList interface{}, chartInfo *data_manage.ChartInfoView) (value string, err error) {
	if markerLine.Calculation == 1 {
		// 区间均值
		averge := 0.0
		// 计算左轴
		if chartInfo.ChartType == 2 && markerLine.EdbType == 0 {
			//季节性图结构体不一样
			quarterDataList := dataList.(data_manage.QuarterDataList)
			for _, quarterData := range quarterDataList[len(quarterDataList)-1:] {
				for _, vv := range quarterData.DataList {
					averge += vv.Value
				}
				averge = averge / float64(len(quarterData.DataList))
				value = fmt.Sprintf("%.2f", averge)
			}
		} else {
			dataList := dataList.([]*data_manage.EdbDataList)
			for _, dataItem := range dataList {
				averge += dataItem.Value
			}
			averge = averge / float64(len(dataList))

			value = fmt.Sprintf("%.2f", averge)
		}

	} else if markerLine.Calculation == 2 {
		// 区间均值加N倍标准差
		averge := 0.0
		// 计算左轴
		if chartInfo.ChartType == 2 && markerLine.EdbType == 0 {
			//季节性图结构体不一样
			faloatList := make([]float64, 0)
			quarterDataList := dataList.(data_manage.QuarterDataList)
			for _, quarterData := range quarterDataList[len(quarterDataList)-1:] {
				for _, vv := range quarterData.DataList {
					dataList = append(faloatList, vv.Value)
					averge += vv.Value
				}
				averge = averge / float64(len(quarterData.DataList))
				stdev := utils.CalculateStandardDeviation(faloatList)
				stdev, _ = decimal.NewFromFloat(stdev).Round(4).Float64()

				value = fmt.Sprintf("%.2f", averge+stdev*float64(markerLine.CalculationValue))
			}

		} else {
			dataList := dataList.([]*data_manage.EdbDataList)
			floatList := make([]float64, 0)
			for _, dataItem := range dataList {
				floatList = append(floatList, dataItem.Value)
				averge += dataItem.Value
			}
			averge = averge / float64(len(dataList))

			stdev := utils.CalculateStandardDeviation(floatList)
			stdev, _ = decimal.NewFromFloat(stdev).Round(4).Float64()

			value = fmt.Sprintf("%.2f", averge+stdev*float64(markerLine.CalculationValue))
		}
	} else if markerLine.Calculation == 3 {
		// 区间个数分位
		markerLineValue := 0.0
		if chartInfo.ChartType == 2 && markerLine.EdbType == 0 {
			//季节性图结构体不一样
			faloatList := make([]float64, 0)
			quarterDataList := dataList.(data_manage.QuarterDataList)
			for _, quarterData := range quarterDataList[len(quarterDataList)-1:] {
				for _, vv := range quarterData.DataList {
					faloatList = append(faloatList, vv.Value)
				}

				markerLineValue = PercentileAlgorithm(float64(markerLine.CalculationValue), faloatList)
				value = fmt.Sprintf("%.2f", markerLineValue)
			}

		} else {
			dataList := dataList.([]*data_manage.EdbDataList)
			floatList := make([]float64, 0)
			for _, dataItem := range dataList {
				floatList = append(floatList, dataItem.Value)
			}

			markerLineValue = PercentileAlgorithm(float64(markerLine.CalculationValue), floatList)
			value = fmt.Sprintf("%.2f", markerLineValue)
		}
	}
	return
}