root/huangguo_server
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Initial commit

Browse Source 
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
This commit is contained in:
root
2026-09-15 13:57:10 +08:00
co-authored by Claude Opus 5
commit 8679200f41
1897 changed files with 257900 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
models/v/activitymod/activity.go
+138
View File
@@ -0,0 +1,138 @@
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 mdb *db.MongoDB
const table = models.Activity
func coll(t *db.MongoTool) *db.MongoTool {
if t == nil {
return mdb.Coll(table)
}
return t.Coll(table)
}
// ActInitIndex 索引设置
func initIndex() {
coll := coll(nil)
many := []mongo.IndexModel{ //batch set indexes //value is the type 1 or -1
{
Keys: bson.D{{Key: "status", Value: 1}},
},
{
Keys: bson.D{{Key: "startTime", Value: -1}},
},
{
Keys: bson.D{{Key: "endTime", Value: -1}},
},
{
Keys: bson.D{{Key: "createdAt", Value: -1}},
},
{
Keys: bson.D{{Key: "updatedAt", Value: -1}},
},
}
if _, err := coll.CreateIndex(many); err != nil {
panic(fmt.Sprintf("%s model set index err ==>[%+v]", table, err))
}
}
// 获取活动信息
func Get(id primitive.ObjectID) (*Activity, error) {
var out *Activity
if err := coll(nil).FindOne(&out, bson.M{"_id": id}); err != nil {
log.Error(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "Get", models.Activity, "FindOne", err),
log.Any("id", id),
)
return nil, err
}
return out, nil
}
// 新增活动
func Add(in AddCond) (interface{}, error) {
result, err := coll(nil).InsertOne(&Activity{
Title: in.Title,
Desc: in.Desc,
Status: false,
StartTime: in.StartTime,
EndTime: in.EndTime,
UpdatedAt: time.Now(),
CreatedAt: time.Now(),
})
if err != nil {
log.Error(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "Add", models.Activity, "InsertOne", err),
log.Any("in", in),
)
return nil, err
}
return result, nil
}
// 修改活动
func Modify(t *db.MongoTool, filter, update primitive.M) error {
result, err := coll(nil).UpdateOne(filter, update)
if err != nil {
log.Error(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "Modify", models.Activity, "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:", "Modify", models.Activity, "result.ModifiedCount == 0", err),
log.Any("filter", filter),
log.Any("update", update),
)
return err
}
return nil
}
// 查询活动列表
func QueryAll(filter primitive.M, opts ...*options.FindOptions) ([]*Activity, error) {
var out []*Activity = []*Activity{}
if err := coll(nil).Find(&out, filter, opts...); err != nil {
log.Error(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "QueryAll", models.Activity, "Find", err),
log.Any("filter", filter),
)
return nil, err
}
return out, nil
}
// 查询总条数
func Count(filter primitive.M) (int64, error) {
count, err := coll(nil).Count(filter)
if err != nil {
log.Error(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "Count", models.Activity, "Count", err),
log.Any("filter", filter),
)
return 0, err
}
return count, nil
}
func QueryDropDownBox() ([]*Activity, error) {
var out []*Activity = []*Activity{}
if err := coll(nil).Find(&out, bson.M{"status": true}); err != nil {
log.Error(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "QueryDropDownBox", models.Activity, "Find", err))
return nil, err
}
return out, nil
}
models/v/activitymod/prize_pool.go
+146
View File
@@ -0,0 +1,146 @@
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
}
models/v/activitymod/prize_pool_type.go
+28
View File
@@ -0,0 +1,28 @@
package activitymod
import (
"time"
"go.mongodb.org/mongo-driver/bson/primitive"
)
type PrizePoolModel int
const (
Game PrizePoolModel = iota + 1 // 棋牌游戏
Free // 免费
)
type PrizePool struct {
ID primitive.ObjectID `json:"id" bson:"_id,omitempty"` // 文档ID
ActivityID primitive.ObjectID `json:"activityId" bson:"activityId"` // 活动ID
Model PrizePoolModel `json:"model" bson:"model"` // 奖池模式
Price int64 `json:"price" bson:"price"` // 单次抽奖金额
FreeCount int32 `json:"freeCount" bson:"freeCount"` // 免费次数
EstimatedIncome int64 `json:"estimatedIncome" bson:"estimatedIncome"` // 当日预计收益---杀放概率固定30%
Reservoir int64 `json:"reservoir" bson:"reservoir"` // 蓄水池---固定抽成5%
SystemIncome int64 `json:"systemIncome" bson:"systemIncome"` // 系统收益
SystemRake int64 `json:"systemRake" bson:"systemRake"` // 系统抽成金额---固定抽成5%
UpdateTime time.Time `json:"updateTime" bson:"updateTime"` // 修改时间
CreateTime time.Time `json:"createTimt" bson:"createTimt"` // 创建时间
}
models/v/activitymod/type.go
+32
View File
@@ -0,0 +1,32 @@
package activitymod
import (
"time"
"91porn-server/common/db"
"91porn-server/models"
"go.mongodb.org/mongo-driver/bson/primitive"
)
type Activity struct {
ID primitive.ObjectID `json:"id" bson:"_id,omitempty"` // 文档ID
Title string `json:"title" bson:"title"` // 活动名称
Desc string `json:"desc" bson:"desc"` // 活动注意事项
Status bool `json:"status" bson:"status"` // 状态---启用/禁用
StartTime time.Time `json:"startTime" bson:"startTime"` // 活动开始时间
EndTime time.Time `json:"endTime" bson:"endTime"` // 活动结束时间
UpdatedAt time.Time `json:"updatedAt" bson:"updatedAt"` // 文档更新时间
CreatedAt time.Time `json:"createdAt" bson:"createdAt"` // 文档创建时间
}
func Init() {
mdb = db.Init(table)
initIndex()
prizePoolDB = db.Init(models.ActivityPrizePool)
initPrizePoolIndex()
userFreeDB = db.Init(models.ActivityUserFree)
initUserFreeIndex()
userRecordDB = db.Init(models.ActivityUserRecord)
initUserRecordIndex()
}
models/v/activitymod/user_free.go
+117
View File
@@ -0,0 +1,117 @@
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 userFreeDB *db.MongoDB
func collUserFree(t *db.MongoTool) *db.MongoTool {
if t == nil {
return userFreeDB.Coll(models.ActivityUserFree)
}
return t.Coll(models.ActivityUserFree)
}
// initUserFreeIndex 索引设置
func initUserFreeIndex() {
many := []mongo.IndexModel{ //batch set indexes //value is the type 1 or -1
{
Keys: bson.D{{Key: "activityId", Value: 1}, {Key: "uid", Value: 1}},
Options: options.Index().SetUnique(true),
},
{
Keys: bson.D{{Key: "createTime", Value: -1}},
},
}
if _, err := collUserFree(nil).CreateIndex(many); err != nil {
panic(fmt.Sprintf("%s model set index err ==>[%+v]", table, err))
}
}
func GetUserFree(activityID primitive.ObjectID, uid uint64) (*UserFree, error) {
var out *UserFree
if err := collUserFree(nil).FindOne(&out, bson.M{"activityId": activityID, "uid": uid}); err != nil {
log.Error(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "AddUserFree", models.ActivityUserFree, "InsertOne", err),
log.Any("activityID", activityID),
log.Any("uid", uid),
)
return nil, err
}
return out, nil
}
func AddUserFree(activityID primitive.ObjectID, uid uint64, freeCount int32) error {
if _, err := collUserFree(nil).InsertOne(&UserFree{
ActivityID: activityID,
UID: uid,
FreeCount: freeCount,
UpdateTime: time.Now(),
CreateTime: time.Now(),
}); err != nil {
log.Error(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "AddUserFree", models.ActivityUserFree, "InsertOne", err),
log.Any("activityID", activityID),
log.Any("uid", uid),
log.Any("freeCount", freeCount),
)
return err
}
return nil
}
func UpdateOneUserFreeInc(t *db.MongoTool, activityID primitive.ObjectID, uid uint64, freeCount int32) error {
result, err := collUserFree(t).UpdateOne(bson.M{"activityId": activityID, "uid": uid},
bson.M{"$inc": bson.M{"freeCount": freeCount}, "$set": bson.M{"updateTime": time.Now()}})
if err != nil {
log.Error(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "UpdateOneInc", models.ActivityUserFree, "UpdateOne", err),
log.Any("activityID", activityID),
log.Any("uid", uid),
log.Any("freeCount", freeCount),
)
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:", "UpdateOneInc", models.ActivityUserFree, "result.ModifiedCount == 0", err),
log.Any("activityID", activityID),
log.Any("uid", uid),
log.Any("freeCount", freeCount),
)
return err
}
return nil
}
func UpdateOneSet(activityID primitive.ObjectID, uid uint64, freeCount int32) error {
result, err := collUserFree(nil).UpdateOne(bson.M{"activityId": activityID, "uid": uid},
bson.M{"$set": bson.M{"freeCount": freeCount, "updateTime": time.Now()}})
if err != nil {
log.Error(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "UpdateOneSet", models.ActivityUserFree, "UpdateOne", err),
log.Any("activityID", activityID),
log.Any("uid", uid),
log.Any("freeCount", freeCount),
)
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:", "UpdateOneSet", models.ActivityUserFree, "result.ModifiedCount == 0", err),
log.Any("activityID", activityID),
log.Any("uid", uid),
log.Any("freeCount", freeCount),
)
return err
}
return nil
}
models/v/activitymod/user_free_type.go
+17
View File
@@ -0,0 +1,17 @@
package activitymod
import (
"time"
"go.mongodb.org/mongo-driver/bson/primitive"
)
// 用户免费次数记录
type UserFree struct {
ID primitive.ObjectID `json:"id" bson:"_id,omitempty"` // 文档ID
ActivityID primitive.ObjectID `json:"activityId" bson:"activityId"` // 活动ID
UID uint64 `json:"uid" bson:"uid"` // 用户ID
FreeCount int32 `json:"freeCount" bson:"freeCount"` // 剩余免费次数
UpdateTime time.Time `json:"updateTime" bson:"updateTime"` // 修改时间
CreateTime time.Time `json:"createTimt" bson:"createTimt"` // 创建时间
}
models/v/activitymod/user_record.go
+93
View File
@@ -0,0 +1,93 @@
package activitymod
import (
"errors"
"fmt"
"91porn-server/common/db"
"91porn-server/common/log"
"91porn-server/models"
"91porn-server/models/v/prizemod"
"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 userRecordDB *db.MongoDB
func collUserRecord(t *db.MongoTool) *db.MongoTool {
if t == nil {
return userRecordDB.Coll(models.ActivityUserRecord)
}
return t.Coll(models.ActivityUserRecord)
}
// initUserFreeIndex 索引设置
func initUserRecordIndex() {
many := []mongo.IndexModel{ //batch set indexes //value is the type 1 or -1
{
Keys: bson.D{{Key: "activityId", Value: 1}, {Key: "uid", Value: 1}, {Key: "createTime", Value: -1}},
},
{
Keys: bson.D{{Key: "createTime", Value: -1}},
},
}
if _, err := collUserRecord(nil).CreateIndex(many); err != nil {
panic(fmt.Sprintf("%s model set index err ==>[%+v]", models.ActivityUserRecord, err))
}
}
func AddMany(records []UserRecord) error {
result, err := collUserRecord(nil).InsertMany(&records)
if err != nil {
log.Error(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "AddMany", models.ActivityUserRecord, "InsertMany", err),
log.Any("records", records),
)
return err
}
if len(result.InsertedIDs) != len(records) {
err = errors.New("activity InsertMany InsertedIDs err")
log.Warn(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "AddMany", models.ActivityUserRecord, "len(result.InsertedIDs) != len(records)", err),
log.Any("records", records),
)
return err
}
return nil
}
func QueryAllRecord(filter primitive.M, opts ...*options.FindOptions) ([]*UserRecord, error) {
var out []*UserRecord = []*UserRecord{}
if err := collUserRecord(nil).Find(&out, filter, opts...); err != nil {
log.Error(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "QueryAllRecord", models.ActivityUserRecord, "Find", err),
log.Any("filter", filter),
)
return nil, err
}
return out, nil
}
// 查询奖品总条数
func CountRecord(filter primitive.M) (int64, error) {
count, err := collUserRecord(nil).Count(filter)
if err != nil {
log.Error(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "CountRecord", models.ActivityUserRecord, "Count", err),
log.Any("filter", filter),
)
return 0, err
}
return count, nil
}
func GetMarquee(activityId primitive.ObjectID) ([]*UserRecord, error) {
filter := bson.M{"activityId": activityId, "level": prizemod.High}
var out []*UserRecord = []*UserRecord{}
if err := collUserRecord(nil).Find(&out, filter, options.Find().SetLimit(10).SetSort(bson.M{"createTime": -1})); err != nil {
log.Error(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "QueryAllRecord", models.ActivityUserRecord, "Find", err),
log.Any("filter", filter),
)
return nil, err
}
return out, nil
}
models/v/activitymod/user_record_type.go
+26
View File
@@ -0,0 +1,26 @@
package activitymod
import (
"time"
"91porn-server/models/v/prizemod"
"go.mongodb.org/mongo-driver/bson/primitive"
)
// 用户抽奖记录
type UserRecord struct {
ID primitive.ObjectID `json:"id" bson:"_id,omitempty"` // 文档ID
ActivityID primitive.ObjectID `json:"activityId" bson:"activityId"` // 活动ID
VIPCardID primitive.ObjectID `json:"vipCardId" bson:"vipCardId"` // 会员卡ID
UID uint64 `json:"uid" bson:"uid"` // 用户ID
UserName string `json:"userName" bson:"userName"` // 用户名
Name string `json:"name" bson:"name"` // 奖品名称
Type prizemod.PrizeType `json:"type" bson:"type"` // 奖品类型
Count int32 `json:"count" bson:"count"` // 奖品数量
Price int64 `json:"price" bson:"price"` // 奖品价值
Value int64 `json:"value" bson:"value"` // 折扣率/活跃值
Level prizemod.PrizeLevel `json:"level" bson:"level"` // 奖品等级
DrawPrice int64 `json:"drawPrice" bson:"drawPrice"` // 单次抽奖价格(金币)
CreateTime time.Time `json:"createTime" bson:"createTime"` // 创建时间
}
models/v/activitymod/web.go
+171
View File
@@ -0,0 +1,171 @@
package activitymod
import (
"time"
"91porn-server/models/commod"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
"go.mongodb.org/mongo-driver/mongo/options"
)
// ActReq 活动请求,公告跳转到活动页面
type ActReq struct {
Token string `form:"token" json:"token"`
Type string `form:"type" json:"type"`
}
// 新增活动
type AddCond struct {
Title string `json:"title"` // 活动名称
Desc string `json:"desc"` // 活动注意事项
StartTime time.Time `json:"startTime"` // 活动开始时间
EndTime time.Time `json:"endTime"` // 活动结束时间
}
// 修改活动
type ModifyCond struct {
ID primitive.ObjectID `json:"id" binding:"required"` // 文档ID
Title *string `json:"title"` // 活动名称
Desc *string `json:"desc"` // 活动注意事项
Status *bool `json:"status"` // 状态---启用/禁用
StartTime *time.Time `json:"startTime"` // 活动开始时间
EndTime *time.Time `json:"endTime"` // 活动结束时间
}
func (m *ModifyCond) Cond() primitive.M {
return bson.M{"_id": m.ID}
}
func (m *ModifyCond) Bson() primitive.M {
set := bson.M{"updatedAt": time.Now()}
if m.Title != nil {
set["title"] = m.Title
}
if m.Desc != nil {
set["desc"] = m.Desc
}
if m.Status != nil {
set["status"] = m.Status
}
if m.StartTime != nil {
set["startTime"] = m.StartTime
}
if m.EndTime != nil {
set["endTime"] = m.EndTime
}
return bson.M{"$set": set}
}
// 查询活动列表
type QueryAllCond struct {
Status *bool `form:"status"` // 状态---启用/禁用
commod.Page
}
func (q *QueryAllCond) Options() *options.FindOptions {
return options.Find().SetLimit(int64(q.PageSize)).SetSkip(int64((q.PageNumber - 1) * q.PageSize)).SetSort(bson.M{"createdAt": -1})
}
func (q *QueryAllCond) Query() primitive.M {
fliter := bson.M{}
if q.Status != nil {
fliter["status"] = q.Status
}
return fliter
}
// 新增活动奖池
type AddPrizePoolCond struct {
ActivityID primitive.ObjectID `json:"activityId" binding:"required"` // 活动ID
Model PrizePoolModel `json:"model"` // 奖池模式
EstimatedIncome int64 `json:"estimatedIncome"` // 当日预计收益
Price int64 `json:"price"` // 单次抽奖金额
FreeCount int32 `json:"freeCount"` // 免费次数
}
// 修改活动奖池
type ModifyPrizePoolCond struct {
ID primitive.ObjectID `json:"id" binding:"required"` // 文档ID
ActivityID *primitive.ObjectID `json:"activityId"` // 活动ID
Model *PrizePoolModel `json:"model"` // 奖池模式
EstimatedIncome *int64 `json:"estimatedIncome"` // 当日预计收益
Price *int64 `json:"price"` // 单次抽奖金额
FreeCount *int32 `json:"freeCount"` // 免费次数
}
func (m *ModifyPrizePoolCond) Cond() primitive.M {
return bson.M{"_id": m.ID}
}
func (m *ModifyPrizePoolCond) Bson() primitive.M {
set := bson.M{"updatedAt": time.Now()}
if m.ActivityID != nil {
set["activityId"] = m.ActivityID
}
if m.Model != nil {
set["model"] = m.Model
}
if m.EstimatedIncome != nil {
set["estimatedIncome"] = m.EstimatedIncome
}
if m.Price != nil {
set["price"] = m.Price
}
if m.FreeCount != nil {
set["freeCount"] = m.FreeCount
}
return bson.M{"$set": set}
}
// 查询活动奖池列表
type QueryAllPrizePoolCond struct {
Model *PrizePoolModel `form:"model"` // 奖池模式
ActivityID *string `form:"activityId"` // 活动ID
commod.Page
}
func (q *QueryAllPrizePoolCond) Options() *options.FindOptions {
return options.Find().SetLimit(int64(q.PageSize)).SetSkip(int64((q.PageNumber - 1) * q.PageSize)).SetSort(bson.M{"createdAt": -1})
}
func (q *QueryAllPrizePoolCond) Query() primitive.M {
fliter := bson.M{}
if q.Model != nil {
fliter["model"] = q.Model
}
if q.ActivityID != nil {
id, _ := primitive.ObjectIDFromHex(*q.ActivityID)
fliter["activityId"] = id
}
return fliter
}
// 查询活动参与记录列表
type QueryAllRecordCond struct {
ActivityID *string `form:"activityId"` // 活动ID
UID *string `form:"uid"` // 活动ID
commod.Page
}
func (q *QueryAllRecordCond) Options() *options.FindOptions {
return options.Find().SetLimit(int64(q.PageSize)).SetSkip(int64((q.PageNumber - 1) * q.PageSize)).SetSort(bson.M{"createTime": -1})
}
func (q *QueryAllRecordCond) Query() primitive.M {
fliter := bson.M{}
if q.UID != nil {
fliter["uid"] = q.UID
}
if q.ActivityID != nil {
id, _ := primitive.ObjectIDFromHex(*q.ActivityID)
fliter["activityId"] = id
}
return fliter
}
type OpenBotDrawCond struct {
ID primitive.ObjectID `json:"id" binding:"required"` // 活动ID
Status bool
}