fix:公式计算指标调整

controllers/base_from_calculate.go

@@ -197,6 +197,7 @@ func (this *CalculateController) Add() {
 	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 = "生成计算指标失败"
@@ -242,280 +243,6 @@ func (this *CalculateController) Add() {
 	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 编辑计算指标接口
@@ -681,91 +408,25 @@ func (this *CalculateController) Edit() {
 			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 {
+	//重新计算
+	err, errMsg := models.EditCalculateInfo(edbInfoDetail, req, formulaMap, edbInfoIdBytes, needCalculate)
+	if err != nil {
+		br.Msg = "生成计算指标失败"
+		if errMsg != `` {
 			br.Msg = errMsg
-			br.ErrMsg = err.Error()
-			return
 		}
+		br.Msg = "生成计算指标失败,AddEdbInfo Err:" + err.Error()
+		return
 	}
 
-	// 修改指标信息
-	err = models.ModifyCalculateEdbInfo(req.EdbName, req.Frequency, req.Unit, req.CalculateFormula, req.ClassifyId, req.EdbInfoId)
+	// 更新指标最大最小值
+	err, errMsg = models.UnifiedModifyEdbInfoMaxAndMinInfo(edbInfoDetail)
 	if err != nil {
-		br.Msg = "修改失败"
-		br.Msg = "修改失败,ModifyEdbInfo Err:" + err.Error()
+		br.Msg = errMsg
+		br.ErrMsg = err.Error()
 		return
 	}
-
 	resp := models.AddEdbInfoResp{
 		EdbInfoId:  edbInfoDetail.EdbInfoId,
 		UniqueCode: edbInfoDetail.UniqueCode,

models/base_from_calculate.go

@@ -125,7 +125,7 @@ func AddCalculate(edbInfoIdArr []*EdbInfo, edbInfoId int, edbCode, formulaStr st
 }
 
 // AddCalculateInfo 新增计算（运算）指标
-func AddCalculateInfo(req *EdbInfoCalculateSaveReq, calculateMappingList []*EdbInfoCalculateMapping, edbInfoList []*EdbInfo, edbCode, uniqueCode string, edbInfoIdBytes []string) (edbInfo *EdbInfo, err error) {
+func AddCalculateInfo(req EdbInfoCalculateSaveReq, calculateMappingList []*EdbInfoCalculateMapping, edbInfoList []*EdbInfo, edbCode, uniqueCode string, edbInfoIdBytes []string) (edbInfo *EdbInfo, err error) {
 
 	o := orm.NewOrm()
 	to, err := o.Begin()
@@ -200,6 +200,107 @@ func AddCalculateInfo(req *EdbInfoCalculateSaveReq, calculateMappingList []*EdbI
 	return
 }
 
+// EditCalculateInfo 编辑计算（运算）指标
+func EditCalculateInfo(edbInfo *EdbInfo, req EdbInfoCalculateSaveReq, formulaMap map[string]string, edbInfoIdBytes []string, needCalculate bool) (err error, errMsg string) {
+	o := orm.NewOrm()
+	to, err := o.Begin()
+	if err != nil {
+		return
+	}
+	defer func() {
+		if err != nil {
+			fmt.Println("AddCalculateHcz,Err:" + err.Error())
+			_ = to.Rollback()
+		} else {
+			_ = to.Commit()
+		}
+	}()
+
+	// 修改指标信息
+	edbInfo.EdbName = req.EdbName
+	edbInfo.EdbNameSource = req.EdbName
+	edbInfo.Frequency = req.Frequency
+	edbInfo.Unit = req.Unit
+	edbInfo.ClassifyId = req.ClassifyId
+	edbInfo.CalculateFormula = req.CalculateFormula
+	edbInfo.ModifyTime = time.Now()
+	_, err = to.Update(edbInfo, "EdbName", "EdbNameSource", "Frequency", "Unit", "ClassifyId", "CalculateFormula", "ModifyTime")
+	if err != nil {
+		return
+	}
+
+	if needCalculate {
+		// 清除计算数据
+		sql := `DELETE FROM edb_data_calculate WHERE edb_info_id=?`
+		_, err = to.Raw(sql, edbInfo.EdbInfoId).Exec()
+		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 {
+			return
+		}
+		edbInfoList := make([]*EdbInfo, 0)
+
+		calculateMappingList := make([]*EdbInfoCalculateMapping, 0)
+		for k, v := range req.EdbInfoIdArr {
+			fromEdbInfo, tmpErr := GetEdbInfoById(v.EdbInfoId)
+			if tmpErr != nil {
+				err = tmpErr
+				return
+			}
+			edbInfoList = append(edbInfoList, fromEdbInfo)
+
+			//关联关系表
+			{
+				calculateMappingItem := &EdbInfoCalculateMapping{
+					EdbInfoCalculateMappingId: 0,
+					EdbInfoId:                 req.EdbInfoId,
+					Source:                    edbInfo.Source,
+					SourceName:                edbInfo.SourceName,
+					EdbCode:                   edbInfo.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, _ := CheckFormula2(edbInfoList, formulaMap, req.CalculateFormula, edbInfoIdBytes)
+		if !ok {
+			errMsg = "生成计算指标失败，请使用正确的计算公式"
+			err = errors.New(errMsg)
+			return
+		}
+
+		//关联关系表
+		{
+			if len(calculateMappingList) > 0 {
+				_, err = to.InsertMulti(len(calculateMappingList), calculateMappingList)
+				if err != nil {
+					return
+				}
+			}
+		}
+
+		//计算数据
+		err = refreshAllCalculate(to, edbInfoList, edbInfo.EdbInfoId, edbInfo.Source, edbInfo.EdbCode, edbInfo.CalculateFormula, "", "", edbInfoIdBytes)
+
+	}
+
+	return
+}
+
 // GetCalculateEdbInfo 获取计算指标的关联指标id
 func GetCalculateEdbInfo(edbInfoId int) (from_edb_info_id string, err error) {
 	o := orm.NewOrm()

models/edb_data_calculate_bp.go

@@ -143,7 +143,7 @@ func EditCalculateBp(edbInfo *EdbInfo, req *EdbInfoCalculateBatchEditReq, fromEd
 	}
 	//清空原有数据
 	sql = ` DELETE FROM edb_data_calculate_bp WHERE edb_info_id = ? `
-	_, err = o.Raw(sql, edbInfo.EdbInfoId).Exec()
+	_, err = to.Raw(sql, edbInfo.EdbInfoId).Exec()
 	if err != nil {
 		return
 	}
@@ -231,7 +231,7 @@ func RefreshAllCalculateBpBak(edbInfoId, source int, fromEdbInfo *EdbInfo, edbCo
 	fmt.Println("dataTableName:", dataTableName)
 	sql := `SELECT * FROM %s WHERE edb_info_id=? `
 	sql = fmt.Sprintf(sql, dataTableName)
-	_, err = o.Raw(sql, edbInfoId).QueryRows(&existDataList)
+	_, err = to.Raw(sql, edbInfoId).QueryRows(&existDataList)
 	if err != nil {
 		return err
 	}
@@ -277,7 +277,7 @@ func RefreshAllCalculateBpBak(edbInfoId, source int, fromEdbInfo *EdbInfo, edbCo
 					if existVal != valStr {
 						sql := ` UPDATE %s SET value=?,modify_time=NOW() WHERE edb_info_id=? AND data_time=? `
 						sql = fmt.Sprintf(sql, dataTableName)
-						_, err = o.Raw(sql, valStr, edbInfoId, needDay).Exec()
+						_, err = to.Raw(sql, valStr, edbInfoId, needDay).Exec()
 						if err != nil {
 							return err
 						}
@@ -298,7 +298,7 @@ func RefreshAllCalculateBpBak(edbInfoId, source int, fromEdbInfo *EdbInfo, edbCo
 				if existVal != valStr {
 					sql := ` UPDATE %s SET value=?,modify_time=NOW() WHERE edb_info_id=? AND data_time=? `
 					sql = fmt.Sprintf(sql, dataTableName)
-					_, err = o.Raw(sql, valStr, edbInfoId, currentItem.DataTime).Exec()
+					_, err = to.Raw(sql, valStr, edbInfoId, currentItem.DataTime).Exec()
 					if err != nil {
 						return err
 					}
@@ -310,7 +310,7 @@ func RefreshAllCalculateBpBak(edbInfoId, source int, fromEdbInfo *EdbInfo, edbCo
 
 	if isAdd {
 		addSql = strings.TrimRight(addSql, ",")
-		_, err = o.Raw(addSql).Exec()
+		_, err = to.Raw(addSql).Exec()
 		if err != nil {
 			return err
 		}

models/edb_data_calculate_cjjx.go

@@ -123,7 +123,7 @@ func EditCalculateCjjx(req *EdbInfoCalculateBatchEditReq, edbInfo, fromEdbInfo *
 	edbInfo.ClassifyId = req.ClassifyId
 	edbInfo.CalculateFormula = req.Formula
 	edbInfo.ModifyTime = time.Now()
-	_, err = o.Update(edbInfo, "EdbName", "EdbNameSource", "Frequency", "Unit", "ClassifyId", "CalculateFormula", "ModifyTime")
+	_, err = to.Update(edbInfo, "EdbName", "EdbNameSource", "Frequency", "Unit", "ClassifyId", "CalculateFormula", "ModifyTime")
 	if err != nil {
 		return
 	}
@@ -148,7 +148,7 @@ func EditCalculateCjjx(req *EdbInfoCalculateBatchEditReq, edbInfo, fromEdbInfo *
 	if count <= 0 {
 		// 需要删除原先的 计算指标关联的，基础指标的关联关系
 		sql := ` DELETE FROM edb_info_calculate_mapping WHERE edb_info_id = ? `
-		_, err = o.Raw(sql, edbInfo.EdbInfoId).Exec()
+		_, err = to.Raw(sql, edbInfo.EdbInfoId).Exec()
 		if err != nil {
 			return
 		}
@@ -171,7 +171,7 @@ func EditCalculateCjjx(req *EdbInfoCalculateBatchEditReq, edbInfo, fromEdbInfo *
 				CreateTime:                time.Now(),
 				ModifyTime:                time.Now(),
 			}
-			_, err = o.Insert(calculateMappingItem)
+			_, err = to.Insert(calculateMappingItem)
 			if err != nil {
 				return
 			}

models/edb_data_calculate_hbz.go

@@ -43,7 +43,7 @@ func AddCalculateHbz(req *EdbInfoCalculateBatchSaveReq, fromEdbInfo *EdbInfo, ed
 		edbInfo.UniqueCode = uniqueCode
 		edbInfo.CalculateFormula = req.Formula
 		edbInfo.EdbType = 2
-		newEdbInfoId, tmpErr := o.Insert(edbInfo)
+		newEdbInfoId, tmpErr := to.Insert(edbInfo)
 		if tmpErr != nil {
 			err = tmpErr
 			return
@@ -78,7 +78,7 @@ func AddCalculateHbz(req *EdbInfoCalculateBatchSaveReq, fromEdbInfo *EdbInfo, ed
 		dataTableName := GetEdbDataTableName(utils.DATA_SOURCE_CALCULATE_HBZ)
 		deleteSql := ` DELETE FROM %s WHERE edb_info_id=? `
 		deleteSql = fmt.Sprintf(deleteSql, dataTableName)
-		_, err = o.Raw(deleteSql, req.EdbInfoId).Exec()
+		_, err = to.Raw(deleteSql, req.EdbInfoId).Exec()
 		if err != nil {
 			return
 		}

models/edb_data_calculate_hcz.go

@@ -138,7 +138,7 @@ func EditCalculateHcz(edbInfo *EdbInfo, req *EdbInfoCalculateBatchEditReq, fromE
 	//删除，计算指标关联的，基础指标的关联关系
 	if count <= 0 {
 		sql := ` DELETE FROM edb_info_calculate_mapping WHERE edb_info_id = ? `
-		_, err = o.Raw(sql, edbInfo.EdbInfoId).Exec()
+		_, err = to.Raw(sql, edbInfo.EdbInfoId).Exec()
 		if err != nil {
 			return
 		}
@@ -168,7 +168,7 @@ func EditCalculateHcz(edbInfo *EdbInfo, req *EdbInfoCalculateBatchEditReq, fromE
 	}
 	//清空原有数据
 	sql := ` DELETE FROM edb_data_calculate_hcz WHERE edb_info_id = ? `
-	_, err = o.Raw(sql, edbInfo.EdbInfoId).Exec()
+	_, err = to.Raw(sql, edbInfo.EdbInfoId).Exec()
 	if err != nil {
 		return
 	}

models/edb_data_calculate_ljzzy.go

@@ -345,7 +345,7 @@ func refreshAllCalculateLjzzy(to orm.TxOrmer, edbInfoId, source int, fromEdbInfo
 				//	if existVal != saveValue {
 				//		sql := ` UPDATE %s SET value=?,modify_time=NOW() WHERE edb_info_id=? AND data_time=? `
 				//		sql = fmt.Sprintf(sql, dataTableName)
-				//		_, err = o.Raw(sql, saveValue, edbInfoId, date).Exec()
+				//		_, err = to.Raw(sql, saveValue, edbInfoId, date).Exec()
 				//		if err != nil {
 				//			return err
 				//		}
@@ -373,7 +373,7 @@ func refreshAllCalculateLjzzy(to orm.TxOrmer, edbInfoId, source int, fromEdbInfo
 	return
 }
 
-func calculateLjzzy(edbInfoId int, date, edbInfoIdStr, edbCode, dataTableName, addSql string, val float64, dataMap, existDataMap map[string]string, o orm.TxOrmer) (newSql string, isAdd bool, err error) {
+func calculateLjzzy(edbInfoId int, date, edbInfoIdStr, edbCode, dataTableName, addSql string, val float64, dataMap, existDataMap map[string]string, to orm.TxOrmer) (newSql string, isAdd bool, err error) {
 	newSql = addSql
 	saveValue := utils.SubFloatToString(val, 4)
 	//判断数据是否存在
@@ -390,7 +390,7 @@ func calculateLjzzy(edbInfoId int, date, edbInfoIdStr, edbCode, dataTableName, a
 		if existVal != saveValue {
 			sql := ` UPDATE %s SET value=?,modify_time=NOW() WHERE edb_info_id=? AND data_time=? `
 			sql = fmt.Sprintf(sql, dataTableName)
-			_, err = o.Raw(sql, saveValue, edbInfoId, date).Exec()
+			_, err = to.Raw(sql, saveValue, edbInfoId, date).Exec()
 		}
 	}
 	return

models/edb_data_calculate_nszydbpjjs.go

@@ -134,7 +134,7 @@ func EditCalculateNszydpjjs(edbInfo *EdbInfo, req *EdbInfoCalculateBatchEditReq,
 	if count <= 0 {
 		// 需要删除原先的 计算指标关联的，基础指标的关联关系
 		sql := ` DELETE FROM edb_info_calculate_mapping WHERE edb_info_id = ? `
-		_, err = o.Raw(sql, edbInfo.EdbInfoId).Exec()
+		_, err = to.Raw(sql, edbInfo.EdbInfoId).Exec()
 		if err != nil {
 			return
 		}

models/edb_data_calculate_zjpj.go

@@ -304,7 +304,7 @@ func EditCalculateZjpj(req *EdbInfoCalculateBatchEditReq, edbInfo, firstEdbInfo,
 
 		tableName := GetEdbDataTableName(edbInfo.Source)
 		sql := fmt.Sprintf(` DELETE FROM %s WHERE edb_info_id = ? `, tableName)
-		_, err = o.Raw(sql, edbInfo.EdbInfoId).Exec()
+		_, err = to.Raw(sql, edbInfo.EdbInfoId).Exec()
 		if err != nil {
 			err = fmt.Errorf("删除历史数据失败,Err:" + err.Error())
 			return
@@ -369,7 +369,9 @@ func refreshAllCalculateZjpj(to orm.TxOrmer, edbInfo *EdbInfo, existItemA, exist
 	condition += " AND edb_info_id=? "
 	pars = append(pars, edbInfo.EdbInfoId)
 
-	dataList, err := GetAllEdbDataCalculateZjpjByEdbInfoId(edbInfo.EdbInfoId)
+	var dataList []*EdbDataCalculateZjpj
+	sql := ` SELECT * FROM edb_data_calculate_zjpj WHERE edb_info_id=? ORDER BY data_time DESC `
+	_, err = to.Raw(sql, edbInfo.EdbInfoId).QueryRows(&dataList)
 	if err != nil {
 		return err
 	}