eta_index_lib/controllers/base_from_calculate.go

package controllers

import (
	"encoding/json"
	"errors"
	"eta/eta_index_lib/logic"
	"eta/eta_index_lib/models"
	"eta/eta_index_lib/services"
	"eta/eta_index_lib/utils"
	"fmt"
	"strconv"
	"strings"
	"sync"
	"time"
)

// CalculateController 计算指标
type CalculateController struct {
	BaseAuthController
}

// Add
// @Title 新增计算指标接口
// @Description 新增计算指标接口
// @Success 200 {object} models.EdbInfoCalculateSaveReq
// @router /add [post]
func (this *CalculateController) Add() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()

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

	req.EdbName = strings.Trim(req.EdbName, " ")
	if req.EdbName == "" {
		br.Msg = "指标名称不能为空"
		return
	}

	if req.Frequency == "" {
		br.Msg = "频率不能为空"
		return
	}

	if req.Unit == "" {
		br.Msg = "单位不能为空"
		return
	}

	if req.ClassifyId <= 0 {
		br.Msg = "请选择分类"
		return
	}

	if len(req.EdbInfoIdArr) <= 0 {
		br.Msg = "请选择指标"
		return
	}

	if req.CalculateFormula == "" {
		br.Msg = "请填写指标"
		return
	}

	//加入缓存机制，避免创建同一个名称的指标 start
	redisKey := fmt.Sprint("edb_lib:edb_info:calculate:add:", utils.DATA_SOURCE_CALCULATE, ":", req.EdbName)
	isExist := utils.Rc.IsExist(redisKey)
	if isExist {
		br.Msg = "指标正在处理,请勿重复提交"
		return
	} else {
		//设置3分钟缓存
		utils.Rc.SetNX(redisKey, 1, time.Second*300)
		defer func() {
			_ = utils.Rc.Delete(redisKey)
		}()
	}

	// 新增
	edbInfo, uniqueCode, err, errMsg := services.EdbCalculateAdd(req, this.Lang)
	if err != nil {
		br.Msg = err.Error()
		br.ErrMsg = errMsg
		return
	}

	//处理同名指标
	{
		edbNameList, e := models.GetEdbInfoByName(req.EdbName)
		if e != nil {
			err = fmt.Errorf("保存失败")
			errMsg = "获取指标信息失败，Err:" + e.Error()
			return
		}
		if len(edbNameList) >= 2 {
			for _, v := range edbNameList {
				edbName := v.EdbName + "(" + v.SourceName + ")"
				err = models.ModifyEdbInfoNameSource(edbName, v.EdbInfoId)
				if err != nil {
					errMsg = "修改指标名称失败，Err:" + err.Error()
					err = fmt.Errorf("保存失败")
					return
				}
			}
		}
	}

	// 更新指标最大最小值
	err, errMsg = models.UnifiedModifyEdbInfoMaxAndMinInfo(edbInfo)
	if err != nil {
		return
	}

	// 判断是否需要禁用
	go services.DisableEdbInfoNoUpdate(edbInfo)
	resp := models.AddEdbInfoResp{
		EdbInfoId:  edbInfo.EdbInfoId,
		UniqueCode: uniqueCode,
	}
	br.Ret = 200
	br.Success = true
	br.Msg = "保存成功"
	br.Data = resp
	br.IsAddLog = true
}

// Edit
// @Title 编辑计算指标接口
// @Description 编辑计算指标接口
// @Success 200 {object} models.EdbInfoCalculateSaveReq
// @router /edit [post]
func (this *CalculateController) Edit() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()

	var req models.EdbInfoCalculateSaveReq
	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.ErrMsg = "指标ID：" + strconv.Itoa(req.EdbInfoId)
		return
	}

	req.EdbName = strings.Trim(req.EdbName, " ")
	if req.EdbName == "" {
		br.Msg = "指标名称不能为空"
		return
	}

	if req.Frequency == "" {
		br.Msg = "频率不能为空"
		return
	}

	if req.Unit == "" {
		br.Msg = "单位不能为空"
		return
	}

	if req.ClassifyId <= 0 {
		br.Msg = "请选择分类"
		return
	}

	if len(req.EdbInfoIdArr) <= 0 {
		br.Msg = "请选择指标"
		return
	}

	if req.CalculateFormula == "" {
		br.Msg = "请填写指标公式"
		return
	}

	//todo 校验空值类型，max、min空值类型
	//todo req.EdbInfoIdArr根据tag排序，排成A，B，AB，这种格式

	calculateFormula := req.CalculateFormula
	calculateFormula = strings.Replace(calculateFormula, "（", "(", -1)
	calculateFormula = strings.Replace(calculateFormula, "）", ")", -1)
	calculateFormula = strings.Replace(calculateFormula, "，", ",", -1)
	calculateFormula = strings.Replace(calculateFormula, "。", ".", -1)
	calculateFormula = strings.Replace(calculateFormula, "%", "*0.01", -1)
	req.CalculateFormula = calculateFormula
	fmt.Println("calculateFormula:" + calculateFormula)

	//判断是否重复指标
	edbInfoMap := make(map[int]string)
	//移除研究员选择指标中的未使用的指标
	{
		//转大写的计算公式
		upperCalculateFormulaStr := strings.ToUpper(req.CalculateFormula)
		//用到的指标
		newEdbInfoIdArr := make([]models.EdbInfoFromTag, 0)
		for _, tmpEdbInfo := range req.EdbInfoIdArr {
			_, ok := edbInfoMap[tmpEdbInfo.EdbInfoId]
			if ok {
				br.Msg = "选择指标失败，请勿选择重复指标！"
				return
			}
			edbInfoMap[tmpEdbInfo.EdbInfoId] = tmpEdbInfo.FromTag

			upperFromTag := strings.ToUpper(tmpEdbInfo.FromTag)
			if strings.Contains(upperCalculateFormulaStr, upperFromTag) {
				newEdbInfoIdArr = append(newEdbInfoIdArr, tmpEdbInfo)
			}
		}
		req.EdbInfoIdArr = newEdbInfoIdArr
	}

	// 根据指标名称和指标ID校验库中是否还存在其他同名指标
	existEdbName, err := logic.CheckExistByEdbNameAndEdbInfoId(utils.EDB_INFO_TYPE, req.EdbInfoId, req.EdbName, this.Lang)
	if err != nil {
		br.Msg = "判断指标名称是否存在失败"
		br.ErrMsg = "判断指标名称是否存在失败,Err:" + err.Error()
		return
	}
	if existEdbName {
		br.Msg = "指标名称已存在，请重新填写"
		br.ErrMsg = "指标名称已存在，请重新填写"
		br.IsSendEmail = false
		return
	}

	//判断公式，指标是否有改动
	edbInfoDetail, err := models.GetEdbInfoById(req.EdbInfoId)
	if err != nil {
		br.Msg = "修改失败"
		br.Msg = "获取指标信息失败,GetEdbInfoById Err:" + err.Error()
		return
	}
	if edbInfoDetail == nil {
		br.Msg = "修改失败"
		br.Msg = "指标信息不存在，EdbInfoId:" + strconv.Itoa(req.EdbInfoId)
		return
	}
	// 记录指标原始的基本信息
	oldEdbName := edbInfoDetail.EdbName
	oldFrequency := edbInfoDetail.Frequency
	oldUnit := edbInfoDetail.Unit

	var needCalculate bool

	if edbInfoDetail.CalculateFormula != req.CalculateFormula || edbInfoDetail.EmptyType != req.EmptyType || edbInfoDetail.MaxEmptyType != req.MaxEmptyType || edbInfoDetail.Extra != req.Extra {
		needCalculate = true
	}

	//检验公式
	var formulaStr string
	var edbInfoIdBytes []string
	var edbInfoIdArr []string
	for _, v := range req.EdbInfoIdArr {
		formulaStr += v.FromTag + ","
		edbInfoIdBytes = append(edbInfoIdBytes, v.FromTag)
		edbInfoIdArr = append(edbInfoIdArr, strconv.Itoa(v.EdbInfoId))
		if v.EdbInfoId == req.EdbInfoId {
			br.Msg = "计算指标中包含此指标，不能修改"
			return
		}
	}

	if needCalculate == false {
		edbInfoIdStr := strings.Join(edbInfoIdArr, ",")
		fromEdbInfoId, err := models.GetCalculateEdbInfo(req.EdbInfoId)
		if err != nil {
			br.Msg = "修改失败"
			br.Msg = "获取数据失败，GetCalculateEdbInfo:" + err.Error()
			return
		}

		if edbInfoIdStr != fromEdbInfoId {
			needCalculate = true
		}
	}

	formulaSlice, err := utils.CheckFormulaJson(req.CalculateFormula)
	if err != nil {
		br.Msg = "公式格式错误，请重新填写"
		return
	}
	for _, formula := range formulaSlice {
		formulaMap, e := utils.CheckFormula(formula)
		if e != nil {
			br.Msg = "公式错误，请重新填写"
			return
		}
		for _, v := range formulaMap {
			if !strings.Contains(formulaStr, v) {
				br.Msg = "公式错误，请重新填写"
				return
			}
		}
	}

	// 额外赋值
	switch this.Lang {
	case utils.EnLangVersion:
		req.EdbNameEn = req.EdbName
		req.UnitEn = req.Unit

		req.EdbName = edbInfoDetail.EdbName
		req.Unit = edbInfoDetail.Unit
	default:
		req.EdbNameEn = edbInfoDetail.EdbNameEn
		req.UnitEn = edbInfoDetail.UnitEn
	}

	//重新计算
	err, errMsg := models.EditCalculateInfo(edbInfoDetail, req, formulaSlice, edbInfoIdBytes, needCalculate)
	if err != nil {
		br.Msg = "生成计算指标失败"
		if errMsg != `` {
			br.Msg = errMsg
		}
		br.Msg = "生成计算指标失败,AddEdbInfo Err:" + err.Error()
		return
	}

	// 更新指标最大最小值
	err, errMsg = models.UnifiedModifyEdbInfoMaxAndMinInfo(edbInfoDetail)
	if err != nil {
		br.Msg = errMsg
		br.ErrMsg = err.Error()
		return
	}
	// 记录基础信息变更日志
	oldEdbInfo := new(models.EdbInfo)
	oldEdbInfo.EdbInfoId = edbInfoDetail.EdbInfoId
	oldEdbInfo.EdbName = oldEdbName
	oldEdbInfo.Frequency = oldFrequency
	oldEdbInfo.Unit = oldUnit
	newEdbInfoEditRecord := new(models.EdbInfoEditRecord)
	newEdbInfoEditRecord.EdbName = req.EdbName
	newEdbInfoEditRecord.Frequency = req.Frequency
	newEdbInfoEditRecord.Unit = req.Unit
	newEdbInfoEditRecord.OperateUserId = req.AdminId
	newEdbInfoEditRecord.OperateUserRealName = req.AdminName
	err = services.AddEditEdbInfoRecord(oldEdbInfo, newEdbInfoEditRecord)
	if err != nil {
		br.Msg = "记录基础信息变更日志失败"
		br.ErrMsg = err.Error()
		return
	}

	resp := models.AddEdbInfoResp{
		EdbInfoId:  edbInfoDetail.EdbInfoId,
		UniqueCode: edbInfoDetail.UniqueCode,
	}
	// 重置计算指标中的引用关系
	go services.ResetEdbRelation(edbInfoDetail.EdbInfoId)
	br.Ret = 200
	br.Success = true
	br.Msg = "保存成功"
	br.Data = resp
	br.IsAddLog = true
}

// BatchSave
// @Title 累计值转月-同比值-同差等计算新增
// @Description 累计值转月-同比值-同差等计算新增接口
// @Param request body models.EdbInfoCalculateBatchSaveReq true "type json string"
// @Success Ret=200 返回指标id
// @router /batch/save [post]
func (this *CalculateController) BatchSave() {
	br := new(models.BaseResponse).Init()
	defer func() {
		if br.ErrMsg == "" {
			br.IsSendEmail = false
		}
		this.Data["json"] = br
		this.ServeJSON()
	}()

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

	req.EdbName = strings.Trim(req.EdbName, " ")
	if req.EdbName == "" {
		br.Msg = "指标名称不能为空"
		return
	}

	if req.Frequency == "" {
		br.Msg = "频率不能为空"
		return
	}

	if req.Unit == "" {
		br.Msg = "单位不能为空"
		return
	}

	if req.ClassifyId <= 0 {
		br.Msg = "请选择分类"
		return
	}

	// 基础指标id
	fromEdbInfoId := req.FromEdbInfoId

	var formulaInt int
	var nhccDate models.NhccDate // 拟合残差的日期
	switch req.Source {
	case utils.DATA_SOURCE_CALCULATE_NSZYDPJJS, utils.DATA_SOURCE_CALCULATE_HBZ, utils.DATA_SOURCE_CALCULATE_HCZ, utils.DATA_SOURCE_CALCULATE_TIME_SHIFT, utils.DATA_SOURCE_CALCULATE_CJJX:
		if req.Formula == "" {
			br.Msg = "请填写N值"
			return
		}
		formulaInt, _ = strconv.Atoi(req.Formula)
		if formulaInt <= 0 {
			br.Msg = "N值输入错误,请重新输入"
			return
		}
	case utils.DATA_SOURCE_CALCULATE_ZJPJ:
		//直接拼接指标
		//校验时间格式
		_, err = time.ParseInLocation(utils.FormatDate, req.Formula, time.Local)
		if err != nil {
			br.Msg = "拼接日期有误,请重新输入"
			return
		}
	case utils.DATA_SOURCE_CALCULATE_NHCC: //拟合残差指标
		//指标校验
		if len(req.EdbInfoIdArr) != 2 {
			br.Msg = "选择的指标异常,请重新选择"
			return
		}
		fromEdbInfoId = req.EdbInfoIdArr[0].EdbInfoId

		//校验时间格式
		//数据格式：2022-11-01,2022-11-10
		timeList := strings.Split(req.Formula, ",")
		if len(timeList) != 2 {
			br.Msg = "选择时间有误,请重新输入"
			return
		}
		startDate, err := time.ParseInLocation(utils.FormatDate, timeList[0], time.Local)
		if err != nil {
			br.Msg = "开始日期有误,请重新输入"
			return
		}
		endDate, err := time.ParseInLocation(utils.FormatDate, timeList[1], time.Local)
		if err != nil {
			br.Msg = "结束日期有误,请重新输入"
			return
		}
		if utils.GetTimeSubDay(startDate, endDate) < 2 {
			br.Msg = "日期间隔不得少于两天"
			return
		}
		nhccDate.StartDate = startDate
		nhccDate.EndDate = endDate
	case utils.DATA_SOURCE_CALCULATE_JP:
		if req.Formula != "期末值" && req.Formula != "平均值" {
			br.Msg = "数据取值类型错误:" + req.Formula
			return
		}
	case utils.DATA_SOURCE_CALCULATE_ZSXY: // 指数修匀
		if req.Formula == "" {
			br.Msg = "请填写alpha值"
			return
		}
		a, e := strconv.ParseFloat(req.Formula, 64)
		if e != nil {
			br.Msg = "alpha值输入错误, 请重新输入"
			return
		}
		if a <= 0 || a >= 1 {
			br.Msg = "alpha值输入错误, 请重新输入"
			return
		}
	}

	notNeedFromEdbSourceList := []int{utils.DATA_SOURCE_CALCULATE_KSZS, utils.DATA_SOURCE_CALCULATE_CORRELATION, utils.DATA_SOURCE_CALCULATE_ZDYFX} // 不需要传入来源指标id的 指标类型
	if fromEdbInfoId <= 0 && !utils.InArrayByInt(notNeedFromEdbSourceList, req.Source) {
		br.Msg = "请选择指标"
		return
	}
	//加入缓存机制，避免创建同一个名称的指标 start
	redisKey := fmt.Sprint("edb_lib:edb_info:calculate:batch:save:", req.Source, ":", req.EdbName)
	isExist := utils.Rc.IsExist(redisKey)
	if isExist {
		br.Msg = "指标正在处理,请勿重复提交"
		return
	} else {
		//设置3分钟缓存
		utils.Rc.SetNX(redisKey, 1, time.Second*300)
		defer func() {
			_ = utils.Rc.Delete(redisKey)
		}()
	}
	//加入缓存机制，避免创建同一个名称的指标 end

	// 根据指标名称和指标ID校验库中是否还存在其他同名指标
	existEdbName, err := logic.CheckExistByEdbNameAndEdbInfoId(utils.EDB_INFO_TYPE, req.EdbInfoId, req.EdbName, this.Lang)
	if err != nil {
		br.Msg = "判断指标名称是否存在失败"
		br.ErrMsg = "判断指标名称是否存在失败,Err:" + err.Error()
		return
	}

	if existEdbName {
		br.Msg = "指标名称已存在，请重新填写"
		br.ErrMsg = "指标名称已存在，请重新填写"
		br.IsSendEmail = false
		return
	}

	// 来源指标
	var fromEdbInfo *models.EdbInfo
	if fromEdbInfoId > 0 {
		fromEdbInfo, err = models.GetEdbInfoById(fromEdbInfoId)
		if err != nil {
			br.Msg = "获取指标信息失败"
			br.ErrMsg = "获取指标信息失败:Err:" + err.Error()
			return
		}
	}

	//生成指标编码
	edbCode, err := utils.GenerateEdbCode(1, "")
	if err != nil {
		br.Msg = "指标生成失败"
		br.ErrMsg = "指标编码生成失败，Err：" + err.Error()
		return
	}
	timestamp := strconv.FormatInt(time.Now().UnixNano(), 10)
	uniqueCode := utils.MD5(utils.DATA_PREFIX + "_" + timestamp)

	sysUserId := req.AdminId
	sysUserName := req.AdminName

	var sourName string
	var edbInfoId int
	var edbInfo *models.EdbInfo
	var errMsg string

	var baseEdbInfoModel models.BaseEdbInfoInterface
	addParam := models.AddCalculateBatchParams{
		Req:             &req,
		FromEdbInfo:     fromEdbInfo,
		EdbCode:         edbCode,
		UniqueCode:      uniqueCode,
		SysUserId:       sysUserId,
		SysUserRealName: sysUserName,
	}

	switch req.Source {
	case utils.DATA_SOURCE_CALCULATE_LJZZY:
		sourName = "累计值转月值"
		if fromEdbInfo.Frequency != "月度" {
			br.Msg = "请选择月度指标"
			return
		}
		edbInfo, err = models.AddCalculateLjzzy(&req, fromEdbInfo, edbCode, uniqueCode, sysUserId, sysUserName)
	case utils.DATA_SOURCE_CALCULATE_TBZ:
		if req.Frequency != fromEdbInfo.Frequency {
			br.Msg = "当前频度和原指标频度不一致"
			return
		}
		if req.Unit != "无" {
			br.Msg = "单位只允许为无，禁止选择其他单位"
			return
		}
		sourName = "同比值"
		edbInfo, err = models.AddCalculateTbz(&req, fromEdbInfo, edbCode, uniqueCode, sysUserId, sysUserName)
	case utils.DATA_SOURCE_CALCULATE_TCZ:
		if req.Frequency != fromEdbInfo.Frequency {
			br.Msg = "当前频度和原指标频度不一致"
			return
		}
		if req.Unit != fromEdbInfo.Unit {
			br.Msg = "当前单位和原指标单位不一致"
			return
		}
		sourName = "同差值"
		edbInfo, err = models.AddCalculateTcz(&req, fromEdbInfo, edbCode, uniqueCode, sysUserId, sysUserName)
	case utils.DATA_SOURCE_CALCULATE_NSZYDPJJS:
		sourName = "N数值移动平均计算"
		edbInfo, err = models.AddCalculateNszydpjjs(&req, fromEdbInfo, edbCode, uniqueCode, sysUserId, sysUserName, formulaInt)
	case utils.DATA_SOURCE_CALCULATE_HBZ:
		checkCount, tmpErr := models.GetLteZeroEdbDataCount(fromEdbInfo.Source, fromEdbInfo.SubSource, fromEdbInfoId)
		if tmpErr != nil && tmpErr.Error() != utils.ErrNoRow() {
			br.Msg = "判断环比值是否可计算失败"
			br.ErrMsg = "判断环比值是否可计算失败,Err:" + tmpErr.Error()
			return
		}
		if checkCount > 0 {
			br.Msg = "原始数据中存在0或负数，该指标不能进行环比运算"
			br.ErrMsg = "原始数据中出现0和负值时，提示该指标不能进行环比运算"
			return
		}
		sourName = "环比值"
		edbInfo, err = models.AddCalculateHbz(&req, fromEdbInfo, edbCode, uniqueCode, sysUserId, sysUserName, formulaInt)
	case utils.DATA_SOURCE_CALCULATE_HCZ:
		sourName = "环差值"
		edbInfo, err = models.AddCalculateHcz(&req, fromEdbInfo, edbCode, uniqueCode, sysUserId, sysUserName, formulaInt)
	case utils.DATA_SOURCE_CALCULATE_BP:
		sourName = utils.DATA_SOURCE_NAME_CALCULATE_BP
		edbInfo, err = models.AddCalculateBp(&req, fromEdbInfo, edbCode, uniqueCode, sysUserId, sysUserName)
	case utils.DATA_SOURCE_CALCULATE_TIME_SHIFT:
		sourName = "时间移位"
		edbInfo, err = models.AddCalculateTimeShift(&req, fromEdbInfo, edbCode, uniqueCode, sysUserId, sysUserName)
	case utils.DATA_SOURCE_CALCULATE_ZJPJ:
		sourName = "直接拼接"

		if len(req.EdbInfoIdArr) != 1 {
			br.Msg = "请传入拼接日期之后的指标"
			br.ErrMsg = "请传入拼接日期之后的指标"
			return
		}

		secondEdbInfoReq := req.EdbInfoIdArr[0]
		secondEdbInfo, tmpErr := models.GetEdbInfoById(secondEdbInfoReq.EdbInfoId)
		if tmpErr != nil {
			br.Msg = "获取拼接日期之后的指标信息失败"
			br.ErrMsg = "获取拼接日期之后的指标信息失败:Err:" + tmpErr.Error()
			return
		}

		if fromEdbInfo.EdbInfoId == secondEdbInfo.EdbInfoId {
			br.Msg = "两个指标不允许为同一个"
			br.ErrMsg = "两个指标不允许为同一个"
			return
		}
		edbInfo, err = models.AddCalculateZjpj(&req, fromEdbInfo, secondEdbInfo, edbCode, uniqueCode, sysUserId, sysUserName)
	case utils.DATA_SOURCE_CALCULATE_LJZTBPJ:
		sourName = "累计值同比拼接"

		if fromEdbInfo.Frequency != "月度" {
			br.Msg = "待拼接指标只能筛选月度指标"
			br.ErrMsg = "待拼接指标只能筛选月度指标"
			return
		}
		if len(req.EdbInfoIdArr) != 1 {
			br.Msg = "请传入同比值指标"
			br.ErrMsg = "请传入同比值指标"
			return
		}

		secondEdbInfoReq := req.EdbInfoIdArr[0]
		tbzEdbInfo, tmpErr := models.GetEdbInfoById(secondEdbInfoReq.EdbInfoId)
		if tmpErr != nil {
			br.Msg = "获取同比值指标信息失败"
			br.ErrMsg = "获取同比值指标信息失败:Err:" + tmpErr.Error()
			return
		}
		if tbzEdbInfo.Source != utils.DATA_SOURCE_CALCULATE_TBZ {
			br.Msg = "指标必须是传入同比值指标类型"
			br.ErrMsg = "指标必须是传入同比值指标类型"
			return
		}
		if tbzEdbInfo.Frequency != "月度" {
			br.Msg = "同比值指标只能筛选月度指标"
			br.ErrMsg = "同比值指标只能筛选月度指标"
			return
		}

		if fromEdbInfo.EdbInfoId == tbzEdbInfo.EdbInfoId {
			br.Msg = "两个指标不允许为同一个"
			br.ErrMsg = "两个指标不允许为同一个"
			return
		}
		edbInfo, err = models.AddCalculateLjztbpj(&req, fromEdbInfo, tbzEdbInfo, edbCode, uniqueCode, sysUserId, sysUserName)
	case utils.DATA_SOURCE_CALCULATE_CJJX:
		sourName = "超季节性"
		edbInfo, err = models.AddCalculateCjjx(&req, fromEdbInfo, edbCode, uniqueCode, sysUserId, sysUserName, formulaInt)
	case utils.DATA_SOURCE_CALCULATE_NHCC:
		sourName = "拟合残差"

		secondEdbInfoReq := req.EdbInfoIdArr[1]
		secondEdbInfo, tmpErr := models.GetEdbInfoById(secondEdbInfoReq.EdbInfoId)
		if tmpErr != nil {
			br.Msg = "获取因变量的指标信息失败"
			br.ErrMsg = "获取因变量的指标信息失败:Err:" + tmpErr.Error()
			return
		}

		if fromEdbInfo.EdbInfoId == secondEdbInfo.EdbInfoId {
			br.Msg = "两个指标不允许为同一个"
			br.ErrMsg = "两个指标不允许为同一个"
			return
		}
		edbInfo, err, errMsg = models.AddCalculateNhcc(&req, fromEdbInfo, secondEdbInfo, edbCode, uniqueCode, nhccDate, sysUserId, sysUserName)
	case utils.DATA_SOURCE_CALCULATE_JP:
		if !models.CheckFrequency(fromEdbInfo.Frequency, req.Frequency) {
			br.Msg = "频度异常,不允许低频降频到高频"
			return
		}
		sourName = utils.DATA_SOURCE_NAME_CALCULATE_JP
		edbInfo, err = models.AddCalculateJp(&req, fromEdbInfo, edbCode, uniqueCode, sysUserId, sysUserName)
	case utils.DATA_SOURCE_CALCULATE_NH:
		sourName = utils.DATA_SOURCE_NAME_CALCULATE_NH
		edbInfo, err = models.AddCalculateNh(&req, fromEdbInfo, edbCode, uniqueCode, sysUserId, sysUserName)
	case utils.DATA_SOURCE_CALCULATE_KSZS:
		//关联的指标信息
		if len(req.EdbInfoIdArr) < 2 {
			br.Msg = "指标数量不能小于2个，请重新选择"
			br.ErrMsg = "指标数量不能小于2个，请重新选择"
			br.IsSendEmail = false
			return
		}
		sourName = utils.DATA_SOURCE_NAME_CALCULATE_KSZS
		edbInfo, err = models.AddCalculateKszs(&req, edbCode, uniqueCode, sysUserId, sysUserName)
	case utils.DATA_SOURCE_CALCULATE_CORRELATION:
		//关联的指标信息
		if len(req.EdbInfoIdArr) < 2 {
			br.Msg = "指标数量不能小于2个，请重新选择"
			br.ErrMsg = "指标数量不能小于2个，请重新选择"
			br.IsSendEmail = false
			return
		}
		sourName = utils.DATA_SOURCE_NAME_CALCULATE_CORRELATION
		edbInfo, err, errMsg = models.AddCalculateCorrelation(&req, edbCode, uniqueCode, sysUserId, sysUserName)
	case utils.DATA_SOURCE_CALCULATE_RJZ:
		if req.Frequency == "日度" {
			br.Msg = "日度指标无需进行日均值计算"
			return
		}
		if req.Frequency != fromEdbInfo.Frequency {
			br.Msg = "当前频度和原指标频度不一致"
			return
		}
		if req.Unit != fromEdbInfo.Unit {
			br.Msg = "单位只允许为和原指标频度保持一致，禁止选择其他单位"
			return
		}
		sourName = "日均值"
		edbInfo, err = models.AddCalculateRjz(&req, fromEdbInfo, edbCode, uniqueCode, sysUserId, sysUserName)
	case utils.DATA_SOURCE_CALCULATE_PHASE_SHIFT:
		sourName = "期数移位"
		edbInfo, err = models.AddCalculatePhaseShift(&req, fromEdbInfo, edbCode, uniqueCode, sysUserId, sysUserName)
	default:
		// 获取通用的数据源处理服务
		baseEdbInfoModel = models.GetBaseEdbInfoModel(req.Source)
		// 没有找到的话，那么就直接返回报错吧
		if baseEdbInfoModel == nil {
			br.Msg = "无效计算方式"
			br.ErrMsg = "无效计算方式,source:" + strconv.Itoa(req.Source)
			return
		}
		sourName = baseEdbInfoModel.GetSourceName()
		edbInfo, err, errMsg = baseEdbInfoModel.Add(addParam)
	}

	if err != nil {
		br.Msg = "生成" + sourName + "失败"
		if errMsg != `` {
			br.Msg = errMsg
		}
		br.ErrMsg = "生成" + sourName + "失败 Err:" + err.Error()
		return
	}

	if edbInfo == nil {
		br.Msg = "生成" + sourName + "失败"
		br.ErrMsg = "生成" + sourName + "失败,指标ID错误:" + strconv.Itoa(edbInfoId)
		return
	}
	edbInfoId = edbInfo.EdbInfoId

	//处理同名指标
	{
		edbNameList, err := models.GetEdbInfoByName(req.EdbName)
		if err != nil {
			br.Msg = "保存失败"
			br.ErrMsg = "获取指标信息失败，Err:" + err.Error()
			return
		}
		if len(edbNameList) >= 2 {
			for _, v := range edbNameList {
				edbName := v.EdbName + "(" + v.SourceName + ")"
				err = models.ModifyEdbInfoNameSource(edbName, v.EdbInfoId)
				if err != nil {
					br.Msg = "保存失败"
					br.ErrMsg = "修改指标名称失败，Err:" + err.Error()
					return
				}
			}
		}
	}

	// 更新指标最大最小值
	err, errMsg = models.UnifiedModifyEdbInfoMaxAndMinInfo(edbInfo)
	if err != nil {
		br.Msg = errMsg
		br.ErrMsg = err.Error()
		return
	}

	newEdbInfo := new(models.EdbInfoEditRecord)
	newEdbInfo.EdbName = req.EdbName
	newEdbInfo.Frequency = req.Frequency
	newEdbInfo.Unit = req.Unit
	newEdbInfo.OperateUserId = req.AdminId
	newEdbInfo.OperateUserRealName = req.AdminName
	err = services.AddEditEdbInfoRecord(edbInfo, newEdbInfo)
	if err != nil {
		br.Msg = "保存失败"
		br.ErrMsg = "保存失败,Err:" + err.Error()
		return
	}
	// 判断是否需要禁用
	go services.DisableEdbInfoNoUpdate(edbInfo)
	resp := models.AddEdbInfoResp{
		EdbInfoId:  edbInfo.EdbInfoId,
		UniqueCode: edbInfo.UniqueCode,
	}
	br.Ret = 200
	br.Success = true
	br.Msg = "保存成功"
	br.Data = resp
	br.IsAddLog = true
}

// BatchEdit
// @Title 累计值转月-同比值-同差等计算新增
// @Description 累计值转月-同比值-同差等计算新增接口
// @Param request body models.EdbInfoCalculateBatchSaveReq true "type json string"
// @Success Ret=200 返回指标id
// @router /batch/edit [post]
func (this *CalculateController) BatchEdit() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()

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

	if req.EdbName == "" {
		br.Msg = "指标名称不能为空"
		return
	}

	if req.Frequency == "" {
		br.Msg = "频率不能为空"
		return
	}

	if req.Unit == "" {
		br.Msg = "单位不能为空"
		return
	}

	if req.ClassifyId <= 0 {
		br.Msg = "请选择分类"
		return
	}

	if req.EdbInfoId <= 0 {
		br.Msg = "请选择指标"
		return
	}

	// 根据指标名称和指标ID校验库中是否还存在其他同名指标
	existEdbName, err := logic.CheckExistByEdbNameAndEdbInfoId(utils.EDB_INFO_TYPE, req.EdbInfoId, req.EdbName, this.Lang)
	if err != nil {
		br.Msg = "判断指标名称是否存在失败"
		br.ErrMsg = "判断指标名称是否存在失败,Err:" + err.Error()
		return
	}

	if existEdbName {
		br.Msg = "指标名称已存在，请重新填写"
		br.ErrMsg = "指标名称已存在，请重新填写"
		br.IsSendEmail = false
		return
	}

	edbInfo, err := models.GetEdbInfoById(req.EdbInfoId)
	if err != nil {
		if err.Error() == utils.ErrNoRow() {
			br.Msg = "指标已被删除，请刷新页面"
			br.ErrMsg = "指标已被删除，请刷新页面:Err:" + err.Error()
			return
		}
		br.Msg = "获取指标信息失败"
		br.ErrMsg = "获取指标信息失败:Err:" + err.Error()
		return
	}
	// 记录原始指标信息
	oldEdbName := edbInfo.EdbName
	oldFrequency := edbInfo.Frequency
	oldUnit := edbInfo.Unit

	// 基础指标id
	fromEdbInfoId := req.FromEdbInfoId

	if req.Source <= 0 {
		req.Source = edbInfo.Source
	}

	var formulaInt int
	var nhccDate models.NhccDate // 拟合残差的日期
	// 初期的参数校验
	switch req.Source {
	case utils.DATA_SOURCE_CALCULATE_NSZYDPJJS, utils.DATA_SOURCE_CALCULATE_HBZ, utils.DATA_SOURCE_CALCULATE_HCZ, utils.DATA_SOURCE_CALCULATE_TIME_SHIFT, utils.DATA_SOURCE_CALCULATE_CJJX:
		if req.Formula == "" {
			br.Msg = "请填写N值"
			return
		}
		formulaInt, _ = strconv.Atoi(req.Formula)
		if formulaInt <= 0 {
			br.Msg = "N值输入错误,请重新输入"
			return
		}
	case utils.DATA_SOURCE_CALCULATE_ZJPJ:
		//直接拼接指标

		//校验时间格式
		_, err = time.ParseInLocation(utils.FormatDate, req.Formula, time.Local)
		if err != nil {
			br.Msg = "拼接日期有误,请重新输入"
			return
		}
	case utils.DATA_SOURCE_CALCULATE_NHCC: //拟合残差指标
		//指标校验
		if len(req.EdbInfoIdArr) != 2 {
			br.Msg = "选择的指标异常,请重新选择"
			return
		}
		fromEdbInfoId = req.EdbInfoIdArr[0].EdbInfoId

		//校验时间格式
		//数据格式：2022-11-01,2022-11-10
		timeList := strings.Split(req.Formula, ",")
		if len(timeList) != 2 {
			br.Msg = "选择时间有误,请重新输入"
			return
		}
		startDate, err := time.ParseInLocation(utils.FormatDate, timeList[0], time.Local)
		if err != nil {
			br.Msg = "开始日期有误,请重新输入"
			return
		}
		endDate, err := time.ParseInLocation(utils.FormatDate, timeList[1], time.Local)
		if err != nil {
			br.Msg = "结束日期有误,请重新输入"
			return
		}
		if utils.GetTimeSubDay(startDate, endDate) < 2 {
			br.Msg = "日期间隔不得少于两天"
			return
		}
		nhccDate.StartDate = startDate
		nhccDate.EndDate = endDate
	case utils.DATA_SOURCE_CALCULATE_JP:
		if req.Formula != "期末值" && req.Formula != "平均值" {
			br.Msg = "数据取值类型错误:" + req.Formula
			return
		}
	case utils.DATA_SOURCE_CALCULATE_ZSXY: // 指数修匀
		if req.Formula == "" {
			br.Msg = "请填写alpha值"
			return
		}
		a, e := strconv.ParseFloat(req.Formula, 64)
		if e != nil {
			br.Msg = "alpha值输入错误, 请重新输入"
			return
		}
		if a <= 0 || a >= 1 {
			br.Msg = "alpha值输入错误, 请重新输入"
			return
		}
	}

	var fromEdbInfo *models.EdbInfo
	if fromEdbInfoId > 0 {
		// 获取基础指标信息
		fromEdbInfo, err = models.GetEdbInfoById(fromEdbInfoId)
		if err != nil {
			if err.Error() == utils.ErrNoRow() {
				br.Msg = "指标已被删除，请刷新页面"
				br.ErrMsg = "指标已被删除，请刷新页面:Err:" + err.Error()
				return
			}
			br.Msg = "获取指标信息失败"
			br.ErrMsg = "获取指标信息失败:Err:" + err.Error()
			return
		}
	}

	//dataUpdateTime := time.Now().Format(utils.FormatDateTime)

	// 额外赋值
	switch this.Lang {
	case utils.EnLangVersion:
		req.EdbNameEn = req.EdbName
		req.UnitEn = req.Unit

		req.EdbName = edbInfo.EdbName
		req.Unit = edbInfo.Unit
	default:
		req.EdbNameEn = edbInfo.EdbNameEn
		req.UnitEn = edbInfo.UnitEn
	}

	var sourName, errMsg string
	var edbInfoId int
	var baseEdbInfoModel models.BaseEdbInfoInterface
	editParams := models.EditCalculateBatchParams{
		Req:         &req,
		EdbInfo:     edbInfo,
		FromEdbInfo: fromEdbInfo,
	}

	switch req.Source {
	case utils.DATA_SOURCE_CALCULATE_LJZZY:
		sourName = "累计值转月值"
		if fromEdbInfo.Frequency != "月度" {
			br.Msg = "请选择月度指标"
			return
		}
		err = models.EditCalculateLjzzy(edbInfo, &req, fromEdbInfo)
	case utils.DATA_SOURCE_CALCULATE_TBZ:
		sourName = "同比值"
		err = models.EditCalculateTbz(edbInfo, &req, fromEdbInfo)
	case utils.DATA_SOURCE_CALCULATE_TCZ:
		fmt.Println("start edit", time.Now())
		sourName = "同差值"
		err = models.EditCalculateTcz(edbInfo, &req, fromEdbInfo)
		fmt.Println("end edit", time.Now())
	case utils.DATA_SOURCE_CALCULATE_NSZYDPJJS:
		sourName = "N数值移动平均计算"
		err = models.EditCalculateNszydpjjs(edbInfo, &req, fromEdbInfo, formulaInt, edbInfo.CalculateFormula)
	case utils.DATA_SOURCE_CALCULATE_HBZ:
		checkCount, tmpErr := models.GetLteZeroEdbDataCount(fromEdbInfo.Source, fromEdbInfo.SubSource, req.FromEdbInfoId)
		if tmpErr != nil && tmpErr.Error() != utils.ErrNoRow() {
			br.Msg = "判断环比值是否可计算失败"
			br.ErrMsg = "判断环比值是否可计算失败,Err:" + tmpErr.Error()
			return
		}
		if checkCount > 0 {
			br.Msg = "原始数据中存在0或负数，该指标不能进行环比运算"
			br.ErrMsg = "原始数据中出现0和负值时，提示该指标不能进行环比运算"
			return
		}
		sourName = "环比值"
		err = models.EditCalculateHbz(edbInfo, &req, fromEdbInfo, formulaInt, edbInfo.CalculateFormula)
	case utils.DATA_SOURCE_CALCULATE_HCZ:
		sourName = "环差值"
		err = models.EditCalculateHcz(edbInfo, &req, fromEdbInfo, formulaInt, edbInfo.CalculateFormula)
	case utils.DATA_SOURCE_CALCULATE_BP:
		sourName = utils.DATA_SOURCE_NAME_CALCULATE_BP
		err = models.EditCalculateBp(edbInfo, &req, fromEdbInfo)
	case utils.DATA_SOURCE_CALCULATE_TIME_SHIFT:
		sourName = "时间移位"
		err = models.EditCalculateTimeShift(edbInfo, &req, fromEdbInfo)
	case utils.DATA_SOURCE_CALCULATE_PHASE_SHIFT:
		sourName = "期数移位"
		err = models.EditCalculatePhaseShift(edbInfo, &req, fromEdbInfo)
	case utils.DATA_SOURCE_CALCULATE_ZJPJ:
		sourName = "直接拼接"

		if len(req.EdbInfoIdArr) != 1 {
			br.Msg = "请传入拼接日期之后的指标"
			br.ErrMsg = "请传入拼接日期之后的指标"
			return
		}

		secondEdbInfoReq := req.EdbInfoIdArr[0]
		secondEdbInfo, tmpErr := models.GetEdbInfoById(secondEdbInfoReq.EdbInfoId)
		if tmpErr != nil {
			br.Msg = "获取拼接日期之后的指标信息失败"
			br.ErrMsg = "获取拼接日期之后的指标信息失败:Err:" + tmpErr.Error()
			return
		}

		if fromEdbInfo.EdbInfoId == secondEdbInfo.EdbInfoId {
			br.Msg = "两个指标不允许为同一个"
			br.ErrMsg = "两个指标不允许为同一个"
			return
		}
		err = models.EditCalculateZjpj(&req, edbInfo, fromEdbInfo, secondEdbInfo)
	case utils.DATA_SOURCE_CALCULATE_LJZTBPJ: //累计值同比拼接
		sourName = "累计值同比拼接"

		if fromEdbInfo.Frequency != "月度" {
			br.Msg = "待拼接指标只能筛选月度指标"
			br.ErrMsg = "待拼接指标只能筛选月度指标"
			return
		}
		if len(req.EdbInfoIdArr) != 1 {
			br.Msg = "请传入同比值指标"
			br.ErrMsg = "请传入同比值指标"
			return
		}

		secondEdbInfoReq := req.EdbInfoIdArr[0]
		tbzEdbInfo, tmpErr := models.GetEdbInfoById(secondEdbInfoReq.EdbInfoId)
		if tmpErr != nil {
			br.Msg = "获取同比值指标信息失败"
			br.ErrMsg = "获取同比值指标信息失败:Err:" + tmpErr.Error()
			return
		}
		if tbzEdbInfo.Source != utils.DATA_SOURCE_CALCULATE_TBZ {
			br.Msg = "指标必须是传入同比值指标类型"
			br.ErrMsg = "指标必须是传入同比值指标类型"
			return
		}
		if tbzEdbInfo.Frequency != "月度" {
			br.Msg = "同比值指标只能筛选月度指标"
			br.ErrMsg = "同比值指标只能筛选月度指标"
			return
		}

		if fromEdbInfo.EdbInfoId == tbzEdbInfo.EdbInfoId {
			br.Msg = "两个指标不允许为同一个"
			br.ErrMsg = "两个指标不允许为同一个"
			return
		}
		err = models.EditCalculateLjztbpj(&req, edbInfo, fromEdbInfo, tbzEdbInfo)
	case utils.DATA_SOURCE_CALCULATE_CJJX:
		sourName = "超季节性"
		err = models.EditCalculateCjjx(&req, edbInfo, fromEdbInfo, formulaInt)
	case utils.DATA_SOURCE_CALCULATE_NHCC:
		sourName = "拟合残差"
		secondEdbInfoReq := req.EdbInfoIdArr[1]
		secondEdbInfo, tmpErr := models.GetEdbInfoById(secondEdbInfoReq.EdbInfoId)
		if tmpErr != nil {
			br.Msg = "获取因变量的指标信息失败"
			br.ErrMsg = "获取因变量的指标信息失败:Err:" + tmpErr.Error()
			return
		}

		if fromEdbInfo.EdbInfoId == secondEdbInfo.EdbInfoId {
			br.Msg = "两个指标不允许为同一个"
			br.ErrMsg = "两个指标不允许为同一个"
			return
		}
		err, errMsg = models.EditCalculateNhcc(&req, edbInfo, fromEdbInfo, secondEdbInfo, nhccDate)
	case utils.DATA_SOURCE_CALCULATE_JP:
		if !models.CheckFrequency(fromEdbInfo.Frequency, req.Frequency) {
			br.Msg = "频度异常,不允许低频降频到高频"
			return
		}
		sourName = utils.DATA_SOURCE_NAME_CALCULATE_JP
		err = models.EditCalculateJp(edbInfo, &req, fromEdbInfo)
	case utils.DATA_SOURCE_CALCULATE_NH:
		sourName = utils.DATA_SOURCE_NAME_CALCULATE_NH
		err = models.EditCalculateNh(edbInfo, &req, fromEdbInfo)
	case utils.DATA_SOURCE_CALCULATE_KSZS:
		//关联的指标信息
		if len(req.EdbInfoIdArr) < 2 {
			br.Msg = "指标数量不能小于2个，请重新选择"
			br.ErrMsg = "指标数量不能小于2个，请重新选择"
			br.IsSendEmail = false
			return
		}
		sourName = utils.DATA_SOURCE_NAME_CALCULATE_KSZS
		err = models.EditCalculateKszs(edbInfo, &req)
	case utils.DATA_SOURCE_CALCULATE_CORRELATION:
		//关联的指标信息
		if len(req.EdbInfoIdArr) < 2 {
			br.Msg = "指标数量不能小于2个，请重新选择"
			br.ErrMsg = "指标数量不能小于2个，请重新选择"
			br.IsSendEmail = false
			return
		}
		sourName = utils.DATA_SOURCE_NAME_CALCULATE_CORRELATION
		err, errMsg = models.EditCalculateCorrelation(edbInfo, &req)
	case utils.DATA_SOURCE_CALCULATE_RJZ:
		if req.Frequency == "日度" {
			br.Msg = "日度指标无需进行日均值计算"
			return
		}
		if req.Frequency != fromEdbInfo.Frequency {
			br.Msg = "当前频度和原指标频度不一致"
			return
		}
		if req.Unit != fromEdbInfo.Unit {
			br.Msg = "单位只允许为和原指标频度保持一致，禁止选择其他单位"
			return
		}
		sourName = "日均值"
		err = models.EditCalculateRjz(edbInfo, &req, fromEdbInfo)
	default:
		// 获取通用的数据源处理服务
		baseEdbInfoModel = models.GetBaseEdbInfoModel(req.Source)
		// 没有找到的话，那么就直接返回报错吧
		if baseEdbInfoModel == nil {
			br.Msg = "无效计算方式"
			br.ErrMsg = "无效计算方式,source:" + strconv.Itoa(req.Source)
			return
		}
		sourName = baseEdbInfoModel.GetSourceName()
		err, errMsg = baseEdbInfoModel.Edit(editParams)
	}
	if err != nil {
		br.Msg = "生成" + sourName + "失败"
		if errMsg != `` {
			br.Msg = errMsg
		}
		br.Msg = "生成" + sourName + "失败 Err:" + err.Error()
		return
	}
	if edbInfo == nil {
		br.Msg = "生成" + sourName + "失败"
		br.ErrMsg = "生成" + sourName + "失败,指标ID错误:" + strconv.Itoa(edbInfoId)
		return
	}
	edbInfoId = edbInfo.EdbInfoId

	//处理同名指标
	{
		edbNameList, err := models.GetEdbInfoByName(req.EdbName)
		if err != nil {
			br.Msg = "保存失败"
			br.ErrMsg = "获取指标信息失败，Err:" + err.Error()
			return
		}
		if len(edbNameList) >= 2 {
			for _, v := range edbNameList {
				edbName := v.EdbName + "(" + v.SourceName + ")"
				err = models.ModifyEdbInfoNameSource(edbName, v.EdbInfoId)
				if err != nil {
					br.Msg = "保存失败"
					br.ErrMsg = "修改指标名称失败，Err:" + err.Error()
					return
				}
			}
		}
	}

	// 更新指标最大最小值
	//err, errMsg = models.UnifiedModifyEdbInfoMaxAndMinInfoTmp(edbInfo, dataUpdateTime)
	err, errMsg = models.UnifiedModifyEdbInfoMaxAndMinInfo(edbInfo)
	if err != nil {
		br.Msg = errMsg
		br.ErrMsg = err.Error()
		return
	}
	// 记录指标的操作记录
	oldEdbInfo := new(models.EdbInfo)
	oldEdbInfo.EdbInfoId = edbInfo.EdbInfoId
	oldEdbInfo.EdbName = oldEdbName
	oldEdbInfo.Frequency = oldFrequency
	oldEdbInfo.Unit = oldUnit
	newEdbInfoRecord := new(models.EdbInfoEditRecord)
	newEdbInfoRecord.EdbName = req.EdbName
	newEdbInfoRecord.Frequency = req.Frequency
	newEdbInfoRecord.Unit = req.Unit
	newEdbInfoRecord.OperateUserId = req.AdminId
	newEdbInfoRecord.OperateUserRealName = req.AdminName
	err = services.AddEditEdbInfoRecord(oldEdbInfo, newEdbInfoRecord)
	if err != nil {
		br.Msg = "保存失败"
		br.ErrMsg = "记录指标操作记录失败，Err:" + err.Error()
	}

	// 重置计算指标中的引用关系
	go services.ResetEdbRelation(edbInfoId)

	resp := models.AddEdbInfoResp{
		EdbInfoId:  edbInfo.EdbInfoId,
		UniqueCode: edbInfo.UniqueCode,
	}
	br.Ret = 200
	br.Success = true
	br.Msg = "保存成功"
	br.Data = resp
	br.IsAddLog = true
}

// Refresh
// @Title 刷新计算指标接口
// @Description 刷新计算指标接口
// @Success 200 {object} models.RefreshEdbInfoReq
// @router /refresh [post]
func (this *CalculateController) Refresh() {
	br := new(models.BaseResponse).Init()
	var cacheKey string
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	var req models.RefreshEdbInfoReq
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}
	if req.EdbCode == "" {
		br.Msg = "请输入指标编码！"
		br.ErrMsg = "请输入指标编码，指标编码为空"
		return
	}
	if req.EdbInfoId <= 0 {
		br.Msg = "请输入指标ID！"
		br.ErrMsg = "请输入指标ID"
		return
	}
	edbInfo, err := models.GetEdbInfoById(req.EdbInfoId)
	if err != nil {
		br.Msg = "指标不存在！"
		br.ErrMsg = "指标不存在"
		return
	}

	cacheKey = utils.CACHE_EDB_DATA_REFRESH + strconv.Itoa(edbInfo.Source) + "_" + req.EdbCode

	if utils.Rc.IsExist(cacheKey) {
		br.Ret = 501
		br.Success = true
		br.Msg = "系统处理中，请稍后重试"
		return
	}

	// 刷新指标
	utils.Rc.SetNX(cacheKey, 1, 1*time.Minute)
	defer func() {
		_ = utils.Rc.Delete(cacheKey)
	}()

	startDate := req.StartDate
	var errMsg string
	endDate := time.Now().Format(utils.FormatDate)
	edbInfoId := edbInfo.EdbInfoId
	source := edbInfo.Source
	subSource := edbInfo.SubSource

	var baseEdbInfoModel models.BaseEdbInfoInterface
	refreshParams := models.RefreshParams{
		EdbInfo:   edbInfo,
		StartDate: "", // 更新所有
		EndDate:   "", // 更新所有数据
	}

	switch source {
	case utils.DATA_SOURCE_CALCULATE:
		//startDate = edbInfo.StartDate
		//sTime, err := time.ParseInLocation(utils.FormatDate, edbInfo.EndDate,time.Local)
		//if err != nil {
		//	return
		//}
		//startDate = sTime.Format(utils.FormatDate)
		startDate = ""
		var edbInfoIdBytes []string
		calculateMap, err := models.GetEdbInfoCalculateDetailList(edbInfo.EdbInfoId)
		if err != nil {
			errMsg = "GetEdbInfoCalculateDetail Err:" + err.Error()
			break
		}
		var formulaStr string
		edbInfoList := make([]*models.EdbInfo, 0)
		edbInfoTag := make(map[string]int)
		for _, v := range calculateMap {
			edbInfoTag[v.FromTag] = v.FromEdbInfoId
			formulaStr += v.FromTag + ","
			edbInfoIdBytes = append(edbInfoIdBytes, v.FromTag)
			edbInfo, _ := models.GetEdbInfoById(v.FromEdbInfoId)
			edbInfoList = append(edbInfoList, edbInfo)
		}
		err = models.RefreshAllCalculate(edbInfoList, edbInfoTag, edbInfo.EdbInfoId, source, subSource, edbInfo.EdbCode, edbInfo.CalculateFormula, startDate, endDate, edbInfoIdBytes, edbInfo.EmptyType, edbInfo.MaxEmptyType, edbInfo.Extra)
		if err != nil && err.Error() != utils.ErrNoRow() {
			errMsg = "RefreshCalculate Err:" + err.Error()
			break
		}
	case utils.DATA_SOURCE_CALCULATE_LJZZY: //刷新累计值转月值
		calculateLjzzy, err := models.GetEdbInfoCalculateMappingDetail(edbInfoId)
		if err != nil {
			errMsg = "GetEdbInfoCalculateLjzzyDetail Err:" + err.Error()
			break
		}
		fromEdbInfo, err := models.GetEdbInfoById(calculateLjzzy.FromEdbInfoId)
		if err != nil {
			errMsg = "GetEdbInfoById Err:" + err.Error()
			break
		}
		//startDate = edbInfo.StartDate
		//endDate = time.Now().Format(utils.FormatDate)
		endDate = ``   //只要填写日期，就会出现问题，还是把日期给去掉吧
		startDate = `` //只要填写日期，就会出现问题，还是把日期给去掉吧
		err = models.RefreshAllCalculateLjzzy(edbInfoId, source, subSource, fromEdbInfo, calculateLjzzy.EdbCode, startDate, endDate)
		if err != nil && err.Error() != utils.ErrNoRow() {
			errMsg = "RefreshAllCalculateLjzzy Err:" + err.Error()
			break
		}
	case utils.DATA_SOURCE_CALCULATE_TBZ: //刷新同比值
		calculateTbz, err := models.GetEdbInfoCalculateMappingDetail(edbInfoId)
		if err != nil {
			errMsg = "GetEdbInfoCalculateTbzDetail Err:" + err.Error()
			break
		}
		fromEdbInfo, err := models.GetEdbInfoById(calculateTbz.FromEdbInfoId)
		if err != nil {
			errMsg = "GetEdbInfoById Err:" + err.Error()
			break
		}
		//startDate = edbInfo.StartDate
		endDate = time.Now().Format(utils.FormatDate)
		err = models.RefreshAllCalculateTbz(edbInfoId, source, subSource, fromEdbInfo, calculateTbz.EdbCode, startDate, endDate)
		if err != nil && err.Error() != utils.ErrNoRow() {
			errMsg = "RefreshAllCalculateTbz Err:" + err.Error()
			break
		}
	case utils.DATA_SOURCE_CALCULATE_TCZ: //同差值
		calculateTcz, err := models.GetEdbInfoCalculateMappingDetail(edbInfoId)
		if err != nil {
			errMsg = "GetEdbInfoCalculateTczDetail Err:" + err.Error()
			break
		}
		fromEdbInfo, err := models.GetEdbInfoById(calculateTcz.FromEdbInfoId)
		if err != nil {
			errMsg = "GetEdbInfoById Err:" + err.Error()
			break
		}
		//startDate = edbInfo.StartDate
		endDate = time.Now().Format(utils.FormatDate)
		err = models.RefreshAllCalculateTcz(edbInfoId, source, subSource, fromEdbInfo, calculateTcz.EdbCode, startDate, endDate)
		if err != nil && err.Error() != utils.ErrNoRow() {
			errMsg = "RefreshCalculateTcz Err:" + err.Error()
			break
		}
	case utils.DATA_SOURCE_CALCULATE_NSZYDPJJS: //N数值移动平均计算
		calculateNszydpjjs, err := models.GetEdbInfoCalculateMappingDetail(edbInfoId)
		if err != nil {
			errMsg = "GetEdbInfoCalculateNszydpjjsDetail Err:" + err.Error()
			break
		}
		fromEdbInfo, err := models.GetEdbInfoById(calculateNszydpjjs.FromEdbInfoId)
		if err != nil {
			errMsg = "GetEdbInfoById Err:" + err.Error()
			break
		}
		formulaInt, _ := strconv.Atoi(edbInfo.CalculateFormula)
		//startDate = edbInfo.StartDate
		startDate = `` //只要填写日期，就会出现问题，还是把日期给去掉吧
		err = models.RefreshAllCalculateNszydpjjs(edbInfoId, edbInfo.Source, edbInfo.SubSource, formulaInt, fromEdbInfo, calculateNszydpjjs.EdbCode, startDate)
		if err != nil && err.Error() != utils.ErrNoRow() {
			errMsg = "RefreshCalculateNszydpjjs Err:" + err.Error()
			break
		}
	case utils.DATA_SOURCE_CALCULATE_HBZ: //刷新环比值
		calculateTbz, err := models.GetEdbInfoCalculateMappingDetail(edbInfoId)
		if err != nil {
			errMsg = "GetEdbInfoCalculateHbzDetail Err:" + err.Error()
			break
		}
		fromEdbInfo, err := models.GetEdbInfoById(calculateTbz.FromEdbInfoId)
		if err != nil {
			errMsg = "GetEdbInfoById Err:" + err.Error()
			break
		}
		startDate = `` //只要填写日期，就会出现问题，还是把日期给去掉吧
		endDate = time.Now().Format(utils.FormatDate)
		formulaInt, _ := strconv.Atoi(edbInfo.CalculateFormula)
		err = models.RefreshAllCalculateHbz(edbInfoId, source, subSource, fromEdbInfo, calculateTbz.EdbCode, startDate, endDate, formulaInt)
		if err != nil && err.Error() != utils.ErrNoRow() {
			errMsg = "RefreshAllCalculateHbz Err:" + err.Error()
			break
		}
	case utils.DATA_SOURCE_CALCULATE_HCZ: //刷新环差值
		calculateTbz, err := models.GetEdbInfoCalculateMappingDetail(edbInfoId)
		if err != nil {
			errMsg = "GetEdbInfoCalculateHczDetail Err:" + err.Error()
			break
		}
		fromEdbInfo, err := models.GetEdbInfoById(calculateTbz.FromEdbInfoId)
		if err != nil {
			errMsg = "GetEdbInfoById Err:" + err.Error()
			break
		}
		startDate = `` //只要填写日期，就会出现问题，还是把日期给去掉吧
		endDate = time.Now().Format(utils.FormatDate)
		formulaInt, _ := strconv.Atoi(edbInfo.CalculateFormula)
		err = models.RefreshAllCalculateHcz(edbInfoId, source, subSource, fromEdbInfo, calculateTbz.EdbCode, startDate, endDate, formulaInt)
		if err != nil && err.Error() != utils.ErrNoRow() {
			errMsg = "RefreshAllCalculateHcz Err:" + err.Error()
			break
		}
	case utils.DATA_SOURCE_CALCULATE_BP: //刷新升频
		calculateTbz, err := models.GetEdbInfoCalculateMappingDetail(edbInfoId)
		if err != nil {
			errMsg = "GetEdbInfoCalculateTbzDetail Err:" + err.Error()
			break
		}
		fromEdbInfo, err := models.GetEdbInfoById(calculateTbz.FromEdbInfoId)
		if err != nil {
			errMsg = "GetEdbInfoById Err:" + err.Error()
			break
		}
		//startDate = edbInfo.StartDate
		endDate = time.Now().Format(utils.FormatDate)
		err = models.RefreshAllCalculateBp(edbInfoId, source, subSource, fromEdbInfo, calculateTbz.EdbCode, startDate, endDate, edbInfo.EmptyType)
		if err != nil && err.Error() != utils.ErrNoRow() {
			errMsg = "RefreshAllCalculateBp Err:" + err.Error()
			break
		}
	case utils.DATA_SOURCE_CALCULATE_TIME_SHIFT:
		calculate, err := models.GetEdbInfoCalculateMappingDetail(edbInfoId)
		if err != nil {
			errMsg = "GetEdbInfoCalculateTbzDetail Err:" + err.Error()
			break
		}
		fromEdbInfo, err := models.GetEdbInfoById(calculate.FromEdbInfoId)
		if err != nil {
			errMsg = "GetEdbInfoById Err:" + err.Error()
			break
		}
		//startDate = edbInfo.StartDate
		startDate = `` //只要填写日期，就会出现问题，还是把日期给去掉吧
		endDate = time.Now().Format(utils.FormatDate)
		formulaInt, _ := strconv.Atoi(calculate.CalculateFormula)
		err = models.RefreshAllCalculateTimeShift(edbInfoId, source, subSource, formulaInt, calculate.MoveType, fromEdbInfo, calculate.EdbCode, startDate, endDate, calculate.MoveFrequency)
		if err != nil && err.Error() != utils.ErrNoRow() {
			errMsg = "RefreshAllCalculateTimeShift Err:" + err.Error()
		}
	case utils.DATA_SOURCE_CALCULATE_PHASE_SHIFT: // 期数位移
		calculate, err := models.GetEdbInfoCalculateMappingDetail(edbInfoId)
		if err != nil {
			errMsg = "GetEdbInfoCalculateMappingDetail Err:" + err.Error()
			break
		}
		fromEdbInfo, err := models.GetEdbInfoById(calculate.FromEdbInfoId)
		if err != nil {
			errMsg = "GetEdbInfoById Err:" + err.Error()
			break
		}
		//startDate = edbInfo.StartDate
		startDate = `` //只要填写日期，就会出现问题，还是把日期给去掉吧
		endDate = time.Now().Format(utils.FormatDate)
		formulaInt, _ := strconv.Atoi(calculate.CalculateFormula)
		err = models.RefreshAllCalculatePhaseShift(edbInfoId, source, subSource, formulaInt, calculate.MoveType, fromEdbInfo, calculate.EdbCode, startDate, endDate, calculate.MoveFrequency)
		if err != nil && err.Error() != utils.ErrNoRow() {
			errMsg = "RefreshAllCalculatePhaseShift Err:" + err.Error()
		}
	case utils.DATA_SOURCE_RESIDUAL_ANALYSIS: // 残差分析
		calculate, err := models.GetEdbInfoCalculateMappingDetail(edbInfoId)
		if err != nil {
			errMsg = "GetEdbInfoCalculateMappingDetail Err:" + err.Error()
			break
		}
		fromEdbInfo, err := models.GetEdbInfoById(calculate.FromEdbInfoId)
		if err != nil {
			errMsg = "GetEdbInfoById Err:" + err.Error()
			break
		}
		//startDate = edbInfo.StartDate
		startDate = `` //只要填写日期，就会出现问题，还是把日期给去掉吧
		endDate = time.Now().Format(utils.FormatDate)
		formulaInt, _ := strconv.Atoi(calculate.CalculateFormula)
		err = models.RefreshAllCalculateResidualAnalysis(edbInfoId, source, subSource, formulaInt, calculate.MoveType, fromEdbInfo, calculate.EdbCode, startDate, endDate, calculate.MoveFrequency)
		if err != nil && err.Error() != utils.ErrNoRow() {
			errMsg = "RefreshAllCalculateResidualAnalysis Err:" + err.Error()
		}
	case utils.DATA_SOURCE_CALCULATE_ZJPJ: //刷新直接拼接
		err = models.RefreshAllCalculateZjpj(edbInfo)
		if err != nil && err.Error() != utils.ErrNoRow() {
			errMsg = "RefreshAllCalculateZjpj Err:" + err.Error()
			break
		}
	case utils.DATA_SOURCE_CALCULATE_LJZTBPJ: //刷新累计值同比拼接
		err = models.RefreshAllCalculateLjztbpj(edbInfo)
		if err != nil && err.Error() != utils.ErrNoRow() {
			errMsg = "RefreshAllCalculateLjztbpj Err:" + err.Error()
			break
		}
	case utils.DATA_SOURCE_PYTHON: //python代码运算
		edbPythonCode, err := models.GetEdbPythonCodeById(edbInfo.EdbInfoId)
		if err != nil {
			errMsg = "获取python代码失败 Err:" + err.Error()
			break
		}
		edbData, err, errMsg := services.ExecPythonCode(edbInfo.EdbCode, edbPythonCode.PythonCode)
		if err != nil {
			br.Msg = "获取数据失败"
			br.ErrMsg = "python代码获取数据失败，err:" + err.Error()
			if errMsg != "" {
				br.Msg = errMsg
			}
			return
		}
		err = models.RefreshAllPythonEdb(edbInfo, edbData)
		if err != nil && err.Error() != utils.ErrNoRow() {
			errMsg = "RefreshAllPythonEdb Err:" + err.Error()
			break
		}
	case utils.DATA_SOURCE_CALCULATE_CJJX: //超季节性
		calculateCjjx, err := models.GetEdbInfoCalculateMappingDetail(edbInfoId)
		if err != nil {
			errMsg = "GetEdbInfoCalculateNszydpjjsDetail Err:" + err.Error()
			break
		}
		fromEdbInfo, err := models.GetEdbInfoById(calculateCjjx.FromEdbInfoId)
		if err != nil {
			errMsg = "GetEdbInfoById Err:" + err.Error()
			break
		}
		formulaInt, _ := strconv.Atoi(edbInfo.CalculateFormula)
		startDate = `` //只要填写日期，就会出现问题，还是把日期给去掉吧
		err = models.RefreshAllCalculateCjjx(edbInfoId, edbInfo.Source, edbInfo.SubSource, fromEdbInfo, calculateCjjx.EdbCode, startDate, "", edbInfo.Calendar, formulaInt)
		if err != nil && err.Error() != utils.ErrNoRow() {
			errMsg = "RefreshAllCalculateCjjx Err:" + err.Error()
			break
		}
	case utils.DATA_SOURCE_CALCULATE_NHCC: //nhcc
		err = models.RefreshAllCalculateNhcc(edbInfo)
		if err != nil && err.Error() != utils.ErrNoRow() {
			errMsg = "RefreshAllCalculateNhcc Err:" + err.Error()
			break
		}
	case utils.DATA_SOURCE_CALCULATE_ADJUST:
		calculateMapping, err := models.GetEdbInfoCalculateMappingDetail(edbInfo.EdbInfoId)
		if err != nil {
			br.Msg = "获取来源指标异常！"
			br.ErrMsg = "获取来源指标异常，Err:" + err.Error()
			return
		}
		fromEdbInfo, err := models.GetEdbInfoById(calculateMapping.FromEdbInfoId)
		if err != nil {
			br.Msg = "来源指标不存在！"
			br.ErrMsg = "来源指标不存在"
			return
		}
		err = models.RefreshAllAdjustEdb(edbInfo, fromEdbInfo)
		if err != nil && err.Error() != utils.ErrNoRow() {
			errMsg = "RefreshAllAdjustEdb Err:" + err.Error()
			break
		}
	case utils.DATA_SOURCE_CALCULATE_JP: //刷新降频
		calculateMapping, err := models.GetEdbInfoCalculateMappingDetail(edbInfoId)
		if err != nil {
			errMsg = "GetEdbInfoCalculateTbzDetail Err:" + err.Error()
			break
		}

		fromEdbInfo, err := models.GetEdbInfoById(calculateMapping.FromEdbInfoId)
		if err != nil {
			errMsg = "GetEdbInfoById Err:" + err.Error()
			break
		}
		//startDate = edbInfo.StartDate
		endDate = time.Now().Format(utils.FormatDate)
		err = models.RefreshAllCalculateJp(edbInfoId, source, subSource, fromEdbInfo, edbInfo.EdbCode, edbInfo.Frequency, edbInfo.CalculateFormula)
		if err != nil && err.Error() != utils.ErrNoRow() {
			errMsg = "RefreshAllCalculateJp Err:" + err.Error()
			break
		}
	case utils.DATA_SOURCE_CALCULATE_NH: //刷新年化
		calculateMapping, err := models.GetEdbInfoCalculateMappingDetail(edbInfoId)
		if err != nil {
			errMsg = "GetEdbInfoCalculateTbzDetail Err:" + err.Error()
			break
		}

		fromEdbInfo, err := models.GetEdbInfoById(calculateMapping.FromEdbInfoId)
		if err != nil {
			errMsg = "GetEdbInfoById Err:" + err.Error()
			break
		}
		//startDate = edbInfo.StartDate
		endDate = time.Now().Format(utils.FormatDate)
		err = models.RefreshAllCalculateNh(edbInfoId, source, subSource, fromEdbInfo, edbInfo.EdbCode)
		if err != nil && err.Error() != utils.ErrNoRow() {
			errMsg = "RefreshAllCalculateNh Err:" + err.Error()
			break
		}
	case utils.DATA_SOURCE_CALCULATE_KSZS: //刷新扩散指数
		//startDate = edbInfo.StartDate
		endDate = time.Now().Format(utils.FormatDate)
		err = models.RefreshAllCalculateKszs(edbInfo)
		if err != nil && err.Error() != utils.ErrNoRow() {
			errMsg = "RefreshAllCalculateKszs Err:" + err.Error()
			break
		}
	case utils.DATA_SOURCE_STOCK_PLANT: //存量装置
		//startDate = edbInfo.StartDate
		endDate = time.Now().Format(utils.FormatDate)
		req.StartDate = `` // 开始日期也给过滤吧，万一研究员补充了之前的数据呢，还是过滤掉吧
		err = models.RefreshEdbDataFromStockPlant(req.EdbInfoId, req.EdbCode, req.StartDate)
		if err != nil && err.Error() != utils.ErrNoRow() {
			errMsg = "RefreshEdbDataFromStockPlant Err:" + err.Error()
			break
		}
	case utils.DATA_SOURCE_CALCULATE_CORRELATION:
		err, errMsg = models.RefreshAllCalculateCorrelation(edbInfo)
	case utils.DATA_SOURCE_CALCULATE_RJZ: //刷新日均值
		calculateRjz, err := models.GetEdbInfoCalculateMappingDetail(edbInfoId)
		if err != nil {
			errMsg = "GetEdbInfoCalculateMappingDetail Err:" + err.Error()
			break
		}
		fromEdbInfo, err := models.GetEdbInfoById(calculateRjz.FromEdbInfoId)
		if err != nil {
			errMsg = "GetEdbInfoById Err:" + err.Error()
			break
		}
		//startDate = edbInfo.StartDate
		endDate = time.Now().Format(utils.FormatDate)
		err = models.RefreshAllCalculateRjz(edbInfoId, source, fromEdbInfo, calculateRjz.EdbCode, startDate, endDate)
		if err != nil && err.Error() != utils.ErrNoRow() {
			errMsg = "RefreshAllCalculateRjz Err:" + err.Error()
			break
		}
	case utils.DATA_SOURCE_CALCULATE_STL: // STL趋势分解
		msg, err := services.RefreshStlData(edbInfoId)
		if err != nil {
			if msg == "" {
				errMsg = "RefreshStlData Err:" + err.Error()
			} else {
				errMsg = msg + " Err:" + err.Error()
			}
			break
		}

	default:
		// 获取通用的数据源处理服务
		baseEdbInfoModel = models.GetBaseEdbInfoModel(source)
		// 没有找到的话，那么就直接返回报错吧
		if baseEdbInfoModel == nil {
			br.Msg = "来源异常，请联系相关开发！"
			br.ErrMsg = "来源异常，请联系相关开发"
			return
		}
		err, errMsg = baseEdbInfoModel.Refresh(refreshParams)

	}
	if errMsg != `` {
		br.Msg = "刷新指标失败！"
		br.ErrMsg = "刷新指标失败，err:" + errMsg
		return
	}

	// 更新指标最大最小值
	err, errMsg = models.UnifiedModifyEdbInfoMaxAndMinInfo(edbInfo)
	if err != nil {
		br.Msg = errMsg
		br.ErrMsg = err.Error()
		return
	}

	// 更新ES
	go logic.UpdateEs(edbInfoId)

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

// SaveAdjust
// @Title 保存数据调整指标接口
// @Description 保存数据调整指标接口
// @Success 200 {object} models.SaveAdjustEdbReq
// @router /adjust/save [post]
func (this *CalculateController) SaveAdjust() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	var req models.SaveAdjustEdbReq
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}
	req.EdbName = strings.Trim(req.EdbName, " ")
	if req.EdbName == "" {
		br.Msg = "指标名称不能为空"
		return
	}

	if req.Frequency == "" {
		br.Msg = "频率不能为空"
		return
	}

	if req.Unit == "" {
		br.Msg = "单位不能为空"
		return
	}

	if req.ClassifyId <= 0 {
		br.Msg = "请选择分类"
		return
	}

	if len(req.DataList) == 0 {
		br.Msg = "请填写数据"
		return
	}

	//加入缓存机制，避免创建同一个名称的指标 start
	redisKey := fmt.Sprint("edb_info:adjust:add:", utils.DATA_SOURCE_CALCULATE_ADJUST, ":", req.EdbName)
	isExist := utils.Rc.IsExist(redisKey)
	if isExist {
		br.Msg = "指标正在处理,请勿重复提交"
		return
	} else {
		//设置3分钟缓存
		utils.Rc.SetNX(redisKey, 1, time.Second*300)
		defer func() {
			_ = utils.Rc.Delete(redisKey)
		}()
	}

	// 校验指标名称是否存在
	existEdbName, err := logic.CheckExistByEdbNameAndEdbInfoId(0, req.EdbInfoId, req.EdbName, this.Lang)
	if err != nil {
		br.Msg = "判断指标名称是否存在失败"
		br.ErrMsg = "判断指标名称是否存在失败,Err:" + err.Error()
		return
	}

	if existEdbName {
		br.Msg = "指标名称已存在，请重新填写"
		br.ErrMsg = "指标名称已存在，请重新填写"
		return
	}

	edbInfo, err, errMsg := models.SaveAdjustEdb(req, this.Lang)
	if err != nil {
		br.Msg = errMsg
		br.Msg = "添加指标失败,Err:" + err.Error()
		return
	}

	//处理同名指标
	{
		edbNameList, err := models.GetEdbInfoByName(req.EdbName)
		if err != nil {
			br.Msg = "保存失败"
			br.ErrMsg = "获取指标信息失败，Err:" + err.Error()
			return
		}
		if len(edbNameList) >= 2 {
			for _, v := range edbNameList {
				edbName := v.EdbName + "(" + v.SourceName + ")"
				err = models.ModifyEdbInfoNameSource(edbName, v.EdbInfoId)
				if err != nil {
					br.Msg = "保存失败"
					br.ErrMsg = "修改指标名称失败，Err:" + err.Error()
					return
				}
			}
		}
	}

	// 更新指标最大最小值
	err, errMsg = models.UnifiedModifyEdbInfoMaxAndMinInfo(edbInfo)
	if err != nil {
		br.Msg = errMsg
		br.ErrMsg = err.Error()
		return
	}
	resp := models.AddEdbInfoResp{
		EdbInfoId:  edbInfo.EdbInfoId,
		UniqueCode: edbInfo.UniqueCode,
	}

	// 判断是否需要禁用
	go services.DisableEdbInfoNoUpdate(edbInfo)
	// 重置计算指标中的引用关系
	go services.ResetEdbRelation(edbInfo.EdbInfoId)
	br.Ret = 200
	br.Success = true
	br.Msg = "保存成功"
	br.Data = resp
	br.IsAddLog = true
}

// CalculateComputeCorrelation
// @Title 拟合残差计算相关性
// @Description 拟合残差计算相关性接口
// @Param request body models.EdbInfoCalculateBatchSaveReq true "type json string"
// @Success Ret=200 返回指标id
// @router /compute_correlation [post]
func (this *CalculateController) CalculateComputeCorrelation() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()

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

	if len(req.EdbInfoIdArr) != 2 {
		br.Msg = "选择的指标异常,请重新选择"
		return
	}

	//校验时间格式
	//数据格式：2022-11-01,2022-11-10
	timeList := strings.Split(req.Formula, ",")
	if len(timeList) != 2 {
		br.Msg = "选择时间有误,请重新输入"
		return
	}
	startDate, err := time.ParseInLocation(utils.FormatDate, timeList[0], time.Local)
	if err != nil {
		br.Msg = "开始日期有误,请重新输入"
		return
	}
	endDate, err := time.ParseInLocation(utils.FormatDate, timeList[1], time.Local)
	if err != nil {
		br.Msg = "结束日期有误,请重新输入"
		return
	}
	if utils.GetTimeSubDay(startDate, endDate) < 2 {
		br.Msg = "日期间隔不得少于两天"
		return
	}
	var nhccDate models.NhccDate // 拟合残差的日期
	nhccDate.StartDate = startDate
	nhccDate.EndDate = endDate

	// 基础指标id
	fromEdbInfoId := req.EdbInfoIdArr[0].EdbInfoId
	if fromEdbInfoId <= 0 {
		br.Msg = "请选择指标"
		return
	}
	// 来源指标（自变量指标）
	fromEdbInfo, err := models.GetEdbInfoById(fromEdbInfoId)
	if err != nil {
		br.Msg = "获取指标信息失败"
		br.ErrMsg = "获取指标信息失败:Err:" + err.Error()
		return
	}

	// 因变量指标
	secondEdbInfoReq := req.EdbInfoIdArr[1]
	secondEdbInfo, tmpErr := models.GetEdbInfoById(secondEdbInfoReq.EdbInfoId)
	if tmpErr != nil {
		br.Msg = "获取因变量的指标信息失败"
		br.ErrMsg = "获取因变量的指标信息失败:Err:" + tmpErr.Error()
		return
	}

	if fromEdbInfo.EdbInfoId == secondEdbInfo.EdbInfoId {
		br.Msg = "两个指标不允许为同一个"
		br.ErrMsg = "两个指标不允许为同一个"
		return
	}
	aVal, bVal, rVal, err, errMsg := models.CalculateComputeCorrelation(&req, fromEdbInfo, secondEdbInfo, nhccDate)
	if err != nil {
		br.Msg = "计算失败"
		if errMsg != `` {
			br.Msg = errMsg
		}
		br.ErrMsg = "计算失败，ERR：" + err.Error()
		return
	}

	connStr := ``
	if bVal >= 0 {
		connStr = `+`
	}
	valStr := fmt.Sprintf("y = %sx %s %s   r=%f", utils.SubFloatToString(aVal, 4), connStr, utils.SubFloatToString(bVal, 4), rVal)

	br.Ret = 200
	br.Success = true
	br.Msg = "计算成功"
	br.Data = valStr
	br.IsAddLog = true
}

// ResetCustomAnalysisData
// @Title 自定义表格数据重置
// @Description 自定义表格数据重置
// @Param request body models.ResetCustomAnalysisData true "type json string"
// @Success Ret=200 返回指标id
// @router /custom_analysis/reset [post]
func (this *CalculateController) ResetCustomAnalysisData() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()

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

	if req.EdbInfoId <= 0 {
		br.Msg = "请选择指标"
		br.ErrMsg = br.Msg
		br.IsSendEmail = false
		return
	}
	if len(req.DateList) <= 0 {
		br.Msg = "请传入日期序列"
		br.ErrMsg = br.Msg
		br.IsSendEmail = false
		return
	}
	if len(req.DataList) <= 0 {
		br.Msg = "请传入数据序列"
		br.ErrMsg = br.Msg
		br.IsSendEmail = false
		return
	}

	edbInfo, err := models.GetEdbInfoById(req.EdbInfoId)
	if err != nil {
		if err.Error() == utils.ErrNoRow() {
			br.Msg = "指标已被删除，请刷新页面"
			br.ErrMsg = "指标已被删除，请刷新页面:Err:" + err.Error()
			return
		}
		br.Msg = "获取指标信息失败"
		br.ErrMsg = "获取指标信息失败:Err:" + err.Error()
		return
	}
	baseEdbInfoModel := models.CustomAnalysis{}
	err, errMsg := baseEdbInfoModel.ResetData(edbInfo, req.DateList, req.DataList)
	if err != nil {
		br.Msg = "更新数据失败"
		if errMsg != `` {
			br.Msg = errMsg
		}
		br.ErrMsg = "更新数据失败 Err:" + err.Error()
		return
	}
	if edbInfo == nil {
		br.Msg = "更新数据失败"
		br.ErrMsg = "更新数据失败,指标ID错误:"
		return
	}

	// 更新指标最大最小值
	err, errMsg = models.UnifiedModifyEdbInfoMaxAndMinInfo(edbInfo)
	if err != nil {
		br.Msg = errMsg
		br.ErrMsg = err.Error()
		return
	}

	resp := models.AddEdbInfoResp{
		EdbInfoId:  edbInfo.EdbInfoId,
		UniqueCode: edbInfo.UniqueCode,
	}
	br.Ret = 200
	br.Success = true
	br.Msg = "处理成功"
	br.Data = resp
	br.IsAddLog = true
}

// Calculate
// @Title 基础数据计算
// @Description 拟合残差计算相关性接口
// @Param request body models.EdbInfoCalculateBatchSaveReq true "type json string"
// @Success Ret=200 返回指标id
// @router /base [post]
func (this *CalculateController) Calculate() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()

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

	dateDataMap := make(map[time.Time]float64)
	var errMsg string

	dataList, err := models.EdbInfoSearchDataToData(req.DataList)
	if err != nil {
		br.Msg = "计算失败，数据异常！"
		br.ErrMsg = "计算失败，数据异常，Err:" + err.Error()
		return
	}

	baseCalculate := models.BaseCalculate{
		DataList:      dataList,
		Frequency:     req.Frequency,
		Formula:       req.Formula,
		Calendar:      req.Calendar,
		MoveType:      req.MoveType,
		MoveFrequency: req.MoveFrequency,
		FromFrequency: req.FromFrequency,
		Source:        req.Source,
	}

	//1：累计值转月；2：累计值转季；3：同比值；4：同差值；5：N数值移动平均数计算；6：环比值；7：环差值；8：升频；9：降频；10：时间移位；11：超季节性；12：年化；13：累计值；14：累计值年初至今；15：指数修匀；16：日均值
	switch baseCalculate.Source {
	case 1:
		dateDataMap, err, errMsg = baseCalculate.Ljzzy()
	case 2:
		dateDataMap, err, errMsg = baseCalculate.Ljzzj()
	case 3:
		dateDataMap, err, errMsg = baseCalculate.Tbz()
	case 4:
		dateDataMap, err, errMsg = baseCalculate.Tcz()
	case 5:
		dateDataMap, err, errMsg = baseCalculate.Nszydpjjs()
	case 6:
		dateDataMap, err, errMsg = baseCalculate.Hbz()
	case 7:
		dateDataMap, err, errMsg = baseCalculate.Hcz()
	case 8:
		dateDataMap, err, errMsg = baseCalculate.UpFrequency()
	case 9:
		dateDataMap, err, errMsg = baseCalculate.DownFrequency()
	case 10:
		dateDataMap, err, errMsg = baseCalculate.TimeShift()
	case 11:
		dateDataMap, err, errMsg = baseCalculate.Cjjx()
	case 12:
		dateDataMap, err, errMsg = baseCalculate.Annualized()
	case 13:
		dateDataMap, err, errMsg = baseCalculate.Ljz()
	case 14:
		dateDataMap, err, errMsg = baseCalculate.LjzNczj()
	case 15:
		dateDataMap, err, errMsg = baseCalculate.ExponentialSmoothing()
	case 16:
		dateDataMap, err, errMsg = baseCalculate.Rjz()
	default:
		errMsg = "错误的计算类型"
		err = errors.New(errMsg + ":" + strconv.Itoa(baseCalculate.Source))
	}

	if err != nil {
		br.Msg = "计算失败"
		if errMsg != `` {
			br.Msg = errMsg
		}
		br.ErrMsg = err.Error()
		return
	}

	dateStrDataMap, dateList := models.GetDateDataAndDateList(dateDataMap)

	br.Ret = 200
	br.Success = true
	br.Msg = "计算成功"
	br.Data = models.BaseCalculateResp{
		DataMap:  dateStrDataMap,
		DateList: dateList,
	}
	br.IsAddLog = true
}

// BatchSaveMulti
// @Title 批量计算 累计值转月-同比值-同差等计算新增
// @Description 批量计算 累计值转月-同比值-同差等计算新增接口
// @Param request body models.EdbInfoCalculateBatchSaveReq true "type json string"
// @Success Ret=200 返回指标id
// @router /batch/save/multi [post]
func (this *CalculateController) BatchSaveMulti() {
	br := new(models.BaseResponse).Init()
	defer func() {
		if br.ErrMsg == "" {
			br.IsSendEmail = false
		}
		this.Data["json"] = br
		this.ServeJSON()
	}()

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

	resp := models.BatchEdbInfoCalculateBatchSaveResp{
		Fail:    make([]models.BatchEdbInfoCalculateBatchSaveFailResp, 0),
		Success: make([]models.BatchEdbInfoCalculateBatchSaveSuccessResp, 0),
	}

	redisKeyList := make([]string, 0) //需要清理的缓存key列表
	defer func() {
		for _, redisKey := range redisKeyList {
			utils.Rc.Delete(redisKey)
		}
	}()
	var wg sync.WaitGroup
	// 校验参数
	for _, item := range req.EdbList {

		calculateId := item.CalculateId
		//加入缓存机制，避免创建同一个名称的指标 start
		redisKey := fmt.Sprint("edb_info:calculate:batch:save:", req.AdminId, ":", req.Source, ":", calculateId)
		isExist := utils.Rc.IsExist(redisKey)
		if isExist {
			resp.Fail = append(resp.Fail, models.BatchEdbInfoCalculateBatchSaveFailResp{
				CalculateId: calculateId,
				Msg:         "指标正在处理,请勿重复提交",
			})
			continue
		} else {
			//设置3分钟缓存
			utils.Rc.SetNX(redisKey, 1, time.Second*300)
			redisKeyList = append(redisKeyList, redisKey)
		}
		wg.Add(1)
		reqItem := models.EdbInfoCalculateBatchSaveReq{
			AdminId:          req.AdminId,
			AdminName:        req.AdminName,
			EdbInfoId:        item.EdbInfoId,
			EdbName:          item.EdbName,
			Frequency:        item.Frequency,
			Unit:             item.Unit,
			ClassifyId:       item.ClassifyId,
			Formula:          req.Formula, //N数值移动平均计算、环比值、环差值
			FromEdbInfoId:    item.FromEdbInfoId,
			CalculateFormula: req.CalculateFormula,
			Source:           req.Source,
			MoveType:         req.MoveType,
			MoveFrequency:    req.MoveFrequency,
			EdbInfoIdArr:     req.EdbInfoIdArr,
			Calendar:         req.Calendar,
			EmptyType:        req.EmptyType,
			MaxEmptyType:     req.MaxEmptyType,
			Extra:            req.Extra,
		}

		var edbInfo *models.EdbInfo
		uniqueCode := ""
		errMsg := ""
		go func() {
			defer func() {
				// todo 批量报错处理
				if err != nil {
					// 整理报错的指标
					utils.FileLog.Info(fmt.Sprintf("批量指标计算，保存失败 Err:%v, ErrMsg:%s", err, errMsg))
					resp.Fail = append(resp.Fail, models.BatchEdbInfoCalculateBatchSaveFailResp{
						CalculateId: calculateId,
						Msg:         err.Error(),
						ErrMsg:      errMsg,
					})
				} else {
					// 整理成功的指标
					//todo 整理执行成功指标信息
					resp.Success = append(resp.Success, models.BatchEdbInfoCalculateBatchSaveSuccessResp{
						ClassifyId:  reqItem.ClassifyId,
						CalculateId: calculateId,
						EdbInfoId:   edbInfo.EdbInfoId,
						UniqueCode:  uniqueCode,
					})
				}
				wg.Done()
			}()

			edbInfo, uniqueCode, err, errMsg = services.EdbCalculateBatchSave(reqItem, this.Lang)
			return
		}()
	}
	wg.Wait()
	br.Ret = 200
	br.Success = true
	br.Msg = "保存成功"
	br.Data = resp
	br.IsAddLog = true
}

// BatchEditMulti
// @Title 批量计算 累计值转月-同比值-同差等计算编辑
// @Description 批量计算 累计值转月-同比值-同差等计算编辑接口
// @Param request body models.EdbInfoCalculateBatchSaveReq true "type json string"
// @Success Ret=200 返回指标id
// @router /batch/edit/multi [post]
func (this *CalculateController) BatchEditMulti() {
	br := new(models.BaseResponse).Init()
	defer func() {
		if br.ErrMsg == "" {
			br.IsSendEmail = false
		}
		this.Data["json"] = br
		this.ServeJSON()
	}()

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

	resp := models.BatchEdbInfoCalculateBatchSaveResp{
		Fail:    make([]models.BatchEdbInfoCalculateBatchSaveFailResp, 0),
		Success: make([]models.BatchEdbInfoCalculateBatchSaveSuccessResp, 0),
	}

	redisKeyList := make([]string, 0) //需要清理的缓存key列表
	defer func() {
		for _, redisKey := range redisKeyList {
			utils.Rc.Delete(redisKey)
		}
	}()
	var wg sync.WaitGroup
	// 校验参数
	for _, item := range req.EdbList {
		calculateId := item.CalculateId
		if item.EdbInfoId <= 0 {
			resp.Fail = append(resp.Fail, models.BatchEdbInfoCalculateBatchSaveFailResp{
				CalculateId: calculateId,
				Msg:         "请选择要编辑的指标",
			})
			continue
		}
		//加入缓存机制，避免创建同一个名称的指标 start
		redisKey := fmt.Sprint("edb_info:calculate:batch:edit:", req.AdminId, ":", req.Source, ":", item.EdbInfoId)
		isExist := utils.Rc.IsExist(redisKey)
		if isExist {
			resp.Fail = append(resp.Fail, models.BatchEdbInfoCalculateBatchSaveFailResp{
				CalculateId: calculateId,
				Msg:         "指标正在处理,请勿重复提交",
			})
			continue
		} else {
			//设置3分钟缓存
			utils.Rc.SetNX(redisKey, 1, time.Second*300)
			redisKeyList = append(redisKeyList, redisKey)
		}
		wg.Add(1)
		reqItem := models.EdbInfoCalculateBatchEditReq{
			EdbInfoId:        item.EdbInfoId,
			EdbName:          item.EdbName,
			Frequency:        item.Frequency,
			Unit:             item.Unit,
			ClassifyId:       item.ClassifyId,
			AdminId:          req.AdminId,
			AdminName:        req.AdminName,
			Formula:          req.Formula, //N数值移动平均计算、环比值、环差值
			FromEdbInfoId:    item.FromEdbInfoId,
			CalculateFormula: req.CalculateFormula,
			Source:           req.Source,
			MoveType:         req.MoveType,
			MoveFrequency:    req.MoveFrequency,
			EdbInfoIdArr:     req.EdbInfoIdArr,
			Calendar:         req.Calendar,
			EmptyType:        req.EmptyType,
			MaxEmptyType:     req.MaxEmptyType,
			Extra:            req.Extra,
		}

		var errMsg string
		var edbInfo *models.EdbInfo
		uniqueCode := ""
		go func() {
			defer func() {
				// todo 批量报错处理
				if err != nil {
					// 整理报错的指标
					utils.FileLog.Info(fmt.Sprintf("批量指标计算，保存失败 Err:%v, ErrMsg:%s", err, errMsg))
					resp.Fail = append(resp.Fail, models.BatchEdbInfoCalculateBatchSaveFailResp{
						CalculateId: calculateId,
						Msg:         err.Error(),
						ErrMsg:      errMsg,
					})
				} else {
					// 整理成功的指标
					//todo 整理执行成功指标信息
					resp.Success = append(resp.Success, models.BatchEdbInfoCalculateBatchSaveSuccessResp{
						ClassifyId:  reqItem.ClassifyId,
						CalculateId: calculateId,
						EdbInfoId:   edbInfo.EdbInfoId,
						UniqueCode:  uniqueCode,
					})
				}
				wg.Done()
			}()
			edbInfo, uniqueCode, err, errMsg = services.EdbCalculateBatchEdit(reqItem)
			return
		}()
	}
	wg.Wait()
	if err != nil {
		br.Msg = "批量指标计算，保存失败"
		br.ErrMsg = "批量指标计算，保存失败，Err:" + err.Error()
		return
	}
	br.Ret = 200
	br.Success = true
	br.Msg = "保存成功"
	br.Data = resp
	br.IsAddLog = true
}

// StepCalculate
// @Title 多步骤计算
// @Description 多步骤计算
// @Param request body models.StepCalculateBySearchData true "type json string"
// @Success Ret=200 返回指标id
// @router /base/step_calculate [post]
func (this *CalculateController) StepCalculate() {
	br := new(models.BaseResponse).Init()
	defer func() {
		if br.ErrMsg == "" {
			br.IsSendEmail = false
		}
		this.Data["json"] = br
		this.ServeJSON()
	}()
	var req models.StepCalculateBySearchData
	if e := json.Unmarshal(this.Ctx.Input.RequestBody, &req); e != nil {
		br.Msg = "参数解析异常"
		br.ErrMsg = fmt.Sprintf("参数解析失败, Err: %v", e)
		return
	}
	//sort.Slice(req.Calculates, func(i, j int) bool {
	//	return req.Calculates[i].Sort < req.Calculates[j].Sort
	//})
	//
	//var errMsg string
	//originData, e := models.EdbInfoSearchDataToData(req.DataList)
	//if e != nil {
	//	br.Msg = "基础数据异常"
	//	br.ErrMsg = fmt.Sprintf("计算失败, 基础数据异常, Err: %v", e)
	//	return
	//}
	//
	//calculateData := originData
	//dateDataMap := make(map[time.Time]float64)
	//for _, v := range req.Calculates {
	//	baseCalculate := models.BaseCalculate{
	//		DataList:      calculateData,
	//		Frequency:     v.Frequency,
	//		Formula:       v.Formula,
	//		Calendar:      v.Calendar,
	//		MoveType:      v.MoveType,
	//		MoveFrequency: v.MoveFrequency,
	//		FromFrequency: v.FromFrequency,
	//		Source:        v.Source,
	//	}
	//
	//	// 计算方式
	//	switch baseCalculate.Source {
	//	case utils.EdbBaseCalculateLjzzy:
	//		dateDataMap, e, errMsg = baseCalculate.Ljzzy()
	//	case utils.EdbBaseCalculateLjzzj:
	//		dateDataMap, e, errMsg = baseCalculate.Ljzzj()
	//	case utils.EdbBaseCalculateTbz:
	//		dateDataMap, e, errMsg = baseCalculate.Tbz()
	//	case utils.EdbBaseCalculateTcz:
	//		dateDataMap, e, errMsg = baseCalculate.Tcz()
	//	case utils.EdbBaseCalculateNszydpjjs:
	//		dateDataMap, e, errMsg = baseCalculate.Nszydpjjs()
	//	case utils.EdbBaseCalculateHbz:
	//		dateDataMap, e, errMsg = baseCalculate.Hbz()
	//	case utils.EdbBaseCalculateHcz:
	//		dateDataMap, e, errMsg = baseCalculate.Hcz()
	//	case utils.EdbBaseCalculateUpFrequency:
	//		dateDataMap, e, errMsg = baseCalculate.UpFrequency()
	//	case utils.EdbBaseCalculateDownFrequency:
	//		dateDataMap, e, errMsg = baseCalculate.DownFrequency()
	//	case utils.EdbBaseCalculateTimeShift:
	//		dateDataMap, e, errMsg = baseCalculate.TimeShift()
	//	case utils.EdbBaseCalculateCjjx:
	//		dateDataMap, e, errMsg = baseCalculate.Cjjx()
	//	case utils.EdbBaseCalculateAnnualized:
	//		dateDataMap, e, errMsg = baseCalculate.Annualized()
	//	case utils.EdbBaseCalculateLjz:
	//		dateDataMap, e, errMsg = baseCalculate.Ljz()
	//	case utils.EdbBaseCalculateLjzNczj:
	//		dateDataMap, e, errMsg = baseCalculate.LjzNczj()
	//	case utils.EdbBaseCalculateExponentialSmoothing:
	//		dateDataMap, e, errMsg = baseCalculate.ExponentialSmoothing()
	//	case utils.EdbBaseCalculateRjz:
	//		dateDataMap, e, errMsg = baseCalculate.Rjz()
	//	default:
	//		errMsg = "计算方式无效"
	//		e = fmt.Errorf("%s:%d", errMsg, baseCalculate.Source)
	//	}
	//	if e != nil {
	//		br.Msg = "计算失败"
	//		if errMsg != "" {
	//			br.Msg = errMsg
	//		}
	//		br.ErrMsg = e.Error()
	//		return
	//	}
	//
	//	calculateData = models.TransDateData2EdbData(dateDataMap)
	//}
	resultData, dates, errMsg, e := services.StepCalculate(req.DataList, req.Calculates)
	if e != nil {
		br.Msg = "计算失败"
		if errMsg != "" {
			br.Msg = errMsg
		}
		br.ErrMsg = fmt.Sprintf("分步骤计算失败, Err: %v", e)
		return
	}

	br.Ret = 200
	br.Success = true
	br.Msg = "计算成功"
	br.Data = models.BaseCalculateResp{
		DataMap:  resultData,
		DateList: dates,
	}
	br.IsAddLog = true
}