1040 lines
38 KiB
Go
1040 lines
38 KiB
Go
package model
|
|
|
|
import (
|
|
"errors"
|
|
"fmt"
|
|
"github.com/codinl/go-logger"
|
|
"mh-server/lib/utils"
|
|
"strings"
|
|
"time"
|
|
)
|
|
|
|
//go:generate goqueryset -in share_card.go
|
|
// gen:qs
|
|
type UserShareCardBill struct {
|
|
Model
|
|
Uid uint32 `json:"uid" gorm:"index"`
|
|
BillSn string `json:"bill_sn" gorm:"index"`
|
|
State string `json:"state" gorm:"index"`
|
|
SendCardType uint32 `json:"send_card_type"` // 1-送卡 2-邮寄
|
|
StoreId uint32 `json:"store_id" gorm:"index"` // 门店id
|
|
ExpressCompany string `json:"express_company"` // 物流公司
|
|
ExpressCompanyNo string `json:"express_company_no"` // 物流公司编号
|
|
ExpressNo string `json:"express_no"` // 物流单号
|
|
SendCardTime time.Time `json:"send_card_time"` // 递送卡时间
|
|
StockTime time.Time `json:"stock_time"` // 入库时间
|
|
RetrieveTime time.Time `json:"retrieve_time"` // 收回卡时间 申请收回
|
|
StockRemovalTime time.Time `json:"stock_removal_time"` // 出库时间
|
|
Store Store `json:"store" gorm:"-"` // 门店
|
|
Remark string `json:"remark"`
|
|
BillGames []ShareCardBillGame `json:"bill_games" gorm:"-"`
|
|
}
|
|
|
|
// gen:qs
|
|
type ShareCardBillGame struct {
|
|
Model
|
|
UserShareCardBillId uint32 `json:"user_share_card_bill_id" gorm:"index"`
|
|
Uid uint32 `json:"uid" gorm:"index"`
|
|
GameCardId uint32 `json:"game_card_id" gorm:"index"`
|
|
BillSn string `json:"bill_sn" gorm:"index"`
|
|
Count uint32 `json:"count"`
|
|
State string `json:"state" gorm:"index"`
|
|
GameCard GameCard `json:"game_card" gorm:"-"` //
|
|
ShareCards []UserShareCard `json:"share_cards" gorm:"-"`
|
|
}
|
|
|
|
const (
|
|
ShareCardBillStateInCheck = "in_check" // 待审核
|
|
ShareCardBillStateInSendCard = "in_send_card" // 待递送卡
|
|
ShareCardBillStateSentCard = "sent_card" // 已递送卡
|
|
ShareCardBillStateCompleted = "completed" // 完成
|
|
ShareCardBillStateCancel = "cancel" // 取消
|
|
ShareCardBillStateAuditLose = "check_lose" // 审核失败
|
|
ShareCardBillStateReceivingCard = "receiving_card" // 收回中
|
|
ShareCardBillStateReceivedCard = "received_card" // 已收回
|
|
)
|
|
|
|
const (
|
|
ShareCardStateInCheck = "in_check" // 待审核
|
|
ShareCardStateInSendCard = "in_send_card" // 待递送卡
|
|
ShareCardStateSentCard = "sent_card" // 已递送卡
|
|
ShareCardStateSharing = "sharing" // 共享中
|
|
ShareCardStateAuditLose = "check_lose" // 审核失败
|
|
ShareCardStateCancel = "cancel" // 取消
|
|
ShareCardStateRetrieve = "retrieve" // 收回
|
|
)
|
|
|
|
const (
|
|
CardProfitVm = 21
|
|
)
|
|
|
|
// gen:qs
|
|
type UserShareCard struct {
|
|
Model
|
|
//Uid uint32 `json:"uid" gorm:"index"`
|
|
//SerialNumber string `json:"serial_number" gorm:"index"` // 编号
|
|
//BillSn string `json:"bill_sn" gorm:"index"`
|
|
//GameCardId uint32 `json:"game_card_id" gorm:"index"`
|
|
//State string `json:"state" gorm:"index"`
|
|
//GameCardGoodsId uint32 `json:"game_card_goods_id" gorm:"index"`
|
|
//UserShareCardBillId uint32 `json:"user_share_card_bill_id" gorm:"index"`
|
|
//ShareCardBillGameId uint32 `json:"share_card_bill_game_id" gorm:"index"`
|
|
//StoreId uint32 `json:"store_id" gorm:"index"` // 门店id
|
|
//ProfitState uint32 `json:"profit_state"` // 1-未生效 2-生效
|
|
//TotalVm uint32 `json:"total_vm"` // 累计积分
|
|
//RetrieveSerialNumber string `json:"retrieve_serial_number" gorm:"index"` // 收卡编号
|
|
//RetrieveGameCardGoodsId uint32 `json:"retrieve_game_card_goods_id" gorm:"index"` // 收回卡id
|
|
|
|
Uid uint32 `json:"uid" gorm:"index"`
|
|
GameCardGoodsId uint32 `json:"game_card_goods_id" gorm:"index"`
|
|
SerialNumber string `json:"serial_number" gorm:"index"` // 编号
|
|
GameCardId uint32 `json:"game_card_id" gorm:"index"`
|
|
|
|
AllotSerialNumber string `json:"allot_serial_number" gorm:"index"` // 库存共享卡编号 分配收回卡 绑定新卡编号
|
|
AllotCardGoodsId uint32 `json:"allot_card_goods_id" gorm:"index"` // 库存共享卡id
|
|
UserShareCardBillId uint32 `json:"user_share_card_bill_id" gorm:"index"`
|
|
BillSn string `json:"bill_sn" gorm:"index"`
|
|
|
|
State string `json:"state" gorm:"index"`
|
|
|
|
ShareCardBillGameId uint32 `json:"share_card_bill_game_id" gorm:"index"`
|
|
StoreId uint32 `json:"store_id" gorm:"index"` // 门店id
|
|
ProfitState uint32 `json:"profit_state"` // 1-未生效 2-生效
|
|
TotalVm uint32 `json:"total_vm"` // 累计积分
|
|
RetrieveSerialNumber string `json:"retrieve_serial_number" gorm:"index"` // 收卡编号
|
|
RetrieveGameCardGoodsId uint32 `json:"retrieve_game_card_goods_id" gorm:"index"` // 收回卡id
|
|
|
|
GameCard GameCard `json:"game_card" gorm:"-"`
|
|
}
|
|
|
|
// gen:qs
|
|
type ShareCardGameVm struct {
|
|
Model
|
|
GameCardId uint32 `json:"game_card_id" gorm:"index"`
|
|
HoldCardCount uint32 `json:"hold_card_count"` //
|
|
StockCardCount uint32 `json:"stock_card_count"` //
|
|
TotalCardCount uint32 `json:"total_card_count"`
|
|
CardProfit uint32 `json:"card_profit"`
|
|
Vm uint32 `json:"vm"` // 发放积分
|
|
ProvideVm uint32 `json:"provide_vm"` // 发放积分
|
|
ProvideDate string `json:"provide_date" gorm:"index"`
|
|
//share_card_game_vm
|
|
}
|
|
|
|
// 用户卡积分记录
|
|
// gen:qs
|
|
type UserShareCardVm struct {
|
|
Model
|
|
ShareCardGameVmId uint32 `json:"share_card_game_vm_id" gorm:"index"`
|
|
Uid uint32 `json:"uid" gorm:"index"`
|
|
SerialNumber string `json:"serial_number" gorm:"index"` // 编号
|
|
BillSn string `json:"bill_sn" gorm:"index"`
|
|
GameCardId uint32 `json:"game_card_id" gorm:"index"`
|
|
GameCardGoodsId uint32 `json:"game_card_goods_id" gorm:"index"`
|
|
UserShareCardBillId uint32 `json:"user_share_card_bill_id" gorm:"index"`
|
|
CardProfit uint32 `json:"card_profit"`
|
|
Vm uint32 `json:"vm"` // 发放积分
|
|
ProvideDate string `json:"provide_date"`
|
|
}
|
|
|
|
// 用户积分记录
|
|
// gen:qs
|
|
type ShareCardDateVm struct {
|
|
Model
|
|
Uid uint32 `json:"uid" gorm:"index"`
|
|
Vm uint32 `json:"vm"` // 发放积分
|
|
TotalVm uint32 `json:"total_vm"` // 用户累计获取积分
|
|
ProvideDate string `json:"provide_date" gorm:"index"` // 收益日期
|
|
}
|
|
|
|
// 总积分记录
|
|
// gen:qs
|
|
type ShareCardVmRecord struct {
|
|
Model
|
|
TotalVm uint32 `json:"total_vm"`
|
|
ProvideVm uint32 `json:"provide_vm"` // 总发放积分
|
|
ProvideDate string `json:"provide_date" gorm:"index"` // 发放收益时间
|
|
//share_card_vm_record
|
|
}
|
|
|
|
//type UserShareCardBillInfo struct {
|
|
// GameCardId uint32 `json:"game_card_id"`
|
|
// Count uint32 `json:"count"`
|
|
//}
|
|
|
|
// 用户收回卡
|
|
// gen:qs
|
|
type ShareCardRetrieve struct {
|
|
Model
|
|
Uid uint32 `json:"uid" gorm:"index"`
|
|
State string `json:"state" gorm:"index"` // 1-暂无库存 2-待发卡 3-待取卡 4-已发卡 5-已收卡 6-已取消
|
|
RetrieveCardType uint32 `json:"retrieve_card_type" gorm:"index"` // 1-送卡门店 2-邮寄
|
|
StoreId uint32 `json:"store_id" gorm:"index"` // 门店id
|
|
ExpressCompany string `json:"express_company"` // 物流公司
|
|
ExpressCompanyNo string `json:"express_company_no"` // 物流公司编号
|
|
ExpressNo string `json:"express_no"` // 物流单号
|
|
StockRemovalTime time.Time `json:"stock_removal_time"` // 出库时间
|
|
StockTime time.Time `json:"stock_time"` // 入库时间
|
|
PayState uint32 `json:"pay_state"` // 1-未支付 2-已支付
|
|
PayAmount uint32 `json:"pay_amount"` // 支付金额
|
|
Remark string `json:"remark"`
|
|
OrderSn string `json:"order_sn" gorm:"index"` // 订单编号
|
|
AddressId uint32 `json:"address_id" gorm:"index"` // 收货地址
|
|
RefundOrderSn string `json:"refund_order_sn" gorm:"index"` // 订单编号退费
|
|
PickupCode string `json:"pickup_code"` // 取货码
|
|
ReceiptTime time.Time `json:"receipt_time"` // 签收时间
|
|
Store Store `json:"store" gorm:"-"`
|
|
UserAddress UserAddress `json:"user_address" gorm:"-"`
|
|
ShareCardRetrieveCards []ShareCardRetrieveCard `json:"share_card_retrieve_cards" gorm:"-"`
|
|
//TotalVm uint32 `json:"total_vm"` // 累计积分
|
|
//ShareCardBillGameId uint32 `json:"share_card_bill_game_id" gorm:"index"`
|
|
//GameCardGoodsId uint32 `json:"game_card_goods_id" gorm:"index"`
|
|
//UserShareCardBillId uint32 `json:"user_share_card_bill_id" gorm:"index"`
|
|
//BillSn string `json:"bill_sn" gorm:"index"`
|
|
//GameCardId uint32 `json:"game_card_id" gorm:"index"`
|
|
//SerialNumber string `json:"serial_number" gorm:"index"` // 编号
|
|
//GameCard GameCard `json:"game_card" gorm:"-"`
|
|
}
|
|
|
|
const (
|
|
RetrieveStateInCheck = "in_check" // 待审核
|
|
RetrieveStateCheckLose = "check_lose" // 审核失败
|
|
RetrieveStateOutStock = "out_stock" // 暂无库存
|
|
RetrieveStateInSendCard = "in_send_card" // 待发卡
|
|
RetrieveStateInPickCard = "in_pick_card" // 待取卡
|
|
RetrieveStateSentCard = "sent_card" // 已发卡
|
|
RetrieveStateReceivedCard = "received_card" // 已收卡
|
|
RetrieveStateCancel = "cancel" // 取消
|
|
)
|
|
|
|
// gen:qs
|
|
type ShareCardRetrieveCard struct {
|
|
//ShareCardRetrieveId uint32 `json:"share_card_retrieve_id" gorm:"index"`
|
|
//UserShareCardId uint32 `json:"user_share_card_id" gorm:"index"` // 用户共享卡收回
|
|
//Uid uint32 `json:"uid" gorm:"index"`
|
|
//SerialNumber string `json:"serial_number" gorm:"index"` // 编号
|
|
//State string `json:"state" gorm:"index"` // 1-暂无库存 2-待发卡 3-待取卡 4-已发卡 5-已收卡 6-已取消
|
|
//BillSn string `json:"bill_sn" gorm:"index"`
|
|
//GameCardId uint32 `json:"game_card_id" gorm:"index"`
|
|
//RetrieveCardType uint32 `json:"retrieve_card_type" gorm:"index"` // 1-送卡 2-邮寄
|
|
//GameCardGoodsId uint32 `json:"game_card_goods_id" gorm:"index"`
|
|
//UserShareCardBillId uint32 `json:"user_share_card_bill_id" gorm:"index"`
|
|
//StoreId uint32 `json:"store_id" gorm:"index"` // 门店id
|
|
//Remark string `json:"remark"`
|
|
//RetrieveSerialNumber string `json:"retrieve_serial_number" gorm:"index"` // 收卡编号
|
|
//RetrieveGameCardGoodsId uint32 `json:"retrieve_game_card_goods_id" gorm:"index"` // 收回卡id
|
|
|
|
Model
|
|
ShareCardRetrieveId uint32 `json:"share_card_retrieve_id" gorm:"index"` // 收回卡单id
|
|
UserShareCardId uint32 `json:"user_share_card_id" gorm:"index"` // 用户共享卡id
|
|
Uid uint32 `json:"uid" gorm:"index"`
|
|
State string `json:"state" gorm:"index"` // -暂无库存 -待发卡 -待取卡 -已发卡 -已收卡 -已取消
|
|
TransportType uint32 `json:"transport_type" gorm:"index"` // 1-送卡到门店 2-邮寄
|
|
SerialNumber string `json:"serial_number" gorm:"index"` // 编号
|
|
GameCardGoodsId uint32 `json:"game_card_goods_id" gorm:"index"`
|
|
GameCardId uint32 `json:"game_card_id" gorm:"index"`
|
|
|
|
StoreId uint32 `json:"store_id" gorm:"index"` // 共享卡门店id
|
|
UserShareCardBillId uint32 `json:"user_share_card_bill_id" gorm:"index"`
|
|
BillSn string `json:"bill_sn" gorm:"index"`
|
|
|
|
RetrieveSerialNumber string `json:"retrieve_serial_number" gorm:"index"` // 收卡编号
|
|
RetrieveGameCardGoodsId uint32 `json:"retrieve_game_card_goods_id" gorm:"index"` // 收回卡id
|
|
Remark string `json:"remark"`
|
|
|
|
OriginalCardType string `json:"retrieve_card_type" gorm:"index"` // -公共卡 -用户共享 回收前的卡类型 原卡类型
|
|
AllotUserShareCardId uint32 `json:"allot_user_share_card_id"` // 分配用户共享卡id
|
|
ReceiptTime time.Time `json:"receipt_time"` // 签收时间
|
|
PayState uint32 `json:"pay_state"` // 1-未支付 2-已支付
|
|
|
|
GameCard GameCard `json:"game_card" gorm:"-"`
|
|
Store Store `json:"store" gorm:"-"`
|
|
ShareCardRetrieve ShareCardRetrieve `json:"share_card_retrieve" gorm:"-"`
|
|
|
|
//TotalVm uint32 `json:"total_vm"` // 累计积分
|
|
//ShareCardBillGameId uint32 `json:"share_card_bill_game_id" gorm:"index"`
|
|
// share_card_retrieve_card
|
|
}
|
|
|
|
const (
|
|
CardIssueStateFollowing = "following" // 处理中
|
|
CardIssueStateFollowed = "followed" // 已处理
|
|
CardIssueStateInDeliver = "in_deliver" // 发货中
|
|
CardIssueStateCompleted = "completed" // 已完成
|
|
CardIssueStateCanceled = "canceled" // 已取消
|
|
)
|
|
const (
|
|
ObtainTypeRetrieveCard = "retrieve_card" // 收回卡
|
|
ObtainTypeRentCard = "rent_card" // 租卡
|
|
)
|
|
|
|
// gen:qs
|
|
type CardIssueFeedback struct {
|
|
Model
|
|
Uid uint32 `json:"uid" gorm:"index"` // 反馈用户
|
|
GameCardId uint32 `json:"game_card_id" gorm:"index"`
|
|
SerialNumber string `json:"serial_number" gorm:"index"` // 编号
|
|
GameCardGoodsId uint32 `json:"game_card_goods_id" gorm:"index"`
|
|
StoreId uint32 `json:"store_id" gorm:"index"` // 门店id
|
|
RelevanceId uint32 `json:"relevance_id" gorm:"index"` // 关联id
|
|
ObtainType string `json:"obtain_type"` // 卡类型: -收回卡 -租卡
|
|
State string `json:"state" gorm:"index"` // 状态:
|
|
Problem string `json:"problem"` // 问题
|
|
Remark string `json:"remark"`
|
|
|
|
ExpressCompany string `json:"express_company"` // 物流公司
|
|
ExpressCompanyNo string `json:"express_company_no"` // 物流公司编号
|
|
ExpressNo string `json:"express_no" gorm:"index"` // 物流单号
|
|
IsNormalFunction uint32 `json:"is_normal_function"` // 功能是否正常:1-是 2-否
|
|
IsPackingIntact uint32 `json:"is_packing_intact"` // 包装是否完整:1-是 2-否
|
|
IsCardBreakage uint32 `json:"is_card_breakage"` // 卡带是否破损:1-是 2-否
|
|
DeliverExpressCompany string `json:"deliver_express_company"` // 发货物流公司
|
|
DeliverExpressCompanyNo string `json:"deliver_express_company_no"` // 发货物流公司编号
|
|
DeliverExpressNo string `json:"deliver_express_no" gorm:"index"` // 发货物流单号
|
|
ReissueSerialNumber string `json:"reissue_serial_number" gorm:"index"` // 补发货编码
|
|
ReissueGameCardGoodsId uint32 `json:"reissue_game_card_goods_id" gorm:"index"` // 补发货卡id
|
|
DeliverTime time.Time `json:"deliver_time"` // 发货时间
|
|
CheckTime time.Time `json:"check_time"` // 检测时间
|
|
CheckSysUid string `json:"check_sys_uid" gorm:"index"` // 检测店员账号用户id
|
|
ReceiptTime time.Time `json:"receipt_time"` // 签收时间
|
|
//CheckShopAssistant string `json:"check_shop_assistant" gorm:"index"` // 检测店员账号
|
|
TransportType uint32 `json:"transport_type" gorm:"index"` // 1-送卡到门店 2-邮寄
|
|
UserAddressId uint32 `json:"user_address_id" gorm:"index"`
|
|
|
|
UserInfo *User `json:"user_info" gorm:"-"`
|
|
GameCard *GameCard `json:"game_card" gorm:"-"`
|
|
Store *Store `json:"store" gorm:"-"`
|
|
ShareCardRetrieve *ShareCardRetrieve `json:"share_card_retrieve" gorm:"-"`
|
|
Order *Order `json:"order" gorm:"-"`
|
|
UserAddress *UserAddress `json:"user_address" gorm:"-"`
|
|
// card_issue_feedback
|
|
}
|
|
|
|
func GetUserShareCardBillList(uid uint32, page, pageSize int, state string) ([]UserShareCardBill, int, error) {
|
|
page = page - 1
|
|
if page < 0 {
|
|
page = 0
|
|
}
|
|
if pageSize == 0 {
|
|
pageSize = 10
|
|
}
|
|
var shareCardBills []UserShareCardBill
|
|
qs := NewUserShareCardBillQuerySet(DB).UidEq(uid)
|
|
if state != "" {
|
|
qs = qs.StateEq(state)
|
|
}
|
|
count, err := qs.Count()
|
|
if err != nil {
|
|
logger.Error("user share card bill count err:", err)
|
|
return shareCardBills, 0, err
|
|
}
|
|
totalPage := count/pageSize + 1
|
|
err = qs.OrderDescByID().Offset(page * pageSize).Limit(pageSize).All(&shareCardBills)
|
|
if err != nil && err != RecordNotFound {
|
|
logger.Error("user share card bill err:", err)
|
|
return shareCardBills, 0, err
|
|
}
|
|
if len(shareCardBills) == 0 {
|
|
return shareCardBills, 0, nil
|
|
}
|
|
shareCardBills = UserShareCardBillListSetGame(shareCardBills)
|
|
return shareCardBills, totalPage, nil
|
|
}
|
|
|
|
func GetUserShareCardBill(uid uint32, billId uint32) (UserShareCardBill, error) {
|
|
var shareCardBill UserShareCardBill
|
|
err := NewUserShareCardBillQuerySet(DB).IDEq(billId).One(&shareCardBill)
|
|
if err != nil {
|
|
logger.Error("user share card bill err:", err)
|
|
return shareCardBill, err
|
|
}
|
|
|
|
var store Store
|
|
err = NewStoreQuerySet(DB).IDEq(shareCardBill.StoreId).One(&store)
|
|
if err != nil {
|
|
logger.Error("store err:", err)
|
|
return shareCardBill, err
|
|
}
|
|
shareCardBill.Store = store
|
|
list := []UserShareCardBill{shareCardBill}
|
|
list = UserShareCardBillListSetGame(list)
|
|
if len(list) == 0 {
|
|
return shareCardBill, nil
|
|
}
|
|
err = list[0].SetShareCard()
|
|
if err != nil {
|
|
logger.Error("set share card err:", err)
|
|
return shareCardBill, err
|
|
}
|
|
return list[0], nil
|
|
}
|
|
|
|
func UserShareCardBillListSetGame(list []UserShareCardBill) []UserShareCardBill {
|
|
billIds := make([]uint32, 0, len(list))
|
|
for i, _ := range list {
|
|
billIds = append(billIds, list[i].ID)
|
|
}
|
|
if len(billIds) == 0 {
|
|
return list
|
|
}
|
|
billMap := make(map[uint32][]ShareCardBillGame, 0)
|
|
var games []ShareCardBillGame
|
|
err := NewShareCardBillGameQuerySet(DB).UserShareCardBillIdIn(billIds...).All(&games)
|
|
if err != nil && err != RecordNotFound {
|
|
logger.Error("share card bill err:", err)
|
|
return list
|
|
}
|
|
gameIds := make([]uint32, 0, len(games))
|
|
for i, _ := range games {
|
|
gameIds = append(gameIds, games[i].GameCardId)
|
|
}
|
|
cardMap, err := GameCardMap(gameIds)
|
|
for i, _ := range games {
|
|
v, ok := cardMap[games[i].GameCardId]
|
|
if ok {
|
|
games[i].GameCard = v
|
|
}
|
|
}
|
|
|
|
for i, _ := range games {
|
|
billMap[games[i].UserShareCardBillId] = append(billMap[games[i].UserShareCardBillId], games[i])
|
|
}
|
|
|
|
if err != nil {
|
|
logger.Error("game card map err:", err)
|
|
return list
|
|
}
|
|
|
|
for i, _ := range list {
|
|
v, ok := billMap[list[i].ID]
|
|
if ok {
|
|
list[i].BillGames = v
|
|
}
|
|
}
|
|
|
|
return list
|
|
}
|
|
|
|
func GetUserShareCardGameList(uid uint32, page, pageSize int, label string) ([]GameCard, int, error) {
|
|
page = page - 1
|
|
if page < 0 {
|
|
page = 0
|
|
}
|
|
if pageSize == 0 {
|
|
pageSize = 10
|
|
}
|
|
var games []GameCard
|
|
//qs := NewGameCardQuerySet(DB)
|
|
sql := fmt.Sprintf("SELECT * FROM game_card WHERE 1 ")
|
|
if label != "" {
|
|
var gameLabels []GameCardLabel
|
|
labelSql := "SELECT * FROM game_card_label WHERE game_label LIKE '%" + label + "%';"
|
|
err := DB.Raw(labelSql).Scan(&gameLabels).Error
|
|
if err != nil {
|
|
logger.Error("game card label err:", err)
|
|
return games, 0, err
|
|
}
|
|
|
|
if len(gameLabels) > 0 {
|
|
idString := make([]string, 0, len(gameLabels))
|
|
for i, _ := range gameLabels {
|
|
//idString += fmt.Sprintf("%d", gameLabels[i].GameCardId)
|
|
idString = append(idString, fmt.Sprintf("%d", gameLabels[i].GameCardId))
|
|
}
|
|
sql += " AND (`name` LIKE '%" + label + "%' " + fmt.Sprintf(" OR id IN (%s))",
|
|
strings.Join(idString, ","))
|
|
} else {
|
|
sql += " AND `name` LIKE '%" + label + "%' "
|
|
}
|
|
//qs = qs.StateEq(state)
|
|
}
|
|
|
|
type GameCount struct {
|
|
Count int `json:"count"`
|
|
}
|
|
var count GameCount
|
|
countSql := strings.Replace(sql, "SELECT *", "SELECT COUNT(*) AS count ", -1)
|
|
//countSql := strings.Replace(sql, "SELECT *", "SELECT COUNT(*) ", -1)
|
|
fmt.Println("countSql:", countSql)
|
|
err := DB.Raw(countSql).Scan(&count).Error
|
|
//count, err := qs.Count()
|
|
if err != nil {
|
|
logger.Error("user share card bill count err:", err)
|
|
return games, 0, err
|
|
}
|
|
totalPage := count.Count/pageSize + 1
|
|
sql += fmt.Sprintf("ORDER BY id DESC LIMIT %d OFFSET %d ;", pageSize, page*pageSize)
|
|
err = DB.Raw(sql).Scan(&games).Error
|
|
//err = qs.OrderDescByID().Offset(page * pageSize).Limit(pageSize).All(&games)
|
|
fmt.Println("sql:", sql)
|
|
if err != nil && err != RecordNotFound {
|
|
logger.Error("user share card bill err:", err)
|
|
return games, 0, err
|
|
}
|
|
if len(games) == 0 {
|
|
return games, 0, nil
|
|
}
|
|
games = ShareCardGameListSetGameVm(games)
|
|
//shareCardBills = UserShareCardBillListSetGame(shareCardBills)
|
|
return games, totalPage, nil
|
|
}
|
|
|
|
func ShareCardGameListSetGameVm(list []GameCard) []GameCard {
|
|
if len(list) == 0 {
|
|
return list
|
|
}
|
|
gameIds := make([]uint32, 0, len(list))
|
|
for i, _ := range list {
|
|
gameIds = append(gameIds, list[i].ID)
|
|
}
|
|
vmMap := GetShareCardGameVmMap(gameIds)
|
|
for i, _ := range list {
|
|
v, ok := vmMap[list[i].ID]
|
|
if ok {
|
|
list[i].EstimateVm = v.Vm
|
|
}
|
|
if list[i].EstimateVm == 0 {
|
|
list[i].EstimateVm = CardProfitVm
|
|
}
|
|
}
|
|
return list
|
|
}
|
|
|
|
func GetShareCardGameVmMap(ids []uint32) map[uint32]ShareCardGameVm {
|
|
shareCardGameVmMap := make(map[uint32]ShareCardGameVm, 0)
|
|
if len(ids) == 0 {
|
|
return shareCardGameVmMap
|
|
}
|
|
dateFormat := utils.ZeroDateFormat(-1)
|
|
var shareGameVm []ShareCardGameVm
|
|
err := NewShareCardGameVmQuerySet(DB).IDIn(ids...).ProvideDateEq(dateFormat).All(&shareGameVm)
|
|
if err != nil && err != RecordNotFound {
|
|
logger.Error("share card game vm err:", err)
|
|
return shareCardGameVmMap
|
|
}
|
|
for i, _ := range shareGameVm {
|
|
shareCardGameVmMap[shareGameVm[i].GameCardId] = shareGameVm[i]
|
|
}
|
|
|
|
return shareCardGameVmMap
|
|
}
|
|
|
|
func (m *UserShareCardBill) SetShareCard() error {
|
|
var userShareCards []UserShareCard
|
|
err := NewUserShareCardQuerySet(DB).UserShareCardBillIdEq(m.ID).All(&userShareCards)
|
|
if err != nil {
|
|
logger.Error("user share card err:", err)
|
|
return err
|
|
}
|
|
shareCardMap := make(map[uint32][]UserShareCard, 0)
|
|
for i, _ := range userShareCards {
|
|
shareCardMap[userShareCards[i].GameCardId] = append(shareCardMap[userShareCards[i].GameCardId], userShareCards[i])
|
|
}
|
|
if len(m.BillGames) == 0 {
|
|
logger.Error("bill games is nil")
|
|
return nil
|
|
}
|
|
for i, _ := range m.BillGames {
|
|
v, ok := shareCardMap[m.BillGames[i].GameCardId]
|
|
if ok {
|
|
m.BillGames[i].ShareCards = v
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func GetUserShareCardMyCardList(uid uint32, page, pageSize int, state string) ([]UserShareCard, int, int, error) {
|
|
page = page - 1
|
|
if page < 0 {
|
|
page = 0
|
|
}
|
|
if pageSize == 0 {
|
|
pageSize = 10
|
|
}
|
|
states := []string{state}
|
|
if state == "" {
|
|
states = []string{ShareCardStateInCheck, ShareCardStateSharing, ShareCardStateRetrieve}
|
|
}
|
|
|
|
var shareCards []UserShareCard
|
|
shareCardCount, err := NewUserShareCardQuerySet(DB).UidEq(uid).StateEq(ShareCardStateSharing).Count()
|
|
if err != nil {
|
|
logger.Error("user share card count err:", err)
|
|
return shareCards, 0, shareCardCount, err
|
|
}
|
|
|
|
qs := NewUserShareCardQuerySet(DB).UidEq(uid).StateIn(states...)
|
|
|
|
count, err := qs.Count()
|
|
if err != nil {
|
|
logger.Error("user share card bill count err:", err)
|
|
return shareCards, 0, shareCardCount, err
|
|
}
|
|
totalPage := count/pageSize + 1
|
|
err = qs.OrderDescByID().Offset(page * pageSize).Limit(pageSize).All(&shareCards)
|
|
if err != nil && err != RecordNotFound {
|
|
logger.Error("user share card bill err:", err)
|
|
return shareCards, 0, shareCardCount, err
|
|
}
|
|
if len(shareCards) == 0 {
|
|
return shareCards, 0, shareCardCount, nil
|
|
}
|
|
shareCards = UserShareCardListSetGame(shareCards)
|
|
return shareCards, totalPage, shareCardCount, nil
|
|
}
|
|
|
|
func UserShareCardListSetGame(list []UserShareCard) []UserShareCard {
|
|
gameIds := make([]uint32, 0, len(list))
|
|
for i, _ := range list {
|
|
gameIds = append(gameIds, list[i].GameCardId)
|
|
}
|
|
cardMap, err := GameCardMap(gameIds)
|
|
if err != nil {
|
|
logger.Error("game card map err:", err)
|
|
return list
|
|
}
|
|
for i, _ := range list {
|
|
v, ok := cardMap[list[i].GameCardId]
|
|
if ok {
|
|
list[i].GameCard = v
|
|
}
|
|
}
|
|
|
|
return list
|
|
}
|
|
|
|
func GetUserShareCardVmList(uid uint32, page, pageSize int, goodsId uint32) ([]UserShareCardVm, int, error) {
|
|
page = page - 1
|
|
if page < 0 {
|
|
page = 0
|
|
}
|
|
if pageSize == 0 {
|
|
pageSize = 10
|
|
}
|
|
|
|
var shareCardVms []UserShareCardVm
|
|
qs := NewUserShareCardVmQuerySet(DB).UidEq(uid).GameCardGoodsIdEq(goodsId)
|
|
|
|
count, err := qs.Count()
|
|
if err != nil {
|
|
logger.Error("user share card bill count err:", err)
|
|
return shareCardVms, 0, err
|
|
}
|
|
totalPage := count/pageSize + 1
|
|
err = qs.OrderDescByID().Offset(page * pageSize).Limit(pageSize).All(&shareCardVms)
|
|
if err != nil && err != RecordNotFound {
|
|
logger.Error("user share card bill err:", err)
|
|
return shareCardVms, 0, err
|
|
}
|
|
//if len(shareCardVms) == 0 {
|
|
// return shareCardVms, 0, nil
|
|
//}
|
|
//shareCards = UserShareCardListSetGame(shareCards)
|
|
return shareCardVms, totalPage, nil
|
|
}
|
|
|
|
func GetUserShareCardDateVmInfo(uid uint32) (ShareCardDateVm, error) {
|
|
var cardDateVm ShareCardDateVm
|
|
//err := NewShareCardDateVmQuerySet(DB).UidEq(uid).ProvideDateEq(utils.ZeroDateFormat(-1)).One(&cardDateVm)
|
|
err := NewShareCardDateVmQuerySet(DB).UidEq(uid).OrderDescByID().Limit(1).One(&cardDateVm)
|
|
if err != nil && err != RecordNotFound {
|
|
logger.Error("share card date vm err:", err)
|
|
}
|
|
//count := len(cardDateVms)
|
|
//var cardDateVm ShareCardDateVm
|
|
//if count == 2 {
|
|
// cardDateVm = cardDateVms[1]
|
|
// cardDateVm.TotalVm += cardDateVms[0].Vm
|
|
//} else if count == 1 {
|
|
// cardDateVm = cardDateVms[0]
|
|
//} else {
|
|
//
|
|
//}
|
|
return cardDateVm, nil
|
|
}
|
|
|
|
type ShareCardRetrieveCreateReq struct {
|
|
SerialNumbers []string `json:"serial_numbers"`
|
|
StoreId uint32 `json:"store_id"` // 门店id
|
|
RetrieveCardType uint32 `json:"retrieve_card_type"` // 1-门店 2-邮寄 修改
|
|
AddressId uint32 `json:"address_id"` // 收货地址
|
|
Amount uint32 `json:"amount"` // 金额
|
|
Uid uint32 `json:"uid"`
|
|
}
|
|
|
|
func (m *ShareCardRetrieveCreateReq) RetrieveCreate() (*ShareCardRetrieve, error) {
|
|
var userShareCards []UserShareCard
|
|
err := NewUserShareCardQuerySet(DB).SerialNumberIn(m.SerialNumbers...).All(&userShareCards)
|
|
if err != nil {
|
|
logger.Error("user share card err:", err)
|
|
return nil, err
|
|
}
|
|
//gameIds := make([]uint64, 0)
|
|
//for i, _ := range user{
|
|
// gameIds = append(gameIds, uint64(userShareCards[i].GameCardId))
|
|
//}
|
|
//// TODO 共享卡半年收回 测试上线修改
|
|
for i, _ := range userShareCards {
|
|
if userShareCards[i].CreatedAt.AddDate(0, 6, 0).After(time.Now()) {
|
|
logger.Error("user share before 6 month")
|
|
return nil, errors.New("before_6_month")
|
|
}
|
|
}
|
|
//var gameCardGoodsStocks []GameCardGoodsStock
|
|
//err = NewGameCardGoodsStockQuerySet(DB).StoreIdEq(uint64(m.StoreId)).GameCardIdIn(gameIds...).All(&gameCardGoodsStocks)
|
|
//if err != nil {
|
|
// logger.Error("game card goods stock err:", err)
|
|
// return err
|
|
//}
|
|
//var gameGoods []GameCardGoods
|
|
//err = NewGameCardGoodsQuerySet(DB).GameCardIdIn(gameIds...).StatusEq(1).OrderAscByID().All(&gameGoods)
|
|
//if err != nil && err != RecordNotFound {
|
|
// logger.Error("game card goods err:", err)
|
|
// return err
|
|
//}
|
|
payState := uint32(1)
|
|
if m.RetrieveCardType == 1 {
|
|
payState = 2
|
|
}
|
|
begin := DB.Begin()
|
|
retrieve := &ShareCardRetrieve{
|
|
Uid: m.Uid,
|
|
RetrieveCardType: m.RetrieveCardType,
|
|
StoreId: m.StoreId,
|
|
State: RetrieveStateInCheck,
|
|
OrderSn: GetShareCardRetrieveOrderSn(),
|
|
PayState: payState,
|
|
AddressId: m.AddressId,
|
|
PayAmount: m.Amount,
|
|
PickupCode: GetShareCardRetrievePickupCode(),
|
|
}
|
|
err = begin.Create(&retrieve).Error
|
|
if err != nil {
|
|
begin.Rollback()
|
|
logger.Error("create share card retrieve err:", err)
|
|
return retrieve, err
|
|
}
|
|
for i, _ := range userShareCards {
|
|
card := &ShareCardRetrieveCard{
|
|
ShareCardRetrieveId: retrieve.ID,
|
|
UserShareCardId: userShareCards[i].ID,
|
|
Uid: m.Uid,
|
|
SerialNumber: userShareCards[i].SerialNumber,
|
|
State: RetrieveStateInCheck,
|
|
BillSn: userShareCards[i].BillSn,
|
|
GameCardId: userShareCards[i].GameCardId,
|
|
TransportType: m.RetrieveCardType,
|
|
//RetrieveCardType: m.RetrieveCardType,
|
|
GameCardGoodsId: userShareCards[i].GameCardGoodsId,
|
|
UserShareCardBillId: userShareCards[i].ShareCardBillGameId,
|
|
StoreId: m.StoreId,
|
|
}
|
|
err = begin.Create(&card).Error
|
|
if err != nil {
|
|
begin.Rollback()
|
|
logger.Error("create share card retrieve card err:", err)
|
|
return retrieve, err
|
|
}
|
|
}
|
|
err = begin.Commit().Error
|
|
if err != nil {
|
|
begin.Rollback()
|
|
logger.Error("commit err:", err)
|
|
return retrieve, err
|
|
}
|
|
return retrieve, nil
|
|
}
|
|
|
|
//func GetUserCardBySerialNumber(serialNumber string, list []GameCardGoods) (*GameCardGoods, bool) {
|
|
// for i, _ := range list {
|
|
// if list[i].SerialNumber == serialNumber {
|
|
// return &list[i], true
|
|
// }
|
|
// }
|
|
// return nil, false
|
|
//}
|
|
|
|
//func SetUserCardSerialNumber(storeId uint32, list []UserShareCard) ([]UserShareCard, error) {
|
|
// for i, _ := range list {
|
|
// var goods GameCardGoods
|
|
// err := NewGameCardGoodsQuerySet(DB).StoreIdEq(uint64(storeId)).SerialNumberEq(list[i].SerialNumber).
|
|
// StatusEq(1).One(&goods)
|
|
// if err != nil && err != RecordNotFound {
|
|
// logger.Error("game card goods err:", err)
|
|
// return list, err
|
|
// }
|
|
// if goods.ID == list[i].GameCardGoodsId {
|
|
// list[i].SerialNumber = goods.SerialNumber
|
|
// list[i].GameCardGoodsIdRetrieve = goods.ID
|
|
// }
|
|
// }
|
|
// return list, nil
|
|
//}
|
|
//
|
|
//func SetRandomCardSerialNumber(storeId uint32, list []UserShareCard) ([]UserShareCard, error) {
|
|
// for i, _ := range list {
|
|
// var goods GameCardGoods
|
|
// err := NewGameCardGoodsQuerySet(DB).StoreIdEq(uint64(storeId)).GameCardIdEq(uint64(list[i].GameCardId)).
|
|
// StatusEq(1).OrderAscByID().Limit(1).One(&goods)
|
|
// if err != nil && err != RecordNotFound {
|
|
// logger.Error("game card goods err:", err)
|
|
// return list, err
|
|
// }
|
|
// list[i].SerialNumber = goods.SerialNumber
|
|
// list[i].GameCardGoodsIdRetrieve = goods.ID
|
|
// }
|
|
// return list, nil
|
|
//}
|
|
|
|
type ShareCardRetrieveListReq struct {
|
|
Uid uint32 `json:"uid"`
|
|
State string `json:"state"`
|
|
Page int `json:"cur_page"`
|
|
PageSize int `json:"page_size"`
|
|
}
|
|
|
|
func (m *ShareCardRetrieveListReq) List() ([]ShareCardRetrieve, int, error) {
|
|
var retrieveCards []ShareCardRetrieve
|
|
qs := NewShareCardRetrieveQuerySet(DB).UidEq(m.Uid).PayStateEq(2)
|
|
if m.State != "" {
|
|
qs = qs.StateEq(m.State)
|
|
}
|
|
page := m.Page - 1
|
|
if page < 0 {
|
|
page = 0
|
|
}
|
|
if m.PageSize == 0 {
|
|
m.PageSize = 10
|
|
}
|
|
|
|
count, err := qs.Count()
|
|
if err != nil {
|
|
logger.Error("user share card bill count err:", err)
|
|
return retrieveCards, 0, err
|
|
}
|
|
totalPage := count/m.PageSize + 1
|
|
err = qs.OrderDescByID().Offset(page * m.PageSize).Limit(m.PageSize).All(&retrieveCards)
|
|
if err != nil && err != RecordNotFound {
|
|
logger.Error("user share card bill err:", err)
|
|
return retrieveCards, 0, err
|
|
}
|
|
if len(retrieveCards) == 0 {
|
|
return retrieveCards, totalPage, nil
|
|
}
|
|
retrieveCards = ShareCardRetrieveListSetGames(retrieveCards)
|
|
return retrieveCards, totalPage, nil
|
|
}
|
|
|
|
func ShareCardRetrieveListSetGames(list []ShareCardRetrieve) []ShareCardRetrieve {
|
|
gameIds := make([]uint32, 0, len(list))
|
|
retrieveIds := make([]uint32, 0, len(list))
|
|
for i, _ := range list {
|
|
//gameIds = append(gameIds, list[i].GameCardId)
|
|
retrieveIds = append(retrieveIds, list[i].ID)
|
|
}
|
|
if len(retrieveIds) == 0 {
|
|
return list
|
|
}
|
|
var cards []ShareCardRetrieveCard
|
|
err := NewShareCardRetrieveCardQuerySet(DB).ShareCardRetrieveIdIn(retrieveIds...).All(&cards)
|
|
if err != nil {
|
|
logger.Error("share card retrieve card err:", err)
|
|
return list
|
|
}
|
|
for i, _ := range cards {
|
|
gameIds = append(gameIds, cards[i].GameCardId)
|
|
}
|
|
if len(gameIds) == 0 {
|
|
logger.Error("game ids err:", err)
|
|
return list
|
|
}
|
|
gameMap, err := GameCardMap(gameIds)
|
|
if err != nil {
|
|
logger.Error("game card map err:", err)
|
|
return list
|
|
}
|
|
for i, _ := range cards {
|
|
v, ok := gameMap[cards[i].GameCardId]
|
|
if ok {
|
|
cards[i].GameCard = v
|
|
}
|
|
}
|
|
|
|
cardsMap := make(map[uint32][]ShareCardRetrieveCard, 0)
|
|
for i, _ := range cards {
|
|
cardsMap[cards[i].ShareCardRetrieveId] = append(
|
|
cardsMap[cards[i].ShareCardRetrieveId], cards[i])
|
|
}
|
|
|
|
//retrieveMap, err := GetShareCardRetrieveMap(retrieveIds)
|
|
//if err != nil {
|
|
// logger.Error("get share card retrieve map err:", err)
|
|
// return list
|
|
//}
|
|
for i, _ := range list {
|
|
v, ok1 := cardsMap[list[i].ID]
|
|
if ok1 {
|
|
list[i].ShareCardRetrieveCards = v
|
|
}
|
|
//retrieve, ok2 := retrieveMap[list[i].ShareCardRetrieveId]
|
|
//if ok2 {
|
|
// list[i].ShareCardRetrieve = retrieve
|
|
//}
|
|
}
|
|
|
|
return list
|
|
}
|
|
|
|
func ShareCardRetrieveCardListSetGame(list []ShareCardRetrieveCard) []ShareCardRetrieveCard {
|
|
gameIds := make([]uint32, 0, len(list))
|
|
retrieveIds := make([]uint32, 0, len(list))
|
|
for i, _ := range list {
|
|
gameIds = append(gameIds, list[i].GameCardId)
|
|
retrieveIds = append(retrieveIds, list[i].ShareCardRetrieveId)
|
|
}
|
|
|
|
cardMap, err := GameCardMap(gameIds)
|
|
if err != nil {
|
|
logger.Error("game card map err:", err)
|
|
return list
|
|
}
|
|
|
|
for i, _ := range list {
|
|
v, ok1 := cardMap[list[i].GameCardId]
|
|
if ok1 {
|
|
list[i].GameCard = v
|
|
}
|
|
}
|
|
|
|
return list
|
|
}
|
|
|
|
func GetShareCardRetrieveMap(ids []uint32) (map[uint32]ShareCardRetrieve, error) {
|
|
retrieveMap := make(map[uint32]ShareCardRetrieve, 0)
|
|
if len(ids) == 0 {
|
|
return retrieveMap, nil
|
|
}
|
|
var retrieves []ShareCardRetrieve
|
|
err := NewShareCardRetrieveQuerySet(DB).IDIn(ids...).All(&retrieves)
|
|
if err != nil {
|
|
logger.Error("share card retrieve err:", err)
|
|
return retrieveMap, err
|
|
}
|
|
for i, _ := range retrieves {
|
|
retrieveMap[retrieves[i].ID] = retrieves[i]
|
|
}
|
|
return retrieveMap, nil
|
|
}
|
|
|
|
func GetShareCardRetrieveInfo(retrieveId uint32) (ShareCardRetrieve, error) {
|
|
var retrieve ShareCardRetrieve
|
|
err := NewShareCardRetrieveQuerySet(DB).IDEq(retrieveId).One(&retrieve)
|
|
if err != nil {
|
|
logger.Error("share card retrieve err:", err)
|
|
return retrieve, err
|
|
}
|
|
var cards []ShareCardRetrieveCard
|
|
err = NewShareCardRetrieveCardQuerySet(DB).ShareCardRetrieveIdEq(retrieveId).All(&cards)
|
|
if err != nil {
|
|
logger.Error("share card retrieve card err:", err)
|
|
return retrieve, err
|
|
}
|
|
|
|
retrieve.ShareCardRetrieveCards = ShareCardRetrieveCardListSetGame(cards)
|
|
err = retrieve.SetStore()
|
|
if err != nil {
|
|
logger.Error("store err:", err)
|
|
return retrieve, err
|
|
}
|
|
|
|
err = retrieve.SetUserAddress()
|
|
if err != nil {
|
|
logger.Error("user address err:", err)
|
|
return retrieve, err
|
|
}
|
|
|
|
return retrieve, nil
|
|
}
|
|
|
|
func (m *ShareCardRetrieve) SetStore() error {
|
|
err := NewStoreQuerySet(DB).IDEq(m.StoreId).One(&m.Store)
|
|
if err != nil && err != RecordNotFound {
|
|
logger.Error("set store err:", err)
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
func (m *ShareCardRetrieve) SetUserAddress() error {
|
|
err := NewUserAddressQuerySet(DB).IDEq(m.AddressId).One(&m.UserAddress)
|
|
if err != nil && err != RecordNotFound {
|
|
logger.Error("set store err:", err)
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func CardIssueFeedbackListSetGame(list []CardIssueFeedback) []CardIssueFeedback {
|
|
ids := make([]uint32, 0, len(list))
|
|
for i, _ := range list {
|
|
ids = append(ids, list[i].GameCardId)
|
|
}
|
|
if len(ids) == 0 {
|
|
return list
|
|
}
|
|
gameMap, err := GameCardMap(ids)
|
|
if err != nil {
|
|
logger.Error("set store err:", err)
|
|
return list
|
|
}
|
|
|
|
for i, _ := range list {
|
|
v, ok := gameMap[list[i].GameCardId]
|
|
if ok {
|
|
list[i].GameCard = &v
|
|
}
|
|
}
|
|
|
|
return list
|
|
}
|
|
|
|
// 用户收回卡
|
|
//// gen:qs
|
|
//type ShareCardRetrieve struct {
|
|
// Model
|
|
// Uid uint32 `json:"uid" gorm:"index"`
|
|
// State string `json:"state" gorm:"index"` // 1-暂无库存 2-待发卡 3-待取卡 4-已发卡 5-已收卡 6-已取消
|
|
// RetrieveCardType uint32 `json:"retrieve_card_type" gorm:"index"` // 1-送卡 2-邮寄
|
|
// StoreId uint32 `json:"store_id" gorm:"index"` // 门店id
|
|
// ExpressCompany string `json:"express_company"` // 物流公司
|
|
// ExpressCompanyNo string `json:"express_company_no"` // 物流公司编号
|
|
// ExpressNo string `json:"express_no"` // 物流单号
|
|
// StockRemovalTime time.Time `json:"stock_removal_time"` // 出库时间
|
|
// StockTime time.Time `json:"stock_time"` // 入库时间
|
|
// Remark string `json:"remark"`
|
|
//
|
|
// Store Store `json:"store" gorm:"-"`
|
|
//}
|
|
//
|
|
//// gen:qs
|
|
//type ShareCardRetrieveCard struct {
|
|
// Model
|
|
// ShareCardRetrieveId uint32 `json:"share_card_retrieve_id" gorm:"index"`
|
|
// UserShareCardId uint32 `json:"user_share_card_id" gorm:"index"` // 用户共享卡收回
|
|
// Uid uint32 `json:"uid" gorm:"index"`
|
|
// SerialNumber string `json:"serial_number" gorm:"index"` // 编号
|
|
// State string `json:"state" gorm:"index"` // 1-暂无库存 2-待发卡 3-待取卡 4-已发卡 5-已收卡 6-已取消
|
|
// BillSn string `json:"bill_sn" gorm:"index"`
|
|
// GameCardId uint32 `json:"game_card_id" gorm:"index"`
|
|
// RetrieveCardType uint32 `json:"retrieve_card_type" gorm:"index"` // 1-送卡 2-邮寄
|
|
// GameCardGoodsId uint32 `json:"game_card_goods_id" gorm:"index"`
|
|
// UserShareCardBillId uint32 `json:"user_share_card_bill_id" gorm:"index"`
|
|
// StoreId uint32 `json:"store_id" gorm:"index"` // 门店id
|
|
// Remark string `json:"remark"`
|
|
// GameCard GameCard `json:"game_card" gorm:"-"`
|
|
// Store Store `json:"store" gorm:"-"`
|
|
//
|
|
// //TotalVm uint32 `json:"total_vm"` // 累计积分
|
|
// //ShareCardBillGameId uint32 `json:"share_card_bill_game_id" gorm:"index"`
|
|
//}
|