805 lines
26 KiB
Go
805 lines
26 KiB
Go
package model
|
|
|
|
import (
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"github.com/codinl/go-logger"
|
|
"github.com/jinzhu/gorm"
|
|
"math/rand"
|
|
"time"
|
|
)
|
|
|
|
const (
|
|
OrderCardStatusUnPick = 1 // 待取货中
|
|
OrderCardStatusPlaying = 2 // 游玩中
|
|
OrderCardStatusReturning = 3 // 归还中
|
|
OrderCardStatusCompleted = 4 // 已完成
|
|
OrderCardStatusCancel = 5 // 已取消
|
|
OrderCardStatusRefund = 6 // 已退款
|
|
|
|
DeliveryTypeStorePick = 1 // 门店取货
|
|
DeliveryTypeExpress = 2 // 快递取货
|
|
|
|
ExpressFeeProvince = 10 * 100 // 省内
|
|
ExpressFeeOutsideProvince = 15 * 100 // 省外
|
|
|
|
PayStatusUnPay = 1 // 未支付
|
|
PayStatusPaid = 2 // 已支付
|
|
)
|
|
|
|
//go:generate goqueryset -in order.go
|
|
// gen:qs
|
|
type Order struct {
|
|
Model
|
|
|
|
Uid uint64 `json:"uid" gorm:"index"`
|
|
GameCardId uint64 `json:"game_card_id" gorm:"index"` // 游戏id
|
|
GameCardGoodsId uint64 `json:"game_card_goods_id" gorm:"index"` // 游戏卡id
|
|
StoreId uint64 `json:"store_id"` // 门店id
|
|
UserAddressId uint64 `json:"user_address_id"` // 地址id
|
|
DeliveryType uint8 `json:"delivery_type"` // 取货类型 1-门店自取 2-快递
|
|
Count uint32 `json:"count"` // 数量
|
|
PickupCode string `json:"pickup_code"` // 取货码
|
|
CardStatus uint8 `json:"card_status"` // 1-待取货中 2-游玩中 3-归还中 4-已完成 5-已取消
|
|
DeliveryTime time.Time `json:"delivery_time"` // 发货时间
|
|
ReceiptTime time.Time `json:"receipt_time"` // 收货时间
|
|
PayTime time.Time `json:"pay_time"` // 支付时间
|
|
PayStatus uint8 `json:"pay_status"` // 支付状态 1-未支付 2-已支付
|
|
OrderSn string `json:"order_sn" gorm:"type:varchar(255);not null;COMMENT:'订单编号'"` // 订单编号
|
|
PayPrice uint32 `json:"pay_price"` // 实际付款金额(包含运费)
|
|
Postage uint32 `json:"postage"` // 邮费
|
|
ExpressCompany string `json:"express_company"` // 物流公司
|
|
ExpressCompanyNo string `json:"express_company_no"` // 物流公司编号
|
|
ExpressNo string `json:"express_no"` // 物流单号
|
|
ExpressDuration uint64 `json:"express_duration"` // 物流时长
|
|
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"` // 归还物流时长
|
|
OutTradeNo string `json:"out_trade_no"` // 支付订单
|
|
Mchid string `json:"mchid"` // 商户
|
|
|
|
OrderCardId uint32 `json:"order_card_id" gorm:"-"` //
|
|
}
|
|
|
|
// gen:qs
|
|
type OrderCard struct {
|
|
Model
|
|
OrderId uint32 `json:"order_id" gorm:"index"`
|
|
Uid uint32 `json:"uid" gorm:"index"`
|
|
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
|
|
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 {
|
|
return "order"
|
|
}
|
|
|
|
func (m *Order) ToInfo(card *GameCard) OrderInfo {
|
|
return OrderInfo{
|
|
Order: *m,
|
|
}
|
|
}
|
|
|
|
type OrderInfo struct {
|
|
Order
|
|
Cards []OrderCard
|
|
}
|
|
|
|
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
|
|
}
|
|
|
|
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 {
|
|
logger.Error("NewGameCardQuerySet err:", err)
|
|
return orderCards, 0, err
|
|
}
|
|
err = oq.OrderDescByCreatedAt().Offset(m.Page * m.PageSize).Limit(m.PageSize).All(&orderCards)
|
|
if err != nil && err != RecordNotFound {
|
|
logger.Error("err:", err)
|
|
return orderCards, 0, err
|
|
}
|
|
totalPage = uint32(count/m.PageSize + 1)
|
|
|
|
orderCards = OrderCardListSetGameInfo(orderCards)
|
|
|
|
return orderCards, totalPage, nil
|
|
}
|
|
|
|
func (m *Order) Info(orderCardId uint32) ([]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).IDEq(orderCardId)
|
|
//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 {
|
|
logger.Error("err:", err)
|
|
return nil, err
|
|
}
|
|
orderCards = OrderCardListSetGameInfo(orderCards)
|
|
|
|
//info := order.ToInfo(&card)
|
|
return orderCards, nil
|
|
}
|
|
|
|
func (m *Order) Revert() error {
|
|
var (
|
|
orderCard OrderCard
|
|
//card GameCard
|
|
)
|
|
|
|
//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)
|
|
fmt.Println("OrderCardId------:", m.OrderCardId)
|
|
err := NewOrderCardQuerySet(DB).IDEq(m.OrderCardId).One(&orderCard)
|
|
//err := NewOrderCardQuerySet(DB).OrderIdEq(m.ID).GameCardGoodsIdEq(uint32(m.GameCardGoodsId)).One(&orderCard)
|
|
if err != nil {
|
|
logger.Errorf("err:%#v", err)
|
|
return err
|
|
}
|
|
if orderCard.CardStatus == OrderCardStatusCompleted {
|
|
logger.Error("order card status completed")
|
|
return errors.New("order card status completed")
|
|
}
|
|
|
|
//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).IDEq(m.OrderCardId).GetUpdater().
|
|
//_, 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).UpdateNum()
|
|
if err != nil {
|
|
logger.Error("err:", err)
|
|
return err
|
|
}
|
|
//err = NewGameCardQuerySet(DB).IDEq(uint32(order.GameCardId)).One(&card)
|
|
//if err != nil && err != RecordNotFound {
|
|
// logger.Error("err:", err)
|
|
// return nil, err
|
|
//}
|
|
|
|
//info := order.ToInfo(&card)
|
|
return nil
|
|
}
|
|
|
|
func (m *Order) RevertCancel() (bool, error) {
|
|
var (
|
|
orderCard OrderCard
|
|
//order Order
|
|
//card GameCard
|
|
)
|
|
|
|
//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).IDEq(m.OrderCardId).One(&orderCard)
|
|
//err := NewOrderCardQuerySet(DB).OrderIdEq(m.ID).GameCardGoodsIdEq(uint32(m.GameCardGoodsId)).One(&orderCard)
|
|
if err != nil {
|
|
logger.Errorf("err:%#v", err)
|
|
return false, err
|
|
}
|
|
if orderCard.CardStatus != OrderCardStatusReturning {
|
|
logger.Error("order card status returning")
|
|
return false, errors.New("order card status returning")
|
|
}
|
|
|
|
//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).IDEq(m.OrderCardId).GetUpdater().
|
|
//_, err = NewOrderCardQuerySet(DB).OrderIdEq(m.ID).GameCardGoodsIdEq(uint32(m.GameCardGoodsId)).GetUpdater().
|
|
SetCardStatus(OrderCardStatusPlaying).
|
|
//SetRevertTime(time.Time{}).
|
|
SetRevertStoreId(0).
|
|
SetRevertExpressCompany("").
|
|
SetRevertExpressCompanyNo("").
|
|
SetRevertExpressNo("").UpdateNum()
|
|
if err != nil {
|
|
logger.Error("err:", 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
|
|
// }
|
|
//}
|
|
//info := order.ToInfo(&card)
|
|
return isRecede, nil
|
|
}
|
|
|
|
func (m *Order) OrderCreate(gdb *gorm.DB) error {
|
|
err := m.Create(gdb)
|
|
if err != nil {
|
|
logger.Error("err:", err)
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *Order) Modify() (*OrderInfo, error) {
|
|
if m.ID == 0 {
|
|
return nil, errors.New("orderId is null")
|
|
}
|
|
fields := make([]OrderDBSchemaField, 0)
|
|
if m.CardStatus != 0 {
|
|
fields = append(fields, OrderDBSchema.CardStatus)
|
|
}
|
|
|
|
if len(fields) > 0 {
|
|
err := m.Update(DB.Where(&Order{Model: Model{ID: m.ID}, Uid: m.Uid}), fields...)
|
|
if err != nil {
|
|
logger.Error("err:", err)
|
|
return nil, err
|
|
}
|
|
}
|
|
|
|
var card GameCard
|
|
err := NewGameCardQuerySet(DB).IDEq(uint32(m.GameCardId)).One(&card)
|
|
if err != nil && err != RecordNotFound {
|
|
logger.Error("err:", err)
|
|
return nil, err
|
|
}
|
|
|
|
info := m.ToInfo(&card)
|
|
|
|
return &info, nil
|
|
}
|
|
|
|
func (m *UserRentCard) IsHaveUnreturnedOrders(RentCount uint32) (bool, error) {
|
|
fmt.Println("uid", m.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)
|
|
// return false, err
|
|
//}
|
|
unreturned := &struct {
|
|
Count int `json:"count"`
|
|
}{}
|
|
err := DB.Raw(sql).Scan(unreturned).Error
|
|
if err != nil {
|
|
logger.Error("err:", err)
|
|
return false, err
|
|
}
|
|
fmt.Println("订单数量count:", unreturned.Count)
|
|
return uint32(unreturned.Count)+RentCount > m.LevelRentCount, nil
|
|
}
|
|
|
|
func IsHaveOnDeliverOrderCards(orderId uint32) (bool, error) {
|
|
count, err := NewOrderCardQuerySet(DB).OrderIdEq(orderId).CardStatusEq(OrderCardStatusUnPick).Count()
|
|
if err != nil {
|
|
logger.Error("err:", err)
|
|
return false, err
|
|
}
|
|
return count > 0, nil
|
|
}
|
|
|
|
func IsUserHaveUnreturnedOrder(uid uint32) (bool, error) {
|
|
fmt.Println("uid", uid)
|
|
|
|
sql := fmt.Sprintf("SELECT COUNT(*) AS count FROM `order` WHERE uid = %d AND pay_status IN (1,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)
|
|
// return false, err
|
|
//}
|
|
unreturned := &struct {
|
|
Count int `json:"count"`
|
|
}{}
|
|
DB.Raw(sql).Scan(unreturned)
|
|
fmt.Println("订单数量count:", unreturned.Count)
|
|
return unreturned.Count != 0, nil
|
|
}
|
|
|
|
// gen:qs
|
|
type ExpressCompany struct {
|
|
Model
|
|
|
|
CompanyName string `json:"company_name"`
|
|
CompanyCode string `json:"company_code"`
|
|
}
|
|
|
|
func (*ExpressCompany) TableName() string {
|
|
return "express_company"
|
|
}
|
|
|
|
func (*ExpressCompany) List() ([]ExpressCompany, error) {
|
|
companys := make([]ExpressCompany, 0)
|
|
err := NewExpressCompanyQuerySet(DB).OrderAscByID().All(&companys)
|
|
if err != nil && err != RecordNotFound {
|
|
logger.Error("err:", err)
|
|
return companys, err
|
|
}
|
|
return companys, nil
|
|
}
|
|
|
|
func GetPickupCode() string {
|
|
for {
|
|
rand.Seed(time.Now().UnixNano())
|
|
code := fmt.Sprintf("%d", rand.Intn(1000000)+100000)
|
|
count, err := NewOrderQuerySet(DB).PickupCodeEq(code).Count()
|
|
if err != nil {
|
|
logger.Error("err:", err)
|
|
}
|
|
if count == 0 {
|
|
return code
|
|
}
|
|
}
|
|
//将时间戳设置成种子数
|
|
|
|
}
|
|
|
|
func (m *Order) Cancel() (bool, Order, error) {
|
|
var (
|
|
order Order
|
|
orderCard OrderCard
|
|
)
|
|
err := NewOrderQuerySet(DB).IDEq(m.ID).One(&order)
|
|
if err != nil {
|
|
logger.Error("err:", err)
|
|
return false, order, err
|
|
}
|
|
orderJson, _ := json.Marshal(m)
|
|
fmt.Println("orderJson:", string(orderJson))
|
|
|
|
err = NewOrderCardQuerySet(DB).IDEq(m.OrderCardId).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, order, err
|
|
}
|
|
if err == RecordNotFound {
|
|
logger.Error("order card status not unpick")
|
|
return false, order, errors.New("order card status not unpick")
|
|
}
|
|
if orderCard.CardStatus != OrderCardStatusUnPick {
|
|
logger.Error("order card status not unpick")
|
|
return false, order, 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()) {
|
|
// logger.Error("card status expire err: ")
|
|
// return errors.New("card status expire")
|
|
//}
|
|
|
|
begin := DB.Begin()
|
|
//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()
|
|
logger.Error("err:", err)
|
|
return false, order, err
|
|
}
|
|
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 false, order, err
|
|
}
|
|
//UserRentCard{}
|
|
sqlRent := fmt.Sprintf("UPDATE user_rent_card SET have_rent_count = have_rent_count-1,can_rent_count=can_rent_count+1 WHERE uid =%d;", order.Uid)
|
|
fmt.Println("sqlRent:", sqlRent)
|
|
err = begin.Exec(sqlRent).Error
|
|
if err != nil {
|
|
begin.Rollback()
|
|
logger.Errorf("err:%#v", err)
|
|
return false, order, err
|
|
}
|
|
err = begin.Commit().Error
|
|
if err != nil {
|
|
begin.Rollback()
|
|
logger.Errorf("err:%#v", err)
|
|
return false, order, err
|
|
}
|
|
isHaveOnDeliver, err := IsHaveOnDeliverOrderCards(m.ID)
|
|
if err != nil {
|
|
logger.Error("err:", err)
|
|
return false, order, err
|
|
}
|
|
if !isHaveOnDeliver {
|
|
err = NewOrderQuerySet(DB).IDEq(order.ID).GetUpdater().SetCardStatus(OrderCardStatusCancel).Update()
|
|
if err != nil {
|
|
logger.Error("err:", err)
|
|
return false, order, err
|
|
}
|
|
}
|
|
|
|
isRecede := false
|
|
if order.DeliveryType == 2 && order.Postage > 0 {
|
|
if !isHaveOnDeliver {
|
|
isRecede = true
|
|
}
|
|
}
|
|
//m.ID = order.ID
|
|
//m.Uid = order.Uid
|
|
//m.PayPrice = order.PayPrice
|
|
return isRecede, order, nil
|
|
}
|
|
|
|
func UnPayOrderSetCancel(uid uint32) {
|
|
fmt.Println("uid:", uid)
|
|
var order Order
|
|
err := NewOrderQuerySet(DB.Debug()).UidEq(uint64(uid)).PayStatusEq(PayStatusUnPay).CardStatusEq(OrderCardStatusUnPick).One(&order)
|
|
if err != nil {
|
|
logger.Error("err:", err)
|
|
return
|
|
}
|
|
|
|
fmt.Println("Order:", order)
|
|
|
|
begin := DB.Begin()
|
|
_, err = NewOrderQuerySet(begin).IDEq(order.ID).GetUpdater().
|
|
SetCardStatus(OrderCardStatusCancel).UpdateNum()
|
|
if err != nil {
|
|
begin.Rollback()
|
|
logger.Error("err:", err)
|
|
return
|
|
}
|
|
|
|
sql := fmt.Sprintf("UPDATE game_card_goods_stock SET rent_stock= rent_stock+1 WHERE store_id=%d AND game_card_id=%d;", order.StoreId, order.GameCardId)
|
|
fmt.Println("sql:", sql)
|
|
err = begin.Exec(sql).Error
|
|
if err != nil {
|
|
begin.Rollback()
|
|
logger.Error("err:", err)
|
|
return
|
|
}
|
|
err = begin.Commit().Error
|
|
if err != nil {
|
|
begin.Rollback()
|
|
logger.Error("err:", err)
|
|
}
|
|
|
|
}
|
|
|
|
//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 && err != RecordNotFound {
|
|
logger.Error("err:", err)
|
|
return false, err
|
|
}
|
|
if err == RecordNotFound {
|
|
logger.Error("order stock out:")
|
|
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
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *Order) InventoryReduction(gdb *gorm.DB) error {
|
|
var cards []OrderCard
|
|
err := NewOrderCardQuerySet(DB).UidEq(uint32(m.Uid)).OrderIdEq(m.ID).All(&cards)
|
|
if err != nil {
|
|
logger.Error("err:", err)
|
|
return err
|
|
}
|
|
|
|
//fmt.Println("cards:", cards)
|
|
for i, _ := range cards {
|
|
var gameCardGoodsStock GameCardGoodsStock
|
|
err := NewGameCardGoodsStockQuerySet(DB).GameCardIdEq(uint64(cards[i].GameCardId)).StoreIdEq(m.StoreId).One(&gameCardGoodsStock)
|
|
if err != nil {
|
|
logger.Error("err:", err)
|
|
return err
|
|
}
|
|
//fmt.Println("cards:", cards[i].GameCardId, cards[i].StoreId, cards[i].Uid)
|
|
if gameCardGoodsStock.RentStock < 1 {
|
|
logger.Error("rent stock not enough:")
|
|
return errors.New("rent stock not enough")
|
|
}
|
|
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
|
|
}
|
|
}
|
|
err = OrderCardUserRentCard(uint32(m.Uid), uint32(len(cards)), nil, gdb)
|
|
if err != nil {
|
|
logger.Error("err:", 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
|
|
}
|