huangguo_server/models/v/activitymod/prize_pool.go

package activitymod

import (
	"errors"
	"fmt"
	"time"

	"91porn-server/common/db"
	"91porn-server/common/log"
	"91porn-server/models"

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

var prizePoolDB *db.MongoDB

func collPrizePool(t *db.MongoTool) *db.MongoTool {
	if t == nil {
		return prizePoolDB.Coll(models.ActivityPrizePool)
	}
	return t.Coll(models.ActivityPrizePool)
}

// initPrizePoolIndex 索引设置
func initPrizePoolIndex() {
	many := []mongo.IndexModel{ //batch set indexes   //value is the type 1 or -1
		{
			Keys:    bson.D{{Key: "activityId", Value: 1}},
			Options: options.Index().SetUnique(true),
		},
		{
			Keys: bson.D{{Key: "createTime", Value: -1}},
		},
	}
	_, err := collPrizePool(nil).CreateIndex(many)
	if err != nil {
		panic(fmt.Sprintf("%s model set index err ==>[%+v]", table, err))
	}
}

func GetPrizePool(activityID primitive.ObjectID) (*PrizePool, error) {
	var out *PrizePool
	if err := collPrizePool(nil).FindOne(&out, bson.M{"activityId": activityID}); err != nil {
		log.Error(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "GetPrizePool", models.ActivityPrizePool, "FindOne", err),
			log.Any("activityID", activityID),
		)
		return nil, err
	}
	return out, nil
}

func UpdatePrizePoolInc(t *db.MongoTool, activityID primitive.ObjectID, reservoir, systemIncome, systemRake int64) error {
	result, err := collPrizePool(t).UpdateOne(bson.M{"activityId": activityID}, bson.M{"$inc": bson.M{
		"reservoir":    reservoir,
		"systemIncome": systemIncome,
		"systemRake":   systemRake,
	}})
	if err != nil {
		log.Error(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "UpdatePrizePoolInc", models.ActivityPrizePool, "UpdateOne", err),
			log.Any("activityID", activityID),
			log.Any("reservoir", reservoir),
			log.Any("systemIncome", systemIncome),
			log.Any("systemRake", systemRake),
		)
		return err
	}
	if result.ModifiedCount == 0 {
		err = errors.New("activity UpdateOne ModifiedCount err")
		log.Warn(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "UpdatePrizePoolInc", models.ActivityPrizePool, "result.ModifiedCount == 0", err),
			log.Any("activityID", activityID),
			log.Any("reservoir", reservoir),
			log.Any("systemIncome", systemIncome),
			log.Any("systemRake", systemRake),
		)
		return err
	}
	return nil
}

// 新增活动奖池
func AddPrizePool(in AddPrizePoolCond) (interface{}, error) {
	result, err := collPrizePool(nil).InsertOne(&PrizePool{
		ActivityID:      in.ActivityID,
		Model:           in.Model,
		EstimatedIncome: in.EstimatedIncome,
		Price:           in.Price,
		FreeCount:       in.FreeCount,
		UpdateTime:      time.Now(),
		CreateTime:      time.Now(),
	})
	if err != nil {
		log.Error(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "AddPrizePool", models.ActivityPrizePool, "InsertOne", err),
			log.Any("in", in),
		)
		return nil, err
	}
	return result, nil
}

// 修改活动奖池
func ModifyPrizePool(filter, update primitive.M) error {
	result, err := collPrizePool(nil).UpdateOne(filter, update)
	if err != nil {
		log.Error(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "ModifyPrizePool", models.ActivityPrizePool, "UpdateOne", err),
			log.Any("filter", filter),
			log.Any("update", update),
		)
		return err
	}
	if result.ModifiedCount == 0 {
		err = errors.New("activity UpdateOne ModifiedCount err")
		log.Warn(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "ModifyPrizePool", models.ActivityPrizePool, "result.ModifiedCount == 0", err),
			log.Any("filter", filter),
			log.Any("update", update),
		)
		return err
	}
	return nil
}

// 查询活动奖池列表
func QueryAllPrizePool(filter primitive.M, opts ...*options.FindOptions) ([]*PrizePool, error) {
	var out []*PrizePool = []*PrizePool{}
	if err := collPrizePool(nil).Find(&out, filter, opts...); err != nil {
		log.Error(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "QueryAllPrizePool", models.ActivityPrizePool, "Find", err),
			log.Any("filter", filter),
		)
		return nil, err
	}
	return out, nil
}

// 查询活动奖池总条数
func CountPrizePool(filter primitive.M) (int64, error) {
	count, err := collPrizePool(nil).Count(filter)
	if err != nil {
		log.Error(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "CountPrizePool", models.ActivityPrizePool, "Count", err),
			log.Any("filter", filter),
		)
		return 0, err
	}
	return count, nil
}