eta_forum_admin/services/edb_info.go

package services

import (
	"encoding/json"
	"errors"
	"eta/eta_forum_admin/models"
	"eta/eta_forum_admin/models/mgodb"
	"eta/eta_forum_admin/utils"
	"fmt"
	"strconv"
	"strings"
	"time"
)

// BatchAddOrUpdateEdbInfo 添加批量添加指标到指标库
func BatchAddOrUpdateEdbInfo(edbList []*models.EdbInfo, edbMapping []*models.EdbInfoCalculateMapping, sysUserId int, sysUserRealName string) (newList []*models.EdbInfo, err error, errMsg string, isSendEmail bool) {
	isSendEmail = true
	edbCodeMap := make(map[string]*models.EdbInfo)
	for _, v := range edbList {
		tmp, e, msg, _ := AddOrUpdateEdbInfo(v, sysUserId, sysUserRealName)
		if e != nil {
			err = e
			errMsg = msg
			return
		}
		newList = append(newList, tmp)
		edbCodeMap[tmp.EdbCode] = tmp
	}
	//批量添加指标的mapping信息
	calculateMappingItemList := make([]*models.EdbInfoCalculateMapping, 0)
	for _, v := range edbMapping {
		edbInfo, ok := edbCodeMap[v.EdbCode]
		if !ok {
			continue
		}
		fromEdbInfo, ok := edbCodeMap[v.FromEdbCode]
		if !ok {
			continue
		}

		calculateMappingItem := new(models.EdbInfoCalculateMapping)
		calculateMappingItem.CreateTime = time.Now()
		calculateMappingItem.ModifyTime = time.Now()
		calculateMappingItem.Sort = v.Sort
		calculateMappingItem.EdbCode = edbInfo.EdbCode
		calculateMappingItem.EdbInfoId = edbInfo.EdbInfoId
		calculateMappingItem.FromEdbInfoId = fromEdbInfo.EdbInfoId
		calculateMappingItem.FromEdbCode = fromEdbInfo.EdbCode
		calculateMappingItem.FromEdbName = fromEdbInfo.EdbName
		calculateMappingItem.FromSource = fromEdbInfo.Source
		calculateMappingItem.FromSourceName = fromEdbInfo.SourceName
		calculateMappingItem.FromTag = v.FromTag
		calculateMappingItem.Source = edbInfo.Source
		calculateMappingItem.SourceName = edbInfo.SourceName
		calculateMappingItem.FromSubSource = edbInfo.SubSource
		calculateMappingItemList = append(calculateMappingItemList, calculateMappingItem)
	}
	err = models.AddEdbInfoCalculateMappingMulti(calculateMappingItemList)
	if err != nil {
		errMsg = "指标映射关系添加失败"
		return
	}
	return
}

// AddOrUpdateEdbInfo 添加指标到指标库
func AddOrUpdateEdbInfo(edbItem *models.EdbInfo, sysUserId int, sysUserRealName string) (edbInfo *models.EdbInfo, err error, errMsg string, isSendEmail bool) {
	isSendEmail = true
	//判断指标是否存在
	edbInfo, err = models.GetEdbInfoByEdbCode(edbItem.Source, edbItem.EdbCode)
	if err != nil {
		if err.Error() == utils.ErrNoRow() {
			err = nil
		} else {
			errMsg = "判断指标名称是否存在失败"
			err = errors.New("判断指标名称是否存在失败,Err:" + err.Error())
			return
		}
	}
	var edbInfoId int64
	// 指标已存在
	if edbInfo != nil && edbInfo.EdbInfoId > 0 {
		edbInfoId = int64(edbInfo.EdbInfoId)
		// 更新指标信息
		edbInfo.Source = edbItem.Source
		edbInfo.SourceName = edbItem.SourceName
		edbInfo.EdbType = edbItem.EdbType
		edbInfo.EdbCode = edbItem.EdbCode
		edbInfo.EdbName = edbItem.EdbName
		edbInfo.EdbNameSource = edbItem.EdbNameSource
		edbInfo.Frequency = edbItem.Frequency
		edbInfo.Unit = edbItem.Unit
		edbInfo.StartDate = edbItem.StartDate
		edbInfo.EndDate = edbItem.EndDate
		edbInfo.ClassifyId = edbItem.ClassifyId
		edbInfo.SysUserId = sysUserId
		edbInfo.SysUserRealName = sysUserRealName
		edbInfo.ModifyTime = time.Now()
		edbInfo.ServerUrl = edbItem.ServerUrl
		edbInfo.Sort = edbItem.Sort
		edbInfo.DataDateType = edbItem.DataDateType
		edbInfo.TerminalCode = edbItem.TerminalCode
		edbInfo.SourceIndexName = edbItem.SourceIndexName

		edbInfo.MaxValue = edbItem.MaxValue
		edbInfo.MinValue = edbItem.MinValue
		edbInfo.EdbType = edbItem.EdbType
		err = edbInfo.Update([]string{})
		if err != nil {
			errMsg = "保存失败"
			err = errors.New("保存失败，Err:" + err.Error())
			return
		}
		//同时删除指标的映射信息
		err = models.DeleteEdbInfoMapping(edbInfoId)
		if err != nil {
			errMsg = "删除指标映射信息失败"
			err = errors.New("删除指标映射信息失败，Err:" + err.Error())
			return
		}
	} else {
		edbInfo = new(models.EdbInfo)
		edbInfo.Source = edbItem.Source
		edbInfo.SourceName = edbItem.SourceName
		edbInfo.EdbType = edbItem.EdbType
		edbInfo.EdbCode = edbItem.EdbCode
		edbInfo.EdbName = edbItem.EdbName
		edbInfo.EdbNameSource = edbItem.EdbNameSource
		edbInfo.Frequency = edbItem.Frequency
		edbInfo.Unit = edbItem.Unit
		edbInfo.StartDate = edbItem.StartDate
		edbInfo.EndDate = edbItem.EndDate
		edbInfo.ClassifyId = edbItem.ClassifyId
		edbInfo.SysUserId = sysUserId
		edbInfo.SysUserRealName = sysUserRealName
		edbInfo.CreateTime = time.Now()
		edbInfo.ModifyTime = time.Now()
		edbInfo.ServerUrl = edbItem.ServerUrl
		edbInfo.Sort = edbItem.Sort
		edbInfo.DataDateType = edbItem.DataDateType
		edbInfo.TerminalCode = edbItem.TerminalCode
		edbInfo.SourceIndexName = edbItem.SourceIndexName
		timestamp := strconv.FormatInt(time.Now().UnixNano(), 10)
		edbInfo.UniqueCode = utils.MD5(utils.DATA_PREFIX + "_" + timestamp)

		edbInfo.MaxValue = edbItem.MaxValue
		edbInfo.MinValue = edbItem.MinValue
		edbInfo.EdbType = edbItem.EdbType
		edbInfoId, err = models.AddEdbInfo(edbInfo)
		if err != nil {
			errMsg = "保存失败"
			err = errors.New("保存失败，Err:" + err.Error())
			return
		}
		edbInfo.EdbInfoId = int(edbInfoId)
	}

	err = mgodb.ModifyEdbInfoDataStatus(edbInfoId, edbInfo.EdbCode)
	if err != nil {
		errMsg = "保存失败"
		err = errors.New("更新指标数据失败，Err:" + err.Error())
		return
	}

	return
}

// 批量删除指标，
func BatchDeleteEdbInfo(edbInfoIds []int) (err error, errMsg string) {
	for _, v := range edbInfoIds {
		//查询单个指标是否允许删除
		err, errMsg = DeleteEdbInfo(v)
		if err != nil {
			errMsg = "删除指标失败"
			return
		}
	}
	return
}

// 删除单个指标
func DeleteEdbInfo(edbInfoId int) (err error, errMsg string) {
	//判断指标是否存在
	_, err = models.GetEdbInfoById(edbInfoId)
	if err != nil {
		if err.Error() == utils.ErrNoRow() {
			err = nil
			return
		} else {
			errMsg = "判断指标名称是否存在失败"
			err = errors.New("判断指标名称是否存在失败,Err:" + err.Error())
			return
		}
	}
	//判断指标是否用于作图，如果用于作图，则不可删除
	chartCount, tmpErr := models.GetChartEdbMappingCount(edbInfoId)
	if tmpErr != nil && tmpErr.Error() != utils.ErrNoRow() {
		errMsg = "删除失败"
		err = errors.New("判断指标是否被用于作图失败，Err:" + tmpErr.Error())
		return
	}
	if chartCount > 0 {
		errMsg = "当前指标已用作画图，不可删除"
		return
	}

	//判断指标是否用作其他指标的计算
	calculateCount, tmpErr := models.GetEdbInfoCalculateMappingCount(edbInfoId)
	if tmpErr != nil {
		errMsg = "删除失败"
		err = errors.New("判断指标是否被用于计算失败，GetEdbInfoCalculateCount Err:" + tmpErr.Error())
		return
	}
	if calculateCount > 0 {
		errMsg = "当前指标已用作，指标运算，不可删除"
		return
	}

	// 删除指标，删除映射关系，删除指标数据
	err = models.DeleteEdbInfo(edbInfoId)
	if err != nil {
		errMsg = "删除失败"
		err = errors.New("删除指标失败，Err:" + err.Error())
		return
	}

	err = mgodb.DeleteEdbInfoDataByEdbInfoId(edbInfoId)
	if err != nil {
		errMsg = "删除失败"
		err = errors.New("删除指标数据失败，Err:" + err.Error())
		return
	}
	return
}

// TraceEdbInfoByEdbInfoId 指标追溯
func TraceEdbInfoByEdbInfoId(edbInfoId, sysUserId int) (traceEdbInfo models.TraceEdbInfoResp, err error) {
	edbInfo, err := models.GetEdbInfoById(edbInfoId)
	if err != nil {
		return
	}
	edbInfoRuleMap := make(map[int]string, 0)
	edbMappingMap := make(map[int][]*models.EdbInfoCalculateMappingInfo)
	//edbInfoRuleMap[edbInfoId] = getEdbRuleTitle(edbInfo)
	traceEdbInfo = models.TraceEdbInfoResp{
		//EdbInfoId: edbInfo.EdbInfoId,
		EdbInfoId:   edbInfoId,
		EdbInfoType: edbInfo.EdbInfoType,
		EdbName:     edbInfo.EdbName,
		EdbType:     edbInfo.EdbType,
		//Source:      edbInfo.Source,
		UniqueCode: edbInfo.UniqueCode,
		ClassifyId: edbInfo.ClassifyId,
		IsStop:     edbInfo.NoUpdate,
		EdbInfo:    edbInfo,
	}
	findIdMap := make(map[int]int)
	findIdMap[edbInfoId] = edbInfoId
	existMap := make(map[int]models.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 := models.GetEdbInfoByIdList(edbInfoIdList)
	if err != nil {
		return
	}
	edbInfoMap := make(map[int]*models.EdbInfo)
	for _, tmpEdbInfo := range edbInfoList {
		edbInfoMap[tmpEdbInfo.EdbInfoId] = tmpEdbInfo
		classifyIdList = append(classifyIdList, tmpEdbInfo.ClassifyId)
	}

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

	// 权限校验

	return
}

// TraceEdbInfoByEdbInfoIdList 指标追溯
func TraceEdbInfoByEdbInfoIdList(edbInfoIdList []int) (traceEdbInfoList []models.TraceEdbInfoResp, err error) {
	traceEdbInfoList = make([]models.TraceEdbInfoResp, 0)
	edbInfoList, err := models.GetEdbInfoByIdList(edbInfoIdList)
	if err != nil {
		return
	}
	edbInfoRuleMap := make(map[int]string, 0)
	edbMappingMap := make(map[int][]*models.EdbInfoCalculateMappingInfo)

	findIdMap := make(map[int]int)
	existMap := make(map[int]models.TraceEdbInfoResp)

	for _, edbInfo := range edbInfoList {
		findIdMap[edbInfo.EdbInfoId] = edbInfo.EdbInfoId
		//edbInfoRuleMap[edbInfoId] = getEdbRuleTitle(edbInfo)
		traceEdbInfo := models.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,
			IsStop:     edbInfo.NoUpdate,
			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 := models.GetEdbInfoByIdList(findEdbInfoIdList)
	//if err != nil {
	//	return
	//}
	//edbInfoMap := make(map[int]*models.EdbInfo)
	//for _, tmpEdbInfo := range findEdbInfoList {
	//	edbInfoMap[tmpEdbInfo.EdbInfoId] = tmpEdbInfo
	//}
	//for k, traceEdbInfo := range traceEdbInfoList {
	//	traceEdbInfoList[k], err = handleTraceEdbInfo(traceEdbInfo, 0, edbInfoMap, edbMappingMap)
	//}
	return
}

// traceEdbInfoByEdbInfoId 指标追溯
func traceEdbInfoByEdbInfoId(edbInfoId int, traceEdbInfo models.TraceEdbInfoResp, edbInfoRuleMap map[int]string, findIdMap map[int]int, existMap map[int]models.TraceEdbInfoResp, edbMappingMap map[int][]*models.EdbInfoCalculateMappingInfo) (child []models.TraceEdbInfoResp, err error) {
	traceEdbInfo, ok := existMap[edbInfoId]
	if ok {
		return
	}
	child = make([]models.TraceEdbInfoResp, 0)

	edbInfoMappingList, e := models.GetEdbInfoCalculateMappingListByEdbInfoId(edbInfoId)
	if e != nil {
		err = fmt.Errorf("GetEdbInfoCalculateMappingListByEdbInfoId err: %s", e.Error())
		return
	}

	// 指标信息map
	edbInfoMap := make(map[int]*models.EdbInfo)
	if len(edbInfoMappingList) > 0 {
		fromEdbInfoIdList := make([]int, 0)
		for _, v := range edbInfoMappingList {
			fromEdbInfoIdList = append(fromEdbInfoIdList, v.FromEdbInfoId)
		}
		edbInfoList, tmpErr := models.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 := models.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 models.TraceEdbInfoResp, parentEdbInfoId int, edbInfoMap map[int]*models.EdbInfo, edbMappingMap map[int][]*models.EdbInfoCalculateMappingInfo) (newTraceEdbInfoResp models.TraceEdbInfoResp, err error) {
	edbInfo, ok := edbInfoMap[traceEdbInfoResp.EdbInfoId]
	if !ok {
		err = errors.New("指标异常")
		return
	}

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

	//traceEdbInfoResp.EdbName = edbInfo.EdbName
	traceEdbInfoResp.EdbName, traceEdbInfoResp.RuleTitle = 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)
			if err != nil {
				return
			}
		}
	}

	newTraceEdbInfoResp = traceEdbInfoResp

	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 GetRefreshEdbInfoFromBase(edbInfoId, source int) (baseEdbInfoArr, calculateInfoArr []*models.EdbInfo, err error) {
	calculateList, err := models.GetEdbInfoCalculateMap(edbInfoId, source)
	if err != nil && err.Error() != utils.ErrNoRow() {
		return
	}
	for _, item := range calculateList {
		if item.EdbInfoId == edbInfoId { //	如果查出来关联的指标就是自己的话，那么就过滤
			continue
		}
		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
}

// getEdbRule 获取规则名称
func getEdbRuleTitle(edbInfo, parentEdbInfo *models.EdbInfo, childList []models.TraceEdbInfoResp, edbInfoMap map[int]*models.EdbInfo, edbMappingMap map[int][]*models.EdbInfoCalculateMappingInfo) (edbName, ruleTitle string) {
	edbName = edbInfo.EdbName
	ruleTitle = `来源于` + edbInfo.SourceName

	if parentEdbInfo != nil {
		edbMappingList, ok := edbMappingMap[parentEdbInfo.EdbInfoId]
		if !ok {
			edbMappingList = []*models.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)
				}
			}

		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 := ``
					if v.FromTag == `A` {
						tmpName = `拼接日期前`
					} else if v.FromTag == `B` {
						tmpName = `拼接日期后`
					}
					edbName = fmt.Sprintf("%s（%s）", edbInfo.EdbName, tmpName)
				}
			}
		case utils.DATA_SOURCE_CALCULATE_NHCC, utils.DATA_SOURCE_PREDICT_CALCULATE_NHCC: //计算指标（拟合残差）
			for _, v := range edbMappingList {
				//（需对上游指标+自变量，领先10天/因变量）
				if v.FromEdbInfoId == edbInfo.EdbInfoId {
					tmpName := ``
					if v.FromTag == `A` {
						tmpName = fmt.Sprintf(`自变量，领先%d天`, v.MoveValue)
					} else if v.FromTag == `B` {
						tmpName = `因变量`
					}
					edbName = fmt.Sprintf("%s（%s）", edbInfo.EdbName, tmpName)
				}
			}
		case utils.DATA_SOURCE_CALCULATE_CORRELATION: // 滚动相关性
			for _, v := range edbMappingList {
				if v.FromEdbInfoId == edbInfo.EdbInfoId {
					edbName = fmt.Sprintf("%s（%s）", edbInfo.EdbName, v.FromTag)
				}
			}

		}

	}

	if edbInfo.EdbType == 1 {
		// 基础指标的话，直接返回来源名称
		//ruleTitle = `来源于`+edbInfo.SourceName

		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 = `累计转月值计算`
	case utils.DATA_SOURCE_CALCULATE_TBZ, utils.DATA_SOURCE_PREDICT_CALCULATE_TBZ:
		ruleTitle = `同比值计算`
	case utils.DATA_SOURCE_CALCULATE_TCZ, utils.DATA_SOURCE_PREDICT_CALCULATE_TCZ:
		ruleTitle = `同差值计算`
	case utils.DATA_SOURCE_CALCULATE_NSZYDPJJS, utils.DATA_SOURCE_PREDICT_CALCULATE_NSZYDPJJS:
		ruleTitle = fmt.Sprintf("N数值移动均值计算（N=%s）", edbInfo.CalculateFormula)
	case utils.DATA_SOURCE_CALCULATE_HBZ, utils.DATA_SOURCE_PREDICT_CALCULATE_HBZ:
		ruleTitle = fmt.Sprintf("N数值环比值计算（N=%s）", edbInfo.CalculateFormula)
	case utils.DATA_SOURCE_CALCULATE_HCZ, utils.DATA_SOURCE_PREDICT_CALCULATE_HCZ:
		ruleTitle = fmt.Sprintf("N数值环差值计算（N=%s）", edbInfo.CalculateFormula)
	case utils.DATA_SOURCE_CALCULATE_TIME_SHIFT, utils.DATA_SOURCE_PREDICT_CALCULATE_TIME_SHIFT:
		moveType := `领先`
		if edbInfo.MoveType == 2 {
			moveType = "滞后"
		}
		ruleTitle = fmt.Sprintf("时间移位计算（%s%s%s）", moveType, 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)
	case utils.DATA_SOURCE_CALCULATE_ZJPJ, utils.DATA_SOURCE_PREDICT_CALCULATE_ZJPJ: // 直接拼接
		ruleTitle = fmt.Sprintf("直接拼接计算（%s）", edbInfo.CalculateFormula)
	case utils.DATA_SOURCE_CALCULATE_LJZTBPJ, utils.DATA_SOURCE_PREDICT_CALCULATE_LJZTBPJ: // 累计值同比拼
		ruleTitle = fmt.Sprintf("累计值同比值拼接计算（%s）", edbInfo.CalculateFormula)
	case utils.DATA_SOURCE_PYTHON:
		ruleTitle = `代码运算`
	case utils.DATA_SOURCE_CALCULATE_CJJX, utils.DATA_SOURCE_PREDICT_CALCULATE_CJJX:
		ruleTitle = fmt.Sprintf("超季节性计算（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)
	case utils.DATA_SOURCE_CALCULATE_ADJUST:
		ruleTitle = `数据调整`
	case utils.DATA_SOURCE_CALCULATE_NH, utils.DATA_SOURCE_PREDICT_CALCULATE_NH:
		ruleTitle = `年化计算`
	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 = []*models.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, tmpErr := time.ParseInLocation(utils.FormatDate, childEdbInfo.StartDate, time.Local)
				if tmpErr != nil {
					return
				}
				if startDate.IsZero() || startDate.After(tmpStartDate) {
					startDate = tmpStartDate
				}

				tmpEndDate, tmpErr := time.ParseInLocation(utils.FormatDate, childEdbInfo.EndDate, time.Local)
				if tmpErr != nil {
					return
				}
				if endDate.IsZero() || endDate.Before(tmpEndDate) {
					endDate = tmpEndDate
				}
			}
		}
		ruleTitle = fmt.Sprintf("扩散指数计算（%s至%s）", startDate.Format(utils.FormatDate), endDate.Format(utils.FormatDate))
	case utils.DATA_SOURCE_STOCK_PLANT:
		ruleTitle = `来源于装置分析`
	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)
	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)
	case utils.DATA_SOURCE_CALCULATE_STANDARD_DEVIATION:
		ruleTitle = fmt.Sprintf("标准差（滚动%s期）", 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)
	case utils.DATA_SOURCE_CALCULATE_ZSXY, utils.DATA_SOURCE_PREDICT_CALCULATE_ZSXY:
		ruleTitle = `指数修匀计算`
	}

	return
}