Merge branch 'predict_edb_data_base' into debug

controllers/base_from_predict.go

@@ -177,6 +177,26 @@ func (this *PredictController) Refresh() {
 		return
 	}
 
+	refreshParams := models.RefreshParams{
+		EdbInfo: edbInfo,
+	}
+
+	obj := new(models.PredictStandardBase)
+	latestDateStr, latestValue, err, errMsg := obj.Refresh(refreshParams)
+	if errMsg != `` {
+		br.Msg = "刷新指标失败！"
+		br.ErrMsg = "刷新指标失败，err:" + errMsg
+		return
+	}
+
+	// 更新指标最大最小值
+	err, errMsg = models.UnifiedModifyPredictEdbInfoMaxAndMinInfo(edbInfo, latestDateStr, latestValue)
+	if err != nil {
+		br.Msg = errMsg
+		br.ErrMsg = err.Error()
+		return
+	}
+
 	// 更新ES
 	go logic.UpdateEs(edbInfo.EdbInfoId)
 

models/edb_data_table.go

@@ -162,6 +162,8 @@ func GetEdbDataTableName(source, subSource int) (tableName string) {
 		tableName = "edb_data_calculate_zdyfx" // 自定义分析->74
 	case utils.DATA_SOURCE_CALCULATE_RJZ: //日均值75
 		tableName = "edb_data_calculate_rjz"
+	case utils.DATA_SOURCE_PREDICT: // 基础预测指标->30
+		tableName = "edb_data_predict_base"
 	default:
 		edbSource := EdbSourceIdMap[source]
 		if edbSource != nil {

models/edb_info.go

@@ -458,8 +458,11 @@ func UnifiedModifyEdbInfoMaxAndMinInfo(edbInfo *EdbInfo) (err error, errMsg stri
 			}
 		}
 	}
-	// 修改关联的预测指标
-	go ModifyPredictEdbInfoMaxAndMinInfoBySourceEdbInfoId(edbInfo.EdbInfoId, maxAndMinItem)
+
+	// 刷新关联的预测指标
+	go RefreshPredictStandardBaseByGeneralEdbInfoId(edbInfo.EdbInfoId)
+
+	//go ModifyPredictEdbInfoMaxAndMinInfoBySourceEdbInfoId(edbInfo.EdbInfoId, maxAndMinItem)
 	return
 }
 

models/predict_edb_conf.go

@@ -152,269 +152,6 @@ func AddPredictEdbConf(item *PredictEdbConf) (lastId int64, err error) {
 	return
 }
 
-// AddPredictEdb 添加预测指标
-// edbInfo, calculateMappingList, predictEdbConfList,calculateRule9List,trendsMappingList
-func AddPredictEdb(item *EdbInfo, calculateMappingList []*EdbInfoCalculateMapping, predictEdbConfList []*PredictEdbConf, calculateRuleMap map[int]CalculateRule) (err error, errMsg string) {
-	o := orm.NewOrm()
-	tx, err := o.Begin()
-	if err != nil {
-		return
-	}
-	defer func() {
-		if err != nil {
-			tx.Rollback()
-		} else {
-			err = tx.Commit()
-		}
-	}()
-	// 新增预测指标
-	edbInfoId, err := tx.Insert(item)
-	if err != nil {
-		return
-	}
-	item.EdbInfoId = int(edbInfoId)
-
-	// 新增预测指标的关联关系
-	lenCalculateMapping := len(calculateMappingList)
-	if lenCalculateMapping > 0 {
-		for _, calculateMappingItem := range calculateMappingList {
-			calculateMappingItem.EdbInfoId = item.EdbInfoId
-			calculateMappingItem.EdbCode = item.EdbCode
-		}
-		_, err = tx.InsertMulti(lenCalculateMapping, calculateMappingList)
-		if err != nil {
-			return
-		}
-	}
-
-	predictEdbConfAndDataList := make([]*PredictEdbConfAndData, 0)
-
-	// 新增预测指标配置
-	for k, v := range predictEdbConfList {
-		v.PredictEdbInfoId = item.EdbInfoId
-		configId, tmpErr := tx.Insert(v)
-		if tmpErr != nil {
-			err = tmpErr
-			return
-		}
-		v.ConfigId = int(configId)
-
-		// 每次规则计算的时候，产生的临时数据
-		resultDataList := make([]*EdbInfoSearchData, 0)
-		switch v.RuleType {
-		case 9: //动态环差规则
-			calculateRule := calculateRuleMap[k]
-			calculateRule.ConfigId = v.ConfigId
-			calculateRule.EdbInfoId = v.PredictEdbInfoId
-
-			// 指标与规则的动态数据生成入库
-			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 := calculateRuleMap[k]
-			calculateRule.ConfigId = v.ConfigId
-			calculateRule.EdbInfoId = v.PredictEdbInfoId
-
-			// 指标与规则的动态数据（拟合数据）生成入库
-			err, errMsg = CalculateByRuleByRuleLineNh(tx, *item, predictEdbConfAndDataList, *v)
-			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
-				}
-			}
-
-		}
-
-		// 规则配置（含数据）
-		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
-}
-
-// EditPredictEdb 修改预测指标
-func EditPredictEdb(edbInfo *EdbInfo, updateEdbInfoCol []string, calculateMappingList []*EdbInfoCalculateMapping, predictEdbConfList []*PredictEdbConf, calculateRuleMap map[int]CalculateRule) (err error, errMsg string) {
-	o := orm.NewOrm()
-	tx, err := o.Begin()
-	if err != nil {
-		return
-	}
-	defer func() {
-		if err != nil {
-			tx.Rollback()
-		} else {
-			err = tx.Commit()
-		}
-	}()
-	// 修改预测指标
-	_, err = tx.Update(edbInfo, updateEdbInfoCol...)
-	if err != nil {
-		return
-	}
-
-	// 先删除原有的预测指标 与 其他指标的 关联关系
-	sql := ` DELETE FROM edb_info_calculate_mapping WHERE edb_info_id = ?`
-	_, err = tx.Raw(sql, edbInfo.EdbInfoId).Exec()
-	if err != nil {
-		return
-	}
-
-	// 先删除原有的配置
-	sql = ` DELETE FROM predict_edb_conf WHERE predict_edb_info_id = ?`
-	_, err = tx.Raw(sql, edbInfo.EdbInfoId).Exec()
-	if err != nil {
-		return
-	}
-
-	// 删除基础预测指标 规则配置 与 其他指标的 关联关系
-	sql = ` DELETE FROM predict_edb_conf_calculate_mapping WHERE edb_info_id = ?`
-	_, err = tx.Raw(sql, edbInfo.EdbInfoId).Exec()
-	if err != nil {
-		return
-	}
-
-	// 删除基础预测指标 规则配置 生成的动态数据值
-	sql = ` DELETE FROM predict_edb_rule_data WHERE edb_info_id = ?`
-	_, err = tx.Raw(sql, edbInfo.EdbInfoId).Exec()
-	if err != nil {
-		return
-	}
-
-	// 新增预测指标的关联关系
-	lenCalculateMapping := len(calculateMappingList)
-	if lenCalculateMapping > 0 {
-		for _, calculateMappingItem := range calculateMappingList {
-			calculateMappingItem.EdbInfoId = edbInfo.EdbInfoId
-			calculateMappingItem.EdbCode = edbInfo.EdbCode
-		}
-		_, err = tx.InsertMulti(lenCalculateMapping, calculateMappingList)
-		if err != nil {
-			return
-		}
-	}
-
-	calculateRuleIndex := 0 // 预测计算规则下标
-	predictEdbConfAndDataList := make([]*PredictEdbConfAndData, 0)
-
-	// 新增预测指标配置
-	for confIndex, v := range predictEdbConfList {
-		configId, tmpErr := tx.Insert(v)
-		if tmpErr != nil {
-			err = tmpErr
-			return
-		}
-		v.ConfigId = int(configId)
-		// 每次规则计算的时候，产生的临时数据
-		resultDataList := make([]*EdbInfoSearchData, 0)
-
-		switch v.RuleType {
-		case 9: //动态环差规则
-			calculateRule := calculateRuleMap[confIndex]
-			calculateRule.ConfigId = v.ConfigId
-			calculateRule.EdbInfoId = v.PredictEdbInfoId
-
-			// 指标与规则的动态数据生成入库
-			resultDataList, err = CalculateByRuleBy9(tx, calculateRule)
-			if err != nil {
-				return
-			}
-
-			// 规则与指标的关系入库
-			lenTrendsCalculateMapping := len(calculateRule.TrendsCalculateMappingList)
-			if lenTrendsCalculateMapping > 0 {
-				for _, vv := range calculateRule.TrendsCalculateMappingList {
-					vv.EdbInfoId = edbInfo.EdbInfoId
-					vv.ConfigId = v.ConfigId
-				}
-				_, err = tx.InsertMulti(lenTrendsCalculateMapping, calculateRule.TrendsCalculateMappingList)
-				if err != nil {
-					return
-				}
-			}
-		case 14: //14：根据 一元线性拟合 规则获取预测数据
-			calculateRule := calculateRuleMap[confIndex]
-			calculateRule.ConfigId = v.ConfigId
-			calculateRule.EdbInfoId = v.PredictEdbInfoId
-
-			// 指标与规则的动态数据（拟合数据）生成入库
-			err, errMsg = CalculateByRuleByRuleLineNh(tx, *edbInfo, predictEdbConfAndDataList, *v)
-			if err != nil {
-				return
-			}
-
-			// 规则与指标的关系入库
-			lenTrendsCalculateMapping := len(calculateRule.TrendsCalculateMappingList)
-			if lenTrendsCalculateMapping > 0 {
-				for _, vv := range calculateRule.TrendsCalculateMappingList {
-					vv.EdbInfoId = edbInfo.EdbInfoId
-					vv.ConfigId = v.ConfigId
-				}
-				_, err = tx.InsertMulti(lenTrendsCalculateMapping, calculateRule.TrendsCalculateMappingList)
-				if err != nil {
-					return
-				}
-			}
-
-		}
-
-		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
-}
-
 // GetPredictEdbInfoAllCalculate 根据基础预测指标id集合 获取 所有的普通指标列表数据
 func GetPredictEdbInfoAllCalculate(edbInfoIdList []int) (list []*EdbInfo, err error) {
 	num := len(edbInfoIdList)

models/predict_edb_data_base.go

@@ -0,0 +1,563 @@
+package models
+
+import (
+	"errors"
+	"eta/eta_index_lib/utils"
+	"fmt"
+	"github.com/beego/beego/v2/client/orm"
+	"github.com/shopspring/decimal"
+	"reflect"
+	"strconv"
+	"strings"
+	"time"
+)
+
+// PredictStandardBase 基础预测指标
+type PredictStandardBase struct {
+}
+
+// AddPredictEdb 添加预测指标
+// edbInfo, calculateMappingList, predictEdbConfList,calculateRule9List,trendsMappingList
+func AddPredictEdb(item *EdbInfo, calculateMappingList []*EdbInfoCalculateMapping, predictEdbConfList []*PredictEdbConf, calculateRuleMap map[int]CalculateRule) (err error, errMsg string) {
+	var latestDateStr string
+	var latestValue float64
+	o := orm.NewOrm()
+	tx, err := o.Begin()
+	if err != nil {
+		return
+	}
+	defer func() {
+		if err != nil {
+			tx.Rollback()
+		} else {
+			err = tx.Commit()
+
+			// 更新指标最大最小值
+			go UnifiedModifyPredictEdbInfoMaxAndMinInfo(item, latestDateStr, latestValue)
+		}
+	}()
+	// 新增预测指标
+	edbInfoId, err := tx.Insert(item)
+	if err != nil {
+		return
+	}
+	item.EdbInfoId = int(edbInfoId)
+
+	// 新增预测指标的关联关系
+	lenCalculateMapping := len(calculateMappingList)
+	if lenCalculateMapping > 0 {
+		for _, calculateMappingItem := range calculateMappingList {
+			calculateMappingItem.EdbInfoId = item.EdbInfoId
+			calculateMappingItem.EdbCode = item.EdbCode
+		}
+		_, err = tx.InsertMulti(lenCalculateMapping, calculateMappingList)
+		if err != nil {
+			return
+		}
+	}
+
+	predictEdbConfAndDataList := make([]*PredictEdbConfAndData, 0)
+
+	// 新增预测指标配置
+	for k, v := range predictEdbConfList {
+		v.PredictEdbInfoId = item.EdbInfoId
+		configId, tmpErr := tx.Insert(v)
+		if tmpErr != nil {
+			err = tmpErr
+			return
+		}
+		v.ConfigId = int(configId)
+
+		// 每次规则计算的时候，产生的临时数据
+		resultDataList := make([]*EdbInfoSearchData, 0)
+		switch v.RuleType {
+		case 9: //动态环差规则
+			calculateRule := calculateRuleMap[k]
+			calculateRule.ConfigId = v.ConfigId
+			calculateRule.EdbInfoId = v.PredictEdbInfoId
+
+			// 指标与规则的动态数据生成入库
+			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 := calculateRuleMap[k]
+			calculateRule.ConfigId = v.ConfigId
+			calculateRule.EdbInfoId = v.PredictEdbInfoId
+
+			// 指标与规则的动态数据（拟合数据）生成入库
+			err, errMsg = CalculateByRuleByRuleLineNh(tx, *item, predictEdbConfAndDataList, *v)
+			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
+				}
+			}
+
+		}
+
+		// 规则配置（含数据）
+		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)
+	}
+
+	// 重新预测数据
+	obj := new(PredictStandardBase)
+	latestDateStr, latestValue, err, errMsg = obj.refresh(tx, item, predictEdbConfAndDataList, item.EdbCode, "")
+
+	return
+}
+
+// EditPredictEdb 修改预测指标
+func EditPredictEdb(edbInfo *EdbInfo, updateEdbInfoCol []string, calculateMappingList []*EdbInfoCalculateMapping, predictEdbConfList []*PredictEdbConf, calculateRuleMap map[int]CalculateRule) (err error, errMsg string) {
+	var latestDateStr string
+	var latestValue float64
+
+	o := orm.NewOrm()
+	tx, err := o.Begin()
+	if err != nil {
+		return
+	}
+	defer func() {
+		if err != nil {
+			tx.Rollback()
+		} else {
+			err = tx.Commit()
+
+			// 更新指标最大最小值
+			go UnifiedModifyPredictEdbInfoMaxAndMinInfo(edbInfo, latestDateStr, latestValue)
+		}
+	}()
+	// 修改预测指标
+	_, err = tx.Update(edbInfo, updateEdbInfoCol...)
+	if err != nil {
+		return
+	}
+
+	// 先删除原有的预测指标 与 其他指标的 关联关系
+	sql := ` DELETE FROM edb_info_calculate_mapping WHERE edb_info_id = ?`
+	_, err = tx.Raw(sql, edbInfo.EdbInfoId).Exec()
+	if err != nil {
+		return
+	}
+
+	// 先删除原有的配置
+	sql = ` DELETE FROM predict_edb_conf WHERE predict_edb_info_id = ?`
+	_, err = tx.Raw(sql, edbInfo.EdbInfoId).Exec()
+	if err != nil {
+		return
+	}
+
+	// 删除基础预测指标 规则配置 与 其他指标的 关联关系
+	sql = ` DELETE FROM predict_edb_conf_calculate_mapping WHERE edb_info_id = ?`
+	_, err = tx.Raw(sql, edbInfo.EdbInfoId).Exec()
+	if err != nil {
+		return
+	}
+
+	// 删除基础预测指标 规则配置 生成的动态数据值
+	sql = ` DELETE FROM predict_edb_rule_data WHERE edb_info_id = ?`
+	_, err = tx.Raw(sql, edbInfo.EdbInfoId).Exec()
+	if err != nil {
+		return
+	}
+
+	// 新增预测指标的关联关系
+	lenCalculateMapping := len(calculateMappingList)
+	if lenCalculateMapping > 0 {
+		for _, calculateMappingItem := range calculateMappingList {
+			calculateMappingItem.EdbInfoId = edbInfo.EdbInfoId
+			calculateMappingItem.EdbCode = edbInfo.EdbCode
+		}
+		_, err = tx.InsertMulti(lenCalculateMapping, calculateMappingList)
+		if err != nil {
+			return
+		}
+	}
+
+	calculateRuleIndex := 0 // 预测计算规则下标
+	predictEdbConfAndDataList := make([]*PredictEdbConfAndData, 0)
+
+	// 新增预测指标配置
+	for confIndex, v := range predictEdbConfList {
+		configId, tmpErr := tx.Insert(v)
+		if tmpErr != nil {
+			err = tmpErr
+			return
+		}
+		v.ConfigId = int(configId)
+		// 每次规则计算的时候，产生的临时数据
+		resultDataList := make([]*EdbInfoSearchData, 0)
+
+		switch v.RuleType {
+		case 9: //动态环差规则
+			calculateRule := calculateRuleMap[confIndex]
+			calculateRule.ConfigId = v.ConfigId
+			calculateRule.EdbInfoId = v.PredictEdbInfoId
+
+			// 指标与规则的动态数据生成入库
+			resultDataList, err = CalculateByRuleBy9(tx, calculateRule)
+			if err != nil {
+				return
+			}
+
+			// 规则与指标的关系入库
+			lenTrendsCalculateMapping := len(calculateRule.TrendsCalculateMappingList)
+			if lenTrendsCalculateMapping > 0 {
+				for _, vv := range calculateRule.TrendsCalculateMappingList {
+					vv.EdbInfoId = edbInfo.EdbInfoId
+					vv.ConfigId = v.ConfigId
+				}
+				_, err = tx.InsertMulti(lenTrendsCalculateMapping, calculateRule.TrendsCalculateMappingList)
+				if err != nil {
+					return
+				}
+			}
+		case 14: //14：根据 一元线性拟合 规则获取预测数据
+			calculateRule := calculateRuleMap[confIndex]
+			calculateRule.ConfigId = v.ConfigId
+			calculateRule.EdbInfoId = v.PredictEdbInfoId
+
+			// 指标与规则的动态数据（拟合数据）生成入库
+			err, errMsg = CalculateByRuleByRuleLineNh(tx, *edbInfo, predictEdbConfAndDataList, *v)
+			if err != nil {
+				return
+			}
+
+			// 规则与指标的关系入库
+			lenTrendsCalculateMapping := len(calculateRule.TrendsCalculateMappingList)
+			if lenTrendsCalculateMapping > 0 {
+				for _, vv := range calculateRule.TrendsCalculateMappingList {
+					vv.EdbInfoId = edbInfo.EdbInfoId
+					vv.ConfigId = v.ConfigId
+				}
+				_, err = tx.InsertMulti(lenTrendsCalculateMapping, calculateRule.TrendsCalculateMappingList)
+				if err != nil {
+					return
+				}
+			}
+
+		}
+
+		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)
+	}
+
+	// 重新预测数据
+	obj := new(PredictStandardBase)
+	latestDateStr, latestValue, err, errMsg = obj.refresh(tx, edbInfo, predictEdbConfAndDataList, edbInfo.EdbCode, "")
+
+	return
+}
+
+// Add 添加
+func (obj PredictStandardBase) Add(params BatchSaveCalculateBatchParams) (edbInfo *EdbInfo, latestDateStr string, latestValue float64, err error, errMsg string) {
+	err = errors.New("暂不支持该方法")
+	return
+}
+
+// Edit 编辑
+func (obj PredictStandardBase) Edit(params BatchSaveCalculateBatchParams) (latestDateStr string, latestValue float64, err error, errMsg string) {
+	err = errors.New("暂不支持该方法")
+	return
+}
+
+// Refresh 刷新
+func (obj PredictStandardBase) Refresh(params RefreshParams) (latestDateStr string, latestValue float64, err error, errMsg string) {
+	edbInfo := params.EdbInfo
+	if edbInfo == nil {
+		errMsg = `错误的指标`
+		err = errors.New(errMsg)
+		return
+	}
+
+	// 查找该预测指标配置
+	predictEdbConfList, err := GetPredictEdbConfAndDataListById(edbInfo.EdbInfoId)
+	if err != nil && err.Error() != utils.ErrNoRow() {
+		errMsg = "获取预测指标配置信息失败"
+		return
+	}
+	if len(predictEdbConfList) == 0 {
+		errMsg = "获取预测指标配置信息失败"
+		err = errors.New(errMsg)
+		return
+	}
+
+	o := orm.NewOrm()
+	to, err := o.Begin()
+	if err != nil {
+		return
+	}
+	defer func() {
+		if err != nil {
+			_ = to.Rollback()
+			fmt.Println(reflect.TypeOf(obj).Name(), "；Refresh,Err:"+err.Error())
+		} else {
+			_ = to.Commit()
+		}
+	}()
+
+	// 重新预测数据
+	latestDateStr, latestValue, err, errMsg = obj.refresh(to, edbInfo, predictEdbConfList, edbInfo.EdbCode, "")
+
+	return
+}
+
+// GetSource 获取来源编码id
+func (obj PredictStandardBase) GetSource() int {
+	return utils.DATA_SOURCE_PREDICT
+}
+
+// GetSourceName 获取来源名称
+func (obj PredictStandardBase) GetSourceName() string {
+	return utils.DATA_SOURCE_NAME_PREDICT
+}
+
+func (obj PredictStandardBase) refresh(to orm.TxOrmer, edbInfo *EdbInfo, predictEdbConfAndDataList []*PredictEdbConfAndData, edbCode, startDate string) (latestDateStr string, latestValue float64, err error, errMsg string) {
+	edbInfoId := edbInfo.EdbInfoId
+	dataTableName := GetEdbDataTableName(edbInfo.Source, edbInfo.SubSource)
+	edbInfoIdStr := strconv.Itoa(edbInfoId)
+
+	// 获取标准差图表的指标数据
+	fromDataList, fromEdbInfo, err, errMsg := obj.GetCalculateDataList(edbInfo, predictEdbConfAndDataList, 1, startDate)
+	if err != nil {
+		return
+	}
+	latestDateStr = fromEdbInfo.LatestDate
+
+	//获取指标所有数据
+	existDataList := make([]*EdbData, 0)
+	sql := `SELECT * FROM %s WHERE edb_info_id=? `
+	sql = fmt.Sprintf(sql, dataTableName)
+	_, err = to.Raw(sql, edbInfoId).QueryRows(&existDataList)
+	if err != nil {
+		return
+	}
+	existDataMap := make(map[string]string)
+	removeDataTimeMap := make(map[string]int) //需要移除的日期数据
+	for _, v := range existDataList {
+		existDataMap[v.DataTime] = v.Value
+		removeDataTimeMap[v.DataTime] = 1
+	}
+	needAddDateMap := make(map[time.Time]int)
+
+	addSql := ` INSERT INTO ` + dataTableName + `(edb_info_id,edb_code,data_time,value,create_time,modify_time,data_timestamp) values `
+	var isAdd bool
+	for _, tmpData := range fromDataList {
+		currDateStr := tmpData.DataTime
+		currTime, tmpErr := time.ParseInLocation(utils.FormatDate, currDateStr, time.Local)
+		if tmpErr != nil {
+			err = tmpErr
+			return
+		}
+		// 当前的实际值
+		saveValue := decimal.NewFromFloat(tmpData.Value).Round(4).String()
+
+		existVal, ok := existDataMap[currDateStr]
+		// 如果库中已经存在该数据的话，那么就进行值的变更操作
+		if ok {
+			//校验待删除日期数据里面是否存在该元素，如果存在的话，那么移除该日期
+			delete(removeDataTimeMap, currDateStr)
+
+			if existVal != saveValue {
+				sql := ` UPDATE %s SET value=?,modify_time=NOW() WHERE edb_info_id=? AND data_time=? `
+				sql = fmt.Sprintf(sql, dataTableName)
+				_, err = to.Raw(sql, saveValue, edbInfoId, currDateStr).Exec()
+				if err != nil {
+					return
+				}
+			}
+
+			continue
+		}
+
+		// 库中不存在该日期的数据
+		timestamp := currTime.UnixNano() / 1e6
+		timeStr := fmt.Sprintf("%d", timestamp)
+		if _, existOk := needAddDateMap[currTime]; !existOk {
+			addSql += GetAddSql(edbInfoIdStr, edbCode, currDateStr, timeStr, saveValue)
+			isAdd = true
+		}
+		needAddDateMap[currTime] = 1
+	}
+
+	//删除已经不存在的指标数据（由于该指标当日的数据删除了）
+	{
+		removeDateList := make([]string, 0)
+		for dateTime := range removeDataTimeMap {
+			removeDateList = append(removeDateList, dateTime)
+		}
+		removeNum := len(removeDateList)
+		if removeNum > 0 {
+			sql := fmt.Sprintf(` DELETE FROM %s WHERE edb_info_id = ? and data_time in (`+utils.GetOrmInReplace(removeNum)+`) `, dataTableName)
+			_, err = to.Raw(sql, edbInfo.EdbInfoId, removeDateList).Exec()
+			if err != nil {
+				fmt.Println(reflect.TypeOf(obj).Name(), " add data ;delete Err", err.Error())
+				err = fmt.Errorf("删除不存在的指标数据失败,Err:" + err.Error())
+				return
+			}
+		}
+	}
+
+	if isAdd {
+		addSql = strings.TrimRight(addSql, ",")
+		_, err = to.Raw(addSql).Exec()
+		if err != nil {
+			fmt.Println(reflect.TypeOf(obj).Name(), " add data Err", err.Error())
+			return
+		}
+	}
+
+	//确定实际数据的最终值
+	{
+		finalLast, tmpErr := GetFinalLastByTo(to, edbInfoId, edbInfo.Source, edbInfo.SubSource, fromEdbInfo.LatestDate)
+		if tmpErr != nil && tmpErr.Error() != utils.ErrNoRow() {
+			return
+		}
+		if tmpErr == nil {
+			latestDateStr = finalLast.DataTime
+			latestValue = finalLast.Value
+		}
+	}
+
+	return
+}
+
+// GetCalculateDataList
+// @Description: 获取计算后的数据
+// @author: Roc
+// @receiver obj
+// @datetime 2024-04-24 10:42:51
+// @param edbInfo *EdbInfo
+// @param predictEdbConfList []*PredictEdbConfAndData
+// @param order int order:1升序，其余值为降序
+// @param startDate string
+// @return dataList []*EdbInfoSearchData
+// @return sourceEdbInfoItem *EdbInfo
+// @return err error
+// @return errMsg string
+func (obj PredictStandardBase) GetCalculateDataList(edbInfo *EdbInfo, predictEdbConfList []*PredictEdbConfAndData, order int, startDate string) (dataList []*EdbInfoSearchData, sourceEdbInfoItem *EdbInfo, err error, errMsg string) {
+	if len(predictEdbConfList) == 0 {
+		errMsg = "获取预测指标配置信息失败"
+		err = errors.New(errMsg)
+		return
+	}
+	predictEdbConf := predictEdbConfList[0]
+
+	// 来源指标
+	sourceEdbInfoItem, err = GetEdbInfoById(predictEdbConf.SourceEdbInfoId)
+	if err != nil {
+		if err.Error() == utils.ErrNoRow() {
+			errMsg = "找不到来源指标信息"
+			err = errors.New(errMsg)
+		}
+		return
+	}
+
+	dataList, err, errMsg = GetPredictDataListByPredictEdbConfList(edbInfo, sourceEdbInfoItem, predictEdbConfList, order, startDate)
+
+	return
+}
+
+// RefreshPredictStandardBaseByGeneralEdbInfoId
+// @Description:  根据普通指标id刷新预测标准基础数据
+// @author: Roc
+// @datetime 2024-04-24 13:40:59
+// @param sourceEdbInfoId int
+// @return err error
+func RefreshPredictStandardBaseByGeneralEdbInfoId(sourceEdbInfoId int) {
+	errList := make([]string, 0)
+	defer func() {
+		if len(errList) > 0 {
+			fmt.Println(errList)
+
+		}
+	}()
+	o := orm.NewOrm()
+	var list []*PredictEdbConf
+	sql := ` SELECT * FROM predict_edb_conf WHERE source_edb_info_id=? `
+	total, err := o.Raw(sql, sourceEdbInfoId).QueryRows(&list)
+	if err != nil {
+		errList = append(errList, fmt.Sprintf("根据来源换指标id获取配置项失败,来源指标ID:%d；err：%s", sourceEdbInfoId, err.Error()))
+		return
+	}
+
+	if total > 0 {
+		idList := make([]int, 0)
+		for _, v := range list {
+			idList = append(idList, v.PredictEdbInfoId)
+			edbInfo, tmpErr := GetEdbInfoById(v.PredictEdbInfoId)
+			if tmpErr != nil {
+				errList = append(errList, fmt.Sprintf("获取预测指标配置信息失败,预测指标配置ID:%d；err：%s", v.PredictEdbInfoId, tmpErr.Error()))
+				continue
+			}
+			refreshParams := RefreshParams{
+				EdbInfo: edbInfo,
+			}
+			obj := new(PredictStandardBase)
+			latestDateStr, latestValue, tmpErr, errMsg := obj.Refresh(refreshParams)
+			if tmpErr != nil {
+				errList = append(errList, fmt.Sprintf("更新失败,预测指标配置ID:%d；err：%s；errMsg:%s", v.PredictEdbInfoId, tmpErr.Error(), errMsg))
+				continue
+			}
+
+			// 更新指标最大最小值
+			tmpErr, errMsg = UnifiedModifyPredictEdbInfoMaxAndMinInfo(edbInfo, latestDateStr, latestValue)
+			if tmpErr != nil {
+				errList = append(errList, fmt.Sprintf("更新指标最大最小值失败,预测指标配置ID:%d；err：%s；errMsg:%s", v.PredictEdbInfoId, tmpErr.Error(), errMsg))
+				continue
+			}
+		}
+	}
+
+	return
+}