根据图表编码查询指标信息

controllers/business_chart.go

@@ -226,4 +226,83 @@ func (this *BusinessChartController) TraceEdbInfo() {
 	br.Ret = 200
 	br.Data = resp
 	br.Msg = "刷新成功"
+}
+
+// List
+// @Title 图表详情
+// @Description 图表详情
+// @Param   ChartInfoId  query  int  true  "图表id"
+// @Success 200 {object} data_manage.ChartInfoItem
+// @router /detail [get]
+func (this *BusinessChartController) ChartDetail() {
+	br := new(models.BaseResponse).Init()
+	defer func() {
+		this.Data["json"] = br
+		this.ServeJSON()
+	}()
+
+	businessCode := this.GetString("BusinessCode")
+	uniqueCode := this.GetString("UniqueCode")
+
+
+	if businessCode == "" {
+		br.Msg = "商家编码不允许为空"
+		return
+	}
+	if uniqueCode == "" {
+		br.Msg = "图表唯一编码不允许为空"
+		return
+	}
+
+	chartOb := new(data_manage.EtaBusinessChartPermission)
+		
+	
+	chartInfo, err := chartOb.GetChartInfoByUniqueCode(businessCode, uniqueCode)
+	if err != nil {
+		if err.Error() == utils.ErrNoRow() {
+			br.Msg = "图表不存在"
+			return
+		}
+		br.Msg = "获取图表信息失败"
+		br.ErrMsg = "ChartList GetChartListByBusinessCode err: " + err.Error()
+		return
+	}
+	descriptionList, err := chartOb.GetChartDescriptionListByChartInfoId(chartInfo.ChartInfoId)
+	if err != nil {
+		br.Msg = "获取图表描述信息失败"
+		br.ErrMsg = "ChartList GetChartDescriptionListByChartInfoIds err: " + err.Error()
+		return
+	}
+	descriptionStr := make([]string, 0)
+	for _, v := range descriptionList {
+		descriptionStr = append(descriptionStr, v.Description)
+	}
+	edbMappingList, err := data_manage.GetChartEdbMappingListByChartInfoId(chartInfo.ChartInfoId)
+	if err != nil {
+		br.Msg = "获取失败"
+		br.ErrMsg = "ChartList GetChartEdbMappingList err: " + err.Error()
+		return
+	}
+	edbList := make([]data_manage.TraceEdbInfoMoreResp, 0)
+	for _, v := range edbMappingList {
+		traceList, err := data.TraceBusinessEdbInfoByEdbInfoId(v.EdbInfoId, "")
+		if err != nil {
+			br.Msg = "获取失败"
+			br.ErrMsg = "ChartList GetChartEdbMappingList err: " + err.Error()
+			return
+		}
+		edbList = append(edbList, traceList)
+	}
+	
+	
+	resp := new(data_manage.BusinessChartDetailResp)
+	resp.ChartInfoId = chartInfo.ChartInfoId
+	resp.ChartName = chartInfo.ChartName
+	resp.UniqueCode = chartInfo.UniqueCode
+	resp.Description = descriptionStr
+	resp.EdbInfoList = edbList
+
+	br.Data = resp
+	br.Ret = 200
+	br.Msg = "获取成功"
 }

models/data_manage/chart_edb_mapping.go

@@ -66,4 +66,13 @@ func GetChartEdbMappingList(chartInfoIds []int) (mappingList []*ChartEdbInfoMapp
 	`
 	_, err = o.Raw(sql, chartInfoIds).QueryRows(&mappingList)
 	return
+}
+
+func GetChartEdbMappingListByChartInfoId(chartInfoId int) (mappingList []*ChartEdbInfoMapping, err error) {
+	o := orm.NewOrmUsingDB("data")
+	sql := `
+		SELECT * FROM chart_edb_mapping WHERE chart_info_id = ?
+	`
+	_, err = o.Raw(sql, chartInfoId).QueryRows(&mappingList)
+	return
 }

models/data_manage/edb_info.go

@@ -181,6 +181,24 @@ func FormatEdbInfo2Item(origin *EdbInfo) (item *EdbInfoItem) {
 }
 
 // TraceEdbInfoResp 指标追溯数据返回
+type TraceEdbInfoMoreResp struct {
+	EdbInfoId   int                `description:"指标id"`
+	EdbCode     string             `description:"指标编码"`
+	EdbInfoType int                `description:"指标类型: 0-普通指标; 1-预测指标"`
+	EdbName     string             `description:"指标名称"`
+	EdbType     int                `description:"指标类型: 1-基础指标; 2-计算指标"`
+	RuleTitle   string             `description:"指标规则"`
+	UniqueCode  string             `description:"唯一编码"`
+	Frequency   string             `description:"频率"`
+	Unit        string             `description:"单位"`
+	EndDate     string             `description:"终止日期"`
+	EndValue    float64            `description:"终止值"`
+	LatestDate  string             `description:"最新日期"`
+	LatestValue float64            `description:"最新值"`
+	Child       []TraceEdbInfoMoreResp `description:"下级来源"`
+	EdbInfo     *EdbInfo           `description:"指标信息" json:"-"`
+}
+
 type TraceEdbInfoResp struct {
 	EdbInfoId   int                `description:"指标id"`
 	EdbCode     string             `description:"指标编码"`

models/data_manage/eta_business_chart_permission.go

@@ -82,6 +82,23 @@ func (m *EtaBusinessChartPermission) GetChartListByBusinessCodeTotal(businessCod
 	return total, nil
 }
 
+// GetChartInfoByUniqueCode 根据唯一编码获取图表信息
+func (m *EtaBusinessChartPermission) GetChartInfoByUniqueCode(businessCode string, uniqueCode string) (chartInfo *BusinessChartInfoView, err error) {
+	o := orm.NewOrmUsingDB("data")
+	sql := `
+		SELECT 
+			c.chart_info_id, c.chart_name, c.unique_code
+		FROM 
+			eta_business_chart_permission p
+		JOIN 
+			chart_info c ON p.chart_info_id = c.chart_info_id
+		WHERE 
+			p.business_code = ? AND c.unique_code = ?
+	`
+	err = o.Raw(sql, businessCode, uniqueCode).QueryRow(&chartInfo)
+	return
+}
+
 // Init 初始化表结构
 func init() {
 	orm.RegisterModel(new(EtaBusinessChartPermission))
@@ -124,4 +141,21 @@ func (m *EtaBusinessChartPermission) GetChartDescriptionListByChartInfoIds(chart
 	`
 	_, err = o.Raw(sql, chartInfoIds).QueryRows(&list)
 	return list, err
+}
+
+func (m *EtaBusinessChartPermission) GetChartDescriptionListByChartInfoId(chartInfoId int) (list []*ChartDescription, err error) {
+	o := orm.NewOrmUsingDB("data")
+	sql := `
+		SELECT * FROM chart_description WHERE chart_info_id = ? ORDER BY id DESC
+	`
+	_, err = o.Raw(sql, chartInfoId).QueryRows(&list)
+	return 
+}
+
+type BusinessChartDetailResp struct {
+	ChartInfoId int
+	ChartName string
+	UniqueCode string	
+	Description []string
+	EdbInfoList []TraceEdbInfoMoreResp
 }

routers/commentsRouter.go

@@ -7,6 +7,15 @@ import (
 
 func init() {
 
+    beego.GlobalControllerRouter["eta/eta_hub/controllers:BusinessChartController"] = append(beego.GlobalControllerRouter["eta/eta_hub/controllers:BusinessChartController"],
+        beego.ControllerComments{
+            Method: "ChartDetail",
+            Router: `/detail`,
+            AllowHTTPMethods: []string{"get"},
+            MethodParams: param.Make(),
+            Filters: nil,
+            Params: nil})
+
     beego.GlobalControllerRouter["eta/eta_hub/controllers:BusinessChartController"] = append(beego.GlobalControllerRouter["eta/eta_hub/controllers:BusinessChartController"],
         beego.ControllerComments{
             Method: "ChartEdbDataList",

services/data/business_edb_info.go

@@ -0,0 +1,427 @@
+package data
+
+import (
+	"encoding/json"
+	"errors"
+	"eta/eta_hub/models/data_manage"
+	"eta/eta_hub/utils"
+	"fmt"
+	"strings"
+	"time"
+)
+
+// TraceEdbInfoByEdbInfoId 指标追溯
+func TraceBusinessEdbInfoByEdbInfoId(edbInfoId int, edbInfoCode string) (traceEdbInfo data_manage.TraceEdbInfoMoreResp, err error) {
+	var edbInfo *data_manage.EdbInfo
+	edbInfoOb := new(data_manage.EdbInfo)
+	if edbInfoId > 0 {
+		edbInfo, err = data_manage.GetEdbInfoById(edbInfoId)
+		if err != nil {
+			return
+		}
+	}else if edbInfoCode != "" {
+		edbInfo, err = edbInfoOb.GetItemByEdbCode(edbInfoCode)
+		if err != nil {
+			return
+		}
+		edbInfoId = edbInfo.EdbInfoId
+	}
+	
+	edbInfoRuleMap := make(map[int]string, 0)
+	edbMappingMap := make(map[int][]*data_manage.EdbInfoCalculateMappingInfo)
+	//edbInfoRuleMap[edbInfoId] = getEdbRuleTitle(edbInfo)
+	tmpEndValue := edbInfo.EndValue
+	if edbInfo.EdbInfoType == 0 {
+		tmpEndValue = edbInfo.LatestValue
+	}
+		
+	traceEdbInfo = data_manage.TraceEdbInfoMoreResp{
+		//EdbInfoId: edbInfo.EdbInfoId,
+		EdbInfoId:   edbInfoId,
+		EdbCode: edbInfo.EdbCode,
+		EdbInfoType: edbInfo.EdbInfoType,
+		EdbName:     edbInfo.EdbName,
+		EdbType:     edbInfo.EdbType,
+		//Source:      edbInfo.Source,
+		UniqueCode: edbInfo.UniqueCode,
+		Frequency: edbInfo.Frequency,
+		Unit: edbInfo.Unit,
+		EndDate: edbInfo.EndDate,
+		EndValue: tmpEndValue,
+		LatestDate: edbInfo.LatestDate,
+		LatestValue: edbInfo.LatestValue,
+		EdbInfo:    edbInfo,
+	}
+	findIdMap := make(map[int]int)
+	findIdMap[edbInfoId] = edbInfoId
+	existMap := make(map[int]data_manage.TraceEdbInfoMoreResp)
+	traceEdbInfo.Child, err = traceBusinessEdbInfoByEdbInfoId(edbInfoId, traceEdbInfo, edbInfoRuleMap, findIdMap, existMap, edbMappingMap)
+
+	edbInfoIdList := make([]int, 0)
+	for _, v := range findIdMap {
+		edbInfoIdList = append(edbInfoIdList, v)
+	}
+	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
+	}
+	traceEdbInfo, err = handleBusinessTraceEdbInfo(traceEdbInfo, 0, edbInfoMap, edbMappingMap)
+	return
+}
+
+// traceEdbInfoByEdbInfoId 指标追溯
+func traceBusinessEdbInfoByEdbInfoId(edbInfoId int, traceEdbInfo data_manage.TraceEdbInfoMoreResp, edbInfoRuleMap map[int]string, findIdMap map[int]int, existMap map[int]data_manage.TraceEdbInfoMoreResp, edbMappingMap map[int][]*data_manage.EdbInfoCalculateMappingInfo) (child []data_manage.TraceEdbInfoMoreResp, err error) {
+	traceEdbInfo, ok := existMap[edbInfoId]
+	if ok {
+		return
+	}
+	child = make([]data_manage.TraceEdbInfoMoreResp, 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
+		tmpEndValue := edbInfoMap[v.FromEdbInfoId].EndValue
+		if edbInfoMap[v.FromEdbInfoId].EdbInfoType == 0 {
+			tmpEndValue = edbInfoMap[v.FromEdbInfoId].LatestValue
+		}
+		
+		tmpTraceEdbInfo := data_manage.TraceEdbInfoMoreResp{
+			EdbInfoId:   tmpEdbInfoId,
+			EdbCode:     v.FromEdbCode,
+			EdbInfoType: v.FromEdbInfoType,
+			EdbType:     v.FromEdbType,
+			UniqueCode:  v.FromUniqueCode,
+			Frequency: edbInfoMap[v.FromEdbInfoId].Frequency,
+			Unit: edbInfoMap[v.FromEdbInfoId].Unit,
+			EndDate: edbInfoMap[v.FromEdbInfoId].EndDate,
+			EndValue: 	tmpEndValue,
+			LatestDate: edbInfoMap[v.FromEdbInfoId].LatestDate,
+			LatestValue: edbInfoMap[v.FromEdbInfoId].LatestValue,
+			EdbInfo:     edbInfoMap[v.FromEdbInfoId],
+		}
+
+		// 计算指标/预测指标继续溯源
+		if v.FromEdbType == 2 || v.FromEdbInfoType == 1 {
+			// 查过了就不查了
+			if _, ok2 := findIdMap[tmpEdbInfoId]; !ok2 {
+				tmpTraceEdbInfo.Child, e = traceBusinessEdbInfoByEdbInfoId(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 handleBusinessTraceEdbInfo(traceEdbInfoResp data_manage.TraceEdbInfoMoreResp, parentEdbInfoId int, edbInfoMap map[int]*data_manage.EdbInfo, edbMappingMap map[int][]*data_manage.EdbInfoCalculateMappingInfo) (newTraceEdbInfoResp data_manage.TraceEdbInfoMoreResp, 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 = edbInfo.EdbName
+	traceEdbInfoResp.EdbName, _, traceEdbInfoResp.RuleTitle, _ = getBusinessEdbRuleTitle(edbInfo, parentEdbInfo, traceEdbInfoResp.Child, edbInfoMap, edbMappingMap)
+
+	if traceEdbInfoResp.Child != nil && len(traceEdbInfoResp.Child) > 0 {
+		for k, v := range traceEdbInfoResp.Child {
+			traceEdbInfoResp.Child[k], err = handleBusinessTraceEdbInfo(v, traceEdbInfoResp.EdbInfoId, edbInfoMap, edbMappingMap)
+			if err != nil {
+				return
+			}
+		}
+	}
+	newTraceEdbInfoResp = traceEdbInfoResp
+
+	return
+}
+
+// getEdbRule 获取规则名称
+func getBusinessEdbRuleTitle(edbInfo, parentEdbInfo *data_manage.EdbInfo, childList []data_manage.TraceEdbInfoMoreResp, 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 {
+				//（需对上游指标+自变量，领先10天/因变量）
+				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 {
+		// 基础指标的话，直接返回来源名称
+		//ruleTitle = `来源于`+edbInfo.SourceName
+
+		return
+	}
+
+	// 规则
+	switch edbInfo.Source {
+	case utils.DATA_SOURCE_CALCULATE, utils.DATA_SOURCE_PREDICT_CALCULATE:
+		ruleTitle = formatCalculateFormula(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, 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))
+		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
+}