Merge branch 'chart/10.6'

# Conflicts:
#	models/tables/edb_data/query.go
#	utils/constants.go

controller/chart/chart_info.go

@@ -429,7 +429,7 @@ func RefreshChartInfo(c *gin.Context) {
 	}
 
 	// 刷新图表
-	if err = chart.RefreshChart(chartInfo.ChartInfoId); err != nil {
+	if err = chart.ChartInfoRefreshV2(chartInfo.ChartInfoId); err != nil {
 		errContent := fmt.Sprint("ErrMsg: 刷新图表关联指标信息失败, " + err.Error())
 		if global.CONFIG.Serve.RunMode == "release" {
 			go alarm_msg.SendAlarmMsg("刷新图表报错"+time.Now().Format("2006-01-02 15:04:05")+";Err:"+errContent, 3)

models/tables/edb_info/query.go

@@ -1,10 +1,83 @@
 package edb_info
 
-import "hongze/hongze_yb/global"
+import (
+	"hongze/hongze_yb/global"
+	"hongze/hongze_yb/utils"
+)
 
 // GetEdbInfoById 主键获取指标信息
 func GetEdbInfoById(edbInfoId int) (item *EdbInfo, err error) {
 	err = global.MYSQL["data"].Where("edb_info_id = ? ", edbInfoId).First(&item).Error
 
 	return
-}
+}
+
+// GetEdbInfoAllCalculateByEdbInfoIdList 根据指标id集合 获取基础指标对应的所有计算指标
+func GetEdbInfoAllCalculateByEdbInfoIdList(edbInfoIdList []int) (list []*EdbInfo, err error) {
+	num := len(edbInfoIdList)
+	if num <= 0 {
+		return
+	}
+	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 (?)
+			 GROUP BY a.edb_info_id
+			 ORDER BY a.edb_info_id ASC `
+	err = global.MYSQL["data"].Raw(sql, edbInfoIdList).Scan(&list).Error
+	return
+}
+
+// GetEdbInfoByIdList 根据指标id集合 获取 指标列表
+func GetEdbInfoByIdList(edbInfoIdList []int) (items []*EdbInfo, err error) {
+	num := len(edbInfoIdList)
+	if num <= 0 {
+		return
+	}
+	sql := ` SELECT * FROM edb_info WHERE edb_info_id IN (?) `
+	err = global.MYSQL["data"].Raw(sql, edbInfoIdList).Scan(&items).Error
+	return
+}
+
+// GetRefreshEdbInfoFromBase 查询基础指标
+func GetRefreshEdbInfoFromBase(edbInfoId, source int) (baseEdbInfoArr, calculateInfoArr []*EdbInfo, err error) {
+	calculateList, err := GetEdbInfoCalculateMap(edbInfoId)
+	if err != nil && err != 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
+}
+
+// GetEdbInfoCalculateMap 获取计算指标关联信息
+func GetEdbInfoCalculateMap(edbInfoId int) (list []*EdbInfo, err error) {
+	sql := ` SELECT b.* FROM edb_info_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=? ORDER BY sort ASC `
+	err = global.MYSQL["data"].Raw(sql, edbInfoId).Scan(&list).Error
+	return
+}
+
+// GetPredictEdbInfoAllCalculate 根据基础预测指标id集合 获取 所有的普通指标列表数据
+func GetPredictEdbInfoAllCalculate(edbInfoIdList []int) (list []*EdbInfo, err error) {
+	num := len(edbInfoIdList)
+	if num <= 0 {
+		return
+	}
+	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 (?)
+			 GROUP BY a.source_edb_info_id
+			 ORDER BY a.source_edb_info_id ASC `
+	err = global.MYSQL["data"].Raw(sql, edbInfoIdList).Scan(&list).Error
+
+	return
+}

services/chart/chart_info.go

@@ -685,3 +685,37 @@ func GetLeadUnitEn(unit string) (unitEn string) {
 	}
 	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 := chartEdbMappingModel.GetMappingListByChartInfoId(chartInfoId)
+	if err != nil {
+		errmsg = "获取需要刷新的指标失败:Err:" + err.Error()
+		return
+	}
+
+	edbIdList := make([]int, 0)
+	for _, v := range edbMappingList {
+		edbIdList = append(edbIdList, v.EdbInfoId)
+	}
+
+	// 批量刷新
+	err = EdbInfoRefreshAllFromBase(edbIdList, false)
+	if err != nil {
+		return
+	}
+
+	return
+}

services/chart/edb_data.go

@@ -128,3 +128,13 @@ func RefreshEdbCalculateData(edbInfoId int, edbCode, startDate string) (resp *Re
 	resp, err = postRefreshEdbData(param, "/calculate/refresh")
 	return
 }
+
+// RefreshPredictEdbCalculateData 刷新 预测计算指标 数据请求
+func RefreshPredictEdbCalculateData(edbInfoId int, edbCode, startDate string) (resp *RefreshResponse, err error) {
+	param := make(map[string]interface{})
+	param["EdbCode"] = edbCode
+	param["EdbInfoId"] = edbInfoId
+	param["StartDate"] = startDate
+	resp, err = postRefreshEdbData(param, "predict_calculate/refresh")
+	return
+}

services/chart/edb_info.go

@@ -0,0 +1,442 @@
+package chart
+
+import (
+	"errors"
+	"fmt"
+	edbInfoModel "hongze/hongze_yb/models/tables/edb_info"
+	"hongze/hongze_yb/services/alarm_msg"
+	"hongze/hongze_yb/utils"
+	"sort"
+	"time"
+)
+
+// EdbInfoRefreshAllFromBase 全部刷新指标（切换到edb_lib服务）
+// @author Roc
+// @datetime 2022-09-16 11:04:44
+// @description 将原有的单个指标刷新，调整为批量多个指标刷新
+func EdbInfoRefreshAllFromBase(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.IsZero() {
+			continue
+		}
+		//开始时间
+		startDate = ``
+		if refreshAll { //刷新所有数据，用开始时间作为起始日期去刷新
+			startDate = bv.StartDate.Format(utils.FormatDate)
+		} else {
+			sTime := bv.EndDate
+			frequency := bv.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, 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.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_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, 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.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, err := RefreshPredictEdbCalculateData(edbInfo.EdbInfoId, edbInfo.EdbCode, startDate)
+		if err != nil {
+			fmt.Println(v, "RefreshPredictEdbCalculateData err", time.Now())
+			errmsg = "RefreshPredictEdbCalculateData Err:" + err.Error()
+			return err
+		}
+		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("刷新失败")
+		}
+	}
+	return err
+}
+
+// getRefreshEdbInfoList 获取待更新的指标（普通基础指标、普通运算指标，预测运算指标）
+func getRefreshEdbInfoListByIds(edbInfoIdList []int) (newBaseEdbInfoArr []*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())
+		return
+	}
+	// 获取指标信息
+	edbInfoList, err := edbInfoModel.GetEdbInfoByIdList(edbInfoIdList)
+	if err != nil {
+		err = errors.New("GetEdbInfoAllCalGetEdbInfoByIdr:" + err.Error())
+		return
+	}
+
+	baseEdbInfoArr := make([]*edbInfoModel.EdbInfo, 0)          // 基础普通指标
+	calculateInfoArr := make([]*edbInfoModel.EdbInfo, 0)        //基础运算指标
+	basePredictEdbInfoArr := make([]*edbInfoModel.EdbInfo, 0)   // 预测普通指标
+	predictCalculateInfoArr := make([]*edbInfoModel.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 := edbInfoModel.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)
+				if tmpEdbInfo.EdbType == 1 { //预测普通指标
+					basePredictEdbInfoArr = append(basePredictEdbInfoArr, tmpEdbInfo)
+				} else {
+					predictCalculateInfoArr = append(predictCalculateInfoArr, tmpEdbInfo)
+				}
+			}
+		}
+		switch v.EdbInfoType {
+		case 0: //普通运算指标
+			calculateInfoArr = append(calculateInfoArr, v)
+		case 1: //预测运算指标
+			//predictCalculateInfoArr = append(predictCalculateInfoArr, v)
+			if v.EdbType == 1 { //预测普通指标
+				basePredictEdbInfoArr = append(basePredictEdbInfoArr, v)
+			} else {
+				predictCalculateInfoArr = append(predictCalculateInfoArr, v)
+			}
+		}
+	}
+
+	// 预测计算指标
+	for _, v := range predictCalculateInfoArr {
+		getBaseEdbInfoArr, getCalculateInfoArr, tmpErr := edbInfoModel.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)
+				if tmpEdbInfo.EdbType == 1 { //预测普通指标
+					basePredictEdbInfoArr = append(basePredictEdbInfoArr, tmpEdbInfo)
+				} else {
+					predictCalculateInfoArr = append(predictCalculateInfoArr, tmpEdbInfo)
+				}
+			}
+		}
+
+		for _, tmpEdbInfo := range getCalculateInfoArr {
+			switch tmpEdbInfo.EdbInfoType {
+			case 0: //普通运算指标
+				calculateInfoArr = append(calculateInfoArr, tmpEdbInfo)
+			case 1: //预测运算指标
+				//predictCalculateInfoArr = append(predictCalculateInfoArr, tmpEdbInfo)
+				if tmpEdbInfo.EdbType == 1 { //预测普通指标
+					basePredictEdbInfoArr = append(basePredictEdbInfoArr, tmpEdbInfo)
+				} else {
+					predictCalculateInfoArr = append(predictCalculateInfoArr, tmpEdbInfo)
+				}
+			}
+		}
+		switch v.EdbInfoType {
+		case 0: //普通运算指标
+			calculateInfoArr = append(calculateInfoArr, v)
+		case 1: //预测运算指标
+			//predictCalculateInfoArr = append(predictCalculateInfoArr, v)
+			if v.EdbType == 1 { //预测普通指标
+				basePredictEdbInfoArr = append(basePredictEdbInfoArr, v)
+			} else {
+				predictCalculateInfoArr = append(predictCalculateInfoArr, v)
+			}
+		}
+	}
+
+	// 第一次的计算指标map
+	newCalculateMap = make(map[int]*edbInfoModel.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 := edbInfoModel.GetPredictEdbInfoAllCalculate(basePredictEdbInfoIdList)
+		if tmpErr != nil {
+			err = tmpErr
+			return
+		}
+
+		tmpCalculateList := make([]*edbInfoModel.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 := edbInfoModel.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)
+					if v.EdbType == 1 { //预测普通指标
+						basePredictEdbInfoArr = append(basePredictEdbInfoArr, tmpEdbInfo)
+					} else {
+						predictCalculateInfoArr = append(predictCalculateInfoArr, tmpEdbInfo)
+					}
+				}
+			}
+			switch v.EdbInfoType {
+			case 0: //普通运算指标
+				calculateInfoArr = append(calculateInfoArr, v)
+			case 1: //预测运算指标
+				//predictCalculateInfoArr = append(predictCalculateInfoArr, v)
+				if v.EdbType == 1 { //预测普通指标
+					basePredictEdbInfoArr = append(basePredictEdbInfoArr, v)
+				} else { //预测运算指标
+					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([]*edbInfoModel.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]*edbInfoModel.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/chart/predict_edb_info.go

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