Jelajahi Sumber

多指标编辑接口

xyxie 1 tahun lalu
induk
melakukan
858b94c27d

+ 123 - 0
controllers/base_from_calculate.go

@@ -2181,3 +2181,126 @@ func (this *CalculateController) BatchSaveMulti() {
 	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,
+			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
+}

+ 17 - 18
models/base_from_calculate.go

@@ -682,24 +682,23 @@ type EdbInfoCalculateEdbInfoIdReq struct {
 
 // EdbInfoCalculateBatchEditReq 编辑计算指标的请求参数
 type EdbInfoCalculateBatchEditReq struct {
-	EdbName       string `description:"指标名称"`
-	Frequency     string `description:"频度"`
-	Unit          string `description:"单位"`
-	ClassifyId    int    `description:"分类id"`
-	Formula       string `description:"N值"`
-	EdbInfoId     int    `description:"编辑指标id"`
-	FromEdbInfoId int    `description:"计算来源指标id"`
-	Source        int    `description:"来源:1:同花顺,2:wind,3:彭博,4:指标运算,5:累计值转月,6:同比值,7:同差值,8:N数值移动平均计算,12:环比值,13:环差值,14:升频"`
-	MoveType      int    `description:"移动方式:1:领先(默认),2:滞后"`
-	MoveFrequency string `description:"移动频度:天/周/月/季/年"`
-	EdbInfoIdArr  []struct {
-		EdbInfoId int    `description:"指标id"`
-		FromTag   string `description:"指标对应标签"`
-		MoveValue int    `description:"移动的值"`
-	}
-	Calendar string      `description:"公历/农历" orm:"default(公历)"`
-	Extra    string      `description:"指标的额外配置"`
-	Data     interface{} `description:"数据"`
+	EdbName          string                         `description:"指标名称"`
+	Frequency        string                         `description:"频度"`
+	Unit             string                         `description:"单位"`
+	ClassifyId       int                            `description:"分类id"`
+	Formula          string                         `description:"N值"`
+	EdbInfoId        int                            `description:"编辑指标id"`
+	FromEdbInfoId    int                            `description:"计算来源指标id"`
+	Source           int                            `description:"来源:1:同花顺,2:wind,3:彭博,4:指标运算,5:累计值转月,6:同比值,7:同差值,8:N数值移动平均计算,12:环比值,13:环差值,14:升频"`
+	MoveType         int                            `description:"移动方式:1:领先(默认),2:滞后"`
+	MoveFrequency    string                         `description:"移动频度:天/周/月/季/年"`
+	EdbInfoIdArr     []EdbInfoCalculateEdbInfoIdReq `description:"关联指标列表"`
+	Calendar         string                         `description:"公历/农历" orm:"default(公历)"`
+	Extra            string                         `description:"指标的额外配置"`
+	Data             interface{}                    `description:"数据"`
+	EmptyType        int                            `description:"空值处理类型(0查找前后35天,1不计算,2前值填充,3后值填充,4等于0)"`
+	MaxEmptyType     int                            `description:"MAX、MIN公式空值处理类型(1、等于0;2、跳过空值)"`
+	CalculateFormula string                         `description:"计算公式"`
 }
 
 // CheckFormula2 校验公式是否正常(比如说除法的分母不能为0之类的,实际上就是用预设的字段数据做一次计算)

+ 46 - 2
models/edb_data_calculate_avg.go

@@ -53,6 +53,9 @@ func (obj CalculateAvg) Add(params AddCalculateBatchParams) (edbInfo *EdbInfo, e
 	edbInfo.ModifyTime = time.Now()
 	edbInfo.UniqueCode = params.UniqueCode
 	edbInfo.EdbType = obj.GetEdbType()
+	edbInfo.EmptyType = req.EmptyType
+	edbInfo.MaxEmptyType = req.MaxEmptyType
+	edbInfo.Extra = req.Extra
 	newEdbInfoId, tmpErr := to.Insert(edbInfo)
 	if tmpErr != nil {
 		err = tmpErr
@@ -112,13 +115,22 @@ func (obj CalculateAvg) Edit(params EditCalculateBatchParams) (err error, errMsg
 	}
 	defer func() {
 		if err != nil {
-			fmt.Println("EditCalculateKszs,Err:" + err.Error())
+			fmt.Println("CalculateAvg.Edit,Err:" + err.Error())
 			_ = to.Rollback()
 		} else {
 			_ = to.Commit()
 		}
 	}()
 
+	if len(req.EdbInfoIdArr) <= 0 {
+		err = fmt.Errorf("请选择要关联的指标")
+		return
+	}
+	needCalculate := false
+	if edbInfo.EmptyType != req.EmptyType || edbInfo.Extra != req.Extra {
+		needCalculate = true
+	}
+
 	//修改指标信息
 	edbInfo.EdbName = req.EdbName
 	edbInfo.EdbNameSource = req.EdbName
@@ -126,12 +138,44 @@ func (obj CalculateAvg) Edit(params EditCalculateBatchParams) (err error, errMsg
 	edbInfo.Unit = req.Unit
 	edbInfo.ClassifyId = req.ClassifyId
 	edbInfo.CalculateFormula = req.Formula
+	edbInfo.Extra = req.Extra
+	edbInfo.EmptyType = req.EmptyType
+	edbInfo.MaxEmptyType = req.MaxEmptyType
 	edbInfo.ModifyTime = time.Now()
-	_, err = to.Update(edbInfo, "EdbName", "EdbNameSource", "Frequency", "Unit", "ClassifyId", "CalculateFormula", "ModifyTime")
+	_, err = to.Update(edbInfo, "EdbName", "EdbNameSource", "Frequency", "Unit", "ClassifyId", "CalculateFormula", "Extra", "EmptyType", "MaxEmptyType", "ModifyTime")
 	if err != nil {
 		return
 	}
+	//判断是否重复指标
+	//edbInfoMap := make(map[int]string)
+	if !needCalculate {
+		//用到的指标
+		newEdbInfoIdArr := make([]string, 0)
+		for _, tmpEdbInfo := range req.EdbInfoIdArr {
+			/*_, ok := edbInfoMap[tmpEdbInfo.EdbInfoId]
+			if ok {
+				br.Msg = "选择指标失败,请勿选择重复指标!"
+				return
+			}
+			edbInfoMap[tmpEdbInfo.EdbInfoId] = tmpEdbInfo.FromTag*/
+			newEdbInfoIdArr = append(newEdbInfoIdArr, strconv.Itoa(tmpEdbInfo.EdbInfoId))
+		}
+
+		edbInfoIdStr := strings.Join(newEdbInfoIdArr, ",")
+		oldEdbInfoIdStr, e := GetCalculateEdbInfo(req.EdbInfoId)
+		if e != nil {
+			errMsg = "获取数据失败,GetCalculateEdbInfo:" + e.Error()
+			err = fmt.Errorf("查询关联指标失败")
+			return
+		}
 
+		if edbInfoIdStr != oldEdbInfoIdStr { // 不需要重复计算
+			needCalculate = true
+		}
+	}
+	if !needCalculate {
+		return
+	}
 	//删除,计算指标关联的,基础指标的关联关系
 	sql := ` DELETE FROM edb_info_calculate_mapping WHERE edb_info_id = ? `
 	_, err = to.Raw(sql, edbInfo.EdbInfoId).Exec()

+ 45 - 1
models/edb_data_calculate_sum.go

@@ -53,6 +53,9 @@ func (obj CalculateSum) Add(params AddCalculateBatchParams) (edbInfo *EdbInfo, e
 	edbInfo.ModifyTime = time.Now()
 	edbInfo.UniqueCode = params.UniqueCode
 	edbInfo.EdbType = obj.GetEdbType()
+	edbInfo.EmptyType = req.EmptyType
+	edbInfo.MaxEmptyType = req.MaxEmptyType
+	edbInfo.Extra = req.Extra
 	newEdbInfoId, tmpErr := to.Insert(edbInfo)
 	if tmpErr != nil {
 		err = tmpErr
@@ -119,6 +122,15 @@ func (obj CalculateSum) Edit(params EditCalculateBatchParams) (err error, errMsg
 		}
 	}()
 
+	if len(req.EdbInfoIdArr) <= 0 {
+		err = fmt.Errorf("请选择要关联的指标")
+		return
+	}
+	needCalculate := false
+	if edbInfo.EmptyType != req.EmptyType || edbInfo.Extra != req.Extra {
+		needCalculate = true
+	}
+
 	//修改指标信息
 	edbInfo.EdbName = req.EdbName
 	edbInfo.EdbNameSource = req.EdbName
@@ -126,12 +138,44 @@ func (obj CalculateSum) Edit(params EditCalculateBatchParams) (err error, errMsg
 	edbInfo.Unit = req.Unit
 	edbInfo.ClassifyId = req.ClassifyId
 	edbInfo.CalculateFormula = req.Formula
+	edbInfo.Extra = req.Extra
+	edbInfo.EmptyType = req.EmptyType
+	edbInfo.MaxEmptyType = req.MaxEmptyType
 	edbInfo.ModifyTime = time.Now()
-	_, err = to.Update(edbInfo, "EdbName", "EdbNameSource", "Frequency", "Unit", "ClassifyId", "CalculateFormula", "ModifyTime")
+	_, err = to.Update(edbInfo, "EdbName", "EdbNameSource", "Frequency", "Unit", "ClassifyId", "CalculateFormula", "Extra", "EmptyType", "MaxEmptyType", "ModifyTime")
 	if err != nil {
 		return
 	}
+	//判断是否重复指标
+	//edbInfoMap := make(map[int]string)
+	if !needCalculate {
+		//用到的指标
+		newEdbInfoIdArr := make([]string, 0)
+		for _, tmpEdbInfo := range req.EdbInfoIdArr {
+			/*_, ok := edbInfoMap[tmpEdbInfo.EdbInfoId]
+			if ok {
+				br.Msg = "选择指标失败,请勿选择重复指标!"
+				return
+			}
+			edbInfoMap[tmpEdbInfo.EdbInfoId] = tmpEdbInfo.FromTag*/
+			newEdbInfoIdArr = append(newEdbInfoIdArr, strconv.Itoa(tmpEdbInfo.EdbInfoId))
+		}
+
+		edbInfoIdStr := strings.Join(newEdbInfoIdArr, ",")
+		oldEdbInfoIdStr, e := GetCalculateEdbInfo(req.EdbInfoId)
+		if e != nil {
+			errMsg = "获取数据失败,GetCalculateEdbInfo:" + e.Error()
+			err = fmt.Errorf("查询关联指标失败")
+			return
+		}
 
+		if edbInfoIdStr != oldEdbInfoIdStr { // 不需要重复计算
+			needCalculate = true
+		}
+	}
+	if !needCalculate {
+		return
+	}
 	//删除,计算指标关联的,基础指标的关联关系
 	sql := ` DELETE FROM edb_info_calculate_mapping WHERE edb_info_id = ? `
 	_, err = to.Raw(sql, edbInfo.EdbInfoId).Exec()

+ 9 - 0
routers/commentsRouter.go

@@ -115,6 +115,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: "BatchEditMulti",
+            Router: `/batch/edit/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: "BatchSave",

+ 406 - 0
services/base_from_calculate.go

@@ -458,6 +458,412 @@ func EdbCalculateBatchSave(req models.EdbInfoCalculateBatchSaveReq) (edbInfo *mo
 	return
 }
 
+// EdbCalculateBatchEdit 批量指标编辑
+func EdbCalculateBatchEdit(req models.EdbInfoCalculateBatchEditReq) (edbInfo *models.EdbInfo, 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
+	}
+
+	if req.EdbInfoId <= 0 {
+		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=?  AND edb_info_id<>? "
+	pars = append(pars, req.EdbName, req.EdbInfoId)
+
+	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
+	}
+
+	edbInfo, err = models.GetEdbInfoById(req.EdbInfoId)
+	if err != nil {
+		if err.Error() == utils.ErrNoRow() {
+			errMsg = "指标已被删除,请刷新页面:Err:" + err.Error()
+			err = fmt.Errorf("指标已被删除,请刷新页面")
+
+			return
+		}
+		errMsg = "获取指标信息失败:Err:" + err.Error()
+		err = fmt.Errorf("获取指标信息失败")
+
+		return
+	}
+	// 基础指标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 == "" {
+			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
+		}
+	}
+	// 来源指标
+	var fromEdbInfo *models.EdbInfo
+	// 基础指标id
+	if fromEdbInfoId > 0 {
+		fromEdbInfo, err = models.GetEdbInfoById(fromEdbInfoId)
+		if err != nil {
+			errMsg = "获取指标信息失败:Err:" + err.Error()
+			err = fmt.Errorf("获取指标信息失败")
+			return
+		}
+	}
+
+	var sourName 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 != "月度" {
+			err = fmt.Errorf("请选择月度指标")
+			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:
+		var condition string
+		var pars []interface{}
+		condition += " AND edb_info_id =? "
+		pars = append(pars, req.FromEdbInfoId)
+		condition += " AND value <=0 "
+		checkCount, tmpErr := models.GetEdbDataCount(condition, pars, fromEdbInfo.Source, fromEdbInfo.SubSource)
+		if tmpErr != nil && tmpErr.Error() != utils.ErrNoRow() {
+			errMsg = "判断环比值是否可计算失败,Err:" + tmpErr.Error()
+			err = fmt.Errorf("判断环比值是否可计算失败")
+			return
+		}
+		if checkCount > 0 {
+			err = fmt.Errorf("原始数据中存在0或负数,该指标不能进行环比运算")
+			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_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 {
+			errMsg = "获取拼接日期之后的指标信息失败:Err:" + tmpErr.Error()
+			err = fmt.Errorf("获取拼接日期之后的指标信息失败")
+			return
+		}
+
+		if fromEdbInfo.EdbInfoId == secondEdbInfo.EdbInfoId {
+			err = fmt.Errorf("两个指标不允许为同一个")
+			errMsg = "两个指标不允许为同一个"
+			return
+		}
+		err = models.EditCalculateZjpj(&req, edbInfo, fromEdbInfo, secondEdbInfo)
+	case utils.DATA_SOURCE_CALCULATE_LJZTBPJ: //累计值同比拼接
+		sourName = "累计值同比拼接"
+
+		if fromEdbInfo.Frequency != "月度" {
+			errMsg = "待拼接指标只能筛选月度指标"
+			err = fmt.Errorf("待拼接指标只能筛选月度指标")
+			return
+		}
+		if len(req.EdbInfoIdArr) != 1 {
+			errMsg = "请传入同比值指标"
+			err = fmt.Errorf("请传入同比值指标")
+			return
+		}
+
+		secondEdbInfoReq := req.EdbInfoIdArr[0]
+		tbzEdbInfo, tmpErr := models.GetEdbInfoById(secondEdbInfoReq.EdbInfoId)
+		if tmpErr != nil {
+			errMsg = "获取同比值指标信息失败:Err:" + tmpErr.Error()
+			err = fmt.Errorf("获取同比值指标信息失败")
+
+			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
+		}
+		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 {
+			errMsg = "获取因变量的指标信息失败:Err:" + tmpErr.Error()
+			err = fmt.Errorf("获取因变量的指标信息失败")
+
+			return
+		}
+
+		if fromEdbInfo.EdbInfoId == secondEdbInfo.EdbInfoId {
+			err = fmt.Errorf("两个指标不允许为同一个")
+			errMsg = "两个指标不允许为同一个"
+			return
+		}
+		err, errMsg = models.EditCalculateNhcc(&req, edbInfo, fromEdbInfo, secondEdbInfo, nhccDate)
+	case utils.DATA_SOURCE_CALCULATE_JP:
+		if !models.CheckFrequency(fromEdbInfo.Frequency, req.Frequency) {
+			err = fmt.Errorf("频度异常,不允许低频降频到高频")
+			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 {
+			err = fmt.Errorf("指标数量不能小于2个,请重新选择")
+			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 {
+			err = fmt.Errorf("指标数量不能小于2个,请重新选择")
+			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 == "日度" {
+			err = fmt.Errorf("日度指标无需进行日均值计算")
+			return
+		}
+		if req.Frequency != fromEdbInfo.Frequency {
+			err = fmt.Errorf("当前频度和原指标频度不一致")
+			return
+		}
+		if req.Unit != fromEdbInfo.Unit {
+			err = fmt.Errorf("单位只允许为和原指标频度保持一致,禁止选择其他单位")
+			return
+		}
+		sourName = "日均值"
+		err = models.EditCalculateRjz(edbInfo, &req, fromEdbInfo)
+	default:
+		// 获取通用的数据源处理服务
+		baseEdbInfoModel = models.GetBaseEdbInfoModel(req.Source)
+		// 没有找到的话,那么就直接返回报错吧
+		if baseEdbInfoModel == nil {
+			err = fmt.Errorf("无效计算方式")
+			errMsg = "无效计算方式,source:" + strconv.Itoa(req.Source)
+			return
+		}
+		sourName = baseEdbInfoModel.GetSourceName()
+		err, errMsg = baseEdbInfoModel.Edit(editParams)
+	}
+	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
+	uniqueCode = edbInfo.UniqueCode
+	//处理同名指标
+	{
+		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
+}
+
 // EdbCalculateAdd 新增指标运算
 func EdbCalculateAdd(req models.EdbInfoCalculateSaveReq) (edbInfo *models.EdbInfo, uniqueCode string, err error, errMsg string) {
 	calculateFormula := req.CalculateFormula