fix:新增预测运算指标画图、刷新

models/data_manage/chart_info.go

@@ -58,3 +58,53 @@ func GetChartRefreshEdbInfo(edbInfoId, source, n int) (baseEdbInfoArr, calculate
 	}
 	return
 }
+
+type ChartEdbInfoMapping struct {
+	EdbInfoId           int     `description:"指标id"`
+	SourceName          string  `description:"来源名称"`
+	Source              int     `description:"来源id"`
+	EdbCode             string  `description:"指标编码"`
+	EdbName             string  `description:"指标名称"`
+	EdbNameEn           string  `description:"英文指标名称"`
+	EdbType             int     `description:"指标类型:1:基础指标,2:计算指标"`
+	Frequency           string  `description:"频率"`
+	FrequencyEn         string  `description:"英文频率"`
+	Unit                string  `description:"单位"`
+	UnitEn              string  `description:"英文单位"`
+	StartDate           string  `description:"起始日期"`
+	EndDate             string  `description:"终止日期"`
+	ModifyTime          string  `description:"指标最后更新时间"`
+	ChartEdbMappingId   int     `description:"图表指标id"`
+	ChartInfoId         int     `description:"图表id"`
+	MaxData             float64 `description:"上限"`
+	MinData             float64 `description:"下限"`
+	IsOrder             bool    `description:"true:正序,false:逆序"`
+	IsAxis              int     `description:"1:左轴,0:右轴"`
+	EdbInfoType         int     `description:"1:标准指标,0:领先指标"`
+	EdbInfoCategoryType int     `description:"0:普通指标,1:预测指标"`
+	LeadValue           int     `description:"领先值"`
+	LeadUnit            string  `description:"领先单位"`
+	LeadUnitEn          string  `description:"领先英文单位"`
+	ChartStyle          string  `description:"图表类型"`
+	ChartColor          string  `description:"颜色"`
+	PredictChartColor   string  `description:"预测数据的颜色"`
+	ChartWidth          float64 `description:"线条大小"`
+	ChartType           int     `description:"生成样式:1:曲线图,2:季节性图,3:面积图，4：柱状图，5：散点图，6：组合图"`
+	LatestDate          string  `description:"数据最新日期"`
+	LatestValue         float64 `description:"数据最新值"`
+	UniqueCode          string  `description:"指标唯一编码"`
+	MinValue            float64 `json:"-" description:"最小值"`
+	MaxValue            float64 `json:"-" description:"最大值"`
+	DataList            interface{}
+}
+
+func GetChartEdbMappingList(chartInfoId int) (list []*ChartEdbInfoMapping, err error) {
+	o := orm.NewOrmUsingDB("data")
+	sql := ` SELECT a.*,b.source_name,b.source,b.edb_code,b.edb_name,b.edb_name_en,b.frequency,b.unit,b.unit_en,b.start_date,b.end_date,b.modify_time,b.latest_date,b.latest_value,b.unique_code,b.edb_info_type AS edb_info_category_type
+             FROM chart_edb_mapping AS a
+			 INNER JOIN edb_info AS b ON a.edb_info_id=b.edb_info_id
+			 WHERE chart_info_id=? 
+             ORDER BY chart_edb_mapping_id ASC `
+	_, err = o.Raw(sql, chartInfoId).QueryRows(&list)
+	return
+}

models/data_manage/edb_data_base.go

@@ -63,6 +63,12 @@ func GetEdbDataTableName(source int) (tableName string) {
 		tableName = "edb_data_python"
 	case utils.DATA_SOURCE_GOOGLE_TRAVEL:
 		tableName = "edb_data_google_travel"
+	case utils.DATA_SOURCE_PREDICT_CALCULATE:
+		tableName = "edb_data_predict_calculate"
+	case utils.DATA_SOURCE_PREDICT_CALCULATE_TBZ:
+		tableName = "edb_data_predict_calculate_tbz"
+	case utils.DATA_SOURCE_PREDICT_CALCULATE_TCZ:
+		tableName = "edb_data_predict_calculate_tcz"
 	default:
 		tableName = ""
 	}

models/data_manage/edb_info.go

@@ -3,6 +3,7 @@ package data_manage
 import (
 	"fmt"
 	"github.com/beego/beego/v2/client/orm"
+	"hongze/hongze_chart_lib/utils"
 	"time"
 )
 
@@ -72,3 +73,33 @@ func GetEdbInfoById(edbInfoId int) (item *EdbInfo, err error) {
 	err = o.Raw(sql, edbInfoId).QueryRow(&item)
 	return
 }
+
+// GetEdbInfoByIdList 根据指标id集合 获取 指标列表
+func GetEdbInfoByIdList(edbInfoIdList []int) (items []*EdbInfo, err error) {
+	num := len(edbInfoIdList)
+	if num <= 0 {
+		return
+	}
+	o := orm.NewOrmUsingDB("data")
+	sql := ` SELECT * FROM edb_info WHERE edb_info_id in (` + utils.GetOrmInReplace(num) + `) `
+	_, err = o.Raw(sql, edbInfoIdList).QueryRows(&items)
+	return
+}
+
+func GetRefreshEdbInfoFromBase(edbInfoId, source int) (baseEdbInfoArr, calculateInfoArr []*EdbInfo, err error) {
+	calculateList, err := GetEdbInfoCalculateMap(edbInfoId, source)
+	if err != nil && err.Error() != utils.ErrNoRow() {
+		return
+	}
+	for _, item := range calculateList {
+		if item.EdbType == 1 {
+			baseEdbInfoArr = append(baseEdbInfoArr, item)
+		} else {
+			calculateInfoArr = append(calculateInfoArr, item)
+			newBaseEdbInfoArr, newCalculateInfoArr, _ := GetRefreshEdbInfoFromBase(item.EdbInfoId, item.Source)
+			baseEdbInfoArr = append(baseEdbInfoArr, newBaseEdbInfoArr...)
+			calculateInfoArr = append(calculateInfoArr, newCalculateInfoArr...)
+		}
+	}
+	return
+}

models/data_manage/edb_info_calculate.go

@@ -2,6 +2,7 @@ package data_manage
 
 import (
 	"github.com/beego/beego/v2/client/orm"
+	"hongze/hongze_chart_lib/utils"
 )
 
 func GetEdbInfoCalculateMap(edbInfoId, source int) (list []*EdbInfo, err error) {
@@ -21,3 +22,20 @@ func GetEdbInfoCalculateMap(edbInfoId, source int) (list []*EdbInfo, err error)
 	_, err = o.Raw(sql, edbInfoId).QueryRows(&list)
 	return
 }
+
+// GetEdbInfoAllCalculateByEdbInfoIdList 根据指标id集合 获取基础指标对应的所有计算指标
+func GetEdbInfoAllCalculateByEdbInfoIdList(edbInfoIdList []int) (list []*EdbInfo, err error) {
+	num := len(edbInfoIdList)
+	if num <= 0 {
+		return
+	}
+
+	o := orm.NewOrmUsingDB("data")
+	sql := ` SELECT b.* FROM edb_info_calculate_mapping AS a
+			 INNER JOIN edb_info AS b ON a.edb_info_id=b.edb_info_id
+             WHERE a.from_edb_info_id in (` + utils.GetOrmInReplace(num) + `)
+			 GROUP BY a.edb_info_id
+			 ORDER BY a.edb_info_id ASC `
+	_, err = o.Raw(sql, edbInfoIdList).QueryRows(&list)
+	return
+}

models/data_manage/predict_edb_conf.go

@@ -3,6 +3,7 @@ package data_manage
 import (
 	"github.com/beego/beego/v2/client/orm"
 	"hongze/hongze_chart_lib/services/alarm_msg"
+	"hongze/hongze_chart_lib/utils"
 	"time"
 )
 
@@ -108,3 +109,19 @@ func EditPredictEdb(edbInfo *EdbInfo, predictEdbConf *PredictEdbConf, updateEdbI
 	}
 	return
 }
+
+// GetPredictEdbInfoAllCalculate 根据基础预测指标id集合 获取 所有的普通指标列表数据
+func GetPredictEdbInfoAllCalculate(edbInfoIdList []int) (list []*EdbInfo, err error) {
+	num := len(edbInfoIdList)
+	if num <= 0 {
+		return
+	}
+	o := orm.NewOrmUsingDB("data")
+	sql := ` SELECT b.* FROM predict_edb_conf AS a
+			 INNER JOIN edb_info AS b ON a.source_edb_info_id=b.edb_info_id
+             WHERE a.predict_edb_info_id in (` + utils.GetOrmInReplace(num) + `)
+			 GROUP BY a.source_edb_info_id
+			 ORDER BY a.source_edb_info_id ASC `
+	_, err = o.Raw(sql, edbInfoIdList).QueryRows(&list)
+	return
+}

models/edb_data_base.go

@@ -62,6 +62,12 @@ func GetEdbDataTableName(source int) (tableName string) {
 		tableName = "edb_data_python"
 	case utils.DATA_SOURCE_GOOGLE_TRAVEL:
 		tableName = "edb_data_google_travel"
+	case utils.DATA_SOURCE_PREDICT_CALCULATE:
+		tableName = "edb_data_predict_calculate"
+	case utils.DATA_SOURCE_PREDICT_CALCULATE_TBZ:
+		tableName = "edb_data_predict_calculate_tbz"
+	case utils.DATA_SOURCE_PREDICT_CALCULATE_TCZ:
+		tableName = "edb_data_predict_calculate_tcz"
 	default:
 		tableName = ""
 	}

services/data/base_edb_lib.go

@@ -119,6 +119,16 @@ func RefreshEdbCalculateData(edbInfoId int, edbCode, startDate string) (resp *mo
 	return
 }
 
+// RefreshPredictEdbCalculateData 刷新 预测计算指标 数据请求
+func RefreshPredictEdbCalculateData(edbInfoId int, edbCode, startDate string) (resp *models.BaseResponse, err error) {
+	param := make(map[string]interface{})
+	param["EdbCode"] = edbCode
+	param["EdbInfoId"] = edbInfoId
+	param["StartDate"] = startDate
+	resp, err = postRefreshEdbData(param, "predict_calculate/refresh")
+	return
+}
+
 // postRefreshEdbData 刷新指标数据
 func postRefreshEdbData(param map[string]interface{}, urlStr string) (resp *models.BaseResponse, err error) {
 	postUrl := utils.EDB_LIB_URL + urlStr

services/data/chart_info.go

@@ -5,6 +5,7 @@ import (
 	"fmt"
 	"hongze/hongze_chart_lib/models"
 	"hongze/hongze_chart_lib/models/data_manage"
+	"hongze/hongze_chart_lib/services/alarm_msg"
 	"hongze/hongze_chart_lib/utils"
 	"sort"
 	"time"
@@ -421,3 +422,36 @@ func GetChartEdbData(chartInfoId, chartType int, calendar, startDate, endDate st
 	}
 	return
 }
+
+// ChartInfoRefreshV2 图表刷新
+// @author Roc
+// @datetime 2022-09-16 10:15:38
+// @description 将原来自己写的一套获取所有关联指标，然后刷新指标逻辑 改成  只获取使用的指标id，然后遍历去调用“指标刷新服务”
+func ChartInfoRefreshV2(chartInfoId int) (err error) {
+	var errmsg string
+	defer func() {
+		if err != nil {
+			go alarm_msg.SendAlarmMsg("ChartInfoRefresh:"+errmsg, 3)
+			//go utils.SendEmail(utils.APPNAME+"【"+utils.RunMode+"】"+"失败提醒", "ChartInfoRefresh:"+errmsg, utils.EmailSendToUsers)
+			fmt.Println("ChartInfoRefresh Err:" + errmsg)
+		}
+	}()
+	edbMappingList, err := data_manage.GetChartEdbMappingList(chartInfoId)
+	if err != nil {
+		errmsg = "获取需要刷新的指标失败:Err:" + err.Error()
+		return
+	}
+
+	edbIdList := make([]int, 0)
+	for _, v := range edbMappingList {
+		edbIdList = append(edbIdList, v.EdbInfoId)
+	}
+
+	// 批量刷新
+	err = EdbInfoRefreshAllFromBaseV3(edbIdList, false)
+	if err != nil {
+		return
+	}
+
+	return
+}

services/data/edb_info.go

@@ -0,0 +1,420 @@
+package data
+
+import (
+	"errors"
+	"fmt"
+	"hongze/hongze_chart_lib/models/data_manage"
+	"hongze/hongze_chart_lib/services/alarm_msg"
+	"hongze/hongze_chart_lib/utils"
+	"sort"
+	"time"
+)
+
+// EdbInfoRefreshAllFromBaseV3 全部刷新指标（切换到edb_lib服务）
+// @author Roc
+// @datetime 2022-09-16 11:04:44
+// @description 将原有的单个指标刷新，调整为批量多个指标刷新
+func EdbInfoRefreshAllFromBaseV3(edbInfoIdList []int, refreshAll bool) (err error) {
+	var errmsg string
+	defer func() {
+		if err != nil {
+			fmt.Println("EdbInfoRefreshAllFromBaseV2 Err:" + err.Error() + ";errmsg:" + errmsg)
+			go alarm_msg.SendAlarmMsg("EdbInfoRefreshFromBaseV2,Err"+err.Error()+";errMsg:"+errmsg, 3)
+			//go utils.SendEmail(utils.APPNAME+"【"+utils.RunMode+"】"+"失败提醒", "EdbInfoRefreshFromBase:"+errmsg, utils.EmailSendToUsers)
+		}
+	}()
+
+	// 获取关联的基础指标
+	newBaseEdbInfoArr, newCalculateMap, newPredictCalculateMap, calculateArr, predictCalculateArr, err, errmsg := getRefreshEdbInfoListByIds(edbInfoIdList)
+	if err != nil {
+		return
+	}
+
+	var startDate string
+	for _, bv := range newBaseEdbInfoArr {
+		//source := bv.Source
+		//edbInfoId := bv.EdbInfoId
+		//edbCode := bv.EdbCode
+		if bv.StartDate == "0000-00-00" {
+			continue
+		}
+		//开始时间
+		startDate = ``
+		if refreshAll { //刷新所有数据，用开始时间作为起始日期去刷新
+			sTime, err := time.Parse(utils.FormatDate, bv.StartDate)
+			if err != nil {
+				return err
+			}
+			startDate = sTime.Format(utils.FormatDate)
+		} else {
+			sTime, err := time.Parse(utils.FormatDate, bv.EndDate)
+			if err != nil {
+				return err
+			}
+			frequency := bv.Frequency
+			var limitDay int
+			switch frequency {
+			case "日度":
+				limitDay = utils.DATA_REFRESH
+			case "周度":
+				limitDay = utils.DATA_REFRESH * 7
+			case "月度":
+				limitDay = utils.DATA_REFRESH * 30
+			case "季度":
+				limitDay = utils.DATA_REFRESH * 90
+			case "年度":
+				limitDay = utils.DATA_REFRESH * 365
+			default:
+				limitDay = utils.DATA_REFRESH
+			}
+			startDate = sTime.AddDate(0, 0, -limitDay).Format(utils.FormatDate)
+		}
+		result, err := RefreshEdbData(bv.EdbInfoId, bv.Source, bv.EdbCode, startDate)
+		if err != nil {
+			fmt.Println(bv.EdbInfoId, "RefreshBaseEdbData err", time.Now())
+			errmsg = "RefreshBaseEdbData Err:" + err.Error()
+			return err
+		}
+		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)
+		}
+
+		//maxAndMinItem, err := data_manage.GetEdbInfoMaxAndMinInfo(source, edbCode)
+		//if err != nil {
+		//	if err.Error() == utils.ErrNoRow() { //找不到数据，那么就进入到下一条数据做处理
+		//		continue
+		//	}
+		//	return err
+		//}
+		//if maxAndMinItem != nil {
+		//	err = data_manage.ModifyEdbInfoMaxAndMinInfo(edbInfoId, maxAndMinItem)
+		//	if err != nil {
+		//		return err
+		//	}
+		//}
+		fmt.Println("end newBaseEdbInfoArr:", bv, time.Now())
+	}
+
+	//刷新相关普通计算指标
+	for _, v := range calculateArr {
+		edbInfo := newCalculateMap[v]
+		if edbInfo == nil {
+			return err
+		}
+		startDate = edbInfo.StartDate
+		source := edbInfo.Source
+		if startDate == "" || startDate == "0000-00-00" { //如果没有开始日期，说明还没有计算出来数据，那么就往前面推40年吧（也意味着重新计算了）
+			startDate = time.Now().AddDate(-40, 0, 0).Format(utils.FormatDate)
+		} else {
+			if source == utils.DATA_SOURCE_CALCULATE {
+				startDate = ``
+				if refreshAll { //刷新所有数据，用开始时间作为起始日期去刷新
+					startDate = edbInfo.StartDate
+				} else {
+					sTime, err := time.Parse(utils.FormatDate, edbInfo.EndDate)
+					if err != nil {
+						return err
+					}
+					frequency := edbInfo.Frequency
+					var limitDay int
+					switch frequency {
+					case "日度":
+						limitDay = utils.DATA_REFRESH
+					case "周度":
+						limitDay = utils.DATA_REFRESH * 7
+					case "月度":
+						limitDay = utils.DATA_REFRESH * 30
+					case "季度":
+						limitDay = utils.DATA_REFRESH * 90
+					case "年度":
+						limitDay = utils.DATA_REFRESH * 365
+					default:
+						limitDay = utils.DATA_REFRESH
+					}
+					startDate = sTime.AddDate(0, 0, -limitDay).Format(utils.FormatDate)
+				}
+			}
+		}
+
+		result, err := RefreshEdbCalculateData(edbInfo.EdbInfoId, edbInfo.EdbCode, startDate)
+		if err != nil {
+			fmt.Println(v, "RefreshEdbCalculateData err", time.Now())
+			errmsg = "RefreshEdbCalculateData Err:" + err.Error()
+			return err
+		}
+		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("刷新失败")
+		}
+	}
+
+	//刷新相关预测计算指标
+	for _, v := range predictCalculateArr {
+		edbInfo := newPredictCalculateMap[v]
+		if edbInfo == nil {
+			return err
+		}
+		startDate = edbInfo.StartDate
+		source := edbInfo.Source
+		if startDate == "" || startDate == "0000-00-00" { //如果没有开始日期，说明还没有计算出来数据，那么就往前面推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
+				} else {
+					sTime, err := time.Parse(utils.FormatDate, edbInfo.EndDate)
+					if err != nil {
+						return err
+					}
+					frequency := edbInfo.Frequency
+					var limitDay int
+					switch frequency {
+					case "日度":
+						limitDay = utils.DATA_REFRESH
+					case "周度":
+						limitDay = utils.DATA_REFRESH * 7
+					case "月度":
+						limitDay = utils.DATA_REFRESH * 30
+					case "季度":
+						limitDay = utils.DATA_REFRESH * 90
+					case "年度":
+						limitDay = utils.DATA_REFRESH * 365
+					default:
+						limitDay = utils.DATA_REFRESH
+					}
+					startDate = sTime.AddDate(0, 0, -limitDay).Format(utils.FormatDate)
+				}
+			}
+		}
+
+		result, err := RefreshPredictEdbCalculateData(edbInfo.EdbInfoId, edbInfo.EdbCode, startDate)
+		if err != nil {
+			fmt.Println(v, "RefreshEdbCalculateData err", time.Now())
+			errmsg = "RefreshEdbCalculateData Err:" + err.Error()
+			return err
+		}
+		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("刷新失败")
+		}
+	}
+	return err
+}
+
+// getRefreshEdbInfoList 获取待更新的指标（普通基础指标、普通运算指标，预测运算指标）
+func getRefreshEdbInfoListByIds(edbInfoIdList []int) (newBaseEdbInfoArr []*data_manage.EdbInfo, newCalculateMap, newPredictCalculateMap map[int]*data_manage.EdbInfo, calculateArr, predictCalculateArr []int, err error, errMsg string) {
+	calculateList, err := data_manage.GetEdbInfoAllCalculateByEdbInfoIdList(edbInfoIdList)
+	if err != nil && err.Error() != utils.ErrNoRow() {
+		err = errors.New("GetEdbInfoAllCalculate Err:" + err.Error())
+		return
+	}
+	// 获取指标信息
+	edbInfoList, err := data_manage.GetEdbInfoByIdList(edbInfoIdList)
+	if err != nil {
+		err = errors.New("GetEdbInfoAllCalGetEdbInfoByIdr:" + err.Error())
+		return
+	}
+
+	baseEdbInfoArr := make([]*data_manage.EdbInfo, 0)          // 基础普通指标
+	calculateInfoArr := make([]*data_manage.EdbInfo, 0)        //基础运算指标
+	basePredictEdbInfoArr := make([]*data_manage.EdbInfo, 0)   // 预测普通指标
+	predictCalculateInfoArr := make([]*data_manage.EdbInfo, 0) //预测运算指标
+
+	for _, baseEdbInfo := range edbInfoList {
+		if baseEdbInfo.EdbInfoType == 0 { //普通指标
+			switch baseEdbInfo.EdbType {
+			case 1: //基础指标
+				baseEdbInfoArr = append(baseEdbInfoArr, baseEdbInfo)
+			case 2: //计算指标
+				calculateList = append(calculateList, baseEdbInfo)
+			}
+		} else { //预测指标
+			switch baseEdbInfo.EdbType {
+			case 1: //基础指标
+				basePredictEdbInfoArr = append(basePredictEdbInfoArr, baseEdbInfo)
+			case 2: //计算指标
+				predictCalculateInfoArr = append(predictCalculateInfoArr, baseEdbInfo)
+			}
+		}
+	}
+
+	// 计算指标
+	for _, v := range calculateList {
+		getBaseEdbInfoArr, getCalculateInfoArr, tmpErr := data_manage.GetRefreshEdbInfoFromBase(v.EdbInfoId, v.Source)
+		if tmpErr != nil {
+			err = tmpErr
+			fmt.Println("GetRefreshEdbInfoFromBase err:" + err.Error())
+			errMsg = "获取需要刷新的指标失败:Err:" + err.Error()
+			return
+		}
+		for _, tmpEdbInfo := range getBaseEdbInfoArr {
+			switch tmpEdbInfo.EdbInfoType {
+			case 0: //普通基础指标
+				baseEdbInfoArr = append(baseEdbInfoArr, tmpEdbInfo)
+			case 1: //预测基础指标
+				basePredictEdbInfoArr = append(basePredictEdbInfoArr, tmpEdbInfo)
+			}
+		}
+
+		for _, tmpEdbInfo := range getCalculateInfoArr {
+			switch tmpEdbInfo.EdbInfoType {
+			case 0: //普通运算指标
+				calculateInfoArr = append(calculateInfoArr, tmpEdbInfo)
+			case 1: //预测运算指标
+				predictCalculateInfoArr = append(predictCalculateInfoArr, tmpEdbInfo)
+			}
+		}
+		switch v.EdbInfoType {
+		case 0: //普通运算指标
+			calculateInfoArr = append(calculateInfoArr, v)
+		case 1: //预测运算指标
+			predictCalculateInfoArr = append(predictCalculateInfoArr, v)
+		}
+	}
+
+	// 预测计算指标
+	for _, v := range predictCalculateInfoArr {
+		getBaseEdbInfoArr, getCalculateInfoArr, tmpErr := data_manage.GetRefreshEdbInfoFromBase(v.EdbInfoId, v.Source)
+		if tmpErr != nil {
+			err = tmpErr
+			fmt.Println("GetRefreshEdbInfoFromBase err:" + err.Error())
+			errMsg = "获取需要刷新的指标失败:Err:" + err.Error()
+			return
+		}
+		for _, tmpEdbInfo := range getBaseEdbInfoArr {
+			switch tmpEdbInfo.EdbInfoType {
+			case 0: //普通基础指标
+				baseEdbInfoArr = append(baseEdbInfoArr, tmpEdbInfo)
+			case 1: //预测基础指标
+				basePredictEdbInfoArr = append(basePredictEdbInfoArr, tmpEdbInfo)
+			}
+		}
+
+		for _, tmpEdbInfo := range getCalculateInfoArr {
+			switch tmpEdbInfo.EdbInfoType {
+			case 0: //普通运算指标
+				calculateInfoArr = append(calculateInfoArr, tmpEdbInfo)
+			case 1: //预测运算指标
+				predictCalculateInfoArr = append(predictCalculateInfoArr, tmpEdbInfo)
+			}
+		}
+		switch v.EdbInfoType {
+		case 0: //普通运算指标
+			calculateInfoArr = append(calculateInfoArr, v)
+		case 1: //预测运算指标
+			predictCalculateInfoArr = append(predictCalculateInfoArr, v)
+		}
+	}
+
+	// 第一次的计算指标map
+	newCalculateMap = make(map[int]*data_manage.EdbInfo)
+	for _, v := range calculateInfoArr {
+		if _, ok := newCalculateMap[v.EdbInfoId]; !ok {
+			calculateArr = append(calculateArr, v.EdbInfoId)
+		}
+		newCalculateMap[v.EdbInfoId] = v
+	}
+
+	// 基础预测指标
+	if len(basePredictEdbInfoArr) > 0 {
+		basePredictEdbInfoIdList := make([]int, 0)
+		for _, v := range basePredictEdbInfoArr {
+			basePredictEdbInfoIdList = append(basePredictEdbInfoIdList, v.EdbInfoId)
+		}
+		baseEdbInfoList, tmpErr := data_manage.GetPredictEdbInfoAllCalculate(basePredictEdbInfoIdList)
+		if tmpErr != nil {
+			err = tmpErr
+			return
+		}
+
+		tmpCalculateList := make([]*data_manage.EdbInfo, 0)
+		for _, v := range baseEdbInfoList {
+			switch v.EdbType {
+			case 1:
+				baseEdbInfoArr = append(baseEdbInfoArr, v)
+			case 2:
+				// 如果不在第一次里面，那么在第二次 刷新预测指标的时候 需要加进去
+				if _, ok := newCalculateMap[v.EdbInfoId]; !ok {
+					tmpCalculateList = append(tmpCalculateList, v)
+				}
+			}
+		}
+
+		// 这里是查询预测指标用到的 普通计算指标
+		for _, v := range tmpCalculateList {
+			getBaseEdbInfoArr, getCalculateInfoArr, tmpErr := data_manage.GetRefreshEdbInfoFromBase(v.EdbInfoId, v.Source)
+			if tmpErr != nil {
+				err = tmpErr
+				fmt.Println("GetRefreshEdbInfoFromBase err:" + err.Error())
+				errMsg = "获取需要刷新的指标失败:Err:" + err.Error()
+				return
+			}
+
+			// 基础指标
+			for _, tmpEdbInfo := range getBaseEdbInfoArr {
+				switch tmpEdbInfo.EdbInfoType {
+				case 0: //普通基础指标
+					baseEdbInfoArr = append(baseEdbInfoArr, tmpEdbInfo)
+				case 1: //预测基础指标
+					basePredictEdbInfoArr = append(basePredictEdbInfoArr, tmpEdbInfo)
+				}
+			}
+
+			// 计算指标
+			for _, tmpEdbInfo := range getCalculateInfoArr {
+				switch tmpEdbInfo.EdbInfoType {
+				case 0: //普通运算指标
+					calculateInfoArr = append(calculateInfoArr, tmpEdbInfo)
+				case 1: //预测运算指标
+					predictCalculateInfoArr = append(predictCalculateInfoArr, tmpEdbInfo)
+				}
+			}
+			switch v.EdbInfoType {
+			case 0: //普通运算指标
+				calculateInfoArr = append(calculateInfoArr, v)
+			case 1: //预测运算指标
+				predictCalculateInfoArr = append(predictCalculateInfoArr, v)
+			}
+		}
+
+		// 第二次计算指标的map
+		for _, v := range calculateInfoArr {
+			if _, ok := newCalculateMap[v.EdbInfoId]; !ok {
+				calculateArr = append(calculateArr, v.EdbInfoId)
+			}
+			newCalculateMap[v.EdbInfoId] = v
+		}
+	}
+
+	// 普通基础指标去重
+	newBaseEdbInfoArr = make([]*data_manage.EdbInfo, 0)
+	baseMap := make(map[int]int)
+	for _, v := range baseEdbInfoArr {
+		if _, ok := baseMap[v.EdbInfoId]; !ok {
+			newBaseEdbInfoArr = append(newBaseEdbInfoArr, v)
+		}
+		baseMap[v.EdbInfoId] = v.EdbInfoId
+	}
+
+	// 普通计算指标的id
+	sort.Ints(calculateArr)
+
+	// 预测计算指标去重
+	newPredictCalculateMap = make(map[int]*data_manage.EdbInfo)
+	for _, v := range predictCalculateInfoArr {
+		if _, ok := newPredictCalculateMap[v.EdbInfoId]; !ok {
+			predictCalculateArr = append(predictCalculateArr, v.EdbInfoId)
+		}
+		newPredictCalculateMap[v.EdbInfoId] = v
+	}
+	// 预测计算指标的id
+	sort.Ints(predictCalculateArr)
+
+	return
+}

services/data/predict_edb_info.go

@@ -95,6 +95,10 @@ func GetPredictDataListByPredictEdbInfoId(edbInfoId int, startDate, endDate stri
 
 // GetPredictDataListByPredictEdbInfo 根据预测指标信息获取预测指标的数据
 func GetPredictDataListByPredictEdbInfo(edbInfo *data_manage.EdbInfo, startDate, endDate string, isTimeBetween bool) (dataList []*models.EdbDataList, sourceEdbInfoItem *data_manage.EdbInfo, predictEdbConf *data_manage.PredictEdbConf, err error, errMsg string) {
+	// 非计算指标，直接从表里获取数据
+	if edbInfo.EdbType != 1 {
+		return GetPredictCalculateDataListByPredictEdbInfo(edbInfo, startDate, endDate)
+	}
 	// 查找该预测指标配置
 	predictEdbConf, err = data_manage.GetPredictEdbConfById(edbInfo.EdbInfoId)
 	if err != nil && err.Error() != utils.ErrNoRow() {
@@ -156,3 +160,9 @@ func GetPredictDataListByPredictEdbInfo(edbInfo *data_manage.EdbInfo, startDate,
 	}
 	return
 }
+
+// GetPredictCalculateDataListByPredictEdbInfo 根据预测运算指标信息获取预测指标的数据
+func GetPredictCalculateDataListByPredictEdbInfo(edbInfo *data_manage.EdbInfo, startDate, endDate string) (dataList []*models.EdbDataList, sourceEdbInfoItem *data_manage.EdbInfo, predictEdbConf *data_manage.PredictEdbConf, err error, errMsg string) {
+	dataList, err = models.GetEdbDataList(edbInfo.Source, edbInfo.EdbInfoId, startDate, endDate)
+	return
+}

utils/constants.go

@@ -32,36 +32,39 @@ const (
 
 //数据来源渠道
 const (
-	DATA_SOURCE_THS                  = iota + 1 //同花顺
-	DATA_SOURCE_WIND                            //wind
-	DATA_SOURCE_PB                              //彭博
-	DATA_SOURCE_CALCULATE                       //指标运算
-	DATA_SOURCE_CALCULATE_LJZZY                 //累计值转月
-	DATA_SOURCE_CALCULATE_TBZ                   //同比值
-	DATA_SOURCE_CALCULATE_TCZ                   //同差值
-	DATA_SOURCE_CALCULATE_NSZYDPJJS             //N数值移动平均计算
-	DATA_SOURCE_MANUAL                          //手工指标
-	DATA_SOURCE_LZ                              //隆众
-	DATA_SOURCE_YS                              //有色
-	DATA_SOURCE_CALCULATE_HBZ                   //环比值->12
-	DATA_SOURCE_CALCULATE_HCZ                   //环差值->13
-	DATA_SOURCE_CALCULATE_BP                    //变频->14
-	DATA_SOURCE_GL                              //钢联->15
-	DATA_SOURCE_ZZ                              //郑商所->16
-	DATA_SOURCE_DL                              //大商所->17
-	DATA_SOURCE_SH                              //上期所->18
-	DATA_SOURCE_CFFEX                           //中金所->19
-	DATA_SOURCE_SHFE                            //上期能源->20
-	DATA_SOURCE_GIE                             //欧洲天然气->21
-	DATA_SOURCE_CALCULATE_TIME_SHIFT            //时间移位->22
-	DATA_SOURCE_CALCULATE_ZJPJ                  //直接拼接->23
-	DATA_SOURCE_CALCULATE_LJZTBPJ               //累计值同比拼接->24
-	DATA_SOURCE_LT                              //路透->25
-	DATA_SOURCE_COAL                            //煤炭网->26
-	DATA_SOURCE_PYTHON                          //python代码->27
-	DATA_SOURCE_PB_FINANCE                      //彭博财务数据->28
-	DATA_SOURCE_GOOGLE_TRAVEL                   //谷歌出行->29
-	DATA_SOURCE_PREDICT                         //普通预测指标->30
+	DATA_SOURCE_THS                   = iota + 1 //同花顺
+	DATA_SOURCE_WIND                             //wind
+	DATA_SOURCE_PB                               //彭博
+	DATA_SOURCE_CALCULATE                        //指标运算
+	DATA_SOURCE_CALCULATE_LJZZY                  //累计值转月
+	DATA_SOURCE_CALCULATE_TBZ                    //同比值
+	DATA_SOURCE_CALCULATE_TCZ                    //同差值
+	DATA_SOURCE_CALCULATE_NSZYDPJJS              //N数值移动平均计算
+	DATA_SOURCE_MANUAL                           //手工指标
+	DATA_SOURCE_LZ                               //隆众
+	DATA_SOURCE_YS                               //有色
+	DATA_SOURCE_CALCULATE_HBZ                    //环比值->12
+	DATA_SOURCE_CALCULATE_HCZ                    //环差值->13
+	DATA_SOURCE_CALCULATE_BP                     //变频->14
+	DATA_SOURCE_GL                               //钢联->15
+	DATA_SOURCE_ZZ                               //郑商所->16
+	DATA_SOURCE_DL                               //大商所->17
+	DATA_SOURCE_SH                               //上期所->18
+	DATA_SOURCE_CFFEX                            //中金所->19
+	DATA_SOURCE_SHFE                             //上期能源->20
+	DATA_SOURCE_GIE                              //欧洲天然气->21
+	DATA_SOURCE_CALCULATE_TIME_SHIFT             //时间移位->22
+	DATA_SOURCE_CALCULATE_ZJPJ                   //直接拼接->23
+	DATA_SOURCE_CALCULATE_LJZTBPJ                //累计值同比拼接->24
+	DATA_SOURCE_LT                               //路透->25
+	DATA_SOURCE_COAL                             //煤炭网->26
+	DATA_SOURCE_PYTHON                           //python代码->27
+	DATA_SOURCE_PB_FINANCE                       //彭博财务数据->28
+	DATA_SOURCE_GOOGLE_TRAVEL                    //谷歌出行->29
+	DATA_SOURCE_PREDICT                          //普通预测指标->30
+	DATA_SOURCE_PREDICT_CALCULATE                //预测指标运算->31
+	DATA_SOURCE_PREDICT_CALCULATE_TBZ            //同比值->32
+	DATA_SOURCE_PREDICT_CALCULATE_TCZ            //同差值->33
 )
 
 //数据刷新频率