minghui/mh_server
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

fix:

Browse Source
This commit is contained in:
li 2022-01-26 16:02:21 +08:00
parent 688a10f782
commit 0a4c7f2c4b
11 changed files with 4056 additions and 298 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

66
controller/game_card.go
View File

@ -251,13 +251,49 @@ func PushWXPayNotice(c *gin.Context) {
if notify.Attach == wxpay.WxPayRentCard {
logger.Info("租借游戏卡 支付成功:")
err = model.NewOrderQuerySet(model.DB).OrderSnEq(notify.OutTradeNo).GetUpdater().
SetPayStatus(model.PayStatusPaid).SetPayTime(time.Now()).Update()
var order model.Order
err := model.NewOrderQuerySet(model.DB).OrderSnEq(notify.OutTradeNo).One(&order)
if err != nil {
logger.Error("err:", err)
return
}
begin := model.DB.Begin()
err = model.NewOrderQuerySet(begin).IDEq(order.ID).GetUpdater().
SetPayStatus(model.PayStatusPaid).SetPayTime(time.Now()).Update()
if err != nil {
begin.Rollback()
logger.Error("err:", err)
return
}
//model.OrderCard{}
_, err = model.NewOrderCardQuerySet(begin).OrderIdEq(order.ID).GetUpdater().
SetPayStatus(model.PayStatusPaid).UpdateNum()
if err != nil {
begin.Rollback()
logger.Error("err:", err)
return
}
err = order.InventoryReduction(begin)
if err != nil {
begin.Rollback()
logger.Error("err:", err)
return
}
err = begin.Commit().Error
if err != nil {
begin.Rollback()
logger.Error("err:", err)
return
}
count, err := model.NewOrderQuerySet(begin).IDEq(order.ID).Count()
if err != nil {
logger.Error("err:", err)
return
}
go model.OrderCardUserRentCard(uint32(order.Uid), uint32(count), nil)
} else if notify.Attach == wxpay.WxPayMember {
logger.Info("开通会员 支付成功:")
@ -364,17 +400,29 @@ func PushWXPayNotice(c *gin.Context) {
} else if notify.Attach == wxpay.WxPayDeposit {
record := &model.UserOpenMemberRecord{OpenNo: notify.OutTradeNo}
err := record.GetByOpenNo()
if err != nil {
logger.Error("err:", err)
}
configInfo, err := model.PayConfigInfo()
if err != nil {
logger.Error("err:", err)
return
}
num, err := model.NewUserQuerySet(model.DB).UidEq(record.Uid).GetUpdater().SetDeposit(configInfo.DepositFee).UpdateNum()
//configInfo, err := model.PayConfigInfo()
//if err != nil {
// logger.Error("err:", err)
// return
//}
user := model.GetUserByUid(record.Uid)
if user == nil {
logger.Error("user nil")
return
}
memberConfig, err := model.GetMemberConfig(user.MemberLevel)
if err != nil {
logger.Error("err:",err)
return
}
num, err := model.NewUserQuerySet(model.DB).UidEq(record.Uid).GetUpdater().SetDeposit(memberConfig.MemberDeposit).UpdateNum()
if err != nil {
logger.Error("update deposit err:", err)
}

278
controller/order.go
View File

@ -55,14 +55,9 @@ import (
// }
//}
func OrderList(c *gin.Context) {
req := struct {
Page int `json:"page"`
PageSize int `json:"page_size"`
}{
Page: 1,
PageSize: 10,
}
func RentCardOrderList(c *gin.Context) {
fmt.Println("RentCardOrderList")
req := model.OrderListReq{}
if c.ShouldBindJSON(&req) != nil {
logger.Error("ShouldBindJSON err")
RespJson(c, status.BadRequest, nil)
@ -74,7 +69,10 @@ func OrderList(c *gin.Context) {
RespJson(c, status.Unauthorized, nil)
return
}
orderList, totalPage, err := model.GetOrderList(uint64(uc.Uid), req.Page, req.PageSize) // TODO
req.Uid = uc.Uid
orderCardList, totalPage, err := req.GetOrderCardList() // TODO
if err != nil {
logger.Error("err:", err)
RespJson(c, status.InternalServerError, nil)
@ -82,7 +80,7 @@ func OrderList(c *gin.Context) {
}
ret := map[string]interface{}{
"order_list": orderList,
"order_card_list": orderCardList,
"cur_page": req.Page,
"total_page": totalPage,
}
@ -93,6 +91,8 @@ func OrderList(c *gin.Context) {
func OrderInfo(c *gin.Context) {
req := struct {
OrderId uint32 `json:"order_id"`
GameCardId uint64 `json:"game_card_id"` // 游戏id
GameCardGoodsId uint64 `json:"game_card_goods_id" ` // 游戏卡id
}{}
if c.ShouldBindJSON(&req) != nil {
logger.Error("ShouldBindJSON err")
@ -101,14 +101,18 @@ func OrderInfo(c *gin.Context) {
}
order := model.Order{}
order.ID = req.OrderId
order.GameCardId = req.GameCardId
info, err := order.Info()
if err != nil {
logger.Error("err:", err)
RespJson(c, status.InternalServerError, nil)
return
}
RespOK(c, info)
var orderCard model.OrderCard
if len(info) > 0 {
orderCard = info[0]
}
RespOK(c, orderCard)
return
}
@ -155,15 +159,15 @@ func WXPaySuccess(c *gin.Context) {
var orderCreateLocker sync.Mutex
// 创建订单
func OrderCreate(c *gin.Context) {
func RentCardOrderCreate(c *gin.Context) {
//type Goods struct {
// Price uint32 `json:"price"`
//}
req := struct {
GameCardList []model.CardInfo `json:"game_card_list"`
StoreId uint64 `json:"store_id"`
UserAddressId uint64 `json:"user_address_id"`
StoreId uint32 `json:"store_id"`
UserAddressId uint32 `json:"user_address_id"`
Price uint32 `json:"price"`
DeliveryType uint8 `json:"delivery_type"` // 取货方式
ExpressFee uint32 `json:"express_fee"`
@ -217,38 +221,52 @@ func OrderCreate(c *gin.Context) {
RespJson(c, status.NotMember, nil)
return
}
if user.Deposit == 0 {
logger.Error(errors.New("user deposit 0"))
RespJson(c, status.OrderUnpaidDeposit, nil)
return
}
memberConfig, err := model.GetMemberConfig(user.MemberLevel)
if err != nil {
logger.Error("GetMemberConfig err:", err)
RespJson(c, status.InternalServerError, nil)
return
}
if user.Deposit != memberConfig.MemberDeposit {
logger.Error(errors.New("user deposit 0"))
RespJson(c, status.OrderUnpaidDeposit, nil)
return
}
cardCount := uint32(0)
for _, v := range req.GameCardList {
cardCount += v.Count
}
if memberConfig.MemberLever < cardCount {
fmt.Println("cardCount:", cardCount)
rentCard := model.GetUserRentCard(uc.Uid)
if rentCard == nil {
//logger.Error(errors.New("GetUserByUid err"))
//RespJson(c, status.InternalServerError, nil)
//return
fmt.Println("CardMax", memberConfig.CardMax)
rentCard = &model.UserRentCard{LevelRentCount: memberConfig.CardMax, CanRentCount: memberConfig.CardMax}
}
fmt.Println("rentCard", rentCard.CanRentCount)
if cardCount > rentCard.CanRentCount {
logger.Error("GetMemberConfig err:", err)
RespJson(c, status.OrderMemberLevelLow, nil)
RespJson(c, status.OrderOutRentCount, nil)
return
}
model.UnPayOrderSetCancel(user.Uid)
// 订单成功后 扣减库存
//model.UnPayOrderSetCancel(user.Uid)
orderCreateLocker.Lock()
defer orderCreateLocker.Unlock()
unreturnedOrders, err := model.IsHaveUnreturnedOrders(uc.Uid) // TODO
isRentCount, err := rentCard.IsHaveUnreturnedOrders(cardCount)
//unreturnedOrders, err := model.IsHaveUnreturnedOrders(uc.Uid) // TODO
if err != nil {
logger.Error("err:", err)
RespJson(c, status.InternalServerError, nil)
return
}
if unreturnedOrders {
if isRentCount {
logger.Error("unreturnedOrders")
RespJson(c, status.HaveUnreturnedOrders, nil)
return
@ -265,9 +283,9 @@ func OrderCreate(c *gin.Context) {
RespJson(c, status.GoodsSoldOut, nil)
return
}
if req.DeliveryType == 1 {
}
//if req.DeliveryType == 1 {
//}
reqJson, _ := json.Marshal(&req)
fmt.Println("reqJson:", string(reqJson))
@ -277,8 +295,8 @@ func OrderCreate(c *gin.Context) {
order := model.Order{
Uid: uint64(uc.Uid),
GameCardId: 0,
StoreId: req.StoreId,
UserAddressId: req.UserAddressId,
StoreId: uint64(req.StoreId),
UserAddressId: uint64(req.UserAddressId),
DeliveryType: req.DeliveryType,
Count: 1,
PickupCode: model.GetPickupCode(), // TODO 取货码
@ -290,8 +308,7 @@ func OrderCreate(c *gin.Context) {
Postage: req.ExpressFee,
}
//tx := model.TransactionBegin()
////TODO 以支付成功作为订单下单成功的依据，不是订单创建 已修改
//TODO 以支付成功作为订单下单成功的依据，不是订单创建 已修改
//var gameCardGoodsStock model.GameCardGoodsStock
//err = model.NewGameCardGoodsStockQuerySet(model.DB).StoreIdEq(req.StoreId).GameCardIdEq(req.GameCardId).One(&gameCardGoodsStock)
//if err != nil {
@ -304,52 +321,86 @@ func OrderCreate(c *gin.Context) {
// RespJson(c, status.OrderStockOut, nil)
// return
//}
//
//fmt.Println("PayPrice:", order.PayPrice)
//if req.Price == 0 {
// order.PayStatus = model.PayStatusPaid
// fmt.Println("orderId:", order.PayStatus)
// err = order.OrderCreate()
// if err != nil {
// logger.Error("err:", err)
// RespJson(c, status.InternalServerError, nil)
// return
// }
//
// // 减库存
// sql := fmt.Sprintf("UPDATE game_card_goods_stock SET rent_stock= rent_stock-1 WHERE store_id=%d AND game_card_id=%d;", req.StoreId, req.GameCardId)
// fmt.Println("sql:", sql)
// err = model.DB.Exec(sql).Error
// if err != nil {
stockEnough, err := model.IsCardGoodsStockEnough(req.GameCardList, req.StoreId)
if err != nil {
logger.Error("err:", err)
RespJson(c, status.InternalServerError, nil)
return
}
if stockEnough {
logger.Error("order stock out ")
RespJson(c, status.OrderStockOut, nil)
return
}
fmt.Println("PayPrice:", order.PayPrice)
if req.Price == 0 {
tx := model.TransactionBegin()
order.PayStatus = model.PayStatusPaid
fmt.Println("orderId:", order.PayStatus)
err = order.OrderCreate(tx)
if err != nil {
tx.Rollback()
logger.Error("err:", err)
RespJson(c, status.InternalServerError, nil)
return
}
// 减库存
//sql := fmt.Sprintf("UPDATE game_card_goods_stock SET rent_stock= rent_stock-1 WHERE store_id=%d AND game_card_id=%d;", req.StoreId, req.GameCardId)
//fmt.Println("sql:", sql)
//err = model.DB.Exec(sql).Error
//if err != nil {
// logger.Errorf("err:", err)
// RespJson(c, status.InternalServerError, nil)
// return
// }
//
// ret := map[string]interface{}{
// "web_pay": "",
// "order_id": order.ID,
// }
// RespOK(c, ret)
// return
//}
//
//begin := model.DB.Begin()
////err = order.OrderCreate()
////if err != nil {
//// logger.Error("err:", err)
//// RespJson(c, status.InternalServerError, nil)
//// return
////}
//err = order.Create(begin)
err := model.GameCardGoodsInventoryReduction(req.GameCardList, req.StoreId, tx)
if err != nil {
tx.Rollback()
logger.Error("inventory reduction err:%s", err.Error())
RespJson(c, status.InternalServerError, nil)
return
}
err = order.CreatOrderCard(req.GameCardList, req.StoreId, tx)
if err != nil {
tx.Rollback()
logger.Error("inventory reduction err:%s", err.Error())
RespJson(c, status.InternalServerError, nil)
return
}
err = tx.Commit().Error
if err != nil {
tx.Rollback()
logger.Error("commit err:", err)
RespJson(c, status.InternalServerError, nil)
return
}
go model.OrderCardUserRentCard(uc.Uid, cardCount, memberConfig)
ret := map[string]interface{}{
"web_pay": "",
"order_id": order.ID,
}
RespOK(c, ret)
return
}
//err = order.OrderCreate()
//if err != nil {
// begin.Rollback()
// logger.Error("err:", err)
// RespJson(c, status.InternalServerError, nil)
// return
//}
//
//// 减库存
begin := model.DB.Begin()
err = order.Create(begin)
if err != nil {
begin.Rollback()
logger.Error("err:", err)
RespJson(c, status.InternalServerError, nil)
return
}
// 减库存
//sql := fmt.Sprintf("UPDATE game_card_goods_stock SET rent_stock= rent_stock-1 WHERE store_id=%d AND game_card_id=%d;", req.StoreId, req.GameCardId)
//fmt.Println("sql:", sql)
//err = begin.Exec(sql).Error
@ -359,14 +410,29 @@ func OrderCreate(c *gin.Context) {
// RespJson(c, status.InternalServerError, nil)
// return
//}
//err = begin.Commit().Error
// TODO 订单回调成功减库存
//err = model.GameCardGoodsInventoryReduction(req.GameCardList, req.StoreId, begin)
//if err != nil {
// begin.Rollback()
// logger.Errorf("err:", err)
// logger.Error("inventory reduction err:%s", err.Error())
// RespJson(c, status.InternalServerError, nil)
// return
//}
//
err = order.CreatOrderCard(req.GameCardList, req.StoreId, begin)
if err != nil {
begin.Rollback()
logger.Error("inventory reduction err:%s", err.Error())
RespJson(c, status.InternalServerError, nil)
return
}
err = begin.Commit().Error
if err != nil {
begin.Rollback()
logger.Errorf("err:", err)
RespJson(c, status.InternalServerError, nil)
return
}
//orderId := fmt.Sprintf("%d", order.ID)
////orderId = "100000"
//fmt.Println("orderId", orderId)
@ -712,14 +778,14 @@ func OrderRevert(c *gin.Context) {
}
//order := model.Order{}
//order.ID = req.OrderId
info, err := order.Revert()
err := order.Revert()
if err != nil {
logger.Error("err:", err)
RespJson(c, status.OrderCompleted, nil)
return
}
RespOK(c, info)
RespOK(c, nil)
return
}
@ -732,22 +798,55 @@ func OrderRevertCancel(c *gin.Context) {
}
//order := model.Order{}
//order.ID = req.OrderId
info, err := order.RevertCancel()
_, err := order.RevertCancel()
if err != nil {
logger.Error("err:", err)
RespJson(c, status.OrderCompleted, nil)
RespJson(c, status.OrderStatusNotReturning, nil)
return
}
RespOK(c, info)
//if isRecede {
// outTradeNo, err := model.GetWxPayExpressFeeRefundRecord(order.ID)
// if err != nil {
// logger.Error("err:", err)
// RespJson(c, status.InternalServerError, nil)
// return
// }
//
// orderSn := model.GetOrderSn()
// err = model.UserOpenMemberRecord{Uid: uint32(order.Uid), OpenNo: orderSn, OrderId: order.ID, OrderType: 2}.Insert()
// if err != nil {
// logger.Error(errors.New("WebPay err"))
// RespJson(c, status.InternalServerError, nil)
// return
// }
//
// orderRefund := wxpay.OrderRefund{
// OutTradeNo: outTradeNo,
// OutRefundNo: orderSn,
// NotifyUrl: "",
// Amount: wxpay.OrderRefundAmount{
// Refund: order.PayPrice,
// Total: order.PayPrice,
// Currency: "CNY",
// },
// }
// //bytes, _ := json.Marshal(orderRefund)
// //fmt.Println("订单取消:", string(bytes))
// //err = wxpay.WxPayOrderRefund(orderRefund)
// err = wxpay.TransactionOrderRefund(orderRefund)
// if err != nil {
// logger.Error("err:", err)
// RespJson(c, status.InternalServerError, nil)
// return
// }
//}
RespOK(c, nil)
return
}
func OrderCancel(c *gin.Context) {
req := struct {
OrderId uint32 `json:"order_id"`
}{}
if c.ShouldBindJSON(&req) != nil {
order := model.Order{}
if c.ShouldBindJSON(&order) != nil {
logger.Error("ShouldBindJSON err")
RespJson(c, status.BadRequest, nil)
return
@ -758,10 +857,10 @@ func OrderCancel(c *gin.Context) {
// RespJson(c, status.Unauthorized, nil)
// return
//}
fmt.Println("OrderId:", req.OrderId)
order := &model.Order{}
order.ID = req.OrderId
err := order.Cancel()
fmt.Println("OrderId:", order.ID)
//order := &model.Order{}
//order.ID = req.OrderId
isRecede, err := order.Cancel()
if err != nil {
logger.Error("err:", err)
RespJson(c, status.OrderDelivered, nil)
@ -769,7 +868,14 @@ func OrderCancel(c *gin.Context) {
}
fmt.Println("order:", order)
if order.DeliveryType == 2 {
if isRecede {
err = model.NewOrderQuerySet(model.DB).IDEq(order.ID).GetUpdater().SetCardStatus(OrderCardStatusCancel).Update()
if err != nil {
logger.Error("err:", err)
RespJson(c, status.InternalServerError, nil)
return
}
outTradeNo, err := model.GetWxPayExpressFeeRefundRecord(order.ID)
if err != nil {
logger.Error("err:", err)

84
controller/user.go
View File

@ -260,7 +260,84 @@ func OpenMember(c *gin.Context) {
//}
//orderSn := utils.GetSerialNo32HEXString()
orderSn := model.GetOrderSn()
err = model.UserOpenMemberRecord{Uid: uc.Uid, OpenNo: orderSn,MemberLevel: req.MemberLevel}.Insert()
err = model.UserOpenMemberRecord{Uid: uc.Uid, OpenNo: orderSn, MemberLevel: req.MemberLevel}.Insert()
if err != nil {
logger.Error(errors.New("WebPay err"))
RespJson(c, status.InternalServerError, nil)
return
}
webPay, err := wxpay.WebPay(orderSn, totalFee, user.WxOpenID, "N", wxpay.WxPayMember)
if err != nil {
logger.Error(errors.New("WebPay err"))
RespJson(c, status.InternalServerError, nil)
return
}
RespOK(c, webPay)
}
func UpgradeMember(c *gin.Context) {
req := struct {
MemberLevel uint32 `json:"member_level"` // 昵称
}{}
if c.ShouldBindJSON(&req) != nil {
logger.Error("parameter err")
RespJson(c, status.BadRequest, nil)
return
}
uc := auth.GetCurrentUser(c)
if uc == nil {
RespJson(c, status.Unauthorized, nil)
return
}
user := model.GetUserByUid(uc.Uid)
if user.MemberLevel != 2 && user.MemberLevel != 4 {
logger.Error("MemberLevel err:")
RespJson(c, status.InternalServerError, nil)
return
}
//configInfo, err := model.PayConfigInfo()
//if err != nil {
// logger.Error("err:", err)
// RespJson(c, status.InternalServerError, nil)
// return
//}
memberConfig, err := model.GetMemberConfig(req.MemberLevel)
if err != nil {
logger.Error("err:", err)
RespJson(c, status.InternalServerError, nil)
return
}
//totalFee := uint32(MemberFee + DepositFee)
////totalFee = uint32(3) // TODO 测试
//if user.Deposit == 300 {
// totalFee = MemberFee
// // //totalFee = uint32(1) // TODO 测试
//}
fmt.Println("configInfo.MemberFee : configInfo.DepositFee", memberConfig.MemberFee, memberConfig.MemberDeposit)
totalFee := memberConfig.MemberFee + memberConfig.MemberDeposit
if user.Deposit == memberConfig.MemberDeposit {
totalFee = memberConfig.MemberFee
}
if totalFee == 0 {
logger.Error(errors.New("totalFee is 0"))
RespJson(c, status.InternalServerError, nil)
return
}
//webPay, err := wxpay.WebPay(uid, totalFee, user.WxOpenID, "N", wxpay.WxPayMember)
//if err != nil {
// logger.Error(errors.New("WebPay err"))
// RespJson(c, status.InternalServerError, nil)
// return
//}
//orderSn := utils.GetSerialNo32HEXString()
orderSn := model.GetOrderSn()
err = model.UserOpenMemberRecord{Uid: uc.Uid, OpenNo: orderSn, MemberLevel: req.MemberLevel}.Insert()
if err != nil {
logger.Error(errors.New("WebPay err"))
RespJson(c, status.InternalServerError, nil)
@ -303,7 +380,7 @@ func PayDeposit(c *gin.Context) {
//}
memberConfig, err := model.GetMemberConfig(level)
if err != nil {
logger.Error("GetMemberConfig err:",err)
logger.Error("GetMemberConfig err:", err)
RespJson(c, status.InternalServerError, nil)
return
}
@ -430,3 +507,6 @@ func MemberConfigList(c *gin.Context) {
// 会员列表 开通会员 下订单 借卡 还卡
// 会员升级
// 299会员 升级
// 订单 会员导数据
// 退押金记录

5
lib/status/status.go
View File

@ -90,6 +90,8 @@ const (
OrderUnpaidDeposit = 500506 // 未交押金
RefundDepositSubmitted = 500507 // 已提交押金退款
OrderMemberLevelLow = 500508 // 会员等级低
OrderOutRentCount = 500509 // 会员超过可借卡数
OrderStatusNotReturning = 500510 // 订单已完成
ToastErr = 600 // 报错
)
@ -131,6 +133,7 @@ var statusDesc = map[int]string{
NotExists: "请求的资源不存在",
IsExists: "资源已经存在",
OrderStatusNotReturning: "该卡状态不能取消",
InternalServerError: "服务器开小差了，请稍后再试",
SmsFail: "短信发送失败",
@ -194,7 +197,7 @@ var statusMsg = map[int]string{
NotExists: "请求的资源不存在",
IsExists: "资源已经存在",
OrderOutRentCount: "借卡数量超了",
InternalServerError: "服务器开小差了，请稍后再试",
SmsFail: "短信发送失败",

1551
model/autogenerated_order.go
View File

File diff suppressed because it is too large Load Diff

1602
model/autogenerated_user.go
View File

File diff suppressed because it is too large Load Diff

2
model/base_init_db.go
View File

@ -27,7 +27,7 @@ func InitDB() {
DB.DB().SetMaxIdleConns(500)
DB.DB().SetConnMaxLifetime(time.Second * 10)
DB.LogMode(true)
DB.SetLogger(DBLoggerWriter{})
//DB.SetLogger(DBLoggerWriter{})
DB.SingularTable(true)
if err := DB.DB().Ping(); err != nil {
fmt.Println("Ping Database Fail, error = ", err)

3
model/model_test.go
View File

@ -95,6 +95,9 @@ func InitTestDB() {
&UserRedeemCode{},
&DepositRefundRecord{},
&GroupSendMessageTemplate{},
&OrderCard{},
&UserRentCard{},
&UserConsumeRecord{},
)

610
model/order.go
View File

@ -1,12 +1,12 @@
package model
import (
"encoding/json"
"errors"
"fmt"
"github.com/codinl/go-logger"
"github.com/jinzhu/gorm"
"math/rand"
"qiniupkg.com/x/log.v7"
"time"
)
@ -63,6 +63,7 @@ type Order struct {
Mchid string `json:"mchid"` // 商户
}
// gen:qs
type OrderCard struct {
Model
OrderId uint32 `json:"order_id" gorm:"index"`
@ -70,7 +71,31 @@ type OrderCard struct {
GameCardId uint32 `json:"game_card_id" gorm:"index"` // 游戏id
GameCardGoodsId uint32 `json:"game_card_goods_id" gorm:"index"` // 游戏卡id
StoreId uint32 `json:"store_id" gorm:"index"` // 门店id
Status uint8 `json:"status" gorm:"index"` // 1-待领取 2-游玩中 3-已归还 4-未领取
CardStatus uint32 `json:"card_status"` // 1-待取货中 2-游玩中 3-归还中 4-已完成 5-已取消
DeliveryTime time.Time `json:"delivery_time"` // 发货时间
ReceiptTime time.Time `json:"receipt_time"` // 收货时间
DeliveryType uint8 `json:"delivery_type"` // 取货类型 1-门店自取 2-快递
SerialNumber string `json:"serial_number" gorm:"index"` // 编号
PayStatus uint8 `json:"pay_status"` // 支付状态 1-未支付 2-已支付
RevertStoreId uint64 `json:"revert_store_id"` // 归还门店id
RevertTime time.Time `json:"revert_time"` // 归还时间
RevertExpressCompany string `json:"revert_express_company"` // 归还物流公司
RevertExpressCompanyNo string `json:"revert_express_company_no"` // 归还物流公司编号
RevertExpressNo string `json:"revert_express_no"` // 归还物流单号
RevertExpressDuration uint64 `json:"revert_express_duration"` // 归还物流时长
//Status uint8 `json:"status" gorm:"index"` // 1-待领取 2-游玩中 3-已归还 4-未领取
Postage uint32 `json:"postage" gorm:"-"` // 邮费
ExpressCompany string `json:"express_company" gorm:"-"` // 物流公司
ExpressCompanyNo string `json:"express_company_no" gorm:"-"` // 物流公司编号
ExpressNo string `json:"express_no" gorm:"-"` // 物流单号
GameName string `json:"name" gorm:"-"` // 名称
GamePrice uint32 `json:"price" gorm:"-"` // 价格
GameCoverImg string `json:"cover_img" gorm:"-"` // 封面
Order *Order `json:"order" gorm:"-"` // 订单
//PickupCode string `json:"pickup_code"` // 取货码
}
func (*Order) TableName() string {
@ -80,181 +105,310 @@ func (*Order) TableName() string {
func (m *Order) ToInfo(card *GameCard) OrderInfo {
return OrderInfo{
Order: *m,
GameName: card.Name,
GamePrice: card.Price,
GameCoverImg: card.CoverImg,
}
}
type OrderInfo struct {
Order
GameName string `json:"name" gorm:"index"` // 名称
GamePrice uint32 `json:"price" gorm:"index"` // 价格
GameCoverImg string `json:"cover_img"` // 封面
Cards []OrderCard
}
func GetOrderList(uid uint64, page, pageSize int) ([]OrderInfo, uint32, error) {
var (
orders []Order
totalPage uint32
orderInfos = make([]OrderInfo, 0, pageSize)
)
page -= 1
if page < 0 {
page = 0
func OrderCardListSetGameInfo(list []OrderCard) []OrderCard {
//GameCardMap
ids := make([]uint32, 0, len(list))
orderIds := make([]uint32, 0, len(list))
for i, _ := range list {
ids = append(ids, list[i].GameCardId)
orderIds = append(orderIds, list[i].OrderId)
}
if len(ids) == 0 || len(orderIds) == 0 {
return list
}
//oq := NewOrderQuerySet(DB).UidEq(uid).OrderDescByCreatedAt().PayStatusEq(PayStatusPaid)
oq := NewOrderQuerySet(DB).UidEq(uid).OrderDescByCreatedAt()
orderMap, err := OrderMap(orderIds)
if err != nil {
logger.Error("err:", err)
return list
}
fmt.Println("ids:", ids)
cardMap, err := GameCardMap(ids)
if err != nil {
logger.Error("err:", err)
return list
}
bytes, _ := json.Marshal(&cardMap)
orderMapbytes, _ := json.Marshal(&orderMap)
fmt.Println("cardMap:", string(bytes))
fmt.Println("orderMap:", string(orderMapbytes))
for i, _ := range list {
fmt.Println("list[i].GameCardId", list[i].GameCardId)
fmt.Println("list[i].OrderId", list[i].OrderId)
gameCard, ok1 := cardMap[list[i].GameCardId]
order, ok2 := orderMap[list[i].OrderId]
fmt.Printf("gameCard1:%#v \n", gameCard)
if ok1 && ok2 {
fmt.Printf("gameCard2:%#v \n", gameCard)
list[i].GameName = gameCard.Name
list[i].GameCoverImg = gameCard.CoverImg
list[i].GamePrice = gameCard.Price
list[i].Order = &order
}
}
listbytes, _ := json.Marshal(&list)
fmt.Println("listbytes:", string(listbytes))
return list
}
func GameCardMap(ids []uint32) (map[uint32]GameCard, error) {
cardMap := make(map[uint32]GameCard, 0)
var cards []GameCard
err := NewGameCardQuerySet(DB).IDIn(ids...).All(&cards)
if err != nil {
logger.Error("err:", err)
return cardMap, err
}
if len(cards) == 0 {
return cardMap, nil
}
for i, _ := range cards {
cardMap[cards[i].ID] = cards[i]
}
return cardMap, nil
}
func OrderMap(ids []uint32) (map[uint32]Order, error) {
cardMap := make(map[uint32]Order, 0)
var cards []Order
err := NewOrderQuerySet(DB).IDIn(ids...).All(&cards)
if err != nil {
logger.Error("err:", err)
return cardMap, err
}
if len(cards) == 0 {
return cardMap, nil
}
for i, _ := range cards {
cardMap[cards[i].ID] = cards[i]
}
return cardMap, nil
}
type OrderListReq struct {
Page int `json:"page"`
PageSize int `json:"page_size"`
OrderType uint32 `json:"order_type"` // 1-全部 2-进行中 3-已完成
Uid uint32 `json:"uid"`
}
func (m *OrderListReq) GetOrderCardList() ([]OrderCard, uint32, error) {
var (
orderCards []OrderCard
totalPage uint32
//orderInfos = make([]OrderInfo, 0, pageSize)
)
m.Page -= 1
if m.Page < 0 {
m.Page = 0
}
if m.PageSize == 0 {
m.PageSize = 10
}
oq := NewOrderCardQuerySet(DB).PayStatusEq(PayStatusPaid).UidEq(m.Uid)
if m.OrderType == 2 {
oq = oq.CardStatusIn([]uint32{1, 2, 3}...)
}
if m.OrderType == 3 {
oq = oq.CardStatusEq(4)
}
count, err := oq.Count()
if err != nil {
log.Error("NewGameCardQuerySet err:", err)
return orderInfos, 0, err
logger.Error("NewGameCardQuerySet err:", err)
return orderCards, 0, err
}
err = oq.Offset(page * pageSize).Limit(pageSize).All(&orders)
err = oq.OrderDescByCreatedAt().Offset(m.Page * m.PageSize).Limit(m.PageSize).All(&orderCards)
if err != nil && err != RecordNotFound {
log.Error("err:", err)
return orderInfos, 0, err
logger.Error("err:", err)
return orderCards, 0, err
}
totalPage = uint32(count/pageSize + 1)
totalPage = uint32(count/m.PageSize + 1)
var games []GameCard
gameIds := make([]uint32, 0, len(orders))
for i, _ := range orders {
gameIds = append(gameIds, uint32(orders[i].GameCardId))
}
if len(gameIds) == 0 {
log.Error("gameIds is null")
return orderInfos, 0, err
}
err = NewGameCardQuerySet(DB).IDIn(gameIds...).All(&games)
if err != nil && err != RecordNotFound {
log.Error("err:", err)
return orderInfos, 0, err
}
gamesMap := make(map[uint32]*GameCard)
for i, _ := range games {
gamesMap[games[i].ID] = &games[i]
}
for i, _ := range orders {
card, ok := gamesMap[uint32(orders[i].GameCardId)]
if !ok {
continue
}
orderInfos = append(orderInfos, orders[i].ToInfo(card))
}
orderCards = OrderCardListSetGameInfo(orderCards)
return orderInfos, totalPage, nil
return orderCards, totalPage, nil
}
func (m *Order) Info() (*OrderInfo, error) {
var (
order Order
card GameCard
)
err := NewOrderQuerySet(DB).IDEq(m.ID).One(&order)
func (m *Order) Info() ([]OrderCard, error) {
//err := NewOrderQuerySet(DB).IDEq(m.ID).One(&order)
//if err != nil {
// logger.Error("err:", err)
// return nil, err
//}
//
//err = NewGameCardQuerySet(DB).IDEq(uint32(order.GameCardId)).One(&card)
//if err != nil && err != RecordNotFound {
// logger.Error("err:", err)
// return nil, err
//}
qs := NewOrderCardQuerySet(DB).OrderIdEq(m.ID).GameCardIdEq(uint32(m.GameCardId))
if m.GameCardGoodsId != 0 {
qs = qs.GameCardGoodsIdEq(uint32(m.GameCardGoodsId))
}
var orderCards []OrderCard
err := qs.All(&orderCards)
if err != nil {
log.Error("err:", err)
logger.Error("err:", err)
return nil, err
}
orderCards = OrderCardListSetGameInfo(orderCards)
err = NewGameCardQuerySet(DB).IDEq(uint32(order.GameCardId)).One(&card)
if err != nil && err != RecordNotFound {
log.Error("err:", err)
return nil, err
}
info := order.ToInfo(&card)
return &info, nil
//info := order.ToInfo(&card)
return orderCards, nil
}
func (m *Order) Revert() (*OrderInfo, error) {
func (m *Order) Revert() error {
var (
order Order
card GameCard
orderCard OrderCard
//card GameCard
)
qs := NewOrderQuerySet(DB).IDEq(m.ID)
err := qs.One(&order)
//qs := NewOrderQuerySet(DB).IDEq(m.ID)
//err := qs.One(&order)
//if err != nil {
// logger.Errorf("err:%#v", err)
// return err
//}
//if order.CardStatus == OrderCardStatusCompleted {
// logger.Error("order card status completed")
// return errors.New("order card status completed")
//}
fmt.Println("GameCardGoodsId------:",m.GameCardGoodsId)
fmt.Println("ID------:",m.ID)
err := NewOrderCardQuerySet(DB).OrderIdEq(m.ID).GameCardGoodsIdEq(uint32(m.GameCardGoodsId)).One(&orderCard)
if err != nil {
logger.Errorf("err:%#v", err)
return nil, err
return err
}
if order.CardStatus == OrderCardStatusCompleted {
if orderCard.CardStatus == OrderCardStatusCompleted {
logger.Error("order card status completed")
return nil, errors.New("order card status completed")
return errors.New("order card status completed")
}
err = qs.GetUpdater().
//err = qs.GetUpdater().
// SetCardStatus(OrderCardStatusReturning).
// SetRevertTime(time.Now()).
// SetRevertStoreId(m.RevertStoreId).
// SetRevertExpressCompany(m.RevertExpressCompany).
// SetRevertExpressCompanyNo(m.RevertExpressCompanyNo).
// SetRevertExpressNo(m.RevertExpressNo).Update()
//if err != nil {
// logger.Error("err:", err)
// return nil, err
//}
//order.CardStatus = OrderCardStatusReturning
////order.RevertTime = time.Now()
//order.RevertStoreId = m.RevertStoreId
//order.RevertExpressCompany = m.RevertExpressCompany
//order.RevertExpressCompanyNo = m.RevertExpressCompanyNo
//order.RevertExpressNo = m.RevertExpressNo
_, err = NewOrderCardQuerySet(DB).OrderIdEq(m.ID).GameCardGoodsIdEq(uint32(m.GameCardGoodsId)).GetUpdater().
SetCardStatus(OrderCardStatusReturning).
SetRevertTime(time.Now()).
SetRevertStoreId(m.RevertStoreId).
SetRevertExpressCompany(m.RevertExpressCompany).
SetRevertExpressCompanyNo(m.RevertExpressCompanyNo).
SetRevertExpressNo(m.RevertExpressNo).Update()
SetRevertExpressNo(m.RevertExpressNo).UpdateNum()
if err != nil {
log.Error("err:", err)
return nil, err
logger.Error("err:", err)
return err
}
order.CardStatus = OrderCardStatusReturning
order.RevertTime = time.Now()
order.RevertStoreId = m.RevertStoreId
order.RevertExpressCompany = m.RevertExpressCompany
order.RevertExpressCompanyNo = m.RevertExpressCompanyNo
order.RevertExpressNo = m.RevertExpressNo
//err = NewGameCardQuerySet(DB).IDEq(uint32(order.GameCardId)).One(&card)
//if err != nil && err != RecordNotFound {
// log.Error("err:", err)
// logger.Error("err:", err)
// return nil, err
//}
info := order.ToInfo(&card)
return &info, nil
//info := order.ToInfo(&card)
return nil
}
func (m *Order) RevertCancel() (*OrderInfo, error) {
func (m *Order) RevertCancel() (bool, error) {
var (
order Order
card GameCard
orderCard OrderCard
//order Order
//card GameCard
)
qs := NewOrderQuerySet(DB).IDEq(m.ID)
err := qs.One(&order)
//qs := NewOrderQuerySet(DB).IDEq(m.ID)
//err := qs.One(&order)
//if err != nil {
// logger.Errorf("err:%#v", err)
// return false, err
//}
//if order.CardStatus != OrderCardStatusReturning {
// logger.Error("order card status completed")
// return false, errors.New("order card status completed")
//}
err := NewOrderCardQuerySet(DB).OrderIdEq(m.ID).GameCardGoodsIdEq(uint32(m.GameCardGoodsId)).One(&orderCard)
if err != nil {
logger.Errorf("err:%#v", err)
return nil, err
return false, err
}
if order.CardStatus != OrderCardStatusReturning {
logger.Error("order card status completed")
return nil, errors.New("order card status completed")
if orderCard.CardStatus != OrderCardStatusReturning {
logger.Error("order card status returning")
return false, errors.New("order card status returning")
}
err = qs.GetUpdater().
//err = qs.GetUpdater().
// SetCardStatus(OrderCardStatusPlaying).
// SetRevertStoreId(0).
// SetRevertExpressCompany("").
// SetRevertExpressCompanyNo("").
// SetRevertExpressNo("").Update()
//if err != nil {
// logger.Error("err:", err)
// return nil, err
//}
//order.CardStatus = OrderCardStatusCancel
////order.RevertTime = time.Now()
//order.RevertStoreId = m.RevertStoreId
//order.RevertExpressCompany = m.RevertExpressCompany
//order.RevertExpressCompanyNo = m.RevertExpressCompanyNo
//order.RevertExpressNo = m.RevertExpressNo
_, err = NewOrderCardQuerySet(DB).OrderIdEq(m.ID).GameCardGoodsIdEq(uint32(m.GameCardGoodsId)).GetUpdater().
SetCardStatus(OrderCardStatusPlaying).
//SetRevertTime(time.Time{}).
SetRevertStoreId(0).
SetRevertExpressCompany("").
SetRevertExpressCompanyNo("").
SetRevertExpressNo("").Update()
SetRevertExpressNo("").UpdateNum()
if err != nil {
log.Error("err:", err)
return nil, err
logger.Error("err:", err)
return false, err
}
order.CardStatus = OrderCardStatusPlaying
//order.RevertTime = time.Now()
order.RevertStoreId = m.RevertStoreId
order.RevertExpressCompany = m.RevertExpressCompany
order.RevertExpressCompanyNo = m.RevertExpressCompanyNo
order.RevertExpressNo = m.RevertExpressNo
info := order.ToInfo(&card)
return &info, nil
isRecede := false
//if order.DeliveryType == 2 && order.Postage > 0 {
// isHaveOnDeliver, err := IsHaveOnDeliverOrderCards(m.ID)
// if err != nil {
// logger.Error("err:", err)
// return false, err
// }
// if !isHaveOnDeliver {
// isRecede = true
// }
//}
//info := order.ToInfo(&card)
return isRecede, nil
}
func (m *Order) OrderCreate() error {
err := m.Create(DB)
func (m *Order) OrderCreate(gdb *gorm.DB) error {
err := m.Create(gdb)
if err != nil {
log.Error("err:", err)
logger.Error("err:", err)
return err
}
return nil
@ -280,7 +434,7 @@ func (m *Order) Modify() (*OrderInfo, error) {
var card GameCard
err := NewGameCardQuerySet(DB).IDEq(uint32(m.GameCardId)).One(&card)
if err != nil && err != RecordNotFound {
log.Error("err:", err)
logger.Error("err:", err)
return nil, err
}
@ -289,10 +443,12 @@ func (m *Order) Modify() (*OrderInfo, error) {
return &info, nil
}
func IsHaveUnreturnedOrders(uid uint32) (bool, error) {
fmt.Println("uid", uid)
func (m *UserRentCard) IsHaveUnreturnedOrders(RentCount uint32) (bool, error) {
fmt.Println("uid", m.Uid)
sql := fmt.Sprintf("SELECT COUNT(*) AS count FROM `order` WHERE uid = %d AND pay_status=2 AND card_status IN (1,2,3) ;", uid)
sql := fmt.Sprintf("SELECT COUNT(order_card.id) FROM `order` RIGHT JOIN order_card ON `order`.id = order_card.order_id WHERE `order`.uid=%d AND `order`.pay_status=2 AND order_card.card_status IN (1,2,3) ;", m.Uid)
//sql := fmt.Sprintf("SELECT COUNT(*) AS count FROM `order` WHERE uid = %d AND pay_status=2 AND card_status IN (1,2,3) ;", m.Uid)
//sql := fmt.Sprintf("SELECT COUNT(*) AS count FROM `order` WHERE uid = %d AND pay_status=2 AND card_status IN (1,2,3) ;", uid)
//count, err := NewOrderQuerySet(DB).UidEq(uint64(uid)).PayStatusEq(PayStatusPaid).CardStatusIn(1, 2, 3).Count()
//if err != nil {
// logger.Error("err:", err)
@ -301,9 +457,22 @@ func IsHaveUnreturnedOrders(uid uint32) (bool, error) {
unreturned := &struct {
Count int `json:"count"`
}{}
DB.Raw(sql).Scan(unreturned)
err := DB.Raw(sql).Scan(unreturned).Error
if err != nil {
logger.Error("err:", err)
return false, err
}
fmt.Println("订单数量count:", unreturned.Count)
return unreturned.Count != 0, nil
return uint32(unreturned.Count)+RentCount > m.LevelRentCount, nil
}
func IsHaveOnDeliverOrderCards(orderId uint32) (bool, error) {
count, err := NewOrderCardQuerySet(DB).OrderIdEq(orderId).CardStatusEq(1).Count()
if err != nil {
logger.Error("err:", err)
return false, err
}
return count > 0, nil
}
func IsUserHaveUnreturnedOrder(uid uint32) (bool, error) {
@ -361,57 +530,88 @@ func GetPickupCode() string {
}
func (m *Order) Cancel() error {
var userOrder Order
err := NewOrderQuerySet(DB).IDEq(m.ID).One(&userOrder)
func (m *Order) Cancel() (bool, error) {
var (
order Order
orderCard OrderCard
)
err := NewOrderQuerySet(DB).IDEq(m.ID).One(&order)
if err != nil {
log.Error("err:", err)
return err
logger.Error("err:", err)
return false, err
}
if userOrder.CardStatus != OrderCardStatusUnPick {
log.Error("card status not unpick err: ")
return errors.New("card status not unpick")
//err = NewOrderCardQuerySet(DB).OrderIdEq(m.ID).GameCardGoodsIdEq(uint32(m.GameCardGoodsId)).One(&orderCard)
err = NewOrderCardQuerySet(DB).OrderIdEq(m.ID).GameCardIdEq(uint32(m.GameCardId)).CardStatusEq(OrderCardStatusUnPick).Limit(1).One(&orderCard)
if err != nil && err != RecordNotFound {
logger.Errorf("err:%#v", err)
return false, err
}
if userOrder.PayStatus == PayStatusUnPay && userOrder.CreatedAt.Add(30*time.Minute).Before(time.Now()) {
//if userOrder.PayStatus == PayStatusUnPay && userOrder.CreatedAt.Add(3*time.Minute).Before(time.Now()) {
log.Error("card status expire err: ")
return errors.New("card status expire")
if err == RecordNotFound {
logger.Error("order card status not unpick")
return false, errors.New("order card status not unpick")
}
//if userOrder.CardStatus != OrderCardStatusUnPick {
// logger.Error("card status not unpick err: ")
// return false,errors.New("card status not unpick")
//}
//if userOrder.PayStatus == PayStatusUnPay && userOrder.CreatedAt.Add(30*time.Minute).Before(time.Now()) {
// //if userOrder.PayStatus == PayStatusUnPay && userOrder.CreatedAt.Add(3*time.Minute).Before(time.Now()) {
// logger.Error("card status expire err: ")
// return errors.New("card status expire")
//}
//fmt.Println("PayStatus",userOrder.PayStatus)
//fmt.Println("DeliveryType",userOrder.DeliveryType)
//fmt.Println("CreatedAt",userOrder.CreatedAt.Add(4*time.Minute))
//fmt.Println("Now",time.Now())
if userOrder.PayStatus == PayStatusPaid && userOrder.DeliveryType == DeliveryTypeStorePick && userOrder.CreatedAt.Add(24*time.Hour).Before(time.Now()) {
//if userOrder.PayStatus == PayStatusPaid && userOrder.DeliveryType == DeliveryTypeStorePick && userOrder.CreatedAt.Add(4*time.Minute).Before(time.Now()) {
log.Error("card status expire err: ")
return errors.New("card status expire")
}
//if userOrder.PayStatus == PayStatusPaid && userOrder.DeliveryType == DeliveryTypeStorePick && userOrder.CreatedAt.Add(24*time.Hour).Before(time.Now()) {
// //if userOrder.PayStatus == PayStatusPaid && userOrder.DeliveryType == DeliveryTypeStorePick && userOrder.CreatedAt.Add(4*time.Minute).Before(time.Now()) {
// logger.Error("card status expire err: ")
// return errors.New("card status expire")
//}
begin := DB.Begin()
err = NewOrderQuerySet(begin).IDEq(m.ID).GetUpdater().SetCardStatus(OrderCardStatusCancel).Update()
//err = NewOrderQuerySet(begin).IDEq(orderCard.OrderId).GetUpdater().SetCardStatus(OrderCardStatusCancel).Update()
//if err != nil {
// begin.Rollback()
// logger.Error("err:", err)
// return false,err
//}
_, err = NewOrderCardQuerySet(DB).IDEq(orderCard.ID).GetUpdater().SetCardStatus(OrderCardStatusCancel).UpdateNum()
if err != nil {
begin.Rollback()
log.Error("err:", err)
return err
logger.Error("err:", err)
return false, err
}
sql := fmt.Sprintf("UPDATE game_card_goods_stock SET rent_stock= rent_stock+1 WHERE store_id=%d AND game_card_id=%d;", userOrder.StoreId, userOrder.GameCardId)
sql := fmt.Sprintf("UPDATE game_card_goods_stock SET rent_stock= rent_stock+1 WHERE store_id=%d AND game_card_id=%d;", orderCard.StoreId, orderCard.GameCardId)
fmt.Println("sql:", sql)
err = begin.Exec(sql).Error
if err != nil {
begin.Rollback()
logger.Errorf("err:%#v", err)
return err
return false, err
}
err = begin.Commit().Error
if err != nil {
begin.Rollback()
logger.Errorf("err:%#v", err)
return err
return false, err
}
isRecede := false
if order.DeliveryType == 2 && order.Postage > 0 {
isHaveOnDeliver, err := IsHaveOnDeliverOrderCards(m.ID)
if err != nil {
logger.Error("err:", err)
return false, err
}
if !isHaveOnDeliver {
isRecede = true
}
}
*m = userOrder
return nil
m = &order
return isRecede, nil
}
func UnPayOrderSetCancel(uid uint32) {
@ -419,7 +619,7 @@ func UnPayOrderSetCancel(uid uint32) {
var order Order
err := NewOrderQuerySet(DB.Debug()).UidEq(uint64(uid)).PayStatusEq(PayStatusUnPay).CardStatusEq(OrderCardStatusUnPick).One(&order)
if err != nil {
log.Error("err:", err)
logger.Error("err:", err)
return
}
@ -430,7 +630,7 @@ func UnPayOrderSetCancel(uid uint32) {
SetCardStatus(OrderCardStatusCancel).UpdateNum()
if err != nil {
begin.Rollback()
log.Error("err:", err)
logger.Error("err:", err)
return
}
@ -439,39 +639,115 @@ func UnPayOrderSetCancel(uid uint32) {
err = begin.Exec(sql).Error
if err != nil {
begin.Rollback()
log.Error("err:", err)
logger.Error("err:", err)
return
}
err = begin.Commit().Error
if err != nil {
begin.Rollback()
log.Error("err:", err)
logger.Error("err:", err)
}
}
func (m *Order) CreateByCardInfoList(cardInfos []CardInfo, gdb *gorm.DB) error {
err := gdb.Create(m).Error
//func (m *Order) CreateByCardInfoList(cardInfos []CardInfo, gdb *gorm.DB) error {
// err := gdb.Create(m).Error
// if err != nil {
// logger.Error("err:", err)
// return err
// }
// if m.ID == 0 {
// return errors.New("order id is 0")
// }
// for _, v := range cardInfos {
// for i := 0; i < int(v.Count); i++ {
// //OrderCard{
// // OrderId: m.ID,
// // Uid: uint32(m.Uid),
// // GameCardId: v.GameCardId,
// // GameCardGoodsId: 0,
// // StoreId: uint32(m.StoreId),
// // Status: 0,
// //}
// }
//
// }
//
// return nil
//}
func IsCardGoodsStockEnough(cards []CardInfo, storeId uint32) (bool, error) {
for i, _ := range cards {
var gameCardGoodsStock GameCardGoodsStock
err := NewGameCardGoodsStockQuerySet(DB).StoreIdEq(uint64(storeId)).GameCardIdEq(uint64(cards[i].GameCardId)).
One(&gameCardGoodsStock)
if err != nil {
log.Error("err:", err)
logger.Error("err:", err)
return false, err
}
if gameCardGoodsStock.RentStock < cards[i].Count {
logger.Error("order stock out ")
return false, errors.New("order stock out")
}
}
return false, nil
}
func GameCardGoodsInventoryReduction(cards []CardInfo, storeId uint32, gdb *gorm.DB) error {
for i, _ := range cards {
sql := fmt.Sprintf("UPDATE game_card_goods_stock SET rent_stock= rent_stock-%d WHERE store_id=%d AND game_card_id=%d;", cards[i].Count, storeId, cards[i].GameCardId)
fmt.Println("sql:", sql)
err := gdb.Exec(sql).Error
if err != nil {
logger.Error("err:", err)
return err
}
if m.ID == 0 {
return errors.New("order id is 0")
}
for _, v := range cardInfos {
for i := 0; i < int(v.Count); i++ {
//OrderCard{
// OrderId: m.ID,
// Uid: uint32(m.Uid),
// GameCardId: v.GameCardId,
// GameCardGoodsId: 0,
// StoreId: uint32(m.StoreId),
// Status: 0,
//}
}
}
return nil
}
func (m *Order) InventoryReduction(gdb *gorm.DB) error {
var cards []OrderCard
err := NewOrderCardQuerySet(DB).OrderIdEq(m.ID).All(&cards)
if err != nil {
logger.Error("err:", err)
return err
}
for i, _ := range cards {
sql := fmt.Sprintf("UPDATE game_card_goods_stock SET rent_stock= rent_stock-1 WHERE store_id=%d AND game_card_id=%d;", m.StoreId, cards[i].GameCardId)
fmt.Println("sql:", sql)
err := gdb.Exec(sql).Error
if err != nil {
logger.Error("err:", err)
return err
}
}
return nil
}
func (m *Order) CreatOrderCard(cards []CardInfo, storeId uint32, gdb *gorm.DB) error {
for _, v := range cards {
for i := 0; i < int(v.Count); i++ {
orderCard := &OrderCard{
OrderId: m.ID,
Uid: uint32(m.Uid),
GameCardId: v.GameCardId,
GameCardGoodsId: 0,
StoreId: storeId,
CardStatus: OrderCardStatusUnPick,
DeliveryTime: time.Time{},
ReceiptTime: time.Time{},
DeliveryType: m.DeliveryType,
SerialNumber: "",
PayStatus: m.PayStatus,
}
err := gdb.Create(orderCard).Error
if err != nil {
logger.Error("err:", err)
return err
}
}
}
return nil
}

88
model/user.go
View File

@ -2,6 +2,7 @@ package model
import (
"errors"
"fmt"
"github.com/codinl/go-logger"
"mh-server/lib/utils"
"sync"
@ -91,6 +92,39 @@ type DepositRefundRecord struct {
User User `json:"user" gorm:"-"`
}
// 黄金会员 member_gold 白金会员 member_platinum 黑金会员 member_black_gold
// member_gold_deposit member_platinum_deposit member_black_gold_platinum
// express_fee
const (
UserConsumeTypeMemberGold = "member_gold"
UserConsumeTypeMemberPlatinum = "member_platinum"
UserConsumeTypeMemberBlackGold = "member_black_gold"
UserConsumeTypeMemberGoldDeposit = "member_gold_deposit"
UserConsumeTypeMemberPlatinumDeposit = "member_platinum_deposit"
UserConsumeTypeMemberBlackGoldDeposit = "member_black_gold_platinum"
UserConsumeTypeExpressFee = "express_fee"
)
// gen:qs
type UserConsumeRecord struct {
Model
Uid uint32 `json:"uid"`
ConsumeType string `json:"consume_type"` // 黄金会员 member_gold 白金会员 member_platinum 黑金会员 member_black_gold
Amount uint32 `json:"amount"`
Status uint32 `json:"status"` // 1-待支付 2-已支付 3-已退款
}
// gen:qs
type UserRentCard struct {
Model
Uid uint32 `json:"uid"`
MemberLevel uint32 `json:"member_level"` // 会员等级 1-用户 2-会员
LevelRentCount uint32 `json:"level_rent_count"` // 等级借卡数量
HaveRentCount uint32 `json:"have_rent_count"` // 已借卡数量
CanRentCount uint32 `json:"can_rent_count"` // 可借卡数量
Status uint32 `json:"status"` // 状态
}
func GetUserByUid(uid uint32) *User {
user := new(User)
if err := NewUserQuerySet(DB).UidEq(uid).One(user); err != nil {
@ -100,6 +134,15 @@ func GetUserByUid(uid uint32) *User {
return user
}
func GetUserRentCard(uid uint32) *UserRentCard {
userRent := new(UserRentCard)
if err := NewUserRentCardQuerySet(DB).UidEq(uid).One(userRent); err != nil {
logger.Error(err, uid)
return nil
}
return userRent
}
func UserUpdate(user *User) error {
if user.Uid == 0 {
return errors.New("uid is null")
@ -395,3 +438,48 @@ func GetUserMutex(mutexKey string) *sync.Mutex {
//}
var AuthLoginMutex = sync.Mutex{}
func OrderCardUserRentCard(uid uint32, count uint32, memberConfig *MemberConfig) error {
//UserRentCard{}
var userRentCard UserRentCard
err := NewUserRentCardQuerySet(DB).UidEq(uid).One(&userRentCard)
if err != nil && err != RecordNotFound {
logger.Error("err:", err)
return err
}
if err == RecordNotFound {
user := GetUserByUid(uid)
if user == nil {
logger.Error("user nil")
return errors.New("user nil")
}
if memberConfig == nil {
memberConfig, err = GetMemberConfig(user.MemberLevel)
if err != nil {
logger.Error("GetMemberConfig err:", err)
return err
}
}
rentCard := &UserRentCard{
Uid: uid,
MemberLevel: user.MemberLevel,
LevelRentCount: memberConfig.CardMax,
HaveRentCount: uint32(count),
CanRentCount: uint32(memberConfig.CardMax - count),
Status: 0,
}
err := DB.Create(rentCard).Error
if err != nil {
logger.Error("err", err)
return err
}
return nil
}
sql := fmt.Sprintf("UPDATE user_rent_card SET have_rent_count=have_rent_count+%d ,can_rent_count=can_rent_count-%d WHERE uid = %d", count, count, uid)
err = DB.Exec(sql).Error
if err != nil {
logger.Error("err", err)
return err
}
return nil
}

13
router/router_app.go
View File

@ -75,8 +75,9 @@ func ConfigAppRouter(r gin.IRouter) {
user.POST("user_info/tel", controller.UserTel) // 获取用户手机号
user.POST("user_info/update", controller.UserInfoUpdate) // 修改用户信息
user.POST("open_member", controller.OpenMember) // 开通会员
user.POST("upgrade_member", controller.UpgradeMember) // 开通会员
user.POST("pay_deposit", controller.PayDeposit) // 支付押金
user.POST("refund_deposit", controller.RefundDeposit) // 押金
user.POST("refund_deposit", controller.RefundDeposit) // 退押金
user.POST("refund_deposit_record", controller.UserDepositRefundRecordList) // 押金记录
user.POST("member_config", controller.MemberConfigList) // 开通会员配置
@ -128,11 +129,11 @@ func ConfigAppRouter(r gin.IRouter) {
order.POST("cancel", controller.OrderCancel) // 订单取消
order.Use(auth.UserAccessAuth) // TODO
order.POST("create", controller.OrderCreate) // 创建订单
order.POST("pay", controller.OrderPay) // 订单支付
order.POST("list", controller.OrderList) // 订单列表
order.POST("revert", controller.OrderRevert) // 订单归还
order.POST("revert/cancel", controller.OrderRevertCancel) // 订单归还
order.POST("create", controller.RentCardOrderCreate) // 创建租卡
order.POST("pay", controller.OrderPay) // 租卡订单支付
order.POST("list", controller.RentCardOrderList) // 租卡订单列表
order.POST("revert", controller.OrderRevert) // 租卡订单归还
order.POST("revert/cancel", controller.OrderRevertCancel) // 租卡订单取消归还
//order.POST("express_fee/refund", controller.ExpressFeeRefund) // 物流费退款
order.POST("confirm_receipt", controller.ConfirmReceipt) // 订单确认收货