批量指标计算改版

controllers/base_from_calculate.go

@@ -10,6 +10,7 @@ import (
 	"fmt"
 	"strconv"
 	"strings"
+	"sync"
 	"time"
 )
 
@@ -2199,3 +2200,121 @@ func (this *CalculateController) Calculate() {
 	}
 	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,
+
+			//CalculateFormula: edbInfo.CalculateFormula,
+			EdbInfoIdArr: req.EdbInfoIdArr,
+			Calendar:     req.Calendar,
+			Extra:        req.Extra,
+		}
+		var errMsg string
+
+		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:   reqItem.EdbInfoId,
+						UniqueCode:  uniqueCode,
+					})
+				}
+				wg.Done()
+			}()
+
+			uniqueCode, err, errMsg = services.EdbCalculateBatchSave(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
+}

models/base_from_calculate.go

@@ -622,6 +622,32 @@ func GetFormulaMap() map[string]string {
 	return funMap
 }
 
+// CalculateBatchSaveReq 添加计算指标的请求参数
+type CalculateBatchSaveReq struct {
+	EdbList          []*CalculateEdbInfoItem        //需要批量计算的指标列表
+	AdminId          int                            `description:"添加人id"`
+	AdminName        string                         `description:"添加人名称"`
+	Formula          string                         `description:"N值/移动天数"`
+	Source           int                            `description:"来源:1:同花顺,2:wind,3:彭博,4:指标运算,5:累计值转月,6:同比值,7:同差值,8:N数值移动平均计算,12:环比值,13:环差值,14:升频"`
+	CalculateFormula string                         `description:"计算公式"`
+	EdbInfoIdArr     []EdbInfoCalculateEdbInfoIdReq `description:"关联指标列表"`
+	MoveType         int                            `description:"移动方式:1:领先(默认),2:滞后"`
+	MoveFrequency    string                         `description:"移动频度:天/周/月/季/年"`
+	Calendar         string                         `description:"公历/农历"`
+	Data             interface{}                    `description:"数据"`
+	Extra            string                         `description:"指标的额外配置"`
+}
+
+type CalculateEdbInfoItem struct {
+	EdbInfoId     int    `description:"指标id"`
+	EdbName       string `description:"指标名称"`
+	Frequency     string `description:"频度"`
+	Unit          string `description:"单位"`
+	ClassifyId    int    `description:"分类id"`
+	CalculateId   string `description:"当前请求时,单个计算的唯一标识"`
+	FromEdbInfoId int    `description:"计算来源指标id"`
+}
+
 // EdbInfoCalculateBatchSaveReq 添加计算指标的请求参数
 type EdbInfoCalculateBatchSaveReq struct {
 	AdminId          int                            `description:"添加人id"`
@@ -914,3 +940,24 @@ type PredictRuleCalculateByNineResp struct {
 	LatestDate string
 	DataList   interface{}
 }
+
+// BatchEdbInfoCalculateBatchSaveResp 批量添加 计算指标 返回数据
+type BatchEdbInfoCalculateBatchSaveResp struct {
+	Fail    []BatchEdbInfoCalculateBatchSaveFailResp    `description:"添加失败的指标"`
+	Success []BatchEdbInfoCalculateBatchSaveSuccessResp `description:"添加成功的指标"`
+}
+
+// BatchEdbInfoCalculateBatchSaveFailResp 添加失败的指标信息
+type BatchEdbInfoCalculateBatchSaveFailResp struct {
+	CalculateId string `description:"当前请求时,单个计算的唯一标识"`
+	Msg         string `description:"用户提示信息"`
+	ErrMsg      string `description:"错误信息,内部查看"`
+}
+
+// BatchEdbInfoCalculateBatchSaveSuccessResp 添加成功的指标信息
+type BatchEdbInfoCalculateBatchSaveSuccessResp struct {
+	ClassifyId  int    `description:"分类id"`
+	CalculateId string `description:"当前请求时,单个计算的唯一标识"`
+	EdbInfoId   int    `description:"指标ID"`
+	UniqueCode  string `description:"指标唯一编码"`
+}

routers/commentsRouter.go

@@ -124,6 +124,15 @@ func init() {
             Filters: nil,
             Params: nil})
 
+    beego.GlobalControllerRouter["eta/eta_index_lib/controllers:CalculateController"] = append(beego.GlobalControllerRouter["eta/eta_index_lib/controllers:CalculateController"],
+        beego.ControllerComments{
+            Method: "BatchSaveMulti",
+            Router: `/batch/save/multi`,
+            AllowHTTPMethods: []string{"post"},
+            MethodParams: param.Make(),
+            Filters: nil,
+            Params: nil})
+
     beego.GlobalControllerRouter["eta/eta_index_lib/controllers:CalculateController"] = append(beego.GlobalControllerRouter["eta/eta_index_lib/controllers:CalculateController"],
         beego.ControllerComments{
             Method: "CalculateComputeCorrelation",

services/base_from_calculate.go

@@ -0,0 +1,428 @@
+package services
+
+import (
+	"eta/eta_index_lib/logic"
+	"eta/eta_index_lib/models"
+	"eta/eta_index_lib/utils"
+	"fmt"
+	"strconv"
+	"strings"
+	"time"
+)
+
+// EdbCalculateBatchSave 批量指标运算
+func EdbCalculateBatchSave(req models.EdbInfoCalculateBatchSaveReq) (uniqueCode string, err error, errMsg string) {
+	// 校验参数
+	req.EdbName = strings.Trim(req.EdbName, " ")
+	if req.EdbName == "" {
+		err = fmt.Errorf("指标名称不能为空")
+		return
+	}
+
+	if req.Frequency == "" {
+		err = fmt.Errorf("频率不能为空")
+		return
+	}
+
+	if req.Unit == "" {
+		err = fmt.Errorf("单位不能为空")
+		return
+	}
+
+	if req.ClassifyId <= 0 {
+		err = fmt.Errorf("请选择分类")
+		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 == "" {
+			err = fmt.Errorf("请填写N值")
+			return
+		}
+		formulaInt, _ = strconv.Atoi(req.Formula)
+		if formulaInt <= 0 {
+			err = fmt.Errorf(" N值输入错误,请重新输入")
+			return
+		}
+	case utils.DATA_SOURCE_CALCULATE_ZJPJ:
+		//直接拼接指标
+		//校验时间格式
+		_, err = time.ParseInLocation(utils.FormatDate, req.Formula, time.Local)
+		if err != nil {
+			err = fmt.Errorf("拼接日期有误,请重新输入")
+			return
+		}
+	case utils.DATA_SOURCE_CALCULATE_NHCC: //拟合残差指标
+		//指标校验
+		if len(req.EdbInfoIdArr) != 2 {
+			err = fmt.Errorf("选择的指标异常,请重新选择")
+			return
+		}
+		fromEdbInfoId = req.EdbInfoIdArr[0].EdbInfoId
+
+		//校验时间格式
+		//数据格式：2022-11-01,2022-11-10
+		timeList := strings.Split(req.Formula, ",")
+		if len(timeList) != 2 {
+			err = fmt.Errorf("选择时间有误,请重新输入")
+			return
+		}
+		startDate, e := time.ParseInLocation(utils.FormatDate, timeList[0], time.Local)
+		if e != nil {
+			err = fmt.Errorf("开始日期有误,请重新输入")
+			return
+		}
+		endDate, e := time.ParseInLocation(utils.FormatDate, timeList[1], time.Local)
+		if e != nil {
+			err = fmt.Errorf("结束日期有误,请重新输入")
+			return
+		}
+		if utils.GetTimeSubDay(startDate, endDate) < 2 {
+			err = fmt.Errorf("日期间隔不得少于两天")
+			return
+		}
+		nhccDate.StartDate = startDate
+		nhccDate.EndDate = endDate
+	case utils.DATA_SOURCE_CALCULATE_JP:
+		if req.Formula != "期末值" && req.Formula != "平均值" {
+			err = fmt.Errorf("数据取值类型错误:" + req.Formula)
+			return
+		}
+	case utils.DATA_SOURCE_CALCULATE_ZSXY: // 指数修匀
+		if req.Formula == "" {
+			err = fmt.Errorf("请填写alpha值")
+			return
+		}
+		a, e := strconv.ParseFloat(req.Formula, 64)
+		if e != nil {
+			err = fmt.Errorf("alpha值输入错误, 请重新输入")
+			return
+		}
+		if a <= 0 || a >= 1 {
+			err = fmt.Errorf("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) {
+		err = fmt.Errorf("请选择指标")
+		return
+	}
+	//加入缓存机制，避免创建同一个名称的指标 start
+	redisKey := fmt.Sprint("edb_lib:edb_info:calculate:batch:save:", req.Source, ":", req.EdbName)
+	isExist := utils.Rc.IsExist(redisKey)
+	if isExist {
+		err = fmt.Errorf("指标正在处理,请勿重复提交")
+		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 {
+		err = fmt.Errorf("判断指标名称是否存在失败")
+		errMsg = "判断指标名称是否存在失败,Err:" + err.Error()
+		return
+	}
+
+	if count > 0 {
+		err = fmt.Errorf("指标名称已存在，请重新填写")
+		errMsg = "指标名称已存在，请重新填写"
+		return
+	}
+
+	// 来源指标
+	var fromEdbInfo *models.EdbInfo
+	if fromEdbInfoId > 0 {
+		fromEdbInfo, err = models.GetEdbInfoById(fromEdbInfoId)
+		if err != nil {
+			errMsg = "获取指标信息失败:Err:" + err.Error()
+			err = fmt.Errorf("获取指标信息失败")
+			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
+
+	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 != "月度" {
+			err = fmt.Errorf("请选择月度指标")
+			return
+		}
+		edbInfo, err = models.AddCalculateLjzzy(&req, fromEdbInfo, edbCode, uniqueCode, sysUserId, sysUserName)
+	case utils.DATA_SOURCE_CALCULATE_TBZ:
+		if req.Frequency != fromEdbInfo.Frequency {
+			err = fmt.Errorf("当前频度和原指标频度不一致")
+			return
+		}
+		if req.Unit != "无" {
+			err = fmt.Errorf("单位只允许为无，禁止选择其他单位")
+			return
+		}
+		sourName = "同比值"
+		edbInfo, err = models.AddCalculateTbz(&req, fromEdbInfo, edbCode, uniqueCode, sysUserId, sysUserName)
+	case utils.DATA_SOURCE_CALCULATE_TCZ:
+		if req.Frequency != fromEdbInfo.Frequency {
+			err = fmt.Errorf("当前频度和原指标频度不一致")
+			return
+		}
+		if req.Unit != fromEdbInfo.Unit {
+			err = fmt.Errorf("当前单位和原指标单位不一致")
+			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:
+		var condition string
+		var pars []interface{}
+		condition += " AND edb_info_id =? "
+		pars = append(pars, fromEdbInfoId)
+		condition += " AND value <=0 "
+		checkCount, tmpErr := models.GetEdbDataCount(condition, pars, fromEdbInfo.Source, fromEdbInfo.SubSource)
+		if tmpErr != nil && tmpErr.Error() != utils.ErrNoRow() {
+			err = fmt.Errorf("判断环比值是否可计算失败")
+			errMsg = "判断环比值是否可计算失败,Err:" + tmpErr.Error()
+			return
+		}
+		if checkCount > 0 {
+			err = fmt.Errorf("原始数据中存在0或负数，该指标不能进行环比运算")
+			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 {
+			err = fmt.Errorf("请传入拼接日期之后的指标")
+			errMsg = "请传入拼接日期之后的指标"
+			return
+		}
+
+		secondEdbInfoReq := req.EdbInfoIdArr[0]
+		secondEdbInfo, tmpErr := models.GetEdbInfoById(secondEdbInfoReq.EdbInfoId)
+		if tmpErr != nil {
+			err = fmt.Errorf("获取拼接日期之后的指标信息失败")
+			errMsg = "获取拼接日期之后的指标信息失败:Err:" + tmpErr.Error()
+			return
+		}
+
+		if fromEdbInfo.EdbInfoId == secondEdbInfo.EdbInfoId {
+			err = fmt.Errorf("两个指标不允许为同一个")
+			errMsg = "两个指标不允许为同一个"
+			return
+		}
+		edbInfo, err = models.AddCalculateZjpj(&req, fromEdbInfo, secondEdbInfo, edbCode, uniqueCode, sysUserId, sysUserName)
+	case utils.DATA_SOURCE_CALCULATE_LJZTBPJ:
+		sourName = "累计值同比拼接"
+
+		if fromEdbInfo.Frequency != "月度" {
+			err = fmt.Errorf("待拼接指标只能筛选月度指标")
+			errMsg = "待拼接指标只能筛选月度指标"
+			return
+		}
+		if len(req.EdbInfoIdArr) != 1 {
+			err = fmt.Errorf("请传入同比值指标")
+			errMsg = "请传入同比值指标"
+			return
+		}
+
+		secondEdbInfoReq := req.EdbInfoIdArr[0]
+		tbzEdbInfo, tmpErr := models.GetEdbInfoById(secondEdbInfoReq.EdbInfoId)
+		if tmpErr != nil {
+			err = fmt.Errorf("获取同比值指标信息失败")
+			errMsg = "获取同比值指标信息失败:Err:" + tmpErr.Error()
+			return
+		}
+		if tbzEdbInfo.Source != utils.DATA_SOURCE_CALCULATE_TBZ {
+			err = fmt.Errorf("指标必须是传入同比值指标类型")
+			errMsg = "指标必须是传入同比值指标类型"
+			return
+		}
+		if tbzEdbInfo.Frequency != "月度" {
+			err = fmt.Errorf("同比值指标只能筛选月度指标")
+			errMsg = "同比值指标只能筛选月度指标"
+			return
+		}
+
+		if fromEdbInfo.EdbInfoId == tbzEdbInfo.EdbInfoId {
+			err = fmt.Errorf("两个指标不允许为同一个")
+			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 {
+			err = fmt.Errorf("获取因变量的指标信息失败")
+			errMsg = "获取因变量的指标信息失败:Err:" + tmpErr.Error()
+			return
+		}
+
+		if fromEdbInfo.EdbInfoId == secondEdbInfo.EdbInfoId {
+			err = fmt.Errorf("两个指标不允许为同一个")
+			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) {
+			err = fmt.Errorf("频度异常,不允许低频降频到高频")
+			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 {
+			err = fmt.Errorf("指标数量不能小于2个，请重新选择")
+			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 {
+			err = fmt.Errorf("指标数量不能小于2个，请重新选择")
+			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 == "日度" {
+			err = fmt.Errorf("日度指标无需进行日均值计算")
+			return
+		}
+		if req.Frequency != fromEdbInfo.Frequency {
+			err = fmt.Errorf("当前频度和原指标频度不一致")
+			return
+		}
+		if req.Unit != fromEdbInfo.Unit {
+			err = fmt.Errorf("单位只允许为和原指标频度保持一致，禁止选择其他单位")
+			return
+		}
+		sourName = "日均值"
+		edbInfo, err = models.AddCalculateRjz(&req, fromEdbInfo, edbCode, uniqueCode, sysUserId, sysUserName)
+	default:
+		// 获取通用的数据源处理服务
+		baseEdbInfoModel = models.GetBaseEdbInfoModel(req.Source)
+		// 没有找到的话，那么就直接返回报错吧
+		if baseEdbInfoModel == nil {
+			err = fmt.Errorf("无效计算方式")
+			errMsg = "无效计算方式,source:" + strconv.Itoa(req.Source)
+			return
+		}
+		sourName = baseEdbInfoModel.GetSourceName()
+		edbInfo, err, errMsg = baseEdbInfoModel.Add(addParam)
+	}
+
+	if err != nil {
+		errMsg = "生成" + sourName + "失败 Err:" + err.Error() + errMsg
+		err = fmt.Errorf("生成" + sourName + "失败")
+		return
+	}
+
+	if edbInfo == nil {
+		err = fmt.Errorf("生成" + sourName + "失败")
+		errMsg = "生成" + sourName + "失败,指标ID错误:" + strconv.Itoa(edbInfoId)
+		return
+	}
+	edbInfoId = edbInfo.EdbInfoId
+
+	//处理同名指标
+	{
+		edbNameList, tErr := models.GetEdbInfoByName(req.EdbName)
+		if tErr != nil {
+			err = fmt.Errorf("保存失败")
+			errMsg = "获取指标信息失败，Err:" + tErr.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
+	}
+
+	// 更新ES
+	go logic.UpdateEs(edbInfo.EdbInfoId)
+	return
+}