Merge branch 'chart/13.4' into debug

logic/predict_edb.go

@@ -665,10 +665,14 @@ func RefreshPredictEdbInfo(edbInfoId int) (edbInfo *models.EdbInfo, err error, e
 		edbInfoListMap[v.EdbInfoId] = v
 	}
 
+	predictEdbConfAndDataList := make([]*models.PredictEdbConfAndData, 0)
 	// 刷新所有的规则
 	for _, v := range predictEdbConfList {
+		// 每次规则计算的时候，产生的临时数据
+		resultDataList := make([]*models.EdbInfoSearchData, 0)
+
 		switch v.RuleType {
-		case 9:
+		case 9: //动态环差值
 			if v.Value == "" {
 				errMsg = "请填写计算规则"
 				return
@@ -728,11 +732,37 @@ func RefreshPredictEdbInfo(edbInfoId int) (edbInfo *models.EdbInfo, err error, e
 				EndDate:                    v.EndDate.Format(utils.FormatDate),
 				EdbInfoIdArr:               edbInfoIdArr,
 			}
-			err = models.RefreshCalculateByRuleBy9(rule)
+			resultDataList, err = models.RefreshCalculateByRuleBy9(rule)
 			if err != nil {
 				return
 			}
+		case 14: //14：根据 一元线性拟合 规则获取预测数据
+
+			if v.Value == "" {
+				errMsg = "一元线性拟合规则信息未配置"
+				return
+			}
+			err = models.RefreshCalculateByRuleByLineNh(*edbInfo, predictEdbConfAndDataList, *v)
+			if err != nil {
+				return
+			}
+		}
+
+		// 规则配置（含数据）
+		tmpPredictEdbConfAndData := &models.PredictEdbConfAndData{
+			ConfigId:         0,
+			PredictEdbInfoId: 0,
+			SourceEdbInfoId:  v.SourceEdbInfoId,
+			RuleType:         v.RuleType,
+			FixedValue:       v.FixedValue,
+			Value:            v.Value,
+			EndDate:          v.EndDate,
+			ModifyTime:       v.ModifyTime,
+			CreateTime:       v.CreateTime,
+			DataList:         resultDataList,
 		}
+		predictEdbConfAndDataList = append(predictEdbConfAndDataList, tmpPredictEdbConfAndData)
+
 	}
 
 	return

models/base_from_calculate.go

@@ -764,14 +764,14 @@ func handleDateSaveDataMap(dateList []string, realSaveDataMap, saveDataMap map[s
 				case "年度":
 					day = 365
 				}
-				handleDataMap(realSaveDataMap, saveDataMap, date, tmpEdbInfoId, day)
+				handleDateDataMap(realSaveDataMap, saveDataMap, date, tmpEdbInfoId, day)
 			}
 		}
 	}
 }
 
-// handleDataMap 处理单个日期的数据
-func handleDataMap(realSaveDataMap, saveDataMap map[string]map[int]float64, date string, edbInfoId, day int) {
+// handleDateDataMap 处理单个日期的数据
+func handleDateDataMap(realSaveDataMap, saveDataMap map[string]map[int]float64, date string, edbInfoId, day int) {
 	currDate, _ := time.ParseInLocation(utils.FormatDate, date, time.Local)
 
 	// 后一天

models/edb_data_calculate_nhcc.go

@@ -508,7 +508,7 @@ func refreshAllCalculateNhcc(to orm.TxOrmer, edbInfo *EdbInfo, existItemA, exist
 	// 计算线性方程公式
 	var a, b float64
 	{
-		coordinateData := make([]Coordinate, 0)
+		coordinateData := make([]utils.Coordinate, 0)
 		for i := nhccDate.StartDate; i.Before(nhccDate.EndDate) || i.Equal(nhccDate.EndDate); i = i.AddDate(0, 0, 1) {
 			dateStr := i.Format(utils.FormatDate)
 			xValue, ok := aDataMap[dateStr]
@@ -521,13 +521,13 @@ func refreshAllCalculateNhcc(to orm.TxOrmer, edbInfo *EdbInfo, existItemA, exist
 				err = errors.New("指标B日期：" + dateStr + "数据异常，导致计算线性方程公式失败")
 				return
 			}
-			tmpCoordinate := Coordinate{
+			tmpCoordinate := utils.Coordinate{
 				X: xValue,
 				Y: yValue,
 			}
 			coordinateData = append(coordinateData, tmpCoordinate)
 		}
-		a, b = getLinearResult(coordinateData)
+		a, b = utils.GetLinearResult(coordinateData)
 	}
 
 	if math.IsNaN(a) || math.IsNaN(b) {

models/edb_info.go

@@ -461,7 +461,7 @@ func GetChartPredictEdbInfoDataList(predictEdbConf PredictEdbConf, latestDateStr
 }
 
 // GetChartPredictEdbInfoDataListByConfList 获取图表的预测指标的未来数据
-func GetChartPredictEdbInfoDataListByConfList(predictEdbConfList []*PredictEdbConf, filtrateStartDateStr, latestDateStr, endDateStr, frequency string, realPredictEdbInfoData []*EdbInfoSearchData) (predictEdbInfoData []*EdbInfoSearchData, minValue, maxValue float64, err error) {
+func GetChartPredictEdbInfoDataListByConfList(predictEdbConfList []*PredictEdbConfAndData, filtrateStartDateStr, latestDateStr, endDateStr, frequency string, realPredictEdbInfoData []*EdbInfoSearchData) (predictEdbInfoData []*EdbInfoSearchData, minValue, maxValue float64, err error) {
 	endDate, err := time.ParseInLocation(utils.FormatDate, endDateStr, time.Local)
 	if err != nil {
 		return
@@ -508,6 +508,11 @@ func GetChartPredictEdbInfoDataListByConfList(predictEdbConfList []*PredictEdbCo
 
 		var tmpMinValue, tmpMaxValue float64 // 当前预测结果中的最大/最小值
 
+		dayList := getPredictEdbDayList(startDate, dataEndTime, frequency)
+		if len(dayList) <= 0 { // 如果未来没有日期的话，那么就退出当前循环，进入下一个循环
+			continue
+		}
+
 		switch predictEdbConf.RuleType {
 		case 1: //1：最新
 			var lastDataValue float64 //最新值
@@ -518,7 +523,7 @@ func GetChartPredictEdbInfoDataListByConfList(predictEdbConfList []*PredictEdbCo
 			if lenTmpAllData > 0 {
 				lastDataValue = tmpAllData[lenTmpAllData-1].Value
 			}
-			predictEdbInfoData = GetChartPredictEdbInfoDataListByRule1(predictEdbConf.PredictEdbInfoId, lastDataValue, startDate, dataEndTime, frequency, predictEdbInfoData, existMap)
+			predictEdbInfoData = GetChartPredictEdbInfoDataListByRule1(predictEdbConf.PredictEdbInfoId, lastDataValue, dayList, predictEdbInfoData, existMap)
 			tmpMaxValue = lastDataValue
 			tmpMinValue = lastDataValue
 		case 2: //2：固定值
@@ -528,7 +533,7 @@ func GetChartPredictEdbInfoDataListByConfList(predictEdbConfList []*PredictEdbCo
 				return
 			}
 			dataValue, _ := tmpValDecimal.Float64()
-			predictEdbInfoData = GetChartPredictEdbInfoDataListByRule1(predictEdbConf.PredictEdbInfoId, dataValue, startDate, dataEndTime, frequency, predictEdbInfoData, existMap)
+			predictEdbInfoData = GetChartPredictEdbInfoDataListByRule1(predictEdbConf.PredictEdbInfoId, dataValue, dayList, predictEdbInfoData, existMap)
 
 			tmpMaxValue = dataValue
 			tmpMinValue = dataValue
@@ -539,7 +544,7 @@ func GetChartPredictEdbInfoDataListByConfList(predictEdbConfList []*PredictEdbCo
 				return
 			}
 			tbValue, _ := tmpValDecimal.Float64()
-			predictEdbInfoData, tmpMinValue, tmpMaxValue = GetChartPredictEdbInfoDataListByRuleTb(predictEdbConf.PredictEdbInfoId, tbValue, startDate, dataEndTime, frequency, realPredictEdbInfoData, predictEdbInfoData, existMap)
+			predictEdbInfoData, tmpMinValue, tmpMaxValue = GetChartPredictEdbInfoDataListByRuleTb(predictEdbConf.PredictEdbInfoId, tbValue, dayList, frequency, realPredictEdbInfoData, predictEdbInfoData, existMap)
 		case 4: //4：同差
 			tmpValDecimal, tmpErr := decimal.NewFromString(predictEdbConf.Value)
 			if tmpErr != nil {
@@ -547,7 +552,7 @@ func GetChartPredictEdbInfoDataListByConfList(predictEdbConfList []*PredictEdbCo
 				return
 			}
 			tcValue, _ := tmpValDecimal.Float64()
-			predictEdbInfoData, tmpMinValue, tmpMaxValue = GetChartPredictEdbInfoDataListByRuleTc(predictEdbConf.PredictEdbInfoId, tcValue, startDate, dataEndTime, frequency, realPredictEdbInfoData, predictEdbInfoData, existMap)
+			predictEdbInfoData, tmpMinValue, tmpMaxValue = GetChartPredictEdbInfoDataListByRuleTc(predictEdbConf.PredictEdbInfoId, tcValue, dayList, frequency, realPredictEdbInfoData, predictEdbInfoData, existMap)
 		case 5: //5：环比
 			tmpValDecimal, tmpErr := decimal.NewFromString(predictEdbConf.Value)
 			if tmpErr != nil {
@@ -555,7 +560,7 @@ func GetChartPredictEdbInfoDataListByConfList(predictEdbConfList []*PredictEdbCo
 				return
 			}
 			hbValue, _ := tmpValDecimal.Float64()
-			predictEdbInfoData, tmpMinValue, tmpMaxValue = GetChartPredictEdbInfoDataListByRuleHb(predictEdbConf.PredictEdbInfoId, hbValue, startDate, dataEndTime, frequency, realPredictEdbInfoData, predictEdbInfoData, existMap)
+			predictEdbInfoData, tmpMinValue, tmpMaxValue = GetChartPredictEdbInfoDataListByRuleHb(predictEdbConf.PredictEdbInfoId, hbValue, dayList, realPredictEdbInfoData, predictEdbInfoData, existMap)
 		case 6: //6：环差
 			tmpValDecimal, tmpErr := decimal.NewFromString(predictEdbConf.Value)
 			if tmpErr != nil {
@@ -563,26 +568,54 @@ func GetChartPredictEdbInfoDataListByConfList(predictEdbConfList []*PredictEdbCo
 				return
 			}
 			hcValue, _ := tmpValDecimal.Float64()
-			predictEdbInfoData, tmpMinValue, tmpMaxValue = GetChartPredictEdbInfoDataListByRuleHc(predictEdbConf.PredictEdbInfoId, hcValue, startDate, dataEndTime, frequency, realPredictEdbInfoData, predictEdbInfoData, existMap)
+			predictEdbInfoData, tmpMinValue, tmpMaxValue = GetChartPredictEdbInfoDataListByRuleHc(predictEdbConf.PredictEdbInfoId, hcValue, dayList, realPredictEdbInfoData, predictEdbInfoData, existMap)
 		case 7: //7：N期移动均值
 			nValue, tmpErr := strconv.Atoi(predictEdbConf.Value)
 			if tmpErr != nil {
 				err = tmpErr
 				return
 			}
-			predictEdbInfoData, tmpMinValue, tmpMaxValue = GetChartPredictEdbInfoDataListByRuleNMoveMeanValue(predictEdbConf.PredictEdbInfoId, nValue, startDate, dataEndTime, frequency, realPredictEdbInfoData, predictEdbInfoData, existMap)
+			predictEdbInfoData, tmpMinValue, tmpMaxValue = GetChartPredictEdbInfoDataListByRuleNMoveMeanValue(predictEdbConf.PredictEdbInfoId, nValue, dayList, realPredictEdbInfoData, predictEdbInfoData, existMap)
 		case 8: //8：N期段线性外推值
 			nValue, tmpErr := strconv.Atoi(predictEdbConf.Value)
 			if tmpErr != nil {
 				err = tmpErr
 				return
 			}
-			predictEdbInfoData, tmpMinValue, tmpMaxValue, err = GetChartPredictEdbInfoDataListByRuleNLinearRegression(predictEdbConf.PredictEdbInfoId, nValue, startDate, dataEndTime, frequency, realPredictEdbInfoData, predictEdbInfoData, existMap)
+			predictEdbInfoData, tmpMinValue, tmpMaxValue, err = GetChartPredictEdbInfoDataListByRuleNLinearRegression(predictEdbConf.PredictEdbInfoId, nValue, dayList, realPredictEdbInfoData, predictEdbInfoData, existMap)
 			if err != nil {
 				return
 			}
 		case 9: //9：动态环差”预测规则；
-			predictEdbInfoData, tmpMinValue, tmpMaxValue = GetChartPredictEdbInfoDataListByRuleTrendsHC(predictEdbConf.PredictEdbInfoId, predictEdbConf.ConfigId, startDate, dataEndTime, frequency, realPredictEdbInfoData, predictEdbInfoData, existMap)
+			hcDataMap := make(map[string]float64) //规则计算的环差值map
+
+			if predictEdbConf.PredictEdbInfoId > 0 {
+				tmpPredictEdbRuleDataList, tmpErr := GetPredictEdbRuleDataItemList(predictEdbConf.PredictEdbInfoId, predictEdbConf.ConfigId, startDate.Format(utils.FormatDate), endDate.Format(utils.FormatDate))
+				if tmpErr != nil {
+					err = tmpErr
+					return
+				}
+				for _, v := range tmpPredictEdbRuleDataList {
+					hcDataMap[v.DataTime] = v.Value
+				}
+			} else {
+				if len(predictEdbConf.DataList) <= 0 {
+					return
+				}
+				for _, v := range predictEdbConf.DataList {
+					currentDate, tmpErr := time.ParseInLocation(utils.FormatDate, v.DataTime, time.Local)
+					if tmpErr != nil {
+						continue
+					}
+					// 只处理时间段内的数据
+					if currentDate.Before(startDate) || currentDate.After(endDate) {
+						continue
+					}
+					hcDataMap[v.DataTime] = v.Value
+				}
+			}
+
+			predictEdbInfoData, tmpMinValue, tmpMaxValue = GetChartPredictEdbInfoDataListByRuleTrendsHC(predictEdbConf.PredictEdbInfoId, dayList, realPredictEdbInfoData, predictEdbInfoData, hcDataMap, existMap)
 		case 10: //10：根据 给定终值后插值 规则获取预测数据
 			tmpValDecimal, tmpErr := decimal.NewFromString(predictEdbConf.Value)
 			if tmpErr != nil {
@@ -590,7 +623,7 @@ func GetChartPredictEdbInfoDataListByConfList(predictEdbConfList []*PredictEdbCo
 				return
 			}
 			finalValue, _ := tmpValDecimal.Float64()
-			predictEdbInfoData, tmpMinValue, tmpMaxValue = GetChartPredictEdbInfoDataListByRuleFinalValueHc(predictEdbConf.PredictEdbInfoId, finalValue, startDate, dataEndTime, frequency, realPredictEdbInfoData, predictEdbInfoData, existMap)
+			predictEdbInfoData, tmpMinValue, tmpMaxValue = GetChartPredictEdbInfoDataListByRuleFinalValueHc(predictEdbConf.PredictEdbInfoId, finalValue, dayList, realPredictEdbInfoData, predictEdbInfoData, existMap)
 		case 11: //11：根据 季节性 规则获取预测数据
 			var seasonConf SeasonConf
 			tmpErr := json.Unmarshal([]byte(predictEdbConf.Value), &seasonConf)
@@ -617,7 +650,7 @@ func GetChartPredictEdbInfoDataListByConfList(predictEdbConfList []*PredictEdbCo
 			} else {
 				yearList = seasonConf.YearList
 			}
-			predictEdbInfoData, tmpMinValue, tmpMaxValue, err = GetChartPredictEdbInfoDataListByRuleSeason(predictEdbConf.PredictEdbInfoId, yearList, calendar, startDate, dataEndTime, frequency, realPredictEdbInfoData, predictEdbInfoData, existMap)
+			predictEdbInfoData, tmpMinValue, tmpMaxValue, err = GetChartPredictEdbInfoDataListByRuleSeason(predictEdbConf.PredictEdbInfoId, yearList, calendar, dayList, realPredictEdbInfoData, predictEdbInfoData, existMap)
 			if err != nil {
 				return
 			}
@@ -628,7 +661,42 @@ func GetChartPredictEdbInfoDataListByConfList(predictEdbConfList []*PredictEdbCo
 				err = errors.New("季节性配置信息异常:" + tmpErr.Error())
 				return
 			}
-			predictEdbInfoData, tmpMinValue, tmpMaxValue, err = GetChartPredictEdbInfoDataListByRuleMoveAverageTb(predictEdbConf.PredictEdbInfoId, moveAverageConf.NValue, moveAverageConf.Year, startDate, dataEndTime, frequency, realPredictEdbInfoData, predictEdbInfoData, existMap)
+			predictEdbInfoData, tmpMinValue, tmpMaxValue, err = GetChartPredictEdbInfoDataListByRuleMoveAverageTb(predictEdbConf.PredictEdbInfoId, moveAverageConf.NValue, moveAverageConf.Year, dayList, realPredictEdbInfoData, predictEdbInfoData, existMap)
+			if err != nil {
+				return
+			}
+		case 13: //13：根据 同比增速差值 规则获取预测数据
+			tmpValDecimal, tmpErr := decimal.NewFromString(predictEdbConf.Value)
+			if tmpErr != nil {
+				err = tmpErr
+				return
+			}
+			tbEndValue, _ := tmpValDecimal.Float64()
+			predictEdbInfoData, tmpMinValue, tmpMaxValue = GetChartPredictEdbInfoDataListByRuleTbzscz(predictEdbConf.PredictEdbInfoId, tbEndValue, dayList, frequency, realPredictEdbInfoData, predictEdbInfoData, existMap)
+		case 14: //14：根据 一元线性拟合 规则获取预测数据
+			var ruleConf RuleLineNhConf
+			err = json.Unmarshal([]byte(predictEdbConf.Value), &ruleConf)
+			if err != nil {
+				err = errors.New("一元线性拟合规则配置信息异常:" + err.Error())
+				return
+			}
+
+			// 规则计算的拟合残差值map
+			newNhccDataMap := make(map[string]float64)
+			if predictEdbConf.PredictEdbInfoId > 0 { //已经生成的动态数据
+				tmpPredictEdbRuleDataList, tmpErr := GetPredictEdbRuleDataItemList(predictEdbConf.PredictEdbInfoId, predictEdbConf.ConfigId, startDate.Format(utils.FormatDate), endDate.Format(utils.FormatDate))
+				if tmpErr != nil {
+					err = tmpErr
+					return
+				}
+				for _, v := range tmpPredictEdbRuleDataList {
+					newNhccDataMap[v.DataTime] = v.Value
+				}
+			} else { //未生成的动态数据，需要使用外部传入的数据进行计算
+				newNhccDataMap, err = getCalculateNhccData(append(realPredictEdbInfoData, predictEdbInfoData...), ruleConf)
+			}
+
+			predictEdbInfoData, tmpMinValue, tmpMaxValue, err = GetChartPredictEdbInfoDataListByRuleLineNh(predictEdbConf.PredictEdbInfoId, dayList, realPredictEdbInfoData, predictEdbInfoData, newNhccDataMap, existMap)
 			if err != nil {
 				return
 			}
@@ -684,20 +752,10 @@ func getPredictEdbDayList(startDate, endDate time.Time, frequency string) (dayLi
 	return
 }
 
-// GetPredictDataListByPredictEdbInfoId 根据预测指标id获取预测指标的数据，order:1升序，其余值为降序
-func GetPredictDataListByPredictEdbInfoId(edbInfoId, order int, startDate string) (dataList []*EdbInfoSearchData, sourceEdbInfoItem *EdbInfo, predictEdbConf *PredictEdbConf, err error, errMsg string) {
-	edbInfo, err := GetEdbInfoById(edbInfoId)
-	if err != nil {
-		errMsg = `获取预测指标信息失败`
-		return
-	}
-	return GetPredictDataListByPredictEdbInfo(edbInfo, order, startDate)
-}
-
 // GetPredictDataListByPredictEdbInfo 根据预测指标信息获取预测指标的数据，order:1升序，其余值为降序
-func GetPredictDataListByPredictEdbInfo(edbInfo *EdbInfo, order int, startDate string) (dataList []*EdbInfoSearchData, sourceEdbInfoItem *EdbInfo, predictEdbConf *PredictEdbConf, err error, errMsg string) {
+func GetPredictDataListByPredictEdbInfo(edbInfo *EdbInfo, order int, startDate string) (dataList []*EdbInfoSearchData, sourceEdbInfoItem *EdbInfo, err error, errMsg string) {
 	// 查找该预测指标配置
-	predictEdbConfList, err := GetPredictEdbConfListById(edbInfo.EdbInfoId)
+	predictEdbConfList, err := GetPredictEdbConfAndDataListById(edbInfo.EdbInfoId)
 	if err != nil && err.Error() != utils.ErrNoRow() {
 		errMsg = "获取预测指标配置信息失败"
 		return
@@ -707,7 +765,7 @@ func GetPredictDataListByPredictEdbInfo(edbInfo *EdbInfo, order int, startDate s
 		err = errors.New(errMsg)
 		return
 	}
-	predictEdbConf = predictEdbConfList[0]
+	predictEdbConf := predictEdbConfList[0]
 
 	// 来源指标
 	sourceEdbInfoItem, err = GetEdbInfoById(predictEdbConf.SourceEdbInfoId)
@@ -719,6 +777,19 @@ func GetPredictDataListByPredictEdbInfo(edbInfo *EdbInfo, order int, startDate s
 		return
 	}
 
+	dataList, err, errMsg = GetPredictDataListByPredictEdbConfList(edbInfo, sourceEdbInfoItem, predictEdbConfList, order, startDate)
+
+	return
+}
+
+// GetPredictDataListByPredictEdbConfList 根据预测指标信息获取预测指标的数据，order:1升序，其余值为降序
+func GetPredictDataListByPredictEdbConfList(edbInfo, sourceEdbInfoItem *EdbInfo, predictEdbConfList []*PredictEdbConfAndData, order int, startDate string) (dataList []*EdbInfoSearchData, err error, errMsg string) {
+	if len(predictEdbConfList) == 0 {
+		errMsg = "获取预测指标配置信息失败"
+		err = errors.New(errMsg)
+		return
+	}
+
 	allDataList := make([]*EdbInfoSearchData, 0)
 	//获取指标数据（实际已生成）
 	var condition string
@@ -748,7 +819,6 @@ func GetPredictDataListByPredictEdbInfo(edbInfo *EdbInfo, order int, startDate s
 
 	endDateStr := edbInfo.EndDate //预测指标的结束日期
 
-	//predictDataList, err = GetChartPredictEdbInfoDataList(*predictEdbConf, sourceEdbInfoItem.LatestDate, sourceEdbInfoItem.LatestValue, endDateStr, edbInfo.Frequency, order)
 	var predictMinValue, predictMaxValue float64
 	predictDataList, predictMinValue, predictMaxValue, err = GetChartPredictEdbInfoDataListByConfList(predictEdbConfList, startDate, sourceEdbInfoItem.LatestDate, endDateStr, edbInfo.Frequency, allDataList)
 
@@ -791,7 +861,7 @@ func GetPredictDataListByPredictEdbInfo(edbInfo *EdbInfo, order int, startDate s
 // GetPredictEdbDataListAll 获取该预测指标所有的数据 ，order:1升序，其余值为降序
 func GetPredictEdbDataListAll(edbInfo *EdbInfo, order int) (items []*EdbInfoSearchData, err error) {
 	if edbInfo.Source == utils.DATA_SOURCE_PREDICT { //普通的预测指标是没有入库数据的，直接往配置里面获取
-		items, _, _, err, _ = GetPredictDataListByPredictEdbInfo(edbInfo, 1, "")
+		items, _, err, _ = GetPredictDataListByPredictEdbInfo(edbInfo, 1, "")
 	} else {
 		var condition string
 		var pars []interface{}
@@ -805,7 +875,7 @@ func GetPredictEdbDataListAll(edbInfo *EdbInfo, order int) (items []*EdbInfoSear
 // GetPredictEdbDataListAllByStartDate 根据开始日期获取该预测指标所有的数据 ，order:1升序，其余值为降序
 func GetPredictEdbDataListAllByStartDate(edbInfo *EdbInfo, order int, startDate string) (items []*EdbInfoSearchData, err error) {
 	if edbInfo.Source == utils.DATA_SOURCE_PREDICT { //普通的预测指标是没有入库数据的，直接往配置里面获取
-		items, _, _, err, _ = GetPredictDataListByPredictEdbInfo(edbInfo, order, startDate)
+		items, _, err, _ = GetPredictDataListByPredictEdbInfo(edbInfo, order, startDate)
 	} else {
 		var condition string
 		var pars []interface{}

models/predict_edb.go

@@ -1,6 +1,7 @@
 package models
 
 import (
+	"encoding/json"
 	"errors"
 	"fmt"
 	"github.com/beego/beego/v2/client/orm"
@@ -27,7 +28,7 @@ type CalculateRule struct {
 }
 
 // RefreshCalculateByRuleBy9 刷新计算
-func RefreshCalculateByRuleBy9(rule CalculateRule) (err error) {
+func RefreshCalculateByRuleBy9(rule CalculateRule) (resultDataList []*EdbInfoSearchData, err error) {
 	o := orm.NewOrm()
 	to, err := o.Begin()
 	if err != nil {
@@ -43,12 +44,14 @@ func RefreshCalculateByRuleBy9(rule CalculateRule) (err error) {
 			err = to.Commit()
 		}
 	}()
-	err = CalculateByRuleBy9(to, rule)
+
+	resultDataList, err = CalculateByRuleBy9(to, rule)
+
 	return
 }
 
 // CalculateByRuleBy9 动态环差规则计算入库
-func CalculateByRuleBy9(to orm.TxOrmer, rule CalculateRule) (err error) {
+func CalculateByRuleBy9(to orm.TxOrmer, rule CalculateRule) (resultDataList []*EdbInfoSearchData, err error) {
 	realSaveDataMap := make(map[string]map[int]float64)
 	saveDataMap := make(map[string]map[int]float64)
 	dateList := make([]string, 0)
@@ -109,7 +112,7 @@ func CalculateByRuleBy9(to orm.TxOrmer, rule CalculateRule) (err error) {
 	sql := `SELECT * FROM predict_edb_rule_data WHERE config_id = ?`
 	_, err = to.Raw(sql, rule.ConfigId).QueryRows(&dataList)
 	if err != nil {
-		return err
+		return
 	}
 	dataMap := make(map[string]*PredictEdbRuleData)
 	for _, v := range dataList {
@@ -129,22 +132,22 @@ func CalculateByRuleBy9(to orm.TxOrmer, rule CalculateRule) (err error) {
 
 		utils.FileLog.Info(fmt.Sprintf("formulaFormStr:%s", formulaFormStr))
 		expression := formula.NewExpression(formulaFormStr)
-		calResult, err := expression.Evaluate()
-		if err != nil {
+		calResult, tmpErr := expression.Evaluate()
+		if tmpErr != nil {
 			// 分母为0的报错
-			if strings.Contains(err.Error(), "divide by zero") {
+			if strings.Contains(tmpErr.Error(), "divide by zero") {
 				removeDateList = append(removeDateList, sk)
 				continue
 			}
-			err = errors.New("计算失败：Err:" + err.Error() + ";formulaStr:" + formulaFormStr)
-			fmt.Println(err)
-			return err
+			err = errors.New("计算失败：Err:" + tmpErr.Error() + ";formulaStr:" + formulaFormStr)
+			//fmt.Println(err)
+			return
 		}
-		calVal, err := calResult.Float64()
-		if err != nil {
-			err = errors.New("计算失败：获取计算值失败 Err:" + err.Error() + ";formulaStr:" + formulaFormStr)
-			fmt.Println(err)
-			return err
+		calVal, tmpErr := calResult.Float64()
+		if tmpErr != nil {
+			err = errors.New("计算失败：获取计算值失败 Err:" + tmpErr.Error() + ";formulaStr:" + formulaFormStr)
+			//fmt.Println(err)
+			return
 		}
 
 		saveValue := decimal.NewFromFloat(calVal).RoundCeil(4).String() //utils.SubFloatToString(calVal, 4)
@@ -168,17 +171,28 @@ func CalculateByRuleBy9(to orm.TxOrmer, rule CalculateRule) (err error) {
 			}
 			existDataMap[sk] = sk
 		} else {
-			existValDecimal, err := decimal.NewFromString(existPredictEdbRuleData.Value)
+			existValDecimal, tmpErr := decimal.NewFromString(existPredictEdbRuleData.Value)
+			if tmpErr != nil {
+				err = tmpErr
+				return
+			}
 			existStr := existValDecimal.String()
 			if existStr != saveValue {
 				existPredictEdbRuleData.Value = saveValue
 				existPredictEdbRuleData.ModifyTime = time.Now()
 				_, err = to.Update(existPredictEdbRuleData, "Value", "ModifyTime")
 				if err != nil {
-					return err
+					return
 				}
 			}
 		}
+
+		// 计算出来的结果集
+		resultDataList = append(resultDataList, &EdbInfoSearchData{
+			//EdbDataId: 0,
+			DataTime: sk,
+			Value:    calVal,
+		})
 	}
 
 	// 添加计算出来的值入库
@@ -202,5 +216,170 @@ func CalculateByRuleBy9(to orm.TxOrmer, rule CalculateRule) (err error) {
 			return
 		}
 	}
+
+	return
+}
+
+// RefreshCalculateByRuleByLineNh 刷新动态结果计算（线性拟合）
+func RefreshCalculateByRuleByLineNh(predictEdbInfo EdbInfo, predictEdbConfAndDataList []*PredictEdbConfAndData, rule PredictEdbConf) (err error) {
+	o := orm.NewOrm()
+	to, err := o.Begin()
+	if err != nil {
+		return
+	}
+	defer func() {
+		if err != nil {
+			tmpErr := to.Rollback()
+			if tmpErr != nil {
+				go alarm_msg.SendAlarmMsg("RefreshCalculateByRuleBy9 事务回滚失败，Err："+tmpErr.Error(), 3)
+			}
+		} else {
+			err = to.Commit()
+		}
+	}()
+	err = CalculateByRuleByRuleLineNh(to, predictEdbInfo, predictEdbConfAndDataList, rule)
+	return
+}
+
+// CalculateByRuleByRuleLineNh 一元线性拟合规则计算入库
+func CalculateByRuleByRuleLineNh(to orm.TxOrmer, predictEdbInfo EdbInfo, predictEdbConfAndDataList []*PredictEdbConfAndData, rule PredictEdbConf) (err error) {
+	var secondDataList []*EdbInfoSearchData
+	predictEdbInfoId := predictEdbInfo.EdbInfoId // 预测指标id
+
+	// 规则
+	var ruleConf RuleLineNhConf
+	tmpErr := json.Unmarshal([]byte(rule.Value), &ruleConf)
+	if tmpErr != nil {
+		err = errors.New("季节性配置信息异常:" + tmpErr.Error())
+		return
+	}
+
+	// 获取自身指标的数据
+	{
+		// 来源指标
+		var sourceEdbInfoItem *EdbInfo
+		sql := ` SELECT * FROM edb_info WHERE edb_info_id=? `
+		err = to.Raw(sql, ruleConf.EdbInfoId).QueryRow(&sourceEdbInfoItem)
+		if err != nil {
+			return
+		}
+
+		predictEdbInfo.EdbInfoId = 0
+		secondDataList, err, _ = GetPredictDataListByPredictEdbConfList(&predictEdbInfo, sourceEdbInfoItem, predictEdbConfAndDataList, 1, ``)
+		if err != nil {
+			return
+		}
+
+	}
+	lenSecondData := len(secondDataList)
+	if lenSecondData <= 0 {
+		return
+	}
+
+	newNhccDataMap, err := getCalculateNhccData(secondDataList, ruleConf)
+	if err != nil {
+		return
+	}
+
+	//将最后计算出来的结果数据处理（新增入库、编辑日期的值、删除日期）
+	{
+		// 获取需要预测的日期
+		startDateStr := secondDataList[lenSecondData-1].DataTime
+		startDate, _ := time.ParseInLocation(utils.FormatDate, startDateStr, time.Local)
+		endDate, _ := time.ParseInLocation(utils.FormatDate, ruleConf.EndDate, time.Local)
+		dayList := getPredictEdbDayList(startDate, endDate, predictEdbInfo.Frequency)
+		if len(dayList) <= 0 { // 如果未来没有日期的话，那么就退出当前循环，进入下一个循环
+			return
+		}
+
+		//获取该配置的所有数据
+		dataList := make([]*PredictEdbRuleData, 0)
+		sql := `SELECT * FROM predict_edb_rule_data WHERE config_id = ?`
+		_, err = to.Raw(sql, rule.ConfigId).QueryRows(&dataList)
+		if err != nil {
+			return
+		}
+		dataMap := make(map[string]*PredictEdbRuleData)
+		for _, v := range dataList {
+			dataMap[v.DataTime] = v
+		}
+
+		//需要移除的日期
+		removeDateList := make([]string, 0)
+		// 已经操作过的日期
+		existDataMap := make(map[string]string)
+		// 添加数据
+		addDataList := make([]*PredictEdbRuleData, 0)
+
+		for _, currentDate := range dayList {
+			// 动态拟合残差值数据
+			currentDateStr := currentDate.Format(utils.FormatDate)
+			val, ok := newNhccDataMap[currentDateStr]
+			// 找不到数据，那么就移除该日期的数据
+			if !ok {
+				removeDateList = append(removeDateList, currentDateStr)
+				continue
+			}
+
+			saveValue := decimal.NewFromFloat(val).RoundCeil(4).String() //utils.SubFloatToString(calVal, 4)
+			existPredictEdbRuleData, ok := dataMap[currentDateStr]
+			if !ok {
+				timestamp := currentDate.UnixNano() / 1e6
+
+				if _, existOk := existDataMap[currentDateStr]; !existOk {
+					tmpPredictEdbRuleData := &PredictEdbRuleData{
+						//PredictEdbRuleDataId: 0,
+						EdbInfoId:     predictEdbInfoId,
+						ConfigId:      rule.ConfigId,
+						DataTime:      currentDateStr,
+						Value:         saveValue,
+						CreateTime:    time.Now(),
+						ModifyTime:    time.Now(),
+						DataTimestamp: timestamp,
+					}
+					addDataList = append(addDataList, tmpPredictEdbRuleData)
+				}
+				existDataMap[currentDateStr] = currentDateStr
+			} else {
+				existValDecimal, tmpErr := decimal.NewFromString(existPredictEdbRuleData.Value)
+				if tmpErr != nil {
+					err = tmpErr
+					return
+				}
+				existStr := existValDecimal.String()
+				if existStr != saveValue {
+					existPredictEdbRuleData.Value = saveValue
+					existPredictEdbRuleData.ModifyTime = time.Now()
+					_, err = to.Update(existPredictEdbRuleData, "Value", "ModifyTime")
+					if err != nil {
+						return
+					}
+				}
+			}
+		}
+
+		// 添加计算出来的值入库
+		lenAddDataList := len(addDataList)
+		if lenAddDataList > 0 {
+			_, err = to.InsertMulti(lenAddDataList, addDataList)
+			if err != nil {
+				return
+			}
+		}
+
+		//删除多余的值
+		lenRemoveDateList := len(removeDateList)
+		if lenRemoveDateList > 0 {
+			//如果拼接指标变更了，那么需要删除所有的指标数据
+			sql := ` DELETE FROM predict_edb_rule_data WHERE config_id = ? and data_time in (` + utils.GetOrmInReplace(lenRemoveDateList) + `) `
+
+			_, err = to.Raw(sql, rule.ConfigId, removeDateList).Exec()
+			if err != nil {
+				err = fmt.Errorf("删除计算失败的预测规则计算指标数据失败,Err:" + err.Error())
+				return
+			}
+		}
+	}
+
 	return
 }

models/predict_edb_conf.go

@@ -46,6 +46,20 @@ type PredictEdbConf struct {
 	CreateTime       time.Time `description:"添加时间"`
 }
 
+// PredictEdbConfAndData 预测规则和其对应的动态数据
+type PredictEdbConfAndData struct {
+	ConfigId         int                  `orm:"column(config_id);pk" description:"规则id"`
+	PredictEdbInfoId int                  `orm:"column(predict_edb_info_id)" description:"预测指标id"`
+	SourceEdbInfoId  int                  `description:"来源指标id"`
+	RuleType         int                  `description:"预测规则，1：最新，2：固定值，3：同比，4：同差，5：环比，6：环差，7：N期移动均值，8：N期段线性外推值，9：动态环差"`
+	FixedValue       float64              `description:"固定值"`
+	Value            string               `description:"配置的值"`
+	EndDate          time.Time            `description:"截止日期"`
+	ModifyTime       time.Time            `description:"修改时间"`
+	CreateTime       time.Time            `description:"添加时间"`
+	DataList         []*EdbInfoSearchData `description:"动态数据"`
+}
+
 // GetPredictEdbConfById 根据预测指标id获取预测指标配置信息
 func GetPredictEdbConfById(edbInfoId int) (item *PredictEdbConf, err error) {
 	o := orm.NewOrm()
@@ -70,6 +84,14 @@ func GetPredictEdbConfListById(edbInfoId int) (items []*PredictEdbConf, err erro
 	return
 }
 
+// GetPredictEdbConfAndDataListById 根据预测指标id获取预测指标配置信息列表
+func GetPredictEdbConfAndDataListById(edbInfoId int) (items []*PredictEdbConfAndData, err error) {
+	o := orm.NewOrm()
+	sql := ` SELECT * FROM predict_edb_conf WHERE predict_edb_info_id=? ORDER BY config_id ASC`
+	_, err = o.Raw(sql, edbInfoId).QueryRows(&items)
+	return
+}
+
 // GetPredictEdbConfListByConfigIdList 根据预测指标id列表获取预测指标配置信息列表
 func GetPredictEdbConfListByConfigIdList(configIdList []int) (items []*PredictEdbConf, err error) {
 	num := len(configIdList)
@@ -120,7 +142,7 @@ func AddPredictEdbConf(item *PredictEdbConf) (lastId int64, err error) {
 }
 
 // AddPredictEdb 添加预测指标
-//edbInfo, calculateMappingList, predictEdbConfList,calculateRule9List,trendsMappingList
+// edbInfo, calculateMappingList, predictEdbConfList,calculateRule9List,trendsMappingList
 func AddPredictEdb(item *EdbInfo, calculateMappingList []*EdbInfoCalculateMapping, predictEdbConfList []*PredictEdbConf, calculateRuleList []CalculateRule) (err error) {
 	o := orm.NewOrm()
 	tx, err := o.Begin()
@@ -158,6 +180,8 @@ func AddPredictEdb(item *EdbInfo, calculateMappingList []*EdbInfoCalculateMappin
 
 	calculateRuleIndex := 0 // 预测计算规则下标
 
+	predictEdbConfAndDataList := make([]*PredictEdbConfAndData, 0)
+
 	// 新增预测指标配置
 	for _, v := range predictEdbConfList {
 		v.PredictEdbInfoId = item.EdbInfoId
@@ -168,6 +192,8 @@ func AddPredictEdb(item *EdbInfo, calculateMappingList []*EdbInfoCalculateMappin
 		}
 		v.ConfigId = int(configId)
 
+		// 每次规则计算的时候，产生的临时数据
+		resultDataList := make([]*EdbInfoSearchData, 0)
 		switch v.RuleType {
 		case 9: //动态环差规则
 			calculateRule := calculateRuleList[calculateRuleIndex]
@@ -175,7 +201,30 @@ func AddPredictEdb(item *EdbInfo, calculateMappingList []*EdbInfoCalculateMappin
 			calculateRule.EdbInfoId = v.PredictEdbInfoId
 
 			// 指标与规则的动态数据生成入库
-			err = CalculateByRuleBy9(tx, calculateRule)
+			resultDataList, err = CalculateByRuleBy9(tx, calculateRule)
+			if err != nil {
+				return
+			}
+
+			// 规则与指标的关系入库
+			lenTrendsCalculateMapping := len(calculateRule.TrendsCalculateMappingList)
+			if lenTrendsCalculateMapping > 0 {
+				for _, vv := range calculateRule.TrendsCalculateMappingList {
+					vv.EdbInfoId = item.EdbInfoId
+					vv.ConfigId = v.ConfigId
+				}
+				_, err = tx.InsertMulti(lenTrendsCalculateMapping, calculateRule.TrendsCalculateMappingList)
+				if err != nil {
+					return
+				}
+			}
+		case 14: //14：根据 一元线性拟合 规则获取预测数据
+			calculateRule := calculateRuleList[calculateRuleIndex]
+			calculateRule.ConfigId = v.ConfigId
+			calculateRule.EdbInfoId = v.PredictEdbInfoId
+
+			// 指标与规则的动态数据（拟合数据）生成入库
+			err = CalculateByRuleByRuleLineNh(tx, *item, predictEdbConfAndDataList, *v)
 			if err != nil {
 				return
 			}
@@ -192,9 +241,25 @@ func AddPredictEdb(item *EdbInfo, calculateMappingList []*EdbInfoCalculateMappin
 					return
 				}
 			}
-			calculateRuleIndex++
 
 		}
+
+		calculateRuleIndex++
+
+		// 规则配置（含数据）
+		tmpPredictEdbConfAndData := &PredictEdbConfAndData{
+			ConfigId:         0,
+			PredictEdbInfoId: 0,
+			SourceEdbInfoId:  v.SourceEdbInfoId,
+			RuleType:         v.RuleType,
+			FixedValue:       v.FixedValue,
+			Value:            v.Value,
+			EndDate:          v.EndDate,
+			ModifyTime:       v.ModifyTime,
+			CreateTime:       v.CreateTime,
+			DataList:         resultDataList,
+		}
+		predictEdbConfAndDataList = append(predictEdbConfAndDataList, tmpPredictEdbConfAndData)
 	}
 	return
 }
@@ -260,6 +325,7 @@ func EditPredictEdb(edbInfo *EdbInfo, updateEdbInfoCol []string, calculateMappin
 	}
 
 	calculateRuleIndex := 0 // 预测计算规则下标
+	predictEdbConfAndDataList := make([]*PredictEdbConfAndData, 0)
 
 	// 新增预测指标配置
 	for _, v := range predictEdbConfList {
@@ -269,6 +335,8 @@ func EditPredictEdb(edbInfo *EdbInfo, updateEdbInfoCol []string, calculateMappin
 			return
 		}
 		v.ConfigId = int(configId)
+		// 每次规则计算的时候，产生的临时数据
+		resultDataList := make([]*EdbInfoSearchData, 0)
 
 		switch v.RuleType {
 		case 9: //动态环差规则
@@ -277,7 +345,29 @@ func EditPredictEdb(edbInfo *EdbInfo, updateEdbInfoCol []string, calculateMappin
 			calculateRule.EdbInfoId = v.PredictEdbInfoId
 
 			// 指标与规则的动态数据生成入库
-			err = CalculateByRuleBy9(tx, calculateRule)
+			resultDataList, err = CalculateByRuleBy9(tx, calculateRule)
+			if err != nil {
+				return
+			}
+
+			// 规则与指标的关系入库
+			lenTrendsCalculateMapping := len(calculateRule.TrendsCalculateMappingList)
+			if lenTrendsCalculateMapping > 0 {
+				for _, vv := range calculateRule.TrendsCalculateMappingList {
+					vv.ConfigId = v.ConfigId
+				}
+				_, err = tx.InsertMulti(lenTrendsCalculateMapping, calculateRule.TrendsCalculateMappingList)
+				if err != nil {
+					return
+				}
+			}
+		case 14: //14：根据 一元线性拟合 规则获取预测数据
+			calculateRule := calculateRuleList[calculateRuleIndex]
+			calculateRule.ConfigId = v.ConfigId
+			calculateRule.EdbInfoId = v.PredictEdbInfoId
+
+			// 指标与规则的动态数据（拟合数据）生成入库
+			err = CalculateByRuleByRuleLineNh(tx, *edbInfo, predictEdbConfAndDataList, *v)
 			if err != nil {
 				return
 			}
@@ -293,9 +383,25 @@ func EditPredictEdb(edbInfo *EdbInfo, updateEdbInfoCol []string, calculateMappin
 					return
 				}
 			}
-			calculateRuleIndex++
 
 		}
+
+		calculateRuleIndex++
+
+		// 规则配置（含数据）
+		tmpPredictEdbConfAndData := &PredictEdbConfAndData{
+			ConfigId:         0,
+			PredictEdbInfoId: 0,
+			SourceEdbInfoId:  v.SourceEdbInfoId,
+			RuleType:         v.RuleType,
+			FixedValue:       v.FixedValue,
+			Value:            v.Value,
+			EndDate:          v.EndDate,
+			ModifyTime:       v.ModifyTime,
+			CreateTime:       v.CreateTime,
+			DataList:         resultDataList,
+		}
+		predictEdbConfAndDataList = append(predictEdbConfAndDataList, tmpPredictEdbConfAndData)
 	}
 
 	return

models/predict_edb_data_calculate_nhcc.go

@@ -297,7 +297,7 @@ func SavePredictCalculateNhcc(req *EdbInfoCalculateBatchSaveReq, firstEdbInfo, s
 				err = fmt.Errorf("删除历史数据失败,Err:" + err.Error())
 				return
 			}
-		}else{
+		} else {
 			return
 		}
 	}
@@ -402,7 +402,7 @@ func refreshAllPredictCalculateNhcc(to orm.TxOrmer, edbInfo, firstEdbInfo, secon
 
 	if latestDateA.Before(latestDateB) {
 		latestDateStr = latestDateA.Format(utils.FormatDate)
-	}else{
+	} else {
 		latestDateStr = latestDateB.Format(utils.FormatDate)
 	}
 
@@ -499,7 +499,7 @@ func refreshAllPredictCalculateNhcc(to orm.TxOrmer, edbInfo, firstEdbInfo, secon
 	// 计算线性方程公式
 	var a, b float64
 	{
-		coordinateData := make([]Coordinate, 0)
+		coordinateData := make([]utils.Coordinate, 0)
 		for i := nhccDate.StartDate; i.Before(nhccDate.EndDate) || i.Equal(nhccDate.EndDate); i = i.AddDate(0, 0, 1) {
 			dateStr := i.Format(utils.FormatDate)
 			xValue, ok := aDataMap[dateStr]
@@ -512,13 +512,13 @@ func refreshAllPredictCalculateNhcc(to orm.TxOrmer, edbInfo, firstEdbInfo, secon
 				err = errors.New("指标B日期：" + dateStr + "数据异常，导致计算线性方程公式失败")
 				return
 			}
-			tmpCoordinate := Coordinate{
+			tmpCoordinate := utils.Coordinate{
 				X: xValue,
 				Y: yValue,
 			}
 			coordinateData = append(coordinateData, tmpCoordinate)
 		}
-		a, b = getLinearResult(coordinateData)
+		a, b = utils.GetLinearResult(coordinateData)
 	}
 
 	if math.IsNaN(a) || math.IsNaN(b) {
@@ -639,7 +639,7 @@ func refreshAllPredictCalculateNhcc(to orm.TxOrmer, edbInfo, firstEdbInfo, secon
 			err = tmpErr
 		}
 		return
-	}else{
+	} else {
 		latestDateStr = finalLast.DataTime
 		latestValue = finalLast.Value
 	}

models/predict_edb_info_rule.go

@@ -12,10 +12,9 @@ import (
 )
 
 // GetChartPredictEdbInfoDataListByRule1 根据规则1获取预测数据
-func GetChartPredictEdbInfoDataListByRule1(edbInfoId int, dataValue float64, startDate, endDate time.Time, frequency string, predictEdbInfoData []*EdbInfoSearchData, existMap map[string]float64) (newPredictEdbInfoData []*EdbInfoSearchData) {
+func GetChartPredictEdbInfoDataListByRule1(edbInfoId int, dataValue float64, dayList []time.Time, predictEdbInfoData []*EdbInfoSearchData, existMap map[string]float64) (newPredictEdbInfoData []*EdbInfoSearchData) {
 	newPredictEdbInfoData = predictEdbInfoData
 	//获取后面的预测数据
-	dayList := getPredictEdbDayList(startDate, endDate, frequency)
 	predictEdbInfoData = make([]*EdbInfoSearchData, 0)
 	for k, v := range dayList {
 		newPredictEdbInfoData = append(newPredictEdbInfoData, &EdbInfoSearchData{
@@ -31,7 +30,7 @@ func GetChartPredictEdbInfoDataListByRule1(edbInfoId int, dataValue float64, sta
 // GetChartPredictEdbInfoDataListByRuleTb 根据同比值规则获取预测数据
 // 2.1 同比: 在未来某一个时间段内，给定一个固定的同比增速a，用去年同期值X乘以同比增速(1+a)，得到预测值Y=X(1+a)
 // 例: 今年1-3月值，100，100，120。给定同比增速a=0.1，则明年1-3月预测值为: 100*1.1=110，100*1.1=110，120*1.1=132。
-func GetChartPredictEdbInfoDataListByRuleTb(edbInfoId int, tbValue float64, startDate, endDate time.Time, frequency string, realPredictEdbInfoData, predictEdbInfoData []*EdbInfoSearchData, existMap map[string]float64) (newPredictEdbInfoData []*EdbInfoSearchData, minValue, maxValue float64) {
+func GetChartPredictEdbInfoDataListByRuleTb(edbInfoId int, tbValue float64, dayList []time.Time, frequency string, realPredictEdbInfoData, predictEdbInfoData []*EdbInfoSearchData, existMap map[string]float64) (newPredictEdbInfoData []*EdbInfoSearchData, minValue, maxValue float64) {
 	allDataList := make([]*EdbInfoSearchData, 0)
 	allDataList = append(allDataList, realPredictEdbInfoData...)
 	allDataList = append(allDataList, predictEdbInfoData...)
@@ -39,7 +38,6 @@ func GetChartPredictEdbInfoDataListByRuleTb(edbInfoId int, tbValue float64, star
 
 	index := len(allDataList)
 	//获取后面的预测数据
-	dayList := getPredictEdbDayList(startDate, endDate, frequency)
 	predictEdbInfoData = make([]*EdbInfoSearchData, 0)
 	for k, currentDate := range dayList {
 
@@ -160,7 +158,7 @@ func PredictTbzDiv(a, b float64) (result float64) {
 // GetChartPredictEdbInfoDataListByRuleTc 根据同差值规则获取预测数据
 // 2.2 同差: 在未来某一个时间段内，给定一个固定的同比增加值a，用去年同期值X加上同比增加值A，得到预测值Y=X+a
 // 例: 今年1-3月值，100，100，120。给定同比增加值a=10，则明年1-3月预测值为: 100+10=110，100+10=110，120+10=130
-func GetChartPredictEdbInfoDataListByRuleTc(edbInfoId int, tcValue float64, startDate, endDate time.Time, frequency string, realPredictEdbInfoData, predictEdbInfoData []*EdbInfoSearchData, existMap map[string]float64) (newPredictEdbInfoData []*EdbInfoSearchData, minValue, maxValue float64) {
+func GetChartPredictEdbInfoDataListByRuleTc(edbInfoId int, tcValue float64, dayList []time.Time, frequency string, realPredictEdbInfoData, predictEdbInfoData []*EdbInfoSearchData, existMap map[string]float64) (newPredictEdbInfoData []*EdbInfoSearchData, minValue, maxValue float64) {
 	allDataList := make([]*EdbInfoSearchData, 0)
 	allDataList = append(allDataList, realPredictEdbInfoData...)
 	allDataList = append(allDataList, predictEdbInfoData...)
@@ -168,7 +166,6 @@ func GetChartPredictEdbInfoDataListByRuleTc(edbInfoId int, tcValue float64, star
 
 	index := len(allDataList)
 	//获取后面的预测数据
-	dayList := getPredictEdbDayList(startDate, endDate, frequency)
 	predictEdbInfoData = make([]*EdbInfoSearchData, 0)
 	for k, currentDate := range dayList {
 
@@ -283,7 +280,7 @@ func PredictTczDiv(a, b float64) (result float64) {
 // GetChartPredictEdbInfoDataListByRuleHb 根据环比值规则获取预测数据
 // 环比：在未来某一个时间段内，给定一个固定的环比增速a，用上一期值X乘以环比增速(1+a)，得到预测值Y=X(1+a)
 // 例: 最近1期值为100，给定环比增速a=0.2，则未来3期预测值为: 100*1.2=120，120*1.2=144，144*1.2=172.8
-func GetChartPredictEdbInfoDataListByRuleHb(edbInfoId int, hbValue float64, startDate, endDate time.Time, frequency string, realPredictEdbInfoData, predictEdbInfoData []*EdbInfoSearchData, existMap map[string]float64) (newPredictEdbInfoData []*EdbInfoSearchData, minValue, maxValue float64) {
+func GetChartPredictEdbInfoDataListByRuleHb(edbInfoId int, hbValue float64, dayList []time.Time, realPredictEdbInfoData, predictEdbInfoData []*EdbInfoSearchData, existMap map[string]float64) (newPredictEdbInfoData []*EdbInfoSearchData, minValue, maxValue float64) {
 	allDataList := make([]*EdbInfoSearchData, 0)
 	allDataList = append(allDataList, realPredictEdbInfoData...)
 	allDataList = append(allDataList, predictEdbInfoData...)
@@ -291,7 +288,6 @@ func GetChartPredictEdbInfoDataListByRuleHb(edbInfoId int, hbValue float64, star
 
 	index := len(allDataList)
 	//获取后面的预测数据
-	dayList := getPredictEdbDayList(startDate, endDate, frequency)
 	for k, currentDate := range dayList {
 		tmpK := index + k - 1 //上1期的值
 
@@ -347,7 +343,7 @@ func PredictHbzDiv(a, b float64) (result float64) {
 // GetChartPredictEdbInfoDataListByRuleHc 根据环差值规则获取预测数据
 // 2.4 环差：在未来某一个时间段内，给定一个固定的环比增加值a，用上一期值X加上环比增加值a，得到预测值Y=X+a
 // 例: 最近1期值为100，给定环比增加值a=10，则未来3期预测值为: 100+10=110，110+10=120，120+10=130
-func GetChartPredictEdbInfoDataListByRuleHc(edbInfoId int, hcValue float64, startDate, endDate time.Time, frequency string, realPredictEdbInfoData, predictEdbInfoData []*EdbInfoSearchData, existMap map[string]float64) (newPredictEdbInfoData []*EdbInfoSearchData, minValue, maxValue float64) {
+func GetChartPredictEdbInfoDataListByRuleHc(edbInfoId int, hcValue float64, dayList []time.Time, realPredictEdbInfoData, predictEdbInfoData []*EdbInfoSearchData, existMap map[string]float64) (newPredictEdbInfoData []*EdbInfoSearchData, minValue, maxValue float64) {
 	allDataList := make([]*EdbInfoSearchData, 0)
 	allDataList = append(allDataList, realPredictEdbInfoData...)
 	allDataList = append(allDataList, predictEdbInfoData...)
@@ -355,7 +351,6 @@ func GetChartPredictEdbInfoDataListByRuleHc(edbInfoId int, hcValue float64, star
 
 	index := len(allDataList)
 	//获取后面的预测数据
-	dayList := getPredictEdbDayList(startDate, endDate, frequency)
 	for k, currentDate := range dayList {
 		tmpK := index + k - 1 //上1期的值
 
@@ -405,7 +400,7 @@ func PredictHczDiv(a, b float64) (result float64) {
 // GetChartPredictEdbInfoDataListByRuleNMoveMeanValue 根据N期移动均值规则获取预测数据
 // 2.5 N期移动均值：在未来某一个时间段内，下一期值等于过去N期值得平均值。
 // 例：最近3期值(N=3),为95，98，105则未来第1期值为 1/3*(95+98+105)=99.33, 未来第2期值为 1/3*(98+105+99.33)=100.78依次类推。
-func GetChartPredictEdbInfoDataListByRuleNMoveMeanValue(edbInfoId int, nValue int, startDate, endDate time.Time, frequency string, realPredictEdbInfoData, predictEdbInfoData []*EdbInfoSearchData, existMap map[string]float64) (newPredictEdbInfoData []*EdbInfoSearchData, minValue, maxValue float64) {
+func GetChartPredictEdbInfoDataListByRuleNMoveMeanValue(edbInfoId int, nValue int, dayList []time.Time, realPredictEdbInfoData, predictEdbInfoData []*EdbInfoSearchData, existMap map[string]float64) (newPredictEdbInfoData []*EdbInfoSearchData, minValue, maxValue float64) {
 	allDataList := make([]*EdbInfoSearchData, 0)
 	allDataList = append(allDataList, realPredictEdbInfoData...)
 	allDataList = append(allDataList, predictEdbInfoData...)
@@ -422,7 +417,6 @@ func GetChartPredictEdbInfoDataListByRuleNMoveMeanValue(edbInfoId int, nValue in
 	decimalN := decimal.NewFromInt(int64(nValue))
 
 	//获取后面的预测数据
-	dayList := getPredictEdbDayList(startDate, endDate, frequency)
 	for k, currentDate := range dayList {
 		tmpIndex := lenAllData + k - 1 //上1期的值
 
@@ -463,7 +457,7 @@ func GetChartPredictEdbInfoDataListByRuleNMoveMeanValue(edbInfoId int, nValue in
 // 例1：过去5期值(N=5)分别为：3，5，7，9，11（每两期值之间的时间间隔相等）。那么按照线性回归方程推算，未来三期的预测值是：13，15，17。
 //
 // 例2：过去6期值(N=6)分别为：3，3，5，7，9，11（每两期值之间的时间间隔相等）。那么按照线性回归方程推算，未来三期的预测值是：12.33，14.05，15.76。例1和例2的区别在于，多加了一期数据，导致回归方程发生改变，从而预测值不同。
-func GetChartPredictEdbInfoDataListByRuleNLinearRegression(edbInfoId int, nValue int, startDate, endDate time.Time, frequency string, realPredictEdbInfoData, predictEdbInfoData []*EdbInfoSearchData, existMap map[string]float64) (newPredictEdbInfoData []*EdbInfoSearchData, minValue, maxValue float64, err error) {
+func GetChartPredictEdbInfoDataListByRuleNLinearRegression(edbInfoId int, nValue int, dayList []time.Time, realPredictEdbInfoData, predictEdbInfoData []*EdbInfoSearchData, existMap map[string]float64) (newPredictEdbInfoData []*EdbInfoSearchData, minValue, maxValue float64, err error) {
 	//var errMsg string
 	//defer func() {
 	//	if errMsg != `` {
@@ -486,16 +480,16 @@ func GetChartPredictEdbInfoDataListByRuleNLinearRegression(edbInfoId int, nValue
 
 	//获取后面的预测数据
 	// 获取线性方程公式的a、b的值
-	coordinateData := make([]Coordinate, 0)
+	coordinateData := make([]utils.Coordinate, 0)
 	for tmpK := nValue; tmpK > 0; tmpK-- {
 		tmpIndex2 := lenAllData - tmpK //上N期的值
-		tmpCoordinate := Coordinate{
+		tmpCoordinate := utils.Coordinate{
 			X: float64(nValue - tmpK + 1),
 			Y: allDataList[tmpIndex2].Value,
 		}
 		coordinateData = append(coordinateData, tmpCoordinate)
 	}
-	a, b := getLinearResult(coordinateData)
+	a, b := utils.GetLinearResult(coordinateData)
 	if math.IsNaN(a) || math.IsNaN(b) {
 		err = errors.New("线性方程公式生成失败")
 		return
@@ -504,7 +498,6 @@ func GetChartPredictEdbInfoDataListByRuleNLinearRegression(edbInfoId int, nValue
 
 	aDecimal := decimal.NewFromFloat(a)
 	bDecimal := decimal.NewFromFloat(b)
-	dayList := getPredictEdbDayList(startDate, endDate, frequency)
 	for k, currentDate := range dayList {
 		tmpK := nValue + k + 1
 
@@ -532,49 +525,6 @@ func GetChartPredictEdbInfoDataListByRuleNLinearRegression(edbInfoId int, nValue
 	return
 }
 
-// Series is a container for a series of data
-type Series []Coordinate
-
-// Coordinate holds the data in a series
-type Coordinate struct {
-	X, Y float64
-}
-
-func getLinearResult(s []Coordinate) (gradient, intercept float64) {
-	if len(s) <= 1 {
-		return
-	}
-
-	// Placeholder for the math to be done
-	var sum [5]float64
-
-	// Loop over data keeping index in place
-	i := 0
-	for ; i < len(s); i++ {
-		sum[0] += s[i].X
-		sum[1] += s[i].Y
-		sum[2] += s[i].X * s[i].X
-		sum[3] += s[i].X * s[i].Y
-		sum[4] += s[i].Y * s[i].Y
-	}
-
-	// Find gradient and intercept
-	f := float64(i)
-	gradient = (f*sum[3] - sum[0]*sum[1]) / (f*sum[2] - sum[0]*sum[0])
-	intercept = (sum[1] / f) - (gradient * sum[0] / f)
-
-	//fmt.Println("gradient:", gradient, ";intercept:", intercept)
-	// Create the new regression series
-	//for j := 0; j < len(s); j++ {
-	//	regressions = append(regressions, Coordinate{
-	//		X: s[j].X,
-	//		Y: s[j].X*gradient + intercept,
-	//	})
-	//}
-
-	return
-}
-
 //	GetChartPredictEdbInfoDataListByRuleTrendsHC 根据动态环比增加值的计算规则获取预测数据
 //
 // 研究员有对预测指标进行动态环差计算的需求，即预测指标使用环差规则进行预测时，环比增加值不是固定值，而是由几个预测指标计算得出的动态变化的值；
@@ -588,7 +538,7 @@ func getLinearResult(s []Coordinate) (gradient, intercept float64) {
 // 计算公式为B-C；
 // 则指标A至2022-10-29的预测值为2022-10-28（100+（240-260）=80）、2022-10-29（80+（300-310）=90）；
 // 注：动态环比增加值的计算遵从计算指标的计算规则，即用于计算的指标若有部分指标缺少部分日期数据，则这部分日期数据不做计算，为空；若动态环比增加值某一天为空，则往前追溯最近一期有值的环比增加值作为该天的数值参与计算；
-func GetChartPredictEdbInfoDataListByRuleTrendsHC(edbInfoId, configId int, startDate, endDate time.Time, frequency string, realPredictEdbInfoData, predictEdbInfoData []*EdbInfoSearchData, existMap map[string]float64) (newPredictEdbInfoData []*EdbInfoSearchData, minValue, maxValue float64) {
+func GetChartPredictEdbInfoDataListByRuleTrendsHC(edbInfoId int, dayList []time.Time, realPredictEdbInfoData, predictEdbInfoData []*EdbInfoSearchData, hcDataMap, existMap map[string]float64) (newPredictEdbInfoData []*EdbInfoSearchData, minValue, maxValue float64) {
 	allDataList := make([]*EdbInfoSearchData, 0)
 	allDataList = append(allDataList, realPredictEdbInfoData...)
 	allDataList = append(allDataList, predictEdbInfoData...)
@@ -599,17 +549,6 @@ func GetChartPredictEdbInfoDataListByRuleTrendsHC(edbInfoId, configId int, start
 		return
 	}
 
-	hcDataMap := make(map[string]float64) //规则计算的环差值map
-
-	tmpPredictEdbRuleDataList, err := GetPredictEdbRuleDataItemList(edbInfoId, configId, startDate.Format(utils.FormatDate), endDate.Format(utils.FormatDate))
-	if err != nil {
-		return
-	}
-	for _, v := range tmpPredictEdbRuleDataList {
-		hcDataMap[v.DataTime] = v.Value
-	}
-
-	dayList := getPredictEdbDayList(startDate, endDate, frequency)
 	for k, currentDate := range dayList {
 		// 最近一条数据
 		tmpLenAllDataList := len(allDataList)
@@ -658,7 +597,7 @@ func GetChartPredictEdbInfoDataListByRuleTrendsHC(edbInfoId, configId int, start
 // 需求说明：
 // 1、增加一个预测规则，名为“给定终值后插值”，给定预测截止日期和预测终值，计算最新数据日期至预测截止日期的时间差T，计算最新数据和预测终值的数据差S，数据频率与指标频度有关，日度=1，周度=7，旬度=10，月度=30，季度=90，年度=365，环差值=S/T*频率，预测数值=前一天数值+环差值；
 // 2、最新数据值和日期改动后，需重新计算环差值和预测数值；
-func GetChartPredictEdbInfoDataListByRuleFinalValueHc(edbInfoId int, finalValue float64, startDate, endDate time.Time, frequency string, realPredictEdbInfoData, predictEdbInfoData []*EdbInfoSearchData, existMap map[string]float64) (newPredictEdbInfoData []*EdbInfoSearchData, minValue, maxValue float64) {
+func GetChartPredictEdbInfoDataListByRuleFinalValueHc(edbInfoId int, finalValue float64, dayList []time.Time, realPredictEdbInfoData, predictEdbInfoData []*EdbInfoSearchData, existMap map[string]float64) (newPredictEdbInfoData []*EdbInfoSearchData, minValue, maxValue float64) {
 	allDataList := make([]*EdbInfoSearchData, 0)
 	allDataList = append(allDataList, realPredictEdbInfoData...)
 	allDataList = append(allDataList, predictEdbInfoData...)
@@ -666,7 +605,6 @@ func GetChartPredictEdbInfoDataListByRuleFinalValueHc(edbInfoId int, finalValue
 
 	index := len(allDataList)
 	//获取后面的预测日期
-	dayList := getPredictEdbDayList(startDate, endDate, frequency)
 	lenDay := len(dayList)
 	if lenDay <= 0 {
 		return
@@ -744,7 +682,7 @@ type SeasonConf struct {
 //
 // 计算2023.1.2预测值，求过去N年环差均值=[(300-200)+(220-210)+(260-250)]/3=40
 // 则2023.1.2预测值=2023.1.1值+过去N年环差均值
-func GetChartPredictEdbInfoDataListByRuleSeason(edbInfoId int, yearsList []int, calendar string, startDate, endDate time.Time, frequency string, realPredictEdbInfoData, predictEdbInfoData []*EdbInfoSearchData, existMap map[string]float64) (newPredictEdbInfoData []*EdbInfoSearchData, minValue, maxValue float64, err error) {
+func GetChartPredictEdbInfoDataListByRuleSeason(edbInfoId int, yearsList []int, calendar string, dayList []time.Time, realPredictEdbInfoData, predictEdbInfoData []*EdbInfoSearchData, existMap map[string]float64) (newPredictEdbInfoData []*EdbInfoSearchData, minValue, maxValue float64, err error) {
 	allDataList := make([]*EdbInfoSearchData, 0)
 	allDataList = append(allDataList, realPredictEdbInfoData...)
 	allDataList = append(allDataList, predictEdbInfoData...)
@@ -800,7 +738,6 @@ func GetChartPredictEdbInfoDataListByRuleSeason(edbInfoId int, yearsList []int,
 
 	index := len(allDataList)
 	//获取后面的预测日期
-	dayList := getPredictEdbDayList(startDate, endDate, frequency)
 
 	//获取后面的预测数据
 	predictEdbInfoData = make([]*EdbInfoSearchData, 0)
@@ -932,7 +869,7 @@ type MoveAverageConf struct {
 // 以此类推...
 // 计算2023.1.2预测值，求过去N年环差均值=[(200-200)+(250-210)+(270-250)]/3=16.67
 // 则2023.1.2预测值=2023.1.1值+过去N年环差均值
-func GetChartPredictEdbInfoDataListByRuleMoveAverageTb(edbInfoId int, nValue, year int, startDate, endDate time.Time, frequency string, realPredictEdbInfoData, predictEdbInfoData []*EdbInfoSearchData, existMap map[string]float64) (newPredictEdbInfoData []*EdbInfoSearchData, minValue, maxValue float64, err error) {
+func GetChartPredictEdbInfoDataListByRuleMoveAverageTb(edbInfoId int, nValue, year int, dayList []time.Time, realPredictEdbInfoData, predictEdbInfoData []*EdbInfoSearchData, existMap map[string]float64) (newPredictEdbInfoData []*EdbInfoSearchData, minValue, maxValue float64, err error) {
 	allDataList := make([]*EdbInfoSearchData, 0)
 	allDataList = append(allDataList, realPredictEdbInfoData...)
 	allDataList = append(allDataList, predictEdbInfoData...)
@@ -949,7 +886,6 @@ func GetChartPredictEdbInfoDataListByRuleMoveAverageTb(edbInfoId int, nValue, ye
 	decimalN := decimal.NewFromInt(int64(nValue))
 
 	//获取后面的预测数据
-	dayList := getPredictEdbDayList(startDate, endDate, frequency)
 	for k, currentDate := range dayList {
 		tmpLenAllDataList := len(allDataList)
 		tmpIndex := tmpLenAllDataList - 1 //上1期数据的下标
@@ -1061,3 +997,378 @@ func GetChartPredictEdbInfoDataListByRuleMoveAverageTb(edbInfoId int, nValue, ye
 	}
 	return
 }
+
+// GetChartPredictEdbInfoDataListByRuleTbzscz 根据 同比增速差值 规则获取预测数据
+// 同比增速差值计算方式:
+// 1、首先计算出所选指标实际最新日期值的同比增速：（本期数值-同期数值）÷同期数值*100%
+// 2、根据预测截止日期的同比增速终值、最新日期值的同比增速、与最新日期距离截止日期的期数，计算出到截止日期为止的每一期的同比增速。（等差规则计算每一期的同比增速，结合去年同期值，计算出每一期的同比预测值）。公差=（末项-首项）÷（n-1），an=a1+(n-1)d，（n为正整数，n大于等于2）
+// 3、根据去年同期值和未来每一期的同比增速值，求出同比预测值，同比预测值=同期值*(1+同比增速)
+// 同比增速差值：计算最新数据的同比增速（（本期数值-同期数值）÷同期数值*100%），结合同比增速终值与期数，计算每一期同比增速，进而求出同比预测值。
+//
+// 例：如上图所示指标，（1）最新日期值2022-12-31   141175 ，结合同期值，计算同比增速；
+// （2）同比增速终值，若为50%，    预测日期为2023-03-31，则根据（1）中的同比增速值与同比增速终值，计算出中间两期的同比增速；
+// （3）求出每一期的预测同比值，预测同比值=同期值*（1+同比增速）
+func GetChartPredictEdbInfoDataListByRuleTbzscz(edbInfoId int, tbEndValue float64, dayList []time.Time, frequency string, realPredictEdbInfoData, predictEdbInfoData []*EdbInfoSearchData, existMap map[string]float64) (newPredictEdbInfoData []*EdbInfoSearchData, minValue, maxValue float64) {
+	allDataList := make([]*EdbInfoSearchData, 0)
+	allDataList = append(allDataList, realPredictEdbInfoData...)
+	allDataList = append(allDataList, predictEdbInfoData...)
+	newPredictEdbInfoData = predictEdbInfoData
+
+	index := len(allDataList)
+
+	// 获取近期数据的同比值
+	if index <= 0 {
+		return
+	}
+	lastData := allDataList[index-1]
+	lastDayTime, _ := time.ParseInLocation(utils.FormatDate, lastData.DataTime, time.Local)
+
+	var lastTb decimal.Decimal // 计算最新数据与上一期的数据同比值
+	{
+		//上一年的日期
+		preDate := lastDayTime.AddDate(-1, 0, 0)
+		preDateStr := preDate.Format(utils.FormatDate)
+		if preValue, ok := existMap[preDateStr]; ok { //上一年同期找到
+			lastTb = decimal.NewFromFloat(lastData.Value).Div(decimal.NewFromFloat(preValue))
+		} else {
+			switch frequency {
+			case "月度":
+				//向上和向下，各找一个月
+				nextDateDay := preDate
+				preDateDay := preDate
+				for i := 0; i <= 35; i++ {
+					nextDateDayStr := nextDateDay.Format(utils.FormatDate)
+					if preValue, ok := existMap[nextDateDayStr]; ok { //上一年同期->下一个月找到
+						lastTb = decimal.NewFromFloat(lastData.Value).Div(decimal.NewFromFloat(preValue))
+						break
+					} else {
+						preDateDayStr := preDateDay.Format(utils.FormatDate)
+						if preValue, ok := existMap[preDateDayStr]; ok { //上一年同期->上一个月找到
+							lastTb = decimal.NewFromFloat(lastData.Value).Div(decimal.NewFromFloat(preValue))
+							break
+						}
+					}
+					nextDateDay = nextDateDay.AddDate(0, 0, 1)
+					preDateDay = preDateDay.AddDate(0, 0, -1)
+				}
+
+			case "季度", "年度":
+				if preValue, ok := existMap[preDateStr]; ok { //上一年同期->下一个月找到
+					lastTb = decimal.NewFromFloat(lastData.Value).Div(decimal.NewFromFloat(preValue))
+					break
+				}
+			default:
+				nextDateDay := preDate
+				preDateDay := preDate
+
+				for i := 0; i < 35; i++ {
+					nextDateDayStr := nextDateDay.Format(utils.FormatDate)
+					if preValue, ok := existMap[nextDateDayStr]; ok { //上一年同期->下一个月找到
+						lastTb = decimal.NewFromFloat(lastData.Value).Div(decimal.NewFromFloat(preValue))
+						break
+					} else {
+						preDateDayStr := preDateDay.Format(utils.FormatDate)
+						if preValue, ok := existMap[preDateDayStr]; ok { //上一年同期->上一个月找到
+							lastTb = decimal.NewFromFloat(lastData.Value).Div(decimal.NewFromFloat(preValue))
+							break
+						} else {
+							//fmt.Println("pre not find:", preDateStr, "i:", i)
+						}
+					}
+					nextDateDay = nextDateDay.AddDate(0, 0, 1)
+					preDateDay = preDateDay.AddDate(0, 0, -1)
+				}
+			}
+		}
+	}
+
+	//获取后面的预测数据
+	lenDay := len(dayList)
+	tbEndValueDecimal := decimal.NewFromFloat(tbEndValue)
+	avgTbVal := tbEndValueDecimal.Sub(lastTb).Div(decimal.NewFromInt(int64(lenDay)))
+
+	fmt.Println(lastTb.Float64())
+	fmt.Println(decimal.NewFromFloat(tbEndValue).Sub(lastTb))
+	fmt.Println(avgTbVal.Float64())
+
+	predictEdbInfoData = make([]*EdbInfoSearchData, 0)
+	for k, currentDate := range dayList {
+		var tbValue decimal.Decimal
+		if k == lenDay-1 { // 如果是最后的日期了，那么就用终值去计算
+			tbValue = tbEndValueDecimal
+		} else { // 最近数据的同比值 + （平均增值乘以当前期数）
+			tbValue = lastTb.Add(avgTbVal.Mul(decimal.NewFromInt(int64(k + 1))))
+		}
+		tmpData := &EdbInfoSearchData{
+			EdbDataId: edbInfoId + 100000 + index + k,
+			//EdbInfoId: edbInfoId,
+			DataTime: currentDate.Format(utils.FormatDate),
+			//Value:         dataValue,
+			//DataTimestamp: (currentDate.UnixNano() / 1e6) + 1000, //前端需要让加1s，说是2022-09-01 00:00:00 这样的整点不合适
+		}
+
+		var val float64
+		var calculateStatus bool //计算结果
+		//currentItem := existMap[av]
+		//上一年的日期
+		preDate := currentDate.AddDate(-1, 0, 0)
+		preDateStr := preDate.Format(utils.FormatDate)
+		if preValue, ok := existMap[preDateStr]; ok { //上一年同期找到
+			val, _ = decimal.NewFromFloat(preValue).Mul(tbValue).RoundCeil(4).Float64()
+			calculateStatus = true
+		} else {
+			switch frequency {
+			case "月度":
+				//向上和向下，各找一个月
+				nextDateDay := preDate
+				preDateDay := preDate
+				for i := 0; i <= 35; i++ {
+					nextDateDayStr := nextDateDay.Format(utils.FormatDate)
+					if preValue, ok := existMap[nextDateDayStr]; ok { //上一年同期->下一个月找到
+						val, _ = decimal.NewFromFloat(preValue).Mul(tbValue).RoundCeil(4).Float64()
+						calculateStatus = true
+						break
+					} else {
+						preDateDayStr := preDateDay.Format(utils.FormatDate)
+						if preValue, ok := existMap[preDateDayStr]; ok { //上一年同期->上一个月找到
+							val, _ = decimal.NewFromFloat(preValue).Mul(tbValue).RoundCeil(4).Float64()
+							calculateStatus = true
+							break
+						}
+					}
+					nextDateDay = nextDateDay.AddDate(0, 0, 1)
+					preDateDay = preDateDay.AddDate(0, 0, -1)
+				}
+
+			case "季度", "年度":
+				if preValue, ok := existMap[preDateStr]; ok { //上一年同期->下一个月找到
+					val, _ = decimal.NewFromFloat(preValue).Mul(tbValue).RoundCeil(4).Float64()
+					calculateStatus = true
+					break
+				}
+			default:
+				nextDateDay := preDate
+				preDateDay := preDate
+
+				for i := 0; i < 35; i++ {
+					nextDateDayStr := nextDateDay.Format(utils.FormatDate)
+					if preValue, ok := existMap[nextDateDayStr]; ok { //上一年同期->下一个月找到
+						val, _ = decimal.NewFromFloat(preValue).Mul(tbValue).RoundCeil(4).Float64()
+						calculateStatus = true
+						break
+					} else {
+						preDateDayStr := preDateDay.Format(utils.FormatDate)
+						if preValue, ok := existMap[preDateDayStr]; ok { //上一年同期->上一个月找到
+							val, _ = decimal.NewFromFloat(preValue).Mul(tbValue).RoundCeil(4).Float64()
+							calculateStatus = true
+							break
+						} else {
+							//fmt.Println("pre not find:", preDateStr, "i:", i)
+						}
+					}
+					nextDateDay = nextDateDay.AddDate(0, 0, 1)
+					preDateDay = preDateDay.AddDate(0, 0, -1)
+				}
+			}
+		}
+
+		if calculateStatus {
+			tmpData.Value = val
+			newPredictEdbInfoData = append(newPredictEdbInfoData, tmpData)
+			allDataList = append(allDataList, tmpData)
+			existMap[tmpData.DataTime] = val
+
+			// 最大最小值
+			if val < minValue {
+				minValue = val
+			}
+			if val > maxValue {
+				maxValue = val
+			}
+		}
+	}
+	return
+}
+
+// RuleLineNhConf 一元线性拟合规则的配置
+type RuleLineNhConf struct {
+	StartDate string `description:"开始日期"`
+	EndDate   string `description:"结束日期"`
+	MoveDay   int    `description:"移动天数"`
+	EdbInfoId int    `description:"指标id"`
+}
+
+//	GetChartPredictEdbInfoDataListByRuleLineNh 根据 一元线性拟合 的计算规则获取预测数据
+//
+// 选择被预测的指标B（作为自变量，非预测指标），选择指标A（作为因变量，可以是基础指标和预测指标）
+// 2、选择拟合时间段，起始日期至今或指定时间段，选择至今，在计算时截止到指标B的最新日期
+// 3、设定A领先B时间（天），正整数、负整数、0
+// 4、调用拟合残差的数据预处理和算法，给出拟合方程Y=aX+b的系数a，b
+// 5、指标A代入拟合方程得到拟合预测指标B'，拟合预测指标使用指标B的频度，在指标B的实际值后面连接拟合预测指标B'对应日期的预测值
+//
+// 注：选择预测截止日期，若所选日期  ≤  指标A设置领先后的日期序列，则预测指标日期最新日期有值（在指标B'的有值范围内）；若所选日期 ＞ 指标A设置领先后的日期序列，则预测指标只到指标A领先后的日期序列（超出指标B'的有值范围，最多到指标B'的最新值）；指标A、B更新后，更新预测指标
+func GetChartPredictEdbInfoDataListByRuleLineNh(edbInfoId int, dayList []time.Time, realPredictEdbInfoData, predictEdbInfoData []*EdbInfoSearchData, newNhccDataMap, existMap map[string]float64) (newPredictEdbInfoData []*EdbInfoSearchData, minValue, maxValue float64, err error) {
+	allDataList := make([]*EdbInfoSearchData, 0)
+	allDataList = append(allDataList, realPredictEdbInfoData...)
+	allDataList = append(allDataList, predictEdbInfoData...)
+	newPredictEdbInfoData = predictEdbInfoData
+
+	lenAllData := len(allDataList)
+	if lenAllData <= 0 {
+		return
+	}
+
+	for k, currentDate := range dayList {
+		// 动态拟合残差值数据
+		currentDateStr := currentDate.Format(utils.FormatDate)
+		val, ok := newNhccDataMap[currentDateStr]
+		if !ok {
+			continue
+		}
+		tmpData := &EdbInfoSearchData{
+			EdbDataId: edbInfoId + 100000 + lenAllData + k,
+			//EdbInfoId:     edbInfoId,
+			DataTime: currentDateStr,
+			Value:    val,
+			//DataTimestamp: (currentDate.UnixNano() / 1e6) + 1000, //前端需要让加1s，说是2022-09-01 00:00:00 这样的整点不合适
+		}
+		newPredictEdbInfoData = append(newPredictEdbInfoData, tmpData)
+		allDataList = append(allDataList, tmpData)
+		existMap[currentDateStr] = val
+
+		// 最大最小值
+		if val < minValue {
+			minValue = val
+		}
+		if val > maxValue {
+			maxValue = val
+		}
+	}
+	return
+}
+
+// getCalculateNhccData 获取计算出来的 拟合残差 数据
+func getCalculateNhccData(secondDataList []*EdbInfoSearchData, ruleConf RuleLineNhConf) (newBDataMap map[string]float64, err error) {
+	firstEdbInfoId := ruleConf.EdbInfoId
+	moveDay := ruleConf.MoveDay
+	startDate, _ := time.ParseInLocation(utils.FormatDate, ruleConf.StartDate, time.Local)
+	endDate, _ := time.ParseInLocation(utils.FormatDate, ruleConf.EndDate, time.Local)
+
+	//查询当前指标现有的数据
+	edbInfo, err := GetEdbInfoById(firstEdbInfoId)
+	if err != nil {
+		return
+	}
+
+	//第一个指标
+	aDataList := make([]EdbInfoSearchData, 0)
+	aDataMap := make(map[string]float64)
+	{
+		//第一个指标的数据列表
+		var firstDataList []*EdbInfoSearchData
+		switch edbInfo.EdbInfoType {
+		case 0:
+			var condition string
+			var pars []interface{}
+			condition += " AND edb_info_id=? "
+			pars = append(pars, edbInfo.EdbInfoId)
+
+			//获取来源指标的数据
+			firstDataList, err = GetEdbDataListAll(condition, pars, edbInfo.Source, 1)
+		case 1:
+			firstDataList, err = GetPredictEdbDataListAllByStartDate(edbInfo, 1, "")
+		default:
+			err = errors.New(fmt.Sprint("获取失败,指标类型异常", edbInfo.EdbInfoType))
+		}
+		if err != nil {
+			return
+		}
+		aDataList, aDataMap = handleNhccData(firstDataList, moveDay)
+
+	}
+
+	//第二个指标
+	bDataList := make([]EdbInfoSearchData, 0)
+	bDataMap := make(map[string]float64)
+	{
+		bDataList, bDataMap = handleNhccData(secondDataList, 0)
+	}
+
+	if len(aDataList) <= 0 {
+		err = errors.New("指标A没有数据")
+		return
+	}
+	if len(bDataList) <= 0 {
+		err = errors.New("指标B没有数据")
+		return
+	}
+	// 拟合残差计算的结束日期判断
+	{
+		endAData := aDataList[len(aDataList)-1]
+		tmpEndDate, tmpErr := time.ParseInLocation(utils.FormatDate, endAData.DataTime, time.Local)
+		if tmpErr != nil {
+			err = tmpErr
+			return
+		}
+		// 如果A指标的最新数据日期早于拟合残差的结束日期，那么就用A指标的最新数据日期
+		if tmpEndDate.Before(endDate) {
+			endDate = tmpEndDate
+		}
+		endBData := bDataList[len(bDataList)-1]
+		tmpEndDate, tmpErr = time.ParseInLocation(utils.FormatDate, endBData.DataTime, time.Local)
+		if tmpErr != nil {
+			err = tmpErr
+			return
+		}
+		// 如果B指标的最新数据日期早于拟合残差的结束日期，那么就用A指标的最新数据日期
+		if tmpEndDate.Before(endDate) {
+			endDate = tmpEndDate
+		}
+	}
+
+	// 计算线性方程公式
+	var a, b float64
+	{
+		coordinateData := make([]utils.Coordinate, 0)
+		for i := startDate; i.Before(endDate) || i.Equal(endDate); i = i.AddDate(0, 0, 1) {
+			dateStr := i.Format(utils.FormatDate)
+			xValue, ok := aDataMap[dateStr]
+			if !ok {
+				err = errors.New("指标A日期：" + dateStr + "数据异常，导致计算线性方程公式失败")
+				return
+			}
+			yValue, ok := bDataMap[dateStr]
+			if !ok {
+				err = errors.New("指标B日期：" + dateStr + "数据异常，导致计算线性方程公式失败")
+				return
+			}
+			tmpCoordinate := utils.Coordinate{
+				X: xValue,
+				Y: yValue,
+			}
+			coordinateData = append(coordinateData, tmpCoordinate)
+		}
+		a, b = utils.GetLinearResult(coordinateData)
+	}
+
+	if math.IsNaN(a) || math.IsNaN(b) {
+		err = errors.New("线性方程公式生成失败")
+		return
+	}
+	//fmt.Println("a:", a, ";======b:", b)
+
+	//计算B’
+	newBDataMap = make(map[string]float64)
+	{
+		//B’=aA+b
+		aDecimal := decimal.NewFromFloat(a)
+		bDecimal := decimal.NewFromFloat(b)
+		for _, aData := range aDataList {
+			xDecimal := decimal.NewFromFloat(aData.Value)
+			val, _ := aDecimal.Mul(xDecimal).Add(bDecimal).RoundCeil(4).Float64()
+			newBDataMap[aData.DataTime] = val
+		}
+
+	}
+	return
+}