stat_center/models/channelsettlementrecord/recharge.go

package channelsettlementrecord

import (
	"context"
	"fmt"
	"go.mongodb.org/mongo-driver/mongo"
	"stat/common/log"
	"stat/common/mongos"

	"go.mongodb.org/mongo-driver/bson"
	"go.mongodb.org/mongo-driver/mongo/options"
)

var (
	dbRecord  *mongos.MongoTool
	dbDeleted *mongos.MongoTool
)

func Init(ctx context.Context) {
	initDbRecord(ctx)
	initDbDeleted(ctx)
}

func initDbRecord(ctx context.Context) {
	// 获取数据库表
	dbRecord = mongos.New(mongos.MgoManager, TN.ChannelSettlementRecord)
	// 初始化索引
	indexes := []mongo.IndexModel{
		{
			Keys: bson.D{
				{Key: FN.ChannelSettlementRecord.Channel, Value: 1},
				{Key: FN.ChannelSettlementRecord.AppId, Value: 1},
			},
		},
		{
			Keys: bson.D{{Key: FN.ChannelSettlementRecord.SettleIds, Value: 1}},
		},
		{
			Keys: bson.D{{Key: FN.ChannelSettlementRecord.Applicant, Value: 1}},
		},
	}
	if _, err := dbRecord.CreateIndex(ctx, indexes); err != nil {
		panic(fmt.Sprintf("(ChannelSettlementRecord:initChannelSettlementRecordIndex) Create ChannelSettlementRecord Index failed! err:%+v:", err))
	}
}
func initDbDeleted(ctx context.Context) {
	// 获取数据库表
	dbDeleted = mongos.New(mongos.MgoManager, TN.ChannelSettlementDeleted)
	// 初始化索引
	indexes := []mongo.IndexModel{
		{
			Keys: bson.D{
				{Key: FN.ChannelSettlementDeleted.Channel, Value: 1},
				{Key: FN.ChannelSettlementDeleted.AppId, Value: 1},
			},
		},
		{
			Keys: bson.D{{Key: FN.ChannelSettlementDeleted.SettleIds, Value: 1}},
		},
	}
	if _, err := dbDeleted.CreateIndex(ctx, indexes); err != nil {
		panic(fmt.Sprintf("(ChannelSettlementDeleted:initChannelSettlementDeletedIndex) Create ChannelSettlementDeleted Index failed! err:%+v:", err))
	}
}

//InsertOneChannelSettlementRecord 插入一个结算记录
func InsertOneChannelSettlementRecord(ctx context.Context, ChannelSettlementRecord *ChannelSettlementRecord) error {
	if _, err := dbRecord.InsertOne(ctx, ChannelSettlementRecord); err != nil {
		log.Warn("ChannelSettlementRecord:InsertOneChannelSettlementRecord dbRecord.InsertOne failed", log.E(err))
		return err
	}
	return nil
}

//FindOneChannelSettlementRecord 查找一个结算记录
func FindOneChannelSettlementRecord(ctx context.Context, filter bson.M) (
	*ChannelSettlementRecord, error) {
	var ChannelSettlementRecord ChannelSettlementRecord
	if err := dbRecord.FindOne(ctx, &ChannelSettlementRecord, filter); err != nil {
		return nil, err
	}
	return &ChannelSettlementRecord, nil
}

//FindOneChannelSettlementRecordEx 查找一个结算记录
func FindOneChannelSettlementRecordEx(ctx context.Context, filter bson.M) (
	*ChannelSettlementRecord, error) {
	var ChannelSettlementRecord ChannelSettlementRecord
	if err := dbRecord.FindOneEx(ctx, &ChannelSettlementRecord, filter); err != nil {
		return nil, err
	}
	return &ChannelSettlementRecord, nil
}

//DelOneChannelSettlementRecord 删除一个结算记录
func DelOneChannelSettlementRecord(ctx context.Context, filter bson.M) (
	int64, error) {
	count, err := dbRecord.DeleteOne(ctx, filter)
	if err != nil {
		log.Warn("ChannelSettlementRecord:DelOneChannelSettlementRecord dbRecord.DeleteOne failed",
			log.E(err), log.Any("filter", filter))
		return 0, err
	}
	return count, nil
}

//UpdateOneChannelSettlementRecord 更新一个结算记录
func UpdateOneChannelSettlementRecord(ctx context.Context, filter bson.M, update bson.M) error {
	_, err := dbRecord.UpdateOne(ctx, filter, update)
	if err != nil {
		log.Warn("user:UpdateOneChannelSettlementRecord dbRecord.UpdateOne failed",
			log.E(err), log.Any("filter", filter))
		return err
	}
	return nil
}

//CountChannelSettlementRecords 统计结算记录数量
func CountChannelSettlementRecords(ctx context.Context, filter bson.M) (
	int64, error) {
	count, err := dbRecord.Count(ctx, filter)
	if err != nil {
		log.Warn("ChannelSettlementRecord:CountChannelSettlementRecords dbRecord.Count failed",
			log.E(err), log.Any("filter", filter))
		return 0, err
	}
	return count, nil
}

//UpdateManyChannelSettlementRecord 更新满足条件的结算记录
func UpdateManyChannelSettlementRecord(ctx context.Context, filter bson.M, update bson.M) error {
	_, err := dbRecord.UpdateMany(ctx, filter, update)
	if err != nil {
		log.Warn("user:UpdateManyChannelSettlementRecord dbRecord.UpdateMany failed",
			log.E(err), log.Any("filter", filter))
		return err
	}
	return nil
}

//FindManyChannelSettlementRecord 查找一批结算记录数据
func FindManyChannelSettlementRecord(ctx context.Context, filter bson.M,
	opts ...*options.FindOptions) (ChannelSettlementRecordList, error) {
	data := make(ChannelSettlementRecordList, 0)
	if err := dbRecord.Find(ctx, &data, filter, opts...); err != nil {
		log.Warn("ChannelSettlementRecord:FindManyChannelSettlementRecord dbRecord.Find failed", log.E(err), log.Any("filter", filter))
		return nil, err
	}
	return data, nil
}

//FindManyChannelSettlementRecordWithBind 用自己定义结构查找一批结算记录数据
func FindManyChannelSettlementRecordWithBind(ctx context.Context, bind interface{}, filter bson.M,
	opts ...*options.FindOptions) error {
	if err := dbRecord.Find(ctx, bind, filter, opts...); err != nil {
		log.Warn("ChannelSettlementRecord:FindManyChannelSettlementRecordWithBind dbRecord.Find failed", log.E(err), log.Any("filter", filter))
		return err
	}
	return nil
}

//AggregateChannelSettlementRecords 聚合查找一批结算记录信息
func AggregateChannelSettlementRecords(ctx context.Context,
	bind interface{}, pipeline []bson.M) error {
	if err := dbRecord.Aggregate(ctx, bind, pipeline); err != nil {
		log.Warn("feedback:AggregateChannelSettlementRecords dbRecord.Aggregate failed",
			log.E(err), log.Any("pipeline", pipeline))
		return err
	}
	return nil
}

// ----------------------------------------

//CountChannelSettlementRecords 统计结算记录数量
func CountChannelSettlementDeletes(ctx context.Context, filter bson.M) (
	int64, error) {
	count, err := dbDeleted.Count(ctx, filter)
	if err != nil {
		log.Warn("ChannelSettlementRecord:CountChannelSettlementDeletes dbDeleted.Count failed",
			log.E(err), log.Any("filter", filter))
		return 0, err
	}
	return count, nil
}

//InsertOneChannelSettlementDeleted 插入一个结算删除记录
func InsertOneChannelSettlementDeleted(ctx context.Context, ChannelSettlementRecord *ChannelSettlementRecord) error {
	if _, err := dbDeleted.InsertOne(ctx, ChannelSettlementRecord); err != nil {
		log.Warn("ChannelSettlementRecord:InsertOneChannelSettlementDeleted dbDeleted.InsertOne failed", log.E(err))
		return err
	}
	return nil
}

//FindOneChannelSettlementDeletedEx 查找一个结算删除记录
func FindOneChannelSettlementDeletedEx(ctx context.Context, filter bson.M) (
	*ChannelSettlementRecord, error) {
	var ChannelSettlementRecord ChannelSettlementRecord
	if err := dbDeleted.FindOneEx(ctx, &ChannelSettlementRecord, filter); err != nil {
		return nil, err
	}
	return &ChannelSettlementRecord, nil
}

//FindManyChannelSettlementDeleted 查找一批结算记录数据
func FindManyChannelSettlementDeleted(ctx context.Context, filter bson.M,
	opts ...*options.FindOptions) (ChannelSettlementRecordList, error) {
	data := make(ChannelSettlementRecordList, 0)
	if err := dbDeleted.Find(ctx, &data, filter, opts...); err != nil {
		log.Warn("ChannelSettlementRecord:FindManyChannelSettlementDeleted dbDeleted.Find failed", log.E(err), log.Any("filter", filter))
		return nil, err
	}
	return data, nil
}