eta_api/services/data/edb_info.go

package data

import (
	"encoding/json"
	"errors"
	"eta_gn/eta_api/cache"
	"eta_gn/eta_api/models"
	"eta_gn/eta_api/models/data_manage"
	"eta_gn/eta_api/models/data_manage/excel"
	"eta_gn/eta_api/services/alarm_msg"
	"eta_gn/eta_api/services/data/data_manage_permission"
	"eta_gn/eta_api/services/elastic"
	"eta_gn/eta_api/utils"
	"fmt"
	"sort"
	"strconv"
	"strings"
	"time"
)

func EdbInfoRefreshAllFromBaseV2(edbInfoId int, refreshAll, isRefreshTop bool) (err error, isAsync bool) {
	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)
		}
	}()

	err, isAsync = EdbInfoRefreshAllFromBaseV3([]int{edbInfoId}, refreshAll, false, isRefreshTop)
	return
}

func EdbInfoRefreshAllFromBaseV3(edbInfoIdList []int, refreshAll, isSync, isRefreshTop bool) (err error, isAsync bool) {
	var 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)
		}
	}()

	var newBaseEdbInfoArr, newBasePredictEdbInfoArr []*data_manage.EdbInfo
	var newCalculateMap, newPredictCalculateMap map[int]*data_manage.EdbInfo
	var calculateArr, predictCalculateArr []int

	if isRefreshTop {
		newBaseEdbInfoArr, newBasePredictEdbInfoArr, newCalculateMap, newPredictCalculateMap, calculateArr, predictCalculateArr, err, errmsg = getRefreshEdbInfoListByIds(edbInfoIdList)
		if err != nil {
			return
		}
	} else {
		newBaseEdbInfoArr, newBasePredictEdbInfoArr, newCalculateMap, newPredictCalculateMap, calculateArr, predictCalculateArr = getEdbInfoIdList(edbInfoIdList)
	}

	totalEdbInfo := len(newBaseEdbInfoArr) + len(calculateArr) + len(predictCalculateArr) + len(newBasePredictEdbInfoArr)
	if totalEdbInfo == 0 {
		return
	}
	if totalEdbInfo <= 20 || isSync {
		err = edbInfoRefreshAll(refreshAll, newBaseEdbInfoArr, newBasePredictEdbInfoArr, newCalculateMap, newPredictCalculateMap, calculateArr, predictCalculateArr)
	} else {
		isAsync = true
		go edbInfoRefreshAll(refreshAll, newBaseEdbInfoArr, newBasePredictEdbInfoArr, newCalculateMap, newPredictCalculateMap, calculateArr, predictCalculateArr)
	}

	return
}

func getEdbInfoIdList(edbInfoIdList []int) (newBaseEdbInfoArr, newBasePredictEdbInfoArr []*data_manage.EdbInfo, newCalculateMap, newPredictCalculateMap map[int]*data_manage.EdbInfo, calculateArr, predictCalculateArr []int) {
	traceEdbInfoList, err := TraceEdbInfoByEdbInfoIdList(edbInfoIdList)

	if err != nil {
		return
	}
	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
				if edbInfo.NoUpdate == 1 {
					continue
				}
				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 {
				if edbInfo.NoUpdate == 1 {
					continue
				}
				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)
			}
		}
	}

	sort.Ints(calculateArr)
	sort.Ints(predictCalculateArr)

	return
}

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 {
	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
}

func edbInfoRefreshAll(refreshAll bool, newBaseEdbInfoArr, newBasePredictEdbInfoArr []*data_manage.EdbInfo, newCalculateMap, newPredictCalculateMap map[int]*data_manage.EdbInfo, calculateArr, predictCalculateArr []int) (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)
		}
	}()

	var startDate string
	for _, bv := range newBaseEdbInfoArr {
		startDate = ``
		if refreshAll { //刷新所有数据，那么就是从配置的开始时间开始刷新
			startDate = utils.BaseEdbRefreshStartDate
		} else {
			sTime := bv.EndDate
			if sTime.IsZero() {
				sTime, _ = time.ParseInLocation(utils.FormatDate, utils.BaseEdbRefreshStartDate, time.Local)
			}

			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.SubSource, 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)
		}

	}

	for _, v := range calculateArr {
		edbInfo := newCalculateMap[v]
		if edbInfo == nil {
			return err
		}

		startDate = ``
		if !refreshAll { //如果不是全部更新，那么以指标的开始时间作为刷新
			startDate = utils.TimeToFormatDate(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 {
					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 = utils.TimeToFormatDate(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 = utils.TimeToFormatDate(edbInfo.StartDate)
				} 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, "RefreshEdbCalculateData err", time.Now())
			errmsg = "RefreshEdbCalculateData 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("刷新失败")
		}
	}

	{
		predictEdbInfoIdList := make([]int, 0)
		for _, v := range newBasePredictEdbInfoArr {
			predictEdbInfoIdList = append(predictEdbInfoIdList, v.EdbInfoId)
		}
		predictEdbConfCalculateMappingDetailList, err := data_manage.GetPredictEdbConfCalculateMappingDetailListByEdbInfoId(predictEdbInfoIdList)
		if err != nil {
			errmsg = fmt.Sprint("更新动态环差值时，获取数据失败:" + err.Error())
			return fmt.Errorf("刷新失败, err:", errmsg)
		}
		for _, bv := range predictEdbConfCalculateMappingDetailList {
			result, err := RefreshEdbData(bv.EdbInfoId, utils.DATA_SOURCE_PREDICT, utils.DATA_SUB_SOURCE_EDB, bv.EdbCode, "")
			if err != nil {
				fmt.Println(bv.EdbInfoId, "RefreshBasePredictEdbData err", time.Now())
				errmsg = "RefreshBasePredictEdbData Err:" + err.Error()
				return err
			}
			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)
				return fmt.Errorf("刷新失败, err:%s", errmsg)
			}
		}
	}

	for _, v := range predictCalculateArr {
		edbInfo := newPredictCalculateMap[v]
		if edbInfo == nil {
			return err
		}
		startDate = utils.TimeToFormatDate(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 = utils.TimeToFormatDate(edbInfo.StartDate)
				} 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, "RefreshEdbCalculateData err", time.Now())
			errmsg = "RefreshEdbCalculateData 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
}

func EdbInfoRefresh(edbInfo *data_manage.EdbInfoView, refreshAll bool) (err error) {
	var errmsg string
	defer func() {
		if err != nil {
			fmt.Println("EdbInfoRefresh Err:" + err.Error() + ";errmsg:" + errmsg)
			go alarm_msg.SendAlarmMsg("EdbInfoRefresh,Err"+err.Error()+";errMsg:"+errmsg, 3)
		}
	}()
	switch edbInfo.EdbInfoType {
	case 0:
		if edbInfo.StartDate == "0000-00-00" {
			return
		}
		startDate := utils.BaseEdbRefreshStartDate // 默认成刷新开始日期
		if edbInfo.EdbType == 1 {
			if !refreshAll { //刷新所有数据，用开始时间作为起始日期去刷新
				sDate := edbInfo.EndDate
				if sDate == `` || sDate == `0000-00-00` {
					sDate = utils.BaseEdbRefreshStartDate
				}
				sTime, err := time.Parse(utils.FormatDate, sDate)
				if err != nil {
					return err
				}

				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 := RefreshEdbData(edbInfo.EdbInfoId, edbInfo.Source, edbInfo.SubSource, edbInfo.EdbCode, startDate)
			if err != nil {
				fmt.Println(edbInfo.EdbInfoId, "RefreshBaseEdbData err", time.Now())
				errmsg = "RefreshBaseEdbData Err:" + err.Error()
				return err
			}
			if result.Ret != 200 {
				fmt.Println(edbInfo.EdbInfoId, "RefreshBaseEdbData err;msg:", result.Msg, ";errMsg:", result.ErrMsg)
				errmsg = fmt.Sprint(edbInfo.EdbInfoId, "RefreshBaseEdbData err;msg:", result.Msg, ";errMsg:", result.ErrMsg)
				return fmt.Errorf("刷新失败, err:", errmsg)
			}
		} else { //计算指标
			if !refreshAll { //如果不是全部更新，那么以指标的开始时间作为刷新
				source := edbInfo.Source
				if source == utils.DATA_SOURCE_CALCULATE {
					sDate := edbInfo.EndDate
					if sDate == `` || sDate == `0000-00-00` {
						sDate = utils.BaseEdbRefreshStartDate
					}
					sTime, err := time.Parse(utils.FormatDate, sDate)
					if err != nil {
						return err
					}

					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(edbInfo.EdbInfoId, "RefreshEdbCalculateData err", time.Now())
				errmsg = "RefreshEdbCalculateData Err:" + err.Error()
				return err
			}
			if result.Ret != 200 {
				fmt.Println(edbInfo.EdbInfoId, "RefreshEdbCalculateData err;msg:", result.Msg, ";errMsg:", result.ErrMsg)
				errmsg = fmt.Sprint(edbInfo.EdbInfoId, "RefreshEdbCalculateData err;msg:", result.Msg, ";errMsg:", result.ErrMsg)
				return fmt.Errorf("刷新失败")
			}
		}
	case 1:
		startDate := edbInfo.StartDate
		var result *models.BaseResponse
		if startDate == "" || startDate == "0000-00-00" { //如果没有开始日期，说明还没有计算出来数据，那么就往前面推40年吧（也意味着重新计算了）
			startDate = time.Now().AddDate(-40, 0, 0).Format(utils.FormatDate)
		} else {
			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_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)
			}
		}
		if edbInfo.EdbType == 1 { //基础指标
			result, err = RefreshPredictEdbCalculateData(edbInfo.EdbInfoId, edbInfo.EdbCode, startDate)
		} else {
			{
				predictEdbConfCalculateMappingDetailList, err := data_manage.GetPredictEdbConfCalculateMappingDetailListByEdbInfoId([]int{edbInfo.EdbInfoId})
				if err != nil {
					errmsg = fmt.Sprint("更新动态环差值时，获取数据失败:" + err.Error())
					return fmt.Errorf("刷新失败, err:", errmsg)
				}
				for _, bv := range predictEdbConfCalculateMappingDetailList {
					result, err := RefreshEdbData(bv.EdbInfoId, utils.DATA_SOURCE_PREDICT, utils.DATA_SUB_SOURCE_EDB, bv.EdbCode, "")
					if err != nil {
						fmt.Println(bv.EdbInfoId, "RefreshBasePredictEdbData err", time.Now())
						errmsg = "RefreshBasePredictEdbData Err:" + err.Error()
						return err
					}
					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)
						return fmt.Errorf("刷新失败, err:%s", errmsg)
					}
				}
			}
		}

		if err != nil {
			fmt.Println(edbInfo.EdbInfoId, "RefreshEdbCalculateData err", time.Now())
			errmsg = "RefreshEdbCalculateData Err:" + err.Error()
			return err
		}
		if result.Ret != 200 {
			fmt.Println(edbInfo.EdbInfoId, "RefreshPredictEdbCalculateData err;msg:", result.Msg, ";errMsg:", result.ErrMsg)
			errmsg = fmt.Sprint(edbInfo.EdbInfoId, "RefreshPredictEdbCalculateData err;msg:", result.Msg, ";errMsg:", result.ErrMsg)
			return fmt.Errorf("刷新失败")
		}
	}

	return err
}

func AddEdbInfo(secName, unit, frequency, noticeTime, mobile string, classifyId, userId int, userName string) (err error) {
	tradeCode, err := models.GetMaxTradeCode()
	if err != nil {
		return
	}

	if tradeCode == "" {
		err = errors.New("最大编码为空")
		return
	}
	maxTradeCode, err := utils.GetMaxTradeCode(tradeCode)
	if err != nil {
		err = errors.New("获取编码信息失败,Err:" + err.Error())
		return
	}
	if maxTradeCode == "" {
		err = errors.New("编码为空，请联系技术")
		return
	}
	if secName == "" {
		err = errors.New("指标名称不能为空")
		return
	}
	item, err := models.GetEdbinfoBySecName(secName)
	if err != nil && !utils.IsErrNoRow(err) {
		err = errors.New("获取信息失败，Err:" + err.Error())
		return
	}
	if item != nil {
		err = errors.New("指标名称已存在")
		return
	}
	_ = models.DeleteAllEdbData(maxTradeCode)
	_ = models.DelEdbinfoOpRecordByTradeCode(maxTradeCode)
	err = models.AddEdbinfo(maxTradeCode, secName, unit, "手动", frequency, noticeTime, classifyId, userId, userName)
	if err != nil {
		err = errors.New("新增失败，Err:" + err.Error())
		return
	}
	err = models.AddEdbinfoUser(maxTradeCode, mobile)
	return
}

func AddOrEditEdbInfoToEs(edbInfoId int) {
	itemInfo, _ := data_manage.GetEdbInfoByCondition("AND edb_info_id=?", []interface{}{edbInfoId})
	go elastic.EsAddOrEditEdbInfoData(utils.DATA_INDEX_NAME, strconv.Itoa(itemInfo.EdbInfoId), itemInfo)
}

func DeleteEdbInfoToEs(edbInfoId int) {
	go elastic.EsDeleteEdbInfoData(utils.DATA_INDEX_NAME, strconv.Itoa(edbInfoId))
}

func RefreshManualData(edbCode string) {
	var err error
	defer func() {
		if err != nil {
			go alarm_msg.SendAlarmMsg("导入手工数据后，根据手工指标code刷新手工指标数据失败提醒,Err"+err.Error(), 3)
		}
	}()
	edbInfo, err := data_manage.GetEdbInfoByEdbCode(utils.DATA_SOURCE_MANUAL, edbCode)
	if err != nil {
		if utils.IsErrNoRow(err) {
			err = nil
		}
		return
	}
	err, _ = EdbInfoRefreshAllFromBaseV2(edbInfo.EdbInfoId, true, true)
	return
}

func GetFrequencyEn(frequency string) (frequencyEn string) {
	switch frequency {
	case "日度":
		frequencyEn = "day"
		return
	case "周度":
		frequencyEn = "week"
		return
	case "旬度":
		frequencyEn = "ten days"
		return
	case "月度":
		frequencyEn = "month"
		return
	case "季度":
		frequencyEn = "quarter"
		return
	case "年度":
		frequencyEn = "year"
		return
	}
	return
}

func GetLeadUnitEn(unit string) (unitEn string) {
	switch unit {
	case "天":
		unitEn = "day"
		return
	case "周":
		unitEn = "week"
		return
	case "月":
		unitEn = "month"
		return
	case "季":
		unitEn = "quarter"
		return
	case "年":
		unitEn = "year"
		return
	}
	return
}

func getRefreshEdbInfoListByIds(edbInfoIdList []int) (newBaseEdbInfoArr, newBasePredictEdbInfoArr []*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 && !utils.IsErrNoRow(err) {
		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.NoUpdate == 1 {
			continue
		}
		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: //预测运算指标
				if tmpEdbInfo.EdbType == 1 { //预测普通指标
					basePredictEdbInfoArr = append(basePredictEdbInfoArr, tmpEdbInfo)
				} else {
					predictCalculateInfoArr = append(predictCalculateInfoArr, tmpEdbInfo)
				}
			}
		}
		switch v.EdbInfoType {
		case 0: //普通运算指标
			calculateInfoArr = append(calculateInfoArr, v)
		case 1: //预测指标
			if v.EdbType == 1 { //预测普通指标
				basePredictEdbInfoArr = append(basePredictEdbInfoArr, v)
			} else {
				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: //预测基础指标
				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: //预测运算指标
				if tmpEdbInfo.EdbType == 1 { //预测普通指标
					basePredictEdbInfoArr = append(basePredictEdbInfoArr, tmpEdbInfo)
				} else {
					predictCalculateInfoArr = append(predictCalculateInfoArr, tmpEdbInfo)
				}
			}
		}
		switch v.EdbInfoType {
		case 0: //普通运算指标
			calculateInfoArr = append(calculateInfoArr, v)
		case 1: //预测指标
			if v.EdbType == 1 { //预测普通指标
				basePredictEdbInfoArr = append(basePredictEdbInfoArr, v)
			} else {
				predictCalculateInfoArr = append(predictCalculateInfoArr, v)
			}
		}
	}

	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: //预测运算指标
					if v.EdbType == 1 { //预测普通指标
						basePredictEdbInfoArr = append(basePredictEdbInfoArr, tmpEdbInfo)
					} else {
						predictCalculateInfoArr = append(predictCalculateInfoArr, tmpEdbInfo)
					}
				}
			}

			switch v.EdbInfoType {
			case 0: //普通运算指标
				calculateInfoArr = append(calculateInfoArr, v)
			case 1: //预测指标
				if v.EdbType == 1 { //预测普通指标
					basePredictEdbInfoArr = append(basePredictEdbInfoArr, v)
				} else { //预测运算指标
					predictCalculateInfoArr = append(predictCalculateInfoArr, v)
				}
			}
		}

		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
	}

	sort.Ints(calculateArr)

	newBasePredictEdbInfoArr = make([]*data_manage.EdbInfo, 0)
	basePredictMap := make(map[int]int)
	for _, v := range basePredictEdbInfoArr {
		if _, ok := basePredictMap[v.EdbInfoId]; !ok {
			newBasePredictEdbInfoArr = append(newBasePredictEdbInfoArr, v)
		}
		basePredictMap[v.EdbInfoId] = v.EdbInfoId
	}

	newPredictCalculateMap = make(map[int]*data_manage.EdbInfo)
	for _, v := range predictCalculateInfoArr {
		if _, ok := newPredictCalculateMap[v.EdbInfoId]; !ok {
			predictCalculateArr = append(predictCalculateArr, v.EdbInfoId)
		}
		newPredictCalculateMap[v.EdbInfoId] = v
	}
	sort.Ints(predictCalculateArr)

	return
}

type AddEdbBaseInfoReq struct {
	EdbCode         string `description:"指标编码"`
	EdbName         string `description:"指标名称"`
	Unit            string `description:"单位"`
	ClassifyId      int    `description:"所属分类"`
	SysUserId       int    `description:"用户id"`
	SysUserRealName string `description:"用户真实名称"`
}

func EdbInfoAdd(source, subSource, classifyId int, edbCode, edbName, frequency, unit, startDate, endDate string, sysUserId int, sysUserRealName, lang string) (edbInfo *data_manage.EdbInfo, err error, errMsg string, isSendEmail bool) {
	if source == utils.DATA_SOURCE_BUSINESS {
		req2 := AddEdbBaseInfoReq{
			EdbCode:         edbCode,
			EdbName:         edbName,
			Unit:            unit,
			ClassifyId:      classifyId,
			SysUserId:       sysUserId,
			SysUserRealName: sysUserRealName,
		}
		reqJson, tmpErr := json.Marshal(req2)
		if tmpErr != nil {
			err = tmpErr
			return
		}
		respItem, tmpErr := AddBaseEdbInfo(string(reqJson), source, subSource, lang)
		if tmpErr != nil {
			errMsg = "添加失败"
			err = tmpErr
			return
		}
		isSendEmail = respItem.IsSendEmail
		if respItem.Ret != 200 {
			errMsg = respItem.Msg
			err = errors.New(respItem.ErrMsg)
		} else {
			edbInfo, err = data_manage.GetEdbInfoById(respItem.Data.EdbInfoId)
		}
		return
	}

	isSendEmail = true

	{
		var count int
		var condition string
		var pars []interface{}


		switch lang {
		case utils.EnLangVersion:
			condition += " AND edb_name_en = ? "
		default:
			condition += " AND edb_name=? "
		}
		pars = append(pars, edbName)

		count, err = data_manage.GetEdbInfoCountByCondition(condition, pars)
		if err != nil {
			errMsg = "判断指标名称是否存在失败"
			err = errors.New("判断指标名称是否存在失败,Err:" + err.Error())
			return
		}

		if count > 0 {
			errMsg = "指标名称已存在，请重新填写"
			err = errors.New(errMsg)
			isSendEmail = false
			return
		}
	}

	edbInfo = new(data_manage.EdbInfo)
	edbInfo.Source = source
	var sourceName string
	edbSource := data_manage.GetEdbSourceBySourceId(source)
	if edbSource != nil {
		sourceName = edbSource.SourceName
	}
	if sourceName == "" {
		errMsg = "指标来源异常"
		err = errors.New(errMsg)
		return
	}
	edbInfo.SourceName = sourceName

	edbType := 1 //基础指标
	if source == utils.DATA_SOURCE_STOCK_PLANT {
		edbType = 2 //计算指标
	}
	terminalCode, serverUrl, sourceIndexName, e := GetEdbTerminalCodeBySource(edbInfo.Source, edbInfo.EdbCode, edbInfo.StockCode)
	if e != nil {
		errMsg = "获取可以使用的终端地址失败"
		err = errors.New("获取可以使用的终端地址失败，Err:" + e.Error())
		return
	}
	maxSort, err := GetEdbClassifyMaxSort(classifyId, 0)
	if err != nil {
		errMsg = "获取失败"
		err = errors.New("查询排序信息失败，Err:" + err.Error())
		return
	}

	edbInfo.EdbCode = edbCode
	edbInfo.EdbName = edbName
	edbInfo.EdbNameEn = edbName
	edbInfo.EdbNameSource = edbName
	edbInfo.Frequency = frequency
	edbInfo.Unit = unit
	edbInfo.UnitEn = unit
	if startDate != `` {
		startDateTime, tmpErr := utils.FormatDateStrToTime(startDate)
		if tmpErr != nil {
			err = tmpErr
			return
		}
		edbInfo.StartDate = startDateTime
	}
	if endDate != `` {
		endDateTime, tmpErr := utils.FormatDateStrToTime(endDate)
		if tmpErr != nil {
			err = tmpErr
			return
		}
		edbInfo.EndDate = endDateTime
	}

	edbInfo.ClassifyId = classifyId
	edbInfo.SysUserId = sysUserId
	edbInfo.SysUserRealName = sysUserRealName
	edbInfo.CreateTime = time.Now()
	edbInfo.ModifyTime = time.Now()
	edbInfo.ServerUrl = serverUrl
	edbInfo.Sort = maxSort + 1
	edbInfo.DataDateType = `交易日`
	edbInfo.TerminalCode = terminalCode
	edbInfo.SourceIndexName = sourceIndexName
	timestamp := strconv.FormatInt(time.Now().UnixNano(), 10)
	edbInfo.UniqueCode = utils.MD5(utils.DATA_PREFIX + "_" + timestamp)
	itemVal, err := data_manage.GetEdbInfoMaxAndMinInfo(source, subSource, edbCode)
	if itemVal != nil && err == nil {
		edbInfo.MaxValue = itemVal.MaxValue
		edbInfo.MinValue = itemVal.MinValue
	}
	edbInfo.EdbType = edbType
	edbInfoId, err := data_manage.AddEdbInfo(edbInfo)
	if err != nil {
		errMsg = "保存失败"
		err = errors.New("保存失败，Err:" + err.Error())
		return
	}
	edbInfo.EdbInfoId = int(edbInfoId)
	data_manage.ModifyEdbInfoDataStatus(edbInfoId, source, subSource, edbCode)

	maxAndMinItem, _ := data_manage.GetEdbInfoMaxAndMinInfo(source, subSource, edbCode)
	if maxAndMinItem != nil {
		err = data_manage.ModifyEdbInfoMaxAndMinInfo(int(edbInfoId), maxAndMinItem)
	}

	AddOrEditEdbInfoToEs(int(edbInfoId))

	go handleByAddEdbInfo(edbInfo)

	return
}

func TraceEdbInfoByEdbInfoId(edbInfoId, sysUserId int) (traceEdbInfo data_manage.TraceEdbInfoResp, err error) {
	edbInfo, err := data_manage.GetEdbInfoById(edbInfoId)
	if err != nil {
		return
	}
	edbInfoRuleMap := make(map[int]string, 0)
	edbMappingMap := make(map[int][]*data_manage.EdbInfoCalculateMappingInfo)
	traceEdbInfo = data_manage.TraceEdbInfoResp{
		EdbInfoId:   edbInfoId,
		EdbInfoType: edbInfo.EdbInfoType,
		EdbName:     edbInfo.EdbName,
		EdbNameEn:   edbInfo.EdbNameEn,
		EdbType:     edbInfo.EdbType,
		UniqueCode: edbInfo.UniqueCode,
		ClassifyId: edbInfo.ClassifyId,
		IsStop:     edbInfo.NoUpdate,
		EdbInfo:    edbInfo,
	}
	findIdMap := make(map[int]int)
	findIdMap[edbInfoId] = edbInfoId
	existMap := make(map[int]data_manage.TraceEdbInfoResp)
	traceEdbInfo.Child, err = traceEdbInfoByEdbInfoId(edbInfoId, traceEdbInfo, edbInfoRuleMap, findIdMap, existMap, edbMappingMap)

	edbInfoIdList := make([]int, 0)
	for _, v := range findIdMap {
		edbInfoIdList = append(edbInfoIdList, v)
	}
	classifyIdList := make([]int, 0)
	edbInfoList, err := data_manage.GetEdbInfoByIdList(edbInfoIdList)
	if err != nil {
		return
	}
	edbInfoMap := make(map[int]*data_manage.EdbInfo)
	for _, tmpEdbInfo := range edbInfoList {
		edbInfoMap[tmpEdbInfo.EdbInfoId] = tmpEdbInfo
		classifyIdList = append(classifyIdList, tmpEdbInfo.ClassifyId)
	}

	edbInfoIdPermissionMap := make(map[int]bool)
	{
		classifyMap := make(map[int]*data_manage.EdbClassify)
		classifyList, tmpErr := data_manage.GetEdbClassifyByIdList(classifyIdList)
		if tmpErr != nil {
			err = tmpErr
			return
		}
		for _, v := range classifyList {
			classifyMap[v.ClassifyId] = v
		}

		permissionEdbIdList, permissionClassifyIdList, tmpErr := data_manage_permission.GetUserEdbAndClassifyPermissionList(sysUserId, 0, 0)
		if tmpErr != nil {
			err = tmpErr
			return
		}

		for _, v := range edbInfoMap {
			if currClassify, ok := classifyMap[v.ClassifyId]; ok {
				edbInfoIdPermissionMap[v.EdbInfoId] = data_manage_permission.CheckEdbPermissionByPermissionIdList(v.IsJoinPermission, currClassify.IsJoinPermission, v.EdbInfoId, v.ClassifyId, permissionEdbIdList, permissionClassifyIdList)
			}
		}
	}

	traceEdbInfo, err = handleTraceEdbInfo(traceEdbInfo, 0, edbInfoMap, edbMappingMap, edbInfoIdPermissionMap)


	return
}

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
		traceEdbInfo := data_manage.TraceEdbInfoResp{
			EdbInfoId:   edbInfo.EdbInfoId,
			EdbInfoType: edbInfo.EdbInfoType,
			EdbName:     edbInfo.EdbName,
			EdbNameEn:   edbInfo.EdbNameEn,
			EdbType:     edbInfo.EdbType,
			UniqueCode: edbInfo.UniqueCode,
			ClassifyId: edbInfo.ClassifyId,
			IsStop:     edbInfo.NoUpdate,
			EdbInfo:    edbInfo,
		}
		traceEdbInfo.Child, err = traceEdbInfoByEdbInfoId(edbInfo.EdbInfoId, traceEdbInfo, edbInfoRuleMap, findIdMap, existMap, edbMappingMap)
		traceEdbInfoList = append(traceEdbInfoList, traceEdbInfo)
	}

	return
}

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
	}

	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,
			IsStop:      v.NoUpdate,
			EdbInfo:     edbInfoMap[v.FromEdbInfoId],
		}

		if edbInfoId != v.FromEdbInfoId && (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
}

func handleTraceEdbInfo(traceEdbInfoResp data_manage.TraceEdbInfoResp, parentEdbInfoId int, edbInfoMap map[int]*data_manage.EdbInfo, edbMappingMap map[int][]*data_manage.EdbInfoCalculateMappingInfo, edbInfoIdPermissionMap map[int]bool) (newTraceEdbInfoResp data_manage.TraceEdbInfoResp, err error) {
	edbInfo, ok := edbInfoMap[traceEdbInfoResp.EdbInfoId]
	if !ok {
		err = errors.New("指标异常")
		return
	}

	var parentEdbInfo *data_manage.EdbInfo
	if parentEdbInfoId > 0 {
		parentEdbInfo, ok = edbInfoMap[parentEdbInfoId]
		if !ok {
			err = errors.New("指标异常")
			return
		}
	}

	traceEdbInfoResp.EdbName, traceEdbInfoResp.EdbNameEn, traceEdbInfoResp.RuleTitle, traceEdbInfoResp.RuleTitleEn = getEdbRuleTitle(edbInfo, parentEdbInfo, traceEdbInfoResp.Child, edbInfoMap, edbMappingMap)

	if traceEdbInfoResp.Child != nil && len(traceEdbInfoResp.Child) > 0 {
		for k, v := range traceEdbInfoResp.Child {
			traceEdbInfoResp.Child[k], err = handleTraceEdbInfo(v, traceEdbInfoResp.EdbInfoId, edbInfoMap, edbMappingMap, edbInfoIdPermissionMap)
			if err != nil {
				return
			}
		}
	}
	traceEdbInfoResp.HaveOperaAuth, _ = edbInfoIdPermissionMap[traceEdbInfoResp.EdbInfoId]

	newTraceEdbInfoResp = traceEdbInfoResp

	return
}

func getEdbRuleTitle(edbInfo, parentEdbInfo *data_manage.EdbInfo, childList []data_manage.TraceEdbInfoResp, edbInfoMap map[int]*data_manage.EdbInfo, edbMappingMap map[int][]*data_manage.EdbInfoCalculateMappingInfo) (edbName, edbNameEn, ruleTitle, ruleTitleEn string) {
	edbName = edbInfo.EdbName
	edbNameEn = edbInfo.EdbNameEn
	ruleTitle = `来源于` + edbInfo.SourceName
	ruleTitleEn = `Source From: ` + edbInfo.SourceName

	if parentEdbInfo != nil {
		edbMappingList, ok := edbMappingMap[parentEdbInfo.EdbInfoId]
		if !ok {
			edbMappingList = []*data_manage.EdbInfoCalculateMappingInfo{}
		}
		switch parentEdbInfo.Source {
		case utils.DATA_SOURCE_CALCULATE, utils.DATA_SOURCE_PREDICT_CALCULATE:
			for _, v := range edbMappingList {
				if v.FromEdbInfoId == edbInfo.EdbInfoId {
					edbName = fmt.Sprintf("%s（%s）", edbInfo.EdbName, v.FromTag)
					edbNameEn = fmt.Sprintf("%s（%s）", edbInfo.EdbNameEn, v.FromTag)
				}
			}

		case utils.DATA_SOURCE_CALCULATE_ZJPJ, utils.DATA_SOURCE_PREDICT_CALCULATE_ZJPJ, utils.DATA_SOURCE_CALCULATE_LJZTBPJ, utils.DATA_SOURCE_PREDICT_CALCULATE_LJZTBPJ: // 直接拼接 ,累计值同比拼接
			for _, v := range edbMappingList {
				if v.FromEdbInfoId == edbInfo.EdbInfoId {
					tmpName := ``
					tmpNameEn := ``
					if v.FromTag == `A` {
						tmpName = `拼接日期前`
						tmpNameEn = `Before Concatenation Date:`
					} else if v.FromTag == `B` {
						tmpName = `拼接日期后`
						tmpNameEn = `After Concatenation Date:`
					}
					edbName = fmt.Sprintf("%s（%s）", edbInfo.EdbName, tmpName)
					edbNameEn = fmt.Sprintf("%s（%s）", edbInfo.EdbNameEn, tmpNameEn)
				}
			}
		case utils.DATA_SOURCE_CALCULATE_NHCC, utils.DATA_SOURCE_PREDICT_CALCULATE_NHCC: //计算指标（拟合残差）
			for _, v := range edbMappingList {
				if v.FromEdbInfoId == edbInfo.EdbInfoId {
					tmpName := ``
					tmpNameEn := ``
					if v.FromTag == `A` {
						tmpName = fmt.Sprintf(`自变量，领先%d天`, v.MoveValue)
						tmpNameEn = fmt.Sprintf(`Independent Variable, Lead %d Days:`, v.MoveValue)
					} else if v.FromTag == `B` {
						tmpName = `因变量`
						tmpNameEn = `Dependent Variable`
					}
					edbName = fmt.Sprintf("%s（%s）", edbInfo.EdbName, tmpName)
					edbNameEn = fmt.Sprintf("%s（%s）", edbInfo.EdbNameEn, tmpNameEn)
				}
			}
		case utils.DATA_SOURCE_CALCULATE_CORRELATION: // 滚动相关性
			for _, v := range edbMappingList {
				if v.FromEdbInfoId == edbInfo.EdbInfoId {
					edbName = fmt.Sprintf("%s（%s）", edbInfo.EdbName, v.FromTag)
					edbNameEn = fmt.Sprintf("%s（%s）", edbInfo.EdbNameEn, v.FromTag)
				}
			}

		}

	}

	if edbInfo.EdbType == 1 {

		return
	}

	switch edbInfo.Source {
	case utils.DATA_SOURCE_CALCULATE, utils.DATA_SOURCE_PREDICT_CALCULATE:
		ruleTitle = "=" + edbInfo.CalculateFormula
	case utils.DATA_SOURCE_CALCULATE_LJZZY, utils.DATA_SOURCE_PREDICT_CALCULATE_LJZZY:
		ruleTitle = `累计转月值计算`
		ruleTitleEn = `Cumulative to Monthly Calculation`
	case utils.DATA_SOURCE_CALCULATE_TBZ, utils.DATA_SOURCE_PREDICT_CALCULATE_TBZ:
		ruleTitle = `同比值计算`
		ruleTitleEn = `Year-on-Year Value Calculation`
	case utils.DATA_SOURCE_CALCULATE_TCZ, utils.DATA_SOURCE_PREDICT_CALCULATE_TCZ:
		ruleTitle = `同差值计算`
		ruleTitleEn = `Yearly Difference Calculation`
	case utils.DATA_SOURCE_CALCULATE_NSZYDPJJS, utils.DATA_SOURCE_PREDICT_CALCULATE_NSZYDPJJS:
		ruleTitle = fmt.Sprintf("N数值移动均值计算（N=%s）", edbInfo.CalculateFormula)
		ruleTitleEn = fmt.Sprintf("N-Value Moving Average Calculation（N=%s）", edbInfo.CalculateFormula)
	case utils.DATA_SOURCE_CALCULATE_HBZ, utils.DATA_SOURCE_PREDICT_CALCULATE_HBZ:
		ruleTitle = fmt.Sprintf("N数值环比值计算（N=%s）", edbInfo.CalculateFormula)
		ruleTitleEn = fmt.Sprintf("N-Value Sequential Comparison Calculation（N=%s）", edbInfo.CalculateFormula)
	case utils.DATA_SOURCE_CALCULATE_HCZ, utils.DATA_SOURCE_PREDICT_CALCULATE_HCZ:
		ruleTitle = fmt.Sprintf("N数值环差值计算（N=%s）", edbInfo.CalculateFormula)
		ruleTitleEn = fmt.Sprintf("N-Value Sequential Difference Calculation（N=%s）", edbInfo.CalculateFormula)
	case utils.DATA_SOURCE_CALCULATE_TIME_SHIFT, utils.DATA_SOURCE_PREDICT_CALCULATE_TIME_SHIFT:
		moveType := `领先`
		moveTypeEn := `Lead`
		if edbInfo.MoveType == 2 {
			moveType = "滞后"
			moveTypeEn = `Lag`
		}
		ruleTitle = fmt.Sprintf("时间移位计算（%s%s%s）", moveType, edbInfo.CalculateFormula, edbInfo.MoveFrequency)
		ruleTitleEn = fmt.Sprintf("Time Shift Calculation（%s%s%s）", moveTypeEn, edbInfo.CalculateFormula, edbInfo.MoveFrequency)
	case utils.DATA_SOURCE_CALCULATE_BP, utils.DATA_SOURCE_PREDICT_CALCULATE_BP: // 变频
		childFrequency := ``
		if len(childList) > 0 {
			if childEdbInfo, ok := edbInfoMap[childList[0].EdbInfoId]; ok {
				childFrequency = childEdbInfo.Frequency
			}

		}
		ruleTitle = fmt.Sprintf("升频计算（%s转%s）", childFrequency, edbInfo.Frequency)
		ruleTitleEn = fmt.Sprintf("Upsampling Calculation（%s转%s）", childFrequency, edbInfo.Frequency)
	case utils.DATA_SOURCE_CALCULATE_ZJPJ, utils.DATA_SOURCE_PREDICT_CALCULATE_ZJPJ: // 直接拼接
		ruleTitle = fmt.Sprintf("直接拼接计算（%s）", edbInfo.CalculateFormula)
		ruleTitleEn = fmt.Sprintf("Direct Concatenation Calculation（%s）", edbInfo.CalculateFormula)
	case utils.DATA_SOURCE_CALCULATE_LJZTBPJ, utils.DATA_SOURCE_PREDICT_CALCULATE_LJZTBPJ: // 累计值同比拼
		ruleTitle = fmt.Sprintf("累计值同比值拼接计算（%s）", edbInfo.CalculateFormula)
		ruleTitleEn = fmt.Sprintf("Cumulative Year-on-Year Concatenation Calculation（%s）", edbInfo.CalculateFormula)
	case utils.DATA_SOURCE_PYTHON:
		ruleTitle = `代码运算`
		ruleTitleEn = `Code Computation`
	case utils.DATA_SOURCE_CALCULATE_CJJX, utils.DATA_SOURCE_PREDICT_CALCULATE_CJJX:
		ruleTitle = fmt.Sprintf("超季节性计算（N=%s，%s）", edbInfo.CalculateFormula, edbInfo.Calendar)
		ruleTitleEn = fmt.Sprintf("Super Seasonality Calculation（N=%s，%s）", edbInfo.CalculateFormula, edbInfo.Calendar)
	case utils.DATA_SOURCE_CALCULATE_NHCC, utils.DATA_SOURCE_PREDICT_CALCULATE_NHCC: //计算指标（拟合残差）
		var startDate, endDate string
		dateList := strings.Split(edbInfo.CalculateFormula, ",")
		if len(dateList) == 2 {
			startDate = dateList[0]
			endDate = dateList[1]
		}
		ruleTitle = fmt.Sprintf("拟合残差计算（%s至%s）", startDate, endDate)
		ruleTitleEn = fmt.Sprintf("Fit Residual Calculation（%s至%s）", startDate, endDate)
	case utils.DATA_SOURCE_CALCULATE_ADJUST:
		ruleTitle = `数据调整`
		ruleTitleEn = `Data Adjustment`
	case utils.DATA_SOURCE_CALCULATE_NH, utils.DATA_SOURCE_PREDICT_CALCULATE_NH:
		ruleTitle = `年化计算`
		ruleTitleEn = `Annualization Calculation`
	case utils.DATA_SOURCE_CALCULATE_KSZS, utils.DATA_SOURCE_PREDICT_CALCULATE_KSZS: // 扩散指数->53
		type KszsConfig struct {
			DateType  int      `description:"扩散指标日期；1：全部指标日期并集;2:部分指标日期并集"`
			CheckList []string `description:"选中的数据,A,B,C"`
		}
		var config KszsConfig
		err := json.Unmarshal([]byte(edbInfo.CalculateFormula), &config)
		if err != nil {
			return
		}
		var startDate, endDate time.Time

		childEdbInfoIdList := make([]int, 0)
		if config.DateType == 1 {
			for _, v := range childList {
				childEdbInfoIdList = append(childEdbInfoIdList, v.EdbInfoId)
			}

		} else {
			if parentEdbInfo != nil {
				edbMappingList, ok := edbMappingMap[parentEdbInfo.EdbInfoId]
				if !ok {
					edbMappingList = []*data_manage.EdbInfoCalculateMappingInfo{}
				}
				tagMap := make(map[string]int)
				for _, v := range edbMappingList {
					tagMap[v.FromTag] = v.FromEdbInfoId
				}
				for _, v := range config.CheckList {
					if tmpEdbInfoId, ok := tagMap[v]; ok {
						childEdbInfoIdList = append(childEdbInfoIdList, tmpEdbInfoId)
					}
				}
			}
		}
		for _, v := range childEdbInfoIdList {
			if childEdbInfo, ok := edbInfoMap[v]; ok {
				tmpStartDate := childEdbInfo.StartDate
				if startDate.IsZero() || startDate.After(tmpStartDate) {
					startDate = tmpStartDate
				}

				tmpEndDate := childEdbInfo.EndDate
				if endDate.IsZero() || endDate.Before(tmpEndDate) {
					endDate = tmpEndDate
				}
			}
		}
		ruleTitle = fmt.Sprintf("扩散指数计算（%s至%s）", startDate.Format(utils.FormatDate), endDate.Format(utils.FormatDate))
		ruleTitleEn = fmt.Sprintf("Diffusion Index Calculation（%s to %s）", startDate.Format(utils.FormatDate), endDate.Format(utils.FormatDate))
	case utils.DATA_SOURCE_STOCK_PLANT:
		ruleTitle = `来源于装置分析`
		ruleTitleEn = `Derived from Plant Analysis`
	case utils.DATA_SOURCE_CALCULATE_CORRELATION:
		type EdbCalculateFormula struct {
			BaseCalculateValue int    `description:"基础计算窗口"`
			BaseCalculateUnit  string `description:"基础计算频度"`
			LeadValue          int    `description:"领先期数"`
			LeadUnit           string `description:"频度"`
			CalculateValue     int    `description:"计算窗口"`
			CalculateUnit      string `description:"计算频度"`
		}
		var correlationConf EdbCalculateFormula
		err := json.Unmarshal([]byte(edbInfo.CalculateFormula), &correlationConf)
		if err != nil {
			return
		}
		ruleTitle = fmt.Sprintf("滚动相关性（计算窗口%d%s，B领先A%d%s）", correlationConf.CalculateValue, correlationConf.CalculateUnit, correlationConf.LeadValue, correlationConf.LeadUnit)
		ruleTitleEn = fmt.Sprintf("Rolling Correlation (Calculation Window %d%s, B Leads A %d%s)", correlationConf.CalculateValue, correlationConf.CalculateUnit, correlationConf.LeadValue, correlationConf.LeadUnit)
	case utils.DATA_SOURCE_CALCULATE_JP, utils.DATA_SOURCE_PREDICT_CALCULATE_JP:
		childFrequency := ``
		if len(childList) > 0 {
			if childEdbInfo, ok := edbInfoMap[childList[0].EdbInfoId]; ok {
				childFrequency = childEdbInfo.Frequency
			}

		}
		ruleTitle = fmt.Sprintf("降频计算（%s转%s，%s）", childFrequency, edbInfo.Frequency, edbInfo.CalculateFormula)
		ruleTitleEn = fmt.Sprintf("Downsampling Calculation（%s to %s，%s）", childFrequency, edbInfo.Frequency, edbInfo.CalculateFormula)
	case utils.DATA_SOURCE_CALCULATE_STANDARD_DEVIATION:
		ruleTitle = fmt.Sprintf("标准差（滚动%s期）", edbInfo.CalculateFormula)
		ruleTitleEn = fmt.Sprintf("Standard Deviation (Rolling %s Periods)", edbInfo.CalculateFormula)
	case utils.DATA_SOURCE_CALCULATE_PERCENTILE, utils.DATA_SOURCE_PREDICT_CALCULATE_PERCENTILE:
		type TempCalculate struct {
			CalculateValue int    `description:"计算窗口"`
			CalculateUnit  string `description:"计算频度"`
		}
		cf := TempCalculate{}
		if e := json.Unmarshal([]byte(edbInfo.CalculateFormula), &cf); e != nil {
			return
		}
		ruleTitle = fmt.Sprintf("百分位（时间长度%d%s）", cf.CalculateValue, cf.CalculateUnit)
		ruleTitle = fmt.Sprintf("Percentile (Time Length %d%s)", cf.CalculateValue, cf.CalculateUnit)
	case utils.DATA_SOURCE_CALCULATE_ZSXY, utils.DATA_SOURCE_PREDICT_CALCULATE_ZSXY:
		ruleTitle = `指数修匀计算`
		ruleTitle = `Index Smoothing Calculation`
	}

	return
}

func GetEdbChartAdminList(source int) (list []int, err error) {
	switch source {
	case 1: //手工数据指标
		list, err = models.GetEdbInfoAdminList()
		if err != nil {
			return
		}

	case 3: //ETA指标库
		list, err = data_manage.GetEdbInfoAdminList(0)
		if err != nil {
			return
		}

	case 4: //ETA预测指标
		list, err = data_manage.GetEdbInfoAdminList(1)
		if err != nil {
			return
		}
	case 5: //图库
		list, err = data_manage.GetChartInfoAdminList()
		if err != nil {
			return
		}
	default:
		return
	}

	return
}

func EdbInfoReplace(oldEdbInfo, newEdbInfo *data_manage.EdbInfo, sysAdminId int, sysAdminRealName string) (replaceChartTotal, replaceCalculateTotal int, err error) {
	defer func() {
		if err != nil {
			fmt.Println("ERR:", err.Error())
		}
	}()

	relationEdbInfoIdList, replaceChartTotal, replaceCalculateTotal, err := data_manage.ReplaceChartEdb(oldEdbInfo, newEdbInfo)
	if err != nil {
		return
	}
	go cache.AddReplaceEdbInfo(oldEdbInfo, newEdbInfo)
	err, _ = EdbInfoRefreshAllFromBaseV3(relationEdbInfoIdList, true, true, true)
	return
}

func GetTerminalFromBaseIndex(source int, edbCode string) (terminalCode string, sourceIndexName string, err error) {
	tbName := GetBaseIndexTableName(source)
	if tbName != "" {
		var item data_manage.BaseIndexTerminalCode
		item, err = data_manage.GetBaseIndexTerminalCode(edbCode, tbName)
		if err != nil {
			err = fmt.Errorf("查询数据源指标信息失败， Err： %s", err)
			return
		}
		terminalCode = item.TerminalCode
		sourceIndexName = item.IndexName
	}
	return
}

func GetBaseIndexTableName(source int) (tableName string) {
	switch source {
	case utils.DATA_SOURCE_YS:
		tableName = "base_from_smm_index"
	case utils.DATA_SOURCE_MYSTEEL_CHEMICAL:
		tableName = "base_from_mysteel_chemical_index"
	case utils.DATA_SOURCE_SCI:
		tableName = "base_from_sci_index"
	case utils.DATA_SOURCE_BAIINFO:
		tableName = "base_from_baiinfo_index"
	default:
	}
	return
}

func EdbInfoWsdAdd(item *data_manage.EdbInfo) (edbInfo *data_manage.EdbInfo, err error, errMsg string, isSendEmail bool) {
	isSendEmail = true
	var condition string
	var pars []interface{}

	condition += " AND edb_name=? "
	pars = append(pars, item.EdbName)

	count, err := data_manage.GetEdbInfoCountByCondition(condition, pars)
	if err != nil {
		errMsg = "判断指标名称是否存在失败"
		err = errors.New("判断指标名称是否存在失败,Err:" + err.Error())
		return
	}

	if count > 0 {
		errMsg = "指标名称已存在，请重新填写"
		err = errors.New(errMsg)
		isSendEmail = false
		return
	}

	source := item.Source

	edbInfo = new(data_manage.EdbInfo)
	edbInfo.Source = source

	var sourceName string
	edbSource := data_manage.GetEdbSourceBySourceId(source)
	if edbSource != nil {
		sourceName = edbSource.SourceName
	}
	if sourceName == "" {
		errMsg = "指标来源异常"
		err = errors.New(errMsg)
		return
	}
	edbInfo.SourceName = sourceName

	edbType := 1 //基础指标
	if source == utils.DATA_SOURCE_STOCK_PLANT {
		edbType = 2 //计算指标
	}

	maxSort, err := GetEdbClassifyMaxSort(item.ClassifyId, 0)
	if err != nil {
		errMsg = "获取失败"
		err = errors.New("查询排序信息失败，Err:" + err.Error())
		return
	}

	edbInfo.EdbCode = item.EdbCode
	edbInfo.EdbName = item.EdbName
	edbInfo.EdbNameSource = item.EdbName
	edbInfo.EdbNameEn = item.EdbNameEn
	edbInfo.Frequency = item.Frequency
	edbInfo.Unit = item.Unit
	edbInfo.UnitEn = item.UnitEn
	edbInfo.ClassifyId = item.ClassifyId
	edbInfo.SysUserId = item.SysUserId
	edbInfo.SysUserRealName = item.SysUserRealName
	edbInfo.CreateTime = time.Now()
	edbInfo.ModifyTime = time.Now()
	edbInfo.ServerUrl = item.ServerUrl
	edbInfo.Sort = maxSort + 1
	edbInfo.DataDateType = `交易日`
	timestamp := strconv.FormatInt(time.Now().UnixNano(), 10)
	edbInfo.UniqueCode = utils.MD5(utils.DATA_PREFIX + "_" + timestamp)
	edbInfo.EdbType = edbType
	edbInfo.SubSource = item.SubSource
	edbInfo.SubSourceName = "日期序列"
	edbInfo.IndicatorCode = item.IndicatorCode
	edbInfo.StockCode = item.StockCode
	edbInfo.TerminalCode = item.TerminalCode
	edbInfo.Extra = item.Extra
	edbInfoId, err := data_manage.AddEdbInfo(edbInfo)
	if err != nil {
		errMsg = "保存失败"
		err = errors.New("保存失败，Err:" + err.Error())
		return
	}
	edbInfo.EdbInfoId = int(edbInfoId)
	err = data_manage.ModifyEdbInfoWindWsdDataStatus(source, item.SubSource, edbInfoId, item.EdbCode)
	if err != nil {
		errMsg = "保存失败"
		err = errors.New("修改数据对应指标ID失败，Err:" + err.Error())
		return
	}
	maxAndMinItem, _ := data_manage.GetEdbInfoWsdMaxAndMinInfo(source, item.SubSource, item.EdbCode)
	if maxAndMinItem != nil {
		err = data_manage.ModifyEdbInfoMaxAndMinInfo(int(edbInfoId), maxAndMinItem)
	}
	AddOrEditEdbInfoToEs(int(edbInfoId))
	return
}

func BatchRefreshEdbByEdbIds(edbIdList []int, redisKey string, refreshKeys []string) (syncing bool, err error) {
	if len(edbIdList) <= 0 {
		return
	}

	if redisKey != `` {
		utils.Rc.SetNX(redisKey, 1, time.Minute*10)
	}

	newBaseEdbInfoArr, newBasePredictEdbInfoArr, newCalculateMap, newPredictCalculateMap, calculateArr, predictCalculateArr := getEdbInfoIdList(edbIdList)

	totalEdbInfo := len(newBaseEdbInfoArr) + len(calculateArr) + len(predictCalculateArr)

	if totalEdbInfo > 20 {
		syncing = true
		var refreshItem EdbQueueRefreshReq
		refreshItem.RefreshKey = redisKey
		refreshItem.ItemRefreshKeys = refreshKeys
		refreshItem.BaseEdbInfoArr = newBaseEdbInfoArr
		refreshItem.BasePredictEdbInfoArr = newBasePredictEdbInfoArr
		refreshItem.CalculateMap = newCalculateMap
		refreshItem.PredictCalculateMap = newPredictCalculateMap
		refreshItem.CalculateArr = calculateArr
		refreshItem.PredictCalculateArr = predictCalculateArr
		go PushEdb2Refresh(refreshItem)
		return
	}

	err = edbInfoRefreshAll(false, newBaseEdbInfoArr, newBasePredictEdbInfoArr, newCalculateMap, newPredictCalculateMap, calculateArr, predictCalculateArr)

	if redisKey != `` {
		_ = utils.Rc.Delete(redisKey)
	}
	if len(refreshKeys) > 0 {
		for _, v := range refreshKeys {
			_ = utils.Rc.Delete(v)
		}
	}
	return
}

func GetEdbTerminal(source int, oldTerminalCode string) (edbTerminal *data_manage.EdbTerminal, err error) {
	if source == utils.DATA_SOURCE_WIND && oldTerminalCode == "" {
		tmpConfig := new(data_manage.EdbConfig)
		tmpConfig, err = data_manage.GetConfigDetailByCode("wind_terminal_code")
		if err != nil && !utils.IsErrNoRow(err) {
			err = errors.New("获取配置的wind地址失败，err:" + err.Error())
			return
		}
		err = nil
		if tmpConfig != nil {
			oldTerminalCode = tmpConfig.ConfigValue
		}
	}
	if oldTerminalCode != "" {
		edbTerminal, err = data_manage.GetEdbTerminalByCode(oldTerminalCode)
		if err != nil {
			return
		}
		return
	}

	list, err := data_manage.GetEdbCountGroupByTerminal(source)
	if err != nil {
		return
	}

	terminalNumMap := make(map[string]int)
	for _, v := range list {
		terminalNumMap[v.TerminalCode] = v.Total
	}

	terminalList, err := data_manage.GetEdbTerminalListBySource(source)
	if err != nil {
		return
	}
	if len(terminalList) == 0 {
		err = errors.New("终端地址未配置")
		return
	}
	num := 0
	for _, v := range terminalList {
		tmpNum := terminalNumMap[v.TerminalCode]
		if edbTerminal == nil {
			edbTerminal = v
			num = tmpNum
		} else if tmpNum < num {
			edbTerminal = v
			num = tmpNum
		}
	}
	if edbTerminal == nil {
		err = errors.New("获取配置的终端地址失败")
		return
	}
	return
}

func GetEdbTerminalCodeBySource(source int, edbCode, stockCode string) (terminalCode, serverUrl, sourceIndexName string, err error) {
	var e error
	if stockCode != "" {
		terminalCodeCacheKey := utils.CACHE_EDB_TERMINAL_CODE_URL + stockCode
		terminalCode, e = utils.Rc.RedisString(terminalCodeCacheKey)
		if e != nil {
			utils.FileLog.Info(fmt.Sprintf("从缓存中获取数据源终端信息失败, Err: %s", e))
		}

		terminalInfo, e := GetEdbTerminal(source, terminalCode)
		if e != nil {
			err = errors.New("获取可以使用的终端失败，Err:" + e.Error())
			return
		}
		serverUrl = terminalInfo.ServerUrl
		terminalCode = terminalInfo.TerminalCode
		return
	}
	terminalCodeCacheKey := utils.CACHE_EDB_TERMINAL_CODE_URL + edbCode
	terminalCode, tE := utils.Rc.RedisString(terminalCodeCacheKey)
	if tE != nil {
		utils.FileLog.Info(fmt.Sprintf("从缓存中获取数据源终端信息失败, Err: %s", tE))
	}
	var terminalCodeOrigin string
	terminalCodeOrigin, sourceIndexName, tE = GetTerminalFromBaseIndex(source, edbCode)
	if tE != nil {
		utils.FileLog.Info(fmt.Sprintf("获取数据源终端信息失败, Err: %s", tE))
	}
	if terminalCodeOrigin != "" {
		terminalCode = terminalCodeOrigin
	}
	if source == utils.DATA_SOURCE_WIND || source == utils.DATA_SOURCE_THS {
		terminalInfo, e := GetEdbTerminal(source, terminalCode)
		if e != nil {
			err = errors.New("获取可以使用的终端失败，Err:" + e.Error())
			return
		}
		serverUrl = terminalInfo.ServerUrl
		terminalCode = terminalInfo.TerminalCode
	}
	return
}

func handleByAddEdbInfo(edbInfo *data_manage.EdbInfo) {
	if edbInfo.Source == utils.DATA_SOURCE_MANUAL {
		_ = models.UpdateManualIsJoinEdbStatus(edbInfo.EdbCode, 1)
	}

}

func handleByDelEdbInfo(edbInfo *data_manage.EdbInfo) {
	if edbInfo.Source == utils.DATA_SOURCE_CALCULATE_ZDYFX {
		err := excel.DeleteCustomAnalysisExcelEdbMappingByEdbInfoId(edbInfo.EdbInfoId)
		if err != nil {
			utils.FileLog.Error(fmt.Sprintf("删除指标时，需要删除与自定义分析的关系失败，指标ID：%d，Err:%s", edbInfo.EdbInfoId, err.Error()), 3)
		}
	}

	if edbInfo.Source == utils.DATA_SOURCE_MANUAL {
		_ = models.UpdateManualIsJoinEdbStatus(edbInfo.EdbCode, 0)
	}
}

func GetIsSupplierStop(source int, edbCode string) (isSupplierStop int) {

	return
}