eta_chart_lib/models/mgo/base_from_business_data.go

package mgo

import (
	"context"
	"errors"
	"eta_gn/eta_chart_lib/utils"
	"fmt"
	"github.com/qiniu/qmgo"
	"go.mongodb.org/mongo-driver/bson"
	"go.mongodb.org/mongo-driver/bson/primitive"
	"time"
)

type BaseFromBusinessData struct {
	ID primitive.ObjectID `json:"_id" bson:"_id,omitempty"` // 文档id
	BaseFromBusinessIndexId int64     `json:"base_from_business_index_id" bson:"base_from_business_index_id"` // 指标id
	IndexCode               string    `json:"index_code" bson:"index_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"`                                 // 修改时间
}

func (m *BaseFromBusinessData) CollectionName() string {
	return "base_from_business_data"
}

func (m *BaseFromBusinessData) DataBaseName() string {
	return utils.MgoDataDbName
}

func (m *BaseFromBusinessData) GetCollection() *qmgo.Collection {
	db := utils.MgoDataCli.Database(m.DataBaseName())
	return db.Collection(m.CollectionName())
}

func (m *BaseFromBusinessData) GetAllDataList(whereParams interface{}, sort []string) (result []*BaseFromBusinessData, 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).Sort(sort...).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
}

func (m *BaseFromBusinessData) GetLimitDataList(whereParams interface{}, size int64, sort []string) (result []*BaseFromBusinessData, 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).Sort(sort...).Limit(size).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
}

func (m *BaseFromBusinessData) GetPageDataList(whereParams interface{}, startSize, size int64, sort []string) (result []*BaseFromBusinessData, 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).Sort(sort...).Skip(startSize).Limit(size).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
}

func (m *BaseFromBusinessData) GetCountDataList(whereParams interface{}) (count int64, 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
	}
	count, err = coll.Find(ctx, whereParams).Count()

	return
}

func (m *BaseFromBusinessData) BatchInsertData(dataList interface{}) (err error) {
	db := utils.MgoDataCli.Database(m.DataBaseName())
	coll := db.Collection(m.CollectionName())
	ctx := context.TODO()
	_, err = coll.InsertMany(ctx, dataList)
	if err != nil {
		fmt.Println("BatchInsertData:Err:" + err.Error())
		return
	}
	return
}

func (m *BaseFromBusinessData) 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
}

func (m *BaseFromBusinessData) UpdateData(whereParams, updateParams interface{}) (err error) {
	db := utils.MgoDataCli.Database(m.DataBaseName())
	coll := db.Collection(m.CollectionName())
	ctx := context.TODO()
	err = coll.UpdateOne(ctx, whereParams, updateParams)
	if err != nil {
		fmt.Println("UpdateData:Err:" + err.Error())
		return
	}
	return
}

func (m *BaseFromBusinessData) HandleData(addDataList, updateDataList []BaseFromBusinessData) (result interface{}, err error) {

	ctx := context.TODO()

	callback := func(sessCtx context.Context) (interface{}, error) {

		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
}

func (m *BaseFromBusinessData) 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
}

func (m *BaseFromBusinessData) 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
	}

	err = coll.Find(ctx, whereParams).Select(selectParam).One(&latestValue)

	return
}