feat:新增一元拟合预测规则，同比增速预测规则

logic/predict_edb.go

@@ -142,11 +142,11 @@ func AddPredictEdbInfo(sourceEdbInfoId, classifyId int, edbName string, ruleList
 	calculateMappingList = append(calculateMappingList, calculateMappingItem)
 
 	// 动态环差 计算列表
-	calculateRuleList := make([]models.CalculateRule, 0)
+	calculateRuleMap := make(map[int]models.CalculateRule, 0)
 
 	// 预测指标配置
 	predictEdbConfList := make([]*models.PredictEdbConf, 0)
-	for _, v := range ruleList {
+	for ruleIndex, v := range ruleList {
 		// 预测指标配置
 		ruleEndDate, tmpErr := time.ParseInLocation(utils.FormatDate, v.EndDate, time.Local)
 		if tmpErr != nil {
@@ -161,6 +161,7 @@ func AddPredictEdbInfo(sourceEdbInfoId, classifyId int, edbName string, ruleList
 			err = errors.New(errMsg)
 			return
 		}
+
 		switch v.RuleType {
 		case 8: //N期段线性外推值
 			valInt, tmpErr := strconv.Atoi(v.Value)
@@ -271,8 +272,7 @@ func AddPredictEdbInfo(sourceEdbInfoId, classifyId int, edbName string, ruleList
 				err = errors.New(errMsg)
 				return
 			}
-
-			calculateRuleList = append(calculateRuleList, models.CalculateRule{
+			calculateRuleMap[ruleIndex] = models.CalculateRule{
 				TrendsCalculateMappingList: trendsMappingList,
 				EdbInfoList:                edbInfoList,
 				EdbInfoIdBytes:             edbInfoIdBytes,
@@ -280,7 +280,85 @@ func AddPredictEdbInfo(sourceEdbInfoId, classifyId int, edbName string, ruleList
 				RuleType:                   v.RuleType,
 				EndDate:                    v.EndDate,
 				EdbInfoIdArr:               v.EdbInfoIdArr,
-			})
+			}
+		case 14: //14：根据 一元线性拟合 规则获取预测数据
+			if v.Value == "" {
+				errMsg = "请填写一元线性拟合规则"
+				err = errors.New(errMsg)
+				return
+			}
+
+			//关联的指标信息
+			edbInfoList := make([]*models.EdbInfo, 0)
+			// 动态环差规则 关系表
+			trendsMappingList := make([]*models.PredictEdbConfCalculateMapping, 0)
+
+			for k, tmpEdbInfoId := range v.EdbInfoIdArr {
+				fromEdbInfo, tmpErr := models.GetEdbInfoById(tmpEdbInfoId.EdbInfoId)
+				if tmpErr != nil {
+					err = tmpErr
+					if err.Error() == utils.ErrNoRow() {
+						errMsg = "指标 " + strconv.Itoa(tmpEdbInfoId.EdbInfoId) + " 不存在"
+						err = errors.New(errMsg)
+						return
+					}
+					errMsg = "获取指标失败:Err:" + err.Error()
+					err = errors.New(errMsg)
+					return
+				}
+
+				edbInfoList = append(edbInfoList, fromEdbInfo)
+
+				//总的 预测指标与所有相关联指标的关系表（不仅仅该条规则）
+				{
+					if _, ok := fromEdbMap[tmpEdbInfoId.EdbInfoId]; !ok {
+						fromEdbMap[tmpEdbInfoId.EdbInfoId] = tmpEdbInfoId.EdbInfoId
+						tmpCalculateMappingItem := &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:                   tmpEdbInfoId.FromTag,
+							Sort:       k + 1,
+							CreateTime: time.Now(),
+							ModifyTime: time.Now(),
+						}
+						calculateMappingList = append(calculateMappingList, tmpCalculateMappingItem)
+					}
+				}
+				// 动态环差规则 关系表
+				tmpPredictEdbConfCalculateMapping := &models.PredictEdbConfCalculateMapping{
+					//PredictEdbConfCalculateMappingId: 0,
+					EdbInfoId:      0,
+					ConfigId:       0,
+					FromEdbInfoId:  fromEdbInfo.EdbInfoId,
+					FromEdbCode:    fromEdbInfo.EdbCode,
+					FromEdbName:    fromEdbInfo.EdbName,
+					FromSource:     fromEdbInfo.Source,
+					FromSourceName: fromEdbInfo.SourceName,
+					FromTag:        tmpEdbInfoId.FromTag,
+					Sort:           k + 1,
+					CreateTime:     time.Now(),
+					ModifyTime:     time.Now(),
+				}
+				trendsMappingList = append(trendsMappingList, tmpPredictEdbConfCalculateMapping)
+			}
+
+			calculateRuleMap[ruleIndex] = models.CalculateRule{
+				TrendsCalculateMappingList: trendsMappingList,
+				EdbInfoList:                edbInfoList,
+				//EdbInfoIdBytes:             edbInfoIdBytes,
+				//Formula:                    formula,
+				RuleType:     v.RuleType,
+				EndDate:      v.EndDate,
+				EdbInfoIdArr: v.EdbInfoIdArr,
+			}
 		}
 
 		tmpPredictEdbConf := &models.PredictEdbConf{
@@ -298,7 +376,7 @@ func AddPredictEdbInfo(sourceEdbInfoId, classifyId int, edbName string, ruleList
 
 		predictEdbConfList = append(predictEdbConfList, tmpPredictEdbConf)
 	}
-	err = models.AddPredictEdb(edbInfo, calculateMappingList, predictEdbConfList, calculateRuleList)
+	err = models.AddPredictEdb(edbInfo, calculateMappingList, predictEdbConfList, calculateRuleMap)
 
 	return
 }
@@ -429,11 +507,11 @@ func EditPredictEdbInfo(edbInfoId, classifyId int, edbName string, ruleList []mo
 	calculateMappingList = append(calculateMappingList, calculateMappingItem)
 
 	// 动态环差 计算列表
-	calculateRuleList := make([]models.CalculateRule, 0)
+	calculateRuleMap := make(map[int]models.CalculateRule, 0)
 
 	// 预测指标配置
 	predictEdbConfList := make([]*models.PredictEdbConf, 0)
-	for _, v := range ruleList {
+	for ruleIndex, v := range ruleList {
 		// 预测指标配置
 		ruleEndDate, tmpErr := time.ParseInLocation(utils.FormatDate, v.EndDate, time.Local)
 		if tmpErr != nil {
@@ -559,7 +637,7 @@ func EditPredictEdbInfo(edbInfoId, classifyId int, edbName string, ruleList []mo
 				return
 			}
 
-			calculateRuleList = append(calculateRuleList, models.CalculateRule{
+			calculateRuleMap[ruleIndex] = models.CalculateRule{
 				TrendsCalculateMappingList: trendsMappingList,
 				EdbInfoList:                edbInfoList,
 				EdbInfoIdBytes:             edbInfoIdBytes,
@@ -567,7 +645,85 @@ func EditPredictEdbInfo(edbInfoId, classifyId int, edbName string, ruleList []mo
 				RuleType:                   v.RuleType,
 				EndDate:                    v.EndDate,
 				EdbInfoIdArr:               v.EdbInfoIdArr,
-			})
+			}
+		case 14: //14：根据 一元线性拟合 规则获取预测数据
+			if v.Value == "" {
+				errMsg = "请填写一元线性拟合规则"
+				err = errors.New(errMsg)
+				return
+			}
+
+			//关联的指标信息
+			edbInfoList := make([]*models.EdbInfo, 0)
+			// 动态环差规则 关系表
+			trendsMappingList := make([]*models.PredictEdbConfCalculateMapping, 0)
+
+			for k, tmpEdbInfoId := range v.EdbInfoIdArr {
+				fromEdbInfo, tmpErr := models.GetEdbInfoById(tmpEdbInfoId.EdbInfoId)
+				if tmpErr != nil {
+					err = tmpErr
+					if err.Error() == utils.ErrNoRow() {
+						errMsg = "指标 " + strconv.Itoa(tmpEdbInfoId.EdbInfoId) + " 不存在"
+						err = errors.New(errMsg)
+						return
+					}
+					errMsg = "获取指标失败:Err:" + err.Error()
+					err = errors.New(errMsg)
+					return
+				}
+
+				edbInfoList = append(edbInfoList, fromEdbInfo)
+
+				//总的 预测指标与所有相关联指标的关系表（不仅仅该条规则）
+				{
+					if _, ok := fromEdbMap[tmpEdbInfoId.EdbInfoId]; !ok {
+						fromEdbMap[tmpEdbInfoId.EdbInfoId] = tmpEdbInfoId.EdbInfoId
+						tmpCalculateMappingItem := &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:                   tmpEdbInfoId.FromTag,
+							Sort:       k + 1,
+							CreateTime: time.Now(),
+							ModifyTime: time.Now(),
+						}
+						calculateMappingList = append(calculateMappingList, tmpCalculateMappingItem)
+					}
+				}
+				// 动态环差规则 关系表
+				tmpPredictEdbConfCalculateMapping := &models.PredictEdbConfCalculateMapping{
+					//PredictEdbConfCalculateMappingId: 0,
+					EdbInfoId:      0,
+					ConfigId:       0,
+					FromEdbInfoId:  fromEdbInfo.EdbInfoId,
+					FromEdbCode:    fromEdbInfo.EdbCode,
+					FromEdbName:    fromEdbInfo.EdbName,
+					FromSource:     fromEdbInfo.Source,
+					FromSourceName: fromEdbInfo.SourceName,
+					FromTag:        tmpEdbInfoId.FromTag,
+					Sort:           k + 1,
+					CreateTime:     time.Now(),
+					ModifyTime:     time.Now(),
+				}
+				trendsMappingList = append(trendsMappingList, tmpPredictEdbConfCalculateMapping)
+			}
+
+			calculateRuleMap[ruleIndex] = models.CalculateRule{
+				TrendsCalculateMappingList: trendsMappingList,
+				EdbInfoList:                edbInfoList,
+				//EdbInfoIdBytes:             edbInfoIdBytes,
+				//Formula:                    formula,
+				RuleType:     v.RuleType,
+				EndDate:      v.EndDate,
+				EdbInfoIdArr: v.EdbInfoIdArr,
+			}
 		}
 
 		tmpPredictEdbConf := &models.PredictEdbConf{
@@ -586,7 +742,7 @@ func EditPredictEdbInfo(edbInfoId, classifyId int, edbName string, ruleList []mo
 		predictEdbConfList = append(predictEdbConfList, tmpPredictEdbConf)
 	}
 
-	err = models.EditPredictEdb(edbInfo, updateEdbInfoCol, calculateMappingList, predictEdbConfList, calculateRuleList)
+	err = models.EditPredictEdb(edbInfo, updateEdbInfoCol, calculateMappingList, predictEdbConfList, calculateRuleMap)
 
 	return
 }

models/predict_edb_conf.go

@@ -143,7 +143,7 @@ func AddPredictEdbConf(item *PredictEdbConf) (lastId int64, err error) {
 
 // AddPredictEdb 添加预测指标
 // edbInfo, calculateMappingList, predictEdbConfList,calculateRule9List,trendsMappingList
-func AddPredictEdb(item *EdbInfo, calculateMappingList []*EdbInfoCalculateMapping, predictEdbConfList []*PredictEdbConf, calculateRuleList []CalculateRule) (err error) {
+func AddPredictEdb(item *EdbInfo, calculateMappingList []*EdbInfoCalculateMapping, predictEdbConfList []*PredictEdbConf, calculateRuleMap map[int]CalculateRule) (err error) {
 	o := orm.NewOrm()
 	tx, err := o.Begin()
 	if err != nil {
@@ -178,12 +178,10 @@ func AddPredictEdb(item *EdbInfo, calculateMappingList []*EdbInfoCalculateMappin
 		}
 	}
 
-	calculateRuleIndex := 0 // 预测计算规则下标
-
 	predictEdbConfAndDataList := make([]*PredictEdbConfAndData, 0)
 
 	// 新增预测指标配置
-	for _, v := range predictEdbConfList {
+	for k, v := range predictEdbConfList {
 		v.PredictEdbInfoId = item.EdbInfoId
 		configId, tmpErr := tx.Insert(v)
 		if tmpErr != nil {
@@ -196,7 +194,7 @@ func AddPredictEdb(item *EdbInfo, calculateMappingList []*EdbInfoCalculateMappin
 		resultDataList := make([]*EdbInfoSearchData, 0)
 		switch v.RuleType {
 		case 9: //动态环差规则
-			calculateRule := calculateRuleList[calculateRuleIndex]
+			calculateRule := calculateRuleMap[k]
 			calculateRule.ConfigId = v.ConfigId
 			calculateRule.EdbInfoId = v.PredictEdbInfoId
 
@@ -219,7 +217,7 @@ func AddPredictEdb(item *EdbInfo, calculateMappingList []*EdbInfoCalculateMappin
 				}
 			}
 		case 14: //14：根据 一元线性拟合 规则获取预测数据
-			calculateRule := calculateRuleList[calculateRuleIndex]
+			calculateRule := calculateRuleMap[k]
 			calculateRule.ConfigId = v.ConfigId
 			calculateRule.EdbInfoId = v.PredictEdbInfoId
 
@@ -244,8 +242,6 @@ func AddPredictEdb(item *EdbInfo, calculateMappingList []*EdbInfoCalculateMappin
 
 		}
 
-		calculateRuleIndex++
-
 		// 规则配置（含数据）
 		tmpPredictEdbConfAndData := &PredictEdbConfAndData{
 			ConfigId:         0,
@@ -265,7 +261,7 @@ func AddPredictEdb(item *EdbInfo, calculateMappingList []*EdbInfoCalculateMappin
 }
 
 // EditPredictEdb 修改预测指标
-func EditPredictEdb(edbInfo *EdbInfo, updateEdbInfoCol []string, calculateMappingList []*EdbInfoCalculateMapping, predictEdbConfList []*PredictEdbConf, calculateRuleList []CalculateRule) (err error) {
+func EditPredictEdb(edbInfo *EdbInfo, updateEdbInfoCol []string, calculateMappingList []*EdbInfoCalculateMapping, predictEdbConfList []*PredictEdbConf, calculateRuleMap map[int]CalculateRule) (err error) {
 	o := orm.NewOrm()
 	tx, err := o.Begin()
 	if err != nil {
@@ -328,7 +324,7 @@ func EditPredictEdb(edbInfo *EdbInfo, updateEdbInfoCol []string, calculateMappin
 	predictEdbConfAndDataList := make([]*PredictEdbConfAndData, 0)
 
 	// 新增预测指标配置
-	for _, v := range predictEdbConfList {
+	for confIndex, v := range predictEdbConfList {
 		configId, tmpErr := tx.Insert(v)
 		if tmpErr != nil {
 			err = tmpErr
@@ -340,7 +336,7 @@ func EditPredictEdb(edbInfo *EdbInfo, updateEdbInfoCol []string, calculateMappin
 
 		switch v.RuleType {
 		case 9: //动态环差规则
-			calculateRule := calculateRuleList[calculateRuleIndex]
+			calculateRule := calculateRuleMap[confIndex]
 			calculateRule.ConfigId = v.ConfigId
 			calculateRule.EdbInfoId = v.PredictEdbInfoId
 
@@ -362,7 +358,7 @@ func EditPredictEdb(edbInfo *EdbInfo, updateEdbInfoCol []string, calculateMappin
 				}
 			}
 		case 14: //14：根据 一元线性拟合 规则获取预测数据
-			calculateRule := calculateRuleList[calculateRuleIndex]
+			calculateRule := calculateRuleMap[confIndex]
 			calculateRule.ConfigId = v.ConfigId
 			calculateRule.EdbInfoId = v.PredictEdbInfoId