Merge branch 'eta/1.2.5'

models/data_manage/edb_info.go

@@ -137,3 +137,16 @@ func GetEdbDataListAll(condition string, pars []interface{}, source, order int)
 	_, err = o.Raw(sql, pars).QueryRows(&item)
 	return
 }
+
+// TraceEdbInfoResp 指标追溯数据返回
+type TraceEdbInfoResp struct {
+	EdbInfoId   int                `description:"指标id"`
+	EdbInfoType int                `description:"指标类型: 0-普通指标; 1-预测指标"`
+	EdbName     string             `description:"指标名称"`
+	EdbType     int                `description:"指标类型: 1-基础指标; 2-计算指标"`
+	RuleTitle   string             `description:"指标规则"`
+	UniqueCode  string             `description:"唯一编码"`
+	ClassifyId  int                `description:"分类ID"`
+	Child       []TraceEdbInfoResp `description:"下级来源"`
+	EdbInfo     *EdbInfo           `description:"指标信息" json:"-"`
+}

models/data_manage/edb_info_calculate.go

@@ -3,6 +3,7 @@ package data_manage
 import (
 	"eta/eta_chart_lib/utils"
 	"github.com/beego/beego/v2/client/orm"
+	"time"
 )
 
 func GetEdbInfoCalculateMap(edbInfoId, source int) (list []*EdbInfo, err error) {
@@ -39,3 +40,36 @@ func GetEdbInfoAllCalculateByEdbInfoIdList(edbInfoIdList []int) (list []*EdbInfo
 	_, err = o.Raw(sql, edbInfoIdList).QueryRows(&list)
 	return
 }
+
+// EdbInfoCalculateMappingInfo
+type EdbInfoCalculateMappingInfo struct {
+	EdbInfoCalculateMappingId int       `orm:"column(edb_info_calculate_mapping_id);pk"`
+	EdbInfoId                 int       `description:"计算指标id"`
+	Source                    int       `description:"计算指标来源"`
+	SourceName                string    `description:"计算指标来源名称"`
+	EdbCode                   string    `description:"计算指标编码"`
+	FromEdbInfoId             int       `description:"基础指标id"`
+	FromEdbCode               string    `description:"基础指标编码"`
+	FromEdbName               string    `description:"基础指标名称"`
+	FromSource                int       `description:"基础指标来源"`
+	FromSourceName            string    `description:"基础指标来源名称"`
+	MoveValue                 int       `description:"领先值"`
+	FromTag                   string    `description:"来源指标标签"`
+	Sort                      int       `description:"计算指标名称排序"`
+	CreateTime                time.Time `description:"创建时间"`
+	ModifyTime                time.Time `description:"修改时间"`
+	FromEdbType               int       `description:"来源指标类型:1:基础指标,2:计算指标"`
+	FromEdbInfoType           int       `description:"来源指标类型: 0-基础指标; 1-预测指标"`
+	FromClassifyId            int       `description:"来源指标分类ID"`
+	FromUniqueCode            string    `description:"来源指标唯一编码"`
+}
+
+// GetEdbInfoCalculateMappingListByEdbInfoId 根据生成的指标id获取来源的指标id列表
+func GetEdbInfoCalculateMappingListByEdbInfoId(edbInfoId int) (items []*EdbInfoCalculateMappingInfo, err error) {
+	o := orm.NewOrmUsingDB("data")
+	sql := ` SELECT a.*,b.edb_type as from_edb_type,b.edb_info_type as from_edb_info_type, b.unique_code AS from_unique_code, b.classify_id AS from_classify_id 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=? `
+	_, err = o.Raw(sql, edbInfoId).QueryRows(&items)
+	return
+}

services/data/edb_info.go

@@ -11,11 +11,13 @@ import (
 	"time"
 )
 
-// EdbInfoRefreshAllFromBase 全部刷新指标（切换到edb_lib服务）
+// EdbInfoRefreshAllFromBaseBak
 // @author Roc
 // @datetime 2022-09-16 11:04:44
-// @description 将原有的单个指标刷新，调整为批量多个指标刷新
-func EdbInfoRefreshAllFromBase(edbInfoIdList []int, refreshAll bool) (err error, errmsg string) {
+// @description 全部刷新指标（切换到edb_lib服务），将原有的单个指标刷新，调整为批量多个指标刷新
+// DeprecatedTime 2023-10-23 09:38:19废弃
+// Deprecated
+func EdbInfoRefreshAllFromBaseBak(edbInfoIdList []int, refreshAll bool) (err error, errmsg string) {
 	defer func() {
 		if err != nil {
 			fmt.Println("EdbInfoRefreshAllFromBaseV2 Err:" + err.Error() + ";errmsg:" + errmsg)
@@ -609,3 +611,596 @@ func GetEdbSourceByEdbInfoIdList(chartEdbInfoMappingList []*models.ChartEdbInfoM
 	}
 	return
 }
+
+// edbInfoRefreshAll
+//
+//	@Description: 指标刷新服务
+//	@author: Roc
+//	@datetime2023-10-23 11:04:30
+//	@param refreshAll bool
+//	@param newBaseEdbInfoArr []*data_manage.EdbInfo
+//	@param newBasePredictEdbInfoArr []*data_manage.EdbInfo
+//	@param newCalculateMap map[int]*data_manage.EdbInfo
+//	@param newPredictCalculateMap map[int]*data_manage.EdbInfo
+//	@param calculateArr []int
+//	@param predictCalculateArr []int
+//	@return err error
+//	@return errmsg string
+func edbInfoRefreshAll(refreshAll bool, newBaseEdbInfoArr, newBasePredictEdbInfoArr []*data_manage.EdbInfo, newCalculateMap, newPredictCalculateMap map[int]*data_manage.EdbInfo, calculateArr, predictCalculateArr []int) (err error, 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)
+		}
+	}()
+
+	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, tmpErr := time.Parse(utils.FormatDate, bv.StartDate)
+			if tmpErr != nil {
+				err = tmpErr
+				errmsg = err.Error()
+				return
+			}
+			startDate = sTime.Format(utils.FormatDate)
+		} else {
+			sTime, tmpErr := time.Parse(utils.FormatDate, bv.EndDate)
+			if tmpErr != nil {
+				err = tmpErr
+				errmsg = err.Error()
+				return
+			}
+			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, 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:" + tmpErr.Error()
+			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)
+			err = fmt.Errorf("刷新失败, err:", errmsg)
+			return
+		}
+
+		//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
+		}
+		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, tmpErr := time.Parse(utils.FormatDate, edbInfo.EndDate)
+					if tmpErr != nil {
+						err = tmpErr
+						errmsg = tmpErr.Error()
+						return
+					}
+					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, tmpErr := RefreshEdbCalculateData(edbInfo.EdbInfoId, edbInfo.EdbCode, startDate)
+		if tmpErr != nil {
+			err = tmpErr
+			fmt.Println(v, "RefreshEdbCalculateData err", time.Now())
+			errmsg = "RefreshEdbCalculateData Err:" + tmpErr.Error()
+			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)
+			err = fmt.Errorf("刷新失败")
+			return
+		}
+	}
+
+	//刷新相关预测计算指标
+	for _, v := range predictCalculateArr {
+		edbInfo := newPredictCalculateMap[v]
+		if edbInfo == nil {
+			return
+		}
+		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, tmpErr := time.Parse(utils.FormatDate, edbInfo.EndDate)
+					if tmpErr != nil {
+						err = tmpErr
+						errmsg = tmpErr.Error()
+						return
+					}
+					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, tmpErr := RefreshPredictEdbCalculateData(edbInfo.EdbInfoId, edbInfo.EdbCode, startDate)
+		if tmpErr != nil {
+			err = tmpErr
+			fmt.Println(v, "RefreshPredictEdbCalculateData err", time.Now())
+			errmsg = "RefreshPredictEdbCalculateData Err:" + tmpErr.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 := data_manage.GetPredictEdbConfCalculateMappingDetailListByEdbInfoId(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
+		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, tmpErr := time.Parse(utils.FormatDate, edbInfo.EndDate)
+					if tmpErr != nil {
+						err = tmpErr
+						errmsg = tmpErr.Error()
+						return
+					}
+					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, tmpErr := RefreshPredictEdbCalculateData(edbInfo.EdbInfoId, edbInfo.EdbCode, startDate)
+		if tmpErr != nil {
+			err = tmpErr
+			fmt.Println(v, "RefreshPredictEdbCalculateData err", time.Now())
+			errmsg = "RefreshPredictEdbCalculateData Err:" + tmpErr.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
+		}
+	}
+
+	return
+}
+
+// EdbInfoRefreshAllFromBaseV3
+//
+//	@Description: 全部刷新指标（切换到edb_lib服务）
+//	@author: Roc
+//	@datetime2023-10-23 09:57:55
+//	@param edbInfoIdList []int
+//	@param refreshAll bool
+//	@param isSync bool
+//	@return err error
+//	@return isAsync bool
+func EdbInfoRefreshAllFromBase(edbInfoIdList []int, refreshAll bool) (err error, errMsg string) {
+	defer func() {
+		if err != nil {
+			fmt.Println("EdbInfoRefreshAllFromBaseV3 Err:" + err.Error() + ";errMsg:" + errMsg)
+			go alarm_msg.SendAlarmMsg("EdbInfoRefreshAllFromBaseV3,Err"+err.Error()+";errMsg:"+errMsg, 3)
+		}
+	}()
+	traceEdbInfoList, err := TraceEdbInfoByEdbInfoIdList(edbInfoIdList)
+	if err != nil {
+		return
+	}
+	// existEdbInfoIdMap 已经处理了的指标id map
+	existEdbInfoIdMap := make(map[int]int)
+
+	// 基础指标
+	newBaseEdbInfoArr := make([]*data_manage.EdbInfo, 0)
+	newBasePredictEdbInfoArr := make([]*data_manage.EdbInfo, 0)
+	newBaseMap := make(map[int]*data_manage.EdbInfo)
+	newPredictBaseMap := make(map[int]*data_manage.EdbInfo)
+
+	// 计算指标
+	newCalculateMap := make(map[int]*data_manage.EdbInfo)
+	newPredictCalculateMap := make(map[int]*data_manage.EdbInfo)
+	calculateArr := make([]int, 0)
+	predictCalculateArr := make([]int, 0)
+
+	// 获取关联指标
+	for _, traceEdbInfo := range traceEdbInfoList {
+		tmpBaseEdbInfoArr, tmpBasePredictEdbInfoArr, tmpCalculateMap, tmpPredictCalculateMap, _, _ := getRefreshEdbInfoListByTraceEdbInfo(traceEdbInfo, existEdbInfoIdMap)
+
+		// 普通基础指标
+		for _, edbInfo := range tmpBaseEdbInfoArr {
+			if _, ok := newBaseMap[edbInfo.EdbInfoId]; !ok {
+				newBaseMap[edbInfo.EdbInfoId] = edbInfo
+				newBaseEdbInfoArr = append(newBaseEdbInfoArr, edbInfo)
+			}
+		}
+
+		// 预测基础指标
+		for _, edbInfo := range tmpBasePredictEdbInfoArr {
+			if _, ok := newPredictBaseMap[edbInfo.EdbInfoId]; !ok {
+				newPredictBaseMap[edbInfo.EdbInfoId] = edbInfo
+				newBasePredictEdbInfoArr = append(newBasePredictEdbInfoArr, edbInfo)
+			}
+		}
+
+		// 普通计算指标
+		for _, edbInfo := range tmpCalculateMap {
+			if _, ok := newCalculateMap[edbInfo.EdbInfoId]; !ok {
+				newCalculateMap[edbInfo.EdbInfoId] = edbInfo
+				calculateArr = append(calculateArr, edbInfo.EdbInfoId)
+			}
+		}
+
+		// 预测计算指标
+		for _, edbInfo := range tmpPredictCalculateMap {
+			if _, ok := newPredictCalculateMap[edbInfo.EdbInfoId]; !ok {
+				newPredictCalculateMap[edbInfo.EdbInfoId] = edbInfo
+				predictCalculateArr = append(predictCalculateArr, edbInfo.EdbInfoId)
+			}
+		}
+	}
+
+	// 普通计算指标的id
+	sort.Ints(calculateArr)
+	// 预测计算指标的id
+	sort.Ints(predictCalculateArr)
+
+	// 需要刷新的指标数量
+	//totalEdbInfo := len(newBaseEdbInfoArr) + len(calculateArr) + len(predictCalculateArr)
+	//if totalEdbInfo <= 20{
+	//	err,errMsg = edbInfoRefreshAll(refreshAll, newBaseEdbInfoArr, newBasePredictEdbInfoArr, newCalculateMap, newPredictCalculateMap, calculateArr, predictCalculateArr)
+	//} else {
+	//	go edbInfoRefreshAll(refreshAll, newBaseEdbInfoArr, newBasePredictEdbInfoArr, newCalculateMap, newPredictCalculateMap, calculateArr, predictCalculateArr)
+	//}
+	err, errMsg = edbInfoRefreshAll(refreshAll, newBaseEdbInfoArr, newBasePredictEdbInfoArr, newCalculateMap, newPredictCalculateMap, calculateArr, predictCalculateArr)
+
+	return
+}
+
+// getRefreshEdbInfoListByTraceEdbInfo
+//
+//	@Description: 根据溯源获取关联指标（去掉重复指标id）
+//	@author: Roc
+//	@datetime2023-10-23 11:22:50
+//	@param traceEdbInfo data_manage.TraceEdbInfoResp
+//	@param existEdbInfoIdMap map[int]int
+//	@return newBaseEdbInfoArr []*data_manage.EdbInfo
+//	@return newBasePredictEdbInfoArr []*data_manage.EdbInfo
+//	@return newCalculateMap map[int]*data_manage.EdbInfo
+//	@return newPredictCalculateMap map[int]*data_manage.EdbInfo
+//	@return calculateArr []int
+//	@return predictCalculateArr []int
+func getRefreshEdbInfoListByTraceEdbInfo(traceEdbInfo data_manage.TraceEdbInfoResp, existEdbInfoIdMap map[int]int) (newBaseEdbInfoArr, newBasePredictEdbInfoArr []*data_manage.EdbInfo, newCalculateMap, newPredictCalculateMap map[int]*data_manage.EdbInfo, calculateArr, predictCalculateArr []int) {
+	newBaseEdbInfoArr = make([]*data_manage.EdbInfo, 0)
+	newBasePredictEdbInfoArr = make([]*data_manage.EdbInfo, 0)
+	newCalculateMap = make(map[int]*data_manage.EdbInfo)
+	newPredictCalculateMap = make(map[int]*data_manage.EdbInfo)
+	calculateArr = make([]int, 0)
+	predictCalculateArr = make([]int, 0)
+
+	_, ok := existEdbInfoIdMap[traceEdbInfo.EdbInfoId]
+	if ok {
+		return
+	}
+
+	existEdbInfoIdMap[traceEdbInfo.EdbInfoId] = traceEdbInfo.EdbInfoId
+
+	switch traceEdbInfo.EdbInfoType {
+	//0-普通指标; 1-预测指标
+	case 0: // 0-普通指标
+		if traceEdbInfo.EdbType == 1 { //1-基础指标
+			newBaseEdbInfoArr = append(newBaseEdbInfoArr, traceEdbInfo.EdbInfo)
+		} else if traceEdbInfo.EdbType == 2 { //2-计算指标
+			newCalculateMap[traceEdbInfo.EdbInfoId] = traceEdbInfo.EdbInfo
+			calculateArr = append(calculateArr, traceEdbInfo.EdbInfoId)
+		}
+	case 1: // 1-预测指标
+		if traceEdbInfo.EdbType == 1 { //1-基础指标
+			newBasePredictEdbInfoArr = append(newBasePredictEdbInfoArr, traceEdbInfo.EdbInfo)
+		} else if traceEdbInfo.EdbType == 2 { //2-计算指标
+			newPredictCalculateMap[traceEdbInfo.EdbInfoId] = traceEdbInfo.EdbInfo
+			predictCalculateArr = append(predictCalculateArr, traceEdbInfo.EdbInfoId)
+		}
+	}
+
+	if traceEdbInfo.Child != nil && len(traceEdbInfo.Child) > 0 {
+		for _, v := range traceEdbInfo.Child {
+			tmpBaseEdbInfoArr, tmpPredictEdbInfoArr, tmpCalculateMap, tmpPredictCalculateMap, tmpCalculateArr, tmpPredictCalculateArr := getRefreshEdbInfoListByTraceEdbInfo(v, existEdbInfoIdMap)
+
+			newBaseEdbInfoArr = append(newBaseEdbInfoArr, tmpBaseEdbInfoArr...)
+			newBasePredictEdbInfoArr = append(newBasePredictEdbInfoArr, tmpPredictEdbInfoArr...)
+
+			for k, tmpEdbInfo := range tmpCalculateMap {
+				newCalculateMap[k] = tmpEdbInfo
+			}
+
+			for k, tmpEdbInfo := range tmpPredictCalculateMap {
+				newPredictCalculateMap[k] = tmpEdbInfo
+			}
+
+			calculateArr = append(calculateArr, tmpCalculateArr...)
+			predictCalculateArr = append(predictCalculateArr, tmpPredictCalculateArr...)
+		}
+	}
+
+	return
+}
+
+// TraceEdbInfoByEdbInfoIdList
+//
+//	@Description: 根据指标id列表返回指标追溯的列表
+//	@author: Roc
+//	@datetime2023-10-23 11:22:21
+//	@param edbInfoIdList []int
+//	@return traceEdbInfoList []data_manage.TraceEdbInfoResp
+//	@return err error
+func TraceEdbInfoByEdbInfoIdList(edbInfoIdList []int) (traceEdbInfoList []data_manage.TraceEdbInfoResp, err error) {
+	traceEdbInfoList = make([]data_manage.TraceEdbInfoResp, 0)
+	edbInfoList, err := data_manage.GetEdbInfoByIdList(edbInfoIdList)
+	if err != nil {
+		return
+	}
+	edbInfoRuleMap := make(map[int]string, 0)
+	edbMappingMap := make(map[int][]*data_manage.EdbInfoCalculateMappingInfo)
+
+	findIdMap := make(map[int]int)
+	existMap := make(map[int]data_manage.TraceEdbInfoResp)
+
+	for _, edbInfo := range edbInfoList {
+		findIdMap[edbInfo.EdbInfoId] = edbInfo.EdbInfoId
+		//edbInfoRuleMap[edbInfoId] = getEdbRuleTitle(edbInfo)
+		traceEdbInfo := data_manage.TraceEdbInfoResp{
+			//EdbInfoId: edbInfo.EdbInfoId,
+			EdbInfoId:   edbInfo.EdbInfoId,
+			EdbInfoType: edbInfo.EdbInfoType,
+			EdbName:     edbInfo.EdbName,
+			EdbType:     edbInfo.EdbType,
+			//Source:      edbInfo.Source,
+			UniqueCode: edbInfo.UniqueCode,
+			ClassifyId: edbInfo.ClassifyId,
+			EdbInfo:    edbInfo,
+		}
+		traceEdbInfo.Child, err = traceEdbInfoByEdbInfoId(edbInfo.EdbInfoId, traceEdbInfo, edbInfoRuleMap, findIdMap, existMap, edbMappingMap)
+		traceEdbInfoList = append(traceEdbInfoList, traceEdbInfo)
+	}
+
+	//findEdbInfoIdList := make([]int, 0)
+	//for _, v := range findIdMap {
+	//	findEdbInfoIdList = append(findEdbInfoIdList, v)
+	//}
+	//findEdbInfoList, err := data_manage.GetEdbInfoByIdList(findEdbInfoIdList)
+	//if err != nil {
+	//	return
+	//}
+	//edbInfoMap := make(map[int]*data_manage.EdbInfo)
+	//for _, tmpEdbInfo := range findEdbInfoList {
+	//	edbInfoMap[tmpEdbInfo.EdbInfoId] = tmpEdbInfo
+	//}
+	//for k, traceEdbInfo := range traceEdbInfoList {
+	//	traceEdbInfoList[k], err = handleTraceEdbInfo(traceEdbInfo, 0, edbInfoMap, edbMappingMap)
+	//}
+	return
+}
+
+// traceEdbInfoByEdbInfoId
+//
+//	@Description: 指标追溯
+//	@author: Roc
+//	@datetime2023-10-23 11:21:54
+//	@param edbInfoId int
+//	@param traceEdbInfo data_manage.TraceEdbInfoResp
+//	@param edbInfoRuleMap map[int]string
+//	@param findIdMap map[int]int
+//	@param existMap map[int]data_manage.TraceEdbInfoResp
+//	@param edbMappingMap map[int][]*data_manage.EdbInfoCalculateMappingInfo
+//	@return child []data_manage.TraceEdbInfoResp
+//	@return err error
+func traceEdbInfoByEdbInfoId(edbInfoId int, traceEdbInfo data_manage.TraceEdbInfoResp, edbInfoRuleMap map[int]string, findIdMap map[int]int, existMap map[int]data_manage.TraceEdbInfoResp, edbMappingMap map[int][]*data_manage.EdbInfoCalculateMappingInfo) (child []data_manage.TraceEdbInfoResp, err error) {
+	traceEdbInfo, ok := existMap[edbInfoId]
+	if ok {
+		return
+	}
+	child = make([]data_manage.TraceEdbInfoResp, 0)
+
+	edbInfoMappingList, e := data_manage.GetEdbInfoCalculateMappingListByEdbInfoId(edbInfoId)
+	if e != nil {
+		err = fmt.Errorf("GetEdbInfoCalculateMappingListByEdbInfoId err: %s", e.Error())
+		return
+	}
+
+	// 指标信息map
+	edbInfoMap := make(map[int]*data_manage.EdbInfo)
+	if len(edbInfoMappingList) > 0 {
+		fromEdbInfoIdList := make([]int, 0)
+		for _, v := range edbInfoMappingList {
+			fromEdbInfoIdList = append(fromEdbInfoIdList, v.FromEdbInfoId)
+		}
+		edbInfoList, tmpErr := data_manage.GetEdbInfoByIdList(fromEdbInfoIdList)
+		if tmpErr != nil {
+			err = fmt.Errorf("traceEdbInfoByEdbInfoId GetEdbInfoByIdList err: %s", tmpErr.Error())
+			return
+		}
+		for _, v := range edbInfoList {
+			edbInfoMap[v.EdbInfoId] = v
+		}
+
+	}
+
+	edbMappingMap[edbInfoId] = edbInfoMappingList
+	for _, v := range edbInfoMappingList {
+		tmpEdbInfoId := v.FromEdbInfoId
+		tmpTraceEdbInfo := data_manage.TraceEdbInfoResp{
+			EdbInfoId:   tmpEdbInfoId,
+			EdbInfoType: v.FromEdbInfoType,
+			EdbType:     v.FromEdbType,
+			UniqueCode:  v.FromUniqueCode,
+			ClassifyId:  v.FromClassifyId,
+			EdbInfo:     edbInfoMap[v.FromEdbInfoId],
+		}
+
+		// 计算指标/预测指标继续溯源
+		if v.FromEdbType == 2 || v.FromEdbInfoType == 1 {
+			// 查过了就不查了
+			if _, ok2 := findIdMap[tmpEdbInfoId]; !ok2 {
+				tmpTraceEdbInfo.Child, e = traceEdbInfoByEdbInfoId(tmpEdbInfoId, tmpTraceEdbInfo, edbInfoRuleMap, findIdMap, existMap, edbMappingMap)
+				if e != nil {
+					err = fmt.Errorf("traceEdbInfoByEdbInfoId err: %s", e.Error())
+					return
+				}
+			}
+		}
+		child = append(child, tmpTraceEdbInfo)
+		findIdMap[tmpEdbInfoId] = tmpEdbInfoId
+	}
+	existMap[edbInfoId] = traceEdbInfo
+	return
+}