eta_api/controllers/data_manage/range_analysis/chart_info.go

package range_analysis

import (
	"encoding/json"
	"eta/eta_api/controllers"
	"eta/eta_api/models"
	"eta/eta_api/models/data_manage"
	"eta/eta_api/models/system"
	"eta/eta_api/services/data"
	"eta/eta_api/services/data/data_manage_permission"
	rangeServ "eta/eta_api/services/data/range_analysis"
	"eta/eta_api/utils"
	"fmt"
	"github.com/rdlucklib/rdluck_tools/paging"
	"sort"
	"strconv"
	"strings"
	"time"
)

// RangeChartChartInfoController 区间计算图表管理
type RangeChartChartInfoController struct {
	controllers.BaseAuthController
}

// Preview
// @Title 区间计算图表-预览数据
// @Description 区间计算图表-获取预览数据
// @Param   StartDate	query	string	true	"自定义开始日期"
// @Param   EndDate		query	string	true	"自定义结束日期"
// @Param   LeadValue	query	int		true	"领先值"
// @Param   LeadUnit	query	string	true	"领先单位:年，天，月，季，周"
// @Success 200 {object} data_manage.ChartEdbInfoDetailResp
// @router /chart_info/preview [post]
func (this *RangeChartChartInfoController) Preview() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	sysUser := this.SysUser
	if sysUser == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}
	var req data_manage.ChartRangeAnalysisPreviewReq
	if err := json.Unmarshal(this.Ctx.Input.RequestBody, &req); err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}
	// 基础校验
	if len(req.ChartEdbInfoList) == 0 {
		br.Msg = "请选择指标"
		return
	}

	err, msg, isSendEmail := rangeServ.CheckChartRangeExtraConfig(req.ExtraConfig)
	if err != nil {
		br.Msg = msg
		br.ErrMsg = err.Error()
		br.IsSendEmail = isSendEmail
		return
	}

	// 获取指标信息
	//chartInfo.CorrelationLeadUnit = req.LeadUnit
	edbInfoMappingList := make([]*data_manage.ChartEdbInfoMapping, 0)
	for _, v := range req.ChartEdbInfoList {
		edbInfoMapping, e := data_manage.GetChartEdbMappingByEdbInfoId(v.EdbInfoId)
		if e != nil {
			br.Msg = "获取失败"
			br.ErrMsg = "获取区间计算图表, A指标mapping信息失败, Err:" + e.Error()
			return
		}
		if v.EdbAliasName != "" {
			edbInfoMapping.EdbAliasName = v.EdbAliasName
		}
		edbInfoMapping.IsAxis = v.IsAxis
		edbInfoMappingList = append(edbInfoMappingList, edbInfoMapping)
	}

	chartInfo := new(data_manage.ChartInfoView)
	chartInfo.ChartType = 1
	chartInfo.Source = utils.CHART_SOURCE_RANGE_ANALYSIS

	// 获取图表x轴y轴
	edbList, xEdbIdValue, dataResp, e := rangeServ.GetChartDataByEdbInfoList(0, req.DateType, req.StartYear, req.StartDate, req.EndDate, edbInfoMappingList, &req.ExtraConfig)
	if e != nil {
		br.Msg = "获取失败"
		br.ErrMsg = "获取区间计算图表, 图表计算值失败, Err:" + e.Error()
		return
	}

	//添加配置信息
	if req.ExtraConfig.MultipleGraphConfigId == 0 {
		multipleGraphConfig := &data_manage.MultipleGraphConfig{
			//MultipleGraphConfigId: 0,
			SysUserId:       sysUser.AdminId,
			SysUserRealName: sysUser.RealName,
			ModifyTime:      time.Now(),
			CreateTime:      time.Now(),
		}
		err = data_manage.AddMultipleGraphConfig(multipleGraphConfig)
		if err != nil {
			br.Msg = "获取失败"
			br.ErrMsg = "新增区间计算图表配置失败, Err: " + err.Error()
			return
		}
		dataResp.MultipleGraphConfigId = multipleGraphConfig.MultipleGraphConfigId
	}

	resp := new(data_manage.ChartInfoDetailResp)
	resp.ChartInfo = chartInfo
	resp.EdbInfoList = edbList
	resp.XEdbIdValue = xEdbIdValue
	resp.DataResp = dataResp
	br.Data = resp
	br.Ret = 200
	br.Success = true
	br.Msg = "获取成功"
}

// Add
// @Title 新增图表接口
// @Description 新增图表接口
// @Param	request	body data_manage.AddChartInfoReq true "type json string"
// @Success 200 {object} data_manage.AddChartInfoResp
// @router /chart_info/add [post]
func (this *RangeChartChartInfoController) Add() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()

	sysUser := this.SysUser
	if sysUser == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}
	deleteCache := true
	cacheKey := "CACHE_CHART_INFO_ADD_" + strconv.Itoa(sysUser.AdminId)
	defer func() {
		if deleteCache {
			_ = utils.Rc.Delete(cacheKey)
		}
	}()
	if !utils.Rc.SetNX(cacheKey, 1, 30*time.Second) {
		deleteCache = false
		br.Msg = "系统处理中，请稍后重试！"
		br.ErrMsg = "系统处理中，请稍后重试！" + sysUser.RealName + ";data:" + string(this.Ctx.Input.RequestBody)
		return
	}
	var req data_manage.AddChartInfoReq
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}

	chartInfo, err, errMsg, isSendEmail := rangeServ.AddChartInfo(req, utils.CHART_SOURCE_RANGE_ANALYSIS, sysUser, this.Lang)
	if err != nil {
		br.Msg = "保存失败"
		if errMsg != `` {
			br.Msg = errMsg
		}
		br.ErrMsg = err.Error()
		br.IsSendEmail = isSendEmail
		return
	}

	//新增操作日志
	{
		chartLog := new(data_manage.ChartInfoLog)
		chartLog.ChartInfoId = chartInfo.ChartInfoId
		chartLog.ChartName = req.ChartName
		chartLog.ChartClassifyId = req.ChartClassifyId
		chartLog.SysUserId = sysUser.AdminId
		chartLog.SysUserRealName = sysUser.RealName
		chartLog.UniqueCode = chartInfo.UniqueCode
		chartLog.CreateTime = time.Now()
		chartLog.Content = string(this.Ctx.Input.RequestBody)
		chartLog.Status = "新增区间计算图表"
		chartLog.Method = this.Ctx.Input.URI()
		go data_manage.AddChartInfoLog(chartLog)
	}

	resp := new(data_manage.AddChartInfoResp)
	resp.ChartInfoId = chartInfo.ChartInfoId
	resp.UniqueCode = chartInfo.UniqueCode
	resp.ChartType = chartInfo.ChartType
	br.Ret = 200
	br.Success = true
	br.Msg = "保存成功"
	br.Data = resp
	br.IsAddLog = true
}

// Edit
// @Title 编辑图表接口
// @Description 编辑图表接口
// @Param	request	body data_manage.EditChartInfoReq true "type json string"
// @Success Ret=200 保存成功
// @router /chart_info/edit [post]
func (this *RangeChartChartInfoController) Edit() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()

	sysUser := this.SysUser
	if sysUser == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}

	var req data_manage.EditChartInfoReq
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}

	chartItem, err, errMsg, isSendEmail := rangeServ.EditChartInfo(req, sysUser, this.Lang)
	if err != nil {
		br.Msg = "保存失败"
		if errMsg != `` {
			br.Msg = errMsg
		}
		br.ErrMsg = err.Error()
		br.IsSendEmail = isSendEmail
		return
	}

	resp := new(data_manage.AddChartInfoResp)
	resp.ChartInfoId = chartItem.ChartInfoId
	resp.UniqueCode = chartItem.UniqueCode
	resp.ChartType = req.ChartType

	//新增操作日志
	{
		chartLog := new(data_manage.ChartInfoLog)
		chartLog.ChartName = chartItem.ChartName
		chartLog.ChartInfoId = req.ChartInfoId
		chartLog.ChartClassifyId = chartItem.ChartClassifyId
		chartLog.SysUserId = sysUser.AdminId
		chartLog.SysUserRealName = sysUser.RealName
		chartLog.UniqueCode = chartItem.UniqueCode
		chartLog.CreateTime = time.Now()
		chartLog.Content = string(this.Ctx.Input.RequestBody)
		chartLog.Status = "编辑区间计算图表"
		chartLog.Method = this.Ctx.Input.URL()
		go data_manage.AddChartInfoLog(chartLog)
	}

	br.Ret = 200
	br.Success = true
	br.Msg = "保存成功"
	br.Data = resp
	br.IsAddLog = true
}

// Detail
// @Title 获取图表详情
// @Description 获取图表详情接口
// @Param   ChartInfoId   query   int  true       "图表id"
// @Param   DateType   query   int  true       "日期类型:1:00年至今,2:10年至今,3:15年至今，4：年初至今，5:自定义时间"
// @Param   StartDate   query   string  true       "自定义开始日期"
// @Param   EndDate   query   string  true       "自定义结束日期"
// @Param   Calendar   query   string  true       "公历/农历"
// @Param   SeasonStartDate   query   string  true       "季节性图开始日期"
// @Param   SeasonEndDate   query   string  true       "季节性图结束日期"
// @Param   EdbInfoId   query   string  true       "指标ID，多个用英文逗号隔开"
// @Param   ChartType   query   int  true       "生成样式:1:曲线图,2:季节性图"
// @Success 200 {object} data_manage.ChartInfoDetailResp
// @router /chart_info/detail [get]
func (this *RangeChartChartInfoController) Detail() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	sysUser := this.SysUser
	if sysUser == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}
	chartInfoId, _ := this.GetInt("ChartInfoId")
	if chartInfoId <= 0 {
		br.Msg = "参数有误"
		return
	}
	dateType, _ := this.GetInt("DateType")
	fmt.Println("dateType:", dateType)

	startDate := this.GetString("StartDate")
	endDate := this.GetString("EndDate")
	startYear, _ := this.GetInt("StartYear")

	var err error
	chartInfo := new(data_manage.ChartInfoView)
	chartInfo, err = data_manage.GetChartInfoViewById(chartInfoId)
	if err != nil {
		if err.Error() == utils.ErrNoRow() {
			br.Msg = "图被删除，请刷新页面"
			br.ErrMsg = "图被删除，请刷新页面，Err:" + err.Error()
			return
		}
		br.Msg = "获取失败"
		br.ErrMsg = "获取图表信息失败，Err:" + err.Error()
		return
	}
	if dateType <= 0 {
		dateType = chartInfo.DateType
	}
	if startDate == "" {
		startDate = chartInfo.StartDate
	}
	if endDate == "" {
		endDate = chartInfo.EndDate
	}

	if startYear <= 0 {
		startYear = chartInfo.StartYear
	}
	// 获取主题样式
	chartTheme, err := data.GetChartThemeConfig(chartInfo.ChartThemeId, utils.CHART_SOURCE_DEFAULT, chartInfo.ChartType)
	if err != nil {
		br.Msg = "获取失败"
		br.ErrMsg = "获取主题信息失败，Err:" + err.Error()
		return
	}
	chartInfo.ChartThemeStyle = chartTheme.Config
	chartInfo.ChartThemeId = chartTheme.ChartThemeId

	// 获取指标信息
	//chartInfo.CorrelationLeadUnit = req.LeadUnit
	edbInfoMappingList, err := data_manage.GetChartEdbMappingList(chartInfoId)
	if err != nil {
		br.Msg = "获取失败"
		br.ErrMsg = "获取图表，指标信息失败，Err:" + err.Error()
		return
	}
	// 获取图表数据
	if len(edbInfoMappingList) == 0 {
		br.Msg = "获取失败"
		br.ErrMsg = "图表没有指标，无法计算"
		return
	}

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

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

	// 判断是否加入我的图库
	if chartInfoId > 0 && chartInfo != nil {
		{
			var myChartCondition string
			var myChartPars []interface{}
			myChartCondition += ` AND a.admin_id=? `
			myChartPars = append(myChartPars, sysUser.AdminId)
			myChartCondition += ` AND a.chart_info_id=? `
			myChartPars = append(myChartPars, chartInfo.ChartInfoId)

			myChartList, err := data_manage.GetMyChartByCondition(myChartCondition, myChartPars)
			if err != nil && err.Error() != utils.ErrNoRow() {
				br.Msg = "获取失败"
				br.ErrMsg = "获取我的图表信息失败，GetMyChartByCondition，Err:" + err.Error()
				return
			}
			if myChartList != nil && len(myChartList) > 0 {
				chartInfo.IsAdd = true
				chartInfo.MyChartId = myChartList[0].MyChartId
				chartInfo.MyChartClassifyId = myChartList[0].MyChartClassifyId
			}
		}
	}

	//图表操作权限
	chartInfo.IsEdit = data.CheckOpChartPermission(sysUser, chartInfo.SysUserId, true)
	//判断是否需要展示英文标识
	chartInfo.IsEnChart = data.CheckIsEnChart(chartInfo.ChartNameEn, edbList[0:1], chartInfo.Source, chartInfo.ChartType)
	// todo 中英文处理
	chartInfo.UnitEn = extraConfig.DataConvertConf.EnUnit

	sourceNameList, sourceNameEnList := data.GetEdbSourceByEdbInfoIdList(edbList)
	chartInfo.ChartSource = strings.Join(sourceNameList, ",")
	chartInfo.ChartSourceEn = strings.Join(sourceNameEnList, ",")

	// 另存为
	chartInfo.Button = data_manage.ChartViewButton{
		IsEdit:    chartInfo.IsEdit,
		IsEnChart: chartInfo.IsEnChart,
		IsAdd:     chartInfo.IsAdd,
		IsCopy:    chartInfo.IsEdit,
		IsSetName: chartInfo.IsSetName,
	}

	// 指标权限
	{
		edbClassifyPermissionMap := make(map[int]data_manage_permission.EdbClassifyPermission)
		classifyMap := make(map[int]*data_manage.EdbClassify)
		// 分类
		{
			classifyIdList := make([]int, 0)
			for _, v := range edbList {
				classifyIdList = append(classifyIdList, v.ClassifyId)
			}
			classifyList, tmpErr := data_manage.GetEdbClassifyByIdList(classifyIdList)
			if tmpErr != nil {
				br.Msg = "获取失败"
				br.ErrMsg = "获取分类列表失败，Err:" + tmpErr.Error()
				return
			}
			for _, v := range classifyList {
				classifyMap[v.ClassifyId] = v
			}
		}

		// 遍历到校验map
		for _, v := range edbList {
			edbClassifyPermissionMap[v.EdbInfoId] = data_manage_permission.EdbClassifyPermission{
				ClassifyId:       v.ClassifyId,
				IsJoinPermission: v.IsJoinPermission,
				EdbInfoId:        v.EdbInfoId,
			}
		}

		// 获取所有有权限的指标和分类
		permissionEdbIdList, permissionClassifyIdList, err := data_manage_permission.GetUserEdbAndClassifyPermissionList(sysUser.AdminId, 0, 0)
		if err != nil {
			br.Msg = "获取失败"
			br.ErrMsg = "获取所有有权限的指标和分类失败，Err:" + err.Error()
			return
		}

		for _, v := range edbList {
			// 数据权限
			edbItem, ok := edbClassifyPermissionMap[v.EdbInfoId]
			if !ok {
				continue
			}

			if currClassify, ok := classifyMap[edbItem.ClassifyId]; ok {
				v.HaveOperaAuth = data_manage_permission.CheckEdbPermissionByPermissionIdList(edbItem.IsJoinPermission, currClassify.IsJoinPermission, edbItem.EdbInfoId, edbItem.ClassifyId, permissionEdbIdList, permissionClassifyIdList)
			}
		}
	}

	// 图表当前分类的分类树
	classifyLevels := make([]string, 0)
	{
		list, e := data_manage.GetChartClassifyAllBySource(utils.CHART_SOURCE_RANGE_ANALYSIS)
		if e != nil {
			br.Msg = "获取失败"
			br.ErrMsg = fmt.Sprintf("获取图表分类失败, Err: %v", e)
			return
		}
		parents := data.GetChartClassifyParentRecursive(list, chartInfo.ChartClassifyId)
		sort.Slice(parents, func(i, j int) bool {
			return parents[i].Level < parents[i].Level
		})
		for _, v := range parents {
			classifyLevels = append(classifyLevels, v.UniqueCode)
		}
	}

	resp := new(data_manage.ChartInfoDetailResp)
	resp.ChartInfo = chartInfo
	resp.EdbInfoList = edbList
	resp.XEdbIdValue = xEdbIdValue
	resp.DataResp = dataResp
	resp.ClassifyLevels = classifyLevels
	br.Ret = 200
	br.Success = true
	br.Msg = "获取成功"
	br.Data = resp
}

// DetailFromUniqueCode
// @Title 根据编码获取图表详情
// @Description 根据编码获取图表详情接口
// @Param   UniqueCode   query   int  true       "图表唯一编码,如果是管理后台访问，传固定字符串:7c69b590249049942070ae9dcd5bf6dc"
// @Param   IsCache   query   bool  true       "是否走缓存，默认false"
// @Success 200 {object} data_manage.ChartInfoDetailFromUniqueCodeResp
// @router /chart_info/detail/from_unique_code [get]
func (this *RangeChartChartInfoController) DetailFromUniqueCode() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()

	sysUser := this.SysUser
	if sysUser == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}
	adminId := sysUser.AdminId

	uniqueCode := this.GetString("UniqueCode")
	if uniqueCode == "" {
		br.Msg = "参数错误"
		br.ErrMsg = "参数错误,uniqueCode is empty"
		return
	}

	//是否走缓存
	isCache, _ := this.GetBool("IsCache")

	resp := new(data_manage.ChartInfoDetailFromUniqueCodeResp)
	status := true
	chartInfo, err := data_manage.GetChartInfoViewByUniqueCode(uniqueCode)
	if err != nil {
		if err.Error() == utils.ErrNoRow() {
			status = false
		} else {
			br.Msg = "获取失败"
			br.ErrMsg = "获取图表信息失败，Err:" + err.Error()
			return
		}
	}
	if chartInfo == nil {
		status = false
	}
	if !status {
		endInfoList := make([]*data_manage.ChartEdbInfoMapping, 0)
		resp.EdbInfoList = endInfoList
		resp.ChartInfo = chartInfo
		resp.Status = false
		br.Ret = 200
		br.Success = true
		br.Msg = "获取成功"
		br.Data = resp
		return
	}

	//判断是否存在缓存，如果存在缓存，那么直接从缓存中获取
	key := data.GetChartInfoDataKey(chartInfo.ChartInfoId)
	if utils.Re == nil && isCache {
		if utils.Re == nil && utils.Rc.IsExist(key) {
			if d, e := utils.Rc.RedisBytes(key); e == nil {
				err := json.Unmarshal(d, &resp)
				if err == nil && resp != nil {
					// 这里跟当前用户相关的信息重新查询写入resp, 不使用缓存中的
					var myCond string
					var myPars []interface{}
					myCond += ` AND a.admin_id=? `
					myPars = append(myPars, adminId)
					myCond += ` AND a.chart_info_id=? `
					myPars = append(myPars, chartInfo.ChartInfoId)
					myList, err := data_manage.GetMyChartByCondition(myCond, myPars)
					if err != nil && err.Error() != utils.ErrNoRow() {
						br.Msg = "获取失败"
						br.ErrMsg = "获取我的图表信息失败，GetMyChartByCondition，Err:" + err.Error()
						return
					}
					resp.ChartInfo.IsAdd = false
					resp.ChartInfo.MyChartId = 0
					resp.ChartInfo.MyChartClassifyId = ""
					if myList != nil && len(myList) > 0 {
						resp.ChartInfo.IsAdd = true
						resp.ChartInfo.MyChartId = myList[0].MyChartId
						resp.ChartInfo.MyChartClassifyId = myList[0].MyChartClassifyId
					}

					br.Ret = 200
					br.Success = true
					br.Msg = "获取成功"
					br.Data = resp
					return
				}
			}
		}
	}
	resp, isOk, msg, errMsg := GetChartInfoDetailFromUniqueCode(chartInfo, isCache, sysUser)
	if !isOk {
		br.Msg = msg
		br.ErrMsg = errMsg
		return
	}

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

// GetChartInfoDetailFromUniqueCode 根据编码获取图表详情
func GetChartInfoDetailFromUniqueCode(chartInfo *data_manage.ChartInfoView, isCache bool, sysUser *system.Admin) (resp *data_manage.ChartInfoDetailFromUniqueCodeResp, isOk bool, msg, errMsg string) {
	resp = new(data_manage.ChartInfoDetailFromUniqueCodeResp)

	adminId := sysUser.AdminId

	// 指标数据map
	edbClassifyPermissionMap := make(map[int]data_manage_permission.EdbClassifyPermission)
	defer func() {
		if isOk {
			// 这里跟当前用户相关的信息重新查询写入resp, 不使用缓存中的
			{
				//判断是否加入我的图库
				var myChartCondition string
				var myChartPars []interface{}
				myChartCondition += ` AND a.admin_id=? `
				myChartPars = append(myChartPars, adminId)
				myChartCondition += ` AND a.chart_info_id=? `
				myChartPars = append(myChartPars, chartInfo.ChartInfoId)

				myChartList, err := data_manage.GetMyChartByCondition(myChartCondition, myChartPars)
				if err != nil && err.Error() != utils.ErrNoRow() {
					msg = "获取失败"
					errMsg = "获取我的图表信息失败，GetMyChartByCondition，Err:" + err.Error()
					return
				}
				if myChartList != nil && len(myChartList) > 0 {
					chartInfo.IsAdd = true
					chartInfo.MyChartId = myChartList[0].MyChartId
					chartInfo.MyChartClassifyId = myChartList[0].MyChartClassifyId
				}
			}

			resp.ChartInfo.HaveOperaAuth = true

			// 指标权限
			{
				classifyMap := make(map[int]*data_manage.EdbClassify)
				// 分类
				{
					classifyIdList := make([]int, 0)
					for _, v := range resp.EdbInfoList {
						classifyIdList = append(classifyIdList, v.ClassifyId)
					}
					classifyList, tmpErr := data_manage.GetEdbClassifyByIdList(classifyIdList)
					if tmpErr != nil {
						errMsg = "获取分类列表失败，Err:" + tmpErr.Error()
						return
					}
					for _, v := range classifyList {
						classifyMap[v.ClassifyId] = v
					}
				}

				// 指标
				if len(edbClassifyPermissionMap) < 0 {
					edbInfoIdList := make([]int, 0)
					for _, v := range resp.EdbInfoList {
						edbInfoIdList = append(edbInfoIdList, v.EdbInfoId)
					}
					edbInfoList, tmpErr := data_manage.GetEdbInfoByIdList(edbInfoIdList)
					if tmpErr != nil {
						errMsg = "获取指标列表失败，Err:" + tmpErr.Error()
						return
					}
					for _, v := range edbInfoList {
						edbClassifyPermissionMap[v.EdbInfoId] = data_manage_permission.EdbClassifyPermission{
							ClassifyId:       v.ClassifyId,
							IsJoinPermission: v.IsJoinPermission,
							EdbInfoId:        v.EdbInfoId,
						}
					}
				}

				// 获取所有有权限的指标和分类
				permissionEdbIdList, permissionClassifyIdList, err := data_manage_permission.GetUserEdbAndClassifyPermissionList(sysUser.AdminId, 0, 0)
				if err != nil {
					errMsg = "获取所有有权限的指标和分类失败，Err:" + err.Error()
					return
				}

				for _, v := range resp.EdbInfoList {
					// 数据权限
					edbItem, ok := edbClassifyPermissionMap[v.EdbInfoId]
					if !ok {
						continue
					}

					if currClassify, ok := classifyMap[edbItem.ClassifyId]; ok {
						v.HaveOperaAuth = data_manage_permission.CheckEdbPermissionByPermissionIdList(edbItem.IsJoinPermission, currClassify.IsJoinPermission, edbItem.EdbInfoId, edbItem.ClassifyId, permissionEdbIdList, permissionClassifyIdList)
					}
				}
			}
		}
	}()

	//判断是否存在缓存，如果存在缓存，那么直接从缓存中获取
	key := data.GetChartInfoDataKey(chartInfo.ChartInfoId)
	if utils.Re == nil && isCache {
		if utils.Re == nil && utils.Rc.IsExist(key) {
			if chartData, err1 := utils.Rc.RedisBytes(key); err1 == nil {
				err := json.Unmarshal(chartData, &resp)
				if err != nil || resp == nil {
					return
				}
				isOk = true
				fmt.Println("source redis")
				return
			}
		}
	}

	// 获取主题样式
	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 := data_manage.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 data_manage.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 := rangeServ.GetChartDataByEdbInfoList(chartInfoId, dateType, startYear, startDate, endDate, edbInfoMappingList, &extraConfig)
	if e != nil {
		msg = "获取失败"
		errMsg = "获取区间计算图表, 图表计算值失败, Err:" + e.Error()
		return
	}

	if chartInfoId > 0 && chartInfo != nil {
		//判断是否加入我的图库
		{
			var myChartCondition string
			var myChartPars []interface{}
			myChartCondition += ` AND a.admin_id=? `
			myChartPars = append(myChartPars, sysUser.AdminId)
			myChartCondition += ` AND a.chart_info_id=? `
			myChartPars = append(myChartPars, chartInfo.ChartInfoId)

			myChartList, err := data_manage.GetMyChartByCondition(myChartCondition, myChartPars)
			if err != nil && err.Error() != utils.ErrNoRow() {
				msg = "获取失败"
				errMsg = "获取我的图表信息失败，GetMyChartByCondition，Err:" + err.Error()
				return
			}
			if myChartList != nil && len(myChartList) > 0 {
				chartInfo.IsAdd = true
				chartInfo.MyChartId = myChartList[0].MyChartId
				chartInfo.MyChartClassifyId = myChartList[0].MyChartClassifyId
			}
		}
	}

	//图表操作权限
	chartInfo.IsEdit = data.CheckOpChartPermission(sysUser, chartInfo.SysUserId, true)
	//判断是否需要展示英文标识
	chartInfo.IsEnChart = data.CheckIsEnChart(chartInfo.ChartNameEn, edbList[0:1], chartInfo.Source, chartInfo.ChartType)
	chartInfo.UnitEn = ""

	// 另存为
	chartInfo.Button = data_manage.ChartViewButton{
		IsEdit:    chartInfo.IsEdit,
		IsEnChart: chartInfo.IsEnChart,
		IsAdd:     chartInfo.IsAdd,
		IsCopy:    chartInfo.IsEdit,
		IsSetName: chartInfo.IsSetName,
	}

	// 图表的指标来源
	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
	resp.Status = true

	// 遍历到校验map
	for _, v := range edbList {
		edbClassifyPermissionMap[v.EdbInfoId] = data_manage_permission.EdbClassifyPermission{
			ClassifyId:       v.ClassifyId,
			IsJoinPermission: v.IsJoinPermission,
			EdbInfoId:        v.EdbInfoId,
		}
	}

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

// List
// @Title 区间计算图表列表接口
// @Description 区间计算图表列表接口
// @Param   PageSize   query   int  true       "每页数据条数"
// @Param   CurrentIndex   query   int  true       "当前页页码，从1开始"
// @Param   ChartClassifyId   query   int  true       "分类id"
// @Param   Keyword   query   string  true       "搜索关键词"
// @Param   IsShowMe   query   bool  true       "是否只看我的，true、false"
// @Param   Source   query   int  true       "图表类型，3：区间计算，4：滚动区间计算"
// @Success 200 {object} data_manage.ChartListResp
// @router /chart_info/list [get]
func (this *RangeChartChartInfoController) List() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	sysUser := this.SysUser
	if sysUser == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}

	chartClassifyId, _ := this.GetInt("ChartClassifyId")

	pageSize, _ := this.GetInt("PageSize")
	currentIndex, _ := this.GetInt("CurrentIndex")
	keyword := this.GetString("KeyWord")

	var total int
	page := paging.GetPaging(currentIndex, pageSize, total)

	var startSize int
	if pageSize <= 0 {
		pageSize = utils.PageSize20
	}
	if currentIndex <= 0 {
		currentIndex = 1
	}
	startSize = paging.StartIndex(currentIndex, pageSize)

	source := utils.CHART_SOURCE_RANGE_ANALYSIS

	var condition string
	var pars []interface{}

	// 普通图表
	condition += ` AND source = ? `
	pars = append(pars, source)

	if chartClassifyId > 0 {
		chartClassifyId, err := data_manage.GetChartClassify(chartClassifyId)
		if err != nil && err.Error() != utils.ErrNoRow() {
			br.Msg = "获取图表信息失败"
			br.ErrMsg = "获取信息失败,GetChartClassify,Err:" + err.Error()
			return
		}
		condition += " AND chart_classify_id IN(" + chartClassifyId + ") "
	}
	if keyword != "" {
		condition += ` AND  ( chart_name LIKE '%` + keyword + `%' )`
	}

	//只看我的
	isShowMe, _ := this.GetBool("IsShowMe")
	if isShowMe {
		condition += ` AND sys_user_id = ? `
		pars = append(pars, sysUser.AdminId)
	}

	// 获取当前账号的不可见指标
	noPermissionChartIdList := make([]int, 0)
	{
		obj := data_manage.EdbInfoNoPermissionAdmin{}
		confList, err := obj.GetAllChartListByAdminId(this.SysUser.AdminId)
		if err != nil && err.Error() != utils.ErrNoRow() {
			br.Msg = "获取失败"
			br.ErrMsg = "获取不可见指标配置数据失败，Err:" + err.Error()
			return
		}
		for _, v := range confList {
			noPermissionChartIdList = append(noPermissionChartIdList, v.ChartInfoId)
		}
	}

	lenNoPermissionChartIdList := len(noPermissionChartIdList)
	if lenNoPermissionChartIdList > 0 {
		condition += ` AND chart_info_id not in (` + utils.GetOrmInReplace(lenNoPermissionChartIdList) + `) `
		pars = append(pars, noPermissionChartIdList)
	}

	//获取图表信息
	list, err := data_manage.GetChartListByCondition(condition, pars, startSize, pageSize)
	if err != nil && err.Error() != utils.ErrNoRow() {
		br.Success = true
		br.Msg = "获取图表信息失败"
		br.ErrMsg = "获取图表信息失败,Err:" + err.Error()
		return
	}

	myChartList, err := data_manage.GetMyChartListByAdminId(sysUser.AdminId)
	if err != nil && err.Error() != utils.ErrNoRow() {
		br.Msg = "获取图表信息失败"
		br.ErrMsg = "获取我的图表信息失败,Err:" + err.Error()
		return
	}
	myChartMap := make(map[int]*data_manage.MyChartView)
	for _, v := range myChartList {
		myChartMap[v.ChartInfoId] = v
	}
	listLen := len(list)
	chartEdbMap := make(map[int][]*data_manage.ChartEdbInfoMapping)
	if listLen > 0 {
		chartInfoIds := ""
		for _, v := range list {
			chartInfoIds += strconv.Itoa(v.ChartInfoId) + ","
		}
		if chartInfoIds != "" {
			chartInfoIds = strings.Trim(chartInfoIds, ",")
			//判断是否需要展示英文标识
			edbList, e := data_manage.GetChartEdbMappingListByChartInfoIds(chartInfoIds)
			if e != nil {
				br.Msg = "获取失败"
				br.ErrMsg = "获取图表，指标信息失败，Err:" + e.Error()
				return
			}
			for _, v := range edbList {
				chartEdbMap[v.ChartInfoId] = append(chartEdbMap[v.ChartInfoId], v)
			}
		}
	}
	for i := 0; i < listLen; i++ {
		//判断是否需要展示英文标识
		if edbTmpList, ok := chartEdbMap[list[i].ChartInfoId]; ok {
			list[i].IsEnChart = data.CheckIsEnChart(list[i].ChartNameEn, edbTmpList, list[i].Source, list[i].ChartType)
		}

		if existItem, ok := myChartMap[list[i].ChartInfoId]; ok {
			list[i].IsAdd = true
			list[i].MyChartId = existItem.MyChartId
			list[i].MyChartClassifyId = existItem.MyChartClassifyId
		}
	}

	resp := new(data_manage.ChartListResp)
	if list == nil || len(list) <= 0 || (err != nil && err.Error() == utils.ErrNoRow()) {
		items := make([]*data_manage.ChartInfoView, 0)
		resp.Paging = page
		resp.List = items
		br.Ret = 200
		br.Success = true
		br.Msg = "获取成功"
		return
	}

	dataCount, err := data_manage.GetChartListCountByCondition(condition, pars)
	if err != nil && err.Error() != utils.ErrNoRow() {
		br.Msg = "获取指标信息失败"
		br.ErrMsg = "获取指标数据总数失败,Err:" + err.Error()
		return
	}
	page = paging.GetPaging(currentIndex, pageSize, dataCount)
	resp.Paging = page
	resp.List = list
	br.Ret = 200
	br.Success = true
	br.Msg = "获取成功"
	br.Data = resp
}

// Copy
// @Title 复制并新增图表接口
// @Description 新增图表接口
// @Params	request	body data_manage.CopyAddChartInfoReq true "type json string"
// @Success 200 {object} data_manage.AddChartInfoResp
// @router /chart_info/copy [post]
func (this *RangeChartChartInfoController) Copy() {
	br := new(models.BaseResponse).Init()
	defer func() {
		if br.ErrMsg == "" {
			br.IsSendEmail = false
		}
		this.Data["json"] = br
		this.ServeJSON()
	}()
	sysUser := this.SysUser
	if sysUser == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}
	var req data_manage.CopyAddChartInfoReq
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}
	if req.ChartInfoId <= 0 {
		br.Msg = "参数有误"
		br.ErrMsg = fmt.Sprintf("参数有误, ChartInfoId: %d", req.ChartInfoId)
		return
	}
	req.ChartName = strings.TrimSpace(req.ChartName)
	if req.ChartName == "" {
		br.Msg = "请输入图表名称"
		return
	}
	if req.ChartClassifyId <= 0 {
		br.Msg = "请选择图表分类"
		return
	}

	deleteCache := true
	cacheKey := "CACHE_CHART_INFO_ADD_" + strconv.Itoa(sysUser.AdminId)
	defer func() {
		if deleteCache {
			utils.Rc.Delete(cacheKey)
		}
	}()
	if !utils.Rc.SetNX(cacheKey, 1, 30*time.Second) {
		deleteCache = false
		br.Msg = "系统处理中，请稍后重试！"
		br.ErrMsg = "系统处理中，请稍后重试！" + sysUser.RealName + ";data:" + string(this.Ctx.Input.RequestBody)
		return
	}

	chartSource := utils.CHART_SOURCE_RANGE_ANALYSIS
	// 校验分类、图表名称
	{
		var cond string
		var pars []interface{}
		switch this.Lang {
		case utils.EnLangVersion:
			cond += " AND chart_name_en = ? AND source = ? "
		default:
			cond += " AND chart_name = ? AND source = ? "
		}
		pars = append(pars, req.ChartName, chartSource)
		count, e := data_manage.GetChartInfoCountByCondition(cond, pars)
		if e != nil {
			br.Msg = "保存失败"
			br.ErrMsg = fmt.Sprintf("获取同名图表失败, Err: %v", e)
			return
		}
		if count > 0 {
			br.Msg = "图表名称已存在, 请重新填写"
			return
		}

		_, e = data_manage.GetChartClassifyById(req.ChartClassifyId)
		if e != nil {
			if e.Error() == utils.ErrNoRow() {
				br.Msg = "分类不存在"
				return
			}
			br.Msg = "保存失败"
			br.ErrMsg = fmt.Sprintf("获取图表分类失败, Err: %v", e)
			return
		}
	}

	// 图表信息
	originChart, e := data_manage.GetChartInfoById(req.ChartInfoId)
	if e != nil {
		if e.Error() == utils.ErrNoRow() {
			br.Msg = "原图表不存在"
			return
		}
		br.Msg = "保存失败"
		br.ErrMsg = fmt.Sprintf("获取原图表信息失败, Err: %v", e)
		return
	}
	if originChart.Source == utils.CHART_SOURCE_ROLLING_CORRELATION {
		br.Msg = `滚动区间计算图不支持另存为`
		br.IsSendEmail = false
		return
	}

	// 普通区间计算图表
	chartInfo := new(data_manage.ChartInfo)

	newChart, err, errMsg, isSendEmail := rangeServ.CopyChartInfo(req.ChartClassifyId, req.ChartName, originChart, sysUser, this.Lang)
	chartInfo = newChart

	if err != nil {
		br.Msg = "保存失败"
		if errMsg != `` {
			br.Msg = errMsg
		}
		br.ErrMsg = err.Error()
		br.IsSendEmail = isSendEmail
		return
	}

	// 新增操作日志
	{
		chartLog := new(data_manage.ChartInfoLog)
		chartLog.ChartInfoId = chartInfo.ChartInfoId
		chartLog.ChartName = req.ChartName
		chartLog.ChartClassifyId = req.ChartClassifyId
		chartLog.SysUserId = sysUser.AdminId
		chartLog.SysUserRealName = sysUser.RealName
		chartLog.UniqueCode = chartInfo.UniqueCode
		chartLog.CreateTime = time.Now()
		chartLog.Content = string(this.Ctx.Input.RequestBody)
		chartLog.Status = "复制区间计算图表"
		chartLog.Method = this.Ctx.Input.URI()
		go data_manage.AddChartInfoLog(chartLog)
	}

	br.Ret = 200
	br.Success = true
	br.Msg = "保存成功"
	br.Data = data_manage.AddChartInfoResp{
		ChartInfoId: chartInfo.ChartInfoId,
		UniqueCode:  chartInfo.UniqueCode,
		ChartType:   chartInfo.ChartType,
	}
	br.IsAddLog = true
}

// Refresh
// @Title 图表刷新接口
// @Description 图表刷新接口
// @Param   ChartInfoId   query   int  true       "图表id"
// @Param   UniqueCode   query   string  true       "唯一code"
// @Success Ret=200 刷新成功
// @router /chart_info/refresh [get]
func (this *RangeChartChartInfoController) Refresh() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	sysUser := this.SysUser
	if sysUser == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}
	chartInfoId, _ := this.GetInt("ChartInfoId")
	uniqueCode := this.GetString("UniqueCode")
	if chartInfoId <= 0 && uniqueCode == `` {
		br.Msg = "参数错误"
		br.ErrMsg = "参数错误:chartInfoId:" + strconv.Itoa(chartInfoId) + ",UniqueCode:" + uniqueCode
		return
	}

	var chartInfo *data_manage.ChartInfo
	var err error
	if chartInfoId > 0 {
		chartInfo, err = data_manage.GetChartInfoById(chartInfoId)
	} else {
		chartInfo, err = data_manage.GetChartInfoByUniqueCode(uniqueCode)
	}
	if err != nil {
		if err.Error() == utils.ErrNoRow() {
			br.Msg = "图表已被删除，无需刷新"
			br.ErrMsg = "获取指标信息失败，Err:" + err.Error()
			return
		}
		br.Msg = "刷新失败"
		br.ErrMsg = "获取图表信息失败，Err:" + err.Error()
		return
	}

	// 刷新区间计算图表
	isAsync, e := rangeServ.ChartInfoRefresh(chartInfo.ChartInfoId, chartInfo.UniqueCode)
	if e != nil {
		br.Msg = "刷新失败"
		br.ErrMsg = "刷新区间计算图表失败, Err:" + err.Error()
		return
	}
	// 多因子区间计算异步刷新, 前端提示
	if isAsync {
		br.Ret = 200
		br.Success = true
		br.Msg = "刷新时间较长, 请10分钟后查看"
		return
	}

	//清除图表缓存
	{
		key := utils.HZ_CHART_LIB_DETAIL + chartInfo.UniqueCode
		_ = utils.Rc.Delete(key)
	}

	br.Ret = 200
	br.Success = true
	br.Msg = "刷新成功"
}

// MultipleGraphConfigSaveEdb
// @Title 保存指标接口
// @Description 保存指标接口
// @Param	request	body request.SaveMultipleGraphEdbReq true "type json string"
// @Success Ret=200 返回指标id
// @router /edb/save [post]
func (this *RangeChartChartInfoController) MultipleGraphConfigSaveEdb() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()

	sysUser := this.SysUser
	if sysUser == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}

	var req data_manage.SaveChartRangeAnalysisEdbReq
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}
	cacheKey := "CACHE_CHART_EDB_INFO_ADD_" + strconv.Itoa(sysUser.AdminId)
	if !utils.Rc.SetNX(cacheKey, 1, 30*time.Second) {
		br.Msg = "系统处理中，请稍后重试！"
		br.ErrMsg = "系统处理中，请稍后重试！" + sysUser.RealName + ";data:" + string(this.Ctx.Input.RequestBody)
		return
	}
	defer func() {
		_ = utils.Rc.Delete(cacheKey)
	}()
	edbInfoIds := make([]int, 0)
	for _, v := range req.EdbInfoList {
		edbInfoIds = append(edbInfoIds, v.FromEdbInfoId)
	}
	mappingList, err := data_manage.GetChartEdbMappingListByEdbInfoIdList(edbInfoIds)
	if err != nil {
		br.Msg = "获取失败"
		br.ErrMsg = "获取图表，指标信息失败，Err:" + err.Error()
		return
	}
	edbInfoMap := make(map[int]*data_manage.ChartEdbInfoMapping, 0)
	for _, v := range mappingList {
		edbInfoMap[v.EdbInfoId] = v
	}

	for _, v := range req.EdbInfoList {
		if _, ok := edbInfoMap[v.FromEdbInfoId]; !ok {
			br.Msg = "指标信息不存在"
			br.ErrMsg = "指标信息不存在，EdbInfoId:" + strconv.Itoa(v.FromEdbInfoId)
			br.IsSendEmail = false
			return
		}
	}
	// 区间计算图表配置校验
	/*var extraConfig string
	extraConfigByte, err := json.Marshal(req.ExtraConfig)
	if err != nil {
		br.Msg = "配置信息错误"
		br.ErrMsg = "配置信息错误, Err: " + err.Error()
		return
	}*/
	extraConfig := req.ExtraConfig
	// todo 校验配置合法性
	multipleGraphConfigEdbMappingList, err := data_manage.GetMultipleGraphConfigEdbMappingListByIdAndSource(req.MultipleGraphConfigId, utils.CHART_SOURCE_RANGE_ANALYSIS)
	if err != nil {
		br.Msg = `保存失败`
		br.ErrMsg = "查询配置与图表的关联关系失败，ERR:" + err.Error()
		return
	}
	deleteEdbInfoIds := make([]int, 0) // 需要解除绑定的指标ID
	fromEdbMap := make(map[int]int)
	configMapping := make(map[int]*data_manage.MultipleGraphConfigEdbMapping, 0)
	if len(multipleGraphConfigEdbMappingList) == 0 || req.IsSaveAs {
		// 需要新增的指标
	} else {
		// 需要更新的指标
		// 查询原先所有指标的来源指标，进一步筛选出需要新增，或者更新 或者删除的指标
		oldEdbInfoIds := make([]int, 0)
		for _, v := range multipleGraphConfigEdbMappingList {
			configMapping[v.EdbInfoId] = v
			oldEdbInfoIds = append(oldEdbInfoIds, v.EdbInfoId)
		}

		oldEdbCalculateMappingList, e := data_manage.GetEdbInfoCalculateMappingListByEdbInfoIds(oldEdbInfoIds)
		if e != nil {
			br.Msg = `保存失败`
			br.ErrMsg = "获取计算指标信息失败，ERR:" + e.Error()
			return
		}

		// 说明指标还在，没有被删除
		for _, v := range oldEdbCalculateMappingList {
			fromEdbMap[v.FromEdbInfoId] = v.EdbInfoId
			if !utils.InArrayByInt(edbInfoIds, v.FromEdbInfoId) {
				deleteEdbInfoIds = append(deleteEdbInfoIds, v.EdbInfoId)
			}
		}
	}
	resp := data_manage.BatchEdbInfoCalculateBatchSaveResp{
		Fail:    make([]data_manage.BatchEdbInfoCalculateBatchSaveFailResp, 0),
		Success: make([]data_manage.BatchEdbInfoCalculateBatchSaveSuccessResp, 0),
	}
	// 普通指标批量新增\批量编辑
	var saveReq data_manage.BatchEdbInfoCalculateBatchSaveReq
	calculateEdbList := make([]data_manage.BatchEdbInfoCalculateBatchSaveSuccessResp, 0)
	reqEdbList := make([]*data_manage.CalculateEdbInfoItem, 0)
	for _, v := range req.EdbInfoList {
		/*if edbInfoId, ok := fromEdbMap[v.EdbInfoId]; ok {
			v.EdbInfoId = edbInfoId
		}*/
		v.CalculateId = strconv.Itoa(v.FromEdbInfoId)
		v.EdbName = strings.Trim(v.EdbName, " ")
		if v.EdbName == "" {
			resp.Fail = append(resp.Fail, data_manage.BatchEdbInfoCalculateBatchSaveFailResp{
				CalculateId: v.CalculateId,
				Msg:         "指标名称不能为空",
			})
			continue
		}

		if v.Frequency == "" {
			resp.Fail = append(resp.Fail, data_manage.BatchEdbInfoCalculateBatchSaveFailResp{
				CalculateId: v.CalculateId,
				Msg:         "频率不能为空",
			})
			continue
		}

		if v.Unit == "" {
			resp.Fail = append(resp.Fail, data_manage.BatchEdbInfoCalculateBatchSaveFailResp{
				CalculateId: v.CalculateId,
				Msg:         "单位不能为空",
			})
			continue
		}

		if v.ClassifyId <= 0 {
			resp.Fail = append(resp.Fail, data_manage.BatchEdbInfoCalculateBatchSaveFailResp{
				CalculateId: v.CalculateId,
				Msg:         "请选择分类",
			})
			continue
		}

		//加入缓存机制，避免创建同一个名称的指标 start
		redisKey := fmt.Sprint("edb_info:calculate:batch:save:", utils.DATA_SOURCE_CALCULATE_RANGEANLYSIS, ":", v.EdbName)
		//加入缓存机制，避免创建同一个名称的指标 start
		if req.EdbInfoType == 1 {
			redisKey = fmt.Sprint("predict_edb_info:calculate:batch:save:", sysUser.AdminId, ":", utils.DATA_SOURCE_CALCULATE_RANGEANLYSIS, ":", v.CalculateId)
		}
		isExist := utils.Rc.IsExist(redisKey)
		if isExist {
			resp.Fail = append(resp.Fail, data_manage.BatchEdbInfoCalculateBatchSaveFailResp{
				CalculateId: strconv.Itoa(v.FromEdbInfoId),
				Msg:         "指标正在处理,请勿重复提交",
			})
			continue
		} else {
		}
		reqEdbList = append(reqEdbList, v)
	}
	if len(reqEdbList) <= 0 {
		br.Msg = "新增失败！"
		if len(resp.Fail) > 0 {
			br.ErrMsg = resp.Fail[0].Msg
		} else {
			br.Msg = "请选择指标"
		}
		return
	}
	if req.EdbInfoType == 0 { //普通指标
		saveReq.Source = utils.DATA_SOURCE_CALCULATE_RANGEANLYSIS
		saveReq.CalculateFormula = extraConfig
		saveReq.AdminId = sysUser.AdminId
		saveReq.AdminName = sysUser.RealName
		saveReq.EdbList = reqEdbList
		// 调用指标库去更新
		reqJson, err := json.Marshal(saveReq)
		if err != nil {
			br.Msg = "参数解析异常！"
			br.ErrMsg = "参数解析失败，Err:" + err.Error()
			return
		}
		respItem, err := data.BatchSaveEdbCalculateMultiData(string(reqJson), this.Lang)
		if err != nil {
			br.Msg = "新增失败！"
			br.ErrMsg = "新增失败，Err:" + err.Error()
			return
		}
		if respItem.Ret != 200 {
			br.Msg = respItem.Msg
			br.ErrMsg = respItem.ErrMsg
			return
		}
		resp = respItem.Data
		calculateEdbList = respItem.Data.Success
	} else if req.EdbInfoType == 1 {
		// 预测指标
		for _, v := range req.EdbInfoList {
			predictReq := new(data_manage.PredictEdbInfoCalculateBatchSaveReq)
			predictReq.EdbInfoId = v.EdbInfoId
			predictReq.CalculateFormula = extraConfig
			predictReq.EdbName = v.EdbName
			predictReq.Frequency = v.Frequency
			predictReq.Unit = v.Unit
			predictReq.ClassifyId = v.ClassifyId
			predictReq.FromEdbInfoId = v.FromEdbInfoId
			predictReq.AdminId = sysUser.AdminId
			predictReq.AdminName = sysUser.RealName
			predictReq.Source = utils.DATA_SOURCE_PREDICT_CALCULATE_RANGEANLYSIS
			reqJson, err := json.Marshal(predictReq)
			if err != nil {
				br.Msg = "参数解析异常！"
				br.ErrMsg = "参数解析失败，Err:" + err.Error()
				return
			}
			respItem, err := data.BatchSavePredictEdbData(string(reqJson), this.Lang)
			if err != nil {
				resp.Fail = append(resp.Fail, data_manage.BatchEdbInfoCalculateBatchSaveFailResp{
					CalculateId: v.CalculateId,
					Msg:         "新增失败！",
					ErrMsg:      "新增失败，Err:" + err.Error(),
				})
				continue
			}
			if respItem.Ret != 200 {
				resp.Fail = append(resp.Fail, data_manage.BatchEdbInfoCalculateBatchSaveFailResp{
					CalculateId: v.CalculateId,
					Msg:         respItem.Msg,
					ErrMsg:      respItem.ErrMsg,
				})
				continue
			}

			calculateEdbList = append(calculateEdbList, data_manage.BatchEdbInfoCalculateBatchSaveSuccessResp{
				CalculateId: v.CalculateId,
				EdbInfoId:   respItem.Data.EdbInfoId,
				UniqueCode:  respItem.Data.UniqueCode,
				ClassifyId:  predictReq.ClassifyId,
			})
		}
	}

	// 批量删除
	if len(deleteEdbInfoIds) > 0 {
		err = data_manage.DeleteMultipleGraphConfigEdbMappingByEdbIds(req.MultipleGraphConfigId, utils.CHART_SOURCE_RANGE_ANALYSIS, deleteEdbInfoIds)
		if err != nil {
			br.Msg = "更新失败！"
			br.ErrMsg = "删除失败，Err:" + err.Error()
			return
		}
	}

	// 如果不是另存为的话，那么需要建立配置与指标的关系
	if !req.IsSaveAs {
		// 如果指标没有建立关联关系，那么就需要添加关系
		configEdbMappingList := make([]*data_manage.MultipleGraphConfigEdbMapping, 0)
		for _, v := range calculateEdbList {
			item, ok := configMapping[v.EdbInfoId]
			if !ok {
				multipleGraphConfigEdbMapping := &data_manage.MultipleGraphConfigEdbMapping{
					//Id:                    0,
					MultipleGraphConfigId: req.MultipleGraphConfigId,
					EdbInfoId:             v.EdbInfoId,
					Source:                utils.CHART_SOURCE_RANGE_ANALYSIS,
					ModifyTime:            time.Now(),
					CreateTime:            time.Now(),
				}
				configEdbMappingList = append(configEdbMappingList, multipleGraphConfigEdbMapping)
			} else {
				item.ModifyTime = time.Now()
				err = item.Update([]string{"ModifyTime"})
				if err != nil {
					br.Msg = "保存失败"
					br.ErrMsg = "保存配置与指标的关联关系失败，ERR:" + err.Error()
					return
				}
			}
			if len(configEdbMappingList) > 0 {
				err = data_manage.AddMultipleGraphConfigEdbMappingList(configEdbMappingList)
				if err != nil {
					br.Msg = "保存失败"
					br.ErrMsg = "保存配置与指标的关联关系失败，ERR:" + err.Error()
					return
				}
			}
		}
	}
	resp.Success = calculateEdbList
	br.Ret = 200
	br.Success = true
	br.Msg = "保存成功"
	br.Data = resp
	br.IsAddLog = true
}

// MultipleGraphConfigEdbList
// @Title 获取指标列表接口
// @Description 获取指标列表接口
// @Param	request	body request.SaveMultipleGraphEdbReq true "type json string"
// @Success Ret=200 返回指标id
// @router /edb/list [get]
func (this *RangeChartChartInfoController) MultipleGraphConfigEdbList() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()

	sysUser := this.SysUser
	if sysUser == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}

	multipleGraphConfigId, _ := this.GetInt("MultipleGraphConfigId")
	if multipleGraphConfigId <= 0 {
		br.Msg = "参数错误"
		br.ErrMsg = "参数错误，MultipleGraphConfigId Is Empty"
		return
	}

	list := make([]*data_manage.ChartRangeAnalysisConfigEdbItem, 0)
	resp := data_manage.ChartRangeAnalysisConfigEdbResp{EdbInfoList: list}

	multipleGraphConfigEdbMappingList, err := data_manage.GetMultipleGraphConfigEdbMappingListByIdAndSource(multipleGraphConfigId, utils.CHART_SOURCE_RANGE_ANALYSIS)
	if err != nil {
		br.Msg = `保存失败`
		br.ErrMsg = "查询配置与图表的关联关系失败，ERR:" + err.Error()
		return
	}
	if len(multipleGraphConfigEdbMappingList) == 0 {
		br.Ret = 200
		br.Success = true
		br.Msg = "操作成功"
		br.Data = resp
		br.IsAddLog = true
		return
	}

	edbInfoIds := make([]int, 0)
	for _, v := range multipleGraphConfigEdbMappingList {
		edbInfoIds = append(edbInfoIds, v.EdbInfoId)
	}
	edbList, err := data_manage.GetChartEdbMappingListByEdbInfoIdList(edbInfoIds)
	if err != nil {
		br.Msg = "获取失败"
		br.ErrMsg = "获取图表，指标信息失败，Err:" + err.Error()
		return
	}
	edbInfoMap := make(map[int]*data_manage.ChartEdbInfoMapping, 0)
	for _, v := range edbList {
		edbInfoMap[v.EdbInfoId] = v
	}

	edbCalculateMappingList, e := data_manage.GetEdbInfoCalculateMappingListByEdbInfoIds(edbInfoIds)
	if e != nil {
		br.Msg = `保存失败`
		br.ErrMsg = "获取计算指标信息失败，ERR:" + e.Error()
		return
	}

	// 说明指标还在，没有被删除
	for _, v := range edbCalculateMappingList {
		tmp := new(data_manage.ChartRangeAnalysisConfigEdbItem)
		info, ok := edbInfoMap[v.EdbInfoId]
		if ok {
			tmp.EdbInfoId = v.EdbInfoId
			tmp.Unit = info.Unit
			tmp.UnitEn = info.UnitEn
			tmp.Frequency = info.Frequency
			tmp.EdbNameEn = info.EdbNameEn
			tmp.EdbName = info.EdbName
			tmp.ClassifyId = info.ClassifyId
			tmp.FromEdbInfoId = v.FromEdbInfoId
			tmp.EdbTypeInfo = info.EdbInfoCategoryType
			list = append(list, tmp)
		}
	}
	resp.EdbInfoList = list

	br.Ret = 200
	br.Success = true
	br.Msg = "保存成功"
	br.Data = resp
	br.IsAddLog = true
}