eta_chart_lib/models/mgo_base.go

package models

import (
	"context"
	"encoding/json"
	"errors"
	"eta_gn/eta_chart_lib/utils"
	"eta_gn/eta_chart_lib/utils/mgodb"
	"fmt"
)

func init() {
	if utils.MgoUrlData != `` {
		var mgoConfig mgodb.MgoConfig
		if e := json.Unmarshal([]byte(utils.MgoUrlData), &mgoConfig); e != nil {
			panic("mongodb链接失败，Err:" + e.Error())
			return
		}

		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)
	}

}

// TestMgoFindOne
// @Description: 获取单条数据
// @author: Roc
// @datetime 2024-04-25 15:44:07
// @param colName string 集合名词：`data_ths`
// @param whereParams interface{} bson.M{"edbcode": "s0033227", "datatime": "2015-12-04"}
// @return result interface{}
// @return err error
func TestMgoFindOne(colName string, whereParams interface{}) (result interface{}, err error) {
	if colName == "" {
		err = errors.New("集合名称不可为空")
		return
	}
	if utils.MgoDataCli == nil {
		err = errors.New("mongodb连接失败")
		return
	}
	db := utils.MgoDataCli.Database("hz_data")
	coll := db.Collection("data_ths")
	ctx := context.TODO()
	if err != nil {
		fmt.Println("MgoGetColl Err:", err.Error())
		return
	}
	//err = coll.Find(ctx, whereParams).One(&result)
	err = coll.Find(ctx, whereParams).All(&result)
	return
}

// 创建集合
//func MgoCreateCollection(collectionName string) (err error) {
//	ctx := context.TODO()
//
//	mgoClient := mgodb.MgoNewClient()
//
//	defer func() {
//		mgoClient.Close(ctx)
//	}()
//
//	colName := collectionName
//	err = mgoClient.Database("hz_data").CreateCollection(ctx, colName)
//	return
//}

// 批量新增多条数据
func MgoBatchInsertData(colName string, dataList interface{}) (err error) {
	if colName == "" {
		err = errors.New("集合名称不可为空")
		return
	}
	ctx := context.TODO()
	coll, err := mgodb.MgoGetColl(colName)
	if err != nil {
		fmt.Println("MgoGetColl Err:", err.Error())
		return
	}
	defer func() {
		coll.Close(ctx)
	}()
	_, err = coll.Collection.InsertMany(ctx, dataList)
	if err != nil {
		fmt.Println("InsertMany:Err:" + err.Error())
		return
	}
	return
}

// 插入单条数据
func MgoInsertData(colName string, dataItem interface{}) (insertedID interface{}, err error) {
	if colName == "" {
		err = errors.New("集合名称不可为空")
		return
	}
	ctx := context.TODO()
	coll, err := mgodb.MgoGetColl(colName)
	if err != nil {
		fmt.Println("MgoGetColl Err:", err.Error())
		return
	}
	defer func() {
		coll.Close(ctx)
	}()
	result, err := coll.Collection.InsertOne(ctx, dataItem)
	if err != nil {
		return
	}
	insertedID = result.InsertedID
	return
}

/*
删除数据
colName := `data_gl`
whereParams := bson.M{"edbcode": "s0033227"}
err := MgoRemove(colName, whereParams)
*/
func MgoRemove(colName string, whereParams interface{}) (err error) {
	if colName == "" {
		err = errors.New("集合名称不可为空")
		return
	}
	ctx := context.TODO()
	coll, err := mgodb.MgoGetColl(colName)
	if err != nil {
		fmt.Println("MgoGetColl Err:", err.Error())
		return
	}
	defer func() {
		coll.Close(ctx)
	}()
	err = coll.Remove(ctx, whereParams)
	return
}

/*
删除多条数据
colName := `data_gl`
whereParams := bson.M{"edbcode": "s0033227"}
err := MgoRemoveAll(colName, whereParams)
*/
func MgoRemoveAll(colName string, whereParams interface{}) (count int64, err error) {
	if colName == "" {
		err = errors.New("集合名称不可为空")
		return
	}
	ctx := context.TODO()
	coll, err := mgodb.MgoGetColl(colName)
	if err != nil {
		fmt.Println("MgoGetColl Err:", err.Error())
		return
	}
	defer func() {
		coll.Close(ctx)
	}()
	res, err := coll.RemoveAll(ctx, whereParams)
	if err != nil {
		fmt.Println("RemoveAll Err:", err.Error())
		return
	}
	count = res.DeletedCount
	return
}

/*
修改单条数据
colName := `data_ths`
whereParams := bson.M{"edbcode": "s0033227", "datatime": "2015-12-04"}
params := bson.M{"$set": bson.M{"value": "1000"}}
*/
func MgoUpdateData(colName string, params, whereParams interface{}) (err error) {
	if colName == "" {
		err = errors.New("集合名称不可为空")
		return
	}
	ctx := context.TODO()
	coll, err := mgodb.MgoGetColl(colName)
	if err != nil {
		fmt.Println("MgoGetColl Err:", err.Error())
		return
	}
	defer func() {
		coll.Close(ctx)
	}()
	err = coll.UpdateOne(ctx, whereParams, params)
	return
}

/*
获取单条数据
colName := `data_ths`
whereParams := bson.M{"edbcode": "s0033227", "datatime": "2015-12-04"}
*/
func MgoFindOne(colName string, whereParams interface{}) (result interface{}, err error) {
	if colName == "" {
		err = errors.New("集合名称不可为空")
		return
	}
	ctx := context.TODO()
	coll, err := mgodb.MgoGetColl(colName)
	if err != nil {
		fmt.Println("MgoGetColl Err:", err.Error())
		return
	}
	defer func() {
		coll.Close(ctx)
	}()
	err = coll.Find(ctx, whereParams).One(&result)
	return
}

/*
分页获取数据
colName := `data_ths`
whereParams := bson.M{"edbcode": "s0033227", "datatime": "2015-12-04"}

sort:="-weight"
skip:0
limit:10
*/
func MgoBatchFind(colName, sort string, whereParams interface{}, skip, limit int64) (list []interface{}, err error) {
	if colName == "" {
		err = errors.New("集合名称不可为空")
		return
	}
	ctx := context.TODO()
	coll, err := mgodb.MgoGetColl(colName)
	if err != nil {
		fmt.Println("MgoGetColl Err:", err.Error())
		return
	}
	defer func() {
		coll.Close(ctx)
	}()
	err = coll.Find(ctx, whereParams).Sort(sort).Skip(skip).Limit(limit).All(&list)
	return
}

/*
MgoUpsertData
更新插入数据-数据存在即更新, 否则新增
colName := `data_ths`
filter := bson.M{"edbcode": "s0033227", "datatime": "2015-12-04"}
replacement := bson.M{"edb_info_id":0,"edb_code":m.EdbCode,"data_time":d.DataTime,"value":f,"create_time":now,"modify_time":now,"data_timestamp": stamp}
*/
func MgoUpsertData(colName string, filter, replacement interface{}) (err error) {
	if colName == "" {
		err = errors.New("集合名称不可为空")
		return
	}
	ctx := context.TODO()
	coll, err := mgodb.MgoGetColl(colName)
	if err != nil {
		fmt.Println("MgoGetColl Err:", err.Error())
		return
	}
	defer func() {
		_ = coll.Close(ctx)
	}()
	_, err = coll.Upsert(ctx, filter, replacement)
	return
}