计算指标相关接口

controllers/data_manage/edb_info.go

@@ -2987,121 +2987,121 @@ func (this *EdbInfoController) EdbInfoReplaceCheck() {
 // @Param	request	body data_manage.EdbInfoReplaceReq true "type json string"
 // @Success 200 {object} data_manage.EdbInfoDataResp
 // @router /edb_info/replace [post]
-//func (this *ChartInfoController) EdbInfoReplace() {
-//	br := new(models.BaseResponse).Init()
-//	setNxKey := "EDB_INFO_REPLACE"
-//	deleteCache := true
-//
-//	defer func() {
-//		if deleteCache {
-//			utils.Rc.Delete(setNxKey)
-//		}
-//		this.Data["json"] = br
-//		this.ServeJSON()
-//	}()
-//
-//	sysUser := this.SysUser
-//	if sysUser == nil {
-//		br.Msg = "请登录"
-//		br.ErrMsg = "请登录，SysUser Is Empty"
-//		br.Ret = 408
-//		return
-//	}
-//
-//	if !utils.Rc.SetNX(setNxKey, 1, 30*time.Minute) {
-//		deleteCache = false
-//		br.Msg = "当前正在替换中，请耐心等待！"
-//		br.IsSendEmail = false
-//		return
-//	}
-//
-//	var req data_manage.EdbInfoReplaceReq
-//	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
-//	if err != nil {
-//		br.Msg = "参数解析异常！"
-//		br.ErrMsg = "参数解析失败，Err:" + err.Error()
-//		return
-//	}
-//	if req.OldEdbInfoId <= 0 || req.NewEdbInfoId <= 0 {
-//		br.Msg = "参数错误！"
-//		br.ErrMsg = "参数错误，指标id为0"
-//		return
-//	}
-//
-//	oldEdbInfo, err := data_manage.GetEdbInfoById(req.OldEdbInfoId)
-//	if err != nil {
-//		br.Msg = "替换失败！"
-//		br.ErrMsg = "获取原指标失败，Err:" + err.Error()
-//		return
-//	}
-//
-//	newEdbInfo, err := data_manage.GetEdbInfoById(req.NewEdbInfoId)
-//	if err != nil {
-//		br.Msg = "替换失败！"
-//		br.ErrMsg = "获取替换目标指标失败，Err:" + err.Error()
-//		return
-//	}
-//
-//	//if oldEdbInfo.EdbType != 1 {
-//	//	br.Msg = "原指标为计算指标，不可替换！"
-//	//	br.ErrMsg = "原指标为计算指标，不可替换！"
-//	//	return
-//	//}
-//	//
-//	//if newEdbInfo.EdbType != 1 {
-//	//	br.Msg = "替换指标为计算指标，不可替换！"
-//	//	br.ErrMsg = "替换指标为计算指标，不可替换！"
-//	//	return
-//	//}
-//
-//	if oldEdbInfo.Frequency != newEdbInfo.Frequency {
-//		br.Msg = "原指标频度为:" + oldEdbInfo.Frequency + " 替换指标频度为:" + newEdbInfo.Frequency + "，频度不同，不可进行替换操作！"
-//		br.ErrMsg = "原指标频度为:" + oldEdbInfo.Frequency + " 替换指标频度为:" + newEdbInfo.Frequency + "，频度不同，不可进行替换操作！"
-//		return
-//	}
-//
-//	sysAdminId := sysUser.AdminId
-//	//replaceChartTotal, replaceCalculateTotal, err := data.EdbInfoReplace(oldEdbInfo, newEdbInfo, sysAdminId, sysUser.RealName)
-//	_, _, err = data_manage.EdbInfoReplaceV2(oldEdbInfo, newEdbInfo, sysAdminId, sysUser.RealName)
-//	//msgContent := ``
-//	isFail := false
-//	var errmsg string
-//	if err != nil {
-//		//msgContent = oldEdbInfo.EdbName + "指标替换" + newEdbInfo.EdbName + "指标，全部替换失败，涉及" + strconv.Itoa(replaceChartTotal) + "张图表，\n\n " + strconv.Itoa(replaceCalculateTotal) + "个计算指标"
-//		isFail = true
-//		errmsg = "replace err:" + err.Error()
-//	} else {
-//		//msgContent = oldEdbInfo.EdbName + "指标替换" + newEdbInfo.EdbName + "指标，全部替换成功，涉及" + strconv.Itoa(replaceChartTotal) + "张图表，\n\n" + strconv.Itoa(replaceCalculateTotal) + "个计算指标"
-//		isFail = false
-//	}
-//
-//	// 添加站内信息
-//	//{
-//	//	msgItem := new(company.CompanyApprovalMessage)
-//	//	msgItem.CreateUserId = sysAdminId
-//	//	msgItem.ReceiveUserId = sysAdminId
-//	//	msgItem.MessageStatus = 0
-//	//	msgItem.Remark = "指标替换"
-//	//	msgItem.OperationStatus = 1
-//	//	msgItem.Content = msgContent
-//	//	msgItem.CreateTime = time.Now()
-//	//	msgItem.ModifyTime = time.Now()
-//	//	msgItem.MessageType = 3 //1:申请消息，2:审批结果，3：文字消息
-//	//	msgItem.SourceType = 4  //消息来源
-//	//	err = company.AddCompanyApprovalMessage(msgItem)
-//	//}
-//
-//	if isFail {
-//		br.Msg = "替换失败"
-//		br.ErrMsg = "替换失败 err:" + errmsg
-//	} else {
-//		br.Msg = "替换成功"
-//		br.ErrMsg = "替换成功"
-//		br.Ret = 200
-//	}
-//	br.IsAddLog = true
-//	return
-//}
+func (this *ChartInfoController) EdbInfoReplace() {
+	br := new(models.BaseResponse).Init()
+	setNxKey := "EDB_INFO_REPLACE"
+	deleteCache := true
+
+	defer func() {
+		if deleteCache {
+			utils.Rc.Delete(setNxKey)
+		}
+		this.Data["json"] = br
+		this.ServeJSON()
+	}()
+
+	sysUser := this.SysUser
+	if sysUser == nil {
+		br.Msg = "请登录"
+		br.ErrMsg = "请登录，SysUser Is Empty"
+		br.Ret = 408
+		return
+	}
+
+	if !utils.Rc.SetNX(setNxKey, 1, 30*time.Minute) {
+		deleteCache = false
+		br.Msg = "当前正在替换中，请耐心等待！"
+		br.IsSendEmail = false
+		return
+	}
+
+	var req data_manage.EdbInfoReplaceReq
+	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
+	if err != nil {
+		br.Msg = "参数解析异常！"
+		br.ErrMsg = "参数解析失败，Err:" + err.Error()
+		return
+	}
+	if req.OldEdbInfoId <= 0 || req.NewEdbInfoId <= 0 {
+		br.Msg = "参数错误！"
+		br.ErrMsg = "参数错误，指标id为0"
+		return
+	}
+
+	oldEdbInfo, err := data_manage.GetEdbInfoById(req.OldEdbInfoId)
+	if err != nil {
+		br.Msg = "替换失败！"
+		br.ErrMsg = "获取原指标失败，Err:" + err.Error()
+		return
+	}
+
+	newEdbInfo, err := data_manage.GetEdbInfoById(req.NewEdbInfoId)
+	if err != nil {
+		br.Msg = "替换失败！"
+		br.ErrMsg = "获取替换目标指标失败，Err:" + err.Error()
+		return
+	}
+
+	//if oldEdbInfo.EdbType != 1 {
+	//	br.Msg = "原指标为计算指标，不可替换！"
+	//	br.ErrMsg = "原指标为计算指标，不可替换！"
+	//	return
+	//}
+	//
+	//if newEdbInfo.EdbType != 1 {
+	//	br.Msg = "替换指标为计算指标，不可替换！"
+	//	br.ErrMsg = "替换指标为计算指标，不可替换！"
+	//	return
+	//}
+
+	if oldEdbInfo.Frequency != newEdbInfo.Frequency {
+		br.Msg = "原指标频度为:" + oldEdbInfo.Frequency + " 替换指标频度为:" + newEdbInfo.Frequency + "，频度不同，不可进行替换操作！"
+		br.ErrMsg = "原指标频度为:" + oldEdbInfo.Frequency + " 替换指标频度为:" + newEdbInfo.Frequency + "，频度不同，不可进行替换操作！"
+		return
+	}
+
+	sysAdminId := sysUser.AdminId
+	//replaceChartTotal, replaceCalculateTotal, err := data.EdbInfoReplace(oldEdbInfo, newEdbInfo, sysAdminId, sysUser.RealName)
+	_, _, err = data_manage.EdbInfoReplaceV2(oldEdbInfo, newEdbInfo, sysAdminId, sysUser.RealName)
+	//msgContent := ``
+	isFail := false
+	var errmsg string
+	if err != nil {
+		//msgContent = oldEdbInfo.EdbName + "指标替换" + newEdbInfo.EdbName + "指标，全部替换失败，涉及" + strconv.Itoa(replaceChartTotal) + "张图表，\n\n " + strconv.Itoa(replaceCalculateTotal) + "个计算指标"
+		isFail = true
+		errmsg = "replace err:" + err.Error()
+	} else {
+		//msgContent = oldEdbInfo.EdbName + "指标替换" + newEdbInfo.EdbName + "指标，全部替换成功，涉及" + strconv.Itoa(replaceChartTotal) + "张图表，\n\n" + strconv.Itoa(replaceCalculateTotal) + "个计算指标"
+		isFail = false
+	}
+
+	// 添加站内信息
+	//{
+	//	msgItem := new(company.CompanyApprovalMessage)
+	//	msgItem.CreateUserId = sysAdminId
+	//	msgItem.ReceiveUserId = sysAdminId
+	//	msgItem.MessageStatus = 0
+	//	msgItem.Remark = "指标替换"
+	//	msgItem.OperationStatus = 1
+	//	msgItem.Content = msgContent
+	//	msgItem.CreateTime = time.Now()
+	//	msgItem.ModifyTime = time.Now()
+	//	msgItem.MessageType = 3 //1:申请消息，2:审批结果，3：文字消息
+	//	msgItem.SourceType = 4  //消息来源
+	//	err = company.AddCompanyApprovalMessage(msgItem)
+	//}
+
+	if isFail {
+		br.Msg = "替换失败"
+		br.ErrMsg = "替换失败 err:" + errmsg
+	} else {
+		br.Msg = "替换成功"
+		br.ErrMsg = "替换成功"
+		br.Ret = 200
+	}
+	br.IsAddLog = true
+	return
+}
 
 // RelationChartList
 // @Title 获取ETA指标关联的图表列表接口

controllers/data_manage/edb_info_calculate.go

@@ -8,9 +8,793 @@ import (
 	"eta/eta_mobile/utils"
 	"fmt"
 	"strconv"
+	"strings"
 	"time"
 )
 
+// @Title 生成计算指标
+// @Description 生成计算指标接口
+// @Param	request	body data_manage.EdbInfoCalculateSaveReq true "type json string"
+// @Success Ret=200 返回图表id
+// @router /edb_info/calculate/save [post]
+func (this *ChartInfoController) CalculateSave() {
+	br := new(models.BaseResponse).Init()
+	defer func() {
+		this.Data["json"] = br
+		this.ServeJSON()
+	}()
+
+	sysUser := this.SysUser
+	if sysUser == nil {
+		br.Msg = "请登录"
+		br.ErrMsg = "请登录，SysUser Is Empty"
+		br.Ret = 408
+		return
+	}
+
+	var req data_manage.EdbInfoCalculateSaveReq
+	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
+	if err != nil {
+		br.Msg = "参数解析异常！"
+		br.ErrMsg = "参数解析失败，Err:" + err.Error()
+		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
+
+	//判断是否重复指标
+	edbInfoMap := make(map[int]string)
+	//移除研究员选择指标中的未使用的指标
+	{
+		//转大写的计算公式
+		upperCalculateFormulaStr := strings.ToUpper(req.CalculateFormula)
+		//用到的指标
+		newEdbInfoIdArr := make([]data_manage.EdbInfoFromTag, 0)
+		for _, tmpEdbInfo := range req.EdbInfoIdArr {
+			_, ok := edbInfoMap[tmpEdbInfo.EdbInfoId]
+			if ok {
+				br.Msg = "选择指标失败，请勿选择重复指标！"
+				return
+			}
+			edbInfoMap[tmpEdbInfo.EdbInfoId] = tmpEdbInfo.FromTag
+
+			upperFromTag := strings.ToUpper(tmpEdbInfo.FromTag)
+			if strings.Contains(upperCalculateFormulaStr, upperFromTag) {
+				newEdbInfoIdArr = append(newEdbInfoIdArr, tmpEdbInfo)
+			}
+		}
+		req.EdbInfoIdArr = newEdbInfoIdArr
+	}
+
+	var condition string
+	var pars []interface{}
+	condition += " AND edb_name=? "
+	pars = append(pars, req.EdbName)
+
+	count, err := data_manage.GetEdbInfoCountByCondition(condition, pars)
+	if err != nil {
+		br.Msg = "判断指标名称是否存在失败"
+		br.ErrMsg = "判断指标名称是否存在失败,Err:" + err.Error()
+		return
+	}
+
+	if count > 0 {
+		br.Msg = "指标名称已存在，请重新填写"
+		br.ErrMsg = "指标名称已存在，请重新填写"
+		br.IsSendEmail = false
+		return
+	}
+	//检验公式
+	var formulaStr string
+	var edbInfoIdBytes []string
+	for _, v := range req.EdbInfoIdArr {
+		formulaStr += v.FromTag + ","
+		edbInfoIdBytes = append(edbInfoIdBytes, v.FromTag)
+	}
+	formulaMap := data.CheckFormula(req.CalculateFormula)
+	for _, v := range formulaMap {
+		if !strings.Contains(formulaStr, v) {
+			br.Msg = "公式错误，请重新填写"
+			return
+		}
+	}
+
+	// 调用指标库去新增
+	req2 := &data_manage.EdbInfoCalculateBatchSaveReqByEdbLib{
+		AdminId:   sysUser.AdminId,
+		AdminName: sysUser.RealName,
+		//EdbInfoId:        req.EdbInfoId,
+		EdbName:          req.EdbName,
+		Frequency:        req.Frequency,
+		Unit:             req.Unit,
+		ClassifyId:       req.ClassifyId,
+		CalculateFormula: req.CalculateFormula,
+		EdbInfoIdArr:     req.EdbInfoIdArr,
+	}
+	reqJson, err := json.Marshal(req2)
+	if err != nil {
+		br.Msg = "参数解析异常！"
+		br.ErrMsg = "参数解析失败，Err:" + err.Error()
+		return
+	}
+	respItem, err := data.AddEdbCalculateData(string(reqJson))
+	if err != nil {
+		br.Msg = "新增失败"
+		br.ErrMsg = "新增失败,Err:" + err.Error()
+		return
+	}
+	if respItem.Ret != 200 {
+		br.Msg = respItem.Msg
+		br.ErrMsg = respItem.ErrMsg
+		return
+	}
+
+	resp := respItem.Data
+
+	//添加es
+	data.AddOrEditEdbInfoToEs(resp.EdbInfoId)
+
+	br.Ret = 200
+	br.Success = true
+	br.Msg = "保存成功"
+	br.Data = resp
+	br.IsAddLog = true
+}
+
+// @Title 获取计算指标详情
+// @Description 获取计算指标详情接口
+// @Param   EdbInfoId   query   int  true       "指标id"
+// @Success 200 {object} data_manage.CalculateDetailResp
+// @router /edb_info/calculate/detail [get]
+func (this *ChartInfoController) CalculateDetail() {
+	br := new(models.BaseResponse).Init()
+	defer func() {
+		this.Data["json"] = br
+		this.ServeJSON()
+	}()
+	sysUser := this.SysUser
+	if sysUser == nil {
+		br.Msg = "请登录"
+		br.ErrMsg = "请登录，SysUser Is Empty"
+		br.Ret = 408
+		return
+	}
+	edbInfoId, _ := this.GetInt("EdbInfoId")
+	edbInfo, err := data_manage.GetEdbInfoById(edbInfoId)
+	if err != nil {
+		br.Msg = "获取失败"
+		br.ErrMsg = "获取失败，Err:" + err.Error()
+		return
+	}
+
+	calculateList, err := data_manage.GetEdbInfoCalculateDetail(edbInfoId, edbInfo.Source)
+	if err != nil {
+		br.Msg = "获取失败"
+		br.ErrMsg = "获取失败，Err:" + err.Error()
+		return
+	}
+	resp := new(data_manage.CalculateDetailResp)
+	resp.EdbInfoDetail = edbInfo
+	resp.CalculateList = calculateList
+	br.Ret = 200
+	br.Success = true
+	br.Msg = "保存成功"
+	br.Data = resp
+}
+
+// @Title 修改计算指标
+// @Description 修改计算指标接口
+// @Param	request	body data_manage.EdbInfoCalculateEditReq true "type json string"
+// @Success Ret=200 返回图表id
+// @router /edb_info/calculate/edit [post]
+func (this *ChartInfoController) CalculateEdit() {
+	br := new(models.BaseResponse).Init()
+	defer func() {
+		this.Data["json"] = br
+		this.ServeJSON()
+	}()
+
+	sysUser := this.SysUser
+	if sysUser == nil {
+		br.Msg = "请登录"
+		br.ErrMsg = "请登录，SysUser Is Empty"
+		br.Ret = 408
+		return
+	}
+
+	var req data_manage.EdbInfoCalculateEditReq
+	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([]data_manage.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 := data_manage.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 := data_manage.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
+	}
+
+	// 调用指标库去更新
+	req2 := &data_manage.EdbInfoCalculateBatchSaveReqByEdbLib{
+		AdminId:          sysUser.AdminId,
+		AdminName:        sysUser.RealName,
+		EdbInfoId:        req.EdbInfoId,
+		EdbName:          req.EdbName,
+		Frequency:        req.Frequency,
+		Unit:             req.Unit,
+		ClassifyId:       req.ClassifyId,
+		CalculateFormula: req.CalculateFormula,
+		EdbInfoIdArr:     req.EdbInfoIdArr,
+	}
+	reqJson, err := json.Marshal(req2)
+	if err != nil {
+		br.Msg = "参数解析异常！"
+		br.ErrMsg = "参数解析失败，Err:" + err.Error()
+		return
+	}
+	respItem, err := data.EditEdbCalculateData(string(reqJson))
+	if err != nil {
+		br.Msg = "编辑失败"
+		br.ErrMsg = "编辑失败,Err:" + err.Error()
+		return
+	}
+	if respItem.Ret != 200 {
+		br.Msg = respItem.Msg
+		br.ErrMsg = respItem.ErrMsg
+		return
+	}
+
+	resp := respItem.Data
+
+	//添加es
+	data.AddOrEditEdbInfoToEs(req.EdbInfoId)
+
+	// 修改关联的预测指标基础信息
+	go data.ModifyPredictEdbBaseInfoBySourceEdb(edbInfoDetail)
+
+	br.Ret = 200
+	br.Success = true
+	br.Msg = "保存成功"
+	br.IsAddLog = true
+	br.Data = resp
+}
+
+// @Title 累计值转月-同比值-同差等计算新增
+// @Description 累计值转月-同比值-同差等计算新增接口
+// @Param	request	body data_manage.EdbInfoCalculateBatchSaveReq true "type json string"
+// @Success Ret=200 返回指标id
+// @router /edb_info/calculate/batch/save [post]
+func (this *ChartInfoController) CalculateBatchSave() {
+	br := new(models.BaseResponse).Init()
+	defer func() {
+		if br.ErrMsg == "" {
+			br.IsSendEmail = false
+		}
+		this.Data["json"] = br
+		this.ServeJSON()
+	}()
+	sysUser := this.SysUser
+	if sysUser == nil {
+		br.Msg = "请登录"
+		br.ErrMsg = "请登录，SysUser Is Empty"
+		br.Ret = 408
+		return
+	}
+
+	var req data_manage.EdbInfoCalculateBatchSaveReq
+	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
+	if err != nil {
+		br.Msg = "参数解析异常！"
+		br.ErrMsg = "参数解析失败，Err:" + err.Error()
+		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
+	}
+
+	fromEdbInfoId := req.FromEdbInfoId
+
+	var formulaInt int
+	switch req.Source {
+	case utils.DATA_SOURCE_CALCULATE_NSZYDPJJS, utils.DATA_SOURCE_CALCULATE_HBZ, utils.DATA_SOURCE_CALCULATE_HCZ, utils.DATA_SOURCE_CALCULATE_TIME_SHIFT, utils.DATA_SOURCE_CALCULATE_CJJX:
+		if req.Formula == "" {
+			br.Msg = "请填写N值"
+			return
+		}
+		formulaInt, _ = strconv.Atoi(req.Formula)
+		if formulaInt <= 0 {
+			br.Msg = "N值输入错误,请重新输入"
+			return
+		}
+	case utils.DATA_SOURCE_CALCULATE_ZJPJ:
+		//直接拼接指标
+		//校验时间格式
+		_, err = time.ParseInLocation(utils.FormatDate, req.Formula, time.Local)
+		if err != nil {
+			br.Msg = "拼接日期有误,请重新输入"
+			return
+		}
+	case utils.DATA_SOURCE_CALCULATE_NHCC: //拟合残差指标
+		//指标校验
+		if len(req.EdbInfoIdArr) != 2 {
+			br.Msg = "选择的指标异常,请重新选择"
+			return
+		}
+		fromEdbInfoId = req.EdbInfoIdArr[0].EdbInfoId
+
+		//校验时间格式
+		//数据格式：2022-11-01,2022-11-10
+		timeList := strings.Split(req.Formula, ",")
+		if len(timeList) != 2 {
+			br.Msg = "选择时间有误,请重新输入"
+			return
+		}
+		startDate, err := time.ParseInLocation(utils.FormatDate, timeList[0], time.Local)
+		if err != nil {
+			br.Msg = "开始日期有误,请重新输入"
+			return
+		}
+		endDate, err := time.ParseInLocation(utils.FormatDate, timeList[1], time.Local)
+		if err != nil {
+			br.Msg = "结束日期有误,请重新输入"
+			return
+		}
+		if utils.GetTimeSubDay(startDate, endDate) < 2 {
+			br.Msg = "日期间隔不得少于两天"
+			return
+		}
+	case utils.DATA_SOURCE_CALCULATE_ZSXY: // 指数修匀
+		if req.Formula == "" {
+			br.Msg = "请填写alpha值"
+			return
+		}
+		alpha, e := strconv.ParseFloat(req.Formula, 64)
+		if e != nil {
+			br.Msg = "alpha值输入错误, 请重新输入"
+			return
+		}
+		if alpha <= 0 || alpha >= 1 {
+			br.Msg = "alpha值输入错误, 请重新输入"
+			return
+		}
+	}
+
+	notNeedFromEdbSourceList := []int{utils.DATA_SOURCE_CALCULATE_KSZS} // 不需要传入来源指标id的 指标类型
+	if fromEdbInfoId <= 0 && !utils.InArrayByInt(notNeedFromEdbSourceList, req.Source) {
+		br.Msg = "请选择指标"
+		return
+	}
+
+	//加入缓存机制，避免创建同一个名称的指标 start
+	redisKey := fmt.Sprint("edb_info:calculate:batch:save:", req.Source, ":", req.EdbName)
+	isExist := utils.Rc.IsExist(redisKey)
+	if isExist {
+		br.Msg = "指标正在处理,请勿重复提交"
+		return
+	} else {
+		//设置3分钟缓存
+		utils.Rc.SetNX(redisKey, 1, time.Second*300)
+		defer func() {
+			utils.Rc.Delete(redisKey)
+		}()
+	}
+	//加入缓存机制，避免创建同一个名称的指标 end
+
+	req2 := &data_manage.EdbInfoCalculateBatchSaveReqByEdbLib{
+		AdminId:          sysUser.AdminId,
+		AdminName:        sysUser.RealName,
+		EdbInfoId:        req.EdbInfoId,
+		EdbName:          req.EdbName,
+		Frequency:        req.Frequency,
+		Unit:             req.Unit,
+		ClassifyId:       req.ClassifyId,
+		Formula:          req.Formula, //N数值移动平均计算、环比值、环差值
+		FromEdbInfoId:    req.FromEdbInfoId,
+		CalculateFormula: req.CalculateFormula,
+		Source:           req.Source,
+		MoveType:         req.MoveType,
+		MoveFrequency:    req.MoveFrequency,
+
+		//CalculateFormula: edbInfo.CalculateFormula,
+		EdbInfoIdArr: req.EdbInfoIdArr,
+		Calendar:     req.Calendar,
+	}
+
+	// 调用指标库去更新
+	reqJson, err := json.Marshal(req2)
+	if err != nil {
+		br.Msg = "参数解析异常！"
+		br.ErrMsg = "参数解析失败，Err:" + err.Error()
+		return
+	}
+	respItem, err := data.BatchSaveEdbCalculateData(string(reqJson))
+	if err != nil {
+		br.Msg = "新增失败"
+		br.ErrMsg = "新增失败,Err:" + err.Error()
+		return
+	}
+	if respItem.Ret != 200 {
+		br.Msg = respItem.Msg
+		br.ErrMsg = respItem.ErrMsg
+		return
+	}
+
+	resp := respItem.Data
+
+	//添加es
+	data.AddOrEditEdbInfoToEs(resp.EdbInfoId)
+
+	br.Ret = 200
+	br.Success = true
+	br.Msg = "保存成功"
+	br.Data = resp
+	br.IsAddLog = true
+}
+
+// @Title 累计值转月-同比值-同差等计算编辑
+// @Description 累计值转月-同比值-同差等计算编辑接口
+// @Param	request	body data_manage.EdbInfoCalculateBatchEditReq true "type json string"
+// @Success Ret=200 返回指标id
+// @router /edb_info/calculate/batch/edit [post]
+func (this *ChartInfoController) CalculateBatchEdit() {
+	br := new(models.BaseResponse).Init()
+	defer func() {
+		if br.ErrMsg == "" {
+			br.IsSendEmail = false
+		}
+		this.Data["json"] = br
+		this.ServeJSON()
+	}()
+
+	sysUser := this.SysUser
+	if sysUser == nil {
+		br.Msg = "请登录"
+		br.ErrMsg = "请登录，SysUser Is Empty"
+		br.Ret = 408
+		return
+	}
+
+	var req data_manage.EdbInfoCalculateBatchEditReq
+	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
+	if err != nil {
+		br.Msg = "参数解析异常！"
+		br.ErrMsg = "参数解析失败，Err:" + err.Error()
+		return
+	}
+
+	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 req.EdbInfoId <= 0 {
+		br.Msg = "请选择指标"
+		return
+	}
+
+	var condition string
+	var pars []interface{}
+	condition += " AND edb_name=? "
+	pars = append(pars, req.EdbName)
+
+	condition += " AND edb_info_id<>? "
+	pars = append(pars, req.EdbInfoId)
+
+	count, err := data_manage.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
+	}
+
+	edbInfo, err := data_manage.GetEdbInfoById(req.EdbInfoId)
+	if err != nil {
+		if err.Error() == utils.ErrNoRow() {
+			br.Msg = "指标已被删除，请刷新页面"
+			br.ErrMsg = "指标已被删除，请刷新页面:Err:" + err.Error()
+			return
+		}
+		br.Msg = "获取指标信息失败"
+		br.ErrMsg = "获取指标信息失败:Err:" + err.Error()
+		return
+	}
+
+	if req.Source <= 0 {
+		req.Source = edbInfo.Source
+	}
+
+	var formulaInt int
+	switch req.Source {
+	case utils.DATA_SOURCE_CALCULATE_NSZYDPJJS, utils.DATA_SOURCE_CALCULATE_HBZ, utils.DATA_SOURCE_CALCULATE_HCZ, utils.DATA_SOURCE_CALCULATE_TIME_SHIFT, utils.DATA_SOURCE_CALCULATE_CJJX:
+		if req.Formula == "" {
+			br.Msg = "请填写N值"
+			return
+		}
+		formulaInt, _ = strconv.Atoi(req.Formula)
+		if formulaInt <= 0 {
+			br.Msg = "N值输入错误,请重新输入"
+			return
+		}
+	case utils.DATA_SOURCE_CALCULATE_ZJPJ:
+		//直接拼接指标
+
+		//校验时间格式
+		_, err = time.ParseInLocation(utils.FormatDate, req.Formula, time.Local)
+		if err != nil {
+			br.Msg = "拼接日期有误,请重新输入"
+			return
+		}
+	case utils.DATA_SOURCE_CALCULATE_NHCC: //拟合残差指标
+		//指标校验
+		if len(req.EdbInfoIdArr) != 2 {
+			br.Msg = "选择的指标异常,请重新选择"
+			return
+		}
+
+		//校验时间格式
+		//数据格式：2022-11-01,2022-11-10
+		timeList := strings.Split(req.Formula, ",")
+		if len(timeList) != 2 {
+			br.Msg = "选择时间有误,请重新输入"
+			return
+		}
+		startDate, err := time.ParseInLocation(utils.FormatDate, timeList[0], time.Local)
+		if err != nil {
+			br.Msg = "开始日期有误,请重新输入"
+			return
+		}
+		endDate, err := time.ParseInLocation(utils.FormatDate, timeList[1], time.Local)
+		if err != nil {
+			br.Msg = "结束日期有误,请重新输入"
+			return
+		}
+		if utils.GetTimeSubDay(startDate, endDate) < 2 {
+			br.Msg = "日期间隔不得少于两天"
+			return
+		}
+	case utils.DATA_SOURCE_CALCULATE_ZSXY: // 指数修匀
+		if req.Formula == "" {
+			br.Msg = "请填写alpha值"
+			return
+		}
+		alpha, e := strconv.ParseFloat(req.Formula, 64)
+		if e != nil {
+			br.Msg = "alpha值输入错误, 请重新输入"
+			return
+		}
+		if alpha <= 0 || alpha >= 1 {
+			br.Msg = "alpha值输入错误, 请重新输入"
+			return
+		}
+	}
+
+	// 构造请求
+	req2 := &data_manage.EdbInfoCalculateBatchEditReqByEdbLib{
+		EdbInfoId:     req.EdbInfoId,
+		EdbName:       req.EdbName,
+		Frequency:     req.Frequency,
+		Unit:          req.Unit,
+		ClassifyId:    req.ClassifyId,
+		Formula:       req.Formula, //N数值移动平均计算、环比值、环差值
+		FromEdbInfoId: req.FromEdbInfoId,
+		Source:        req.Source,
+		MoveType:      req.MoveType,
+		MoveFrequency: req.MoveFrequency,
+		EdbInfoIdArr:  req.EdbInfoIdArr,
+		Calendar:      req.Calendar,
+	}
+
+	// 调用指标库去更新
+	reqJson, err := json.Marshal(req2)
+	if err != nil {
+		br.Msg = "参数解析异常！"
+		br.ErrMsg = "参数解析失败，Err:" + err.Error()
+		return
+	}
+	respItem, err := data.BatchEditEdbCalculateData(string(reqJson))
+	if err != nil {
+		br.Msg = "编辑失败"
+		br.ErrMsg = "编辑失败,Err:" + err.Error()
+		return
+	}
+	if respItem.Ret != 200 {
+		br.Msg = respItem.Msg
+		br.ErrMsg = respItem.ErrMsg
+		return
+	}
+
+	resp := respItem.Data
+
+	//添加es
+	data.AddOrEditEdbInfoToEs(resp.EdbInfoId)
+
+	// 修改关联的预测指标基础信息
+	go data.ModifyPredictEdbBaseInfoBySourceEdb(edbInfo)
+
+	br.Ret = 200
+	br.Success = true
+	br.Msg = "保存成功"
+	br.Data = resp
+	br.IsAddLog = true
+}
+
 // @Title 累计值转月-同比值-同差等重新计算
 // @Description 累计值转月-同比值-同差等重新计算接口
 // @Param	request	body data_manage.EdbInfoCalculateBatchSaveReq true "type json string"
@@ -171,3 +955,371 @@ func (this *ChartInfoController) CalculateBatchReset() {
 	br.Data = resp
 	br.IsAddLog = true
 }
+
+// BatchCalculateBatchSave
+// @Title 批量添加 累计值转月-同比值-同差等计算新增
+// @Description 批量添加 累计值转月-同比值-同差等计算新增接口
+// @Param	request	body data_manage.EdbInfoCalculateBatchSaveReq true "type json string"
+// @Success Ret=200 返回指标id
+// @router /edb_info/calculate/batch/save/batch [post]
+func (this *ChartInfoController) BatchCalculateBatchSave() {
+	br := new(models.BaseResponse).Init()
+	defer func() {
+		if br.ErrMsg == "" {
+			br.IsSendEmail = false
+		}
+		this.Data["json"] = br
+		this.ServeJSON()
+	}()
+
+	sysUser := this.SysUser
+	if sysUser == nil {
+		br.Msg = "请登录"
+		br.ErrMsg = "请登录，SysUser Is Empty"
+		br.Ret = 408
+		return
+	}
+
+	var reqList []data_manage.BatchEdbInfoCalculateBatchSaveReq
+	err := json.Unmarshal(this.Ctx.Input.RequestBody, &reqList)
+	if err != nil {
+		br.Msg = "参数解析异常！"
+		br.ErrMsg = "参数解析失败，Err:" + err.Error()
+		return
+	}
+
+	resp := data_manage.BatchEdbInfoCalculateBatchSaveResp{
+		Fail:    make([]data_manage.BatchEdbInfoCalculateBatchSaveFailResp, 0),
+		Success: make([]data_manage.BatchEdbInfoCalculateBatchSaveSuccessResp, 0),
+	}
+	redisKeyList := make([]string, 0) //需要清理的缓存key列表
+	defer func() {
+		for _, redisKey := range redisKeyList {
+			utils.Rc.Delete(redisKey)
+		}
+	}()
+
+	for _, v := range reqList {
+		req := v.CalculateInfo
+		req.EdbName = strings.Trim(req.EdbName, " ")
+		if req.EdbName == "" {
+			resp.Fail = append(resp.Fail, data_manage.BatchEdbInfoCalculateBatchSaveFailResp{
+				CalculateId: v.CalculateId,
+				Msg:         "指标名称不能为空",
+			})
+			continue
+		}
+
+		if req.Frequency == "" {
+			resp.Fail = append(resp.Fail, data_manage.BatchEdbInfoCalculateBatchSaveFailResp{
+				CalculateId: v.CalculateId,
+				Msg:         "频率不能为空",
+			})
+			continue
+		}
+
+		if req.Unit == "" {
+			resp.Fail = append(resp.Fail, data_manage.BatchEdbInfoCalculateBatchSaveFailResp{
+				CalculateId: v.CalculateId,
+				Msg:         "单位不能为空",
+			})
+			continue
+		}
+
+		if req.ClassifyId <= 0 {
+			resp.Fail = append(resp.Fail, data_manage.BatchEdbInfoCalculateBatchSaveFailResp{
+				CalculateId: v.CalculateId,
+				Msg:         "请选择分类",
+			})
+			continue
+		}
+
+		fromEdbInfoId := req.FromEdbInfoId
+
+		var formulaInt int
+		switch req.Source {
+		case utils.DATA_SOURCE_CALCULATE_NSZYDPJJS, utils.DATA_SOURCE_CALCULATE_HBZ, utils.DATA_SOURCE_CALCULATE_HCZ, utils.DATA_SOURCE_CALCULATE_TIME_SHIFT, utils.DATA_SOURCE_CALCULATE_CJJX:
+			if req.Formula == "" {
+				resp.Fail = append(resp.Fail, data_manage.BatchEdbInfoCalculateBatchSaveFailResp{
+					CalculateId: v.CalculateId,
+					Msg:         "请选择分类",
+				})
+				continue
+			}
+			formulaInt, _ = strconv.Atoi(req.Formula)
+			if formulaInt <= 0 {
+				resp.Fail = append(resp.Fail, data_manage.BatchEdbInfoCalculateBatchSaveFailResp{
+					CalculateId: v.CalculateId,
+					Msg:         "N值输入错误,请重新输入",
+				})
+				continue
+			}
+		case utils.DATA_SOURCE_CALCULATE_ZJPJ:
+			//直接拼接指标
+			//校验时间格式
+			_, err = time.ParseInLocation(utils.FormatDate, req.Formula, time.Local)
+			if err != nil {
+				resp.Fail = append(resp.Fail, data_manage.BatchEdbInfoCalculateBatchSaveFailResp{
+					CalculateId: v.CalculateId,
+					Msg:         "拼接日期有误,请重新输入",
+				})
+				continue
+			}
+		case utils.DATA_SOURCE_CALCULATE_NHCC: //拟合残差指标
+			//指标校验
+			if len(req.EdbInfoIdArr) != 2 {
+				resp.Fail = append(resp.Fail, data_manage.BatchEdbInfoCalculateBatchSaveFailResp{
+					CalculateId: v.CalculateId,
+					Msg:         "选择的指标异常,请重新选择",
+				})
+				continue
+			}
+			fromEdbInfoId = req.EdbInfoIdArr[0].EdbInfoId
+
+			//校验时间格式
+			//数据格式：2022-11-01,2022-11-10
+			timeList := strings.Split(req.Formula, ",")
+			if len(timeList) != 2 {
+				resp.Fail = append(resp.Fail, data_manage.BatchEdbInfoCalculateBatchSaveFailResp{
+					CalculateId: v.CalculateId,
+					Msg:         "选择时间有误,请重新输入",
+				})
+				continue
+			}
+			startDate, err := time.ParseInLocation(utils.FormatDate, timeList[0], time.Local)
+			if err != nil {
+				resp.Fail = append(resp.Fail, data_manage.BatchEdbInfoCalculateBatchSaveFailResp{
+					CalculateId: v.CalculateId,
+					Msg:         "开始日期有误,请重新输入",
+				})
+				continue
+			}
+			endDate, err := time.ParseInLocation(utils.FormatDate, timeList[1], time.Local)
+			if err != nil {
+				resp.Fail = append(resp.Fail, data_manage.BatchEdbInfoCalculateBatchSaveFailResp{
+					CalculateId: v.CalculateId,
+					Msg:         "结束日期有误,请重新输入",
+				})
+				continue
+			}
+			if utils.GetTimeSubDay(startDate, endDate) < 2 {
+				resp.Fail = append(resp.Fail, data_manage.BatchEdbInfoCalculateBatchSaveFailResp{
+					CalculateId: v.CalculateId,
+					Msg:         "日期间隔不得少于两天",
+				})
+				continue
+			}
+		case utils.DATA_SOURCE_CALCULATE_ZSXY: // 指数修匀
+			if req.Formula == "" {
+				br.Msg = "请填写alpha值"
+				return
+			}
+			alpha, e := strconv.ParseFloat(req.Formula, 64)
+			if e != nil {
+				br.Msg = "alpha值输入错误, 请重新输入"
+				return
+			}
+			if alpha <= 0 || alpha >= 1 {
+				br.Msg = "alpha值输入错误, 请重新输入"
+				return
+			}
+		}
+
+		if fromEdbInfoId <= 0 {
+			resp.Fail = append(resp.Fail, data_manage.BatchEdbInfoCalculateBatchSaveFailResp{
+				CalculateId: v.CalculateId,
+				Msg:         "请选择指标",
+			})
+			continue
+		}
+
+		//加入缓存机制，避免创建同一个名称的指标 start
+		redisKey := fmt.Sprint("edb_info:calculate:batch:save:", sysUser.AdminId, ":", req.Source, ":", v.CalculateId)
+		isExist := utils.Rc.IsExist(redisKey)
+		if isExist {
+			resp.Fail = append(resp.Fail, data_manage.BatchEdbInfoCalculateBatchSaveFailResp{
+				CalculateId: v.CalculateId,
+				Msg:         "指标正在处理,请勿重复提交",
+			})
+			continue
+		} else {
+			//设置3分钟缓存
+			utils.Rc.SetNX(redisKey, 1, time.Second*300)
+			redisKeyList = append(redisKeyList, redisKey)
+		}
+		//加入缓存机制，避免创建同一个名称的指标 end
+
+		req2 := &data_manage.EdbInfoCalculateBatchSaveReqByEdbLib{
+			AdminId:          sysUser.AdminId,
+			AdminName:        sysUser.RealName,
+			EdbInfoId:        req.EdbInfoId,
+			EdbName:          req.EdbName,
+			Frequency:        req.Frequency,
+			Unit:             req.Unit,
+			ClassifyId:       req.ClassifyId,
+			Formula:          req.Formula, //N数值移动平均计算、环比值、环差值
+			FromEdbInfoId:    req.FromEdbInfoId,
+			CalculateFormula: req.CalculateFormula,
+			Source:           req.Source,
+			MoveType:         req.MoveType,
+			MoveFrequency:    req.MoveFrequency,
+
+			//CalculateFormula: edbInfo.CalculateFormula,
+			EdbInfoIdArr: req.EdbInfoIdArr,
+			Calendar:     req.Calendar,
+		}
+
+		// 调用指标库去更新
+		reqJson, err := json.Marshal(req2)
+		if err != nil {
+			resp.Fail = append(resp.Fail, data_manage.BatchEdbInfoCalculateBatchSaveFailResp{
+				CalculateId: v.CalculateId,
+				Msg:         "参数解析异常！",
+				ErrMsg:      "参数解析失败，Err:" + err.Error(),
+			})
+			continue
+		}
+		respItem, err := data.BatchSaveEdbCalculateData(string(reqJson))
+		if err != nil {
+			resp.Fail = append(resp.Fail, data_manage.BatchEdbInfoCalculateBatchSaveFailResp{
+				CalculateId: v.CalculateId,
+				Msg:         "新增失败！",
+				ErrMsg:      "新增失败，Err:" + err.Error(),
+			})
+			continue
+		}
+		if respItem.Ret != 200 {
+			resp.Fail = append(resp.Fail, data_manage.BatchEdbInfoCalculateBatchSaveFailResp{
+				CalculateId: v.CalculateId,
+				Msg:         respItem.Msg,
+				ErrMsg:      respItem.ErrMsg,
+			})
+			continue
+		}
+
+		result := respItem.Data
+
+		//添加es
+		data.AddOrEditEdbInfoToEs(result.EdbInfoId)
+		resp.Success = append(resp.Success, data_manage.BatchEdbInfoCalculateBatchSaveSuccessResp{
+			ClassifyId:  req.ClassifyId,
+			CalculateId: v.CalculateId,
+			EdbInfoId:   result.EdbInfoId,
+			UniqueCode:  result.UniqueCode,
+		})
+	}
+
+	br.Ret = 200
+	br.Success = true
+	br.Msg = "批量保存成功"
+	br.Data = resp
+	br.IsAddLog = true
+}
+
+// CalculateComputeCorrelation
+// @Title 拟合残差计算相关性
+// @Description 拟合残差计算相关性接口
+// @Param	request	body data_manage.EdbInfoCalculateBatchSaveReq true "type json string"
+// @Success Ret=200 返回指标id
+// @router /edb_info/calculate/compute_correlation [post]
+func (this *ChartInfoController) CalculateComputeCorrelation() {
+	br := new(models.BaseResponse).Init()
+	defer func() {
+		this.Data["json"] = br
+		this.ServeJSON()
+	}()
+
+	sysUser := this.SysUser
+	if sysUser == nil {
+		br.Msg = "请登录"
+		br.ErrMsg = "请登录，SysUser Is Empty"
+		br.Ret = 408
+		return
+	}
+
+	var req data_manage.EdbInfoCalculateBatchSaveReq
+	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
+	if err != nil {
+		br.Msg = "参数解析异常！"
+		br.ErrMsg = "参数解析失败，Err:" + err.Error()
+		return
+	}
+
+	if len(req.EdbInfoIdArr) != 2 {
+		br.Msg = "选择的指标异常,请重新选择"
+		return
+	}
+	fromEdbInfoId := req.EdbInfoIdArr[0].EdbInfoId
+
+	//校验时间格式
+	//数据格式：2022-11-01,2022-11-10
+	timeList := strings.Split(req.Formula, ",")
+	if len(timeList) != 2 {
+		br.Msg = "选择时间有误,请重新输入"
+		return
+	}
+	startDate, err := time.ParseInLocation(utils.FormatDate, timeList[0], time.Local)
+	if err != nil {
+		br.Msg = "开始日期有误,请重新输入"
+		return
+	}
+	endDate, err := time.ParseInLocation(utils.FormatDate, timeList[1], time.Local)
+	if err != nil {
+		br.Msg = "结束日期有误,请重新输入"
+		return
+	}
+	if utils.GetTimeSubDay(startDate, endDate) < 2 {
+		br.Msg = "日期间隔不得少于两天"
+		return
+	}
+
+	if fromEdbInfoId <= 0 {
+		br.Msg = "请选择指标"
+		return
+	}
+
+	req2 := &data_manage.EdbInfoCalculateBatchSaveReqByEdbLib{
+		AdminId:          sysUser.AdminId,
+		AdminName:        sysUser.RealName,
+		EdbInfoId:        req.EdbInfoId,
+		EdbName:          req.EdbName,
+		Frequency:        req.Frequency,
+		Unit:             req.Unit,
+		ClassifyId:       req.ClassifyId,
+		Formula:          req.Formula, //N数值移动平均计算、环比值、环差值
+		FromEdbInfoId:    req.FromEdbInfoId,
+		CalculateFormula: req.CalculateFormula,
+		Source:           req.Source,
+		MoveType:         req.MoveType,
+		MoveFrequency:    req.MoveFrequency,
+
+		//CalculateFormula: edbInfo.CalculateFormula,
+		EdbInfoIdArr: req.EdbInfoIdArr,
+		Calendar:     req.Calendar,
+	}
+
+	// 调用指标库去更新
+	reqJson, err := json.Marshal(req2)
+	if err != nil {
+		br.Msg = "参数解析异常！"
+		br.ErrMsg = "参数解析失败，Err:" + err.Error()
+		return
+	}
+	respItem, err := data.CalculateComputeCorrelation(string(reqJson))
+	if err != nil {
+		br.Msg = "新增失败"
+		br.ErrMsg = "新增失败,Err:" + err.Error()
+		return
+	}
+
+	if respItem.Ret == 200 {
+		br.Data = respItem.Data
+	} else {
+		br.Data = ``
+	}
+
+	br.Ret = 200
+	br.Success = true
+	br.Msg = "计算成功"
+	br.IsAddLog = true
+}

models/data_manage/edb_data_calculate_ljztbpj.go

@@ -0,0 +1,27 @@
+package data_manage
+
+import (
+	"github.com/beego/beego/v2/client/orm"
+	"time"
+)
+
+// EdbDataCalculateLjztbpj 累计值同比拼接数据结构体
+type EdbDataCalculateLjztbpj struct {
+	EdbDataId     int `orm:"column(edb_data_id);pk"`
+	EdbInfoId     int
+	EdbCode       string
+	DataTime      string
+	Value         float64
+	Status        int
+	CreateTime    time.Time
+	ModifyTime    time.Time
+	DataTimestamp int64
+}
+
+// GetAllEdbDataCalculateLjztbpjByEdbInfoId 根据指标id获取全部的数据
+func GetAllEdbDataCalculateLjztbpjByEdbInfoId(edbInfoId int) (items []*EdbDataCalculateLjztbpj, err error) {
+	o := orm.NewOrmUsingDB("data")
+	sql := ` SELECT * FROM edb_data_calculate_ljztbpj WHERE edb_info_id=? ORDER BY data_time DESC `
+	_, err = o.Raw(sql, edbInfoId).QueryRows(&items)
+	return
+}

models/data_manage/edb_data_calculate_time_shift.go

@@ -0,0 +1,160 @@
+package data_manage
+
+import (
+	"errors"
+	"eta/eta_mobile/utils"
+	"fmt"
+	"github.com/beego/beego/v2/client/orm"
+	"github.com/shopspring/decimal"
+	"strconv"
+	"strings"
+	"time"
+)
+
+// 时间移位
+func EditCalculateTimeShift(req *EdbInfoCalculateBatchEditReq, fromEdbInfo *EdbInfo, edbCode string, oldEdbInfo *EdbInfo) (edbInfoId int, err error) {
+	edbInfoId = req.EdbInfoId
+	o := orm.NewOrmUsingDB("data")
+	to, err := o.Begin()
+	if err != nil {
+		return
+	}
+	defer func() {
+		if err != nil {
+			_ = to.Rollback()
+		} else {
+			_ = to.Commit()
+		}
+	}()
+
+	//修改指标信息
+	sql := ` UPDATE  edb_info
+			SET
+			  edb_name =?,
+			  edb_name_source=?,
+			  frequency = ?,
+			  unit = ?,
+			  classify_id = ?,
+			  move_type=?,
+			  move_frequency=?,
+			  calculate_formula=?,
+			  modify_time = NOW()
+			WHERE edb_info_id = ? `
+	_, err = to.Raw(sql, req.EdbName, req.EdbName, req.Frequency, req.Unit, req.ClassifyId, req.MoveType, req.MoveFrequency, req.Formula, edbInfoId).Exec()
+	if err != nil {
+		return
+	}
+
+	var existCondition string
+	var existPars []interface{}
+	existCondition += " AND edb_info_id=? "
+	existPars = append(existPars, edbInfoId)
+
+	existCondition += " AND from_edb_info_id=? "
+	existPars = append(existPars, req.FromEdbInfoId)
+
+	//判断计算指标是否被更换
+	count, err := GetEdbInfoCalculateCountByCondition(req.Source, existCondition, existPars)
+	if err != nil {
+		err = errors.New("判断指标是否改变失败,Err:" + err.Error())
+		return
+	}
+	if count <= 0 || req.MoveType != oldEdbInfo.MoveType || req.MoveFrequency != oldEdbInfo.MoveFrequency || req.Formula != oldEdbInfo.CalculateFormula {
+		if count <= 0 {
+			//删除，计算指标关联的，基础指标的关联关系
+			sql = ` DELETE FROM edb_info_calculate_mapping WHERE edb_info_id = ? `
+			_, err = to.Raw(sql, edbInfoId).Exec()
+			if err != nil {
+				err = errors.New("删除计算指标关联关系失败,Err:" + err.Error())
+				return
+			}
+			//关联关系
+			{
+				calculateMappingItem := new(EdbInfoCalculateMapping)
+				calculateMappingItem.CreateTime = time.Now()
+				calculateMappingItem.ModifyTime = time.Now()
+				calculateMappingItem.Sort = 1
+				calculateMappingItem.EdbCode = edbCode
+				calculateMappingItem.EdbInfoId = 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 = utils.DATA_SOURCE_CALCULATE_TIME_SHIFT
+				calculateMappingItem.SourceName = "时间移位"
+				_, err = to.Insert(calculateMappingItem)
+				if err != nil {
+					return
+				}
+			}
+		}
+		//清空原有数据
+		sql = ` DELETE FROM edb_data_calculate_time_shift WHERE edb_info_id = ? `
+		_, err = to.Raw(sql, edbInfoId).Exec()
+		if err != nil {
+			return edbInfoId, err
+		}
+
+		edbInfoIdStr := strconv.Itoa(edbInfoId)
+
+		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
+		}
+
+		//计算数据
+		var condition string
+		var pars []interface{}
+		condition += " AND edb_info_id=? "
+		pars = append(pars, req.FromEdbInfoId)
+		fmt.Println("EdbInfoId:", req.FromEdbInfoId)
+		dataList, err := GetEdbDataListAll(condition, pars, fromEdbInfo.Source, 0)
+		if err != nil {
+			return edbInfoId, err
+		}
+		addSql := ` INSERT INTO edb_data_calculate_time_shift(edb_info_id,edb_code,data_time,value,create_time,modify_time,status,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)
+			newDate := currentDate.AddDate(0, 0, shiftDay)
+			existKey := edbCode + newDate.Format(utils.FormatDate)
+			if _, ok := existMap[existKey]; !ok {
+				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
+}

models/data_manage/edb_data_calculate_zjpj.go

@@ -0,0 +1,34 @@
+package data_manage
+
+import (
+	"github.com/beego/beego/v2/client/orm"
+	"time"
+)
+
+// EdbDataCalculateZjpj 直接拼接数据结构体
+type EdbDataCalculateZjpj struct {
+	EdbDataId     int `orm:"column(edb_data_id);pk"`
+	EdbInfoId     int
+	EdbCode       string
+	DataTime      string
+	Value         float64
+	Status        int
+	CreateTime    time.Time
+	ModifyTime    time.Time
+	DataTimestamp int64
+}
+
+// GetAllEdbDataCalculateZjpjByEdbInfoId 根据指标id获取全部的数据
+func GetAllEdbDataCalculateZjpjByEdbInfoId(edbInfoId int) (items []*EdbDataCalculateZjpj, err error) {
+	o := orm.NewOrmUsingDB("data")
+	sql := ` SELECT * FROM edb_data_calculate_zjpj WHERE edb_info_id=? ORDER BY data_time DESC `
+	_, err = o.Raw(sql, edbInfoId).QueryRows(&items)
+	return
+}
+
+type EdbDataFromZjpj struct {
+	Date   map[string]int64   `json:"date"`
+	Ticker map[string]string  `json:"ticker"`
+	Field  map[string]string  `json:"field"`
+	Value  map[string]float64 `json:"value"`
+}

models/data_manage/edb_info.go

@@ -6,6 +6,8 @@ import (
 	"fmt"
 	"github.com/beego/beego/v2/client/orm"
 	"github.com/rdlucklib/rdluck_tools/paging"
+	"strconv"
+	"strings"
 	"time"
 )
 
@@ -61,7 +63,7 @@ type EdbInfoItem struct {
 // GetEdbInfoAll 用于分类展示
 func GetEdbInfoAll(edbInfoType uint8) (items []*EdbClassifyItems, err error) {
 	o := orm.NewOrmUsingDB("data")
-	sql := ` SELECT edb_info_id,classify_id,edb_name_source AS classify_name,unique_code,source_name,source,sys_user_id,sys_user_real_name,start_date,edb_code,edb_type FROM edb_info WHERE edb_info_type = ? order by sort asc,edb_info_id asc`
+	sql := ` SELECT edb_info_id,classify_id,edb_name_source AS classify_name,edb_name_en AS classify_name_en,unique_code,source_name,source,sys_user_id,sys_user_real_name,start_date,edb_code,edb_type FROM edb_info WHERE edb_info_type = ? order by sort asc,edb_info_id asc`
 	_, err = o.Raw(sql, edbInfoType).QueryRows(&items)
 	return
 }
@@ -69,7 +71,7 @@ func GetEdbInfoAll(edbInfoType uint8) (items []*EdbClassifyItems, err error) {
 // GetPredictEdbInfoAll 用于分类展示（预测指标）
 func GetPredictEdbInfoAll(edbInfoType uint8) (items []*EdbClassifyItems, err error) {
 	o := orm.NewOrmUsingDB("data")
-	sql := ` SELECT edb_info_id,classify_id,edb_name AS classify_name,unique_code,source_name,source,sys_user_id,sys_user_real_name,start_date,edb_code,edb_type FROM edb_info WHERE edb_info_type = ? order by sort asc,edb_info_id asc`
+	sql := ` SELECT edb_info_id,classify_id,edb_name AS classify_name,edb_name_en AS classify_name_en,unique_code,source_name,source,sys_user_id,sys_user_real_name,start_date,edb_code,edb_type FROM edb_info WHERE edb_info_type = ? order by sort asc,edb_info_id asc`
 	_, err = o.Raw(sql, edbInfoType).QueryRows(&items)
 	return
 }
@@ -552,6 +554,7 @@ func ModifyCalculateEdbInfo(item *EditEdbInfoReq) (err error) {
 type AddEdbInfoResp struct {
 	EdbInfoId  int    `description:"指标ID"`
 	UniqueCode string `description:"指标唯一编码"`
+	ClassifyId int    `description:"分类id"`
 }
 
 // 根据基础指标获取所有关联指标
@@ -749,6 +752,21 @@ type EdbInfoReplaceReq struct {
 	NewEdbInfoId int `description:"替换为指标ID"`
 }
 
+// EdbInfoReplaceV2 替换指标v2版本（更换时间：2022年01月05日15:33:42）
+func EdbInfoReplaceV2(oldEdbInfo, newEdbInfo *EdbInfo, sysAdminId int, sysAdminRealName string) (replaceChartTotal, replaceCalculateTotal int, err error) {
+	defer func() {
+		if err != nil {
+			fmt.Println("ERR:", err.Error())
+		}
+	}()
+	mappingList, replaceChartTotal, replaceCalculateTotal, err := replaceChartEdb(oldEdbInfo, newEdbInfo)
+	if err != nil {
+		return
+	}
+	err = replaceRelationEdbInfo(mappingList, oldEdbInfo, newEdbInfo, sysAdminId, sysAdminRealName)
+	return
+}
+
 // ReplaceChartEdb 替换图表中的指标
 func ReplaceChartEdb(oldEdbInfo, newEdbInfo *EdbInfo) (mappingList []*EdbInfoCalculateMapping, replaceChartTotal, replaceCalculateTotal int, err error) {
 	return replaceChartEdb(oldEdbInfo, newEdbInfo)
@@ -844,6 +862,340 @@ func replaceChartEdb(oldEdbInfo, newEdbInfo *EdbInfo) (mappingList []*EdbInfoCal
 	return
 }
 
+// replaceRelationEdbInfo 替换关联指标
+func replaceRelationEdbInfo(mappingList []*EdbInfoCalculateMapping, oldEdbInfo, newEdbInfo *EdbInfo, sysAdminId int, sysAdminRealName string) (err error) {
+	errmsg := ``
+	defer func() {
+		if errmsg != "" {
+			fmt.Println("errmsg:" + errmsg)
+		}
+		if err != nil && errmsg != "" {
+			go alarm_msg.SendAlarmMsg("替换关联指标失败提醒,errmsg："+errmsg, 3)
+			//go utils.SendEmail(utils.APPNAME+"【"+utils.RunMode+"】"+"替换指标失败提醒", "errmsg:"+errmsg, utils.EmailSendToUsers)
+		}
+	}()
+	//获取计算指标关联指标
+	allMappingList := make([]*EdbInfoCalculateMapping, 0)
+	allMapping := make(map[int]int)
+	tmpMapping := make(map[int]int)
+	for _, v := range mappingList {
+		if _, ok := allMapping[v.EdbInfoId]; !ok {
+			allMappingList = append(allMappingList, v)
+		}
+		newList, _ := GetAllCalculateV2(v.EdbInfoId, newEdbInfo.EdbInfoId, tmpMapping)
+		for _, nv := range newList {
+			if _, ok := allMapping[v.EdbInfoId]; !ok {
+				allMappingList = append(allMappingList, nv)
+			}
+			allMapping[v.EdbInfoId] = v.EdbInfoId
+		}
+		allMapping[v.EdbInfoId] = v.EdbInfoId
+	}
+	for mk, mv := range allMappingList { //原指标关联的所有计算指标
+		fmt.Println("mk/mv", mk, mv)
+		//重新计算计算指标
+		{
+			edbInfo, tmpErr := GetEdbInfoById(mv.EdbInfoId) //计算指标
+			err = tmpErr
+			if err != nil {
+				if err.Error() == utils.ErrNoRow() {
+					errmsg = "计算指标已被删除"
+				} else {
+					errmsg = "获取计算指标失败:err:" + err.Error()
+				}
+				return
+			}
+
+			fromEdbInfoList, tmpErr := GetEdbInfoCalculateDetail(mv.EdbInfoId, edbInfo.Source)
+			err = tmpErr
+			if err != nil {
+				errmsg = "获取计算指标失败:err:" + err.Error()
+				return
+			}
+			if len(fromEdbInfoList) <= 0 {
+				errmsg = "计算指标所依赖指标不存在"
+				err = fmt.Errorf("计算指标所依赖指标不存在")
+				return
+			}
+			fromEdbInfoItem := fromEdbInfoList[0]
+			if fromEdbInfoItem == nil {
+				return
+			}
+			fromEdbInfo, tmpErr := GetEdbInfoById(fromEdbInfoItem.FromEdbInfoId)
+			err = tmpErr
+			if err != nil {
+				errmsg = "获取计算指标 来源指标失败:err:" + err.Error()
+				return
+			}
+			edbCode := edbInfo.EdbCode
+			uniqueCode := edbInfo.UniqueCode
+			sourName := edbInfo.SourceName
+			source := edbInfo.Source
+			edbInfoId := edbInfo.EdbInfoId
+
+			req := new(EdbInfoCalculateBatchSaveReq)
+			req.EdbInfoId = edbInfoId
+			req.EdbName = edbInfo.EdbName
+			req.Frequency = edbInfo.Frequency
+			req.Unit = edbInfo.Unit
+			req.ClassifyId = edbInfo.ClassifyId
+			req.FromEdbInfoId = fromEdbInfoList[0].FromEdbInfoId
+
+			if source == utils.DATA_SOURCE_CALCULATE {
+				//检验公式
+				var formulaStr string
+				var edbInfoIdBytes []string
+				for _, v := range fromEdbInfoList {
+					formulaStr += v.FromTag + ","
+					edbInfoIdBytes = append(edbInfoIdBytes, v.FromTag)
+				}
+				formulaStr = strings.Trim(formulaStr, ",")
+				formulaMap := CheckFormula(edbInfo.CalculateFormula)
+				for _, v := range formulaMap {
+					if !strings.Contains(formulaStr, v) {
+						errmsg = "公式错误，请重新填写"
+						err = fmt.Errorf("公式错误，请重新填写")
+						return
+					}
+				}
+
+				edbInfoList := make([]*EdbInfo, 0)
+
+				for _, v := range fromEdbInfoList {
+					edbInfo, tmpErr := GetEdbInfoById(v.FromEdbInfoId)
+					err = tmpErr
+					if err != nil {
+						if err.Error() == utils.ErrNoRow() {
+							errmsg = "指标 " + strconv.Itoa(v.FromEdbInfoId) + " 不存在"
+						} else {
+							errmsg = "获取指标失败:Err:" + err.Error()
+						}
+						return
+					}
+					edbInfoList = append(edbInfoList, edbInfo)
+				}
+				//清除历史数据
+				err = DeleteCalculateData(edbInfoId)
+				if err != nil {
+					errmsg = "清空运算指标失败:Err:" + err.Error() + " edb_info_id:" + strconv.Itoa(edbInfoId)
+					return
+				}
+				err = Calculate(edbInfoList, int(edbInfoId), edbCode, edbInfo.CalculateFormula, edbInfoIdBytes)
+				if err != nil {
+					errmsg = "生成计算指标失败,Calculate Err:" + err.Error()
+					return
+				}
+			} else if source == utils.DATA_SOURCE_CALCULATE_LJZZY {
+				_, err = AddCalculateLjzzy(req, fromEdbInfo, edbCode, uniqueCode, sysAdminId, sysAdminRealName)
+			} else if source == utils.DATA_SOURCE_CALCULATE_TBZ {
+				sourName = "同比值"
+				edbInfoId, err = AddCalculateTbz(req, fromEdbInfo, edbCode, uniqueCode, sysAdminId, sysAdminRealName)
+			} else if source == utils.DATA_SOURCE_CALCULATE_TCZ {
+				sourName = "同差值"
+				edbInfoId, err = AddCalculateTcz(req, fromEdbInfo, edbCode, uniqueCode, sysAdminId, sysAdminRealName)
+			} else if source == utils.DATA_SOURCE_CALCULATE_NSZYDPJJS {
+				sourName = "N数值移动平均计算"
+				formulaInt, _ := strconv.Atoi(edbInfo.CalculateFormula)
+				edbInfoId, err = AddCalculateNszydpjjs(req, fromEdbInfo, edbCode, uniqueCode, sysAdminId, sysAdminRealName, formulaInt)
+			} else if source == utils.DATA_SOURCE_CALCULATE_HBZ {
+				sourName = "环比值"
+				formulaInt, _ := strconv.Atoi(edbInfo.CalculateFormula)
+				edbInfoId, err = AddCalculateHbz(req, fromEdbInfo, edbCode, uniqueCode, sysAdminId, sysAdminRealName, formulaInt)
+			} else if source == utils.DATA_SOURCE_CALCULATE_HCZ {
+				sourName = "环差值"
+				formulaInt, _ := strconv.Atoi(edbInfo.CalculateFormula)
+				edbInfoId, err = AddCalculateHcz(req, fromEdbInfo, edbCode, uniqueCode, sysAdminId, sysAdminRealName, formulaInt)
+			} else if source == utils.DATA_SOURCE_CALCULATE_BP {
+				sourName = "变频"
+				fmt.Println("变频", req, fromEdbInfo, edbCode, uniqueCode, sysAdminId, sysAdminRealName)
+				edbInfoId, err = AddCalculateBp(req, fromEdbInfo, edbCode, uniqueCode, sysAdminId, sysAdminRealName)
+			} else if source == utils.DATA_SOURCE_CALCULATE_TIME_SHIFT {
+				req2 := &EdbInfoCalculateBatchEditReq{
+					EdbName:       edbInfo.EdbName,
+					Frequency:     edbInfo.Frequency,
+					Unit:          edbInfo.Unit,
+					ClassifyId:    edbInfo.ClassifyId,
+					Formula:       edbInfo.CalculateFormula,
+					EdbInfoId:     edbInfo.EdbInfoId,
+					FromEdbInfoId: fromEdbInfoList[0].FromEdbInfoId,
+					Source:        edbInfo.Source,
+					MoveType:      edbInfo.MoveType,
+					MoveFrequency: edbInfo.MoveFrequency,
+				}
+				sourName = "时间移位"
+				edbInfoId, err = EditCalculateTimeShift(req2, fromEdbInfo, edbCode, edbInfo)
+			} else if source == utils.DATA_SOURCE_CALCULATE_ZJPJ {
+				edbInfoIdArr := make([]EdbInfoFromTag, 0)
+				//A指标
+				aFromEdbInfoId := fromEdbInfoList[0].FromEdbInfoId
+				for _, v := range fromEdbInfoList {
+					if v.FromTag == "A" {
+						if v.FromEdbInfoId == oldEdbInfo.EdbInfoId {
+							aFromEdbInfoId = newEdbInfo.EdbInfoId
+						} else {
+							aFromEdbInfoId = fromEdbInfoList[0].FromEdbInfoId
+						}
+					}
+					if v.FromTag == "B" {
+						if v.FromEdbInfoId == oldEdbInfo.EdbInfoId {
+							edbInfoIdArr = append(edbInfoIdArr, EdbInfoFromTag{
+								EdbInfoId: newEdbInfo.EdbInfoId,
+								FromTag:   v.FromTag,
+								MoveValue: v.MoveValue,
+							})
+						} else {
+							edbInfoIdArr = append(edbInfoIdArr, EdbInfoFromTag{
+								EdbInfoId: v.FromEdbInfoId,
+								FromTag:   v.FromTag,
+								MoveValue: v.MoveValue,
+							})
+						}
+					}
+				}
+				req2 := &EdbInfoCalculateBatchEditReq{
+					EdbName:       edbInfo.EdbName,
+					Frequency:     edbInfo.Frequency,
+					Unit:          edbInfo.Unit,
+					ClassifyId:    edbInfo.ClassifyId,
+					Formula:       edbInfo.CalculateFormula,
+					EdbInfoId:     edbInfo.EdbInfoId,
+					FromEdbInfoId: aFromEdbInfoId,
+					Source:        edbInfo.Source,
+					MoveType:      edbInfo.MoveType,
+					MoveFrequency: edbInfo.MoveFrequency,
+					EdbInfoIdArr:  edbInfoIdArr,
+				}
+
+				sourName = "直接拼接"
+				if len(req2.EdbInfoIdArr) != 1 {
+					errmsg = "请传入拼接日期之后的指标"
+					err = fmt.Errorf("请传入拼接日期之后的指标")
+					return
+				}
+
+				secondEdbInfoReq := req2.EdbInfoIdArr[0]
+				secondEdbInfo, tmpErr := GetEdbInfoById(secondEdbInfoReq.EdbInfoId)
+				err = tmpErr
+				if err != nil {
+					errmsg = "获取拼接日期之后的指标信息失败:Err:" + err.Error()
+					err = fmt.Errorf("获取拼接日期之后的指标信息失败:Err:" + err.Error())
+					return
+				}
+
+				if fromEdbInfo.EdbInfoId == secondEdbInfo.EdbInfoId {
+					errmsg = "两个指标不允许为同一个"
+					err = fmt.Errorf("两个指标不允许为同一个")
+					return
+				}
+				tmpEdbInfoId, tmpErr := EditCalculateZjpj(req2, edbInfo, fromEdbInfo, secondEdbInfo)
+				err = tmpErr
+				edbInfoId = tmpEdbInfoId
+			} else if source == utils.DATA_SOURCE_CALCULATE_LJZTBPJ { //累计值同比拼接
+				edbInfoIdArr := make([]EdbInfoFromTag, 0)
+				//A指标
+				aFromEdbInfoId := fromEdbInfoList[0].FromEdbInfoId
+				for _, v := range fromEdbInfoList {
+					if v.FromTag == "A" {
+						if v.FromEdbInfoId == oldEdbInfo.EdbInfoId {
+							aFromEdbInfoId = newEdbInfo.EdbInfoId
+						} else {
+							aFromEdbInfoId = fromEdbInfoList[0].FromEdbInfoId
+						}
+					}
+					if v.FromTag == "B" {
+						if v.FromEdbInfoId == oldEdbInfo.EdbInfoId {
+							edbInfoIdArr = append(edbInfoIdArr, EdbInfoFromTag{
+								EdbInfoId: newEdbInfo.EdbInfoId,
+								FromTag:   v.FromTag,
+								MoveValue: v.MoveValue,
+							})
+						} else {
+							edbInfoIdArr = append(edbInfoIdArr, EdbInfoFromTag{
+								EdbInfoId: v.FromEdbInfoId,
+								FromTag:   v.FromTag,
+								MoveValue: v.MoveValue,
+							})
+						}
+					}
+				}
+
+				req2 := &EdbInfoCalculateBatchEditReq{
+					EdbName:       edbInfo.EdbName,
+					Frequency:     edbInfo.Frequency,
+					Unit:          edbInfo.Unit,
+					ClassifyId:    edbInfo.ClassifyId,
+					Formula:       edbInfo.CalculateFormula,
+					EdbInfoId:     edbInfo.EdbInfoId,
+					FromEdbInfoId: aFromEdbInfoId,
+					Source:        edbInfo.Source,
+					MoveType:      edbInfo.MoveType,
+					MoveFrequency: edbInfo.MoveFrequency,
+					EdbInfoIdArr:  edbInfoIdArr,
+				}
+
+				sourName = "累计值同比拼接"
+
+				if fromEdbInfo.Frequency != "月度" {
+					errmsg = "累计值同比拼接,待拼接指标只能筛选月度指标"
+					err = fmt.Errorf("累计值同比拼接,待拼接指标只能筛选月度指标")
+					return
+				}
+				if len(req2.EdbInfoIdArr) != 1 {
+					errmsg = "请传入同比值指标"
+					err = fmt.Errorf("请传入同比值指标")
+					return
+				}
+
+				secondEdbInfoReq := req2.EdbInfoIdArr[0]
+				tbzEdbInfo, tmpErr := GetEdbInfoById(secondEdbInfoReq.EdbInfoId)
+				err = tmpErr
+				if err != nil {
+					errmsg = "获取同比值指标信息失败:Err:" + err.Error()
+					err = fmt.Errorf("获取同比值指标信息失败:Err:" + err.Error())
+					return
+				}
+				if tbzEdbInfo.Source != utils.DATA_SOURCE_CALCULATE_TBZ {
+					errmsg = "指标必须是传入同比值指标类型"
+					err = fmt.Errorf("指标必须是传入同比值指标类型")
+					return
+				}
+				if tbzEdbInfo.Frequency != "月度" {
+					errmsg = "同比值指标只能筛选月度指标"
+					err = fmt.Errorf("同比值指标只能筛选月度指标")
+					return
+				}
+
+				if fromEdbInfo.EdbInfoId == tbzEdbInfo.EdbInfoId {
+					errmsg = "两个指标不允许为同一个"
+					err = fmt.Errorf("两个指标不允许为同一个")
+					return
+				}
+				tmpEdbInfoId, tmpErr := EditCalculateLjztbpj(req2, edbInfo, fromEdbInfo, tbzEdbInfo)
+				err = tmpErr
+				edbInfoId = tmpEdbInfoId
+			} else if source == utils.DATA_SOURCE_PYTHON {
+				//python代码运算的过滤
+				continue
+			} else {
+				errmsg = "无效计算方式,source:" + strconv.Itoa(source)
+				err = fmt.Errorf("无效计算方式,source:" + strconv.Itoa(source))
+				return
+			}
+			maxAndMinItem, tmpErr := GetEdbInfoMaxAndMinInfo(source, edbCode)
+			err = tmpErr
+			if err != nil && err.Error() != utils.ErrNoRow() {
+				errmsg = "生成" + sourName + "失败,GetEdbInfoMaxAndMinInfo Err:" + err.Error()
+				err = fmt.Errorf("生成" + sourName + "失败,GetEdbInfoMaxAndMinInfo Err:" + err.Error())
+				return
+			}
+			if maxAndMinItem != nil {
+				err = ModifyEdbInfoMaxAndMinInfo(edbInfoId, maxAndMinItem)
+			}
+		}
+	}
+	return
+}
+
 type EdbInfoView struct {
 	EdbInfoId        int    `orm:"column(edb_info_id);pk"`
 	EdbInfoType      int    `description:"指标类型，0：普通指标，1：预测指标"`
@@ -1042,6 +1394,18 @@ func GetEdbInfoListByCondition(condition string, pars []interface{}, startSize,
 	return
 }
 
+// GetEdbInfoListV2ByCondition 根据条件获取指标列表数据（EdbInfo原始数据结构）
+func GetEdbInfoListV2ByCondition(condition string, pars []interface{}, startSize, pageSize int) (items []*EdbInfo, err error) {
+	o := orm.NewOrmUsingDB("data")
+	sql := ` SELECT * FROM edb_info WHERE 1=1 `
+	if condition != "" {
+		sql += condition
+	}
+	sql += ` ORDER BY edb_info_id ASC LIMIT ?,? `
+	_, err = o.Raw(sql, pars, startSize, pageSize).QueryRows(&items)
+	return
+}
+
 // GetEdbInfoListGroupByUserId 根据指标id列表、用户分组获取指标信息
 func GetEdbInfoListGroupByUserId(edbIdList []string) (items []*EdbInfo, err error) {
 	num := len(edbIdList)
@@ -1117,7 +1481,7 @@ type SetEdbDataInsertConfigReq struct {
 // GetEdbInfoAll 用于分类展示
 func GetEdbInfoByClassifyId(classifyId, edbInfoType int) (items []*EdbClassifyItems, err error) {
 	o := orm.NewOrmUsingDB("data")
-	sql := ` SELECT edb_info_id,classify_id,edb_name_source AS classify_name,unique_code,source_name,source,sys_user_id,sys_user_real_name,start_date,edb_code,edb_type FROM edb_info WHERE classify_id = ? AND edb_info_type = ? order by sort asc,edb_info_id asc`
+	sql := ` SELECT edb_info_id,classify_id,edb_name_source AS classify_name,edb_name_en AS classify_name_en,unique_code,source_name,source,sys_user_id,sys_user_real_name,start_date,edb_code,edb_type FROM edb_info WHERE classify_id = ? AND edb_info_type = ? order by sort asc,edb_info_id asc`
 	_, err = o.Raw(sql, classifyId, edbInfoType).QueryRows(&items)
 	return
 }
@@ -1152,9 +1516,27 @@ func GetEdbInfoAndClassifyListByEdbIdList(edbIdList []int) (items []*EdbAndClass
 
 // TraceEdbInfoResp 指标追溯数据返回
 type TraceEdbInfoResp struct {
-	//EdbInfo   *EdbInfo
-	EdbInfoId int                `description:"指标id"`
-	EdbName   string             `description:"指标名称"`
-	RuleTitle string             `description:"指标规则"`
-	Child     []TraceEdbInfoResp `description:"下级来源"`
+	EdbInfoId   int                `description:"指标id"`
+	EdbInfoType int                `description:"指标类型: 0-普通指标; 1-预测指标"`
+	EdbName     string             `description:"指标名称"`
+	EdbType     int                `description:"指标类型: 1-基础指标; 2-计算指标"`
+	RuleTitle   string             `description:"指标规则"`
+	UniqueCode  string             `description:"唯一编码"`
+	ClassifyId  int                `description:"分类ID"`
+	Child       []TraceEdbInfoResp `description:"下级来源"`
+}
+
+// BeforeAndAfterDateDataResp 前后几期数据
+type BeforeAndAfterDateDataResp struct {
+	List []*EdbDataList `description:"list"`
+	Date string         `description:"实际日期"`
+}
+
+// GetEdbInfoAdminList
+func GetEdbInfoAdminList(edbType int) (list []int, err error) {
+	o := orm.NewOrmUsingDB("data")
+	sql := ` SELECT sys_user_id FROM edb_info WHERE edb_info_type = ? GROUP BY sys_user_id  `
+
+	_, err = o.Raw(sql, edbType).QueryRows(&list)
+	return
 }

models/data_manage/edb_info_calculate.go

@@ -1,9 +1,12 @@
 package data_manage
 
 import (
+	"errors"
 	"eta/eta_mobile/utils"
 	"fmt"
 	"github.com/beego/beego/v2/client/orm"
+	"github.com/yidane/formula"
+	"strconv"
 	"strings"
 	"time"
 )
@@ -546,6 +549,92 @@ func GetFormulaMap() map[string]string {
 	return funMap
 }
 
+func Calculate(edbInfoIdArr []*EdbInfo, edbInfoId int, edbCode, formulaStr string, edbInfoIdBytes []string) (err error) {
+	defer func() {
+		if err != nil {
+			utils.FileLog.Info("Calculate Err:%s" + err.Error())
+		}
+	}()
+	saveDataMap := make(map[string]map[int]float64)
+	for _, v := range edbInfoIdArr {
+		var condition string
+		var pars []interface{}
+		condition += " AND edb_info_id=? "
+		pars = append(pars, v.EdbInfoId)
+		dataList, err := GetEdbDataListAll(condition, pars, v.Source, 1)
+		if err != nil {
+			return err
+		}
+		dataMap := make(map[string]float64)
+		for _, dv := range dataList {
+			if val, ok := saveDataMap[dv.DataTime]; ok {
+				if _, ok := val[v.EdbInfoId]; !ok {
+					val[v.EdbInfoId] = dv.Value
+				}
+			} else {
+				temp := make(map[int]float64)
+				temp[v.EdbInfoId] = dv.Value
+				saveDataMap[dv.DataTime] = temp
+			}
+		}
+		item := new(CalculateItems)
+		item.EdbInfoId = v.EdbInfoId
+		item.DataMap = dataMap
+	}
+	formulaMap := CheckFormula(formulaStr)
+	addSql := ` INSERT INTO edb_data_calculate(edb_info_id,edb_code,data_time,value,create_time,modify_time,status,data_timestamp) values `
+	nowStr := time.Now().Format(utils.FormatDateTime)
+	var isAdd bool
+
+	for sk, sv := range saveDataMap {
+		formulaStr = strings.ToUpper(formulaStr)
+		formulaFormStr := ReplaceFormula(edbInfoIdArr, sv, formulaMap, formulaStr, edbInfoIdBytes)
+		if formulaStr == "" {
+			return
+		}
+		if formulaFormStr != "" {
+			utils.FileLog.Info("formulaFormStr:%s", formulaFormStr)
+			expression := formula.NewExpression(formulaFormStr)
+			calResult, err := expression.Evaluate()
+			if err != nil {
+				err = errors.New("计算失败：Err:" + err.Error() + ";formulaStr:" + formulaFormStr)
+				fmt.Println(err)
+				return err
+			}
+			calVal, err := calResult.Float64()
+			if err != nil {
+				err = errors.New("计算失败：获取计算值失败 Err:" + err.Error() + ";formulaStr:" + formulaFormStr)
+				fmt.Println(err)
+				return err
+			}
+
+			//需要存入的数据
+			{
+				dataTime, _ := time.Parse(utils.FormatDate, sk)
+				timestamp := dataTime.UnixNano() / 1e6
+				timeStr := fmt.Sprintf("%d", timestamp)
+				addSql += "("
+				addSql += strconv.Itoa(edbInfoId) + "," + "'" + edbCode + "'" + "," + "'" + sk + "'" + "," + utils.SubFloatToString(calVal, 4) + "," + "'" + nowStr + "'" +
+					"," + "'" + nowStr + "'" + "," + "1"
+				addSql += "," + "'" + timeStr + "'"
+				addSql += "),"
+				isAdd = true
+			}
+		} else {
+			fmt.Println("formulaFormStr is empty")
+		}
+	}
+	if isAdd {
+		addSql = strings.TrimRight(addSql, ",")
+		AddEdbDataCalculateBySql(addSql)
+		if err != nil {
+			fmt.Println("AddEdbDataCalculate Err:" + err.Error())
+			return err
+		}
+	}
+	return
+}
+
 // SaveAdjustEdbInfoReq 保存数据调整请求参数（请求指标服务）
 type SaveAdjustEdbInfoReq struct {
 	AdminId       int                    `description:"添加人id"`

models/data_manage/edb_info_calculate_bp.go

@@ -0,0 +1,157 @@
+package data_manage
+
+import (
+	"eta/eta_mobile/utils"
+	"fmt"
+	"github.com/beego/beego/v2/client/orm"
+	"github.com/shopspring/decimal"
+	"strconv"
+	"strings"
+	"time"
+)
+
+// 变频
+func AddCalculateBp(req *EdbInfoCalculateBatchSaveReq, fromEdbInfo *EdbInfo, edbCode, uniqueCode string, sysUserId int, sysUserRealName string) (edbInfoId int, err error) {
+	fmt.Println("AddCalculateBp")
+	o := orm.NewOrmUsingDB("data")
+	to, err := o.Begin()
+	if err != nil {
+		return
+	}
+	defer func() {
+		if err != nil {
+			fmt.Println("AddCalculateBp,Err:" + err.Error())
+			_ = to.Rollback()
+		} else {
+			_ = to.Commit()
+		}
+	}()
+	if req.EdbInfoId <= 0 {
+		edbInfo := new(EdbInfo)
+		edbInfo.Source = utils.DATA_SOURCE_CALCULATE_BP
+		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 {
+			return edbInfoId, tmpErr
+		}
+		edbInfoId = int(newEdbInfoId)
+		//关联关系
+		{
+			calculateMappingItem := new(EdbInfoCalculateMapping)
+			calculateMappingItem.CreateTime = time.Now()
+			calculateMappingItem.ModifyTime = time.Now()
+			calculateMappingItem.Sort = 1
+			calculateMappingItem.EdbCode = edbCode
+			calculateMappingItem.EdbInfoId = 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 {
+		edbInfoId = req.EdbInfoId
+		dataTableName := GetEdbDataTableName(utils.DATA_SOURCE_CALCULATE_BP)
+		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
+		}
+	}
+
+	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,status,data_timestamp) values `
+	var isAdd bool
+	existMap := make(map[string]string)
+	dataLen := len(dataList)
+	fmt.Println("dataLen:", dataLen)
+
+	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
+}

models/data_manage/edb_info_calculate_hbz.go

@@ -0,0 +1,144 @@
+package data_manage
+
+import (
+	"eta/eta_mobile/utils"
+	"fmt"
+	"github.com/beego/beego/v2/client/orm"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/shopspring/decimal"
+)
+
+// 环比值
+func AddCalculateHbz(req *EdbInfoCalculateBatchSaveReq, fromEdbInfo *EdbInfo, edbCode, uniqueCode string, sysUserId int, sysUserRealName string, formulaInt int) (edbInfoId int, err error) {
+	fmt.Println("AddCalculateHbz")
+	o := orm.NewOrmUsingDB("data")
+	to, err := o.Begin()
+	if err != nil {
+		return
+	}
+	defer func() {
+		if err != nil {
+			fmt.Println("AddCalculateHbz,Err:" + err.Error())
+			_ = to.Rollback()
+		} else {
+			_ = to.Commit()
+		}
+	}()
+	if req.EdbInfoId <= 0 {
+		edbInfo := new(EdbInfo)
+		edbInfo.Source = utils.DATA_SOURCE_CALCULATE_HBZ
+		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 {
+			return edbInfoId, tmpErr
+		}
+		edbInfoId = int(newEdbInfoId)
+		//关联关系
+		{
+			calculateMappingItem := new(EdbInfoCalculateMapping)
+			calculateMappingItem.CreateTime = time.Now()
+			calculateMappingItem.ModifyTime = time.Now()
+			calculateMappingItem.Sort = 1
+			calculateMappingItem.EdbCode = edbCode
+			calculateMappingItem.EdbInfoId = 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 {
+		edbInfoId = req.EdbInfoId
+		dataTableName := GetEdbDataTableName(utils.DATA_SOURCE_CALCULATE_HBZ)
+		deleteSql := ` DELETE FROM %s WHERE edb_info_id=? `
+		deleteSql = fmt.Sprintf(deleteSql, dataTableName)
+		_, err = to.Raw(deleteSql, req.EdbInfoId).Exec()
+	}
+
+	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_hbz(edb_info_id,edb_code,data_time,value,create_time,modify_time,status,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 = to.Raw(addSql).Exec()
+		if err != nil {
+			return edbInfoId, err
+		}
+	}
+	return
+}
+
+// 环比值，current:当期,pre:上期 公式: (当期-上期）/上期
+func HbzDiv(current, pre float64) string {
+	if pre == 0 {
+		return ""
+	}
+	currentVal := decimal.NewFromFloat(float64(current))
+	preVal := decimal.NewFromFloat(float64(pre))
+	val, _ := currentVal.Sub(preVal).Div(preVal).Float64()
+	valStr := utils.SubFloatToString(val, 4)
+	return valStr
+}

models/data_manage/edb_info_calculate_hcz.go

@@ -0,0 +1,149 @@
+package data_manage
+
+import (
+	"eta/eta_mobile/utils"
+	"fmt"
+	"github.com/beego/beego/v2/client/orm"
+	"github.com/shopspring/decimal"
+	"strconv"
+	"strings"
+	"time"
+)
+
+// 环差值
+func AddCalculateHcz(req *EdbInfoCalculateBatchSaveReq, fromEdbInfo *EdbInfo, edbCode, uniqueCode string, sysUserId int, sysUserRealName string, formulaInt int) (edbInfoId int, err error) {
+	fmt.Println("AddCalculateHcz")
+	o := orm.NewOrmUsingDB("data")
+	to, err := o.Begin()
+	if err != nil {
+		return
+	}
+	defer func() {
+		if err != nil {
+			fmt.Println("AddCalculateHcz,Err:" + err.Error())
+			_ = to.Rollback()
+		} else {
+			_ = to.Commit()
+		}
+	}()
+	if req.EdbInfoId <= 0 {
+		edbInfo := new(EdbInfo)
+		edbInfo.Source = utils.DATA_SOURCE_CALCULATE_HCZ
+		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 {
+			return edbInfoId, tmpErr
+		}
+		edbInfoId = int(newEdbInfoId)
+
+		//关联关系
+		{
+			calculateMappingItem := new(EdbInfoCalculateMapping)
+			calculateMappingItem.CreateTime = time.Now()
+			calculateMappingItem.ModifyTime = time.Now()
+			calculateMappingItem.Sort = 1
+			calculateMappingItem.EdbCode = edbCode
+			calculateMappingItem.EdbInfoId = 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 {
+		edbInfoId = req.EdbInfoId
+		dataTableName := GetEdbDataTableName(utils.DATA_SOURCE_CALCULATE_HCZ)
+		deleteSql := ` DELETE FROM %s WHERE edb_info_id=? `
+		deleteSql = fmt.Sprintf(deleteSql, dataTableName)
+		_, err = to.Raw(deleteSql, req.EdbInfoId).Exec()
+	}
+
+	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_hcz(edb_info_id,edb_code,data_time,value,create_time,modify_time,status,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
+}
+
+// 环差值，current:当期,pre:上期 公式:当期-上期
+func HczDiv(current, pre float64) string {
+	if pre == 0 {
+		return ""
+	}
+	currentVal := decimal.NewFromFloat(current)
+	preVal := decimal.NewFromFloat(pre)
+	val, _ := currentVal.Sub(preVal).Float64()
+	valStr := utils.SubFloatToString(val, 4)
+	return valStr
+}

models/data_manage/edb_info_calculate_ljztbpj.go

@@ -0,0 +1,387 @@
+package data_manage
+
+import (
+	"errors"
+	"eta/eta_mobile/utils"
+	"fmt"
+	"github.com/beego/beego/v2/client/orm"
+	"github.com/shopspring/decimal"
+	"sort"
+	"strings"
+	"time"
+)
+
+// EditCalculateLjztbpj 编辑累计值同比拼接数据
+func EditCalculateLjztbpj(req *EdbInfoCalculateBatchEditReq, nowEdbInfo, firstEdbInfo, secondEdbInfo *EdbInfo) (edbInfoId int, err error) {
+	edbInfoId = req.EdbInfoId
+	o := orm.NewOrmUsingDB("data")
+	to, err := o.Begin()
+	if err != nil {
+		return
+	}
+	defer func() {
+		if err != nil {
+			_ = to.Rollback()
+		} else {
+			_ = to.Commit()
+		}
+	}()
+
+	sql := ``
+
+	var existCondition string
+	var existPars []interface{}
+	existCondition += " AND edb_info_id=? "
+	existPars = append(existPars, 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, nowEdbInfo.CalculateFormula, time.Local)
+
+	//待拼接指标map
+	pjDataMap := make(map[string]float64)     //需要入库的数据
+	nowEdbDataMap := make(map[string]float64) //当前指标的数据（已经在库里了，不需要重新）
+
+	//拼接指标的日期切片数据
+	pjEdbDataTimeList := make([]string, 0)
+
+	//最近开始的时间
+	lastDateTime := startCalculationDate
+
+	//待拼接指标数据
+	{
+		//如果拼接指标变更了，那么需要删除所有的指标进行重新拼接
+		if existItemA.FromEdbInfoId != firstEdbInfo.EdbInfoId {
+			//删除旧的指标数据
+			{
+				//删除之前的A指标关联关系
+				sql = ` DELETE FROM edb_info_calculate_mapping WHERE edb_info_id = ? and from_edb_info_id = ?`
+				_, err = to.Raw(sql, edbInfoId, existItemA.FromEdbInfoId).Exec()
+				if err != nil {
+					err = errors.New("删除拼接日期之前的指标关联关系失败,Err:" + err.Error())
+					return
+				}
+
+				//如果拼接指标变更了，那么需要删除所有的指标数据
+				tableName := GetEdbDataTableName(nowEdbInfo.Source)
+				sql = fmt.Sprintf(` DELETE FROM %s WHERE edb_info_id = ? `, tableName)
+
+				_, err = to.Raw(sql, edbInfoId).Exec()
+				if err != nil {
+					err = errors.New("删除所有的累计值同比拼接指标数据失败,Err:" + err.Error())
+					return
+				}
+			}
+
+			//添加新的指标关系
+			{
+				calculateMappingItem := new(EdbInfoCalculateMapping)
+				calculateMappingItem.CreateTime = time.Now()
+				calculateMappingItem.ModifyTime = time.Now()
+				calculateMappingItem.Sort = 1
+				calculateMappingItem.EdbCode = nowEdbInfo.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 = nowEdbInfo.Source
+				calculateMappingItem.SourceName = nowEdbInfo.SourceName
+				_, err = to.Insert(calculateMappingItem)
+				if err != nil {
+					return
+				}
+			}
+
+			var condition string
+			var pars []interface{}
+
+			//获取待拼接指标最近的个12月31日有值的年份
+			condition += " AND data_time like ? AND edb_info_id=? "
+			pars = append(pars, "%12-31", firstEdbInfo.EdbInfoId)
+
+			//获取最新的待拼接指标
+			lastEdbData, tmpErr := GetLastEdbData(condition, pars, firstEdbInfo.Source)
+			if tmpErr != nil {
+				return edbInfoId, tmpErr
+			}
+			lastDateTime, _ = time.ParseInLocation(utils.FormatDate, lastEdbData.DataTime, time.Local)
+
+			//获取待拼接指标的数据列表
+			condition = ``
+			pars = make([]interface{}, 0)
+			condition += " AND data_time <= ? AND edb_info_id=? "
+			pars = append(pars, lastEdbData.DataTime, firstEdbInfo.EdbInfoId)
+
+			firstDataList, tmpErr := GetEdbDataListAll(condition, pars, firstEdbInfo.Source, 0)
+			if tmpErr != nil {
+				return edbInfoId, tmpErr
+			}
+
+			for _, v := range firstDataList {
+				pjDataMap[v.DataTime] = v.Value
+				pjEdbDataTimeList = append(pjEdbDataTimeList, v.DataTime)
+
+				//将新的数据存入已入库指标map里面，以便后续计算
+				nowEdbDataMap[v.DataTime] = v.Value
+			}
+		} else {
+			// 获取当前指标的所有数据
+			var condition string
+			var pars []interface{}
+			condition += " AND edb_info_id=? and data_time <= ?"
+			pars = append(pars, nowEdbInfo.EdbInfoId, nowEdbInfo.CalculateFormula)
+
+			nowEdbDataList, tmpErr := GetEdbDataListAll(condition, pars, nowEdbInfo.Source, 0)
+			if tmpErr != nil {
+				return edbInfoId, tmpErr
+			}
+
+			for _, v := range nowEdbDataList {
+				nowEdbDataMap[v.DataTime] = v.Value
+				pjEdbDataTimeList = append(pjEdbDataTimeList, v.DataTime)
+			}
+		}
+	}
+
+	//同比值指标map
+	tbzEdbDataMap := make(map[string]float64)
+
+	//同比值日期切片列表
+	tbzEdbDataTimeList := make([]string, 0)
+
+	//同比值指标
+	{
+		if existItemB.FromEdbInfoId != secondEdbInfo.EdbInfoId {
+			//删除通过B指标生成的数据
+			{
+				//删除之前的B指标关联关系
+				sql = ` DELETE FROM edb_info_calculate_mapping WHERE edb_info_id = ? and from_edb_info_id = ?`
+				_, err = to.Raw(sql, edbInfoId, existItemB.FromEdbInfoId).Exec()
+				if err != nil {
+					err = errors.New("删除拼接日期之后的指标关联关系失败,Err:" + err.Error())
+					return
+				}
+
+				//如果同比值指标变更了，那么需要删除所有计算出来的指标数据
+				tableName := GetEdbDataTableName(nowEdbInfo.Source)
+				sql = fmt.Sprintf(` DELETE FROM %s WHERE edb_info_id = ? and data_time > ? `, tableName)
+
+				_, err = to.Raw(sql, edbInfoId, nowEdbInfo.CalculateFormula).Exec()
+				if err != nil {
+					err = errors.New("删除计算出来的累计值同比拼接指标数据失败,Err:" + err.Error())
+					return
+				}
+			}
+
+			//添加新的指标关系
+			{
+				calculateMappingItem := new(EdbInfoCalculateMapping)
+				calculateMappingItem.CreateTime = time.Now()
+				calculateMappingItem.ModifyTime = time.Now()
+				calculateMappingItem.Sort = 1
+				calculateMappingItem.EdbCode = nowEdbInfo.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 = nowEdbInfo.Source
+				calculateMappingItem.SourceName = nowEdbInfo.SourceName
+				_, err = to.Insert(calculateMappingItem)
+				if err != nil {
+					return
+				}
+			}
+		}
+
+		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)
+
+	// 遍历现有的数据，判断拼接指标中是否存在该日期数据，如果拼接指标无此数据，那么需要删除该日期数据（日期的判断：需要在开始计算日期之后）
+	removeDateList := make([]string, 0)
+	for nowEdbDate := range nowEdbDataMap {
+		nowEdbDateTime, _ := time.ParseInLocation(utils.FormatDate, nowEdbDate, time.Local)
+		//校验日期 需要 大于 拼接前日期
+		if startCalculationDate.Before(nowEdbDateTime) {
+			if _, ok := tbzEdbDataMap[nowEdbDate]; !ok {
+				// 同比指标中，不存在该日期数据，那么需要移除 现有数据 中该日期的数据
+				removeDateList = append(removeDateList, nowEdbDate)
+			}
+		}
+	}
+
+	//待修改的指标数据map（index：日期，value：值）
+	updateEdbDataMap := make(map[string]float64)
+	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 nowEdbDataValue, isHas := nowEdbDataMap[v]; isHas {
+			//获取去年今日的数据，获取到后，然后是去修改该日期的数据
+			if lastYearEdbDataValue, ok := nowEdbDataMap[pjDataTime.Format(utils.FormatDate)]; ok {
+				tbzDataValue := tbzEdbDataMap[v] //同比值
+				currValue := lastYearEdbDataValue * (1 + tbzDataValue/100)
+				currValue, _ = decimal.NewFromFloat(currValue).Truncate(4).Float64() //保留4位小数
+				//如果计算出来的值与库里面的值不匹配，那么就去修改该值
+				if nowEdbDataValue != currValue {
+					//将计算后的数据存入待拼接指标map里面，以便后续计算
+					updateEdbDataMap[v] = currValue
+				}
+			}
+		} else {
+			//因为 现有数据中 不存在该日期数据，那么需要做新增数据处理
+
+			//如果去年今日存在该数据，那么就去计算当前的数据
+			if pjDataValue, ok := nowEdbDataMap[pjDataTime.Format(utils.FormatDate)]; ok {
+				tbzDataValue := tbzEdbDataMap[v] //同比值
+				currValue := pjDataValue * (1 + tbzDataValue/100)
+
+				currValue, _ = decimal.NewFromFloat(currValue).Truncate(4).Float64()
+				//将计算后的数据存入已入库指标map里面，以便后续计算
+				nowEdbDataMap[v] = currValue
+
+				//将计算后的数据存入待拼接指标map里面，以便后续入库
+				pjDataMap[v] = currValue
+				pjEdbDataTimeList = append(pjEdbDataTimeList, v)
+			}
+		}
+	}
+
+	//新增的数据入库
+	{
+		addDataList := make([]*EdbDataCalculateLjztbpj, 0)
+		for dataTime, dataValue := range pjDataMap {
+			//时间戳
+			currentDate, _ := time.Parse(utils.FormatDate, dataTime)
+			timestamp := currentDate.UnixNano() / 1e6
+
+			edbDataLjztbpj := &EdbDataCalculateLjztbpj{
+				EdbInfoId:     edbInfoId,
+				EdbCode:       nowEdbInfo.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)
+			if tmpErr != nil {
+				err = tmpErr
+				return
+			}
+		}
+	}
+
+	//删除已经不存在的累计同比拼接指标数据（由于同比值当日的数据删除了）
+	{
+		if len(removeDateList) > 0 {
+			removeDateStr := strings.Join(removeDateList, `","`)
+			removeDateStr = `"` + removeDateStr + `"`
+			//如果拼接指标变更了，那么需要删除所有的指标数据
+			tableName := GetEdbDataTableName(nowEdbInfo.Source)
+			sql = fmt.Sprintf(` DELETE FROM %s WHERE edb_info_id = ? and data_time in (%s) `, tableName, removeDateStr)
+
+			_, err = to.Raw(sql, edbInfoId).Exec()
+			if err != nil {
+				err = errors.New("删除不存在的累计值同比拼接指标数据失败,Err:" + err.Error())
+				return
+			}
+		}
+	}
+
+	//修改现有的数据中对应的值
+	{
+		tableName := GetEdbDataTableName(nowEdbInfo.Source)
+		for edbDate, edbDataValue := range updateEdbDataMap {
+			sql = fmt.Sprintf(` UPDATE  %s set value = %f,modify_time=now() WHERE edb_info_id = ? and data_time = %s `, tableName, edbDataValue, edbDate)
+
+			_, err = to.Raw(sql, edbInfoId).Exec()
+			if err != nil {
+				err = errors.New("更新现有的累计值同比拼接指标数据失败,Err:" + err.Error())
+				return
+			}
+		}
+	}
+
+	//修改指标信息
+	sql = ` UPDATE  edb_info SET
+			  edb_name =?,
+			  edb_name_source=?,
+			  frequency = ?,
+			  unit = ?,
+			  classify_id = ?, 
+			  calculate_formula=?,
+			  modify_time = NOW()
+			WHERE edb_info_id = ? `
+	_, err = to.Raw(sql, req.EdbName, req.EdbName, req.Frequency, req.Unit, req.ClassifyId, lastDateTime.Format(utils.FormatDate), edbInfoId).Exec()
+	if err != nil {
+		return
+	}
+
+	return
+}

models/data_manage/edb_info_calculate_ljzzy.go

@@ -0,0 +1,210 @@
+package data_manage
+
+import (
+	"eta/eta_mobile/utils"
+	"fmt"
+	"github.com/beego/beego/v2/client/orm"
+	"github.com/shopspring/decimal"
+	"strconv"
+	"strings"
+	"time"
+)
+
+// 累计值转月
+func AddCalculateLjzzy(req *EdbInfoCalculateBatchSaveReq, fromEdbInfo *EdbInfo, edbCode, uniqueCode string, sysUserId int, sysUserRealName string) (edbInfoId int, err error) {
+	o := orm.NewOrmUsingDB("data")
+	to, err := o.Begin()
+	if err != nil {
+		return
+	}
+	defer func() {
+		if err != nil {
+			_ = to.Rollback()
+		} else {
+			_ = to.Commit()
+		}
+	}()
+
+	if req.EdbInfoId <= 0 {
+		edbInfo := new(EdbInfo)
+		edbInfo.Source = utils.DATA_SOURCE_CALCULATE_LJZZY
+		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 {
+			return int(newEdbInfoId), tmpErr
+		}
+		edbInfoId = int(newEdbInfoId)
+
+		//calculateItem := new(EdbInfoCalculateLjzzy)
+		//calculateItem.CreateTime = time.Now()
+		//calculateItem.ModifyTime = time.Now()
+		//calculateItem.Sort = 1
+		//calculateItem.EdbCode = edbCode
+		//calculateItem.EdbInfoId = edbInfoId
+		//calculateItem.FromEdbInfoId = fromEdbInfo.EdbInfoId
+		//calculateItem.FromEdbCode = fromEdbInfo.EdbCode
+		//calculateItem.FromEdbName = fromEdbInfo.EdbName
+		//calculateItem.FromSource = fromEdbInfo.Source
+		//calculateItem.FromSourceName = fromEdbInfo.SourceName
+		//_, err = to.Insert(calculateItem)
+		//if err != nil {
+		//	return edbInfoId, err
+		//}
+		//关联关系
+		{
+			calculateMappingItem := new(EdbInfoCalculateMapping)
+			calculateMappingItem.CreateTime = time.Now()
+			calculateMappingItem.ModifyTime = time.Now()
+			calculateMappingItem.Sort = 1
+			calculateMappingItem.EdbCode = edbCode
+			calculateMappingItem.EdbInfoId = 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 {
+		edbInfoId = req.EdbInfoId
+		dataTableName := GetEdbDataTableName(utils.DATA_SOURCE_CALCULATE_LJZZY)
+		deleteSql := ` DELETE FROM %s WHERE edb_info_id=? `
+		deleteSql = fmt.Sprintf(deleteSql, dataTableName)
+		_, err = to.Raw(deleteSql, req.EdbInfoId).Exec()
+	}
+	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,status,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)
+
+				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
+}

models/data_manage/edb_info_calculate_nszydpjjs.go

@@ -0,0 +1,173 @@
+package data_manage
+
+import (
+	"eta/eta_mobile/utils"
+	"fmt"
+	"github.com/beego/beego/v2/client/orm"
+	"github.com/shopspring/decimal"
+	"strconv"
+	"strings"
+	"time"
+)
+
+// N数值移动平均计算
+func AddCalculateNszydpjjs(req *EdbInfoCalculateBatchSaveReq, fromEdbInfo *EdbInfo, edbCode, uniqueCode string, sysUserId int, sysUserRealName string, formulaInt int) (edbInfoId int, err error) {
+	o := orm.NewOrmUsingDB("data")
+	to, err := o.Begin()
+	if err != nil {
+		return
+	}
+	defer func() {
+		if err != nil {
+			_ = to.Rollback()
+		} else {
+			_ = to.Commit()
+		}
+	}()
+	if req.EdbInfoId <= 0 {
+		edbInfo := new(EdbInfo)
+		edbInfo.Source = utils.DATA_SOURCE_CALCULATE_NSZYDPJJS
+		edbInfo.SourceName = "N数值移动平均计算"
+		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 {
+			return edbInfoId, tmpErr
+		}
+		edbInfoId = int(newEdbInfoId)
+
+		//calculateItem := new(EdbInfoCalculateNszydpjjs)
+		//calculateItem.CreateTime = time.Now()
+		//calculateItem.ModifyTime = time.Now()
+		//calculateItem.Sort = 1
+		//calculateItem.EdbCode = edbCode
+		//calculateItem.EdbInfoId = edbInfoId
+		//calculateItem.FromEdbInfoId = fromEdbInfo.EdbInfoId
+		//calculateItem.FromEdbCode = fromEdbInfo.EdbCode
+		//calculateItem.FromEdbName = fromEdbInfo.EdbName
+		//calculateItem.FromSource = fromEdbInfo.Source
+		//calculateItem.FromSourceName = fromEdbInfo.SourceName
+		//
+		//_, err = to.Insert(calculateItem)
+		//if err != nil {
+		//	return edbInfoId, err
+		//}
+
+		//关联关系
+		{
+			calculateMappingItem := new(EdbInfoCalculateMapping)
+			calculateMappingItem.CreateTime = time.Now()
+			calculateMappingItem.ModifyTime = time.Now()
+			calculateMappingItem.Sort = 1
+			calculateMappingItem.EdbCode = edbCode
+			calculateMappingItem.EdbInfoId = 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 {
+		edbInfoId = req.EdbInfoId
+		dataTableName := GetEdbDataTableName(utils.DATA_SOURCE_CALCULATE_NSZYDPJJS)
+		deleteSql := ` DELETE FROM %s WHERE edb_info_id=? `
+		deleteSql = fmt.Sprintf(deleteSql, dataTableName)
+		_, err = to.Raw(deleteSql, req.EdbInfoId).Exec()
+	}
+
+	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,status,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
+		}
+	}
+	return
+}

models/data_manage/edb_info_calculate_tcz.go

@@ -0,0 +1,256 @@
+package data_manage
+
+import (
+	"eta/eta_mobile/utils"
+	"fmt"
+	"github.com/beego/beego/v2/client/orm"
+	"github.com/shopspring/decimal"
+	"strconv"
+	"strings"
+	"time"
+)
+
+// 同差值
+func AddCalculateTcz(req *EdbInfoCalculateBatchSaveReq, fromEdbInfo *EdbInfo, edbCode, uniqueCode string, sysUserId int, sysUserRealName string) (edbInfoId int, err error) {
+	o := orm.NewOrmUsingDB("data")
+	to, err := o.Begin()
+	if err != nil {
+		return
+	}
+	defer func() {
+		if err != nil {
+			fmt.Println("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_TCZ
+		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 {
+			return edbInfoId, tmpErr
+		}
+		edbInfoId = int(newEdbInfoId)
+
+		//calculateItem := new(EdbInfoCalculateTcz)
+		//calculateItem.CreateTime = time.Now()
+		//calculateItem.ModifyTime = time.Now()
+		//calculateItem.Sort = 1
+		//calculateItem.EdbCode = edbCode
+		//calculateItem.EdbInfoId = edbInfoId
+		//calculateItem.FromEdbInfoId = fromEdbInfo.EdbInfoId
+		//calculateItem.FromEdbCode = fromEdbInfo.EdbCode
+		//calculateItem.FromEdbName = fromEdbInfo.EdbName
+		//calculateItem.FromSource = fromEdbInfo.Source
+		//calculateItem.FromSourceName = fromEdbInfo.SourceName
+		//
+		//_, err = to.Insert(calculateItem)
+		//if err != nil {
+		//	return edbInfoId, err
+		//}
+
+		//关联关系
+		{
+			calculateMappingItem := new(EdbInfoCalculateMapping)
+			calculateMappingItem.CreateTime = time.Now()
+			calculateMappingItem.ModifyTime = time.Now()
+			calculateMappingItem.Sort = 1
+			calculateMappingItem.EdbCode = edbCode
+			calculateMappingItem.EdbInfoId = 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 {
+		edbInfoId = req.EdbInfoId
+		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
+		}
+	}
+
+	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,status,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)
+
+									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
+}
+
+func TczSub(a, b float64) string {
+	af := decimal.NewFromFloat(float64(a))
+	fmt.Println(af)
+	bf := decimal.NewFromFloat(float64(b))
+	val, _ := af.Sub(bf).Float64()
+	valStr := utils.SubFloatToString(val, 4)
+	return valStr
+}

models/data_manage/edb_info_calculate_zjpj.go

@@ -0,0 +1,286 @@
+package data_manage
+
+import (
+	"errors"
+	"eta/eta_mobile/utils"
+	"github.com/beego/beego/v2/client/orm"
+	"time"
+)
+
+// EditCalculateZjpj 编辑直接拼接数据
+func EditCalculateZjpj(req *EdbInfoCalculateBatchEditReq, nowEdbInfo, firstEdbInfo, secondEdbInfo *EdbInfo) (edbInfoId int, err error) {
+	edbInfoId = req.EdbInfoId
+	o := orm.NewOrmUsingDB("data")
+	to, err := o.Begin()
+	if err != nil {
+		return
+	}
+	defer func() {
+		if err != nil {
+			_ = to.Rollback()
+		} else {
+			_ = to.Commit()
+		}
+	}()
+
+	//修改指标信息
+	sql := ` UPDATE  edb_info SET
+			  edb_name =?,
+			  edb_name_source=?,
+			  frequency = ?,
+			  unit = ?,
+			  classify_id = ?, 
+			  calculate_formula=?,
+			  modify_time = NOW()
+			WHERE edb_info_id = ? `
+	_, err = to.Raw(sql, req.EdbName, req.EdbName, req.Frequency, req.Unit, req.ClassifyId, req.Formula, edbInfoId).Exec()
+	if err != nil {
+		return
+	}
+
+	var existCondition string
+	var existPars []interface{}
+	existCondition += " AND edb_info_id=? "
+	existPars = append(existPars, 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
+		}
+	}
+
+	addDataList := make([]*EdbDataCalculateZjpj, 0)
+	firstDataList := make([]*EdbInfoSearchData, 0)
+	secondDataList := make([]*EdbInfoSearchData, 0)
+
+	//如果 之前的拼接日期 与 现在的拼接日期 不一致的话，需要做以下处理
+	nowFormulaDate, _ := time.ParseInLocation(utils.FormatDate, nowEdbInfo.CalculateFormula, time.Local)
+	reqFormulaDate, _ := time.ParseInLocation(utils.FormatDate, req.Formula, time.Local)
+
+	//如果前后选择的日期不一致，那么需要删除一部分数据
+	if nowEdbInfo.CalculateFormula != req.Formula {
+		var startDate, endDate time.Time
+		//如果当前选择的日期 小于 之前选择的日期
+		if reqFormulaDate.Before(nowFormulaDate) {
+			startDate = reqFormulaDate
+			endDate = nowFormulaDate
+		} else { //如果当前选择的日期 大于 之前选择的日期
+			startDate = nowFormulaDate
+			endDate = reqFormulaDate
+		}
+		//删除 之前日期 与 当前日期 之间的指标数据
+		sql = ` DELETE FROM edb_data_calculate_zjpj WHERE edb_info_id = ? and data_time >= ? and data_time < ?`
+		_, err = to.Raw(sql, edbInfoId, startDate, endDate).Exec()
+		if err != nil {
+			err = errors.New("删除 之前日期 与 当前日期 之间的指标数据失败,Err:" + err.Error())
+			return
+		}
+	}
+	//第一个指标数据
+	{
+		var condition string
+		var pars []interface{}
+		if existItemA.FromEdbInfoId != firstEdbInfo.EdbInfoId {
+			//删除之前的A指标关联关系
+			sql = ` DELETE FROM edb_info_calculate_mapping WHERE edb_info_id = ? and from_edb_info_id = ?`
+			_, err = to.Raw(sql, edbInfoId, existItemA.FromEdbInfoId).Exec()
+			if err != nil {
+				err = errors.New("删除拼接日期之前的指标关联关系失败,Err:" + err.Error())
+				return
+			}
+
+			//删除之前所有的A指标数据
+			sql = ` DELETE FROM edb_data_calculate_zjpj WHERE edb_info_id = ? and data_time < ?`
+			_, err = to.Raw(sql, edbInfoId, req.Formula).Exec()
+			if err != nil {
+				err = errors.New("删除拼接日期之前的数据失败,Err:" + err.Error())
+				return
+			}
+
+			//获取第一个指标的数据列表
+			condition += " AND data_time < ? AND edb_info_id=? "
+			pars = append(pars, req.Formula, firstEdbInfo.EdbInfoId)
+
+			tmpFirstDataList, tmpErr := GetEdbDataListAll(condition, pars, firstEdbInfo.Source, 0)
+			if tmpErr != nil {
+				return edbInfoId, tmpErr
+			}
+			firstDataList = tmpFirstDataList
+
+			//添加新的指标关系
+			{
+				calculateMappingItem := new(EdbInfoCalculateMapping)
+				calculateMappingItem.CreateTime = time.Now()
+				calculateMappingItem.ModifyTime = time.Now()
+				calculateMappingItem.Sort = 1
+				calculateMappingItem.EdbCode = nowEdbInfo.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 = nowEdbInfo.Source
+				calculateMappingItem.SourceName = nowEdbInfo.SourceName
+				_, err = to.Insert(calculateMappingItem)
+				if err != nil {
+					return
+				}
+			}
+		} else {
+			if req.Formula != nowEdbInfo.CalculateFormula {
+				//获取第一个指标的数据列表
+				condition += " AND data_time >= ?  AND data_time < ? AND edb_info_id=? "
+				pars = append(pars, nowFormulaDate, reqFormulaDate, firstEdbInfo.EdbInfoId)
+
+				tmpFirstDataList, tmpErr := GetEdbDataListAll(condition, pars, firstEdbInfo.Source, 0)
+				if tmpErr != nil {
+					return edbInfoId, tmpErr
+				}
+				firstDataList = tmpFirstDataList
+			}
+		}
+
+		//待插入数据
+		for _, v := range firstDataList {
+			//时间戳
+			currentDate, _ := time.Parse(utils.FormatDate, v.DataTime)
+			timestamp := currentDate.UnixNano() / 1e6
+
+			edbDataZjpj := &EdbDataCalculateZjpj{
+				EdbInfoId:     edbInfoId,
+				EdbCode:       nowEdbInfo.EdbCode,
+				DataTime:      v.DataTime,
+				Value:         v.Value,
+				Status:        1,
+				CreateTime:    time.Now(),
+				ModifyTime:    time.Now(),
+				DataTimestamp: timestamp,
+			}
+			addDataList = append(addDataList, edbDataZjpj)
+		}
+	}
+
+	//第二个指标数据
+	{
+		var condition string
+		var pars []interface{}
+
+		if existItemB.FromEdbInfoId != secondEdbInfo.EdbInfoId {
+			//删除之前的B指标关联关系
+			sql = ` DELETE FROM edb_info_calculate_mapping WHERE edb_info_id = ? and from_edb_info_id = ?`
+			_, err = to.Raw(sql, edbInfoId, existItemB.FromEdbInfoId).Exec()
+			if err != nil {
+				err = errors.New("删除拼接日期之后的指标关联关系失败,Err:" + err.Error())
+				return
+			}
+
+			//删除历史拼接日期之前所有的B指标数据
+			sql = ` DELETE FROM edb_data_calculate_zjpj WHERE edb_info_id = ? and data_time >= ?`
+			_, err = to.Raw(sql, edbInfoId, nowEdbInfo.CalculateFormula).Exec()
+			if err != nil {
+				err = errors.New("删除历史拼接日期之后的数据失败,Err:" + err.Error())
+				return
+			}
+
+			//第二个指标的数据列表
+			condition = " AND data_time >= ?  AND edb_info_id=? "
+			pars = append(pars, reqFormulaDate, secondEdbInfo.EdbInfoId)
+			tmpSecondDataList, tmpErr := GetEdbDataListAll(condition, pars, secondEdbInfo.Source, 0)
+			if tmpErr != nil {
+				return edbInfoId, tmpErr
+			}
+			secondDataList = tmpSecondDataList
+
+			//添加新的指标关系
+			{
+				calculateMappingItem := new(EdbInfoCalculateMapping)
+				calculateMappingItem.CreateTime = time.Now()
+				calculateMappingItem.ModifyTime = time.Now()
+				calculateMappingItem.Sort = 1
+				calculateMappingItem.EdbCode = nowEdbInfo.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 = nowEdbInfo.Source
+				calculateMappingItem.SourceName = nowEdbInfo.SourceName
+				_, err = to.Insert(calculateMappingItem)
+				if err != nil {
+					return
+				}
+			}
+		} else {
+			if req.Formula != nowEdbInfo.CalculateFormula {
+				//获取第二个指标的数据列表
+				condition += " AND data_time >= ?  AND data_time < ? AND edb_info_id=? "
+				pars = append(pars, reqFormulaDate, nowFormulaDate, secondEdbInfo.EdbInfoId)
+
+				tmpSecondDataList, tmpErr := GetEdbDataListAll(condition, pars, secondEdbInfo.Source, 0)
+				if tmpErr != nil {
+					return edbInfoId, tmpErr
+				}
+				secondDataList = tmpSecondDataList
+			}
+		}
+
+		//待插入数据
+		for _, v := range secondDataList {
+			//时间戳
+			currentDate, _ := time.Parse(utils.FormatDate, v.DataTime)
+			timestamp := currentDate.UnixNano() / 1e6
+
+			edbDataZjpj := &EdbDataCalculateZjpj{
+				EdbInfoId:     edbInfoId,
+				EdbCode:       nowEdbInfo.EdbCode,
+				DataTime:      v.DataTime,
+				Value:         v.Value,
+				Status:        1,
+				CreateTime:    time.Now(),
+				ModifyTime:    time.Now(),
+				DataTimestamp: timestamp,
+			}
+			addDataList = append(addDataList, edbDataZjpj)
+		}
+	}
+
+	//数据入库
+	tmpAddDataList := make([]*EdbDataCalculateZjpj, 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([]*EdbDataCalculateZjpj, 0)
+		}
+	}
+	//最后如果还有需要新增的数据，那么就统一入库
+	if len(tmpAddDataList) > 0 {
+		_, tmpErr := to.InsertMulti(len(tmpAddDataList), tmpAddDataList)
+		if tmpErr != nil {
+			err = tmpErr
+			return
+		}
+	}
+
+	return
+}

models/data_manage/predict_edb_conf.go

@@ -187,3 +187,13 @@ func GetPredictEdbConfListById(edbInfoId int) (items []*PredictEdbConf, err erro
 	_, err = o.Raw(sql, edbInfoId).QueryRows(&items)
 	return
 }
+
+// GetGroupPredictEdbBySourceEdbInfoId 根据来源指标id获取配置
+func GetGroupPredictEdbBySourceEdbInfoId(sourceEdbInfoId int) (items []*EdbInfo, err error) {
+	o := orm.NewOrmUsingDB("data")
+	sql := ` SELECT a.* FROM edb_info AS a 
+     JOIN predict_edb_conf AS b  on a.edb_info_id = b.predict_edb_info_id
+          WHERE b.source_edb_info_id=? group by a.edb_info_id`
+	_, err = o.Raw(sql, sourceEdbInfoId).QueryRows(&items)
+	return
+}

routers/commentsRouter.go

@@ -349,6 +349,15 @@ func init() {
             Filters: nil,
             Params: nil})
 
+    beego.GlobalControllerRouter["eta/eta_mobile/controllers/data_manage:ChartInfoController"] = append(beego.GlobalControllerRouter["eta/eta_mobile/controllers/data_manage:ChartInfoController"],
+        beego.ControllerComments{
+            Method: "CalculateBatchEdit",
+            Router: `/edb_info/calculate/batch/edit`,
+            AllowHTTPMethods: []string{"post"},
+            MethodParams: param.Make(),
+            Filters: nil,
+            Params: nil})
+
     beego.GlobalControllerRouter["eta/eta_mobile/controllers/data_manage:ChartInfoController"] = append(beego.GlobalControllerRouter["eta/eta_mobile/controllers/data_manage:ChartInfoController"],
         beego.ControllerComments{
             Method: "CalculateBatchReset",
@@ -358,6 +367,60 @@ func init() {
             Filters: nil,
             Params: nil})
 
+    beego.GlobalControllerRouter["eta/eta_mobile/controllers/data_manage:ChartInfoController"] = append(beego.GlobalControllerRouter["eta/eta_mobile/controllers/data_manage:ChartInfoController"],
+        beego.ControllerComments{
+            Method: "CalculateBatchSave",
+            Router: `/edb_info/calculate/batch/save`,
+            AllowHTTPMethods: []string{"post"},
+            MethodParams: param.Make(),
+            Filters: nil,
+            Params: nil})
+
+    beego.GlobalControllerRouter["eta/eta_mobile/controllers/data_manage:ChartInfoController"] = append(beego.GlobalControllerRouter["eta/eta_mobile/controllers/data_manage:ChartInfoController"],
+        beego.ControllerComments{
+            Method: "BatchCalculateBatchSave",
+            Router: `/edb_info/calculate/batch/save/batch`,
+            AllowHTTPMethods: []string{"post"},
+            MethodParams: param.Make(),
+            Filters: nil,
+            Params: nil})
+
+    beego.GlobalControllerRouter["eta/eta_mobile/controllers/data_manage:ChartInfoController"] = append(beego.GlobalControllerRouter["eta/eta_mobile/controllers/data_manage:ChartInfoController"],
+        beego.ControllerComments{
+            Method: "CalculateComputeCorrelation",
+            Router: `/edb_info/calculate/compute_correlation`,
+            AllowHTTPMethods: []string{"post"},
+            MethodParams: param.Make(),
+            Filters: nil,
+            Params: nil})
+
+    beego.GlobalControllerRouter["eta/eta_mobile/controllers/data_manage:ChartInfoController"] = append(beego.GlobalControllerRouter["eta/eta_mobile/controllers/data_manage:ChartInfoController"],
+        beego.ControllerComments{
+            Method: "CalculateDetail",
+            Router: `/edb_info/calculate/detail`,
+            AllowHTTPMethods: []string{"get"},
+            MethodParams: param.Make(),
+            Filters: nil,
+            Params: nil})
+
+    beego.GlobalControllerRouter["eta/eta_mobile/controllers/data_manage:ChartInfoController"] = append(beego.GlobalControllerRouter["eta/eta_mobile/controllers/data_manage:ChartInfoController"],
+        beego.ControllerComments{
+            Method: "CalculateEdit",
+            Router: `/edb_info/calculate/edit`,
+            AllowHTTPMethods: []string{"post"},
+            MethodParams: param.Make(),
+            Filters: nil,
+            Params: nil})
+
+    beego.GlobalControllerRouter["eta/eta_mobile/controllers/data_manage:ChartInfoController"] = append(beego.GlobalControllerRouter["eta/eta_mobile/controllers/data_manage:ChartInfoController"],
+        beego.ControllerComments{
+            Method: "CalculateSave",
+            Router: `/edb_info/calculate/save`,
+            AllowHTTPMethods: []string{"post"},
+            MethodParams: param.Make(),
+            Filters: nil,
+            Params: nil})
+
     beego.GlobalControllerRouter["eta/eta_mobile/controllers/data_manage:ChartInfoController"] = append(beego.GlobalControllerRouter["eta/eta_mobile/controllers/data_manage:ChartInfoController"],
         beego.ControllerComments{
             Method: "EdbInfoData",
@@ -385,6 +448,15 @@ func init() {
             Filters: nil,
             Params: nil})
 
+    beego.GlobalControllerRouter["eta/eta_mobile/controllers/data_manage:ChartInfoController"] = append(beego.GlobalControllerRouter["eta/eta_mobile/controllers/data_manage:ChartInfoController"],
+        beego.ControllerComments{
+            Method: "EdbInfoReplace",
+            Router: `/edb_info/replace`,
+            AllowHTTPMethods: []string{"post"},
+            MethodParams: param.Make(),
+            Filters: nil,
+            Params: nil})
+
     beego.GlobalControllerRouter["eta/eta_mobile/controllers/data_manage:EdbClassifyController"] = append(beego.GlobalControllerRouter["eta/eta_mobile/controllers/data_manage:EdbClassifyController"],
         beego.ControllerComments{
             Method: "AddEdbClassify",

services/data/base_edb_lib.go

@@ -3,6 +3,7 @@ package data
 import (
 	"encoding/json"
 	"eta/eta_mobile/models"
+	"eta/eta_mobile/models/data_manage"
 	"eta/eta_mobile/utils"
 	"fmt"
 	"io/ioutil"
@@ -74,6 +75,17 @@ func AddEdbData(source int, edbCode string) (resp *models.BaseResponse, err erro
 	return
 }
 
+type AddPredictEdbDataResponse struct {
+	Ret         int
+	Msg         string
+	ErrMsg      string
+	ErrCode     string
+	Data        data_manage.AddEdbInfoResp
+	Success     bool `description:"true 执行成功，false 执行失败"`
+	IsSendEmail bool `json:"-" description:"true 发送邮件，false 不发送邮件"`
+	IsAddLog    bool `json:"-" description:"true 新增操作日志，false 不新增操作日志" `
+}
+
 // RefreshEdbData 刷新指标数据
 func RefreshEdbData(edbInfoId, source int, edbCode, startDate string) (resp *models.BaseResponse, err error) {
 	param := make(map[string]interface{})
@@ -163,6 +175,68 @@ func RefreshPredictEdbCalculateData(edbInfoId int, edbCode, startDate string) (r
 	return
 }
 
+// AddEdbCalculateData 新增 累计值转月-同比值-同差等计算新增
+func AddEdbCalculateData(edbInfoCalculateBatchSaveReqStr string) (resp *AddPredictEdbDataResponse, err error) {
+	_, resultByte, err := postAddEdbData(edbInfoCalculateBatchSaveReqStr, "calculate/add")
+	err = json.Unmarshal(resultByte, &resp)
+	if err != nil {
+		return
+	}
+	return
+}
+
+// EditEdbCalculateData 编辑 累计值转月-同比值-同差等计算新增
+func EditEdbCalculateData(edbInfoCalculateBatchSaveReqStr string) (resp *AddPredictEdbDataResponse, err error) {
+	_, resultByte, err := postAddEdbData(edbInfoCalculateBatchSaveReqStr, "calculate/edit")
+	err = json.Unmarshal(resultByte, &resp)
+	if err != nil {
+		return
+	}
+	return
+}
+
+// BatchSaveEdbCalculateData 新增 累计值转月-同比值-同差等计算新增
+func BatchSaveEdbCalculateData(edbInfoCalculateBatchSaveReqStr string) (resp *AddPredictEdbDataResponse, err error) {
+	_, resultByte, err := postAddEdbData(edbInfoCalculateBatchSaveReqStr, "calculate/batch/save")
+	err = json.Unmarshal(resultByte, &resp)
+	if err != nil {
+		return
+	}
+	return
+}
+
+// BatchEditEdbCalculateData 编辑 累计值转月-同比值-同差等计算新增
+func BatchEditEdbCalculateData(edbInfoCalculateBatchSaveReqStr string) (resp *AddPredictEdbDataResponse, err error) {
+	_, resultByte, err := postAddEdbData(edbInfoCalculateBatchSaveReqStr, "calculate/batch/edit")
+	err = json.Unmarshal(resultByte, &resp)
+	if err != nil {
+		return
+	}
+	return
+}
+
+// CalculateComputeCorrelationResp 拟合残差计算相关性的值返回
+type CalculateComputeCorrelationResp struct {
+	Ret         int
+	Msg         string
+	ErrMsg      string
+	ErrCode     string
+	Data        float64
+	Success     bool `description:"true 执行成功，false 执行失败"`
+	IsSendEmail bool `json:"-" description:"true 发送邮件，false 不发送邮件"`
+	IsAddLog    bool `json:"-" description:"true 新增操作日志，false 不新增操作日志" `
+}
+
+// CalculateComputeCorrelation 拟合残差计算相关性的值
+func CalculateComputeCorrelation(edbInfoCalculateBatchSaveReqStr string) (resp *CalculateComputeCorrelationResp, err error) {
+	_, resultByte, err := postAddEdbData(edbInfoCalculateBatchSaveReqStr, "calculate/compute_correlation")
+	err = json.Unmarshal(resultByte, &resp)
+	if err != nil {
+		return
+	}
+	return
+}
+
 // postRefreshEdbData 刷新指标数据
 func postRefreshEdbData(param map[string]interface{}, urlStr string) (resp *models.BaseResponse, err error) {
 	postUrl := utils.EDB_LIB_URL + urlStr
@@ -182,6 +256,21 @@ func postRefreshEdbData(param map[string]interface{}, urlStr string) (resp *mode
 	return resp, nil
 }
 
+// postAddEdbData 新增指标数据
+func postAddEdbData(paramStr string, urlStr string) (resp *models.BaseResponse, result []byte, err error) {
+	postUrl := utils.EDB_LIB_URL + urlStr
+	result, err = HttpPost(postUrl, paramStr, "application/json")
+	if err != nil {
+		return
+	}
+	err = json.Unmarshal(result, &resp)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
 func HttpPost(url, postData string, params ...string) ([]byte, error) {
 	body := ioutil.NopCloser(strings.NewReader(postData))
 	client := &http.Client{}

services/data/edb_info_calculate.go

@@ -0,0 +1,685 @@
+package data
+
+import (
+	"errors"
+	"eta/eta_mobile/models/data_manage"
+	"eta/eta_mobile/utils"
+	"fmt"
+	"github.com/shopspring/decimal"
+	"github.com/yidane/formula"
+	"math"
+	"strconv"
+	"strings"
+	"time"
+)
+
+func CheckFormula(formula string) map[string]string {
+	mathFormula := []string{"MAX", "MIN", "ABS", "ACOS", "ASIN", "CEIL", "MOD", "POW", "ROUND", "SIGN", "SIN", "TAN", "LOG10", "LOG2", "LOG", "LN"}
+
+	str := strings.ToUpper(formula)
+	for _, v := range mathFormula {
+		str = strings.Replace(str, v, "", -1)
+	}
+	str = strings.Replace(str, "(", "", -1)
+	str = strings.Replace(str, ")", "", -1)
+
+	byteMap := make(map[string]string)
+	for i := 0; i < len(str); i++ {
+		byteInt := str[i]
+		if byteInt >= 65 && byteInt <= 90 {
+			byteStr := string(byteInt)
+			if _, ok := byteMap[byteStr]; !ok {
+				byteMap[byteStr] = byteStr
+			}
+		}
+	}
+	return byteMap
+}
+
+// CheckFormula2 校验公式是否正常（比如说除法的分母不能为0之类的，实际上就是用预设的字段数据做一次计算）
+func CheckFormula2(edbInfoArr []*data_manage.EdbInfo, formulaMap map[string]string, formulaStr string, edbInfoIdBytes []string) (ok bool, err error) {
+	valArr := make(map[int]float64)
+	for _, v := range edbInfoArr {
+		valArr[v.EdbInfoId] = 100
+	}
+	formulaStr = strings.ToUpper(formulaStr)
+	formulaFormStr := ReplaceFormula(edbInfoArr, valArr, formulaMap, formulaStr, edbInfoIdBytes)
+	if formulaFormStr == "" {
+		return
+	}
+	expression := formula.NewExpression(formulaFormStr)
+	_, err = expression.Evaluate()
+	if err != nil {
+	} else {
+		ok = true
+	}
+	return
+}
+
+type CalculateItems struct {
+	EdbInfoId int
+	DataMap   map[string]float64
+}
+
+func Calculate(edbInfoIdArr []*data_manage.EdbInfo, edbInfoId int, edbCode, formulaStr string, edbInfoIdBytes []string) (err error) {
+	defer func() {
+		if err != nil {
+			utils.FileLog.Info("Calculate Err:%s" + err.Error())
+		}
+	}()
+	saveDataMap := make(map[string]map[int]float64)
+	for _, v := range edbInfoIdArr {
+		var condition string
+		var pars []interface{}
+		condition += " AND edb_info_id=? "
+		pars = append(pars, v.EdbInfoId)
+		dataList, err := data_manage.GetEdbDataListAll(condition, pars, v.Source, 1)
+		if err != nil {
+			return err
+		}
+		dataMap := make(map[string]float64)
+		for _, dv := range dataList {
+			if val, ok := saveDataMap[dv.DataTime]; ok {
+				if _, ok := val[v.EdbInfoId]; !ok {
+					val[v.EdbInfoId] = dv.Value
+				}
+			} else {
+				temp := make(map[int]float64)
+				temp[v.EdbInfoId] = dv.Value
+				saveDataMap[dv.DataTime] = temp
+			}
+		}
+		item := new(CalculateItems)
+		item.EdbInfoId = v.EdbInfoId
+		item.DataMap = dataMap
+	}
+	formulaMap := CheckFormula(formulaStr)
+	addSql := ` INSERT INTO edb_data_calculate(edb_info_id,edb_code,data_time,value,create_time,modify_time,status,data_timestamp) values `
+	nowStr := time.Now().Format(utils.FormatDateTime)
+	var isAdd bool
+	for sk, sv := range saveDataMap {
+		formulaStr = strings.ToUpper(formulaStr)
+		formulaFormStr := ReplaceFormula(edbInfoIdArr, sv, formulaMap, formulaStr, edbInfoIdBytes)
+		if formulaStr == "" {
+			return
+		}
+		if formulaFormStr != "" {
+			expression := formula.NewExpression(formulaFormStr)
+			calResult, err := expression.Evaluate()
+			if err != nil {
+				err = errors.New("计算失败：Err:" + err.Error() + ";formulaStr:" + formulaFormStr)
+				fmt.Println(err)
+				return err
+			}
+			calVal, err := calResult.Float64()
+			if err != nil {
+				err = errors.New("计算失败：获取计算值失败 Err:" + err.Error() + ";formulaStr:" + formulaFormStr)
+				fmt.Println(err)
+				return err
+			}
+
+			//需要存入的数据
+			{
+				dataTime, _ := time.Parse(utils.FormatDate, sk)
+				timestamp := dataTime.UnixNano() / 1e6
+				timeStr := fmt.Sprintf("%d", timestamp)
+				addSql += "("
+				addSql += strconv.Itoa(edbInfoId) + "," + "'" + edbCode + "'" + "," + "'" + sk + "'" + "," + utils.SubFloatToString(calVal, 4) + "," + "'" + nowStr + "'" +
+					"," + "'" + nowStr + "'" + "," + "1"
+				addSql += "," + "'" + timeStr + "'"
+				addSql += "),"
+				isAdd = true
+			}
+		} else {
+			fmt.Println("formulaFormStr is empty")
+		}
+	}
+	if isAdd {
+		addSql = strings.TrimRight(addSql, ",")
+		data_manage.AddEdbDataCalculateBySql(addSql)
+		if err != nil {
+			fmt.Println("AddEdbDataCalculate Err:" + err.Error())
+			return err
+		}
+	}
+	return
+}
+
+func ReplaceFormula(edbInfoIdArr []*data_manage.EdbInfo, valArr map[int]float64, formulaMap map[string]string, formulaStr string, edbInfoIdBytes []string) string {
+	funMap := GetFormulaMap()
+	for k, v := range funMap {
+		formulaStr = strings.Replace(formulaStr, k, v, -1)
+	}
+	replaceCount := 0
+	for dk, dv := range edbInfoIdArr {
+		if dk == 0 {
+			dKey := edbInfoIdBytes[dk]
+			if _, ok := formulaMap[dKey]; ok { //公式中存在
+				if val, valOk := valArr[dv.EdbInfoId]; valOk { //值存在
+					dvStr := fmt.Sprintf("%v", val)
+					formulaStr = strings.Replace(formulaStr, dKey, dvStr, -1)
+					replaceCount++
+				} else {
+					fmt.Println("valArr not found:", valArr, valOk)
+				}
+			} else {
+				fmt.Println("formulaMap not found:", dKey, dk)
+			}
+		}
+		if dk == 1 {
+			dKey := edbInfoIdBytes[dk]
+			if _, ok := formulaMap[dKey]; ok { //公式中存在
+				if val, valOk := valArr[dv.EdbInfoId]; valOk { //值存在
+					dvStr := fmt.Sprintf("%v", val)
+					formulaStr = strings.Replace(formulaStr, dKey, dvStr, -1)
+					replaceCount++
+				} else {
+					fmt.Println("valArr not found:", valArr, valOk)
+				}
+			} else {
+				fmt.Println("formulaMap not found:", dKey, dk)
+			}
+		}
+		if dk == 2 {
+			dKey := edbInfoIdBytes[dk]
+			if _, ok := formulaMap[dKey]; ok { //公式中存在
+				if val, valOk := valArr[dv.EdbInfoId]; valOk { //值存在
+					dvStr := fmt.Sprintf("%v", val)
+					formulaStr = strings.Replace(formulaStr, dKey, dvStr, -1)
+					replaceCount++
+				}
+			}
+		}
+		if dk == 3 {
+			dKey := edbInfoIdBytes[dk]
+			if _, ok := formulaMap[dKey]; ok { //公式中存在
+				if val, valOk := valArr[dv.EdbInfoId]; valOk { //值存在
+					dvStr := fmt.Sprintf("%v", val)
+					formulaStr = strings.Replace(formulaStr, dKey, dvStr, -1)
+					replaceCount++
+				}
+			}
+		}
+		if dk == 4 {
+			dKey := edbInfoIdBytes[dk]
+			if _, ok := formulaMap[dKey]; ok { //公式中存在
+				if val, valOk := valArr[dv.EdbInfoId]; valOk { //值存在
+					dvStr := fmt.Sprintf("%v", val)
+					formulaStr = strings.Replace(formulaStr, dKey, dvStr, -1)
+					replaceCount++
+				}
+			}
+		}
+		if dk == 5 {
+			dKey := edbInfoIdBytes[dk]
+			if _, ok := formulaMap[dKey]; ok { //公式中存在
+				if val, valOk := valArr[dv.EdbInfoId]; valOk { //值存在
+					dvStr := fmt.Sprintf("%v", val)
+					formulaStr = strings.Replace(formulaStr, dKey, dvStr, -1)
+					replaceCount++
+				}
+			}
+		}
+		if dk == 6 {
+			dKey := edbInfoIdBytes[dk]
+			if _, ok := formulaMap[dKey]; ok { //公式中存在
+				if val, valOk := valArr[dv.EdbInfoId]; valOk { //值存在
+					dvStr := fmt.Sprintf("%v", val)
+					formulaStr = strings.Replace(formulaStr, dKey, dvStr, -1)
+					replaceCount++
+				}
+			}
+		}
+		if dk == 7 {
+			dKey := edbInfoIdBytes[dk]
+			if _, ok := formulaMap[dKey]; ok { //公式中存在
+				if val, valOk := valArr[dv.EdbInfoId]; valOk { //值存在
+					dvStr := fmt.Sprintf("%v", val)
+					formulaStr = strings.Replace(formulaStr, dKey, dvStr, -1)
+					replaceCount++
+				}
+			}
+		}
+		if dk == 8 {
+			dKey := edbInfoIdBytes[dk]
+			if _, ok := formulaMap[dKey]; ok { //公式中存在
+				if val, valOk := valArr[dv.EdbInfoId]; valOk { //值存在
+					dvStr := fmt.Sprintf("%v", val)
+					formulaStr = strings.Replace(formulaStr, dKey, dvStr, -1)
+					replaceCount++
+				}
+			}
+		}
+		if dk == 9 {
+			dKey := edbInfoIdBytes[dk]
+			if _, ok := formulaMap[dKey]; ok { //公式中存在
+				if val, valOk := valArr[dv.EdbInfoId]; valOk { //值存在
+					dvStr := fmt.Sprintf("%v", val)
+					formulaStr = strings.Replace(formulaStr, dKey, dvStr, -1)
+					replaceCount++
+				}
+			}
+		}
+		if dk == 10 {
+			dKey := edbInfoIdBytes[dk]
+			if _, ok := formulaMap[dKey]; ok { //公式中存在
+				if val, valOk := valArr[dv.EdbInfoId]; valOk { //值存在
+					dvStr := fmt.Sprintf("%v", val)
+					formulaStr = strings.Replace(formulaStr, dKey, dvStr, -1)
+					replaceCount++
+				}
+			}
+		}
+		if dk == 11 {
+			dKey := edbInfoIdBytes[dk]
+			if _, ok := formulaMap[dKey]; ok { //公式中存在
+				if val, valOk := valArr[dv.EdbInfoId]; valOk { //值存在
+					dvStr := fmt.Sprintf("%v", val)
+					formulaStr = strings.Replace(formulaStr, dKey, dvStr, -1)
+					replaceCount++
+				}
+			}
+		}
+		if dk == 12 {
+			dKey := edbInfoIdBytes[dk]
+			if _, ok := formulaMap[dKey]; ok { //公式中存在
+				if val, valOk := valArr[dv.EdbInfoId]; valOk { //值存在
+					dvStr := fmt.Sprintf("%v", val)
+					formulaStr = strings.Replace(formulaStr, dKey, dvStr, -1)
+					replaceCount++
+				}
+			}
+		}
+		if dk == 13 {
+			dKey := edbInfoIdBytes[dk]
+			if _, ok := formulaMap[dKey]; ok { //公式中存在
+				if val, valOk := valArr[dv.EdbInfoId]; valOk { //值存在
+					dvStr := fmt.Sprintf("%v", val)
+					formulaStr = strings.Replace(formulaStr, dKey, dvStr, -1)
+					replaceCount++
+				}
+			}
+		}
+		if dk == 14 {
+			dKey := edbInfoIdBytes[dk]
+			if _, ok := formulaMap[dKey]; ok { //公式中存在
+				if val, valOk := valArr[dv.EdbInfoId]; valOk { //值存在
+					dvStr := fmt.Sprintf("%v", val)
+					formulaStr = strings.Replace(formulaStr, dKey, dvStr, -1)
+					replaceCount++
+				}
+			}
+		}
+		if dk == 15 {
+			dKey := edbInfoIdBytes[dk]
+			if _, ok := formulaMap[dKey]; ok { //公式中存在
+				if val, valOk := valArr[dv.EdbInfoId]; valOk { //值存在
+					dvStr := fmt.Sprintf("%v", val)
+					formulaStr = strings.Replace(formulaStr, dKey, dvStr, -1)
+					replaceCount++
+				}
+			}
+		}
+		if dk == 16 {
+			dKey := edbInfoIdBytes[dk]
+			if _, ok := formulaMap[dKey]; ok { //公式中存在
+				if val, valOk := valArr[dv.EdbInfoId]; valOk { //值存在
+					dvStr := fmt.Sprintf("%v", val)
+					formulaStr = strings.Replace(formulaStr, dKey, dvStr, -1)
+					replaceCount++
+				}
+			}
+		}
+		if dk == 17 {
+			dKey := edbInfoIdBytes[dk]
+			if _, ok := formulaMap[dKey]; ok { //公式中存在
+				if val, valOk := valArr[dv.EdbInfoId]; valOk { //值存在
+					dvStr := fmt.Sprintf("%v", val)
+					formulaStr = strings.Replace(formulaStr, dKey, dvStr, -1)
+					replaceCount++
+				}
+			}
+		}
+		if dk == 18 {
+			dKey := edbInfoIdBytes[dk]
+			if _, ok := formulaMap[dKey]; ok { //公式中存在
+				if val, valOk := valArr[dv.EdbInfoId]; valOk { //值存在
+					dvStr := fmt.Sprintf("%v", val)
+					formulaStr = strings.Replace(formulaStr, dKey, dvStr, -1)
+					replaceCount++
+				}
+			}
+		}
+		if dk == 19 {
+			dKey := edbInfoIdBytes[dk]
+			if _, ok := formulaMap[dKey]; ok { //公式中存在
+				if val, valOk := valArr[dv.EdbInfoId]; valOk { //值存在
+					dvStr := fmt.Sprintf("%v", val)
+					formulaStr = strings.Replace(formulaStr, dKey, dvStr, -1)
+					replaceCount++
+				}
+			}
+		}
+		if dk == 20 {
+			dKey := edbInfoIdBytes[dk]
+			if _, ok := formulaMap[dKey]; ok { //公式中存在
+				if val, valOk := valArr[dv.EdbInfoId]; valOk { //值存在
+					dvStr := fmt.Sprintf("%v", val)
+					formulaStr = strings.Replace(formulaStr, dKey, dvStr, -1)
+					replaceCount++
+				}
+			}
+		}
+		if dk == 21 {
+			dKey := edbInfoIdBytes[dk]
+			if _, ok := formulaMap[dKey]; ok { //公式中存在
+				if val, valOk := valArr[dv.EdbInfoId]; valOk { //值存在
+					dvStr := fmt.Sprintf("%v", val)
+					formulaStr = strings.Replace(formulaStr, dKey, dvStr, -1)
+					replaceCount++
+				}
+			}
+		}
+		if dk == 22 {
+			dKey := edbInfoIdBytes[dk]
+			if _, ok := formulaMap[dKey]; ok { //公式中存在
+				if val, valOk := valArr[dv.EdbInfoId]; valOk { //值存在
+					dvStr := fmt.Sprintf("%v", val)
+					formulaStr = strings.Replace(formulaStr, dKey, dvStr, -1)
+					replaceCount++
+				}
+			}
+		}
+		if dk == 23 {
+			dKey := edbInfoIdBytes[dk]
+			if _, ok := formulaMap[dKey]; ok { //公式中存在
+				if val, valOk := valArr[dv.EdbInfoId]; valOk { //值存在
+					dvStr := fmt.Sprintf("%v", val)
+					formulaStr = strings.Replace(formulaStr, dKey, dvStr, -1)
+					replaceCount++
+				}
+			}
+		}
+		if dk == 24 {
+			dKey := edbInfoIdBytes[dk]
+			if _, ok := formulaMap[dKey]; ok { //公式中存在
+				if val, valOk := valArr[dv.EdbInfoId]; valOk { //值存在
+					dvStr := fmt.Sprintf("%v", val)
+					formulaStr = strings.Replace(formulaStr, dKey, dvStr, -1)
+					replaceCount++
+				}
+			}
+		}
+		if dk == 25 {
+			dKey := edbInfoIdBytes[dk]
+			if _, ok := formulaMap[dKey]; ok { //公式中存在
+				if val, valOk := valArr[dv.EdbInfoId]; valOk { //值存在
+					dvStr := fmt.Sprintf("%v", val)
+					formulaStr = strings.Replace(formulaStr, dKey, dvStr, -1)
+					replaceCount++
+				}
+			}
+		}
+	}
+	for k, v := range funMap {
+		formulaStr = strings.Replace(formulaStr, v, k, -1)
+	}
+	if replaceCount == len(formulaMap) {
+		return formulaStr
+	} else {
+		return ""
+	}
+}
+
+func GetFormulaMap() map[string]string {
+	funMap := make(map[string]string)
+	funMap["MAX"] = "[@@]"
+	funMap["MIN"] = "[@!]"
+	funMap["ABS"] = "[@#]"
+	funMap["CEIL"] = "[@$]"
+	funMap["COS"] = "[@%]"
+	funMap["FLOOR"] = "[@^]"
+	funMap["MOD"] = "[@&]"
+	funMap["POW"] = "[@*]"
+	funMap["ROUND"] = "[@(]"
+	return funMap
+}
+
+// 刷新数据
+func RefreshCalculate(edbInfoIdArr []*data_manage.EdbInfo, edbInfoId int, edbCode, formulaStr, startDate, endDate string, edbInfoIdBytes []string) (err error) {
+	defer func() {
+		if err != nil {
+			fmt.Println("RefreshCalculate:Err " + err.Error())
+			utils.FileLog.Info("Calculate Err:%s" + err.Error())
+		}
+	}()
+	saveDataMap := make(map[string]map[int]float64)
+	for _, v := range edbInfoIdArr {
+		var condition string
+		var pars []interface{}
+		condition += " AND edb_info_id=? "
+		pars = append(pars, v.EdbInfoId)
+		if startDate != "" {
+			condition += " AND data_time>=? "
+			pars = append(pars, startDate)
+		}
+		if endDate != "" {
+			condition += " AND data_time<=? "
+			pars = append(pars, endDate)
+		}
+		dataList, err := data_manage.GetEdbDataListAll(condition, pars, v.Source, 1)
+		if err != nil {
+			return err
+		}
+		dataMap := make(map[string]float64)
+		for _, dv := range dataList {
+			if val, ok := saveDataMap[dv.DataTime]; ok {
+				if _, ok := val[v.EdbInfoId]; !ok {
+					val[v.EdbInfoId] = dv.Value
+				}
+			} else {
+				temp := make(map[int]float64)
+				temp[v.EdbInfoId] = dv.Value
+				saveDataMap[dv.DataTime] = temp
+			}
+		}
+		item := new(CalculateItems)
+		item.EdbInfoId = v.EdbInfoId
+		item.DataMap = dataMap
+	}
+
+	formulaMap := CheckFormula(formulaStr)
+	addSql := ` INSERT INTO edb_data_calculate(edb_info_id,edb_code,data_time,value,create_time,modify_time,status,data_timestamp) values `
+	nowStr := time.Now().Format(utils.FormatDateTime)
+	var isAdd bool
+
+	for sk, sv := range saveDataMap {
+		formulaStr = strings.ToUpper(formulaStr)
+		formulaFormStr := ReplaceFormula(edbInfoIdArr, sv, formulaMap, formulaStr, edbInfoIdBytes)
+		if formulaFormStr != "" {
+			utils.FileLog.Info("formulaFormStr:%s", formulaFormStr)
+			expression := formula.NewExpression(formulaFormStr)
+			calResult, err := expression.Evaluate()
+			if err != nil {
+				err = errors.New("计算失败：Err:" + err.Error() + ";formulaStr:" + formulaFormStr)
+				fmt.Println(err)
+				return err
+			}
+			calVal, err := calResult.Float64()
+			if err != nil {
+				err = errors.New("计算失败：获取计算值失败 Err:" + err.Error() + ";formulaStr:" + formulaFormStr)
+				fmt.Println(err)
+				return err
+			}
+
+			count, err := data_manage.GetEdbDataCalculateByCodeAndDate(edbCode, sk)
+			if err != nil && err.Error() != utils.ErrNoRow() {
+				return err
+			}
+			if count <= 0 { //需要存入的数据
+				dataTime, _ := time.Parse(utils.FormatDate, sk)
+				timestamp := dataTime.UnixNano() / 1e6
+				timeStr := fmt.Sprintf("%d", timestamp)
+				addSql += "("
+				addSql += strconv.Itoa(edbInfoId) + "," + "'" + edbCode + "'" + "," + "'" + sk + "'" + "," + utils.SubFloatToString(calVal, 4) + "," + "'" + nowStr + "'" +
+					"," + "'" + nowStr + "'" + "," + "1"
+				addSql += "," + "'" + timeStr + "'"
+				addSql += "),"
+				isAdd = true
+			} else {
+				calVal = utils.FixFloat(calVal, 4)
+				err = data_manage.ModifyEdbDataCalculate(int64(edbInfoId), sk, calVal)
+				if err != nil {
+					return err
+				}
+			}
+		}
+	}
+	if isAdd {
+		addSql = strings.TrimRight(addSql, ",")
+		data_manage.AddEdbDataCalculateBySql(addSql)
+		if err != nil {
+			fmt.Println("AddEdbDataCalculate Err:" + err.Error())
+			return err
+		}
+	}
+	return
+}
+
+// 处理整个数据
+func handleDateSaveDataMap(dateList []string, realSaveDataMap, saveDataMap map[string]map[int]float64, edbInfoIdArr []*data_manage.EdbInfo) {
+	for _, date := range dateList {
+		tmpDataMap := realSaveDataMap[date]
+		for _, edbInfo := range edbInfoIdArr {
+			tmpEdbInfoId := edbInfo.EdbInfoId // 当前指标id
+			// 如果该日期不存在该指标数据，那么需要找寻前后日期的数据，进行填补
+			if _, ok := tmpDataMap[tmpEdbInfoId]; !ok {
+				//day := 0
+				//switch edbInfo.Frequency {
+				//case "周度":
+				//	day = 7
+				//case "旬度":
+				//	day = 15
+				//case "月度":
+				//	day = 30
+				//case "季度":
+				//	day = 90
+				//case "年度":
+				//	day = 365
+				//}
+				// 需求池 255 指标运算文案修改，补数据遍历区间修改（2023-3-7 09:37:23修改）
+				day := 35
+				handleDateDataMap(realSaveDataMap, saveDataMap, date, tmpEdbInfoId, day)
+			}
+		}
+	}
+}
+
+// handleDataMap 处理单个日期的数据
+func handleDateDataMap(realSaveDataMap, saveDataMap map[string]map[int]float64, date string, edbInfoId, day int) {
+	currDate, _ := time.ParseInLocation(utils.FormatDate, date, time.Local)
+
+	// 后一天
+	nextDateDayStr := currDate.AddDate(0, 0, 1).Format(utils.FormatDate)
+
+	// 前一天
+	preDateDayStr := currDate.AddDate(0, 0, -1).Format(utils.FormatDate)
+
+	for i := 1; i <= day; i++ {
+
+		// 下个日期的数据
+		{
+			if i >= 1 {
+				nextDateDayStr = currDate.AddDate(0, 0, i).Format(utils.FormatDate)
+			}
+			if findDataMap, hasFindDataMap := realSaveDataMap[nextDateDayStr]; hasFindDataMap { // 下一个日期有数据
+				if val, hasFindItem := findDataMap[edbInfoId]; hasFindItem {
+					saveDataMap[date][edbInfoId] = val
+					return
+				}
+			}
+		}
+
+		// 上个日期的数据
+		{
+			if i >= 1 {
+				preDateDayStr = currDate.AddDate(0, 0, -i).Format(utils.FormatDate)
+			}
+			if findDataMap, hasFindDataMap := realSaveDataMap[preDateDayStr]; hasFindDataMap { // 下一个日期有数据
+				if val, hasFindItem := findDataMap[edbInfoId]; hasFindItem {
+					saveDataMap[date][edbInfoId] = val
+					return
+				}
+			}
+		}
+	}
+}
+
+// handleDataByLinearRegression 插值法补充数据(线性方程式)
+func handleDataByLinearRegression(edbInfoDataList []*data_manage.EdbDataList, handleDataMap map[string]float64) (err error) {
+	if len(edbInfoDataList) < 2 {
+		return
+	}
+
+	var startEdbInfoData *data_manage.EdbDataList
+	for _, v := range edbInfoDataList {
+		handleDataMap[v.DataTime] = v.Value
+
+		// 第一个数据就给过滤了,给后面的试用
+		if startEdbInfoData == nil {
+			startEdbInfoData = v
+			continue
+		}
+
+		// 获取两条数据之间相差的天数
+		startDataTime, _ := time.ParseInLocation(utils.FormatDate, startEdbInfoData.DataTime, time.Local)
+		currDataTime, _ := time.ParseInLocation(utils.FormatDate, v.DataTime, time.Local)
+		betweenHour := int(currDataTime.Sub(startDataTime).Hours())
+		betweenDay := betweenHour / 24
+
+		// 如果相差一天,那么过滤
+		if betweenDay <= 1 {
+			startEdbInfoData = v
+			continue
+		}
+
+		// 生成线性方程式
+		var a, b float64
+		{
+			coordinateData := make([]utils.Coordinate, 0)
+			tmpCoordinate1 := utils.Coordinate{
+				X: 1,
+				Y: startEdbInfoData.Value,
+			}
+			coordinateData = append(coordinateData, tmpCoordinate1)
+			tmpCoordinate2 := utils.Coordinate{
+				X: float64(betweenDay) + 1,
+				Y: v.Value,
+			}
+			coordinateData = append(coordinateData, tmpCoordinate2)
+
+			a, b = utils.GetLinearResult(coordinateData)
+			if math.IsNaN(a) || math.IsNaN(b) {
+				err = errors.New("线性方程公式生成失败")
+				return
+			}
+		}
+
+		// 生成对应的值
+		{
+			for i := 1; i < betweenDay; i++ {
+				tmpDataTime := startDataTime.AddDate(0, 0, i)
+				aDecimal := decimal.NewFromFloat(a)
+				xDecimal := decimal.NewFromInt(int64(i) + 1)
+				bDecimal := decimal.NewFromFloat(b)
+
+				val, _ := aDecimal.Mul(xDecimal).Add(bDecimal).Round(4).Float64()
+				handleDataMap[tmpDataTime.Format(utils.FormatDate)] = val
+			}
+		}
+
+		startEdbInfoData = v
+	}
+
+	return
+}

services/data/predict_edb_info.go

@@ -609,3 +609,17 @@ func GetPredictCalculateDataListByPredictEdbInfo(edbInfo *data_manage.EdbInfo, s
 	dataList, err = data_manage.GetEdbDataList(edbInfo.Source, edbInfo.EdbInfoId, startDate, endDate)
 	return
 }
+
+// ModifyPredictEdbBaseInfoBySourceEdb  根据来源ETA指标修改预测指标的基础信息
+func ModifyPredictEdbBaseInfoBySourceEdb(sourceEDdbInfo *data_manage.EdbInfo) {
+	list, err := data_manage.GetGroupPredictEdbBySourceEdbInfoId(sourceEDdbInfo.EdbInfoId)
+	if err != nil {
+		return
+	}
+	for _, v := range list {
+		v.Frequency = sourceEDdbInfo.Frequency
+		v.Unit = sourceEDdbInfo.Unit
+		v.Update([]string{"Frequency", "Unit"})
+		AddOrEditEdbInfoToEs(v.EdbInfoId)
+	}
+}

services/data/predict_edb_info_rule.go

@@ -853,73 +853,73 @@ func GetChartPredictEdbInfoDataListByRuleSeason(edbInfoId int, yearsList []int,
 }
 
 // handleDataByLinearRegression 插值法补充数据(线性方程式)
-func handleDataByLinearRegression(edbInfoDataList []*data_manage.EdbDataList, handleDataMap map[string]float64) (err error) {
-	if len(edbInfoDataList) < 2 {
-		return
-	}
-
-	var startEdbInfoData *data_manage.EdbDataList
-	for _, v := range edbInfoDataList {
-		handleDataMap[v.DataTime] = v.Value
-
-		// 第一个数据就给过滤了,给后面的试用
-		if startEdbInfoData == nil {
-			startEdbInfoData = v
-			continue
-		}
-
-		// 获取两条数据之间相差的天数
-		startDataTime, _ := time.ParseInLocation(utils.FormatDate, startEdbInfoData.DataTime, time.Local)
-		currDataTime, _ := time.ParseInLocation(utils.FormatDate, v.DataTime, time.Local)
-		betweenHour := int(currDataTime.Sub(startDataTime).Hours())
-		betweenDay := betweenHour / 24
-
-		// 如果相差一天,那么过滤
-		if betweenDay <= 1 {
-			startEdbInfoData = v
-			continue
-		}
-
-		// 生成线性方程式
-		var a, b float64
-		{
-			coordinateData := make([]utils.Coordinate, 0)
-			tmpCoordinate1 := utils.Coordinate{
-				X: 1,
-				Y: startEdbInfoData.Value,
-			}
-			coordinateData = append(coordinateData, tmpCoordinate1)
-			tmpCoordinate2 := utils.Coordinate{
-				X: float64(betweenDay) + 1,
-				Y: v.Value,
-			}
-			coordinateData = append(coordinateData, tmpCoordinate2)
-
-			a, b = utils.GetLinearResult(coordinateData)
-			if math.IsNaN(a) || math.IsNaN(b) {
-				err = errors.New("线性方程公式生成失败")
-				return
-			}
-		}
-
-		// 生成对应的值
-		{
-			for i := 1; i < betweenDay; i++ {
-				tmpDataTime := startDataTime.AddDate(0, 0, i)
-				aDecimal := decimal.NewFromFloat(a)
-				xDecimal := decimal.NewFromInt(int64(i) + 1)
-				bDecimal := decimal.NewFromFloat(b)
-
-				val, _ := aDecimal.Mul(xDecimal).Add(bDecimal).Round(4).Float64()
-				handleDataMap[tmpDataTime.Format(utils.FormatDate)] = val
-			}
-		}
-
-		startEdbInfoData = v
-	}
-
-	return
-}
+//func handleDataByLinearRegression(edbInfoDataList []*data_manage.EdbDataList, handleDataMap map[string]float64) (err error) {
+//	if len(edbInfoDataList) < 2 {
+//		return
+//	}
+//
+//	var startEdbInfoData *data_manage.EdbDataList
+//	for _, v := range edbInfoDataList {
+//		handleDataMap[v.DataTime] = v.Value
+//
+//		// 第一个数据就给过滤了,给后面的试用
+//		if startEdbInfoData == nil {
+//			startEdbInfoData = v
+//			continue
+//		}
+//
+//		// 获取两条数据之间相差的天数
+//		startDataTime, _ := time.ParseInLocation(utils.FormatDate, startEdbInfoData.DataTime, time.Local)
+//		currDataTime, _ := time.ParseInLocation(utils.FormatDate, v.DataTime, time.Local)
+//		betweenHour := int(currDataTime.Sub(startDataTime).Hours())
+//		betweenDay := betweenHour / 24
+//
+//		// 如果相差一天,那么过滤
+//		if betweenDay <= 1 {
+//			startEdbInfoData = v
+//			continue
+//		}
+//
+//		// 生成线性方程式
+//		var a, b float64
+//		{
+//			coordinateData := make([]utils.Coordinate, 0)
+//			tmpCoordinate1 := utils.Coordinate{
+//				X: 1,
+//				Y: startEdbInfoData.Value,
+//			}
+//			coordinateData = append(coordinateData, tmpCoordinate1)
+//			tmpCoordinate2 := utils.Coordinate{
+//				X: float64(betweenDay) + 1,
+//				Y: v.Value,
+//			}
+//			coordinateData = append(coordinateData, tmpCoordinate2)
+//
+//			a, b = utils.GetLinearResult(coordinateData)
+//			if math.IsNaN(a) || math.IsNaN(b) {
+//				err = errors.New("线性方程公式生成失败")
+//				return
+//			}
+//		}
+//
+//		// 生成对应的值
+//		{
+//			for i := 1; i < betweenDay; i++ {
+//				tmpDataTime := startDataTime.AddDate(0, 0, i)
+//				aDecimal := decimal.NewFromFloat(a)
+//				xDecimal := decimal.NewFromInt(int64(i) + 1)
+//				bDecimal := decimal.NewFromFloat(b)
+//
+//				val, _ := aDecimal.Mul(xDecimal).Add(bDecimal).Round(4).Float64()
+//				handleDataMap[tmpDataTime.Format(utils.FormatDate)] = val
+//			}
+//		}
+//
+//		startEdbInfoData = v
+//	}
+//
+//	return
+//}
 
 // MoveAverageConf 移动平均同比规则的配置
 type MoveAverageConf struct {