1518 lines
47 KiB
Go
1518 lines
47 KiB
Go
package model
|
|
|
|
import (
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"github.com/codinl/go-logger"
|
|
"github.com/jinzhu/gorm"
|
|
"golang.org/x/sync/errgroup"
|
|
"math/rand"
|
|
"mh-server/kuaidi"
|
|
"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
|
|
GameCardSerialNumber string `json:"game_card_serial_number" gorm:"index"` // 游戏卡编号
|
|
StoreId uint64 `json:"store_id" gorm:"index"` // 门店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"` // 商户
|
|
CooperativeBusinessId uint32 `json:"cooperative_business_id" gorm:"index"` // 合作商id
|
|
CooperativeName string `json:"cooperative_name"` // 合作商名称
|
|
OrderCardId uint32 `json:"order_card_id" gorm:"-"` //
|
|
|
|
OrderCards []OrderCard `json:"order_cards" gorm:"-"`
|
|
Store *Store `json:"store" gorm:"-"`
|
|
UserAddress *UserAddress `json:"user_address" 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"` // 归还物流时长
|
|
IssueType uint32 `json:"issue_type"` // 问题类型: 1-问题反馈 2-正常
|
|
CooperativeBusinessId uint32 `json:"cooperative_business_id" gorm:"index"` // 合作商id
|
|
CooperativeName string `json:"cooperative_name"` // 合作商名称
|
|
|
|
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:"-"` // 封面
|
|
IssueFeedbackStoreId uint32 `json:"issue_feedback_store_id" gorm:"-"` // 问题反馈门店
|
|
Order *Order `json:"order" gorm:"-"` // 订单
|
|
GameCard *GameCard `json:"game_card" gorm:"-"` // 游戏
|
|
Store *Store `json:"store" gorm:"-"` // 游戏
|
|
RevertStore *Store `json:"revert_store" gorm:"-"` // 游戏
|
|
//Status uint8 `json:"status" gorm:"index"` // 1-待领取 2-游玩中 3-已归还 4-未领取
|
|
//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 {
|
|
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
|
|
}
|
|
|
|
cardMap, err := GameCardMap(ids)
|
|
if err != nil {
|
|
logger.Error("err:", err)
|
|
return list
|
|
}
|
|
|
|
for i, _ := range list {
|
|
gameCard, ok1 := cardMap[list[i].GameCardId]
|
|
order, ok2 := orderMap[list[i].OrderId]
|
|
if ok1 && ok2 {
|
|
if order.CardStatus == 2 || order.CardStatus == 3 {
|
|
order.CardStatus = 4
|
|
}
|
|
list[i].GameName = gameCard.Name
|
|
list[i].GameCoverImg = gameCard.CoverImg
|
|
list[i].GamePrice = gameCard.Price
|
|
list[i].Order = &order
|
|
}
|
|
}
|
|
|
|
return list
|
|
}
|
|
|
|
func GameCardMap(ids []uint32) (map[uint32]GameCard, error) {
|
|
cardMap := make(map[uint32]GameCard, 0)
|
|
if len(ids) == 0 {
|
|
return cardMap, nil
|
|
}
|
|
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)
|
|
if len(ids) == 0 {
|
|
return cardMap, nil
|
|
}
|
|
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)
|
|
fmt.Println("orderCards:", orderCards)
|
|
|
|
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.Error("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
|
|
//card GameCard
|
|
)
|
|
|
|
//qs := NewOrderQuerySet(DB).IDEq(m.ID)
|
|
//err := qs.One(&order)
|
|
//if err != nil {
|
|
// logger.Error("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)
|
|
sql := fmt.Sprintf("SELECT COUNT(*) AS count FROM order_card WHERE uid = %d AND pay_status IN (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 GetShareCardRetrievePickupCode() string {
|
|
for {
|
|
rand.Seed(time.Now().UnixNano())
|
|
code := fmt.Sprintf("%d", rand.Intn(1000000)+100000)
|
|
//count, err := NewOrderQuerySet(DB).PickupCodeEq(code).Count()
|
|
count, err := NewShareCardRetrieveQuerySet(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
|
|
}
|
|
}
|
|
if order.DeliveryType == 2 {
|
|
UpdateDeliverTaskSubStateCancel(order.ID)
|
|
}
|
|
//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,
|
|
IssueType: 2,
|
|
CooperativeBusinessId: m.CooperativeBusinessId,
|
|
CooperativeName: m.CooperativeName,
|
|
}
|
|
err := gdb.Create(orderCard).Error
|
|
if err != nil {
|
|
logger.Error("err:", err)
|
|
return err
|
|
}
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type RecordExist struct {
|
|
RecordExist int64 `json:"record_exist"`
|
|
}
|
|
|
|
func QueryRecordExist(sql string) (bool, error) {
|
|
var recordExist RecordExist
|
|
existSql := fmt.Sprintf("SELECT EXISTS (%s) AS record_exist;", sql)
|
|
err := DB.Raw(existSql).Scan(&recordExist).Error
|
|
if err != nil {
|
|
logger.Error("err:", err)
|
|
return false, err
|
|
}
|
|
|
|
return recordExist.RecordExist == 1, nil
|
|
}
|
|
|
|
type CooperativeRentCardOrderReq struct {
|
|
SerialNumber string `json:"serial_number" ` // 编号
|
|
PickupCode string `json:"pickup_code"` // 取货码
|
|
OrderId uint32 `json:"order_id"` // 取货码
|
|
}
|
|
|
|
func (m *CooperativeRentCardOrderReq) Info() (Order, error) {
|
|
var order Order
|
|
if m.PickupCode != "" {
|
|
err := NewOrderQuerySet(DB).PickupCodeEq(m.PickupCode).PayStatusEq(PayStatusPaid).
|
|
CardStatusEq(OrderCardStatusUnPick).One(&order)
|
|
if err != nil {
|
|
logger.Error("order err:", err)
|
|
return order, err
|
|
}
|
|
} else if m.SerialNumber != "" {
|
|
var orderCard OrderCard
|
|
err := NewOrderCardQuerySet(DB).SerialNumberEq(m.SerialNumber).CardStatusIn(OrderCardStatusPlaying,
|
|
OrderCardStatusReturning).One(&orderCard)
|
|
if err != nil {
|
|
logger.Error("order card err:", err)
|
|
return order, err
|
|
}
|
|
|
|
err = NewOrderQuerySet(DB).IDEq(orderCard.OrderId).One(&order)
|
|
if err != nil {
|
|
logger.Error("order err:", err)
|
|
return order, err
|
|
}
|
|
} else if m.OrderId != 0 {
|
|
err := NewOrderQuerySet(DB).IDEq(m.OrderId).One(&order)
|
|
if err != nil {
|
|
logger.Error("order err:", err)
|
|
return order, err
|
|
}
|
|
} else {
|
|
return order, errors.New("parameter_err")
|
|
}
|
|
|
|
var orderCards []OrderCard
|
|
err := NewOrderCardQuerySet(DB).OrderIdEq(order.ID).All(&orderCards)
|
|
if err != nil {
|
|
logger.Error("order card err:", err)
|
|
return order, err
|
|
}
|
|
var store Store
|
|
err = NewStoreQuerySet(DB).IDEq(uint32(order.StoreId)).One(&store)
|
|
if err != nil {
|
|
logger.Error("store err:", err)
|
|
return order, err
|
|
}
|
|
if order.UserAddressId != 0 {
|
|
var address UserAddress
|
|
err = NewUserAddressQuerySet(DB).IDEq(uint32(order.UserAddressId)).One(&address)
|
|
if err != nil {
|
|
logger.Error("address err:", err)
|
|
return order, err
|
|
}
|
|
order.UserAddress = &address
|
|
}
|
|
order.Store = &store
|
|
order.OrderCards = CooperativeOrderCardListSetInfo(orderCards)
|
|
return order, nil
|
|
}
|
|
|
|
func CooperativeOrderCardListSetInfo(list []OrderCard) []OrderCard {
|
|
ids := make([]uint32, 0, len(list))
|
|
storeIds := make([]uint32, 0, len(list))
|
|
for i, _ := range list {
|
|
ids = append(ids, list[i].GameCardId)
|
|
storeIds = append(storeIds, uint32(list[i].RevertStoreId))
|
|
}
|
|
if len(ids) == 0 {
|
|
return list
|
|
}
|
|
|
|
cardMap, err := GameCardMap(ids)
|
|
if err != nil {
|
|
logger.Error("game card map err:", err)
|
|
return list
|
|
}
|
|
storeMap, err := GetStoreMap(storeIds)
|
|
if err != nil {
|
|
logger.Error("store map err:", err)
|
|
return list
|
|
}
|
|
for i, _ := range list {
|
|
gameCard, ok1 := cardMap[list[i].GameCardId]
|
|
if ok1 {
|
|
list[i].GameName = gameCard.Name
|
|
list[i].GameCoverImg = gameCard.CoverImg
|
|
list[i].GamePrice = gameCard.Price
|
|
}
|
|
|
|
revertStore, ok2 := storeMap[uint32(list[i].RevertStoreId)]
|
|
if ok2 {
|
|
list[i].RevertStore = &revertStore
|
|
}
|
|
}
|
|
|
|
return list
|
|
}
|
|
|
|
func GetStoreMap(ids []uint32) (map[uint32]Store, error) {
|
|
storeMap := make(map[uint32]Store, 0)
|
|
if len(ids) == 0 {
|
|
return storeMap, nil
|
|
}
|
|
var stores []Store
|
|
err := NewStoreQuerySet(DB).IDIn(ids...).All(&stores)
|
|
if err != nil {
|
|
logger.Error("err:", err)
|
|
return storeMap, err
|
|
}
|
|
|
|
if len(stores) == 0 {
|
|
return storeMap, nil
|
|
}
|
|
for i, _ := range stores {
|
|
storeMap[stores[i].ID] = stores[i]
|
|
}
|
|
return storeMap, nil
|
|
}
|
|
|
|
func (m *Order) GetById() error {
|
|
err := NewOrderQuerySet(DB).IDEq(m.ID).One(m)
|
|
if err != nil {
|
|
logger.Error("get order err")
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *Order) SetUnPickOrderCards() error {
|
|
var cards []OrderCard
|
|
err := NewOrderCardQuerySet(DB).OrderIdEq(m.ID).CardStatusEq(OrderCardStatusUnPick).All(&cards)
|
|
if err != nil {
|
|
logger.Error("get order err")
|
|
return err
|
|
}
|
|
m.OrderCards = cards
|
|
return nil
|
|
}
|
|
|
|
func (m *Order) SetOrderCards() error {
|
|
var cards []OrderCard
|
|
err := NewOrderCardQuerySet(DB).OrderIdEq(m.ID).All(&cards)
|
|
if err != nil {
|
|
logger.Error("get order err")
|
|
return err
|
|
}
|
|
m.OrderCards = cards
|
|
return nil
|
|
}
|
|
|
|
func (m *Order) GetOrderCardMap() (map[string]OrderCard, error) {
|
|
cardMap := make(map[string]OrderCard, 0)
|
|
err := m.SetOrderCards()
|
|
if err != nil {
|
|
logger.Error("order card err:", err)
|
|
return cardMap, err
|
|
}
|
|
for i, _ := range m.OrderCards {
|
|
cardMap[m.OrderCards[i].SerialNumber] = m.OrderCards[i]
|
|
}
|
|
return cardMap, nil
|
|
}
|
|
|
|
type CooperativeRentCardOrderDeliverReq struct {
|
|
OrderId uint32 `json:"order_id"`
|
|
SerialNumbers []string `json:"serial_numbers"`
|
|
StoreId uint32 `json:"store_id"`
|
|
ExpressCompany string `json:"express_company"`
|
|
ExpressCompanyNo string `json:"express_company_no"`
|
|
ExpressNo string `json:"express_no"`
|
|
OperationUid uint32 `json:"operation_uid"`
|
|
}
|
|
|
|
func (m *CooperativeRentCardOrderDeliverReq) Deliver() (error, string) {
|
|
|
|
order := new(Order)
|
|
order.ID = m.OrderId
|
|
err := order.GetById()
|
|
if err != nil && err != RecordNotFound {
|
|
logger.Error("err:", err)
|
|
return err, ""
|
|
}
|
|
err = order.SetUnPickOrderCards()
|
|
if err != nil {
|
|
logger.Error("err:", err)
|
|
return err, ""
|
|
}
|
|
|
|
if len(m.SerialNumbers) != len(order.OrderCards) || len(m.SerialNumbers) == 0 {
|
|
logger.Error("发货卡的数量与订单游戏卡数量不一致")
|
|
return errors.New("发货卡的数量与订单游戏卡数量不一致"), "发货卡的数量与订单游戏卡数量不一致"
|
|
}
|
|
|
|
user := GetUserByUid(uint32(order.Uid))
|
|
if user.MemberExpire.Before(time.Now()) {
|
|
logger.Error("会员已过期，不能发货")
|
|
return errors.New("会员已过期，不能发货"), "会员已过期，不能发货"
|
|
}
|
|
|
|
orderCardMaps := make(map[uint32]OrderCard, 0)
|
|
for i, _ := range order.OrderCards {
|
|
orderCardMaps[order.OrderCards[i].ID] = order.OrderCards[i]
|
|
}
|
|
|
|
receiptTime := time.Time{}
|
|
if order.DeliveryType == 1 {
|
|
receiptTime = time.Now()
|
|
}
|
|
|
|
serialNumberMap := make(map[string]GameCardGoods, 0)
|
|
var serialGoods []GameCardGoods
|
|
err = NewGameCardGoodsQuerySet(DB).SerialNumberIn(m.SerialNumbers...).All(&serialGoods)
|
|
if err != nil {
|
|
logger.Error("serial goods err:", err)
|
|
return err, ""
|
|
}
|
|
for i, _ := range serialGoods {
|
|
serialNumberMap[serialGoods[i].SerialNumber] = serialGoods[i]
|
|
}
|
|
|
|
isUpdateOrder := false
|
|
begin := DB.Begin()
|
|
for _, serialNumber := range m.SerialNumbers {
|
|
if serialNumber == "" {
|
|
continue
|
|
}
|
|
|
|
gameCardGoods, ok := serialNumberMap[serialNumber]
|
|
if !ok {
|
|
begin.Rollback()
|
|
logger.Errorf("游戏编号卡未找到:%s", serialNumber)
|
|
return errors.New("游戏卡未找到"), "编号的游戏卡不存在"
|
|
}
|
|
|
|
if gameCardGoods.Status == GameCardGoodsStatusCannibalize {
|
|
begin.Rollback()
|
|
return errors.New("card goods status err"), "该卡在调拨中,不能发货"
|
|
}
|
|
if gameCardGoods.Status != GameCardGoodsStatusStock {
|
|
begin.Rollback()
|
|
return errors.New("card goods status err"), "该卡状态,不能发货"
|
|
}
|
|
|
|
if order.CardStatus != OrderCardStatusUnPick {
|
|
begin.Rollback()
|
|
logger.Error("order not unpick")
|
|
return errors.New("order not unpick"), "订单不是待取货状态"
|
|
}
|
|
if order.PayStatus != PayStatusPaid {
|
|
begin.Rollback()
|
|
logger.Error("order not pay")
|
|
return errors.New("order not pay"), "订单未支付"
|
|
}
|
|
|
|
orderCard := GetOrderCardMapSerialNumberUnset(orderCardMaps, uint32(gameCardGoods.GameCardId))
|
|
if orderCard == nil {
|
|
begin.Rollback()
|
|
logger.Error("发货游戏卡错误")
|
|
return errors.New("发货游戏卡错误"), "发货游戏卡错误"
|
|
}
|
|
|
|
if m.StoreId != uint32(gameCardGoods.StoreId) {
|
|
begin.Rollback()
|
|
logger.Error("游戏编号卡不是该门店")
|
|
return errors.New("游戏编号卡不是该门店"), "该门店没有改游戏卡"
|
|
}
|
|
|
|
if (m.StoreId) != orderCard.StoreId {
|
|
begin.Rollback()
|
|
// 订单锁库存
|
|
logger.Error("订单门店与发货门店不一致")
|
|
return errors.New("订单门店与发货门店不一致"), "订单门店与发货门店不一致,请取消订单后重新下单"
|
|
}
|
|
|
|
paraMap := make(map[string]interface{}, 0)
|
|
//paraMap["game_card_serial_number"] = serialNumber
|
|
|
|
if !isUpdateOrder {
|
|
if m.StoreId != 0 {
|
|
paraMap["store_id"] = m.StoreId
|
|
paraMap["pickup_code"] = "已取货"
|
|
paraMap["card_status"] = 4
|
|
paraMap["store_id"] = m.StoreId
|
|
paraMap["delivery_time"] = time.Now()
|
|
}
|
|
if m.ExpressCompany != "" {
|
|
paraMap["express_company"] = m.ExpressCompany
|
|
}
|
|
if m.ExpressCompanyNo != "" {
|
|
paraMap["express_company_no"] = m.ExpressCompanyNo
|
|
}
|
|
if m.ExpressNo != "" {
|
|
paraMap["express_no"] = m.ExpressNo
|
|
}
|
|
err := begin.Table("order").Where("id=?", m.OrderId).Updates(paraMap).Error
|
|
if err != nil {
|
|
begin.Rollback()
|
|
logger.Error("err:", err)
|
|
return err, ""
|
|
}
|
|
isUpdateOrder = true
|
|
}
|
|
|
|
var eg errgroup.Group
|
|
eg.Go(func() error {
|
|
err := begin.Table("game_card_goods").Where("serial_number=?", serialNumber).
|
|
Update("status", GameCardGoodsStatusCustomerHold).Error
|
|
if err != nil {
|
|
begin.Rollback()
|
|
logger.Error("err:", err)
|
|
return err
|
|
}
|
|
return nil
|
|
})
|
|
eg.Go(func() error {
|
|
goodsStock := &GameCardGoodsStock{
|
|
StoreId: uint64(m.StoreId),
|
|
GameCardId: gameCardGoods.GameCardId,
|
|
}
|
|
err = goodsStock.AddUserHoldStock(begin)
|
|
if err != nil {
|
|
begin.Rollback()
|
|
logger.Error("err:", err)
|
|
return err
|
|
}
|
|
return nil
|
|
})
|
|
|
|
eg.Go(func() error {
|
|
user := GetUserByUid(uint32(order.Uid))
|
|
if user.StoreId == 0 {
|
|
sql := fmt.Sprintf("UPDATE `user` SET store_id = %d WHERE uid =%d", order.StoreId, order.Uid)
|
|
err := DB.Exec(sql).Error
|
|
if err != nil {
|
|
logger.Error("err:", err)
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
})
|
|
eg.Go(func() error {
|
|
err = begin.Table("order_card").Where("id=?", orderCard.ID).Updates(map[string]interface{}{
|
|
"store_id": m.StoreId,
|
|
"delivery_time": time.Now(),
|
|
"game_card_goods_id": gameCardGoods.ID,
|
|
"serial_number": gameCardGoods.SerialNumber,
|
|
"card_status": 2,
|
|
"receipt_time": receiptTime,
|
|
}).Error
|
|
if err != nil {
|
|
begin.Rollback()
|
|
logger.Error("err:", err)
|
|
return err
|
|
}
|
|
delete(orderCardMaps, orderCard.ID)
|
|
return nil
|
|
})
|
|
|
|
err = eg.Wait()
|
|
if err != nil {
|
|
begin.Rollback()
|
|
logger.Error("err:", err)
|
|
return err, ""
|
|
}
|
|
}
|
|
|
|
err = begin.Commit().Error
|
|
if err != nil {
|
|
begin.Rollback()
|
|
logger.Error("err:", err)
|
|
return err, ""
|
|
}
|
|
|
|
err = DB.Table("order_card").Where("order_id=?", m.OrderId).Where("uid=?", order.Uid).
|
|
Where("serial_number=''").Updates(&map[string]interface{}{
|
|
"card_status": 5,
|
|
}).Error
|
|
if err != nil {
|
|
logger.Error("err:", err)
|
|
return err, ""
|
|
}
|
|
|
|
go func() {
|
|
if m.ExpressCompanyNo != "" && m.ExpressNo != "" {
|
|
_, err = kuaidi.SubscribeExpressState(m.ExpressCompanyNo, m.ExpressNo)
|
|
if err != nil {
|
|
logger.Error("subscribe express state err:", err)
|
|
}
|
|
}
|
|
|
|
operationLog := &OperationLog{
|
|
Uid: m.OperationUid,
|
|
Description: "借卡发货",
|
|
OperationType: OperationTypeRentCardDeliver,
|
|
CorrelationId: order.ID,
|
|
CorrelationName: LogCorrelationOrderId,
|
|
StoreId: m.StoreId,
|
|
StoreName: "",
|
|
CooperativeName: "",
|
|
//SerialNumber: m.SerialNumber,
|
|
}
|
|
operationLog.AddLog()
|
|
}()
|
|
|
|
return nil, ""
|
|
}
|
|
|
|
type CooperativeRentCardOrderRevertReq struct {
|
|
OrderId uint32 `json:"order_id"`
|
|
SerialNumber string `json:"serial_number"`
|
|
RevertStoreId uint32 `json:"revert_store_id"`
|
|
OperationUid uint32 `json:"operation_uid"`
|
|
}
|
|
|
|
func (m *CooperativeRentCardOrderRevertReq) Revert() error {
|
|
order := new(Order)
|
|
order.ID = m.OrderId
|
|
err := order.GetById()
|
|
if err != nil {
|
|
logger.Error("get order err:", err)
|
|
return err
|
|
}
|
|
|
|
cardMap, err := order.GetOrderCardMap()
|
|
if err != nil {
|
|
logger.Error("err:", err)
|
|
return err
|
|
}
|
|
orderCardIds := make([]uint32, 0, len(cardMap))
|
|
orderCardIdString := ""
|
|
for _, card := range cardMap {
|
|
orderCardIds = append(orderCardIds, card.ID)
|
|
orderCardIdString += fmt.Sprintf("%d,", card.ID)
|
|
}
|
|
|
|
recordExist, err := QueryRecordExist(fmt.Sprintf(
|
|
"SELECT * FROM card_issue_feedback WHERE state='%s' AND relevance_id in (%s)",
|
|
CardIssueStateFollowing, orderCardIdString[:len(orderCardIdString)-1]))
|
|
if err != nil {
|
|
logger.Errorf("err:%#v", err)
|
|
return err
|
|
}
|
|
if recordExist {
|
|
logger.Error("untreated_issue_feedback")
|
|
return errors.New("untreated_issue_feedback")
|
|
}
|
|
|
|
serialNumber := m.SerialNumber
|
|
|
|
orderCard, ok := cardMap[serialNumber]
|
|
if !ok {
|
|
logger.Error("order card is not revert card")
|
|
return errors.New("order card is not revert card")
|
|
}
|
|
if m.RevertStoreId == 0 {
|
|
logger.Error("revert store id null")
|
|
return errors.New("revert store id null")
|
|
}
|
|
if orderCard.CardStatus != OrderCardStatusReturning && orderCard.CardStatus != OrderCardStatusPlaying {
|
|
logger.Error("order card status not returning playing ")
|
|
return errors.New("order card status not returning playing ")
|
|
}
|
|
|
|
gameCardGoods, err := GetGameCardGoodsBySerialNumber(serialNumber)
|
|
if err != nil {
|
|
logger.Errorf("err:%#v", err)
|
|
return err
|
|
}
|
|
|
|
if order.StoreId != gameCardGoods.StoreId {
|
|
logger.Error("order store id not game card goods store id")
|
|
return errors.New("order store id not game card goods store id")
|
|
}
|
|
|
|
begin := DB.Begin()
|
|
var eg errgroup.Group
|
|
eg.Go(func() error {
|
|
goodsStatus := GameCardGoodsStatusStock
|
|
if gameCardGoods.Status == 7 {
|
|
goodsStatus = GameCardGoodsStatusUnusual
|
|
}
|
|
err := begin.Table("game_card_goods").Where("serial_number=?", serialNumber).
|
|
Updates(map[string]interface{}{
|
|
"status": goodsStatus,
|
|
"store_id": m.RevertStoreId,
|
|
"stock_time": time.Now(),
|
|
}).Error
|
|
|
|
if err != nil {
|
|
begin.Rollback()
|
|
logger.Error("err:", err)
|
|
return err
|
|
}
|
|
|
|
return nil
|
|
})
|
|
eg.Go(func() error {
|
|
if uint32(gameCardGoods.StoreId) != m.RevertStoreId {
|
|
sqlStore := fmt.Sprintf(
|
|
"UPDATE game_card_goods_stock SET user_hold_stock= user_hold_stock-1,order_count=order_count+1,total_stock=total_stock-1 WHERE store_id=%d AND game_card_id=%d;",
|
|
order.StoreId, gameCardGoods.GameCardId)
|
|
fmt.Println("sqlStore:", sqlStore)
|
|
err = begin.Exec(sqlStore).Error
|
|
if err != nil {
|
|
begin.Rollback()
|
|
logger.Error("err:", err)
|
|
return err
|
|
}
|
|
|
|
var count int64
|
|
err := DB.Table("game_card_goods_stock").Where("store_id=?", m.RevertStoreId).
|
|
Where("game_card_id=?", gameCardGoods.GameCardId).Count(&count).Error
|
|
if err != nil {
|
|
begin.Rollback()
|
|
logger.Error("err:", err)
|
|
return err
|
|
}
|
|
if count == 0 && (gameCardGoods.Status != 7 || gameCardGoods.FunctionState != 1) {
|
|
goodsStock := &GameCardGoodsStock{
|
|
StoreId: uint64(m.RevertStoreId),
|
|
GameCardId: gameCardGoods.GameCardId,
|
|
StoreStock: 0,
|
|
RentStock: 1,
|
|
UserHoldStock: 0,
|
|
OrderCount: 0,
|
|
TotalStock: 1,
|
|
}
|
|
err := begin.Create(goodsStock).Error
|
|
if err != nil {
|
|
begin.Rollback()
|
|
logger.Error("err:", err)
|
|
return err
|
|
}
|
|
return nil
|
|
} else {
|
|
if gameCardGoods.Status != 7 || gameCardGoods.FunctionState != 1 {
|
|
sql := fmt.Sprintf("UPDATE game_card_goods_stock SET rent_stock= rent_stock+1,total_stock=total_stock+1 WHERE store_id=%d AND game_card_id=%d;", m.RevertStoreId, gameCardGoods.GameCardId)
|
|
fmt.Println("sql:", sql)
|
|
err = begin.Exec(sql).Error
|
|
if err != nil {
|
|
begin.Rollback()
|
|
logger.Error("err:", err)
|
|
return err
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
//sqlStore := fmt.Sprintf("UPDATE game_card_goods_stock SET user_hold_stock= user_hold_stock-1,order_count=order_count+1,order_count=order_count+1 WHERE store_id=%d AND game_card_id=%d;", order.StoreId, gameCardGoods.GameCardId)
|
|
sqlStore := fmt.Sprintf("UPDATE game_card_goods_stock SET user_hold_stock= user_hold_stock-1,order_count=order_count+1 WHERE store_id=%d AND game_card_id=%d;", order.StoreId, gameCardGoods.GameCardId)
|
|
fmt.Println("sqlStore:", sqlStore)
|
|
err = begin.Exec(sqlStore).Error
|
|
if err != nil {
|
|
begin.Rollback()
|
|
logger.Error("err:", err)
|
|
return err
|
|
}
|
|
if gameCardGoods.Status != 7 || gameCardGoods.FunctionState != 1 {
|
|
//sql := fmt.Sprintf("UPDATE game_card_goods_stock SET rent_stock= rent_stock+1,user_hold_stock= user_hold_stock-1 WHERE store_id=%d AND game_card_id=%d;", m.RevertStoreId, gameCardGoods.GameCardId)
|
|
sql := fmt.Sprintf("UPDATE game_card_goods_stock SET rent_stock= rent_stock+1 WHERE store_id=%d AND game_card_id=%d;", m.RevertStoreId, gameCardGoods.GameCardId)
|
|
fmt.Println("sql:", sql)
|
|
err = begin.Exec(sql).Error
|
|
if err != nil {
|
|
begin.Rollback()
|
|
logger.Error("err:", err)
|
|
return err
|
|
}
|
|
}
|
|
}
|
|
return nil
|
|
})
|
|
eg.Go(func() error {
|
|
if order.GameCardId != 0 {
|
|
sql := fmt.Sprintf("UPDATE game_card SET order_count = order_count+1 WHERE id = %d", order.GameCardId)
|
|
err := begin.Exec(sql).Error
|
|
if err != nil {
|
|
begin.Rollback()
|
|
logger.Error("err:", err)
|
|
return err
|
|
}
|
|
}
|
|
|
|
return nil
|
|
})
|
|
eg.Go(func() error {
|
|
err := begin.Table("order_card").Where("id=?", orderCard.ID).Updates(map[string]interface{}{
|
|
"card_status": OrderCardStatusCompleted,
|
|
"revert_store_id": m.RevertStoreId,
|
|
"revert_time": time.Now(),
|
|
}).Error
|
|
if err != nil {
|
|
begin.Rollback()
|
|
logger.Error("err:", err)
|
|
return err
|
|
}
|
|
var count int64
|
|
err = DB.Table("order_card").Where("order_id=?", orderCard.OrderId).
|
|
Where("card_status in (?)", []uint32{1, 2, 3}).Count(&count).Error
|
|
if err != nil {
|
|
begin.Rollback()
|
|
logger.Error("err:", err)
|
|
return err
|
|
}
|
|
if count == 0 {
|
|
err := begin.Table("order").Where("id=?", orderCard.OrderId).Updates(map[string]interface{}{
|
|
"card_status": OrderCardStatusCompleted,
|
|
}).Error
|
|
if err != nil {
|
|
begin.Rollback()
|
|
logger.Error("err:", err)
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
})
|
|
eg.Go(func() error {
|
|
sql := fmt.Sprintf(
|
|
"UPDATE user_rent_card SET have_rent_count = have_rent_count-1,can_rent_count=can_rent_count+1 WHERE uid =%d;",
|
|
orderCard.Uid)
|
|
//sql := fmt.Sprintf("UPDATE user_rent_card SET have_rent_count = have_rent_count-1,can_rent_count=can_rent_count+1 WHERE uid =%d;", m.Uid)
|
|
fmt.Println("sql:", sql)
|
|
err = begin.Exec(sql).Error
|
|
if err != nil {
|
|
begin.Rollback()
|
|
logger.Error("err:", err)
|
|
return err
|
|
}
|
|
return nil
|
|
})
|
|
err = eg.Wait()
|
|
if err != nil {
|
|
begin.Rollback()
|
|
logger.Error("err:", err)
|
|
return err
|
|
}
|
|
err = begin.Commit().Error
|
|
if err != nil {
|
|
begin.Rollback()
|
|
logger.Error("err:", err)
|
|
return err
|
|
}
|
|
operationLog := &OperationLog{
|
|
Uid: m.OperationUid,
|
|
Description: "借卡归还入库",
|
|
OperationType: OperationTypeRentCardRevert,
|
|
CorrelationId: orderCard.ID,
|
|
CorrelationName: LogCorrelationOrderCard,
|
|
StoreId: m.RevertStoreId,
|
|
StoreName: "",
|
|
CooperativeName: "",
|
|
SerialNumber: m.SerialNumber,
|
|
}
|
|
operationLog.AddLog()
|
|
return nil
|
|
}
|