fix：新增预测指标运算编辑

controllers/base_from_predict_calculate.go

@@ -16,12 +16,12 @@ type PredictCalculateController struct {
 	BaseAuthController
 }
 
-// Add
-// @Title 编辑指标接口
-// @Description 编辑指标接口
-// @Success 200 {object} models.EditEdbInfoReq
-// @router /add [post]
-func (this *PredictCalculateController) Add() {
+// Save
+// @Title 新增/编辑预测指标运算接口
+// @Description 新增预测指标运算接口
+// @Success 200 {object} models.EdbInfoCalculateSaveReq
+// @router /save [post]
+func (this *PredictCalculateController) Save() {
 	br := new(models.BaseResponse).Init()
 	defer func() {
 		this.Data["json"] = br
@@ -34,6 +34,16 @@ func (this *PredictCalculateController) Add() {
 		br.ErrMsg = "参数解析失败，Err:" + err.Error()
 		return
 	}
+	if req.EdbInfoId <= 0 {
+		addPredictCalculate(br, req)
+	} else {
+		editPredictCalculate(br, req)
+	}
+}
+
+// AddPredictCalculate 添加预测指标运算
+func addPredictCalculate(br *models.BaseResponse, req models.EdbInfoCalculateSaveReq) {
+
 	req.EdbName = strings.Trim(req.EdbName, " ")
 	if req.EdbName == "" {
 		br.Msg = "指标名称不能为空"
@@ -228,7 +238,7 @@ func (this *PredictCalculateController) Add() {
 	}
 
 	// 开始添加预测指标
-	latestDateStr, latestValue, err := models.AddPredictCalculate(edbInfoList, int(edbInfoId), edbCode, req.CalculateFormula, edbInfoIdBytes)
+	latestDateStr, latestValue, err := models.AddPredictCalculateData(edbInfoList, int(edbInfoId), edbCode, req.CalculateFormula, edbInfoIdBytes)
 	if err != nil {
 		br.Msg = "生成计算指标失败"
 		br.Msg = "生成计算指标失败,Calculate Err:" + err.Error()
@@ -253,27 +263,8 @@ func (this *PredictCalculateController) Add() {
 	br.IsAddLog = true
 }
 
-// CalculateBatchSave
-// @Title 累计值转月-同比值-同差等计算新增
-// @Description 累计值转月-同比值-同差等计算新增接口
-// @Param	request	body models.EdbInfoCalculateBatchSaveReq true "type json string"
-// @Success Ret=200 返回指标id
-// @router /batch/save [post]
-func (this *PredictCalculateController) CalculateBatchSave() {
-	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
-	}
-
+// editPredictCalculate 编辑预测指标运算
+func editPredictCalculate(br *models.BaseResponse, req models.EdbInfoCalculateSaveReq) {
 	req.EdbName = strings.Trim(req.EdbName, " ")
 	if req.EdbName == "" {
 		br.Msg = "指标名称不能为空"
@@ -295,46 +286,18 @@ func (this *PredictCalculateController) CalculateBatchSave() {
 		return
 	}
 
-	if req.FromEdbInfoId <= 0 {
+	if len(req.EdbInfoIdArr) <= 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 {
-		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
-		}
-	}
-
-	// 获取指标详情
-	edbInfo, err := models.GetEdbInfoById(req.EdbInfoId)
-	if err != nil {
-		br.Msg = "指标不存在！"
-		br.ErrMsg = "指标不存在"
+	if req.CalculateFormula == "" {
+		br.Msg = "请填写指标"
 		return
 	}
 
 	//加入缓存机制，避免创建同一个名称的指标 start
-	redisKey := fmt.Sprint("edb_info:calculate:batch:save:", req.Source, ":", req.EdbName)
+	redisKey := fmt.Sprint("predict_edb_info:calculate:batch:save:", utils.DATA_SOURCE_PREDICT_CALCULATE, ":", req.EdbName)
 	isExist := utils.Rc.IsExist(redisKey)
 	if isExist {
 		br.Msg = "指标正在处理,请勿重复提交"
@@ -346,169 +309,98 @@ func (this *PredictCalculateController) CalculateBatchSave() {
 			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
+	calculateFormula := req.CalculateFormula
+	calculateFormula = strings.Replace(calculateFormula, "（", "(", -1)
+	calculateFormula = strings.Replace(calculateFormula, "）", ")", -1)
+	calculateFormula = strings.Replace(calculateFormula, "，", ",", -1)
+	calculateFormula = strings.Replace(calculateFormula, "。", ".", -1)
+	if strings.Contains(req.CalculateFormula, "%") {
+		calculateFormula = strings.Replace(calculateFormula, "%", "*0.01", -1)
 	}
+	req.CalculateFormula = calculateFormula
 
-	if count > 0 {
-		br.Msg = "指标名称已存在，请重新填写"
-		br.ErrMsg = "指标名称已存在，请重新填写"
-		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
+		}
 	}
 
-	fromEdbInfo, err := models.GetEdbInfoById(req.FromEdbInfoId)
+	// 获取计算指标信息
+	edbInfo, err := models.GetEdbInfoById(req.EdbInfoId)
 	if err != nil {
 		br.Msg = "获取指标信息失败"
-		br.ErrMsg = "获取指标信息失败:Err:" + err.Error()
+		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)
-
-	adminId := req.AdminId
-	adminName := req.AdminName
-	var sourName string
-	var edbInfoId int
-	if req.Source == utils.DATA_SOURCE_CALCULATE_LJZZY {
-		sourName = "累计值转月值"
-		if fromEdbInfo.Frequency != "月度" {
-			br.Msg = "请选择月度指标"
-			return
-		}
-		edbInfoId, err = models.AddCalculateLjzzy(&req, fromEdbInfo, edbCode, uniqueCode, adminId, adminName)
-	} else if req.Source == utils.DATA_SOURCE_CALCULATE_TBZ {
-		sourName = "同比值"
-		edbInfoId, err = models.AddCalculateTbz(&req, fromEdbInfo, edbCode, uniqueCode, adminId, adminName)
-	} else if req.Source == utils.DATA_SOURCE_CALCULATE_TCZ {
-		sourName = "同差值"
-		edbInfoId, err = models.AddCalculateTcz(&req, fromEdbInfo, edbCode, uniqueCode, adminId, adminName)
-	} else if req.Source == utils.DATA_SOURCE_CALCULATE_NSZYDPJJS {
-		sourName = "N数值移动平均计算"
-		edbInfoId, err = models.AddCalculateNszydpjjs(&req, fromEdbInfo, edbCode, uniqueCode, adminId, adminName, 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 = "环比值"
-		edbInfoId, err = models.AddCalculateHbz(&req, fromEdbInfo, edbCode, uniqueCode, adminId, adminName, formulaInt)
-	} else if req.Source == utils.DATA_SOURCE_CALCULATE_HCZ {
-		sourName = "环差值"
-		edbInfoId, err = models.AddCalculateHcz(&req, fromEdbInfo, edbCode, uniqueCode, adminId, adminName, formulaInt)
-	} else if req.Source == utils.DATA_SOURCE_CALCULATE_BP {
-		if fromEdbInfo.Frequency == "日度" {
-			br.Msg = "日度指标,无法进行变频操作"
-			br.ErrMsg = "日度指标,无法进行变频操作:edbcode:" + fromEdbInfo.EdbCode
-			return
-		}
-		sourName = "变频"
-		edbInfoId, err = models.AddCalculateBp(&req, fromEdbInfo, edbCode, uniqueCode, adminId, adminName)
-	} else if req.Source == utils.DATA_SOURCE_CALCULATE_TIME_SHIFT { //时间移位
-		sourName = "时间移位"
-		edbInfoId, err = models.AddCalculateTimeShift(&req, fromEdbInfo, edbCode, uniqueCode, adminId, adminName)
-	} else if req.Source == utils.DATA_SOURCE_CALCULATE_ZJPJ { //直接拼接
-		sourName = "直接拼接"
-
-		if len(req.EdbInfoIdArr) != 1 {
-			br.Msg = "请传入拼接日期之后的指标"
-			br.ErrMsg = "请传入拼接日期之后的指标"
-			return
-		}
+		// 指标类型，0：普通指标，1：预测指标
+		condition += " AND edb_info_id !=?  AND edb_info_type=?  AND edb_name=? "
+		pars = append(pars, edbInfo.EdbInfoId, edbInfo.EdbInfoType, req.EdbName)
 
-		secondEdbInfoReq := req.EdbInfoIdArr[0]
-		secondEdbInfo, err := models.GetEdbInfoById(secondEdbInfoReq.EdbInfoId)
+		count, err := models.GetEdbInfoCountByCondition(condition, pars)
 		if err != nil {
-			br.Msg = "获取拼接日期之后的指标信息失败"
-			br.ErrMsg = "获取拼接日期之后的指标信息失败:Err:" + err.Error()
-			return
-		}
-
-		if fromEdbInfo.EdbInfoId == secondEdbInfo.EdbInfoId {
-			br.Msg = "两个指标不允许为同一个"
-			br.ErrMsg = "两个指标不允许为同一个"
-			return
-		}
-		edbInfoId, err = models.AddCalculateZjpj(&req, fromEdbInfo, secondEdbInfo, edbCode, uniqueCode, adminId, adminName)
-	} else if req.Source == utils.DATA_SOURCE_CALCULATE_LJZTBPJ { //累计值同比拼接
-		sourName = "累计值同比拼接"
-
-		if fromEdbInfo.Frequency != "月度" {
-			br.Msg = "待拼接指标只能筛选月度指标"
-			br.ErrMsg = "待拼接指标只能筛选月度指标"
+			br.Msg = "判断指标名称是否存在失败"
+			br.ErrMsg = "判断指标名称是否存在失败,Err:" + err.Error()
 			return
 		}
-		if len(req.EdbInfoIdArr) != 1 {
-			br.Msg = "请传入同比值指标"
-			br.ErrMsg = "请传入同比值指标"
+		if count > 0 {
+			br.Msg = "指标名称已存在，请重新填写"
+			br.ErrMsg = "指标名称已存在，请重新填写"
 			return
 		}
+	}
 
-		secondEdbInfoReq := req.EdbInfoIdArr[0]
-		tbzEdbInfo, err := models.GetEdbInfoById(secondEdbInfoReq.EdbInfoId)
+	// 关联指标信息
+	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 {
-			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 = "同比值指标只能筛选月度指标"
+			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)
 
-		if fromEdbInfo.EdbInfoId == tbzEdbInfo.EdbInfoId {
-			br.Msg = "两个指标不允许为同一个"
-			br.ErrMsg = "两个指标不允许为同一个"
-			return
+		//关联关系表
+		{
+			calculateMappingItem := &models.EdbInfoCalculateMapping{
+				CreateTime:     time.Now(),
+				ModifyTime:     time.Now(),
+				Sort:           k + 1,
+				EdbCode:        edbInfo.EdbCode,
+				EdbInfoId:      edbInfo.EdbInfoId,
+				FromEdbInfoId:  fromEdbInfo.EdbInfoId,
+				FromEdbCode:    fromEdbInfo.EdbCode,
+				FromEdbName:    fromEdbInfo.EdbName,
+				FromSource:     fromEdbInfo.Source,
+				FromSourceName: fromEdbInfo.SourceName,
+				FromTag:        v.FromTag,
+				Source:         utils.DATA_SOURCE_PREDICT_CALCULATE,
+				SourceName:     "预测指标运算",
+			}
+			calculateMappingList = append(calculateMappingList, calculateMappingItem)
 		}
-		edbInfoId, err = models.AddCalculateLjztbpj(&req, fromEdbInfo, tbzEdbInfo, edbCode, uniqueCode, adminId, adminName)
-	} 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 edbInfoId <= 0 {
-		br.Msg = "生成" + sourName + "失败"
-		br.ErrMsg = "生成" + sourName + "失败,指标ID错误:" + strconv.Itoa(edbInfoId)
-		return
-	}
 	//处理同名指标
 	{
 		edbNameList, err := models.GetEdbInfoByName(req.EdbName)
@@ -530,16 +422,36 @@ func (this *PredictCalculateController) CalculateBatchSave() {
 		}
 	}
 
+	edbInfo.EdbName = req.EdbName
+	edbInfo.Frequency = req.Frequency
+	edbInfo.Unit = req.Unit
+	edbInfo.ClassifyId = req.ClassifyId
+	edbInfo.CalculateFormula = req.CalculateFormula
+	err = models.EditPredictCalculate(edbInfo, calculateMappingList)
+	if err != nil {
+		br.Msg = "修改计算指标失败"
+		br.Msg = "修改计算指标失败,Calculate Err:" + err.Error()
+		return
+	}
+
+	// 开始添加预测指标
+	latestDateStr, latestValue, err := models.AddPredictCalculateData(edbInfoList, edbInfo.EdbInfoId, edbInfo.EdbCode, req.CalculateFormula, edbInfoIdBytes)
+	if err != nil {
+		br.Msg = "生成计算指标失败"
+		br.Msg = "生成计算指标失败,Calculate Err:" + err.Error()
+		return
+	}
+
 	// 更新指标最大最小值
-	err, errMsg := models.UnifiedModifyEdbInfoMaxAndMinInfo(edbInfo)
+	err, errMsg := models.UnifiedModifyPredictEdbInfoMaxAndMinInfo(edbInfo, latestDateStr, latestValue)
 	if err != nil {
 		br.Msg = errMsg
 		br.ErrMsg = err.Error()
 		return
 	}
 	resp := models.AddEdbInfoResp{
-		EdbInfoId:  edbInfoId,
-		UniqueCode: uniqueCode,
+		EdbInfoId:  edbInfo.EdbInfoId,
+		UniqueCode: edbInfo.UniqueCode,
 	}
 	br.Ret = 200
 	br.Success = true

models/base_from_calculate.go

@@ -17,6 +17,7 @@ import (
 type EdbInfoCalculateSaveReq struct {
 	AdminId          int    `description:"添加人id"`
 	AdminName        string `description:"添加人名称"`
+	EdbInfoId        int    `description:"指标id"`
 	EdbName          string `description:"指标名称"`
 	Frequency        string `description:"频率"`
 	Unit             string `description:"单位"`

models/base_predict_from_calculate.go

@@ -34,8 +34,64 @@ type PredictCalculateItems struct {
 	DataMap   map[string]float64
 }
 
-// AddPredictCalculate 新增预测计算（运算）指标的数据
-func AddPredictCalculate(edbInfoIdList []*EdbInfo, edbInfoId int, edbCode, formulaStr string, edbInfoIdBytes []string) (latestDateStr string, latestValue float64, err error) {
+// EditPredictCalculate 新增预测计算（运算）指标
+func EditPredictCalculate(edbInfo *EdbInfo, calculateMappingList []*EdbInfoCalculateMapping) (err error) {
+	o := orm.NewOrm()
+	to, err := o.Begin()
+	if err != nil {
+		return
+	}
+	defer func() {
+		if err != nil {
+			tmpErr := to.Rollback()
+			errMsg := fmt.Sprintf("AddPredictCalculate Err:%s" + err.Error())
+			if tmpErr != nil {
+				errMsg += `;rollback失败：` + tmpErr.Error()
+			}
+			utils.FileLog.Info(errMsg)
+			return
+		}
+
+		tmpErr := to.Commit()
+		if tmpErr != nil {
+			errMsg := fmt.Sprintf("AddPredictCalculate commit Err:%s" + tmpErr.Error())
+			utils.FileLog.Info(errMsg)
+		}
+	}()
+
+	// 修改指标信息
+	_, err = to.Update(edbInfo, "EdbName", "Frequency", "Unit", "ClassifyId", "CalculateFormula")
+	if err != nil {
+		return
+	}
+
+	//删除，计算指标关联的，基础指标的关联关系
+	sql := ` DELETE FROM edb_info_calculate_mapping WHERE edb_info_id = ? `
+	_, err = to.Raw(sql, edbInfo.EdbInfoId).Exec()
+	if err != nil {
+		err = errors.New("删除计算指标关联关系失败,Err:" + err.Error())
+		return
+	}
+
+	// 插入新的关系表
+	if len(calculateMappingList) > 0 {
+		_, err = to.InsertMulti(len(calculateMappingList), calculateMappingList)
+	}
+
+	//数据表
+	tableName := GetEdbDataTableName(edbInfo.Source)
+	//清空原有数据
+	sql = ` DELETE FROM ` + tableName + ` WHERE edb_info_id = ? `
+	_, err = o.Raw(sql, edbInfo.EdbInfoId).Exec()
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// AddPredictCalculateData 新增预测计算（运算）指标的数据
+func AddPredictCalculateData(edbInfoIdList []*EdbInfo, edbInfoId int, edbCode, formulaStr string, edbInfoIdBytes []string) (latestDateStr string, latestValue float64, err error) {
 	o := orm.NewOrm()
 	defer func() {
 		if err != nil {

routers/commentsRouter.go

@@ -234,17 +234,8 @@ func init() {
 
     beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:PredictCalculateController"] = append(beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:PredictCalculateController"],
         beego.ControllerComments{
-            Method: "Add",
-            Router: `/add`,
-            AllowHTTPMethods: []string{"post"},
-            MethodParams: param.Make(),
-            Filters: nil,
-            Params: nil})
-
-    beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:PredictCalculateController"] = append(beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:PredictCalculateController"],
-        beego.ControllerComments{
-            Method: "CalculateBatchSave",
-            Router: `/batch/save`,
+            Method: "Refresh",
+            Router: `/refresh`,
             AllowHTTPMethods: []string{"post"},
             MethodParams: param.Make(),
             Filters: nil,
@@ -252,8 +243,8 @@ func init() {
 
     beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:PredictCalculateController"] = append(beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:PredictCalculateController"],
         beego.ControllerComments{
-            Method: "Refresh",
-            Router: `/refresh`,
+            Method: "Save",
+            Router: `/save`,
             AllowHTTPMethods: []string{"post"},
             MethodParams: param.Make(),
             Filters: nil,