eta_chart_lib/controllers/chart_common.go

package controllers

import (
	"encoding/json"
	"eta/eta_chart_lib/models"
	aiPredictModel "eta/eta_chart_lib/models/ai_predict_model"
	"eta/eta_chart_lib/models/data_manage"
	cross_varietyReq "eta/eta_chart_lib/models/data_manage/cross_variety/request"
	"eta/eta_chart_lib/models/data_manage/future_good"
	"eta/eta_chart_lib/models/data_manage/future_good/request"
	"eta/eta_chart_lib/models/data_manage/future_good/response"
	line_equationReq "eta/eta_chart_lib/models/data_manage/line_equation/request"
	line_featureReq "eta/eta_chart_lib/models/data_manage/line_feature/request"
	"eta/eta_chart_lib/services/data"
	correlationServ "eta/eta_chart_lib/services/data/correlation"
	"eta/eta_chart_lib/services/data/cross_variety"
	"eta/eta_chart_lib/services/data/excel"
	future_goodServ "eta/eta_chart_lib/services/data/future_good"
	"eta/eta_chart_lib/services/data/line_equation"
	lineFeatureServ "eta/eta_chart_lib/services/data/line_feature"
	"eta/eta_chart_lib/services/data/range_analysis"
	dwmini "eta/eta_chart_lib/services/dw_mini"
	"eta/eta_chart_lib/utils"
	"fmt"
	"sort"
	"strconv"
	"strings"
	"time"
)

// CommonChartInfoDetailFromUniqueCode
// @Title 根据编码获取图表详情
// @Description 根据编码获取图表详情接口
// @Param   UniqueCode   query   int  true       "图表唯一编码,如果是管理后台访问，传固定字符串:7c69b590249049942070ae9dcd5bf6dc"
// @Param   IsCache   query   bool  true       "是否走缓存，默认false"
// @Param   Token   query   string  true       "东吴小程序token"
// @Param   AuthToken   query   string  true       "图表权限鉴权token"
// @Param   Source   query   int  true       "查询来源 1:东吴"
// @Success 200 {object} data_manage.ChartInfoDetailFromUniqueCodeResp
// @router /common/detail [get]
func (this *ChartController) CommonChartInfoDetailFromUniqueCode() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()

	uniqueCode := this.GetString("UniqueCode")
	token := this.GetString("Token")
	source, _ := this.GetInt("Source")
	authToken := this.GetString("AuthToken")
	if uniqueCode == "" {
		br.Msg = "参数错误"
		br.ErrMsg = "参数错误,uniqueCode is empty"
		return
	}
	key := utils.HZ_CHART_LIB_DETAIL + uniqueCode
	resp := new(models.ChartInfoDetailResp)

	chartInfo, err := models.GetChartInfoByUniqueCode(uniqueCode)
	if err != nil {
		if utils.IsErrNoRow(err) {
			br.Msg = "该图已被删除，请刷新页面"
			br.ErrMsg = "该图已被删除，请刷新页面，Err:" + err.Error()
			return
		}
		br.Msg = "获取失败"
		br.ErrMsg = "获取图表信息失败，Err:" + err.Error()
		return
	}

	// 图表水印
	conf, e := models.GetBusinessConf()
	if e != nil {
		br.Msg = "获取失败"
		br.ErrMsg = "获取配置信息失败, Err: " + e.Error()
		return
	}

	// 图表有效期是否开启
	if conf[models.BusinessConfIsOpenChartExpired] == "true" {
		resp.ChartInfo = chartInfo
		br.Data = resp

		if authToken == `` {
			br.Ret = 200
			br.Success = true
			br.Msg = "无鉴权"
			return
		}

		tmpKey := fmt.Sprint(utils.CACHE_CHART_AUTH, authToken)
		redisChartCode, err := utils.Rc.RedisString(tmpKey)
		if err != nil {
			br.Ret = 200
			br.Success = true
			br.Msg = "获取成功"
			return
		}
		if redisChartCode != uniqueCode {
			br.Ret = 200
			br.Msg = "获取失败"
			br.ErrMsg = "获取失败"
			return
		}
	}

	var isCollect bool
	if source == utils.CHART_SOURCE_DW && token != "" {
		tmpIsCollect, err := dwmini.GetMyChartIsCollect(token, uniqueCode)
		if err != nil {
			br.Msg = "获取失败"
			br.ErrMsg = "获取收藏状态失败，Err:" + err.Error()
			return
		}
		isCollect = tmpIsCollect
	}
	//判断是否有缓存
	if utils.Re == nil {
		if utils.Re == nil && utils.Rc.IsExist(key) {
			if data, err1 := utils.Rc.RedisBytes(key); err1 == nil {
				err := json.Unmarshal(data, &resp)
				if err == nil && resp != nil {
					if conf[models.BusinessConfWatermarkChart] == "true" && conf[models.BusinessConfCompanyWatermark] != "" {
						resp.WaterMark = conf[models.BusinessConfCompanyWatermark]
					}
					if isCollect {
						resp.IsCollect = isCollect
					}
					resp.IsAuth = true
					br.Ret = 200
					br.Success = true
					br.Msg = "获取成功"
					br.Data = resp
					fmt.Println("source redis")
					return
				}
			}
		}
	}

	//var resp interface{}
	var isOk bool
	var msg, errMsg string
	switch chartInfo.Source {
	case utils.CHART_SOURCE_DEFAULT:
		resp, isOk, msg, errMsg = GetChartInfoDetailFromUniqueCode(chartInfo, key)
	case utils.CHART_SOURCE_FUTURE_GOOD:
		resp, isOk, msg, errMsg = GetFutureGoodChartInfoDetailFromUniqueCode(chartInfo, key)
	case utils.CHART_SOURCE_FUTURE_GOOD_PROFIT:
		resp, isOk, msg, errMsg = GetFutureGoodProfitChartInfoDetailFromUniqueCode(chartInfo, key)
	case utils.CHART_SOURCE_CORRELATION, utils.CHART_SOURCE_ROLLING_CORRELATION:
		resp, isOk, msg, errMsg = GetCorrelationChartInfoDetailFromUniqueCode(chartInfo, key)
	case utils.CHART_SOURCE_LINE_EQUATION:
		resp, isOk, msg, errMsg = GetLineEquationChartInfoDetailFromUniqueCode(chartInfo, key)
	case utils.CHART_SOURCE_LINE_FEATURE_STANDARD_DEVIATION, utils.CHART_SOURCE_LINE_FEATURE_PERCENTILE, utils.CHART_SOURCE_LINE_FEATURE_FREQUENCY:
		resp, isOk, msg, errMsg = GetLineFeatureChartInfoDetailFromUniqueCode(chartInfo, key)
	case utils.CHART_SOURCE_CROSS_HEDGING:
		resp, isOk, msg, errMsg = GetCrossVarietyChartInfoDetailFromUniqueCode(chartInfo, key)
	case utils.CHART_SOURCE_BALANCE_EXCEL:
		resp, isOk, msg, errMsg = GetBalanceChartInfoDetailFromUniqueCode(chartInfo, key, this.Lang)
		if !isOk {
			br.Msg = msg
			br.ErrMsg = errMsg
			return
		}
	case utils.CHART_SOURCE_RANGE_ANALYSIS:
		resp, isOk, msg, errMsg = GetRangeAnalysisChartInfoDetailFromUniqueCode(chartInfo, key, this.Lang)
		if !isOk {
			br.Msg = msg
			br.ErrMsg = errMsg
			return
		}
	default:
		br.Msg = "错误的图表"
		br.ErrMsg = "错误的图表"
		return
	}
	if !isOk {
		br.Msg = msg
		br.ErrMsg = errMsg
		return
	}

	if isCollect {
		resp.IsCollect = isCollect
	}

	if conf[models.BusinessConfWatermarkChart] == "true" && conf[models.BusinessConfCompanyWatermark] != "" {
		resp.WaterMark = conf[models.BusinessConfCompanyWatermark]
	}
	resp.IsAuth = true

	br.Ret = 200
	br.Success = true
	br.Msg = "获取成功"
	br.Data = resp
}

// GetFutureGoodChartInfoDetailFromUniqueCode 根据编码获取图表详情
func GetFutureGoodChartInfoDetailFromUniqueCode(chartInfo *models.ChartInfo, key string) (resp *models.ChartInfoDetailResp, isOk bool, msg, errMsg string) {
	resp = new(models.ChartInfoDetailResp)

	// 获取主题样式
	chartTheme, err := data.GetChartThemeConfig(chartInfo.ChartThemeId, utils.CHART_SOURCE_DEFAULT, 1)
	if err != nil {
		msg = "获取失败"
		errMsg = "获取主题信息失败，Err:" + err.Error()
		return
	}
	chartInfo.ChartThemeStyle = chartTheme.Config
	chartInfo.ChartThemeId = chartTheme.ChartThemeId

	chartInfoId := chartInfo.ChartInfoId

	startDate := chartInfo.StartDate
	endDate := chartInfo.EndDate

	// 兼容日期错误
	{
		if strings.Count(startDate, "-") == 1 {
			startDate = startDate + "-01"
		}
		if strings.Count(endDate, "-") == 1 {
			endDate = endDate + "-01"
		}
	}

	edbInfoMappingList, err := models.GetEtaEdbChartEdbMappingList(chartInfoId)
	if err != nil {
		msg = "获取失败"
		errMsg = "获取图表，现货指标信息失败，Err:" + err.Error()
		return
	}
	futureGoodEdbInfoMapping, err := models.GetFutureGoodEdbChartEdbMapping(chartInfoId)
	if err != nil {
		msg = "获取失败"
		errMsg = "获取图表的期货商品指标信息失败，Err:" + err.Error()
		return
	}

	// 商品价格曲线图的一些配置
	var barConfig data_manage.FutureGoodBarChartInfoReq
	//barChartInfoSort := data_manage.BarChartInfoSortReq{}

	if chartInfo.BarConfig == `` {
		msg = "商品价格曲线图未配置"
		errMsg = "商品价格曲线图未配置"
		return
	}
	err = json.Unmarshal([]byte(chartInfo.BarConfig), &barConfig)
	if err != nil {
		msg = "商品价格曲线图配置异常"
		errMsg = "商品价格曲线图配置异常"
		return
	}

	baseEdbInfoId := barConfig.BaseEdbInfoId
	var baseEdbInfoMapping *models.ChartEdbInfoMapping
	// todo 兼容历史数据，
	if baseEdbInfoId == 0 {
		// 默认取第一个现货指标
		baseEdbInfoId = edbInfoMappingList[0].EdbInfoId
		baseEdbInfoMapping = edbInfoMappingList[0]
		barConfig.BaseEdbInfoId = baseEdbInfoId
	} else {
		baseEdbInfoMapping, err = models.GetChartEdbMappingByEdbInfoId(baseEdbInfoId)
		if err != nil {
			msg = "获取失败"
			errMsg = "获取图表，指标信息失败，Err:" + err.Error()
			return
		}
	}

	// 获取图表中的指标数据
	barConfigEdbInfoIdList, edbList, xEdbIdValue, xDataList, yDataList, err := future_goodServ.GetChartEdbData(chartInfoId, startDate, endDate, baseEdbInfoMapping, edbInfoMappingList, futureGoodEdbInfoMapping, barConfig, true)
	if err != nil {
		msg = "获取失败"
		errMsg = "获取图表，指标信息失败，Err:" + err.Error()
		return
	}
	warnEdbList := make([]string, 0)
	if len(edbList) <= 0 {
		msg = "商品价格曲线图表指标异常"
		errMsg = "商品价格曲线图表异常"
		return
	}
	baseEdbInfo := edbList[0] //现货指标

	for _, v := range edbList {
		if v.IsNullData {
			warnEdbList = append(warnEdbList, v.EdbName+"("+v.EdbCode+")")
		}
		// 指标别名
		if barConfigEdbInfoIdList != nil && len(barConfigEdbInfoIdList) > 0 {
			for _, reqEdb := range barConfigEdbInfoIdList {
				if v.EdbInfoId == reqEdb.EdbInfoId {
					v.EdbAliasName = reqEdb.Name
					v.EdbAliasNameEn = reqEdb.NameEn
				}
			}
		}
		if v.Source == 0 {
			name := strings.Split(v.EdbName, "(")
			if barConfig.FutureGoodEdbName != "" {
				name[0] = barConfig.FutureGoodEdbName
			}
			v.EdbName = name[0]
			if len(name) > 1 {
				v.EdbName = v.EdbName + "(" + name[1]
			}
			//英文
			// 编译正则表达式，匹配一个或多个数字

			if v.EdbNameEn != "" {
				name = strings.Split(v.EdbNameEn, "(")
				if barConfig.FutureGoodEdbNameEn != "" {
					name[0] = barConfig.FutureGoodEdbNameEn
				}
				v.EdbNameEn = name[0]
				if len(name) > 1 {
					v.EdbNameEn = v.EdbNameEn + "(" + name[1]
				}
			}
		}
	}
	chartInfo.UnitEn = baseEdbInfo.UnitEn

	// 图表的指标来源
	sourceNameList, sourceNameEnList := data.GetEdbSourceByEdbInfoIdList(edbList)
	chartInfo.ChartSource = strings.Join(sourceNameList, ",")
	chartInfo.ChartSourceEn = strings.Join(sourceNameEnList, ",")

	xDataListFinal := make([]models.XData, 0)
	for _, v := range xDataList {
		tmp := models.XData{
			Name:   v.Name,
			NameEn: v.NameEn,
			IsHide: v.IsHide,
		}
		xDataListFinal = append(xDataListFinal, tmp)
	}
	resp.ChartInfo = chartInfo
	resp.EdbInfoList = edbList
	resp.XEdbIdValue = xEdbIdValue
	resp.YDataList = yDataList
	resp.XDataList = xDataListFinal
	//resp.BarChartInfo = barConfig
	//resp.Status = true

	// 将数据加入缓存
	if utils.Re == nil {
		data, _ := json.Marshal(resp)
		utils.Rc.Put(key, data, 2*time.Hour)
	}
	isOk = true

	return
}

// GetFutureGoodProfitChartInfoDetailFromUniqueCode 根据编码获取商品利润图表详情
func GetFutureGoodProfitChartInfoDetailFromUniqueCode(chartInfo *models.ChartInfo, key string) (resp *models.ChartInfoDetailResp, isOk bool, msg, errMsg string) {
	resp = new(models.ChartInfoDetailResp)

	chartInfoId := chartInfo.ChartInfoId

	// 获取主题样式
	chartTheme, err := data.GetChartThemeConfig(chartInfo.ChartThemeId, utils.CHART_SOURCE_DEFAULT, 1)
	if err != nil {
		msg = "获取失败"
		errMsg = "获取主题信息失败，Err:" + err.Error()
		return
	}
	chartInfo.ChartThemeStyle = chartTheme.Config
	chartInfo.ChartThemeId = chartTheme.ChartThemeId

	// 商品利润曲线图的一些配置
	var extraConf request.ChartInfoReq
	err = json.Unmarshal([]byte(chartInfo.ExtraConfig), &extraConf)
	if err != nil {
		msg = "商品利润曲线图配置异常"
		errMsg = "商品利润曲线图配置异常，Err:" + err.Error()
		return
	}

	if len(extraConf.EdbInfoIdList) == 0 {
		extraConf.EdbInfoIdList = append(extraConf.EdbInfoIdList, extraConf.BaseEdbInfoId)
	}

	edbList := make([]*models.ChartEdbInfoMapping, 0)
	edbInfoMappingList, err := models.GetEtaEdbChartEdbMappingList(chartInfoId)
	if err != nil {
		msg = "获取失败"
		errMsg = "获取商品利润图表，基础指标信息失败，Err:" + err.Error()
		return
	}
	baseEdbInfo := new(models.ChartEdbInfoMapping)
	for _, v := range edbInfoMappingList {
		if v.EdbInfoId == extraConf.BaseEdbInfoId {
			baseEdbInfo = v
		}
	}
	edbList = edbInfoMappingList
	futureGoodEdbInfoMappingList, err := models.GetFutureGoodEdbChartEdbMappingList(chartInfoId)
	if err != nil {
		msg = "获取失败"
		errMsg = "获取商品利润图表，商品指标信息失败，Err:" + err.Error()
		return
	}
	edbList = append(edbList, futureGoodEdbInfoMappingList...)
	if len(edbList) <= 0 {
		msg = "商品利润曲线图表指标异常"
		errMsg = "商品利润曲线图表指标异常"
		return
	}

	xDataList := make([]models.XData, 0)
	yDataList := make([]models.YData, 0)

	// 查找商品利润图表的扩展信息
	chartInfoFutureGoodProfit := new(future_good.ChartInfoFutureGoodProfit)
	if err = chartInfoFutureGoodProfit.GetItemById(chartInfo.ChartInfoId); err != nil {
		msg = "获取失败"
		errMsg = "获取基础相关性图表信息失败, Err: " + err.Error()
		return
	}

	err = json.Unmarshal([]byte(chartInfoFutureGoodProfit.XValue), &xDataList)
	if err != nil {
		msg = "获取失败"
		errMsg = "转换X轴数据失败, Err: " + err.Error()
		return
	}

	err = json.Unmarshal([]byte(chartInfoFutureGoodProfit.YValue), &yDataList)
	if err != nil {
		msg = "获取失败"
		errMsg = "转换Y轴数据失败, Err: " + err.Error()
		return
	}

	warnEdbList := make([]string, 0)
	for _, v := range edbList {
		if v.IsNullData {
			warnEdbList = append(warnEdbList, v.EdbName+"("+v.EdbCode+")")
		}
	}

	chartInfo.UnitEn = baseEdbInfo.UnitEn

	resp.ChartInfo = chartInfo
	resp.EdbInfoList = edbList
	resp.DataResp = response.ProfitFutureGoodChartResp{
		YDataList:    yDataList,
		XDataList:    xDataList,
		ProfitName:   chartInfoFutureGoodProfit.ProfitName,
		ProfitNameEn: chartInfoFutureGoodProfit.ProfitNameEn,
		Extra:        extraConf,
	}

	// 将数据加入缓存
	if utils.Re == nil {
		data, _ := json.Marshal(resp)
		utils.Rc.Put(key, data, 2*time.Hour)
	}
	isOk = true

	return
}

// GetLineEquationChartInfoDetailFromUniqueCode 根据编码获取拟合方程图表详情
func GetLineEquationChartInfoDetailFromUniqueCode(chartInfo *models.ChartInfo, key string) (resp *models.ChartInfoDetailResp, isOk bool, msg, errMsg string) {
	resp = new(models.ChartInfoDetailResp)
	// 获取主题样式
	chartTheme, err := data.GetChartThemeConfig(chartInfo.ChartThemeId, utils.CHART_SOURCE_DEFAULT, 1)
	if err != nil {
		msg = "获取失败"
		errMsg = "获取主题信息失败，Err:" + err.Error()
		return
	}
	chartInfo.ChartThemeStyle = chartTheme.Config
	chartInfo.ChartThemeId = chartTheme.ChartThemeId

	//chartInfoId := chartInfo.ChartInfoId
	if chartInfo.ExtraConfig == `` {
		msg = "获取失败"
		errMsg = "获取配置信息失败"
		return
	}

	var lineChartInfoConfig line_equationReq.LineChartInfoReq
	err = json.Unmarshal([]byte(chartInfo.ExtraConfig), &lineChartInfoConfig)
	if err != nil {
		msg = "获取失败"
		errMsg = "获取图表配置信息失败, Err:" + err.Error()
		return
	}

	var getAData, getBData, getR2Data bool
	switch lineChartInfoConfig.Source {
	case utils.CHART_MULTIPLE_GRAPH_LINE_EQUATION_ONE:
		getAData = true
	case utils.CHART_MULTIPLE_GRAPH_LINE_EQUATION_TWO:
		getBData = true
	case utils.CHART_MULTIPLE_GRAPH_LINE_EQUATION_THREE:
		getR2Data = true
	}

	edbList, dataResp, err, errMsg := line_equation.GetChartEdbData(chartInfo.ChartInfoId, lineChartInfoConfig, getAData, getBData, getR2Data)
	if err != nil {
		if errMsg == `` {
			errMsg = "获取失败"
		}
		return
	}

	var resultResp interface{}
	switch lineChartInfoConfig.Source {
	case utils.CHART_MULTIPLE_GRAPH_LINE_EQUATION_ONE:
		resultResp = dataResp.AData
	case utils.CHART_MULTIPLE_GRAPH_LINE_EQUATION_TWO:
		resultResp = dataResp.BData
	case utils.CHART_MULTIPLE_GRAPH_LINE_EQUATION_THREE:
		resultResp = dataResp.R2Data
	}

	//chartInfo.UnitEn = baseEdbInfo.UnitEn
	// 图表的指标来源
	sourceNameList, sourceNameEnList := data.GetEdbSourceByEdbInfoIdList(edbList)
	chartInfo.ChartSource = strings.Join(sourceNameList, ",")
	chartInfo.ChartSourceEn = strings.Join(sourceNameEnList, ",")

	resp.ChartInfo = chartInfo
	resp.DataResp = resultResp
	resp.EdbInfoList = edbList

	// 将数据加入缓存
	if utils.Re == nil {
		data, _ := json.Marshal(resp)
		utils.Rc.Put(key, data, 2*time.Hour)
	}
	isOk = true

	return
}

// GetLineFeatureChartInfoDetailFromUniqueCode 根据编码获取统计特征图表详情
func GetLineFeatureChartInfoDetailFromUniqueCode(chartInfo *models.ChartInfo, key string) (resp *models.ChartInfoDetailResp, isOk bool, msg, errMsg string) {
	resp = new(models.ChartInfoDetailResp)
	// 获取主题样式
	chartTheme, err := data.GetChartThemeConfig(chartInfo.ChartThemeId, utils.CHART_SOURCE_DEFAULT, 1)
	if err != nil {
		msg = "获取失败"
		errMsg = "获取主题信息失败，Err:" + err.Error()
		return
	}
	chartInfo.ChartThemeStyle = chartTheme.Config
	chartInfo.ChartThemeId = chartTheme.ChartThemeId

	// 获取图表关联指标
	edbMappingList, err := models.GetChartEdbMappingList(chartInfo.ChartInfoId)
	if err != nil {
		msg = "获取失败"
		errMsg = "获取图表关联指标信息失败，Err:" + err.Error()
		return
	}
	if len(edbMappingList) != 1 {
		msg = "获取失败"
		errMsg = fmt.Sprint("获取图表关联指标信息异常，数量:", len(edbMappingList))
		return
	}
	edbMapping := edbMappingList[0]

	var edbList []*models.ChartEdbInfoMapping
	var resultResp interface{}

	switch chartInfo.Source {
	case utils.CHART_SOURCE_LINE_FEATURE_STANDARD_DEVIATION:
		calculateValue, tmpErr := strconv.Atoi(chartInfo.ExtraConfig)
		if tmpErr != nil {
			msg = "获取失败"
			errMsg = "格式化配置项失败，Err:" + tmpErr.Error()
			return
		}
		startDate, endDate := utils.GetDateByDateType(chartInfo.DateType, chartInfo.StartDate, chartInfo.EndDate)
		edbList, resultResp, err, msg = lineFeatureServ.GetStandardDeviationData(chartInfo.ChartInfoId, startDate, endDate, edbMapping, calculateValue)
	case utils.CHART_SOURCE_LINE_FEATURE_PERCENTILE:
		var percentileConfig line_featureReq.Percentile
		err = json.Unmarshal([]byte(chartInfo.ExtraConfig), &percentileConfig)
		if err != nil {
			msg = "获取失败"
			errMsg = "格式化配置项失败，Err:" + err.Error()
			return
		}
		startDate, endDate := utils.GetDateByDateType(chartInfo.DateType, chartInfo.StartDate, chartInfo.EndDate)
		edbList, resultResp, err, msg = lineFeatureServ.GetPercentileData(chartInfo.ChartInfoId, startDate, endDate, edbMapping, percentileConfig.CalculateValue, percentileConfig.CalculateUnit, percentileConfig.PercentType)
	case utils.CHART_SOURCE_LINE_FEATURE_FREQUENCY:
		var frequencyDistributionConfig line_featureReq.FrequencyDistribution
		err = json.Unmarshal([]byte(chartInfo.ExtraConfig), &frequencyDistributionConfig)
		if err != nil {
			msg = "获取失败"
			errMsg = "格式化配置项失败，Err:" + err.Error()
			return
		}
		// 获取图表中的指标数据
		edbList, resultResp, err, errMsg = lineFeatureServ.GetFrequencyDistributionData(0, edbMapping, frequencyDistributionConfig.DateType, frequencyDistributionConfig.FrequencyValue, frequencyDistributionConfig.StartDate, frequencyDistributionConfig.EndDate)
	default:
		msg = `错误的图表`
		errMsg = fmt.Sprint("错误的图表来源，source", chartInfo.Source)
		return
	}
	if err != nil {
		if msg == `` {
			msg = "获取失败"
		}
		errMsg = "获取图表，指标信息失败，Err:" + err.Error()
		return
	}

	//chartInfo.UnitEn = baseEdbInfo.UnitEn
	// 图表的指标来源
	sourceNameList, sourceNameEnList := data.GetEdbSourceByEdbInfoIdList(edbList)
	chartInfo.ChartSource = strings.Join(sourceNameList, ",")
	chartInfo.ChartSourceEn = strings.Join(sourceNameEnList, ",")

	resp.ChartInfo = chartInfo
	resp.DataResp = resultResp
	resp.EdbInfoList = edbList

	// 将数据加入缓存
	if utils.Re == nil {
		data, _ := json.Marshal(resp)
		utils.Rc.Put(key, data, 2*time.Hour)
	}
	isOk = true

	return
}

// GetCrossVarietyChartInfoDetailFromUniqueCode 根据编码获取图表详情
func GetCrossVarietyChartInfoDetailFromUniqueCode(chartInfo *models.ChartInfo, key string) (resp *models.ChartInfoDetailResp, isOk bool, msg, errMsg string) {
	resp = new(models.ChartInfoDetailResp)
	// 获取主题样式
	chartTheme, err := data.GetChartThemeConfig(chartInfo.ChartThemeId, utils.CHART_SOURCE_DEFAULT, 5)
	if err != nil {
		msg = "获取失败"
		errMsg = "获取主题信息失败，Err:" + err.Error()
		return
	}
	chartInfo.ChartThemeStyle = chartTheme.Config
	chartInfo.ChartThemeId = chartTheme.ChartThemeId

	if chartInfo.ExtraConfig == `` {
		msg = "图表配置信息异常"
		errMsg = "图表配置信息异常"
		return
	}
	var config cross_varietyReq.ChartConfigReq
	err = json.Unmarshal([]byte(chartInfo.ExtraConfig), &config)
	if err != nil {
		msg = "解析跨品种分析配置失败"
		errMsg = "解析跨品种分析配置失败，Err:" + err.Error()
		return
	}
	// 获取图表x轴y轴
	edbList, dataResp, err, msg, _ := cross_variety.GetChartData(0, config)
	if err != nil {
		errMsg = "获取图表，指标信息失败，Err:" + err.Error()
		return
	}
	//判断是否需要展示英文标识
	//chartInfo.IsEnChart = data.CheckIsEnChart(chartInfo.ChartNameEn, edbList[0:1], chartInfo.Source, chartInfo.ChartType)
	//chartInfo.UnitEn = edbInfoMappingA.UnitEn

	// 另存为
	resp.ChartInfo = chartInfo
	resp.DataResp = dataResp
	resp.EdbInfoList = edbList

	// 图表的指标来源
	sourceNameList, sourceNameEnList := data.GetEdbSourceByEdbInfoIdList(edbList)
	chartInfo.ChartSource = strings.Join(sourceNameList, ",")
	chartInfo.ChartSourceEn = strings.Join(sourceNameEnList, ",")

	// 将数据加入缓存
	if utils.Re == nil {
		d, _ := json.Marshal(resp)
		_ = utils.Rc.Put(key, d, 2*time.Hour)
	}
	isOk = true

	return
}

func GetBalanceChartInfoDetailFromUniqueCode(chartInfo *models.ChartInfo, key, lang string) (resp *models.ChartInfoDetailResp, isOk bool, msg, errMsg string) {
	resp = new(models.ChartInfoDetailResp)
	msg = `获取失败`
	var err error
	defer func() {
		if err != nil {
			if errMsg != "" {
				msg = errMsg
			}
			errMsg = err.Error()
		}
	}()
	// 相关联指标
	mappingListTmp, dataListMap, err, errMsg := excel.GetBalanceExcelChartSingle(chartInfo.ChartInfoId, 0, lang)
	if err != nil {
		errMsg = "获取失败"
		err = fmt.Errorf(" 获取图表，指标信息失败 Err:%s", err.Error())
		return
	}
	var chartInfoResp *models.ChartInfoDetailResp
	chartInfoResp, err, errMsg = data.GetBalanceExcelChartDetail(chartInfo, mappingListTmp, dataListMap)
	if err != nil {
		msg = "查询图表详情失败"
		errMsg = "查询图表详情失败，Err:" + err.Error()
		return
	}
	resp = &models.ChartInfoDetailResp{
		ChartInfo:            chartInfoResp.ChartInfo,
		EdbInfoList:          chartInfoResp.EdbInfoList,
		XEdbIdValue:          chartInfoResp.XEdbIdValue,
		YDataList:            chartInfoResp.YDataList,
		XDataList:            chartInfoResp.XDataList,
		CorrelationChartInfo: chartInfoResp.CorrelationChartInfo,
		DataResp:             chartInfoResp.DataResp,
	}

	if utils.Re == nil {
		jsonData, _ := json.Marshal(resp)
		utils.Rc.Put(key, jsonData, 10*time.Minute)
	}

	isOk = true

	return
}

// FutureGoodChartInfoRefresh
// @Title 商品价格图表刷新接口
// @Description 商品价格图表刷新接口
// @Param   UniqueCode   query   string  true       "图表唯一编码,如果是管理后台访问，传固定字符串:7c69b590249049942070ae9dcd5bf6dc"
// @Success Ret=200 刷新成功
// @router /future_good/refresh [get]
func (this *ChartController) FutureGoodChartInfoRefresh() {
	br := new(models.BaseResponse).Init()
	chartId := 0
	defer func() {
		// 添加日志
		if chartId > 0 {
			shareChartRefreshLogInfo := &models.ShareChartRefreshLog{
				Ip:         this.Ctx.Input.IP(),
				ChartId:    chartId,
				CreateTime: time.Now(),
			}
			models.AddShareChartRefreshLog(shareChartRefreshLogInfo)
		}
		this.Data["json"] = br
		this.ServeJSON()
	}()

	uniqueCode := this.GetString("UniqueCode")
	if uniqueCode == "" {
		br.Msg = "参数错误"
		br.ErrMsg = "参数错误,uniqueCode is empty"
		return
	}
	chartInfo, err := models.GetChartInfoByUniqueCode(uniqueCode)
	if err != nil {
		if utils.IsErrNoRow(err) {
			br.Msg = "该图已被删除，请刷新页面"
			br.ErrMsg = "该图已被删除，请刷新页面，Err:" + err.Error()
			return
		}
		br.Msg = "获取失败"
		br.ErrMsg = "获取图表信息失败，Err:" + err.Error()
		return
	}
	chartId = chartInfo.ChartInfoId

	err = future_goodServ.FutureGoodChartInfoRefresh(chartInfo.ChartInfoId)
	if err != nil {
		br.Msg = "刷新失败"
		br.ErrMsg = "刷新图表关联指标信息失败，Err:" + err.Error()
		return
	}
	//err = data.ChartInfoRefresh(chartInfo.ChartInfoId)
	//if err != nil {
	//	br.Msg = "刷新失败"
	//	br.ErrMsg = "刷新图表关联指标信息失败，Err:" + err.Error()
	//	return
	//}

	//err = data.ChartInfoRefreshV2(chartInfo.ChartInfoId)
	//if err != nil {
	//	br.Msg = "刷新失败"
	//	br.ErrMsg = "刷新图表关联指标信息失败，Err:" + err.Error()
	//	return
	//}

	//清除数据缓存
	key := utils.HZ_CHART_LIB_DETAIL + uniqueCode
	if utils.Re == nil {
		utils.Rc.Delete(key)
	}
	br.Ret = 200
	br.Success = true
	br.Msg = "刷新成功"
}

// GetCorrelationChartInfoDetailFromUniqueCode 根据编码获取相关性图表详情
func GetCorrelationChartInfoDetailFromUniqueCode(chartInfo *models.ChartInfo, key string) (resp *models.ChartInfoDetailResp, isOk bool, msg, errMsg string) {
	resp = new(models.ChartInfoDetailResp)
	// 获取主题样式
	chartTheme, err := data.GetChartThemeConfig(chartInfo.ChartThemeId, utils.CHART_SOURCE_DEFAULT, 1)
	if err != nil {
		msg = "获取失败"
		errMsg = "获取主题信息失败，Err:" + err.Error()
		return
	}
	chartInfo.ChartThemeStyle = chartTheme.Config
	chartInfo.ChartThemeId = chartTheme.ChartThemeId

	chartInfoId := chartInfo.ChartInfoId

	startDate := chartInfo.StartDate
	endDate := chartInfo.EndDate

	// 兼容日期错误
	{
		if strings.Count(startDate, "-") == 1 {
			startDate = startDate + "-01"
		}
		if strings.Count(endDate, "-") == 1 {
			endDate = endDate + "-01"
		}
	}

	// 相关性图表信息
	correlationChart := new(data_manage.ChartInfoCorrelation)
	if e := correlationChart.GetItemById(chartInfoId); e != nil {
		msg = "获取失败"
		errMsg = "获取图表相关性信息失败, Err:" + e.Error()
		return
	}

	// 获取指标信息
	edbInfoMappingA, e := models.GetChartEdbMappingByEdbInfoId(correlationChart.EdbInfoIdFirst)
	if e != nil {
		msg = "获取失败"
		errMsg = "获取相关性图表, A指标mapping信息失败, Err:" + e.Error()
		return
	}
	edbInfoMappingB := new(models.ChartEdbInfoMapping)
	if correlationChart.AnalysisMode != 1 {
		edbInfoMappingB, e = models.GetChartEdbMappingByEdbInfoId(correlationChart.EdbInfoIdSecond)
		if e != nil {
			msg = "获取失败"
			errMsg = "获取相关性图表, B指标mapping信息失败, Err:" + e.Error()
			return
		}
	}

	var dataResp interface{} // 绘图数据返回（目前是滚动相关性的图）
	var xEdbIdValue []int
	var yDataList []models.YData
	if correlationChart.AnalysisMode != 1 {
		switch chartInfo.Source {
		case utils.CHART_SOURCE_CORRELATION: // 相关性图
			moveUnitDays, ok := utils.FrequencyDaysMap[correlationChart.CalculateUnit]
			if !ok {
				msg = "错误的分析周期"
				errMsg = "相关性图表数据有误"
				return
			}
			st := time.Now().AddDate(0, 0, -correlationChart.CalculateValue*moveUnitDays).Format(utils.FormatDate)
			ed := time.Now().Format(utils.FormatDate)

			xEdbIdValue, yDataList, e = correlationServ.GetChartDataByEdbInfo(edbInfoMappingA, edbInfoMappingB, correlationChart.LeadValue, correlationChart.LeadUnit, st, ed, chartInfo.ExtraConfig)
			if e != nil {
				msg = "获取失败"
				errMsg = "获取相关性图表, 图表计算值失败, Err:" + e.Error()
				return
			}
		case utils.CHART_SOURCE_ROLLING_CORRELATION: // 滚动相关性图
			st, ed := utils.GetDateByDateType(correlationChart.DateType, correlationChart.StartDate.Format(utils.FormatDate), correlationChart.EndDate.Format(utils.FormatDate))
			dataResp, e = correlationServ.GetRollingCorrelationChartDataByEdbInfo(edbInfoMappingA, edbInfoMappingB, correlationChart.LeadValue, correlationChart.LeadUnit, correlationChart.CalculateValue, correlationChart.CalculateUnit, st, ed, chartInfo.ChartName, chartInfo.ChartNameEn)
		}
	} else {
		xEdbIdValue, yDataList, e = correlationServ.GetFactorChartDataByChartId(chartInfoId, chartInfo.ExtraConfig)
		if e != nil {
			msg = "获取失败"
			errMsg = "获取相关性图表, 图表计算值失败, Err:" + e.Error()
			return
		}
	}

	// 完善指标信息
	edbList, e := correlationServ.GetChartEdbInfoFormat(chartInfo.ChartInfoId, edbInfoMappingA, edbInfoMappingB)
	if e != nil {
		msg = "获取失败"
		errMsg = "获取相关性图表, 完善指标信息失败, Err:" + e.Error()
		return
	}

	// 图表的指标来源
	sourceNameList, sourceNameEnList := data.GetEdbSourceByEdbInfoIdList(edbList)
	chartInfo.ChartSource = strings.Join(sourceNameList, ",")
	chartInfo.ChartSourceEn = strings.Join(sourceNameEnList, ",")

	correlationInfo := new(models.CorrelationInfo)
	correlationInfo.LeadValue = correlationChart.LeadValue
	correlationInfo.LeadUnit = correlationChart.LeadUnit
	correlationInfo.StartDate = correlationChart.StartDate.Format(utils.FormatDate)
	correlationInfo.EndDate = correlationChart.EndDate.Format(utils.FormatDate)
	correlationInfo.LeadValue = correlationChart.LeadValue
	correlationInfo.EdbInfoIdFirst = correlationChart.EdbInfoIdFirst
	correlationInfo.EdbInfoIdSecond = correlationChart.EdbInfoIdSecond
	correlationInfo.AnalysisMode = correlationChart.AnalysisMode

	resp.ChartInfo = chartInfo
	resp.EdbInfoList = edbList
	resp.XEdbIdValue = xEdbIdValue
	resp.YDataList = yDataList
	resp.CorrelationChartInfo = correlationInfo
	resp.DataResp = dataResp

	// 将数据加入缓存
	if utils.Re == nil {
		d, _ := json.Marshal(resp)
		_ = utils.Rc.Put(key, d, 2*time.Hour)
	}
	isOk = true
	return
}

// CorrelationChartInfoRefresh
// @Title 商品价格图表刷新接口
// @Description 商品价格图表刷新接口
// @Param   UniqueCode   query   string  true       "图表唯一编码,如果是管理后台访问，传固定字符串:7c69b590249049942070ae9dcd5bf6dc"
// @Success Ret=200 刷新成功
// @router /correlation/refresh [get]
func (this *ChartController) CorrelationChartInfoRefresh() {
	br := new(models.BaseResponse).Init()
	chartId := 0
	defer func() {
		// 添加日志
		if chartId > 0 {
			shareChartRefreshLogInfo := &models.ShareChartRefreshLog{
				Ip:         this.Ctx.Input.IP(),
				ChartId:    chartId,
				CreateTime: time.Now(),
			}
			models.AddShareChartRefreshLog(shareChartRefreshLogInfo)
		}
		this.Data["json"] = br
		this.ServeJSON()
	}()

	uniqueCode := this.GetString("UniqueCode")
	if uniqueCode == "" {
		br.Msg = "参数错误"
		br.ErrMsg = "参数错误,uniqueCode is empty"
		return
	}
	chartInfo, err := models.GetChartInfoByUniqueCode(uniqueCode)
	if err != nil {
		if utils.IsErrNoRow(err) {
			br.Msg = "该图已被删除，请刷新页面"
			br.ErrMsg = "该图已被删除，请刷新页面，Err:" + err.Error()
			return
		}
		br.Msg = "获取失败"
		br.ErrMsg = "获取图表信息失败，Err:" + err.Error()
		return
	}
	chartId = chartInfo.ChartInfoId

	err = data.ChartInfoRefreshV2(chartInfo.ChartInfoId)
	if err != nil {
		br.Msg = "刷新失败"
		br.ErrMsg = "刷新图表关联指标信息失败，Err:" + err.Error()
		return
	}

	//// 刷新相关性图表
	//if e := correlationServ.ChartInfoRefresh(chartInfo.ChartInfoId); e != nil {
	//	br.Msg = "刷新失败"
	//	br.ErrMsg = "刷新相关性图表失败, Err:" + e.Error()
	//	return
	//}

	//清除数据缓存
	key := utils.HZ_CHART_LIB_DETAIL + uniqueCode
	if utils.Re == nil {
		_ = utils.Rc.Delete(key)
	}
	br.Ret = 200
	br.Success = true
	br.Msg = "刷新成功"
}

// GetRangeAnalysisChartInfoDetailFromUniqueCode 根据编码获取区间计算图表详情
func GetRangeAnalysisChartInfoDetailFromUniqueCode(chartInfo *models.ChartInfo, key, lang string) (resp *models.ChartInfoDetailResp, isOk bool, msg, errMsg string) {
	resp = new(models.ChartInfoDetailResp)
	// 获取主题样式
	chartTheme, err := data.GetChartThemeConfig(chartInfo.ChartThemeId, utils.CHART_SOURCE_DEFAULT, 1)
	if err != nil {
		msg = "获取失败"
		errMsg = "获取主题信息失败，Err:" + err.Error()
		return
	}
	chartInfo.ChartThemeStyle = chartTheme.Config
	chartInfo.ChartThemeId = chartTheme.ChartThemeId

	chartInfoId := chartInfo.ChartInfoId

	// 获取指标信息
	//chartInfo.CorrelationLeadUnit = req.LeadUnit
	edbInfoMappingList, err := models.GetChartEdbMappingList(chartInfoId)
	if err != nil {
		msg = "获取失败"
		errMsg = "获取图表，指标信息失败，Err:" + err.Error()
		return
	}
	dateType := chartInfo.DateType
	// 开始/结束日期
	startYear := chartInfo.StartYear
	startDate := chartInfo.StartDate
	endDate := chartInfo.EndDate

	// 区间计算图表配置校验
	var extraConfig models.ChartRangeAnalysisExtraConf
	if chartInfo.ExtraConfig == `` {
		msg = "配置信息错误"
		return
	}
	err = json.Unmarshal([]byte(chartInfo.ExtraConfig), &extraConfig)
	if err != nil {
		msg = "配置信息错误"
		errMsg = "图表配置信息错误，Err:" + err.Error()
		return
	}

	// 获取图表数据
	if len(edbInfoMappingList) == 0 {
		msg = "获取失败"
		errMsg = "图表没有指标，无法计算"
		return
	}

	// 获取图表x轴y轴
	edbList, xEdbIdValue, dataResp, e := range_analysis.GetChartDataByEdbInfoList(chartInfoId, dateType, startYear, startDate, endDate, edbInfoMappingList, &extraConfig)
	if e != nil {
		msg = "获取失败"
		errMsg = "获取区间计算图表, 图表计算值失败, Err:" + e.Error()
		return
	}

	// 图表的指标来源
	sourceNameList, sourceNameEnList := data.GetEdbSourceByEdbInfoIdList(edbList)
	chartInfo.ChartSource = strings.Join(sourceNameList, ",")
	chartInfo.ChartSourceEn = strings.Join(sourceNameEnList, ",")

	resp.ChartInfo = chartInfo
	resp.EdbInfoList = edbList
	resp.XEdbIdValue = xEdbIdValue
	resp.DataResp = dataResp

	if utils.Re == nil {
		jsonData, _ := json.Marshal(resp)
		utils.Rc.Put(key, jsonData, 10*time.Minute)
	}

	isOk = true
	return
}

// GetAiPredictChartInfoDetailFromUniqueCode 根据编码获取AI预测模型图表详情
func GetAiPredictChartInfoDetailFromUniqueCode(chartInfo *models.ChartInfo, key string) (resp *models.ChartInfoDetailResp, isOk bool, msg, errMsg string) {
	var err error
	msg = "获取成功"
	defer func() {
		if err != nil {
			tips := fmt.Sprintf("UniqueCode获取图表详情失败, %v", err)
			msg = "获取失败"
			errMsg = fmt.Sprintf(tips)
			utils.FileLog.Info(tips)
		}
	}()
	if chartInfo == nil {
		err = fmt.Errorf("图表信息不存在")
		return
	}
	if chartInfo.Source != utils.CHART_SOURCE_AI_PREDICT_MODEL_DAILY && chartInfo.Source != utils.CHART_SOURCE_AI_PREDICT_MODEL_MONTHLY {
		err = fmt.Errorf("图表来源有误, Source: %d", chartInfo.Source)
		return
	}
	resp = new(models.ChartInfoDetailResp)

	// 获取图表标的
	edbMappings, e := models.GetChartEdbMappingsByChartInfoId(chartInfo.ChartInfoId)
	if e != nil {
		err = fmt.Errorf("获取图表指标关联失败, %v", e)
		return
	}
	if len(edbMappings) == 0 {
		err = fmt.Errorf("图表指标关联不存在, %v", e)
		return
	}
	indexId := edbMappings[0].EdbInfoId
	if indexId <= 0 {
		err = fmt.Errorf("图表标的有误")
		return
	}
	indexOb := new(aiPredictModel.AiPredictModelIndex)
	indexItem, e := indexOb.GetItemById(indexId)
	if e != nil {
		err = fmt.Errorf("获取图表标的失败, %v", e)
		return
	}
	if indexItem != nil && indexItem.AiPredictModelIndexId <= 0 {
		err = fmt.Errorf("图表标的不存在, IndexId: %d", indexId)
		return
	}

	// 获取标的数据
	indexData := make([]*aiPredictModel.AiPredictModelData, 0)
	dataSource := aiPredictModel.ModelDataSourceDaily
	if chartInfo.Source == utils.CHART_SOURCE_AI_PREDICT_MODEL_MONTHLY {
		dataSource = aiPredictModel.ModelDataSourceMonthly
	}
	dataOb := new(aiPredictModel.AiPredictModelData)
	dataCond := fmt.Sprintf(` AND %s = ?`, dataOb.Cols().IndexCode)
	dataPars := make([]interface{}, 0)
	dataPars = append(dataPars, indexItem.IndexCode)
	list, e := dataOb.GetItemsByCondition(dataCond, dataPars, []string{}, fmt.Sprintf("%s DESC", dataOb.Cols().DataTime))
	if e != nil {
		err = fmt.Errorf("获取标的数据失败, %v", e)
		return
	}
	for _, v := range list {
		if v.Source == dataSource {
			indexData = append(indexData, v)
			continue
		}
	}

	// 图表详情
	resp, e = GetAiPredictChartDetailByData(indexItem, indexData, dataSource)
	if e != nil {
		err = fmt.Errorf("获取图表详情失败, %v", e)
		return
	}
	if utils.Re == nil {
		jsonData, _ := json.Marshal(resp)
		_ = utils.Rc.Put(key, jsonData, 10*time.Minute)
	}
	isOk = true
	return
}

func GetAiPredictChartDetailByData(indexItem *aiPredictModel.AiPredictModelIndex, indexData []*aiPredictModel.AiPredictModelData, source int) (resp *models.ChartInfoDetailResp, err error) {
	resp = new(models.ChartInfoDetailResp)

	// 标的配置
	var extraConfig aiPredictModel.AiPredictModelIndexExtraConfig
	if indexItem.ExtraConfig != "" {
		if e := json.Unmarshal([]byte(indexItem.ExtraConfig), &extraConfig); e != nil {
			err = fmt.Errorf("标的额外配置解析失败, Config: %s, Err: %v", indexItem.ExtraConfig, e)
			return
		}
	}

	// 图表信息
	var predictLegendName, confLeftMin, confLeftMax, unit string
	if source == aiPredictModel.ModelDataSourceDaily {
		predictLegendName = extraConfig.DailyChart.PredictLegendName
		if predictLegendName == "" {
			predictLegendName = "Predicted"
		}
		unit = extraConfig.DailyChart.Unit
		confLeftMin = extraConfig.DailyChart.LeftMin
		confLeftMax = extraConfig.DailyChart.LeftMax
	}
	if source == aiPredictModel.ModelDataSourceMonthly {
		predictLegendName = "预测值"
		unit = extraConfig.MonthlyChart.Unit
		confLeftMin = extraConfig.MonthlyChart.LeftMin
		confLeftMax = extraConfig.MonthlyChart.LeftMax
	}
	// 这里简单兼容下吧，暂时就不修数据了
	if confLeftMin == "" {
		confLeftMin = indexItem.LeftMin
	}
	if confLeftMax == "" {
		confLeftMax = indexItem.LeftMax
	}

	// 获取指标对应的图表
	chartSourceMapping := map[int]int{
		aiPredictModel.ModelDataSourceMonthly: utils.CHART_SOURCE_AI_PREDICT_MODEL_MONTHLY,
		aiPredictModel.ModelDataSourceDaily:   utils.CHART_SOURCE_AI_PREDICT_MODEL_DAILY,
	}
	chartInfo, e := data_manage.GetAiPredictChartInfoByIndexId(chartSourceMapping[source], indexItem.AiPredictModelIndexId)
	if e != nil && !utils.IsErrNoRow(e) {
		err = fmt.Errorf("获取标的图表失败, %v", e)
		return
	}

	// 获取曲线图主题样式
	chartView := new(models.ChartInfo)
	if chartInfo != nil && chartInfo.ChartInfoId > 0 {
		chartView.ChartInfoId = chartInfo.ChartInfoId
		chartView.ChartName = chartInfo.ChartName
		chartView.ChartNameEn = chartInfo.ChartNameEn
		chartView.Source = chartInfo.Source
		chartView.ChartImage = chartInfo.ChartImage
	} else {
		chartView.ChartName = indexItem.IndexName
		chartView.ChartNameEn = indexItem.IndexName
	}
	chartView.ChartType = utils.CHART_SOURCE_DEFAULT
	chartTheme, e := data.GetChartThemeConfig(0, chartView.ChartType, utils.CHART_TYPE_CURVE)
	if e != nil {
		err = fmt.Errorf("获取图表主题样式失败, %v", e)
		return
	}
	chartView.ChartThemeStyle = chartTheme.Config
	chartView.ChartThemeId = chartTheme.ChartThemeId

	chartView.DateType = 3
	chartView.Calendar = "公历"
	chartView.ChartSource = "AI预测模型"
	chartView.ChartSourceEn = "AI预测模型"
	chartView.Unit = unit
	chartView.UnitEn = unit

	// EdbList-固定一条为标的实际值、一条为预测值
	edbList := make([]*models.ChartEdbInfoMapping, 0)
	edbActual, edbPredict := new(models.ChartEdbInfoMapping), new(models.ChartEdbInfoMapping)
	edbActual.EdbName = indexItem.IndexName
	edbActual.EdbNameEn = indexItem.IndexName
	edbActual.IsAxis = 1
	edbActual.Unit = unit
	edbActual.UnitEn = unit

	edbPredict.EdbName = predictLegendName
	edbPredict.EdbNameEn = predictLegendName
	edbPredict.IsAxis = 1
	edbPredict.Unit = unit
	edbPredict.UnitEn = unit
	actualData, predictData := make([]*models.EdbDataList, 0), make([]*models.EdbDataList, 0)

	var startDate, endDate time.Time
	var actualValues, predictValues []float64
	var actualNewest, predictNewest bool
	var actualLatestTimestamp int64 // 实际值最后一天的时间戳，作为日度图表的分割线
	for k, v := range indexData {
		// 如果实际值和预测值都是null那么该日期无效直接忽略
		if !v.Value.Valid && !v.PredictValue.Valid {
			continue
		}

		// 将有效值加入[]float64，最后取极值
		if v.Value.Valid {
			actualValues = append(actualValues, v.Value.Float64)
		}
		if v.PredictValue.Valid {
			predictValues = append(predictValues, v.PredictValue.Float64)
		}

		// 开始结束时间
		if k == 0 {
			startDate = v.DataTime
			endDate = v.CreateTime
		}
		if v.DataTime.Before(startDate) {
			startDate = v.DataTime
		}
		if v.DataTime.After(endDate) {
			endDate = v.DataTime
		}

		// 指标数据
		if v.Value.Valid {
			if !actualNewest {
				edbActual.LatestDate = v.DataTime.Format(utils.FormatDate)
				edbActual.LatestValue = v.Value.Float64
				actualLatestTimestamp = v.DataTime.UnixNano() / 1e6
				actualNewest = true
			}
			actualData = append(actualData, &models.EdbDataList{
				DataTime:      v.DataTime.Format(utils.FormatDate),
				Value:         v.Value.Float64,
				DataTimestamp: v.DataTimestamp,
			})
		}
		if v.PredictValue.Valid {
			if !predictNewest {
				edbPredict.LatestDate = v.DataTime.Format(utils.FormatDate)
				edbPredict.LatestValue = v.Value.Float64
				predictNewest = true
			}
			predictData = append(predictData, &models.EdbDataList{
				DataTime:      v.DataTime.Format(utils.FormatDate),
				Value:         v.PredictValue.Float64,
				DataTimestamp: v.DataTimestamp,
			})
		}
	}

	// 图表数据这里均做一个升序排序
	sort.Slice(actualData, func(i, j int) bool {
		return actualData[i].DataTimestamp < actualData[j].DataTimestamp
	})
	sort.Slice(predictData, func(i, j int) bool {
		return predictData[i].DataTimestamp < predictData[j].DataTimestamp
	})

	// 极值
	actualMin, actualMax := utils.FindMinMax(actualValues)
	predictMin, predictMax := utils.FindMinMax(predictValues)
	edbActual.MinData = actualMin
	edbActual.MaxData = actualMax
	edbPredict.MinData = predictMin
	edbPredict.MaxData = predictMax

	edbActual.DataList = actualData
	edbPredict.DataList = predictData
	edbList = append(edbList, edbActual, edbPredict)

	// 上下限
	if confLeftMin != "" {
		chartView.LeftMin = confLeftMin
	} else {
		leftMin := actualMin
		if leftMin > predictMin {
			leftMin = predictMin
		}
		chartView.LeftMin = fmt.Sprint(leftMin)
	}
	if confLeftMax != "" {
		chartView.LeftMax = confLeftMax
	} else {
		leftMax := actualMax
		if leftMax < predictMax {
			leftMax = predictMax
		}
		chartView.LeftMax = fmt.Sprint(leftMax)
	}

	chartView.StartDate = startDate.Format(utils.FormatDate)
	chartView.EndDate = endDate.Format(utils.FormatDate)

	// 日度图表的分割线日期
	if source == aiPredictModel.ModelDataSourceDaily {
		var dataResp struct {
			ActualLatestTimestamp int64
		}
		dataResp.ActualLatestTimestamp = actualLatestTimestamp
		resp.DataResp = dataResp
	}

	resp.ChartInfo = chartView
	resp.EdbInfoList = edbList
	return
}