Initial commit

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
This commit is contained in:
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
+46
View File
@@ -0,0 +1,46 @@
package wdordmod
import "time"
// WithdrawOrder struct {
type WithdrawQueryReq struct {
ID *string `json:"_id,omitempty" form:"id" bson:"_id"` //流水id
UID *uint64 `json:"uid,omitempty" form:"uid" bson:"uid"` //用户id
Amount *int64 `json:"amount,omitempty" form:"amount" bson:"amount"` //蝴蝶币数量
Money *int64 `json:"money,omitempty" form:"money" bson:"money"` //提现金额
Type *int `json:"type,omitempty" form:"type" bson:"type"` //提现类型
ActName *string `json:"actName,omitempty" form:"actName" bson:"actName,omitempty"` //交易账户持有人
Act *string `json:"act,omitempty" form:"act" bson:"act,omitempty"` //交易账户
TaxRate *int `json:"taxRate,omitempty" form:"taxRate" bson:"taxRate"` //税率
Status *int `json:"status,omitempty" form:"status" bson:"status"` //1审核中 2审核通过,转账中 3 审核失败 4 完成
StatusDesc *string `json:"statusDesc,omitempty" form:"statusDesc" bson:"statusDesc"` //状态说明
UpdatedAt *string `json:"updatedAt,omitempty" form:"updatedAt" bson:"updatedAt"` //时间戳
CreatedAt *string `json:"createdAt,omitempty" form:"createdAt" bson:"createdAt"` //时间错
}
type EditSelector struct {
OID *string `json:"oid,omitempty" bson:"oid,omitempty"`
//第三方支付平台id
PayMoney *int64 `json:"payMoney,omitempty" bson:"payMoney,omitempty"` //实际到账
Status int `json:"status" bson:"status"` //1未审核 2审核通过,转账中 3已拒绝 4未知错误 5提现成功 6提现失败
StatusDesc string `json:"statusDesc,omitempty" bson:"statusDesc,omitempty"` //状态说明
CheckedAt *time.Time `json:"checkedAt,omitempty" bson:"checkedAt,omitempty"` //审核时间
UsdtRate *float64 `json:"usdtRate" bson:"usdtRate,omitempty"` //usdt费率 Todo:仅订单类型为usdt时必传
ProgressAt *time.Time `json:"progressAt,omitempty" bson:"progressAt,omitempty"` //第三方下单成功时间
FailureAt *time.Time `json:"failureAt,omitempty" bson:"failureAt,omitempty"` //回调失败时间
SuccessAt *time.Time `json:"successAt,omitempty" bson:"successAt,omitempty"` //回调成功时间
ReceivedAt *time.Time `json:"receivedAt,omitempty" bson:"receivedAt,omitempty"` //到账时间
Operator *string `json:"operator,omitempty" bson:"operator,omitempty"` //操作者
UpdatedAt time.Time `json:"updatedAt" bson:"updatedAt"`
}
type WithdrawReq struct {
Name *string `json:"name" ` //用户名
Money int64 `json:"money" binding:"required"` //提现金额
PayType string `json:"payType" binding:"required"` //提现方式,alipaybankcardusdt
WithdrawType *WithdrawTypes `json:"withdrawType"` //提现类型,0,代理提现; 1,金币提现
ActName string `json:"actName"` //交易账户持有人
Act string `json:"act" ` //交易账户
DevID *string `json:"devID" ` //设备id
ProductType int `json:"productType"` //产品类型 0站群 1棋牌
}
+170
View File
@@ -0,0 +1,170 @@
package wdordmod
import (
"strings"
"time"
"91porn-server/common/pageopt"
"91porn-server/common/ysinterface/disc"
)
// DistrictStatKey
type DistrictStatKey struct {
DiscSeqe `bson:",inline"` //商区码
DeviceType string `bson:"deviceType"` //系统类型 iOS Android
}
var (
discWithdraw = DiscWithdraw
)
func (d DistrictStatKey) GetDiscCode() string {
return d.DistrictCode
}
func (d DistrictStatKey) GetPromSeqe() string {
return d.PromSeqe
}
func (d DistrictStatKey) GetSysType() string {
return d.DeviceType
}
func (d DistrictStatKey) String() string {
if d.DiscSeqe.String() == "" {
return ""
}
return strings.ToUpper(strings.Join([]string{d.DiscSeqe.String(), d.DeviceType}, "-"))
}
// DistrictStater
type DistrictStater = disc.DistrictStater
// DistrictOrderCountMap districtCode->订单数 map
func DistrictOrderCountMap(start, end time.Time, mats ...Matcher) (map[DistrictStater]int64, error) {
mats = append(mats,
(&CreatedAtGTEAndLTMatch{&start, &end}).New(),
(&WithdrawTypeNEMatch{&discWithdraw}).New(),
)
filter := pageopt.MergeM(mats)
list := []DistrictStatKey{}
if err := coll(nil).Find(&list, filter); err != nil {
return nil, err
}
m := make(map[DistrictStater]int64, len(list))
for _, v := range list {
if v.String() != "" {
m[v] += 1
}
}
return m, nil
}
// DistrictOrderMoneyMap districtCode->订单金额 map
func DistrictOrderMoneyMap(start, end time.Time, mats ...Matcher) (map[DistrictStater]int64, error) {
mats = append(mats,
(&CreatedAtGTEAndLTMatch{&start, &end}).New(),
(&WithdrawTypeNEMatch{&discWithdraw}).New(),
)
filter := pageopt.MergeM(mats)
list := []struct {
DistrictStatKey `bson:",inline"` //商区码
Money int64 `bson:"money"` //提现金额
}{}
if err := coll(nil).Find(&list, filter); err != nil {
return nil, err
}
m := make(map[DistrictStater]int64, len(list))
for _, v := range list {
if v.String() != "" {
m[v.DistrictStatKey] += v.Money
}
}
return m, nil
}
// DistrictCompleteOrderCountMap districtCode->完成订单数 map
func DistrictCompleteOrderCountMap(start, end time.Time, mats ...Matcher) (map[DistrictStater]int64, error) {
mats = append(mats,
(&SuccessAtGTEAndLTMatch{&start, &end}).New(),
(&WithdrawTypeNEMatch{&discWithdraw}).New(),
)
filter := pageopt.MergeM(mats)
list := []DistrictStatKey{}
if err := coll(nil).Find(&list, filter); err != nil {
return nil, err
}
m := make(map[DistrictStater]int64, len(list))
for _, v := range list {
if v.String() != "" {
m[v] += 1
}
}
return m, nil
}
// DistrictCompleteOrderPayMoneyMap districtCode->完成订单的实际到账金额 map
func DistrictCompleteOrderPayMoneyMap(start, end time.Time, mats ...Matcher) (map[DistrictStater]int64, error) {
mats = append(mats,
(&SuccessAtGTEAndLTMatch{&start, &end}).New(),
(&WithdrawTypeNEMatch{&discWithdraw}).New(),
)
filter := pageopt.MergeM(mats)
list := []struct {
DistrictStatKey `bson:",inline"` //商区码
PayMoney int64 `bson:"payMoney"` //实际到账金额 李秋山确认
}{}
if err := coll(nil).Find(&list, filter); err != nil {
return nil, err
}
m := make(map[DistrictStater]int64, len(list))
for _, v := range list {
if v.String() != "" {
m[v.DistrictStatKey] += v.PayMoney
}
}
return m, nil
}
// DistrictReceivedOrderCountMap districtCode->已出款订单数 map
func DistrictReceivedOrderCountMap(start, end time.Time, mats ...Matcher) (map[DistrictStater]int64, error) {
mats = append(mats,
(&ReceivedAtGTEAndLTMatch{&start, &end}).New(),
(&WithdrawTypeNEMatch{&discWithdraw}).New(),
)
list := []DistrictStatKey{}
filter := pageopt.MergeM(mats)
if err := coll(nil).Find(&list, filter); err != nil {
return nil, err
}
m := make(map[DistrictStater]int64, len(list))
for _, v := range list {
if v.String() != "" {
m[v] += 1
}
}
return m, nil
}
// DistrictReceivedMoneyMap districtCode->已出款金额 map
func DistrictReceivedMoneyMap(start, end time.Time, mats ...Matcher) (map[DistrictStater]int64, error) {
list := []struct {
DistrictStatKey `bson:",inline"` //商区码
PayMoney int64 `bson:"payMoney"` //实际到账金额 李秋山确认
}{}
mats = append(mats,
(&ReceivedAtGTEAndLTMatch{&start, &end}).New(),
(&WithdrawTypeNEMatch{&discWithdraw}).New(),
)
filter := pageopt.MergeM(mats)
if err := coll(nil).Find(&list, filter); err != nil {
return nil, err
}
m := make(map[DistrictStater]int64, len(list))
for _, v := range list {
if v.String() != "" {
m[v.DistrictStatKey] += v.PayMoney
}
}
return m, nil
}
+9
View File
@@ -0,0 +1,9 @@
package wdordmod
// OrderNotExistError
type OrderNotExistError struct {
}
func (d OrderNotExistError) Error() string {
return "order not exist error"
}
+200
View File
@@ -0,0 +1,200 @@
package wdordmod
import (
"fmt"
"time"
"91porn-server/common/log"
"91porn-server/common/pageopt"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
"go.mongodb.org/mongo-driver/mongo/options"
)
type Matcher = pageopt.Matcher
// StatusMatch
type StatusMatch struct {
Status *int
}
func (s *StatusMatch) New() Matcher {
return pageopt.NewAssignMatch("status", s.Status)
}
// UIDMatch
type UIDMatch = pageopt.UIDMatch
// WithdrawTypeMatch
type WithdrawTypeMatch struct {
WithdrawTypes *WithdrawTypes
}
func (w *WithdrawTypeMatch) New() Matcher {
return pageopt.NewAssignMatch("withdrawType", w.WithdrawTypes)
}
// WithdrawTypeNEMatch
type WithdrawTypeNEMatch struct {
WithdrawTypes *WithdrawTypes
}
func (w *WithdrawTypeNEMatch) New() Matcher {
return pageopt.NewNEMatch("withdrawType", w.WithdrawTypes)
}
// PayTypeMatch
type PayTypeMatch struct {
PayType *string
}
func (w *PayTypeMatch) New() Matcher {
return pageopt.NewAssignMatch("payType", w.PayType)
}
// IDMatch
type IDMatch struct {
ID *primitive.ObjectID
}
func (s *IDMatch) New() Matcher {
return pageopt.NewAssignMatch("_id", s.ID)
}
// DistrictCodeMatch
type DistrictCodeMatch struct {
DistrictCode *string
}
func (d *DistrictCodeMatch) New() Matcher {
return pageopt.NewAssignMatch("districtCode", d.DistrictCode)
}
// PromSeqeMatch
type PromSeqeMatch struct {
PromSeqe *string
}
func (s *PromSeqeMatch) New() Matcher {
return pageopt.NewAssignMatch("promSeqe", s.PromSeqe)
}
// CheckedAtGTEAndLTMatch 审核时间
type CheckedAtGTEAndLTMatch struct {
GTE *time.Time
LT *time.Time
}
func (c *CheckedAtGTEAndLTMatch) New() Matcher {
return pageopt.NewGTEAndLTMatch("checkedAt", c.GTE, c.LT)
}
// ProgressAtGTEAndLTMatch 第三方下单成功时间
type ProgressAtGTEAndLTMatch struct {
GTE *time.Time
LT *time.Time
}
func (p *ProgressAtGTEAndLTMatch) New() Matcher {
return pageopt.NewGTEAndLTMatch("progressAt", p.GTE, p.LT)
}
// FailureAtGTEAndLTMatch 回调失败时间
type FailureAtGTEAndLTMatch struct {
GTE *time.Time
LT *time.Time
}
func (f *FailureAtGTEAndLTMatch) New() Matcher {
return pageopt.NewGTEAndLTMatch("failureAt", f.GTE, f.LT)
}
// SuccessAtGTEAndLTMatch 回调成功时间
type SuccessAtGTEAndLTMatch struct {
GTE *time.Time
LT *time.Time
}
func (s *SuccessAtGTEAndLTMatch) New() Matcher {
return pageopt.NewGTEAndLTMatch("successAt", s.GTE, s.LT)
}
// CreatedAtGTEAndLTMatch 提现申请时间
type CreatedAtGTEAndLTMatch struct {
GTE *time.Time
LT *time.Time
}
func (c *CreatedAtGTEAndLTMatch) New() Matcher {
return pageopt.NewGTEAndLTMatch("createdAt", c.GTE, c.LT)
}
// ReceivedAtGTEAndLTMatch 到账时间 李秋山确认 三方出款时间
type ReceivedAtGTEAndLTMatch struct {
GTE *time.Time
LT *time.Time
}
func (r *ReceivedAtGTEAndLTMatch) New() Matcher {
return pageopt.NewGTEAndLTMatch("receivedAt", r.GTE, r.LT)
}
// IsDirectMatch
type IsDirectMatch struct {
IsDirect *bool
}
func (b *IsDirectMatch) New() Matcher {
return pageopt.NewAssignMatch("isDirect", b.IsDirect)
}
// DeviceTypeMatch
type DeviceTypeMatch struct {
DeviceType *string
}
func (d *DeviceTypeMatch) New() Matcher {
return pageopt.NewAssignMatch("deviceType", d.DeviceType)
}
type Sort = bson.D
var Sort_CreatedAt_n1 = Sort{{Key: "createdAt", Value: -1}}
func List(sort Sort, skip, limit *int64, matchers ...Matcher) ([]WithdrawOrder, error) {
filter := pageopt.MergeM(matchers)
opt := (&options.FindOptions{})
if len(sort) != 0 {
opt.SetSort(sort)
}
if skip != nil {
opt.SetSkip(*skip)
}
if limit != nil {
opt.SetLimit(*limit)
}
list := []WithdrawOrder{}
if err := coll(nil).Find(&list, filter, opt); err != nil {
log.Error(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "List", table, "Find", err),
log.Any("sort", sort),
log.Any("skip", skip),
log.Any("limit", limit),
log.Any("matchers", matchers),
)
return nil, err
}
return list, nil
}
func Count(matchers ...Matcher) (int64, error) {
filter := pageopt.MergeM(matchers)
count, err := coll(nil).Count(filter)
if err != nil {
log.Error(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "Count", table, "Count", err),
log.Any("matchers", matchers),
)
return 0, err
}
return count, nil
}
+84
View File
@@ -0,0 +1,84 @@
package wdordmod
import (
"time"
"91porn-server/common/db"
"91porn-server/models/commod"
"go.mongodb.org/mongo-driver/bson/primitive"
)
const (
_ = iota
DEFAULT //1 用户发起提现
PROCESSING //2 进行中,审核已通过,等待转账
REFUSE //3 已拒绝
UNKNOWN //4 未知错误
SUCCESS //5 提现成功,提现到账
FAILURE //6 失败,已经退款
)
const (
UNKNOWNError = "网络错误,"
ServerError = "系统错误"
PROCESSINGError = "订单进行中"
SUCCESSStatus = " 提现已到账"
TypeAlipay = "alipay" //支付宝方式
TypeBankCard = "bankcard" //银行卡方式
TypeUsdt = "usdt" //USDT方式
)
type WithdrawTypes = int
const (
AgentWithdraw WithdrawTypes = iota //代理提现
GoldWithdraw //金币提现
DiscWithdraw //商区提现
FinanWithdraw //财务转账提现
WlGameWithdraw //瓦力游戏提现
)
var mdb *db.MongoDB
type DiscSeqe = commod.DiscSeqe
type DiscDoc = commod.DiscDoc
// WithdrawOrder 提现订单
type WithdrawOrder struct {
ID primitive.ObjectID `json:"id" bson:"_id,omitempty"` //流水id
CID string `json:"cid" bson:"cid"`
UID uint64 `json:"uid" bson:"uid"` //用户id
Name string `json:"name" bson:"name"` //用户名
Amount int64 `json:"amount" bson:"amount"` //蝴蝶币数量
OID string `json:"oid" bson:"oid"` //第三方支付平台id
Money int64 `json:"money" bson:"money" binding:"required"` //提现金额
PayMoney int64 `json:"payMoney" bson:"payMoney"` //实际到账
PayType string `json:"payType" bson:"payType" binding:"required"` //提现方式,alipaybankcard
WithdrawType WithdrawTypes `json:"withdrawType" bson:"withdrawType"` //提现类型,0,代理提现; 1,金币提现
ActName string `json:"actName" bson:"actName"` //交易账户持有人
Act string `json:"act" bson:"act"` //交易账户
UserIP string `json:"userIp" bson:"userIp"` //用户ip
DeviceType string `json:"deviceType" bson:"deviceType"` //设备类型
DevID string `json:"devID" bson:"devID"` //设备id
Status int `json:"status" bson:"status"` //1未审核 2审核通过,转账中 3已拒绝 4未知错误 5提现成功 6提现失败
StatusDesc string `json:"statusDesc" bson:"statusDesc"` //状态说明
CheckedAt time.Time `json:"checkedAt" bson:"checkedAt"` //审核时间
UsdtRate float64 `json:"usdtRate" bson:"usdtRate"` //usdt费率 Todo:仅订单类型为usdt时必传
ProgressAt time.Time `json:"progressAt" bson:"progressAt"` //第三方下单成功时间
FailureAt time.Time `json:"failureAt" bson:"failureAt"` //回调失败时间
SuccessAt time.Time `json:"successAt" bson:"successAt"` //回调成功时间
UpdatedAt time.Time `json:"updatedAt" bson:"updatedAt"` //刷新时间
CreatedAt time.Time `json:"createdAt" bson:"createdAt"` //提现申请时间
ReceivedAt time.Time `json:"receivedAt" bson:"receivedAt"` //到账时间 李秋山确认 三方出款时间
DistrictRemark string `json:"districtRemark" bson:"districtRemark"` //备注
ProductType int `json:"productType" bson:"productType"` //支付产品类型 0 站群 1 棋牌
BankCode string `json:"bankCode" bson:"bankCode"` //银行编码
DiscDoc `bson:",inline"` //商区
}
func Init() {
mdb = db.Init(table)
initIndex()
}
+25
View File
@@ -0,0 +1,25 @@
package wdordmod
// WithdrawUpdate struct {
type WithdrawUpdate struct {
ID string `json:"id" form:"id" bson:"_id"` //流水id
StatusDesc string `json:"statusDesc" form:"statusDesc" bson:"statusDesc"` //状态说明
//时间错
}
// WithdrawOrder struct {
type WithdrawWebQueryReq struct {
ID *string `json:"_id,omitempty" form:"id" bson:"_id"` //流水id
OID *string `json:"oid,omitempty" form:"oid,omitempty" bson:"oid"`
UID *uint64 `json:"uid,omitempty" form:"uid" bson:"uid"` //用户id
Amount *int64 `json:"amount,omitempty" form:"amount" bson:"amount"` //蝴蝶币数量
Money *int64 `json:"money,omitempty" form:"money" bson:"money" ` //提现金额
PayType *string `json:"payType,omitempty" form:"payType" bson:"payType" ` //提现类型
TaxRate *int `json:"taxRate,omitempty" form:"taxRate" bson:"taxRate"` //税率
Status *int `json:"status,omitempty" form:"status" bson:"status" ` //1审核中 2审核通过,转账中 3 审核失败 4 完成
StatusDesc *string `json:"statusDesc,omitempty" form:"statusDesc" bson:"statusDesc"` //状态说明
DistrictCode *string `json:"districtCode,omitempty" form:"districtCode" bson:"districtCode"` //商区码
DistrictRemark *string `json:"districtRemark,omitempty" form:"districtRemark" bson:"districtRemark"` //备注
ProductType *int `form:"productType" json:"productType,omitempty" bson:"productType"` //产品类型 0站群 1棋牌
FilterChecked bool `form:"filterChecked" json:"filterChecked" bson:"-"` //是否过滤15分钟内未审核过的订单
}
+470
View File
@@ -0,0 +1,470 @@
/*
* @Description: 账户充值流水
* @Author: your name
* @Date: 2019-08-29 20:45:27
* @LastEditTime: 2019-08-30 13:54:21
* @LastEditors: Please set LastEditors
*/
package wdordmod
import (
"errors"
"fmt"
"time"
"91porn-server/common/db"
"91porn-server/common/log"
"91porn-server/common/pageopt"
"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"
)
const table = models.WithdrawOrder
// InitIndex 设置index
func initIndex() {
coll := coll(nil)
many := []mongo.IndexModel{
{
Keys: bson.D{{Key: "name", Value: 1}},
},
{
Keys: bson.D{{Key: "amount", Value: 1}},
},
{
Keys: bson.D{{Key: "oid", Value: 1}},
// Options: options.Index().SetUnique(true).SetSparse(true),
},
{
Keys: bson.D{{Key: "money", Value: 1}},
},
{
Keys: bson.D{{Key: "payMoney", Value: 1}},
},
{
Keys: bson.D{{Key: "createdAt", Value: 1}},
},
{
Keys: bson.D{{Key: "updatedAt", Value: 1}},
},
{
Keys: bson.D{{Key: "districtCode", Value: 1}, {Key: "createdAt", Value: -1}},
},
{
Keys: bson.D{{Key: "isDirect", Value: 1}, {Key: "createdAt", Value: -1}},
},
{
Keys: bson.D{{Key: "uid", Value: 1}, {Key: "createdAt", Value: -1}},
},
{
Keys: bson.D{{Key: "withdrawType", Value: 1}, {Key: "createdAt", Value: -1}},
},
{
Keys: bson.D{{Key: "status", Value: 1}, {Key: "createdAt", Value: -1}},
},
{
Keys: bson.D{{Key: "payType", Value: 1}, {Key: "createdAt", Value: -1}},
},
{
Keys: bson.D{{Key: "deductType", Value: 1}, {Key: "createdAt", Value: -1}},
Options: options.Index().SetSparse(true),
},
{
Keys: bson.D{{Key: "districtRemark", Value: 1}, {Key: "createdAt", Value: -1}},
},
}
if _, err := coll.CreateIndex(many); err != nil {
panic(fmt.Sprintf("%s model set index err ==>[%+v]", table, err))
}
}
func coll(t *db.MongoTool) *db.MongoTool {
if t == nil {
return mdb.Coll(table)
}
return t.Coll(table)
}
// InsertWithdrawOrder 订单写入
func InsertWithdrawOrder(t *db.MongoTool, w *WithdrawOrder) (id primitive.ObjectID, err error) {
if w.CreatedAt.IsZero() {
w.CreatedAt = time.Now()
}
ret, err := coll(t).InsertOne(w)
if err != nil {
log.Warn(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "InsertWithdrawOrder", table, "InsertOne", err),
log.Any("w", w),
)
return primitive.NilObjectID, err
}
return ret.InsertedID.(primitive.ObjectID), err
}
// FindOneAndUpate 查询
func FindOneAndUpate(id string, status int, set EditSelector) (w WithdrawOrder, err error) {
oid, err := primitive.ObjectIDFromHex(id)
if err != nil {
log.Warn(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "FindOneAndUpate", table, "ObjectIDFromHex", err),
log.Any("id", id),
log.Any("status", status),
log.Any("set", set),
)
return
}
if err = coll(nil).FindOneAndUpdate(&w, bson.M{"_id": oid, "status": status}, bson.M{"$set": set}); err != nil {
log.Warn(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "FindOneAndUpate", table, "FindOneAndUpdate", err),
log.Any("id", id),
log.Any("status", status),
log.Any("set", set),
)
}
return
}
// FindWithdrawOrderByID 查询
func FindWithdrawOrderByID(id string) (w WithdrawOrder, err error) {
oid, err := primitive.ObjectIDFromHex(id)
if err != nil {
log.Warn(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "FindWithdrawOrderByID", table, "ObjectIDFromHex", err),
log.Any("id", id),
)
return
}
if err = coll(nil).FindOneByID(&w, oid); err != nil {
log.Warn(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "FindWithdrawOrderByID", table, "FindOneByID", err),
log.Any("id", id),
)
}
if w.ID.IsZero() { //coll(nil).FindOne过滤了mongo.ErrNoDocuments
err = OrderNotExistError{}
}
return
}
// FindWithdrawOrderByIDAndStatus 查询
func FindWithdrawOrderByIDAndStatus(id string, status int) (w WithdrawOrder, err error) {
oid, err := primitive.ObjectIDFromHex(id)
if err != nil {
log.Warn(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "FindWithdrawOrderByIDAndStatus", table, "ObjectIDFromHex", err),
log.Any("status", status),
log.Any("id", id),
)
return
}
if err = coll(nil).FindOne(&w, bson.M{"_id": oid, "status": status}); err != nil {
log.Warn(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "FindWithdrawOrderByIDAndStatus", table, "FindOne", err),
log.Any("status", status),
log.Any("id", id),
)
}
if w.ID.IsZero() { //coll(nil).FindOne过滤了mongo.ErrNoDocuments
err = OrderNotExistError{}
}
return
}
// FindOrders 查询充值订单
func FindOrdersByUID(uid uint64, pageNumber, pageSize uint64) (total int64, data []*WithdrawOrder, hasNext bool, err error) {
data = make([]*WithdrawOrder, 0)
f := bson.M{"uid": uid}
skip := int64(pageSize * (pageNumber - 1))
limit := int64(pageSize + 1)
opts := options.FindOptions{
Skip: &skip,
Limit: &limit,
Sort: bson.D{{Key: "createdAt", Value: -1}},
}
if err = coll(nil).Find(&data, f, &opts); err != nil {
log.Warn(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "FindOrders", table, "Find", err),
log.Any("cond", f),
)
return
}
total, err = coll(nil).Count(f)
if err != nil {
log.Warn(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "FindOrders", table, "Count", err),
log.Any("cond", f),
)
}
if len(data) > int(pageSize) {
hasNext = true
data = data[:pageSize]
}
return
}
// FindOrders 查询充值订单
func FindOrders(cond bson.M, opts *options.FindOptions) (total int64, data []*WithdrawOrder, err error) {
if v, ok := cond["districtRemark"]; ok {
cond["districtRemark"] = bson.M{"$regex": v, "$options": "i"}
}
data = make([]*WithdrawOrder, 0)
if err = coll(nil).Find(&data, cond, opts); err != nil {
log.Warn(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "FindOrders", table, "Find", err),
log.Any("cond", cond),
)
return
}
total, err = coll(nil).Count(cond)
if err != nil {
log.Warn(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "FindOrders", table, "Count", err),
log.Any("cond", cond),
)
}
return
}
// UpdateWithPROCESSINGAndUNKNOWN 回调更改订单状态
func UpdateWithPROCESSINGAndUNKNOWN(t *db.MongoTool, id string, set EditSelector) error {
set.UpdatedAt = time.Now()
objID, err := primitive.ObjectIDFromHex(id)
if err != nil {
log.Warn(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "Update", table, "ObjectIDFromHex", err),
log.Any("id", id),
log.Any("set", set),
)
return err
}
res, err := coll(t).UpdateOne(primitive.M{"_id": objID, "status": bson.M{"$in": []int{PROCESSING, UNKNOWN}}}, bson.M{"$set": set})
if err != nil {
log.Warn(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "Update", table, "UpdateOne", err),
log.Any("id", id),
log.Any("set", set),
)
return err
}
if res.ModifiedCount <= 0 {
log.Warn(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "Update", table, "errors.New", "Invalid account"),
log.Any("id", id),
log.Any("set", set),
)
return errors.New("Invalid account")
}
return nil
}
// Update 更新充值订单状态,OId
func Update(t *db.MongoTool, id string, set EditSelector) error {
set.UpdatedAt = time.Now()
objID, err := primitive.ObjectIDFromHex(id)
if err != nil {
log.Warn(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "Update", table, "ObjectIDFromHex", err),
log.Any("id", id),
log.Any("set", set),
)
return err
}
res, err := coll(t).UpdateOne(primitive.M{"_id": objID}, bson.M{"$set": set})
if err != nil {
log.Warn(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "Update", table, "UpdateOne", err),
log.Any("id", id),
log.Any("set", set),
)
return err
}
if res.ModifiedCount <= 0 {
log.Warn(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "Update", table, "errors.New", "Invalid account"),
log.Any("id", id),
log.Any("set", set),
)
return errors.New("Invalid account")
}
return nil
}
// TotalMoney 统计总提现金额
func TotalMoney(matchers ...Matcher) (int64, error) {
var ret struct {
Money int64 `bson:"money"` //实际到账金额
}
filter := []bson.M{
{
"$match": pageopt.MergeM(matchers),
},
{
"$group": bson.M{
"_id": nil,
"money": bson.M{"$sum": "$money"},
},
},
}
if err := coll(nil).AggregateDecode(&ret, filter); err != nil {
log.ZapLog.Warn("withdraw TotalMoney AggregateDecode failed", log.E(err))
return 0, err
}
return ret.Money, nil
}
// WithdrawAmontByTime 金币提现金额 提现类型,0:代理提现; 1:金币提现 李秋山确认
func WithdrawAmontByTime(start time.Time, end time.Time, types WithdrawTypes) (int64, error) {
pipeline := []bson.M{
{
"$match": bson.M{
// createdAt ∈ [startTime, endTime)
"successAt": bson.M{"$gte": start, "$lt": end},
"withdrawType": types,
},
},
{
"$group": bson.M{
"_id": nil,
"totalWithdrawAmount": bson.M{"$sum": "$money"}, //Money:提现金额
},
},
}
var ret struct {
TotalWithdrawAmount int64 `bson:"totalWithdrawAmount"`
}
if err := coll(nil).AggregateDecode(&ret, pipeline); err != nil {
return 0, err
}
return ret.TotalWithdrawAmount, nil
}
// ChannelOrderCountMap channel->订单数 map
func ChannelOrderCountMap(start, end time.Time) (map[string]int64, error) {
filter := bson.M{
"createdAt": bson.M{
"$gte": start,
"$lt": end,
},
}
list := []struct {
ID primitive.ObjectID `bson:"_id,omitempty"` //流水id
Channel string `bson:"channel"` //渠道类型 金鱼
}{}
if err := coll(nil).Find(&list, filter); err != nil {
return nil, err
}
m := make(map[string]int64, len(list))
for _, v := range list {
m[v.Channel] += 1
}
return m, nil
}
// ChannelOrderMoneyMap channel->订单金额 map
func ChannelOrderMoneyMap(start, end time.Time) (map[string]int64, error) {
filter := bson.M{
"createdAt": bson.M{
"$gte": start,
"$lt": end,
},
}
list := []struct {
Channel string `bson:"channel"` //渠道类型 鲨鱼 金鱼
Money int64 `bson:"money"` //提现金额
}{}
if err := coll(nil).Find(&list, filter); err != nil {
return nil, err
}
m := make(map[string]int64, len(list))
for _, v := range list {
m[v.Channel] += v.Money
}
return m, nil
}
// ChannelCompleteOrderCountMap channel->完成订单数 map
func ChannelCompleteOrderCountMap(start, end time.Time) (map[string]int64, error) {
filter := bson.M{
"successAt": bson.M{
"$gte": start,
"$lt": end,
},
}
list := []struct {
ID primitive.ObjectID `bson:"_id,omitempty"` //流水id
Channel string `bson:"channel"` //渠道类型 鲨鱼 金鱼
}{}
if err := coll(nil).Find(&list, filter); err != nil {
return nil, err
}
m := make(map[string]int64, len(list))
for _, v := range list {
m[v.Channel] += 1
}
return m, nil
}
// ChannelCompleteOrderAmountMap channel->完成订单的实际到账金额 map
func ChannelCompleteOrderPayMoneyMap(start, end time.Time) (map[string]int64, error) {
filter := bson.M{
"successAt": bson.M{
"$gte": start,
"$lt": end,
},
}
list := []struct {
Channel string `bson:"channel"` //渠道类型 鲨鱼 金鱼
PayMoney int64 `bson:"payMoney"` //实际到账金额 李秋山确认
}{}
if err := coll(nil).Find(&list, filter); err != nil {
return nil, err
}
m := make(map[string]int64, len(list))
for _, v := range list {
m[v.Channel] += v.PayMoney
}
return m, nil
}
// ChannelReceivedOrderCountMap channel->已出款订单数 map
func ChannelReceivedOrderCountMap(start, end time.Time) (map[string]int64, error) {
filter := bson.M{
"receivedAt": bson.M{
"$gte": start,
"$lt": end,
},
}
list := []struct {
ID primitive.ObjectID `bson:"_id,omitempty"` //流水id
Channel string `bson:"channel"` //渠道类型 鲨鱼 金鱼
}{}
if err := coll(nil).Find(&list, filter); err != nil {
return nil, err
}
m := make(map[string]int64, len(list))
for _, v := range list {
m[v.Channel] += 1
}
return m, nil
}
// ChannelReceivedMoneyMap channel->已出款金额 map
func ChannelReceivedMoneyMap(start, end time.Time) (map[string]int64, error) {
filter := bson.M{
"receivedAt": bson.M{
"$gte": start,
"$lt": end,
},
}
list := []struct {
Channel string `bson:"channel"` //渠道类型 鲨鱼 金鱼
PayMoney int64 `bson:"payMoney"` //实际到账金额 李秋山确认
}{}
if err := coll(nil).Find(&list, filter); err != nil {
return nil, err
}
m := make(map[string]int64, len(list))
for _, v := range list {
m[v.Channel] += v.PayMoney
}
return m, nil
}
func UpdateOne(t *db.MongoTool, filter bson.M, update bson.M) (rr error) {
n, err := coll(t).UpdateOne(filter, bson.M{"$set": update})
if err != nil {
log.Warn(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "update", table, "updateOne", err))
return err
}
if n.ModifiedCount <= 0 {
return errors.New("not modified")
}
return nil
}