eta_api/controllers/data_manage/line_feature/chart_info.go

package line_feature

import (
	"encoding/json"
	"errors"
	"eta/eta_api/controllers"
	"eta/eta_api/models"
	"eta/eta_api/models/data_manage"
	"eta/eta_api/models/data_manage/line_feature/request"
	"eta/eta_api/models/data_manage/line_feature/response"
	"eta/eta_api/models/system"
	"eta/eta_api/services/alarm_msg"
	"eta/eta_api/services/data"
	"eta/eta_api/services/data/data_manage_permission"
	lineFeatureServ "eta/eta_api/services/data/line_feature"
	"eta/eta_api/utils"
	"fmt"
	"strconv"
	"strings"
	"time"

	"github.com/rdlucklib/rdluck_tools/paging"
)

// LineFeaturesChartInfoController 统计特征图表管理
type LineFeaturesChartInfoController struct {
	controllers.BaseAuthController
}

// MultipleGraphConfigSave
// @Title 保存配置接口
// @Description 保存配置接口
// @Param	request	body request.SaveMultipleGraphConfigReq true "type json string"
// @Success Ret=200 返回图表id
// @router /config/save [post]
func (this *LineFeaturesChartInfoController) MultipleGraphConfigSave() {
	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 request.SaveMultipleGraphConfigReq
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}

	if req.EdbInfoId <= 0 {
		br.Msg = "指标未选择"
		br.IsSendEmail = false
		return
	}
	_, err = data_manage.GetEdbInfoById(req.EdbInfoId)
	if err != nil {
		br.Msg = "指标A异常"
		br.ErrMsg = "指标A异常,err:" + err.Error()
		if err.Error() == utils.ErrNoRow() {
			br.Msg = `指标A不存在`
			br.IsSendEmail = false
		}
		return
	}

	configSave := request.ConfigSave{
		Curve:                 req.Curve,
		StandardDeviation:     req.StandardDeviation,
		Percentile:            req.Percentile,
		FrequencyDistribution: req.FrequencyDistribution,
	}
	configSaveStrByte, err := json.Marshal(configSave)
	if err != nil {
		br.Msg = `相关性配置异常`
		br.ErrMsg = `相关性配置异常,ERR:` + err.Error()
		return
	}

	var multipleGraphConfig *data_manage.MultipleGraphConfig
	if req.MultipleGraphConfigId > 0 {
		multipleGraphConfig, err = data_manage.GetMultipleGraphConfigById(req.MultipleGraphConfigId)
		if err != nil {
			br.Msg = `不存在该配置`
			br.ErrMsg = `不存在该配置`
			return
		}
		multipleGraphConfig.EdbInfoIdA = req.EdbInfoId
		multipleGraphConfig.Curve = string(configSaveStrByte)
		multipleGraphConfig.ModifyTime = time.Now()
		err = multipleGraphConfig.Update([]string{"EdbInfoIdA", "Curve", "ModifyTime"})
	} else {
		multipleGraphConfig = &data_manage.MultipleGraphConfig{
			//MultipleGraphConfigId: 0,
			EdbInfoIdA:      req.EdbInfoId,
			Curve:           string(configSaveStrByte),
			SysUserId:       this.SysUser.AdminId,
			SysUserRealName: this.SysUser.RealName,
			ModifyTime:      time.Now(),
			CreateTime:      time.Now(),
		}
		err = data_manage.AddMultipleGraphConfig(multipleGraphConfig)
	}
	if err != nil {
		br.Msg = `保存失败`
		br.ErrMsg = `保存失败，Err:` + err.Error()
		return
	}

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

// MultipleGraphPreview
// @Title 批量添加图表的预览接口
// @Description 批量添加图表的预览接口
// @Param	request	body request.SaveMultipleGraphConfigReq true "type json string"
// @Success Ret=200 返回图表id
// @router /preview [post]
func (this *LineFeaturesChartInfoController) MultipleGraphPreview() {
	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 request.SaveMultipleGraphConfigReq
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}

	edbInfoMapping, err := data_manage.GetChartEdbMappingByEdbInfoId(req.EdbInfoId)
	if err != nil {
		br.Msg = "获取失败"
		br.ErrMsg = "获取图表，指标信息失败，Err:" + err.Error()
		return
	}
	if edbInfoMapping == nil {
		br.Msg = "指标不存在"
		br.IsSendEmail = false
		return
	}

	resp := response.PreviewMultipleGraphConfigResp{}

	chartInfo := new(data_manage.ChartInfoView)
	chartInfo.Calendar = `公历`
	chartInfo.ChartName = edbInfoMapping.EdbName

	// 曲线图表信息
	curveConf := req.Curve
	var maxDate time.Time
	if edbInfoMapping.LatestDate != "" {
		latestDateT, _ := time.Parse(utils.FormatDate, edbInfoMapping.LatestDate)
		maxDate = latestDateT
	}
	startDate, endDate := utils.GetDateByDateTypeV2(curveConf.DateType, curveConf.StartDate, curveConf.EndDate, curveConf.StartYear, maxDate)
	{
		tmpChartInfo := *chartInfo
		// 获取图表中的指标数据
		edbList, _, _, _, err, errMsg := data.GetChartEdbData(tmpChartInfo.ChartInfoId, tmpChartInfo.ChartType, tmpChartInfo.Calendar, startDate, endDate, []*data_manage.ChartEdbInfoMapping{edbInfoMapping}, tmpChartInfo.ExtraConfig, tmpChartInfo.SeasonExtraConfig)
		if err != nil {
			br.Msg = "获取失败"
			if errMsg != `` {
				br.Msg = errMsg
			}
			br.ErrMsg = "获取图表，指标信息失败，Err:" + err.Error()
			return
		}
		warnEdbList := make([]string, 0)

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

			chartEdbInfoMapping := *v
			chartEdbInfoMapping.IsOrder = false
			chartEdbInfoMapping.IsAxis = 1
			chartEdbInfoMapping.MinData = curveConf.LeftMin
			chartEdbInfoMapping.MaxData = curveConf.LeftMax
			chartEdbInfoMapping.ChartColor = `#00F`
			chartEdbInfoMapping.ChartWidth = 3
			chartEdbInfoMapping.EdbInfoType = 1
			tmpEdbList = append(tmpEdbList, chartEdbInfoMapping)
		}
		if len(warnEdbList) > 0 {
			tmpChartInfo.WarnMsg = `图表引用指标异常，异常指标：` + strings.Join(warnEdbList, "，")
		}

		tmpChartInfo.Source = utils.CHART_SOURCE_DEFAULT
		tmpChartInfo.DateType = curveConf.DateType
		tmpChartInfo.StartDate = startDate
		tmpChartInfo.EndDate = endDate
		tmpChartInfo.ChartType = utils.CHART_TYPE_CURVE

		resp.CurveData = response.CurveResp{
			ChartInfo:   tmpChartInfo,
			EdbInfoList: tmpEdbList,
		}
	}

	// 标准差图表信息
	{
		// 配置了数据才有返回
		if req.StandardDeviation.CalculateValue > 0 {
			tmpChartInfo := *chartInfo
			tmpChartInfo.ChartName = fmt.Sprintf("%s%d期滚动标准差", edbInfoMapping.EdbName, req.StandardDeviation.CalculateValue)

			// 获取图表中的指标数据
			edbList, dataResp, err, errMsg := lineFeatureServ.GetStandardDeviationData(0, startDate, endDate, edbInfoMapping, req.StandardDeviation.CalculateValue)
			if err != nil {
				br.Msg = "获取失败"
				if errMsg != `` {
					br.Msg = errMsg
				}
				br.ErrMsg = "获取图表，指标信息失败，Err:" + err.Error()
				return
			}
			warnEdbList := make([]string, 0)

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

				chartEdbInfoMapping := *v
				chartEdbInfoMapping.IsOrder = false
				chartEdbInfoMapping.IsAxis = 1
				//chartEdbInfoMapping.MinData = curveConf.LeftMin
				//chartEdbInfoMapping.MaxData = curveConf.LeftMax
				chartEdbInfoMapping.ChartColor = `#00F`
				chartEdbInfoMapping.ChartWidth = 3
				chartEdbInfoMapping.EdbInfoType = 1
				tmpEdbList = append(tmpEdbList, chartEdbInfoMapping)
			}
			if len(warnEdbList) > 0 {
				tmpChartInfo.WarnMsg = `图表引用指标异常，异常指标：` + strings.Join(warnEdbList, "，")
			}

			tmpChartInfo.Source = utils.CHART_SOURCE_LINE_FEATURE_STANDARD_DEVIATION
			//tmpChartInfo.DateType = curveConf.DateType
			//tmpChartInfo.StartDate = startDate
			//tmpChartInfo.EndDate = endDate
			tmpChartInfo.ChartType = utils.CHART_TYPE_CURVE

			resp.StandardDeviationData = response.CurveResp{
				ChartInfo:   tmpChartInfo,
				EdbInfoList: tmpEdbList,
				DataResp:    dataResp,
			}
		}

	}

	// 百分位图表信息
	{
		// 配置了数据才有返回
		if req.Percentile.CalculateValue > 0 && req.Percentile.CalculateUnit != `` {
			tmpChartInfo := *chartInfo
			tmpChartInfo.ChartName = fmt.Sprintf("%s%d%s百分位", edbInfoMapping.EdbName, req.Percentile.CalculateValue, req.Percentile.CalculateUnit)

			// 获取图表中的指标数据
			edbList, dataResp, err, errMsg := lineFeatureServ.GetPercentileData(0, startDate, endDate, edbInfoMapping, req.Percentile.CalculateValue, req.Percentile.CalculateUnit, req.Percentile.PercentType)
			if err != nil && errMsg != `` {
				br.Msg = errMsg
				br.ErrMsg = "获取图表，指标信息失败，Err:" + err.Error()
				return
			}
			if err == nil {
				warnEdbList := make([]string, 0)

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

					chartEdbInfoMapping := *v
					chartEdbInfoMapping.IsOrder = false
					chartEdbInfoMapping.IsAxis = 1
					//chartEdbInfoMapping.MinData = curveConf.LeftMin
					//chartEdbInfoMapping.MaxData = curveConf.LeftMax
					chartEdbInfoMapping.ChartColor = `#00F`
					chartEdbInfoMapping.ChartWidth = 3
					chartEdbInfoMapping.EdbInfoType = 1
					tmpEdbList = append(tmpEdbList, chartEdbInfoMapping)
				}
				if len(warnEdbList) > 0 {
					tmpChartInfo.WarnMsg = `图表引用指标异常，异常指标：` + strings.Join(warnEdbList, "，")
				}

				tmpChartInfo.Source = utils.CHART_SOURCE_LINE_FEATURE_PERCENTILE
				tmpChartInfo.ChartType = utils.CHART_TYPE_CURVE

				resp.PercentileData = response.CurveResp{
					ChartInfo:   tmpChartInfo,
					EdbInfoList: tmpEdbList,
					DataResp:    dataResp,
				}
			}
		}

	}

	// 频率分布图表信息
	{
		// 配置了数据才有返回
		if req.FrequencyDistribution.DateType > 0 && req.FrequencyDistribution.FrequencyValue > 0 {
			tmpChartInfo := *chartInfo
			tmpChartInfo.ChartName = fmt.Sprintf("%s频率和累计频率", edbInfoMapping.EdbName)

			// 获取图表中的指标数据
			edbList, dataResp, err, errMsg := lineFeatureServ.GetFrequencyDistributionData(0, edbInfoMapping, req.FrequencyDistribution.DateType, req.FrequencyDistribution.FrequencyValue, req.FrequencyDistribution.StartDate, req.FrequencyDistribution.EndDate)
			if err != nil && errMsg != `` {
				br.Msg = errMsg
				br.ErrMsg = "获取图表，指标信息失败，Err:" + err.Error()
				return
			}
			if err == nil {
				warnEdbList := make([]string, 0)

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

					chartEdbInfoMapping := *v
					chartEdbInfoMapping.IsOrder = false
					chartEdbInfoMapping.IsAxis = 1
					//chartEdbInfoMapping.MinData = curveConf.LeftMin
					//chartEdbInfoMapping.MaxData = curveConf.LeftMax
					chartEdbInfoMapping.ChartColor = `#00F`
					chartEdbInfoMapping.ChartWidth = 3
					chartEdbInfoMapping.EdbInfoType = 1
					tmpEdbList = append(tmpEdbList, chartEdbInfoMapping)
				}
				if len(warnEdbList) > 0 {
					tmpChartInfo.WarnMsg = `图表引用指标异常，异常指标：` + strings.Join(warnEdbList, "，")
				}

				tmpChartInfo.Source = utils.CHART_SOURCE_LINE_FEATURE_FREQUENCY
				tmpChartInfo.ChartType = utils.CHART_TYPE_CURVE

				resp.FrequencyDistributionData = response.CurveResp{
					ChartInfo:   tmpChartInfo,
					EdbInfoList: tmpEdbList,
					DataResp:    dataResp,
				}
			}
		}

	}

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

// MultipleGraphPreviewCurve
// @Title 批量添加图表的预览曲线图接口（只返回曲线图的数据）
// @Description 批量添加图表的预览曲线图接口
// @Param	request	body request.SaveMultipleGraphConfigReq true "type json string"
// @Success Ret=200 返回图表id
// @router /preview_cure [post]
func (this *LineFeaturesChartInfoController) MultipleGraphPreviewCurve() {
	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 request.SaveMultipleGraphConfigReq
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}

	edbInfoMapping, err := data_manage.GetChartEdbMappingByEdbInfoId(req.EdbInfoId)
	if err != nil {
		br.Msg = "获取失败"
		br.ErrMsg = "获取图表，指标信息失败，Err:" + err.Error()
		return
	}
	if edbInfoMapping == nil {
		br.Msg = "指标不存在"
		br.IsSendEmail = false
		return
	}

	resp := response.PreviewMultipleGraphConfigResp{}

	chartInfo := new(data_manage.ChartInfoView)
	chartInfo.Calendar = `公历`
	chartInfo.ChartName = edbInfoMapping.EdbName

	// 曲线图表信息
	{
		tmpChartInfo := *chartInfo

		curveConf := req.Curve
		var maxDate time.Time
		if edbInfoMapping.LatestDate != "" {
			latestDateT, _ := time.Parse(utils.FormatDate, edbInfoMapping.LatestDate)
			maxDate = latestDateT
		}
		startDate, endDate := utils.GetDateByDateTypeV2(curveConf.DateType, curveConf.StartDate, curveConf.EndDate, curveConf.StartYear, maxDate)

		// 获取图表中的指标数据
		edbList, _, _, _, err, errMsg := data.GetChartEdbData(tmpChartInfo.ChartInfoId, tmpChartInfo.ChartType, tmpChartInfo.Calendar, startDate, endDate, []*data_manage.ChartEdbInfoMapping{edbInfoMapping}, tmpChartInfo.ExtraConfig, tmpChartInfo.SeasonExtraConfig)
		if err != nil {
			br.Msg = "获取失败"
			if errMsg != `` {
				br.Msg = errMsg
			}
			br.ErrMsg = "获取图表，指标信息失败，Err:" + err.Error()
			return
		}
		warnEdbList := make([]string, 0)

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

			chartEdbInfoMapping := *v
			chartEdbInfoMapping.IsOrder = false
			chartEdbInfoMapping.IsAxis = 1
			chartEdbInfoMapping.MinData = curveConf.LeftMin
			chartEdbInfoMapping.MaxData = curveConf.LeftMax
			chartEdbInfoMapping.ChartColor = `#00F`
			chartEdbInfoMapping.ChartWidth = 3
			chartEdbInfoMapping.EdbInfoType = 1
			tmpEdbList = append(tmpEdbList, chartEdbInfoMapping)
		}
		if len(warnEdbList) > 0 {
			tmpChartInfo.WarnMsg = `图表引用指标异常，异常指标：` + strings.Join(warnEdbList, "，")
		}

		tmpChartInfo.Source = utils.CHART_SOURCE_DEFAULT
		tmpChartInfo.DateType = curveConf.DateType
		tmpChartInfo.StartDate = startDate
		tmpChartInfo.EndDate = endDate
		tmpChartInfo.ChartType = utils.CHART_TYPE_CURVE

		resp.CurveData = response.CurveResp{
			ChartInfo:   tmpChartInfo,
			EdbInfoList: tmpEdbList,
		}
	}

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

// MultipleGraphConfigSaveChart
// @Title 保存图表接口
// @Description 保存图表接口
// @Param	request	body request.SaveMultipleGraphChartReq true "type json string"
// @Success Ret=200 返回图表id
// @router /chart/save [post]
func (this *LineFeaturesChartInfoController) MultipleGraphConfigSaveChart() {
	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 request.SaveMultipleGraphChartReq
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}
	cacheKey := "CACHE_CHART_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)
	}()

	if req.MultipleGraphConfigId <= 0 {
		br.Msg = "配置未保存"
		br.IsSendEmail = false
		return
	}

	if req.IsSaveAs {
		CopyMultipleGraphConfigSaveChart(req, this, br, sysUser)
		return
	}

	edbInfoMapping, err := data_manage.GetChartEdbMappingByEdbInfoId(req.EdbInfoId)
	if err != nil {
		br.Msg = "获取失败"
		br.ErrMsg = "获取图表，指标信息失败，Err:" + err.Error()
		return
	}
	if edbInfoMapping == nil {
		br.Msg = "指标不存在"
		br.IsSendEmail = false
		return
	}

	multipleGraphConfigChartMapping, err := data_manage.GetMultipleGraphConfigChartMappingByIdAndSource(req.MultipleGraphConfigId, req.Source)
	if err != nil && err.Error() != utils.ErrNoRow() {
		br.Msg = `保存失败`
		br.ErrMsg = "获取配置与图表的关联关系失败，ERR:" + err.Error()
		return
	}

	err = nil
	var isAdd bool
	var chartInfoId int
	if multipleGraphConfigChartMapping == nil {
		isAdd = true
	} else {
		chartInfo, err := data_manage.GetChartInfoById(multipleGraphConfigChartMapping.ChartInfoId)
		if err != nil && err.Error() != utils.ErrNoRow() {
			br.Msg = `保存失败`
			br.ErrMsg = "获取图表信息失败，ERR:" + err.Error()
			return
		}
		// 说明图还在，没有被删除
		if chartInfo != nil {
			chartInfoId = multipleGraphConfigChartMapping.ChartInfoId
			req.ChartName = chartInfo.ChartName
			req.ClassifyId = chartInfo.ChartClassifyId
		}
	}

	var chartInfo *data_manage.ChartInfo
	var errMsg string
	isSendEmail := true

	curveConf := req.Curve
	var maxDate time.Time
	if edbInfoMapping.LatestDate != "" {
		latestDateT, _ := time.Parse(utils.FormatDate, edbInfoMapping.LatestDate)
		maxDate = latestDateT
	}
	startDate, endDate := utils.GetDateByDateTypeV2(curveConf.DateType, curveConf.StartDate, curveConf.EndDate, curveConf.StartYear, maxDate)
	switch req.Source {
	case utils.CHART_MULTIPLE_GRAPH_CURVE: // 曲线图
		curveConf := req.Curve
		chartSaveItemList := []*data_manage.ChartSaveItem{
			{
				EdbInfoId:   edbInfoMapping.EdbInfoId,
				MaxData:     curveConf.LeftMax,
				MinData:     curveConf.LeftMin,
				IsOrder:     false,
				IsAxis:      1,
				EdbInfoType: 1,
				//LeadValue:         curveConf.LeadValue,
				//LeadUnit:          curveConf.LeadUnit,
				ChartStyle:        "spline",
				ChartColor:        `#00F`,
				PredictChartColor: "",
				ChartWidth:        3,
				Source:            utils.CHART_SOURCE_DEFAULT,
			},
		}

		if chartInfoId <= 0 {
			addChartReq := data_manage.AddChartInfoReq{
				ChartEdbInfoList: chartSaveItemList,
				ChartClassifyId:  req.ClassifyId,
				ChartName:        req.ChartName,
				ChartType:        utils.CHART_TYPE_CURVE,
				DateType:         curveConf.DateType,
				StartDate:        curveConf.StartDate,
				EndDate:          curveConf.EndDate,
				Calendar:         "公历",
				LeftMin:          fmt.Sprint(curveConf.LeftMin),
				LeftMax:          fmt.Sprint(curveConf.LeftMax),
			}
			chartInfo, err, errMsg, isSendEmail = data.AddChartInfo(addChartReq, sysUser.AdminId, sysUser.RealName, this.Lang)
		} else {
			editChartReq := data_manage.EditChartInfoReq{
				ChartInfoId:      multipleGraphConfigChartMapping.ChartInfoId,
				ChartName:        req.ChartName,
				ChartClassifyId:  req.ClassifyId,
				ChartEdbInfoList: chartSaveItemList,
				ChartType:        utils.CHART_TYPE_CURVE,
				DateType:         curveConf.DateType,
				StartDate:        curveConf.StartDate,
				EndDate:          curveConf.EndDate,
				Calendar:         "公历",
				LeftMin:          fmt.Sprint(curveConf.LeftMin),
				LeftMax:          fmt.Sprint(curveConf.LeftMax),
			}
			chartInfo, err, errMsg, isSendEmail = data.EditChartInfo(editChartReq, sysUser, this.Lang)
			if err != nil {
				br.Msg = "保存失败"
				if errMsg != `` {
					br.Msg = errMsg
				}
				br.ErrMsg = err.Error()
				br.IsSendEmail = isSendEmail
				return
			}
		}
	default:
		var extraConfig string
		var chartSource int
		var leftMinVal, leftMaxVal, rightMinVal, rightMaxVal float64

		// 统计特征-标准差图表
		if req.Source == utils.CHART_MULTIPLE_GRAPH_LINE_FEATURE_STANDARD_DEVIATION {
			chartSource = utils.CHART_SOURCE_LINE_FEATURE_STANDARD_DEVIATION // 统计特征-标准差图表

			standardDeviationConf := req.StandardDeviation
			if standardDeviationConf.CalculateValue <= 0 {
				br.Msg = "滚动周期需要大于0"
				br.IsSendEmail = false
				return
			}
			extraConfig = fmt.Sprint(standardDeviationConf.CalculateValue)

			_, dataResp, err, errMsg := lineFeatureServ.GetStandardDeviationData(0, startDate, endDate, edbInfoMapping, req.StandardDeviation.CalculateValue)
			if err != nil {
				br.Msg = "保存失败"
				if errMsg != `` {
					br.Msg = errMsg
				}
				br.ErrMsg = "获取图表，指标信息失败，Err:" + err.Error()
				return
			}
			leftMinVal = dataResp.MinData
			leftMaxVal = dataResp.MaxData
		} else if req.Source == utils.CHART_MULTIPLE_GRAPH_LINE_FEATURE_PERCENTILE {
			chartSource = utils.CHART_SOURCE_LINE_FEATURE_PERCENTILE // 统计特征-百分位图表

			percentileConf := req.Percentile
			if percentileConf.CalculateUnit == `` {
				br.Msg = "时间长度频度必选"
				br.IsSendEmail = false
				return
			}
			if percentileConf.CalculateValue <= 0 {
				br.Msg = "时间长度期数需要大于0"
				br.IsSendEmail = false
				return
			}
			extraConfigByte, _ := json.Marshal(percentileConf)
			extraConfig = string(extraConfigByte)

			// 获取图表中的指标数据
			_, dataResp, err, errMsg := lineFeatureServ.GetPercentileData(0, startDate, endDate, edbInfoMapping, req.Percentile.CalculateValue, req.Percentile.CalculateUnit, req.Percentile.PercentType)
			if err != nil && errMsg != `` {
				br.Msg = errMsg
				br.ErrMsg = "获取图表，指标信息失败，Err:" + err.Error()
				return
			}
			leftMinVal = dataResp.MinData
			leftMaxVal = dataResp.MaxData
		} else if req.Source == utils.CHART_MULTIPLE_GRAPH_LINE_FEATURE_FREQUENCY {
			chartSource = utils.CHART_SOURCE_LINE_FEATURE_FREQUENCY // 统计特征-频率分布图表

			frequencyDistributionConf := req.FrequencyDistribution
			if frequencyDistributionConf.DateType <= 0 {
				br.Msg = "日期类型必选"
				br.IsSendEmail = false
				return
			}
			if frequencyDistributionConf.FrequencyValue <= 0 {
				br.Msg = "频段数必填"
				br.IsSendEmail = false
				return
			}
			extraConfigByte, _ := json.Marshal(frequencyDistributionConf)
			extraConfig = string(extraConfigByte)

			// 获取图表中的指标数据
			_, dataResp, err, errMsg := lineFeatureServ.GetFrequencyDistributionData(0, edbInfoMapping, req.FrequencyDistribution.DateType, req.FrequencyDistribution.FrequencyValue, req.FrequencyDistribution.StartDate, req.FrequencyDistribution.EndDate)
			if err != nil && errMsg != `` {
				br.Msg = errMsg
				br.ErrMsg = "获取图表，指标信息失败，Err:" + err.Error()
				return
			}
			leftMinVal = dataResp.LeftMinValue
			leftMaxVal = dataResp.LeftMaxValue
			rightMinVal = dataResp.RightMinValue
			rightMaxVal = dataResp.RightMaxValue
		}
		if chartSource <= 0 {
			br.Msg = "错误的来源"
			br.ErrMsg = "错误的来源,source:" + strconv.Itoa(req.Source)
			br.IsSendEmail = false
			return
		}
		if chartInfoId <= 0 {
			addChartReq := data_manage.AddChartInfoReq{
				DateType:        curveConf.DateType,
				StartDate:       curveConf.StartDate,
				EndDate:         curveConf.StartDate,
				ChartClassifyId: req.ClassifyId,
				ChartName:       req.ChartName,
				ChartType:       utils.CHART_TYPE_CURVE,
				Calendar:        "公历",
				LeftMin:         fmt.Sprint(leftMinVal),
				LeftMax:         fmt.Sprint(leftMaxVal),
				RightMin:        fmt.Sprint(rightMinVal),
				RightMax:        fmt.Sprint(rightMaxVal),
				ExtraConfig:     extraConfig,
			}
			chartInfo, err, errMsg, isSendEmail = lineFeatureServ.AddChartInfo(addChartReq, edbInfoMapping, chartSource, sysUser, this.Lang)
		} else {
			editChartReq := data_manage.EditChartInfoReq{
				ChartInfoId:     multipleGraphConfigChartMapping.ChartInfoId,
				ChartName:       req.ChartName,
				ChartClassifyId: req.ClassifyId,
				ChartType:       utils.CHART_TYPE_CURVE,
				DateType:        curveConf.DateType,
				StartDate:       curveConf.StartDate,
				EndDate:         curveConf.StartDate,
				Calendar:        "公历",
				LeftMin:         fmt.Sprint(leftMinVal),
				LeftMax:         fmt.Sprint(leftMaxVal),
				RightMin:        fmt.Sprint(rightMinVal),
				RightMax:        fmt.Sprint(rightMaxVal),
				ExtraConfig:     extraConfig,
			}
			chartInfo, err, errMsg, isSendEmail = lineFeatureServ.EditChartInfo(editChartReq, edbInfoMapping, sysUser, this.Lang)
			if err != nil {
				br.Msg = "保存失败"
				if errMsg != `` {
					br.Msg = errMsg
				}
				br.ErrMsg = err.Error()
				br.IsSendEmail = isSendEmail
				return
			}
		}

	}

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

	// 如果图没有建立关联关系，那么就需要添加关系
	if isAdd {
		multipleGraphConfigChartMapping = &data_manage.MultipleGraphConfigChartMapping{
			//Id:                    0,
			MultipleGraphConfigId: req.MultipleGraphConfigId,
			ChartInfoId:           chartInfo.ChartInfoId,
			Source:                req.Source,
			ModifyTime:            time.Now(),
			CreateTime:            time.Now(),
		}
		err = data_manage.AddMultipleGraphConfigChartMapping(multipleGraphConfigChartMapping)
		if err != nil {
			br.Msg = "保存失败"
			br.ErrMsg = "保存配置与图表的关联关系失败，ERR:" + err.Error()
			return
		}
	} else if multipleGraphConfigChartMapping != nil {
		multipleGraphConfigChartMapping.ChartInfoId = chartInfo.ChartInfoId
		multipleGraphConfigChartMapping.ModifyTime = time.Now()
		err = multipleGraphConfigChartMapping.Update([]string{"ChartInfoId", "ModifyTime"})
		if err != nil {
			br.Msg = "保存失败"
			br.ErrMsg = "保存配置与图表的关联关系失败，ERR:" + err.Error()
			return
		}
	}

	//新增操作日志
	{
		chartLog := new(data_manage.ChartInfoLog)
		chartLog.ChartInfoId = chartInfo.ChartInfoId
		chartLog.ChartName = req.ChartName
		chartLog.ChartClassifyId = req.ClassifyId
		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
}

// CopyMultipleGraphConfigSaveChart 图表另存为
func CopyMultipleGraphConfigSaveChart(req request.SaveMultipleGraphChartReq, this *LineFeaturesChartInfoController, br *models.BaseResponse, sysUser *system.Admin) {
	edbInfoMapping, err := data_manage.GetChartEdbMappingByEdbInfoId(req.EdbInfoId)
	if err != nil {
		br.Msg = "获取失败"
		br.ErrMsg = "获取图表，指标信息失败，Err:" + err.Error()
		return
	}
	if edbInfoMapping == nil {
		br.Msg = "指标不存在"
		br.IsSendEmail = false
		return
	}

	multipleGraphConfigChartMapping, err := data_manage.GetMultipleGraphConfigChartMappingByIdAndSource(req.MultipleGraphConfigId, req.Source)
	if err != nil && err.Error() != utils.ErrNoRow() {
		br.Msg = `保存失败`
		br.ErrMsg = "获取配置与图表的关联关系失败，ERR:" + err.Error()
		return
	}

	// 原图
	oldChartInfo, err := data_manage.GetChartInfoById(multipleGraphConfigChartMapping.ChartInfoId)
	if err != nil && err.Error() != utils.ErrNoRow() {
		br.Msg = `保存失败`
		br.ErrMsg = "获取图表信息失败，ERR:" + err.Error()
		return
	}
	// 说明图还在，没有被删除
	if oldChartInfo == nil {
		br.Msg = "原图不存在"
		br.IsSendEmail = false
	}

	var chartInfo *data_manage.ChartInfo
	var errMsg string
	isSendEmail := true

	switch req.Source {
	case utils.CHART_MULTIPLE_GRAPH_CURVE: // 曲线图
		curveConf := req.Curve
		chartSaveItemList := []*data_manage.ChartSaveItem{
			{
				EdbInfoId:   edbInfoMapping.EdbInfoId,
				MaxData:     curveConf.LeftMax,
				MinData:     curveConf.LeftMin,
				IsOrder:     false,
				IsAxis:      1,
				EdbInfoType: 1,
				//LeadValue:         curveConf.LeadValue,
				//LeadUnit:          curveConf.LeadUnit,
				ChartStyle:        "spline",
				ChartColor:        `#00F`,
				PredictChartColor: "",
				ChartWidth:        3,
				Source:            utils.CHART_SOURCE_DEFAULT,
			},
		}

		addChartReq := data_manage.AddChartInfoReq{
			ChartEdbInfoList: chartSaveItemList,
			ChartClassifyId:  req.ClassifyId,
			ChartName:        req.ChartName,
			ChartType:        utils.CHART_TYPE_CURVE,
			DateType:         curveConf.DateType,
			StartDate:        curveConf.StartDate,
			EndDate:          curveConf.EndDate,
			Calendar:         "公历",
			LeftMin:          fmt.Sprint(curveConf.LeftMin),
			LeftMax:          fmt.Sprint(curveConf.LeftMax),
		}
		chartInfo, err, errMsg, isSendEmail = data.AddChartInfo(addChartReq, sysUser.AdminId, sysUser.RealName, this.Lang)
	default:
		if !utils.InArrayByInt([]int{utils.CHART_MULTIPLE_GRAPH_LINE_FEATURE_STANDARD_DEVIATION, utils.CHART_MULTIPLE_GRAPH_LINE_FEATURE_PERCENTILE, utils.CHART_MULTIPLE_GRAPH_LINE_FEATURE_FREQUENCY}, req.Source) {
			br.Msg = "错误的来源"
			br.ErrMsg = "错误的来源,source:" + strconv.Itoa(req.Source)
			br.IsSendEmail = false
			return
		}

		chartInfo, err, errMsg, isSendEmail = lineFeatureServ.CopyChartInfo(multipleGraphConfigChartMapping.MultipleGraphConfigId, req.Source, req.ClassifyId, req.ChartName, edbInfoMapping, oldChartInfo, 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.ClassifyId
		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
}

// MultipleGraphConfigSaveEdb
// @Title 保存指标接口
// @Description 保存指标接口
// @Param	request	body request.SaveMultipleGraphEdbReq true "type json string"
// @Success Ret=200 返回指标id
// @router /edb/save [post]
func (this *LineFeaturesChartInfoController) 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 request.SaveMultipleGraphEdbReq
	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)
	}()

	edbInfoMapping, err := data_manage.GetChartEdbMappingByEdbInfoId(req.EdbInfoId)
	if err != nil {
		br.Msg = "获取失败"
		br.ErrMsg = "获取图表，指标信息失败，Err:" + err.Error()
		return
	}
	if edbInfoMapping == nil {
		br.Msg = "指标不存在"
		br.IsSendEmail = false
		return
	}

	// 计算公式
	var formula string
	var edbSource int
	switch req.Source {
	case utils.CHART_MULTIPLE_GRAPH_LINE_FEATURE_STANDARD_DEVIATION:
		edbSource = utils.DATA_SOURCE_CALCULATE_STANDARD_DEVIATION // 统计特征-标准差
		if edbInfoMapping.EdbInfoCategoryType == 1 {
			edbSource = utils.DATA_SOURCE_PREDICT_CALCULATE_STANDARD_DEVIATION // 统计特征-预测标准差
		}
		standardDeviationConf := req.StandardDeviation
		if standardDeviationConf.CalculateValue <= 0 {
			br.Msg = "滚动周期需要大于0"
			br.IsSendEmail = false
			return
		}
		formula = fmt.Sprint(standardDeviationConf.CalculateValue)
	case utils.CHART_MULTIPLE_GRAPH_LINE_FEATURE_PERCENTILE:
		edbSource = utils.DATA_SOURCE_CALCULATE_PERCENTILE // 统计特征-百分位图表
		if edbInfoMapping.EdbInfoCategoryType == 1 {
			edbSource = utils.DATA_SOURCE_PREDICT_CALCULATE_PERCENTILE // 统计特征-预测标准差
		}
		percentileConf := req.Percentile
		if percentileConf.CalculateUnit == `` {
			br.Msg = "时间长度频度必选"
			br.IsSendEmail = false
			return
		}
		if percentileConf.CalculateValue <= 0 {
			br.Msg = "时间长度期数需要大于0"
			br.IsSendEmail = false
			return
		}
		extraConfigByte, _ := json.Marshal(percentileConf)
		formula = string(extraConfigByte)
	default:
		br.Msg = "错误的来源"
		br.ErrMsg = "错误的来源,source:" + strconv.Itoa(req.Source)
		br.IsSendEmail = false
		return
	}

	multipleGraphConfigEdbMapping, err := data_manage.GetMultipleGraphConfigEdbMappingByIdAndSource(req.MultipleGraphConfigId, req.Source)
	if err != nil && err.Error() != utils.ErrNoRow() {
		br.Msg = `保存失败`
		br.ErrMsg = "获取配置与图表的关联关系失败，ERR:" + err.Error()
		return
	}
	err = nil
	var isAdd bool
	var edbInfoId int
	if multipleGraphConfigEdbMapping == nil {
		isAdd = true
	} else {
		edbInfo, err := data_manage.GetEdbInfoById(multipleGraphConfigEdbMapping.EdbInfoId)
		if err != nil && err.Error() != utils.ErrNoRow() {
			br.Msg = `保存失败`
			br.ErrMsg = "获取图表信息失败，ERR:" + err.Error()
			return
		}
		// 说明指标还在，没有被删除
		if edbInfo != nil && !req.IsSaveAs {
			edbInfoId = multipleGraphConfigEdbMapping.EdbInfoId
			req.EdbName = edbInfo.EdbName
			req.ClassifyId = edbInfo.ClassifyId
			req.Frequency = edbInfo.Frequency
			req.Unit = edbInfo.Unit
		}
	}

	var respItem *data.AddPredictEdbDataResponse

	// 0：普通，1：预测
	if edbInfoMapping.EdbInfoCategoryType == 0 {
		if edbInfoId <= 0 || req.IsSaveAs {
			req2 := &data_manage.EdbInfoCalculateBatchSaveReqByEdbLib{
				AdminId:       sysUser.AdminId,
				AdminName:     sysUser.RealName,
				EdbName:       req.EdbName,
				Frequency:     req.Frequency,
				Unit:          req.Unit,
				ClassifyId:    req.ClassifyId,
				Formula:       formula,
				Source:        edbSource,
				FromEdbInfoId: edbInfoMapping.EdbInfoId,
				Calendar:      `公历`,
			}

			// 调用指标库去添加
			reqJson, err := json.Marshal(req2)
			if err != nil {
				br.Msg = "参数解析异常！"
				br.ErrMsg = "参数解析失败，Err:" + err.Error()
				return
			}
			respItem, err = data.BatchSaveEdbCalculateData(string(reqJson), this.Lang)
			if err != nil {
				br.Msg = "新增失败"
				br.ErrMsg = "新增失败,Err:" + err.Error()
				return
			}
		} else {
			req2 := &data_manage.EdbInfoCalculateBatchEditReqByEdbLib{
				EdbInfoId:     edbInfoId,
				EdbName:       req.EdbName,
				Frequency:     req.Frequency,
				Unit:          req.Unit,
				ClassifyId:    req.ClassifyId,
				Formula:       formula,
				Source:        edbSource,
				FromEdbInfoId: edbInfoMapping.EdbInfoId,
				Calendar:      `公历`,
			}

			// 调用指标库去更新
			reqJson, err := json.Marshal(req2)
			if err != nil {
				br.Msg = "参数解析异常！"
				br.ErrMsg = "参数解析失败，Err:" + err.Error()
				return
			}
			respItem, err = data.BatchEditEdbCalculateData(string(reqJson), this.Lang)
			if err != nil {
				br.Msg = "编辑失败"
				br.ErrMsg = "编辑失败,Err:" + err.Error()
				return
			}
		}
	} else {
		req2 := &data_manage.PredictEdbInfoCalculateBatchSaveReq{
			AdminId:       sysUser.AdminId,
			AdminName:     sysUser.RealName,
			EdbName:       req.EdbName,
			Frequency:     req.Frequency,
			Unit:          req.Unit,
			ClassifyId:    req.ClassifyId,
			Formula:       formula,
			Source:        edbSource,
			FromEdbInfoId: edbInfoMapping.EdbInfoId,
			Calendar:      `公历`,
		}
		if edbInfoId > 0 && !req.IsSaveAs {
			req2.EdbInfoId = edbInfoId
		}
		// 调用指标库去添加
		reqJson, err := json.Marshal(req2)
		if err != nil {
			br.Msg = "参数解析异常！"
			br.ErrMsg = "参数解析失败，Err:" + err.Error()
			return
		}
		respItem, err = data.BatchSavePredictEdbData(string(reqJson), this.Lang)
		if err != nil {
			br.Msg = "新增失败"
			br.ErrMsg = "新增失败,Err:" + err.Error()
			return
		}
	}

	if respItem == nil {
		br.Msg = "保存失败"
		br.ErrMsg = "保存失败"
		return
	}
	if respItem.Ret != 200 {
		br.Msg = respItem.Msg
		br.ErrMsg = respItem.ErrMsg
		return
	}

	resp := respItem.Data

	//添加es
	data.AddOrEditEdbInfoToEs(resp.EdbInfoId)

	// 如果不是另存为的话，那么需要建立配置与指标的关系
	if !req.IsSaveAs {
		// 如果指标没有建立关联关系，那么就需要添加关系
		if isAdd {
			multipleGraphConfigEdbMapping = &data_manage.MultipleGraphConfigEdbMapping{
				//Id:                    0,
				MultipleGraphConfigId: req.MultipleGraphConfigId,
				EdbInfoId:             resp.EdbInfoId,
				Source:                req.Source,
				ModifyTime:            time.Now(),
				CreateTime:            time.Now(),
			}
			err = data_manage.AddMultipleGraphConfigEdbMapping(multipleGraphConfigEdbMapping)
			if err != nil {
				br.Msg = "保存失败"
				br.ErrMsg = "保存配置与指标的关联关系失败，ERR:" + err.Error()
				return
			}
		} else if multipleGraphConfigEdbMapping != nil {
			multipleGraphConfigEdbMapping.EdbInfoId = resp.EdbInfoId
			multipleGraphConfigEdbMapping.ModifyTime = time.Now()
			err = multipleGraphConfigEdbMapping.Update([]string{"EdbInfoId", "ModifyTime"})
			if err != nil {
				br.Msg = "保存失败"
				br.ErrMsg = "保存配置与指标的关联关系失败，ERR:" + err.Error()
				return
			}
		}
	}

	//新增操作日志
	//{
	//	edbLog := new(data_manage.EdbInfoLog)
	//	edbLog.EdbInfoId = resp.EdbInfoId
	//	edbLog.SourceName = edbInfo.SourceName
	//	edbLog.Source = edbInfo.Source
	//	edbLog.EdbCode = edbInfo.EdbCode
	//	edbLog.EdbName = req2.EdbName
	//	edbLog.ClassifyId = req2.ClassifyId
	//	edbLog.SysUserId = sysUser.AdminId
	//	edbLog.SysUserRealName = sysUser.RealName
	//	edbLog.CreateTime = time.Now()
	//	edbLog.Content = string(this.Ctx.Input.RequestBody)
	//	edbLog.Status = "多图配置保存指标"
	//	edbLog.Method = this.Ctx.Input.URI()
	//	go data_manage.AddEdbInfoLog(edbLog)
	//}

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

// GetMultipleGraphConfig
// @Title 保存配置接口
// @Description 保存配置接口
// @Param   UniqueCode   query   int  true       "图表唯一编码,如果是管理后台访问，传固定字符串:7c69b590249049942070ae9dcd5bf6dc"
// @Success Ret=200 返回图表id
// @router /config/detail [get]
func (this *LineFeaturesChartInfoController) GetMultipleGraphConfig() {
	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
	}
	uniqueCode := this.GetString("UniqueCode")
	if uniqueCode == "" {
		br.Msg = "参数错误"
		br.ErrMsg = "参数错误,uniqueCode is empty"
		return
	}

	chartInfo, err := data_manage.GetChartInfoViewByUniqueCode(uniqueCode)
	if err != nil {
		br.Msg = "获取失败"
		br.ErrMsg = "获取图表信息失败，Err:" + err.Error()
		return
	}
	if chartInfo == nil {
		br.Msg = "获取失败"
		br.ErrMsg = "获取图表信息失败，Err:" + err.Error()
		return
	}
	multipleGraphConfigChartMapping, err := data_manage.GetMultipleGraphConfigChartMappingByChartId(chartInfo.ChartInfoId)
	if err != nil {
		br.Msg = "获取失败"
		br.ErrMsg = "获取滚动相关性图表的配置信息失败，Err:" + err.Error()
		return
	}

	multipleGraphConfig, err := data_manage.GetMultipleGraphConfigById(multipleGraphConfigChartMapping.MultipleGraphConfigId)
	if err != nil {
		br.Msg = `获取失败`
		br.ErrMsg = `获取配置失败，ERR：` + err.Error()
		return
	}

	// 生成的图表
	multipleGraphConfigChartMappingList := make([]response.MultipleGraphConfigChartMapping, 0)
	{
		chartMappingList, err := data_manage.GetMultipleGraphConfigChartMappingListById(multipleGraphConfigChartMapping.MultipleGraphConfigId)
		if err != nil {
			br.Msg = `获取失败`
			br.ErrMsg = `获取关联图表配置失败，ERR：` + err.Error()
			return
		}
		chartInfoIdList := make([]int, 0)
		chartMappingMap := make(map[int]*data_manage.MultipleGraphConfigChartMapping)
		for _, v := range chartMappingList {
			chartInfoIdList = append(chartInfoIdList, v.ChartInfoId)
			chartMappingMap[v.ChartInfoId] = v
		}
		chartList, err := data_manage.GetChartInfoByIdList(chartInfoIdList)
		if err != nil {
			br.Msg = `获取失败`
			br.ErrMsg = `获取关联图表列表失败，ERR：` + err.Error()
			return
		}
		for _, v := range chartList {
			if tmpInfo, ok := chartMappingMap[v.ChartInfoId]; ok {
				multipleGraphConfigChartMappingList = append(multipleGraphConfigChartMappingList, response.MultipleGraphConfigChartMapping{
					ChartInfoId:            tmpInfo.ChartInfoId,
					Source:                 tmpInfo.Source,
					MultipleLocationSource: tmpInfo.Source,
				})
			}
		}
	}

	// 生成的指标
	multipleGraphConfigEdbMappingList := make([]response.MultipleGraphConfigEdbMapping, 0)
	{
		edbMappingList, err := data_manage.GetMultipleGraphConfigEdbMappingListById(multipleGraphConfigChartMapping.MultipleGraphConfigId)
		if err != nil {
			br.Msg = `获取失败`
			br.ErrMsg = `获取关联指标配置失败，ERR：` + err.Error()
			return
		}
		edbInfoIdList := make([]int, 0)
		edbMappingMap := make(map[int]*data_manage.MultipleGraphConfigEdbMapping)
		for _, v := range edbMappingList {
			edbInfoIdList = append(edbInfoIdList, v.EdbInfoId)
			edbMappingMap[v.EdbInfoId] = v
		}

		edbList, err := data_manage.GetEdbInfoByIdList(edbInfoIdList)
		if err != nil {
			br.Msg = `获取失败`
			br.ErrMsg = `获取关联图表列表失败，ERR：` + err.Error()
			return
		}
		for _, v := range edbList {
			if tmpInfo, ok := edbMappingMap[v.EdbInfoId]; ok {
				multipleGraphConfigEdbMappingList = append(multipleGraphConfigEdbMappingList, response.MultipleGraphConfigEdbMapping{
					EdbInfoId:              tmpInfo.EdbInfoId,
					Source:                 tmpInfo.Source,
					MultipleLocationSource: tmpInfo.Source,
				})
			}
		}
	}

	// 关联指标
	mappingList, err := data_manage.GetChartEdbMappingListByEdbInfoIdList([]int{multipleGraphConfig.EdbInfoIdA, multipleGraphConfig.EdbInfoIdB})
	if err != nil {
		br.Msg = "获取失败"
		br.ErrMsg = "获取图表，指标信息失败，Err:" + err.Error()
		return
	}

	var config request.ConfigSave
	err = json.Unmarshal([]byte(multipleGraphConfig.Curve), &config)
	if err != nil {
		br.Msg = `相关性配置异常`
		br.ErrMsg = `相关性配置异常,ERR:` + err.Error()
		return
	}

	resp := response.MultipleGraphConfigDetailResp{
		MultipleGraphConfigId: multipleGraphConfigChartMapping.MultipleGraphConfigId,
		Curve:                 config.Curve,
		StandardDeviation:     config.StandardDeviation,
		Percentile:            config.Percentile,
		FrequencyDistribution: config.FrequencyDistribution,
		EdbInfoList:           mappingList,
		ChartMappingList:      multipleGraphConfigChartMappingList,
		EdbMappingList:        multipleGraphConfigEdbMappingList,
	}
	br.Ret = 200
	br.Success = true
	br.Msg = "保存成功"
	br.Data = resp
	br.IsAddLog = true
}

// Move
// @Title 移动图表接口
// @Description 移动图表接口
// @Success 200 {object} data_manage.MoveChartInfoReq
// @router /chart_info/move [post]
func (this *LineFeaturesChartInfoController) Move() {
	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.MoveChartInfoReq
	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 = "图表id小于等于0"
		return
	}

	if req.ChartClassifyId <= 0 {
		br.Msg = "请选择分类"
		return
	}
	//判断分类是否存在
	count, _ := data_manage.GetChartClassifyCountById(req.ChartClassifyId)
	if count <= 0 {
		br.Msg = "分类已被删除，不可移动，请刷新页面"
		return
	}

	chartInfo, err := data_manage.GetChartInfoById(req.ChartInfoId)
	if err != nil {
		br.Msg = "移动失败"
		br.ErrMsg = "获取图表信息失败,Err:" + err.Error()
		return
	}

	if !utils.InArrayByInt([]int{utils.CHART_SOURCE_LINE_FEATURE_STANDARD_DEVIATION, utils.CHART_SOURCE_LINE_FEATURE_PERCENTILE, utils.CHART_SOURCE_LINE_FEATURE_FREQUENCY}, chartInfo.Source) {
		br.Msg = "图表异常"
		br.ErrMsg = "分类异常,不是统计特征的图表"
		return
	}

	//如果改变了分类，那么移动该图表数据
	if chartInfo.ChartClassifyId != req.ChartClassifyId {
		//查询需要修改的分类下是否存在同一个图表名称
		tmpChartInfo, tmpErr := data_manage.GetChartInfoByClassifyIdAndName(req.ChartClassifyId, chartInfo.ChartName)
		if tmpErr != nil && tmpErr.Error() != utils.ErrNoRow() {
			br.Msg = "移动失败"
			br.ErrMsg = "移动失败,Err:" + tmpErr.Error()
			return
		}
		if tmpChartInfo != nil {
			br.Msg = "移动失败，同一个分类下图表名称不允许重复"
			br.ErrMsg = "移动失败，同一个分类下图表名称不允许重复"
			return
		}
		err = data_manage.MoveChartInfo(req.ChartInfoId, req.ChartClassifyId)
		if err != nil {
			br.Msg = "移动失败"
			br.ErrMsg = "移动失败,Err:" + err.Error()
			return
		}
	}

	//移动排序
	updateCol := make([]string, 0)
	//如果有传入 上一个兄弟节点分类id
	if req.PrevChartInfoId > 0 {
		prevChartInfo, err := data_manage.GetChartInfoById(req.PrevChartInfoId)
		if err != nil {
			br.Msg = "移动失败"
			br.ErrMsg = "获取上一个兄弟节点分类信息失败,Err:" + err.Error()
			return
		}

		//如果是移动在两个兄弟节点之间
		if req.NextChartInfoId > 0 {
			//下一个兄弟节点
			nextChartInfo, err := data_manage.GetChartInfoById(req.NextChartInfoId)
			if err != nil {
				br.Msg = "移动失败"
				br.ErrMsg = "获取下一个兄弟节点分类信息失败,Err:" + err.Error()
				return
			}
			//如果上一个兄弟与下一个兄弟的排序权重是一致的，那么需要将下一个兄弟（以及下个兄弟的同样排序权重）的排序权重+2，自己变成上一个兄弟的排序权重+1
			if prevChartInfo.Sort == nextChartInfo.Sort || prevChartInfo.Sort == chartInfo.Sort {
				//变更兄弟节点的排序
				updateSortStr := `sort + 2`
				_ = data_manage.UpdateChartInfoSortByClassifyId(prevChartInfo.ChartClassifyId, prevChartInfo.Sort, prevChartInfo.ChartInfoId, []int{utils.CHART_SOURCE_LINE_FEATURE_STANDARD_DEVIATION, utils.CHART_SOURCE_LINE_FEATURE_PERCENTILE, utils.CHART_SOURCE_LINE_FEATURE_FREQUENCY}, updateSortStr)
			} else {
				//如果下一个兄弟的排序权重正好是上个兄弟节点的下一层，那么需要再加一层了
				if nextChartInfo.Sort-prevChartInfo.Sort == 1 {
					//变更兄弟节点的排序
					updateSortStr := `sort + 1`
					_ = data_manage.UpdateChartInfoSortByClassifyId(prevChartInfo.ChartClassifyId, prevChartInfo.Sort, prevChartInfo.ChartInfoId, []int{utils.CHART_SOURCE_LINE_FEATURE_STANDARD_DEVIATION, utils.CHART_SOURCE_LINE_FEATURE_PERCENTILE, utils.CHART_SOURCE_LINE_FEATURE_FREQUENCY}, updateSortStr)
				}
			}
		}

		chartInfo.Sort = prevChartInfo.Sort + 1
		chartInfo.ModifyTime = time.Now()
		updateCol = append(updateCol, "Sort", "ModifyTime")

	} else {
		firstClassify, err := data_manage.GetFirstChartInfoByClassifyId(req.ChartClassifyId)
		if err != nil && err.Error() != utils.ErrNoRow() {
			br.Msg = "移动失败"
			br.ErrMsg = "获取获取当前父级分类下的排序第一条的分类信息失败,Err:" + err.Error()
			return
		}

		//如果该分类下存在其他分类，且第一个其他分类的排序等于0，那么需要调整排序
		if firstClassify != nil && firstClassify.Sort == 0 {
			updateSortStr := ` sort + 1 `
			_ = data_manage.UpdateChartInfoSortByClassifyId(firstClassify.ChartClassifyId, 0, firstClassify.ChartInfoId-1, []int{utils.CHART_SOURCE_LINE_FEATURE_STANDARD_DEVIATION, utils.CHART_SOURCE_LINE_FEATURE_PERCENTILE, utils.CHART_SOURCE_LINE_FEATURE_FREQUENCY}, updateSortStr)
		}

		chartInfo.Sort = 0 //那就是排在第一位
		chartInfo.ModifyTime = time.Now()
		updateCol = append(updateCol, "Sort", "ModifyTime")
	}

	//更新
	if len(updateCol) > 0 {
		err = chartInfo.Update(updateCol)
		if err != nil {
			br.Msg = "移动失败"
			br.ErrMsg = "修改失败,Err:" + err.Error()
			return
		}
	}

	if err != nil {
		br.Msg = "移动失败"
		br.ErrMsg = "修改失败,Err:" + err.Error()
		return
	}

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

	//新增操作日志
	{
		chartLog := new(data_manage.ChartInfoLog)
		chartLog.ChartName = chartInfo.ChartName
		chartLog.ChartInfoId = req.ChartInfoId
		chartLog.ChartClassifyId = chartInfo.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.URL()
		go data_manage.AddChartInfoLog(chartLog)
	}

	br.Ret = 200
	br.Success = true
	br.Msg = "移动成功"
}

// 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 *LineFeaturesChartInfoController) 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)

	var condition string
	var pars []interface{}

	// 普通图表
	condition += ` AND source in(?,?,?) `
	pars = append(pars, utils.CHART_SOURCE_LINE_FEATURE_STANDARD_DEVIATION, utils.CHART_SOURCE_LINE_FEATURE_PERCENTILE, utils.CHART_SOURCE_LINE_FEATURE_FREQUENCY)

	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 _, ok := chartEdbMap[list[i].ChartInfoId]; ok {
			list[i].IsEnChart = data.CheckIsEnChart(list[i].ChartNameEn, []*data_manage.ChartEdbInfoMapping{}, 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
}

// Detail
// @Title 获取图表详情
// @Description 获取图表详情接口
// @Param   ChartInfoId   query   int  true       "图表id"
// @Success 200 {object} data_manage.ChartInfoDetailResp
// @router /chart_info/detail [get]
func (this *LineFeaturesChartInfoController) 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
	}

	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 chartInfo.ExtraConfig == `` {
		br.Msg = "获取失败"
		br.ErrMsg = "获取配置信息失败，图表的额外配置信息为空"
		return
	}

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

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

	var edbList []*data_manage.ChartEdbInfoMapping
	var errMsg string
	var resultResp interface{}

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

	warnEdbList := make([]string, 0)

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

		chartEdbInfoMapping := *v
		chartEdbInfoMapping.IsOrder = false
		chartEdbInfoMapping.IsAxis = 1
		//chartEdbInfoMapping.MinData = curveConf.LeftMin
		//chartEdbInfoMapping.MaxData = curveConf.LeftMax
		chartEdbInfoMapping.ChartColor = `#00F`
		chartEdbInfoMapping.ChartWidth = 3
		chartEdbInfoMapping.EdbInfoType = 1
		tmpEdbList = append(tmpEdbList, chartEdbInfoMapping)
	}
	if len(warnEdbList) > 0 {
		chartInfo.WarnMsg = `图表引用指标异常，异常指标：` + strings.Join(warnEdbList, "，")
	}

	// 判断是否加入我的图库
	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, []*data_manage.ChartEdbInfoMapping{}, chartInfo.Source, chartInfo.ChartType)
	//chartInfo.UnitEn = edbInfoMappingA.UnitEn

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

	chartInfo.HaveOperaAuth = true
	// 指标权限
	{
		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)
			}
		}
	}

	resp := new(data_manage.ChartInfoDetailResp)
	resp.ChartInfo = chartInfo
	resp.EdbInfoList = edbList
	resp.DataResp = resultResp
	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 *LineFeaturesChartInfoController) 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
	}
	if !isOk {
		br.Msg = msg
		br.ErrMsg = errMsg
		return
	}
	br.Ret = 200
	br.Success = true
	br.Msg = "获取成功"
	br.Data = resp
}

// 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 *LineFeaturesChartInfoController) 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
	}

	// 刷新图表的指标信息
	err, isAsync := data.ChartInfoRefreshV2(chartInfo.ChartInfoId)

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

	br.Ret = 200
	br.Success = true
	br.Msg = "刷新成功"
	if isAsync {
		br.Msg = "图表关联指标较多，请10分钟后刷新页面查看最新数据"
	}
}

// Copy
// @Title 复制并新增图表接口
// @Description 复制并新增图表接口
// @Param	request	body data_manage.CopyAddChartInfoReq true "type json string"
// @Success 200 {object} data_manage.AddChartInfoResp
// @router /chart_info/copy [post]
func (this *LineFeaturesChartInfoController) Copy() {
	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.CopyAddChartInfoReq
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}

	// 获取原图表信息
	oldChartInfo, err := data_manage.GetChartInfoById(req.ChartInfoId)
	if err != nil {
		br.Msg = "获取原图表信息失败"
		br.ErrMsg = "获取原图表信息失败,Err:" + err.Error()
		return
	}
	if !utils.InArrayByInt([]int{utils.CHART_SOURCE_LINE_FEATURE_STANDARD_DEVIATION, utils.CHART_SOURCE_LINE_FEATURE_PERCENTILE, utils.CHART_SOURCE_LINE_FEATURE_FREQUENCY}, oldChartInfo.Source) {
		br.Msg = `错误的图表类型`
		br.IsSendEmail = false
		return
	}

	multipleGraphConfigChartMapping, err := data_manage.GetMultipleGraphConfigChartMappingByChartId(oldChartInfo.ChartInfoId)
	if err != nil && err.Error() != utils.ErrNoRow() {
		br.Msg = `保存失败`
		br.ErrMsg = "获取配置与图表的关联关系失败，ERR:" + err.Error()
		return
	}

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

	// 批量设置图
	chartInfo, err, errMsg, isSendEmail := lineFeatureServ.CopyChartInfo(multipleGraphConfigChartMapping.MultipleGraphConfigId, multipleGraphConfigChartMapping.Source, req.ChartClassifyId, req.ChartName, edbInfoMapping, oldChartInfo, sysUser, this.Lang)

	if err != nil {
		br.Msg = "复制失败"
		if errMsg != `` {
			br.Msg = errMsg
		}
		br.ErrMsg = "复制失败，ERR:" + err.Error()
		br.IsSendEmail = isSendEmail
		return
	}

	resp := data_manage.AddChartInfoResp{
		ChartInfoId: chartInfo.ChartInfoId,
		UniqueCode:  chartInfo.UniqueCode,
		ChartType:   chartInfo.ChartType,
	}

	//新增操作日志
	{

		chartLog := new(data_manage.ChartInfoLog)
		chartLog.ChartInfoId = chartInfo.ChartInfoId
		chartLog.ChartName = chartInfo.ChartName
		chartLog.ChartClassifyId = chartInfo.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.Data = resp
	br.Success = true
	br.Msg = "保存成功"
	br.IsAddLog = true
}

// 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)
					}
				}
			}
		}
		if !isOk {
			if errMsg != "" {
				uniqueCode := ""
				if chartInfo != nil {
					uniqueCode = chartInfo.UniqueCode
				}
				tmpTip := fmt.Sprintf("查询图表详情失败，line_feature.GetChartInfoDetailFromUniqueCode UniqueCode:%s,err:%s", uniqueCode, errMsg)
				utils.FileLog.Info(tmpTip)
				go alarm_msg.SendAlarmMsg(tmpTip, 3)
			}
		}
	}()

	//判断是否存在缓存，如果存在缓存，那么直接从缓存中获取
	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

	if chartInfo.ExtraConfig == `` {
		msg = "获取失败"
		errMsg = "获取配置信息失败，图表的额外配置信息为空"
		return
	}

	// 获取图表关联指标
	edbMappingList, err := data_manage.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 []*data_manage.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
		}
		var maxDate time.Time
		if edbMapping.LatestDate != "" {
			latestDateT, _ := time.Parse(utils.FormatDate, edbMapping.LatestDate)
			maxDate = latestDateT
		}
		startDate, endDate := utils.GetDateByDateTypeV2(chartInfo.DateType, chartInfo.StartDate, chartInfo.EndDate, chartInfo.StartYear, maxDate)
		edbList, resultResp, err, msg = lineFeatureServ.GetStandardDeviationData(0, startDate, endDate, edbMapping, calculateValue)
	case utils.CHART_SOURCE_LINE_FEATURE_PERCENTILE:
		var percentileConfig request.Percentile
		err = json.Unmarshal([]byte(chartInfo.ExtraConfig), &percentileConfig)
		if err != nil {
			msg = "获取失败"
			errMsg = "格式化配置项失败，Err:" + err.Error()
			return
		}
		var maxDate time.Time
		if edbMapping.LatestDate != "" {
			latestDateT, _ := time.Parse(utils.FormatDate, edbMapping.LatestDate)
			maxDate = latestDateT
		}
		startDate, endDate := utils.GetDateByDateTypeV2(chartInfo.DateType, chartInfo.StartDate, chartInfo.EndDate, chartInfo.StartYear, maxDate)
		edbList, resultResp, err, msg = lineFeatureServ.GetPercentileData(0, startDate, endDate, edbMapping, percentileConfig.CalculateValue, percentileConfig.CalculateUnit, percentileConfig.PercentType)
	case utils.CHART_SOURCE_LINE_FEATURE_FREQUENCY:
		var frequencyDistributionConfig request.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
	}

	if chartInfo.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, []*data_manage.ChartEdbInfoMapping{}, chartInfo.Source, chartInfo.ChartType)
	//chartInfo.UnitEn = edbInfoMappingA.UnitEn

	isSaveAs := true
	// 另存为
	chartInfo.Button = data_manage.ChartViewButton{
		IsEdit:    chartInfo.IsEdit,
		IsEnChart: chartInfo.IsEnChart,
		IsAdd:     chartInfo.IsAdd,
		IsCopy:    isSaveAs,
		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.DataResp = resultResp
	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
}

// EnInfoEdit
// @Title 编辑图表英文信息接口
// @Description 编辑图表英文信息接口
// @Param	request	body data_manage.EditChartEnInfoReq true "type json string"
// @Success Ret=200 编辑成功
// @router /chart_info/en/edit [post]
func (this *LineFeaturesChartInfoController) EnInfoEdit() {
	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 request.EditChartEnInfoReq
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}
	req.ChartNameEn = strings.Trim(req.ChartNameEn, " ")
	if req.ChartInfoId <= 0 {
		br.Msg = "请选择图表"
		return
	}
	if req.ChartNameEn == "" {
		br.Msg = "请输入英文图表名称"
		return
	}

	//判断指标名称是否存在
	chartItem, err := data_manage.GetChartInfoById(req.ChartInfoId)
	if err != nil {
		if err.Error() == utils.ErrNoRow() {
			br.Msg = "图表已被删除，请刷新页面"
			br.ErrMsg = "图表已被删除，请刷新页面"
			return
		}
		br.Msg = "获取图表信息失败"
		br.ErrMsg = "获取图表信息失败,Err:" + err.Error()
		return
	}

	// 校验名称是否有重复
	{
		var condition string
		var pars []interface{}
		condition += " AND chart_info_id <> ?  AND chart_name_en = ? AND source in (?,?,?)"
		pars = append(pars, req.ChartInfoId, req.ChartNameEn, utils.CHART_SOURCE_LINE_FEATURE_STANDARD_DEVIATION, utils.CHART_SOURCE_LINE_FEATURE_PERCENTILE, utils.CHART_SOURCE_LINE_FEATURE_FREQUENCY)
		existItem, err := data_manage.GetChartInfoByCondition(condition, pars)
		if err != nil {
			if err.Error() != utils.ErrNoRow() {
				br.Msg = "判断英文图表名称是否存在失败"
				br.ErrMsg = "判断英文图表名称是否存在失败,Err:" + err.Error()
				return
			}
		}
		if err == nil && existItem.ChartInfoId > 0 {
			br.Msg = existItem.ChartName + "：" + req.ChartNameEn + "图表名称已存在"
			return
		}
	}

	chartItem.ChartNameEn = req.ChartNameEn
	chartItem.ModifyTime = time.Now().Local()
	if e := chartItem.Update([]string{"ChartNameEn", "ModifyTime"}); e != nil {
		br.Msg = "操作失败"
		br.ErrMsg = "更新图表信息失败, Err: " + e.Error()
		return
	}

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

	//指标 修改es信息
	//go data.AddOrEditEdbInfoToEs(edbInfo.EdbInfoId)

	//新增操作日志
	{
		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)
	}
	// 清除缓存
	if utils.Re == nil && utils.Rc != nil {
		_ = utils.Rc.Delete(utils.HZ_CHART_LIB_DETAIL + chartItem.UniqueCode) //图表分享链接缓存
		_ = utils.Rc.Delete(data.GetChartInfoDataKey(req.ChartInfoId))
	}

	br.Ret = 200
	br.Success = true
	br.Msg = "编辑成功"
	br.IsAddLog = true
}

// SearchByEs
// @Title 图表模糊搜索（从es获取）
// @Description  图表模糊搜索（从es获取）
// @Param   Keyword   query   string  true       "图表名称"
// @Param   IsShowMe   query   bool  true       "是否只看我的，true、false"
// @Param   Source   query   int  true       "来源，3：统计特征，4：滚动统计特征，默认0：全部"
// @Success 200 {object} data_manage.ChartInfo
// @router /chart_info/search_by_es [get]
func (this *LineFeaturesChartInfoController) SearchByEs() {
	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
	}
	pageSize, _ := this.GetInt("PageSize")
	currentIndex, _ := this.GetInt("CurrentIndex")

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

	keyword := this.GetString("Keyword")

	//只看我的
	isShowMe, _ := this.GetBool("IsShowMe")
	showSysId := 0
	if isShowMe {
		showSysId = sysUser.AdminId
	}

	sourceList := []int{utils.CHART_SOURCE_LINE_FEATURE_STANDARD_DEVIATION, utils.CHART_SOURCE_LINE_FEATURE_PERCENTILE, utils.CHART_SOURCE_LINE_FEATURE_FREQUENCY}

	var searchList []*data_manage.ChartInfo
	var total int64
	var err error

	// 获取当前账号的不可见指标
	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)
		}
	}

	if keyword != "" {
		searchList, total, err = data.EsSearchChartInfo(keyword, showSysId, sourceList, noPermissionChartIdList, startSize, pageSize)
	} else {
		total, searchList, err = data_manage.ChartInfoSearchByEmptyKeyWord(showSysId, sourceList, noPermissionChartIdList, startSize, pageSize)
		if err != nil && err.Error() != utils.ErrNoRow() {
			br.Msg = "获取失败"
			br.ErrMsg = "获取图表信息失败，Err:" + err.Error()
			return
		}
	}

	finalList := make([]*data_manage.ChartInfoMore, 0)
	if len(searchList) > 0 {
		chartInfoIds := ""
		chartEdbMap := make(map[int][]*data_manage.ChartEdbInfoMapping)
		for _, v := range searchList {
			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 _, v := range searchList {
			tmp := new(data_manage.ChartInfoMore)
			tmp.ChartInfo = *v
			// 图表数据权限
			tmp.HaveOperaAuth = true
			//判断是否需要展示英文标识
			if _, ok := chartEdbMap[v.ChartInfoId]; ok {
				tmp.IsEnChart = data.CheckIsEnChart(v.ChartNameEn, []*data_manage.ChartEdbInfoMapping{}, v.Source, v.ChartType)
			}
			finalList = append(finalList, tmp)
		}
	}
	//新增搜索词记录
	{
		searchKeyword := new(data_manage.SearchKeyword)
		searchKeyword.KeyWord = keyword
		searchKeyword.CreateTime = time.Now()
		go data_manage.AddSearchKeyword(searchKeyword)
	}

	page := paging.GetPaging(currentIndex, pageSize, int(total))
	resp := data_manage.ChartInfoListByEsResp{
		Paging: page,
		List:   finalList,
	}
	br.Ret = 200
	br.Success = true
	br.Msg = "获取成功"
	br.Data = resp
}

// BaseInfoEdit
// @Title 编辑图表基础信息接口
// @Description 编辑图表基础信息接口
// @Param	request	body data_manage.EditChartInfoBaseReq true "type json string"
// @Success Ret=200 编辑成功
// @router /chart_info/base/edit [post]
func (this *LineFeaturesChartInfoController) BaseInfoEdit() {
	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 request.EditChartInfoBaseReq
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}
	req.ChartName = strings.Trim(req.ChartName, " ")
	if req.ChartInfoId <= 0 {
		br.Msg = "请选择图表"
		return
	}
	if req.ChartName == "" {
		br.Msg = "请输入英文图表名称"
		return
	}

	//判断指标名称是否存在
	chartItem, err := data_manage.GetChartInfoById(req.ChartInfoId)
	if err != nil {
		if err.Error() == utils.ErrNoRow() {
			br.Msg = "图表已被删除，请刷新页面"
			br.ErrMsg = "图表已被删除，请刷新页面"
			return
		}
		br.Msg = "获取图表信息失败"
		br.ErrMsg = "获取图表信息失败,Err:" + err.Error()
		return
	}

	// 校验名称是否有重复
	{
		var condition string
		var pars []interface{}
		condition += " AND chart_info_id <> ? AND source in (?,?,?) "
		pars = append(pars, req.ChartInfoId, utils.CHART_SOURCE_LINE_FEATURE_STANDARD_DEVIATION, utils.CHART_SOURCE_LINE_FEATURE_PERCENTILE, utils.CHART_SOURCE_LINE_FEATURE_FREQUENCY)

		switch this.Lang {
		case utils.EnLangVersion:
			condition += " AND chart_name_en = ? "
		default:
			condition += " AND chart_name = ? "
		}
		pars = append(pars, req.ChartName)
		existItem, err := data_manage.GetChartInfoByCondition(condition, pars)
		if err != nil {
			if err.Error() != utils.ErrNoRow() {
				br.Msg = "判断英文图表名称是否存在失败"
				br.ErrMsg = "判断英文图表名称是否存在失败,Err:" + err.Error()
				return
			}
		}
		if err == nil && existItem.ChartInfoId > 0 {
			br.Msg = existItem.ChartName + "：" + req.ChartName + "图表名称已存在"
			return
		}
	}

	switch this.Lang {
	case utils.EnLangVersion:
		chartItem.ChartNameEn = req.ChartName
	default:
		chartItem.ChartName = req.ChartName
	}
	chartItem.ModifyTime = time.Now().Local()
	if e := chartItem.Update([]string{"ChartName", "ChartNameEn", "ModifyTime"}); e != nil {
		br.Msg = "操作失败"
		br.ErrMsg = "更新图表信息失败, Err: " + e.Error()
		return
	}

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

	//新增操作日志
	{
		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)
	}

	// 清除缓存
	if utils.Re == nil && utils.Rc != nil {
		_ = utils.Rc.Delete(utils.HZ_CHART_LIB_DETAIL + chartItem.UniqueCode) //图表分享链接缓存
		_ = utils.Rc.Delete(data.GetChartInfoDataKey(req.ChartInfoId))
	}

	br.Ret = 200
	br.Success = true
	br.Msg = "编辑成功"
	br.IsAddLog = true
}