批量计算添加指标运算

controllers/base_from_calculate.go

@@ -69,13 +69,6 @@ func (this *CalculateController) Add() {
 		br.Msg = "请填写指标"
 		return
 	}
-	calculateFormula := req.CalculateFormula
-	calculateFormula = strings.Replace(calculateFormula, "（", "(", -1)
-	calculateFormula = strings.Replace(calculateFormula, "）", ")", -1)
-	calculateFormula = strings.Replace(calculateFormula, "，", ",", -1)
-	calculateFormula = strings.Replace(calculateFormula, "。", ".", -1)
-	calculateFormula = strings.Replace(calculateFormula, "%", "*0.01", -1)
-	req.CalculateFormula = calculateFormula
 
 	//加入缓存机制，避免创建同一个名称的指标 start
 	redisKey := fmt.Sprint("edb_lib:edb_info:calculate:add:", utils.DATA_SOURCE_CALCULATE, ":", req.EdbName)
@@ -91,148 +84,20 @@ func (this *CalculateController) Add() {
 		}()
 	}
 
-	//判断是否重复指标
-	edbInfoMap := make(map[int]string)
-	//移除研究员选择指标中的未使用的指标
-	{
-		//转大写的计算公式
-		upperCalculateFormulaStr := strings.ToUpper(req.CalculateFormula)
-		//用到的指标
-		newEdbInfoIdArr := make([]models.EdbInfoFromTag, 0)
-		for _, tmpEdbInfo := range req.EdbInfoIdArr {
-			_, ok := edbInfoMap[tmpEdbInfo.EdbInfoId]
-			if ok {
-				br.Msg = "选择指标失败，请勿选择重复指标！"
-				return
-			}
-			edbInfoMap[tmpEdbInfo.EdbInfoId] = tmpEdbInfo.FromTag
-
-			upperFromTag := strings.ToUpper(tmpEdbInfo.FromTag)
-			if strings.Contains(upperCalculateFormulaStr, upperFromTag) {
-				newEdbInfoIdArr = append(newEdbInfoIdArr, tmpEdbInfo)
-			}
-		}
-		req.EdbInfoIdArr = newEdbInfoIdArr
-	}
-
-	var condition string
-	var pars []interface{}
-	condition += " AND edb_name=? "
-	pars = append(pars, 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 = "指标名称已存在，请重新填写"
-		br.IsSendEmail = false
-		return
-	}
-	//检验公式
-	var formulaStr string
-	var edbInfoIdBytes []string
-	for _, v := range req.EdbInfoIdArr {
-		formulaStr += v.FromTag + ","
-		edbInfoIdBytes = append(edbInfoIdBytes, v.FromTag)
-	}
-	formulaSlice, err := utils.CheckFormulaJson(req.CalculateFormula)
+	// 新增
+	edbInfo, uniqueCode, err, errMsg := services.EdbCalculateAdd(req)
 	if err != nil {
-		br.Msg = "公式格式错误，请重新填写"
+		br.Msg = err.Error()
+		br.ErrMsg = errMsg
 		return
 	}
-	for _, formula := range formulaSlice {
-		formulaMap, e := utils.CheckFormula(formula)
-		if e != nil {
-			br.Msg = "公式错误，请重新填写"
-			return
-		}
-		for _, v := range formulaMap {
-			if !strings.Contains(formulaStr, v) {
-				br.Msg = "公式错误，请重新填写"
-				return
-			}
-		}
-	}
-
-	//关联的指标信息
-	edbInfoList := make([]*models.EdbInfo, 0)
-	//关联的指标数据表
-	calculateMappingList := make([]*models.EdbInfoCalculateMapping, 0)
-	for k, v := range req.EdbInfoIdArr {
-		fromEdbInfo, err := models.GetEdbInfoById(v.EdbInfoId)
-		if err != nil {
-			if err.Error() == utils.ErrNoRow() {
-				br.Msg = "生成计算指标失败"
-				br.Msg = "指标 " + strconv.Itoa(v.EdbInfoId) + " 不存在"
-				return
-			}
-			br.Msg = "生成计算指标失败"
-			br.Msg = "获取指标失败:Err:" + err.Error()
-			return
-		}
-
-		edbInfoList = append(edbInfoList, fromEdbInfo)
-		//关联关系表
-		{
-			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:                   v.FromTag,
-				Sort:                      k + 1,
-				CreateTime:                time.Now(),
-				ModifyTime:                time.Now(),
-			}
-			//calculateMappingItem.EdbCode = edbCode
-			//calculateMappingItem.EdbInfoId = int(edbInfoId)
-			calculateMappingList = append(calculateMappingList, calculateMappingItem)
-		}
-	}
-
-	for _, v := range formulaSlice {
-		formulaMap, e := utils.CheckFormula(v)
-		if e != nil {
-			br.Msg = "公式错误，请重新填写"
-			return
-		}
-		//预先计算，判断公式是否正常
-		ok, _ := models.CheckFormula2(edbInfoList, formulaMap, v, edbInfoIdBytes)
-		if !ok {
-			br.Msg = "生成计算指标失败，请使用正确的计算公式"
-			return
-		}
-	}
-
-	randStr := utils.GetRandDigit(4)
-	edbCode := `C` + time.Now().Format("060102") + randStr
-	timestamp := strconv.FormatInt(time.Now().UnixNano(), 10)
-	uniqueCode := utils.MD5(utils.DATA_PREFIX + "_" + timestamp)
 
-	// 新增计算指标
-	edbInfo, err := models.AddCalculateInfo(req, calculateMappingList, edbInfoList, edbCode, uniqueCode, edbInfoIdBytes)
-	if err != nil {
-		br.Msg = "生成计算指标失败"
-		br.Msg = "生成计算指标失败,AddEdbInfo Err:" + err.Error()
-		return
-	}
 	//处理同名指标
 	{
-		edbNameList, err := models.GetEdbInfoByName(req.EdbName)
-		if err != nil {
-			br.Msg = "保存失败"
-			br.ErrMsg = "获取指标信息失败，Err:" + err.Error()
+		edbNameList, e := models.GetEdbInfoByName(req.EdbName)
+		if e != nil {
+			err = fmt.Errorf("保存失败")
+			errMsg = "获取指标信息失败，Err:" + e.Error()
 			return
 		}
 		if len(edbNameList) >= 2 {
@@ -240,8 +105,8 @@ func (this *CalculateController) Add() {
 				edbName := v.EdbName + "(" + v.SourceName + ")"
 				err = models.ModifyEdbInfoNameSource(edbName, v.EdbInfoId)
 				if err != nil {
-					br.Msg = "保存失败"
-					br.ErrMsg = "修改指标名称失败，Err:" + err.Error()
+					errMsg = "修改指标名称失败，Err:" + err.Error()
+					err = fmt.Errorf("保存失败")
 					return
 				}
 			}
@@ -249,10 +114,8 @@ func (this *CalculateController) Add() {
 	}
 
 	// 更新指标最大最小值
-	err, errMsg := models.UnifiedModifyEdbInfoMaxAndMinInfo(edbInfo)
+	err, errMsg = models.UnifiedModifyEdbInfoMaxAndMinInfo(edbInfo)
 	if err != nil {
-		br.Msg = errMsg
-		br.ErrMsg = err.Error()
 		return
 	}
 	resp := models.AddEdbInfoResp{
@@ -2269,11 +2132,11 @@ func (this *CalculateController) BatchSaveMulti() {
 			Source:           req.Source,
 			MoveType:         req.MoveType,
 			MoveFrequency:    req.MoveFrequency,
-
-			//CalculateFormula: edbInfo.CalculateFormula,
-			EdbInfoIdArr: req.EdbInfoIdArr,
-			Calendar:     req.Calendar,
-			Extra:        req.Extra,
+			EdbInfoIdArr:     req.EdbInfoIdArr,
+			Calendar:         req.Calendar,
+			EmptyType:        req.EmptyType,
+			MaxEmptyType:     req.MaxEmptyType,
+			Extra:            req.Extra,
 		}
 		var errMsg string
 

models/base_from_calculate.go

@@ -635,7 +635,9 @@ type CalculateBatchSaveReq struct {
 	MoveFrequency    string                         `description:"移动频度:天/周/月/季/年"`
 	Calendar         string                         `description:"公历/农历"`
 	Data             interface{}                    `description:"数据"`
-	Extra            string                         `description:"指标的额外配置"`
+	EmptyType        int                            `description:"空值处理类型（0查找前后35天，1不计算，2前值填充，3后值填充，4等于0）"`
+	MaxEmptyType     int                            `description:"MAX、MIN公式空值处理类型（1、等于0；2、跳过空值）"`
+	Extra            string                         `description:"指标额外配置"`
 }
 
 type CalculateEdbInfoItem struct {
@@ -666,7 +668,9 @@ type EdbInfoCalculateBatchSaveReq struct {
 	MoveFrequency    string                         `description:"移动频度:天/周/月/季/年"`
 	Calendar         string                         `description:"公历/农历"`
 	Data             interface{}                    `description:"数据"`
-	Extra            string                         `description:"指标的额外配置"`
+	EmptyType        int                            `description:"空值处理类型（0查找前后35天，1不计算，2前值填充，3后值填充，4等于0）"`
+	MaxEmptyType     int                            `description:"MAX、MIN公式空值处理类型（1、等于0；2、跳过空值）"`
+	Extra            string                         `description:"指标额外配置"`
 }
 
 // EdbInfoCalculateEdbInfoIdReq 新增/编辑请求 关联的指标列表

services/base_from_calculate.go

@@ -183,6 +183,38 @@ func EdbCalculateBatchSave(req models.EdbInfoCalculateBatchSaveReq) (uniqueCode
 	}
 
 	switch req.Source {
+	case utils.DATA_SOURCE_CALCULATE:
+		sourName = "计算指标"
+		req2 := models.EdbInfoCalculateSaveReq{
+			AdminId:          sysUserId,
+			AdminName:        sysUserName,
+			EdbName:          req.EdbName,
+			Frequency:        req.Frequency,
+			Unit:             req.Unit,
+			ClassifyId:       req.ClassifyId,
+			CalculateFormula: req.CalculateFormula,
+			//EdbInfoIdArr:     req.EdbInfoIdArr,
+			EmptyType:    req.EmptyType,
+			MaxEmptyType: req.MaxEmptyType,
+			Extra:        req.Extra,
+		}
+
+		// 放入A指标
+		t := models.EdbInfoFromTag{
+			EdbInfoId: req.FromEdbInfoId,
+			FromTag:   "A",
+		}
+		req2.EdbInfoIdArr = append(req2.EdbInfoIdArr, t)
+		// 放入B指标
+		if len(req.EdbInfoIdArr) > 0 {
+			t = models.EdbInfoFromTag{
+				EdbInfoId: req.EdbInfoIdArr[0].EdbInfoId,
+				FromTag:   "B",
+			}
+			req2.EdbInfoIdArr = append(req2.EdbInfoIdArr, t)
+		}
+
+		edbInfo, _, err, errMsg = EdbCalculateAdd(req2)
 	case utils.DATA_SOURCE_CALCULATE_LJZZY:
 		sourName = "累计值转月值"
 		if fromEdbInfo.Frequency != "月度" {
@@ -426,3 +458,153 @@ func EdbCalculateBatchSave(req models.EdbInfoCalculateBatchSaveReq) (uniqueCode
 	go logic.UpdateEs(edbInfo.EdbInfoId)
 	return
 }
+
+// EdbCalculateAdd 新增指标运算
+func EdbCalculateAdd(req models.EdbInfoCalculateSaveReq) (edbInfo *models.EdbInfo, uniqueCode string, err error, errMsg string) {
+	calculateFormula := req.CalculateFormula
+	calculateFormula = strings.Replace(calculateFormula, "（", "(", -1)
+	calculateFormula = strings.Replace(calculateFormula, "）", ")", -1)
+	calculateFormula = strings.Replace(calculateFormula, "，", ",", -1)
+	calculateFormula = strings.Replace(calculateFormula, "。", ".", -1)
+	calculateFormula = strings.Replace(calculateFormula, "%", "*0.01", -1)
+	req.CalculateFormula = calculateFormula
+
+	//判断是否重复指标
+	edbInfoMap := make(map[int]string)
+	//移除研究员选择指标中的未使用的指标
+	{
+		//转大写的计算公式
+		upperCalculateFormulaStr := strings.ToUpper(req.CalculateFormula)
+		//用到的指标
+		newEdbInfoIdArr := make([]models.EdbInfoFromTag, 0)
+		for _, tmpEdbInfo := range req.EdbInfoIdArr {
+			_, ok := edbInfoMap[tmpEdbInfo.EdbInfoId]
+			if ok {
+				err = fmt.Errorf("选择指标失败，请勿选择重复指标！")
+				return
+			}
+			edbInfoMap[tmpEdbInfo.EdbInfoId] = tmpEdbInfo.FromTag
+
+			upperFromTag := strings.ToUpper(tmpEdbInfo.FromTag)
+			if strings.Contains(upperCalculateFormulaStr, upperFromTag) {
+				newEdbInfoIdArr = append(newEdbInfoIdArr, tmpEdbInfo)
+			}
+		}
+		req.EdbInfoIdArr = newEdbInfoIdArr
+	}
+
+	var condition string
+	var pars []interface{}
+	condition += " AND edb_name=? "
+	pars = append(pars, req.EdbName)
+
+	count, err := models.GetEdbInfoCountByCondition(condition, pars)
+	if err != nil {
+		errMsg = "判断指标名称是否存在失败,Err:" + err.Error()
+		err = fmt.Errorf("判断指标名称是否存在失败")
+		return
+	}
+
+	if count > 0 {
+		err = fmt.Errorf("指标名称已存在，请重新填写")
+		errMsg = "指标名称已存在，请重新填写"
+		//br.IsSendEmail = false
+		return
+	}
+	//检验公式
+	var formulaStr string
+	var edbInfoIdBytes []string
+	for _, v := range req.EdbInfoIdArr {
+		formulaStr += v.FromTag + ","
+		edbInfoIdBytes = append(edbInfoIdBytes, v.FromTag)
+	}
+	formulaSlice, err := utils.CheckFormulaJson(req.CalculateFormula)
+	if err != nil {
+		err = fmt.Errorf("公式格式错误，请重新填写")
+		return
+	}
+	for _, formula := range formulaSlice {
+		formulaMap, e := utils.CheckFormula(formula)
+		if e != nil {
+			err = fmt.Errorf("公式错误，请重新填写")
+			return
+		}
+		for _, v := range formulaMap {
+			if !strings.Contains(formulaStr, v) {
+				err = fmt.Errorf("公式错误，请重新填写")
+				return
+			}
+		}
+	}
+
+	//关联的指标信息
+	edbInfoList := make([]*models.EdbInfo, 0)
+	//关联的指标数据表
+	calculateMappingList := make([]*models.EdbInfoCalculateMapping, 0)
+	for k, v := range req.EdbInfoIdArr {
+		fromEdbInfo, e := models.GetEdbInfoById(v.EdbInfoId)
+		if e != nil {
+			if e.Error() == utils.ErrNoRow() {
+				err = fmt.Errorf("生成计算指标失败")
+				errMsg = "指标 " + strconv.Itoa(v.EdbInfoId) + " 不存在"
+				return
+			}
+			err = fmt.Errorf("生成计算指标失败")
+			errMsg = "获取指标失败:Err:" + e.Error()
+			return
+		}
+
+		edbInfoList = append(edbInfoList, fromEdbInfo)
+		//关联关系表
+		{
+			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:                   v.FromTag,
+				Sort:                      k + 1,
+				CreateTime:                time.Now(),
+				ModifyTime:                time.Now(),
+			}
+			//calculateMappingItem.EdbCode = edbCode
+			//calculateMappingItem.EdbInfoId = int(edbInfoId)
+			calculateMappingList = append(calculateMappingList, calculateMappingItem)
+		}
+	}
+
+	for _, v := range formulaSlice {
+		formulaMap, e := utils.CheckFormula(v)
+		if e != nil {
+			err = fmt.Errorf("公式错误，请重新填写")
+			return
+		}
+		//预先计算，判断公式是否正常
+		ok, _ := models.CheckFormula2(edbInfoList, formulaMap, v, edbInfoIdBytes)
+		if !ok {
+			err = fmt.Errorf("生成计算指标失败，请使用正确的计算公式")
+			return
+		}
+	}
+
+	randStr := utils.GetRandDigit(4)
+	edbCode := `C` + time.Now().Format("060102") + randStr
+	timestamp := strconv.FormatInt(time.Now().UnixNano(), 10)
+	uniqueCode = utils.MD5(utils.DATA_PREFIX + "_" + timestamp)
+
+	// 新增计算指标
+	edbInfo, err = models.AddCalculateInfo(req, calculateMappingList, edbInfoList, edbCode, uniqueCode, edbInfoIdBytes)
+	if err != nil {
+		errMsg = "生成计算指标失败,AddEdbInfo Err:" + err.Error()
+		err = fmt.Errorf("生成计算指标失败")
+		return
+	}
+
+	return
+}