stat_center/models/channelmod/channel.go

package channelmod

import (
	"context"
	"fmt"
	"stat/common/log"
	"stat/common/mongos"

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

var dbChannel *mongos.MongoTool
var dbRule *mongos.MongoTool
var dbStat *mongos.MongoTool
var dbSettlement *mongos.MongoTool
var dbChannelOwnerChange *mongos.MongoTool

var dbStatYestoday *mongos.MongoTool

func Init() {
	ctx := context.Background()
	InitChannel(ctx)
	InitStat(ctx)
	InitRule(ctx)
	InitSettlement(ctx)
	InitStatYestoday(ctx)
	InitChannelOwnerChange(ctx)
}

func InitRule(ctx context.Context) {
	// 获取数据库表
	dbRule = mongos.New(mongos.MgoManager, TN.ChannelDeductionRule)

	// 初始化
	indexes := []mongo.IndexModel{
		{
			Keys:    bson.D{{Key: FN.ChannelDeductionRule.Channel, Value: 1}, {Key: FN.ChannelDeductionRule.AppId, Value: 1}},
			Options: options.Index().SetUnique(true),
		},
	}
	if _, err := dbRule.CreateIndex(context.Background(), indexes); err != nil {
		panic(fmt.Sprintf("%s model set index err ==>[%+v]", TN.ChannelDeductionRule, err))
	}
}

func InitStat(ctx context.Context) {
	// 获取数据库表
	dbStat = mongos.New(mongos.MgoManager, TN.ChannelStat)

	// 初始化
	indexes := []mongo.IndexModel{
		{
			Keys:    bson.D{{Key: FN.ChannelStat.Channel, Value: 1}, {Key: FN.ChannelStat.AppId, Value: 1}, {Key: FN.ChannelStat.SumDate, Value: 1}},
			Options: options.Index().SetUnique(true),
		},
		{
			Keys: bson.D{{Key: FN.ChannelStat.SumDate, Value: -1}, {Key: FN.ChannelStat.NewDirectCount, Value: -1}},
		},
		{
			Keys: bson.D{{Key: FN.ChannelStat.CreatedAt, Value: -1}},
		},
		// {
		// 	Keys: bson.D{{Key: FN.ChannelStat.NewDirectCount, Value: -1}},
		// },
		{
			Keys: bson.D{
				{Key: FN.ChannelStat.Channel, Value: 1},
				{Key: FN.ChannelStat.ParentChannel, Value: 1},
				{Key: FN.ChannelStat.AppId, Value: 1},
				{Key: FN.ChannelStat.SumDate, Value: -1},
				{Key: FN.ChannelStat.Type, Value: 1},
			},
		},
		{
			Keys: bson.D{{Key: FN.ChannelStat.Type, Value: 1}},
		},
		// {
		// 	Keys: bson.D{{Key: FN.ChannelStat.IsPay, Value: 1}},
		// },
		// {
		// 	Keys: bson.D{{Key: FN.ChannelStat.SumDate, Value: -1}},
		// },
		// {
		// 	Keys: bson.D{{Key: FN.ChannelStat.AppId, Value: 1}},
		// },
		{
			Keys: bson.D{
				{Key: FN.ChannelStat.AppId, Value: 1},
				{Key: FN.ChannelStat.SumDate, Value: -1},
			},
		},
	}
	if _, err := dbStat.CreateIndex(context.Background(), indexes); err != nil {
		panic(fmt.Sprintf("%s model set index err ==>[%+v]", TN.ChannelStat, err))
	}
}

func InitStatYestoday(ctx context.Context) {
	// 获取数据库表
	dbStatYestoday = mongos.New(mongos.MgoManager, TN.ChannelStatYestoday)

	// 初始化
	indexes := []mongo.IndexModel{
		{
			Keys:    bson.D{{Key: FN.ChannelStatYestoday.Channel, Value: 1}, {Key: FN.ChannelStatYestoday.AppId, Value: 1}, {Key: FN.ChannelStatYestoday.SumDate, Value: 1}},
			Options: options.Index().SetUnique(true),
		},
		{
			Keys: bson.D{{Key: FN.ChannelStatYestoday.SumDate, Value: -1}, {Key: FN.ChannelStatYestoday.NewCount, Value: -1}},
		},
		{
			Keys: bson.D{
				{Key: FN.ChannelStatYestoday.SumDate, Value: -1},
			},
			Options: options.Index().SetExpireAfterSeconds(3 * 24 * 60 * 60),
		},
	}
	if _, err := dbStatYestoday.CreateIndex(context.Background(), indexes); err != nil {
		panic(fmt.Sprintf("%s model set index err ==>[%+v]", TN.ChannelStatYestoday, err))
	}
}

func InitSettlement(ctx context.Context) {
	// 获取数据库表
	dbSettlement = mongos.New(mongos.MgoManager, TN.ChannelSettlement)

	// 初始化
	indexes := []mongo.IndexModel{
		{
			Keys:    bson.D{{Key: FN.ChannelSettlement.Channel, Value: 1}, {Key: FN.ChannelSettlement.AppId, Value: 1}, {Key: FN.ChannelSettlement.SumDate, Value: 1}},
			Options: options.Index().SetUnique(true),
		},
		{
			Keys:    bson.D{{Key: FN.ChannelSettlement.CreatedAt, Value: -1}},
			Options: options.Index().SetExpireAfterSeconds(5 * 24 * 60 * 60),
		},
	}
	if _, err := dbSettlement.CreateIndex(context.Background(), indexes); err != nil {
		panic(fmt.Sprintf("%s model set index err ==>[%+v]", TN.ChannelSettlement, err))
	}
}

func InitChannel(ctx context.Context) {
	// 获取数据库表
	dbChannel = mongos.New(mongos.MgoManager, TN.ChannelInfo)

	// 初始化
	indexes := []mongo.IndexModel{
		{
			Keys:    bson.D{{Key: FN.ChannelInfo.Channel, Value: 1}},
			Options: options.Index().SetUnique(true),
		},
		{
			Keys: bson.D{
				{Key: FN.ChannelInfo.ParentAgent, Value: 1},
			},
		},
		{
			Keys: bson.D{
				{Key: FN.ChannelInfo.ParentChannel, Value: 1},
			},
		},
	}
	if _, err := dbChannel.CreateIndex(context.Background(), indexes); err != nil {
		panic(fmt.Sprintf("%s model set index err ==>[%+v]", TN.ChannelInfo, err))
	}
}

func InitChannelOwnerChange(ctx context.Context) {
	// 获取数据库表
	dbChannelOwnerChange = mongos.New(mongos.MgoManager, TN.ChannelOwnerChange)

	// 初始化
	indexes := []mongo.IndexModel{
		{
			Keys: bson.D{{Key: FN.ChannelOwnerChange.Channel, Value: -1}},
		},
		{
			Keys: bson.D{
				{Key: FN.ChannelOwnerChange.NewUser, Value: -1},
				{Key: FN.ChannelOwnerChange.OldUser, Value: -1},
			},
		},
	}
	if _, err := dbChannelOwnerChange.CreateIndex(context.Background(), indexes); err != nil {
		panic(fmt.Sprintf("%s model set index err ==>[%+v]", TN.ChannelOwnerChange, err))
	}
}

// InsertOneChannelInfo 插入一个渠道信息
func InsertOneChannelInfo(ctx context.Context, media *ChannelInfo) error {
	if _, err := dbChannel.InsertOne(ctx, media); err != nil {
		log.Warn("media:InsertOneChannelInfo db.InsertOne failed", log.E(err))
		return err
	}
	return nil
}

// FindOneChannelInfo 查找一个渠道信息
func FindOneChannelInfo(ctx context.Context, filter bson.M) (*ChannelInfo, error) {
	var ChannelInfo ChannelInfo
	if err := dbChannel.FindOne(ctx, &ChannelInfo, filter); err != nil {
		log.Warn("ChannelInfo:FindOneChannelInfo dbChannel.FindOne failed",
			log.E(err), log.Any("filter", filter))
		return nil, err
	}
	return &ChannelInfo, nil
}

// FindOneChannelInfo 查找一个渠道信息
func FindOneChannelInfoEx(ctx context.Context, filter bson.M) (*ChannelInfo, error) {
	var ChannelInfo ChannelInfo
	if err := dbChannel.FindOneEx(ctx, &ChannelInfo, filter); err != nil {
		log.Warn("ChannelInfo:FindOneChannelInfoEx dbChannel.FindOneEx failed",
			log.E(err), log.Any("filter", filter))
		return nil, err
	}
	return &ChannelInfo, nil
}

// DelOneChannelInfo 删除一个渠道信息
func DelOneChannelInfo(ctx context.Context, filter bson.M) (int64, error) {
	count, err := dbChannel.DeleteOne(ctx, filter)
	if err != nil {
		log.Warn("ChannelInfo:DelOneChannelInfo dbChannel.DeleteOne failed",
			log.E(err), log.Any("filter", filter))
		return 0, err
	}
	return count, nil
}

// UpdateOneChannelInfo 更新一个渠道信息
func UpdateOneChannelInfo(ctx context.Context, filter bson.M, update bson.M) error {
	_, err := dbChannel.UpdateOne(ctx, filter, update)
	if err != nil {
		log.Warn("user:UpdateOneChannelInfo dbChannel.UpdateOne failed",
			log.E(err), log.Any("filter", filter))
		return err
	}

	return nil
}

// CountChannelInfos 统计渠道信息数量
func CountChannelInfos(ctx context.Context, filter bson.M) (int64, error) {
	count, err := dbChannel.Count(ctx, filter)
	if err != nil {
		log.Warn("ChannelInfo:CountChannelInfos dbChannel.Count failed",
			log.E(err), log.Any("filter", filter))
		return 0, err
	}
	return count, nil
}

// UpdateManyChannelInfo 更新满足条件的渠道信息
func UpdateManyChannelInfo(ctx context.Context, filter bson.M, update bson.M) error {
	_, err := dbChannel.UpdateMany(ctx, filter, update)
	if err != nil {
		log.Warn("user:UpdateManyChannelInfo dbChannel.UpdateMany failed",
			log.E(err), log.Any("filter", filter))
		return err
	}
	return nil
}

// FindManyChannelInfo 查找一批渠道信息数据
func FindManyChannelInfo(ctx context.Context, filter bson.M, opts ...*options.FindOptions) (ChannelInfoList, error) {
	data := make(ChannelInfoList, 0)
	if err := dbChannel.Find(ctx, &data, filter, opts...); err != nil {
		log.Warn("ChannelInfo:FindManyChannelInfo dbChannel.Find failed", log.E(err), log.Any("filter", filter))
		return nil, err
	}
	return data, nil
}

// FindManyChannelInfoWithBind 用自己定义结构查找一批渠道信息数据
func FindManyChannelInfoWithBind(ctx context.Context, bind interface{}, filter bson.M, opts ...*options.FindOptions) error {
	if err := dbChannel.Find(ctx, bind, filter, opts...); err != nil {
		log.Warn("ChannelInfo:FindManyChannelInfoWithBind dbChannel.Find failed", log.E(err), log.Any("filter", filter))
		return err
	}
	return nil
}

// InsertOneChannelDeductionRule 插入一个渠道扣量规则
func InsertOneChannelDeductionRule(ctx context.Context, media *ChannelDeductionRule) error {
	if _, err := dbRule.InsertOne(ctx, media); err != nil {
		log.Warn("media:InsertOneChannelDeductionRule db.InsertOne failed", log.E(err))
		return err
	}
	return nil
}

// FindOneChannelDeductionRule 查找一个渠道扣量规则
func FindOneChannelDeductionRule(ctx context.Context, filter bson.M) (*ChannelDeductionRule, error) {
	var ChannelDeductionRule ChannelDeductionRule
	if err := dbRule.FindOne(ctx, &ChannelDeductionRule, filter); err != nil {
		log.Warn("ChannelDeductionRule:FindOneChannelDeductionRule dbChannel.FindOne failed",
			log.E(err), log.Any("filter", filter))
		return nil, err
	}
	return &ChannelDeductionRule, nil
}

// FindOneChannelDeductionRuleEx 查找一个渠道扣量规则
func FindOneChannelDeductionRuleEx(ctx context.Context, filter bson.M) (*ChannelDeductionRule, error) {
	var ChannelDeductionRule ChannelDeductionRule
	if err := dbRule.FindOneEx(ctx, &ChannelDeductionRule, filter); err != nil {
		log.Warn("ChannelDeductionRule:FindOneChannelDeductionRuleEx dbChannel.FindOneEx failed",
			log.E(err), log.Any("filter", filter))
		return nil, err
	}
	return &ChannelDeductionRule, nil
}

// DelOneChannelDeductionRule 删除一个渠道扣量规则
func DelOneChannelDeductionRule(ctx context.Context, filter bson.M) (int64, error) {
	count, err := dbRule.DeleteOne(ctx, filter)
	if err != nil {
		log.Warn("ChannelDeductionRule:DelOneChannelDeductionRule dbChannel.DeleteOne failed",
			log.E(err), log.Any("filter", filter))
		return 0, err
	}
	return count, nil
}

// UpdateOneChannelDeductionRule 更新一个渠道扣量规则
func UpdateOneChannelDeductionRule(ctx context.Context, filter bson.M, update bson.M) error {
	_, err := dbRule.UpdateOne(ctx, filter, update)
	if err != nil {
		log.Warn("UpdateOneChannelDeductionRule dbChannel.UpdateOne failed",
			log.E(err), log.Any("filter", filter))
		return err
	}

	return nil
}

// CountChannelDeductionRules 统计渠道扣量规则数量
func CountChannelDeductionRules(ctx context.Context, filter bson.M) (int64, error) {
	count, err := dbRule.Count(ctx, filter)
	if err != nil {
		log.Warn("ChannelDeductionRule:CountChannelDeductionRules dbChannel.Count failed",
			log.E(err), log.Any("filter", filter))
		return 0, err
	}
	return count, nil
}

// UpdateManyChannelDeductionRule 更新满足条件的渠道扣量规则
func UpdateManyChannelDeductionRule(ctx context.Context, filter bson.M, update bson.M) error {
	_, err := dbRule.UpdateMany(ctx, filter, update)
	if err != nil {
		log.Warn("user:UpdateManyChannelDeductionRule dbChannel.UpdateMany failed",
			log.E(err), log.Any("filter", filter))
		return err
	}
	return nil
}

// FindManyChannelDeductionRule 查找一批渠道扣量规则数据
func FindManyChannelDeductionRule(ctx context.Context, filter bson.M, opts ...*options.FindOptions) (ChannelDeductionRuleList, error) {
	data := make(ChannelDeductionRuleList, 0)
	if err := dbRule.Find(ctx, &data, filter, opts...); err != nil {
		log.Warn("ChannelDeductionRule:FindManyChannelDeductionRule dbChannel.Find failed", log.E(err), log.Any("filter", filter))
		return nil, err
	}
	return data, nil
}

// FindManyChannelDeductionRuleWithBind 用自己定义结构查找一批渠道扣量规则数据
func FindManyChannelDeductionRuleWithBind(ctx context.Context, bind interface{}, filter bson.M, opts ...*options.FindOptions) error {
	if err := dbRule.Find(ctx, bind, filter, opts...); err != nil {
		log.Warn("ChannelDeductionRule:FindManyChannelDeductionRuleWithBind dbChannel.Find failed", log.E(err), log.Any("filter", filter))
		return err
	}
	return nil
}

// InsertOneChannelStat 插入一个渠道统计信息
func InsertOneChannelStat(ctx context.Context, media *ChannelStat) error {
	if _, err := dbStat.InsertOne(ctx, media); err != nil {
		log.Warn("media:InsertOneChannelStat db.InsertOne failed", log.E(err))
		return err
	}
	return nil
}

// FindOneChannelStat 查找一个渠道日常统计
func FindOneChannelStat(ctx context.Context, filter bson.M) (*ChannelStat, error) {
	var ChannelStat ChannelStat
	if err := dbStat.FindOne(ctx, &ChannelStat, filter); err != nil {
		log.Warn("ChannelStat:FindOneChannelStat dbStat.FindOne failed",
			log.E(err), log.Any("filter", filter))
		return nil, err
	}
	return &ChannelStat, nil
}

// DelOneChannelStat 删除一个渠道日常统计
func DelOneChannelStat(ctx context.Context, filter bson.M) (int64, error) {
	count, err := dbStat.DeleteOne(ctx, filter)
	if err != nil {
		log.Warn("ChannelStat:DelOneChannelStat dbStat.DeleteOne failed",
			log.E(err), log.Any("filter", filter))
		return 0, err
	}
	return count, nil
}

// UpdateOneChannelStat 更新一个渠道日常统计
func UpdateOneChannelStat(ctx context.Context, filter bson.M, update bson.M) error {
	_, err := dbStat.UpdateOne(ctx, filter, update)
	if err != nil {
		log.Warn("UpdateOneChannelStat dbStat.UpdateOne failed",
			log.E(err), log.Any("filter", filter))
		return err
	}

	return nil
}

// CountChannelStats 统计渠道日常统计数量
func CountChannelStats(ctx context.Context, filter bson.M) (int64, error) {
	count, err := dbStat.Count(ctx, filter)
	if err != nil {
		log.Warn("ChannelStat:CountChannelStats dbStat.Count failed",
			log.E(err), log.Any("filter", filter))
		return 0, err
	}
	return count, nil
}

// UpdateManyChannelStat 更新满足条件的渠道日常统计
func UpdateManyChannelStat(ctx context.Context, filter bson.M, update bson.M) error {
	_, err := dbStat.UpdateMany(ctx, filter, update)
	if err != nil {
		log.Warn("user:UpdateManyChannelStat dbStat.UpdateMany failed",
			log.E(err), log.Any("filter", filter))
		return err
	}
	return nil
}

// UpdateManyChannelStat 更新满足条件的渠道日常统计
func UpdateManyChannelStatWithResult(ctx context.Context, filter bson.M, update bson.M) (int64, error) {
	result, err := dbStat.UpdateMany(ctx, filter, update)
	if err != nil {
		log.Warn("user:UpdateManyChannelStatWithResult dbStat.UpdateMany failed",
			log.E(err), log.Any("filter", filter))
		return 0, err
	}
	return result.MatchedCount, nil
}

// FindManyChannelStat 查找一批渠道日常统计数据
func FindManyChannelStat(ctx context.Context, filter bson.M, opts ...*options.FindOptions) (ChannelStatList, error) {
	data := make(ChannelStatList, 0)
	if err := dbStat.Find(ctx, &data, filter, opts...); err != nil {
		log.Warn("ChannelStat:FindManyChannelStat dbStat.Find failed", log.E(err), log.Any("filter", filter))
		return nil, err
	}
	return data, nil
}

type OnItem func(item *ChannelStat)

// FindManyChannelStatShard 查找一批渠道日常统计数据
func FindManyChannelStatShard(ctx context.Context, filter bson.M, shard int64, onItem OnItem) error {
	num := int64(0)
	for {
		opt := &options.FindOptions{}
		opt.SetSkip(num * shard)
		opt.SetLimit(shard)
		lst := make(ChannelStatList, 0)
		if err := dbStat.Find(ctx, &lst, filter, opt); err != nil {
			log.Warn("ChannelStat:FindManyChannelStatShard dbStat.Find failed", log.E(err), log.Any("filter", filter))
			return err
		}
		for _, item := range lst {
			onItem(item)
		}
		if int64(len(lst)) < shard {
			break
		}
		lst = nil
		num++
	}
	return nil
}

// FindManyChannelStatWithBind 用自己定义结构查找一批渠道日常统计数据
func FindManyChannelStatWithBind(ctx context.Context, bind interface{}, filter bson.M, opts ...*options.FindOptions) error {
	if err := dbStat.Find(ctx, bind, filter, opts...); err != nil {
		log.Warn("ChannelStat:FindManyChannelStatWithBind dbStat.Find failed", log.E(err), log.Any("filter", filter))
		return err
	}
	return nil
}

// InsertOneChannelSettlement 插入一个渠道统计信息
func InsertOneChannelSettlement(ctx context.Context, media *ChannelSettlement) error {
	if _, err := dbSettlement.InsertOne(ctx, media); err != nil {
		log.Warn("media:InsertOneChannelSettlement dbSettlement.InsertOne failed", log.E(err))
		return err
	}
	return nil
}

// FindOneChannelSettlement 查找一个15分钟结算
func FindOneChannelSettlement(ctx context.Context, filter bson.M) (*ChannelSettlement, error) {
	var ChannelSettlement ChannelSettlement
	if err := dbSettlement.FindOne(ctx, &ChannelSettlement, filter); err != nil {
		log.Warn("ChannelSettlement:FindOneChannelSettlement dbSettlement.FindOne failed",
			log.E(err), log.Any("filter", filter))
		return nil, err
	}
	return &ChannelSettlement, nil
}

// DelOneChannelSettlement 删除一个15分钟结算
func DelOneChannelSettlement(ctx context.Context, filter bson.M) (int64, error) {
	count, err := dbSettlement.DeleteOne(ctx, filter)
	if err != nil {
		log.Warn("ChannelSettlement:DelOneChannelSettlement dbSettlement.DeleteOne failed",
			log.E(err), log.Any("filter", filter))
		return 0, err
	}
	return count, nil
}

// UpdateOneChannelSettlement 更新一个15分钟结算
func UpdateOneChannelSettlement(ctx context.Context, filter bson.M, update bson.M) error {
	_, err := dbSettlement.UpdateOne(ctx, filter, update)
	if err != nil {
		log.Warn("UpdateOneChannelSettlement dbSettlement.UpdateOne failed",
			log.E(err), log.Any("filter", filter))
		return err
	}

	return nil
}

// CountChannelSettlements 统计15分钟结算数量
func CountChannelSettlements(ctx context.Context, filter bson.M) (int64, error) {
	count, err := dbSettlement.Count(ctx, filter)
	if err != nil {
		log.Warn("ChannelSettlement:CountChannelSettlements dbSettlement.Count failed",
			log.E(err), log.Any("filter", filter))
		return 0, err
	}
	return count, nil
}

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

// FindManyChannelSettlement 查找一批渠道15分钟结算
func FindManyChannelSettlement(ctx context.Context, filter bson.M, opts ...*options.FindOptions) (ChannelSettlementList, error) {
	data := make(ChannelSettlementList, 0)
	if err := dbSettlement.Find(ctx, &data, filter, opts...); err != nil {
		log.Warn("ChannelSettlement:FindManyChannelSettlement dbSettlement.Find failed", log.E(err), log.Any("filter", filter))
		return nil, err
	}
	return data, nil
}

// FindManyChannelSettlementWithBind 用自己定义结构查找一批渠道15分钟结算
func FindManyChannelSettlementWithBind(ctx context.Context, bind interface{}, filter bson.M, opts ...*options.FindOptions) error {
	if err := dbSettlement.Find(ctx, bind, filter, opts...); err != nil {
		log.Warn("ChannelSettlement:FindManyChannelSettlementWithBind dbSettlement.Find failed", log.E(err), log.Any("filter", filter))
		return err
	}
	return nil
}

// FindManyChannelStatYestoday 查找一批渠道日常统计数据
func FindManyChannelStatYestoday(ctx context.Context, filter bson.M, opts ...*options.FindOptions) (ChannelStatYestodayList, error) {
	data := make(ChannelStatYestodayList, 0)
	if err := dbStatYestoday.Find(ctx, &data, filter, opts...); err != nil {
		log.Warn("ChannelStat:FindManyChannelStat dbStat.Find failed", log.E(err), log.Any("filter", filter))
		return nil, err
	}
	return data, nil
}

// InsertOneChannelStatYestoday 插入一个渠道统计信息
func InsertOneChannelStatYestoday(ctx context.Context, media *ChannelStatYesterday) error {
	if _, err := dbStatYestoday.InsertOne(ctx, media); err != nil {
		log.Warn("media:InsertOneChannelStat db.InsertOne failed", log.E(err))
		return err
	}
	return nil
}

// UpsertOneChannelStatYestoday 按 (channel, appId, sumDate) 覆盖写入一条同时段对比数据。
// 用 ReplaceOne 而不是 InsertOne: 整点任务可能因服务重启或重试在同一小时内跑第二次,
// 而该表有 (channel, appId, sumDate) 唯一索引,InsertOne 第二次必然冲突失败。
// 整条替换也保证快照不会残留上一次的旧值。
// 注意不可改用 UpsertMOne: 它内部用 Struct2Map 走 JSON 序列化,time.Time 会被写成字符串,
// sumDate 将不再是 BSON Date,按时间范围的查询会全部失效。
func UpsertOneChannelStatYestoday(ctx context.Context, doc *ChannelStatYesterday) error {
	filter := bson.M{
		FN.ChannelStatYestoday.Channel: doc.Channel,
		FN.ChannelStatYestoday.AppId:   doc.AppId,
		FN.ChannelStatYestoday.SumDate: doc.SumDate,
	}
	opt := options.Replace().SetUpsert(true)
	if _, err := dbStatYestoday.GetCollection().ReplaceOne(ctx, filter, doc, opt); err != nil {
		log.Warn("ChannelStatYestoday:UpsertOneChannelStatYestoday ReplaceOne failed",
			log.E(err), log.Any("filter", filter))
		return err
	}
	return nil
}

// CountChannelStatYestoday 统计渠道扣量规则数量
func CountChannelStatYestoday(ctx context.Context, filter bson.M) (int64, error) {
	count, err := dbStatYestoday.Count(ctx, filter)
	if err != nil {
		log.Warn("ChannelDeductionRule:CountChannelStatYestoday dbChannel.Count failed",
			log.E(err), log.Any("filter", filter))
		return 0, err
	}
	return count, nil
}

// InsertOneChannelOwnerChange 插入一个渠道信息
func InsertOneChannelOwnerChange(ctx context.Context, media *ChannelOwnerChange) error {
	if _, err := dbChannelOwnerChange.InsertOne(ctx, media); err != nil {
		log.Warn("media:InsertOneChannelOwnerChange db.InsertOne failed", log.E(err))
		return err
	}
	return nil
}

// FindOneChannelOwnerChange 查找一个渠道信息
func FindOneChannelOwnerChange(ctx context.Context, filter bson.M) (*ChannelOwnerChange, error) {
	var ChannelOwnerChange ChannelOwnerChange
	if err := dbChannelOwnerChange.FindOne(ctx, &ChannelOwnerChange, filter); err != nil {
		log.Warn("ChannelOwnerChange:FindOneChannelOwnerChange dbChannelOwnerChange.FindOne failed",
			log.E(err), log.Any("filter", filter))
		return nil, err
	}
	return &ChannelOwnerChange, nil
}

// FindOneChannelOwnerChange 查找一个渠道信息
func FindOneChannelOwnerChangeEx(ctx context.Context, filter bson.M) (*ChannelOwnerChange, error) {
	var ChannelOwnerChange ChannelOwnerChange
	if err := dbChannelOwnerChange.FindOneEx(ctx, &ChannelOwnerChange, filter); err != nil {
		log.Warn("ChannelOwnerChange:FindOneChannelOwnerChangeEx dbChannelOwnerChange.FindOneEx failed",
			log.E(err), log.Any("filter", filter))
		return nil, err
	}
	return &ChannelOwnerChange, nil
}

// DelOneChannelOwnerChange 删除一个渠道信息
func DelOneChannelOwnerChange(ctx context.Context, filter bson.M) (int64, error) {
	count, err := dbChannelOwnerChange.DeleteOne(ctx, filter)
	if err != nil {
		log.Warn("ChannelOwnerChange:DelOneChannelOwnerChange dbChannelOwnerChange.DeleteOne failed",
			log.E(err), log.Any("filter", filter))
		return 0, err
	}
	return count, nil
}

// UpdateOneChannelOwnerChange 更新一个渠道信息
func UpdateOneChannelOwnerChange(ctx context.Context, filter bson.M, update bson.M) error {
	_, err := dbChannelOwnerChange.UpdateOne(ctx, filter, update)
	if err != nil {
		log.Warn("user:UpdateOneChannelOwnerChange dbChannelOwnerChange.UpdateOne failed",
			log.E(err), log.Any("filter", filter))
		return err
	}

	return nil
}

// CountChannelOwnerChanges 统计渠道信息数量
func CountChannelOwnerChanges(ctx context.Context, filter bson.M) (int64, error) {
	count, err := dbChannelOwnerChange.Count(ctx, filter)
	if err != nil {
		log.Warn("ChannelOwnerChange:CountChannelOwnerChanges dbChannelOwnerChange.Count failed",
			log.E(err), log.Any("filter", filter))
		return 0, err
	}
	return count, nil
}

// UpdateManyChannelOwnerChange 更新满足条件的渠道信息
func UpdateManyChannelOwnerChange(ctx context.Context, filter bson.M, update bson.M) error {
	_, err := dbChannelOwnerChange.UpdateMany(ctx, filter, update)
	if err != nil {
		log.Warn("user:UpdateManyChannelOwnerChange dbChannelOwnerChange.UpdateMany failed",
			log.E(err), log.Any("filter", filter))
		return err
	}
	return nil
}

// FindManyChannelOwnerChanges 查找一批渠道信息数据
func FindManyChannelOwnerChanges(ctx context.Context, filter bson.M, opts ...*options.FindOptions) (ChannelOwnerChangeList, error) {
	data := make(ChannelOwnerChangeList, 0)
	if err := dbChannelOwnerChange.Find(ctx, &data, filter, opts...); err != nil {
		log.Warn("ChannelOwnerChange:FindManyChannelOwnerChange dbChannelOwnerChange.Find failed", log.E(err), log.Any("filter", filter))
		return nil, err
	}
	return data, nil
}

// FindManyChannelOwnerChangeWithBind 用自己定义结构查找一批渠道信息数据
func FindManyChannelOwnerChangeWithBind(ctx context.Context, bind interface{}, filter bson.M, opts ...*options.FindOptions) error {
	if err := dbChannelOwnerChange.Find(ctx, bind, filter, opts...); err != nil {
		log.Warn("ChannelOwnerChange:FindManyChannelOwnerChangeWithBind dbChannelOwnerChange.Find failed", log.E(err), log.Any("filter", filter))
		return err
	}
	return nil
}