Merge remote-tracking branch 'origin/eta/1.7.3' into eta/1.8.4

controllers/base_auth.go

@@ -30,6 +30,7 @@ func init() {
 
 type BaseAuthController struct {
 	web.Controller
+	Lang string `description:"当前语言类型，中文：zh；英文：en；默认：zh"`
 }
 
 func (this *BaseAuthController) Prepare() {
@@ -39,6 +40,15 @@ func (this *BaseAuthController) Prepare() {
 	fmt.Println("Url:", uri)
 	if method != "HEAD" {
 		if method == "POST" {
+			// 当前语言
+			{
+				lang := this.Ctx.Input.Header("Lang")
+				if lang == "" {
+					lang = utils.ZhLangVersion
+				}
+				this.Lang = lang
+			}
+
 			authorization := this.Ctx.Input.Header("authorization")
 			if authorization == "" {
 				this.JSON(models.BaseResponse{Ret: 408, Msg: "请重新授权！", ErrMsg: "请重新授权:authorization is empty "}, false, false)

controllers/base_common.go

@@ -13,6 +13,28 @@ import (
 
 type BaseCommonController struct {
 	web.Controller
+	Lang string `description:"当前语言类型，中文：zh；英文：en；默认：zh"`
+}
+
+func (c *BaseCommonController) Prepare() {
+	//var requestBody string
+	//method := c.Ctx.Input.Method()
+	//if method == "GET" {
+	//	requestBody = c.Ctx.Request.RequestURI
+	//} else {
+	//	requestBody, _ = url.QueryUnescape(string(c.Ctx.Input.RequestBody))
+	//}
+	// 当前语言
+	{
+		lang := c.Ctx.Input.Header("Lang")
+		if lang == "" {
+			lang = utils.ZhLangVersion
+		}
+		c.Lang = lang
+	}
+
+	//ip := c.Ctx.Input.IP()
+	//utils.ApiLog.Info("uri:%s, requestBody:%s, responseBody:%s, ip:%s", c.Ctx.Input.URI(), requestBody, ip)
 }
 
 func (c *BaseCommonController) ServeJSON(encoding ...bool) {

controllers/base_from_calculate.go

@@ -85,7 +85,7 @@ func (this *CalculateController) Add() {
 	}
 
 	// 新增
-	edbInfo, uniqueCode, err, errMsg := services.EdbCalculateAdd(req)
+	edbInfo, uniqueCode, err, errMsg := services.EdbCalculateAdd(req, this.Lang)
 	if err != nil {
 		br.Msg = err.Error()
 		br.ErrMsg = errMsg
@@ -222,22 +222,14 @@ func (this *CalculateController) Edit() {
 		req.EdbInfoIdArr = newEdbInfoIdArr
 	}
 
-	var condition string
-	var pars []interface{}
-	condition += " AND edb_name=? "
-	pars = append(pars, req.EdbName)
-
-	condition += " AND edb_info_id<>? "
-	pars = append(pars, req.EdbInfoId)
-
-	count, err := models.GetEdbInfoCountByCondition(condition, pars)
+	// 根据指标名称和指标ID校验库中是否还存在其他同名指标
+	existEdbName, err := logic.CheckExistByEdbNameAndEdbInfoId(0, req.EdbInfoId, req.EdbName, this.Lang)
 	if err != nil {
 		br.Msg = "判断指标名称是否存在失败"
 		br.ErrMsg = "判断指标名称是否存在失败,Err:" + err.Error()
 		return
 	}
-
-	if count > 0 {
+	if existEdbName {
 		br.Msg = "指标名称已存在，请重新填写"
 		br.ErrMsg = "指标名称已存在，请重新填写"
 		br.IsSendEmail = false
@@ -309,6 +301,19 @@ func (this *CalculateController) Edit() {
 		}
 	}
 
+	// 额外赋值
+	switch this.Lang {
+	case utils.EnLangVersion:
+		req.EdbNameEn = req.EdbName
+		req.UnitEn = req.Unit
+
+		req.EdbName = edbInfoDetail.EdbName
+		req.Unit = edbInfoDetail.Unit
+	default:
+		req.EdbNameEn = edbInfoDetail.EdbNameEn
+		req.UnitEn = edbInfoDetail.UnitEn
+	}
+
 	//重新计算
 	err, errMsg := models.EditCalculateInfo(edbInfoDetail, req, formulaSlice, edbInfoIdBytes, needCalculate)
 	if err != nil {
@@ -479,19 +484,15 @@ func (this *CalculateController) BatchSave() {
 	}
 	//加入缓存机制，避免创建同一个名称的指标 end
 
-	var condition string
-	var pars []interface{}
-	condition += " AND edb_name=? "
-	pars = append(pars, req.EdbName)
-
-	count, err := models.GetEdbInfoCountByCondition(condition, pars)
+	// 根据指标名称和指标ID校验库中是否还存在其他同名指标
+	existEdbName, err := logic.CheckExistByEdbNameAndEdbInfoId(0, req.EdbInfoId, req.EdbName, this.Lang)
 	if err != nil {
 		br.Msg = "判断指标名称是否存在失败"
 		br.ErrMsg = "判断指标名称是否存在失败,Err:" + err.Error()
 		return
 	}
 
-	if count > 0 {
+	if existEdbName {
 		br.Msg = "指标名称已存在，请重新填写"
 		br.ErrMsg = "指标名称已存在，请重新填写"
 		br.IsSendEmail = false
@@ -835,22 +836,15 @@ func (this *CalculateController) BatchEdit() {
 		return
 	}
 
-	var condition string
-	var pars []interface{}
-	condition += " AND edb_name=? "
-	pars = append(pars, req.EdbName)
-
-	condition += " AND edb_info_id<>? "
-	pars = append(pars, req.EdbInfoId)
-
-	count, err := models.GetEdbInfoCountByCondition(condition, pars)
+	// 根据指标名称和指标ID校验库中是否还存在其他同名指标
+	existEdbName, err := logic.CheckExistByEdbNameAndEdbInfoId(0, req.EdbInfoId, req.EdbName, this.Lang)
 	if err != nil {
 		br.Msg = "判断指标名称是否存在失败"
 		br.ErrMsg = "判断指标名称是否存在失败,Err:" + err.Error()
 		return
 	}
 
-	if count > 0 {
+	if existEdbName {
 		br.Msg = "指标名称已存在，请重新填写"
 		br.ErrMsg = "指标名称已存在，请重新填写"
 		br.IsSendEmail = false
@@ -969,6 +963,19 @@ func (this *CalculateController) BatchEdit() {
 
 	//dataUpdateTime := time.Now().Format(utils.FormatDateTime)
 
+	// 额外赋值
+	switch this.Lang {
+	case utils.EnLangVersion:
+		req.EdbNameEn = req.EdbName
+		req.UnitEn = req.Unit
+
+		req.EdbName = edbInfo.EdbName
+		req.Unit = edbInfo.Unit
+	default:
+		req.EdbNameEn = edbInfo.EdbNameEn
+		req.UnitEn = edbInfo.UnitEn
+	}
+
 	var sourName, errMsg string
 	var edbInfoId int
 	var baseEdbInfoModel models.BaseEdbInfoInterface
@@ -2167,7 +2174,7 @@ func (this *CalculateController) BatchSaveMulti() {
 				wg.Done()
 			}()
 
-			edbInfo, uniqueCode, err, errMsg = services.EdbCalculateBatchSave(reqItem)
+			edbInfo, uniqueCode, err, errMsg = services.EdbCalculateBatchSave(reqItem, this.Lang)
 			return
 		}()
 	}

controllers/base_from_predict.go

@@ -36,14 +36,14 @@ func (this *PredictController) Save() {
 		return
 	}
 	if req.EdbInfoId <= 0 {
-		addPredict(br, req)
+		addPredict(br, req, this.Lang)
 	} else {
-		editPredict(br, req)
+		editPredict(br, req, this.Lang)
 	}
 }
 
-// AddPredictCalculate 添加预测指标运算
-func addPredict(br *models.BaseResponse, req models.AddPredictEdbInfoReq) {
+// addPredict 添加预测指标运算
+func addPredict(br *models.BaseResponse, req models.AddPredictEdbInfoReq, lang string) {
 	//加入缓存机制，避免创建同一个名称的指标 start
 	redisKey := fmt.Sprint("predict_edb_info:calculate:batch:save:", utils.DATA_SOURCE_PREDICT, ":", req.EdbName)
 	isExist := utils.Rc.IsExist(redisKey)
@@ -59,7 +59,7 @@ func addPredict(br *models.BaseResponse, req models.AddPredictEdbInfoReq) {
 	}
 
 	// 添加指标
-	edbInfo, err, errMsg := logic.AddPredictEdbInfo(req.SourceEdbInfoId, req.ClassifyId, req.EdbName, req.DataDateType, req.RuleList, req.MinValue, req.MaxValue, req.AdminId, req.AdminName)
+	edbInfo, err, errMsg := logic.AddPredictEdbInfo(req.SourceEdbInfoId, req.ClassifyId, req.EdbName, req.DataDateType, req.RuleList, req.MinValue, req.MaxValue, req.AdminId, req.AdminName, lang)
 	if err != nil {
 		br.Msg = "保存失败"
 		if errMsg != `` {
@@ -79,8 +79,8 @@ func addPredict(br *models.BaseResponse, req models.AddPredictEdbInfoReq) {
 	br.IsAddLog = true
 }
 
-// editPredictCalculate 编辑预测指标运算
-func editPredict(br *models.BaseResponse, req models.AddPredictEdbInfoReq) {
+// editPredict 编辑预测指标运算
+func editPredict(br *models.BaseResponse, req models.AddPredictEdbInfoReq, lang string) {
 	req.EdbName = strings.Trim(req.EdbName, " ")
 	//加入缓存机制，避免创建同一个名称的指标 start
 	redisKey := fmt.Sprint("predict_edb_info:calculate:batch:save:", utils.DATA_SOURCE_PREDICT, ":", req.EdbName)
@@ -97,7 +97,7 @@ func editPredict(br *models.BaseResponse, req models.AddPredictEdbInfoReq) {
 	}
 
 	// 编辑指标
-	edbInfo, err, errMsg := logic.EditPredictEdbInfo(req.EdbInfoId, req.ClassifyId, req.EdbName, req.DataDateType, req.RuleList, req.MinValue, req.MaxValue)
+	edbInfo, err, errMsg := logic.EditPredictEdbInfo(req.EdbInfoId, req.ClassifyId, req.EdbName, req.DataDateType, req.RuleList, req.MinValue, req.MaxValue, lang)
 	if err != nil {
 		br.Msg = "保存失败"
 		if errMsg != `` {

controllers/base_from_predict_calculate.go

@@ -35,14 +35,14 @@ func (this *PredictCalculateController) Save() {
 		return
 	}
 	if req.EdbInfoId <= 0 {
-		addPredictCalculate(br, req)
+		addPredictCalculate(br, req, this.Lang)
 	} else {
-		editPredictCalculate(br, req)
+		editPredictCalculate(br, req, this.Lang)
 	}
 }
 
 // AddPredictCalculate 添加预测指标运算
-func addPredictCalculate(br *models.BaseResponse, req models.EdbInfoCalculateSaveReq) {
+func addPredictCalculate(br *models.BaseResponse, req models.EdbInfoCalculateSaveReq, lang string) {
 
 	req.EdbName = strings.Trim(req.EdbName, " ")
 	if req.EdbName == "" {
@@ -125,25 +125,17 @@ func addPredictCalculate(br *models.BaseResponse, req models.EdbInfoCalculateSav
 		}
 	}
 
-	// 判断指标名称是否存在
-	{
-		var condition string
-		var pars []interface{}
-		// 指标类型，0：普通指标，1：预测指标
-		condition += " AND edb_info_type=?  AND edb_name=? "
-		pars = append(pars, 1, req.EdbName)
-
-		count, err := models.GetEdbInfoCountByCondition(condition, pars)
-		if err != nil {
-			br.Msg = "判断指标名称是否存在失败"
-			br.ErrMsg = "判断指标名称是否存在失败,Err:" + err.Error()
-			return
-		}
-		if count > 0 {
-			br.Msg = "指标名称已存在，请重新填写"
-			br.ErrMsg = "指标名称已存在，请重新填写"
-			return
-		}
+	// 根据指标名称和指标ID校验库中是否还存在其他同名指标
+	existEdbName, err := logic.CheckExistByEdbNameAndEdbInfoId(1, 0, req.EdbName, lang)
+	if err != nil {
+		br.Msg = "判断指标名称是否存在失败"
+		br.ErrMsg = "判断指标名称是否存在失败,Err:" + err.Error()
+		return
+	}
+	if existEdbName {
+		br.Msg = "指标名称已存在，请重新填写"
+		br.ErrMsg = "指标名称已存在，请重新填写"
+		return
 	}
 
 	// 关联指标信息
@@ -222,6 +214,8 @@ func addPredictCalculate(br *models.BaseResponse, req models.EdbInfoCalculateSav
 		EdbType:          2,
 		EmptyType:        req.EmptyType,
 		MaxEmptyType:     req.MaxEmptyType,
+		EdbNameEn:        req.EdbName,
+		UnitEn:           req.Unit,
 	}
 	edbInfoId, err := models.AddEdbInfo(edbInfo)
 	if err != nil {
@@ -291,7 +285,7 @@ func addPredictCalculate(br *models.BaseResponse, req models.EdbInfoCalculateSav
 }
 
 // editPredictCalculate 编辑预测指标运算
-func editPredictCalculate(br *models.BaseResponse, req models.EdbInfoCalculateSaveReq) {
+func editPredictCalculate(br *models.BaseResponse, req models.EdbInfoCalculateSaveReq, lang string) {
 	req.EdbName = strings.Trim(req.EdbName, " ")
 	if req.EdbName == "" {
 		br.Msg = "指标名称不能为空"
@@ -380,25 +374,18 @@ func editPredictCalculate(br *models.BaseResponse, req models.EdbInfoCalculateSa
 		br.ErrMsg = "获取指标信息失败,Err:" + err.Error()
 		return
 	}
-	// 判断指标名称是否存在
-	{
-		var condition string
-		var pars []interface{}
-		// 指标类型，0：普通指标，1：预测指标
-		condition += " AND edb_info_id !=?  AND edb_info_type=?  AND edb_name=? "
-		pars = append(pars, edbInfo.EdbInfoId, edbInfo.EdbInfoType, req.EdbName)
 
-		count, err := models.GetEdbInfoCountByCondition(condition, pars)
-		if err != nil {
-			br.Msg = "判断指标名称是否存在失败"
-			br.ErrMsg = "判断指标名称是否存在失败,Err:" + err.Error()
-			return
-		}
-		if count > 0 {
-			br.Msg = "指标名称已存在，请重新填写"
-			br.ErrMsg = "指标名称已存在，请重新填写"
-			return
-		}
+	// 根据指标名称和指标ID校验库中是否还存在其他同名指标
+	existEdbName, err := logic.CheckExistByEdbNameAndEdbInfoId(edbInfo.EdbInfoType, edbInfo.EdbInfoId, req.EdbName, lang)
+	if err != nil {
+		br.Msg = "判断指标名称是否存在失败"
+		br.ErrMsg = "判断指标名称是否存在失败,Err:" + err.Error()
+		return
+	}
+	if existEdbName {
+		br.Msg = "指标名称已存在，请重新填写"
+		br.ErrMsg = "指标名称已存在，请重新填写"
+		return
 	}
 
 	// 关联指标信息
@@ -473,9 +460,15 @@ func editPredictCalculate(br *models.BaseResponse, req models.EdbInfoCalculateSa
 		}
 	}
 
-	edbInfo.EdbName = req.EdbName
+	switch lang {
+	case utils.EnLangVersion:
+		edbInfo.EdbNameEn = req.EdbName
+		edbInfo.UnitEn = req.Unit
+	default:
+		edbInfo.EdbName = req.EdbName
+		edbInfo.Unit = req.Unit
+	}
 	edbInfo.Frequency = req.Frequency
-	edbInfo.Unit = req.Unit
 	edbInfo.ClassifyId = req.ClassifyId
 	edbInfo.CalculateFormula = req.CalculateFormula
 	edbInfo.EmptyType = req.EmptyType
@@ -578,24 +571,14 @@ func (this *PredictCalculateController) CalculateBatchSave() {
 	}
 	//加入缓存机制，避免创建同一个名称的指标 end
 
-	var condition string
-	var pars []interface{}
-	condition += " AND edb_name=? "
-	pars = append(pars, req.EdbName)
-
-	if req.EdbInfoId > 0 {
-		condition += " AND edb_info_id !=? "
-		pars = append(pars, req.EdbInfoId)
-	}
-
-	count, err := models.GetEdbInfoCountByCondition(condition, pars)
+	// 根据指标名称和指标ID校验库中是否还存在其他同名指标
+	existEdbName, err := logic.CheckExistByEdbNameAndEdbInfoId(1, req.EdbInfoId, req.EdbName, this.Lang)
 	if err != nil {
 		br.Msg = "判断指标名称是否存在失败"
 		br.ErrMsg = "判断指标名称是否存在失败,Err:" + err.Error()
 		return
 	}
-
-	if count > 0 {
+	if existEdbName {
 		br.Msg = "指标名称已存在，请重新填写"
 		br.ErrMsg = "指标名称已存在，请重新填写"
 		return
@@ -713,6 +696,7 @@ func (this *PredictCalculateController) CalculateBatchSave() {
 		UniqueCode:      uniqueCode,
 		SysUserId:       req.AdminId,
 		SysUserRealName: req.AdminName,
+		Lang:            this.Lang,
 	}
 
 	if req.Source == utils.DATA_SOURCE_PREDICT_CALCULATE_TBZ {
@@ -740,13 +724,13 @@ func (this *PredictCalculateController) CalculateBatchSave() {
 			}
 		}
 		sourName = "预测同差"
-		edbInfo, latestDateStr, latestValue, err, errMsg = models.SavePredictCalculateTcz(req.EdbInfoId, req.ClassifyId, req.EdbName, req.Frequency, req.Unit, req.Formula, fromEdbInfo, edbCode, uniqueCode, adminId, adminName)
+		edbInfo, latestDateStr, latestValue, err, errMsg = models.SavePredictCalculateTcz(req.EdbInfoId, req.ClassifyId, req.EdbName, req.Frequency, req.Unit, req.Formula, fromEdbInfo, edbCode, uniqueCode, adminId, adminName, this.Lang)
 	} else if req.Source == utils.DATA_SOURCE_PREDICT_CALCULATE_NSZYDPJJS {
 		sourName = "预测N数值移动平均计算"
-		edbInfo, latestDateStr, latestValue, err, errMsg = models.SavePredictCalculateNszydpjjs(req.EdbInfoId, req.ClassifyId, req.EdbName, req.Frequency, req.Unit, req.Formula, fromEdbInfo, edbCode, uniqueCode, adminId, adminName)
+		edbInfo, latestDateStr, latestValue, err, errMsg = models.SavePredictCalculateNszydpjjs(req.EdbInfoId, req.ClassifyId, req.EdbName, req.Frequency, req.Unit, req.Formula, fromEdbInfo, edbCode, uniqueCode, adminId, adminName, this.Lang)
 	} else if req.Source == utils.DATA_SOURCE_PREDICT_CALCULATE_BP {
 		sourName = "预测变频"
-		edbInfo, latestDateStr, latestValue, err = models.SavePredictCalculateBp(&req, fromEdbInfo, edbCode, uniqueCode, adminId, adminName)
+		edbInfo, latestDateStr, latestValue, err = models.SavePredictCalculateBp(&req, fromEdbInfo, edbCode, uniqueCode, adminId, adminName, this.Lang)
 	} else if req.Source == utils.DATA_SOURCE_PREDICT_CALCULATE_HBZ {
 		checkDataList, tmpErr := models.GetPredictEdbDataListAllByStartDate(fromEdbInfo, 0, "")
 		if tmpErr != nil && tmpErr.Error() != utils.ErrNoRow() {
@@ -762,23 +746,23 @@ func (this *PredictCalculateController) CalculateBatchSave() {
 			}
 		}
 		sourName = "预测环比值"
-		edbInfo, latestDateStr, latestValue, err = models.SavePredictCalculateHbz(&req, fromEdbInfo, edbCode, uniqueCode, adminId, adminName, formulaInt)
+		edbInfo, latestDateStr, latestValue, err = models.SavePredictCalculateHbz(&req, fromEdbInfo, edbCode, uniqueCode, adminId, adminName, formulaInt, this.Lang)
 	} else if req.Source == utils.DATA_SOURCE_PREDICT_CALCULATE_HCZ {
 		sourName = "预测环差值"
-		edbInfo, latestDateStr, latestValue, err = models.SavePredictCalculateHcz(&req, fromEdbInfo, edbCode, uniqueCode, adminId, adminName, formulaInt)
+		edbInfo, latestDateStr, latestValue, err = models.SavePredictCalculateHcz(&req, fromEdbInfo, edbCode, uniqueCode, adminId, adminName, formulaInt, this.Lang)
 	} else if req.Source == utils.DATA_SOURCE_PREDICT_CALCULATE_LJZZY {
 		sourName = "预测累计值转月值"
 		if fromEdbInfo.Frequency != "月度" {
 			br.Msg = "请选择月度指标"
 			return
 		}
-		edbInfo, latestDateStr, latestValue, err = models.SavePredictCalculateLjzzy(&req, fromEdbInfo, edbCode, uniqueCode, adminId, adminName)
+		edbInfo, latestDateStr, latestValue, err = models.SavePredictCalculateLjzzy(&req, fromEdbInfo, edbCode, uniqueCode, adminId, adminName, this.Lang)
 	} else if req.Source == utils.DATA_SOURCE_PREDICT_CALCULATE_TIME_SHIFT {
 		sourName = "预测时间移位"
-		edbInfo, latestDateStr, latestValue, err = models.SavePredictCalculateTimeShift(&req, fromEdbInfo, edbCode, uniqueCode, adminId, adminName)
+		edbInfo, latestDateStr, latestValue, err = models.SavePredictCalculateTimeShift(&req, fromEdbInfo, edbCode, uniqueCode, adminId, adminName, this.Lang)
 	} else if req.Source == utils.DATA_SOURCE_PREDICT_CALCULATE_CJJX {
 		sourName = "预测超季节性"
-		edbInfo, latestDateStr, latestValue, err = models.SavePredictCalculateCjjx(&req, fromEdbInfo, edbCode, uniqueCode, adminId, adminName, formulaInt)
+		edbInfo, latestDateStr, latestValue, err = models.SavePredictCalculateCjjx(&req, fromEdbInfo, edbCode, uniqueCode, adminId, adminName, formulaInt, this.Lang)
 	} else if req.Source == utils.DATA_SOURCE_PREDICT_CALCULATE_NHCC {
 		sourName = "预测拟合残差"
 		secondEdbInfoReq := req.EdbInfoIdArr[1]
@@ -794,16 +778,16 @@ func (this *PredictCalculateController) CalculateBatchSave() {
 			br.ErrMsg = "两个指标不允许为同一个"
 			return
 		}
-		edbInfo, latestDateStr, latestValue, err = models.SavePredictCalculateNhcc(&req, fromEdbInfo, secondEdbInfo, edbCode, uniqueCode, nhccDate, adminId, adminName)
+		edbInfo, latestDateStr, latestValue, err = models.SavePredictCalculateNhcc(&req, fromEdbInfo, secondEdbInfo, edbCode, uniqueCode, nhccDate, adminId, adminName, this.Lang)
 	} else if req.Source == utils.DATA_SOURCE_PREDICT_CALCULATE_JP {
 		sourName = utils.DATA_SOURCE_NAME_PREDICT_CALCULATE_JP
-		edbInfo, latestDateStr, latestValue, err, errMsg = models.SavePredictCalculateJp(req.EdbInfoId, req.ClassifyId, req.EdbName, req.Frequency, req.Unit, req.Formula, fromEdbInfo, edbCode, uniqueCode, adminId, adminName)
+		edbInfo, latestDateStr, latestValue, err, errMsg = models.SavePredictCalculateJp(req.EdbInfoId, req.ClassifyId, req.EdbName, req.Frequency, req.Unit, req.Formula, fromEdbInfo, edbCode, uniqueCode, adminId, adminName, this.Lang)
 	} else if req.Source == utils.DATA_SOURCE_PREDICT_CALCULATE_NH {
 		sourName = utils.DATA_SOURCE_NAME_PREDICT_CALCULATE_NH
-		edbInfo, latestDateStr, latestValue, err, errMsg = models.SavePredictCalculateNh(req.EdbInfoId, req.ClassifyId, req.EdbName, req.Frequency, req.Unit, req.Formula, fromEdbInfo, edbCode, uniqueCode, adminId, adminName)
+		edbInfo, latestDateStr, latestValue, err, errMsg = models.SavePredictCalculateNh(req.EdbInfoId, req.ClassifyId, req.EdbName, req.Frequency, req.Unit, req.Formula, fromEdbInfo, edbCode, uniqueCode, adminId, adminName, this.Lang)
 	} else if req.Source == utils.DATA_SOURCE_PREDICT_CALCULATE_KSZS {
 		sourName = utils.DATA_SOURCE_NAME_PREDICT_CALCULATE_KSZS
-		edbInfo, latestDateStr, latestValue, err, errMsg = models.SavePredictCalculateKszs(req.EdbInfoId, req.ClassifyId, req.EdbName, req.Frequency, req.Unit, req.Formula, req.EdbInfoIdArr, edbCode, uniqueCode, adminId, adminName)
+		edbInfo, latestDateStr, latestValue, err, errMsg = models.SavePredictCalculateKszs(req.EdbInfoId, req.ClassifyId, req.EdbName, req.Frequency, req.Unit, req.Formula, req.EdbInfoIdArr, edbCode, uniqueCode, adminId, adminName, this.Lang)
 	} else {
 		// 获取通用的数据源处理服务
 		baseEdbInfoModel = models.GetBasePredictEdbInfoModel(req.Source)

logic/predict_edb.go

@@ -11,7 +11,7 @@ import (
 )
 
 // AddPredictEdbInfo 新增预测指标
-func AddPredictEdbInfo(sourceEdbInfoId, classifyId int, edbName, dataDateType string, ruleList []models.RuleConfig, minValue, maxValue float64, sysUserId int, sysUserName string) (edbInfo *models.EdbInfo, err error, errMsg string) {
+func AddPredictEdbInfo(sourceEdbInfoId, classifyId int, edbName, dataDateType string, ruleList []models.RuleConfig, minValue, maxValue float64, sysUserId int, sysUserName, lang string) (edbInfo *models.EdbInfo, err error, errMsg string) {
 	var sourceEdbInfo *models.EdbInfo
 	// 来源指标信息校验
 	{
@@ -65,22 +65,14 @@ func AddPredictEdbInfo(sourceEdbInfoId, classifyId int, edbName, dataDateType st
 
 	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)
+	// 根据指标名称和指标ID校验库中是否还存在其他同名指标
+	existEdbName, err := CheckExistByEdbNameAndEdbInfoId(0, 0, edbName, lang)
 	if err != nil {
 		errMsg = "判断指标名称是否存在失败"
 		err = errors.New("判断指标名称是否存在失败,Err:" + err.Error())
 		return
 	}
-	if count > 0 {
+	if existEdbName {
 		errMsg = "指标名称已存在，请重新填写"
 		err = errors.New(errMsg)
 		return
@@ -118,6 +110,8 @@ func AddPredictEdbInfo(sourceEdbInfoId, classifyId int, edbName, dataDateType st
 		MoveFrequency: sourceEdbInfo.MoveFrequency,
 		NoUpdate:      sourceEdbInfo.NoUpdate,
 		ServerUrl:     "",
+		EdbNameEn:     edbName,
+		UnitEn:        sourceEdbInfo.UnitEn,
 		DataDateType:  dataDateType,
 	}
 
@@ -407,7 +401,7 @@ func AddPredictEdbInfo(sourceEdbInfoId, classifyId int, edbName, dataDateType st
 }
 
 // EditPredictEdbInfo 编辑预测指标
-func EditPredictEdbInfo(edbInfoId, classifyId int, edbName, dataDateType string, ruleList []models.RuleConfig, minValue, maxValue float64) (edbInfo *models.EdbInfo, err error, errMsg string) {
+func EditPredictEdbInfo(edbInfoId, classifyId int, edbName, dataDateType string, ruleList []models.RuleConfig, minValue, maxValue float64, lang string) (edbInfo *models.EdbInfo, err error, errMsg string) {
 	// 指标信息校验
 	{
 		edbInfo, err = models.GetEdbInfoById(edbInfoId)
@@ -447,27 +441,14 @@ func EditPredictEdbInfo(edbInfoId, classifyId int, edbName, dataDateType string,
 		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)
+	// 根据指标名称和指标ID校验库中是否还存在其他同名指标
+	existEdbName, err := CheckExistByEdbNameAndEdbInfoId(1, edbInfoId, edbName, lang)
 	if err != nil {
 		errMsg = "判断指标名称是否存在失败"
 		err = errors.New("判断指标名称是否存在失败,Err:" + err.Error())
 		return
 	}
-
-	if count > 0 {
+	if existEdbName {
 		errMsg = "指标名称已存在，请重新填写"
 		err = errors.New(errMsg)
 		return
@@ -476,14 +457,20 @@ func EditPredictEdbInfo(edbInfoId, classifyId int, edbName, dataDateType string,
 	if dataDateType == `` {
 		dataDateType = `自然日`
 	}
-	edbInfo.EdbName = edbName
+	switch lang {
+	case utils.EnLangVersion:
+		edbInfo.EdbNameEn = edbName
+	default:
+		edbInfo.EdbName = edbName
+
+	}
 	edbInfo.EdbNameSource = edbName
 	edbInfo.ClassifyId = classifyId
 	edbInfo.MinValue = minValue
 	edbInfo.MaxValue = maxValue
 	edbInfo.DataDateType = dataDateType
 	edbInfo.ModifyTime = time.Now()
-	updateEdbInfoCol := []string{"EdbName", "EdbNameSource", "ClassifyId", "EndDate", "MinValue", "MaxValue", "DataDateType", "ModifyTime"}
+	updateEdbInfoCol := []string{"EdbName", "EdbNameEn", "EdbNameSource", "ClassifyId", "EndDate", "MinValue", "MaxValue", "DataDateType", "ModifyTime"}
 
 	var sourceEdbInfo *models.EdbInfo
 	// 来源指标信息校验
@@ -990,3 +977,103 @@ func RefreshPredictEdbInfo(edbInfoId int) (edbInfo *models.EdbInfo, err error, e
 
 	return
 }
+
+
+// checkExistByEdbName
+// @Description: 根据指标名称校验该指标是否存在库中
+// @author: Roc
+// @datetime 2024-04-18 14:58:52
+// @param edbInfoType int
+// @param edbName string
+// @param lang string
+// @return has bool
+// @return err error
+func checkExistByEdbName(edbInfoType int, edbName, lang string) (has bool, err error) {
+	var condition string
+	var pars []interface{}
+
+	condition += " AND edb_info_type=? "
+	pars = append(pars, 0)
+
+	switch lang {
+	case utils.EnLangVersion:
+		condition += " AND edb_name_en = ? "
+	default:
+		condition += " AND edb_name=? "
+	}
+
+	pars = append(pars, edbName)
+
+	count, err := models.GetEdbInfoCountByCondition(condition, pars)
+	if err != nil {
+		return
+	}
+
+	if count > 0 {
+		has = true
+		return
+	}
+
+	return
+}
+
+// checkExistByEdbNameAndEdbInfoId
+// @Description: 根据指标名称和指标ID校验库中是否还存在其他同名指标
+// @author: Roc
+// @datetime 2024-04-18 15:00:19
+// @param edbInfoType int
+// @param edbInfoId int
+// @param edbName string
+// @param lang string
+// @return has bool
+// @return err error
+func checkExistByEdbNameAndEdbInfoId(edbInfoType, edbInfoId int, edbName, lang string) (has bool, err error) {
+	var condition string
+	var pars []interface{}
+	condition += " AND edb_info_type=? "
+	pars = append(pars, edbInfoType)
+
+	condition += " AND edb_info_id<>? "
+	pars = append(pars, edbInfoId)
+
+	switch lang {
+	case utils.EnLangVersion:
+		condition += " AND edb_name_en = ? "
+	default:
+		condition += " AND edb_name=? "
+	}
+
+	pars = append(pars, edbName)
+
+	count, err := models.GetEdbInfoCountByCondition(condition, pars)
+	if err != nil {
+		return
+	}
+
+	if count > 0 {
+		has = true
+		return
+	}
+
+	return
+}
+
+// CheckExistByEdbNameAndEdbInfoId
+// @Description: 根据指标名称和指标ID校验库中是否还存在其他同名指标
+// @author: Roc
+// @datetime 2024-04-18 15:01:44
+// @param edbInfoType int
+// @param edbInfoId int
+// @param edbName string
+// @param lang string
+// @return has bool
+// @return err error
+func CheckExistByEdbNameAndEdbInfoId(edbInfoType, edbInfoId int, edbName, lang string) (has bool, err error) {
+	// 指标没有入库的情况
+	if edbInfoId == 0 {
+		return checkExistByEdbName(edbInfoType, edbName, lang)
+	}
+
+	//指标已经入库的情况
+	return checkExistByEdbNameAndEdbInfoId(edbInfoType, edbInfoId, edbName, lang)
+}

models/base_from_calculate.go

@@ -19,8 +19,10 @@ type EdbInfoCalculateSaveReq struct {
 	AdminName        string `description:"添加人名称"`
 	EdbInfoId        int    `description:"指标id"`
 	EdbName          string `description:"指标名称"`
+	EdbNameEn        string `description:"英文指标名称"`
 	Frequency        string `description:"频率"`
 	Unit             string `description:"单位"`
+	UnitEn           string `description:"英文单位"`
 	ClassifyId       int    `description:"分类id"`
 	CalculateFormula string `description:"计算公式"`
 	EmptyType        int    `description:"空值处理类型（0查找前后35天，1不计算，2前值填充，3后值填充，4等于0）"`
@@ -85,8 +87,8 @@ func AddCalculateInfo(req EdbInfoCalculateSaveReq, calculateMappingList []*EdbIn
 		NoUpdate:         0,
 		ServerUrl:        "",
 		EdbInfoType:      0,
-		EdbNameEn:        "",
-		UnitEn:           "",
+		EdbNameEn:        req.EdbName,
+		UnitEn:           req.Unit,
 		LatestDate:       "",
 		LatestValue:      0,
 		ChartImage:       "",
@@ -139,16 +141,18 @@ func EditCalculateInfo(edbInfo *EdbInfo, req EdbInfoCalculateSaveReq, formulaSli
 
 	// 修改指标信息
 	edbInfo.EdbName = req.EdbName
+	edbInfo.EdbNameEn = req.EdbNameEn
 	edbInfo.EdbNameSource = req.EdbName
 	edbInfo.Frequency = req.Frequency
 	edbInfo.Unit = req.Unit
+	edbInfo.UnitEn = req.UnitEn
 	edbInfo.ClassifyId = req.ClassifyId
 	edbInfo.CalculateFormula = req.CalculateFormula
 	edbInfo.ModifyTime = time.Now()
 	edbInfo.EmptyType = req.EmptyType
 	edbInfo.MaxEmptyType = req.MaxEmptyType
 	edbInfo.Extra = req.Extra
-	_, err = to.Update(edbInfo, "EdbName", "EdbNameSource", "Frequency", "Unit", "ClassifyId", "CalculateFormula", "ModifyTime", "EmptyType", "MaxEmptyType", "Extra")
+	_, err = to.Update(edbInfo, "EdbName", "EdbNameSource", "Frequency", "Unit", "EdbNameEn", "UnitEn", "ClassifyId", "CalculateFormula", "ModifyTime", "EmptyType", "MaxEmptyType", "Extra")
 	if err != nil {
 		return
 	}
@@ -683,8 +687,10 @@ type EdbInfoCalculateEdbInfoIdReq struct {
 // EdbInfoCalculateBatchEditReq 编辑计算指标的请求参数
 type EdbInfoCalculateBatchEditReq struct {
 	EdbName          string                         `description:"指标名称"`
+	EdbNameEn        string                         `description:"英文指标名称"`
 	Frequency        string                         `description:"频度"`
 	Unit             string                         `description:"单位"`
+	UnitEn           string                         `description:"英文单位"`
 	ClassifyId       int                            `description:"分类id"`
 	Formula          string                         `description:"N值"`
 	EdbInfoId        int                            `description:"编辑指标id"`

models/base_predict_from_calculate.go

@@ -59,7 +59,7 @@ func EditPredictCalculate(edbInfo *EdbInfo, calculateMappingList []*EdbInfoCalcu
 	}()
 
 	// 修改指标信息
-	_, err = to.Update(edbInfo, "EdbName", "Frequency", "Unit", "ClassifyId", "CalculateFormula", "EmptyType", "MaxEmptyType")
+	_, err = to.Update(edbInfo, "EdbName", "Frequency", "Unit", "ClassifyId", "CalculateFormula", "EmptyType", "MaxEmptyType", "EdbNameEn", "UnitEn")
 	if err != nil {
 		return
 	}

models/common.go

@@ -73,6 +73,7 @@ type BatchSaveCalculateBatchParams struct {
 	UniqueCode      string
 	SysUserId       int
 	SysUserRealName string
+	Lang            string
 }
 
 // BasePredictEdbInfoInterface 基础指标接口

models/edb_data_calculate_avg.go

@@ -56,6 +56,8 @@ func (obj CalculateAvg) Add(params AddCalculateBatchParams) (edbInfo *EdbInfo, e
 	edbInfo.EmptyType = req.EmptyType
 	edbInfo.MaxEmptyType = req.MaxEmptyType
 	edbInfo.Extra = req.Extra
+	edbInfo.EdbNameEn = req.EdbName
+	edbInfo.UnitEn = req.Unit
 	newEdbInfoId, tmpErr := to.Insert(edbInfo)
 	if tmpErr != nil {
 		err = tmpErr
@@ -141,8 +143,10 @@ func (obj CalculateAvg) Edit(params EditCalculateBatchParams) (err error, errMsg
 	edbInfo.Extra = req.Extra
 	edbInfo.EmptyType = req.EmptyType
 	edbInfo.MaxEmptyType = req.MaxEmptyType
+	edbInfo.EdbNameEn = req.EdbNameEn
+	edbInfo.UnitEn = req.UnitEn
 	edbInfo.ModifyTime = time.Now()
-	_, err = to.Update(edbInfo, "EdbName", "EdbNameSource", "Frequency", "Unit", "ClassifyId", "CalculateFormula", "Extra", "EmptyType", "MaxEmptyType", "ModifyTime")
+	_, err = to.Update(edbInfo, "EdbName", "EdbNameSource", "Frequency", "Unit", "ClassifyId", "CalculateFormula", "Extra", "EmptyType", "MaxEmptyType", "ModifyTime", "EdbNameEn", "UnitEn")
 	if err != nil {
 		return
 	}

models/edb_data_calculate_bp.go

@@ -42,6 +42,8 @@ func AddCalculateBp(req *EdbInfoCalculateBatchSaveReq, fromEdbInfo *EdbInfo, edb
 		edbInfo.ModifyTime = time.Now()
 		edbInfo.UniqueCode = uniqueCode
 		edbInfo.CalculateFormula = req.Formula
+		edbInfo.EdbNameEn = req.EdbName
+		edbInfo.UnitEn = req.Unit
 		edbInfo.EdbType = 2
 		newEdbInfoId, tmpErr := to.Insert(edbInfo)
 		if tmpErr != nil {
@@ -114,8 +116,10 @@ func EditCalculateBp(edbInfo *EdbInfo, req *EdbInfoCalculateBatchEditReq, fromEd
 	edbInfo.Frequency = req.Frequency
 	edbInfo.Unit = req.Unit
 	edbInfo.ClassifyId = req.ClassifyId
+	edbInfo.EdbNameEn = req.EdbNameEn
+	edbInfo.UnitEn = req.UnitEn
 	edbInfo.ModifyTime = time.Now()
-	_, err = to.Update(edbInfo, "EdbName", "EdbNameSource", "Frequency", "Unit", "ClassifyId", "ModifyTime")
+	_, err = to.Update(edbInfo, "EdbName", "EdbNameSource", "Frequency", "Unit", "ClassifyId", "ModifyTime", "EdbNameEn", "UnitEn")
 	if err != nil {
 		return
 	}

models/edb_data_calculate_cjjx.go

@@ -45,6 +45,8 @@ func AddCalculateCjjx(req *EdbInfoCalculateBatchSaveReq, fromEdbInfo *EdbInfo, e
 		edbInfo.UniqueCode = uniqueCode
 		edbInfo.CalculateFormula = req.Formula
 		edbInfo.Calendar = req.Calendar
+		edbInfo.EdbNameEn = req.EdbName
+		edbInfo.UnitEn = req.Unit
 		edbInfo.EdbType = 2
 		newEdbInfoId, tmpErr := to.Insert(edbInfo)
 		if tmpErr != nil {
@@ -127,8 +129,10 @@ func EditCalculateCjjx(req *EdbInfoCalculateBatchEditReq, edbInfo, fromEdbInfo *
 	edbInfo.ClassifyId = req.ClassifyId
 	edbInfo.CalculateFormula = req.Formula
 	edbInfo.Calendar = req.Calendar
+	edbInfo.EdbNameEn = req.EdbNameEn
+	edbInfo.UnitEn = req.UnitEn
 	edbInfo.ModifyTime = time.Now()
-	_, err = to.Update(edbInfo, "EdbName", "EdbNameSource", "Frequency", "Unit", "ClassifyId", "CalculateFormula", "Calendar", "ModifyTime")
+	_, err = to.Update(edbInfo, "EdbName", "EdbNameSource", "Frequency", "Unit", "ClassifyId", "CalculateFormula", "Calendar", "ModifyTime", "EdbNameEn", "UnitEn")
 	if err != nil {
 		return
 	}

models/edb_data_calculate_correlation.go

@@ -47,6 +47,8 @@ func AddCalculateCorrelation(req *EdbInfoCalculateBatchSaveReq, edbCode, uniqueC
 	edbInfo.ModifyTime = time.Now()
 	edbInfo.UniqueCode = uniqueCode
 	edbInfo.CalculateFormula = req.Formula
+	edbInfo.EdbNameEn = req.EdbName
+	edbInfo.UnitEn = req.Unit
 	edbInfo.EdbType = 2
 	newEdbInfoId, tmpErr := to.Insert(edbInfo)
 	if tmpErr != nil {
@@ -135,8 +137,10 @@ func EditCalculateCorrelation(edbInfo *EdbInfo, req *EdbInfoCalculateBatchEditRe
 	edbInfo.Unit = req.Unit
 	edbInfo.ClassifyId = req.ClassifyId
 	edbInfo.CalculateFormula = req.Formula
+	edbInfo.EdbNameEn = req.EdbNameEn
+	edbInfo.UnitEn = req.UnitEn
 	edbInfo.ModifyTime = time.Now()
-	_, err = to.Update(edbInfo, "EdbName", "EdbNameSource", "Frequency", "Unit", "ClassifyId", "CalculateFormula", "ModifyTime")
+	_, err = to.Update(edbInfo, "EdbName", "EdbNameSource", "Frequency", "Unit", "ClassifyId", "CalculateFormula", "ModifyTime", "EdbNameEn", "UnitEn")
 	if err != nil {
 		return
 	}

models/edb_data_calculate_hbz.go

@@ -42,6 +42,8 @@ func AddCalculateHbz(req *EdbInfoCalculateBatchSaveReq, fromEdbInfo *EdbInfo, ed
 		edbInfo.ModifyTime = time.Now()
 		edbInfo.UniqueCode = uniqueCode
 		edbInfo.CalculateFormula = req.Formula
+		edbInfo.EdbNameEn = req.EdbName
+		edbInfo.UnitEn = req.Unit
 		edbInfo.EdbType = 2
 		newEdbInfoId, tmpErr := to.Insert(edbInfo)
 		if tmpErr != nil {
@@ -114,8 +116,10 @@ func EditCalculateHbz(edbInfo *EdbInfo, req *EdbInfoCalculateBatchEditReq, fromE
 	edbInfo.Unit = req.Unit
 	edbInfo.ClassifyId = req.ClassifyId
 	edbInfo.CalculateFormula = req.Formula
+	edbInfo.EdbNameEn = req.EdbNameEn
+	edbInfo.UnitEn = req.UnitEn
 	edbInfo.ModifyTime = time.Now()
-	_, err = to.Update(edbInfo, "EdbName", "EdbNameSource", "Frequency", "Unit", "ClassifyId", "CalculateFormula", "ModifyTime")
+	_, err = to.Update(edbInfo, "EdbName", "EdbNameSource", "Frequency", "Unit", "ClassifyId", "CalculateFormula", "ModifyTime", "EdbNameEn", "UnitEn")
 	if err != nil {
 		return
 	}

models/edb_data_calculate_hcz.go

@@ -42,6 +42,8 @@ func AddCalculateHcz(req *EdbInfoCalculateBatchSaveReq, fromEdbInfo *EdbInfo, ed
 		edbInfo.ModifyTime = time.Now()
 		edbInfo.UniqueCode = uniqueCode
 		edbInfo.CalculateFormula = req.Formula
+		edbInfo.EdbNameEn = req.EdbName
+		edbInfo.UnitEn = req.Unit
 		edbInfo.EdbType = 2
 		newEdbInfoId, tmpErr := to.Insert(edbInfo)
 		if tmpErr != nil {
@@ -115,8 +117,10 @@ func EditCalculateHcz(edbInfo *EdbInfo, req *EdbInfoCalculateBatchEditReq, fromE
 	edbInfo.Unit = req.Unit
 	edbInfo.ClassifyId = req.ClassifyId
 	edbInfo.CalculateFormula = req.Formula
+	edbInfo.EdbNameEn = req.EdbNameEn
+	edbInfo.UnitEn = req.UnitEn
 	edbInfo.ModifyTime = time.Now()
-	_, err = to.Update(edbInfo, "EdbName", "EdbNameSource", "Frequency", "Unit", "ClassifyId", "CalculateFormula", "ModifyTime")
+	_, err = to.Update(edbInfo, "EdbName", "EdbNameSource", "Frequency", "Unit", "ClassifyId", "CalculateFormula", "ModifyTime", "EdbNameEn", "UnitEn")
 	if err != nil {
 		return
 	}

models/edb_data_calculate_jp.go

@@ -69,6 +69,8 @@ func AddCalculateJp(req *EdbInfoCalculateBatchSaveReq, fromEdbInfo *EdbInfo, edb
 		edbInfo.ModifyTime = time.Now()
 		edbInfo.UniqueCode = uniqueCode
 		edbInfo.CalculateFormula = req.Formula
+		edbInfo.EdbNameEn = req.EdbName
+		edbInfo.UnitEn = req.Unit
 		edbInfo.EdbType = 2
 		newEdbInfoId, tmpErr := to.Insert(edbInfo)
 		if tmpErr != nil {
@@ -142,8 +144,10 @@ func EditCalculateJp(edbInfo *EdbInfo, req *EdbInfoCalculateBatchEditReq, fromEd
 	edbInfo.Unit = req.Unit
 	edbInfo.ClassifyId = req.ClassifyId
 	edbInfo.CalculateFormula = req.Formula
+	edbInfo.EdbNameEn = req.EdbNameEn
+	edbInfo.UnitEn = req.UnitEn
 	edbInfo.ModifyTime = time.Now()
-	_, err = to.Update(edbInfo, "EdbName", "EdbNameSource", "Frequency", "Unit", "ClassifyId", "CalculateFormula", "ModifyTime")
+	_, err = to.Update(edbInfo, "EdbName", "EdbNameSource", "Frequency", "Unit", "ClassifyId", "CalculateFormula", "ModifyTime", "EdbNameEn", "UnitEn")
 	if err != nil {
 		return
 	}

models/edb_data_calculate_kszs.go

@@ -47,6 +47,8 @@ func AddCalculateKszs(req *EdbInfoCalculateBatchSaveReq, edbCode, uniqueCode str
 	edbInfo.ModifyTime = time.Now()
 	edbInfo.UniqueCode = uniqueCode
 	edbInfo.CalculateFormula = req.Formula
+	edbInfo.EdbNameEn = req.EdbName
+	edbInfo.UnitEn = req.Unit
 	edbInfo.EdbType = 2
 	newEdbInfoId, tmpErr := to.Insert(edbInfo)
 	if tmpErr != nil {
@@ -120,8 +122,10 @@ func EditCalculateKszs(edbInfo *EdbInfo, req *EdbInfoCalculateBatchEditReq) (err
 	edbInfo.Unit = req.Unit
 	edbInfo.ClassifyId = req.ClassifyId
 	edbInfo.CalculateFormula = req.Formula
+	edbInfo.EdbNameEn = req.EdbNameEn
+	edbInfo.UnitEn = req.UnitEn
 	edbInfo.ModifyTime = time.Now()
-	_, err = to.Update(edbInfo, "EdbName", "EdbNameSource", "Frequency", "Unit", "ClassifyId", "CalculateFormula", "ModifyTime")
+	_, err = to.Update(edbInfo, "EdbName", "EdbNameSource", "Frequency", "Unit", "ClassifyId", "CalculateFormula", "ModifyTime", "EdbNameEn", "UnitEn")
 	if err != nil {
 		return
 	}

models/edb_data_calculate_ljz.go

@@ -75,8 +75,8 @@ func (obj Ljz) Add(params AddCalculateBatchParams) (edbInfo *EdbInfo, err error,
 		NoUpdate:         0,
 		ServerUrl:        "",
 		EdbInfoType:      0,
-		EdbNameEn:        "",
-		UnitEn:           "",
+		EdbNameEn:        req.EdbName,
+		UnitEn:           req.Unit,
 		LatestDate:       "",
 		LatestValue:      0,
 		ChartImage:       "",
@@ -164,8 +164,10 @@ func (obj Ljz) Edit(params EditCalculateBatchParams) (err error, errMsg string)
 	edbInfo.Unit = req.Unit
 	edbInfo.ClassifyId = req.ClassifyId
 	edbInfo.Extra = req.Extra
+	edbInfo.EdbNameEn = req.EdbNameEn
+	edbInfo.UnitEn = req.UnitEn
 	edbInfo.ModifyTime = time.Now()
-	_, err = to.Update(edbInfo, "EdbName", "EdbNameSource", "Frequency", "Unit", "ClassifyId", "ModifyTime", "Extra")
+	_, err = to.Update(edbInfo, "EdbName", "EdbNameSource", "Frequency", "Unit", "ClassifyId", "ModifyTime", "Extra", "EdbNameEn", "UnitEn")
 	if err != nil {
 		return
 	}

models/edb_data_calculate_ljznczj.go

@@ -74,8 +74,8 @@ func (obj LjzNczj) Add(params AddCalculateBatchParams) (edbInfo *EdbInfo, err er
 		NoUpdate:         0,
 		ServerUrl:        "",
 		EdbInfoType:      0,
-		EdbNameEn:        "",
-		UnitEn:           "",
+		EdbNameEn:        req.EdbName,
+		UnitEn:           req.Unit,
 		LatestDate:       "",
 		LatestValue:      0,
 		ChartImage:       "",
@@ -161,8 +161,10 @@ func (obj LjzNczj) Edit(params EditCalculateBatchParams) (err error, errMsg stri
 	edbInfo.Frequency = req.Frequency
 	edbInfo.Unit = req.Unit
 	edbInfo.ClassifyId = req.ClassifyId
+	edbInfo.EdbNameEn = req.EdbNameEn
+	edbInfo.UnitEn = req.UnitEn
 	edbInfo.ModifyTime = time.Now()
-	_, err = to.Update(edbInfo, "EdbName", "EdbNameSource", "Frequency", "Unit", "ClassifyId", "ModifyTime")
+	_, err = to.Update(edbInfo, "EdbName", "EdbNameSource", "Frequency", "Unit", "ClassifyId", "ModifyTime", "EdbNameEn", "UnitEn")
 	if err != nil {
 		return
 	}

models/edb_data_calculate_ljztbpj.go

@@ -99,6 +99,8 @@ func AddCalculateLjztbpj(req *EdbInfoCalculateBatchSaveReq, firstEdbInfo, second
 			CreateTime:       time.Now(),
 			ModifyTime:       time.Now(),
 			CalculateFormula: lastDateTime.Format(utils.FormatDate),
+			EdbNameEn:        req.EdbName,
+			UnitEn:           req.Unit,
 			EdbType:          2,
 		}
 		newEdbInfoId, tmpErr := to.Insert(edbInfo)
@@ -229,8 +231,10 @@ func EditCalculateLjztbpj(req *EdbInfoCalculateBatchEditReq, edbInfo, firstEdbIn
 	edbInfo.Unit = req.Unit
 	edbInfo.ClassifyId = req.ClassifyId
 	//edbInfo.CalculateFormula = req.Formula
+	edbInfo.EdbNameEn = req.EdbNameEn
+	edbInfo.UnitEn = req.UnitEn
 	edbInfo.ModifyTime = time.Now()
-	_, err = to.Update(edbInfo, "EdbName", "EdbNameSource", "Frequency", "Unit", "ClassifyId", "ModifyTime")
+	_, err = to.Update(edbInfo, "EdbName", "EdbNameSource", "Frequency", "Unit", "ClassifyId", "ModifyTime", "EdbNameEn", "UnitEn")
 	if err != nil {
 		return
 	}

models/edb_data_calculate_ljzzj.go

@@ -55,6 +55,8 @@ func (obj Ljzzj) Add(params AddCalculateBatchParams) (edbInfo *EdbInfo, err erro
 	edbInfo.ModifyTime = time.Now()
 	edbInfo.UniqueCode = params.UniqueCode
 	edbInfo.CalculateFormula = req.Formula
+	edbInfo.EdbNameEn = req.EdbName
+	edbInfo.UnitEn = req.Unit
 	edbInfo.EdbType = obj.GetEdbType()
 	newEdbInfoId, tmpErr := to.Insert(edbInfo)
 	if tmpErr != nil {
@@ -124,8 +126,10 @@ func (obj Ljzzj) Edit(params EditCalculateBatchParams) (err error, errMsg string
 	edbInfo.Frequency = req.Frequency
 	edbInfo.Unit = req.Unit
 	edbInfo.ClassifyId = req.ClassifyId
+	edbInfo.EdbNameEn = req.EdbNameEn
+	edbInfo.UnitEn = req.UnitEn
 	edbInfo.ModifyTime = time.Now()
-	_, err = to.Update(edbInfo, "EdbName", "EdbNameSource", "Frequency", "Unit", "ClassifyId", "ModifyTime")
+	_, err = to.Update(edbInfo, "EdbName", "EdbNameSource", "Frequency", "Unit", "ClassifyId", "ModifyTime", "EdbNameEn", "UnitEn")
 	if err != nil {
 		return
 	}

models/edb_data_calculate_ljzzy.go

@@ -43,6 +43,8 @@ func AddCalculateLjzzy(req *EdbInfoCalculateBatchSaveReq, fromEdbInfo *EdbInfo,
 		edbInfo.ModifyTime = time.Now()
 		edbInfo.UniqueCode = uniqueCode
 		edbInfo.CalculateFormula = req.Formula
+		edbInfo.EdbNameEn = req.EdbName
+		edbInfo.UnitEn = req.Unit
 		edbInfo.EdbType = 2
 		newEdbInfoId, tmpErr := to.Insert(edbInfo)
 		if tmpErr != nil {
@@ -111,12 +113,16 @@ func EditCalculateLjzzy(edbInfo *EdbInfo, req *EdbInfoCalculateBatchEditReq, fro
 
 	//修改指标信息
 	edbInfo.EdbName = req.EdbName
+	edbInfo.EdbNameEn = req.EdbNameEn
+	edbInfo.UnitEn = req.UnitEn
 	edbInfo.EdbNameSource = req.EdbName
 	edbInfo.Frequency = req.Frequency
 	edbInfo.Unit = req.Unit
 	edbInfo.ClassifyId = req.ClassifyId
+	edbInfo.EdbNameEn = req.EdbNameEn
+	edbInfo.UnitEn = req.UnitEn
 	edbInfo.ModifyTime = time.Now()
-	_, err = to.Update(edbInfo, "EdbName", "EdbNameSource", "Frequency", "Unit", "ClassifyId", "ModifyTime")
+	_, err = to.Update(edbInfo, "EdbName", "EdbNameSource", "Frequency", "Unit", "ClassifyId", "ModifyTime", "EdbNameEn", "UnitEn")
 	if err != nil {
 		return
 	}

models/edb_data_calculate_nh.go

@@ -42,6 +42,8 @@ func AddCalculateNh(req *EdbInfoCalculateBatchSaveReq, fromEdbInfo *EdbInfo, edb
 		edbInfo.ModifyTime = time.Now()
 		edbInfo.UniqueCode = uniqueCode
 		edbInfo.CalculateFormula = req.Formula
+		edbInfo.EdbNameEn = req.EdbName
+		edbInfo.UnitEn = req.Unit
 		edbInfo.EdbType = 2
 		newEdbInfoId, tmpErr := to.Insert(edbInfo)
 		if tmpErr != nil {
@@ -115,8 +117,10 @@ func EditCalculateNh(edbInfo *EdbInfo, req *EdbInfoCalculateBatchEditReq, fromEd
 	edbInfo.Unit = req.Unit
 	edbInfo.ClassifyId = req.ClassifyId
 	edbInfo.CalculateFormula = req.Formula
+	edbInfo.EdbNameEn = req.EdbNameEn
+	edbInfo.UnitEn = req.UnitEn
 	edbInfo.ModifyTime = time.Now()
-	_, err = to.Update(edbInfo, "EdbName", "EdbNameSource", "Frequency", "Unit", "ClassifyId", "CalculateFormula", "ModifyTime")
+	_, err = to.Update(edbInfo, "EdbName", "EdbNameSource", "Frequency", "Unit", "ClassifyId", "CalculateFormula", "ModifyTime", "EdbNameEn", "UnitEn")
 	if err != nil {
 		return
 	}

models/edb_data_calculate_nhcc.go

@@ -63,6 +63,8 @@ func AddCalculateNhcc(req *EdbInfoCalculateBatchSaveReq, firstEdbInfo, secondEdb
 			CreateTime:       time.Now(),
 			ModifyTime:       time.Now(),
 			CalculateFormula: req.Formula,
+			EdbNameEn:        req.EdbName,
+			UnitEn:           req.Unit,
 			EdbType:          2,
 		}
 		newEdbInfoId, tmpErr := to.Insert(edbInfo)
@@ -195,8 +197,10 @@ func EditCalculateNhcc(req *EdbInfoCalculateBatchEditReq, edbInfo, firstEdbInfo,
 	edbInfo.Unit = req.Unit
 	edbInfo.ClassifyId = req.ClassifyId
 	edbInfo.CalculateFormula = req.Formula
+	edbInfo.EdbNameEn = req.EdbNameEn
+	edbInfo.UnitEn = req.UnitEn
 	edbInfo.ModifyTime = time.Now()
-	_, err = to.Update(edbInfo, "EdbName", "EdbNameSource", "Frequency", "Unit", "ClassifyId", "CalculateFormula", "ModifyTime")
+	_, err = to.Update(edbInfo, "EdbName", "EdbNameSource", "Frequency", "Unit", "ClassifyId", "CalculateFormula", "ModifyTime", "EdbNameEn", "UnitEn")
 	if err != nil {
 		return
 	}

models/edb_data_calculate_nszydbpjjs.go

@@ -39,6 +39,8 @@ func AddCalculateNszydpjjs(req *EdbInfoCalculateBatchSaveReq, fromEdbInfo *EdbIn
 		edbInfo.ModifyTime = time.Now()
 		edbInfo.UniqueCode = uniqueCode
 		edbInfo.CalculateFormula = req.Formula
+		edbInfo.EdbNameEn = req.EdbName
+		edbInfo.UnitEn = req.Unit
 		edbInfo.EdbType = 2
 		newEdbInfoId, tmpErr := to.Insert(edbInfo)
 		if tmpErr != nil {
@@ -108,8 +110,10 @@ func EditCalculateNszydpjjs(edbInfo *EdbInfo, req *EdbInfoCalculateBatchEditReq,
 	edbInfo.Unit = req.Unit
 	edbInfo.ClassifyId = req.ClassifyId
 	edbInfo.CalculateFormula = req.Formula
+	edbInfo.EdbNameEn = req.EdbNameEn
+	edbInfo.UnitEn = req.UnitEn
 	edbInfo.ModifyTime = time.Now()
-	_, err = to.Update(edbInfo, "EdbName", "EdbNameSource", "Frequency", "Unit", "ClassifyId", "CalculateFormula", "ModifyTime")
+	_, err = to.Update(edbInfo, "EdbName", "EdbNameSource", "Frequency", "Unit", "ClassifyId", "CalculateFormula", "ModifyTime", "EdbNameEn", "UnitEn")
 	if err != nil {
 		return
 	}

models/edb_data_calculate_percentile.go

@@ -51,6 +51,8 @@ func (obj Percentile) Add(params AddCalculateBatchParams) (edbInfo *EdbInfo, err
 	edbInfo.ModifyTime = time.Now()
 	edbInfo.UniqueCode = params.UniqueCode
 	edbInfo.CalculateFormula = req.Formula
+	edbInfo.EdbNameEn = req.EdbName
+	edbInfo.UnitEn = req.Unit
 	edbInfo.EdbType = obj.GetEdbType()
 	newEdbInfoId, tmpErr := to.Insert(edbInfo)
 	if tmpErr != nil {
@@ -118,8 +120,10 @@ func (obj Percentile) Edit(params EditCalculateBatchParams) (err error, errMsg s
 	edbInfo.Unit = req.Unit
 	edbInfo.ClassifyId = req.ClassifyId
 	edbInfo.CalculateFormula = req.Formula
+	edbInfo.EdbNameEn = req.EdbNameEn
+	edbInfo.UnitEn = req.UnitEn
 	edbInfo.ModifyTime = time.Now()
-	_, err = to.Update(edbInfo, "EdbName", "EdbNameSource", "Frequency", "Unit", "ClassifyId", "CalculateFormula", "ModifyTime")
+	_, err = to.Update(edbInfo, "EdbName", "EdbNameSource", "Frequency", "Unit", "ClassifyId", "CalculateFormula", "ModifyTime", "EdbNameEn", "UnitEn")
 	if err != nil {
 		return
 	}

models/edb_data_calculate_rjz.go

@@ -42,6 +42,8 @@ func AddCalculateRjz(req *EdbInfoCalculateBatchSaveReq, fromEdbInfo *EdbInfo, ed
 		edbInfo.ModifyTime = time.Now()
 		edbInfo.UniqueCode = uniqueCode
 		edbInfo.CalculateFormula = req.Formula
+		edbInfo.EdbNameEn = req.EdbName
+		edbInfo.UnitEn = req.Unit
 		edbInfo.EdbType = 2
 		newEdbInfoId, tmpErr := to.Insert(edbInfo)
 		if tmpErr != nil {
@@ -115,8 +117,10 @@ func EditCalculateRjz(edbInfo *EdbInfo, req *EdbInfoCalculateBatchEditReq, fromE
 	edbInfo.Frequency = req.Frequency
 	edbInfo.Unit = req.Unit
 	edbInfo.ClassifyId = req.ClassifyId
+	edbInfo.EdbNameEn = req.EdbNameEn
+	edbInfo.UnitEn = req.UnitEn
 	edbInfo.ModifyTime = time.Now()
-	_, err = to.Update(edbInfo, "EdbName", "EdbNameSource", "Frequency", "Unit", "ClassifyId", "ModifyTime")
+	_, err = to.Update(edbInfo, "EdbName", "EdbNameSource", "Frequency", "Unit", "ClassifyId", "ModifyTime", "EdbNameEn", "UnitEn")
 	if err != nil {
 		return
 	}

models/edb_data_calculate_standard_deviation.go

@@ -50,6 +50,8 @@ func (obj StandardDeviation) Add(params AddCalculateBatchParams) (edbInfo *EdbIn
 	edbInfo.ModifyTime = time.Now()
 	edbInfo.UniqueCode = params.UniqueCode
 	edbInfo.CalculateFormula = req.Formula
+	edbInfo.EdbNameEn = req.EdbName
+	edbInfo.UnitEn = req.Unit
 	edbInfo.EdbType = obj.GetEdbType()
 	newEdbInfoId, tmpErr := to.Insert(edbInfo)
 	if tmpErr != nil {
@@ -117,8 +119,10 @@ func (obj StandardDeviation) Edit(params EditCalculateBatchParams) (err error, e
 	edbInfo.Unit = req.Unit
 	edbInfo.ClassifyId = req.ClassifyId
 	edbInfo.CalculateFormula = req.Formula
+	edbInfo.EdbNameEn = req.EdbNameEn
+	edbInfo.UnitEn = req.UnitEn
 	edbInfo.ModifyTime = time.Now()
-	_, err = to.Update(edbInfo, "EdbName", "EdbNameSource", "Frequency", "Unit", "ClassifyId", "CalculateFormula", "ModifyTime")
+	_, err = to.Update(edbInfo, "EdbName", "EdbNameSource", "Frequency", "Unit", "ClassifyId", "CalculateFormula", "ModifyTime", "EdbNameEn", "UnitEn")
 	if err != nil {
 		return
 	}

models/edb_data_calculate_sum.go

@@ -57,6 +57,8 @@ func (obj CalculateSum) Add(params AddCalculateBatchParams) (edbInfo *EdbInfo, e
 	edbInfo.EmptyType = req.EmptyType
 	edbInfo.MaxEmptyType = req.MaxEmptyType
 	edbInfo.Extra = req.Extra
+	edbInfo.EdbNameEn = req.EdbName
+	edbInfo.UnitEn = req.Unit
 	newEdbInfoId, tmpErr := to.Insert(edbInfo)
 	if tmpErr != nil {
 		errMsg = "新增失败"
@@ -145,8 +147,10 @@ func (obj CalculateSum) Edit(params EditCalculateBatchParams) (err error, errMsg
 	edbInfo.Extra = req.Extra
 	edbInfo.EmptyType = req.EmptyType
 	edbInfo.MaxEmptyType = req.MaxEmptyType
+	edbInfo.EdbNameEn = req.EdbNameEn
+	edbInfo.UnitEn = req.UnitEn
 	edbInfo.ModifyTime = time.Now()
-	_, err = to.Update(edbInfo, "EdbName", "EdbNameSource", "Frequency", "Unit", "ClassifyId", "CalculateFormula", "Extra", "EmptyType", "MaxEmptyType", "ModifyTime")
+	_, err = to.Update(edbInfo, "EdbName", "EdbNameSource", "Frequency", "Unit", "ClassifyId", "CalculateFormula", "Extra", "EmptyType", "MaxEmptyType", "ModifyTime", "EdbNameEn", "UnitEn")
 	if err != nil {
 		return
 	}

models/edb_data_calculate_tbz.go

@@ -42,6 +42,8 @@ func AddCalculateTbz(req *EdbInfoCalculateBatchSaveReq, fromEdbInfo *EdbInfo, ed
 		edbInfo.ModifyTime = time.Now()
 		edbInfo.UniqueCode = uniqueCode
 		edbInfo.CalculateFormula = req.Formula
+		edbInfo.EdbNameEn = req.EdbName
+		edbInfo.UnitEn = req.Unit
 		edbInfo.EdbType = 2
 		newEdbInfoId, tmpErr := to.Insert(edbInfo)
 		if tmpErr != nil {
@@ -115,8 +117,10 @@ func EditCalculateTbz(edbInfo *EdbInfo, req *EdbInfoCalculateBatchEditReq, fromE
 	edbInfo.Frequency = req.Frequency
 	edbInfo.Unit = req.Unit
 	edbInfo.ClassifyId = req.ClassifyId
+	edbInfo.EdbNameEn = req.EdbNameEn
+	edbInfo.UnitEn = req.UnitEn
 	edbInfo.ModifyTime = time.Now()
-	_, err = to.Update(edbInfo, "EdbName", "EdbNameSource", "Frequency", "Unit", "ClassifyId", "ModifyTime")
+	_, err = to.Update(edbInfo, "EdbName", "EdbNameSource", "Frequency", "Unit", "ClassifyId", "ModifyTime", "EdbNameEn", "UnitEn")
 	if err != nil {
 		return
 	}

models/edb_data_calculate_tcz.go

@@ -43,6 +43,8 @@ func AddCalculateTcz(req *EdbInfoCalculateBatchSaveReq, fromEdbInfo *EdbInfo, ed
 		edbInfo.ModifyTime = time.Now()
 		edbInfo.UniqueCode = uniqueCode
 		edbInfo.CalculateFormula = req.Formula
+		edbInfo.EdbNameEn = req.EdbName
+		edbInfo.UnitEn = req.Unit
 		edbInfo.EdbType = 2
 		newEdbInfoId, tmpErr := to.Insert(edbInfo)
 		if tmpErr != nil {
@@ -116,8 +118,10 @@ func EditCalculateTcz(edbInfo *EdbInfo, req *EdbInfoCalculateBatchEditReq, fromE
 	edbInfo.Frequency = req.Frequency
 	edbInfo.Unit = req.Unit
 	edbInfo.ClassifyId = req.ClassifyId
+	edbInfo.EdbNameEn = req.EdbNameEn
+	edbInfo.UnitEn = req.UnitEn
 	edbInfo.ModifyTime = time.Now()
-	_, err = to.Update(edbInfo, "EdbName", "EdbNameSource", "Frequency", "Unit", "ClassifyId", "ModifyTime")
+	_, err = to.Update(edbInfo, "EdbName", "EdbNameSource", "Frequency", "Unit", "ClassifyId", "ModifyTime", "EdbNameEn", "UnitEn")
 	if err != nil {
 		return
 	}

models/edb_data_calculate_time_shift.go

@@ -43,6 +43,8 @@ func AddCalculateTimeShift(req *EdbInfoCalculateBatchSaveReq, fromEdbInfo *EdbIn
 		edbInfo.ModifyTime = time.Now()
 		edbInfo.UniqueCode = uniqueCode
 		edbInfo.CalculateFormula = req.Formula
+		edbInfo.EdbNameEn = req.EdbName
+		edbInfo.UnitEn = req.Unit
 		edbInfo.EdbType = 2
 		edbInfo.MoveType = req.MoveType
 		edbInfo.MoveFrequency = req.MoveFrequency
@@ -124,8 +126,10 @@ func EditCalculateTimeShift(edbInfo *EdbInfo, req *EdbInfoCalculateBatchEditReq,
 	edbInfo.MoveType = req.MoveType
 	edbInfo.MoveFrequency = req.MoveFrequency
 	edbInfo.CalculateFormula = req.Formula
+	edbInfo.EdbNameEn = req.EdbNameEn
+	edbInfo.UnitEn = req.UnitEn
 	edbInfo.ModifyTime = time.Now()
-	_, err = to.Update(edbInfo, "EdbName", "EdbNameSource", "Frequency", "Unit", "ClassifyId", "MoveType", "MoveFrequency", "CalculateFormula", "ModifyTime")
+	_, err = to.Update(edbInfo, "EdbName", "EdbNameSource", "Frequency", "Unit", "ClassifyId", "MoveType", "MoveFrequency", "CalculateFormula", "ModifyTime", "EdbNameEn", "UnitEn")
 	if err != nil {
 		return
 	}

models/edb_data_calculate_zdyfx.go

@@ -69,6 +69,8 @@ func (obj CustomAnalysis) Add(params AddCalculateBatchParams) (edbInfo *EdbInfo,
 	edbInfo.ModifyTime = time.Now()
 	edbInfo.UniqueCode = params.UniqueCode
 	edbInfo.CalculateFormula = req.Formula
+	edbInfo.EdbNameEn = req.EdbName
+	edbInfo.UnitEn = req.Unit
 	edbInfo.EdbType = 2
 	newEdbInfoId, tmpErr := to.Insert(edbInfo)
 	if tmpErr != nil {
@@ -134,8 +136,10 @@ func (obj CustomAnalysis) Edit(params EditCalculateBatchParams) (err error, errM
 	edbInfo.Unit = req.Unit
 	edbInfo.ClassifyId = req.ClassifyId
 	edbInfo.CalculateFormula = req.Formula
+	edbInfo.EdbNameEn = req.EdbNameEn
+	edbInfo.UnitEn = req.UnitEn
 	edbInfo.ModifyTime = time.Now()
-	_, err = to.Update(edbInfo, "EdbName", "EdbNameSource", "Frequency", "Unit", "ClassifyId", "CalculateFormula", "ModifyTime")
+	_, err = to.Update(edbInfo, "EdbName", "EdbNameSource", "Frequency", "Unit", "ClassifyId", "CalculateFormula", "ModifyTime", "EdbNameEn", "UnitEn")
 	if err != nil {
 		return
 	}

models/edb_data_calculate_zjpj.go

@@ -54,6 +54,8 @@ func AddCalculateZjpj(req *EdbInfoCalculateBatchSaveReq, firstEdbInfo, secondEdb
 			CreateTime:       time.Now(),
 			ModifyTime:       time.Now(),
 			CalculateFormula: req.Formula,
+			EdbNameEn:        req.EdbName,
+			UnitEn:           req.Unit,
 			EdbType:          2,
 		}
 		newEdbInfoId, tmpErr := to.Insert(edbInfo)
@@ -184,8 +186,10 @@ func EditCalculateZjpj(req *EdbInfoCalculateBatchEditReq, edbInfo, firstEdbInfo,
 	edbInfo.Unit = req.Unit
 	edbInfo.ClassifyId = req.ClassifyId
 	edbInfo.CalculateFormula = req.Formula
+	edbInfo.EdbNameEn = req.EdbNameEn
+	edbInfo.UnitEn = req.UnitEn
 	edbInfo.ModifyTime = time.Now()
-	_, err = to.Update(edbInfo, "EdbName", "EdbNameSource", "Frequency", "Unit", "ClassifyId", "CalculateFormula", "ModifyTime")
+	_, err = to.Update(edbInfo, "EdbName", "EdbNameSource", "Frequency", "Unit", "ClassifyId", "CalculateFormula", "ModifyTime", "EdbNameEn", "UnitEn")
 	if err != nil {
 		return
 	}

models/edb_data_calculate_zsxy.go

@@ -49,6 +49,8 @@ func (obj ExponentialSmoothing) Add(params AddCalculateBatchParams) (edbInfo *Ed
 	edbInfo.ModifyTime = time.Now()
 	edbInfo.UniqueCode = params.UniqueCode
 	edbInfo.CalculateFormula = req.Formula
+	edbInfo.EdbNameEn = req.EdbName
+	edbInfo.UnitEn = req.Unit
 	edbInfo.EdbType = obj.GetEdbType()
 	newEdbInfoId, tmpErr := to.Insert(edbInfo)
 	if tmpErr != nil {
@@ -115,8 +117,10 @@ func (obj ExponentialSmoothing) Edit(params EditCalculateBatchParams) (err error
 	edbInfo.Unit = req.Unit
 	edbInfo.ClassifyId = req.ClassifyId
 	edbInfo.CalculateFormula = req.Formula
+	edbInfo.EdbNameEn = req.EdbNameEn
+	edbInfo.UnitEn = req.UnitEn
 	edbInfo.ModifyTime = time.Now()
-	_, err = to.Update(edbInfo, "EdbName", "EdbNameSource", "Frequency", "Unit", "ClassifyId", "CalculateFormula", "ModifyTime")
+	_, err = to.Update(edbInfo, "EdbName", "EdbNameSource", "Frequency", "Unit", "ClassifyId", "CalculateFormula", "ModifyTime", "EdbNameEn", "UnitEn")
 	if err != nil {
 		return
 	}

models/predict_edb_data_calculate_bp.go

@@ -12,7 +12,7 @@ import (
 )
 
 // SavePredictCalculateBp 变频
-func SavePredictCalculateBp(req *EdbInfoCalculateBatchSaveReq, fromEdbInfo *EdbInfo, edbCode, uniqueCode string, sysUserId int, sysUserRealName string) (edbInfo *EdbInfo, latestDateStr string, latestValue float64, err error) {
+func SavePredictCalculateBp(req *EdbInfoCalculateBatchSaveReq, fromEdbInfo *EdbInfo, edbCode, uniqueCode string, sysUserId int, sysUserRealName, lang string) (edbInfo *EdbInfo, latestDateStr string, latestValue float64, err error) {
 	o := orm.NewOrm()
 	to, err := o.Begin()
 	if err != nil {
@@ -42,6 +42,8 @@ func SavePredictCalculateBp(req *EdbInfoCalculateBatchSaveReq, fromEdbInfo *EdbI
 		edbInfo.CreateTime = time.Now()
 		edbInfo.ModifyTime = time.Now()
 		edbInfo.UniqueCode = uniqueCode
+		edbInfo.EdbNameEn = req.EdbName
+		edbInfo.UnitEn = req.Unit
 		edbInfo.CalculateFormula = req.Formula
 		edbInfo.EdbType = 2
 		newEdbInfoId, tmpErr := to.Insert(edbInfo)
@@ -79,13 +81,20 @@ func SavePredictCalculateBp(req *EdbInfoCalculateBatchSaveReq, fromEdbInfo *EdbI
 		latestDateStr = edbInfo.LatestDate
 		latestValue = edbInfo.LatestValue
 		//修改指标信息
-		edbInfo.EdbName = req.EdbName
-		edbInfo.EdbNameSource = req.EdbName
+		switch lang {
+		case utils.EnLangVersion:
+			edbInfo.EdbNameEn = req.EdbName
+			edbInfo.UnitEn = req.Unit
+		default:
+			edbInfo.EdbName = req.EdbName
+			edbInfo.Unit = req.Unit
+			edbInfo.EdbNameSource = req.EdbName
+		}
+
 		edbInfo.Frequency = req.Frequency
-		edbInfo.Unit = req.Unit
 		edbInfo.ClassifyId = req.ClassifyId
 		edbInfo.ModifyTime = time.Now()
-		_, err = to.Update(edbInfo, "EdbName", "EdbNameSource", "Frequency", "Unit", "ClassifyId", "ModifyTime")
+		_, err = to.Update(edbInfo, "EdbName", "EdbNameSource", "Frequency", "Unit", "ClassifyId", "ModifyTime", "EdbNameEn", "UnitEn")
 		if err != nil {
 			return
 		}

models/predict_edb_data_calculate_cjjx.go

@@ -12,7 +12,7 @@ import (
 )
 
 // SavePredictCalculateCjjx 超季节性
-func SavePredictCalculateCjjx(req *EdbInfoCalculateBatchSaveReq, fromEdbInfo *EdbInfo, edbCode, uniqueCode string, sysUserId int, sysUserRealName string, formulaInt int) (edbInfo *EdbInfo, latestDateStr string, latestValue float64, err error) {
+func SavePredictCalculateCjjx(req *EdbInfoCalculateBatchSaveReq, fromEdbInfo *EdbInfo, edbCode, uniqueCode string, sysUserId int, sysUserRealName string, formulaInt int, lang string) (edbInfo *EdbInfo, latestDateStr string, latestValue float64, err error) {
 	o := orm.NewOrm()
 	to, err := o.Begin()
 	if err != nil {
@@ -45,6 +45,8 @@ func SavePredictCalculateCjjx(req *EdbInfoCalculateBatchSaveReq, fromEdbInfo *Ed
 		edbInfo.UniqueCode = uniqueCode
 		edbInfo.CalculateFormula = req.Formula
 		edbInfo.Calendar = req.Calendar
+		edbInfo.EdbNameEn = req.EdbName
+		edbInfo.UnitEn = req.Unit
 		edbInfo.EdbType = 2
 		newEdbInfoId, tmpErr := to.Insert(edbInfo)
 		if tmpErr != nil {
@@ -88,15 +90,21 @@ func SavePredictCalculateCjjx(req *EdbInfoCalculateBatchSaveReq, fromEdbInfo *Ed
 		latestDateStr = edbInfo.LatestDate
 		latestValue = edbInfo.LatestValue
 		//修改指标信息
-		edbInfo.EdbName = req.EdbName
-		edbInfo.EdbNameSource = req.EdbName
+		switch lang {
+		case utils.EnLangVersion:
+			edbInfo.EdbNameEn = req.EdbName
+			edbInfo.UnitEn = req.Unit
+		default:
+			edbInfo.EdbName = req.EdbName
+			edbInfo.Unit = req.Unit
+			edbInfo.EdbNameSource = req.EdbName
+		}
 		edbInfo.Frequency = req.Frequency
-		edbInfo.Unit = req.Unit
 		edbInfo.ClassifyId = req.ClassifyId
 		edbInfo.CalculateFormula = req.Formula
 		edbInfo.Calendar = req.Calendar
 		edbInfo.ModifyTime = time.Now()
-		_, err = to.Update(edbInfo, "EdbName", "EdbNameSource", "Frequency", "Unit", "ClassifyId", "CalculateFormula", "Calendar", "ModifyTime")
+		_, err = to.Update(edbInfo, "EdbName", "EdbNameSource", "Frequency", "Unit", "ClassifyId", "CalculateFormula", "Calendar", "ModifyTime", "EdbNameEn", "UnitEn")
 		if err != nil {
 			return
 		}

models/predict_edb_data_calculate_hbz.go

@@ -12,7 +12,7 @@ import (
 )
 
 // SavePredictCalculateHbz 新增环比值指标
-func SavePredictCalculateHbz(req *EdbInfoCalculateBatchSaveReq, fromEdbInfo *EdbInfo, edbCode, uniqueCode string, sysUserId int, sysUserRealName string, formulaInt int) (edbInfo *EdbInfo, latestDateStr string, latestValue float64, err error) {
+func SavePredictCalculateHbz(req *EdbInfoCalculateBatchSaveReq, fromEdbInfo *EdbInfo, edbCode, uniqueCode string, sysUserId int, sysUserRealName string, formulaInt int, lang string) (edbInfo *EdbInfo, latestDateStr string, latestValue float64, err error) {
 	o := orm.NewOrm()
 	to, err := o.Begin()
 	if err != nil {
@@ -43,6 +43,8 @@ func SavePredictCalculateHbz(req *EdbInfoCalculateBatchSaveReq, fromEdbInfo *Edb
 		edbInfo.ModifyTime = time.Now()
 		edbInfo.UniqueCode = uniqueCode
 		edbInfo.CalculateFormula = req.Formula
+		edbInfo.EdbNameEn = req.EdbName
+		edbInfo.UnitEn = req.Unit
 		edbInfo.EdbType = 2
 		newEdbInfoId, tmpErr := to.Insert(edbInfo)
 		if tmpErr != nil {
@@ -81,14 +83,20 @@ func SavePredictCalculateHbz(req *EdbInfoCalculateBatchSaveReq, fromEdbInfo *Edb
 		oldCalculateFormula := edbInfo.CalculateFormula
 		dataTableName := GetEdbDataTableName(utils.DATA_SOURCE_PREDICT_CALCULATE_HBZ, utils.DATA_SUB_SOURCE_EDB)
 		//修改指标信息
-		edbInfo.EdbName = req.EdbName
-		edbInfo.EdbNameSource = req.EdbName
+		switch lang {
+		case utils.EnLangVersion:
+			edbInfo.EdbNameEn = req.EdbName
+			edbInfo.UnitEn = req.Unit
+		default:
+			edbInfo.EdbName = req.EdbName
+			edbInfo.Unit = req.Unit
+			edbInfo.EdbNameSource = req.EdbName
+		}
 		edbInfo.Frequency = req.Frequency
-		edbInfo.Unit = req.Unit
 		edbInfo.ClassifyId = req.ClassifyId
 		edbInfo.CalculateFormula = req.Formula
 		edbInfo.ModifyTime = time.Now()
-		_, err = to.Update(edbInfo, "EdbName", "EdbNameSource", "Frequency", "Unit", "ClassifyId", "CalculateFormula", "ModifyTime")
+		_, err = to.Update(edbInfo, "EdbName", "EdbNameSource", "Frequency", "Unit", "ClassifyId", "CalculateFormula", "ModifyTime", "EdbNameEn", "UnitEn")
 		if err != nil {
 			return
 		}

models/predict_edb_data_calculate_hcz.go

@@ -12,7 +12,7 @@ import (
 )
 
 // SavePredictCalculateHcz 新增环差值指标
-func SavePredictCalculateHcz(req *EdbInfoCalculateBatchSaveReq, fromEdbInfo *EdbInfo, edbCode, uniqueCode string, sysUserId int, sysUserRealName string, formulaInt int) (edbInfo *EdbInfo, latestDateStr string, latestValue float64, err error) {
+func SavePredictCalculateHcz(req *EdbInfoCalculateBatchSaveReq, fromEdbInfo *EdbInfo, edbCode, uniqueCode string, sysUserId int, sysUserRealName string, formulaInt int, lang string) (edbInfo *EdbInfo, latestDateStr string, latestValue float64, err error) {
 	o := orm.NewOrm()
 	to, err := o.Begin()
 	if err != nil {
@@ -43,6 +43,8 @@ func SavePredictCalculateHcz(req *EdbInfoCalculateBatchSaveReq, fromEdbInfo *Edb
 		edbInfo.ModifyTime = time.Now()
 		edbInfo.UniqueCode = uniqueCode
 		edbInfo.CalculateFormula = req.Formula
+		edbInfo.EdbNameEn = req.EdbName
+		edbInfo.UnitEn = req.Unit
 		edbInfo.EdbType = 2
 		newEdbInfoId, tmpErr := to.Insert(edbInfo)
 		if tmpErr != nil {
@@ -81,14 +83,20 @@ func SavePredictCalculateHcz(req *EdbInfoCalculateBatchSaveReq, fromEdbInfo *Edb
 		latestValue = edbInfo.LatestValue
 		oldCalculateFormula := edbInfo.CalculateFormula
 		//修改指标信息
-		edbInfo.EdbName = req.EdbName
-		edbInfo.EdbNameSource = req.EdbName
+		switch lang {
+		case utils.EnLangVersion:
+			edbInfo.EdbNameEn = req.EdbName
+			edbInfo.UnitEn = req.Unit
+		default:
+			edbInfo.EdbName = req.EdbName
+			edbInfo.Unit = req.Unit
+			edbInfo.EdbNameSource = req.EdbName
+		}
 		edbInfo.Frequency = req.Frequency
-		edbInfo.Unit = req.Unit
 		edbInfo.ClassifyId = req.ClassifyId
 		edbInfo.CalculateFormula = req.Formula
 		edbInfo.ModifyTime = time.Now()
-		_, err = to.Update(edbInfo, "EdbName", "EdbNameSource", "Frequency", "Unit", "ClassifyId", "CalculateFormula", "ModifyTime")
+		_, err = to.Update(edbInfo, "EdbName", "EdbNameSource", "Frequency", "Unit", "ClassifyId", "CalculateFormula", "ModifyTime", "EdbNameEn", "UnitEn")
 		if err != nil {
 			return
 		}

models/predict_edb_data_calculate_jp.go

@@ -12,7 +12,7 @@ import (
 )
 
 // SavePredictCalculateJp 预测降频值
-func SavePredictCalculateJp(reqEdbInfoId, classifyId int, edbName, frequency, unit, formula string, fromEdbInfo *EdbInfo, edbCode, uniqueCode string, sysUserId int, sysUserRealName string) (edbInfo *EdbInfo, latestDateStr string, latestValue float64, err error, errMsg string) {
+func SavePredictCalculateJp(reqEdbInfoId, classifyId int, edbName, frequency, unit, formula string, fromEdbInfo *EdbInfo, edbCode, uniqueCode string, sysUserId int, sysUserRealName, lang string) (edbInfo *EdbInfo, latestDateStr string, latestValue float64, err error, errMsg string) {
 	o := orm.NewOrm()
 	to, err := o.Begin()
 	if err != nil {
@@ -56,8 +56,8 @@ func SavePredictCalculateJp(reqEdbInfoId, classifyId int, edbName, frequency, un
 			MoveFrequency:    "",
 			NoUpdate:         0,
 			ServerUrl:        "",
-			EdbNameEn:        "",
-			UnitEn:           "",
+			EdbNameEn:        edbName,
+			UnitEn:           unit,
 			LatestDate:       "",
 			LatestValue:      0,
 			ChartImage:       "",
@@ -110,14 +110,20 @@ func SavePredictCalculateJp(reqEdbInfoId, classifyId int, edbName, frequency, un
 		latestValue = edbInfo.LatestValue
 		oldCalculateFormula := edbInfo.CalculateFormula
 		//修改指标信息
-		edbInfo.EdbName = edbName
-		edbInfo.EdbNameSource = edbName
+		switch lang {
+		case utils.EnLangVersion:
+			edbInfo.EdbNameEn = edbName
+			edbInfo.UnitEn = unit
+		default:
+			edbInfo.EdbName = edbName
+			edbInfo.Unit = unit
+			edbInfo.EdbNameSource = edbName
+		}
 		edbInfo.Frequency = frequency
-		edbInfo.Unit = unit
 		edbInfo.ClassifyId = classifyId
 		edbInfo.CalculateFormula = formula
 		edbInfo.ModifyTime = time.Now()
-		_, err = to.Update(edbInfo, "EdbName", "EdbNameSource", "Frequency", "Unit", "ClassifyId", "CalculateFormula", "ModifyTime")
+		_, err = to.Update(edbInfo, "EdbName", "EdbNameSource", "Frequency", "Unit", "ClassifyId", "CalculateFormula", "ModifyTime", "EdbNameEn", "UnitEn")
 		if err != nil {
 			return
 		}

models/predict_edb_data_calculate_kszs.go

@@ -13,7 +13,7 @@ import (
 )
 
 // SavePredictCalculateKszs 预测扩散指数
-func SavePredictCalculateKszs(reqEdbInfoId, classifyId int, edbName, frequency, unit, formula string, relationCalculateEdbInfoIdList []EdbInfoCalculateEdbInfoIdReq, edbCode, uniqueCode string, sysUserId int, sysUserRealName string) (edbInfo *EdbInfo, latestDateStr string, latestValue float64, err error, errMsg string) {
+func SavePredictCalculateKszs(reqEdbInfoId, classifyId int, edbName, frequency, unit, formula string, relationCalculateEdbInfoIdList []EdbInfoCalculateEdbInfoIdReq, edbCode, uniqueCode string, sysUserId int, sysUserRealName, lang string) (edbInfo *EdbInfo, latestDateStr string, latestValue float64, err error, errMsg string) {
 	o := orm.NewOrm()
 	to, err := o.Begin()
 	if err != nil {
@@ -59,8 +59,8 @@ func SavePredictCalculateKszs(reqEdbInfoId, classifyId int, edbName, frequency,
 			MoveFrequency:    "",
 			NoUpdate:         0,
 			ServerUrl:        "",
-			EdbNameEn:        "",
-			UnitEn:           "",
+			EdbNameEn:        edbName,
+			UnitEn:           unit,
 			LatestDate:       "",
 			LatestValue:      0,
 			ChartImage:       "",
@@ -118,14 +118,20 @@ func SavePredictCalculateKszs(reqEdbInfoId, classifyId int, edbName, frequency,
 			return
 		}
 		//修改指标信息
-		edbInfo.EdbName = edbName
-		edbInfo.EdbNameSource = edbName
+		switch lang {
+		case utils.EnLangVersion:
+			edbInfo.EdbNameEn = edbName
+			edbInfo.UnitEn = unit
+		default:
+			edbInfo.EdbName = edbName
+			edbInfo.Unit = unit
+			edbInfo.EdbNameSource = edbName
+		}
 		edbInfo.Frequency = frequency
-		edbInfo.Unit = unit
 		edbInfo.ClassifyId = classifyId
 		edbInfo.CalculateFormula = formula
 		edbInfo.ModifyTime = time.Now()
-		_, err = to.Update(edbInfo, "EdbName", "EdbNameSource", "Frequency", "Unit", "ClassifyId", "CalculateFormula", "ModifyTime")
+		_, err = to.Update(edbInfo, "EdbName", "EdbNameSource", "Frequency", "Unit", "ClassifyId", "CalculateFormula", "ModifyTime", "EdbNameEn", "UnitEn")
 		if err != nil {
 			return
 		}

models/predict_edb_data_calculate_ljz.go

@@ -74,8 +74,8 @@ func (obj PredictLjz) Add(params BatchSaveCalculateBatchParams) (edbInfo *EdbInf
 		NoUpdate:         0,
 		ServerUrl:        "",
 		EdbInfoType:      1,
-		EdbNameEn:        "",
-		UnitEn:           "",
+		EdbNameEn:        req.EdbName,
+		UnitEn:           req.Unit,
 		LatestDate:       "",
 		LatestValue:      0,
 		ChartImage:       "",
@@ -159,13 +159,19 @@ func (obj PredictLjz) Edit(params BatchSaveCalculateBatchParams) (latestDateStr
 		isRecalculate = true
 	}
 	//修改指标信息
-	edbInfo.EdbName = req.EdbName
-	edbInfo.EdbNameSource = req.EdbName
+	switch params.Lang {
+	case utils.EnLangVersion:
+		edbInfo.EdbNameEn = req.EdbName
+		edbInfo.UnitEn = req.Unit
+	default:
+		edbInfo.EdbName = req.EdbName
+		edbInfo.Unit = req.Unit
+		edbInfo.EdbNameSource = req.EdbName
+	}
 	edbInfo.Frequency = req.Frequency
-	edbInfo.Unit = req.Unit
 	edbInfo.ClassifyId = req.ClassifyId
 	edbInfo.ModifyTime = time.Now()
-	_, err = to.Update(edbInfo, "EdbName", "EdbNameSource", "Frequency", "Unit", "ClassifyId", "ModifyTime")
+	_, err = to.Update(edbInfo, "EdbName", "EdbNameSource", "Frequency", "Unit", "ClassifyId", "ModifyTime", "EdbNameEn", "UnitEn")
 	if err != nil {
 		return
 	}

models/predict_edb_data_calculate_ljznczj.go

@@ -73,8 +73,8 @@ func (obj PredictLjzNczj) Add(params BatchSaveCalculateBatchParams) (edbInfo *Ed
 		NoUpdate:         0,
 		ServerUrl:        "",
 		EdbInfoType:      1,
-		EdbNameEn:        "",
-		UnitEn:           "",
+		EdbNameEn:        req.EdbName,
+		UnitEn:           req.Unit,
 		LatestDate:       "",
 		LatestValue:      0,
 		ChartImage:       "",
@@ -157,13 +157,19 @@ func (obj PredictLjzNczj) Edit(params BatchSaveCalculateBatchParams) (latestDate
 		isRecalculate = true
 	}
 	//修改指标信息
-	edbInfo.EdbName = req.EdbName
-	edbInfo.EdbNameSource = req.EdbName
+	switch params.Lang {
+	case utils.EnLangVersion:
+		edbInfo.EdbNameEn = req.EdbName
+		edbInfo.UnitEn = req.Unit
+	default:
+		edbInfo.EdbName = req.EdbName
+		edbInfo.Unit = req.Unit
+		edbInfo.EdbNameSource = req.EdbName
+	}
 	edbInfo.Frequency = req.Frequency
-	edbInfo.Unit = req.Unit
 	edbInfo.ClassifyId = req.ClassifyId
 	edbInfo.ModifyTime = time.Now()
-	_, err = to.Update(edbInfo, "EdbName", "EdbNameSource", "Frequency", "Unit", "ClassifyId", "ModifyTime")
+	_, err = to.Update(edbInfo, "EdbName", "EdbNameSource", "Frequency", "Unit", "ClassifyId", "ModifyTime", "EdbNameEn", "UnitEn")
 	if err != nil {
 		return
 	}

models/predict_edb_data_calculate_ljzzj.go

@@ -56,6 +56,8 @@ func (obj PredictLjzzj) Add(params BatchSaveCalculateBatchParams) (edbInfo *EdbI
 	edbInfo.ModifyTime = time.Now()
 	edbInfo.UniqueCode = params.UniqueCode
 	edbInfo.CalculateFormula = req.Formula
+	edbInfo.EdbNameEn = req.EdbName
+	edbInfo.UnitEn = req.Unit
 	edbInfo.EdbType = 2
 	newEdbInfoId, tmpErr := to.Insert(edbInfo)
 	if tmpErr != nil {
@@ -122,13 +124,19 @@ func (obj PredictLjzzj) Edit(params BatchSaveCalculateBatchParams) (latestDateSt
 	tableName := GetEdbDataTableName(edbInfo.Source, edbInfo.SubSource)
 
 	//修改指标信息
-	edbInfo.EdbName = req.EdbName
-	edbInfo.EdbNameSource = req.EdbName
+	switch params.Lang {
+	case utils.EnLangVersion:
+		edbInfo.EdbNameEn = req.EdbName
+		edbInfo.UnitEn = req.Unit
+	default:
+		edbInfo.EdbName = req.EdbName
+		edbInfo.Unit = req.Unit
+		edbInfo.EdbNameSource = req.EdbName
+	}
 	edbInfo.Frequency = req.Frequency
-	edbInfo.Unit = req.Unit
 	edbInfo.ClassifyId = req.ClassifyId
 	edbInfo.ModifyTime = time.Now()
-	_, err = to.Update(edbInfo, "EdbName", "EdbNameSource", "Frequency", "Unit", "ClassifyId", "ModifyTime")
+	_, err = to.Update(edbInfo, "EdbName", "EdbNameSource", "Frequency", "Unit", "ClassifyId", "ModifyTime", "EdbNameEn", "UnitEn")
 	if err != nil {
 		return
 	}

models/predict_edb_data_calculate_ljzzy.go

@@ -12,7 +12,7 @@ import (
 )
 
 // SavePredictCalculateLjzzy 累计值转月
-func SavePredictCalculateLjzzy(req *EdbInfoCalculateBatchSaveReq, fromEdbInfo *EdbInfo, edbCode, uniqueCode string, sysUserId int, sysUserRealName string) (edbInfo *EdbInfo, latestDateStr string, latestValue float64, err error) {
+func SavePredictCalculateLjzzy(req *EdbInfoCalculateBatchSaveReq, fromEdbInfo *EdbInfo, edbCode, uniqueCode string, sysUserId int, sysUserRealName, lang string) (edbInfo *EdbInfo, latestDateStr string, latestValue float64, err error) {
 	o := orm.NewOrm()
 	to, err := o.Begin()
 	if err != nil {
@@ -44,6 +44,8 @@ func SavePredictCalculateLjzzy(req *EdbInfoCalculateBatchSaveReq, fromEdbInfo *E
 		edbInfo.ModifyTime = time.Now()
 		edbInfo.UniqueCode = uniqueCode
 		edbInfo.CalculateFormula = req.Formula
+		edbInfo.EdbNameEn = req.EdbName
+		edbInfo.UnitEn = req.Unit
 		edbInfo.EdbType = 2
 		newEdbInfoId, tmpErr := to.Insert(edbInfo)
 		if tmpErr != nil {
@@ -81,13 +83,19 @@ func SavePredictCalculateLjzzy(req *EdbInfoCalculateBatchSaveReq, fromEdbInfo *E
 		latestDateStr = edbInfo.LatestDate
 		latestValue = edbInfo.LatestValue
 		//修改指标信息
-		edbInfo.EdbName = req.EdbName
-		edbInfo.EdbNameSource = req.EdbName
+		switch lang {
+		case utils.EnLangVersion:
+			edbInfo.EdbNameEn = req.EdbName
+			edbInfo.UnitEn = req.Unit
+		default:
+			edbInfo.EdbName = req.EdbName
+			edbInfo.Unit = req.Unit
+			edbInfo.EdbNameSource = req.EdbName
+		}
 		edbInfo.Frequency = req.Frequency
-		edbInfo.Unit = req.Unit
 		edbInfo.ClassifyId = req.ClassifyId
 		edbInfo.ModifyTime = time.Now()
-		_, err = to.Update(edbInfo, "EdbName", "EdbNameSource", "Frequency", "Unit", "ClassifyId", "ModifyTime")
+		_, err = to.Update(edbInfo, "EdbName", "EdbNameSource", "Frequency", "Unit", "ClassifyId", "ModifyTime", "EdbNameEn", "UnitEn")
 		if err != nil {
 			return
 		}

models/predict_edb_data_calculate_nh.go

@@ -12,7 +12,7 @@ import (
 )
 
 // SavePredictCalculateNh 预测年化值
-func SavePredictCalculateNh(reqEdbInfoId, classifyId int, edbName, frequency, unit, formula string, fromEdbInfo *EdbInfo, edbCode, uniqueCode string, sysUserId int, sysUserRealName string) (edbInfo *EdbInfo, latestDateStr string, latestValue float64, err error, errMsg string) {
+func SavePredictCalculateNh(reqEdbInfoId, classifyId int, edbName, frequency, unit, formula string, fromEdbInfo *EdbInfo, edbCode, uniqueCode string, sysUserId int, sysUserRealName, lang string) (edbInfo *EdbInfo, latestDateStr string, latestValue float64, err error, errMsg string) {
 	o := orm.NewOrm()
 	to, err := o.Begin()
 	if err != nil {
@@ -56,8 +56,8 @@ func SavePredictCalculateNh(reqEdbInfoId, classifyId int, edbName, frequency, un
 			MoveFrequency:    "",
 			NoUpdate:         0,
 			ServerUrl:        "",
-			EdbNameEn:        "",
-			UnitEn:           "",
+			EdbNameEn:        edbName,
+			UnitEn:           unit,
 			LatestDate:       "",
 			LatestValue:      0,
 			ChartImage:       "",
@@ -109,14 +109,20 @@ func SavePredictCalculateNh(reqEdbInfoId, classifyId int, edbName, frequency, un
 		latestDateStr = edbInfo.LatestDate
 		latestValue = edbInfo.LatestValue
 		//修改指标信息
-		edbInfo.EdbName = edbName
-		edbInfo.EdbNameSource = edbName
+		switch lang {
+		case utils.EnLangVersion:
+			edbInfo.EdbNameEn = edbName
+			edbInfo.UnitEn = unit
+		default:
+			edbInfo.EdbName = edbName
+			edbInfo.Unit = unit
+			edbInfo.EdbNameSource = edbName
+		}
 		edbInfo.Frequency = frequency
-		edbInfo.Unit = unit
 		edbInfo.ClassifyId = classifyId
 		edbInfo.CalculateFormula = formula
 		edbInfo.ModifyTime = time.Now()
-		_, err = to.Update(edbInfo, "EdbName", "EdbNameSource", "Frequency", "Unit", "ClassifyId", "CalculateFormula", "ModifyTime")
+		_, err = to.Update(edbInfo, "EdbName", "EdbNameSource", "Frequency", "Unit", "ClassifyId", "CalculateFormula", "ModifyTime", "EdbNameEn", "UnitEn")
 		if err != nil {
 			return
 		}

models/predict_edb_data_calculate_nhcc.go

@@ -25,7 +25,7 @@ type EdbDataPredictCalculateNhcc struct {
 }
 
 // SavePredictCalculateNhcc 新增拟合残差数据
-func SavePredictCalculateNhcc(req *EdbInfoCalculateBatchSaveReq, firstEdbInfo, secondEdbInfo *EdbInfo, edbCode, uniqueCode string, nhccDate NhccDate, sysUserId int, sysUserRealName string) (edbInfo *EdbInfo, latestDateStr string, latestValue float64, err error) {
+func SavePredictCalculateNhcc(req *EdbInfoCalculateBatchSaveReq, firstEdbInfo, secondEdbInfo *EdbInfo, edbCode, uniqueCode string, nhccDate NhccDate, sysUserId int, sysUserRealName, lang string) (edbInfo *EdbInfo, latestDateStr string, latestValue float64, err error) {
 	o := orm.NewOrm()
 	to, err := o.Begin()
 	if err != nil {
@@ -59,6 +59,8 @@ func SavePredictCalculateNhcc(req *EdbInfoCalculateBatchSaveReq, firstEdbInfo, s
 			CreateTime:       time.Now(),
 			ModifyTime:       time.Now(),
 			CalculateFormula: req.Formula,
+			EdbNameEn:        req.EdbName,
+			UnitEn:           req.Unit,
 			EdbType:          2,
 		}
 		newEdbInfoId, tmpErr := to.Insert(edbInfo)
@@ -130,14 +132,20 @@ func SavePredictCalculateNhcc(req *EdbInfoCalculateBatchSaveReq, firstEdbInfo, s
 		nowEdbInfo := *edbInfo // 现在的指标信息
 
 		//修改指标信息
-		edbInfo.EdbName = req.EdbName
-		edbInfo.EdbNameSource = req.EdbName
+		switch lang {
+		case utils.EnLangVersion:
+			edbInfo.EdbNameEn = req.EdbName
+			edbInfo.UnitEn = req.Unit
+		default:
+			edbInfo.EdbName = req.EdbName
+			edbInfo.Unit = req.Unit
+			edbInfo.EdbNameSource = req.EdbName
+		}
 		edbInfo.Frequency = req.Frequency
-		edbInfo.Unit = req.Unit
 		edbInfo.ClassifyId = req.ClassifyId
 		edbInfo.CalculateFormula = req.Formula
 		edbInfo.ModifyTime = time.Now()
-		_, err = to.Update(edbInfo, "EdbName", "EdbNameSource", "Frequency", "Unit", "ClassifyId", "CalculateFormula", "ModifyTime")
+		_, err = to.Update(edbInfo, "EdbName", "EdbNameSource", "Frequency", "Unit", "ClassifyId", "CalculateFormula", "ModifyTime", "EdbNameEn", "UnitEn")
 		if err != nil {
 			return
 		}

models/predict_edb_data_calculate_nszydbpjjs.go

@@ -12,7 +12,7 @@ import (
 )
 
 // SavePredictCalculateNszydpjjs 新增/编辑 预测 N数值移动平均计算指标
-func SavePredictCalculateNszydpjjs(reqEdbInfoId, classifyId int, edbName, frequency, unit, formula string, fromEdbInfo *EdbInfo, edbCode, uniqueCode string, sysUserId int, sysUserRealName string) (edbInfo *EdbInfo, latestDateStr string, latestValue float64, err error, errMsg string) {
+func SavePredictCalculateNszydpjjs(reqEdbInfoId, classifyId int, edbName, frequency, unit, formula string, fromEdbInfo *EdbInfo, edbCode, uniqueCode string, sysUserId int, sysUserRealName, lang string) (edbInfo *EdbInfo, latestDateStr string, latestValue float64, err error, errMsg string) {
 	o := orm.NewOrm()
 	to, err := o.Begin()
 	if err != nil {
@@ -62,8 +62,8 @@ func SavePredictCalculateNszydpjjs(reqEdbInfoId, classifyId int, edbName, freque
 			MoveFrequency:    "",
 			NoUpdate:         0,
 			ServerUrl:        "",
-			EdbNameEn:        "",
-			UnitEn:           "",
+			EdbNameEn:        edbName,
+			UnitEn:           unit,
 			LatestDate:       "",
 			LatestValue:      0,
 			ChartImage:       "",
@@ -116,14 +116,21 @@ func SavePredictCalculateNszydpjjs(reqEdbInfoId, classifyId int, edbName, freque
 		latestValue = edbInfo.LatestValue
 		oldCalculateFormula := edbInfo.CalculateFormula //原先的n值
 
-		edbInfo.EdbName = edbName
-		edbInfo.EdbNameSource = edbName
+		switch lang {
+		case utils.EnLangVersion:
+			edbInfo.EdbNameEn = edbName
+			edbInfo.UnitEn = unit
+		default:
+			edbInfo.EdbName = edbName
+			edbInfo.Unit = unit
+			edbInfo.EdbNameSource = edbName
+		}
+
 		edbInfo.Frequency = frequency
-		edbInfo.Unit = unit
 		edbInfo.ClassifyId = classifyId
 		edbInfo.CalculateFormula = formula
 		edbInfo.ModifyTime = time.Now()
-		_, err = to.Update(edbInfo, "EdbName", "EdbNameSource", "Frequency", "Unit", "ClassifyId", "CalculateFormula", "ModifyTime")
+		_, err = to.Update(edbInfo, "EdbName", "EdbNameSource", "Frequency", "Unit", "ClassifyId", "CalculateFormula", "ModifyTime", "EdbNameEn", "UnitEn")
 		if err != nil {
 			return
 		}

models/predict_edb_data_calculate_percentile.go

@@ -64,8 +64,8 @@ func (obj PredictPercentile) Add(params BatchSaveCalculateBatchParams) (edbInfo
 		NoUpdate:         0,
 		ServerUrl:        "",
 		EdbInfoType:      1,
-		EdbNameEn:        "",
-		UnitEn:           "",
+		EdbNameEn:        req.EdbName,
+		UnitEn:           req.Unit,
 		LatestDate:       "",
 		LatestValue:      0,
 		ChartImage:       "",
@@ -136,14 +136,20 @@ func (obj PredictPercentile) Edit(params BatchSaveCalculateBatchParams) (latestD
 		isRecalculate = true
 	}
 	//修改指标信息
-	edbInfo.EdbName = req.EdbName
-	edbInfo.EdbNameSource = req.EdbName
+	switch params.Lang {
+	case utils.EnLangVersion:
+		edbInfo.EdbNameEn = req.EdbName
+		edbInfo.UnitEn = req.Unit
+	default:
+		edbInfo.EdbName = req.EdbName
+		edbInfo.Unit = req.Unit
+		edbInfo.EdbNameSource = req.EdbName
+	}
 	edbInfo.Frequency = req.Frequency
-	edbInfo.Unit = req.Unit
 	edbInfo.ClassifyId = req.ClassifyId
 	edbInfo.CalculateFormula = req.Formula
 	edbInfo.ModifyTime = time.Now()
-	_, err = to.Update(edbInfo, "EdbName", "EdbNameSource", "Frequency", "Unit", "ClassifyId", "CalculateFormula", "ModifyTime")
+	_, err = to.Update(edbInfo, "EdbName", "EdbNameSource", "Frequency", "Unit", "ClassifyId", "CalculateFormula", "ModifyTime", "EdbNameEn", "UnitEn")
 	if err != nil {
 		return
 	}

models/predict_edb_data_calculate_standard_deviation.go

@@ -63,8 +63,8 @@ func (obj PredictStandardDeviation) Add(params BatchSaveCalculateBatchParams) (e
 		NoUpdate:         0,
 		ServerUrl:        "",
 		EdbInfoType:      1,
-		EdbNameEn:        "",
-		UnitEn:           "",
+		EdbNameEn:        req.EdbName,
+		UnitEn:           req.Unit,
 		LatestDate:       "",
 		LatestValue:      0,
 		ChartImage:       "",
@@ -147,14 +147,20 @@ func (obj PredictStandardDeviation) Edit(params BatchSaveCalculateBatchParams) (
 		isRecalculate = true
 	}
 	//修改指标信息
-	edbInfo.EdbName = req.EdbName
-	edbInfo.EdbNameSource = req.EdbName
+	switch params.Lang {
+	case utils.EnLangVersion:
+		edbInfo.EdbNameEn = req.EdbName
+		edbInfo.UnitEn = req.Unit
+	default:
+		edbInfo.EdbName = req.EdbName
+		edbInfo.Unit = req.Unit
+		edbInfo.EdbNameSource = req.EdbName
+	}
 	edbInfo.Frequency = req.Frequency
-	edbInfo.Unit = req.Unit
 	edbInfo.ClassifyId = req.ClassifyId
 	edbInfo.CalculateFormula = req.Formula
 	edbInfo.ModifyTime = time.Now()
-	_, err = to.Update(edbInfo, "EdbName", "EdbNameSource", "Frequency", "Unit", "ClassifyId", "CalculateFormula", "ModifyTime")
+	_, err = to.Update(edbInfo, "EdbName", "EdbNameSource", "Frequency", "Unit", "ClassifyId", "CalculateFormula", "ModifyTime", "EdbNameEn", "UnitEn")
 	if err != nil {
 		return
 	}

models/predict_edb_data_calculate_tbz.go

@@ -63,8 +63,8 @@ func (obj PredictTb) Add(params BatchSaveCalculateBatchParams) (edbInfo *EdbInfo
 		NoUpdate:         0,
 		ServerUrl:        "",
 		EdbInfoType:      1,
-		EdbNameEn:        "",
-		UnitEn:           "",
+		EdbNameEn:        req.EdbName,
+		UnitEn:           req.Unit,
 		LatestDate:       "",
 		LatestValue:      0,
 		ChartImage:       "",
@@ -145,13 +145,19 @@ func (obj PredictTb) Edit(params BatchSaveCalculateBatchParams) (latestDateStr s
 	tableName := GetEdbDataTableName(edbInfo.Source, edbInfo.SubSource)
 
 	//修改指标信息
-	edbInfo.EdbName = req.EdbName
-	edbInfo.EdbNameSource = req.EdbName
+	switch params.Lang {
+	case utils.EnLangVersion:
+		edbInfo.EdbNameEn = req.EdbName
+		edbInfo.UnitEn = req.Unit
+	default:
+		edbInfo.EdbName = req.EdbName
+		edbInfo.Unit = req.Unit
+		edbInfo.EdbNameSource = req.EdbName
+	}
 	edbInfo.Frequency = req.Frequency
-	edbInfo.Unit = req.Unit
 	edbInfo.ClassifyId = req.ClassifyId
 	edbInfo.ModifyTime = time.Now()
-	_, err = to.Update(edbInfo, "EdbName", "EdbNameSource", "Frequency", "Unit", "ClassifyId", "ModifyTime")
+	_, err = to.Update(edbInfo, "EdbName", "EdbNameSource", "Frequency", "Unit", "ClassifyId", "ModifyTime", "EdbNameEn", "UnitEn")
 	if err != nil {
 		return
 	}

models/predict_edb_data_calculate_tcz.go

@@ -12,7 +12,7 @@ import (
 )
 
 // SavePredictCalculateTcz 同差值
-func SavePredictCalculateTcz(reqEdbInfoId, classifyId int, edbName, frequency, unit, formula string, fromEdbInfo *EdbInfo, edbCode, uniqueCode string, sysUserId int, sysUserRealName string) (edbInfo *EdbInfo, latestDateStr string, latestValue float64, err error, errMsg string) {
+func SavePredictCalculateTcz(reqEdbInfoId, classifyId int, edbName, frequency, unit, formula string, fromEdbInfo *EdbInfo, edbCode, uniqueCode string, sysUserId int, sysUserRealName, lang string) (edbInfo *EdbInfo, latestDateStr string, latestValue float64, err error, errMsg string) {
 	o := orm.NewOrm()
 	to, err := o.Begin()
 	if err != nil {
@@ -56,8 +56,8 @@ func SavePredictCalculateTcz(reqEdbInfoId, classifyId int, edbName, frequency, u
 			MoveFrequency:    "",
 			NoUpdate:         0,
 			ServerUrl:        "",
-			EdbNameEn:        "",
-			UnitEn:           "",
+			EdbNameEn:        edbName,
+			UnitEn:           unit,
 			LatestDate:       "",
 			LatestValue:      0,
 			ChartImage:       "",
@@ -108,13 +108,20 @@ func SavePredictCalculateTcz(reqEdbInfoId, classifyId int, edbName, frequency, u
 		latestDateStr = edbInfo.LatestDate
 		latestValue = edbInfo.LatestValue
 		//修改指标信息
-		edbInfo.EdbName = edbName
-		edbInfo.EdbNameSource = edbName
+		switch lang {
+		case utils.EnLangVersion:
+			edbInfo.EdbNameEn = edbName
+			edbInfo.UnitEn = unit
+		default:
+			edbInfo.EdbName = edbName
+			edbInfo.Unit = unit
+			edbInfo.EdbNameSource = edbName
+		}
+
 		edbInfo.Frequency = frequency
-		edbInfo.Unit = unit
 		edbInfo.ClassifyId = classifyId
 		edbInfo.ModifyTime = time.Now()
-		_, err = to.Update(edbInfo, "EdbName", "EdbNameSource", "Frequency", "Unit", "ClassifyId", "ModifyTime")
+		_, err = to.Update(edbInfo, "EdbName", "EdbNameSource", "Frequency", "Unit", "ClassifyId", "ModifyTime", "EdbNameEn", "UnitEn")
 		if err != nil {
 			return
 		}

models/predict_edb_data_calculate_time_shift.go

@@ -12,7 +12,7 @@ import (
 )
 
 // SavePredictCalculateTimeShift 时间移位
-func SavePredictCalculateTimeShift(req *EdbInfoCalculateBatchSaveReq, fromEdbInfo *EdbInfo, edbCode, uniqueCode string, sysUserId int, sysUserRealName string) (edbInfo *EdbInfo, latestDateStr string, latestValue float64, err error) {
+func SavePredictCalculateTimeShift(req *EdbInfoCalculateBatchSaveReq, fromEdbInfo *EdbInfo, edbCode, uniqueCode string, sysUserId int, sysUserRealName, lang string) (edbInfo *EdbInfo, latestDateStr string, latestValue float64, err error) {
 	o := orm.NewOrm()
 	to, err := o.Begin()
 	if err != nil {
@@ -47,6 +47,8 @@ func SavePredictCalculateTimeShift(req *EdbInfoCalculateBatchSaveReq, fromEdbInf
 		edbInfo.EdbType = 2
 		edbInfo.MoveType = req.MoveType
 		edbInfo.MoveFrequency = req.MoveFrequency
+		edbInfo.EdbNameEn = req.EdbName
+		edbInfo.UnitEn = req.Unit
 		newEdbInfoId, tmpErr := to.Insert(edbInfo)
 		if tmpErr != nil {
 			err = tmpErr
@@ -84,16 +86,22 @@ func SavePredictCalculateTimeShift(req *EdbInfoCalculateBatchSaveReq, fromEdbInf
 		oldEdbInfo := *edbInfo //旧的指标信息
 
 		//修改指标信息
-		edbInfo.EdbName = req.EdbName
-		edbInfo.EdbNameSource = req.EdbName
+		switch lang {
+		case utils.EnLangVersion:
+			edbInfo.EdbNameEn = req.EdbName
+			edbInfo.UnitEn = req.Unit
+		default:
+			edbInfo.EdbName = req.EdbName
+			edbInfo.Unit = req.Unit
+			edbInfo.EdbNameSource = req.EdbName
+		}
 		edbInfo.Frequency = req.Frequency
-		edbInfo.Unit = req.Unit
 		edbInfo.ClassifyId = req.ClassifyId
 		edbInfo.MoveType = req.MoveType
 		edbInfo.MoveFrequency = req.MoveFrequency
 		edbInfo.CalculateFormula = req.Formula
 		edbInfo.ModifyTime = time.Now()
-		_, err = to.Update(edbInfo, "EdbName", "EdbNameSource", "Frequency", "Unit", "ClassifyId", "MoveType", "MoveFrequency", "CalculateFormula", "ModifyTime")
+		_, err = to.Update(edbInfo, "EdbName", "EdbNameSource", "Frequency", "Unit", "ClassifyId", "MoveType", "MoveFrequency", "CalculateFormula", "ModifyTime", "EdbNameEn", "UnitEn")
 		if err != nil {
 			return
 		}

models/predict_edb_data_calculate_zsxy.go

@@ -68,8 +68,8 @@ func (obj PredictExponentialSmoothing) Add(params BatchSaveCalculateBatchParams)
 		NoUpdate:         0,
 		ServerUrl:        "",
 		EdbInfoType:      1,
-		EdbNameEn:        "",
-		UnitEn:           "",
+		EdbNameEn:        req.EdbName,
+		UnitEn:           req.Unit,
 		LatestDate:       "",
 		LatestValue:      0,
 		ChartImage:       "",
@@ -139,14 +139,20 @@ func (obj PredictExponentialSmoothing) Edit(params BatchSaveCalculateBatchParams
 		isRecalculate = true
 	}
 	//修改指标信息
-	edbInfo.EdbName = req.EdbName
-	edbInfo.EdbNameSource = req.EdbName
+	switch params.Lang {
+	case utils.EnLangVersion:
+		edbInfo.EdbNameEn = req.EdbName
+		edbInfo.UnitEn = req.Unit
+	default:
+		edbInfo.EdbName = req.EdbName
+		edbInfo.Unit = req.Unit
+		edbInfo.EdbNameSource = req.EdbName
+	}
 	edbInfo.Frequency = req.Frequency
-	edbInfo.Unit = req.Unit
 	edbInfo.ClassifyId = req.ClassifyId
 	edbInfo.CalculateFormula = req.Formula
 	edbInfo.ModifyTime = time.Now()
-	_, err = to.Update(edbInfo, "EdbName", "EdbNameSource", "Frequency", "Unit", "ClassifyId", "CalculateFormula", "ModifyTime")
+	_, err = to.Update(edbInfo, "EdbName", "EdbNameSource", "Frequency", "Unit", "ClassifyId", "CalculateFormula", "ModifyTime", "EdbNameEn", "UnitEn")
 	if err != nil {
 		return
 	}

services/base_from_calculate.go

@@ -11,7 +11,7 @@ import (
 )
 
 // EdbCalculateBatchSave 批量指标运算
-func EdbCalculateBatchSave(req models.EdbInfoCalculateBatchSaveReq) (edbInfo *models.EdbInfo, uniqueCode string, err error, errMsg string) {
+func EdbCalculateBatchSave(req models.EdbInfoCalculateBatchSaveReq, lang string) (edbInfo *models.EdbInfo, uniqueCode string, err error, errMsg string) {
 	// 校验参数
 	req.EdbName = strings.Trim(req.EdbName, " ")
 	if req.EdbName == "" {
@@ -213,7 +213,7 @@ func EdbCalculateBatchSave(req models.EdbInfoCalculateBatchSaveReq) (edbInfo *mo
 			req2.EdbInfoIdArr = append(req2.EdbInfoIdArr, t)
 		}
 
-		edbInfo, _, err, errMsg = EdbCalculateAdd(req2)
+		edbInfo, _, err, errMsg = EdbCalculateAdd(req2, lang)
 	case utils.DATA_SOURCE_CALCULATE_LJZZY:
 		sourName = "累计值转月值"
 		if fromEdbInfo.Frequency != "月度" {
@@ -865,7 +865,7 @@ func EdbCalculateBatchEdit(req models.EdbInfoCalculateBatchEditReq) (edbInfo *mo
 }
 
 // EdbCalculateAdd 新增指标运算
-func EdbCalculateAdd(req models.EdbInfoCalculateSaveReq) (edbInfo *models.EdbInfo, uniqueCode string, err error, errMsg string) {
+func EdbCalculateAdd(req models.EdbInfoCalculateSaveReq, lang string) (edbInfo *models.EdbInfo, uniqueCode string, err error, errMsg string) {
 	calculateFormula := req.CalculateFormula
 	calculateFormula = strings.Replace(calculateFormula, "（", "(", -1)
 	calculateFormula = strings.Replace(calculateFormula, "）", ")", -1)
@@ -898,24 +898,21 @@ func EdbCalculateAdd(req models.EdbInfoCalculateSaveReq) (edbInfo *models.EdbInf
 		req.EdbInfoIdArr = newEdbInfoIdArr
 	}
 
-	var condition string
-	var pars []interface{}
-	condition += " AND edb_name=? "
-	pars = append(pars, req.EdbName)
-
-	count, err := models.GetEdbInfoCountByCondition(condition, pars)
+	// 校验指标名称是否存在
+	existEdbName, err := logic.CheckExistByEdbNameAndEdbInfoId(0, 0, req.EdbName, lang)
 	if err != nil {
 		errMsg = "判断指标名称是否存在失败,Err:" + err.Error()
 		err = fmt.Errorf("判断指标名称是否存在失败")
 		return
 	}
 
-	if count > 0 {
-		err = fmt.Errorf("指标名称已存在，请重新填写")
+	if existEdbName {
 		errMsg = "指标名称已存在，请重新填写"
+		err = fmt.Errorf(errMsg)
 		//br.IsSendEmail = false
 		return
 	}
+
 	//检验公式
 	var formulaStr string
 	var edbInfoIdBytes []string

utils/constants.go

@@ -280,3 +280,9 @@ const (
 	DATA_SUB_SOURCE_EDB  = iota //经济数据库
 	DATA_SUB_SOURCE_DATE        //日期序列
 )
+
+// 语言版本
+const (
+	ZhLangVersion = "zh" // 中文语言版本
+	EnLangVersion = "en" // 英文语言版本
+)