eta_index_lib/controllers/base_from_calculate.go

package controllers

import (
	"encoding/json"
	"fmt"
	"hongze/hongze_edb_lib/models"
	"hongze/hongze_edb_lib/services"
	"hongze/hongze_edb_lib/utils"
	"strconv"
	"strings"
	"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
	}
	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

	//加入缓存机制，避免创建同一个名称的指标 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)
		}()
	}

	//判断是否重复指标
	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
	}

	var condition string
	var pars []interface{}
	condition += " AND edb_name=? "
	pars = append(pars, req.EdbName)

	count, err := models.GetEdbInfoCountByCondition(condition, pars)
	if err != nil {
		br.Msg = "判断指标名称是否存在失败"
		br.ErrMsg = "判断指标名称是否存在失败,Err:" + err.Error()
		return
	}

	if count > 0 {
		br.Msg = "指标名称已存在，请重新填写"
		br.ErrMsg = "指标名称已存在，请重新填写"
		br.IsSendEmail = false
		return
	}
	//检验公式
	var formulaStr string
	var edbInfoIdBytes []string
	for _, v := range req.EdbInfoIdArr {
		formulaStr += v.FromTag + ","
		edbInfoIdBytes = append(edbInfoIdBytes, v.FromTag)
	}
	formulaMap := services.CheckFormula(req.CalculateFormula)
	for _, v := range formulaMap {
		if !strings.Contains(formulaStr, v) {
			br.Msg = "公式错误，请重新填写"
			return
		}
	}

	//关联的指标信息
	edbInfoList := make([]*models.EdbInfo, 0)
	//关联的指标数据表
	calculateMappingList := make([]*models.EdbInfoCalculateMapping, 0)
	for k, v := range req.EdbInfoIdArr {
		fromEdbInfo, err := models.GetEdbInfoById(v.EdbInfoId)
		if err != nil {
			if err.Error() == utils.ErrNoRow() {
				br.Msg = "生成计算指标失败"
				br.Msg = "指标 " + strconv.Itoa(v.EdbInfoId) + " 不存在"
				return
			}
			br.Msg = "生成计算指标失败"
			br.Msg = "获取指标失败:Err:" + err.Error()
			return
		}

		edbInfoList = append(edbInfoList, fromEdbInfo)
		//关联关系表
		{
			calculateMappingItem := &models.EdbInfoCalculateMapping{
				EdbInfoCalculateMappingId: 0,
				EdbInfoId:                 0,
				Source:                    utils.DATA_SOURCE_CALCULATE,
				SourceName:                "指标运算",
				EdbCode:                   "",
				FromEdbInfoId:             fromEdbInfo.EdbInfoId,
				FromEdbCode:               fromEdbInfo.EdbCode,
				FromEdbName:               fromEdbInfo.EdbName,
				FromSource:                fromEdbInfo.Source,
				FromSourceName:            fromEdbInfo.SourceName,
				FromTag:                   v.FromTag,
				Sort:                      k + 1,
				CreateTime:                time.Now(),
				ModifyTime:                time.Now(),
			}
			//calculateMappingItem.EdbCode = edbCode
			//calculateMappingItem.EdbInfoId = int(edbInfoId)
			calculateMappingList = append(calculateMappingList, calculateMappingItem)
		}
	}
	ok, _ := models.CheckFormula2(edbInfoList, formulaMap, calculateFormula, edbInfoIdBytes)
	if !ok {
		br.Msg = "生成计算指标失败，请使用正确的计算公式"
		return
	}

	randStr := utils.GetRandDigit(4)
	edbCode := `C` + time.Now().Format("060102") + randStr
	timestamp := strconv.FormatInt(time.Now().UnixNano(), 10)
	uniqueCode := utils.MD5(utils.DATA_PREFIX + "_" + timestamp)

	edbInfo, err := models.AddCalculateInfo(req, calculateMappingList, edbInfoList, edbCode, uniqueCode, edbInfoIdBytes)
	if err != nil {
		br.Msg = "生成计算指标失败"
		br.Msg = "生成计算指标失败,AddEdbInfo 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: uniqueCode,
	}
	br.Ret = 200
	br.Success = true
	br.Msg = "保存成功"
	br.Data = resp
	br.IsAddLog = true
}

//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
//	}
//	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
//
//	//加入缓存机制，避免创建同一个名称的指标 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)
//		}()
//	}
//
//	//判断是否重复指标
//	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
//	}
//
//	var condition string
//	var pars []interface{}
//	condition += " AND edb_name=? "
//	pars = append(pars, req.EdbName)
//
//	count, err := models.GetEdbInfoCountByCondition(condition, pars)
//	if err != nil {
//		br.Msg = "判断指标名称是否存在失败"
//		br.ErrMsg = "判断指标名称是否存在失败,Err:" + err.Error()
//		return
//	}
//
//	if count > 0 {
//		br.Msg = "指标名称已存在，请重新填写"
//		br.ErrMsg = "指标名称已存在，请重新填写"
//		br.IsSendEmail = false
//		return
//	}
//	//检验公式
//	var formulaStr string
//	var edbInfoIdBytes []string
//	for _, v := range req.EdbInfoIdArr {
//		formulaStr += v.FromTag + ","
//		edbInfoIdBytes = append(edbInfoIdBytes, v.FromTag)
//	}
//	formulaMap := services.CheckFormula(req.CalculateFormula)
//	for _, v := range formulaMap {
//		if !strings.Contains(formulaStr, v) {
//			br.Msg = "公式错误，请重新填写"
//			return
//		}
//	}
//
//	//关联的指标信息
//	edbInfoList := make([]*models.EdbInfo, 0)
//	//关联的指标数据表
//	calculateMappingList := make([]*models.EdbInfoCalculateMapping, 0)
//	for k, v := range req.EdbInfoIdArr {
//		fromEdbInfo, err := models.GetEdbInfoById(v.EdbInfoId)
//		if err != nil {
//			if err.Error() == utils.ErrNoRow() {
//				br.Msg = "生成计算指标失败"
//				br.Msg = "指标 " + strconv.Itoa(v.EdbInfoId) + " 不存在"
//				return
//			}
//			br.Msg = "生成计算指标失败"
//			br.Msg = "获取指标失败:Err:" + err.Error()
//			return
//		}
//
//		edbInfoList = append(edbInfoList, fromEdbInfo)
//		//关联关系表
//		{
//			calculateMappingItem := &models.EdbInfoCalculateMapping{
//				EdbInfoCalculateMappingId: 0,
//				EdbInfoId:                 0,
//				Source:                    utils.DATA_SOURCE_CALCULATE,
//				SourceName:                "指标运算",
//				EdbCode:                   "",
//				FromEdbInfoId:             fromEdbInfo.EdbInfoId,
//				FromEdbCode:               fromEdbInfo.EdbCode,
//				FromEdbName:               fromEdbInfo.EdbName,
//				FromSource:                fromEdbInfo.Source,
//				FromSourceName:            fromEdbInfo.SourceName,
//				FromTag:                   v.FromTag,
//				Sort:                      k + 1,
//				CreateTime:                time.Now(),
//				ModifyTime:                time.Now(),
//			}
//			//calculateMappingItem.EdbCode = edbCode
//			//calculateMappingItem.EdbInfoId = int(edbInfoId)
//			calculateMappingList = append(calculateMappingList, calculateMappingItem)
//		}
//	}
//	ok, _ := models.CheckFormula2(edbInfoList, formulaMap, calculateFormula, edbInfoIdBytes)
//	if !ok {
//		br.Msg = "生成计算指标失败，请使用正确的计算公式"
//		return
//	}
//
//	randStr := utils.GetRandDigit(4)
//	edbCode := `C` + time.Now().Format("060102") + randStr
//
//	timestamp := strconv.FormatInt(time.Now().UnixNano(), 10)
//	uniqueCode := utils.MD5(utils.DATA_PREFIX + "_" + timestamp)
//	edbInfo := &models.EdbInfo{
//		EdbInfoId:        0,
//		SourceName:       "指标运算",
//		Source:           utils.DATA_SOURCE_CALCULATE,
//		EdbCode:          edbCode,
//		EdbName:          req.EdbName,
//		EdbNameSource:    req.EdbName,
//		Frequency:        req.Frequency,
//		Unit:             req.Unit,
//		StartDate:        "",
//		EndDate:          "",
//		ClassifyId:       req.ClassifyId,
//		SysUserId:        req.AdminId,
//		SysUserRealName:  req.AdminName,
//		UniqueCode:       uniqueCode,
//		CreateTime:       time.Now(),
//		ModifyTime:       time.Now(),
//		MinValue:         0,
//		MaxValue:         0,
//		CalculateFormula: req.CalculateFormula,
//		EdbType:          2,
//		Sort:             0,
//		MoveType:         0,
//		MoveFrequency:    "",
//		NoUpdate:         0,
//		ServerUrl:        "",
//		EdbInfoType:      0,
//		EdbNameEn:        "",
//		UnitEn:           "",
//		LatestDate:       "",
//		LatestValue:      0,
//		ChartImage:       "",
//	}
//	edbInfoId, err := models.AddEdbInfo(edbInfo)
//	if err != nil {
//		br.Msg = "生成计算指标失败"
//		br.Msg = "生成计算指标失败,AddEdbInfo 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
//				}
//			}
//		}
//	}
//
//	//关联关系表
//	{
//		//处理关联指标
//		for _, v := range calculateMappingList {
//			v.EdbCode = edbCode
//			v.EdbInfoId = int(edbInfoId)
//		}
//		if len(calculateMappingList) > 0 {
//			go models.AddEdbInfoCalculateMappingMulti(calculateMappingList)
//		}
//	}
//
//	// 指标数据入库
//	err = models.AddCalculate(edbInfoList, int(edbInfoId), edbCode, req.CalculateFormula, edbInfoIdBytes)
//	if err != nil {
//		br.Msg = "生成计算指标失败"
//		br.Msg = "生成计算指标失败,Calculate Err:" + err.Error()
//		return
//	}
//
//	// 更新指标最大最小值
//	err, errMsg := models.UnifiedModifyEdbInfoMaxAndMinInfo(edbInfo)
//	if err != nil {
//		br.Msg = errMsg
//		br.ErrMsg = err.Error()
//		return
//	}
//	resp := models.AddEdbInfoResp{
//		EdbInfoId:  int(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
	}

	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
	}

	var condition string
	var pars []interface{}
	condition += " AND edb_name=? "
	pars = append(pars, req.EdbName)

	condition += " AND edb_info_id<>? "
	pars = append(pars, req.EdbInfoId)

	count, err := models.GetEdbInfoCountByCondition(condition, pars)
	if err != nil {
		br.Msg = "判断指标名称是否存在失败"
		br.ErrMsg = "判断指标名称是否存在失败,Err:" + err.Error()
		return
	}

	if count > 0 {
		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
	}
	var needCalculate bool

	if edbInfoDetail.CalculateFormula != req.CalculateFormula {
		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
		}
	}

	formulaMap := services.CheckFormula(req.CalculateFormula)
	for _, v := range formulaMap {
		if !strings.Contains(formulaStr, v) {
			br.Msg = "公式错误，请重新填写"
			return
		}
	}
	//重新计算
	if needCalculate {
		err = models.DeleteCalculateEdbInfo(req.EdbInfoId)
		if err != nil {
			br.Msg = "修改失败"
			br.Msg = "修改失败,DeleteCalculateEdbInfo Err:" + err.Error()
			return
		}
		//calculateList := make([]*data_manage.EdbInfoCalculate, 0)
		edbInfoList := make([]*models.EdbInfo, 0)

		calculateMappingList := make([]*models.EdbInfoCalculateMapping, 0)
		for k, v := range req.EdbInfoIdArr {
			fromEdbInfo, err := models.GetEdbInfoById(v.EdbInfoId)
			if err != nil {
				if err.Error() == utils.ErrNoRow() {
					br.Msg = "生成计算指标失败"
					br.Msg = "指标 " + strconv.Itoa(v.EdbInfoId) + " 不存在"
					return
				}
				br.Msg = "生成计算指标失败"
				br.Msg = "获取指标失败:Err:" + err.Error()
				return
			}
			edbInfoList = append(edbInfoList, fromEdbInfo)

			//关联关系表
			{
				calculateMappingItem := &models.EdbInfoCalculateMapping{
					EdbInfoCalculateMappingId: 0,
					EdbInfoId:                 req.EdbInfoId,
					Source:                    edbInfoDetail.Source,
					SourceName:                edbInfoDetail.SourceName,
					EdbCode:                   edbInfoDetail.EdbCode,
					FromEdbInfoId:             fromEdbInfo.EdbInfoId,
					FromEdbCode:               fromEdbInfo.EdbCode,
					FromEdbName:               fromEdbInfo.EdbName,
					FromSource:                fromEdbInfo.Source,
					FromSourceName:            fromEdbInfo.SourceName,
					FromTag:                   v.FromTag,
					Sort:                      k + 1,
					CreateTime:                time.Now(),
					ModifyTime:                time.Now(),
				}
				calculateMappingList = append(calculateMappingList, calculateMappingItem)
			}
		}

		//预先计算，判断公式是否正常
		ok, _ := models.CheckFormula2(edbInfoList, formulaMap, calculateFormula, edbInfoIdBytes)
		if !ok {
			br.Msg = "生成计算指标失败，请使用正确的计算公式"
			return
		}

		//关联关系表
		{
			if len(calculateMappingList) > 0 {
				go models.AddEdbInfoCalculateMappingMulti(calculateMappingList)
			}
		}

		err = models.AddCalculate(edbInfoList, edbInfoDetail.EdbInfoId, edbInfoDetail.EdbCode, req.CalculateFormula, edbInfoIdBytes)
		if err != nil {
			br.Msg = "生成计算指标失败"
			br.Msg = "生成计算指标失败,Calculate Err:" + err.Error()
			return
		}
		// 更新指标最大最小值
		err, errMsg := models.UnifiedModifyEdbInfoMaxAndMinInfo(edbInfoDetail)
		if err != nil {
			br.Msg = errMsg
			br.ErrMsg = err.Error()
			return
		}
	}

	// 修改指标信息
	err = models.ModifyCalculateEdbInfo(req.EdbName, req.Frequency, req.Unit, req.CalculateFormula, req.ClassifyId, req.EdbInfoId)
	if err != nil {
		br.Msg = "修改失败"
		br.Msg = "修改失败,ModifyEdbInfo Err:" + err.Error()
		return
	}

	resp := models.AddEdbInfoResp{
		EdbInfoId:  edbInfoDetail.EdbInfoId,
		UniqueCode: edbInfoDetail.UniqueCode,
	}
	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() {
		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
	}

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

	var formulaInt int
	if req.Source == utils.DATA_SOURCE_CALCULATE_NSZYDPJJS ||
		req.Source == utils.DATA_SOURCE_CALCULATE_HBZ ||
		req.Source == utils.DATA_SOURCE_CALCULATE_HCZ ||
		req.Source == utils.DATA_SOURCE_CALCULATE_TIME_SHIFT ||
		req.Source == utils.DATA_SOURCE_CALCULATE_CJJX {
		if req.Formula == "" {
			br.Msg = "请填写N值"
			return
		}
		formulaInt, _ = strconv.Atoi(req.Formula)
		if formulaInt <= 0 {
			br.Msg = "N值输入错误,请重新输入"
			return
		}
	} else if req.Source == utils.DATA_SOURCE_CALCULATE_ZJPJ {
		//直接拼接指标

		//校验时间格式
		_, err = time.ParseInLocation(utils.FormatDate, req.Formula, time.Local)
		if err != nil {
			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

	var condition string
	var pars []interface{}
	condition += " AND edb_name=? "
	pars = append(pars, req.EdbName)

	count, err := models.GetEdbInfoCountByCondition(condition, pars)
	if err != nil {
		br.Msg = "判断指标名称是否存在失败"
		br.ErrMsg = "判断指标名称是否存在失败,Err:" + err.Error()
		return
	}

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

	fromEdbInfo, err := models.GetEdbInfoById(req.FromEdbInfoId)
	if err != nil {
		br.Msg = "获取指标信息失败"
		br.ErrMsg = "获取指标信息失败:Err:" + err.Error()
		return
	}

	//生成指标编码
	randStr := utils.GetRandDigit(4)
	edbCode := `C` + time.Now().Format("060102") + randStr
	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
	if req.Source == utils.DATA_SOURCE_CALCULATE_LJZZY {
		sourName = "累计值转月值"
		if fromEdbInfo.Frequency != "月度" {
			br.Msg = "请选择月度指标"
			return
		}
		edbInfo, err = models.AddCalculateLjzzy(&req, fromEdbInfo, edbCode, uniqueCode, sysUserId, sysUserName)
	} else if req.Source == utils.DATA_SOURCE_CALCULATE_TBZ {
		sourName = "同比值"
		edbInfo, err = models.AddCalculateTbz(&req, fromEdbInfo, edbCode, uniqueCode, sysUserId, sysUserName)
	} else if req.Source == utils.DATA_SOURCE_CALCULATE_TCZ {
		sourName = "同差值"
		edbInfo, err = models.AddCalculateTcz(&req, fromEdbInfo, edbCode, uniqueCode, sysUserId, sysUserName)
	} else if req.Source == utils.DATA_SOURCE_CALCULATE_NSZYDPJJS {
		sourName = "N数值移动平均计算"
		edbInfo, err = models.AddCalculateNszydpjjs(&req, fromEdbInfo, edbCode, uniqueCode, sysUserId, sysUserName, formulaInt)
	} else if req.Source == utils.DATA_SOURCE_CALCULATE_HBZ {
		var condition string
		var pars []interface{}
		condition += " AND edb_info_id =? "
		pars = append(pars, req.FromEdbInfoId)
		condition += " AND value <=0 "
		checkCount, err := models.GetEdbDataCount(condition, pars, fromEdbInfo.Source)
		if err != nil && err.Error() != utils.ErrNoRow() {
			br.Msg = "判断环比值是否可计算失败"
			br.ErrMsg = "判断环比值是否可计算失败,Err:" + err.Error()
			return
		}
		if checkCount > 0 {
			br.Msg = "原始数据中存在0或负数，该指标不能进行环比运算"
			br.ErrMsg = "原始数据中出现0和负值时，提示该指标不能进行环比运算"
			return
		}
		sourName = "环比值"
		edbInfo, err = models.AddCalculateHbz(&req, fromEdbInfo, edbCode, uniqueCode, sysUserId, sysUserName, formulaInt)
	} else if req.Source == utils.DATA_SOURCE_CALCULATE_HCZ {
		sourName = "环差值"
		edbInfo, err = models.AddCalculateHcz(&req, fromEdbInfo, edbCode, uniqueCode, sysUserId, sysUserName, formulaInt)
	} else if req.Source == utils.DATA_SOURCE_CALCULATE_BP {
		//if fromEdbInfo.Frequency == "日度" {
		//	br.Msg = "日度指标,无法进行变频操作"
		//	br.ErrMsg = "日度指标,无法进行变频操作:edbcode:" + fromEdbInfo.EdbCode
		//	return
		//}
		sourName = "变频"
		edbInfo, err = models.AddCalculateBp(&req, fromEdbInfo, edbCode, uniqueCode, sysUserId, sysUserName)
	} else if req.Source == utils.DATA_SOURCE_CALCULATE_TIME_SHIFT { //时间移位
		sourName = "时间移位"
		edbInfo, err = models.AddCalculateTimeShift(&req, fromEdbInfo, edbCode, uniqueCode, sysUserId, sysUserName)
	} else if req.Source == utils.DATA_SOURCE_CALCULATE_ZJPJ { //直接拼接
		sourName = "直接拼接"

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

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

		if fromEdbInfo.EdbInfoId == secondEdbInfo.EdbInfoId {
			br.Msg = "两个指标不允许为同一个"
			br.ErrMsg = "两个指标不允许为同一个"
			return
		}
		edbInfo, err = models.AddCalculateZjpj(&req, fromEdbInfo, secondEdbInfo, edbCode, uniqueCode, sysUserId, sysUserName)
	} else if req.Source == 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, err := models.GetEdbInfoById(secondEdbInfoReq.EdbInfoId)
		if err != nil {
			br.Msg = "获取同比值指标信息失败"
			br.ErrMsg = "获取同比值指标信息失败:Err:" + err.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)
	} else if req.Source == utils.DATA_SOURCE_CALCULATE_CJJX {
		sourName = "超季节性"
		edbInfo, err = models.AddCalculateCjjx(&req, fromEdbInfo, edbCode, uniqueCode, sysUserId, sysUserName, formulaInt)
	} else {
		br.Msg = "无效计算方式"
		br.ErrMsg = "无效计算方式,source:" + strconv.Itoa(req.Source)
		return
	}
	if err != nil {
		br.Msg = "生成" + sourName + "失败"
		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.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
}

// 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
	}

	var condition string
	var pars []interface{}
	condition += " AND edb_name=? "
	pars = append(pars, req.EdbName)

	condition += " AND edb_info_id<>? "
	pars = append(pars, req.EdbInfoId)

	count, err := models.GetEdbInfoCountByCondition(condition, pars)
	if err != nil {
		br.Msg = "判断指标名称是否存在失败"
		br.ErrMsg = "判断指标名称是否存在失败,Err:" + err.Error()
		return
	}

	if count > 0 {
		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
	}

	fromEdbInfo, err := models.GetEdbInfoById(req.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
	}

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

	var formulaInt int
	if req.Source == utils.DATA_SOURCE_CALCULATE_NSZYDPJJS ||
		req.Source == utils.DATA_SOURCE_CALCULATE_HBZ ||
		req.Source == utils.DATA_SOURCE_CALCULATE_HCZ ||
		req.Source == utils.DATA_SOURCE_CALCULATE_TIME_SHIFT ||
		req.Source == utils.DATA_SOURCE_CALCULATE_CJJX {
		if req.Formula == "" {
			br.Msg = "请填写N值"
			return
		}
		formulaInt, _ = strconv.Atoi(req.Formula)
		if formulaInt <= 0 {
			br.Msg = "N值输入错误,请重新输入"
			return
		}
	} else if req.Source == utils.DATA_SOURCE_CALCULATE_ZJPJ {
		//直接拼接指标

		//校验时间格式
		_, err = time.ParseInLocation(utils.FormatDate, req.Formula, time.Local)
		if err != nil {
			br.Msg = "拼接日期有误,请重新输入"
			return
		}
	}

	var sourName string
	var edbInfoId int

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

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

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

		if fromEdbInfo.EdbInfoId == secondEdbInfo.EdbInfoId {
			br.Msg = "两个指标不允许为同一个"
			br.ErrMsg = "两个指标不允许为同一个"
			return
		}
		err = models.EditCalculateZjpj(&req, edbInfo, fromEdbInfo, secondEdbInfo)
	} else if req.Source == 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, err := models.GetEdbInfoById(secondEdbInfoReq.EdbInfoId)
		if err != nil {
			br.Msg = "获取同比值指标信息失败"
			br.ErrMsg = "获取同比值指标信息失败:Err:" + err.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)

	} else if req.Source == utils.DATA_SOURCE_CALCULATE_CJJX {
		sourName = "超季节性"
		err = models.EditCalculateCjjx(&req, edbInfo, fromEdbInfo, formulaInt)
	} else {
		br.Msg = "无效计算方式"
		br.ErrMsg = "无效计算方式,source:" + strconv.Itoa(req.Source)
		return
	}
	if err != nil {
		br.Msg = "生成" + sourName + "失败"
		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.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
}

// 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

	switch source {
	case utils.DATA_SOURCE_CALCULATE:
		//startDate = edbInfo.StartDate
		//sTime, err := time.Parse(utils.FormatDate, edbInfo.EndDate)
		//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)

		for _, v := range calculateMap {
			formulaStr += v.FromTag + ","
			edbInfoIdBytes = append(edbInfoIdBytes, v.FromTag)
			edbInfo, _ := models.GetEdbInfoById(v.FromEdbInfoId)
			edbInfoList = append(edbInfoList, edbInfo)
		}
		err = models.RefreshAllCalculate(edbInfoList, edbInfo.EdbInfoId, source, edbInfo.EdbCode, edbInfo.CalculateFormula, startDate, endDate, edbInfoIdBytes)
		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)
		err = models.RefreshAllCalculateLjzzy(edbInfoId, source, 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, 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, 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
		err = models.RefreshAllCalculateNszydpjjs(edbInfoId, edbInfo.Source, 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 = edbInfo.StartDate
		endDate = time.Now().Format(utils.FormatDate)
		formulaInt, _ := strconv.Atoi(edbInfo.CalculateFormula)
		err = models.RefreshAllCalculateHbz(edbInfoId, source, 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 = edbInfo.StartDate
		endDate = time.Now().Format(utils.FormatDate)
		formulaInt, _ := strconv.Atoi(edbInfo.CalculateFormula)
		err = models.RefreshAllCalculateHcz(edbInfoId, source, 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, fromEdbInfo, calculateTbz.EdbCode, startDate, endDate)
		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
		endDate = time.Now().Format(utils.FormatDate)
		formulaInt, _ := strconv.Atoi(calculate.CalculateFormula)
		err = models.RefreshAllCalculateTimeShift(edbInfoId, source, 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_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.ErrMsg = 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 = edbInfo.StartDate
		err = models.RefreshAllCalculateCjjx(edbInfoId, edbInfo.Source, fromEdbInfo, calculateCjjx.EdbCode, startDate, "", formulaInt)
		if err != nil && err.Error() != utils.ErrNoRow() {
			errMsg = "RefreshAllCalculateCjjx Err:" + err.Error()
			break
		}

	default:
		br.Msg = "来源异常，请联系相关开发！"
		br.ErrMsg = "来源异常，请联系相关开发"
		return
	}
	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
	}
	br.Ret = 200
	br.Success = true
	br.Msg = "获取成功"
}