eta_api/services/data/line_equation/chart_info.go

package line_equation

import (
	"encoding/json"
	"errors"
	"eta_gn/eta_api/models/data_manage"
	"eta_gn/eta_api/models/data_manage/line_equation"
	"eta_gn/eta_api/models/data_manage/line_equation/request"
	"eta_gn/eta_api/models/system"
	"eta_gn/eta_api/services/data"
	"eta_gn/eta_api/utils"
	"fmt"
	"github.com/shopspring/decimal"
	"math"
	"sort"
	"strconv"
	"strings"
	"time"
)

type LineEquationResp struct {
	AData  LineEquationDataResp
	BData  LineEquationDataResp
	R2Data LineEquationDataResp
}

type LineEquationDataResp struct {
	MaxData             float64
	MinData             float64
	LatestDate          string `description:"真实数据的最后日期"`
	EdbInfoCategoryType int
	ChartColor          string
	ChartStyle          string
	PredictChartColor   string
	ChartType           int
	ChartWidth          int
	EdbName             string
	EdbNameEn           string
	Unit                string
	UnitEn              string
	IsAxis              int
	DataList            []data_manage.EdbDataList
}

func GetChartEdbData(chartInfoId int, lineChartInfoConfig request.LineChartInfoReq, getAData, getBData, getR2Data bool) (edbList []*data_manage.ChartEdbInfoMapping, dataResp LineEquationResp, err error, errMsg string) {
	mappingList, startDate, endDate, err, errMsg := getConfigData(lineChartInfoConfig)
	if err != nil {
		return
	}
	xEdbInfoIdList := lineChartInfoConfig.XEdbInfoIdList
	yEdbInfoIdList := lineChartInfoConfig.YEdbInfoIdList

	aLineEquationDataResp := LineEquationDataResp{
		DataList:          make([]data_manage.EdbDataList, 0),
		MaxData:           0,
		MinData:           0,
		ChartColor:        "#00f",
		ChartStyle:        `spline`,
		PredictChartColor: `#00f`,
		ChartType:         0,
		ChartWidth:        3,
		EdbName:           `弹性系数`,
		EdbNameEn:         `elastic coefficient`,
		IsAxis:            1,
	}
	bLineEquationDataResp := LineEquationDataResp{
		DataList:          make([]data_manage.EdbDataList, 0),
		MaxData:           0,
		MinData:           0,
		ChartColor:        "#00f",
		ChartStyle:        `spline`,
		PredictChartColor: `#00f`,
		ChartType:         0,
		ChartWidth:        3,
		EdbName:           `截距`,
		EdbNameEn:         `intercept`,
		IsAxis:            1,
	}
	r2LineEquationDataResp := LineEquationDataResp{
		DataList:          make([]data_manage.EdbDataList, 0),
		MaxData:           0,
		MinData:           0,
		ChartColor:        "#00f",
		ChartStyle:        `spline`,
		PredictChartColor: `#00f`,
		ChartType:         0,
		ChartWidth:        3,
		EdbName:           `相关系数`,
		EdbNameEn:         `coefficient of association`,
		IsAxis:            1,
	}
	edbList = make([]*data_manage.ChartEdbInfoMapping, 0)
	dataResp = LineEquationResp{
		AData:  aLineEquationDataResp,
		BData:  bLineEquationDataResp,
		R2Data: r2LineEquationDataResp,
	}

	var baseEdbInfo *data_manage.ChartEdbInfoMapping
	{
		var xEdbInfo, yEdbInfo *data_manage.ChartEdbInfoMapping
		for _, v := range mappingList {
			if v.EdbInfoId == xEdbInfoIdList[0] {
				xEdbInfo = v
			}
			if v.EdbInfoId == yEdbInfoIdList[0] {
				yEdbInfo = v
			}
		}
		if xEdbInfo == nil {
			errMsg = `X轴第一个指标异常`
			err = errors.New(errMsg)
			return
		}
		if yEdbInfo == nil {
			errMsg = `Y轴第一个指标异常`
			err = errors.New(errMsg)
			return
		}

		frequencyIntMap := map[string]int{
			"日度": 1,
			"周度": 2,
			"旬度": 3,
			"月度": 4,
			"季度": 5,
			"年度": 6,
		}
		if frequencyIntMap[xEdbInfo.Frequency] <= frequencyIntMap[yEdbInfo.Frequency] {
			baseEdbInfo = yEdbInfo
		} else {
			baseEdbInfo = xEdbInfo
		}
	}

	chartType := 1 //1：普通图，2：季节性图
	calendar := "公历"
	edbDataListMap, edbList, err := data.GetEdbDataMapList(chartInfoId, chartType, calendar, startDate, endDate, mappingList, "")
	if err != nil {
		return
	}

	dateList := make([]string, 0)
	for _, v := range edbDataListMap[baseEdbInfo.EdbInfoId] {
		dateList = append(dateList, v.DataTime)
	}

	dateEdbMap, err := handleData(baseEdbInfo.EdbInfoId, edbDataListMap)
	if err != nil {
		return
	}

	lenX := len(xEdbInfoIdList)

	var isNotAFirst, isNotBFirst, isNotR2First bool
	for i, date := range dateList {
		coordinateData := make([]utils.Coordinate, 0)
		for k := 0; k < lenX; k++ {
			xVal, ok1 := dateEdbMap[date][xEdbInfoIdList[k]]
			yVal, ok2 := dateEdbMap[date][yEdbInfoIdList[k]]
			if !ok1 || !ok2 {
				continue
			}
			tmpCoordinate1 := utils.Coordinate{
				X: xVal,
				Y: yVal,
			}
			coordinateData = append(coordinateData, tmpCoordinate1)
		}
		dataTime, _ := time.ParseInLocation(utils.FormatDate, date, time.Local)
		timestamp := dataTime.UnixNano() / 1e6

		if len(coordinateData) >= 2 {
			a, b := utils.GetLinearResult(coordinateData)
			if !math.IsNaN(a) && !math.IsNaN(b) && !math.IsInf(a, 0) && !math.IsInf(b, 0) {
				if getAData {
					a, _ = decimal.NewFromFloat(a).Round(4).Float64()
					dataResp.AData.DataList = append(dataResp.AData.DataList, data_manage.EdbDataList{
						EdbDataId:     i,
						EdbInfoId:     0,
						DataTime:      date,
						DataTimestamp: timestamp,
						Value:         a,
					})
					if !isNotAFirst {
						dataResp.AData.MinData = a
						dataResp.AData.MaxData = a
						isNotAFirst = true
					}
					if dataResp.AData.MinData > a {
						dataResp.AData.MinData = a
					}
					if dataResp.AData.MaxData < a {
						dataResp.AData.MaxData = a
					}
				}
				if getBData {
					b, _ = decimal.NewFromFloat(b).Round(4).Float64()
					dataResp.BData.DataList = append(dataResp.BData.DataList, data_manage.EdbDataList{
						EdbDataId:     i,
						EdbInfoId:     0,
						DataTime:      date,
						DataTimestamp: timestamp,
						Value:         b,
					})
					if !isNotBFirst {
						dataResp.BData.MinData = b
						dataResp.BData.MaxData = b
						isNotBFirst = true
					}
					if dataResp.BData.MinData > b {
						dataResp.BData.MinData = b
					}
					if dataResp.BData.MaxData < b {
						dataResp.BData.MaxData = b
					}
				}
			}

			if getR2Data {
				tmpVal := utils.CalculationDecisive(coordinateData)
				if math.IsNaN(tmpVal) || math.IsInf(tmpVal, 0) {
					continue
				}

				tmpVal, _ = decimal.NewFromFloat(tmpVal).Round(4).Float64()
				dataResp.R2Data.DataList = append(dataResp.R2Data.DataList, data_manage.EdbDataList{
					EdbDataId:     i,
					EdbInfoId:     0,
					DataTime:      date,
					DataTimestamp: timestamp,
					Value:         tmpVal,
				})
				if !isNotR2First {
					dataResp.R2Data.MinData = tmpVal
					dataResp.R2Data.MaxData = tmpVal
					isNotR2First = true
				}
				if dataResp.R2Data.MinData > tmpVal {
					dataResp.R2Data.MinData = tmpVal
				}
				if dataResp.R2Data.MaxData < tmpVal {
					dataResp.R2Data.MaxData = tmpVal
				}
			}
		}
	}
	dataResp.AData.LatestDate = baseEdbInfo.LatestDate
	dataResp.AData.EdbInfoCategoryType = baseEdbInfo.EdbInfoCategoryType
	dataResp.BData.LatestDate = baseEdbInfo.LatestDate
	dataResp.BData.EdbInfoCategoryType = baseEdbInfo.EdbInfoCategoryType
	dataResp.R2Data.LatestDate = baseEdbInfo.LatestDate
	dataResp.R2Data.EdbInfoCategoryType = baseEdbInfo.EdbInfoCategoryType

	return
}

func GetConfigData(lineChartInfoConfig request.LineChartInfoReq) (mappingList []*data_manage.ChartEdbInfoMapping, startDate, endDate string, err error, errMsg string) {
	return getConfigData(lineChartInfoConfig)
}

func getConfigData(lineChartInfoConfig request.LineChartInfoReq) (mappingList []*data_manage.ChartEdbInfoMapping, startDate, endDate string, err error, errMsg string) {
	dateType := lineChartInfoConfig.DateType
	switch dateType {
	case 1:
		startDate = "2000-01-01"
	case 2:
		startDate = "2010-01-01"
	case 3:
		startDate = "2015-01-01"
	case 4:
		startDate = "2021-01-01"
	case 5:
		startDate = lineChartInfoConfig.StartDate + "-01"
		endDate = lineChartInfoConfig.EndDate + "-01"
	case 6:
		startDate = lineChartInfoConfig.StartDate + "-01"
	case 7:
		startDate = "2018-01-01"
	case 8:
		startDate = "2019-01-01"
	case 9:
		startDate = "2020-01-01"
	case 11:
		startDate = "2022-01-01"
	}

	edbInfoIdList := make([]int, 0)
	{
		edbInfoIdMap := make(map[int]int, 0)
		for _, edbInfoId := range lineChartInfoConfig.XEdbInfoIdList {
			edbInfoIdMap[edbInfoId] = edbInfoId
		}
		for _, edbInfoId := range lineChartInfoConfig.YEdbInfoIdList {
			edbInfoIdMap[edbInfoId] = edbInfoId
		}
		for _, edbInfoId := range edbInfoIdMap {
			edbInfoIdList = append(edbInfoIdList, edbInfoId)
		}
	}
	mappingList, err = data_manage.GetChartEdbMappingListByEdbInfoIdList(edbInfoIdList)
	if err != nil {
		errMsg = `获取失败`
		err = errors.New("获取图表，指标信息失败，Err:" + err.Error())
		return
	}

	return
}

func handleData(baseEdbInfoId int, edbDataListMap map[int][]*data_manage.EdbDataList) (dateEdbMap map[string]map[int]float64, err error) {
	dateEdbMap = make(map[string]map[int]float64) // [日期][A指标id:值，B指标id:值]
	for edbInfoId, edbDataList := range edbDataListMap {
		if edbInfoId != baseEdbInfoId {
			handleDataMap := make(map[string]float64)
			err = data_manage.HandleDataByPreviousData(edbDataList, handleDataMap)
			if err != nil {
				return
			}

			for date, val := range handleDataMap {
				item, ok := dateEdbMap[date]
				if ok {
					item[edbInfoId] = val
				} else {
					item = map[int]float64{
						edbInfoId: val,
					}
				}
				dateEdbMap[date] = item
			}
		} else {
			for _, edbData := range edbDataList {
				item, ok := dateEdbMap[edbData.DataTime]
				if ok {
					item[edbInfoId] = edbData.Value
				} else {
					item = map[int]float64{
						edbInfoId: edbData.Value,
					}
				}
				dateEdbMap[edbData.DataTime] = item
			}
		}
	}

	return
}

func BatchAddChartInfo(batchAddChartReq []request.AddChart, lineChartInfoConfig request.LineChartInfoReq, sysUser *system.Admin, lang string) (batchAddChartList []line_equation.BatchAddChart, err error, errMsg string, isSendEmail bool) {
	source := utils.CHART_SOURCE_LINE_EQUATION
	for k, v := range batchAddChartReq {
		v.ChartName = strings.Trim(v.ChartName, " ")
		batchAddChartReq[k] = v

		if v.ChartName == "" {
			errMsg = "请填写图表名称！"
			err = errors.New(errMsg)
			isSendEmail = false
			return
		}
		if v.ChartClassifyId <= 0 {
			errMsg = "请填写图表名称！"
			err = errors.New(errMsg)
			isSendEmail = false
			return
		}

		chartClassify, tmpErr := data_manage.GetChartClassifyById(v.ChartClassifyId)
		if tmpErr != nil {
			if utils.IsErrNoRow(tmpErr) {
				errMsg = "分类不存在"
				err = errors.New(errMsg)
				isSendEmail = false
				return
			}
			errMsg = "获取分类信息失败"
			err = errors.New("获取分类信息失败，Err:" + tmpErr.Error())
			return
		}
		if chartClassify == nil {
			errMsg = "分类不存在"
			err = errors.New(errMsg)
			isSendEmail = false
			return
		}

		{
			var condition string
			var pars []interface{}
			switch lang {
			case utils.EnLangVersion:
				condition += " AND chart_name_en = ? AND source = ? "
			default:
				condition += " AND chart_name = ? AND source = ? "
			}
			pars = append(pars, v.ChartName, source)
			count, tmpErr := data_manage.GetChartInfoCountByCondition(condition, pars)
			if tmpErr != nil {
				errMsg = "判断图表名称是否存在失败"
				err = errors.New("判断图表名称是否存在失败,Err:" + tmpErr.Error())
				return
			}

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

		}
	}

	edbList, _, _, err, errMsg := getConfigData(lineChartInfoConfig)

	var edbInfoIdArr []int
	for _, v := range edbList {
		edbInfoIdArr = append(edbInfoIdArr, v.EdbInfoId)
	}
	disableVal := data.CheckIsDisableChart(edbInfoIdArr)

	sort.Ints(edbInfoIdArr)
	var edbInfoIdArrStr []string
	for _, v := range edbInfoIdArr {
		edbInfoIdArrStr = append(edbInfoIdArrStr, strconv.Itoa(v))
	}
	edbInfoIdStr := strings.Join(edbInfoIdArrStr, ",")

	lineChartInfoConfigByte, err := json.Marshal(lineChartInfoConfig)
	if err != nil {
		return
	}
	multipleGraphConfig := &data_manage.MultipleGraphConfig{
		Curve:           string(lineChartInfoConfigByte),
		SysUserId:       sysUser.AdminId,
		SysUserRealName: sysUser.RealName,
		ModifyTime:      time.Now(),
		CreateTime:      time.Now(),
	}

	batchAddChartList = make([]line_equation.BatchAddChart, 0)
	for _, v := range batchAddChartReq {
		tmpLineChartInfoConfig := lineChartInfoConfig
		tmpLineChartInfoConfig.Source = v.Source
		tmpLineChartInfoConfigByte, tmpErr := json.Marshal(tmpLineChartInfoConfig)
		if tmpErr != nil {
			err = tmpErr
			return
		}

		chartInfo := &data_manage.ChartInfo{
			ChartInfoId:     0,
			ChartName:       v.ChartName,
			ChartNameEn:     v.ChartName,
			ChartClassifyId: v.ChartClassifyId,
			SysUserId:       sysUser.AdminId,
			SysUserRealName: sysUser.RealName,
			UniqueCode:      utils.MD5(utils.CHART_PREFIX + "_" + fmt.Sprint(v.Source) + "_" + strconv.FormatInt(time.Now().UnixNano(), 10)),
			CreateTime:      time.Now(),
			ModifyTime:      time.Now(),
			DateType:        lineChartInfoConfig.DateType,
			StartDate:       lineChartInfoConfig.StartDate,
			EndDate:         lineChartInfoConfig.EndDate,
			IsSetName:       0,
			EdbInfoIds:      edbInfoIdStr,
			ChartType:       1,
			Calendar:        "公历",
			SeasonStartDate: "",
			SeasonEndDate:   "",
			ChartImage:      v.ChartImage,
			Sort:            0,
			LeftMin:         v.LeftMin,
			LeftMax:         v.LeftMax,
			RightMin:        "",
			RightMax:        "",
			Disabled:        disableVal,
			BarConfig:       "",
			Source:          source,
			ExtraConfig:     string(tmpLineChartInfoConfigByte),
			ChartThemeId:    v.ChartThemeId,
			SourcesFrom:     v.SourcesFrom,
			Instructions:    v.Instructions,
			MarkersLines:    v.MarkersLines,
			MarkersAreas:    v.MarkersAreas,
		}

		mapList := make([]*data_manage.ChartEdbMapping, 0)
		for _, edbInfo := range edbList {
			mapItem := new(data_manage.ChartEdbMapping)
			mapItem.EdbInfoId = edbInfo.EdbInfoId
			mapItem.CreateTime = time.Now()
			mapItem.ModifyTime = time.Now()
			timestamp := strconv.FormatInt(time.Now().UnixNano(), 10)

			mapItem.UniqueCode = utils.MD5(utils.CHART_PREFIX + "_" + fmt.Sprint(v.Source) + "_" + timestamp + "_" + strconv.Itoa(edbInfo.EdbInfoId))
			mapItem.IsOrder = true
			mapItem.IsAxis = 1
			mapItem.EdbInfoType = 1
			mapItem.Source = source
			mapList = append(mapList, mapItem)
		}

		multipleGraphConfigChartMapping := &data_manage.MultipleGraphConfigChartMapping{
			Source:     v.Source,
			ModifyTime: time.Now(),
			CreateTime: time.Now(),
		}

		batchAddChartList = append(batchAddChartList, line_equation.BatchAddChart{
			ChartInfo:                       chartInfo,
			EdbMappingList:                  mapList,
			MultipleGraphConfigChartMapping: multipleGraphConfigChartMapping,
		})
	}

	err = line_equation.CreateLineEquationChartAndEdb(multipleGraphConfig, batchAddChartList)

	for _, v := range batchAddChartList {
		_ = data.SaveChartEdbInfoRelation(edbInfoIdArr, v.ChartInfo)
		go data.EsAddOrEditChartInfo(v.ChartInfo.ChartInfoId)
	}

	return
}

func BatchSaveChartInfo(multipleGraphConfigId int, batchAddChartReq []request.AddChart, lineChartInfoConfig request.LineChartInfoReq, sysUser *system.Admin) (batchAddChartList []line_equation.BatchAddChart, err error, errMsg string, isSendEmail bool) {
	multipleGraphConfig, err := data_manage.GetMultipleGraphConfigById(multipleGraphConfigId)
	if err != nil {
		errMsg = `获取失败`
		err = errors.New(`获取配置失败，ERR：` + err.Error())
		return
	}
	chartMappingList, err := data_manage.GetMultipleGraphConfigChartMappingListById(multipleGraphConfig.MultipleGraphConfigId)
	if err != nil {
		errMsg = `获取失败`
		err = errors.New(`获取关联图表配置失败，ERR：` + err.Error())
		return
	}

	existSourceChartMap := make(map[int]*data_manage.MultipleGraphConfigChartMapping)
	existChartInfoMap := make(map[int]*data_manage.ChartInfo)
	for _, v := range chartMappingList {
		existSourceChartMap[v.Source] = v

		chartInfo, tmpErr := data_manage.GetChartInfoById(v.ChartInfoId)
		if tmpErr != nil && !utils.IsErrNoRow(tmpErr) {
			err = tmpErr
			return
		}
		if chartInfo != nil {
			existChartInfoMap[v.Source] = chartInfo
		}
	}

	source := utils.CHART_SOURCE_LINE_EQUATION
	for k, v := range batchAddChartReq {
		v.ChartName = strings.Trim(v.ChartName, " ")
		batchAddChartReq[k] = v

		if v.ChartName == "" {
			errMsg = "请填写图表名称！"
			err = errors.New(errMsg)
			isSendEmail = false
			return
		}
		if v.ChartClassifyId <= 0 {
			errMsg = "请填写图表名称！"
			err = errors.New(errMsg)
			isSendEmail = false
			return
		}

		chartClassify, tmpErr := data_manage.GetChartClassifyById(v.ChartClassifyId)
		if tmpErr != nil {
			if utils.IsErrNoRow(tmpErr) {
				errMsg = "分类不存在"
				err = errors.New(errMsg)
				isSendEmail = false
				return
			}
			errMsg = "获取分类信息失败"
			err = errors.New("获取分类信息失败，Err:" + tmpErr.Error())
			return
		}
		if chartClassify == nil {
			errMsg = "分类不存在"
			err = errors.New(errMsg)
			isSendEmail = false
			return
		}

		var condition string
		var pars []interface{}
		condition += " AND chart_name=? AND source = ? "
		pars = append(pars, v.ChartName, source)

		if sourceChart, ok := existChartInfoMap[v.Source]; ok {
			condition += " AND chart_info_id != ?  "
			pars = append(pars, sourceChart.ChartInfoId)
		}

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

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

	edbList, _, _, err, errMsg := getConfigData(lineChartInfoConfig)

	var edbInfoIdArr []int
	for _, v := range edbList {
		edbInfoIdArr = append(edbInfoIdArr, v.EdbInfoId)
	}
	disableVal := data.CheckIsDisableChart(edbInfoIdArr)

	sort.Ints(edbInfoIdArr)
	var edbInfoIdArrStr []string
	for _, v := range edbInfoIdArr {
		edbInfoIdArrStr = append(edbInfoIdArrStr, strconv.Itoa(v))
	}
	edbInfoIdStr := strings.Join(edbInfoIdArrStr, ",")

	lineChartInfoConfigByte, err := json.Marshal(lineChartInfoConfig)
	if err != nil {
		return
	}
	multipleGraphConfig.Curve = string(lineChartInfoConfigByte)
	multipleGraphConfig.ModifyTime = time.Now()
	updateMultipleGraphConfigCols := []string{"Curve", "ModifyTime"}
	updateChartCols := []string{"ChartName", "DateType", "StartDate", "EndDate", "EdbInfoIds", "LeftMin", "LeftMax", "Disabled", "ExtraConfig"}

	batchAddChartList = make([]line_equation.BatchAddChart, 0)
	for _, v := range batchAddChartReq {
		tmpLineChartInfoConfig := lineChartInfoConfig
		tmpLineChartInfoConfig.Source = v.Source
		tmpLineChartInfoConfigByte, tmpErr := json.Marshal(tmpLineChartInfoConfig)
		if tmpErr != nil {
			err = tmpErr
			return
		}

		var multipleGraphConfigChartMapping *data_manage.MultipleGraphConfigChartMapping
		chartInfo, ok := existChartInfoMap[v.Source]
		if ok {
			chartInfo.ChartName = v.ChartName
			chartInfo.DateType = lineChartInfoConfig.DateType
			chartInfo.StartDate = lineChartInfoConfig.StartDate
			chartInfo.EndDate = lineChartInfoConfig.EndDate
			chartInfo.EdbInfoIds = edbInfoIdStr
			chartInfo.LeftMin = v.LeftMin
			chartInfo.LeftMax = v.LeftMax
			chartInfo.Disabled = disableVal
			chartInfo.ExtraConfig = string(tmpLineChartInfoConfigByte)

			tmpMultipleGraphConfigChartMapping, ok2 := existSourceChartMap[v.Source]
			if !ok2 {
				err = errors.New("找不到对应的统一配置关系")
				return
			}
			multipleGraphConfigChartMapping = tmpMultipleGraphConfigChartMapping
		} else {
			chartInfo = &data_manage.ChartInfo{
				ChartInfoId: 0,
				ChartName:   v.ChartName,
				ChartClassifyId: v.ChartClassifyId,
				SysUserId:       sysUser.AdminId,
				SysUserRealName: sysUser.RealName,
				UniqueCode:      utils.MD5(utils.CHART_PREFIX + "_" + fmt.Sprint(v.Source) + "_" + strconv.FormatInt(time.Now().UnixNano(), 10)),
				CreateTime:      time.Now(),
				ModifyTime:      time.Now(),
				DateType:        lineChartInfoConfig.DateType,
				StartDate:       lineChartInfoConfig.StartDate,
				EndDate:         lineChartInfoConfig.EndDate,
				IsSetName:       0,
				EdbInfoIds:      edbInfoIdStr,
				ChartType:       1,
				Calendar:        "公历",
				SeasonStartDate: "",
				SeasonEndDate:   "",
				ChartImage:      "",
				Sort:            0,
				LeftMin:         v.LeftMin,
				LeftMax:         v.LeftMax,
				RightMin:        "",
				RightMax:        "",
				Disabled:        disableVal,
				BarConfig:       "",
				Source:          source,
				ExtraConfig:     string(tmpLineChartInfoConfigByte),
			}

			if tmpMultipleGraphConfigChartMapping, ok2 := existSourceChartMap[v.Source]; ok2 {
				multipleGraphConfigChartMapping = tmpMultipleGraphConfigChartMapping
			} else {
				multipleGraphConfigChartMapping = &data_manage.MultipleGraphConfigChartMapping{
					Source:     v.Source,
					ModifyTime: time.Now(),
					CreateTime: time.Now(),
				}
			}

		}

		mapList := make([]*data_manage.ChartEdbMapping, 0)
		for _, edbInfo := range edbList {
			mapItem := new(data_manage.ChartEdbMapping)
			mapItem.EdbInfoId = edbInfo.EdbInfoId
			mapItem.CreateTime = time.Now()
			mapItem.ModifyTime = time.Now()
			timestamp := strconv.FormatInt(time.Now().UnixNano(), 10)

			mapItem.UniqueCode = utils.MD5(utils.CHART_PREFIX + "_" + fmt.Sprint(v.Source) + "_" + timestamp + "_" + strconv.Itoa(edbInfo.EdbInfoId))
			mapItem.IsOrder = true
			mapItem.IsAxis = 1
			mapItem.EdbInfoType = 1
			mapItem.Source = source
			mapList = append(mapList, mapItem)
		}

		batchAddChartList = append(batchAddChartList, line_equation.BatchAddChart{
			ChartInfo:                       chartInfo,
			EdbMappingList:                  mapList,
			MultipleGraphConfigChartMapping: multipleGraphConfigChartMapping,
		})
	}

	err = line_equation.CreateAndEditLineEquationChartAndEdb(multipleGraphConfig, batchAddChartList, updateMultipleGraphConfigCols, updateChartCols)

	for _, v := range batchAddChartList {
		_ = data.SaveChartEdbInfoRelation(edbInfoIdArr, v.ChartInfo)

		go data.EsAddOrEditChartInfo(v.ChartInfo.ChartInfoId)
	}
	return
}