fix：计算指标新增逻辑调整

controllers/base_from_calculate.go

@@ -17,9 +17,9 @@ type CalculateController struct {
 }
 
 // Add
-// @Title 编辑指标接口
-// @Description 编辑指标接口
-// @Success 200 {object} models.EditEdbInfoReq
+// @Title 新增计算指标接口
+// @Description 新增计算指标接口
+// @Success 200 {object} models.EdbInfoCalculateSaveReq
 // @router /add [post]
 func (this *CalculateController) Add() {
 	br := new(models.BaseResponse).Init()
@@ -27,7 +27,7 @@ func (this *CalculateController) Add() {
 		this.Data["json"] = br
 		this.ServeJSON()
 	}()
-	//source := utils.DATA_SOURCE_WIND
+
 	var req models.EdbInfoCalculateSaveReq
 	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
 	if err != nil {
@@ -35,6 +35,7 @@ func (this *CalculateController) Add() {
 		br.ErrMsg = "参数解析失败，Err:" + err.Error()
 		return
 	}
+
 	req.EdbName = strings.Trim(req.EdbName, " ")
 	if req.EdbName == "" {
 		br.Msg = "指标名称不能为空"
@@ -65,9 +66,16 @@ 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_info:calculate:batch:save:", utils.DATA_SOURCE_CALCULATE, ":", req.EdbName)
+	redisKey := fmt.Sprint("edb_lib:edb_info:calculate:add:", utils.DATA_SOURCE_CALCULATE, ":", req.EdbName)
 	isExist := utils.Rc.IsExist(redisKey)
 	if isExist {
 		br.Msg = "指标正在处理,请勿重复提交"
@@ -80,15 +88,29 @@ func (this *CalculateController) Add() {
 		}()
 	}
 
-	calculateFormula := req.CalculateFormula
-	calculateFormula = strings.Replace(calculateFormula, "（", "(", -1)
-	calculateFormula = strings.Replace(calculateFormula, "）", ")", -1)
-	calculateFormula = strings.Replace(calculateFormula, "，", ",", -1)
-	calculateFormula = strings.Replace(calculateFormula, "。", ".", -1)
-	if strings.Contains(req.CalculateFormula, "%") {
-		calculateFormula = strings.Replace(calculateFormula, "%", "*0.01", -1)
+	//判断是否重复指标
+	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
 	}
-	req.CalculateFormula = calculateFormula
 
 	var condition string
 	var pars []interface{}
@@ -101,9 +123,11 @@ func (this *CalculateController) Add() {
 		br.ErrMsg = "判断指标名称是否存在失败,Err:" + err.Error()
 		return
 	}
+
 	if count > 0 {
 		br.Msg = "指标名称已存在，请重新填写"
 		br.ErrMsg = "指标名称已存在，请重新填写"
+		br.IsSendEmail = false
 		return
 	}
 	//检验公式
@@ -121,36 +145,97 @@ func (this *CalculateController) Add() {
 		}
 	}
 
+	//关联的指标信息
+	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)
+		}
+	}
+	ok, _ := models.CheckFormula2(edbInfoList, formulaMap, calculateFormula, 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 := &models.EdbInfo{
-		Source:           utils.DATA_SOURCE_CALCULATE,
+		EdbInfoId:        0,
 		SourceName:       "指标运算",
+		Source:           utils.DATA_SOURCE_CALCULATE,
 		EdbCode:          edbCode,
 		EdbName:          req.EdbName,
 		EdbNameSource:    req.EdbName,
 		Frequency:        req.Frequency,
 		Unit:             req.Unit,
+		StartDate:        "",
+		EndDate:          "",
 		ClassifyId:       req.ClassifyId,
 		SysUserId:        req.AdminId,
 		SysUserRealName:  req.AdminName,
+		UniqueCode:       uniqueCode,
 		CreateTime:       time.Now(),
 		ModifyTime:       time.Now(),
-		UniqueCode:       uniqueCode,
+		MinValue:         0,
+		MaxValue:         0,
 		CalculateFormula: req.CalculateFormula,
 		EdbType:          2,
+		Sort:             0,
+		MoveType:         0,
+		MoveFrequency:    "",
+		NoUpdate:         0,
+		ServerUrl:        "",
+		EdbInfoType:      0,
+		EdbNameEn:        "",
+		UnitEn:           "",
+		LatestDate:       "",
+		LatestValue:      0,
+		ChartImage:       "",
 	}
-
 	edbInfoId, err := models.AddEdbInfo(edbInfo)
 	if err != nil {
 		br.Msg = "生成计算指标失败"
 		br.Msg = "生成计算指标失败,AddEdbInfo Err:" + err.Error()
 		return
 	}
-	edbInfo.EdbInfoId = int(edbInfoId)
 	//处理同名指标
 	{
 		edbNameList, err := models.GetEdbInfoByName(req.EdbName)
@@ -172,50 +257,19 @@ func (this *CalculateController) Add() {
 		}
 	}
 
-	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{
-				CreateTime:     time.Now(),
-				ModifyTime:     time.Now(),
-				Sort:           k + 1,
-				EdbCode:        edbCode,
-				EdbInfoId:      int(edbInfoId),
-				FromEdbInfoId:  fromEdbInfo.EdbInfoId,
-				FromEdbCode:    fromEdbInfo.EdbCode,
-				FromEdbName:    fromEdbInfo.EdbName,
-				FromSource:     fromEdbInfo.Source,
-				FromSourceName: fromEdbInfo.SourceName,
-				FromTag:        v.FromTag,
-				Source:         utils.DATA_SOURCE_CALCULATE,
-				SourceName:     "指标运算",
-			}
-			calculateMappingList = append(calculateMappingList, calculateMappingItem)
-		}
-	}
 	//关联关系表
 	{
+		//处理关联指标
+		for _, v := range calculateMappingList {
+			v.EdbCode = edbCode
+			v.EdbInfoId = int(edbInfoId)
+		}
 		if len(calculateMappingList) > 0 {
 			go models.AddEdbInfoCalculateMappingMulti(calculateMappingList)
 		}
 	}
 
+	// 指标数据入库
 	err = models.AddCalculate(edbInfoList, int(edbInfoId), edbCode, req.CalculateFormula, edbInfoIdBytes)
 	if err != nil {
 		br.Msg = "生成计算指标失败"
@@ -241,13 +295,274 @@ func (this *CalculateController) Add() {
 	br.IsAddLog = true
 }
 
-// CalculateBatchSave
+// Edit
+// @Title 编辑计算指标接口
+// @Description 编辑计算指标接口
+// @Success 200 {object} models.EdbInfoCalculateSaveReq
+// @router /edit [post]
+func (this *CalculateController) Edit() {
+	br := new(models.BaseResponse).Init()
+	defer func() {
+		this.Data["json"] = br
+		this.ServeJSON()
+	}()
+
+	var req models.EdbInfoCalculateSaveReq
+	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
+	if err != nil {
+		br.Msg = "参数解析异常！"
+		br.ErrMsg = "参数解析失败，Err:" + err.Error()
+		return
+	}
+
+	if req.EdbInfoId <= 0 {
+		br.Msg = "参数错误"
+		br.ErrMsg = "指标ID：" + strconv.Itoa(req.EdbInfoId)
+		return
+	}
+
+	req.EdbName = strings.Trim(req.EdbName, " ")
+	if req.EdbName == "" {
+		br.Msg = "指标名称不能为空"
+		return
+	}
+
+	if req.Frequency == "" {
+		br.Msg = "频率不能为空"
+		return
+	}
+
+	if req.Unit == "" {
+		br.Msg = "单位不能为空"
+		return
+	}
+
+	if req.ClassifyId <= 0 {
+		br.Msg = "请选择分类"
+		return
+	}
+
+	if len(req.EdbInfoIdArr) <= 0 {
+		br.Msg = "请选择指标"
+		return
+	}
+
+	if req.CalculateFormula == "" {
+		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
+	fmt.Println("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 {
+				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)
+
+	condition += " AND edb_info_id<>? "
+	pars = append(pars, req.EdbInfoId)
+
+	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
+	}
+
+	//判断公式，指标是否有改动
+	edbInfoDetail, err := models.GetEdbInfoById(req.EdbInfoId)
+	if err != nil {
+		br.Msg = "修改失败"
+		br.Msg = "获取指标信息失败,GetEdbInfoById Err:" + err.Error()
+		return
+	}
+	if edbInfoDetail == nil {
+		br.Msg = "修改失败"
+		br.Msg = "指标信息不存在，EdbInfoId:" + strconv.Itoa(req.EdbInfoId)
+		return
+	}
+	var needCalculate bool
+
+	if edbInfoDetail.CalculateFormula != req.CalculateFormula {
+		needCalculate = true
+	}
+
+	//检验公式
+	var formulaStr string
+	var edbInfoIdBytes []string
+	var edbInfoIdArr []string
+	for _, v := range req.EdbInfoIdArr {
+		formulaStr += v.FromTag + ","
+		edbInfoIdBytes = append(edbInfoIdBytes, v.FromTag)
+		edbInfoIdArr = append(edbInfoIdArr, strconv.Itoa(v.EdbInfoId))
+		if v.EdbInfoId == req.EdbInfoId {
+			br.Msg = "计算指标中包含此指标，不能修改"
+			return
+		}
+	}
+
+	if needCalculate == false {
+		edbInfoIdStr := strings.Join(edbInfoIdArr, ",")
+		fromEdbInfoId, err := models.GetCalculateEdbInfo(req.EdbInfoId)
+		if err != nil {
+			br.Msg = "修改失败"
+			br.Msg = "获取数据失败，GetCalculateEdbInfo:" + err.Error()
+			return
+		}
+
+		if edbInfoIdStr != fromEdbInfoId {
+			needCalculate = true
+		}
+	}
+
+	formulaMap := services.CheckFormula(req.CalculateFormula)
+	for _, v := range formulaMap {
+		if !strings.Contains(formulaStr, v) {
+			br.Msg = "公式错误，请重新填写"
+			return
+		}
+	}
+	//重新计算
+	if needCalculate {
+		err = models.DeleteCalculateEdbInfo(req.EdbInfoId)
+		if err != nil {
+			br.Msg = "修改失败"
+			br.Msg = "修改失败,DeleteCalculateEdbInfo Err:" + err.Error()
+			return
+		}
+		//calculateList := make([]*data_manage.EdbInfoCalculate, 0)
+		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:                 req.EdbInfoId,
+					Source:                    edbInfoDetail.Source,
+					SourceName:                edbInfoDetail.SourceName,
+					EdbCode:                   edbInfoDetail.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(),
+				}
+				calculateMappingList = append(calculateMappingList, calculateMappingItem)
+			}
+		}
+
+		//预先计算，判断公式是否正常
+		ok, _ := models.CheckFormula2(edbInfoList, formulaMap, calculateFormula, edbInfoIdBytes)
+		if !ok {
+			br.Msg = "生成计算指标失败，请使用正确的计算公式"
+			return
+		}
+
+		//关联关系表
+		{
+			if len(calculateMappingList) > 0 {
+				go models.AddEdbInfoCalculateMappingMulti(calculateMappingList)
+			}
+		}
+
+		err = models.AddCalculate(edbInfoList, edbInfoDetail.EdbInfoId, edbInfoDetail.EdbCode, req.CalculateFormula, edbInfoIdBytes)
+		if err != nil {
+			br.Msg = "生成计算指标失败"
+			br.Msg = "生成计算指标失败,Calculate Err:" + err.Error()
+			return
+		}
+		// 更新指标最大最小值
+		err, errMsg := models.UnifiedModifyEdbInfoMaxAndMinInfo(edbInfoDetail)
+		if err != nil {
+			br.Msg = errMsg
+			br.ErrMsg = err.Error()
+			return
+		}
+	}
+
+	// 修改指标信息
+	err = models.ModifyCalculateEdbInfo(req.EdbName, req.Frequency, req.Unit, req.CalculateFormula, req.ClassifyId, req.EdbInfoId)
+	if err != nil {
+		br.Msg = "修改失败"
+		br.Msg = "修改失败,ModifyEdbInfo Err:" + err.Error()
+		return
+	}
+
+	resp := models.AddEdbInfoResp{
+		EdbInfoId:  edbInfoDetail.EdbInfoId,
+		UniqueCode: edbInfoDetail.UniqueCode,
+	}
+	br.Ret = 200
+	br.Success = true
+	br.Msg = "保存成功"
+	br.Data = resp
+	br.IsAddLog = true
+}
+
+// BatchSave
 // @Title 累计值转月-同比值-同差等计算新增
 // @Description 累计值转月-同比值-同差等计算新增接口
-// @Param	request	body models.EdbInfoCalculateBatchSaveReq true "type json string"
+// @Param request body models.EdbInfoCalculateBatchSaveReq true "type json string"
 // @Success Ret=200 返回指标id
 // @router /batch/save [post]
-func (this *CalculateController) CalculateBatchSave() {
+func (this *CalculateController) BatchSave() {
 	br := new(models.BaseResponse).Init()
 	defer func() {
 		this.Data["json"] = br
@@ -292,7 +607,7 @@ func (this *CalculateController) CalculateBatchSave() {
 	if req.Source == utils.DATA_SOURCE_CALCULATE_NSZYDPJJS ||
 		req.Source == utils.DATA_SOURCE_CALCULATE_HBZ ||
 		req.Source == utils.DATA_SOURCE_CALCULATE_HCZ ||
-		req.Source == utils.DATA_SOURCE_CALCULATE_TIME_SHIFT {
+		req.Source == utils.DATA_SOURCE_CALCULATE_TIME_SHIFT || req.Source == utils.DATA_SOURCE_CALCULATE_CJJX {
 		if req.Formula == "" {
 			br.Msg = "请填写N值"
 			return
@@ -313,16 +628,8 @@ func (this *CalculateController) CalculateBatchSave() {
 		}
 	}
 
-	// 获取指标详情
-	edbInfo, err := models.GetEdbInfoById(req.EdbInfoId)
-	if err != nil {
-		br.Msg = "指标不存在！"
-		br.ErrMsg = "指标不存在"
-		return
-	}
-
 	//加入缓存机制，避免创建同一个名称的指标 start
-	redisKey := fmt.Sprint("edb_info:calculate:batch:save:", req.Source, ":", req.EdbName)
+	redisKey := fmt.Sprint("edb_lib:edb_info:calculate:batch:save:", req.Source, ":", req.EdbName)
 	isExist := utils.Rc.IsExist(redisKey)
 	if isExist {
 		br.Msg = "指标正在处理,请勿重复提交"
@@ -351,6 +658,7 @@ func (this *CalculateController) CalculateBatchSave() {
 	if count > 0 {
 		br.Msg = "指标名称已存在，请重新填写"
 		br.ErrMsg = "指标名称已存在，请重新填写"
+		br.IsSendEmail = false
 		return
 	}
 
@@ -367,27 +675,29 @@ func (this *CalculateController) CalculateBatchSave() {
 	timestamp := strconv.FormatInt(time.Now().UnixNano(), 10)
 	uniqueCode := utils.MD5(utils.DATA_PREFIX + "_" + timestamp)
 
-	adminId := req.AdminId
-	adminName := req.AdminName
+	sysUserId := req.AdminId
+	sysUserName := req.AdminName
+
 	var sourName string
 	var edbInfoId int
+	var edbInfo *models.EdbInfo
 	if req.Source == utils.DATA_SOURCE_CALCULATE_LJZZY {
 		sourName = "累计值转月值"
 		if fromEdbInfo.Frequency != "月度" {
 			br.Msg = "请选择月度指标"
 			return
 		}
-		edbInfoId, err = models.AddCalculateLjzzy(&req, fromEdbInfo, edbCode, uniqueCode, adminId, adminName)
+		edbInfo, err = models.AddCalculateLjzzy(&req, fromEdbInfo, edbCode, uniqueCode, sysUserId, sysUserName)
 	} else if req.Source == utils.DATA_SOURCE_CALCULATE_TBZ {
 		sourName = "同比值"
-		edbInfoId, err = models.AddCalculateTbz(&req, fromEdbInfo, edbCode, uniqueCode, adminId, adminName)
+		edbInfo, err = models.AddCalculateTbz(&req, fromEdbInfo, edbCode, uniqueCode, sysUserId, sysUserName)
 	} else if req.Source == utils.DATA_SOURCE_CALCULATE_TCZ {
 		sourName = "同差值"
-		edbInfoId, err = models.AddCalculateTcz(&req, fromEdbInfo, edbCode, uniqueCode, adminId, adminName)
+		edbInfo, err = models.AddCalculateTcz(&req, fromEdbInfo, edbCode, uniqueCode, sysUserId, sysUserName)
 	} else if req.Source == utils.DATA_SOURCE_CALCULATE_NSZYDPJJS {
 		sourName = "N数值移动平均计算"
-		edbInfoId, err = models.AddCalculateNszydpjjs(&req, fromEdbInfo, edbCode, uniqueCode, adminId, adminName, formulaInt)
-	} else if req.Source == utils.DATA_SOURCE_CALCULATE_HBZ { //环比值
+		edbInfo, err = models.AddCalculateNszydpjjs(&req, fromEdbInfo, edbCode, uniqueCode, sysUserId, sysUserName, formulaInt)
+	} else if req.Source == utils.DATA_SOURCE_CALCULATE_HBZ {
 		var condition string
 		var pars []interface{}
 		condition += " AND edb_info_id =? "
@@ -405,21 +715,21 @@ func (this *CalculateController) CalculateBatchSave() {
 			return
 		}
 		sourName = "环比值"
-		edbInfoId, err = models.AddCalculateHbz(&req, fromEdbInfo, edbCode, uniqueCode, adminId, adminName, formulaInt)
+		edbInfo, err = models.AddCalculateHbz(&req, fromEdbInfo, edbCode, uniqueCode, sysUserId, sysUserName, formulaInt)
 	} else if req.Source == utils.DATA_SOURCE_CALCULATE_HCZ {
 		sourName = "环差值"
-		edbInfoId, err = models.AddCalculateHcz(&req, fromEdbInfo, edbCode, uniqueCode, adminId, adminName, formulaInt)
+		edbInfo, err = models.AddCalculateHcz(&req, fromEdbInfo, edbCode, uniqueCode, sysUserId, sysUserName, formulaInt)
 	} else if req.Source == utils.DATA_SOURCE_CALCULATE_BP {
-		if fromEdbInfo.Frequency == "日度" {
-			br.Msg = "日度指标,无法进行变频操作"
-			br.ErrMsg = "日度指标,无法进行变频操作:edbcode:" + fromEdbInfo.EdbCode
-			return
-		}
+		//if fromEdbInfo.Frequency == "日度" {
+		//	br.Msg = "日度指标,无法进行变频操作"
+		//	br.ErrMsg = "日度指标,无法进行变频操作:edbcode:" + fromEdbInfo.EdbCode
+		//	return
+		//}
 		sourName = "变频"
-		edbInfoId, err = models.AddCalculateBp(&req, fromEdbInfo, edbCode, uniqueCode, adminId, adminName)
+		edbInfo, err = models.AddCalculateBp(&req, fromEdbInfo, edbCode, uniqueCode, sysUserId, sysUserName)
 	} else if req.Source == utils.DATA_SOURCE_CALCULATE_TIME_SHIFT { //时间移位
 		sourName = "时间移位"
-		edbInfoId, err = models.AddCalculateTimeShift(&req, fromEdbInfo, edbCode, uniqueCode, adminId, adminName)
+		edbInfo, err = models.AddCalculateTimeShift(&req, fromEdbInfo, edbCode, uniqueCode, sysUserId, sysUserName)
 	} else if req.Source == utils.DATA_SOURCE_CALCULATE_ZJPJ { //直接拼接
 		sourName = "直接拼接"
 
@@ -442,7 +752,7 @@ func (this *CalculateController) CalculateBatchSave() {
 			br.ErrMsg = "两个指标不允许为同一个"
 			return
 		}
-		edbInfoId, err = models.AddCalculateZjpj(&req, fromEdbInfo, secondEdbInfo, edbCode, uniqueCode, adminId, adminName)
+		edbInfo, err = models.AddCalculateZjpj(&req, fromEdbInfo, secondEdbInfo, edbCode, uniqueCode, sysUserId, sysUserName)
 	} else if req.Source == utils.DATA_SOURCE_CALCULATE_LJZTBPJ { //累计值同比拼接
 		sourName = "累计值同比拼接"
 
@@ -480,23 +790,28 @@ func (this *CalculateController) CalculateBatchSave() {
 			br.ErrMsg = "两个指标不允许为同一个"
 			return
 		}
-		edbInfoId, err = models.AddCalculateLjztbpj(&req, fromEdbInfo, tbzEdbInfo, edbCode, uniqueCode, adminId, adminName)
+		edbInfo, err = models.AddCalculateLjztbpj(&req, fromEdbInfo, tbzEdbInfo, edbCode, uniqueCode, sysUserId, sysUserName)
+	} else if req.Source == utils.DATA_SOURCE_CALCULATE_CJJX {
+		sourName = "超季节性"
+		edbInfo, err = models.AddCalculateCjjx(&req, fromEdbInfo, edbCode, uniqueCode, sysUserId, sysUserName, formulaInt)
 	} else {
 		br.Msg = "无效计算方式"
 		br.ErrMsg = "无效计算方式,source:" + strconv.Itoa(req.Source)
 		return
 	}
-
 	if err != nil {
 		br.Msg = "生成" + sourName + "失败"
 		br.Msg = "生成" + sourName + "失败 Err:" + err.Error()
 		return
 	}
-	if edbInfoId <= 0 {
+
+	if edbInfo == nil {
 		br.Msg = "生成" + sourName + "失败"
 		br.ErrMsg = "生成" + sourName + "失败,指标ID错误:" + strconv.Itoa(edbInfoId)
 		return
 	}
+	edbInfoId = edbInfo.EdbInfoId
+
 	//处理同名指标
 	{
 		edbNameList, err := models.GetEdbInfoByName(req.EdbName)
@@ -525,9 +840,10 @@ func (this *CalculateController) CalculateBatchSave() {
 		br.ErrMsg = err.Error()
 		return
 	}
+
 	resp := models.AddEdbInfoResp{
-		EdbInfoId:  edbInfoId,
-		UniqueCode: uniqueCode,
+		EdbInfoId:  edbInfo.EdbInfoId,
+		UniqueCode: edbInfo.UniqueCode,
 	}
 	br.Ret = 200
 	br.Success = true
@@ -792,6 +1108,24 @@ func (this *CalculateController) Refresh() {
 				errMsg = "RefreshAllPythonEdb Err:" + err.Error()
 				break
 			}
+		case utils.DATA_SOURCE_CALCULATE_CJJX: //超季节性
+			calculateCjjx, err := models.GetEdbInfoCalculateMappingDetail(edbInfoId)
+			if err != nil {
+				errMsg = "GetEdbInfoCalculateNszydpjjsDetail Err:" + err.Error()
+				break
+			}
+			fromEdbInfo, err := models.GetEdbInfoById(calculateCjjx.FromEdbInfoId)
+			if err != nil {
+				errMsg = "GetEdbInfoById Err:" + err.Error()
+				break
+			}
+			formulaInt, _ := strconv.Atoi(edbInfo.CalculateFormula)
+			startDate = edbInfo.StartDate
+			err = models.RefreshAllCalculateCjjx(edbInfoId, edbInfo.Source, fromEdbInfo, calculateCjjx.EdbCode, startDate, "", formulaInt)
+			if err != nil && err.Error() != utils.ErrNoRow() {
+				errMsg = "RefreshAllCalculateCjjx Err:" + err.Error()
+				break
+			}
 
 		default:
 			br.Msg = "来源异常，请联系相关开发！"

models/base_from_calculate.go

@@ -23,10 +23,13 @@ type EdbInfoCalculateSaveReq struct {
 	Unit             string `description:"单位"`
 	ClassifyId       int    `description:"分类id"`
 	CalculateFormula string `description:"计算公式"`
-	EdbInfoIdArr     []struct {
-		EdbInfoId int    `description:"指标id"`
-		FromTag   string `description:"指标对应标签"`
-	}
+	EdbInfoIdArr     []EdbInfoFromTag
+}
+
+// EdbInfoFromTag 计算指标的关联指标
+type EdbInfoFromTag struct {
+	EdbInfoId int    `description:"指标id"`
+	FromTag   string `description:"指标对应标签"`
 }
 
 // CalculateItems 计算（运算）指标信息
@@ -121,6 +124,42 @@ func AddCalculate(edbInfoIdArr []*EdbInfo, edbInfoId int, edbCode, formulaStr st
 	return
 }
 
+// GetCalculateEdbInfo 获取计算指标的关联指标id
+func GetCalculateEdbInfo(edbInfoId int) (from_edb_info_id string, err error) {
+	o := orm.NewOrm()
+	sql := ` SELECT GROUP_CONCAT(from_edb_info_id ORDER BY sort ASC SEPARATOR ',') AS from_edb_info_id 
+			FROM edb_info_calculate_mapping
+			WHERE edb_info_id=?
+			GROUP BY edb_info_id
+			 `
+	err = o.Raw(sql, edbInfoId).QueryRow(&from_edb_info_id)
+	return
+}
+
+// DeleteCalculateEdbInfo 删除指标信息
+func DeleteCalculateEdbInfo(edbInfoId int) (err error) {
+	o := orm.NewOrm()
+	to, err := o.Begin()
+	if err != nil {
+		return
+	}
+	defer func() {
+		if err != nil {
+			_ = to.Rollback()
+		} else {
+			_ = to.Commit()
+		}
+	}()
+	sql := `DELETE FROM edb_data_calculate WHERE edb_info_id=?`
+	_, err = to.Raw(sql, edbInfoId).Exec()
+	if err != nil {
+		return
+	}
+	sql = `DELETE FROM edb_info_calculate_mapping WHERE edb_info_id=?`
+	_, err = to.Raw(sql, edbInfoId).Exec()
+	return
+}
+
 // RefreshAllCalculate 刷新全部数据
 func RefreshAllCalculate(edbInfoIdArr []*EdbInfo, edbInfoId, source int, edbCode, formulaStr, startDate, endDate string, edbInfoIdBytes []string) (err error) {
 	o := orm.NewOrm()

models/edb_data_calculate_bp.go

@@ -12,7 +12,7 @@ import (
 )
 
 // AddCalculateBp 变频
-func AddCalculateBp(req *EdbInfoCalculateBatchSaveReq, fromEdbInfo *EdbInfo, edbCode, uniqueCode string, sysUserId int, sysUserRealName string) (edbInfoId int, err error) {
+func AddCalculateBp(req *EdbInfoCalculateBatchSaveReq, fromEdbInfo *EdbInfo, edbCode, uniqueCode string, sysUserId int, sysUserRealName string) (edbInfo *EdbInfo, err error) {
 	o := orm.NewOrm()
 	to, err := o.Begin()
 	if err != nil {
@@ -27,7 +27,7 @@ func AddCalculateBp(req *EdbInfoCalculateBatchSaveReq, fromEdbInfo *EdbInfo, edb
 		}
 	}()
 	if req.EdbInfoId <= 0 {
-		edbInfo := new(EdbInfo)
+		edbInfo = new(EdbInfo)
 		edbInfo.Source = utils.DATA_SOURCE_CALCULATE_BP
 		edbInfo.SourceName = "变频"
 		edbInfo.EdbCode = edbCode
@@ -45,9 +45,10 @@ func AddCalculateBp(req *EdbInfoCalculateBatchSaveReq, fromEdbInfo *EdbInfo, edb
 		edbInfo.EdbType = 2
 		newEdbInfoId, tmpErr := to.Insert(edbInfo)
 		if tmpErr != nil {
-			return edbInfoId, tmpErr
+			err = tmpErr
+			return
 		}
-		edbInfoId = int(newEdbInfoId)
+		edbInfo.EdbInfoId = int(newEdbInfoId)
 		//关联关系
 		{
 			calculateMappingItem := new(EdbInfoCalculateMapping)
@@ -55,7 +56,7 @@ func AddCalculateBp(req *EdbInfoCalculateBatchSaveReq, fromEdbInfo *EdbInfo, edb
 			calculateMappingItem.ModifyTime = time.Now()
 			calculateMappingItem.Sort = 1
 			calculateMappingItem.EdbCode = edbCode
-			calculateMappingItem.EdbInfoId = edbInfoId
+			calculateMappingItem.EdbInfoId = edbInfo.EdbInfoId
 			calculateMappingItem.FromEdbInfoId = fromEdbInfo.EdbInfoId
 			calculateMappingItem.FromEdbCode = fromEdbInfo.EdbCode
 			calculateMappingItem.FromEdbName = fromEdbInfo.EdbName
@@ -70,7 +71,10 @@ func AddCalculateBp(req *EdbInfoCalculateBatchSaveReq, fromEdbInfo *EdbInfo, edb
 			}
 		}
 	} else {
-		edbInfoId = req.EdbInfoId
+		edbInfo, err = GetEdbInfoById(req.EdbInfoId)
+		if err != nil {
+			return
+		}
 		dataTableName := GetEdbDataTableName(utils.DATA_SOURCE_CALCULATE_BP)
 		fmt.Println("dataTableName:" + dataTableName)
 		deleteSql := ` DELETE FROM %s WHERE edb_info_id=? `
@@ -81,78 +85,9 @@ func AddCalculateBp(req *EdbInfoCalculateBatchSaveReq, fromEdbInfo *EdbInfo, edb
 		}
 	}
 
-	edbInfoIdStr := strconv.Itoa(edbInfoId)
-	fmt.Println("edbInfoIdStr:" + edbInfoIdStr)
 	//计算数据
-	var condition string
-	var pars []interface{}
-	condition += " AND edb_info_id=? "
-	if req.EdbInfoId <= 0 {
-		pars = append(pars, req.FromEdbInfoId)
-	} else {
-		pars = append(pars, fromEdbInfo.EdbInfoId)
-	}
-	dataList, err := GetEdbDataListAll(condition, pars, fromEdbInfo.Source, 0)
-	if err != nil {
-		return edbInfoId, err
-	}
-
-	addSql := ` INSERT INTO edb_data_calculate_bp(edb_info_id,edb_code,data_time,value,create_time,modify_time,data_timestamp) values `
-	var isAdd bool
-	existMap := make(map[string]string)
-	dataLen := len(dataList)
-	fmt.Println("dataLen:", dataLen)
+	err = refreshAllCalculateBp(to, edbInfo.EdbInfoId, edbInfo.Source, fromEdbInfo, edbInfo.EdbCode, "", "")
 
-	for i := 0; i < dataLen; i++ {
-		//当期
-		currentItem := dataList[i]
-		currentDate, _ := time.Parse(utils.FormatDate, currentItem.DataTime)
-		var day int
-		var preItem *EdbInfoSearchData
-		var preDate time.Time
-		if i == 0 {
-			day = int(time.Now().Sub(currentDate).Hours() / float64(24))
-			preDate = time.Now()
-		} else {
-			j := i - 1
-			if j < dataLen {
-				preItem = dataList[j]
-				preDate, _ = time.Parse(utils.FormatDate, preItem.DataTime)
-				day = int(preDate.Sub(currentDate).Hours() / float64(24))
-				utils.FileLog.Info("preItem.DataTime:" + preItem.DataTime + ";currentItem.DataTime" + currentItem.DataTime)
-			}
-		}
-		for k := 0; k <= day; k++ {
-			needDay := preDate.AddDate(0, 0, -k)
-			needDayStr := needDay.Format(utils.FormatDate)
-			existKey := edbCode + needDayStr
-			if _, ok := existMap[existKey]; !ok {
-				timestamp := needDay.UnixNano() / 1e6
-				timestampStr := fmt.Sprintf("%d", timestamp)
-				valStr := decimal.NewFromFloat(currentItem.Value).String()
-				addSql += GetAddSql(edbInfoIdStr, edbCode, needDayStr, timestampStr, valStr)
-				isAdd = true
-			}
-			existMap[existKey] = needDayStr
-		}
-		existKey := edbCode + currentItem.DataTime
-		if _, ok := existMap[existKey]; !ok {
-			currentDate, _ := time.Parse(utils.FormatDate, currentItem.DataTime)
-			timestamp := currentDate.UnixNano() / 1e6
-			timestampStr := fmt.Sprintf("%d", timestamp)
-			valStr := decimal.NewFromFloat(currentItem.Value).String()
-			addSql += GetAddSql(edbInfoIdStr, edbCode, currentItem.DataTime, timestampStr, valStr)
-			isAdd = true
-		}
-		existMap[existKey] = currentItem.DataTime
-	}
-	if isAdd {
-		addSql = strings.TrimRight(addSql, ",")
-		_, err = to.Raw(addSql).Exec()
-		if err != nil {
-			return edbInfoId, err
-		}
-	}
 	return
 }
 
@@ -484,11 +419,15 @@ func RefreshAllCalculateBp(edbInfoId, source int, fromEdbInfo *EdbInfo, edbCode,
 		}
 	}()
 
-	if err != nil {
-		return
-	}
+	// 计算数据
+	err = refreshAllCalculateBp(to, edbInfoId, source, fromEdbInfo, edbCode, startDate, endDate)
+
+	return
+}
+
+// refreshAllCalculateBp 刷新变频数据
+func refreshAllCalculateBp(to orm.TxOrmer, edbInfoId, source int, fromEdbInfo *EdbInfo, edbCode, startDate, endDate string) (err error) {
 	edbInfoIdStr := strconv.Itoa(edbInfoId)
-	//计算数据
 
 	//计算数据
 	var condition string
@@ -619,7 +558,7 @@ func RefreshAllCalculateBp(edbInfoId, source int, fromEdbInfo *EdbInfo, edbCode,
 			//如果没有来源指标数据，那么已经入库的计算指标数据需要全部删除
 			tableName := GetEdbDataTableName(source)
 			sql := fmt.Sprintf(` DELETE FROM %s WHERE edb_info_id = ?`, tableName)
-			_, err = o.Raw(sql, edbInfoId).Exec()
+			_, err = to.Raw(sql, edbInfoId).Exec()
 			if err != nil {
 				err = fmt.Errorf("删除所有的变频指标数据失败,Err:" + err.Error())
 				return
@@ -639,7 +578,7 @@ func RefreshAllCalculateBp(edbInfoId, source int, fromEdbInfo *EdbInfo, edbCode,
 		tableName := GetEdbDataTableName(source)
 		sql := fmt.Sprintf(` DELETE FROM %s WHERE edb_info_id = ? and data_time in (%s) `, tableName, removeDateStr)
 
-		_, err = o.Raw(sql, edbInfoId).Exec()
+		_, err = to.Raw(sql, edbInfoId).Exec()
 		if err != nil {
 			err = fmt.Errorf("删除不存在的变频指标数据失败,Err:" + err.Error())
 			return
@@ -648,7 +587,7 @@ func RefreshAllCalculateBp(edbInfoId, source int, fromEdbInfo *EdbInfo, edbCode,
 
 	if isAdd {
 		addSql = strings.TrimRight(addSql, ",")
-		_, err = o.Raw(addSql).Exec()
+		_, err = to.Raw(addSql).Exec()
 	}
 	return
 }

models/edb_data_calculate_cjjx.go

@@ -0,0 +1,369 @@
+package models
+
+import (
+	"errors"
+	"fmt"
+	"github.com/beego/beego/v2/client/orm"
+	"github.com/shopspring/decimal"
+	"hongze/hongze_edb_lib/utils"
+	"strconv"
+	"strings"
+	"time"
+)
+
+// AddCalculateCjjx 超季节性
+func AddCalculateCjjx(req *EdbInfoCalculateBatchSaveReq, fromEdbInfo *EdbInfo, edbCode, uniqueCode string, sysUserId int, sysUserRealName string, formulaInt int) (edbInfo *EdbInfo, err error) {
+	o := orm.NewOrm()
+	to, err := o.Begin()
+	if err != nil {
+		return
+	}
+	defer func() {
+		if err != nil {
+			fmt.Println("AddCalculateCjjx,Err:" + err.Error())
+			_ = to.Rollback()
+		} else {
+			_ = to.Commit()
+		}
+	}()
+	fmt.Println("req.EdbInfoId:", req.EdbInfoId)
+	if req.EdbInfoId <= 0 {
+		edbInfo = new(EdbInfo)
+		edbInfo.Source = utils.DATA_SOURCE_CALCULATE_CJJX
+		edbInfo.SourceName = "超季节性"
+		edbInfo.EdbCode = edbCode
+		edbInfo.EdbName = req.EdbName
+		edbInfo.EdbNameSource = req.EdbName
+		edbInfo.Frequency = req.Frequency
+		edbInfo.Unit = req.Unit
+		edbInfo.ClassifyId = req.ClassifyId
+		edbInfo.SysUserId = sysUserId
+		edbInfo.SysUserRealName = sysUserRealName
+		edbInfo.CreateTime = time.Now()
+		edbInfo.ModifyTime = time.Now()
+		edbInfo.UniqueCode = uniqueCode
+		edbInfo.CalculateFormula = req.Formula
+		edbInfo.EdbType = 2
+		newEdbInfoId, tmpErr := to.Insert(edbInfo)
+		if tmpErr != nil {
+			err = tmpErr
+			return
+		}
+		edbInfo.EdbInfoId = int(newEdbInfoId)
+
+		//关联关系
+		{
+			calculateMappingItem := new(EdbInfoCalculateMapping)
+			calculateMappingItem.CreateTime = time.Now()
+			calculateMappingItem.ModifyTime = time.Now()
+			calculateMappingItem.Sort = 1
+			calculateMappingItem.EdbCode = edbCode
+			calculateMappingItem.EdbInfoId = edbInfo.EdbInfoId
+			calculateMappingItem.FromEdbInfoId = fromEdbInfo.EdbInfoId
+			calculateMappingItem.FromEdbCode = fromEdbInfo.EdbCode
+			calculateMappingItem.FromEdbName = fromEdbInfo.EdbName
+			calculateMappingItem.FromSource = fromEdbInfo.Source
+			calculateMappingItem.FromSourceName = fromEdbInfo.SourceName
+			calculateMappingItem.FromTag = ""
+			calculateMappingItem.Source = edbInfo.Source
+			calculateMappingItem.SourceName = edbInfo.SourceName
+			_, err = to.Insert(calculateMappingItem)
+			if err != nil {
+				return
+			}
+		}
+	} else {
+		edbInfo, err = GetEdbInfoById(req.EdbInfoId)
+		if err != nil {
+			return
+		}
+		dataTableName := GetEdbDataTableName(utils.DATA_SOURCE_CALCULATE_CJJX)
+		fmt.Println("dataTableName:", dataTableName)
+		deleteSql := ` DELETE FROM %s WHERE edb_info_id=? `
+		deleteSql = fmt.Sprintf(deleteSql, dataTableName)
+		_, err = to.Raw(deleteSql, req.EdbInfoId).Exec()
+		if err != nil {
+			return
+		}
+	}
+
+	//计算数据
+	err = refreshAllCalculateCjjx(to, edbInfo.EdbInfoId, edbInfo.Source, fromEdbInfo, edbInfo.EdbCode, "", "", formulaInt)
+
+	return
+}
+
+// EditCalculateCjjx 超季节性
+func EditCalculateCjjx(req *EdbInfoCalculateBatchEditReq, fromEdbInfo *EdbInfo, edbCode string, formulaInt int) (edbInfo *EdbInfo, err error) {
+	o := orm.NewOrm()
+	to, err := o.Begin()
+	if err != nil {
+		return
+	}
+	defer func() {
+		if err != nil {
+			fmt.Println("EditCalculateCjjx,Err:" + err.Error())
+			_ = to.Rollback()
+		} else {
+			_ = to.Commit()
+		}
+	}()
+
+	oldCalculateFormula := edbInfo.CalculateFormula //原先的n值
+	edbInfo, err = GetEdbInfoById(req.EdbInfoId)
+	if err != nil {
+		return
+	}
+
+	//修改指标信息
+	edbInfo.EdbName = req.EdbName
+	edbInfo.EdbNameSource = req.EdbName
+	edbInfo.Frequency = req.Frequency
+	edbInfo.Unit = req.Unit
+	edbInfo.ClassifyId = req.ClassifyId
+	edbInfo.ModifyTime = time.Now()
+	_, err = o.Update(edbInfo, "EdbName", "EdbNameSource", "Frequency", "Unit", "ClassifyId", "ModifyTime")
+	if err != nil {
+		return
+	}
+
+	var existCondition string
+	var existPars []interface{}
+	existCondition += " AND edb_info_id=? "
+	existPars = append(existPars, edbInfo.EdbInfoId)
+
+	existCondition += " AND from_edb_info_id=? "
+	existPars = append(existPars, req.FromEdbInfoId)
+
+	//判断计算指标是否被更换
+	count, err := GetEdbInfoCalculateCountByCondition(existCondition, existPars)
+	if err != nil {
+		err = errors.New("判断指标是否改变失败,Err:" + err.Error())
+		return
+	}
+	if count > 0 && oldCalculateFormula != req.Formula { // 指标未被替换，同时N值未修改，无需重新计算
+		return
+	}
+
+	// 指标被替换，或者N值未修改，那么需要重新计算数据
+
+	// ，需要删除原先的信息，重新计算
+	//基础指标被替换了，需要删除原先的 计算指标关联的，基础指标的关联关系
+	if count <= 0 {
+		// 需要删除原先的 计算指标关联的，基础指标的关联关系
+		sql := ` DELETE FROM edb_info_calculate_mapping WHERE edb_info_id = ? `
+		_, err = o.Raw(sql, edbInfo.EdbInfoId).Exec()
+		if err != nil {
+			return
+		}
+
+		// 添加新的关联关系
+		{
+			calculateMappingItem := &EdbInfoCalculateMapping{
+				EdbInfoCalculateMappingId: 0,
+				EdbInfoId:                 edbInfo.EdbInfoId,
+				Source:                    utils.DATA_SOURCE_CALCULATE_CJJX,
+				SourceName:                "超季节性",
+				EdbCode:                   edbCode,
+				FromEdbInfoId:             fromEdbInfo.EdbInfoId,
+				FromEdbCode:               fromEdbInfo.EdbCode,
+				FromEdbName:               fromEdbInfo.EdbName,
+				FromSource:                fromEdbInfo.Source,
+				FromSourceName:            fromEdbInfo.SourceName,
+				FromTag:                   "",
+				Sort:                      1,
+				CreateTime:                time.Now(),
+				ModifyTime:                time.Now(),
+			}
+			_, err = o.Insert(calculateMappingItem)
+			if err != nil {
+				return
+			}
+		}
+	}
+
+	//清空原有数据
+	sql := ` DELETE FROM edb_data_calculate_cjjx WHERE edb_info_id = ? `
+	_, err = o.Raw(sql, edbInfo.EdbInfoId).Exec()
+	if err != nil {
+		return
+	}
+
+	//计算数据
+	err = refreshAllCalculateCjjx(to, edbInfo.EdbInfoId, edbInfo.Source, fromEdbInfo, edbInfo.EdbCode, "", "", formulaInt)
+
+	return
+}
+
+// RefreshAllCalculateCjjx 刷新全部超季节性数据
+func RefreshAllCalculateCjjx(edbInfoId, source int, fromEdbInfo *EdbInfo, edbCode, startDate, endDate string, formulaInt int) (err error) {
+	o := orm.NewOrm()
+	to, err := o.Begin()
+	if err != nil {
+		return
+	}
+	defer func() {
+		if err != nil {
+			fmt.Println("RefreshAllCalculateCjjx,Err:" + err.Error())
+			_ = to.Rollback()
+		} else {
+			_ = to.Commit()
+		}
+	}()
+
+	// 重新计算
+	err = refreshAllCalculateCjjx(to, edbInfoId, source, fromEdbInfo, edbCode, startDate, endDate, formulaInt)
+
+	return
+}
+
+// refreshAllCalculateCjjx 刷新全部超季节性数据
+func refreshAllCalculateCjjx(to orm.TxOrmer, edbInfoId, source int, fromEdbInfo *EdbInfo, edbCode, startDate, endDate string, formulaInt int) (err error) {
+	if err != nil {
+		return
+	}
+	edbInfoIdStr := strconv.Itoa(edbInfoId)
+	//计算数据
+
+	var condition string
+	var pars []interface{}
+	condition += " AND edb_info_id=? "
+	pars = append(pars, fromEdbInfo.EdbInfoId)
+
+	if startDate != "" {
+		condition += " AND data_time>=? "
+		pars = append(pars, startDate)
+	}
+	//if endDate != "" {
+	//	condition += " AND data_time<=? "
+	//	pars = append(pars, endDate)
+	//}
+
+	dataList, err := GetEdbDataListAll(condition, pars, fromEdbInfo.Source, 0)
+	if err != nil {
+		return err
+	}
+	var dateArr []string
+	dataMap := make(map[string]*EdbInfoSearchData)
+	for _, v := range dataList {
+		dateArr = append(dateArr, v.DataTime)
+		dataMap[v.DataTime] = v
+	}
+	//获取指标所有数据
+	existDataList := make([]*EdbData, 0)
+	dataTableName := GetEdbDataTableName(source)
+	sql := `SELECT * FROM %s WHERE edb_info_id=? `
+	sql = fmt.Sprintf(sql, dataTableName)
+	_, err = to.Raw(sql, edbInfoId).QueryRows(&existDataList)
+	if err != nil {
+		return err
+	}
+	existDataMap := make(map[string]string)
+	for _, v := range existDataList {
+		existDataMap[v.DataTime] = v.Value
+	}
+
+	addSql := ` INSERT INTO edb_data_calculate_cjjx(edb_info_id,edb_code,data_time,value,create_time,modify_time,data_timestamp) values `
+	var isAdd bool
+	//日度/周度/季度/月度
+	isCompatibility := false //是否向上下兼容35天
+	if utils.InArrayByStr([]string{"日度", "周度", "季度", "月度"}, fromEdbInfo.Frequency) {
+		isCompatibility = true
+	}
+
+	for _, av := range dateArr {
+		currentItem := dataMap[av]
+		if currentItem != nil {
+			pastValueList := make([]float64, 0) // 过去几期的数据
+			//当前日期
+			currentDate, tmpErr := time.Parse(utils.FormatDate, av)
+			if tmpErr != nil {
+				err = tmpErr
+				return
+			}
+			pastValueList = append(pastValueList, currentItem.Value)
+			for i := 1; i < formulaInt; i++ {
+				//前几年的日期
+				preDate := currentDate.AddDate(-i, 0, 0)
+				preDateStr := preDate.Format(utils.FormatDate)
+				if findItem, ok := dataMap[preDateStr]; ok { //上一年同期找到
+					pastValueList = append(pastValueList, findItem.Value)
+				} else if isCompatibility { // 如果需要兼容上下35天
+					nextDateDay := preDate
+					preDateDay := preDate
+					for i := 0; i < 35; i++ {
+						nextDateDayStr := nextDateDay.Format(utils.FormatDate)
+						if findItem, ok := dataMap[nextDateDayStr]; ok { //上一年同期->下一个月找到
+							pastValueList = append(pastValueList, findItem.Value)
+							break
+						} else {
+							preDateDayStr := preDateDay.Format(utils.FormatDate)
+							if findItem, ok := dataMap[preDateDayStr]; ok { //上一年同期->上一个月找到
+								pastValueList = append(pastValueList, findItem.Value)
+								break
+							}
+						}
+						nextDateDay = nextDateDay.AddDate(0, 0, 1)
+						preDateDay = preDateDay.AddDate(0, 0, -1)
+					}
+				}
+			}
+
+			if len(pastValueList) == formulaInt {
+				val := CjjxSub(currentItem.Value, pastValueList)
+
+				if existVal, ok := existDataMap[edbCode+av]; !ok {
+					timestamp := currentDate.UnixNano() / 1e6
+					timestampStr := fmt.Sprintf("%d", timestamp)
+					addSql += GetAddSql(edbInfoIdStr, edbCode, av, timestampStr, val)
+					isAdd = true
+				} else {
+					existValDecimal, err := decimal.NewFromString(existVal)
+					existStr := existValDecimal.String()
+					if existStr != val {
+						sql := ` UPDATE %s SET value=?,modify_time=NOW() WHERE edb_info_id=? AND data_time=? `
+						sql = fmt.Sprintf(sql, dataTableName)
+						_, err = to.Raw(sql, val, edbInfoId, av).Exec()
+						if err != nil {
+							return err
+						}
+					}
+				}
+			}
+			existDataMap[edbCode+av] = av
+		}
+	}
+	if isAdd {
+		addSql = strings.TrimRight(addSql, ",")
+		_, err = to.Raw(addSql).Exec()
+		if err != nil {
+			return err
+		}
+	}
+	return
+}
+
+// CjjxSub 计算超季节性值
+// 计算公式=现值-过去n年（包括今年）均值，n为取数个数，需大于等于1；
+//举例：A指标  2022-10-13值100，2021-10-13值120，2020-10-13值110，设置n=3，则“超季节性”指标计算值为100-（100+120+110）/3=-10。
+func CjjxSub(currValue float64, pastValue []float64) (value string) {
+	num := len(pastValue)
+	if num == 0 {
+		return
+	}
+	numDecimal := decimal.NewFromInt(int64(num))
+
+	af := decimal.NewFromFloat(currValue)
+	fmt.Println(af)
+
+	bf := decimal.NewFromFloat(pastValue[0])
+
+	for k := 1; k < num; k++ {
+		tmpVal := decimal.NewFromFloat(pastValue[k])
+		bf = bf.Add(tmpVal)
+	}
+	val, _ := af.Sub(bf.Div(numDecimal)).Float64()
+	//valStr := utils.SubFloatToString(val, 4)
+	valStr := decimal.NewFromFloat(val).RoundCeil(4).String()
+	return valStr
+}

models/edb_data_calculate_hbz.go

@@ -12,7 +12,7 @@ import (
 )
 
 // AddCalculateHbz 新增环比值指标
-func AddCalculateHbz(req *EdbInfoCalculateBatchSaveReq, fromEdbInfo *EdbInfo, edbCode, uniqueCode string, sysUserId int, sysUserRealName string, formulaInt int) (edbInfoId int, err error) {
+func AddCalculateHbz(req *EdbInfoCalculateBatchSaveReq, fromEdbInfo *EdbInfo, edbCode, uniqueCode string, sysUserId int, sysUserRealName string, formulaInt int) (edbInfo *EdbInfo, err error) {
 	o := orm.NewOrm()
 	to, err := o.Begin()
 	if err != nil {
@@ -27,7 +27,7 @@ func AddCalculateHbz(req *EdbInfoCalculateBatchSaveReq, fromEdbInfo *EdbInfo, ed
 		}
 	}()
 	if req.EdbInfoId <= 0 {
-		edbInfo := new(EdbInfo)
+		edbInfo = new(EdbInfo)
 		edbInfo.Source = utils.DATA_SOURCE_CALCULATE_HBZ
 		edbInfo.SourceName = "环比值"
 		edbInfo.EdbCode = edbCode
@@ -45,9 +45,10 @@ func AddCalculateHbz(req *EdbInfoCalculateBatchSaveReq, fromEdbInfo *EdbInfo, ed
 		edbInfo.EdbType = 2
 		newEdbInfoId, tmpErr := o.Insert(edbInfo)
 		if tmpErr != nil {
-			return edbInfoId, tmpErr
+			err = tmpErr
+			return
 		}
-		edbInfoId = int(newEdbInfoId)
+		edbInfo.EdbInfoId = int(newEdbInfoId)
 		//关联关系
 		{
 			calculateMappingItem := new(EdbInfoCalculateMapping)
@@ -55,7 +56,7 @@ func AddCalculateHbz(req *EdbInfoCalculateBatchSaveReq, fromEdbInfo *EdbInfo, ed
 			calculateMappingItem.ModifyTime = time.Now()
 			calculateMappingItem.Sort = 1
 			calculateMappingItem.EdbCode = edbCode
-			calculateMappingItem.EdbInfoId = edbInfoId
+			calculateMappingItem.EdbInfoId = edbInfo.EdbInfoId
 			calculateMappingItem.FromEdbInfoId = fromEdbInfo.EdbInfoId
 			calculateMappingItem.FromEdbCode = fromEdbInfo.EdbCode
 			calculateMappingItem.FromEdbName = fromEdbInfo.EdbName
@@ -70,7 +71,10 @@ func AddCalculateHbz(req *EdbInfoCalculateBatchSaveReq, fromEdbInfo *EdbInfo, ed
 			}
 		}
 	} else {
-		edbInfoId = req.EdbInfoId
+		edbInfo, err = GetEdbInfoById(req.EdbInfoId)
+		if err != nil {
+			return
+		}
 		dataTableName := GetEdbDataTableName(utils.DATA_SOURCE_CALCULATE_HBZ)
 		deleteSql := ` DELETE FROM %s WHERE edb_info_id=? `
 		deleteSql = fmt.Sprintf(deleteSql, dataTableName)
@@ -80,56 +84,9 @@ func AddCalculateHbz(req *EdbInfoCalculateBatchSaveReq, fromEdbInfo *EdbInfo, ed
 		}
 	}
 
-	edbInfoIdStr := strconv.Itoa(edbInfoId)
-	fmt.Println("edbInfoIdStr:" + edbInfoIdStr)
 	//计算数据
-	var condition string
-	var pars []interface{}
-	condition += " AND edb_info_id=? "
-	if req.EdbInfoId <= 0 {
-		pars = append(pars, req.FromEdbInfoId)
-	} else {
-		pars = append(pars, fromEdbInfo.EdbInfoId)
-	}
-	dataList, err := GetEdbDataListAll(condition, pars, fromEdbInfo.Source, 0)
-	if err != nil {
-		return edbInfoId, err
-	}
+	err = refreshAllCalculateHbz(to, edbInfo.EdbInfoId, edbInfo.Source, fromEdbInfo, edbInfo.EdbCode, "", "", formulaInt)
 
-	addSql := ` INSERT INTO edb_data_calculate_hbz(edb_info_id,edb_code,data_time,value,create_time,modify_time,data_timestamp) values `
-	var isAdd bool
-	existMap := make(map[string]string)
-	dataLen := len(dataList)
-	for i := 0; i < dataLen; i++ {
-		j := i + formulaInt
-		if j < dataLen {
-			//当期
-			currentItem := dataList[i]
-			preItem := dataList[j]
-			fmt.Println("preItem.Value:", preItem.Value)
-			if currentItem != nil && preItem != nil && preItem.Value != 0 {
-				existKey := edbCode + currentItem.DataTime
-				if _, ok := existMap[existKey]; !ok {
-					currentDate, _ := time.Parse(utils.FormatDate, currentItem.DataTime)
-					timestamp := currentDate.UnixNano() / 1e6
-					timestampStr := fmt.Sprintf("%d", timestamp)
-					val := HbzDiv(currentItem.Value, preItem.Value)
-					if val != "" {
-						addSql += GetAddSql(edbInfoIdStr, edbCode, currentItem.DataTime, timestampStr, val)
-						isAdd = true
-					}
-				}
-				existMap[existKey] = currentItem.DataTime
-			}
-		}
-	}
-	if isAdd {
-		addSql = strings.TrimRight(addSql, ",")
-		_, err = o.Raw(addSql).Exec()
-		if err != nil {
-			return edbInfoId, err
-		}
-	}
 	return
 }
 
@@ -278,12 +235,15 @@ func RefreshAllCalculateHbz(edbInfoId, source int, fromEdbInfo *EdbInfo, edbCode
 			_ = to.Commit()
 		}
 	}()
-	if err != nil {
-		return
-	}
-	edbInfoIdStr := strconv.Itoa(edbInfoId)
+
 	//计算数据
+	err = refreshAllCalculateHbz(to, edbInfoId, source, fromEdbInfo, edbCode, startDate, endDate, formulaInt)
+	return
+}
 
+// refreshAllCalculateHbz 刷新所有环比值数据
+func refreshAllCalculateHbz(to orm.TxOrmer, edbInfoId, source int, fromEdbInfo *EdbInfo, edbCode, startDate, endDate string, formulaInt int) (err error) {
+	edbInfoIdStr := strconv.Itoa(edbInfoId)
 	//计算数据
 	var condition string
 	var pars []interface{}
@@ -316,7 +276,7 @@ func RefreshAllCalculateHbz(edbInfoId, source int, fromEdbInfo *EdbInfo, edbCode
 	fmt.Println("dataTableName:", dataTableName)
 	sql := `SELECT * FROM %s WHERE edb_info_id=? `
 	sql = fmt.Sprintf(sql, dataTableName)
-	_, err = o.Raw(sql, edbInfoId).QueryRows(&existDataList)
+	_, err = to.Raw(sql, edbInfoId).QueryRows(&existDataList)
 	if err != nil {
 		return err
 	}
@@ -353,7 +313,7 @@ func RefreshAllCalculateHbz(edbInfoId, source int, fromEdbInfo *EdbInfo, edbCode
 							if existStr != val {
 								sql := ` UPDATE %s SET value=?,modify_time=NOW() WHERE edb_info_id=? AND data_time=? `
 								sql = fmt.Sprintf(sql, dataTableName)
-								_, err = o.Raw(sql, val, edbInfoId, currentItem.DataTime).Exec()
+								_, err = to.Raw(sql, val, edbInfoId, currentItem.DataTime).Exec()
 								if err != nil {
 									return err
 								}
@@ -367,7 +327,7 @@ func RefreshAllCalculateHbz(edbInfoId, source int, fromEdbInfo *EdbInfo, edbCode
 	}
 	if isAdd {
 		addSql = strings.TrimRight(addSql, ",")
-		_, err = o.Raw(addSql).Exec()
+		_, err = to.Raw(addSql).Exec()
 		if err != nil {
 			return err
 		}

models/edb_data_calculate_hcz.go

@@ -12,7 +12,7 @@ import (
 )
 
 // AddCalculateHcz 新增环差值指标
-func AddCalculateHcz(req *EdbInfoCalculateBatchSaveReq, fromEdbInfo *EdbInfo, edbCode, uniqueCode string, sysUserId int, sysUserRealName string, formulaInt int) (edbInfoId int, err error) {
+func AddCalculateHcz(req *EdbInfoCalculateBatchSaveReq, fromEdbInfo *EdbInfo, edbCode, uniqueCode string, sysUserId int, sysUserRealName string, formulaInt int) (edbInfo *EdbInfo, err error) {
 	o := orm.NewOrm()
 	to, err := o.Begin()
 	if err != nil {
@@ -27,7 +27,7 @@ func AddCalculateHcz(req *EdbInfoCalculateBatchSaveReq, fromEdbInfo *EdbInfo, ed
 		}
 	}()
 	if req.EdbInfoId <= 0 {
-		edbInfo := new(EdbInfo)
+		edbInfo = new(EdbInfo)
 		edbInfo.Source = utils.DATA_SOURCE_CALCULATE_HCZ
 		edbInfo.SourceName = "环差值"
 		edbInfo.EdbCode = edbCode
@@ -45,9 +45,10 @@ func AddCalculateHcz(req *EdbInfoCalculateBatchSaveReq, fromEdbInfo *EdbInfo, ed
 		edbInfo.EdbType = 2
 		newEdbInfoId, tmpErr := to.Insert(edbInfo)
 		if tmpErr != nil {
-			return edbInfoId, tmpErr
+			err = tmpErr
+			return
 		}
-		edbInfoId = int(newEdbInfoId)
+		edbInfo.EdbInfoId = int(newEdbInfoId)
 
 		//关联关系
 		{
@@ -56,7 +57,7 @@ func AddCalculateHcz(req *EdbInfoCalculateBatchSaveReq, fromEdbInfo *EdbInfo, ed
 			calculateMappingItem.ModifyTime = time.Now()
 			calculateMappingItem.Sort = 1
 			calculateMappingItem.EdbCode = edbCode
-			calculateMappingItem.EdbInfoId = edbInfoId
+			calculateMappingItem.EdbInfoId = edbInfo.EdbInfoId
 			calculateMappingItem.FromEdbInfoId = fromEdbInfo.EdbInfoId
 			calculateMappingItem.FromEdbCode = fromEdbInfo.EdbCode
 			calculateMappingItem.FromEdbName = fromEdbInfo.EdbName
@@ -71,7 +72,10 @@ func AddCalculateHcz(req *EdbInfoCalculateBatchSaveReq, fromEdbInfo *EdbInfo, ed
 			}
 		}
 	} else {
-		edbInfoId = req.EdbInfoId
+		edbInfo, err = GetEdbInfoById(req.EdbInfoId)
+		if err != nil {
+			return
+		}
 		dataTableName := GetEdbDataTableName(utils.DATA_SOURCE_CALCULATE_HCZ)
 		deleteSql := ` DELETE FROM %s WHERE edb_info_id=? `
 		deleteSql = fmt.Sprintf(deleteSql, dataTableName)
@@ -81,61 +85,9 @@ func AddCalculateHcz(req *EdbInfoCalculateBatchSaveReq, fromEdbInfo *EdbInfo, ed
 		}
 	}
 
-	edbInfoIdStr := strconv.Itoa(edbInfoId)
-	fmt.Println("edbInfoIdStr:" + edbInfoIdStr)
 	//计算数据
-	var condition string
-	var pars []interface{}
-	condition += " AND edb_info_id=? "
-	if req.EdbInfoId <= 0 {
-		pars = append(pars, req.FromEdbInfoId)
-	} else {
-		pars = append(pars, fromEdbInfo.EdbInfoId)
-	}
-	dataList, err := GetEdbDataListAll(condition, pars, fromEdbInfo.Source, 0)
-	if err != nil {
-		return edbInfoId, err
-	}
+	err = refreshAllCalculateHcz(to, edbInfo.EdbInfoId, edbInfo.Source, fromEdbInfo, edbInfo.EdbCode, "", "", formulaInt)
 
-	addSql := ` INSERT INTO edb_data_calculate_hcz(edb_info_id,edb_code,data_time,value,create_time,modify_time,data_timestamp) values `
-	var isAdd bool
-	existMap := make(map[string]string)
-	dataLen := len(dataList)
-	fmt.Println("dataLen:", dataLen)
-	for i := 0; i < dataLen; i++ {
-		j := i + formulaInt
-		if j < dataLen {
-			//当期
-			currentItem := dataList[i]
-			preItem := dataList[j]
-			if currentItem != nil && preItem != nil {
-				existKey := edbCode + currentItem.DataTime
-				if _, ok := existMap[existKey]; !ok {
-					currentDate, _ := time.Parse(utils.FormatDate, currentItem.DataTime)
-					timestamp := currentDate.UnixNano() / 1e6
-					timestampStr := fmt.Sprintf("%d", timestamp)
-					val := ""
-					if preItem.Value == 0 {
-						val = "0"
-					} else {
-						val = HczDiv(currentItem.Value, preItem.Value)
-					}
-					if val != "" {
-						addSql += GetAddSql(edbInfoIdStr, edbCode, currentItem.DataTime, timestampStr, val)
-						isAdd = true
-					}
-				}
-				existMap[existKey] = currentItem.DataTime
-			}
-		}
-	}
-	if isAdd {
-		addSql = strings.TrimRight(addSql, ",")
-		_, err = to.Raw(addSql).Exec()
-		if err != nil {
-			return edbInfoId, err
-		}
-	}
 	return
 }
 
@@ -295,9 +247,13 @@ func RefreshAllCalculateHcz(edbInfoId, source int, fromEdbInfo *EdbInfo, edbCode
 		}
 	}()
 
-	if err != nil {
-		return
-	}
+	//计算数据
+	err = refreshAllCalculateHcz(to, edbInfoId, source, fromEdbInfo, edbCode, startDate, endDate, formulaInt)
+	return
+}
+
+// refreshAllCalculateHcz 刷新所有环差值数据
+func refreshAllCalculateHcz(to orm.TxOrmer, edbInfoId, source int, fromEdbInfo *EdbInfo, edbCode, startDate, endDate string, formulaInt int) (err error) {
 	edbInfoIdStr := strconv.Itoa(edbInfoId)
 
 	//计算数据
@@ -332,7 +288,7 @@ func RefreshAllCalculateHcz(edbInfoId, source int, fromEdbInfo *EdbInfo, edbCode
 	fmt.Println("dataTableName:", dataTableName)
 	sql := `SELECT * FROM %s WHERE edb_info_id=? `
 	sql = fmt.Sprintf(sql, dataTableName)
-	_, err = o.Raw(sql, edbInfoId).QueryRows(&existDataList)
+	_, err = to.Raw(sql, edbInfoId).QueryRows(&existDataList)
 	if err != nil {
 		return err
 	}
@@ -369,7 +325,7 @@ func RefreshAllCalculateHcz(edbInfoId, source int, fromEdbInfo *EdbInfo, edbCode
 							if existStr != val {
 								sql := ` UPDATE %s SET value=?,modify_time=NOW() WHERE edb_info_id=? AND data_time=? `
 								sql = fmt.Sprintf(sql, dataTableName)
-								_, err = o.Raw(sql, val, edbInfoId, currentItem.DataTime).Exec()
+								_, err = to.Raw(sql, val, edbInfoId, currentItem.DataTime).Exec()
 								if err != nil {
 									return err
 								}
@@ -383,7 +339,7 @@ func RefreshAllCalculateHcz(edbInfoId, source int, fromEdbInfo *EdbInfo, edbCode
 	}
 	if isAdd {
 		addSql = strings.TrimRight(addSql, ",")
-		_, err = o.Raw(addSql).Exec()
+		_, err = to.Raw(addSql).Exec()
 		if err != nil {
 			return err
 		}
@@ -399,6 +355,6 @@ func HczDiv(current, pre float64) string {
 	currentVal := decimal.NewFromFloat(current)
 	preVal := decimal.NewFromFloat(pre)
 	val, _ := currentVal.Sub(preVal).Float64()
-	valStr := decimal.NewFromFloat(val).RoundCeil(4).String()//utils.SubFloatToString(val, 4)
+	valStr := decimal.NewFromFloat(val).RoundCeil(4).String() //utils.SubFloatToString(val, 4)
 	return valStr
 }

models/edb_data_calculate_ljztbpj.go

@@ -25,7 +25,7 @@ type EdbDataCalculateLjztbpj struct {
 }
 
 // AddCalculateLjztbpj 新增累计值同比拼接数据
-func AddCalculateLjztbpj(req *EdbInfoCalculateBatchSaveReq, firstEdbInfo, secondEdbInfo *EdbInfo, edbCode, uniqueCode string, sysUserId int, sysUserRealName string) (edbInfoId int, err error) {
+func AddCalculateLjztbpj(req *EdbInfoCalculateBatchSaveReq, firstEdbInfo, secondEdbInfo *EdbInfo, edbCode, uniqueCode string, sysUserId int, sysUserRealName string) (edbInfo *EdbInfo, err error) {
 	o := orm.NewOrm()
 	to, err := o.Begin()
 	if err != nil {
@@ -58,7 +58,8 @@ func AddCalculateLjztbpj(req *EdbInfoCalculateBatchSaveReq, firstEdbInfo, second
 
 		lastEdbData, tmpErr := GetLastEdbData(condition, pars, firstEdbInfo.Source)
 		if tmpErr != nil {
-			return edbInfoId, tmpErr
+			err = tmpErr
+			return
 		}
 		lastDateTime, _ = time.ParseInLocation(utils.FormatDate, lastEdbData.DataTime, time.Local)
 
@@ -70,7 +71,8 @@ func AddCalculateLjztbpj(req *EdbInfoCalculateBatchSaveReq, firstEdbInfo, second
 
 		firstDataList, tmpErr := GetEdbDataListAll(condition, pars, firstEdbInfo.Source, 0)
 		if tmpErr != nil {
-			return edbInfoId, tmpErr
+			err = tmpErr
+			return
 		}
 
 		for _, v := range firstDataList {
@@ -79,7 +81,6 @@ func AddCalculateLjztbpj(req *EdbInfoCalculateBatchSaveReq, firstEdbInfo, second
 		}
 	}
 
-	var edbInfo *EdbInfo
 	if req.EdbInfoId <= 0 {
 		edbInfo = &EdbInfo{
 			SourceName:       "累计值同比拼接",
@@ -100,15 +101,19 @@ func AddCalculateLjztbpj(req *EdbInfoCalculateBatchSaveReq, firstEdbInfo, second
 			CalculateFormula: lastDateTime.Format(utils.FormatDate),
 			EdbType:          2,
 		}
-		newEdbInfoId, err := to.Insert(edbInfo)
-		if err != nil {
-			return edbInfoId, err
+		newEdbInfoId, tmpErr := to.Insert(edbInfo)
+		if tmpErr != nil {
+			err = tmpErr
+			return
 		}
-		edbInfoId = int(newEdbInfoId)
+		edbInfo.EdbInfoId = int(newEdbInfoId)
 	} else {
-		edbInfoId = req.EdbInfoId
+		edbInfo, err = GetEdbInfoById(req.EdbInfoId)
+		if err != nil {
+			return
+		}
 		//查询
-		tmpEdbInfo, tmpErr := GetEdbInfoById(edbInfoId)
+		tmpEdbInfo, tmpErr := GetEdbInfoById(edbInfo.EdbInfoId)
 		if tmpErr != nil {
 			err = tmpErr
 			return
@@ -128,161 +133,72 @@ func AddCalculateLjztbpj(req *EdbInfoCalculateBatchSaveReq, firstEdbInfo, second
 		deleteSql = fmt.Sprintf(deleteSql, dataTableName)
 		_, err = to.Raw(deleteSql, req.EdbInfoId).Exec()
 		if err != nil {
-			return 0, err
+			return
 		}
 
 		//删除指标关系
 		sql := ` DELETE FROM edb_info_calculate_mapping WHERE edb_info_id=? `
-		_, err = to.Raw(sql, edbInfoId).Exec()
+		_, err = to.Raw(sql, edbInfo.EdbInfoId).Exec()
 	}
 
 	//关联关系
 
+	var existItemA, existItemB *EdbInfoCalculateMapping
 	//拼接指标
 	{
-		calculateMappingItem := new(EdbInfoCalculateMapping)
-		calculateMappingItem.CreateTime = time.Now()
-		calculateMappingItem.ModifyTime = time.Now()
-		calculateMappingItem.Sort = 1
-		calculateMappingItem.EdbCode = edbCode
-		calculateMappingItem.EdbInfoId = edbInfoId
-		calculateMappingItem.FromEdbInfoId = firstEdbInfo.EdbInfoId
-		calculateMappingItem.FromEdbCode = firstEdbInfo.EdbCode
-		calculateMappingItem.FromEdbName = firstEdbInfo.EdbName
-		calculateMappingItem.FromSource = firstEdbInfo.Source
-		calculateMappingItem.FromSourceName = firstEdbInfo.SourceName
-		calculateMappingItem.FromTag = "A"
-		calculateMappingItem.Source = edbInfo.Source
-		calculateMappingItem.SourceName = edbInfo.SourceName
-		_, err = to.Insert(calculateMappingItem)
-		if err != nil {
-			return
-		}
-	}
-
-	//同比值指标
-	{
-		calculateMappingItem := new(EdbInfoCalculateMapping)
-		calculateMappingItem.CreateTime = time.Now()
-		calculateMappingItem.ModifyTime = time.Now()
-		calculateMappingItem.Sort = 1
-		calculateMappingItem.EdbCode = edbCode
-		calculateMappingItem.EdbInfoId = edbInfoId
-		calculateMappingItem.FromEdbInfoId = secondEdbInfo.EdbInfoId
-		calculateMappingItem.FromEdbCode = secondEdbInfo.EdbCode
-		calculateMappingItem.FromEdbName = secondEdbInfo.EdbName
-		calculateMappingItem.FromSource = secondEdbInfo.Source
-		calculateMappingItem.FromSourceName = secondEdbInfo.SourceName
-		calculateMappingItem.FromTag = "B"
-		calculateMappingItem.Source = edbInfo.Source
-		calculateMappingItem.SourceName = edbInfo.SourceName
-		_, err = to.Insert(calculateMappingItem)
-		if err != nil {
+		existItemA = &EdbInfoCalculateMapping{
+			EdbInfoCalculateMappingId: 0,
+			EdbInfoId:                 edbInfo.EdbInfoId,
+			Source:                    edbInfo.Source,
+			SourceName:                edbInfo.SourceName,
+			EdbCode:                   edbInfo.EdbCode,
+			FromEdbInfoId:             firstEdbInfo.EdbInfoId,
+			FromEdbCode:               firstEdbInfo.EdbCode,
+			FromEdbName:               firstEdbInfo.EdbName,
+			FromSource:                firstEdbInfo.Source,
+			FromSourceName:            firstEdbInfo.SourceName,
+			FromTag:                   "A",
+			Sort:                      1,
+			CreateTime:                time.Now(),
+			ModifyTime:                time.Now(),
+		}
+		insertId, tmpErr := to.Insert(existItemA)
+		if tmpErr != nil {
+			err = tmpErr
 			return
 		}
+		existItemA.EdbInfoCalculateMappingId = int(insertId)
 	}
 
-	//同比值指标map
-	tbzEdbDataMap := make(map[string]float64)
-
-	//同比值日期切片列表
-	tbzEdbDataTimeList := make([]string, 0)
-
 	//同比值指标
 	{
-		var condition string
-		var pars []interface{}
-
-		condition += " AND data_time > ? AND edb_info_id = ? "
-		pars = append(pars, lastDateTime, secondEdbInfo.EdbInfoId)
-
-		//同比值指标的数据列表
-		secondDataList, tmpErr := GetEdbDataListAll(condition, pars, secondEdbInfo.Source, 0)
-		if tmpErr != nil {
-			return edbInfoId, tmpErr
-		}
-
-		for _, v := range secondDataList {
-			tbzEdbDataMap[v.DataTime] = v.Value
-			tbzEdbDataTimeList = append(tbzEdbDataTimeList, v.DataTime)
-		}
-	}
-
-	sort.Strings(tbzEdbDataTimeList)
-	for _, v := range tbzEdbDataTimeList {
-		tbzDataTime, _ := time.ParseInLocation(utils.FormatDate, v, time.Local)
-
-		//获取拼接指标上一年同一天的数据
-		var pjDataTime time.Time
-		if tbzDataTime.Month() == 2 {
-			pjDataTime = tbzDataTime.AddDate(0, -11, 0)
-			pjDataTime = time.Date(pjDataTime.Year(), pjDataTime.Month(), 1, 0, 0, 0, 0, time.Now().Location()).AddDate(0, 0, -1)
-		} else {
-			pjDataTime = tbzDataTime.AddDate(-1, 0, 0)
-		}
-
-		//如果存在数据，那么就去计算当前的数据
-		if pjDataValue, ok := pjDataMap[pjDataTime.Format(utils.FormatDate)]; ok {
-			tbzDataValue := tbzEdbDataMap[v] //同比值
-			currValue := pjDataValue * (1 + tbzDataValue/100)
-
-			currValue, _ = decimal.NewFromFloat(currValue).Truncate(4).Float64()
-			//将计算后的数据存入待拼接指标map里面，以便后续计算
-			pjDataMap[v] = currValue
-
-			pjEdbDataTimeList = append(pjEdbDataTimeList, v)
-		}
-	}
-
-	addDataList := make([]*EdbDataCalculateLjztbpj, 0)
-
-	//日期排序下
-	sort.Strings(pjEdbDataTimeList)
-	//这么做的目的是为了让数据插入的时候，可以正序插入（业务上没啥卵用，就是为了让我看数据的时候舒服点，手动狗头-_-|）
-	for _, dataTime := range pjEdbDataTimeList {
-		if dataValue, ok := pjDataMap[dataTime]; ok {
-			//时间戳
-			currentDate, _ := time.Parse(utils.FormatDate, dataTime)
-			timestamp := currentDate.UnixNano() / 1e6
-
-			edbDataLjztbpj := &EdbDataCalculateLjztbpj{
-				EdbInfoId:     edbInfoId,
-				EdbCode:       edbInfo.EdbCode,
-				DataTime:      dataTime,
-				Value:         dataValue,
-				Status:        1,
-				CreateTime:    time.Now(),
-				ModifyTime:    time.Now(),
-				DataTimestamp: timestamp,
-			}
-			addDataList = append(addDataList, edbDataLjztbpj)
-		}
-	}
-
-	//数据入库
-	tmpAddDataList := make([]*EdbDataCalculateLjztbpj, 0)
-	for _, v := range addDataList {
-		tmpAddDataList = append(tmpAddDataList, v)
-
-		if len(tmpAddDataList) >= 200 {
-			_, tmpErr := to.InsertMulti(len(tmpAddDataList), tmpAddDataList)
-			if tmpErr != nil {
-				err = tmpErr
-				return
-			}
-			//重新初始化需要加入的数据切片
-			tmpAddDataList = make([]*EdbDataCalculateLjztbpj, 0)
-		}
-	}
-	//最后如果还有需要新增的数据，那么就统一入库
-	if len(tmpAddDataList) > 0 {
-		_, tmpErr := to.InsertMulti(len(tmpAddDataList), tmpAddDataList)
+		existItemB = &EdbInfoCalculateMapping{
+			EdbInfoCalculateMappingId: 0,
+			EdbInfoId:                 edbInfo.EdbInfoId,
+			Source:                    edbInfo.Source,
+			SourceName:                edbInfo.SourceName,
+			EdbCode:                   edbInfo.EdbCode,
+			FromEdbInfoId:             secondEdbInfo.EdbInfoId,
+			FromEdbCode:               secondEdbInfo.EdbCode,
+			FromEdbName:               secondEdbInfo.EdbName,
+			FromSource:                secondEdbInfo.Source,
+			FromSourceName:            secondEdbInfo.SourceName,
+			FromTag:                   "B",
+			Sort:                      1,
+			CreateTime:                time.Now(),
+			ModifyTime:                time.Now(),
+		}
+		insertId, tmpErr := to.Insert(existItemB)
 		if tmpErr != nil {
 			err = tmpErr
 			return
 		}
+		existItemB.EdbInfoCalculateMappingId = int(insertId)
 	}
 
+	// 添加数据
+	err = refreshAllCalculateLjztbpj(to, edbInfo, existItemA, existItemB)
+
 	return
 }
 
@@ -686,14 +602,42 @@ func RefreshAllCalculateLjztbpj(edbInfo *EdbInfo) (err error) {
 		}
 	}()
 
+	//查询关联指标信息
+	var existCondition string
+	var existPars []interface{}
+	existCondition += " AND edb_info_id=? "
+	existPars = append(existPars, edbInfo.EdbInfoId)
+	existList, err := GetEdbInfoCalculateListByCondition(existCondition, existPars)
+	if err != nil {
+		err = errors.New("判断指标是否改变失败,Err:" + err.Error())
+		return
+	}
+
+	var existItemA, existItemB *EdbInfoCalculateMapping
+	for _, existItem := range existList {
+		if existItem.FromTag == "A" {
+			existItemA = existItem
+		} else if existItem.FromTag == "B" {
+			existItemB = existItem
+		}
+	}
+	// 刷新数据
+	err = refreshAllCalculateLjztbpj(to, edbInfo, existItemA, existItemB)
+	return
+}
+
+// refreshAllCalculateLjztbpj 刷新所有 累计值同比拼接 数据
+func refreshAllCalculateLjztbpj(to orm.TxOrmer, edbInfo *EdbInfo, existItemA, existItemB *EdbInfoCalculateMapping) (err error) {
 	//查询当前指标现有的数据
 	var condition string
 	var pars []interface{}
 	condition += " AND edb_info_id=? "
 	pars = append(pars, edbInfo.EdbInfoId)
 
-	//所有的数据
-	dataList, err := GetAllEdbDataCalculateLjztbpjByEdbInfoId(edbInfo.EdbInfoId)
+	//根据指标id获取全部的数据
+	var dataList []*EdbDataCalculateLjztbpj
+	sql := ` SELECT * FROM edb_data_calculate_ljztbpj WHERE edb_info_id=? ORDER BY data_time DESC `
+	_, err = to.Raw(sql, edbInfo.EdbInfoId).QueryRows(&dataList)
 	if err != nil {
 		return err
 	}
@@ -711,25 +655,6 @@ func RefreshAllCalculateLjztbpj(edbInfo *EdbInfo) (err error) {
 		nowEdbDataMap[v.DataTime] = v.Value
 	}
 
-	//查询关联指标信息
-	var existCondition string
-	var existPars []interface{}
-	existCondition += " AND edb_info_id=? "
-	existPars = append(existPars, edbInfo.EdbInfoId)
-	existList, err := GetEdbInfoCalculateListByCondition(existCondition, existPars)
-	if err != nil {
-		err = errors.New("判断指标是否改变失败,Err:" + err.Error())
-		return
-	}
-
-	var existItemA, existItemB *EdbInfoCalculateMapping
-	for _, existItem := range existList {
-		if existItem.FromTag == "A" {
-			existItemA = existItem
-		} else if existItem.FromTag == "B" {
-			existItemB = existItem
-		}
-	}
 	// 原数据开始计算日期
 	startCalculationDate, _ := time.ParseInLocation(utils.FormatDate, edbInfo.CalculateFormula, time.Local)
 
@@ -753,12 +678,15 @@ func RefreshAllCalculateLjztbpj(edbInfo *EdbInfo) (err error) {
 				if edbData.Value != v.Value {
 					//更新指标数据
 					edbData.Value = v.Value
-					_, _ = o.Update(edbData, "Value")
-
-					//将新的数据存入已入库指标map里面，以便后续计算
-					nowEdbDataMap[edbData.DataTime] = v.Value
+					_, _ = to.Update(edbData, "Value")
 				}
+			} else {
+				pjDataMap[v.DataTime] = v.Value
+				pjEdbDataTimeList = append(pjEdbDataTimeList, v.DataTime)
 			}
+
+			//将新的数据存入已入库指标map里面，以便后续计算
+			nowEdbDataMap[v.DataTime] = v.Value
 		}
 	}
 
@@ -856,41 +784,32 @@ func RefreshAllCalculateLjztbpj(edbInfo *EdbInfo) (err error) {
 	//新增的数据入库
 	{
 		addDataList := make([]*EdbDataCalculateLjztbpj, 0)
-		for dataTime, dataValue := range pjDataMap {
-			//时间戳
-			currentDate, _ := time.Parse(utils.FormatDate, dataTime)
-			timestamp := currentDate.UnixNano() / 1e6
-
-			edbDataLjztbpj := &EdbDataCalculateLjztbpj{
-				EdbInfoId:     edbInfo.EdbInfoId,
-				EdbCode:       edbInfo.EdbCode,
-				DataTime:      dataTime,
-				Value:         dataValue,
-				Status:        1,
-				CreateTime:    time.Now(),
-				ModifyTime:    time.Now(),
-				DataTimestamp: timestamp,
-			}
-			addDataList = append(addDataList, edbDataLjztbpj)
-		}
-
-		tmpAddDataList := make([]*EdbDataCalculateLjztbpj, 0)
-		for _, v := range addDataList {
-			tmpAddDataList = append(tmpAddDataList, v)
-
-			if len(tmpAddDataList) >= 200 {
-				_, tmpErr := o.InsertMulti(len(tmpAddDataList), tmpAddDataList)
-				if tmpErr != nil {
-					err = tmpErr
-					return
+		//日期排序下
+		sort.Strings(pjEdbDataTimeList)
+		//这么做的目的是为了让数据插入的时候，可以正序插入（业务上没啥卵用，就是为了让我看数据的时候舒服点，手动狗头-_-|）
+		for _, dataTime := range pjEdbDataTimeList {
+			if dataValue, ok := pjDataMap[dataTime]; ok {
+				//时间戳
+				currentDate, _ := time.Parse(utils.FormatDate, dataTime)
+				timestamp := currentDate.UnixNano() / 1e6
+
+				edbDataLjztbpj := &EdbDataCalculateLjztbpj{
+					EdbInfoId:     edbInfo.EdbInfoId,
+					EdbCode:       edbInfo.EdbCode,
+					DataTime:      dataTime,
+					Value:         dataValue,
+					Status:        1,
+					CreateTime:    time.Now(),
+					ModifyTime:    time.Now(),
+					DataTimestamp: timestamp,
 				}
-				//重新初始化需要加入的数据切片
-				tmpAddDataList = make([]*EdbDataCalculateLjztbpj, 0)
+				addDataList = append(addDataList, edbDataLjztbpj)
 			}
 		}
-		//最后如果还有需要新增的数据，那么就统一入库
-		if len(tmpAddDataList) > 0 {
-			_, tmpErr := o.InsertMulti(len(tmpAddDataList), tmpAddDataList)
+
+		//数据入库
+		if len(addDataList) > 0 {
+			_, tmpErr := to.InsertMulti(len(addDataList), addDataList)
 			if tmpErr != nil {
 				err = tmpErr
 				return
@@ -907,7 +826,7 @@ func RefreshAllCalculateLjztbpj(edbInfo *EdbInfo) (err error) {
 			tableName := GetEdbDataTableName(edbInfo.Source)
 			sql := fmt.Sprintf(` DELETE FROM %s WHERE edb_info_id = ? and data_time in (%s) `, tableName, removeDateStr)
 
-			_, err = o.Raw(sql, edbInfo.EdbInfoId).Exec()
+			_, err = to.Raw(sql, edbInfo.EdbInfoId).Exec()
 			if err != nil {
 				err = errors.New("删除不存在的累计值同比拼接指标数据失败,Err:" + err.Error())
 				return
@@ -921,7 +840,7 @@ func RefreshAllCalculateLjztbpj(edbInfo *EdbInfo) (err error) {
 		for edbDate, edbDataValue := range updateEdbDataMap {
 			sql := fmt.Sprintf(` UPDATE  %s set value = ?,modify_time=now() WHERE edb_info_id = ? and data_time = ? `, tableName)
 
-			_, err = o.Raw(sql, edbDataValue, edbInfo.EdbInfoId, edbDate).Exec()
+			_, err = to.Raw(sql, edbDataValue, edbInfo.EdbInfoId, edbDate).Exec()
 			if err != nil {
 				err = errors.New("更新现有的累计值同比拼接指标数据失败,Err:" + err.Error())
 				return

models/edb_data_calculate_ljzzy.go

@@ -12,7 +12,7 @@ import (
 )
 
 // AddCalculateLjzzy 累计值转月
-func AddCalculateLjzzy(req *EdbInfoCalculateBatchSaveReq, fromEdbInfo *EdbInfo, edbCode, uniqueCode string, sysUserId int, sysUserRealName string) (edbInfoId int, err error) {
+func AddCalculateLjzzy(req *EdbInfoCalculateBatchSaveReq, fromEdbInfo *EdbInfo, edbCode, uniqueCode string, sysUserId int, sysUserRealName string) (edbInfo *EdbInfo, err error) {
 	o := orm.NewOrm()
 	to, err := o.Begin()
 	if err != nil {
@@ -28,7 +28,7 @@ func AddCalculateLjzzy(req *EdbInfoCalculateBatchSaveReq, fromEdbInfo *EdbInfo,
 	}()
 
 	if req.EdbInfoId <= 0 {
-		edbInfo := new(EdbInfo)
+		edbInfo = new(EdbInfo)
 		edbInfo.Source = utils.DATA_SOURCE_CALCULATE_LJZZY
 		edbInfo.SourceName = "累计值转月值"
 		edbInfo.EdbCode = edbCode
@@ -46,9 +46,10 @@ func AddCalculateLjzzy(req *EdbInfoCalculateBatchSaveReq, fromEdbInfo *EdbInfo,
 		edbInfo.EdbType = 2
 		newEdbInfoId, tmpErr := to.Insert(edbInfo)
 		if tmpErr != nil {
-			return int(newEdbInfoId), tmpErr
+			err = tmpErr
+			return
 		}
-		edbInfoId = int(newEdbInfoId)
+		edbInfo.EdbInfoId = int(newEdbInfoId)
 
 		//关联关系
 		{
@@ -57,7 +58,7 @@ func AddCalculateLjzzy(req *EdbInfoCalculateBatchSaveReq, fromEdbInfo *EdbInfo,
 			calculateMappingItem.ModifyTime = time.Now()
 			calculateMappingItem.Sort = 1
 			calculateMappingItem.EdbCode = edbCode
-			calculateMappingItem.EdbInfoId = edbInfoId
+			calculateMappingItem.EdbInfoId = edbInfo.EdbInfoId
 			calculateMappingItem.FromEdbInfoId = fromEdbInfo.EdbInfoId
 			calculateMappingItem.FromEdbCode = fromEdbInfo.EdbCode
 			calculateMappingItem.FromEdbName = fromEdbInfo.EdbName
@@ -72,7 +73,10 @@ func AddCalculateLjzzy(req *EdbInfoCalculateBatchSaveReq, fromEdbInfo *EdbInfo,
 			}
 		}
 	} else {
-		edbInfoId = req.EdbInfoId
+		edbInfo, err = GetEdbInfoById(req.EdbInfoId)
+		if err != nil {
+			return
+		}
 		dataTableName := GetEdbDataTableName(utils.DATA_SOURCE_CALCULATE_LJZZY)
 		deleteSql := ` DELETE FROM %s WHERE edb_info_id=? `
 		deleteSql = fmt.Sprintf(deleteSql, dataTableName)
@@ -81,121 +85,10 @@ func AddCalculateLjzzy(req *EdbInfoCalculateBatchSaveReq, fromEdbInfo *EdbInfo,
 			return
 		}
 	}
-	edbInfoIdStr := strconv.Itoa(edbInfoId)
-	//计算数据
-	var condition string
-	var pars []interface{}
-	condition += " AND edb_info_id=? "
-	if req.EdbInfoId <= 0 {
-		pars = append(pars, req.FromEdbInfoId)
-	} else {
-		pars = append(pars, fromEdbInfo.EdbInfoId)
-	}
-	fmt.Println("EdbInfoId:", req.FromEdbInfoId)
-	dataList, err := GetEdbDataListAll(condition, pars, fromEdbInfo.Source, 1)
-	if err != nil {
-		return edbInfoId, err
-	}
 
-	yearMap := make(map[int]map[int]*EdbInfoSearchData)
-	dataLen := len(dataList)
-	for i := 0; i < dataLen; i++ {
-		item := dataList[i]
-		//日其中获取年
-		itemDate, err := time.Parse(utils.FormatDate, item.DataTime)
-		if err != nil {
-			return edbInfoId, err
-		}
-		year := itemDate.Year()
-		month := int(itemDate.Month())
-		if monthMap, yok := yearMap[year]; yok {
-			monthMap[month] = item
-			yearMap[year] = monthMap
-		} else {
-			monthMap = make(map[int]*EdbInfoSearchData)
-			monthMap[month] = item
-			yearMap[year] = monthMap
-		}
-	}
-
-	addSql := ` INSERT INTO edb_data_calculate_ljzzy(edb_info_id,edb_code,data_time,value,create_time,modify_time,data_timestamp) values `
-	var isAdd bool
-	existMap := make(map[string]string)
-	for yk, yv := range yearMap {
-		_, oneMonthOk := yv[1]
-		_, twoMonthOk := yv[2]
-		if !oneMonthOk && !twoMonthOk {
-			continue
-		}
-		for i := 1; i <= 12; i++ {
-			fmt.Println(yk, i, yv[i])
-			dataCurrentItem := yv[i]
-			fmt.Println("i:", i, yk, dataCurrentItem)
-			var date string
-			var val float64
-			if i == 1 || i == 2 {
-				if _, mok := yv[1]; mok { //1月有值
-					if i == 1 {
-						date = dataCurrentItem.DataTime
-						val, _ = decimal.NewFromFloat(dataCurrentItem.Value).Float64() //a.Div(b).Float64()
-					}
-					if i == 2 {
-						dataOneItem := yv[1]
-						if dataCurrentItem != nil {
-							date = dataCurrentItem.DataTime
-							twoMonth := decimal.NewFromFloat(dataCurrentItem.Value)
-							oneMonth := decimal.NewFromFloat(dataOneItem.Value)
-							val, _ = twoMonth.Sub(oneMonth).Float64()
-						} else {
-							continue
-						}
-					}
-				} else { //1月无值
-					dataTwoItem := yv[2]
-					if i == 1 {
-						date = strconv.Itoa(yk) + "-01-31"
-						a := decimal.NewFromFloat(dataTwoItem.Value)
-						b := decimal.NewFromFloat(2.0)
-						val, _ = a.Div(b).Float64()
-					}
-					if i == 2 {
-						date = dataCurrentItem.DataTime
-						a := decimal.NewFromFloat(dataTwoItem.Value)
-						b := decimal.NewFromFloat(2.0)
-						val, _ = a.Div(b).Float64()
-					}
-				}
-			} else {
-				dataPreItem := yv[i-1]
-				if dataCurrentItem != nil && dataPreItem != nil {
-					date = dataCurrentItem.DataTime
-					//val, _ = decimal.NewFromFloat(dataCurrentItem.Value).Sub(decimal.NewFromFloat(dataPreItem.Value)).Float64()
-					a := decimal.NewFromFloat(dataCurrentItem.Value)
-					b := decimal.NewFromFloat(dataPreItem.Value)
-					val, _ = a.Sub(b).Float64()
-				}
-			}
-
-			if date != "" {
-				dataTime, _ := time.Parse(utils.FormatDate, date)
-				timestamp := dataTime.UnixNano() / 1e6
-				timeStr := fmt.Sprintf("%d", timestamp)
+	//计算数据
+	err = refreshAllCalculateLjzzy(to, edbInfo.EdbInfoId, edbInfo.Source, fromEdbInfo, edbInfo.EdbCode, "", "")
 
-				if _, ok := existMap[edbCode+date]; !ok {
-					addSql += GetAddSql(edbInfoIdStr, edbCode, date, timeStr, utils.SubFloatToString(val, 4))
-					isAdd = true
-				}
-				existMap[edbCode+date] = date
-			}
-		}
-	}
-	if isAdd {
-		addSql = strings.TrimRight(addSql, ",")
-		_, err = to.Raw(addSql).Exec()
-		if err != nil {
-			return edbInfoId, err
-		}
-	}
 	return
 }
 
@@ -431,9 +324,13 @@ func RefreshAllCalculateLjzzy(edbInfoId, source int, fromEdbInfo *EdbInfo, edbCo
 		}
 	}()
 
-	if err != nil {
-		return
-	}
+	// 计算数据
+	err = refreshAllCalculateLjzzy(to, edbInfoId, source, fromEdbInfo, edbCode, startDate, endDate)
+
+	return
+}
+
+func refreshAllCalculateLjzzy(to orm.TxOrmer, edbInfoId, source int, fromEdbInfo *EdbInfo, edbCode, startDate, endDate string) (err error) {
 	edbInfoIdStr := strconv.Itoa(edbInfoId)
 	//计算数据
 	var condition string
@@ -483,7 +380,7 @@ func RefreshAllCalculateLjzzy(edbInfoId, source int, fromEdbInfo *EdbInfo, edbCo
 	dataTableName := GetEdbDataTableName(source)
 	sql := `SELECT * FROM %s WHERE edb_info_id=? `
 	sql = fmt.Sprintf(sql, dataTableName)
-	_, err = o.Raw(sql, edbInfoId).QueryRows(&existDataList)
+	_, err = to.Raw(sql, edbInfoId).QueryRows(&existDataList)
 	if err != nil {
 		return err
 	}
@@ -533,7 +430,7 @@ func RefreshAllCalculateLjzzy(edbInfoId, source int, fromEdbInfo *EdbInfo, edbCo
 								b := decimal.NewFromFloat(2.0)
 								val, _ = a.Div(b).Float64()
 
-								tmpSql, newAdd, tmpErr := calculateLjzzy(edbInfoId, date, edbInfoIdStr, edbCode, dataTableName, addSql, val, dataMap, existDataMap, o)
+								tmpSql, newAdd, tmpErr := calculateLjzzy(edbInfoId, date, edbInfoIdStr, edbCode, dataTableName, addSql, val, dataMap, existDataMap, to)
 								if !isAdd {
 									isAdd = newAdd
 								}
@@ -583,7 +480,7 @@ func RefreshAllCalculateLjzzy(edbInfoId, source int, fromEdbInfo *EdbInfo, edbCo
 				//		}
 				//	}
 				//}
-				tmpSql, newAdd, tmpErr := calculateLjzzy(edbInfoId, date, edbInfoIdStr, edbCode, dataTableName, addSql, val, dataMap, existDataMap, o)
+				tmpSql, newAdd, tmpErr := calculateLjzzy(edbInfoId, date, edbInfoIdStr, edbCode, dataTableName, addSql, val, dataMap, existDataMap, to)
 				if !isAdd {
 					isAdd = newAdd
 				}
@@ -596,7 +493,7 @@ func RefreshAllCalculateLjzzy(edbInfoId, source int, fromEdbInfo *EdbInfo, edbCo
 	}
 	if isAdd {
 		addSql = strings.TrimRight(addSql, ",")
-		_, err = o.Raw(addSql).Exec()
+		_, err = to.Raw(addSql).Exec()
 		if err != nil {
 			fmt.Println("RefreshAllCalculateLjzzy add Err", err.Error())
 			return
@@ -605,7 +502,7 @@ func RefreshAllCalculateLjzzy(edbInfoId, source int, fromEdbInfo *EdbInfo, edbCo
 	return
 }
 
-func calculateLjzzy(edbInfoId int, date, edbInfoIdStr, edbCode, dataTableName, addSql string, val float64, dataMap, existDataMap map[string]string, o orm.Ormer) (newSql string, isAdd bool, err error) {
+func calculateLjzzy(edbInfoId int, date, edbInfoIdStr, edbCode, dataTableName, addSql string, val float64, dataMap, existDataMap map[string]string, o orm.TxOrmer) (newSql string, isAdd bool, err error) {
 	newSql = addSql
 	saveValue := utils.SubFloatToString(val, 4)
 	//判断数据是否存在

models/edb_data_calculate_nszydbpjjs.go

@@ -12,7 +12,7 @@ import (
 )
 
 // AddCalculateNszydpjjs N数值移动平均计算
-func AddCalculateNszydpjjs(req *EdbInfoCalculateBatchSaveReq, fromEdbInfo *EdbInfo, edbCode, uniqueCode string, sysUserId int, sysUserRealName string, formulaInt int) (edbInfoId int, err error) {
+func AddCalculateNszydpjjs(req *EdbInfoCalculateBatchSaveReq, fromEdbInfo *EdbInfo, edbCode, uniqueCode string, sysUserId int, sysUserRealName string, formulaInt int) (edbInfo *EdbInfo, err error) {
 	o := orm.NewOrm()
 	to, err := o.Begin()
 	defer func() {
@@ -24,7 +24,7 @@ func AddCalculateNszydpjjs(req *EdbInfoCalculateBatchSaveReq, fromEdbInfo *EdbIn
 		}
 	}()
 	if req.EdbInfoId <= 0 {
-		edbInfo := new(EdbInfo)
+		edbInfo = new(EdbInfo)
 		edbInfo.Source = utils.DATA_SOURCE_CALCULATE_NSZYDPJJS
 		edbInfo.SourceName = "N数值移动平均计算"
 		edbInfo.EdbCode = edbCode
@@ -42,9 +42,10 @@ func AddCalculateNszydpjjs(req *EdbInfoCalculateBatchSaveReq, fromEdbInfo *EdbIn
 		edbInfo.EdbType = 2
 		newEdbInfoId, tmpErr := to.Insert(edbInfo)
 		if tmpErr != nil {
-			return edbInfoId, tmpErr
+			err = tmpErr
+			return
 		}
-		edbInfoId = int(newEdbInfoId)
+		edbInfo.EdbInfoId = int(newEdbInfoId)
 
 		//关联关系
 		{
@@ -53,7 +54,7 @@ func AddCalculateNszydpjjs(req *EdbInfoCalculateBatchSaveReq, fromEdbInfo *EdbIn
 			calculateMappingItem.ModifyTime = time.Now()
 			calculateMappingItem.Sort = 1
 			calculateMappingItem.EdbCode = edbCode
-			calculateMappingItem.EdbInfoId = edbInfoId
+			calculateMappingItem.EdbInfoId = edbInfo.EdbInfoId
 			calculateMappingItem.FromEdbInfoId = fromEdbInfo.EdbInfoId
 			calculateMappingItem.FromEdbCode = fromEdbInfo.EdbCode
 			calculateMappingItem.FromEdbName = fromEdbInfo.EdbName
@@ -68,7 +69,10 @@ func AddCalculateNszydpjjs(req *EdbInfoCalculateBatchSaveReq, fromEdbInfo *EdbIn
 			}
 		}
 	} else {
-		edbInfoId = req.EdbInfoId
+		edbInfo, err = GetEdbInfoById(req.EdbInfoId)
+		if err != nil {
+			return
+		}
 		dataTableName := GetEdbDataTableName(utils.DATA_SOURCE_CALCULATE_NSZYDPJJS)
 		deleteSql := ` DELETE FROM %s WHERE edb_info_id=? `
 		deleteSql = fmt.Sprintf(deleteSql, dataTableName)
@@ -78,82 +82,8 @@ func AddCalculateNszydpjjs(req *EdbInfoCalculateBatchSaveReq, fromEdbInfo *EdbIn
 		}
 	}
 
-	edbInfoIdStr := strconv.Itoa(edbInfoId)
 	//计算数据
-	var condition string
-	var pars []interface{}
-	condition += " AND edb_info_id=? "
-	if req.EdbInfoId <= 0 {
-		pars = append(pars, req.FromEdbInfoId)
-	} else {
-		pars = append(pars, fromEdbInfo.EdbInfoId)
-	}
-	dataList, err := GetEdbDataListAll(condition, pars, fromEdbInfo.Source, 0)
-	if err != nil {
-		return edbInfoId, err
-	}
-	var dateArr []string
-	dataMap := make(map[string]*EdbInfoSearchData)
-	for _, v := range dataList {
-		dateArr = append(dateArr, v.DataTime)
-		dataMap[v.DataTime] = v
-	}
-
-	addSql := ` INSERT INTO edb_data_calculate_nszydpjjs(edb_info_id,edb_code,data_time,value,create_time,modify_time,data_timestamp) values `
-	var isAdd bool
-
-	arrLen := len(dateArr)
-	for ak, av := range dateArr {
-		//处理第一个值
-		var valArr []float64
-		if findItem, ok := dataMap[av]; ok {
-			valArr = append(valArr, findItem.Value)
-		} else {
-			continue
-		}
-		if ak+1 != arrLen {
-			//处理除第一个值之外的N-1个值
-			for i := 1; i < formulaInt; i++ {
-				arrIndex := ak + i
-				if arrIndex >= arrLen {
-					break
-				}
-				arrVal := dateArr[arrIndex]
-				if findItem, ok := dataMap[arrVal]; ok {
-					valArr = append(valArr, findItem.Value)
-				} else {
-					continue
-				}
-			}
-		}
-		valArrLen := len(valArr)
-		totalVal := decimal.NewFromFloat(0.00)
-		for _, v := range valArr {
-			newDecimal := decimal.NewFromFloat(v)
-			totalVal = totalVal.Add(newDecimal)
-		}
-		af := totalVal //decimal.NewFromFloat(totalVal)
-		bf := decimal.NewFromFloat(float64(valArrLen))
-		val, _ := af.Div(bf).Float64()
-		currentDate, err := time.Parse(utils.FormatDate, av)
-		if err != nil {
-			return edbInfoId, err
-		}
-
-		timestamp := currentDate.UnixNano() / 1e6
-		timestampStr := fmt.Sprintf("%d", timestamp)
-		valStr := utils.SubFloatToString(val, 4)
-		addSql += GetAddSql(edbInfoIdStr, edbCode, av, timestampStr, valStr)
-		isAdd = true
-	}
-
-	if isAdd {
-		addSql = strings.TrimRight(addSql, ",")
-		_, err = to.Raw(addSql).Exec()
-		if err != nil {
-			return edbInfoId, err
-		}
-	}
+	err = refreshAllCalculateNszydpjjs(to, edbInfo.EdbInfoId, edbInfo.Source, formulaInt, fromEdbInfo, edbInfo.EdbCode, "")
 	return
 }
 
@@ -327,9 +257,13 @@ func RefreshAllCalculateNszydpjjs(edbInfoId, source, formulaInt int, fromEdbInfo
 		}
 	}()
 
-	if err != nil {
-		return
-	}
+	//计算数据
+	err = refreshAllCalculateNszydpjjs(to, edbInfoId, source, formulaInt, fromEdbInfo, edbCode, startDate)
+	return
+}
+
+// refreshAllCalculateNszydpjjs 更新全部N数值移动平均计算
+func refreshAllCalculateNszydpjjs(to orm.TxOrmer, edbInfoId, source, formulaInt int, fromEdbInfo *EdbInfo, edbCode, startDate string) (err error) {
 	edbInfoIdStr := strconv.Itoa(edbInfoId)
 	fmt.Println(edbInfoIdStr)
 	//计算数据
@@ -430,7 +364,7 @@ func RefreshAllCalculateNszydpjjs(edbInfoId, source, formulaInt int, fromEdbInfo
 			if existStr != valStr {
 				sql := ` UPDATE %s SET value=?,modify_time=NOW() WHERE edb_info_id=? AND data_time=? `
 				sql = fmt.Sprintf(sql, dataTableName)
-				_, err = o.Raw(sql, valStr, edbInfoId, av).Exec()
+				_, err = to.Raw(sql, valStr, edbInfoId, av).Exec()
 				if err != nil {
 					return err
 				}
@@ -440,7 +374,7 @@ func RefreshAllCalculateNszydpjjs(edbInfoId, source, formulaInt int, fromEdbInfo
 	if isAdd {
 		addSql = strings.TrimRight(addSql, ",")
 		utils.FileLog.Info("addSql:" + addSql)
-		_, err = o.Raw(addSql).Exec()
+		_, err = to.Raw(addSql).Exec()
 		if err != nil {
 			return err
 		}

models/edb_data_calculate_tbz.go

@@ -12,7 +12,7 @@ import (
 )
 
 // AddCalculateTbz 同比值
-func AddCalculateTbz(req *EdbInfoCalculateBatchSaveReq, fromEdbInfo *EdbInfo, edbCode, uniqueCode string, sysUserId int, sysUserRealName string) (edbInfoId int, err error) {
+func AddCalculateTbz(req *EdbInfoCalculateBatchSaveReq, fromEdbInfo *EdbInfo, edbCode, uniqueCode string, sysUserId int, sysUserRealName string) (edbInfo *EdbInfo, err error) {
 	o := orm.NewOrm()
 	to, err := o.Begin()
 	if err != nil {
@@ -27,7 +27,7 @@ func AddCalculateTbz(req *EdbInfoCalculateBatchSaveReq, fromEdbInfo *EdbInfo, ed
 		}
 	}()
 	if req.EdbInfoId <= 0 {
-		edbInfo := new(EdbInfo)
+		edbInfo = new(EdbInfo)
 		edbInfo.Source = utils.DATA_SOURCE_CALCULATE_TBZ
 		edbInfo.SourceName = "同比值"
 		edbInfo.EdbCode = edbCode
@@ -45,9 +45,10 @@ func AddCalculateTbz(req *EdbInfoCalculateBatchSaveReq, fromEdbInfo *EdbInfo, ed
 		edbInfo.EdbType = 2
 		newEdbInfoId, tmpErr := to.Insert(edbInfo)
 		if tmpErr != nil {
-			return edbInfoId, tmpErr
+			err = tmpErr
+			return
 		}
-		edbInfoId = int(newEdbInfoId)
+		edbInfo.EdbInfoId = int(newEdbInfoId)
 
 		//关联关系
 		{
@@ -56,7 +57,7 @@ func AddCalculateTbz(req *EdbInfoCalculateBatchSaveReq, fromEdbInfo *EdbInfo, ed
 			calculateMappingItem.ModifyTime = time.Now()
 			calculateMappingItem.Sort = 1
 			calculateMappingItem.EdbCode = edbCode
-			calculateMappingItem.EdbInfoId = edbInfoId
+			calculateMappingItem.EdbInfoId = edbInfo.EdbInfoId
 			calculateMappingItem.FromEdbInfoId = fromEdbInfo.EdbInfoId
 			calculateMappingItem.FromEdbCode = fromEdbInfo.EdbCode
 			calculateMappingItem.FromEdbName = fromEdbInfo.EdbName
@@ -72,7 +73,10 @@ func AddCalculateTbz(req *EdbInfoCalculateBatchSaveReq, fromEdbInfo *EdbInfo, ed
 		}
 
 	} else {
-		edbInfoId = req.EdbInfoId
+		edbInfo, err = GetEdbInfoById(req.EdbInfoId)
+		if err != nil {
+			return
+		}
 		dataTableName := GetEdbDataTableName(utils.DATA_SOURCE_CALCULATE_TBZ)
 		deleteSql := ` DELETE FROM %s WHERE edb_info_id=? `
 		deleteSql = fmt.Sprintf(deleteSql, dataTableName)
@@ -82,147 +86,9 @@ func AddCalculateTbz(req *EdbInfoCalculateBatchSaveReq, fromEdbInfo *EdbInfo, ed
 		}
 	}
 
-	edbInfoIdStr := strconv.Itoa(edbInfoId)
-
 	//计算数据
-	var condition string
-	var pars []interface{}
-	condition += " AND edb_info_id=? "
-	if req.EdbInfoId <= 0 {
-		pars = append(pars, req.FromEdbInfoId)
-	} else {
-		pars = append(pars, fromEdbInfo.EdbInfoId)
-	}
-	dataList, err := GetEdbDataListAll(condition, pars, fromEdbInfo.Source, 0)
-	if err != nil {
-		return edbInfoId, err
-	}
-	var dateArr []string
-	dataMap := make(map[string]*EdbInfoSearchData)
-	for _, v := range dataList {
-		dateArr = append(dateArr, v.DataTime)
-		dataMap[v.DataTime] = v
-	}
-
-	addSql := ` INSERT INTO edb_data_calculate_tbz(edb_info_id,edb_code,data_time,value,create_time,modify_time,data_timestamp) values `
-	var isAdd bool
-	existMap := make(map[string]string)
-	for _, av := range dateArr {
-		//fmt.Println(ak, av)
-		currentItem := dataMap[av]
-		if currentItem != nil {
-			//当前日期
-			currentDate, err := time.Parse(utils.FormatDate, av)
-			if err != nil {
-				return edbInfoId, err
-			}
-			//上一年的日期
-			preDate := currentDate.AddDate(-1, 0, 0)
-			preDateStr := preDate.Format(utils.FormatDate)
-			if findItem, ok := dataMap[preDateStr]; ok { //上一年同期找到
-				//dataTime, _ := time.Parse(utils.FormatDate, date)
-				if _, ok := existMap[edbCode+av]; !ok {
-					timestamp := currentDate.UnixNano() / 1e6
-					timestampStr := fmt.Sprintf("%d", timestamp)
-					val := TbzDiv(currentItem.Value, findItem.Value)
-					addSql += GetAddSql(edbInfoIdStr, edbCode, av, timestampStr, val)
-					isAdd = true
-					utils.FileLog.Info("同期找到:" + av + ";" + preDateStr)
-				}
-				existMap[edbCode+av] = av
-			} else {
-				if fromEdbInfo.Frequency == "月度" { //向上和向下，各找一个月
-					nextDateDay := preDate
-					preDateDay := preDate
-					for i := 0; i <= 35; i++ {
-						nextDateDayStr := nextDateDay.Format(utils.FormatDate)
-						if findItem, ok := dataMap[nextDateDayStr]; ok { //上一年同期->下一个月找到
-							if _, ok := existMap[edbCode+av]; !ok {
-								timestamp := currentDate.UnixNano() / 1e6
-								timestampStr := fmt.Sprintf("%d", timestamp)
-								val := TbzDiv(currentItem.Value, findItem.Value)
-								addSql += GetAddSql(edbInfoIdStr, edbCode, av, timestampStr, val)
-								isAdd = true
-							}
-							existMap[edbCode+av] = av
-							break
-						} else {
-							preDateDayStr := preDateDay.Format(utils.FormatDate)
-							if findItem, ok := dataMap[preDateDayStr]; ok { //上一年同期->上一个月找到
-								if _, ok := existMap[edbCode+av]; !ok {
-									timestamp := currentDate.UnixNano() / 1e6
-									timestampStr := fmt.Sprintf("%d", timestamp)
-									val := TbzDiv(currentItem.Value, findItem.Value)
+	err = refreshAllCalculateTbz(to, edbInfo.EdbInfoId, edbInfo.Source, fromEdbInfo, edbCode, "", "")
 
-									addSql += GetAddSql(edbInfoIdStr, edbCode, av, timestampStr, val)
-									isAdd = true
-								}
-								existMap[edbCode+av] = av
-								break
-							}
-						}
-						nextDateDay = nextDateDay.AddDate(0, 0, 1)
-						preDateDay = preDateDay.AddDate(0, 0, -1)
-					}
-				} else if fromEdbInfo.Frequency == "季度" || fromEdbInfo.Frequency == "年度" {
-					if findItem, ok := dataMap[preDateStr]; ok { //上一年同期->下一个月找到
-						if _, ok := existMap[edbCode+av]; !ok {
-							timestamp := currentDate.UnixNano() / 1e6
-							timestampStr := fmt.Sprintf("%d", timestamp)
-							val := TbzDiv(currentItem.Value, findItem.Value)
-
-							addSql += GetAddSql(edbInfoIdStr, edbCode, av, timestampStr, val)
-							isAdd = true
-						}
-						existMap[edbCode+av] = av
-						break
-					}
-				} else {
-					nextDateDay := preDate
-					preDateDay := preDate
-
-					for i := 0; i < 35; i++ {
-						nextDateDayStr := nextDateDay.Format(utils.FormatDate)
-						if findItem, ok := dataMap[nextDateDayStr]; ok { //上一年同期->下一个月找到
-							if _, ok := existMap[edbCode+av]; !ok {
-								timestamp := currentDate.UnixNano() / 1e6
-								timestampStr := fmt.Sprintf("%d", timestamp)
-								val := TbzDiv(currentItem.Value, findItem.Value)
-								addSql += GetAddSql(edbInfoIdStr, edbCode, av, timestampStr, val)
-								isAdd = true
-							}
-							existMap[edbCode+av] = av
-							break
-						} else {
-							preDateDayStr := preDateDay.Format(utils.FormatDate)
-							if findItem, ok := dataMap[preDateDayStr]; ok { //上一年同期->上一个月找到
-								if _, ok := existMap[edbCode+av]; !ok {
-									timestamp := currentDate.UnixNano() / 1e6
-									timestampStr := fmt.Sprintf("%d", timestamp)
-									val := TbzDiv(currentItem.Value, findItem.Value)
-									addSql += GetAddSql(edbInfoIdStr, edbCode, av, timestampStr, val)
-									isAdd = true
-								}
-								existMap[edbCode+av] = av
-								break
-							} else {
-								//fmt.Println("pre not find:", preDateStr, "i:", i)
-							}
-						}
-						nextDateDay = nextDateDay.AddDate(0, 0, 1)
-						preDateDay = preDateDay.AddDate(0, 0, -1)
-					}
-				}
-			}
-		}
-	}
-	if isAdd {
-		addSql = strings.TrimRight(addSql, ",")
-		_, err = to.Raw(addSql).Exec()
-		if err != nil {
-			return edbInfoId, err
-		}
-	}
 	return
 }
 
@@ -486,9 +352,13 @@ func RefreshAllCalculateTbz(edbInfoId, source int, fromEdbInfo *EdbInfo, edbCode
 		}
 	}()
 
-	if err != nil {
-		return
-	}
+	//计算数据
+	err = refreshAllCalculateTbz(to, edbInfoId, source, fromEdbInfo, edbCode, startDate, endDate)
+	return
+}
+
+// refreshAllCalculateTbz
+func refreshAllCalculateTbz(to orm.TxOrmer, edbInfoId, source int, fromEdbInfo *EdbInfo, edbCode, startDate, endDate string) (err error) {
 	edbInfoIdStr := strconv.Itoa(edbInfoId)
 	//计算数据
 
@@ -524,7 +394,7 @@ func RefreshAllCalculateTbz(edbInfoId, source int, fromEdbInfo *EdbInfo, edbCode
 	fmt.Println("dataTableName:", dataTableName)
 	sql := `SELECT * FROM %s WHERE edb_info_id=? `
 	sql = fmt.Sprintf(sql, dataTableName)
-	_, err = o.Raw(sql, edbInfoId).QueryRows(&existDataList)
+	_, err = to.Raw(sql, edbInfoId).QueryRows(&existDataList)
 	if err != nil {
 		return err
 	}
@@ -565,7 +435,7 @@ func RefreshAllCalculateTbz(edbInfoId, source int, fromEdbInfo *EdbInfo, edbCode
 					if existStr != val {
 						sql := ` UPDATE %s SET value=?,modify_time=NOW() WHERE edb_info_id=? AND data_time=? `
 						sql = fmt.Sprintf(sql, dataTableName)
-						_, err = o.Raw(sql, val, edbInfoId, av).Exec()
+						_, err = to.Raw(sql, val, edbInfoId, av).Exec()
 						if err != nil {
 							return err
 						}
@@ -594,7 +464,7 @@ func RefreshAllCalculateTbz(edbInfoId, source int, fromEdbInfo *EdbInfo, edbCode
 								if existStr != val {
 									sql := ` UPDATE %s SET value=?,modify_time=NOW() WHERE edb_info_id=? AND data_time=? `
 									sql = fmt.Sprintf(sql, dataTableName)
-									_, err = o.Raw(sql, val, edbInfoId, av).Exec()
+									_, err = to.Raw(sql, val, edbInfoId, av).Exec()
 									if err != nil {
 										return err
 									}
@@ -621,7 +491,7 @@ func RefreshAllCalculateTbz(edbInfoId, source int, fromEdbInfo *EdbInfo, edbCode
 									if existStr != val {
 										sql := ` UPDATE %s SET value=?,modify_time=NOW() WHERE edb_info_id=? AND data_time=? `
 										sql = fmt.Sprintf(sql, dataTableName)
-										_, err = o.Raw(sql, val, edbInfoId, av).Exec()
+										_, err = to.Raw(sql, val, edbInfoId, av).Exec()
 										if err != nil {
 											return err
 										}
@@ -649,7 +519,7 @@ func RefreshAllCalculateTbz(edbInfoId, source int, fromEdbInfo *EdbInfo, edbCode
 							if existStr != val {
 								sql := ` UPDATE %s SET value=?,modify_time=NOW() WHERE edb_info_id=? AND data_time=? `
 								sql = fmt.Sprintf(sql, dataTableName)
-								_, err = o.Raw(sql, val, edbInfoId, av).Exec()
+								_, err = to.Raw(sql, val, edbInfoId, av).Exec()
 								if err != nil {
 									return err
 								}
@@ -686,7 +556,7 @@ func RefreshAllCalculateTbz(edbInfoId, source int, fromEdbInfo *EdbInfo, edbCode
 								if existStr != val {
 									sql := ` UPDATE %s SET value=?,modify_time=NOW() WHERE edb_info_id=? AND data_time=? `
 									sql = fmt.Sprintf(sql, dataTableName)
-									_, err = o.Raw(sql, val, edbInfoId, av).Exec()
+									_, err = to.Raw(sql, val, edbInfoId, av).Exec()
 									if err != nil {
 										return err
 									}
@@ -715,7 +585,7 @@ func RefreshAllCalculateTbz(edbInfoId, source int, fromEdbInfo *EdbInfo, edbCode
 									if existStr != val {
 										sql := ` UPDATE %s SET value=?,modify_time=NOW() WHERE edb_info_id=? AND data_time=? `
 										sql = fmt.Sprintf(sql, dataTableName)
-										_, err = o.Raw(sql, val, edbInfoId, av).Exec()
+										_, err = to.Raw(sql, val, edbInfoId, av).Exec()
 										if err != nil {
 											return err
 										}
@@ -731,7 +601,7 @@ func RefreshAllCalculateTbz(edbInfoId, source int, fromEdbInfo *EdbInfo, edbCode
 	}
 	if isAdd {
 		addSql = strings.TrimRight(addSql, ",")
-		_, err = o.Raw(addSql).Exec()
+		_, err = to.Raw(addSql).Exec()
 		if err != nil {
 			return err
 		}

models/edb_data_calculate_tcz.go

@@ -12,7 +12,7 @@ import (
 )
 
 // AddCalculateTcz 同差值
-func AddCalculateTcz(req *EdbInfoCalculateBatchSaveReq, fromEdbInfo *EdbInfo, edbCode, uniqueCode string, sysUserId int, sysUserRealName string) (edbInfoId int, err error) {
+func AddCalculateTcz(req *EdbInfoCalculateBatchSaveReq, fromEdbInfo *EdbInfo, edbCode, uniqueCode string, sysUserId int, sysUserRealName string) (edbInfo *EdbInfo, err error) {
 	o := orm.NewOrm()
 	to, err := o.Begin()
 	if err != nil {
@@ -28,7 +28,7 @@ func AddCalculateTcz(req *EdbInfoCalculateBatchSaveReq, fromEdbInfo *EdbInfo, ed
 	}()
 	fmt.Println("req.EdbInfoId:", req.EdbInfoId)
 	if req.EdbInfoId <= 0 {
-		edbInfo := new(EdbInfo)
+		edbInfo = new(EdbInfo)
 		edbInfo.Source = utils.DATA_SOURCE_CALCULATE_TCZ
 		edbInfo.SourceName = "同差值"
 		edbInfo.EdbCode = edbCode
@@ -46,9 +46,10 @@ func AddCalculateTcz(req *EdbInfoCalculateBatchSaveReq, fromEdbInfo *EdbInfo, ed
 		edbInfo.EdbType = 2
 		newEdbInfoId, tmpErr := to.Insert(edbInfo)
 		if tmpErr != nil {
-			return edbInfoId, tmpErr
+			err = tmpErr
+			return
 		}
-		edbInfoId = int(newEdbInfoId)
+		edbInfo.EdbInfoId = int(newEdbInfoId)
 
 		//关联关系
 		{
@@ -57,7 +58,7 @@ func AddCalculateTcz(req *EdbInfoCalculateBatchSaveReq, fromEdbInfo *EdbInfo, ed
 			calculateMappingItem.ModifyTime = time.Now()
 			calculateMappingItem.Sort = 1
 			calculateMappingItem.EdbCode = edbCode
-			calculateMappingItem.EdbInfoId = edbInfoId
+			calculateMappingItem.EdbInfoId = edbInfo.EdbInfoId
 			calculateMappingItem.FromEdbInfoId = fromEdbInfo.EdbInfoId
 			calculateMappingItem.FromEdbCode = fromEdbInfo.EdbCode
 			calculateMappingItem.FromEdbName = fromEdbInfo.EdbName
@@ -72,161 +73,23 @@ func AddCalculateTcz(req *EdbInfoCalculateBatchSaveReq, fromEdbInfo *EdbInfo, ed
 			}
 		}
 	} else {
-		edbInfoId = req.EdbInfoId
+		edbInfo, err = GetEdbInfoById(req.EdbInfoId)
+		if err != nil {
+			return
+		}
 		dataTableName := GetEdbDataTableName(utils.DATA_SOURCE_CALCULATE_TCZ)
 		fmt.Println("dataTableName:", dataTableName)
 		deleteSql := ` DELETE FROM %s WHERE edb_info_id=? `
 		deleteSql = fmt.Sprintf(deleteSql, dataTableName)
 		_, err = to.Raw(deleteSql, req.EdbInfoId).Exec()
 		if err != nil {
-			return edbInfoId, err
+			return
 		}
 	}
 
-	edbInfoIdStr := strconv.Itoa(edbInfoId)
-
 	//计算数据
-	var condition string
-	var pars []interface{}
-	condition += " AND edb_info_id=? "
-	if req.EdbInfoId <= 0 {
-		pars = append(pars, req.FromEdbInfoId)
-	} else {
-		pars = append(pars, fromEdbInfo.EdbInfoId)
-	}
-
-	fmt.Println("EdbInfoId:", req.FromEdbInfoId)
-	dataList, err := GetEdbDataListAll(condition, pars, fromEdbInfo.Source, 0)
-	if err != nil {
-		return edbInfoId, err
-	}
-	var dateArr []string
-	dataMap := make(map[string]*EdbInfoSearchData)
-	for _, v := range dataList {
-		dateArr = append(dateArr, v.DataTime)
-		dataMap[v.DataTime] = v
-	}
-	fmt.Println("Frequency:", fromEdbInfo.Frequency)
-	addSql := ` INSERT INTO edb_data_calculate_tcz(edb_info_id,edb_code,data_time,value,create_time,modify_time,data_timestamp) values `
-	var isAdd bool
-	existMap := make(map[string]string)
-	for _, av := range dateArr {
-		//fmt.Println("dateArr:", ak, av)
-		currentItem := dataMap[av]
-		if currentItem != nil {
-			//当前日期
-			currentDate, err := time.Parse(utils.FormatDate, av)
-			if err != nil {
-				return edbInfoId, err
-			}
-			//上一年的日期
-			preDate := currentDate.AddDate(-1, 0, 0)
-			preDateStr := preDate.Format(utils.FormatDate)
-			if findItem, ok := dataMap[preDateStr]; ok { //上一年同期找到
-				//dataTime, _ := time.Parse(utils.FormatDate, date)
-				if _, ok := existMap[edbCode+av]; !ok {
-					timestamp := currentDate.UnixNano() / 1e6
-					timestampStr := fmt.Sprintf("%d", timestamp)
-
-					val := TczSub(currentItem.Value, findItem.Value)
-					addSql += GetAddSql(edbInfoIdStr, edbCode, av, timestampStr, val)
-					isAdd = true
-				}
-				existMap[edbCode+av] = av
-			} else {
-				if fromEdbInfo.Frequency == "月度" { //向上和向下，各找一个月
-					nextDateDay := preDate
-					preDateDay := preDate
-					for i := 0; i <= 35; i++ {
-						nextDateDayStr := nextDateDay.Format(utils.FormatDate)
-						if findItem, ok := dataMap[nextDateDayStr]; ok { //下一年同期->下一个月找到
-							if _, ok := existMap[edbCode+av]; !ok {
-								timestamp := currentDate.UnixNano() / 1e6
-								timestampStr := fmt.Sprintf("%d", timestamp)
-								val := TczSub(currentItem.Value, findItem.Value)
-
-								addSql += GetAddSql(edbInfoIdStr, edbCode, av, timestampStr, val)
-								isAdd = true
-							}
-							existMap[edbCode+av] = av
-							break
-						} else {
-							preDateDayStr := preDateDay.Format(utils.FormatDate)
-							if findItem, ok := dataMap[preDateDayStr]; ok { //上一年同期->上一个月找到
-								if _, ok := existMap[edbCode+av]; !ok {
-									timestamp := currentDate.UnixNano() / 1e6
-									timestampStr := fmt.Sprintf("%d", timestamp)
-									val := TczSub(currentItem.Value, findItem.Value)
+	err = refreshAllCalculateTcz(to, edbInfo.EdbInfoId, edbInfo.Source, fromEdbInfo, edbInfo.EdbCode, "", "")
 
-									addSql += GetAddSql(edbInfoIdStr, edbCode, av, timestampStr, val)
-									isAdd = true
-								}
-								existMap[edbCode+av] = av
-								break
-							}
-						}
-						nextDateDay = nextDateDay.AddDate(0, 0, 1)
-						preDateDay = preDateDay.AddDate(0, 0, -1)
-					}
-				} else if fromEdbInfo.Frequency == "季度" || fromEdbInfo.Frequency == "年度" {
-					if findItem, ok := dataMap[preDateStr]; ok { //上一年同期->下一个月找到
-						if _, ok := existMap[edbCode+av]; !ok {
-							timestamp := currentDate.UnixNano() / 1e6
-							timestampStr := fmt.Sprintf("%d", timestamp)
-							val := TczSub(currentItem.Value, findItem.Value)
-							addSql += GetAddSql(edbInfoIdStr, edbCode, av, timestampStr, val)
-							isAdd = true
-						}
-						existMap[edbCode+av] = av
-						break
-					}
-				} else {
-					nextDateDay := preDate
-					preDateDay := preDate
-					for i := 0; i < 35; i++ {
-						nextDateDayStr := nextDateDay.Format(utils.FormatDate)
-						if findItem, ok := dataMap[nextDateDayStr]; ok { //上一年同期->下一个月找到
-							if _, ok := existMap[edbCode+av]; !ok {
-								timestamp := currentDate.UnixNano() / 1e6
-								timestampStr := fmt.Sprintf("%d", timestamp)
-								val := TczSub(currentItem.Value, findItem.Value)
-
-								addSql += GetAddSql(edbInfoIdStr, edbCode, av, timestampStr, val)
-								isAdd = true
-							}
-							existMap[edbCode+av] = av
-							break
-						} else {
-							preDateDayStr := preDateDay.Format(utils.FormatDate)
-							if findItem, ok := dataMap[preDateDayStr]; ok { //上一年同期->上一个月找到
-								if _, ok := existMap[edbCode+av]; !ok {
-									timestamp := currentDate.UnixNano() / 1e6
-									timestampStr := fmt.Sprintf("%d", timestamp)
-									val := TczSub(currentItem.Value, findItem.Value)
-
-									addSql += GetAddSql(edbInfoIdStr, edbCode, av, timestampStr, val)
-									isAdd = true
-								}
-								existMap[edbCode+av] = av
-								break
-							} else {
-
-							}
-						}
-						nextDateDay = nextDateDay.AddDate(0, 0, 1)
-						preDateDay = preDateDay.AddDate(0, 0, -1)
-					}
-				}
-			}
-		}
-	}
-	if isAdd {
-		addSql = strings.TrimRight(addSql, ",")
-		_, err = to.Raw(addSql).Exec()
-		if err != nil {
-			return edbInfoId, err
-		}
-	}
 	return
 }
 
@@ -494,9 +357,12 @@ func RefreshAllCalculateTcz(edbInfoId, source int, fromEdbInfo *EdbInfo, edbCode
 		}
 	}()
 
-	if err != nil {
-		return
-	}
+	err = refreshAllCalculateTcz(to, edbInfoId, source, fromEdbInfo, edbCode, startDate, endDate)
+
+	return
+}
+
+func refreshAllCalculateTcz(to orm.TxOrmer, edbInfoId, source int, fromEdbInfo *EdbInfo, edbCode, startDate, endDate string) (err error) {
 	edbInfoIdStr := strconv.Itoa(edbInfoId)
 	//计算数据
 
@@ -530,7 +396,7 @@ func RefreshAllCalculateTcz(edbInfoId, source int, fromEdbInfo *EdbInfo, edbCode
 	dataTableName := GetEdbDataTableName(source)
 	sql := `SELECT * FROM %s WHERE edb_info_id=? `
 	sql = fmt.Sprintf(sql, dataTableName)
-	_, err = o.Raw(sql, edbInfoId).QueryRows(&existDataList)
+	_, err = to.Raw(sql, edbInfoId).QueryRows(&existDataList)
 	if err != nil {
 		return err
 	}
@@ -571,7 +437,7 @@ func RefreshAllCalculateTcz(edbInfoId, source int, fromEdbInfo *EdbInfo, edbCode
 					if existStr != val {
 						sql := ` UPDATE %s SET value=?,modify_time=NOW() WHERE edb_info_id=? AND data_time=? `
 						sql = fmt.Sprintf(sql, dataTableName)
-						_, err = o.Raw(sql, val, edbInfoId, av).Exec()
+						_, err = to.Raw(sql, val, edbInfoId, av).Exec()
 						if err != nil {
 							return err
 						}
@@ -601,7 +467,7 @@ func RefreshAllCalculateTcz(edbInfoId, source int, fromEdbInfo *EdbInfo, edbCode
 								if existStr != val {
 									sql := ` UPDATE %s SET value=?,modify_time=NOW() WHERE edb_info_id=? AND data_time=? `
 									sql = fmt.Sprintf(sql, dataTableName)
-									_, err = o.Raw(sql, val, edbInfoId, av).Exec()
+									_, err = to.Raw(sql, val, edbInfoId, av).Exec()
 									if err != nil {
 										return err
 									}
@@ -628,7 +494,7 @@ func RefreshAllCalculateTcz(edbInfoId, source int, fromEdbInfo *EdbInfo, edbCode
 									if existStr != val {
 										sql := ` UPDATE %s SET value=?,modify_time=NOW() WHERE edb_info_id=? AND data_time=? `
 										sql = fmt.Sprintf(sql, dataTableName)
-										_, err = o.Raw(sql, val, edbInfoId, av).Exec()
+										_, err = to.Raw(sql, val, edbInfoId, av).Exec()
 										if err != nil {
 											return err
 										}
@@ -656,7 +522,7 @@ func RefreshAllCalculateTcz(edbInfoId, source int, fromEdbInfo *EdbInfo, edbCode
 							if existStr != val {
 								sql := ` UPDATE %s SET value=?,modify_time=NOW() WHERE edb_info_id=? AND data_time=? `
 								sql = fmt.Sprintf(sql, dataTableName)
-								_, err = o.Raw(sql, val, edbInfoId, av).Exec()
+								_, err = to.Raw(sql, val, edbInfoId, av).Exec()
 								if err != nil {
 									return err
 								}
@@ -685,7 +551,7 @@ func RefreshAllCalculateTcz(edbInfoId, source int, fromEdbInfo *EdbInfo, edbCode
 								if existStr != val {
 									sql := ` UPDATE %s SET value=?,modify_time=NOW() WHERE edb_info_id=? AND data_time=? `
 									sql = fmt.Sprintf(sql, dataTableName)
-									_, err = o.Raw(sql, val, edbInfoId, av).Exec()
+									_, err = to.Raw(sql, val, edbInfoId, av).Exec()
 									if err != nil {
 										return err
 									}
@@ -712,7 +578,7 @@ func RefreshAllCalculateTcz(edbInfoId, source int, fromEdbInfo *EdbInfo, edbCode
 									if existStr != val {
 										sql := ` UPDATE %s SET value=?,modify_time=NOW() WHERE edb_info_id=? AND data_time=? `
 										sql = fmt.Sprintf(sql, dataTableName)
-										_, err = o.Raw(sql, val, edbInfoId, av).Exec()
+										_, err = to.Raw(sql, val, edbInfoId, av).Exec()
 										if err != nil {
 											return err
 										}
@@ -728,7 +594,7 @@ func RefreshAllCalculateTcz(edbInfoId, source int, fromEdbInfo *EdbInfo, edbCode
 	}
 	if isAdd {
 		addSql = strings.TrimRight(addSql, ",")
-		_, err = o.Raw(addSql).Exec()
+		_, err = to.Raw(addSql).Exec()
 		if err != nil {
 			return err
 		}

models/edb_data_calculate_time_shift.go

@@ -12,7 +12,7 @@ import (
 )
 
 // AddCalculateTimeShift 时间移位
-func AddCalculateTimeShift(req *EdbInfoCalculateBatchSaveReq, fromEdbInfo *EdbInfo, edbCode, uniqueCode string, sysUserId int, sysUserRealName string) (edbInfoId int, err error) {
+func AddCalculateTimeShift(req *EdbInfoCalculateBatchSaveReq, fromEdbInfo *EdbInfo, edbCode, uniqueCode string, sysUserId int, sysUserRealName string) (edbInfo *EdbInfo, err error) {
 	o := orm.NewOrm()
 	to, err := o.Begin()
 	if err != nil {
@@ -28,7 +28,7 @@ func AddCalculateTimeShift(req *EdbInfoCalculateBatchSaveReq, fromEdbInfo *EdbIn
 		}
 	}()
 	if req.EdbInfoId <= 0 {
-		edbInfo := new(EdbInfo)
+		edbInfo = new(EdbInfo)
 		edbInfo.Source = utils.DATA_SOURCE_CALCULATE_TIME_SHIFT
 		edbInfo.SourceName = "时间移位"
 		edbInfo.EdbCode = edbCode
@@ -48,9 +48,10 @@ func AddCalculateTimeShift(req *EdbInfoCalculateBatchSaveReq, fromEdbInfo *EdbIn
 		edbInfo.MoveFrequency = req.MoveFrequency
 		newEdbInfoId, tmpErr := o.Insert(edbInfo)
 		if tmpErr != nil {
-			return edbInfoId, tmpErr
+			err = tmpErr
+			return
 		}
-		edbInfoId = int(newEdbInfoId)
+		edbInfo.EdbInfoId = int(newEdbInfoId)
 		//关联关系
 		{
 			calculateMappingItem := new(EdbInfoCalculateMapping)
@@ -58,7 +59,7 @@ func AddCalculateTimeShift(req *EdbInfoCalculateBatchSaveReq, fromEdbInfo *EdbIn
 			calculateMappingItem.ModifyTime = time.Now()
 			calculateMappingItem.Sort = 1
 			calculateMappingItem.EdbCode = edbCode
-			calculateMappingItem.EdbInfoId = edbInfoId
+			calculateMappingItem.EdbInfoId = edbInfo.EdbInfoId
 			calculateMappingItem.FromEdbInfoId = fromEdbInfo.EdbInfoId
 			calculateMappingItem.FromEdbCode = fromEdbInfo.EdbCode
 			calculateMappingItem.FromEdbName = fromEdbInfo.EdbName
@@ -73,79 +74,25 @@ func AddCalculateTimeShift(req *EdbInfoCalculateBatchSaveReq, fromEdbInfo *EdbIn
 			}
 		}
 	} else {
-		edbInfoId = req.EdbInfoId
+		edbInfo, err = GetEdbInfoById(req.EdbInfoId)
+		if err != nil {
+			return
+		}
 		dataTableName := GetEdbDataTableName(utils.DATA_SOURCE_CALCULATE_TIME_SHIFT)
 		fmt.Println("dataTableName:" + dataTableName)
 		deleteSql := ` DELETE FROM %s WHERE edb_info_id=? `
 		deleteSql = fmt.Sprintf(deleteSql, dataTableName)
 		_, err = to.Raw(deleteSql, req.EdbInfoId).Exec()
 		if err != nil {
-			return 0, err
+			return
 		}
 	}
 
-	var shiftDay int
 	formulaInt, _ := strconv.Atoi(req.Formula)
-	switch req.MoveFrequency {
-	case "天":
-		shiftDay = formulaInt
-	case "周":
-		shiftDay = formulaInt * 7
-	case "月":
-		shiftDay = formulaInt * 30
-	case "季":
-		shiftDay = formulaInt * 90
-	case "年":
-		shiftDay = formulaInt * 365
-	default:
-		shiftDay = formulaInt
-	}
 
-	edbInfoIdStr := strconv.Itoa(edbInfoId)
 	//计算数据
-	var condition string
-	var pars []interface{}
-	condition += " AND edb_info_id=? "
-	if req.EdbInfoId <= 0 {
-		pars = append(pars, req.FromEdbInfoId)
-	} else {
-		pars = append(pars, fromEdbInfo.EdbInfoId)
-	}
-	dataList, err := GetEdbDataListAll(condition, pars, fromEdbInfo.Source, 0)
-	if err != nil {
-		return edbInfoId, err
-	}
+	err = refreshAllCalculateTimeShift(to, edbInfo.EdbInfoId, edbInfo.Source, formulaInt, edbInfo.MoveType, fromEdbInfo, edbInfo.EdbCode, "", "", edbInfo.MoveFrequency)
 
-	addSql := ` INSERT INTO edb_data_calculate_time_shift(edb_info_id,edb_code,data_time,value,create_time,modify_time,data_timestamp) values `
-	var isAdd bool
-	existMap := make(map[string]string)
-	dataLen := len(dataList)
-	if req.MoveType == 2 {
-		shiftDay = -shiftDay
-	}
-	for i := 0; i < dataLen; i++ {
-		//当期
-		currentItem := dataList[i]
-		currentDate, _ := time.Parse(utils.FormatDate, currentItem.DataTime)
-
-		existKey := edbCode + currentItem.DataTime
-		if _, ok := existMap[existKey]; !ok {
-			newDate := currentDate.AddDate(0, 0, shiftDay)
-			timestamp := newDate.UnixNano() / 1e6
-			timestampStr := fmt.Sprintf("%d", timestamp)
-			valStr := decimal.NewFromFloat(currentItem.Value).String()
-			addSql += GetAddSql(edbInfoIdStr, edbCode, newDate.Format(utils.FormatDate), timestampStr, valStr)
-			isAdd = true
-		}
-		existMap[existKey] = currentItem.DataTime
-	}
-	if isAdd {
-		addSql = strings.TrimRight(addSql, ",")
-		_, err = to.Raw(addSql).Exec()
-		if err != nil {
-			return edbInfoId, err
-		}
-	}
 	return
 }
 
@@ -306,7 +253,6 @@ func RefreshAllCalculateTimeShift(edbInfoId, source, formulaInt, moveType int, f
 	if err != nil {
 		return
 	}
-
 	defer func() {
 		if err != nil {
 			fmt.Println("RefreshAllCalculateTimeShift,Err:" + err.Error())
@@ -316,11 +262,15 @@ func RefreshAllCalculateTimeShift(edbInfoId, source, formulaInt, moveType int, f
 		}
 	}()
 
-	if err != nil {
-		return
-	}
-	edbInfoIdStr := strconv.Itoa(edbInfoId)
 	//计算数据
+	err = refreshAllCalculateTimeShift(to, edbInfoId, source, formulaInt, moveType, fromEdbInfo, edbCode, startDate, endDate, moveFrequency)
+
+	return
+}
+
+// refreshAllCalculateTimeShift 刷新所有时间移位数据
+func refreshAllCalculateTimeShift(to orm.TxOrmer, edbInfoId, source, formulaInt, moveType int, fromEdbInfo *EdbInfo, edbCode, startDate, endDate, moveFrequency string) (err error) {
+	edbInfoIdStr := strconv.Itoa(edbInfoId)
 
 	//计算数据
 	var condition string
@@ -374,7 +324,7 @@ func RefreshAllCalculateTimeShift(edbInfoId, source, formulaInt, moveType int, f
 	fmt.Println("dataTableName:", dataTableName)
 	sql := `SELECT * FROM %s WHERE edb_info_id=? `
 	sql = fmt.Sprintf(sql, dataTableName)
-	_, err = o.Raw(sql, edbInfoId).QueryRows(&existDataList)
+	_, err = to.Raw(sql, edbInfoId).QueryRows(&existDataList)
 	if err != nil {
 		return err
 	}
@@ -408,7 +358,7 @@ func RefreshAllCalculateTimeShift(edbInfoId, source, formulaInt, moveType int, f
 				if existStr != valStr {
 					sql := ` UPDATE %s SET value=?,modify_time=NOW() WHERE edb_info_id=? AND data_time=? `
 					sql = fmt.Sprintf(sql, dataTableName)
-					_, err = o.Raw(sql, valStr, edbInfoId, newDate.Format(utils.FormatDate)).Exec()
+					_, err = to.Raw(sql, valStr, edbInfoId, newDate.Format(utils.FormatDate)).Exec()
 					if err != nil {
 						return err
 					}
@@ -420,7 +370,7 @@ func RefreshAllCalculateTimeShift(edbInfoId, source, formulaInt, moveType int, f
 
 	if isAdd {
 		addSql = strings.TrimRight(addSql, ",")
-		_, err = o.Raw(addSql).Exec()
+		_, err = to.Raw(addSql).Exec()
 		if err != nil {
 			return err
 		}

models/edb_data_calculate_zjpj.go

@@ -22,7 +22,7 @@ type EdbDataCalculateZjpj struct {
 }
 
 // AddCalculateZjpj 新增直接拼接数据
-func AddCalculateZjpj(req *EdbInfoCalculateBatchSaveReq, firstEdbInfo, secondEdbInfo *EdbInfo, edbCode, uniqueCode string, sysUserId int, sysUserRealName string) (edbInfoId int, err error) {
+func AddCalculateZjpj(req *EdbInfoCalculateBatchSaveReq, firstEdbInfo, secondEdbInfo *EdbInfo, edbCode, uniqueCode string, sysUserId int, sysUserRealName string) (edbInfo *EdbInfo, err error) {
 	o := orm.NewOrm()
 	to, err := o.Begin()
 	if err != nil {
@@ -36,7 +36,6 @@ func AddCalculateZjpj(req *EdbInfoCalculateBatchSaveReq, firstEdbInfo, secondEdb
 			_ = to.Commit()
 		}
 	}()
-	var edbInfo *EdbInfo
 	if req.EdbInfoId <= 0 {
 		edbInfo = &EdbInfo{
 			SourceName:       "直接拼接",
@@ -57,15 +56,19 @@ func AddCalculateZjpj(req *EdbInfoCalculateBatchSaveReq, firstEdbInfo, secondEdb
 			CalculateFormula: req.Formula,
 			EdbType:          2,
 		}
-		newEdbInfoId, err := to.Insert(edbInfo)
-		if err != nil {
-			return edbInfoId, err
+		newEdbInfoId, tmpErr := to.Insert(edbInfo)
+		if tmpErr != nil {
+			err = tmpErr
+			return
 		}
-		edbInfoId = int(newEdbInfoId)
+		edbInfo.EdbInfoId = int(newEdbInfoId)
 	} else {
-		edbInfoId = req.EdbInfoId
+		edbInfo, err = GetEdbInfoById(req.EdbInfoId)
+		if err != nil {
+			return
+		}
 		//查询
-		tmpEdbInfo, tmpErr := GetEdbInfoById(edbInfoId)
+		tmpEdbInfo, tmpErr := GetEdbInfoById(edbInfo.EdbInfoId)
 		if tmpErr != nil {
 			err = tmpErr
 			return
@@ -85,156 +88,72 @@ func AddCalculateZjpj(req *EdbInfoCalculateBatchSaveReq, firstEdbInfo, secondEdb
 		deleteSql = fmt.Sprintf(deleteSql, dataTableName)
 		_, err = to.Raw(deleteSql, req.EdbInfoId).Exec()
 		if err != nil {
-			return 0, err
+			return
 		}
 
 		//删除指标关系
 		sql := ` DELETE FROM edb_info_calculate_mapping WHERE edb_info_id=? `
-		_, err = to.Raw(sql, edbInfoId).Exec()
+		_, err = to.Raw(sql, edbInfo.EdbInfoId).Exec()
 	}
 
 	//关联关系
 
+	var existItemA, existItemB *EdbInfoCalculateMapping
 	//第一个指标
 	{
-		calculateMappingItem := new(EdbInfoCalculateMapping)
-		calculateMappingItem.CreateTime = time.Now()
-		calculateMappingItem.ModifyTime = time.Now()
-		calculateMappingItem.Sort = 1
-		calculateMappingItem.EdbCode = edbCode
-		calculateMappingItem.EdbInfoId = edbInfoId
-		calculateMappingItem.FromEdbInfoId = firstEdbInfo.EdbInfoId
-		calculateMappingItem.FromEdbCode = firstEdbInfo.EdbCode
-		calculateMappingItem.FromEdbName = firstEdbInfo.EdbName
-		calculateMappingItem.FromSource = firstEdbInfo.Source
-		calculateMappingItem.FromSourceName = firstEdbInfo.SourceName
-		calculateMappingItem.FromTag = "A"
-		calculateMappingItem.Source = edbInfo.Source
-		calculateMappingItem.SourceName = edbInfo.SourceName
-		_, err = to.Insert(calculateMappingItem)
-		if err != nil {
+		existItemA = &EdbInfoCalculateMapping{
+			EdbInfoCalculateMappingId: 0,
+			EdbInfoId:                 edbInfo.EdbInfoId,
+			Source:                    edbInfo.Source,
+			SourceName:                edbInfo.SourceName,
+			EdbCode:                   edbInfo.EdbCode,
+			FromEdbInfoId:             firstEdbInfo.EdbInfoId,
+			FromEdbCode:               firstEdbInfo.EdbCode,
+			FromEdbName:               firstEdbInfo.EdbName,
+			FromSource:                firstEdbInfo.Source,
+			FromSourceName:            firstEdbInfo.SourceName,
+			FromTag:                   "A",
+			Sort:                      1,
+			CreateTime:                time.Now(),
+			ModifyTime:                time.Now(),
+		}
+		insertId, tmpErr := to.Insert(existItemA)
+		if tmpErr != nil {
+			err = tmpErr
 			return
 		}
+		existItemA.EdbInfoCalculateMappingId = int(insertId)
 	}
 
 	//第二个指标
 	{
-		calculateMappingItem := new(EdbInfoCalculateMapping)
-		calculateMappingItem.CreateTime = time.Now()
-		calculateMappingItem.ModifyTime = time.Now()
-		calculateMappingItem.Sort = 1
-		calculateMappingItem.EdbCode = edbCode
-		calculateMappingItem.EdbInfoId = edbInfoId
-		calculateMappingItem.FromEdbInfoId = secondEdbInfo.EdbInfoId
-		calculateMappingItem.FromEdbCode = secondEdbInfo.EdbCode
-		calculateMappingItem.FromEdbName = secondEdbInfo.EdbName
-		calculateMappingItem.FromSource = secondEdbInfo.Source
-		calculateMappingItem.FromSourceName = secondEdbInfo.SourceName
-		calculateMappingItem.FromTag = "B"
-		calculateMappingItem.Source = edbInfo.Source
-		calculateMappingItem.SourceName = edbInfo.SourceName
-		_, err = to.Insert(calculateMappingItem)
-		if err != nil {
+		existItemB = &EdbInfoCalculateMapping{
+			EdbInfoCalculateMappingId: 0,
+			EdbInfoId:                 edbInfo.EdbInfoId,
+			Source:                    edbInfo.Source,
+			SourceName:                edbInfo.SourceName,
+			EdbCode:                   edbInfo.EdbCode,
+			FromEdbInfoId:             secondEdbInfo.EdbInfoId,
+			FromEdbCode:               secondEdbInfo.EdbCode,
+			FromEdbName:               secondEdbInfo.EdbName,
+			FromSource:                secondEdbInfo.Source,
+			FromSourceName:            secondEdbInfo.SourceName,
+			FromTag:                   "B",
+			Sort:                      1,
+			CreateTime:                time.Now(),
+			ModifyTime:                time.Now(),
+		}
+		insertId, tmpErr := to.Insert(existItemB)
+		if tmpErr != nil {
+			err = tmpErr
 			return
 		}
+		existItemB.EdbInfoCalculateMappingId = int(insertId)
 	}
 
-	addDataList := make([]*EdbDataCalculateZjpj, 0)
-
 	//拼接数据
+	err = refreshAllCalculateZjpj(to, edbInfo, existItemA, existItemB)
 
-	//第一个指标
-	{
-		var condition string
-		var pars []interface{}
-
-		condition += " AND data_time < ? AND edb_info_id=? "
-		pars = append(pars, req.Formula, firstEdbInfo.EdbInfoId)
-
-		//第一个指标的数据列表
-		firstDataList, tmpErr := GetEdbDataListAll(condition, pars, firstEdbInfo.Source, 0)
-		if tmpErr != nil {
-			return edbInfoId, tmpErr
-		}
-
-		for _, v := range firstDataList {
-			//时间戳
-			currentDate, _ := time.Parse(utils.FormatDate, v.DataTime)
-			timestamp := currentDate.UnixNano() / 1e6
-
-			edbDataZjpj := &EdbDataCalculateZjpj{
-				EdbInfoId:     edbInfoId,
-				EdbCode:       edbInfo.EdbCode,
-				DataTime:      v.DataTime,
-				Value:         v.Value,
-				Status:        1,
-				CreateTime:    time.Now(),
-				ModifyTime:    time.Now(),
-				DataTimestamp: timestamp,
-			}
-			addDataList = append(addDataList, edbDataZjpj)
-			if len(addDataList) >= 200 {
-				_, tmpErr := to.InsertMulti(len(addDataList), addDataList)
-				if tmpErr != nil {
-					err = tmpErr
-					return
-				}
-				//重新初始化需要加入的数据切片
-				addDataList = make([]*EdbDataCalculateZjpj, 0)
-			}
-		}
-	}
-
-	//第二个指标
-	{
-		var condition string
-		var pars []interface{}
-
-		condition += " AND data_time >= ? AND edb_info_id = ? "
-		pars = append(pars, req.Formula, secondEdbInfo.EdbInfoId)
-
-		//第二个指标的数据列表
-		secondDataList, tmpErr := GetEdbDataListAll(condition, pars, secondEdbInfo.Source, 0)
-		if tmpErr != nil {
-			return edbInfoId, tmpErr
-		}
-
-		for _, v := range secondDataList {
-			//时间戳
-			currentDate, _ := time.Parse(utils.FormatDate, v.DataTime)
-			timestamp := currentDate.UnixNano() / 1e6
-
-			edbDataZjpj := &EdbDataCalculateZjpj{
-				EdbInfoId:     edbInfoId,
-				EdbCode:       edbInfo.EdbCode,
-				DataTime:      v.DataTime,
-				Value:         v.Value,
-				Status:        1,
-				CreateTime:    time.Now(),
-				ModifyTime:    time.Now(),
-				DataTimestamp: timestamp,
-			}
-			addDataList = append(addDataList, edbDataZjpj)
-			if len(addDataList) >= 200 {
-				_, tmpErr := to.InsertMulti(len(addDataList), addDataList)
-				if tmpErr != nil {
-					err = tmpErr
-					return
-				}
-				//重新初始化需要加入的数据切片
-				addDataList = make([]*EdbDataCalculateZjpj, 0)
-			}
-		}
-	}
-
-	//将剩余的数据入库
-	if len(addDataList) > 0 {
-		_, tmpErr := to.InsertMulti(len(addDataList), addDataList)
-		if tmpErr != nil {
-			err = tmpErr
-			return
-		}
-	}
 	return
 }
 
@@ -537,26 +456,6 @@ func RefreshAllCalculateZjpj(edbInfo *EdbInfo) (err error) {
 			_ = to.Commit()
 		}
 	}()
-
-	//查询当前指标现有的数据
-	var condition string
-	var pars []interface{}
-	condition += " AND edb_info_id=? "
-	pars = append(pars, edbInfo.EdbInfoId)
-
-	dataList, err := GetAllEdbDataCalculateZjpjByEdbInfoId(edbInfo.EdbInfoId)
-	if err != nil {
-		return err
-	}
-	var dateArr []string
-	dataMap := make(map[string]*EdbDataCalculateZjpj)
-	removeDataTimeMap := make(map[string]int) //需要移除的日期数据
-	for _, v := range dataList {
-		dateArr = append(dateArr, v.DataTime)
-		dataMap[v.DataTime] = v
-		removeDataTimeMap[v.DataTime] = 1
-	}
-
 	//查询关联指标信息
 	var existCondition string
 	var existPars []interface{}
@@ -576,6 +475,32 @@ func RefreshAllCalculateZjpj(edbInfo *EdbInfo) (err error) {
 			existItemB = existItem
 		}
 	}
+	// 刷新数据
+	err = refreshAllCalculateZjpj(to, edbInfo, existItemA, existItemB)
+
+	return
+}
+
+// refreshAllCalculateZjpj 刷新所有 直接拼接 数据
+func refreshAllCalculateZjpj(to orm.TxOrmer, edbInfo *EdbInfo, existItemA, existItemB *EdbInfoCalculateMapping) (err error) {
+	//查询当前指标现有的数据
+	var condition string
+	var pars []interface{}
+	condition += " AND edb_info_id=? "
+	pars = append(pars, edbInfo.EdbInfoId)
+
+	dataList, err := GetAllEdbDataCalculateZjpjByEdbInfoId(edbInfo.EdbInfoId)
+	if err != nil {
+		return err
+	}
+	var dateArr []string
+	dataMap := make(map[string]*EdbDataCalculateZjpj)
+	removeDataTimeMap := make(map[string]int) //需要移除的日期数据
+	for _, v := range dataList {
+		dateArr = append(dateArr, v.DataTime)
+		dataMap[v.DataTime] = v
+		removeDataTimeMap[v.DataTime] = 1
+	}
 
 	addDataList := make([]*EdbDataCalculateZjpj, 0)
 	//第一个指标
@@ -602,7 +527,7 @@ func RefreshAllCalculateZjpj(edbInfo *EdbInfo) (err error) {
 				if edbData.Value != v.Value {
 					//更新指标数据
 					edbData.Value = v.Value
-					_, _ = o.Update(edbData, "Value")
+					_, _ = to.Update(edbData, "Value")
 				}
 			} else {
 				//时间戳
@@ -649,7 +574,7 @@ func RefreshAllCalculateZjpj(edbInfo *EdbInfo) (err error) {
 					//更新指标数据
 					edbData.Value = v.Value
 					edbData.ModifyTime = time.Now()
-					_, tmpErr := o.Update(edbData, "Value", "ModifyTime")
+					_, tmpErr := to.Update(edbData, "Value", "ModifyTime")
 					if tmpErr != nil {
 						fmt.Println("tmpErr:", tmpErr)
 					}
@@ -687,7 +612,7 @@ func RefreshAllCalculateZjpj(edbInfo *EdbInfo) (err error) {
 			tableName := GetEdbDataTableName(edbInfo.Source)
 			sql := fmt.Sprintf(` DELETE FROM %s WHERE edb_info_id = ? and data_time in (%s) `, tableName, removeDateStr)
 
-			_, err = o.Raw(sql, edbInfo.EdbInfoId).Exec()
+			_, err = to.Raw(sql, edbInfo.EdbInfoId).Exec()
 			if err != nil {
 				err = fmt.Errorf("删除不存在的直接拼接指标数据失败,Err:" + err.Error())
 				return
@@ -696,23 +621,8 @@ func RefreshAllCalculateZjpj(edbInfo *EdbInfo) (err error) {
 	}
 
 	//数据入库
-	tmpAddDataList := make([]*EdbDataCalculateZjpj, 0)
-	for _, v := range addDataList {
-		tmpAddDataList = append(tmpAddDataList, v)
-
-		if len(tmpAddDataList) >= 200 {
-			_, tmpErr := o.InsertMulti(len(tmpAddDataList), tmpAddDataList)
-			if tmpErr != nil {
-				err = tmpErr
-				return
-			}
-			//重新初始化需要加入的数据切片
-			tmpAddDataList = make([]*EdbDataCalculateZjpj, 0)
-		}
-	}
-	//最后如果还有需要新增的数据，那么就统一入库
-	if len(tmpAddDataList) > 0 {
-		_, tmpErr := o.InsertMulti(len(tmpAddDataList), tmpAddDataList)
+	if len(addDataList) > 0 {
+		_, tmpErr := to.InsertMulti(len(addDataList), addDataList)
 		if tmpErr != nil {
 			err = tmpErr
 			return

models/edb_data_table.go

@@ -71,6 +71,8 @@ func GetEdbDataTableName(source int) (tableName string) {
 		tableName = "edb_data_predict_calculate_tcz"
 	case utils.DATA_SOURCE_MYSTEEL_CHEMICAL:
 		tableName = "edb_data_mysteel_chemical"
+	case utils.DATA_SOURCE_CALCULATE_CJJX:
+		tableName = "edb_data_calculate_cjjx"
 	default:
 		tableName = ""
 	}

models/edb_info.go

@@ -524,3 +524,20 @@ func ModifyPredictEdbInfoMaxAndMinInfo(edbInfoId int, item *EdbInfoMaxAndMinInfo
 	_, err = o.Raw(sql, item.MinDate, item.MaxDate, item.MinValue, item.MaxValue, item.LatestDate, item.LatestValue, edbInfoId).Exec()
 	return
 }
+
+// ModifyCalculateEdbInfo 修改计算指标信息
+func ModifyCalculateEdbInfo(edbName, frequency, unit, calculateFormula string, classifyId, edbInfoId int) (err error) {
+	o := orm.NewOrmUsingDB("data")
+	sql := ` UPDATE  edb_info
+			SET
+			  edb_name =?,
+			  edb_name_source =?,
+			  frequency = ?,
+			  unit = ?,
+			  classify_id = ?,
+			  calculate_formula=?,
+			  modify_time = NOW()
+			WHERE edb_info_id = ?`
+	_, err = o.Raw(sql, edbName, edbName, frequency, unit, classifyId, calculateFormula, edbInfoId).Exec()
+	return
+}

routers/commentsRouter.go

@@ -18,13 +18,22 @@ func init() {
 
     beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:CalculateController"] = append(beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:CalculateController"],
         beego.ControllerComments{
-            Method: "CalculateBatchSave",
+            Method: "BatchSave",
             Router: `/batch/save`,
             AllowHTTPMethods: []string{"post"},
             MethodParams: param.Make(),
             Filters: nil,
             Params: nil})
 
+    beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:CalculateController"] = append(beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:CalculateController"],
+        beego.ControllerComments{
+            Method: "Edit",
+            Router: `/edit`,
+            AllowHTTPMethods: []string{"post"},
+            MethodParams: param.Make(),
+            Filters: nil,
+            Params: nil})
+
     beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:CalculateController"] = append(beego.GlobalControllerRouter["hongze/hongze_edb_lib/controllers:CalculateController"],
         beego.ControllerComments{
             Method: "Refresh",

utils/constants.go

@@ -62,6 +62,7 @@ const (
 	DATA_SOURCE_PREDICT_CALCULATE_TBZ            //同比值->32
 	DATA_SOURCE_PREDICT_CALCULATE_TCZ            //同差值->33
 	DATA_SOURCE_MYSTEEL_CHEMICAL                 //钢联化工->34
+	DATA_SOURCE_CALCULATE_CJJX                   //超季节性->35
 )
 
 //基础数据初始化日期