编辑时候的指标bug

models/predict_edb_data_calculate_ljztbpj.go

@@ -211,40 +211,12 @@ func SavePredictCalculateLjztbpj(req *EdbInfoCalculateBatchSaveReq, firstEdbInfo
 		//如果拼接指标变更了，那么需要删除所有的指标进行重新拼接
 		if existItemA.FromEdbInfoId != firstEdbInfo.EdbInfoId {
 			//删除之前的A指标关联关系
-			sql := ` DELETE FROM edb_info_calculate_mapping WHERE edb_info_id = ? and from_edb_info_id = ?`
+			sql = ` DELETE FROM edb_info_calculate_mapping WHERE edb_info_id = ? and from_edb_info_id = ?`
 			_, err = to.Raw(sql, edbInfo.EdbInfoId, existItemA.FromEdbInfoId).Exec()
 			if err != nil {
 				err = errors.New("删除拼接日期之前的指标关联关系失败,Err:" + err.Error())
 				return
 			}
-
-			//添加新的指标关系
-			{
-				existItemA = &EdbInfoCalculateMapping{
-					EdbInfoCalculateMappingId: 0,
-					EdbInfoId:                 edbInfo.EdbInfoId,
-					Source:                    edbInfo.Source,
-					SourceName:                edbInfo.SourceName,
-					EdbCode:                   edbInfo.EdbCode,
-					FromEdbInfoId:             firstEdbInfo.EdbInfoId,
-					FromEdbCode:               firstEdbInfo.EdbCode,
-					FromEdbName:               firstEdbInfo.EdbName,
-					FromSource:                firstEdbInfo.Source,
-					FromSourceName:            firstEdbInfo.SourceName,
-					FromTag:                   "A",
-					Sort:                      1,
-					CreateTime:                time.Now(),
-					ModifyTime:                time.Now(),
-				}
-				insertId, tmpErr := to.Insert(existItemA)
-				if tmpErr != nil {
-					err = tmpErr
-					return
-				}
-				existItemA.EdbInfoCalculateMappingId = int(insertId)
-
-				isNeedCalculateData = true
-			}
 		}
 
 		//同比值指标
@@ -256,35 +228,62 @@ func SavePredictCalculateLjztbpj(req *EdbInfoCalculateBatchSaveReq, firstEdbInfo
 				err = errors.New("删除拼接日期之后的指标关联关系失败,Err:" + err.Error())
 				return
 			}
+		}
+		//添加新的指标关系
+		if existItemA.FromEdbInfoId != firstEdbInfo.EdbInfoId {
+			existItemA = &EdbInfoCalculateMapping{
+				EdbInfoCalculateMappingId: 0,
+				EdbInfoId:                 edbInfo.EdbInfoId,
+				Source:                    edbInfo.Source,
+				SourceName:                edbInfo.SourceName,
+				EdbCode:                   edbInfo.EdbCode,
+				FromEdbInfoId:             firstEdbInfo.EdbInfoId,
+				FromEdbCode:               firstEdbInfo.EdbCode,
+				FromEdbName:               firstEdbInfo.EdbName,
+				FromSource:                firstEdbInfo.Source,
+				FromSourceName:            firstEdbInfo.SourceName,
+				FromTag:                   "A",
+				Sort:                      1,
+				CreateTime:                time.Now(),
+				ModifyTime:                time.Now(),
+			}
+			insertId, tmpErr := to.Insert(existItemA)
+			if tmpErr != nil {
+				err = tmpErr
+				return
+			}
+			existItemA.EdbInfoCalculateMappingId = int(insertId)
 
-			//添加新的指标关系
-			{
-				existItemB = &EdbInfoCalculateMapping{
-					EdbInfoCalculateMappingId: 0,
-					EdbInfoId:                 edbInfo.EdbInfoId,
-					Source:                    edbInfo.Source,
-					SourceName:                edbInfo.SourceName,
-					EdbCode:                   edbInfo.EdbCode,
-					FromEdbInfoId:             secondEdbInfo.EdbInfoId,
-					FromEdbCode:               secondEdbInfo.EdbCode,
-					FromEdbName:               secondEdbInfo.EdbName,
-					FromSource:                secondEdbInfo.Source,
-					FromSourceName:            secondEdbInfo.SourceName,
-					FromTag:                   "B",
-					Sort:                      2,
-					CreateTime:                time.Now(),
-					ModifyTime:                time.Now(),
-				}
+			isNeedCalculateData = true
+		}
 
-				insertId, tmpErr := to.Insert(existItemB)
-				if tmpErr != nil {
-					err = tmpErr
-					return
-				}
-				existItemB.EdbInfoCalculateMappingId = int(insertId)
+		//添加新的指标关系
+		if existItemB.FromEdbInfoId != secondEdbInfo.EdbInfoId {
+			existItemB = &EdbInfoCalculateMapping{
+				EdbInfoCalculateMappingId: 0,
+				EdbInfoId:                 edbInfo.EdbInfoId,
+				Source:                    edbInfo.Source,
+				SourceName:                edbInfo.SourceName,
+				EdbCode:                   edbInfo.EdbCode,
+				FromEdbInfoId:             secondEdbInfo.EdbInfoId,
+				FromEdbCode:               secondEdbInfo.EdbCode,
+				FromEdbName:               secondEdbInfo.EdbName,
+				FromSource:                secondEdbInfo.Source,
+				FromSourceName:            secondEdbInfo.SourceName,
+				FromTag:                   "B",
+				Sort:                      2,
+				CreateTime:                time.Now(),
+				ModifyTime:                time.Now(),
+			}
 
-				isNeedCalculateData = true
+			insertId, tmpErr := to.Insert(existItemB)
+			if tmpErr != nil {
+				err = tmpErr
+				return
 			}
+			existItemB.EdbInfoCalculateMappingId = int(insertId)
+
+			isNeedCalculateData = true
 		}
 
 		// 如果需要重新计算，那么先删除所有的指标数据，然后再重新计算

models/predict_edb_data_calculate_zjpj.go

@@ -184,34 +184,6 @@ func SavePredictCalculateZjpj(req *EdbInfoCalculateBatchSaveReq, firstEdbInfo, s
 					err = fmt.Errorf("删除拼接日期之前的指标关联关系失败,Err:" + err.Error())
 					return
 				}
-
-				//添加新的指标关系
-				{
-					existItemA = &EdbInfoCalculateMapping{
-						EdbInfoCalculateMappingId: 0,
-						EdbInfoId:                 edbInfo.EdbInfoId,
-						Source:                    edbInfo.Source,
-						SourceName:                edbInfo.SourceName,
-						EdbCode:                   edbInfo.EdbCode,
-						FromEdbInfoId:             firstEdbInfo.EdbInfoId,
-						FromEdbCode:               firstEdbInfo.EdbCode,
-						FromEdbName:               firstEdbInfo.EdbName,
-						FromSource:                firstEdbInfo.Source,
-						FromSourceName:            firstEdbInfo.SourceName,
-						FromTag:                   "A",
-						Sort:                      1,
-						CreateTime:                time.Now(),
-						ModifyTime:                time.Now(),
-					}
-					insertId, tmpErr := to.Insert(existItemA)
-					if tmpErr != nil {
-						err = tmpErr
-						return
-					}
-					existItemA.EdbInfoCalculateMappingId = int(insertId)
-
-					isNeedCalculateData = true
-				}
 			}
 		}
 
@@ -226,35 +198,65 @@ func SavePredictCalculateZjpj(req *EdbInfoCalculateBatchSaveReq, firstEdbInfo, s
 					err = fmt.Errorf("删除拼接日期之后的指标关联关系失败,Err:" + err.Error())
 					return
 				}
-
-				// 添加新的指标关联关系
-				existItemB = &EdbInfoCalculateMapping{
+			}
+		}
+		if existItemA.FromEdbInfoId != firstEdbInfo.EdbInfoId {
+			//添加新的指标关系
+			{
+				existItemA = &EdbInfoCalculateMapping{
 					EdbInfoCalculateMappingId: 0,
 					EdbInfoId:                 edbInfo.EdbInfoId,
 					Source:                    edbInfo.Source,
 					SourceName:                edbInfo.SourceName,
 					EdbCode:                   edbInfo.EdbCode,
-					FromEdbInfoId:             secondEdbInfo.EdbInfoId,
-					FromEdbCode:               secondEdbInfo.EdbCode,
-					FromEdbName:               secondEdbInfo.EdbName,
-					FromSource:                secondEdbInfo.Source,
-					FromSourceName:            secondEdbInfo.SourceName,
-					FromTag:                   "B",
-					Sort:                      2,
+					FromEdbInfoId:             firstEdbInfo.EdbInfoId,
+					FromEdbCode:               firstEdbInfo.EdbCode,
+					FromEdbName:               firstEdbInfo.EdbName,
+					FromSource:                firstEdbInfo.Source,
+					FromSourceName:            firstEdbInfo.SourceName,
+					FromTag:                   "A",
+					Sort:                      1,
 					CreateTime:                time.Now(),
 					ModifyTime:                time.Now(),
 				}
-				insertId, tmpErr := to.Insert(existItemB)
+				insertId, tmpErr := to.Insert(existItemA)
 				if tmpErr != nil {
 					err = tmpErr
 					return
 				}
-				existItemB.EdbInfoCalculateMappingId = int(insertId)
+				existItemA.EdbInfoCalculateMappingId = int(insertId)
 
 				isNeedCalculateData = true
 			}
 		}
 
+		if existItemB.FromEdbInfoId != secondEdbInfo.EdbInfoId {
+			// 添加新的指标关联关系
+			existItemB = &EdbInfoCalculateMapping{
+				EdbInfoCalculateMappingId: 0,
+				EdbInfoId:                 edbInfo.EdbInfoId,
+				Source:                    edbInfo.Source,
+				SourceName:                edbInfo.SourceName,
+				EdbCode:                   edbInfo.EdbCode,
+				FromEdbInfoId:             secondEdbInfo.EdbInfoId,
+				FromEdbCode:               secondEdbInfo.EdbCode,
+				FromEdbName:               secondEdbInfo.EdbName,
+				FromSource:                secondEdbInfo.Source,
+				FromSourceName:            secondEdbInfo.SourceName,
+				FromTag:                   "B",
+				Sort:                      2,
+				CreateTime:                time.Now(),
+				ModifyTime:                time.Now(),
+			}
+			insertId, tmpErr := to.Insert(existItemB)
+			if tmpErr != nil {
+				err = tmpErr
+				return
+			}
+			existItemB.EdbInfoCalculateMappingId = int(insertId)
+
+			isNeedCalculateData = true
+		}
 		// 如果需要重新计算，那么先删除所有的指标数据，然后再重新计算
 		if isNeedCalculateData {
 			// 删除之前所有的指标数据