fix

controllers/base_from_business.go

@@ -2,15 +2,17 @@ package controllers
 
 import (
 	"encoding/json"
+	"eta/eta_index_lib/logic"
 	"eta/eta_index_lib/models"
 	"eta/eta_index_lib/services"
 	"eta/eta_index_lib/utils"
 	"fmt"
 	"strconv"
+	"strings"
 	"time"
 )
 
-// BusinessIndexController 钢联化工
+// BusinessIndexController 外部数据（商家）
 type BusinessIndexController struct {
 	BaseAuthController
 }
@@ -48,20 +50,18 @@ func (c *BusinessIndexController) HandleBusinessIndexData() {
 }
 
 // Add
-// @Title 新增钢联化工指标接口
-// @Description 新增钢联化工指标接口
-// @Success 200 {object} models.AddEdbInfoReq
+// @Title 新增外部数据（商家）指标接口
+// @Description 新增外部数据（商家）指标接口
+// @Success 200 {object} models.AddEdbBaseInfoReq
 // @router /add [post]
 func (c *BusinessIndexController) Add() {
 	br := new(models.BaseResponse).Init()
 	var cacheKey string
 	defer func() {
-		utils.Rc.Delete(cacheKey)
 		c.Data["json"] = br
 		c.ServeJSON()
 	}()
-	source := utils.DATA_SOURCE_MYSTEEL_CHEMICAL
-	var req models.AddEdbInfoReq
+	var req models.AddEdbBaseInfoReq
 	err := json.Unmarshal(c.Ctx.Input.RequestBody, &req)
 	if err != nil {
 		br.Msg = "参数解析异常！"
@@ -73,7 +73,7 @@ func (c *BusinessIndexController) Add() {
 		br.ErrMsg = "请输入指标编码，指标编码为空"
 		return
 	}
-	cacheKey = utils.CACHE_EDB_DATA_ADD + strconv.Itoa(source) + "_" + req.EdbCode
+	cacheKey = utils.CACHE_EDB_DATA_ADD + "_BusinessIndexController_" + req.EdbCode
 	if utils.Rc.IsExist(cacheKey) {
 		br.Ret = 501
 		br.Success = true
@@ -82,17 +82,309 @@ func (c *BusinessIndexController) Add() {
 	}
 
 	utils.Rc.SetNX(cacheKey, 1, 1*time.Minute)
-	err = models.AddEdbDataFromMysteelChemical(req.EdbCode)
+	defer func() {
+		_ = utils.Rc.Delete(cacheKey)
+	}()
+
+	baseFromBusinessIndexObj := models.BaseFromBusinessIndex{}
+
+	businessIndexItem, err := baseFromBusinessIndexObj.GetIndexItem(req.EdbCode)
+	if err != nil {
+		br.Msg = "获取数据源中指标信息失败！"
+		br.ErrMsg = "获取数据源中指标信息失败 baseFromBusinessIndexObj.GetIndexItem，Err:" + err.Error()
+		return
+	}
+
+	// 添加指标
+	timestamp := strconv.FormatInt(time.Now().UnixNano(), 10)
+	uniqueCode := utils.MD5(utils.DATA_PREFIX + "_" + timestamp)
+	params := models.AddBaseParams{
+		EdbCode:         req.EdbCode,
+		EdbName:         req.EdbName,
+		Unit:            req.Unit,
+		ClassifyId:      req.ClassifyId,
+		SysUserId:       req.SysUserId,
+		SysUserRealName: req.SysUserRealName,
+		UniqueCode:      uniqueCode,
+	}
+	obj := models.Business{}
+	edbInfo, err, errMsg := obj.Add(params, businessIndexItem)
+	if err != nil {
+		br.Msg = "生成" + obj.GetSourceName() + "失败"
+		if errMsg != `` {
+			br.Msg = errMsg
+		}
+		br.ErrMsg = "生成" + obj.GetSourceName() + "失败 Err:" + err.Error()
+		return
+	}
+
+	if edbInfo == nil {
+		br.Msg = "生成" + obj.GetSourceName() + "失败2"
+		br.ErrMsg = "生成" + obj.GetSourceName() + "失败"
+		return
+	}
+
+	// 更新指标最大最小值
+	err = obj.UnifiedModifyEdbInfoMaxAndMinInfo(edbInfo)
+	if err != nil {
+		br.Msg = "更新指标最大最小值失败"
+		br.ErrMsg = err.Error()
+		return
+	}
+
+	// 添加到es
+	go logic.UpdateEs(edbInfo.EdbInfoId)
+
+	resp := models.AddEdbInfoResp{
+		EdbInfoId:  edbInfo.EdbInfoId,
+		UniqueCode: edbInfo.UniqueCode,
+	}
+	br.Ret = 200
+	br.Success = true
+	br.Msg = "保存成功"
+	br.Data = resp
+	br.IsAddLog = true
+}
+
+// Edit
+// @Title 编辑外部数据（商家）指标接口
+// @Description 编辑外部数据（商家）指标接口
+// @Success 200 {object} models.EditEdbBaseInfoReq
+// @router /edit [post]
+func (c *BusinessIndexController) Edit() {
+	br := new(models.BaseResponse).Init()
+	defer func() {
+		c.Data["json"] = br
+		c.ServeJSON()
+	}()
+
+	var req models.EditEdbBaseInfoReq
+	err := json.Unmarshal(c.Ctx.Input.RequestBody, &req)
+	if err != nil {
+		br.Msg = "参数解析异常！"
+		br.ErrMsg = "参数解析失败，Err:" + err.Error()
+		return
+	}
+	cacheKey := utils.CACHE_EDB_DATA_EDIT + "_BusinessIndexController_" + fmt.Sprint(req.EdbInfoId)
+	if utils.Rc.IsExist(cacheKey) {
+		br.Ret = 501
+		br.Success = true
+		br.Msg = "系统处理中，请稍后重试"
+		return
+	}
+
+	utils.Rc.SetNX(cacheKey, 1, 1*time.Minute)
+	defer func() {
+		_ = utils.Rc.Delete(cacheKey)
+	}()
+
+	if req.EdbInfoId <= 0 {
+		br.Msg = "参数错误"
+		br.ErrMsg = "指标ID：" + strconv.Itoa(req.EdbInfoId)
+		br.IsSendEmail = false
+		return
+	}
+
+	req.EdbName = strings.Trim(req.EdbName, " ")
+	if req.EdbName == "" {
+		br.Msg = "指标名称不能为空"
+		br.IsSendEmail = false
+		return
+	}
+
+	//if req.Frequency == "" {
+	//	br.Msg = "频率不能为空"
+	//	return
+	//}
+
+	if req.Unit == "" {
+		br.Msg = "单位不能为空"
+		br.IsSendEmail = false
+		return
+	}
+
+	if req.ClassifyId <= 0 {
+		br.Msg = "请选择分类"
+		br.IsSendEmail = false
+		return
+	}
+
+	// 根据指标名称和指标ID校验库中是否还存在其他同名指标
+	existEdbName, err := logic.CheckExistByEdbNameAndEdbInfoId(0, req.EdbInfoId, req.EdbName, c.Lang)
+	if err != nil {
+		br.Msg = "判断指标名称是否存在失败"
+		br.ErrMsg = "判断指标名称是否存在失败,Err:" + err.Error()
+		return
+	}
+	if existEdbName {
+		br.Msg = "指标名称已存在，请重新填写"
+		br.ErrMsg = "指标名称已存在，请重新填写"
+		br.IsSendEmail = false
+		return
+	}
+
+	//判断公式，指标是否有改动
+	edbInfo, err := models.GetEdbInfoById(req.EdbInfoId)
+	if err != nil {
+		br.Msg = "修改失败"
+		br.Msg = "获取指标信息失败,GetEdbInfoById Err:" + err.Error()
+		return
+	}
+	if edbInfo == nil {
+		br.Msg = "修改失败"
+		br.Msg = "指标信息不存在，EdbInfoId:" + strconv.Itoa(req.EdbInfoId)
+		return
+	}
+
+	baseFromBusinessIndexObj := models.BaseFromBusinessIndex{}
+
+	businessIndexItem, err := baseFromBusinessIndexObj.GetIndexItem(edbInfo.EdbCode)
+	if err != nil {
+		br.Msg = "获取数据源中指标信息失败！"
+		br.ErrMsg = "获取数据源中指标信息失败 baseFromBusinessIndexObj.GetIndexItem，Err:" + err.Error()
+		return
+	}
+
+	// 额外赋值
+	switch c.Lang {
+	case utils.EnLangVersion:
+		req.EdbNameEn = req.EdbName
+		req.UnitEn = req.Unit
+
+		req.EdbName = edbInfo.EdbName
+		req.Unit = edbInfo.Unit
+	default:
+		req.EdbNameEn = edbInfo.EdbNameEn
+		req.UnitEn = edbInfo.UnitEn
+	}
+
+	// 编辑指标
+	params := models.EditBaseParams{
+		EdbCode:         edbInfo.EdbCode,
+		EdbName:         req.EdbName,
+		Unit:            req.Unit,
+		ClassifyId:      req.ClassifyId,
+		SysUserId:       req.SysUserId,
+		SysUserRealName: req.SysUserRealName,
+		Lang:            c.Lang,
+		EdbInfo:         edbInfo,
+		EdbNameEn:       req.EdbNameEn,
+		UnitEn:          req.UnitEn,
+	}
+	obj := models.Business{}
+	err, errMsg := obj.Edit(params, businessIndexItem)
 	if err != nil {
-		br.Msg = "获取指标信息失败！"
-		br.ErrMsg = "获取指标信息失败 AddEdbDataFromMysteelChemical，Err:" + err.Error()
+		br.Msg = "修改" + obj.GetSourceName() + "失败"
+		if errMsg != `` {
+			br.Msg = errMsg
+		}
+		br.ErrMsg = "修改" + obj.GetSourceName() + "失败 Err:" + err.Error()
 		return
 	}
+
+	// 更新指标最大最小值
+	err = obj.UnifiedModifyEdbInfoMaxAndMinInfo(edbInfo)
+	if err != nil {
+		br.Msg = "更新指标最大最小值失败"
+		br.ErrMsg = err.Error()
+		return
+	}
+
+	// 添加到es
+	go logic.UpdateEs(edbInfo.EdbInfoId)
+
+	resp := models.AddEdbInfoResp{
+		EdbInfoId:  edbInfo.EdbInfoId,
+		UniqueCode: edbInfo.UniqueCode,
+	}
 	br.Ret = 200
 	br.Success = true
-	br.Msg = "获取成功"
+	br.Msg = "保存成功"
+	br.Data = resp
+	br.IsAddLog = true
+}
+
+// Refresh
+// @Title 刷新计算指标接口
+// @Description 刷新计算指标接口
+// @Success 200 {object} models.RefreshEdbInfoReq
+// @router /refresh [post]
+func (c *BusinessIndexController) Refresh() {
+	br := new(models.BaseResponse).Init()
+	var cacheKey string
+	defer func() {
+		c.Data["json"] = br
+		c.ServeJSON()
+	}()
+	var req models.RefreshEdbInfoReq
+	err := json.Unmarshal(c.Ctx.Input.RequestBody, &req)
+	if err != nil {
+		br.Msg = "参数解析异常！"
+		br.ErrMsg = "参数解析失败，Err:" + err.Error()
+		return
+	}
+	if req.EdbCode == "" {
+		br.Msg = "请输入指标编码！"
+		br.ErrMsg = "请输入指标编码，指标编码为空"
+		return
+	}
+	if req.EdbInfoId <= 0 {
+		br.Msg = "请输入指标ID！"
+		br.ErrMsg = "请输入指标ID"
+		return
+	}
+	edbInfo, err := models.GetEdbInfoById(req.EdbInfoId)
+	if err != nil {
+		br.Msg = "指标不存在！"
+		br.ErrMsg = "指标不存在"
+		return
+	}
 
-	indexObj := new(models.BaseFromBusinessIndex)
-	//判断指标是否存在
-	item, err := indexObj.GetIndexItem(edbCode)
+	cacheKey = utils.CACHE_EDB_DATA_REFRESH + strconv.Itoa(edbInfo.Source) + "_" + req.EdbCode
+
+	if utils.Rc.IsExist(cacheKey) {
+		br.Ret = 501
+		br.Success = true
+		br.Msg = "系统处理中，请稍后重试"
+		return
+	}
+
+	// 刷新指标
+	utils.Rc.SetNX(cacheKey, 1, 1*time.Minute)
+	defer func() {
+		_ = utils.Rc.Delete(cacheKey)
+	}()
+
+	params := models.RefreshBaseParams{
+		EdbInfo:   edbInfo,
+		StartDate: req.StartDate,
+	}
+	obj := models.Business{}
+
+	err, errMsg := obj.Refresh(params)
+	if errMsg != `` {
+		br.Msg = "刷新指标失败！"
+		br.ErrMsg = "刷新指标失败，err:" + errMsg
+		return
+	}
+	if err != nil && err.Error() != utils.ErrNoRow() {
+		br.Msg = "刷新指标信息失败！"
+		br.ErrMsg = "刷新指标信息失败 BusinessIndexController，Err:" + err.Error()
+		return
+	}
+
+	// 更新指标最大最小值
+	err = obj.UnifiedModifyEdbInfoMaxAndMinInfo(edbInfo)
+	if err != nil {
+		br.Msg = "更新指标最大最小值失败"
+		br.ErrMsg = err.Error()
+		return
+	}
+
+	// 更新ES
+	go logic.UpdateEs(edbInfo.EdbInfoId)
+
+	br.Ret = 200
+	br.Success = true
+	br.Msg = "刷新成功"
 }

models/edb_data_base.go

@@ -203,3 +203,25 @@ func GetEdbDataList(source, subSource, endInfoId int, startDate, endDate string)
 	_, err = o.Raw(sql, endInfoId, pars).QueryRows(&list)
 	return
 }
+
+type AddEdbBaseInfoReq struct {
+	EdbCode         string `description:"指标编码"`
+	EdbName         string `description:"指标名称"`
+	Unit            string `description:"单位"`
+	ClassifyId      int    `description:"所属分类"`
+	SysUserId       int    `description:"用户id"`
+	SysUserRealName string `description:"用户真实名称"`
+}
+
+// EditEdbBaseInfoReq 编辑基础指标请求参数
+type EditEdbBaseInfoReq struct {
+	SysUserId       int    `description:"用户id"`
+	SysUserRealName string `description:"用户真实名称"`
+	EdbInfoId       int    `description:"指标id"`
+	EdbName         string `description:"指标名称"`
+	EdbNameEn       string `description:"英文指标名称"`
+	Frequency       string `description:"频率"`
+	Unit            string `description:"单位"`
+	UnitEn          string `description:"英文单位"`
+	ClassifyId      int    `description:"分类id"`
+}

models/edb_data_business.go

@@ -1,21 +1,23 @@
 package models
 
 import (
-	"errors"
+	"eta/eta_index_lib/models/mgo"
 	"eta/eta_index_lib/utils"
 	"fmt"
 	"github.com/beego/beego/v2/client/orm"
 	"github.com/shopspring/decimal"
+	"go.mongodb.org/mongo-driver/bson"
+	"go.mongodb.org/mongo-driver/bson/primitive"
 	"reflect"
-	"strconv"
-	"strings"
 	"time"
 )
 
-// Business 标准差
+// Business 外部数据
 type Business struct {
 }
 
+// AddBaseParams
+// @Description: 基础指标的添加参数
 type AddBaseParams struct {
 	EdbCode         string `description:"指标编码"`
 	EdbName         string `description:"指标名称"`
@@ -26,8 +28,39 @@ type AddBaseParams struct {
 	UniqueCode      string `description:"编码"`
 }
 
-// Add 添加
-func (obj Business) Add(params AddBaseParams, classifyId int, businessIndexItem *BaseFromBusinessIndex) (edbInfo *EdbInfo, err error, errMsg string) {
+// EditBaseParams
+// @Description: 基础指标的修改参数
+type EditBaseParams struct {
+	EdbCode         string   `description:"指标编码"`
+	EdbName         string   `description:"指标名称"`
+	EdbNameEn       string   `description:"指标名称（英文）"`
+	Unit            string   `description:"单位"`
+	UnitEn          string   `description:"单位（英文）"`
+	ClassifyId      int      `description:"所属分类"`
+	SysUserId       int      `description:"用户id"`
+	SysUserRealName string   `description:"用户真实名称"`
+	UniqueCode      string   `description:"编码"`
+	Lang            string   `description:"语言版本"`
+	EdbInfo         *EdbInfo `description:"指标信息"`
+}
+
+type RefreshBaseParams struct {
+	EdbInfo   *EdbInfo
+	StartDate string
+	EndDate   string
+}
+
+// Add
+// @Description: 添加指标
+// @author: Roc
+// @receiver obj
+// @datetime 2024-04-30 17:35:14
+// @param params AddBaseParams
+// @param businessIndexItem *BaseFromBusinessIndex
+// @return edbInfo *EdbInfo
+// @return err error
+// @return errMsg string
+func (obj Business) Add(params AddBaseParams, businessIndexItem *BaseFromBusinessIndex) (edbInfo *EdbInfo, err error, errMsg string) {
 	o := orm.NewOrm()
 	to, err := o.Begin()
 	if err != nil {
@@ -50,7 +83,7 @@ func (obj Business) Add(params AddBaseParams, classifyId int, businessIndexItem
 	edbInfo.EdbNameSource = params.EdbName
 	edbInfo.Frequency = businessIndexItem.Frequency
 	edbInfo.Unit = params.Unit
-	edbInfo.ClassifyId = classifyId
+	edbInfo.ClassifyId = params.ClassifyId
 	edbInfo.SysUserId = params.SysUserId
 	edbInfo.SysUserRealName = params.SysUserRealName
 	edbInfo.CreateTime = time.Now()
@@ -60,6 +93,8 @@ func (obj Business) Add(params AddBaseParams, classifyId int, businessIndexItem
 	edbInfo.EdbNameEn = params.EdbName
 	edbInfo.UnitEn = params.Unit
 	edbInfo.EdbType = obj.GetEdbType()
+	edbInfo.SubSource = businessIndexItem.Source
+	edbInfo.SubSourceName = businessIndexItem.SourceName
 	newEdbInfoId, tmpErr := to.Insert(edbInfo)
 	if tmpErr != nil {
 		err = tmpErr
@@ -67,17 +102,23 @@ func (obj Business) Add(params AddBaseParams, classifyId int, businessIndexItem
 	}
 	edbInfo.EdbInfoId = int(newEdbInfoId)
 
-	//计算数据
-	//err = obj.refresh(to, edbInfo, fromEdbInfo, edbInfo.EdbCode)
+	// 更新数据
+	err = obj.refresh(edbInfo, "")
 
 	return
 }
 
-// Edit 编辑
-func (obj Business) Edit(params EditCalculateBatchParams) (err error, errMsg string) {
-	req := params.Req
+// Edit
+// @Description: 编辑指标
+// @author: Roc
+// @receiver obj
+// @datetime 2024-04-30 17:35:05
+// @param params EditBaseParams
+// @param businessIndexItem *BaseFromBusinessIndex
+// @return err error
+// @return errMsg string
+func (obj Business) Edit(params EditBaseParams, businessIndexItem *BaseFromBusinessIndex) (err error, errMsg string) {
 	edbInfo := params.EdbInfo
-	fromEdbInfo := params.FromEdbInfo
 
 	o := orm.NewOrm()
 	to, err := o.Begin()
@@ -92,103 +133,34 @@ func (obj Business) Edit(params EditCalculateBatchParams) (err error, errMsg str
 			_ = to.Commit()
 		}
 	}()
-	tableName := GetEdbDataTableName(edbInfo.Source, edbInfo.SubSource)
 
-	oldEdbInfo := *edbInfo
+	//oldEdbInfo := *edbInfo
 
 	//修改指标信息
-	edbInfo.EdbName = req.EdbName
-	edbInfo.EdbNameSource = req.EdbName
-	edbInfo.Frequency = req.Frequency
-	edbInfo.Unit = req.Unit
-	edbInfo.ClassifyId = req.ClassifyId
-	edbInfo.CalculateFormula = req.Formula
-	edbInfo.EdbNameEn = req.EdbNameEn
-	edbInfo.UnitEn = req.UnitEn
+	edbInfo.EdbName = params.EdbName
+	edbInfo.EdbNameSource = params.EdbName
+	edbInfo.Frequency = businessIndexItem.Frequency
+	edbInfo.Unit = params.Unit
+	edbInfo.ClassifyId = params.ClassifyId
+	edbInfo.EdbNameEn = params.EdbNameEn
+	edbInfo.UnitEn = params.UnitEn
+	edbInfo.SubSource = businessIndexItem.Source
+	edbInfo.SubSourceName = businessIndexItem.SourceName
 	edbInfo.ModifyTime = time.Now()
-	_, err = to.Update(edbInfo, "EdbName", "EdbNameSource", "Frequency", "Unit", "ClassifyId", "CalculateFormula", "ModifyTime", "EdbNameEn", "UnitEn")
-	if err != nil {
-		return
-	}
-
-	var existCondition string
-	var existPars []interface{}
-	existCondition += " AND edb_info_id=? AND from_edb_info_id=? "
-	existPars = append(existPars, edbInfo.EdbInfoId, req.FromEdbInfoId)
-
-	//判断计算指标是否被更换
-	count, err := GetEdbInfoCalculateCountByCondition(existCondition, existPars)
+	_, err = to.Update(edbInfo, "EdbName", "EdbNameSource", "Frequency", "Unit", "ClassifyId", "CalculateFormula", "ModifyTime", "EdbNameEn", "UnitEn", "SubSource", "SubSourceName")
 	if err != nil {
-		err = errors.New("判断指标是否改变失败,Err:" + err.Error())
 		return
 	}
-	if count > 0 { // 指标未被替换，无需处理逻辑
-		// 如果相关配置更改了，那么重新计算
-		if oldEdbInfo.CalculateFormula != edbInfo.CalculateFormula {
-			err = obj.refresh(to, edbInfo, fromEdbInfo, edbInfo.EdbCode)
-		}
-		return
-	}
-
-	//删除，计算指标关联的，基础指标的关联关系
-	sql := ` DELETE FROM edb_info_calculate_mapping WHERE edb_info_id = ? `
-	_, err = to.Raw(sql, edbInfo.EdbInfoId).Exec()
-	if err != nil {
-		return
-	}
-
-	//清空原有数据
-	sql = ` DELETE FROM ` + tableName + ` WHERE edb_info_id = ? `
-	_, err = to.Raw(sql, edbInfo.EdbInfoId).Exec()
-	if err != nil {
-		return
-	}
-
-	//关联关系
-	{
-		calculateMappingItem := &EdbInfoCalculateMapping{
-			EdbInfoCalculateMappingId: 0,
-			EdbInfoId:                 edbInfo.EdbInfoId,
-			Source:                    obj.GetSource(),
-			SourceName:                obj.GetSourceName(),
-			EdbCode:                   edbInfo.EdbCode,
-			FromEdbInfoId:             fromEdbInfo.EdbInfoId,
-			FromEdbCode:               fromEdbInfo.EdbCode,
-			FromEdbName:               fromEdbInfo.EdbName,
-			FromSource:                fromEdbInfo.Source,
-			FromSourceName:            fromEdbInfo.SourceName,
-			FromTag:                   "",
-			Sort:                      1,
-			CreateTime:                time.Now(),
-			ModifyTime:                time.Now(),
-		}
-		_, err = to.Insert(calculateMappingItem)
-		if err != nil {
-			return
-		}
-	}
 
 	//计算数据
-	err = obj.refresh(to, edbInfo, fromEdbInfo, edbInfo.EdbCode)
+	err = obj.refresh(edbInfo, "")
 
 	return
 }
 
 // Refresh 刷新
-func (obj Business) Refresh(params RefreshParams) (err error, errMsg string) {
-	calculateMapping, err := GetEdbInfoCalculateMappingDetail(params.EdbInfo.EdbInfoId)
-	if err != nil {
-		errMsg = "GetEdbInfoCalculateLjzzyDetail Err:" + err.Error()
-		return
-	}
-	fromEdbInfo, err := GetEdbInfoById(calculateMapping.FromEdbInfoId)
-	if err != nil {
-		errMsg = "GetEdbInfoById Err:" + err.Error()
-		return
-	}
-
-	o := orm.NewOrm()
-	to, err := o.Begin()
+func (obj Business) Refresh(params RefreshBaseParams) (err error, errMsg string) {
+	to, err := orm.NewOrm().Begin()
 	if err != nil {
 		return
 	}
@@ -202,7 +174,7 @@ func (obj Business) Refresh(params RefreshParams) (err error, errMsg string) {
 	}()
 
 	// 计算数据
-	err = obj.refresh(to, params.EdbInfo, fromEdbInfo, params.EdbInfo.EdbCode)
+	err = obj.refresh(params.EdbInfo, params.StartDate)
 
 	return
 }
@@ -222,144 +194,257 @@ func (obj Business) GetEdbType() int {
 	return utils.DEFAULT_EDB_TYPE
 }
 
-func (obj Business) refresh(to orm.TxOrmer, edbInfo, fromEdbInfo *EdbInfo, edbCode string) (err error) {
-	edbInfoId := edbInfo.EdbInfoId
-	dataTableName := GetEdbDataTableName(edbInfo.Source, edbInfo.SubSource)
-	edbInfoIdStr := strconv.Itoa(edbInfoId)
+func (obj Business) refresh(edbInfo *EdbInfo, startDate string) (err error) {
+	//获取已存在的所有数据
+	baseDataList, err := obj.getBaseBusinessData(edbInfo, startDate)
 
-	calculateValue, err := strconv.Atoi(edbInfo.CalculateFormula)
-	if err != nil {
-		return
-	}
+	//获取指标所有数据
+	existDataList := make([]*mgo.EdbDataBusiness, 0)
+	mogDataObj := new(mgo.EdbDataBusiness)
+	{
+		// 构建查询条件
+		queryConditions := bson.M{
+			"edb_code": edbInfo.EdbCode,
+		}
 
-	// 获取标准差图表的指标数据
-	fromDataList, err := obj.getBusinessData(fromEdbInfo, calculateValue)
-	if err != nil {
-		return err
-	}
+		if startDate != `` {
+			//获取已存在的所有数据
+			startDateTime, tmpErr := time.ParseInLocation(utils.FormatDate, startDate, time.Local)
+			if tmpErr != nil {
+				err = tmpErr
+				return
+			}
+			queryConditions["data_time"] = bson.M{"$gte": startDateTime}
+		}
 
-	//获取指标所有数据
-	existDataList := make([]*EdbData, 0)
-	sql := `SELECT * FROM %s WHERE edb_info_id=? `
-	sql = fmt.Sprintf(sql, dataTableName)
-	_, err = to.Raw(sql, edbInfoId).QueryRows(&existDataList)
-	if err != nil {
-		return err
+		existDataList, err = mogDataObj.GetAllDataList(queryConditions)
+		if err != nil {
+			fmt.Println("getEdbDataBusinessList Err:" + err.Error())
+			return
+		}
 	}
-	existDataMap := make(map[string]string)
-	removeDataTimeMap := make(map[string]int) //需要移除的日期数据
+
+	existDataMap := make(map[string]*mgo.EdbDataBusiness)
+	removeDataTimeMap := make(map[string]bool) //需要移除的日期数据
 	for _, v := range existDataList {
-		existDataMap[v.DataTime] = v.Value
-		removeDataTimeMap[v.DataTime] = 1
+		tmpDate := v.DataTime.Format(utils.FormatDate)
+		existDataMap[tmpDate] = v
+		removeDataTimeMap[tmpDate] = true
 	}
 	needAddDateMap := make(map[time.Time]int)
 
-	addSql := ` INSERT INTO ` + dataTableName + `(edb_info_id,edb_code,data_time,value,create_time,modify_time,data_timestamp) values `
-	var isAdd bool
-	for _, tmpData := range fromDataList {
-		currDateStr := tmpData.DataTime
-		currTime, tmpErr := time.ParseInLocation(utils.FormatDate, currDateStr, time.Local)
-		if tmpErr != nil {
-			err = tmpErr
-			return
-		}
+	// 待添加的数据集
+	addDataList := make([]mgo.EdbDataBusiness, 0)
+	// 待更新的数据集
+	updateDataList := make([]mgo.EdbDataBusiness, 0)
+
+	for _, tmpData := range baseDataList {
+		currDate := tmpData.DataTime
+		currDateStr := currDate.Format(utils.FormatDate)
+
 		// 当前的实际值
 		saveValue := decimal.NewFromFloat(tmpData.Value).Round(4).String()
 
-		existVal, ok := existDataMap[currDateStr]
+		existData, ok := existDataMap[currDateStr]
 		// 如果库中已经存在该数据的话，那么就进行值的变更操作
 		if ok {
+			// 已经入到指标库的值
+			existValStr := decimal.NewFromFloat(existData.Value).Round(4).String()
+
 			//校验待删除日期数据里面是否存在该元素，如果存在的话，那么移除该日期
 			delete(removeDataTimeMap, currDateStr)
-
-			if existVal != saveValue {
-				sql := ` UPDATE %s SET value=?,modify_time=NOW() WHERE edb_info_id=? AND data_time=? `
-				sql = fmt.Sprintf(sql, dataTableName)
-				_, err = to.Raw(sql, saveValue, edbInfoId, currDateStr).Exec()
-				if err != nil {
-					return
-				}
+			if existValStr != saveValue {
+				existData.Value = tmpData.Value
+				updateDataList = append(updateDataList, *existData)
 			}
 
 			continue
 		}
 
 		// 库中不存在该日期的数据
-		timestamp := currTime.UnixNano() / 1e6
-		timeStr := fmt.Sprintf("%d", timestamp)
-		if _, existOk := needAddDateMap[currTime]; !existOk {
-			addSql += GetAddSql(edbInfoIdStr, edbCode, currDateStr, timeStr, saveValue)
-			isAdd = true
-		}
-		needAddDateMap[currTime] = 1
+		timestamp := currDate.UnixNano() / 1e6
+		addDataList = append(addDataList, mgo.EdbDataBusiness{
+			EdbInfoId:     edbInfo.EdbInfoId,
+			EdbCode:       edbInfo.EdbCode,
+			DataTime:      currDate,
+			Value:         tmpData.Value,
+			CreateTime:    time.Now(),
+			ModifyTime:    time.Now(),
+			DataTimestamp: timestamp,
+		})
+		needAddDateMap[currDate] = 1
 	}
 
 	//删除已经不存在的指标数据（由于该指标当日的数据删除了）
+	removeDateList := make([]string, 0)
 	{
-		removeDateList := make([]string, 0)
 		for dateTime := range removeDataTimeMap {
 			removeDateList = append(removeDateList, dateTime)
 		}
 		removeNum := len(removeDateList)
 		if removeNum > 0 {
-			sql := fmt.Sprintf(` DELETE FROM %s WHERE edb_info_id = ? and data_time in (`+utils.GetOrmInReplace(removeNum)+`) `, dataTableName)
-			_, err = to.Raw(sql, edbInfo.EdbInfoId, removeDateList).Exec()
+			// todo 删除指定日期的数据
+
+		}
+	}
+
+	// 入库
+	{
+
+		coll := mogDataObj.GetCollection()
+
+		//删除已经不存在的指标数据（由于该指标当日的数据删除了）
+		//{
+		//	for dateTime := range removeDataTimeMap {
+		//		removeDateList = append(removeDateList, dateTime)
+		//	}
+		//	removeNum := len(removeDateList)
+		//	if removeNum > 0 {
+		//		err = mogDataObj.RemoveManyByColl(coll, addDataList)
+		//		if err != nil {
+		//			fmt.Println("mogDataObj.RemoveMany() Err:" + err.Error())
+		//			return
+		//		}
+		//	}
+		//}
+
+		// 插入新数据
+		if len(addDataList) > 0 {
+			err = mogDataObj.BatchInsertDataByColl(coll, addDataList)
 			if err != nil {
-				fmt.Println(reflect.TypeOf(obj).Name(), " add data ;delete Err", err.Error())
-				err = fmt.Errorf("删除不存在的指标数据失败,Err:" + err.Error())
+				fmt.Println("mogDataObj.BatchInsertData() Err:" + err.Error())
 				return
 			}
 		}
+
+		// 修改历史数据
+		if len(updateDataList) > 0 {
+			for _, v := range updateDataList {
+				err = mogDataObj.UpdateDataByColl(coll, bson.M{"_id": v.ID}, bson.M{"$set": bson.M{"value": v.Value, "modify_time": v.ModifyTime}})
+				if err != nil {
+					fmt.Println("mogDataObj.UpdateDataByColl:Err:" + err.Error())
+					return
+				}
+			}
+		}
 	}
 
-	if isAdd {
-		addSql = strings.TrimRight(addSql, ",")
-		_, err = to.Raw(addSql).Exec()
-		if err != nil {
-			fmt.Println(reflect.TypeOf(obj).Name(), " add data Err", err.Error())
+	return
+}
+
+// GetEdbInfoMaxAndMinInfo 获取指标的最新数据记录信息
+func (obj Business) GetEdbInfoMaxAndMinInfo(edbCode string) (item *EdbInfoMaxAndMinInfo, err error) {
+	mogDataObj := new(mgo.EdbDataBusiness)
+	pipeline := []bson.M{
+		{"$match": bson.M{"edb_code": edbCode}},
+		{"$group": bson.M{
+			"_id":       nil,
+			"min_date":  bson.M{"$min": "$data_time"},
+			"max_date":  bson.M{"$max": "$data_time"},
+			"min_value": bson.M{"$min": "$value"},
+			"max_value": bson.M{"$max": "$value"},
+		}},
+		{"$project": bson.M{"_id": 0}}, // 可选，如果不需要_id字段
+	}
+	result, err := mogDataObj.GetEdbInfoMaxAndMinInfo(pipeline)
+	if err != nil {
+		fmt.Println("getEdbDataBusinessList Err:" + err.Error())
+		return
+	}
+
+	if !result.MaxDate.IsZero() {
+		whereQuery := bson.M{"edb_code": edbCode, "data_time": result.MaxDate}
+		selectParam := bson.D{{"value", 1}, {"_id", 0}}
+		latestValue, tmpErr := mogDataObj.GetLatestValue(whereQuery, selectParam)
+		if tmpErr != nil {
+			err = tmpErr
 			return
 		}
+		result.LatestValue = latestValue.Value
+		result.EndValue = latestValue.Value
+	}
+
+	item = &EdbInfoMaxAndMinInfo{
+		MinDate:     result.MinDate.Format(utils.FormatDate),
+		MaxDate:     result.MaxDate.Format(utils.FormatDate),
+		MinValue:    result.MinValue,
+		MaxValue:    result.MaxValue,
+		LatestValue: result.LatestValue,
+		LatestDate:  result.LatestDate.Format(utils.FormatDate),
+		EndValue:    result.EndValue,
 	}
 
 	return
 }
 
-// GetBusinessData 获取标准差图表的指标数据
-func (obj Business) getBusinessData(fromEdbInfo *EdbInfo, calculateValue int) (newDataList []EdbInfoSearchData, err error) {
-	// 获取时间基准指标在时间区间内的值
-	dataList := make([]*EdbInfoSearchData, 0)
-	switch fromEdbInfo.EdbInfoType {
-	case 0:
-		var condition string
-		var pars []interface{}
-		condition += " AND edb_info_id=? "
-		pars = append(pars, fromEdbInfo.EdbInfoId)
-
-		//获取来源指标的数据
-		dataList, err = GetEdbDataListAll(condition, pars, fromEdbInfo.Source, fromEdbInfo.SubSource, 1)
-	case 1:
-		dataList, err = GetPredictEdbDataListAllByStartDate(fromEdbInfo, 1, "")
-	default:
-		err = errors.New(fmt.Sprint("获取失败,指标base类型异常", fromEdbInfo.EdbInfoType))
+// UnifiedModifyEdbInfoMaxAndMinInfo
+// @Description: 修改指标的最大最小值和最新值
+// @author: Roc
+// @receiver obj
+// @datetime 2024-04-30 17:07:35
+// @param edbInfo *EdbInfo
+// @return err error
+func (obj Business) UnifiedModifyEdbInfoMaxAndMinInfo(edbInfo *EdbInfo) (err error) {
+	edbInfoMaxAndMinInfo, err := obj.GetEdbInfoMaxAndMinInfo(edbInfo.EdbCode)
+	if err != nil {
 		return
 	}
+	err = ModifyEdbInfoMaxAndMinInfo(edbInfo.EdbInfoId, edbInfoMaxAndMinInfo)
+	return
+}
+
+// EdbInfoMgoData
+// @Description: mgo里面的数据
+type EdbInfoMgoData struct {
+	EdbDataId primitive.ObjectID `description:"数据ID"`
+	DataTime  time.Time          `description:"数据日期"`
+	Value     float64            `description:"数据"`
+	EdbCode   string             `description:"指标编码"`
+}
+
+// getBaseBusinessData
+// @Description: 获取基础数据
+// @author: Roc
+// @receiver obj
+// @datetime 2024-04-30 11:10:46
+// @param edbInfo *EdbInfo
+// @param startDate string
+// @return newDataList []EdbInfoSearchData
+// @return err error
+func (obj Business) getBaseBusinessData(edbInfo *EdbInfo, startDate string) (newDataList []EdbInfoMgoData, err error) {
+	newDataList = make([]EdbInfoMgoData, 0)
+
+	// 获取数据源的指标数据
+	mogDataObj := new(mgo.BaseFromBusinessData)
+
+	// 构建查询条件
+	queryConditions := bson.M{
+		"index_code": edbInfo.EdbCode,
+	}
 
-	// 指标对应的所有数据
-	newDataList = make([]EdbInfoSearchData, 0)
-	lenData := len(dataList)
-	if lenData >= calculateValue {
-		tmpDataList := make([]float64, 0)
-		for _, tmpData := range dataList {
-			tmpDataList = append(tmpDataList, tmpData.Value)
-		}
-		for i := calculateValue; i <= lenData; i++ {
-			tmpV := utils.CalculateBusiness(tmpDataList[i-calculateValue : i])
-			newDataList = append(newDataList, EdbInfoSearchData{
-				EdbDataId: i,
-				DataTime:  dataList[i-1].DataTime,
-				Value:     tmpV,
-			})
+	if startDate != `` {
+		//获取已存在的所有数据
+		startDateTime, tmpErr := time.ParseInLocation(utils.FormatDate, startDate, time.Local)
+		if tmpErr != nil {
+			err = tmpErr
+			return
 		}
+		queryConditions["data_time"] = bson.M{"$gte": startDateTime}
+	}
+
+	baseDataList, err := mogDataObj.GetAllDataList(queryConditions)
+	if err != nil {
+		fmt.Println("getBaseBusinessData Err:" + err.Error())
+		return
+	}
+
+	for _, v := range baseDataList {
+		newDataList = append(newDataList, EdbInfoMgoData{
+			EdbDataId: v.ID,
+			DataTime:  v.DataTime,
+			Value:     v.Value,
+			EdbCode:   v.IndexCode,
+		})
 	}
 
 	return

models/edb_info.go

@@ -227,13 +227,13 @@ func GetEdbDataListAllByTo(to orm.TxOrmer, condition string, pars []interface{},
 
 // EdbInfoMaxAndMinInfo 指标最新数据记录结构体
 type EdbInfoMaxAndMinInfo struct {
-	MinDate     string  `description:"最小日期"`
-	MaxDate     string  `description:"最大日期"`
-	MinValue    float64 `description:"最小值"`
-	MaxValue    float64 `description:"最大值"`
-	LatestValue float64 `description:"最新值"`
-	LatestDate  string  `description:"实际数据最新日期"`
-	EndValue    float64 `description:"最新值"`
+	MinDate     string  `description:"最小日期" bson:"min_date"`
+	MaxDate     string  `description:"最大日期" bson:"max_date"`
+	MinValue    float64 `description:"最小值" bson:"min_value"`
+	MaxValue    float64 `description:"最大值" bson:"max_value"`
+	LatestValue float64 `description:"最新值" bson:"latest_value"`
+	LatestDate  string  `description:"实际数据最新日期" bson:"latest_date"`
+	EndValue    float64 `description:"最新值" bson:"end_value"`
 }
 
 // GetEdbInfoMaxAndMinInfo 获取指标的最新数据记录信息

models/mgo/base_from_business_data.go

@@ -11,31 +11,17 @@ import (
 	"time"
 )
 
-// BaseAddFromBusinessData
-// @Description: 外部数据基础
-type BaseAddFromBusinessData struct {
-	BaseFromBusinessIndexId int64     `json:"base_from_business_index_id" bson:"base_from_business_index_id"` // 指标id
-	IndexCode               string    `json:"index_code" bson:"index_code"`                                   // 指标编码
-	DataTime                string    `json:"data_time" bson:"data_time"`                                     // 数据日期
-	Value                   float64   `json:"value" bson:"value"`                                             // 数据值
-	CreateTime              time.Time `json:"create_time" bson:"create_time"`                                 // 创建时间
-	ModifyTime              time.Time `json:"modify_time" bson:"modify_time"`                                 // 修改时间
-	//DataTimestamp           int64     `json:"data_timestamp"`              // 数据日期时间戳
-}
-
 // BaseFromBusinessData
 // @Description: 外部数据集合
 type BaseFromBusinessData struct {
-	ID primitive.ObjectID `json:"_id" bson:"_id" ` // 文档id
+	ID primitive.ObjectID `json:"_id" bson:"_id,omitempty"` // 文档id
 	//ID string `json:"_id" bson:"_id" ` // 文档id
-	//BaseAddFromBusinessData
 	BaseFromBusinessIndexId int64     `json:"base_from_business_index_id" bson:"base_from_business_index_id"` // 指标id
 	IndexCode               string    `json:"index_code" bson:"index_code"`                                   // 指标编码
-	DataTime                string    `json:"data_time" bson:"data_time"`                                     // 数据日期
+	DataTime                time.Time `json:"data_time" bson:"data_time"`                                     // 数据日期
 	Value                   float64   `json:"value" bson:"value"`                                             // 数据值
 	CreateTime              time.Time `json:"create_time" bson:"create_time"`                                 // 创建时间
 	ModifyTime              time.Time `json:"modify_time" bson:"modify_time"`                                 // 修改时间
-	//DataTimestamp           int64     `json:"data_timestamp"`              // 数据日期时间戳
 }
 
 // CollectionName
@@ -55,7 +41,7 @@ func (m *BaseFromBusinessData) CollectionName() string {
 // @datetime 2024-04-26 13:41:33
 // @return string
 func (m *BaseFromBusinessData) DataBaseName() string {
-	return "hz_data"
+	return utils.MgoDataDbName
 }
 
 // GetCollection
@@ -77,7 +63,7 @@ func (m *BaseFromBusinessData) GetCollection() *qmgo.Collection {
 // @param whereParams interface{}
 // @return result []BaseFromBusinessData
 // @return err error
-func (m *BaseFromBusinessData) GetAllDataList(whereParams interface{}) (result []BaseFromBusinessData, err error) {
+func (m *BaseFromBusinessData) GetAllDataList(whereParams interface{}) (result []*BaseFromBusinessData, err error) {
 	if utils.MgoDataCli == nil {
 		err = errors.New("mongodb连接失败")
 		return
@@ -90,6 +76,15 @@ func (m *BaseFromBusinessData) GetAllDataList(whereParams interface{}) (result [
 		return
 	}
 	err = coll.Find(ctx, whereParams).All(&result)
+	if err != nil {
+		return
+	}
+
+	for _, v := range result {
+		v.DataTime = v.DataTime.In(time.Local)
+		v.CreateTime = v.CreateTime.In(time.Local)
+		v.ModifyTime = v.ModifyTime.In(time.Local)
+	}
 
 	return
 }
@@ -151,15 +146,16 @@ func (m *BaseFromBusinessData) UpdateData(whereParams, updateParams interface{})
 	return
 }
 
-// UpdateData
-// @Description: 单条数据修改
+// HandleData
+// @Description: 事务处理数据
 // @author: Roc
 // @receiver m
-// @datetime 2024-04-26 15:01:51
-// @param params interface{}
-// @param whereParams interface{}
+// @datetime 2024-04-30 10:40:20
+// @param addDataList []BaseAddFromBusinessData
+// @param updateDataList []BaseFromBusinessData
+// @return result interface{}
 // @return err error
-func (m *BaseFromBusinessData) HandleData(addDataList []BaseAddFromBusinessData, updateDataList []BaseFromBusinessData) (result interface{}, err error) {
+func (m *BaseFromBusinessData) HandleData(addDataList, updateDataList []BaseFromBusinessData) (result interface{}, err error) {
 
 	ctx := context.TODO()
 

models/mgo/edb_data_business.go

@@ -0,0 +1,311 @@
+package mgo
+
+import (
+	"context"
+	"errors"
+	"eta/eta_index_lib/utils"
+	"fmt"
+	"github.com/qiniu/qmgo"
+	"go.mongodb.org/mongo-driver/bson"
+	"go.mongodb.org/mongo-driver/bson/primitive"
+	"time"
+)
+
+// EdbDataBusiness
+// @Description: 外部数据集合（指标库）
+type EdbDataBusiness struct {
+	ID            primitive.ObjectID `json:"_id" bson:"_id,omitempty" `            // 文档id
+	EdbInfoId     int                `json:"edb_info_id" bson:"edb_info_id"`       // 指标编码
+	EdbCode       string             `json:"edb_code" bson:"edb_code"`             // 指标编码
+	DataTime      time.Time          `json:"data_time" bson:"data_time"`           // 数据日期
+	Value         float64            `json:"value" bson:"value"`                   // 数据值
+	CreateTime    time.Time          `json:"create_time" bson:"create_time"`       // 创建时间
+	ModifyTime    time.Time          `json:"modify_time" bson:"modify_time"`       // 修改时间
+	DataTimestamp int64              `json:"data_timestamp" bson:"data_timestamp"` // 数据日期时间戳
+}
+
+// CollectionName
+// @Description:  获取集合名称
+// @author: Roc
+// @receiver m
+// @datetime 2024-04-26 13:41:36
+// @return string
+func (m *EdbDataBusiness) CollectionName() string {
+	return "edb_data_business"
+}
+
+// DataBaseName
+// @Description: 获取数据库名称
+// @author: Roc
+// @receiver m
+// @datetime 2024-04-26 13:41:33
+// @return string
+func (m *EdbDataBusiness) DataBaseName() string {
+	return utils.MgoDataDbName
+}
+
+// GetCollection
+// @Description: 获取mongodb集合的句柄
+// @author: Roc
+// @receiver m
+// @datetime 2024-04-26 13:41:33
+// @return string
+func (m *EdbDataBusiness) GetCollection() *qmgo.Collection {
+	db := utils.MgoDataCli.Database(m.DataBaseName())
+	return db.Collection(m.CollectionName())
+}
+
+// GetAllDataList
+// @Description: 根据条件获取所有数据
+// @author: Roc
+// @receiver m
+// @datetime 2024-04-26 13:42:19
+// @param whereParams interface{}
+// @return result []EdbDataBusiness
+// @return err error
+func (m *EdbDataBusiness) GetAllDataList(whereParams interface{}) (result []*EdbDataBusiness, err error) {
+	if utils.MgoDataCli == nil {
+		err = errors.New("mongodb连接失败")
+		return
+	}
+	db := utils.MgoDataCli.Database(m.DataBaseName())
+	coll := db.Collection(m.CollectionName())
+	ctx := context.TODO()
+	if err != nil {
+		fmt.Println("MgoGetColl Err:", err.Error())
+		return
+	}
+	err = coll.Find(ctx, whereParams).All(&result)
+	if err != nil {
+		return
+	}
+
+	for _, v := range result {
+		v.DataTime = v.DataTime.In(time.Local)
+		v.CreateTime = v.CreateTime.In(time.Local)
+		v.ModifyTime = v.ModifyTime.In(time.Local)
+	}
+
+	return
+}
+
+// BatchInsertData
+// @Description: 批量写入数据
+// @author: Roc
+// @receiver m
+// @datetime 2024-04-26 14:22:18
+// @param dataList interface{}
+// @return err error
+func (m *EdbDataBusiness) BatchInsertData(dataList []EdbDataBusiness) (err error) {
+	db := utils.MgoDataCli.Database(m.DataBaseName())
+	coll := db.Collection(m.CollectionName())
+
+	return m.BatchInsertDataByColl(coll, dataList)
+}
+
+// BatchInsertDataByColl
+// @Description: 批量写入数据（外部传入集合）
+// @author: Roc
+// @receiver m
+// @datetime 2024-04-26 14:22:18
+// @param dataList interface{}
+// @return err error
+func (m *EdbDataBusiness) BatchInsertDataByColl(coll *qmgo.Collection, dataList []EdbDataBusiness) (err error) {
+	ctx := context.TODO()
+	_, err = coll.InsertMany(ctx, dataList)
+	if err != nil {
+		fmt.Println("BatchInsertData:Err:" + err.Error())
+		return
+	}
+
+	return
+}
+
+// UpdateData
+// @Description: 单条数据修改
+// @author: Roc
+// @receiver m
+// @datetime 2024-04-26 15:01:51
+// @param whereParams interface{}
+// @param updateParams interface{}
+// @return err error
+func (m *EdbDataBusiness) UpdateData(whereParams, updateParams interface{}) (err error) {
+	db := utils.MgoDataCli.Database(m.DataBaseName())
+	coll := db.Collection(m.CollectionName())
+
+	return m.UpdateDataByColl(coll, whereParams, updateParams)
+}
+
+// UpdateDataByColl
+// @Description: 单条数据修改（外部传入集合）
+// @author: Roc
+// @receiver m
+// @datetime 2024-04-26 15:01:51
+// @param whereParams interface{}
+// @param updateParams interface{}
+// @return err error
+func (m *EdbDataBusiness) UpdateDataByColl(coll *qmgo.Collection, whereParams, updateParams interface{}) (err error) {
+	ctx := context.TODO()
+	err = coll.UpdateOne(ctx, whereParams, updateParams)
+	if err != nil {
+		fmt.Println("UpdateDataByColl:Err:" + err.Error())
+		return
+	}
+
+	return
+}
+
+// RemoveMany
+// @Description: 根据条件删除多条数据
+// @author: Roc
+// @receiver m
+// @datetime 2024-04-30 13:17:02
+// @param whereParams interface{}
+// @return err error
+func (m *EdbDataBusiness) RemoveMany(whereParams interface{}) (err error) {
+	db := utils.MgoDataCli.Database(m.DataBaseName())
+	coll := db.Collection(m.CollectionName())
+
+	return m.RemoveManyByColl(coll, whereParams)
+}
+
+// RemoveManyByColl
+// @Description: 根据条件删除多条数据（外部传入集合）
+// @author: Roc
+// @receiver m
+// @datetime 2024-04-30 13:18:42
+// @param coll *qmgo.Collection
+// @param whereParams interface{}
+// @return err error
+func (m *EdbDataBusiness) RemoveManyByColl(coll *qmgo.Collection, whereParams interface{}) (err error) {
+	ctx := context.TODO()
+	_, err = coll.RemoveAll(ctx, whereParams)
+	if err != nil {
+		fmt.Println("RemoveManyByColl:Err:" + err.Error())
+		return
+	}
+
+	return
+}
+
+// HandleData
+// @Description: 事务处理数据
+// @author: Roc
+// @receiver m
+// @datetime 2024-04-30 10:39:01
+// @param addDataList []AddEdbDataBusiness
+// @param updateDataList []EdbDataBusiness
+// @return result interface{}
+// @return err error
+func (m *EdbDataBusiness) HandleData(addDataList, updateDataList []EdbDataBusiness) (result interface{}, err error) {
+
+	ctx := context.TODO()
+
+	callback := func(sessCtx context.Context) (interface{}, error) {
+		// 重要：确保事务中的每一个操作，都使用传入的sessCtx参数
+
+		db := utils.MgoDataCli.Database(m.DataBaseName())
+		coll := db.Collection(m.CollectionName())
+
+		// 插入数据
+		if len(addDataList) > 0 {
+			_, err = coll.InsertMany(sessCtx, addDataList)
+			if err != nil {
+				return nil, err
+			}
+		}
+
+		// 修改
+
+		if len(updateDataList) > 0 {
+			for _, v := range updateDataList {
+				err = coll.UpdateOne(ctx, bson.M{"_id": v.ID}, bson.M{"$set": bson.M{"value": v.Value, "modify_time": v.ModifyTime}})
+				if err != nil {
+					fmt.Println("BatchInsertData:Err:" + err.Error())
+					return nil, err
+				}
+			}
+		}
+
+		return nil, nil
+	}
+	result, err = utils.MgoDataCli.DoTransaction(ctx, callback)
+
+	return
+}
+
+// EdbInfoMaxAndMinInfo 指标最新数据记录结构体
+type EdbInfoMaxAndMinInfo struct {
+	MinDate     time.Time `description:"最小日期" bson:"min_date"`
+	MaxDate     time.Time `description:"最大日期" bson:"max_date"`
+	MinValue    float64   `description:"最小值" bson:"min_value"`
+	MaxValue    float64   `description:"最大值" bson:"max_value"`
+	LatestValue float64   `description:"最新值" bson:"latest_value"`
+	LatestDate  time.Time `description:"实际数据最新日期" bson:"latest_date"`
+	EndValue    float64   `description:"最新值" bson:"end_value"`
+}
+
+// GetEdbInfoMaxAndMinInfo
+// @Description: 获取当前指标的最大最小值
+// @author: Roc
+// @receiver m
+// @datetime 2024-04-30 17:15:39
+// @param whereParams interface{}
+// @return result EdbInfoMaxAndMinInfo
+// @return err error
+func (m *EdbDataBusiness) GetEdbInfoMaxAndMinInfo(whereParams interface{}) (result EdbInfoMaxAndMinInfo, err error) {
+	if utils.MgoDataCli == nil {
+		err = errors.New("mongodb连接失败")
+		return
+	}
+	db := utils.MgoDataCli.Database(m.DataBaseName())
+	coll := db.Collection(m.CollectionName())
+	ctx := context.TODO()
+	if err != nil {
+		fmt.Println("MgoGetColl Err:", err.Error())
+		return
+	}
+	err = coll.Aggregate(ctx, whereParams).One(&result)
+	if err != nil {
+		return
+	}
+	result.MinDate = result.MinDate.In(time.Local)
+	result.MaxDate = result.MaxDate.In(time.Local)
+	result.LatestDate = result.LatestDate.In(time.Local)
+
+	return
+}
+
+// LatestValue 指标最新数据记录结构体
+type LatestValue struct {
+	Value float64 `description:"值" bson:"value"`
+}
+
+// GetLatestValue
+// @Description: 获取当前指标的最新数据记录
+// @author: Roc
+// @receiver m
+// @datetime 2024-04-30 17:16:15
+// @param whereParams interface{}
+// @param selectParam interface{}
+// @return latestValue LatestValue
+// @return err error
+func (m *EdbDataBusiness) GetLatestValue(whereParams, selectParam interface{}) (latestValue LatestValue, err error) {
+	if utils.MgoDataCli == nil {
+		err = errors.New("mongodb连接失败")
+		return
+	}
+	db := utils.MgoDataCli.Database(m.DataBaseName())
+	coll := db.Collection(m.CollectionName())
+	ctx := context.TODO()
+	if err != nil {
+		fmt.Println("MgoGetColl Err:", err.Error())
+		return
+	}
+
+	//var result interface{}
+	//err = coll.Find(ctx, whereParams).Select(selectParam).One(&result)
+	err = coll.Find(ctx, whereParams).Select(selectParam).One(&latestValue)
+
+	return
+}

models/mgo_base.go

@@ -7,8 +7,6 @@ import (
 	"eta/eta_index_lib/utils"
 	"eta/eta_index_lib/utils/mgodb"
 	"fmt"
-	"go.mongodb.org/mongo-driver/bson"
-	"time"
 )
 
 func init() {
@@ -21,13 +19,14 @@ func init() {
 
 		mgoCli := mgodb.MgoNewClient(mgoConfig)
 		utils.MgoDataCli = mgoCli
+		utils.MgoDataDbName = mgoConfig.Database
 		//result, err := TestMgoFindOne("data_ths", bson.M{"edbcode": "s0033227", "datatime": "2015-12-04"})
-		fmt.Println(time.Now())
-		result, err := TestMgoFindOne("data_wind", bson.M{"edbcode": "s0033227", "datatime": "2007-12-29"})
-		fmt.Println(time.Now())
-
-		fmt.Println(err)
-		fmt.Println(result)
+		//fmt.Println(time.Now())
+		//result, err := TestMgoFindOne("data_wind", bson.M{"edbcode": "s0033227", "datatime": "2007-12-29"})
+		//fmt.Println(time.Now())
+		//
+		//fmt.Println(err)
+		//fmt.Println(result)
 	}
 
 }

routers/commentsRouter.go

@@ -79,6 +79,24 @@ func init() {
             Filters: nil,
             Params: nil})
 
+    beego.GlobalControllerRouter["eta/eta_index_lib/controllers:BusinessIndexController"] = append(beego.GlobalControllerRouter["eta/eta_index_lib/controllers:BusinessIndexController"],
+        beego.ControllerComments{
+            Method: "Add",
+            Router: `/add`,
+            AllowHTTPMethods: []string{"post"},
+            MethodParams: param.Make(),
+            Filters: nil,
+            Params: nil})
+
+    beego.GlobalControllerRouter["eta/eta_index_lib/controllers:BusinessIndexController"] = append(beego.GlobalControllerRouter["eta/eta_index_lib/controllers:BusinessIndexController"],
+        beego.ControllerComments{
+            Method: "Edit",
+            Router: `/edit`,
+            AllowHTTPMethods: []string{"post"},
+            MethodParams: param.Make(),
+            Filters: nil,
+            Params: nil})
+
     beego.GlobalControllerRouter["eta/eta_index_lib/controllers:BusinessIndexController"] = append(beego.GlobalControllerRouter["eta/eta_index_lib/controllers:BusinessIndexController"],
         beego.ControllerComments{
             Method: "HandleBusinessIndexData",
@@ -88,6 +106,15 @@ func init() {
             Filters: nil,
             Params: nil})
 
+    beego.GlobalControllerRouter["eta/eta_index_lib/controllers:BusinessIndexController"] = append(beego.GlobalControllerRouter["eta/eta_index_lib/controllers:BusinessIndexController"],
+        beego.ControllerComments{
+            Method: "Refresh",
+            Router: `/refresh`,
+            AllowHTTPMethods: []string{"post"},
+            MethodParams: param.Make(),
+            Filters: nil,
+            Params: nil})
+
     beego.GlobalControllerRouter["eta/eta_index_lib/controllers:CalculateController"] = append(beego.GlobalControllerRouter["eta/eta_index_lib/controllers:CalculateController"],
         beego.ControllerComments{
             Method: "Add",

services/base_from_business.go

@@ -129,16 +129,15 @@ func HandleBusinessIndex(indexItem *models.AddBusinessIndexReq) (err error) {
 		fmt.Println("GetIndexDataList Err:" + err.Error())
 		return err
 	}
-	fmt.Println("exitDataListLen:", len(exitDataList))
 
 	// 已经存在的数据集
-	exitDataMap := make(map[string]mgo.BaseFromBusinessData)
+	exitDataMap := make(map[string]*mgo.BaseFromBusinessData)
 	for _, v := range exitDataList {
-		exitDataMap[v.DataTime] = v
+		exitDataMap[v.DataTime.Format(utils.FormatDate)] = v
 	}
 
 	// 待添加的数据集
-	addDataList := make([]mgo.BaseAddFromBusinessData, 0)
+	addDataList := make([]mgo.BaseFromBusinessData, 0)
 	updateDataList := make([]mgo.BaseFromBusinessData, 0)
 	//var hasUpdate bool
 	// 遍历excel数据，然后跟现有的数据做校验，不存在则入库
@@ -152,10 +151,10 @@ func HandleBusinessIndex(indexItem *models.AddBusinessIndexReq) (err error) {
 
 		findData, ok := exitDataMap[date]
 		if !ok {
-			addDataList = append(addDataList, mgo.BaseAddFromBusinessData{
+			addDataList = append(addDataList, mgo.BaseFromBusinessData{
 				BaseFromBusinessIndexId: item.BaseFromBusinessIndexId,
 				IndexCode:               item.IndexCode,
-				DataTime:                date,
+				DataTime:                dateTime,
 				Value:                   data.Value,
 				CreateTime:              time.Now(),
 				ModifyTime:              time.Now(),
@@ -167,7 +166,7 @@ func HandleBusinessIndex(indexItem *models.AddBusinessIndexReq) (err error) {
 		// 值不匹配，修改数据
 		if findData.Value != data.Value {
 			findData.Value = data.Value
-			updateDataList = append(updateDataList, findData)
+			updateDataList = append(updateDataList, *findData)
 		}
 	}
 

utils/config.go

@@ -24,9 +24,10 @@ var (
 
 	REDIS_CACHE string //缓存地址
 	//Rc          *cache.Cache //redis缓存
-	Re         error        //redis错误
-	Rc         RedisClient  //redis缓存
-	MgoDataCli *qmgo.Client // mongodb客户端连接
+	Re            error        //redis错误
+	Rc            RedisClient  //redis缓存
+	MgoDataCli    *qmgo.Client // mongodb客户端连接
+	MgoDataDbName string       // mongodb指标数据的库名
 )
 
 // DATA_INDEX_NAME 数据指标库ES索引名称

utils/constants.go

@@ -218,6 +218,7 @@ const (
 
 const (
 	CACHE_EDB_DATA_ADD               = "CACHE_EDB_DATA_ADD_"
+	CACHE_EDB_DATA_EDIT              = "CACHE_EDB_DATA_EDIT_"
 	CACHE_EDB_DATA_REFRESH           = "CACHE_EDB_DATA_REFRESH_"
 	CACHE_WIND_URL                   = "CACHE_WIND_URL"
 	CACHE_CHART_INFO_DATA            = "chart:info:data:"                 //图表数据