Merge branch '11.3'

# Conflicts:
#	routers/commentsRouter.go
#	routers/router.go

controllers/base_from_predict.go

@@ -0,0 +1,182 @@
+package controllers
+
+import (
+	"encoding/json"
+	"fmt"
+	"hongze/hongze_edb_lib/logic"
+	"hongze/hongze_edb_lib/models"
+	"hongze/hongze_edb_lib/utils"
+	"strconv"
+	"strings"
+	"time"
+)
+
+// PredictController 预测指标
+type PredictController struct {
+	BaseAuthController
+}
+
+// Save
+// @Title 新增/编辑预测指标运算接口
+// @Description 新增预测指标运算接口
+// @Success 200 {object} models.EdbInfoCalculateSaveReq
+// @router /save [post]
+func (this *PredictController) Save() {
+	br := new(models.BaseResponse).Init()
+	defer func() {
+		this.Data["json"] = br
+		this.ServeJSON()
+	}()
+	var req models.AddPredictEdbInfoReq
+	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
+	if err != nil {
+		br.Msg = "参数解析异常！"
+		br.ErrMsg = "参数解析失败，Err:" + err.Error()
+		return
+	}
+	if req.EdbInfoId <= 0 {
+		addPredict(br, req)
+	} else {
+		editPredict(br, req)
+	}
+}
+
+// AddPredictCalculate 添加预测指标运算
+func addPredict(br *models.BaseResponse, req models.AddPredictEdbInfoReq) {
+	//加入缓存机制，避免创建同一个名称的指标 start
+	redisKey := fmt.Sprint("predict_edb_info:calculate:batch:save:", utils.DATA_SOURCE_PREDICT, ":", req.EdbName)
+	isExist := utils.Rc.IsExist(redisKey)
+	if isExist {
+		br.Msg = "指标正在处理,请勿重复提交"
+		return
+	} else {
+		//设置3分钟缓存
+		utils.Rc.SetNX(redisKey, 1, time.Second*300)
+		defer func() {
+			_ = utils.Rc.Delete(redisKey)
+		}()
+	}
+
+	// 添加指标
+	edbInfo, err, errMsg := logic.AddPredictEdbInfo(req.SourceEdbInfoId, req.ClassifyId, req.EdbName, req.RuleList, req.AdminId, req.AdminName)
+	if err != nil {
+		br.Msg = "保存失败"
+		if errMsg != `` {
+			br.Msg = errMsg
+		}
+		br.ErrMsg = err.Error()
+		return
+	}
+	resp := models.AddEdbInfoResp{
+		EdbInfoId:  edbInfo.EdbInfoId,
+		UniqueCode: edbInfo.UniqueCode,
+	}
+	br.Ret = 200
+	br.Success = true
+	br.Msg = "保存成功"
+	br.Data = resp
+	br.IsAddLog = true
+}
+
+// editPredictCalculate 编辑预测指标运算
+func editPredict(br *models.BaseResponse, req models.AddPredictEdbInfoReq) {
+	req.EdbName = strings.Trim(req.EdbName, " ")
+	//加入缓存机制，避免创建同一个名称的指标 start
+	redisKey := fmt.Sprint("predict_edb_info:calculate:batch:save:", utils.DATA_SOURCE_PREDICT, ":", req.EdbName)
+	isExist := utils.Rc.IsExist(redisKey)
+	if isExist {
+		br.Msg = "指标正在处理,请勿重复提交"
+		return
+	} else {
+		//设置3分钟缓存
+		utils.Rc.SetNX(redisKey, 1, time.Second*300)
+		defer func() {
+			_ = utils.Rc.Delete(redisKey)
+		}()
+	}
+
+	// 编辑指标
+	edbInfo, err, errMsg := logic.EditPredictEdbInfo(req.EdbInfoId, req.ClassifyId, req.EdbName, req.RuleList)
+	if err != nil {
+		br.Msg = "保存失败"
+		if errMsg != `` {
+			br.Msg = errMsg
+		}
+		br.ErrMsg = err.Error()
+		return
+	}
+	resp := models.AddEdbInfoResp{
+		EdbInfoId:  edbInfo.EdbInfoId,
+		UniqueCode: edbInfo.UniqueCode,
+	}
+	br.Ret = 200
+	br.Success = true
+	br.Msg = "保存成功"
+	br.Data = resp
+	br.IsAddLog = true
+}
+
+// Refresh
+// @Title 刷新预测指标接口（有些预测指标里面含有动态数据）
+// @Description 刷新预测指标接口（有些预测指标里面含有动态数据）
+// @Success 200 {object} models.RefreshEdbInfoReq
+// @router /refresh [post]
+func (this *PredictController) Refresh() {
+	br := new(models.BaseResponse).Init()
+	var cacheKey string
+	defer func() {
+		this.Data["json"] = br
+		this.ServeJSON()
+	}()
+	var req models.RefreshEdbInfoReq
+	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
+	if err != nil {
+		br.Msg = "参数解析异常！"
+		br.ErrMsg = "参数解析失败，Err:" + err.Error()
+		return
+	}
+	if req.EdbCode == "" {
+		br.Msg = "请输入指标编码！"
+		br.ErrMsg = "请输入指标编码，指标编码为空"
+		return
+	}
+	if req.EdbInfoId <= 0 {
+		br.Msg = "请输入指标ID！"
+		br.ErrMsg = "请输入指标ID"
+		return
+	}
+	edbInfo, err := models.GetEdbInfoById(req.EdbInfoId)
+	if err != nil {
+		br.Msg = "指标不存在！"
+		br.ErrMsg = "指标不存在"
+		return
+	}
+
+	cacheKey = utils.CACHE_EDB_DATA_REFRESH + strconv.Itoa(edbInfo.Source) + "_" + req.EdbCode
+	if utils.Rc.IsExist(cacheKey) {
+		br.Ret = 501
+		br.Success = true
+		br.Msg = "系统处理中，请稍后重试"
+		br.IsSendEmail = false
+	}
+
+	utils.Rc.SetNX(cacheKey, 1, 1*time.Minute)
+	defer func() {
+		_ = utils.Rc.Delete(cacheKey)
+
+	}()
+	var errMsg string
+	_, err, errMsg = logic.RefreshPredictEdbInfo(req.EdbInfoId)
+	if err != nil {
+		br.Msg = "刷新指标失败！"
+		if errMsg != `` {
+			br.ErrMsg = errMsg
+		}
+		br.ErrMsg = "刷新指标失败，err:" + err.Error()
+		return
+	}
+
+	br.Ret = 200
+	br.Success = true
+	br.Msg = "获取成功"
+}

logic/predict_edb.go

@@ -0,0 +1,725 @@
+package logic
+
+import (
+	"errors"
+	"hongze/hongze_edb_lib/models"
+	"hongze/hongze_edb_lib/services"
+	"hongze/hongze_edb_lib/utils"
+	"strconv"
+	"strings"
+	"time"
+)
+
+// AddPredictEdbInfo 新增预测指标
+func AddPredictEdbInfo(sourceEdbInfoId, classifyId int, edbName string, ruleList []models.RuleConfig, sysUserId int, sysUserName string) (edbInfo *models.EdbInfo, err error, errMsg string) {
+	var sourceEdbInfo *models.EdbInfo
+	// 来源指标信息校验
+	{
+		sourceEdbInfo, err = models.GetEdbInfoById(sourceEdbInfoId)
+		if err != nil && err.Error() != utils.ErrNoRow() {
+			errMsg = "新增失败"
+			err = errors.New("获取来源指标失败，Err:" + err.Error())
+			return
+		}
+		if sourceEdbInfo == nil {
+			errMsg = "找不到该来源指标"
+			err = errors.New(errMsg)
+			return
+		}
+		//必须是普通的指标
+		if sourceEdbInfo.EdbInfoType != 0 {
+			errMsg = "来源指标异常，不是普通的指标"
+			err = errors.New(errMsg)
+			return
+		}
+		if !utils.InArrayByStr([]string{"日度", "周度", "月度"}, sourceEdbInfo.Frequency) {
+			errMsg = "预测指标只支持选择日度、周度、月度的指标"
+			err = errors.New(errMsg)
+			return
+		}
+	}
+
+	var classifyInfo *models.EdbClassify
+	// 来源分类信息校验
+	{
+		classifyInfo, err = models.GetEdbClassifyById(classifyId)
+		if err != nil && err.Error() != utils.ErrNoRow() {
+			errMsg = "新增失败"
+			err = errors.New("获取预测指标分类失败，Err:" + err.Error())
+			return
+		}
+		if classifyInfo == nil {
+			errMsg = "找不到该预测指标分类"
+			err = errors.New(errMsg)
+			return
+		}
+		//必须是预测指标分类
+		if classifyInfo.ClassifyType != 1 {
+			errMsg = "预测指标分类异常，不是预测指标分类"
+			err = errors.New(errMsg)
+			return
+		}
+	}
+
+	edbName = strings.Trim(edbName, " ")
+
+	edbCode := sourceEdbInfo.EdbCode + "_" + time.Now().Format(utils.FormatShortDateTimeUnSpace)
+
+	//判断指标名称是否存在
+	var condition string
+	var pars []interface{}
+	condition += " AND edb_info_type=? "
+	pars = append(pars, 1)
+
+	condition += " AND edb_name=? "
+	pars = append(pars, edbName)
+
+	count, err := models.GetEdbInfoCountByCondition(condition, pars)
+	if err != nil {
+		errMsg = "判断指标名称是否存在失败"
+		err = errors.New("判断指标名称是否存在失败,Err:" + err.Error())
+		return
+	}
+	if count > 0 {
+		errMsg = "指标名称已存在，请重新填写"
+		err = errors.New(errMsg)
+		return
+	}
+
+	timestamp := strconv.FormatInt(time.Now().UnixNano(), 10)
+	edbInfo = &models.EdbInfo{
+		//EdbInfoId:   0,
+		EdbInfoType:      1,
+		SourceName:       "预测指标",
+		Source:           utils.DATA_SOURCE_PREDICT,
+		EdbCode:          edbCode,
+		EdbName:          edbName,
+		EdbNameSource:    edbName,
+		Frequency:        sourceEdbInfo.Frequency,
+		Unit:             sourceEdbInfo.Unit,
+		StartDate:        sourceEdbInfo.StartDate,
+		ClassifyId:       classifyId,
+		SysUserId:        sysUserId,
+		SysUserRealName:  sysUserName,
+		UniqueCode:       utils.MD5(utils.DATA_PREFIX + "_" + timestamp),
+		CreateTime:       time.Now(),
+		ModifyTime:       time.Now(),
+		MinValue:         sourceEdbInfo.MinValue,
+		MaxValue:         sourceEdbInfo.MaxValue,
+		CalculateFormula: sourceEdbInfo.CalculateFormula,
+		EdbType:          1,
+		//Sort:             sourceEdbInfo.,
+		LatestDate:    sourceEdbInfo.LatestDate,
+		LatestValue:   sourceEdbInfo.LatestValue,
+		MoveType:      sourceEdbInfo.MoveType,
+		MoveFrequency: sourceEdbInfo.MoveFrequency,
+		NoUpdate:      sourceEdbInfo.NoUpdate,
+		ServerUrl:     "",
+	}
+
+	// 关联关系表
+	calculateMappingList := make([]*models.EdbInfoCalculateMapping, 0)
+	fromEdbMap := make(map[int]int)
+
+	// 源指标关联关系表
+	calculateMappingItem := &models.EdbInfoCalculateMapping{
+		//EdbInfoCalculateMappingId: 0,
+		//EdbInfoId:                 0,
+		Source:         edbInfo.Source,
+		SourceName:     edbInfo.SourceName,
+		EdbCode:        edbInfo.EdbCode,
+		FromEdbInfoId:  sourceEdbInfo.EdbInfoId,
+		FromEdbCode:    sourceEdbInfo.EdbCode,
+		FromEdbName:    sourceEdbInfo.EdbName,
+		FromSource:     sourceEdbInfo.Source,
+		FromSourceName: sourceEdbInfo.SourceName,
+		//FromTag:        "",
+		Sort:       1,
+		CreateTime: time.Now(),
+		ModifyTime: time.Now(),
+	}
+	fromEdbMap[sourceEdbInfoId] = sourceEdbInfoId
+	calculateMappingList = append(calculateMappingList, calculateMappingItem)
+
+	// 动态环差 计算列表
+	calculateRuleList := make([]models.CalculateRule, 0)
+
+	// 预测指标配置
+	predictEdbConfList := make([]*models.PredictEdbConf, 0)
+	for _, v := range ruleList {
+		// 预测指标配置
+		ruleEndDate, tmpErr := time.ParseInLocation(utils.FormatDate, v.EndDate, time.Local)
+		if tmpErr != nil {
+			errMsg = "规则配置的截止日期异常，请重新填写"
+			err = errors.New(errMsg)
+			return
+		}
+		switch v.RuleType {
+		case 8: //N期段线性外推值
+			valInt, tmpErr := strconv.Atoi(v.Value)
+			if tmpErr != nil {
+				errMsg = "N期段线性外推值的N值异常"
+				err = errors.New(errMsg)
+				return
+			}
+			if valInt <= 1 {
+				errMsg = "N期段线性外推值的N值必须大于1"
+				err = errors.New(errMsg)
+				return
+			}
+		case 9: //9：动态环差
+			if v.Value == "" {
+				errMsg = "请填写计算规则"
+				err = errors.New(errMsg)
+				return
+			}
+			formula := v.Value
+			formula = strings.Replace(formula, "（", "(", -1)
+			formula = strings.Replace(formula, "）", ")", -1)
+			formula = strings.Replace(formula, "，", ",", -1)
+			formula = strings.Replace(formula, "。", ".", -1)
+			formula = strings.Replace(formula, "%", "*0.01", -1)
+			v.Value = formula
+
+			//检验公式
+			var formulaStr string
+			var edbInfoIdBytes []string
+			for _, tmpEdbInfoId := range v.EdbInfoIdArr {
+				formulaStr += tmpEdbInfoId.FromTag + ","
+				edbInfoIdBytes = append(edbInfoIdBytes, tmpEdbInfoId.FromTag)
+			}
+			formulaMap := services.CheckFormula(formula)
+			for _, formula := range formulaMap {
+				if !strings.Contains(formulaStr, formula) {
+					errMsg = "公式错误，请重新填写"
+					err = errors.New(errMsg)
+					return
+				}
+			}
+
+			//关联的指标信息
+			edbInfoList := make([]*models.EdbInfo, 0)
+			// 动态环差规则 关系表
+			trendsMappingList := make([]*models.PredictEdbConfCalculateMapping, 0)
+
+			for k, tmpEdbInfoId := range v.EdbInfoIdArr {
+				fromEdbInfo, tmpErr := models.GetEdbInfoById(tmpEdbInfoId.EdbInfoId)
+				if tmpErr != nil {
+					err = tmpErr
+					if err.Error() == utils.ErrNoRow() {
+						errMsg = "指标 " + strconv.Itoa(tmpEdbInfoId.EdbInfoId) + " 不存在"
+						err = errors.New(errMsg)
+						return
+					}
+					errMsg = "获取指标失败:Err:" + err.Error()
+					err = errors.New(errMsg)
+					return
+				}
+
+				edbInfoList = append(edbInfoList, fromEdbInfo)
+
+				//总的 预测指标与所有相关联指标的关系表（不仅仅该条规则）
+				{
+					if _, ok := fromEdbMap[tmpEdbInfoId.EdbInfoId]; !ok {
+						fromEdbMap[tmpEdbInfoId.EdbInfoId] = tmpEdbInfoId.EdbInfoId
+						calculateMappingItem := &models.EdbInfoCalculateMapping{
+							EdbInfoCalculateMappingId: 0,
+							EdbInfoId:                 0,
+							Source:                    utils.DATA_SOURCE_CALCULATE,
+							SourceName:                "指标运算",
+							EdbCode:                   "",
+							FromEdbInfoId:             fromEdbInfo.EdbInfoId,
+							FromEdbCode:               fromEdbInfo.EdbCode,
+							FromEdbName:               fromEdbInfo.EdbName,
+							FromSource:                fromEdbInfo.Source,
+							FromSourceName:            fromEdbInfo.SourceName,
+							//FromTag:                   tmpEdbInfoId.FromTag,
+							Sort:       k + 1,
+							CreateTime: time.Now(),
+							ModifyTime: time.Now(),
+						}
+						calculateMappingList = append(calculateMappingList, calculateMappingItem)
+					}
+				}
+				// 动态环差规则 关系表
+				tmpPredictEdbConfCalculateMapping := &models.PredictEdbConfCalculateMapping{
+					//PredictEdbConfCalculateMappingId: 0,
+					EdbInfoId:      0,
+					ConfigId:       0,
+					FromEdbInfoId:  fromEdbInfo.EdbInfoId,
+					FromEdbCode:    fromEdbInfo.EdbCode,
+					FromEdbName:    fromEdbInfo.EdbName,
+					FromSource:     fromEdbInfo.Source,
+					FromSourceName: fromEdbInfo.SourceName,
+					FromTag:        tmpEdbInfoId.FromTag,
+					Sort:           k + 1,
+					CreateTime:     time.Now(),
+					ModifyTime:     time.Now(),
+				}
+				trendsMappingList = append(trendsMappingList, tmpPredictEdbConfCalculateMapping)
+			}
+			ok, _ := models.CheckFormula2(edbInfoList, formulaMap, formula, edbInfoIdBytes)
+			if !ok {
+				errMsg = "生成计算指标失败，请使用正确的计算公式"
+				err = errors.New(errMsg)
+				return
+			}
+
+			calculateRuleList = append(calculateRuleList, models.CalculateRule{
+				TrendsCalculateMappingList: trendsMappingList,
+				EdbInfoList:                edbInfoList,
+				EdbInfoIdBytes:             edbInfoIdBytes,
+				Formula:                    formula,
+				RuleType:                   v.RuleType,
+				EndDate:                    v.EndDate,
+				EdbInfoIdArr:               v.EdbInfoIdArr,
+			})
+		}
+
+		tmpPredictEdbConf := &models.PredictEdbConf{
+			PredictEdbInfoId: 0,
+			SourceEdbInfoId:  sourceEdbInfoId,
+			RuleType:         v.RuleType,
+			//FixedValue:       v.Value,
+			Value:      v.Value,
+			EndDate:    ruleEndDate,
+			ModifyTime: time.Now(),
+			CreateTime: time.Now(),
+		}
+
+		edbInfo.EndDate = v.EndDate
+
+		predictEdbConfList = append(predictEdbConfList, tmpPredictEdbConf)
+	}
+	err = models.AddPredictEdb(edbInfo, calculateMappingList, predictEdbConfList, calculateRuleList)
+
+	return
+}
+
+// EditPredictEdbInfo 编辑预测指标
+func EditPredictEdbInfo(edbInfoId, classifyId int, edbName string, ruleList []models.RuleConfig) (edbInfo *models.EdbInfo, err error, errMsg string) {
+	// 指标信息校验
+	{
+		edbInfo, err = models.GetEdbInfoById(edbInfoId)
+		if err != nil && err.Error() != utils.ErrNoRow() {
+			errMsg = "修改失败"
+			err = errors.New("获取预测指标失败，Err:" + err.Error())
+			return
+		}
+		if edbInfo == nil {
+			errMsg = "找不到该预测指标"
+			err = errors.New(errMsg)
+			return
+		}
+		//必须是普通的指标
+		if edbInfo.EdbInfoType != 1 {
+			errMsg = "指标异常，不是预测指标"
+			err = errors.New(errMsg)
+			return
+		}
+	}
+
+	var predictEdbConf *models.PredictEdbConf
+	// 指标配置信息校验
+	{
+		// 查找该预测指标配置
+		predictEdbConfList, tmpErr := models.GetPredictEdbConfListById(edbInfo.EdbInfoId)
+		if tmpErr != nil && tmpErr.Error() != utils.ErrNoRow() {
+			errMsg = "修改失败"
+			err = errors.New("获取预测指标配置信息失败，Err:" + tmpErr.Error())
+			return
+		}
+		if len(predictEdbConfList) == 0 {
+			errMsg = "找不到该预测指标配置"
+			err = errors.New(errMsg)
+			return
+		}
+		predictEdbConf = predictEdbConfList[0]
+	}
+
+	//判断指标名称是否存在
+	var condition string
+	var pars []interface{}
+
+	condition += " AND edb_info_id<>? "
+	pars = append(pars, edbInfoId)
+
+	condition += " AND edb_info_type=? "
+	pars = append(pars, 1)
+
+	condition += " AND edb_name=? "
+	pars = append(pars, edbName)
+
+	count, err := models.GetEdbInfoCountByCondition(condition, pars)
+	if err != nil {
+		errMsg = "判断指标名称是否存在失败"
+		err = errors.New("判断指标名称是否存在失败,Err:" + err.Error())
+		return
+	}
+
+	if count > 0 {
+		errMsg = "指标名称已存在，请重新填写"
+		err = errors.New(errMsg)
+		return
+	}
+
+	edbInfo.EdbName = edbName
+	edbInfo.EdbNameSource = edbName
+	edbInfo.ClassifyId = classifyId
+	edbInfo.ModifyTime = time.Now()
+	updateEdbInfoCol := []string{"EdbName", "EdbNameSource", "ClassifyId", "EndDate", "ModifyTime"}
+
+	var sourceEdbInfo *models.EdbInfo
+	// 来源指标信息校验
+	{
+		sourceEdbInfo, err = models.GetEdbInfoById(predictEdbConf.SourceEdbInfoId)
+		if err != nil && err.Error() != utils.ErrNoRow() {
+			errMsg = "新增失败"
+			err = errors.New("获取来源指标失败，Err:" + err.Error())
+			return
+		}
+		if sourceEdbInfo == nil {
+			errMsg = "找不到该来源指标"
+			err = errors.New(errMsg)
+			return
+		}
+		//必须是普通的指标
+		if sourceEdbInfo.EdbInfoType != 0 {
+			errMsg = "来源指标异常，不是普通的指标"
+			err = errors.New(errMsg)
+			return
+		}
+		if !utils.InArrayByStr([]string{"日度", "周度", "月度"}, sourceEdbInfo.Frequency) {
+			errMsg = "预测指标只支持选择日度、周度、月度的指标"
+			err = errors.New(errMsg)
+			return
+		}
+	}
+
+	// 预测指标配置
+	// 关联关系表
+	calculateMappingList := make([]*models.EdbInfoCalculateMapping, 0)
+	fromEdbMap := make(map[int]int)
+
+	// 源指标关联关系表
+	calculateMappingItem := &models.EdbInfoCalculateMapping{
+		//EdbInfoCalculateMappingId: 0,
+		EdbInfoId:      edbInfoId,
+		Source:         edbInfo.Source,
+		SourceName:     edbInfo.SourceName,
+		EdbCode:        edbInfo.EdbCode,
+		FromEdbInfoId:  sourceEdbInfo.EdbInfoId,
+		FromEdbCode:    sourceEdbInfo.EdbCode,
+		FromEdbName:    sourceEdbInfo.EdbName,
+		FromSource:     sourceEdbInfo.Source,
+		FromSourceName: sourceEdbInfo.SourceName,
+		//FromTag:        "",
+		Sort:       1,
+		CreateTime: time.Now(),
+		ModifyTime: time.Now(),
+	}
+	fromEdbMap[sourceEdbInfo.EdbInfoId] = sourceEdbInfo.EdbInfoId
+	calculateMappingList = append(calculateMappingList, calculateMappingItem)
+
+	// 动态环差 计算列表
+	calculateRuleList := make([]models.CalculateRule, 0)
+
+	// 预测指标配置
+	predictEdbConfList := make([]*models.PredictEdbConf, 0)
+	for _, v := range ruleList {
+		// 预测指标配置
+		ruleEndDate, tmpErr := time.ParseInLocation(utils.FormatDate, v.EndDate, time.Local)
+		if tmpErr != nil {
+			errMsg = "规则配置的截止日期异常，请重新填写"
+			err = errors.New(errMsg)
+			return
+		}
+		switch v.RuleType {
+		case 8: //N期段线性外推值
+			valInt, tmpErr := strconv.Atoi(v.Value)
+			if tmpErr != nil {
+				errMsg = "N期段线性外推值的N值异常"
+				err = errors.New(errMsg)
+				return
+			}
+			if valInt <= 1 {
+				errMsg = "N期段线性外推值的N值必须大于1"
+				err = errors.New(errMsg)
+				return
+			}
+		case 9: //9：动态环差
+			if v.Value == "" {
+				errMsg = "请填写计算规则"
+				err = errors.New(errMsg)
+				return
+			}
+			formula := v.Value
+			formula = strings.Replace(formula, "（", "(", -1)
+			formula = strings.Replace(formula, "）", ")", -1)
+			formula = strings.Replace(formula, "，", ",", -1)
+			formula = strings.Replace(formula, "。", ".", -1)
+			formula = strings.Replace(formula, "%", "*0.01", -1)
+			v.Value = formula
+
+			//检验公式
+			var formulaStr string
+			var edbInfoIdBytes []string
+			for _, tmpEdbInfoId := range v.EdbInfoIdArr {
+				formulaStr += tmpEdbInfoId.FromTag + ","
+				edbInfoIdBytes = append(edbInfoIdBytes, tmpEdbInfoId.FromTag)
+			}
+			formulaMap := services.CheckFormula(formula)
+			for _, formula := range formulaMap {
+				if !strings.Contains(formulaStr, formula) {
+					errMsg = "公式错误，请重新填写"
+					err = errors.New(errMsg)
+					return
+				}
+			}
+
+			//关联的指标信息
+			edbInfoList := make([]*models.EdbInfo, 0)
+			// 动态环差规则 关系表
+			trendsMappingList := make([]*models.PredictEdbConfCalculateMapping, 0)
+
+			for k, tmpEdbInfoId := range v.EdbInfoIdArr {
+				fromEdbInfo, tmpErr := models.GetEdbInfoById(tmpEdbInfoId.EdbInfoId)
+				if tmpErr != nil {
+					err = tmpErr
+					if err.Error() == utils.ErrNoRow() {
+						errMsg = "指标 " + strconv.Itoa(tmpEdbInfoId.EdbInfoId) + " 不存在"
+						err = errors.New(errMsg)
+						return
+					}
+					errMsg = "获取指标失败:Err:" + err.Error()
+					err = errors.New(errMsg)
+					return
+				}
+
+				edbInfoList = append(edbInfoList, fromEdbInfo)
+
+				//总的 预测指标与所有相关联指标的关系表（不仅仅该条规则）
+				{
+					if _, ok := fromEdbMap[tmpEdbInfoId.EdbInfoId]; !ok {
+						fromEdbMap[tmpEdbInfoId.EdbInfoId] = tmpEdbInfoId.EdbInfoId
+						calculateMappingItem := &models.EdbInfoCalculateMapping{
+							EdbInfoCalculateMappingId: 0,
+							EdbInfoId:                 edbInfoId,
+							Source:                    utils.DATA_SOURCE_CALCULATE,
+							SourceName:                "指标运算",
+							EdbCode:                   "",
+							FromEdbInfoId:             fromEdbInfo.EdbInfoId,
+							FromEdbCode:               fromEdbInfo.EdbCode,
+							FromEdbName:               fromEdbInfo.EdbName,
+							FromSource:                fromEdbInfo.Source,
+							FromSourceName:            fromEdbInfo.SourceName,
+							//FromTag:                   tmpEdbInfoId.FromTag,
+							Sort:       k + 1,
+							CreateTime: time.Now(),
+							ModifyTime: time.Now(),
+						}
+						calculateMappingList = append(calculateMappingList, calculateMappingItem)
+					}
+				}
+				// 动态环差规则 关系表
+				tmpPredictEdbConfCalculateMapping := &models.PredictEdbConfCalculateMapping{
+					//PredictEdbConfCalculateMappingId: 0,
+					EdbInfoId:      edbInfoId,
+					ConfigId:       0,
+					FromEdbInfoId:  fromEdbInfo.EdbInfoId,
+					FromEdbCode:    fromEdbInfo.EdbCode,
+					FromEdbName:    fromEdbInfo.EdbName,
+					FromSource:     fromEdbInfo.Source,
+					FromSourceName: fromEdbInfo.SourceName,
+					FromTag:        tmpEdbInfoId.FromTag,
+					Sort:           k + 1,
+					CreateTime:     time.Now(),
+					ModifyTime:     time.Now(),
+				}
+				trendsMappingList = append(trendsMappingList, tmpPredictEdbConfCalculateMapping)
+			}
+			ok, _ := models.CheckFormula2(edbInfoList, formulaMap, formula, edbInfoIdBytes)
+			if !ok {
+				errMsg = "生成计算指标失败，请使用正确的计算公式"
+				err = errors.New(errMsg)
+				return
+			}
+
+			calculateRuleList = append(calculateRuleList, models.CalculateRule{
+				TrendsCalculateMappingList: trendsMappingList,
+				EdbInfoList:                edbInfoList,
+				EdbInfoIdBytes:             edbInfoIdBytes,
+				Formula:                    formula,
+				RuleType:                   v.RuleType,
+				EndDate:                    v.EndDate,
+				EdbInfoIdArr:               v.EdbInfoIdArr,
+			})
+		}
+
+		tmpPredictEdbConf := &models.PredictEdbConf{
+			PredictEdbInfoId: edbInfoId,
+			SourceEdbInfoId:  sourceEdbInfo.EdbInfoId,
+			RuleType:         v.RuleType,
+			//FixedValue:       v.Value,
+			Value:      v.Value,
+			EndDate:    ruleEndDate,
+			ModifyTime: time.Now(),
+			CreateTime: time.Now(),
+		}
+
+		edbInfo.EndDate = v.EndDate
+
+		predictEdbConfList = append(predictEdbConfList, tmpPredictEdbConf)
+	}
+
+	err = models.EditPredictEdb(edbInfo, updateEdbInfoCol, calculateMappingList, predictEdbConfList, calculateRuleList)
+
+	return
+}
+
+// RefreshPredictEdbInfo 更新基础预测指标规则中的动态数据
+func RefreshPredictEdbInfo(edbInfoId int) (edbInfo *models.EdbInfo, err error, errMsg string) {
+	// 指标信息校验
+	{
+		edbInfo, err = models.GetEdbInfoById(edbInfoId)
+		if err != nil && err.Error() != utils.ErrNoRow() {
+			errMsg = "刷新失败"
+			err = errors.New("获取预测指标失败，Err:" + err.Error())
+			return
+		}
+		if edbInfo == nil {
+			errMsg = "找不到该预测指标"
+			err = nil
+			return
+		}
+		//必须是普通的指标
+		if edbInfo.EdbInfoType != 1 {
+			errMsg = "指标异常，不是预测指标"
+			return
+		}
+	}
+
+	// 配置 与 指标的 关联关系表
+	list, err := models.GetPredictEdbConfCalculateMappingListByEdbInfoId(edbInfoId)
+	if err != nil {
+		return
+	}
+	// 没有关联指标，不需要刷新
+	if len(list) <= 0 {
+		return
+	}
+
+	// 配置关联的指标信息
+	predictEdbConfCalculateMappingListMap := make(map[int][]*models.PredictEdbConfCalculateMapping)
+	configIdList := make([]int, 0)       //关联配置id
+	edbInfoIdList := make([]int, 0)      //关联指标配置id
+	edbInfoIdMap := make(map[int]int, 0) //关联指标配置map
+	for _, v := range list {
+		configList, ok := predictEdbConfCalculateMappingListMap[v.ConfigId]
+		if !ok {
+			configList = make([]*models.PredictEdbConfCalculateMapping, 0)
+			configIdList = append(configIdList, v.ConfigId)
+		}
+		if _, ok := edbInfoIdMap[v.FromEdbInfoId]; !ok {
+			edbInfoIdList = append(edbInfoIdList, v.FromEdbInfoId)
+		}
+		configList = append(configList, v)
+		predictEdbConfCalculateMappingListMap[v.ConfigId] = configList
+	}
+
+	predictEdbConfList, err := models.GetPredictEdbConfListByConfigIdList(configIdList)
+	if err != nil {
+		errMsg = "刷新失败"
+		err = errors.New("获取预测指标配置信息失败，Err:" + err.Error())
+		return
+	}
+	if len(predictEdbConfList) == 0 {
+		errMsg = "找不到该预测指标配置"
+		err = nil
+		return
+	}
+
+	// 指标信息
+	edbInfoList, err := models.GetEdbInfoByIdList(edbInfoIdList)
+	if err != nil {
+		err = errors.New("获取关联指标失败，Err:" + err.Error())
+		return
+	}
+	// 指标信息map
+	edbInfoListMap := make(map[int]*models.EdbInfo)
+	for _, v := range edbInfoList {
+		edbInfoListMap[v.EdbInfoId] = v
+	}
+
+	// 刷新所有的规则
+	for _, v := range predictEdbConfList {
+		switch v.RuleType {
+		case 9:
+			if v.Value == "" {
+				errMsg = "请填写计算规则"
+				return
+			}
+			formula := v.Value
+
+			// 动态环差规则 关系表
+			trendsMappingList := predictEdbConfCalculateMappingListMap[v.ConfigId]
+
+			// 关联标签
+			edbInfoIdArr := make([]models.EdbInfoFromTag, 0)
+
+			//关联的指标信息
+			edbInfoList := make([]*models.EdbInfo, 0)
+			for _, trendsMapping := range trendsMappingList {
+				tmpEdbInfo, ok := edbInfoListMap[trendsMapping.FromEdbInfoId]
+				if ok {
+					edbInfoList = append(edbInfoList, tmpEdbInfo)
+				}
+
+				// 关联标签
+				edbInfoIdArr = append(edbInfoIdArr, models.EdbInfoFromTag{
+					EdbInfoId: trendsMapping.FromEdbInfoId,
+					FromTag:   trendsMapping.FromTag,
+				})
+			}
+
+			//检验公式
+			var formulaStr string
+			var edbInfoIdBytes []string
+			for _, tmpEdbInfoId := range edbInfoIdArr {
+				formulaStr += tmpEdbInfoId.FromTag + ","
+				edbInfoIdBytes = append(edbInfoIdBytes, tmpEdbInfoId.FromTag)
+			}
+			formulaMap := services.CheckFormula(formula)
+			for _, formula := range formulaMap {
+				if !strings.Contains(formulaStr, formula) {
+					errMsg = "公式错误，请重新填写"
+					return
+				}
+			}
+
+			ok, _ := models.CheckFormula2(edbInfoList, formulaMap, formula, edbInfoIdBytes)
+			if !ok {
+				errMsg = "生成计算指标失败，请使用正确的计算公式"
+				return
+			}
+
+			rule := models.CalculateRule{
+				EdbInfoId:                  v.PredictEdbInfoId,
+				ConfigId:                   v.ConfigId,
+				TrendsCalculateMappingList: trendsMappingList,
+				EdbInfoList:                edbInfoList,
+				EdbInfoIdBytes:             edbInfoIdBytes,
+				Formula:                    formula,
+				RuleType:                   v.RuleType,
+				EndDate:                    v.EndDate.Format(utils.FormatDate),
+				EdbInfoIdArr:               edbInfoIdArr,
+			}
+			err = models.RefreshCalculateByRuleBy9(rule)
+			if err != nil {
+				return
+			}
+		}
+	}
+
+	return
+}

models/base_from_manual.go

@@ -120,10 +120,10 @@ func RefreshEdbDataFromManual(edbInfoId int, edbCode, startDate string) (err err
 	addSql := ` INSERT INTO edb_data_manual(edb_info_id,edb_code,data_time,value,create_time,modify_time,data_timestamp) values `
 	var isAdd bool
 	manualMap := make(map[string]*ManualEdbdata)
-	fmt.Println("manualDataList:", len(manualDataList))
+	//fmt.Println("manualDataList:", len(manualDataList))
 	for _, v := range manualDataList {
 		item := v
-		fmt.Println("Item:", item.Dt, item.Close, item.TradeCode, item.ModifyTime)
+		//fmt.Println("Item:", item.Dt, item.Close, item.TradeCode, item.ModifyTime)
 		if findItem, ok := existMap[v.Dt]; !ok {
 			eDate := item.Dt
 			sValue := item.Close

models/base_predict_from_calculate.go

@@ -251,7 +251,6 @@ func RefreshAllPredictCalculate(edbInfoIdList []*EdbInfo, edbInfoId, source int,
 			_ = to.Commit()
 		}
 	}()
-	fmt.Println(startDate)
 
 	latestDateStr, latestValue, err = refreshAllPredictCalculate(to, edbInfoIdList, edbInfoId, source, edbCode, formulaStr, startDate, edbInfoIdBytes)
 
@@ -260,7 +259,7 @@ func RefreshAllPredictCalculate(edbInfoIdList []*EdbInfo, edbInfoId, source int,
 
 // refreshAllPredictCalculate 刷新预测计算指标的全部数据
 func refreshAllPredictCalculate(to orm.TxOrmer, edbInfoIdList []*EdbInfo, edbInfoId, source int, edbCode, formulaStr, startDate string, edbInfoIdBytes []string) (latestDateStr string, latestValue float64, err error) {
-	fmt.Println(startDate)
+	fmt.Println("startDate:", startDate)
 
 	var minLatestDate time.Time
 	realSaveDataMap := make(map[string]map[int]float64)

models/db.go

@@ -42,5 +42,8 @@ func init() {
 		new(EdbDataPython),
 		new(ChartEdbMapping),
 		new(PredictEdbConf),
+		new(EdbClassify),
+		new(PredictEdbConfCalculateMapping),
+		new(PredictEdbRuleData),
 	)
 }

models/edb_classify.go

@@ -2,8 +2,31 @@ package models
 
 import (
 	"github.com/beego/beego/v2/client/orm"
+	"time"
 )
 
+type EdbClassify struct {
+	ClassifyId      int       `orm:"column(classify_id);pk"`
+	ClassifyType    uint8     `description:"分类类型，0：普通指标分类，1：预测指标分类"`
+	ClassifyName    string    `description:"分类名称"`
+	ParentId        int       `description:"父级id"`
+	HasData         int       `description:"是否含有指标数据"`
+	CreateTime      time.Time `description:"创建时间"`
+	ModifyTime      time.Time `description:"修改时间"`
+	SysUserId       int       `description:"创建人id"`
+	SysUserRealName string    `description:"创建人姓名"`
+	Level           int       `description:"层级"`
+	UniqueCode      string    `description:"唯一编码"`
+	Sort            int       `description:"排序字段，越小越靠前，默认值：10"`
+}
+
+func GetEdbClassifyById(classifyId int) (item *EdbClassify, err error) {
+	o := orm.NewOrm()
+	sql := `SELECT * FROM edb_classify WHERE classify_id=? `
+	err = o.Raw(sql, classifyId).QueryRow(&item)
+	return
+}
+
 type EdbClassifySimplify struct {
 	ClassifyId   int    `description:"分类id"`
 	ClassifyName string `description:"分类名称"`

models/edb_info.go

@@ -97,6 +97,18 @@ func GetEdbInfoById(edbInfoId int) (item *EdbInfo, err error) {
 	return
 }
 
+// GetEdbInfoByIdList 根据指标id列表获取指标信息
+func GetEdbInfoByIdList(edbInfoIdList []int) (items []*EdbInfo, err error) {
+	num := len(edbInfoIdList)
+	if num <= 0 {
+		return
+	}
+	o := orm.NewOrm()
+	sql := ` SELECT * FROM edb_info WHERE edb_info_id in (` + utils.GetOrmInReplace(num) + `) `
+	_, err = o.Raw(sql, edbInfoIdList).QueryRows(&items)
+	return
+}
+
 // Update 更新EdbInfo信息
 func (edbInfo *EdbInfo) Update(cols []string) (err error) {
 	o := orm.NewOrm()
@@ -541,6 +553,8 @@ func GetChartPredictEdbInfoDataListByConfList(predictEdbConfList []*PredictEdbCo
 				return
 			}
 			predictEdbInfoData, tmpMinValue, tmpMaxValue = GetChartPredictEdbInfoDataListByRuleNLinearRegression(predictEdbConf.PredictEdbInfoId, nValue, startDate, dataEndTime, frequency, realPredictEdbInfoData, predictEdbInfoData, existMap)
+		case 9: //9：动态环差”预测规则；
+			predictEdbInfoData, tmpMinValue, tmpMaxValue = GetChartPredictEdbInfoDataListByRuleTrendsHC(predictEdbConf.PredictEdbInfoId, predictEdbConf.ConfigId, startDate, dataEndTime, frequency, realPredictEdbInfoData, predictEdbInfoData, existMap)
 		}
 		//startDate = dataEndTime.AddDate(0, 0, 1)
 		startDate = dataEndTime
@@ -711,7 +725,7 @@ func ModifyPredictEdbInfoMaxAndMinInfo(edbInfoId int, item *EdbInfoMaxAndMinInfo
 
 // ModifyCalculateEdbInfo 修改计算指标信息
 func ModifyCalculateEdbInfo(edbName, frequency, unit, calculateFormula string, classifyId, edbInfoId int) (err error) {
-	o := orm.NewOrmUsingDB("data")
+	o := orm.NewOrm()
 	sql := ` UPDATE  edb_info
 			SET
 			  edb_name =?,

models/predict_edb.go

@@ -0,0 +1,206 @@
+package models
+
+import (
+	"errors"
+	"fmt"
+	"github.com/beego/beego/v2/client/orm"
+	"github.com/shopspring/decimal"
+	"github.com/yidane/formula"
+	"hongze/hongze_edb_lib/services"
+	"hongze/hongze_edb_lib/services/alarm_msg"
+	"hongze/hongze_edb_lib/utils"
+	"strings"
+	"time"
+)
+
+// CalculateRule 预测指标 规则 计算
+type CalculateRule struct {
+	EdbInfoId                  int `description:"指标id"`
+	ConfigId                   int `description:"配置id"`
+	TrendsCalculateMappingList []*PredictEdbConfCalculateMapping
+	EdbInfoList                []*EdbInfo
+	EdbInfoIdBytes             []string
+	Formula                    string
+	RuleType                   int              `description:"预测规则，1：最新，2：固定值，3：同比，4：同差，5：环比，6：环差，7：N期移动均值，8：N期段线性外推值，9：动态环差"`
+	EndDate                    string           `description:"截止日期"`
+	EdbInfoIdArr               []EdbInfoFromTag `description:"指标信息"`
+}
+
+// RefreshCalculateByRuleBy9 刷新计算
+func RefreshCalculateByRuleBy9(rule CalculateRule) (err error) {
+	o := orm.NewOrm()
+	to, err := o.Begin()
+	if err != nil {
+		return
+	}
+	defer func() {
+		if err != nil {
+			tmpErr := to.Rollback()
+			if tmpErr != nil {
+				go alarm_msg.SendAlarmMsg("RefreshCalculateByRuleBy9 事务回滚失败，Err："+tmpErr.Error(), 3)
+			}
+		} else {
+			err = to.Commit()
+		}
+	}()
+	err = CalculateByRuleBy9(to, rule)
+	return
+}
+
+// CalculateByRuleBy9 动态环差规则计算入库
+func CalculateByRuleBy9(to orm.TxOrmer, rule CalculateRule) (err error) {
+	realSaveDataMap := make(map[string]map[int]float64)
+	saveDataMap := make(map[string]map[int]float64)
+	dateList := make([]string, 0)
+
+	formulaStr := strings.ToUpper(rule.Formula)
+	// 获取关联指标数据
+	for edbInfoIndex, v := range rule.EdbInfoList {
+		dataList, tmpErr := GetPredictEdbDataListAll(v, 1)
+		if tmpErr != nil {
+			err = tmpErr
+			return
+		}
+		dataMap := make(map[string]float64)
+		for _, dv := range dataList {
+			// 现有实际数据
+			if val, ok := realSaveDataMap[dv.DataTime]; ok {
+				if _, ok := val[v.EdbInfoId]; !ok {
+					val[v.EdbInfoId] = dv.Value
+				}
+			} else {
+				temp := make(map[int]float64)
+				temp[v.EdbInfoId] = dv.Value
+				realSaveDataMap[dv.DataTime] = temp
+			}
+
+			// 待处理的数据
+			if val, ok := saveDataMap[dv.DataTime]; ok {
+				if _, ok := val[v.EdbInfoId]; !ok {
+					val[v.EdbInfoId] = dv.Value
+				}
+			} else {
+				temp := make(map[int]float64)
+				temp[v.EdbInfoId] = dv.Value
+				saveDataMap[dv.DataTime] = temp
+			}
+
+			// 以第一个指标的日期作为基准日期
+			if edbInfoIndex == 0 {
+				dateList = append(dateList, dv.DataTime)
+			}
+		}
+		item := new(CalculateItems)
+		item.EdbInfoId = v.EdbInfoId
+		item.DataMap = dataMap
+	}
+
+	//数据处理，将日期内不全的数据做补全
+	handleDateSaveDataMap(dateList, realSaveDataMap, saveDataMap, rule.EdbInfoList)
+
+	// 添加数据
+	addDataList := make([]*PredictEdbRuleData, 0)
+
+	// 计算规则
+	formulaMap := services.CheckFormula(formulaStr)
+
+	//获取指标所有数据
+	dataList := make([]*PredictEdbRuleData, 0)
+	sql := `SELECT * FROM predict_edb_rule_data WHERE config_id = ?`
+	_, err = to.Raw(sql, rule.ConfigId).QueryRows(&dataList)
+	if err != nil {
+		return err
+	}
+	dataMap := make(map[string]*PredictEdbRuleData)
+	for _, v := range dataList {
+		dataMap[v.DataTime] = v
+	}
+	existDataMap := make(map[string]string)
+
+	removeDateList := make([]string, 0) //需要移除的日期
+	for sk, sv := range saveDataMap {
+		//fmt.Println(sk, sv)
+		formulaFormStr := ReplaceFormula(rule.EdbInfoList, sv, formulaMap, formulaStr, rule.EdbInfoIdBytes)
+		//计算公式异常，那么就移除该指标
+		if formulaFormStr == "" {
+			removeDateList = append(removeDateList, sk)
+			continue
+		}
+
+		utils.FileLog.Info(fmt.Sprintf("formulaFormStr:%s", formulaFormStr))
+		expression := formula.NewExpression(formulaFormStr)
+		calResult, err := expression.Evaluate()
+		if err != nil {
+			// 分母为0的报错
+			if strings.Contains(err.Error(), "divide by zero") {
+				removeDateList = append(removeDateList, sk)
+				continue
+			}
+			err = errors.New("计算失败：Err:" + err.Error() + ";formulaStr:" + formulaFormStr)
+			fmt.Println(err)
+			return err
+		}
+		calVal, err := calResult.Float64()
+		if err != nil {
+			err = errors.New("计算失败：获取计算值失败 Err:" + err.Error() + ";formulaStr:" + formulaFormStr)
+			fmt.Println(err)
+			return err
+		}
+
+		saveValue := decimal.NewFromFloat(calVal).RoundCeil(4).String() //utils.SubFloatToString(calVal, 4)
+		existPredictEdbRuleData, ok := dataMap[sk]
+		if !ok {
+			dataTime, _ := time.Parse(utils.FormatDate, sk)
+			timestamp := dataTime.UnixNano() / 1e6
+
+			if _, existOk := existDataMap[sk]; !existOk {
+				tmpPredictEdbRuleData := &PredictEdbRuleData{
+					//PredictEdbRuleDataId: 0,
+					EdbInfoId:     rule.EdbInfoId,
+					ConfigId:      rule.ConfigId,
+					DataTime:      sk,
+					Value:         saveValue,
+					CreateTime:    time.Now(),
+					ModifyTime:    time.Now(),
+					DataTimestamp: timestamp,
+				}
+				addDataList = append(addDataList, tmpPredictEdbRuleData)
+			}
+			existDataMap[sk] = sk
+		} else {
+			existValDecimal, err := decimal.NewFromString(existPredictEdbRuleData.Value)
+			existStr := existValDecimal.String()
+			if existStr != saveValue {
+				existPredictEdbRuleData.Value = saveValue
+				existPredictEdbRuleData.ModifyTime = time.Now()
+				_, err = to.Update(existPredictEdbRuleData, "Value", "ModifyTime")
+				if err != nil {
+					return err
+				}
+			}
+		}
+	}
+
+	// 添加计算出来的值入库
+	lenAddDataList := len(addDataList)
+	if lenAddDataList > 0 {
+		_, err = to.InsertMulti(lenAddDataList, addDataList)
+		if err != nil {
+			return
+		}
+	}
+
+	//删除多余的值
+	lenRemoveDateList := len(removeDateList)
+	if lenRemoveDateList > 0 {
+		//如果拼接指标变更了，那么需要删除所有的指标数据
+		sql := ` DELETE FROM predict_edb_rule_data WHERE config_id = ? and data_time in (` + utils.GetOrmInReplace(lenRemoveDateList) + `) `
+
+		_, err = to.Raw(sql, rule.ConfigId, removeDateList).Exec()
+		if err != nil {
+			err = fmt.Errorf("删除计算失败的预测规则计算指标数据失败,Err:" + err.Error())
+			return
+		}
+	}
+	return
+}

models/predict_edb_conf.go

@@ -2,10 +2,38 @@ package models
 
 import (
 	"github.com/beego/beego/v2/client/orm"
+	"hongze/hongze_edb_lib/services/alarm_msg"
 	"hongze/hongze_edb_lib/utils"
 	"time"
 )
 
+// AddPredictEdbInfoReq 添加预测指标请求
+type AddPredictEdbInfoReq struct {
+	EdbInfoId       int          `description:"指标ID"`
+	ClassifyId      int          `description:"分类id"`
+	AdminId         int          `description:"添加人id"`
+	AdminName       string       `description:"添加人名称"`
+	SourceEdbInfoId int          `description:"来源指标id"`
+	EdbName         string       `description:"指标名称"`
+	RuleList        []RuleConfig `description:"配置规则列表"`
+}
+
+// RuleConfig 预测规则配置
+type RuleConfig struct {
+	RuleType     int              `description:"预测规则，1：最新，2：固定值，3：同比，4：同差，5：环比，6：环差，7：N期移动均值，8：N期段线性外推值，9：动态环差"`
+	Value        string           `description:"值/计算公式"`
+	EndDate      string           `description:"截止日期"`
+	EdbInfoIdArr []EdbInfoFromTag `description:"指标信息"`
+}
+
+// EditPredictEdbInfoReq 编辑预测指标请求
+type EditPredictEdbInfoReq struct {
+	EdbInfoId  int          `description:"指标ID"`
+	ClassifyId int          `description:"分类id"`
+	EdbName    string       `description:"指标名称"`
+	RuleList   []RuleConfig `description:"配置规则列表"`
+}
+
 type PredictEdbConf struct {
 	ConfigId         int       `orm:"column(config_id);pk" description:"规则id"`
 	PredictEdbInfoId int       `orm:"column(predict_edb_info_id)" description:"预测指标id"`
@@ -42,6 +70,18 @@ func GetPredictEdbConfListById(edbInfoId int) (items []*PredictEdbConf, err erro
 	return
 }
 
+// GetPredictEdbConfListByConfigIdList 根据预测指标id列表获取预测指标配置信息列表
+func GetPredictEdbConfListByConfigIdList(configIdList []int) (items []*PredictEdbConf, err error) {
+	num := len(configIdList)
+	if num <= 0 {
+		return
+	}
+	o := orm.NewOrm()
+	sql := ` SELECT * FROM predict_edb_conf WHERE config_id in (` + utils.GetOrmInReplace(num) + `) ORDER BY config_id ASC`
+	_, err = o.Raw(sql, configIdList).QueryRows(&items)
+	return
+}
+
 // ModifyPredictEdbInfoMaxAndMinInfoBySourceEdbInfoId 根据来源指标修改预测指标的最新数据信息
 func ModifyPredictEdbInfoMaxAndMinInfoBySourceEdbInfoId(sourceEdbInfoId int, item *EdbInfoMaxAndMinInfo) (err error) {
 	o := orm.NewOrm()
@@ -63,3 +103,216 @@ func ModifyPredictEdbInfoMaxAndMinInfoBySourceEdbInfoId(sourceEdbInfoId int, ite
 	}
 	return
 }
+
+// GetPredictEdbConfBySourceEdbInfoId 根据来源指标id获取配置
+func GetPredictEdbConfBySourceEdbInfoId(sourceEdbInfoId int) (item *PredictEdbConf, err error) {
+	o := orm.NewOrm()
+	sql := ` SELECT * FROM predict_edb_conf WHERE source_edb_info_id=? `
+	err = o.Raw(sql, sourceEdbInfoId).QueryRow(&item)
+	return
+}
+
+// AddPredictEdbConf 添加预测指标规则
+func AddPredictEdbConf(item *PredictEdbConf) (lastId int64, err error) {
+	o := orm.NewOrm()
+	lastId, err = o.Insert(item)
+	return
+}
+
+// AddPredictEdb 添加预测指标
+//edbInfo, calculateMappingList, predictEdbConfList,calculateRule9List,trendsMappingList
+func AddPredictEdb(item *EdbInfo, calculateMappingList []*EdbInfoCalculateMapping, predictEdbConfList []*PredictEdbConf, calculateRuleList []CalculateRule) (err error) {
+	o := orm.NewOrm()
+	tx, err := o.Begin()
+	if err != nil {
+		return
+	}
+	defer func() {
+		if err != nil {
+			tmpErr := tx.Rollback()
+			if tmpErr != nil {
+				go alarm_msg.SendAlarmMsg("AddPredictEdb 事务回滚失败，Err："+tmpErr.Error(), 3)
+			}
+		} else {
+			err = tx.Commit()
+		}
+	}()
+	// 新增预测指标
+	edbInfoId, err := tx.Insert(item)
+	if err != nil {
+		return
+	}
+	item.EdbInfoId = int(edbInfoId)
+
+	// 新增预测指标的关联关系
+	lenCalculateMapping := len(calculateMappingList)
+	if lenCalculateMapping > 0 {
+		for _, calculateMappingItem := range calculateMappingList {
+			calculateMappingItem.EdbInfoId = item.EdbInfoId
+		}
+		_, err = tx.InsertMulti(lenCalculateMapping, calculateMappingList)
+		if err != nil {
+			return
+		}
+	}
+
+	calculateRuleIndex := 0 // 预测计算规则下标
+
+	// 新增预测指标配置
+	for _, v := range predictEdbConfList {
+		v.PredictEdbInfoId = item.EdbInfoId
+		configId, tmpErr := tx.Insert(v)
+		if tmpErr != nil {
+			err = tmpErr
+			return
+		}
+		v.ConfigId = int(configId)
+
+		switch v.RuleType {
+		case 9: //动态环差规则
+			calculateRule := calculateRuleList[calculateRuleIndex]
+			calculateRule.ConfigId = v.ConfigId
+			calculateRule.EdbInfoId = v.PredictEdbInfoId
+
+			// 指标与规则的动态数据生成入库
+			err = CalculateByRuleBy9(tx, calculateRule)
+			if err != nil {
+				return
+			}
+
+			// 规则与指标的关系入库
+			lenTrendsCalculateMapping := len(calculateRule.TrendsCalculateMappingList)
+			if lenTrendsCalculateMapping > 0 {
+				for _, vv := range calculateRule.TrendsCalculateMappingList {
+					vv.EdbInfoId = item.EdbInfoId
+					vv.ConfigId = v.ConfigId
+				}
+				_, err = tx.InsertMulti(lenTrendsCalculateMapping, calculateRule.TrendsCalculateMappingList)
+				if err != nil {
+					return
+				}
+			}
+			calculateRuleIndex++
+
+		}
+	}
+	return
+}
+
+// EditPredictEdb 修改预测指标
+func EditPredictEdb(edbInfo *EdbInfo, updateEdbInfoCol []string, calculateMappingList []*EdbInfoCalculateMapping, predictEdbConfList []*PredictEdbConf, calculateRuleList []CalculateRule) (err error) {
+	o := orm.NewOrm()
+	tx, err := o.Begin()
+	if err != nil {
+		return
+	}
+	defer func() {
+		if err != nil {
+			tmpErr := tx.Rollback()
+			if tmpErr != nil {
+				go alarm_msg.SendAlarmMsg("AddPredictEdb 事务回滚失败，Err："+tmpErr.Error(), 3)
+			}
+		} else {
+			err = tx.Commit()
+		}
+	}()
+	// 修改预测指标
+	_, err = tx.Update(edbInfo, updateEdbInfoCol...)
+	if err != nil {
+		return
+	}
+
+	// 先删除原有的预测指标 与 其他指标的 关联关系
+	sql := ` DELETE FROM edb_info_calculate_mapping WHERE edb_info_id = ?`
+	_, err = tx.Raw(sql, edbInfo.EdbInfoId).Exec()
+	if err != nil {
+		return
+	}
+
+	// 先删除原有的配置
+	sql = ` DELETE FROM predict_edb_conf WHERE predict_edb_info_id = ?`
+	_, err = tx.Raw(sql, edbInfo.EdbInfoId).Exec()
+	if err != nil {
+		return
+	}
+
+	// 删除基础预测指标 规则配置 与 其他指标的 关联关系
+	sql = ` DELETE FROM predict_edb_conf_calculate_mapping WHERE edb_info_id = ?`
+	_, err = tx.Raw(sql, edbInfo.EdbInfoId).Exec()
+	if err != nil {
+		return
+	}
+
+	// 删除基础预测指标 规则配置 生成的动态数据值
+	sql = ` DELETE FROM predict_edb_rule_data WHERE edb_info_id = ?`
+	_, err = tx.Raw(sql, edbInfo.EdbInfoId).Exec()
+	if err != nil {
+		return
+	}
+
+	// 新增预测指标的关联关系
+	lenCalculateMapping := len(calculateMappingList)
+	if lenCalculateMapping > 0 {
+		_, err = tx.InsertMulti(lenCalculateMapping, calculateMappingList)
+		if err != nil {
+			return
+		}
+	}
+
+	calculateRuleIndex := 0 // 预测计算规则下标
+
+	// 新增预测指标配置
+	for _, v := range predictEdbConfList {
+		configId, tmpErr := tx.Insert(v)
+		if tmpErr != nil {
+			err = tmpErr
+			return
+		}
+		v.ConfigId = int(configId)
+
+		switch v.RuleType {
+		case 9: //动态环差规则
+			calculateRule := calculateRuleList[calculateRuleIndex]
+			calculateRule.ConfigId = v.ConfigId
+			calculateRule.EdbInfoId = v.PredictEdbInfoId
+
+			// 指标与规则的动态数据生成入库
+			err = CalculateByRuleBy9(tx, calculateRule)
+			if err != nil {
+				return
+			}
+
+			// 规则与指标的关系入库
+			lenTrendsCalculateMapping := len(calculateRule.TrendsCalculateMappingList)
+			if lenTrendsCalculateMapping > 0 {
+				for _, vv := range calculateRule.TrendsCalculateMappingList {
+					vv.ConfigId = v.ConfigId
+				}
+				_, err = tx.InsertMulti(lenTrendsCalculateMapping, calculateRule.TrendsCalculateMappingList)
+				if err != nil {
+					return
+				}
+			}
+			calculateRuleIndex++
+
+		}
+	}
+
+	return
+}
+
+// GetPredictEdbInfoAllCalculate 根据基础预测指标id集合 获取 所有的普通指标列表数据
+func GetPredictEdbInfoAllCalculate(edbInfoIdList []int) (list []*EdbInfo, err error) {
+	num := len(edbInfoIdList)
+	if num <= 0 {
+		return
+	}
+	o := orm.NewOrm()
+	sql := ` SELECT b.* FROM predict_edb_conf AS a
+			 INNER JOIN edb_info AS b ON a.source_edb_info_id=b.edb_info_id
+             WHERE a.predict_edb_info_id in (` + utils.GetOrmInReplace(num) + `)
+			 GROUP BY a.source_edb_info_id
+			 ORDER BY a.source_edb_info_id ASC `
+	_, err = o.Raw(sql, edbInfoIdList).QueryRows(&list)
+	return
+}

models/predict_edb_conf_calculate_mapping.go

@@ -0,0 +1,32 @@
+package models
+
+import (
+	"github.com/beego/beego/v2/client/orm"
+	"time"
+)
+
+// PredictEdbConfCalculateMapping 预测基础指标规则 与 计算预测指标关联关系表
+type PredictEdbConfCalculateMapping struct {
+	PredictEdbConfCalculateMappingId int       `orm:"column(predict_edb_conf_calculate_mapping_id);pk"`
+	EdbInfoId                        int       `description:"指标id"`
+	ConfigId                         int       `description:"配置id"`
+	FromEdbInfoId                    int       `description:"基础指标id"`
+	FromEdbCode                      string    `description:"基础指标编码"`
+	FromEdbName                      string    `description:"基础指标名称"`
+	FromSource                       int       `description:"基础指标来源"`
+	FromSourceName                   string    `description:"基础指标来源名称"`
+	FromTag                          string    `description:"来源指标标签"`
+	Sort                             int       `description:"计算指标名称排序"`
+	CreateTime                       time.Time `description:"创建时间"`
+	ModifyTime                       time.Time `description:"修改时间"`
+}
+
+// GetPredictEdbConfCalculateMappingListByEdbInfoId 根据预测指标id获取所有关联指标
+func GetPredictEdbConfCalculateMappingListByEdbInfoId(edbInfoId int) (list []*PredictEdbConfCalculateMapping, err error) {
+	o := orm.NewOrm()
+	sql := ` SELECT * from predict_edb_conf_calculate_mapping
+			WHERE edb_info_id=? ORDER BY predict_edb_conf_calculate_mapping_id ASC `
+
+	_, err = o.Raw(sql, edbInfoId).QueryRows(&list)
+	return
+}

models/predict_edb_info_rule.go

@@ -566,3 +566,75 @@ func getLinearResult(s []Coordinate) (gradient, intercept float64) {
 
 	return
 }
+
+//	GetChartPredictEdbInfoDataListByRuleTrendsHC 根据动态环比增加值的计算规则获取预测数据
+// 研究员有对预测指标进行动态环差计算的需求，即预测指标使用环差规则进行预测时，环比增加值不是固定值，而是由几个预测指标计算得出的动态变化的值；
+//需求说明：
+//1、增加“动态环差”预测规则；
+//2、环比增加值在弹窗设置；
+//3、动态环差预测举例：
+//指标A实际最新数据为2022-10-27（100）；
+//预测指标B预测数据为2022-10-28（240）、2022-10-29（300）；
+//预测指标C预测数据为2022-10-28（260）、2022-10-29（310）；
+//计算公式为B-C；
+//则指标A至2022-10-29的预测值为2022-10-28（100+（240-260）=80）、2022-10-29（80+（300-310）=90）；
+//注：动态环比增加值的计算遵从计算指标的计算规则，即用于计算的指标若有部分指标缺少部分日期数据，则这部分日期数据不做计算，为空；若动态环比增加值某一天为空，则往前追溯最近一期有值的环比增加值作为该天的数值参与计算；
+func GetChartPredictEdbInfoDataListByRuleTrendsHC(edbInfoId, configId int, startDate, endDate time.Time, frequency string, realPredictEdbInfoData, predictEdbInfoData []*EdbInfoSearchData, existMap map[string]float64) (newPredictEdbInfoData []*EdbInfoSearchData, minValue, maxValue float64) {
+	allDataList := make([]*EdbInfoSearchData, 0)
+	allDataList = append(allDataList, realPredictEdbInfoData...)
+	allDataList = append(allDataList, predictEdbInfoData...)
+	newPredictEdbInfoData = predictEdbInfoData
+
+	lenAllData := len(allDataList)
+	if lenAllData <= 0 {
+		return
+	}
+
+	hcDataMap := make(map[string]float64) //规则计算的环差值map
+
+	tmpPredictEdbRuleDataList, err := GetPredictEdbRuleDataItemList(edbInfoId, configId, startDate.Format(utils.FormatDate), endDate.Format(utils.FormatDate))
+	if err != nil {
+		return
+	}
+	for _, v := range tmpPredictEdbRuleDataList {
+		hcDataMap[v.DataTime] = v.Value
+	}
+
+	dayList := getPredictEdbDayList(startDate, endDate, frequency)
+	for k, currentDate := range dayList {
+		// 最近一条数据
+		tmpLenAllDataList := len(allDataList)
+		lastValue := allDataList[tmpLenAllDataList-1].Value
+
+		// 动态环差值数据
+		currentDateStr := currentDate.Format(utils.FormatDate)
+		hcVal, ok := hcDataMap[currentDateStr]
+		if !ok {
+			continue
+		}
+		lastValueDecimal := decimal.NewFromFloat(lastValue)
+		hcValDecimal := decimal.NewFromFloat(hcVal)
+
+		val, _ := lastValueDecimal.Add(hcValDecimal).RoundCeil(4).Float64()
+
+		tmpData := &EdbInfoSearchData{
+			EdbDataId: edbInfoId + 10000000000 + lenAllData + k,
+			//EdbInfoId:     edbInfoId,
+			DataTime: currentDateStr,
+			Value:    val,
+			//DataTimestamp: (currentDate.UnixNano() / 1e6) + 1000, //前端需要让加1s，说是2022-09-01 00:00:00 这样的整点不合适
+		}
+		newPredictEdbInfoData = append(newPredictEdbInfoData, tmpData)
+		allDataList = append(allDataList, tmpData)
+		existMap[currentDateStr] = val
+
+		// 最大最小值
+		if val < minValue {
+			minValue = val
+		}
+		if val > maxValue {
+			maxValue = val
+		}
+	}
+	return
+}

models/predict_edb_rule_data.go

@@ -0,0 +1,48 @@
+package models
+
+import (
+	"github.com/beego/beego/v2/client/orm"
+	"time"
+)
+
+// PredictEdbRuleData 预测指标，动态规则的计算数据
+type PredictEdbRuleData struct {
+	PredictEdbRuleDataId int `orm:"column(predict_edb_rule_data_id);pk"`
+	EdbInfoId            int
+	ConfigId             int
+	DataTime             string
+	Value                string
+	CreateTime           time.Time
+	ModifyTime           time.Time
+	DataTimestamp        int64
+}
+
+// PredictEdbRuleDataItem 预测指标，动态规则的计算数据
+type PredictEdbRuleDataItem struct {
+	PredictEdbRuleDataId int `orm:"column(predict_edb_rule_data_id);pk"`
+	EdbInfoId            int
+	ConfigId             int
+	DataTime             string
+	Value                float64
+	CreateTime           time.Time
+	ModifyTime           time.Time
+	DataTimestamp        int64
+}
+
+// GetPredictEdbRuleDataItemList 根据基础预测指标id集合 获取 所有的普通指标列表数据
+func GetPredictEdbRuleDataItemList(edbInfoId, configId int, startDate, endDate string) (list []*PredictEdbRuleDataItem, err error) {
+	o := orm.NewOrm()
+	var pars []interface{}
+	sql := ` SELECT * FROM predict_edb_rule_data WHERE edb_info_id = ? AND config_id = ? `
+	if startDate != "" {
+		sql += ` AND data_time>=? `
+		pars = append(pars, startDate)
+	}
+	if endDate != "" {
+		sql += ` AND data_time<=? `
+		pars = append(pars, endDate)
+	}
+	sql += ` ORDER BY data_time ASC `
+	_, err = o.Raw(sql, edbInfoId, configId, pars).QueryRows(&list)
+	return
+}

routers/commentsRouter.go

@@ -7,445 +7,463 @@ import (
 
 func init() {
 
-	beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:CalculateController"] = append(beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:CalculateController"],
-		beego.ControllerComments{
-			Method:           "Add",
-			Router:           `/add`,
-			AllowHTTPMethods: []string{"post"},
-			MethodParams:     param.Make(),
-			Filters:          nil,
-			Params:           nil})
-
-	beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:CalculateController"] = append(beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:CalculateController"],
-		beego.ControllerComments{
-			Method:           "BatchEdit",
-			Router:           `/batch/edit`,
-			AllowHTTPMethods: []string{"post"},
-			MethodParams:     param.Make(),
-			Filters:          nil,
-			Params:           nil})
-
-	beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:CalculateController"] = append(beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:CalculateController"],
-		beego.ControllerComments{
-			Method:           "BatchSave",
-			Router:           `/batch/save`,
-			AllowHTTPMethods: []string{"post"},
-			MethodParams:     param.Make(),
-			Filters:          nil,
-			Params:           nil})
-
-	beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:CalculateController"] = append(beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:CalculateController"],
-		beego.ControllerComments{
-			Method:           "Edit",
-			Router:           `/edit`,
-			AllowHTTPMethods: []string{"post"},
-			MethodParams:     param.Make(),
-			Filters:          nil,
-			Params:           nil})
-
-	beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:CalculateController"] = append(beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:CalculateController"],
-		beego.ControllerComments{
-			Method:           "Refresh",
-			Router:           `/refresh`,
-			AllowHTTPMethods: []string{"post"},
-			MethodParams:     param.Make(),
-			Filters:          nil,
-			Params:           nil})
-
-	beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:CffexController"] = append(beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:CffexController"],
-		beego.ControllerComments{
-			Method:           "Add",
-			Router:           `/add`,
-			AllowHTTPMethods: []string{"post"},
-			MethodParams:     param.Make(),
-			Filters:          nil,
-			Params:           nil})
-
-	beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:CffexController"] = append(beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:CffexController"],
-		beego.ControllerComments{
-			Method:           "Refresh",
-			Router:           `/refresh`,
-			AllowHTTPMethods: []string{"post"},
-			MethodParams:     param.Make(),
-			Filters:          nil,
-			Params:           nil})
-
-	beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:CoalController"] = append(beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:CoalController"],
-		beego.ControllerComments{
-			Method:           "Add",
-			Router:           `/add`,
-			AllowHTTPMethods: []string{"post"},
-			MethodParams:     param.Make(),
-			Filters:          nil,
-			Params:           nil})
-
-	beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:CoalController"] = append(beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:CoalController"],
-		beego.ControllerComments{
-			Method:           "Refresh",
-			Router:           `/refresh`,
-			AllowHTTPMethods: []string{"post"},
-			MethodParams:     param.Make(),
-			Filters:          nil,
-			Params:           nil})
-
-	beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:DlController"] = append(beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:DlController"],
-		beego.ControllerComments{
-			Method:           "Add",
-			Router:           `/add`,
-			AllowHTTPMethods: []string{"post"},
-			MethodParams:     param.Make(),
-			Filters:          nil,
-			Params:           nil})
-
-	beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:DlController"] = append(beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:DlController"],
-		beego.ControllerComments{
-			Method:           "Refresh",
-			Router:           `/refresh`,
-			AllowHTTPMethods: []string{"post"},
-			MethodParams:     param.Make(),
-			Filters:          nil,
-			Params:           nil})
-
-	beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:EiaSteoController"] = append(beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:EiaSteoController"],
-		beego.ControllerComments{
-			Method:           "Add",
-			Router:           `/add`,
-			AllowHTTPMethods: []string{"post"},
-			MethodParams:     param.Make(),
-			Filters:          nil,
-			Params:           nil})
-
-	beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:EiaSteoController"] = append(beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:EiaSteoController"],
-		beego.ControllerComments{
-			Method:           "Refresh",
-			Router:           `/refresh`,
-			AllowHTTPMethods: []string{"post"},
-			MethodParams:     param.Make(),
-			Filters:          nil,
-			Params:           nil})
-
-	beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:GieController"] = append(beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:GieController"],
-		beego.ControllerComments{
-			Method:           "Add",
-			Router:           `/add`,
-			AllowHTTPMethods: []string{"post"},
-			MethodParams:     param.Make(),
-			Filters:          nil,
-			Params:           nil})
-
-	beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:GieController"] = append(beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:GieController"],
-		beego.ControllerComments{
-			Method:           "Refresh",
-			Router:           `/refresh`,
-			AllowHTTPMethods: []string{"post"},
-			MethodParams:     param.Make(),
-			Filters:          nil,
-			Params:           nil})
-
-	beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:GoogleTravelController"] = append(beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:GoogleTravelController"],
-		beego.ControllerComments{
-			Method:           "Add",
-			Router:           `/add`,
-			AllowHTTPMethods: []string{"post"},
-			MethodParams:     param.Make(),
-			Filters:          nil,
-			Params:           nil})
-
-	beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:GoogleTravelController"] = append(beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:GoogleTravelController"],
-		beego.ControllerComments{
-			Method:           "Refresh",
-			Router:           `/refresh`,
-			AllowHTTPMethods: []string{"post"},
-			MethodParams:     param.Make(),
-			Filters:          nil,
-			Params:           nil})
-
-	beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:LtController"] = append(beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:LtController"],
-		beego.ControllerComments{
-			Method:           "Add",
-			Router:           `/add`,
-			AllowHTTPMethods: []string{"post"},
-			MethodParams:     param.Make(),
-			Filters:          nil,
-			Params:           nil})
-
-	beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:LtController"] = append(beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:LtController"],
-		beego.ControllerComments{
-			Method:           "Refresh",
-			Router:           `/refresh`,
-			AllowHTTPMethods: []string{"post"},
-			MethodParams:     param.Make(),
-			Filters:          nil,
-			Params:           nil})
-
-	beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:LzController"] = append(beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:LzController"],
-		beego.ControllerComments{
-			Method:           "Add",
-			Router:           `/add`,
-			AllowHTTPMethods: []string{"post"},
-			MethodParams:     param.Make(),
-			Filters:          nil,
-			Params:           nil})
-
-	beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:LzController"] = append(beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:LzController"],
-		beego.ControllerComments{
-			Method:           "Refresh",
-			Router:           `/refresh`,
-			AllowHTTPMethods: []string{"post"},
-			MethodParams:     param.Make(),
-			Filters:          nil,
-			Params:           nil})
-
-	beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:ManualController"] = append(beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:ManualController"],
-		beego.ControllerComments{
-			Method:           "Add",
-			Router:           `/add`,
-			AllowHTTPMethods: []string{"post"},
-			MethodParams:     param.Make(),
-			Filters:          nil,
-			Params:           nil})
-
-	beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:ManualController"] = append(beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:ManualController"],
-		beego.ControllerComments{
-			Method:           "Refresh",
-			Router:           `/refresh`,
-			AllowHTTPMethods: []string{"post"},
-			MethodParams:     param.Make(),
-			Filters:          nil,
-			Params:           nil})
-
-	beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:MySteelChemicalController"] = append(beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:MySteelChemicalController"],
-		beego.ControllerComments{
-			Method:           "Add",
-			Router:           `/add`,
-			AllowHTTPMethods: []string{"post"},
-			MethodParams:     param.Make(),
-			Filters:          nil,
-			Params:           nil})
-
-	beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:MySteelChemicalController"] = append(beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:MySteelChemicalController"],
-		beego.ControllerComments{
-			Method:           "Refresh",
-			Router:           `/refresh`,
-			AllowHTTPMethods: []string{"post"},
-			MethodParams:     param.Make(),
-			Filters:          nil,
-			Params:           nil})
-
-	beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:MySteelController"] = append(beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:MySteelController"],
-		beego.ControllerComments{
-			Method:           "Add",
-			Router:           `/add`,
-			AllowHTTPMethods: []string{"post"},
-			MethodParams:     param.Make(),
-			Filters:          nil,
-			Params:           nil})
-
-	beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:MySteelController"] = append(beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:MySteelController"],
-		beego.ControllerComments{
-			Method:           "Refresh",
-			Router:           `/refresh`,
-			AllowHTTPMethods: []string{"post"},
-			MethodParams:     param.Make(),
-			Filters:          nil,
-			Params:           nil})
-
-	beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:PbController"] = append(beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:PbController"],
-		beego.ControllerComments{
-			Method:           "Add",
-			Router:           `/add`,
-			AllowHTTPMethods: []string{"post"},
-			MethodParams:     param.Make(),
-			Filters:          nil,
-			Params:           nil})
-
-	beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:PbController"] = append(beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:PbController"],
-		beego.ControllerComments{
-			Method:           "Refresh",
-			Router:           `/refresh`,
-			AllowHTTPMethods: []string{"post"},
-			MethodParams:     param.Make(),
-			Filters:          nil,
-			Params:           nil})
-
-	beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:PbFinanceController"] = append(beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:PbFinanceController"],
-		beego.ControllerComments{
-			Method:           "Add",
-			Router:           `/add`,
-			AllowHTTPMethods: []string{"post"},
-			MethodParams:     param.Make(),
-			Filters:          nil,
-			Params:           nil})
-
-	beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:PbFinanceController"] = append(beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:PbFinanceController"],
-		beego.ControllerComments{
-			Method:           "Refresh",
-			Router:           `/refresh`,
-			AllowHTTPMethods: []string{"post"},
-			MethodParams:     param.Make(),
-			Filters:          nil,
-			Params:           nil})
-
-	beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:PredictCalculateController"] = append(beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:PredictCalculateController"],
-		beego.ControllerComments{
-			Method:           "CalculateBatchSave",
-			Router:           `/batch/save`,
-			AllowHTTPMethods: []string{"post"},
-			MethodParams:     param.Make(),
-			Filters:          nil,
-			Params:           nil})
-
-	beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:PredictCalculateController"] = append(beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:PredictCalculateController"],
-		beego.ControllerComments{
-			Method:           "Refresh",
-			Router:           `/refresh`,
-			AllowHTTPMethods: []string{"post"},
-			MethodParams:     param.Make(),
-			Filters:          nil,
-			Params:           nil})
-
-	beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:PredictCalculateController"] = append(beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:PredictCalculateController"],
-		beego.ControllerComments{
-			Method:           "Save",
-			Router:           `/save`,
-			AllowHTTPMethods: []string{"post"},
-			MethodParams:     param.Make(),
-			Filters:          nil,
-			Params:           nil})
-
-	beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:PythonController"] = append(beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:PythonController"],
-		beego.ControllerComments{
-			Method:           "Add",
-			Router:           `/add`,
-			AllowHTTPMethods: []string{"post"},
-			MethodParams:     param.Make(),
-			Filters:          nil,
-			Params:           nil})
-
-	beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:PythonController"] = append(beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:PythonController"],
-		beego.ControllerComments{
-			Method:           "Edit",
-			Router:           `/edit`,
-			AllowHTTPMethods: []string{"post"},
-			MethodParams:     param.Make(),
-			Filters:          nil,
-			Params:           nil})
-
-	beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:PythonController"] = append(beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:PythonController"],
-		beego.ControllerComments{
-			Method:           "ExcePython",
-			Router:           `/exec`,
-			AllowHTTPMethods: []string{"post"},
-			MethodParams:     param.Make(),
-			Filters:          nil,
-			Params:           nil})
-
-	beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:ShController"] = append(beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:ShController"],
-		beego.ControllerComments{
-			Method:           "Add",
-			Router:           `/add`,
-			AllowHTTPMethods: []string{"post"},
-			MethodParams:     param.Make(),
-			Filters:          nil,
-			Params:           nil})
-
-	beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:ShController"] = append(beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:ShController"],
-		beego.ControllerComments{
-			Method:           "Refresh",
-			Router:           `/refresh`,
-			AllowHTTPMethods: []string{"post"},
-			MethodParams:     param.Make(),
-			Filters:          nil,
-			Params:           nil})
-
-	beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:ShfeController"] = append(beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:ShfeController"],
-		beego.ControllerComments{
-			Method:           "Add",
-			Router:           `/add`,
-			AllowHTTPMethods: []string{"post"},
-			MethodParams:     param.Make(),
-			Filters:          nil,
-			Params:           nil})
-
-	beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:ShfeController"] = append(beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:ShfeController"],
-		beego.ControllerComments{
-			Method:           "Refresh",
-			Router:           `/refresh`,
-			AllowHTTPMethods: []string{"post"},
-			MethodParams:     param.Make(),
-			Filters:          nil,
-			Params:           nil})
-
-	beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:SmmController"] = append(beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:SmmController"],
-		beego.ControllerComments{
-			Method:           "Add",
-			Router:           `/add`,
-			AllowHTTPMethods: []string{"post"},
-			MethodParams:     param.Make(),
-			Filters:          nil,
-			Params:           nil})
-
-	beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:SmmController"] = append(beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:SmmController"],
-		beego.ControllerComments{
-			Method:           "Refresh",
-			Router:           `/refresh`,
-			AllowHTTPMethods: []string{"post"},
-			MethodParams:     param.Make(),
-			Filters:          nil,
-			Params:           nil})
-
-	beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:ThsController"] = append(beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:ThsController"],
-		beego.ControllerComments{
-			Method:           "Add",
-			Router:           `/add`,
-			AllowHTTPMethods: []string{"post"},
-			MethodParams:     param.Make(),
-			Filters:          nil,
-			Params:           nil})
-
-	beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:ThsController"] = append(beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:ThsController"],
-		beego.ControllerComments{
-			Method:           "Refresh",
-			Router:           `/refresh`,
-			AllowHTTPMethods: []string{"post"},
-			MethodParams:     param.Make(),
-			Filters:          nil,
-			Params:           nil})
-
-	beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:WindController"] = append(beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:WindController"],
-		beego.ControllerComments{
-			Method:           "Add",
-			Router:           `/add`,
-			AllowHTTPMethods: []string{"post"},
-			MethodParams:     param.Make(),
-			Filters:          nil,
-			Params:           nil})
-
-	beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:WindController"] = append(beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:WindController"],
-		beego.ControllerComments{
-			Method:           "Refresh",
-			Router:           `/refresh`,
-			AllowHTTPMethods: []string{"post"},
-			MethodParams:     param.Make(),
-			Filters:          nil,
-			Params:           nil})
-
-	beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:ZzController"] = append(beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:ZzController"],
-		beego.ControllerComments{
-			Method:           "Add",
-			Router:           `/add`,
-			AllowHTTPMethods: []string{"post"},
-			MethodParams:     param.Make(),
-			Filters:          nil,
-			Params:           nil})
-
-	beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:ZzController"] = append(beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:ZzController"],
-		beego.ControllerComments{
-			Method:           "Refresh",
-			Router:           `/refresh`,
-			AllowHTTPMethods: []string{"post"},
-			MethodParams:     param.Make(),
-			Filters:          nil,
-			Params:           nil})
+    beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:CalculateController"] = append(beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:CalculateController"],
+        beego.ControllerComments{
+            Method: "Add",
+            Router: `/add`,
+            AllowHTTPMethods: []string{"post"},
+            MethodParams: param.Make(),
+            Filters: nil,
+            Params: nil})
+
+    beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:CalculateController"] = append(beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:CalculateController"],
+        beego.ControllerComments{
+            Method: "BatchEdit",
+            Router: `/batch/edit`,
+            AllowHTTPMethods: []string{"post"},
+            MethodParams: param.Make(),
+            Filters: nil,
+            Params: nil})
+
+    beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:CalculateController"] = append(beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:CalculateController"],
+        beego.ControllerComments{
+            Method: "BatchSave",
+            Router: `/batch/save`,
+            AllowHTTPMethods: []string{"post"},
+            MethodParams: param.Make(),
+            Filters: nil,
+            Params: nil})
+
+    beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:CalculateController"] = append(beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:CalculateController"],
+        beego.ControllerComments{
+            Method: "Edit",
+            Router: `/edit`,
+            AllowHTTPMethods: []string{"post"},
+            MethodParams: param.Make(),
+            Filters: nil,
+            Params: nil})
+
+    beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:CalculateController"] = append(beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:CalculateController"],
+        beego.ControllerComments{
+            Method: "Refresh",
+            Router: `/refresh`,
+            AllowHTTPMethods: []string{"post"},
+            MethodParams: param.Make(),
+            Filters: nil,
+            Params: nil})
+
+    beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:CffexController"] = append(beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:CffexController"],
+        beego.ControllerComments{
+            Method: "Add",
+            Router: `/add`,
+            AllowHTTPMethods: []string{"post"},
+            MethodParams: param.Make(),
+            Filters: nil,
+            Params: nil})
+
+    beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:CffexController"] = append(beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:CffexController"],
+        beego.ControllerComments{
+            Method: "Refresh",
+            Router: `/refresh`,
+            AllowHTTPMethods: []string{"post"},
+            MethodParams: param.Make(),
+            Filters: nil,
+            Params: nil})
+
+    beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:CoalController"] = append(beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:CoalController"],
+        beego.ControllerComments{
+            Method: "Add",
+            Router: `/add`,
+            AllowHTTPMethods: []string{"post"},
+            MethodParams: param.Make(),
+            Filters: nil,
+            Params: nil})
+
+    beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:CoalController"] = append(beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:CoalController"],
+        beego.ControllerComments{
+            Method: "Refresh",
+            Router: `/refresh`,
+            AllowHTTPMethods: []string{"post"},
+            MethodParams: param.Make(),
+            Filters: nil,
+            Params: nil})
+
+    beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:DlController"] = append(beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:DlController"],
+        beego.ControllerComments{
+            Method: "Add",
+            Router: `/add`,
+            AllowHTTPMethods: []string{"post"},
+            MethodParams: param.Make(),
+            Filters: nil,
+            Params: nil})
+
+    beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:DlController"] = append(beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:DlController"],
+        beego.ControllerComments{
+            Method: "Refresh",
+            Router: `/refresh`,
+            AllowHTTPMethods: []string{"post"},
+            MethodParams: param.Make(),
+            Filters: nil,
+            Params: nil})
+
+    beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:EiaSteoController"] = append(beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:EiaSteoController"],
+        beego.ControllerComments{
+            Method: "Add",
+            Router: `/add`,
+            AllowHTTPMethods: []string{"post"},
+            MethodParams: param.Make(),
+            Filters: nil,
+            Params: nil})
+
+    beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:EiaSteoController"] = append(beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:EiaSteoController"],
+        beego.ControllerComments{
+            Method: "Refresh",
+            Router: `/refresh`,
+            AllowHTTPMethods: []string{"post"},
+            MethodParams: param.Make(),
+            Filters: nil,
+            Params: nil})
+
+    beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:GieController"] = append(beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:GieController"],
+        beego.ControllerComments{
+            Method: "Add",
+            Router: `/add`,
+            AllowHTTPMethods: []string{"post"},
+            MethodParams: param.Make(),
+            Filters: nil,
+            Params: nil})
+
+    beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:GieController"] = append(beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:GieController"],
+        beego.ControllerComments{
+            Method: "Refresh",
+            Router: `/refresh`,
+            AllowHTTPMethods: []string{"post"},
+            MethodParams: param.Make(),
+            Filters: nil,
+            Params: nil})
+
+    beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:GoogleTravelController"] = append(beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:GoogleTravelController"],
+        beego.ControllerComments{
+            Method: "Add",
+            Router: `/add`,
+            AllowHTTPMethods: []string{"post"},
+            MethodParams: param.Make(),
+            Filters: nil,
+            Params: nil})
+
+    beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:GoogleTravelController"] = append(beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:GoogleTravelController"],
+        beego.ControllerComments{
+            Method: "Refresh",
+            Router: `/refresh`,
+            AllowHTTPMethods: []string{"post"},
+            MethodParams: param.Make(),
+            Filters: nil,
+            Params: nil})
+
+    beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:LtController"] = append(beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:LtController"],
+        beego.ControllerComments{
+            Method: "Add",
+            Router: `/add`,
+            AllowHTTPMethods: []string{"post"},
+            MethodParams: param.Make(),
+            Filters: nil,
+            Params: nil})
+
+    beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:LtController"] = append(beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:LtController"],
+        beego.ControllerComments{
+            Method: "Refresh",
+            Router: `/refresh`,
+            AllowHTTPMethods: []string{"post"},
+            MethodParams: param.Make(),
+            Filters: nil,
+            Params: nil})
+
+    beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:LzController"] = append(beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:LzController"],
+        beego.ControllerComments{
+            Method: "Add",
+            Router: `/add`,
+            AllowHTTPMethods: []string{"post"},
+            MethodParams: param.Make(),
+            Filters: nil,
+            Params: nil})
+
+    beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:LzController"] = append(beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:LzController"],
+        beego.ControllerComments{
+            Method: "Refresh",
+            Router: `/refresh`,
+            AllowHTTPMethods: []string{"post"},
+            MethodParams: param.Make(),
+            Filters: nil,
+            Params: nil})
+
+    beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:ManualController"] = append(beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:ManualController"],
+        beego.ControllerComments{
+            Method: "Add",
+            Router: `/add`,
+            AllowHTTPMethods: []string{"post"},
+            MethodParams: param.Make(),
+            Filters: nil,
+            Params: nil})
+
+    beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:ManualController"] = append(beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:ManualController"],
+        beego.ControllerComments{
+            Method: "Refresh",
+            Router: `/refresh`,
+            AllowHTTPMethods: []string{"post"},
+            MethodParams: param.Make(),
+            Filters: nil,
+            Params: nil})
+
+    beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:MySteelChemicalController"] = append(beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:MySteelChemicalController"],
+        beego.ControllerComments{
+            Method: "Add",
+            Router: `/add`,
+            AllowHTTPMethods: []string{"post"},
+            MethodParams: param.Make(),
+            Filters: nil,
+            Params: nil})
+
+    beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:MySteelChemicalController"] = append(beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:MySteelChemicalController"],
+        beego.ControllerComments{
+            Method: "Refresh",
+            Router: `/refresh`,
+            AllowHTTPMethods: []string{"post"},
+            MethodParams: param.Make(),
+            Filters: nil,
+            Params: nil})
+
+    beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:MySteelController"] = append(beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:MySteelController"],
+        beego.ControllerComments{
+            Method: "Add",
+            Router: `/add`,
+            AllowHTTPMethods: []string{"post"},
+            MethodParams: param.Make(),
+            Filters: nil,
+            Params: nil})
+
+    beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:MySteelController"] = append(beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:MySteelController"],
+        beego.ControllerComments{
+            Method: "Refresh",
+            Router: `/refresh`,
+            AllowHTTPMethods: []string{"post"},
+            MethodParams: param.Make(),
+            Filters: nil,
+            Params: nil})
+
+    beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:PbController"] = append(beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:PbController"],
+        beego.ControllerComments{
+            Method: "Add",
+            Router: `/add`,
+            AllowHTTPMethods: []string{"post"},
+            MethodParams: param.Make(),
+            Filters: nil,
+            Params: nil})
+
+    beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:PbController"] = append(beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:PbController"],
+        beego.ControllerComments{
+            Method: "Refresh",
+            Router: `/refresh`,
+            AllowHTTPMethods: []string{"post"},
+            MethodParams: param.Make(),
+            Filters: nil,
+            Params: nil})
+
+    beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:PbFinanceController"] = append(beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:PbFinanceController"],
+        beego.ControllerComments{
+            Method: "Add",
+            Router: `/add`,
+            AllowHTTPMethods: []string{"post"},
+            MethodParams: param.Make(),
+            Filters: nil,
+            Params: nil})
+
+    beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:PbFinanceController"] = append(beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:PbFinanceController"],
+        beego.ControllerComments{
+            Method: "Refresh",
+            Router: `/refresh`,
+            AllowHTTPMethods: []string{"post"},
+            MethodParams: param.Make(),
+            Filters: nil,
+            Params: nil})
+
+    beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:PredictCalculateController"] = append(beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:PredictCalculateController"],
+        beego.ControllerComments{
+            Method: "CalculateBatchSave",
+            Router: `/batch/save`,
+            AllowHTTPMethods: []string{"post"},
+            MethodParams: param.Make(),
+            Filters: nil,
+            Params: nil})
+
+    beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:PredictCalculateController"] = append(beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:PredictCalculateController"],
+        beego.ControllerComments{
+            Method: "Refresh",
+            Router: `/refresh`,
+            AllowHTTPMethods: []string{"post"},
+            MethodParams: param.Make(),
+            Filters: nil,
+            Params: nil})
+
+    beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:PredictCalculateController"] = append(beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:PredictCalculateController"],
+        beego.ControllerComments{
+            Method: "Save",
+            Router: `/save`,
+            AllowHTTPMethods: []string{"post"},
+            MethodParams: param.Make(),
+            Filters: nil,
+            Params: nil})
+
+    beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:PredictController"] = append(beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:PredictController"],
+        beego.ControllerComments{
+            Method: "Refresh",
+            Router: `/refresh`,
+            AllowHTTPMethods: []string{"post"},
+            MethodParams: param.Make(),
+            Filters: nil,
+            Params: nil})
+
+    beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:PredictController"] = append(beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:PredictController"],
+        beego.ControllerComments{
+            Method: "Save",
+            Router: `/save`,
+            AllowHTTPMethods: []string{"post"},
+            MethodParams: param.Make(),
+            Filters: nil,
+            Params: nil})
+
+    beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:PythonController"] = append(beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:PythonController"],
+        beego.ControllerComments{
+            Method: "Add",
+            Router: `/add`,
+            AllowHTTPMethods: []string{"post"},
+            MethodParams: param.Make(),
+            Filters: nil,
+            Params: nil})
+
+    beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:PythonController"] = append(beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:PythonController"],
+        beego.ControllerComments{
+            Method: "Edit",
+            Router: `/edit`,
+            AllowHTTPMethods: []string{"post"},
+            MethodParams: param.Make(),
+            Filters: nil,
+            Params: nil})
+
+    beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:PythonController"] = append(beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:PythonController"],
+        beego.ControllerComments{
+            Method: "ExcePython",
+            Router: `/exec`,
+            AllowHTTPMethods: []string{"post"},
+            MethodParams: param.Make(),
+            Filters: nil,
+            Params: nil})
+
+    beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:ShController"] = append(beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:ShController"],
+        beego.ControllerComments{
+            Method: "Add",
+            Router: `/add`,
+            AllowHTTPMethods: []string{"post"},
+            MethodParams: param.Make(),
+            Filters: nil,
+            Params: nil})
+
+    beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:ShController"] = append(beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:ShController"],
+        beego.ControllerComments{
+            Method: "Refresh",
+            Router: `/refresh`,
+            AllowHTTPMethods: []string{"post"},
+            MethodParams: param.Make(),
+            Filters: nil,
+            Params: nil})
+
+    beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:ShfeController"] = append(beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:ShfeController"],
+        beego.ControllerComments{
+            Method: "Add",
+            Router: `/add`,
+            AllowHTTPMethods: []string{"post"},
+            MethodParams: param.Make(),
+            Filters: nil,
+            Params: nil})
+
+    beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:ShfeController"] = append(beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:ShfeController"],
+        beego.ControllerComments{
+            Method: "Refresh",
+            Router: `/refresh`,
+            AllowHTTPMethods: []string{"post"},
+            MethodParams: param.Make(),
+            Filters: nil,
+            Params: nil})
+
+    beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:SmmController"] = append(beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:SmmController"],
+        beego.ControllerComments{
+            Method: "Add",
+            Router: `/add`,
+            AllowHTTPMethods: []string{"post"},
+            MethodParams: param.Make(),
+            Filters: nil,
+            Params: nil})
+
+    beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:SmmController"] = append(beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:SmmController"],
+        beego.ControllerComments{
+            Method: "Refresh",
+            Router: `/refresh`,
+            AllowHTTPMethods: []string{"post"},
+            MethodParams: param.Make(),
+            Filters: nil,
+            Params: nil})
+
+    beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:ThsController"] = append(beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:ThsController"],
+        beego.ControllerComments{
+            Method: "Add",
+            Router: `/add`,
+            AllowHTTPMethods: []string{"post"},
+            MethodParams: param.Make(),
+            Filters: nil,
+            Params: nil})
+
+    beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:ThsController"] = append(beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:ThsController"],
+        beego.ControllerComments{
+            Method: "Refresh",
+            Router: `/refresh`,
+            AllowHTTPMethods: []string{"post"},
+            MethodParams: param.Make(),
+            Filters: nil,
+            Params: nil})
+
+    beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:WindController"] = append(beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:WindController"],
+        beego.ControllerComments{
+            Method: "Add",
+            Router: `/add`,
+            AllowHTTPMethods: []string{"post"},
+            MethodParams: param.Make(),
+            Filters: nil,
+            Params: nil})
+
+    beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:WindController"] = append(beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:WindController"],
+        beego.ControllerComments{
+            Method: "Refresh",
+            Router: `/refresh`,
+            AllowHTTPMethods: []string{"post"},
+            MethodParams: param.Make(),
+            Filters: nil,
+            Params: nil})
+
+    beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:ZzController"] = append(beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:ZzController"],
+        beego.ControllerComments{
+            Method: "Add",
+            Router: `/add`,
+            AllowHTTPMethods: []string{"post"},
+            MethodParams: param.Make(),
+            Filters: nil,
+            Params: nil})
+
+    beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:ZzController"] = append(beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:ZzController"],
+        beego.ControllerComments{
+            Method: "Refresh",
+            Router: `/refresh`,
+            AllowHTTPMethods: []string{"post"},
+            MethodParams: param.Make(),
+            Filters: nil,
+            Params: nil})
 
 }

routers/router.go

@@ -125,6 +125,11 @@ func init() {
 				&controllers.EiaSteoController{},
 			),
 		),
+		beego.NSNamespace("/predict",
+			beego.NSInclude(
+				&controllers.PredictController{},
+			),
+		),
 	)
 	beego.AddNamespace(ns)
 }

utils/constants.go

@@ -8,16 +8,17 @@ const (
 
 //常量定义
 const (
-	FormatTime            = "15:04:05"            //时间格式
-	FormatDate            = "2006-01-02"          //日期格式
-	FormatDateUnSpace     = "20060102"            //日期格式
-	FormatDateTime        = "2006-01-02 15:04:05" //完整时间格式
-	FormatDateTimeUnSpace = "20060102150405"      //完整时间格式
-	PageSize15            = 15                    //列表页每页数据量
-	PageSize5             = 5
-	PageSize10            = 10
-	PageSize20            = 20
-	PageSize30            = 30
+	FormatTime                 = "15:04:05"            //时间格式
+	FormatDate                 = "2006-01-02"          //日期格式
+	FormatDateUnSpace          = "20060102"            //日期格式
+	FormatDateTime             = "2006-01-02 15:04:05" //完整时间格式
+	FormatDateTimeUnSpace      = "20060102150405"      //完整时间格式
+	FormatShortDateTimeUnSpace = "060102150405"        //省去开头两位年份的时间格式
+	PageSize15                 = 15                    //列表页每页数据量
+	PageSize5                  = 5
+	PageSize10                 = 10
+	PageSize20                 = 20
+	PageSize30                 = 30
 )
 
 const (