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/advanceordermod/advanceorder.go
+254
View File
@@ -0,0 +1,254 @@
package advanceordermod
import (
"91porn-server/common/db"
"91porn-server/common/log"
"91porn-server/models"
"errors"
"fmt"
"time"
"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.AdvanceOrder
func coll(t *db.MongoTool) *db.MongoTool {
if t == nil {
return mdb.Coll(table)
}
return t.Coll(table)
}
func Init() {
mdb = db.Init(table)
initIndex()
}
func initIndex() {
many := []mongo.IndexModel{
{
Keys: bson.D{{Key: "uid", Value: 1}, {Key: "productID", Value: 1}},
},
{
Keys: bson.D{{Key: "uid", Value: 1}},
},
{
Keys: bson.D{{Key: "productID", Value: 1}},
},
{
Keys: bson.D{{Key: "oid", Value: 1}},
},
//{
// Keys: bson.D{{Key: "endTime", Value: 1}, {Key: "status", Value: 1}},
//},
{
Keys: bson.D{{Key: "status", Value: 1}, {Key: "createdAt", Value: -1}},
},
{
Keys: bson.D{{Key: "status", Value: 1}, {Key: "endTime", Value: 1}, {Key: "createdAt", Value: -1}},
},
}
if _, err := coll(nil).CreateIndex(many); err != nil {
panic(fmt.Sprintf("%s model set index err ==>[%+v]", table, err))
}
}
func InsertOne(mt *db.MongoTool, cfg *AdvanceOrder) error {
if _, err := coll(mt).InsertOne(cfg); err != nil {
log.Warn(fmt.Sprintf("[METHOD-InsertOne]==> Model %s InsertOne fail error:%+v:", table, err))
return err
}
return nil
}
// CreditOrder 创建预付订单
func CreditOrder(t *db.MongoTool, cfg *AdvanceOrder) (data *AdvanceOrder, err error) {
filter := bson.M{"uid": cfg.UID, "productID": cfg.ProductID}
update := bson.M{"$set": bson.M{
"uid": cfg.UID,
"advOid": cfg.AdvOid,
"productID": cfg.ProductID,
"status": cfg.Status,
"totalAmount": cfg.TotalAmount,
"advanceAmount": cfg.AdvanceAmount,
"balanceAmount": cfg.BalanceAmount,
"endTime": cfg.EndTime,
"prepaidPrivilege": cfg.PrepaidPrivilege,
"todayUse": cfg.TodayUse,
"createdAt": cfg.CreatedAt,
}}
var advanceOrder *AdvanceOrder
if err := coll(t).FindOneAndUpsert(&advanceOrder, filter, update); err != nil {
log.Warn(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "CreditOrder", table, "FindOneAndUpsert", err))
return nil, err
}
if advanceOrder.ID.IsZero() {
return nil, errors.New("insert is null")
}
return advanceOrder, nil
}
// GetUserValidOrder 获取用户当前订单
func GetUserValidOrder(uid uint64) (hasOrder bool, info *AdvanceOrder) {
n := time.Now()
var cond = bson.M{"uid": uid, "endTime": bson.M{"$gt": n}, "status": bson.M{"$in": []int{AdvanceSUCCESS, BalanceProcessing}}}
var opt = options.FindOne().SetSort(bson.D{{"endTime", -1}})
if err := coll(nil).FindOne(&info, cond, opt); err != nil {
log.Warn(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "GetUserValidCount", table, "FindOne", err),
log.Any("uid", uid),
)
return
}
if info == nil || info.ID.IsZero() {
return
}
hasOrder = true
return
}
// Debit 扣除每日使用次数
func Debit(t *db.MongoTool, uid uint64, debitPlan DebitPlan) error {
// 先查找用户订单
hasOrder, adOrder := GetUserValidOrder(uid)
if !hasOrder {
return errors.New("user advance order not found")
}
// 检查次数是否够用
if debitPlan.CoinVideoCount != nil {
if adOrder.PrepaidPrivilege.CoinVideoLimitPerDay-adOrder.TodayUse.CoinVideoCount < *debitPlan.CoinVideoCount {
return errors.New("free count not enough")
}
}
if debitPlan.LuckyDrawCount != nil {
if adOrder.PrepaidPrivilege.LuckyDrawLimitPerDay-adOrder.TodayUse.LuckyDrawCount < *debitPlan.LuckyDrawCount {
return errors.New("free count not enough")
}
}
if debitPlan.AiUndressCount != nil {
if adOrder.PrepaidPrivilege.AiUndressLimitPerDay-adOrder.TodayUse.AiUndressCount < *debitPlan.AiUndressCount {
return errors.New("free count not enough")
}
}
if debitPlan.DownloadCount != nil {
if adOrder.PrepaidPrivilege.DownloadLimitPerDay-adOrder.TodayUse.DownloadCount < *debitPlan.DownloadCount {
return errors.New("free count not enough")
}
}
if _, err := coll(t).UpdateOne(bson.M{"_id": adOrder.ID}, bson.M{
"$inc": debitPlan,
}); err != nil {
log.Warn(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "Debit", table, "UpdateOne", err),
log.Any("debitPlan", debitPlan),
log.Any("id", adOrder.ID),
)
return err
}
return nil
}
// ResetToday 重置当天使用次数
func ResetToday() error {
n := time.Now()
filter := bson.M{"endTime": bson.M{"$gt": n}, "status": bson.M{"$in": []int{AdvanceSUCCESS, BalanceProcessing}}}
if _, err := coll(nil).UpdateMany(filter, bson.M{
"$set": bson.M{
"todayUse.coinVideoCount": int64(0),
"todayUse.luckyDrawCount": int64(0),
"todayUse.aiUndressCount": int64(0),
"todayUse.downloadCount": int64(0),
},
}); err != nil {
log.Warn(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "ResetToday", table, "UpdateMany", err))
return err
}
return nil
}
// FindDataByID 根据ID查询
func FindDataByID(id string) (AdvanceOrder, error) {
objID, err := primitive.ObjectIDFromHex(id)
if err != nil {
log.Warn(fmt.Sprintf("[METHOD-FindDataByID]==> Model %s ObjectIDFromHex fail error:%+v:", table, err),
log.Any("id", id),
)
return AdvanceOrder{}, err
}
var aud AdvanceOrder
if err = coll(nil).FindOne(&aud, bson.M{"_id": objID}); err != nil {
log.Warn(fmt.Sprintf("[METHOD-FindDataByID]==> Model %s FindOne fail error:%+v:", table, err),
log.Any("objID", objID),
)
return aud, err
}
return aud, nil
}
// FindDataByUID 根据UID查询
func FindDataByUID(uid uint64) ([]*AdvanceOrder, error) {
var aud []*AdvanceOrder
if err := coll(nil).Find(&aud, bson.M{"uid": uid}); err != nil {
log.Warn(fmt.Sprintf("[METHOD-FindDataByUID]==> Model %s FindOne fail error:%+v:", table, err),
log.Any("uid", uid),
)
return aud, err
}
return aud, nil
}
// QueryAllDocument 分页查询文档
func QueryAllDocument(filter primitive.M, opts ...*options.FindOptions) (out []*AdvanceOrder, err error) {
if err = coll(nil).Find(&out, filter, opts...); err != nil {
log.Error(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "QueryAllDocument", table, "Find", err),
log.Any("filter", filter),
)
return
}
return
}
// CountDocument 查询文档条目数
func CountDocument(filter primitive.M) (int64, error) {
if count, err := coll(nil).Count(filter); err != nil {
log.Error(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "CountDocument", table, "Count", err),
log.Any("filter", filter),
)
return 0, err
} else {
return count, nil
}
}
// IsExist 根据标签名获取标签
func IsExist(filter primitive.M) (data *AdvanceOrder, err error) {
if err = coll(nil).FindOne(&data, filter); err != nil {
log.Error(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "isExist", table, "FindOne", err),
log.Any("filter", filter),
)
return nil, err
}
return data, nil
}
// Update 修改订单
func Update(t *db.MongoTool, id primitive.ObjectID, set bson.M) error {
set["updatedAt"] = time.Now()
if _, err := coll(t).UpdateOne(bson.M{"_id": id}, bson.M{"$set": set}); err != nil {
log.Warn(fmt.Sprintf("[METHOD-Update]==> Model %s UpdateOne fail error:%+v:", table, err),
log.Any("id", id),
log.Any("set", set),
)
return err
}
return nil
}
models/v/advanceordermod/app.go
+56
View File
@@ -0,0 +1,56 @@
package advanceordermod
import "time"
// AdvanceStatus 预售状态
type AdvanceStatus struct {
ActivityStatus bool `json:"activityStatus" bson:"activityStatus"` // 预售活动是否开启
ActivityPopUp bool `json:"activityPopUp" bson:"activityPopUp"` // 预售活动是否首页弹窗
GameActivityPopUp bool `json:"gameActivityPopUp" bson:"gameActivityPopUp"` // 游戏预售是否首页弹窗
GameActivityStatus bool `json:"gameActivityStatus" bson:"gameActivityStatus"` // 游戏预售是否开启
BalancePayment bool `json:"balancePayment" bson:"balancePayment"` // 是否有尾款支付
BalanceAmount int64 `bson:"balanceAmount" json:"balanceAmount"` // 尾款金额
Status int `json:"status" bson:"status"` // 预售订单状态
StartTime time.Time `json:"startTime" bson:"startTime,omitempty"` // 预售尾款开始时间
EndTime time.Time `json:"endTime" bson:"endTime,omitempty"` // 预售尾款结束时间
OId string `json:"oid" bson:"oid"` // 预付订单号
PrivilegeLimit PrivilegeLimit `json:"privilegeLimit"` // 预付权益
}
type PrivilegeLimit struct {
HasLimit bool `json:"hasLimit"` // 是否有权益限制
Limit struct {
CoinVideoLimitPerDay int64 `json:"coinVideoLimitPerDay"` // 每日金币视频免费次数
LuckyDrawLimitPerDay int64 `json:"luckyDrawLimitPerDay"` // 每日抽奖次数限制
AiUndressLimitPerDay int64 `json:"aiUndressLimitPerDay"` // 每日ai脱衣次数限制
DownloadLimitPerDay int64 `json:"downloadLimitPerDay"` // 每日下载次数限制
} `json:"limit"` // 每日限制
Remain struct {
TodayCoinVideoCount int64 `json:"todayCoinVideoCount"` // 今日剩余金币视频观看次数
TodayLuckyDrawCount int64 `json:"todayLuckyDrawCount"` // 今日剩余抽奖次数
TodayAiUndressCount int64 `json:"todayAiUndressCount"` // 今日剩余ai脱衣次数
TodayDownloadCount int64 `json:"todayDownloadCount"` // 今日剩余下载次数
} `json:"remain"` // 当日可使用次数
}
type DebitPlan struct {
CoinVideoCount *int64 `bson:"todayUse.coinVideoCount,omitempty"` // 金币视频观看次数
LuckyDrawCount *int64 `bson:"todayUse.luckyDrawCount,omitempty"` // 抽奖次数
AiUndressCount *int64 `bson:"todayUse.aiUndressCount,omitempty"` // ai脱衣次数
DownloadCount *int64 `bson:"todayUse.downloadCount,omitempty"` // 下载次数
}
func (d *DebitPlan) InvertCounts() {
if d.CoinVideoCount != nil {
*d.CoinVideoCount = -(*d.CoinVideoCount)
}
if d.LuckyDrawCount != nil {
*d.LuckyDrawCount = -(*d.LuckyDrawCount)
}
if d.AiUndressCount != nil {
*d.AiUndressCount = -(*d.AiUndressCount)
}
if d.DownloadCount != nil {
*d.DownloadCount = -(*d.DownloadCount)
}
}
models/v/advanceordermod/type.go
+62
View File
@@ -0,0 +1,62 @@
package advanceordermod
import (
"time"
"go.mongodb.org/mongo-driver/bson/primitive"
)
const (
DEFAULT = iota // 0 默认
AdvanceProcessing // 1 预付中
AdvanceSUCCESS // 2 预付成功
BalanceProcessing // 3 尾款预付中
BalanceSUCCESS // 4 尾款预付成功
)
type AdvanceOrder struct {
ID primitive.ObjectID `json:"id" bson:"_id,omitempty"`
UID uint64 `json:"uid" bson:"uid"` // 用户ID
AdvOid string `json:"advOid" bson:"advOid"` // 预付支付平台订单号
BalOid string `json:"balOid" bson:"balOid"` // 尾款支付平台订单号
ProductID primitive.ObjectID `json:"productID" bson:"productID"` // 预售产品ID
Status int `json:"status" bson:"status" ` // 预售订单状态
TotalAmount int64 `bson:"totalAmount" json:"totalAmount" ` // 预付卡总金额
AdvanceAmount int64 `bson:"advanceAmount" json:"advanceAmount" ` // 预付金额
BalanceAmount int64 `bson:"balanceAmount" json:"balanceAmount"` // 尾款金额
StartTime time.Time `json:"startTime" bson:"startTime,omitempty"` // 预售尾款开始时间
EndTime time.Time `json:"endTime" bson:"endTime,omitempty"` // 预售尾款结束时间
PrepaidPrivilege AdvanceCardPrepaidPrivilege `json:"prepaidPrivilege" bson:"prepaidPrivilege"` // 预付后的权益
TodayUse DayUse `json:"todayUse" bson:"todayUse"` // 当天使用次数
CreatedAt time.Time `json:"createdAt" bson:"createdAt,omitempty"` // 创建时间
UpdatedAt time.Time `json:"updatedAt" bson:"updatedAt,omitempty"` // 刷新时间
}
type AdvanceCardPrepaidPrivilege struct {
CoinVideoLimitPerDay int64 `json:"coinVideoLimitPerDay" bson:"coinVideoLimitPerDay"` // 每日金币视频免费次数
LuckyDrawLimitPerDay int64 `json:"luckyDrawLimitPerDay" bson:"luckyDrawLimitPerDay"` // 每日抽奖次数限制
AiUndressLimitPerDay int64 `json:"aiUndressLimitPerDay" bson:"aiUndressLimitPerDay"` // 每日ai脱衣次数限制
DownloadLimitPerDay int64 `json:"downloadLimitPerDay" bson:"downloadLimitPerDay"` // 每日下载次数限制
}
type DayUse struct {
CoinVideoCount int64 `json:"coinVideoCount" bson:"coinVideoCount"` // 金币视频观看次数
LuckyDrawCount int64 `json:"luckyDrawCount" bson:"luckyDrawCount"` // 抽奖次数
AiUndressCount int64 `json:"aiUndressCount" bson:"aiUndressCount"` // ai脱衣次数
DownloadCount int64 `json:"downloadCount" bson:"downloadCount"` // 下载次数
}
type AdvanceOrderExport struct {
ID primitive.ObjectID `json:"id" bson:"_id,omitempty" xlsx:"ID"`
UID uint64 `json:"uid" bson:"uid" xlsx:"用户ID"` // 用户ID
AdvOid string `json:"advOid" bson:"advOid" xlsx:"预付支付平台订单号"` // 预付支付平台订单号
BalOid string `json:"balOid" bson:"balOid" xlsx:"尾款支付平台订单号"` // 尾款支付平台订单号
ProductID primitive.ObjectID `json:"productID" bson:"productID" xlsx:"预售产品ID"` // 预售产品ID
Status string `json:"status" bson:"status" xlsx:"预售订单状态"` // 预售订单状态
TotalAmount int64 `bson:"totalAmount" json:"totalAmount" xlsx:"预付卡总金额"` // 预付卡总金额
AdvanceAmount int64 `bson:"advanceAmount" json:"advanceAmount" xlsx:"预付金额"` // 预付金额
BalanceAmount int64 `bson:"balanceAmount" json:"balanceAmount" xlsx:"尾款金额"` // 尾款金额
StartTime time.Time `json:"startTime" bson:"startTime,omitempty" xlsx:"预售尾款开始时间"` // 预售尾款开始时间
EndTime time.Time `json:"endTime" bson:"endTime,omitempty" xlsx:"预售尾款结束时间"` // 预售尾款结束时间
CreatedAt time.Time `json:"createdAt" bson:"createdAt,omitempty" xlsx:"创建时间"` // 创建时间
}
models/v/advanceordermod/web.go
+49
View File
@@ -0,0 +1,49 @@
package advanceordermod
import (
"time"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/mongo/options"
)
type QueryAllCond struct {
Page int64 `form:"pageNumber" json:"pageNumber" binding:"required"` // 查询页码
Limit int64 `form:"pageSize" json:"pageSize" binding:"required"` // 页码大小
AdvOid *string `form:"advOid" json:"advOid" bson:"advOid"` // 预付订单号
BalOid *string `form:"balOid" json:"balOid" bson:"balOid"` // 尾款订单号
Uid *int `form:"uid" json:"uid" bson:"uid"` // 用户ID
Status *int `form:"status" json:"status" bson:"status"` // 预售订单状态
TimeField string `form:"timeField" json:"timeField"` // 时间筛选字段 createdAt 创建时间 endTime 预售尾款结束时间
Start *time.Time `form:"start" json:"start"` // 开始时间
End *time.Time `form:"end" json:"end"` // 结束时间
}
type QueryAllRes struct {
List []*AdvanceOrder `json:"list"`
Total int64 `json:"total"`
}
func (receiver *QueryAllCond) Filter() bson.M {
var query = bson.M{}
if receiver.Uid != nil {
query["uid"] = receiver.Uid
}
if receiver.Status != nil {
query["status"] = receiver.Status
}
if receiver.AdvOid != nil {
query["advOid"] = receiver.AdvOid
}
if receiver.BalOid != nil {
query["balOid"] = receiver.BalOid
}
if receiver.TimeField != "" && receiver.Start != nil && receiver.End != nil {
query[receiver.TimeField] = bson.M{"$gte": receiver.Start, "$lt": receiver.End}
}
return query
}
func (receiver QueryAllCond) Options() *options.FindOptions {
return options.Find().SetSkip((receiver.Page - 1) * receiver.Limit).SetLimit(receiver.Limit).SetSort(bson.M{"createdAt": -1})
}