// Code generated by gen mm. DO NOT EDIT.
package usermod

import (
	"context"
	"hkdj-web-server/pub/common/log"
	"hkdj-web-server/pub/common/srvdef"

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

/*

var (
    collUser *mongos.Collection
)

type getIndexeser interface {
    GetIndexes() []mongo.IndexModel
}

func Init(ctx context.Context) {
    collUser = mongos.Shop.Coll(TN.User)


    // create indexes for collection 'user's
	if v, ok := interface{}(&User{}).(getIndexeser); ok {
		if indexes := v.GetIndexes(); len(indexes) > 0  {
                if _, err := collUser.CreateIndex(ctx, indexes); err != nil {
                    log.Fatal("collUser.CreateIndex failed", log.E(err))
                    return
                }
            }
	}
}
*/
/*
// InsertOneUser 创建一个User
func InsertOneUser(ctx context.Context, data *User) *srvdef.SrvErr {
	_, err := db.InsertOne(ctx, data)
	if err != nil {
		log.Error("usermod:InsertOneUser db.InsertOne failed",
			log.Any("doc", data),
			log.E(err))
		return srvdef.New(srvdef.ErrDbInsertError, "", "")
	}
	return nil
}
*/

// InsertManyUsers 创建多个User
func InsertManyUsers(ctx context.Context, data []*User, opts ...*options.InsertManyOptions) *srvdef.SrvErr {
	_, err := db.InsertMany(ctx, &data)
	if err != nil {
		log.Error("usermod:InsertManyUsers db.InsertMany failed",
			log.Any("doc", data),
			log.E(err))
		return srvdef.New(srvdef.ErrDbInsertError, "", "")
	}
	return nil
}

/*
// FindOneUser 查找一个User
func FindOneUser(ctx context.Context, filter bson.M, opts ...*options.FindOneOptions) (
	*User, *srvdef.SrvErr) {
	var data *User
	if err := db.FindOneEx(ctx, &data, filter, opts...); err != nil {
		if err != mongo.ErrNoDocuments {
			log.Warn("usermod:FindOneUser db.FindOneEx failed",
				log.E(err), log.Any("filter", filter))
			return nil, srvdef.New(srvdef.ErrDbQueryError, "", "")
		}
		return nil, srvdef.New(srvdef.ErrNoData, "", "")
	}
	return data, nil
}
*/
// FindOneUserById  根据Id查找一个User
func FindOneUserById(ctx context.Context, id int64, opts ...*options.FindOneOptions) (
	*User, *srvdef.SrvErr) {
	filter := bson.M{
		FN.User.Id: id,
	}
	var data *User
	if err := db.FindOneEx(ctx, &data, filter, opts...); err != nil {
		if err != mongo.ErrNoDocuments {
			log.Warn("usermod:FindOneUser db.FindOneEx failed",
				log.E(err), log.Any("filter", filter))
			return nil, srvdef.New(srvdef.ErrDbQueryError, "", "")
		}
		return nil, srvdef.New(srvdef.ErrNoData, "", "")
	}
	return data, nil
}

// FindOneUserWithBind 用自定义结构查找一个User
func FindOneUserWithBind(ctx context.Context, bind interface{}, filter bson.M, opts ...*options.FindOneOptions) *srvdef.SrvErr {
	if err := db.FindOneEx(ctx, bind, filter, opts...); err != nil {
		if err != mongo.ErrNoDocuments {
			log.Warn("usermod:FindOneUserWithBind db.FindOneEx failed",
				log.E(err), log.Any("filter", filter))
			return srvdef.New(srvdef.ErrDbQueryError, "", "")
		}
		return srvdef.New(srvdef.ErrNoData, "", "")
	}
	return nil
}

// FindOneUserAndUpdate 更新查找一个User
func FindOneUserAndUpdate(ctx context.Context, filter bson.M, update bson.M, opts ...*options.FindOneAndUpdateOptions) (
	*User, *srvdef.SrvErr) {
	var data User
	err := db.FindOneAndUpdate(ctx, &data, filter, update, opts...)
	if err != nil {
		log.Warn("usermod:FindOneUserAndUpdate db.FindOneAndUpdate failed",
			log.E(err), log.Any("filter", filter))
		return nil, srvdef.New(srvdef.ErrDbUpdateError, "", "")
	}
	return &data, nil
}

/*

// DelOneUser 删除一个User
func DelOneUser(ctx context.Context, filter bson.M) (
	int64, *srvdef.SrvErr) {
	count, err := db.DeleteOne(ctx, filter)
	if err != nil {
		log.Warn("usermod:DelOneUser db.DeleteOne failed",
			log.E(err), log.Any("filter", filter))
		return 0, srvdef.New(srvdef.ErrDbDeleteError, "", "")
	}
	return count, nil
}

*/

// DelOneUserById  根据Id删除一个User
func DelOneUserById(ctx context.Context, id int64, opts ...*options.FindOneOptions) (
	int64, *srvdef.SrvErr) {
	filter := bson.M{
		FN.User.Id: id,
	}
	return DelOneUser(ctx, filter)
}

// DelManyUsers 删除多个User
func DelManyUsers(ctx context.Context, filter bson.M) (
	int64, *srvdef.SrvErr) {
	count, err := db.DeleteMany(ctx, filter)
	if err != nil {
		log.Warn("usermod:DelManyUsers} db.DeleteMany failed",
			log.E(err), log.Any("filter", filter))
		return 0, srvdef.New(srvdef.ErrDbDeleteError, "", "")
	}
	return count, nil
} /*
// UpdateOneUser 更新一个User
func UpdateOneUser(ctx context.Context, filter bson.M, update bson.M) *srvdef.SrvErr {
	_, err := db.UpdateOne(ctx, filter, update)
	if err != nil {
		log.Warn("usermod:UpdateOneUser db.UpdateOne failed",
			log.E(err), log.Any("filter", filter))
		return srvdef.New(srvdef.ErrDbUpdateError, "", "")
	}
	return nil
}*/
// MustUpdateOneUser 更新一个User
func MustUpdateOneUser(ctx context.Context, filter bson.M, update bson.M) *srvdef.SrvErr {
	result, err := db.UpdateOne(ctx, filter, update)
	if err != nil {
		log.Warn("usermod:UpdateOneUser db.UpdateOne failed",
			log.E(err), log.Any("filter", filter))
		return srvdef.New(srvdef.ErrDbUpdateError, "", "")
	}
	if result.MatchedCount != 1 {
		return srvdef.New(srvdef.ErrNoData, "", "")
	}
	return nil
}

// UpdateOneUserWithResult 更新一个User
func UpdateOneUserWithResult(ctx context.Context, filter bson.M, update bson.M, opts ...*options.UpdateOptions) (*mongo.UpdateResult, *srvdef.SrvErr) {
	result, err := db.UpdateOne(ctx, filter, update, opts...)
	if err != nil {
		log.Warn("usermod:UpdateOneUserWithResult db.UpdateOne failed",
			log.E(err), log.Any("filter", filter))
		return nil, srvdef.New(srvdef.ErrDbUpdateError, "", "")
	}
	if result.MatchedCount != 1 {
		return nil, srvdef.New(srvdef.ErrNoData, "", "")
	}
	return result, nil
}

// UpdateManyUsers 更新多个User
func UpdateManyUsers(ctx context.Context, filter bson.M, update bson.M) *srvdef.SrvErr {
	result, err := db.UpdateMany(ctx, filter, update)
	if err != nil {
		log.Warn("usermod:UpdateManyUsers db.UpdateMany failed",
			log.E(err), log.Any("filter", filter))
		return srvdef.New(srvdef.ErrDbUpdateError, "", "")
	}
	if result.MatchedCount <= 0 {
		log.Warn("usermod:UpdateManyUsers db.UpdateMany failed",
			log.E(err), log.Any("filter", filter))
	}
	return nil
}

/*

// CountUsers 统计User数量
func CountUsers(ctx context.Context, filter bson.M) (
	int64, *srvdef.SrvErr) {
	count, err := db.Count(ctx, filter)
	if err != nil {
		log.Warn("usermod:CountUsers db.Count failed",
			log.E(err), log.Any("filter", filter))
		return 0, srvdef.New(srvdef.ErrDbQueryError, "", "")
	}
	return count, nil
}

*/

// FindManyUsers 查找一批User
func FindManyUsers(ctx context.Context, filter bson.M,
	opts ...*options.FindOptions) ([]*User, *srvdef.SrvErr) {
	data := make([]*User, 0)
	if err := db.Find(ctx, &data, filter, opts...); err != nil {
		log.Warn("usermod:FindManyUsers db.Find failed", log.E(err), log.Any("filter", filter))
		return nil, srvdef.New(srvdef.ErrDbQueryError, "", "")
	}
	return data, nil
}

// FindManyUsers 查找一批User
func FindManyUsersAsInt64Map(ctx context.Context, filter bson.M, keyFn func(*User) int64, opts ...*options.FindOptions) (map[int64]*User, *srvdef.SrvErr) {
	data := make([]*User, 0)
	if err := db.Find(ctx, &data, filter, opts...); err != nil {
		log.Warn("usermod:FindManyUsers db.Find failed", log.E(err), log.Any("filter", filter))
		return nil, srvdef.New(srvdef.ErrDbQueryError, "", "")
	}
	result := make(map[int64]*User)
	for _, item := range data {
		key := keyFn(item)
		if _, ok := result[key]; !ok {
			result[key] = item
		}
	}
	return result, nil
}

// FindManyUsersWithBind 用自己定义结构查找一批User数据
func FindManyUsersWithBind(ctx context.Context, bind interface{}, filter bson.M,
	opts ...*options.FindOptions) *srvdef.SrvErr {
	if err := db.Find(ctx, bind, filter, opts...); err != nil {
		log.Warn("usermod:FindManyUsersWithBind db.Find failed", log.E(err), log.Any("filter", filter))
		return srvdef.New(srvdef.ErrDbQueryError, "", "")
	}
	return nil
}

/*

// AggregateUsers 聚合查找一批User
func AggregateUsers(ctx context.Context,
	bind interface{}, pipeline []bson.M) *srvdef.SrvErr {
	if err := db.Aggregate(ctx, bind, pipeline); err != nil {
		log.Warn("usermod:AggregateUsers db.Aggregate failed",
			log.E(err), log.Any("pipeline", pipeline))
		return srvdef.New(srvdef.ErrDbQueryError, "", "")
	}
	return nil
}

*/

// ObjectAggregateUsers 聚合查找一批User数据
func ObjectAggregateUsers(ctx context.Context,
	bind interface{}, pipeline []bson.M) *srvdef.SrvErr {
	if err := db.ObjectAggregate(ctx, bind, pipeline); err != nil {
		log.Warn("usermod:ObjectAggregateUsers db.Aggregate failed",
			log.E(err), log.Any("pipeline", pipeline))
		return srvdef.New(srvdef.ErrDbQueryError, "", "")
	}
	return nil
}

// BulkWriteUsers 批量写入或者更新User数据
func BulkWriteUsers(ctx context.Context,
	docs []mongo.WriteModel, opts ...*options.BulkWriteOptions) *srvdef.SrvErr {
	_, err := db.BulkWrite(ctx, docs, opts...)
	if err != nil {
		return srvdef.New(srvdef.ErrDbUpdateError, "", "")
	}
	return nil
}

// UpsertOneUser UpsertOneUser
func UpsertOneUser(ctx context.Context, filter bson.M, update bson.M) (*mongo.UpdateResult, *srvdef.SrvErr) {
	result, err := db.UpsertOne(ctx, filter, update)
	if err != nil {
		log.Warn("usermod:UpsertOneUser db.UpdateOne failed",
			log.E(err), log.Any("filter", filter))
		return nil, srvdef.New(srvdef.ErrDbUpdateError, "", "")
	}
	return result, nil
}

// DistinctUser 查找指定字段的不同值
func DistinctUser(ctx context.Context, filter bson.M, fieldName string) ([]interface{}, *srvdef.SrvErr) {
	result, err := db.Distince(ctx, filter, fieldName)
	if err != nil {
		log.Warn("usermod:DistinctUser db.Distince failed",
			log.E(err), log.Any("filter", filter))
		return nil, srvdef.New(srvdef.ErrDbQueryError, "", "")
	}
	return result, nil
}