471 lines
13 KiB
Go
471 lines
13 KiB
Go
/*
|
|
* @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
|
|
}
|