mh_server/model/order.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
	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"`                                                     // 商户

	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 {
			if order.CardStatus == 2|| order.CardStatus == 3 {
				order.CardStatus = 4
			}
			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)
	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.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)
	sql := fmt.Sprintf("SELECT COUNT(*) AS count FROM order_card 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
}