feat:新增动态环差预测

models/tables/predict_edb_conf_calculate_mapping/predict_edb_conf_calculate_mapping.go

@@ -0,0 +1,55 @@
+package predict_edb_conf_calculate_mapping
+
+import (
+	"time"
+)
+
+// PredictEdbConfCalculateMapping 预测基础指标规则 与 计算预测指标关联关系表
+type PredictEdbConfCalculateMapping struct {
+	PredictEdbConfCalculateMappingID int       `gorm:"primaryKey;column:predict_edb_conf_calculate_mapping_id;type:int(11);not null" json:"-"`
+	EdbInfoID                        uint32    `gorm:"column:edb_info_id;type:int(11) unsigned;default:0" json:"edbInfoId"`                                // 预测指标id
+	ConfigID                         int       `gorm:"uniqueIndex:idx_config_from_id;column:config_id;type:int(11);default:0" json:"configId"`             // 指标id
+	FromEdbInfoID                    int       `gorm:"uniqueIndex:idx_config_from_id;column:from_edb_info_id;type:int(11);default:0" json:"fromEdbInfoId"` // 来源指标id
+	FromEdbCode                      string    `gorm:"column:from_edb_code;type:varchar(50);default:''" json:"fromEdbCode"`                                // 来源指标编码
+	FromEdbName                      string    `gorm:"column:from_edb_name;type:varchar(255);default:''" json:"fromEdbName"`                               // 来源指标名称
+	FromSource                       int8      `gorm:"column:from_source;type:tinyint(4);default:0" json:"fromSource"`                                     // 来源指标渠道
+	FromSourceName                   string    `gorm:"column:from_source_name;type:varchar(100);default:''" json:"fromSourceName"`                         // 来源指标渠道名称
+	Sort                             int8      `gorm:"column:sort;type:tinyint(4);default:0" json:"sort"`                                                  // 顺序
+	CreateTime                       time.Time `gorm:"column:create_time;type:datetime" json:"createTime"`                                                 // 创建时间
+	ModifyTime                       time.Time `gorm:"column:modify_time;type:datetime" json:"modifyTime"`                                                 // 修改时间
+	FromTag                          string    `gorm:"column:from_tag;type:varchar(10);default:''" json:"fromTag"`                                         // 标签
+}
+
+// TableName get sql table name.获取数据库表名
+func (m *PredictEdbConfCalculateMapping) TableName() string {
+	return "predict_edb_conf_calculate_mapping"
+}
+
+// PredictEdbConfCalculateMappingColumns get sql column name.获取数据库列名
+var PredictEdbConfCalculateMappingColumns = struct {
+	PredictEdbConfCalculateMappingID string
+	EdbInfoID                        string
+	ConfigID                         string
+	FromEdbInfoID                    string
+	FromEdbCode                      string
+	FromEdbName                      string
+	FromSource                       string
+	FromSourceName                   string
+	Sort                             string
+	CreateTime                       string
+	ModifyTime                       string
+	FromTag                          string
+}{
+	PredictEdbConfCalculateMappingID: "predict_edb_conf_calculate_mapping_id",
+	EdbInfoID:                        "edb_info_id",
+	ConfigID:                         "config_id",
+	FromEdbInfoID:                    "from_edb_info_id",
+	FromEdbCode:                      "from_edb_code",
+	FromEdbName:                      "from_edb_name",
+	FromSource:                       "from_source",
+	FromSourceName:                   "from_source_name",
+	Sort:                             "sort",
+	CreateTime:                       "create_time",
+	ModifyTime:                       "modify_time",
+	FromTag:                          "from_tag",
+}

models/tables/predict_edb_conf_calculate_mapping/query.go

@@ -0,0 +1,35 @@
+package predict_edb_conf_calculate_mapping
+
+import (
+	"hongze/hongze_yb/global"
+	"time"
+)
+
+// GetPredictEdbRuleDataList 根据基础预测指标id集合 获取 所有的普通指标列表数据
+func GetPredictEdbRuleDataList(fromEdbInfoIdList []int) (items []*PredictEdbConfCalculateMappingDetail, err error) {
+	sql := ` SELECT a.predict_edb_conf_calculate_mapping_id,a.edb_info_id,a.from_edb_info_id,a.from_edb_code,a.from_source,a.from_source_name,a.sort,a.create_time,a.modify_time,a.from_tag,b.edb_name_source as from_edb_name,b.start_date,b.end_date,b.edb_type,b.edb_code FROM predict_edb_conf_calculate_mapping AS a
+			INNER JOIN edb_info AS b ON a.from_edb_info_id=b.edb_info_id
+			WHERE a.edb_info_id in (?) GROUP BY a.edb_info_id ORDER BY sort ASC `
+
+	err = global.MYSQL["data"].Raw(sql, fromEdbInfoIdList).Scan(&items).Error
+	return
+}
+
+type PredictEdbConfCalculateMappingDetail struct {
+	PredictEdbConfCalculateMappingId int       `orm:"column(predict_edb_conf_calculate_mapping_id);pk"`
+	EdbInfoId                        int       `description:"指标id"`
+	ConfigId                         int       `description:"配置id"`
+	FromEdbInfoId                    int       `description:"基础指标id"`
+	FromEdbCode                      string    `description:"基础指标编码"`
+	FromEdbName                      string    `description:"基础指标名称"`
+	FromSource                       int       `description:"基础指标来源"`
+	FromSourceName                   string    `description:"基础指标来源名称"`
+	FromTag                          string    `description:"来源指标标签"`
+	Sort                             int       `description:"计算指标名称排序"`
+	CreateTime                       time.Time `description:"创建时间"`
+	ModifyTime                       time.Time `description:"修改时间"`
+	StartDate                        string    `description:"开始日期"`
+	EndDate                          string    `description:"结束日期"`
+	EdbType                          int       `description:"指标类型:1:基础指标,2:计算指标"`
+	EdbCode                          string    `description:"指标code"`
+}

models/tables/predict_edb_rule_data/predict_edb_rule_data.go

@@ -0,0 +1,43 @@
+package predict_edb_rule_data
+
+import (
+	"time"
+)
+
+// PredictEdbRuleData 预测指标，动态规则的计算数据
+type PredictEdbRuleData struct {
+	PredictEdbRuleDataID int       `gorm:"primaryKey;column:predict_edb_rule_data_id;type:int(11);not null" json:"-"`
+	EdbInfoID            uint32    `gorm:"column:edb_info_id;type:int(9) unsigned;default:0" json:"edbInfoId"`                               // 预测指标id
+	ConfigID             int       `gorm:"uniqueIndex:idx_config_id_date;index:idx_config_id;column:config_id;type:int(11)" json:"configId"` // 配置id
+	DataTime             time.Time `gorm:"uniqueIndex:idx_config_id_date;column:data_time;type:date" json:"dataTime"`                        // 数据日期
+	Value                float64   `gorm:"column:value;type:decimal(38,4)" json:"value"`                                                     // 数据值
+	CreateTime           time.Time `gorm:"column:create_time;type:datetime" json:"createTime"`                                               // 创建时间
+	ModifyTime           time.Time `gorm:"column:modify_time;type:datetime" json:"modifyTime"`                                               // 修改时间
+	DataTimestamp        int64     `gorm:"column:data_timestamp;type:bigint(20);default:0" json:"dataTimestamp"`                             // 数据日期时间戳
+}
+
+// TableName get sql table name.获取数据库表名
+func (m *PredictEdbRuleData) TableName() string {
+	return "predict_edb_rule_data"
+}
+
+// PredictEdbRuleDataColumns get sql column name.获取数据库列名
+var PredictEdbRuleDataColumns = struct {
+	PredictEdbRuleDataID string
+	EdbInfoID            string
+	ConfigID             string
+	DataTime             string
+	Value                string
+	CreateTime           string
+	ModifyTime           string
+	DataTimestamp        string
+}{
+	PredictEdbRuleDataID: "predict_edb_rule_data_id",
+	EdbInfoID:            "edb_info_id",
+	ConfigID:             "config_id",
+	DataTime:             "data_time",
+	Value:                "value",
+	CreateTime:           "create_time",
+	ModifyTime:           "modify_time",
+	DataTimestamp:        "data_timestamp",
+}

models/tables/predict_edb_rule_data/query.go

@@ -0,0 +1,19 @@
+package predict_edb_rule_data
+
+import "hongze/hongze_yb/global"
+
+// GetPredictEdbRuleDataList 根据基础预测指标id集合 获取 所有的普通指标列表数据
+func GetPredictEdbRuleDataList(edbInfoId, configId int, startDate, endDate string) (list []*PredictEdbRuleData, err error) {
+	var whereStr string
+	var pars []interface{}
+	if startDate != "" {
+		whereStr += ` AND data_time>=? `
+		pars = append(pars, startDate)
+	}
+	if endDate != "" {
+		whereStr += ` AND data_time<=? `
+		pars = append(pars, endDate)
+	}
+	err = global.MYSQL["data"].Where("edb_info_id = ? AND config_id = ? ", edbInfoId, configId, pars).Order("data_time ASC").Find(&list).Error
+	return
+}

services/chart/chart_info.go

@@ -712,7 +712,7 @@ func ChartInfoRefreshV2(chartInfoId int) (err error) {
 	}
 
 	// 批量刷新
-	err = EdbInfoRefreshAllFromBase(edbIdList, false)
+	err, errmsg = EdbInfoRefreshAllFromBase(edbIdList, false)
 	if err != nil {
 		return
 	}

services/chart/edb_data.go

@@ -67,6 +67,8 @@ func RefreshEdbData(edbInfoId, source int, edbCode, startDate string) (resp *Ref
 		urlStr = "mysteel_chemical/refresh"
 	case utils.DATA_SOURCE_EIA_STEO:
 		urlStr = "eia_steo/refresh"
+	case utils.DATA_SOURCE_PREDICT:
+		urlStr = "predict/refresh"
 	}
 	if urlStr == "" {
 		err = fmt.Errorf(fmt.Sprint("source:", source, ";未实现该指标的刷新接口，请联系管理员"))

services/chart/edb_info.go

@@ -4,6 +4,7 @@ import (
 	"errors"
 	"fmt"
 	edbInfoModel "hongze/hongze_yb/models/tables/edb_info"
+	predictEdbConfCalculateMappingModel "hongze/hongze_yb/models/tables/predict_edb_conf_calculate_mapping"
 	"hongze/hongze_yb/services/alarm_msg"
 	"hongze/hongze_yb/utils"
 	"sort"
@@ -14,8 +15,7 @@ import (
 // @author Roc
 // @datetime 2022-09-16 11:04:44
 // @description 将原有的单个指标刷新，调整为批量多个指标刷新
-func EdbInfoRefreshAllFromBase(edbInfoIdList []int, refreshAll bool) (err error) {
-	var errmsg string
+func EdbInfoRefreshAllFromBase(edbInfoIdList []int, refreshAll bool) (err error, errmsg string) {
 	defer func() {
 		if err != nil {
 			fmt.Println("EdbInfoRefreshAllFromBaseV2 Err:" + err.Error() + ";errmsg:" + errmsg)
@@ -25,7 +25,7 @@ func EdbInfoRefreshAllFromBase(edbInfoIdList []int, refreshAll bool) (err error)
 	}()
 
 	// 获取关联的基础指标
-	newBaseEdbInfoArr, newCalculateMap, newPredictCalculateMap, calculateArr, predictCalculateArr, err, errmsg := getRefreshEdbInfoListByIds(edbInfoIdList)
+	newBaseEdbInfoArr, newBasePredictEdbInfoArr, newCalculateMap, newPredictCalculateMap, calculateArr, predictCalculateArr, err, errmsg := getRefreshEdbInfoListByIds(edbInfoIdList)
 	if err != nil {
 		return
 	}
@@ -62,16 +62,18 @@ func EdbInfoRefreshAllFromBase(edbInfoIdList []int, refreshAll bool) (err error)
 			}
 			startDate = sTime.AddDate(0, 0, -limitDay).Format(utils.FormatDate)
 		}
-		result, err := RefreshEdbData(bv.EdbInfoId, bv.Source, bv.EdbCode, startDate)
-		if err != nil {
+		result, tmpErr := RefreshEdbData(bv.EdbInfoId, bv.Source, bv.EdbCode, startDate)
+		if tmpErr != nil {
+			err = tmpErr
 			fmt.Println(bv.EdbInfoId, "RefreshBaseEdbData err", time.Now())
 			errmsg = "RefreshBaseEdbData Err:" + err.Error()
-			return err
+			return
 		}
 		if result.Ret != 200 {
 			fmt.Println(bv.EdbInfoId, "RefreshBaseEdbData err;msg:", result.Msg, ";errMsg:", result.ErrMsg)
 			errmsg = fmt.Sprint(bv.EdbInfoId, "RefreshBaseEdbData err;msg:", result.Msg, ";errMsg:", result.ErrMsg)
-			return fmt.Errorf("刷新失败, err:", errmsg)
+			err = fmt.Errorf("刷新失败, err:", errmsg)
+			return
 		}
 
 		//maxAndMinItem, err := data_manage.GetEdbInfoMaxAndMinInfo(source, edbCode)
@@ -94,7 +96,7 @@ func EdbInfoRefreshAllFromBase(edbInfoIdList []int, refreshAll bool) (err error)
 	for _, v := range calculateArr {
 		edbInfo := newCalculateMap[v]
 		if edbInfo == nil {
-			return err
+			return
 		}
 		startDate = edbInfo.StartDate.Format(utils.FormatDate)
 		source := edbInfo.Source
@@ -128,16 +130,18 @@ func EdbInfoRefreshAllFromBase(edbInfoIdList []int, refreshAll bool) (err error)
 			}
 		}
 
-		result, err := RefreshEdbCalculateData(edbInfo.EdbInfoId, edbInfo.EdbCode, startDate)
-		if err != nil {
+		result, tmpErr := RefreshEdbCalculateData(edbInfo.EdbInfoId, edbInfo.EdbCode, startDate)
+		if tmpErr != nil {
+			err = tmpErr
 			fmt.Println(v, "RefreshEdbCalculateData err", time.Now())
 			errmsg = "RefreshEdbCalculateData Err:" + err.Error()
-			return err
+			return
 		}
 		if result.Ret != 200 {
 			fmt.Println(v, "RefreshEdbCalculateData err;msg:", result.Msg, ";errMsg:", result.ErrMsg)
 			errmsg = fmt.Sprint(v, "RefreshEdbCalculateData err;msg:", result.Msg, ";errMsg:", result.ErrMsg)
-			return fmt.Errorf("刷新失败")
+			err = fmt.Errorf("刷新失败")
+			return
 		}
 	}
 
@@ -145,7 +149,7 @@ func EdbInfoRefreshAllFromBase(edbInfoIdList []int, refreshAll bool) (err error)
 	for _, v := range predictCalculateArr {
 		edbInfo := newPredictCalculateMap[v]
 		if edbInfo == nil {
-			return err
+			return
 		}
 		startDate = edbInfo.StartDate.Format(utils.FormatDate)
 		source := edbInfo.Source
@@ -179,23 +183,110 @@ func EdbInfoRefreshAllFromBase(edbInfoIdList []int, refreshAll bool) (err error)
 			}
 		}
 
-		result, err := RefreshPredictEdbCalculateData(edbInfo.EdbInfoId, edbInfo.EdbCode, startDate)
-		if err != nil {
+		result, tmpErr := RefreshPredictEdbCalculateData(edbInfo.EdbInfoId, edbInfo.EdbCode, startDate)
+		if tmpErr != nil {
+			err = tmpErr
+			fmt.Println(v, "RefreshPredictEdbCalculateData err", time.Now())
+			errmsg = "RefreshPredictEdbCalculateData Err:" + err.Error()
+			return
+		}
+		if result.Ret != 200 {
+			fmt.Println(v, "RefreshPredictEdbCalculateData err;msg:", result.Msg, ";errMsg:", result.ErrMsg)
+			errmsg = fmt.Sprint(v, "RefreshPredictEdbCalculateData err;msg:", result.Msg, ";errMsg:", result.ErrMsg)
+			err = fmt.Errorf("刷新失败")
+			return
+		}
+	}
+
+	// 4、更新动态环差值
+	{
+		predictEdbInfoIdList := make([]int, 0)
+		for _, v := range newBasePredictEdbInfoArr {
+			predictEdbInfoIdList = append(predictEdbInfoIdList, v.EdbInfoId)
+		}
+		fmt.Println("predictEdbConfCalculateMappingDetailList:", predictEdbInfoIdList)
+		predictEdbConfCalculateMappingDetailList, tmpErr := predictEdbConfCalculateMappingModel.GetPredictEdbRuleDataList(predictEdbInfoIdList)
+		if tmpErr != nil {
+			err = tmpErr
+			errmsg = fmt.Sprint("更新动态环差值时，获取数据失败:" + err.Error())
+			return
+		}
+		for _, bv := range predictEdbConfCalculateMappingDetailList {
+			result, tmpErr := RefreshEdbData(bv.EdbInfoId, utils.DATA_SOURCE_PREDICT, bv.EdbCode, "")
+			if tmpErr != nil {
+				err = tmpErr
+				fmt.Println(bv.EdbInfoId, "RefreshBasePredictEdbData err", time.Now())
+				errmsg = "RefreshBasePredictEdbData Err:" + err.Error()
+				return
+			}
+			if result.Ret != 200 {
+				fmt.Println(bv.EdbInfoId, "RefreshBasePredictEdbData err;msg:", result.Msg, ";errMsg:", result.ErrMsg)
+				errmsg = fmt.Sprint(bv.EdbInfoId, "RefreshBasePredictEdbData err;msg:", result.Msg, ";errMsg:", result.ErrMsg)
+				err = errors.New("刷新失败:" + errmsg)
+				return
+			}
+			fmt.Println("end predictEdbConfCalculateMappingDetailList:", bv, time.Now())
+		}
+	}
+
+	//5、刷新相关预测计算指标
+	for _, v := range predictCalculateArr {
+		edbInfo := newPredictCalculateMap[v]
+		if edbInfo == nil {
+			return
+		}
+		startDate = edbInfo.StartDate.Format(utils.FormatDate)
+		source := edbInfo.Source
+		if edbInfo.StartDate.IsZero() { //如果没有开始日期，说明还没有计算出来数据，那么就往前面推40年吧（也意味着重新计算了）
+			startDate = time.Now().AddDate(-40, 0, 0).Format(utils.FormatDate)
+		} else {
+			if source == utils.DATA_SOURCE_PREDICT_CALCULATE {
+				startDate = ``
+				if refreshAll { //刷新所有数据，用开始时间作为起始日期去刷新
+					startDate = edbInfo.StartDate.Format(utils.FormatDate)
+				} else {
+					sTime := edbInfo.EndDate
+					frequency := edbInfo.Frequency
+					var limitDay int
+					switch frequency {
+					case "日度":
+						limitDay = utils.DATA_START_REFRESH_LIMIT
+					case "周度":
+						limitDay = utils.DATA_START_REFRESH_LIMIT * 7
+					case "月度":
+						limitDay = utils.DATA_START_REFRESH_LIMIT * 30
+					case "季度":
+						limitDay = utils.DATA_START_REFRESH_LIMIT * 90
+					case "年度":
+						limitDay = utils.DATA_START_REFRESH_LIMIT * 365
+					default:
+						limitDay = utils.DATA_START_REFRESH_LIMIT
+					}
+					startDate = sTime.AddDate(0, 0, -limitDay).Format(utils.FormatDate)
+				}
+			}
+		}
+
+		result, tmpErr := RefreshPredictEdbCalculateData(edbInfo.EdbInfoId, edbInfo.EdbCode, startDate)
+		if tmpErr != nil {
+			err = tmpErr
 			fmt.Println(v, "RefreshPredictEdbCalculateData err", time.Now())
 			errmsg = "RefreshPredictEdbCalculateData Err:" + err.Error()
-			return err
+			return
 		}
 		if result.Ret != 200 {
 			fmt.Println(v, "RefreshPredictEdbCalculateData err;msg:", result.Msg, ";errMsg:", result.ErrMsg)
 			errmsg = fmt.Sprint(v, "RefreshPredictEdbCalculateData err;msg:", result.Msg, ";errMsg:", result.ErrMsg)
-			return fmt.Errorf("刷新失败")
+			err = fmt.Errorf("刷新失败")
+			return
 		}
 	}
-	return err
+
+	return
 }
 
 // getRefreshEdbInfoList 获取待更新的指标（普通基础指标、普通运算指标，预测运算指标）
-func getRefreshEdbInfoListByIds(edbInfoIdList []int) (newBaseEdbInfoArr []*edbInfoModel.EdbInfo, newCalculateMap, newPredictCalculateMap map[int]*edbInfoModel.EdbInfo, calculateArr, predictCalculateArr []int, err error, errMsg string) {
+func getRefreshEdbInfoListByIds(edbInfoIdList []int) (newBaseEdbInfoArr, newBasePredictEdbInfoArr []*edbInfoModel.EdbInfo, newCalculateMap, newPredictCalculateMap map[int]*edbInfoModel.EdbInfo, calculateArr, predictCalculateArr []int, err error, errMsg string) {
 	calculateList, err := edbInfoModel.GetEdbInfoAllCalculateByEdbInfoIdList(edbInfoIdList)
 	if err != nil && err != utils.ErrNoRow {
 		err = errors.New("GetEdbInfoAllCalculate Err:" + err.Error())
@@ -427,6 +518,16 @@ func getRefreshEdbInfoListByIds(edbInfoIdList []int) (newBaseEdbInfoArr []*edbIn
 	// 普通计算指标的id
 	sort.Ints(calculateArr)
 
+	// 普通预测指标去重
+	newBasePredictEdbInfoArr = make([]*edbInfoModel.EdbInfo, 0)
+	basePredictMap := make(map[int]int)
+	for _, v := range basePredictEdbInfoArr {
+		if _, ok := basePredictMap[v.EdbInfoId]; !ok {
+			newBasePredictEdbInfoArr = append(newBasePredictEdbInfoArr, v)
+		}
+		basePredictMap[v.EdbInfoId] = v.EdbInfoId
+	}
+
 	// 预测计算指标去重
 	newPredictCalculateMap = make(map[int]*edbInfoModel.EdbInfo)
 	for _, v := range predictCalculateInfoArr {

services/chart/predict_edb_info_rule.go

@@ -3,6 +3,7 @@ package chart
 import (
 	"github.com/shopspring/decimal"
 	edbDataModel "hongze/hongze_yb/models/tables/edb_data"
+	predictEdbRuleDataModel "hongze/hongze_yb/models/tables/predict_edb_rule_data"
 	"hongze/hongze_yb/utils"
 	"time"
 )
@@ -581,3 +582,75 @@ func getLinearResult(s []Coordinate) (gradient, intercept float64) {
 
 	return
 }
+
+//	GetChartPredictEdbInfoDataListByRuleTrendsHC 根据动态环比增加值的计算规则获取预测数据
+// 研究员有对预测指标进行动态环差计算的需求，即预测指标使用环差规则进行预测时，环比增加值不是固定值，而是由几个预测指标计算得出的动态变化的值；
+//需求说明：
+//1、增加“动态环差”预测规则；
+//2、环比增加值在弹窗设置；
+//3、动态环差预测举例：
+//指标A实际最新数据为2022-10-27（100）；
+//预测指标B预测数据为2022-10-28（240）、2022-10-29（300）；
+//预测指标C预测数据为2022-10-28（260）、2022-10-29（310）；
+//计算公式为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 []*edbDataModel.EdbDataList, existMap map[string]float64) (newPredictEdbInfoData []*edbDataModel.EdbDataList, minValue, maxValue float64) {
+	allDataList := make([]*edbDataModel.EdbDataList, 0)
+	allDataList = append(allDataList, realPredictEdbInfoData...)
+	allDataList = append(allDataList, predictEdbInfoData...)
+	newPredictEdbInfoData = predictEdbInfoData
+
+	lenAllData := len(allDataList)
+	if lenAllData <= 0 {
+		return
+	}
+
+	hcDataMap := make(map[string]float64) //规则计算的环差值map
+
+	//已经生成的动态数据
+	tmpPredictEdbRuleDataList, err := predictEdbRuleDataModel.GetPredictEdbRuleDataList(edbInfoId, configId, startDate.Format(utils.FormatDate), endDate.Format(utils.FormatDate))
+	if err != nil {
+		return
+	}
+	for _, v := range tmpPredictEdbRuleDataList {
+		hcDataMap[v.DataTime.Format(utils.FormatDate)] = v.Value
+	}
+	dayList := getPredictEdbDayList(startDate, endDate, frequency)
+	for k, currentDate := range dayList {
+		// 最近一条数据
+		tmpLenAllDataList := len(allDataList)
+		lastValue := allDataList[tmpLenAllDataList-1].Value
+
+		// 动态环差值数据
+		currentDateStr := currentDate.Format(utils.FormatDate)
+		hcVal, ok := hcDataMap[currentDateStr]
+		if !ok {
+			continue
+		}
+		lastValueDecimal := decimal.NewFromFloat(lastValue)
+		hcValDecimal := decimal.NewFromFloat(hcVal)
+
+		val, _ := lastValueDecimal.Add(hcValDecimal).RoundCeil(4).Float64()
+
+		tmpData := &edbDataModel.EdbDataList{
+			EdbDataId:     edbInfoId + 10000000000 + 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
+}