1857 lines
56 KiB
Go
1857 lines
56 KiB
Go
package model
|
|
|
|
import (
|
|
"errors"
|
|
"fmt"
|
|
"github.com/codinl/go-logger"
|
|
"github.com/jinzhu/gorm"
|
|
"strings"
|
|
"time"
|
|
)
|
|
|
|
//go:generate goqueryset -in game_card.go
|
|
// gen:qs
|
|
type GameCard struct {
|
|
Model
|
|
|
|
Name string `json:"name" gorm:"index"` // 名称
|
|
Price uint32 `json:"price" gorm:"index"` // 价格
|
|
CoverImg string `json:"cover_img"` // 封面
|
|
OrderCount uint32 `json:"order_count" gorm:"index"` // 订单数
|
|
NewProducts uint8 `json:"new_products"` // 新品: 1-新品 2-非新品
|
|
Status uint8 `json:"status"` // 状态: 1-上架 2-下架
|
|
StockCount uint32 `json:"stock_count"` // 库存
|
|
StockState uint32 `json:"stock_state" gorm:"-"` // 1-库存 2-门店库存 3-无库存
|
|
TotalCount uint32 `json:"total_count"` // 总量
|
|
GameTypeId uint32 `json:"game_type_id"` // 游戏类型
|
|
GoodsGalleryUrl string `json:"goods_gallery_url" gorm:"type:text;comment:'轮播图'"` // 轮播图
|
|
ViewCount uint32 `json:"view_count"` // 查看人数
|
|
Playability uint32 `json:"playability"` // 耐玩度
|
|
Playfulness uint32 `json:"playfulness"` // 好玩度
|
|
GameTime uint32 `json:"game_time"` // 游戏时间
|
|
Likes uint32 `json:"likes"` // 点赞
|
|
DetailInfo string `json:"detail_info" gorm:"type:text;comment:'详情描述'"` // 详情描述
|
|
DetailImg string `json:"detail_img"` // 详情图片
|
|
EstimateVm uint32 `json:"estimate_vm" gorm:"-"` // 预计积分
|
|
RealPrice uint32 `json:"real_price"` // 真实价格
|
|
CooperativeBusinessId uint32 `json:"cooperative_business_id" gorm:"index"` // 合作商id
|
|
CooperativeName string `json:"cooperative_name"` // 合作商名称
|
|
VideoLink string `json:"video_link"` // 链接
|
|
}
|
|
|
|
func (*GameCard) TableName() string {
|
|
return "game_card"
|
|
}
|
|
|
|
// gen:qs
|
|
type GameCardLabel struct {
|
|
Model
|
|
|
|
GameCardId uint32 `json:"game_card_id" gorm:"index"`
|
|
GameLabel string `json:"game_label" gorm:"index"`
|
|
}
|
|
|
|
func (*GameCardLabel) TableName() string {
|
|
return "game_card_label"
|
|
}
|
|
|
|
// gen:qs
|
|
type HomeCarousel struct {
|
|
Model
|
|
|
|
Name string `json:"name" gorm:"index"` // 名称
|
|
Img string `json:"img"` // 图片
|
|
Sort uint32 `json:"sort" gorm:"index"`
|
|
IsShow uint32 `json:"is_show"` // 1-显示 2-隐藏
|
|
Detail string `json:"detail" gorm:"type:text;comment:'详情描述'"`
|
|
Link string `json:"link"`
|
|
ActivityType uint32 `json:"activity_type"` // 活动类型:1-会员续费
|
|
}
|
|
|
|
func (*HomeCarousel) TableName() string {
|
|
return "home_carousel"
|
|
}
|
|
|
|
type CardInfo struct {
|
|
GameCardId uint32 `json:"game_card_id"`
|
|
Count uint32 `json:"count"`
|
|
}
|
|
|
|
func (m *User) IsMember() bool {
|
|
if m.MemberLevel == 2 || m.MemberLevel == 4 || m.MemberLevel == 5 {
|
|
return true
|
|
}
|
|
return false
|
|
}
|
|
|
|
//var GameCardListUpdateTime = time.Time{}
|
|
|
|
func GetGameCardList(sortType, page, pageSize int, gameTypeIds []uint64, storeId, uid uint32) ([]GameCard, uint32, error) {
|
|
var (
|
|
cards []GameCard = make([]GameCard, 0)
|
|
totalPage uint32
|
|
count int
|
|
err error
|
|
)
|
|
page = page - 1
|
|
if page < 0 {
|
|
page = 0
|
|
//return cards, 0, errors.New("page is err")
|
|
}
|
|
if pageSize == 0 {
|
|
pageSize = 10
|
|
}
|
|
//count, err := NewGameCardQuerySet(DB).Count()
|
|
//if err != nil {
|
|
// logger.Error("NewGameCardQuerySet err:", err)
|
|
// return cards, 0, err
|
|
//}
|
|
|
|
qs := NewGameCardQuerySet(DB).IDNe(914)
|
|
switch sortType {
|
|
case 1:
|
|
// 排序类型 1-默认
|
|
//qs = qs.OrderDescByCreatedAt()
|
|
//qs = qs.OrderAscByStockState()
|
|
qs = qs.OrderAscByID()
|
|
case 2:
|
|
// 排序类型 2-新品
|
|
qs = qs.NewProductsEq(1).OrderDescByID()
|
|
//count, err = NewGameCardQuerySet(DB).NewProductsEq(1).Count()
|
|
case 3:
|
|
// 排序类型 3-销量
|
|
qs = qs.OrderDescByOrderCount()
|
|
case 4:
|
|
// 排序类型 4-价格 大到小
|
|
qs = qs.OrderDescByPrice()
|
|
case 5:
|
|
// 排序类型 5-价格 小到大
|
|
qs = qs.OrderAscByPrice()
|
|
}
|
|
qs = qs.StatusEq(1)
|
|
if len(gameTypeIds) > 0 {
|
|
gameIdByType, err := GetGameIdByType(gameTypeIds)
|
|
if err != nil {
|
|
logger.Error("GetGameIdByType err:", err)
|
|
return cards, 0, err
|
|
}
|
|
if len(gameIdByType) != 0 {
|
|
//qs = qs.GameTypeIdIn(gameIdByType...)
|
|
qs = qs.IDIn(gameIdByType...)
|
|
} else {
|
|
return cards, 0, err
|
|
}
|
|
}
|
|
|
|
hideGamePrice := uint32(30000)
|
|
var user *User
|
|
if uid != 0 {
|
|
user = GetUserByUid(uid)
|
|
if user == nil {
|
|
logger.Error("get user err:", err)
|
|
return cards, 0, err
|
|
}
|
|
if user.MemberExpire.After(time.Now()) &&
|
|
user.MemberExpire.AddDate(0, 0, -14).Before(time.Now()) {
|
|
qs = qs.RealPriceLte(hideGamePrice)
|
|
}
|
|
}
|
|
gameIds := make([]uint32, 0)
|
|
gameIdMap := make(map[uint32]uint32)
|
|
|
|
if sortType == 1 {
|
|
if storeId != 0 {
|
|
//gameIds := make([]uint32, 0)
|
|
////gameIdMap := make(map[uint32]int)
|
|
//var cardStocks []GameCardGoodsStock
|
|
//err := NewGameCardGoodsStockQuerySet(DB).StoreIdEq(uint64(storeId)).RentStockGt(0).OrderDescByRentStock().All(&cardStocks)
|
|
//if err != nil {
|
|
// logger.Error("GetGameIdByType err:", err)
|
|
// return cards, 0, err
|
|
//}
|
|
//for i, _ := range cardStocks {
|
|
// gameIds = append(gameIds, uint32(cardStocks[i].GameCardId))
|
|
//}
|
|
//if len(gameIds) <= 0 {
|
|
// return cards, 0, nil
|
|
//}
|
|
//qs = qs.IDIn(gameIds...)
|
|
|
|
var cardStocks []GameCardGoodsStock
|
|
//err := NewGameCardGoodsStockQuerySet(DB).StoreIdEq(uint64(storeId)).RentStockGt(0).
|
|
// OrderDescByRentStock().All(&cardStocks)
|
|
//DB.Table("game_card_goods_stock").Joins("")
|
|
cardStockSql1 := fmt.Sprintf("SELECT a.* FROM game_card_goods_stock a LEFT JOIN game_card b ON a.game_card_id=b.id WHERE a.store_id=%d AND a.rent_stock>0 ORDER BY b.id ASC;", storeId)
|
|
err = DB.Raw(cardStockSql1).Scan(&cardStocks).Error
|
|
if err != nil {
|
|
logger.Error("GetGameIdByType err:", err)
|
|
return cards, 0, err
|
|
}
|
|
for i, _ := range cardStocks {
|
|
_, ok := gameIdMap[uint32(cardStocks[i].GameCardId)]
|
|
if !ok {
|
|
gameIds = append(gameIds, uint32(cardStocks[i].GameCardId))
|
|
gameIdMap[uint32(cardStocks[i].GameCardId)] = 1
|
|
}
|
|
}
|
|
|
|
cardStocks = []GameCardGoodsStock{}
|
|
//err = NewGameCardGoodsStockQuerySet(DB).StoreIdNe(uint64(storeId)).RentStockGt(0).
|
|
// OrderDescByRentStock().All(&cardStocks)
|
|
cardStockSql2 := fmt.Sprintf("SELECT a.* FROM game_card_goods_stock a LEFT JOIN game_card b ON a.game_card_id=b.id WHERE a.store_id!=%d AND a.rent_stock>0 ORDER BY b.id ASC;", storeId)
|
|
err = DB.Raw(cardStockSql2).Scan(&cardStocks).Error
|
|
if err != nil {
|
|
logger.Error("GetGameIdByType err:", err)
|
|
return cards, 0, err
|
|
}
|
|
for i, _ := range cardStocks {
|
|
_, ok := gameIdMap[uint32(cardStocks[i].GameCardId)]
|
|
if !ok {
|
|
gameIds = append(gameIds, uint32(cardStocks[i].GameCardId))
|
|
gameIdMap[uint32(cardStocks[i].GameCardId)] = 2
|
|
}
|
|
}
|
|
|
|
cardStocks = []GameCardGoodsStock{}
|
|
//err = NewGameCardGoodsStockQuerySet(DB).RentStockEq(0).All(&cardStocks)
|
|
cardStockSql3 := fmt.Sprintf("SELECT a.* FROM game_card_goods_stock a LEFT JOIN game_card b ON a.game_card_id=b.id WHERE a.rent_stock=0 ORDER BY b.id ASC;")
|
|
err = DB.Raw(cardStockSql3).Scan(&cardStocks).Error
|
|
if err != nil {
|
|
logger.Error("GetGameIdByType err:", err)
|
|
return cards, 0, err
|
|
}
|
|
for i, _ := range cardStocks {
|
|
_, ok := gameIdMap[uint32(cardStocks[i].GameCardId)]
|
|
if !ok {
|
|
gameIds = append(gameIds, uint32(cardStocks[i].GameCardId))
|
|
gameIdMap[uint32(cardStocks[i].GameCardId)] = 3
|
|
}
|
|
}
|
|
|
|
if len(gameIds) > 0 {
|
|
qs = qs.IDIn(gameIds...)
|
|
}
|
|
} else {
|
|
var cardStocks []GameCardGoodsStock
|
|
//err := NewGameCardGoodsStockQuerySet(DB).RentStockGt(0).
|
|
// OrderDescByRentStock().All(&cardStocks)
|
|
cardStockSql1 := fmt.Sprintf("SELECT a.* FROM game_card_goods_stock a LEFT JOIN game_card b ON a.game_card_id=b.id WHERE a.rent_stock>0 ORDER BY b.id ASC;")
|
|
err = DB.Raw(cardStockSql1).Scan(&cardStocks).Error
|
|
if err != nil {
|
|
logger.Error("GetGameIdByType err:", err)
|
|
return cards, 0, err
|
|
}
|
|
for i, _ := range cardStocks {
|
|
_, ok := gameIdMap[uint32(cardStocks[i].GameCardId)]
|
|
if !ok {
|
|
gameIds = append(gameIds, uint32(cardStocks[i].GameCardId))
|
|
gameIdMap[uint32(cardStocks[i].GameCardId)] = 1
|
|
}
|
|
}
|
|
|
|
cardStocks = []GameCardGoodsStock{}
|
|
//err = NewGameCardGoodsStockQuerySet(DB).RentStockEq(0).All(&cardStocks)
|
|
cardStockSql2 := fmt.Sprintf("SELECT a.* FROM game_card_goods_stock a LEFT JOIN game_card b ON a.game_card_id=b.id WHERE a.rent_stock=0 ORDER BY b.id ASC;")
|
|
err = DB.Raw(cardStockSql2).Scan(&cardStocks).Error
|
|
if err != nil {
|
|
logger.Error("GetGameIdByType err:", err)
|
|
return cards, 0, err
|
|
}
|
|
for i, _ := range cardStocks {
|
|
_, ok := gameIdMap[uint32(cardStocks[i].GameCardId)]
|
|
if !ok {
|
|
gameIds = append(gameIds, uint32(cardStocks[i].GameCardId))
|
|
gameIdMap[uint32(cardStocks[i].GameCardId)] = 3
|
|
}
|
|
}
|
|
if len(gameIds) > 0 {
|
|
qs = qs.IDIn(gameIds...)
|
|
}
|
|
}
|
|
}
|
|
|
|
count, err = qs.Count()
|
|
if err != nil {
|
|
logger.Error("count err:", err)
|
|
}
|
|
totalPage = uint32(count/pageSize + 1)
|
|
if count%pageSize == 0 {
|
|
totalPage = uint32(count / pageSize)
|
|
}
|
|
//err = qs.OrderDescByCreatedAt().Offset(page * pageSize).Limit(pageSize).All(&cards)
|
|
if sortType != 1 {
|
|
err = qs.Offset(page * pageSize).Limit(pageSize).All(&cards)
|
|
if err != nil && err != RecordNotFound {
|
|
logger.Error("err:", err)
|
|
return cards, 0, err
|
|
}
|
|
|
|
GameCardListSetStockState(cards, storeId)
|
|
} else {
|
|
err = qs.OrderDescByID().All(&cards)
|
|
//err = qs.OrderAscByID().All(&cards)
|
|
if err != nil && err != RecordNotFound {
|
|
logger.Error("list err:", err)
|
|
return cards, 0, err
|
|
}
|
|
//fmt.Println("page:", page, totalPage)
|
|
list := make([]GameCard, 0, len(cards))
|
|
cardMap := make(map[uint32]GameCard, 0)
|
|
for i, _ := range cards {
|
|
cardMap[cards[i].ID] = cards[i]
|
|
}
|
|
for i, _ := range gameIds {
|
|
v, ok1 := cardMap[gameIds[i]]
|
|
v2, _ := gameIdMap[gameIds[i]]
|
|
v.StockState = v2
|
|
if ok1 {
|
|
list = append(list, v)
|
|
}
|
|
}
|
|
count = len(list)
|
|
totalPage = uint32(count/pageSize + 1)
|
|
if count%pageSize == 0 {
|
|
totalPage = uint32(count / pageSize)
|
|
}
|
|
|
|
if uint32(page) < totalPage-1 && totalPage != 1 {
|
|
cards = list[page*pageSize : (page+1)*pageSize]
|
|
} else {
|
|
cards = list[page*pageSize:]
|
|
}
|
|
}
|
|
|
|
//cardIds := make([]uint64, 0)
|
|
//for i, _ := range cards {
|
|
// cardIds = append(cardIds, uint64(cards[i].ID))
|
|
//}
|
|
|
|
//var cardStocks []GameCardGoodsStock
|
|
//err = NewGameCardGoodsStockQuerySet(DB).GameCardIdIn(cardIds...).All(&cardStocks)
|
|
//if err != nil {
|
|
// logger.Error("err:", err)
|
|
// return cards, totalPage, nil
|
|
//}
|
|
//cardStockMap := make(map[uint64]uint32, 0)
|
|
//for i, _ := range cardStocks {
|
|
// cardStockMap[cardStocks[i].GameCardId] += cardStocks[i].RentStock
|
|
//}
|
|
|
|
for i, _ := range cards {
|
|
//stock, ok := cardStockMap[uint64(cards[i].ID)]
|
|
//if ok {
|
|
// cards[i].StockCount = stock
|
|
//}
|
|
if user != nil && user.IsMember() {
|
|
cards[i].RealPrice = 0
|
|
}
|
|
}
|
|
return cards, totalPage, nil
|
|
}
|
|
|
|
func IsGameCardOnline(gameCardId uint32) (bool, error) {
|
|
count, err := NewGameCardQuerySet(DB).IDEq(gameCardId).StatusEq(1).Count()
|
|
if err != nil {
|
|
logger.Error("err:", err)
|
|
return false, err
|
|
}
|
|
return count == 1, nil
|
|
}
|
|
|
|
func IsGameCardListOnline(gameCards []CardInfo) (bool, error) {
|
|
for _, v := range gameCards {
|
|
count, err := NewGameCardQuerySet(DB).IDEq(v.GameCardId).StatusEq(1).Count()
|
|
if err != nil {
|
|
logger.Error("err:", err)
|
|
return false, err
|
|
}
|
|
if count < 1 {
|
|
return false, nil
|
|
}
|
|
}
|
|
|
|
return true, nil
|
|
}
|
|
|
|
func IsGameCardHaveStoke(storeId, gameCardId uint32) (bool, error) {
|
|
var stock GameCardGoodsStock
|
|
err := NewGameCardGoodsStockQuerySet(DB).StoreIdEq(uint64(storeId)).GameCardIdEq(uint64(gameCardId)).One(&stock)
|
|
//count, err := NewGameCardQuerySet(DB).IDEq(gameCardId).StatusEq(1).Count()
|
|
if err != nil {
|
|
logger.Error("err:", err)
|
|
return false, err
|
|
}
|
|
// 发货的时候减库存
|
|
return stock.RentStock > 0, nil
|
|
}
|
|
|
|
const (
|
|
GameCardGoodsStatusStock = 1 // 库存中
|
|
GameCardGoodsStatusInWay = 2 // 在途
|
|
GameCardGoodsStatusCustomerHold = 3 // 客户持有
|
|
GameCardGoodsStatusCannibalize = 4 // 调拨
|
|
GameCardGoodsStatusReceivingCard = 5 //
|
|
GameCardGoodsStatusReceivedCard = 6 // 调拨
|
|
GameCardGoodsStatusUnusual = 7 // 异常锁定
|
|
)
|
|
|
|
const (
|
|
GameCardGoodsTypeShare = "user_share" // 用户共享
|
|
GameCardGoodsTypeCommon = "common" // 公共
|
|
)
|
|
|
|
// gen:qs
|
|
type GameCardGoods struct {
|
|
Model
|
|
|
|
GameCardId uint64 `json:"game_card_id"` // 游戏卡id
|
|
SerialNumber string `json:"serial_number" gorm:"index"` // 编号
|
|
Status uint32 `json:"status"` // 状态:1-库存中 2-在途 3-客户持有 4-调拨 5-待收回 6-已收回 7-锁定
|
|
StoreId uint64 `json:"store_id"` // 门店id
|
|
Provider string `json:"provider"` // 供应商
|
|
StockTime time.Time `json:"stock_time"` // 入库时间
|
|
CardType string `json:"card_type" gorm:"index"` // -用户共享 -公共
|
|
FunctionState uint32 `json:"function_state"` // 1-异常 2-正常
|
|
ShareProfitType uint32 `json:"share_profit_type"` // 1-非共享收益卡 2-共享收益卡
|
|
CooperativeBusinessId uint32 `json:"cooperative_business_id" gorm:"index"` // 合作商id
|
|
CooperativeName string `json:"cooperative_name"` // 合作商名称
|
|
|
|
Store *Store `json:"store" gorm:"-"` // 门店
|
|
GameCard *GameCard `json:"game_card" gorm:"-"` // 游戏
|
|
UserShareCardBill *UserShareCardBill `json:"user_share_card_bill" gorm:"-"`
|
|
}
|
|
|
|
func (*GameCardGoods) TableName() string {
|
|
return "game_card_goods"
|
|
}
|
|
|
|
// gen:qs
|
|
type GameCardGoodsStock struct {
|
|
Model
|
|
|
|
StoreId uint64 `json:"store_id"` // 门店id
|
|
GameCardId uint64 `json:"game_card_id"` // 游戏卡id
|
|
StoreStock uint32 `json:"store_stock"` // 门店库存
|
|
RentStock uint32 `json:"rent_stock"` // 租借库存
|
|
UserHoldStock uint32 `json:"user_hold_stock"`
|
|
OrderCount uint32 `json:"order_count"`
|
|
TotalStock uint32 `json:"total_stock"`
|
|
CooperativeBusinessId uint32 `json:"cooperative_business_id" gorm:"index"` // 合作商id
|
|
CooperativeName string `json:"cooperative_name"` // 合作商名称
|
|
|
|
Name string `json:"name" gorm:"-"` // 名称
|
|
CoverImg string `json:"coverImg" gorm:"-"` // 封面
|
|
|
|
}
|
|
|
|
func (*GameCardGoodsStock) TableName() string {
|
|
return "game_card_goods_stock"
|
|
}
|
|
|
|
func GetGameCardInfo(id uint64, storeId uint32) (GameCard, error) {
|
|
game := GameCard{}
|
|
err := NewGameCardQuerySet(DB).IDEq(uint32(id)).One(&game)
|
|
if err != nil && err != RecordNotFound {
|
|
logger.Error("err:", err)
|
|
return game, err
|
|
}
|
|
|
|
var cardStock GameCardGoodsStock
|
|
if storeId != 0 {
|
|
err = NewGameCardGoodsStockQuerySet(DB).GameCardIdEq(uint64(game.ID)).StoreIdEq(uint64(storeId)).One(&cardStock)
|
|
if err != nil && err != RecordNotFound {
|
|
logger.Error("err:", err)
|
|
return game, nil
|
|
}
|
|
if cardStock.RentStock > 0 {
|
|
game.StockState = 1
|
|
return game, nil
|
|
}
|
|
|
|
cardStock = GameCardGoodsStock{}
|
|
err = NewGameCardGoodsStockQuerySet(DB).GameCardIdEq(uint64(game.ID)).
|
|
StoreIdNe(uint64(storeId)).RentStockGt(0).One(&cardStock)
|
|
if err != nil && err != RecordNotFound {
|
|
logger.Error("err:", err)
|
|
return game, nil
|
|
}
|
|
if cardStock.RentStock > 0 {
|
|
game.StockState = 2
|
|
return game, nil
|
|
}
|
|
} else {
|
|
cardStock = GameCardGoodsStock{}
|
|
err = NewGameCardGoodsStockQuerySet(DB).GameCardIdEq(uint64(game.ID)).RentStockGt(0).One(&cardStock)
|
|
if err != nil && err != RecordNotFound {
|
|
logger.Error("err:", err)
|
|
return game, nil
|
|
}
|
|
if cardStock.RentStock > 0 {
|
|
game.StockState = 1
|
|
return game, nil
|
|
}
|
|
}
|
|
|
|
game.StockState = 3
|
|
//cardStock := uint32(0)
|
|
//for i, _ := range cardStocks {
|
|
// cardStock += cardStocks[i].RentStock
|
|
//}
|
|
//game.StockCount = cardStock
|
|
|
|
return game, nil
|
|
}
|
|
|
|
func GetGameCardSearch(name string, page, pageSize int, storeId uint32) ([]GameCard, uint32, error) {
|
|
var (
|
|
cards []GameCard = make([]GameCard, 0)
|
|
totalPage uint32
|
|
cardCount = struct {
|
|
Count uint32 `json:"count"`
|
|
}{}
|
|
)
|
|
page -= 1
|
|
if page < 0 {
|
|
page = 0
|
|
}
|
|
if pageSize <= 0 {
|
|
pageSize = 10
|
|
}
|
|
//sqlStore := ""
|
|
//if storeId != 0 {
|
|
// var gameStocks []GameCardGoodsStock
|
|
// err := NewGameCardGoodsStockQuerySet(DB).StoreIdEq(uint64(storeId)).All(&gameStocks)
|
|
// if err != nil {
|
|
// logger.Error("game card goods stock err:", err)
|
|
// }
|
|
// if len(gameStocks) == 0 {
|
|
// logger.Error("err:", err)
|
|
// return cards, 0, err
|
|
// }
|
|
// gameCardIds := make([]string, 0, len(gameStocks))
|
|
// for i, _ := range gameStocks {
|
|
// gameCardIds = append(gameCardIds, fmt.Sprintf("%d", gameStocks[i].GameCardId))
|
|
// }
|
|
// sqlStore = fmt.Sprintf(" AND id IN (%s) ", strings.Join(gameCardIds, ","))
|
|
//}
|
|
|
|
countSql := "SELECT COUNT(id) AS count FROM game_card WHERE status=1 AND game_card.name LIKE '%" + name + "%'"
|
|
err := DB.Raw(countSql).Scan(&cardCount).Error
|
|
if err != nil {
|
|
logger.Error("err:", err)
|
|
return cards, 0, err
|
|
}
|
|
|
|
sql := "SELECT game_card.* FROM game_card WHERE status=1 AND game_card.name LIKE '%" + name + "%'"
|
|
//sql := "SELECT game_card.* FROM game_card WHERE status=1 AND game_card.name LIKE '%" + name + "%'" + sqlStore +
|
|
// fmt.Sprintf(" LIMIT %d,%d;", page*pageSize, pageSize)
|
|
err = DB.Raw(sql).Scan(&cards).Error
|
|
if err != nil {
|
|
logger.Error("err:", err)
|
|
return cards, 0, err
|
|
}
|
|
|
|
cardMap := make(map[uint32]GameCard, 0)
|
|
cardIds := make([]uint64, 0, len(cards))
|
|
for i, _ := range cards {
|
|
if cards[i].ID == 914 {
|
|
continue
|
|
}
|
|
cardIds = append(cardIds, uint64(cards[i].ID))
|
|
cardMap[cards[i].ID] = cards[i]
|
|
}
|
|
var cardStocks []GameCardGoodsStock
|
|
if len(cardIds) != 0 {
|
|
err = NewGameCardGoodsStockQuerySet(DB).GameCardIdIn(cardIds...).RentStockGt(0).All(&cardStocks)
|
|
if err != nil {
|
|
logger.Error("game card goods stock err:", err)
|
|
return cards, totalPage, nil
|
|
}
|
|
}
|
|
|
|
list := make([]GameCard, 0, len(cards))
|
|
stockMap := make(map[uint64]uint32, 0)
|
|
for i, _ := range cardStocks {
|
|
_, ok := stockMap[cardStocks[i].GameCardId]
|
|
if !ok {
|
|
stockMap[cardStocks[i].GameCardId] = 1
|
|
v2, ok2 := cardMap[uint32(cardStocks[i].GameCardId)]
|
|
v2.StockState = 1
|
|
if ok2 {
|
|
list = append(list, v2)
|
|
}
|
|
}
|
|
}
|
|
|
|
for i, _ := range cardIds {
|
|
_, ok := stockMap[cardIds[i]]
|
|
if !ok {
|
|
stockMap[cardIds[i]] = 3
|
|
v2, ok2 := cardMap[uint32(cardIds[i])]
|
|
v2.StockState = 3
|
|
if ok2 {
|
|
list = append(list, v2)
|
|
}
|
|
}
|
|
}
|
|
totalPage = cardCount.Count/uint32(pageSize) + 1
|
|
if cardCount.Count%uint32(pageSize) == 0 {
|
|
totalPage = cardCount.Count / uint32(pageSize)
|
|
}
|
|
if len(list) != 0 {
|
|
if uint32(page) < totalPage-1 && totalPage != 1 {
|
|
cards = list[page*pageSize : (page+1)*pageSize]
|
|
} else {
|
|
cards = list[page*pageSize:]
|
|
}
|
|
}
|
|
|
|
return cards, totalPage, nil
|
|
}
|
|
|
|
// TODO 订单
|
|
|
|
func GetHomeCarouselList() ([]HomeCarousel, error) {
|
|
carousels := make([]HomeCarousel, 0)
|
|
err := NewHomeCarouselQuerySet(DB).IsShowEq(1).OrderDescBySort().All(&carousels)
|
|
if err != nil && err != RecordNotFound {
|
|
logger.Error("err:", err)
|
|
return carousels, err
|
|
}
|
|
|
|
return carousels, nil
|
|
}
|
|
|
|
// gen:qs
|
|
type GameCardType struct {
|
|
Model
|
|
|
|
Name string `json:"name"` // 游戏类型
|
|
Sort uint32 `json:"sort" gorm:"index"` // 排序
|
|
//GameCount uint32 `json:"game_count"` // 游戏数量
|
|
}
|
|
|
|
func (*GameCardType) TableName() string {
|
|
return "game_card_type"
|
|
}
|
|
|
|
func GetGameCardTypeList() ([]GameCardType, error) {
|
|
gameTypes := make([]GameCardType, 0)
|
|
err := NewGameCardTypeQuerySet(DB).OrderAscBySort().All(&gameTypes)
|
|
if err != nil {
|
|
logger.Errorf("err:%+v", err)
|
|
return gameTypes, err
|
|
}
|
|
return gameTypes, nil
|
|
}
|
|
|
|
// gen:qs
|
|
type GameType struct {
|
|
Model
|
|
|
|
GameCardId uint64 `json:"gameCardId" gorm:"column:game_card_id;index"` // 游戏卡id
|
|
GameCardTypeId uint64 `json:"gameCardTypeId" gorm:"column:game_card_type_id;index"` // 分类id
|
|
}
|
|
|
|
func (*GameType) TableName() string {
|
|
return "game_type"
|
|
}
|
|
|
|
func GetGameIdByType(gameTypeIds []uint64) ([]uint32, error) {
|
|
gameTypes := make([]GameType, 0)
|
|
err := NewGameTypeQuerySet(DB).GameCardTypeIdIn(gameTypeIds...).All(&gameTypes)
|
|
if err != nil && err != RecordNotFound {
|
|
logger.Error("err:", err)
|
|
return nil, err
|
|
}
|
|
|
|
gameIds := make([]uint32, 0)
|
|
if len(gameTypes) == 0 {
|
|
return gameIds, nil
|
|
}
|
|
|
|
for i, _ := range gameTypes {
|
|
gameIds = append(gameIds, uint32(gameTypes[i].GameCardId))
|
|
}
|
|
return gameIds, nil
|
|
}
|
|
|
|
//func (m *GameType) GetGameByType(gameIds []int) ([]GameCard, error) {
|
|
// games := make([]GameCard, 0)
|
|
// gameTypes := make([]GameType,0)
|
|
// err := DB.Table(m.TableName()).Where("id in (?)", ids).Find(&gameTypes).Error
|
|
// if err != nil {
|
|
// logger.Error("err:", err)
|
|
// return games, err
|
|
// }
|
|
// gameCardId := make([]uint32,0)
|
|
// for i, _ := range gameTypes {
|
|
// gameCardId= append(gameCardId, uint32(gameTypes[i].GameCardId))
|
|
// }
|
|
// NewGameCardQuerySet(DB).IDIn(gameCardId...).All()
|
|
// return games, nil
|
|
//}
|
|
|
|
func (m *GameCard) GetGameType() ([]GameCardType, error) {
|
|
gameCardTypes := make([]GameCardType, 0)
|
|
gameTypes := make([]GameType, 0)
|
|
err := NewGameTypeQuerySet(DB).GameCardIdEq(uint64(m.ID)).All(&gameTypes)
|
|
if err != nil {
|
|
logger.Error("err:", err)
|
|
return gameCardTypes, err
|
|
}
|
|
gameCardTypeId := make([]uint32, 0)
|
|
for i, _ := range gameTypes {
|
|
gameCardTypeId = append(gameCardTypeId, uint32(gameTypes[i].GameCardTypeId))
|
|
}
|
|
if len(gameCardTypeId) == 0 {
|
|
return gameCardTypes, nil
|
|
}
|
|
err = NewGameCardTypeQuerySet(DB).IDIn(gameCardTypeId...).All(&gameCardTypes)
|
|
if err != nil {
|
|
logger.Error("err:", err)
|
|
return gameCardTypes, err
|
|
}
|
|
return gameCardTypes, nil
|
|
}
|
|
|
|
type RspAliyunStsToken struct {
|
|
AccessKeyId string `json:"access_key_id"`
|
|
AccessKeySecret string `json:"access_key_secret"`
|
|
SecurityToken string `json:"security_token"`
|
|
BucketName string `json:"bucket_name"`
|
|
Expiration uint64 `json:"expiration"`
|
|
}
|
|
|
|
func GetOrderCardMapSerialNumberUnset(list map[uint32]OrderCard, gameCardId uint32) *OrderCard {
|
|
for _, v := range list {
|
|
if v.GameCardId == gameCardId && v.SerialNumber == "" {
|
|
return &v
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *GameCardGoodsStock) AddUserHoldStock(gdb *gorm.DB) error {
|
|
if m.StoreId == 0 || m.GameCardId == 0 {
|
|
return errors.New("store id or game card id is null")
|
|
}
|
|
if gdb == nil {
|
|
gdb = DB
|
|
}
|
|
sql := fmt.Sprintf("UPDATE game_card_goods_stock SET user_hold_stock= user_hold_stock+1 WHERE store_id=%d AND game_card_id=%d;", m.StoreId, m.GameCardId)
|
|
fmt.Println("sql:", sql)
|
|
err := gdb.Exec(sql).Error
|
|
if err != nil {
|
|
logger.Error("err:", err)
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func GetGameCardGoodsBySerialNumber(serialNumber string) (GameCardGoods, error) {
|
|
var gameGoods GameCardGoods
|
|
err := NewGameCardGoodsQuerySet(DB).SerialNumberEq(serialNumber).One(&gameGoods)
|
|
if err != nil {
|
|
logger.Error("gameGoods err:", err)
|
|
return gameGoods, err
|
|
}
|
|
return gameGoods, nil
|
|
}
|
|
|
|
func (m *GameCardGoodsStock) Add(begin *gorm.DB) error {
|
|
if begin == nil {
|
|
begin = DB
|
|
}
|
|
//err := orm.Eloquent.Table("game_card_goods_stock").Where("store_id", m.StoreId).
|
|
// Where("game_card_id", m.GameCardId).Count(&count).Error
|
|
|
|
recordExist, err := QueryRecordExist(fmt.Sprintf(
|
|
"SELECT * FROM game_card_goods_stock WHERE store_id=%d AND game_card_id=%d",
|
|
m.StoreId, m.GameCardId))
|
|
if err != nil {
|
|
logger.Error("game card goods stock record exist err:", err)
|
|
return err
|
|
}
|
|
if !recordExist {
|
|
m.StoreStock = 1
|
|
m.RentStock = 1
|
|
m.TotalStock = 1
|
|
err := begin.Create(m).Error
|
|
if err != nil {
|
|
logger.Error("create ame card goods stock record err:", err)
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
|
|
sql := fmt.Sprintf(
|
|
"UPDATE game_card_goods_stock SET rent_stock= rent_stock+1,store_stock=store_stock+1,total_stock=total_stock+1 WHERE store_id=%d AND game_card_id=%d;", m.StoreId, m.GameCardId)
|
|
fmt.Println("sql:", sql)
|
|
err = begin.Exec(sql).Error
|
|
if err != nil {
|
|
logger.Errorf("err:%#v", err)
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (*GameCardGoods) Adds(cards []GameCardGoods) error {
|
|
serialNumbers := make([]string, 0, len(cards))
|
|
for i, _ := range cards {
|
|
serialNumbers = append(serialNumbers, cards[i].SerialNumber)
|
|
}
|
|
var goodsList []GameCardGoods
|
|
err := NewGameCardGoodsQuerySet(DB).SerialNumberIn(serialNumbers...).All(&goodsList)
|
|
if err != nil && err != RecordNotFound {
|
|
logger.Error("err:", err)
|
|
return err
|
|
}
|
|
goodsMap := make(map[string]int, 0)
|
|
for i, _ := range goodsList {
|
|
goodsMap[goodsList[i].SerialNumber] = i
|
|
}
|
|
|
|
for i, _ := range cards {
|
|
_, ok := goodsMap[cards[i].SerialNumber]
|
|
if !ok {
|
|
begin := DB.Begin()
|
|
// 入库 公共添加数据
|
|
cards[i].StockTime = time.Now()
|
|
cards[i].FunctionState = 2
|
|
|
|
err = begin.Create(&cards[i]).Error
|
|
if err != nil {
|
|
begin.Rollback()
|
|
logger.Error("err:", err)
|
|
continue
|
|
}
|
|
|
|
stock := GameCardGoodsStock{StoreId: cards[i].StoreId, GameCardId: cards[i].GameCardId}
|
|
err = stock.Add(begin)
|
|
if err != nil {
|
|
begin.Rollback()
|
|
logger.Error("err:", err)
|
|
continue
|
|
}
|
|
if cards[i].CardType == GameCardGoodsTypeShare {
|
|
userShareCard := &UserShareCard{
|
|
Uid: cards[i].UserShareCardBill.Uid,
|
|
SerialNumber: cards[i].SerialNumber,
|
|
BillSn: cards[i].UserShareCardBill.BillSn,
|
|
GameCardId: uint32(cards[i].GameCardId),
|
|
State: ShareCardStateSharing,
|
|
GameCardGoodsId: cards[i].ID,
|
|
UserShareCardBillId: cards[i].UserShareCardBill.ID,
|
|
ShareCardBillGameId: 0,
|
|
StoreId: uint32(cards[i].StoreId),
|
|
ProfitState: 1,
|
|
}
|
|
if cards[i].CardType == GameCardGoodsTypeShare {
|
|
userShareCard.AllotSerialNumber = userShareCard.SerialNumber
|
|
userShareCard.AllotCardGoodsId = userShareCard.GameCardGoodsId
|
|
}
|
|
err = begin.Create(userShareCard).Error
|
|
if err != nil {
|
|
begin.Rollback()
|
|
logger.Error("err:", err)
|
|
return err
|
|
}
|
|
|
|
}
|
|
err := begin.Commit().Error
|
|
if err != nil {
|
|
begin.Rollback()
|
|
logger.Error("err:", err)
|
|
continue
|
|
}
|
|
}
|
|
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type CooperativeRentCardOrderListReq struct {
|
|
AssistantUid uint32 `json:"assistant_uid"`
|
|
Uid uint64 `json:"uid" `
|
|
OrderId uint64 `json:"order_id"`
|
|
GameCardId uint64 `json:"game_card_id"`
|
|
StoreId uint64 `json:"store_id" ` // 门店id 游戏id
|
|
CardStatus uint8 `json:"card_status"` // 1-待取货中 2-游玩中 3-归还中 4-已完成
|
|
PayStatus uint8 `json:"pay_status"` //
|
|
DeliveryType uint8 `json:"delivery_type"` //
|
|
SerialNumber string `json:"serial_number" ` // 编号
|
|
PickupCode string `json:"pickup_code"` // 取货码
|
|
StartTime time.Time `json:"start_time"` // 开始时间
|
|
EndTime time.Time `json:"end_time"` // 结束时间
|
|
PageNum int `json:"page_num"`
|
|
PageSize int `json:"page_size"`
|
|
}
|
|
|
|
func (m *CooperativeRentCardOrderListReq) List() ([]Order, int, error) {
|
|
var orderCards []OrderCard
|
|
orders := make([]Order, 0)
|
|
if m.PageSize == 0 {
|
|
m.PageSize = 10
|
|
}
|
|
assistant := GetUserByUid(m.AssistantUid)
|
|
if m.SerialNumber == "" {
|
|
m.StoreId = assistant.StoreId
|
|
}
|
|
if assistant.UserType != 2 {
|
|
return orders, 0, errors.New("not assistant")
|
|
}
|
|
qs := NewOrderQuerySet(DB).PayStatusEq(2)
|
|
isDeliver := true
|
|
if m.SerialNumber != "" {
|
|
isDeliver = false
|
|
err := NewOrderCardQuerySet(DB).SerialNumberEq(m.SerialNumber).OrderDescByID().OrderAscByCardStatus().All(&orderCards)
|
|
if err != nil {
|
|
logger.Error("err:", err)
|
|
return orders, 0, err
|
|
}
|
|
orderIds := make([]uint32, 0)
|
|
for i, _ := range orderCards {
|
|
orderIds = append(orderIds, orderCards[i].OrderId)
|
|
}
|
|
qs = qs.IDIn(orderIds...)
|
|
//qs = qs.Where("id in (?)", orderIds)
|
|
}
|
|
if m.PickupCode != "" {
|
|
isDeliver = false
|
|
//qs = qs.Where("pickup_code", m.PickupCode)
|
|
qs = qs.PickupCodeEq(m.PickupCode)
|
|
}
|
|
if m.PayStatus != 0 {
|
|
//qs = qs.Where("pay_status", m.PayStatus)
|
|
qs = qs.PayStatusEq(m.PayStatus)
|
|
}
|
|
if m.DeliveryType != 0 {
|
|
//qs = qs.Where("delivery_type", m.DeliveryType)
|
|
qs = qs.DeliveryTypeEq(m.DeliveryType)
|
|
}
|
|
if m.OrderId != 0 {
|
|
isDeliver = false
|
|
//qs = qs.Where("id", m.OrderId)
|
|
qs = qs.IDEq(uint32(m.OrderId))
|
|
}
|
|
if isDeliver {
|
|
}
|
|
if m.Uid != 0 {
|
|
qs = qs.UidEq(m.Uid)
|
|
}
|
|
if m.GameCardId != 0 {
|
|
qs = qs.GameCardIdEq(m.GameCardId)
|
|
}
|
|
if m.CardStatus != 0 {
|
|
qs = qs.CardStatusEq(m.CardStatus)
|
|
}
|
|
if !m.StartTime.IsZero() {
|
|
qs = qs.CreatedAtGte(m.StartTime)
|
|
}
|
|
if !m.EndTime.IsZero() {
|
|
qs = qs.CreatedAtLte(m.EndTime)
|
|
}
|
|
if m.StoreId != 0 {
|
|
qs = qs.StoreIdEq(m.StoreId)
|
|
}
|
|
count, err := qs.Count()
|
|
if err != nil {
|
|
logger.Errorf("err:%#v", err)
|
|
return orders, 0, err
|
|
}
|
|
|
|
pageSize := m.PageSize
|
|
page := m.PageNum - 1
|
|
if page < 0 {
|
|
page = 0
|
|
}
|
|
if m.PageSize == 0 {
|
|
m.PageSize = 10
|
|
}
|
|
err = qs.OrderDescByID().Offset(page * pageSize).Limit(m.PageSize).All(&orders)
|
|
if err != nil {
|
|
logger.Errorf("err:%#v", err)
|
|
return orders, 0, err
|
|
}
|
|
|
|
ids := make([]uint32, 0, len(orders))
|
|
for i, _ := range orders {
|
|
ids = append(ids, uint32(orders[i].ID))
|
|
}
|
|
if len(ids) == 0 {
|
|
logger.Error("gameIds is nil")
|
|
return orders, 0, err
|
|
}
|
|
|
|
err = NewOrderCardQuerySet(DB).OrderIdIn(ids...).All(&orderCards)
|
|
if err != nil {
|
|
logger.Error("err:", err)
|
|
return orders, 0, err
|
|
}
|
|
orderCards = OrderCardListSetGameInfo(orderCards)
|
|
orderCardsMap := make(map[uint32][]OrderCard, 0)
|
|
for i, _ := range orderCards {
|
|
orderCardsMap[orderCards[i].OrderId] = append(orderCardsMap[orderCards[i].OrderId], orderCards[i])
|
|
}
|
|
for i, _ := range orders {
|
|
if orders[i].CardStatus == 2 || orders[i].CardStatus == 3 {
|
|
orders[i].CardStatus = 4
|
|
}
|
|
v, ok := orderCardsMap[orders[i].ID]
|
|
if ok {
|
|
orders[i].OrderCards = v
|
|
}
|
|
}
|
|
|
|
return orders, count, nil
|
|
}
|
|
|
|
type GameCardGoodsStockAnalysisReq struct {
|
|
Name string `json:"name"`
|
|
SortType uint32 `json:"sort_type"` // 1-总库存 2-库存 3-用户持有 4-订单数量
|
|
SortDirection uint32 `json:"sort_direction"` // 1-升序 2-降序
|
|
CooperativeBusinessId uint32 `json:"cooperative_business_id"` // 合作商id
|
|
StoreId uint32 `json:"store_id"`
|
|
PageNum int `json:"page_num"`
|
|
PageSize int `json:"page_size"`
|
|
}
|
|
type GameCardGoodsStockAnalysisResp struct {
|
|
List []GameCardGoodsStock `json:"list"`
|
|
Count uint32 `json:"count"`
|
|
PageIndex int `json:"page_index"`
|
|
|
|
CardTotalCount int `json:"card_total_count"`
|
|
CardTotalStock int `json:"card_total_stock"`
|
|
CardHoldCount int `json:"card_hold_count"`
|
|
}
|
|
|
|
func (m *GameCardGoodsStockAnalysisReq) GameCardStockListAnalysis() (*GameCardGoodsStockAnalysisResp, error) {
|
|
resp := &GameCardGoodsStockAnalysisResp{PageIndex: m.PageNum}
|
|
type GameCardCount struct {
|
|
CountGame uint32 `json:"count_game"`
|
|
}
|
|
var gameCardCount GameCardCount
|
|
var goodsStocks []GameCardGoodsStock
|
|
sqlOrder := ""
|
|
switch m.SortType {
|
|
case 1:
|
|
sqlOrder = fmt.Sprintf(" ORDER BY total_stock ")
|
|
case 2:
|
|
sqlOrder = fmt.Sprintf(" ORDER BY rent_stock ")
|
|
case 3:
|
|
sqlOrder = fmt.Sprintf(" ORDER BY user_hold_stock ")
|
|
case 4:
|
|
sqlOrder = fmt.Sprintf(" ORDER BY order_count ")
|
|
}
|
|
|
|
if m.SortDirection == 1 {
|
|
sqlOrder += " DESC"
|
|
} else if m.SortDirection == 2 {
|
|
sqlOrder += " ASC"
|
|
}
|
|
sqlStore := fmt.Sprintf(" AND cooperative_business_id = %d", m.CooperativeBusinessId)
|
|
if m.StoreId != 0 {
|
|
sqlStore = fmt.Sprintf(" AND store_id = %d", m.StoreId)
|
|
}
|
|
if m.Name != "" {
|
|
var gameCards []GameCard
|
|
sqlName := "SELECT * FROM game_card WHERE `name` LIKE '%" + m.Name + "%';"
|
|
err := DB.Raw(sqlName).Scan(&gameCards).Error
|
|
//err := orm.Eloquent.Exec(sqlName).Find(&gameCards).Error
|
|
if err != nil {
|
|
return resp, err
|
|
}
|
|
//fmt.Println("--sqlName:", sqlName)
|
|
gameIds := make([]string, 0)
|
|
for i, _ := range gameCards {
|
|
gameIds = append(gameIds, fmt.Sprintf("%d", gameCards[i].ID))
|
|
}
|
|
|
|
//fmt.Println("--gameIds:", gameIds)
|
|
sqlStore += fmt.Sprintf(" AND game_card_id IN (%s) ", strings.Join(gameIds, ","))
|
|
}
|
|
|
|
//var countGame int64
|
|
sqlCount := fmt.Sprintf("SELECT COUNT(*) AS count_game FROM (SELECT SUM(total_stock) AS total_stock,SUM(order_count) AS order_count,SUM(user_hold_stock) AS user_hold_stock,SUM(rent_stock) AS rent_stock FROM game_card_goods_stock WHERE 1 %s GROUP BY game_card_id) a ;", sqlStore)
|
|
fmt.Println("sqlCount:", sqlCount)
|
|
err := DB.Raw(sqlCount).Scan(&gameCardCount).Error
|
|
if err != nil {
|
|
logger.Info("sqlCount:", sqlCount)
|
|
logger.Error("sqlCount err:", err)
|
|
return resp, err
|
|
}
|
|
fmt.Println("countGame:", gameCardCount.CountGame)
|
|
resp.Count = gameCardCount.CountGame
|
|
page := int(m.PageNum) - 1
|
|
if page < 0 {
|
|
page = 0
|
|
}
|
|
if m.PageSize == 0 {
|
|
m.PageSize = 10
|
|
}
|
|
|
|
sql := fmt.Sprintf(
|
|
"SELECT * FROM (SELECT SUM(total_stock) AS total_stock,SUM(order_count) AS order_count,SUM(user_hold_stock) AS user_hold_stock,SUM(rent_stock) AS rent_stock,game_card_id FROM game_card_goods_stock WHERE 1 %s GROUP BY game_card_id) a %s LIMIT %d,%d;",
|
|
sqlStore, sqlOrder, page*m.PageSize, m.PageSize)
|
|
fmt.Println("sql:", sql)
|
|
err = DB.Raw(sql).Scan(&goodsStocks).Error
|
|
if err != nil {
|
|
logger.Error("err:", err)
|
|
return resp, err
|
|
}
|
|
|
|
if len(goodsStocks) == 0 {
|
|
return resp, nil
|
|
}
|
|
|
|
gameIds := make([]uint32, 0, len(goodsStocks))
|
|
for i, _ := range goodsStocks {
|
|
gameIds = append(gameIds, uint32(goodsStocks[i].GameCardId))
|
|
}
|
|
fmt.Println("gameIds:", gameIds)
|
|
var games []GameCard
|
|
err = NewGameCardQuerySet(DB).IDIn(gameIds...).All(&games)
|
|
//err = orm.Eloquent.Table("game_card").Where("id IN (?)", gameIds).Find(&games).Error
|
|
if err != nil {
|
|
logger.Error("err:", err)
|
|
return resp, err
|
|
}
|
|
gameMap := make(map[uint32]GameCard, 0)
|
|
for i, _ := range games {
|
|
gameMap[games[i].ID] = games[i]
|
|
}
|
|
fmt.Println("games:", games)
|
|
for i, _ := range goodsStocks {
|
|
game, ok := gameMap[uint32(goodsStocks[i].GameCardId)]
|
|
if ok {
|
|
goodsStocks[i].Name = game.Name
|
|
goodsStocks[i].CoverImg = game.CoverImg
|
|
}
|
|
}
|
|
resp.List = goodsStocks
|
|
|
|
holdQs := NewGameCardGoodsQuerySet(DB).StatusEq(GameCardGoodsStatusCustomerHold)
|
|
//holdQs := orm.Eloquent.Table("game_card_goods").Where("status", GameCardGoodsStatusCustomerHold)
|
|
if m.StoreId != 0 {
|
|
holdQs = holdQs.StoreIdEq(uint64(m.StoreId))
|
|
}
|
|
cardHoldCount, err := holdQs.Count()
|
|
if err != nil {
|
|
logger.Error("hold count err:", err)
|
|
return resp, err
|
|
}
|
|
resp.CardHoldCount = int(cardHoldCount)
|
|
|
|
var (
|
|
rentStock uint32
|
|
totalCount int
|
|
cardStocks []GameCardGoodsStock
|
|
)
|
|
|
|
if m.StoreId != 0 {
|
|
err = NewGameCardGoodsStockQuerySet(DB).StoreIdEq(uint64(m.StoreId)).All(&cardStocks)
|
|
} else {
|
|
err = NewGameCardGoodsStockQuerySet(DB).All(&cardStocks)
|
|
}
|
|
if err != nil {
|
|
logger.Error("err:", err)
|
|
return resp, err
|
|
}
|
|
for i, _ := range cardStocks {
|
|
rentStock += cardStocks[i].RentStock
|
|
}
|
|
//var game GameCardGoods
|
|
if m.StoreId != 0 {
|
|
totalCount, err = NewGameCardGoodsQuerySet(DB).StoreIdEq(uint64(m.StoreId)).StatusIn([]uint32{1, 2, 3, 4}...).Count()
|
|
} else {
|
|
totalCount, err = NewGameCardGoodsQuerySet(DB).StatusIn([]uint32{1, 2, 3, 4}...).Count()
|
|
}
|
|
if err != nil {
|
|
logger.Error("total count err:", err)
|
|
return resp, err
|
|
}
|
|
|
|
resp.CardTotalStock = int(rentStock)
|
|
resp.CardTotalCount = int(totalCount)
|
|
|
|
return resp, nil
|
|
}
|
|
|
|
func CannibalizeTaskImportGoods(taskId uint32, serials []string) (uint32, error) {
|
|
if taskId == 0 || len(serials) == 0 {
|
|
return 0, errors.New("para err")
|
|
}
|
|
var cannibalizeTask CannibalizeStockTask
|
|
err := NewCannibalizeStockTaskQuerySet(DB).IDEq(taskId).One(&cannibalizeTask)
|
|
//err := orm.Eloquent.Table("cannibalize_stock_task").Where("id = ?", taskId).Find(&cannibalizeTask).Error
|
|
if err != nil {
|
|
logger.Error("cannibalize task err:", err)
|
|
return 0, err
|
|
}
|
|
if cannibalizeTask.Status != CannibalizeTaskStatusNotImportGoods &&
|
|
cannibalizeTask.Status != CannibalizeTaskStatusNotDeliverGoods {
|
|
logger.Error("cannibalize status err:", err)
|
|
return 0, err
|
|
}
|
|
|
|
var cannibalizeGoodses []CannibalizeGameCardGoods
|
|
err = NewCannibalizeGameCardGoodsQuerySet(DB).CannibalizeStockTaskIdEq(taskId).All(&cannibalizeGoodses)
|
|
if err != nil && err != RecordNotFound {
|
|
logger.Error("cannibalize goods err:", err)
|
|
return 0, err
|
|
}
|
|
impotentSerialMap := make(map[string]uint32, 0)
|
|
if len(cannibalizeGoodses) > 0 {
|
|
for i, _ := range cannibalizeGoodses {
|
|
impotentSerialMap[cannibalizeGoodses[i].SerialNumber] = cannibalizeGoodses[i].GameCardId
|
|
}
|
|
}
|
|
|
|
serialNumberSql := ""
|
|
for i, _ := range serials {
|
|
serialNumberSql += "'" + serials[i] + "',"
|
|
}
|
|
serialNumberSql = serialNumberSql[:len(serialNumberSql)-1]
|
|
// 这些卡已在调拨任务中
|
|
var cannibalizeInGoodses []CannibalizeGameCardGoods
|
|
sql := fmt.Sprintf(
|
|
"SELECT cannibalize_game_card_goods.* FROM cannibalize_game_card_goods LEFT JOIN cannibalize_stock_task ON cannibalize_stock_task.id = cannibalize_game_card_goods.cannibalize_stock_task_id WHERE serial_number IN (%s) AND cannibalize_stock_task.status IN (1,2,3) ;",
|
|
serialNumberSql)
|
|
err = DB.Raw(sql).Scan(&cannibalizeInGoodses).Error
|
|
if err != nil {
|
|
logger.Error("cannibalize in goods err:", err)
|
|
return 0, err
|
|
}
|
|
cannibalizeInGoodsMap := make(map[string]uint32, 0)
|
|
if len(cannibalizeInGoodses) > 0 {
|
|
for i, _ := range cannibalizeInGoodses {
|
|
cannibalizeInGoodsMap[cannibalizeInGoodses[i].SerialNumber] = cannibalizeInGoodses[i].GameCardId
|
|
}
|
|
}
|
|
|
|
list := make([]GameCardGoods, 0)
|
|
err = DB.Table("game_card_goods").Where("serial_number in (?)", serials).Find(&list).Error
|
|
if err != nil {
|
|
logger.Error("err:", err)
|
|
return 0, err
|
|
}
|
|
unImpotentCount := 0
|
|
impotentCount := 0
|
|
begin := DB.Begin()
|
|
for i, _ := range list {
|
|
if list[i].Status != 1 {
|
|
unImpotentCount++
|
|
//fmt.Println("1", list[i].Status)
|
|
continue
|
|
}
|
|
_, ok := impotentSerialMap[list[i].SerialNumber]
|
|
if ok {
|
|
unImpotentCount++
|
|
//fmt.Println("2", list[i].SerialNumber)
|
|
continue
|
|
}
|
|
if uint32(list[i].StoreId) != cannibalizeTask.FromStoreId {
|
|
//fmt.Println("3", list[i].StoreId)
|
|
continue
|
|
}
|
|
_, ok2 := cannibalizeInGoodsMap[list[i].SerialNumber]
|
|
if ok2 {
|
|
unImpotentCount++
|
|
//fmt.Println("4", list[i].SerialNumber)
|
|
continue
|
|
}
|
|
|
|
cardGoods := &CannibalizeGameCardGoods{
|
|
CannibalizeStockTaskId: taskId,
|
|
GameCardId: uint32(list[i].GameCardId),
|
|
SerialNumber: list[i].SerialNumber,
|
|
}
|
|
err := begin.Create(cardGoods).Error
|
|
if err != nil {
|
|
begin.Rollback()
|
|
logger.Error("err:", err)
|
|
unImpotentCount++
|
|
continue
|
|
}
|
|
impotentCount++
|
|
}
|
|
|
|
if cannibalizeTask.Status == CannibalizeTaskStatusNotImportGoods && impotentCount > 0 {
|
|
sql := fmt.Sprintf("UPDATE cannibalize_stock_task SET status = 2 WHERE id = %d", taskId)
|
|
err = begin.Exec(sql).Error
|
|
if err != nil {
|
|
begin.Rollback()
|
|
logger.Errorf("update status err:%s", err.Error())
|
|
}
|
|
}
|
|
err = begin.Commit().Error
|
|
if err != nil {
|
|
begin.Rollback()
|
|
logger.Error("commit err:", err)
|
|
}
|
|
|
|
return uint32(unImpotentCount), nil
|
|
}
|
|
|
|
func CannibalizeDeliverGoods(taskId uint32) error {
|
|
var cannibalizeTask CannibalizeStockTask
|
|
err := NewCannibalizeStockTaskQuerySet(DB).IDEq(taskId).One(&cannibalizeTask)
|
|
//err := orm.Eloquent.Table("cannibalize_stock_task").Where("id = ?", taskId).Find(&cannibalizeTask).Error
|
|
if err != nil {
|
|
logger.Error("cannibalize task err:", err)
|
|
return err
|
|
}
|
|
if cannibalizeTask.Status != CannibalizeTaskStatusNotDeliverGoods {
|
|
return errors.New("cannibalize task status err")
|
|
}
|
|
var cannibalizeGoodses []CannibalizeGameCardGoods
|
|
err = NewCannibalizeGameCardGoodsQuerySet(DB).CannibalizeStockTaskIdEq(taskId).All(&cannibalizeGoodses)
|
|
//err = orm.Eloquent.Table("cannibalize_game_card_goods").Where("cannibalize_stock_task_id = ?", taskId).Find(&cannibalizeGoodses).Error
|
|
if err != nil && err != RecordNotFound {
|
|
logger.Error("cannibalize goods err:", err)
|
|
return err
|
|
}
|
|
serials := make([]string, 0, len(cannibalizeGoodses))
|
|
serialMap := make(map[string]int, 0)
|
|
for i, _ := range cannibalizeGoodses {
|
|
serials = append(serials, cannibalizeGoodses[i].SerialNumber)
|
|
serialMap[cannibalizeGoodses[i].SerialNumber] = i
|
|
}
|
|
list := make([]GameCardGoods, 0)
|
|
//err = orm.Eloquent.Table("game_card_goods").Where("serial_number in (?)", serials).Find(&list).Error
|
|
err = NewGameCardGoodsQuerySet(DB).SerialNumberIn(serials...).All(&list)
|
|
if err != nil {
|
|
logger.Error("err:", err)
|
|
return err
|
|
}
|
|
|
|
for i, _ := range list {
|
|
if list[i].Status != 1 {
|
|
err = NewCannibalizeGameCardGoodsQuerySet(DB).SerialNumberEq(list[i].SerialNumber).Delete()
|
|
//err = orm.Eloquent.Unscoped().Table("cannibalize_game_card_goods").Where("serial_number", list[i].SerialNumber).Delete(&CannibalizeGameCardGoods{}).Error
|
|
if err != nil {
|
|
logger.Error("delete card goods err:", err)
|
|
}
|
|
continue
|
|
}
|
|
begin := DB.Begin()
|
|
sqlStatus := fmt.Sprintf("UPDATE game_card_goods SET status = 4 WHERE id = %d;", list[i].ID)
|
|
err = begin.Exec(sqlStatus).Error
|
|
if err != nil {
|
|
begin.Rollback()
|
|
logger.Error("err:", err)
|
|
continue
|
|
}
|
|
|
|
//sql := fmt.Sprintf("UPDATE game_card_goods_stock SET rent_stock= rent_stock-1,store_stock=store_stock-1,total_stock=total_stock-1 WHERE store_id=%d AND game_card_id=%d;", list[i].StoreId, list[i].GameCardId)
|
|
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;",
|
|
list[i].StoreId, list[i].GameCardId)
|
|
fmt.Println("sql:", sql)
|
|
err = begin.Exec(sql).Error
|
|
if err != nil {
|
|
begin.Rollback()
|
|
logger.Error("err:", err)
|
|
continue
|
|
}
|
|
|
|
err = begin.Commit().Error
|
|
if err != nil {
|
|
begin.Rollback()
|
|
logger.Error("commit err:", err)
|
|
continue
|
|
}
|
|
delete(serialMap, list[i].SerialNumber)
|
|
|
|
}
|
|
|
|
// 没有更新库存的卡
|
|
if len(serialMap) > 0 {
|
|
for k, _ := range serialMap {
|
|
//fmt.Println("--------k", k)
|
|
err = NewCannibalizeGameCardGoodsQuerySet(DB).SerialNumberEq(k).Delete()
|
|
//err = orm.Eloquent.Unscoped().Table("cannibalize_game_card_goods").Where("serial_number=?", k).Delete(&CannibalizeGameCardGoods{}).Error
|
|
if err != nil {
|
|
logger.Error("delete card goods err:", err)
|
|
}
|
|
}
|
|
}
|
|
|
|
if cannibalizeTask.Status == CannibalizeTaskStatusNotDeliverGoods {
|
|
sql := fmt.Sprintf("UPDATE cannibalize_stock_task SET status = 3,delivery_time=? WHERE id = %d", taskId)
|
|
err = DB.Exec(sql, time.Now()).Error
|
|
if err != nil {
|
|
logger.Errorf("update status err:%s", err.Error())
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func CannibalizePutInStorage(taskId uint32) error {
|
|
var cannibalizeTask CannibalizeStockTask
|
|
err := NewCannibalizeStockTaskQuerySet(DB).IDEq(taskId).One(&cannibalizeTask)
|
|
//err := orm.Eloquent.Table("cannibalize_stock_task").Where("id = ?", taskId).Find(&cannibalizeTask).Error
|
|
if err != nil {
|
|
logger.Error("cannibalize task err:", err)
|
|
return err
|
|
}
|
|
if cannibalizeTask.Status != CannibalizeTaskStatusDeliveredGoods {
|
|
return errors.New("cannibalize task status err")
|
|
}
|
|
var cannibalizeGoodses []CannibalizeGameCardGoods
|
|
err = NewCannibalizeGameCardGoodsQuerySet(DB).CannibalizeStockTaskIdEq(taskId).All(&cannibalizeGoodses)
|
|
//err = orm.Eloquent.Table("cannibalize_game_card_goods").Where("cannibalize_stock_task_id = ?", taskId).
|
|
// Find(&cannibalizeGoodses).Error
|
|
if err != nil && err != RecordNotFound {
|
|
logger.Error("cannibalize goods err:", err)
|
|
return err
|
|
}
|
|
serials := make([]string, 0, len(cannibalizeGoodses))
|
|
for i, _ := range cannibalizeGoodses {
|
|
serials = append(serials, cannibalizeGoodses[i].SerialNumber)
|
|
}
|
|
list := make([]GameCardGoods, 0)
|
|
err = NewGameCardGoodsQuerySet(DB).SerialNumberIn(serials...).All(&list)
|
|
//err = orm.Eloquent.Table("game_card_goods").Where("serial_number in (?)", serials).Find(&list).Error
|
|
if err != nil {
|
|
logger.Error("err:", err)
|
|
return err
|
|
}
|
|
for i, _ := range list {
|
|
if list[i].Status != 4 {
|
|
continue
|
|
}
|
|
//if CannibalizeUserShareCardRetrieve(cannibalizeTask.ToStoreId, list[i]) {
|
|
// continue
|
|
//}
|
|
//var count int64
|
|
count, err := NewGameCardGoodsStockQuerySet(DB).StoreIdEq(uint64(cannibalizeTask.ToStoreId)).
|
|
GameCardIdEq(list[i].GameCardId).Count()
|
|
//err = orm.Eloquent.Table("game_card_goods_stock").Where("store_id = ?", cannibalizeTask.ToStoreId).
|
|
// Where("game_card_id = ?", list[i].GameCardId).Count(&count).Error
|
|
if err != nil {
|
|
logger.Error("err:", err)
|
|
continue
|
|
}
|
|
|
|
begin := DB.Begin()
|
|
sqlStatus := fmt.Sprintf("UPDATE game_card_goods SET status = 1,store_id=%d,stock_time='%s' WHERE id = %d;",
|
|
cannibalizeTask.ToStoreId, time.Now().Format(TimeFormat), list[i].ID)
|
|
err = begin.Exec(sqlStatus).Error
|
|
if err != nil {
|
|
begin.Rollback()
|
|
logger.Error("err:", err)
|
|
continue
|
|
}
|
|
|
|
if count > 0 {
|
|
sql := fmt.Sprintf(
|
|
"UPDATE game_card_goods_stock SET rent_stock= rent_stock+1,store_stock=store_stock+1,total_stock=total_stock+1 WHERE store_id=%d AND game_card_id=%d;",
|
|
cannibalizeTask.ToStoreId, list[i].GameCardId)
|
|
fmt.Println("sql:", sql)
|
|
err = begin.Exec(sql).Error
|
|
if err != nil {
|
|
begin.Rollback()
|
|
logger.Error("err:", err)
|
|
continue
|
|
}
|
|
} else {
|
|
cardGoodsStock := &GameCardGoodsStock{
|
|
StoreId: uint64(cannibalizeTask.ToStoreId),
|
|
GameCardId: list[i].GameCardId,
|
|
StoreStock: 1,
|
|
RentStock: 1,
|
|
UserHoldStock: 0,
|
|
OrderCount: 0,
|
|
TotalStock: 1,
|
|
}
|
|
err := begin.Create(cardGoodsStock).Error
|
|
if err != nil {
|
|
begin.Rollback()
|
|
logger.Error("err:", err)
|
|
continue
|
|
}
|
|
}
|
|
|
|
err = begin.Commit().Error
|
|
if err != nil {
|
|
begin.Rollback()
|
|
logger.Error("commit err:", err)
|
|
continue
|
|
}
|
|
}
|
|
|
|
if cannibalizeTask.Status == CannibalizeTaskStatusDeliveredGoods {
|
|
sql := fmt.Sprintf("UPDATE cannibalize_stock_task SET status = 4,in_storage_time=? WHERE id = %d", taskId)
|
|
err = DB.Exec(sql, time.Now()).Error
|
|
if err != nil {
|
|
logger.Errorf("update status err:%s", err.Error())
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
type CannibalizeTaskListReq struct {
|
|
PageNum int `json:"page_num"`
|
|
PageSize int `json:"page_size"`
|
|
CannibalizeDirection uint32 `json:"cannibalize_direction"` // 1-调入 2-调出
|
|
StoreId uint32 `json:"store_id" ` // 门店id
|
|
Status uint8 `json:"status"`
|
|
}
|
|
type CannibalizeTaskListResp struct {
|
|
PageSize int `json:"page_size"`
|
|
List []CannibalizeStockTask `json:"list"`
|
|
Count int `json:"count"`
|
|
PageNum int `json:"page_num"`
|
|
TotalPage int `json:"total_page"`
|
|
}
|
|
|
|
func (m *CannibalizeTaskListReq) GetCannibalizeTaskList() (*CannibalizeTaskListResp, error) {
|
|
resp := &CannibalizeTaskListResp{
|
|
PageNum: m.PageNum,
|
|
PageSize: m.PageSize,
|
|
}
|
|
|
|
qs := DB.Table("cannibalize_stock_task")
|
|
//if m.StoreId != 0 {
|
|
// qs = qs.Where("from_store_id = ?", m.StoreId).Or("to_store_id = ?", m.StoreId)
|
|
//}
|
|
if m.Status != 0 {
|
|
qs = qs.Where("status = ?", m.Status)
|
|
}
|
|
if m.CannibalizeDirection != 0 {
|
|
if m.CannibalizeDirection == 1 {
|
|
qs = qs.Where("to_store_id=?", m.StoreId)
|
|
} else if m.CannibalizeDirection == 2 {
|
|
qs = qs.Where("from_store_id=?", m.StoreId)
|
|
}
|
|
}
|
|
page := m.PageNum - 1
|
|
if page < 0 {
|
|
page = 0
|
|
}
|
|
if m.PageSize == 0 {
|
|
m.PageSize = 10
|
|
}
|
|
var (
|
|
count int64
|
|
tasks []CannibalizeStockTask
|
|
)
|
|
|
|
err := qs.Count(&count).Offset(page * m.PageSize).Limit(m.PageSize).Order("id DESC").Find(&tasks).Error
|
|
if err != nil && err != RecordNotFound {
|
|
logger.Error("err:", err)
|
|
return resp, err
|
|
}
|
|
|
|
resp.Count = int(count)
|
|
resp.List = CannibalizeStockTaskListSetInfo(tasks)
|
|
|
|
return resp, nil
|
|
}
|
|
|
|
type CannibalizeTaskGameCardGoodsListReq struct {
|
|
PageNum int `json:"page_num"`
|
|
PageSize int `json:"page_size"`
|
|
CannibalizeStockTaskId uint32 `json:"cannibalize_stock_task_id"`
|
|
}
|
|
type CannibalizeTaskGameCardGoodsListResp struct {
|
|
PageSize int `json:"pageSize"`
|
|
List []CannibalizeGameCardGoods `json:"list"`
|
|
Count int `json:"count"`
|
|
PageNum int `json:"page_num"`
|
|
TotalPage int `json:"total_page"`
|
|
}
|
|
|
|
func (m *CannibalizeTaskGameCardGoodsListReq) GetCannibalizeTaskGameCardGoodsList() (*CannibalizeTaskGameCardGoodsListResp, error) {
|
|
resp := &CannibalizeTaskGameCardGoodsListResp{
|
|
PageNum: m.PageNum,
|
|
PageSize: m.PageSize,
|
|
}
|
|
qs := DB.Table("cannibalize_game_card_goods").Where("cannibalize_stock_task_id = ?", m.CannibalizeStockTaskId)
|
|
|
|
page := m.PageNum - 1
|
|
if page < 0 {
|
|
page = 0
|
|
}
|
|
if m.PageSize == 0 {
|
|
m.PageSize = 10
|
|
}
|
|
var (
|
|
count int64
|
|
cannibalizeGoodses []CannibalizeGameCardGoods
|
|
)
|
|
//CannibalizeGameCardGoods int `json:"cannibalize_game_card_goods" gorm:"-"`
|
|
err := qs.Count(&count).Offset(page * m.PageSize).Limit(m.PageSize).Order("id DESC").Find(&cannibalizeGoodses).Error
|
|
if err != nil && err != RecordNotFound {
|
|
logger.Error("err:", err)
|
|
return resp, err
|
|
}
|
|
|
|
resp.Count = int(count)
|
|
resp.List = CannibalizeGameCardGoodsSetInfo(cannibalizeGoodses)
|
|
|
|
return resp, nil
|
|
}
|
|
|
|
func CannibalizeTaskDel(taskId uint32) error {
|
|
var cannibalizeTask CannibalizeStockTask
|
|
err := DB.Table("cannibalize_stock_task").Where("id = ?", taskId).Find(&cannibalizeTask).Error
|
|
if err != nil {
|
|
logger.Error("cannibalize task err:", err)
|
|
return err
|
|
}
|
|
|
|
if cannibalizeTask.Status != CannibalizeTaskStatusNotImportGoods &&
|
|
cannibalizeTask.Status != CannibalizeTaskStatusNotDeliverGoods {
|
|
return errors.New("status err")
|
|
}
|
|
sql := fmt.Sprintf("UPDATE cannibalize_stock_task SET status = 5 WHERE id = %d", taskId)
|
|
err = DB.Exec(sql).Error
|
|
if err != nil {
|
|
logger.Error("update status err:", err)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type CooperativeGameCardGoodsListReq struct {
|
|
PageNum int `json:"page_num"`
|
|
PageSize int `json:"page_size"`
|
|
StoreId uint32 `json:"store_id"`
|
|
Status int `json:"status"`
|
|
GameCardId int `json:"game_card_id"`
|
|
SerialNumber string `json:"serial_number" ` // 编号
|
|
AssistantUid uint32 `json:"assistant_uid"`
|
|
}
|
|
type CooperativeGameCardGoodsListResp struct {
|
|
List []GameCardGoods `json:"list"`
|
|
Count int `json:"count"`
|
|
PageNum int `json:"page_num"`
|
|
TotalPage int `json:"total_page"`
|
|
}
|
|
|
|
func (m *CooperativeGameCardGoodsListReq) List() (*CooperativeGameCardGoodsListResp, error) {
|
|
var (
|
|
cardGoods = make([]GameCardGoods, 0)
|
|
totalPage uint32
|
|
)
|
|
resp := &CooperativeGameCardGoodsListResp{List: cardGoods, PageNum: m.PageNum}
|
|
m.PageNum -= 1
|
|
if m.PageNum < 0 {
|
|
m.PageNum = 0
|
|
}
|
|
if m.PageSize == 0 {
|
|
m.PageSize = 10
|
|
}
|
|
assistant := GetUserByUid(m.AssistantUid)
|
|
m.StoreId = uint32(assistant.StoreId)
|
|
fmt.Println("GetGameCardGoodsListReq:", m)
|
|
gdb := DB.Table("game_card_goods")
|
|
if m.Status != 0 {
|
|
gdb = gdb.Where("status=?", m.Status)
|
|
}
|
|
if m.StoreId != 0 {
|
|
gdb = gdb.Where("store_id=?", m.StoreId)
|
|
}
|
|
if m.GameCardId != 0 {
|
|
gdb = gdb.Where("game_card_id=?", m.GameCardId)
|
|
}
|
|
if m.SerialNumber != "" {
|
|
gdb = gdb.Where("serial_number=?", m.SerialNumber)
|
|
}
|
|
var count int64
|
|
err := gdb.Count(&count).Error
|
|
if err != nil {
|
|
logger.Error("err:", err)
|
|
return resp, err
|
|
}
|
|
resp.Count = int(count)
|
|
err = gdb.Order("created_at DESC").Offset(m.PageNum * m.PageSize).Limit(m.PageSize).Find(&cardGoods).Error
|
|
if err != nil && err != RecordNotFound {
|
|
logger.Error("err:", err)
|
|
return resp, err
|
|
}
|
|
|
|
if len(cardGoods) > 0 {
|
|
//storeIds := make([]uint32, 0)
|
|
gameCardIds := make([]uint32, 0)
|
|
|
|
for i, _ := range cardGoods {
|
|
//storeIds = append(storeIds, uint32(cardGoods[i].StoreId))
|
|
gameCardIds = append(gameCardIds, uint32(cardGoods[i].GameCardId))
|
|
}
|
|
|
|
cardMap, err := GameCardMap(gameCardIds)
|
|
if err != nil {
|
|
logger.Error("game card map err:", err)
|
|
return resp, err
|
|
}
|
|
//storeMap := GetStoreMapByIds(storeIds)
|
|
|
|
for i, _ := range cardGoods {
|
|
gameCard, ok1 := cardMap[uint32(cardGoods[i].GameCardId)]
|
|
if ok1 {
|
|
cardGoods[i].GameCard = &gameCard
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
totalPage = uint32(int(count)/m.PageSize + 1)
|
|
resp.TotalPage = int(totalPage)
|
|
resp.List = cardGoods
|
|
return resp, nil
|
|
}
|
|
|
|
type AssistantMemberPromotionReq struct {
|
|
PageNum int `json:"page_num"`
|
|
PageSize int `json:"page_size"`
|
|
Date string `json:"date"`
|
|
StoreId uint32 `json:"store_id"`
|
|
AssistantUid uint32 `json:"assistant_uid"`
|
|
Assistant *User `json:"assistant"`
|
|
}
|
|
|
|
func (m *AssistantMemberPromotionReq) List() ([]InviteMemberReport, int, error) {
|
|
var reports []InviteMemberReport
|
|
|
|
m.PageNum -= 1
|
|
if m.PageNum < 0 {
|
|
m.PageNum = 0
|
|
}
|
|
if m.PageSize == 0 {
|
|
m.PageSize = 10
|
|
}
|
|
|
|
m.StoreId = uint32(m.Assistant.StoreId)
|
|
|
|
qs := NewInviteMemberReportQuerySet(DB).CooperativeBusinessIdEq(m.Assistant.CooperativeBusinessId).
|
|
StoreIdEq(m.StoreId)
|
|
if m.Date != "" {
|
|
qs = qs.DateEq(m.Date)
|
|
}
|
|
count, err := qs.Count()
|
|
if err != nil {
|
|
logger.Error("err:", err)
|
|
return reports, 0, err
|
|
}
|
|
totalPage := int(count)/m.PageSize + 1
|
|
err = qs.OrderDescByID().Offset(m.PageNum * m.PageSize).Limit(m.PageSize).All(&reports)
|
|
if err != nil && err != RecordNotFound {
|
|
logger.Error("err:", err)
|
|
return reports, totalPage, err
|
|
}
|
|
|
|
reports = InviteMemberReportListSetUser(reports)
|
|
return reports, totalPage, nil
|
|
}
|
|
|
|
func GameCardListSetStockState(list []GameCard, storeId uint32) {
|
|
gameCardIds := make([]uint64, 0, len(list))
|
|
for i, _ := range list {
|
|
gameCardIds = append(gameCardIds, uint64(list[i].ID))
|
|
}
|
|
if len(gameCardIds) == 0 {
|
|
return
|
|
}
|
|
//gameIds := make([]uint32, 0)
|
|
gameIdMap := make(map[uint32]uint32)
|
|
if storeId != 0 {
|
|
var cardStocks []GameCardGoodsStock
|
|
err := NewGameCardGoodsStockQuerySet(DB).StoreIdEq(uint64(storeId)).GameCardIdIn(gameCardIds...).
|
|
RentStockGt(0).All(&cardStocks)
|
|
if err != nil {
|
|
logger.Error("GetGameIdByType err:", err)
|
|
}
|
|
for i, _ := range cardStocks {
|
|
_, ok := gameIdMap[uint32(cardStocks[i].GameCardId)]
|
|
if !ok {
|
|
//gameIds = append(gameIds, uint32(cardStocks[i].GameCardId))
|
|
gameIdMap[uint32(cardStocks[i].GameCardId)] = 1
|
|
}
|
|
}
|
|
|
|
err = NewGameCardGoodsStockQuerySet(DB).StoreIdNe(uint64(storeId)).GameCardIdIn(gameCardIds...).
|
|
RentStockGt(0).All(&cardStocks)
|
|
if err != nil {
|
|
logger.Error("GetGameIdByType err:", err)
|
|
}
|
|
for i, _ := range cardStocks {
|
|
_, ok := gameIdMap[uint32(cardStocks[i].GameCardId)]
|
|
if !ok {
|
|
//gameIds = append(gameIds, uint32(cardStocks[i].GameCardId))
|
|
gameIdMap[uint32(cardStocks[i].GameCardId)] = 2
|
|
}
|
|
}
|
|
|
|
err = NewGameCardGoodsStockQuerySet(DB).GameCardIdIn(gameCardIds...).RentStockEq(0).All(&cardStocks)
|
|
if err != nil {
|
|
logger.Error("GetGameIdByType err:", err)
|
|
}
|
|
for i, _ := range cardStocks {
|
|
_, ok := gameIdMap[uint32(cardStocks[i].GameCardId)]
|
|
if !ok {
|
|
//gameIds = append(gameIds, uint32(cardStocks[i].GameCardId))
|
|
gameIdMap[uint32(cardStocks[i].GameCardId)] = 3
|
|
}
|
|
}
|
|
|
|
} else {
|
|
var cardStocks []GameCardGoodsStock
|
|
err := NewGameCardGoodsStockQuerySet(DB).GameCardIdIn(gameCardIds...).RentStockGt(0).
|
|
All(&cardStocks)
|
|
if err != nil {
|
|
logger.Error("GetGameIdByType err:", err)
|
|
}
|
|
for i, _ := range cardStocks {
|
|
_, ok := gameIdMap[uint32(cardStocks[i].GameCardId)]
|
|
if !ok {
|
|
gameIdMap[uint32(cardStocks[i].GameCardId)] = 1
|
|
}
|
|
}
|
|
|
|
err = NewGameCardGoodsStockQuerySet(DB).GameCardIdIn(gameCardIds...).RentStockEq(0).All(&cardStocks)
|
|
if err != nil {
|
|
logger.Error("GetGameIdByType err:", err)
|
|
}
|
|
for i, _ := range cardStocks {
|
|
_, ok := gameIdMap[uint32(cardStocks[i].GameCardId)]
|
|
if !ok {
|
|
gameIdMap[uint32(cardStocks[i].GameCardId)] = 3
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
for i, _ := range list {
|
|
v, ok := gameIdMap[uint32(list[i].ID)]
|
|
if ok {
|
|
//gameIdMap[uint32(cardStocks[i].GameCardId)] = 3
|
|
list[i].StockState = v
|
|
}
|
|
//gameCardIds = append(gameCardIds, uint64(list[i].ID))
|
|
}
|
|
}
|
|
|
|
func InviteMemberReportListSetUser(list []InviteMemberReport) []InviteMemberReport {
|
|
uids := make([]uint32, 0, len(list))
|
|
for i, _ := range list {
|
|
uids = append(uids, list[i].Uid)
|
|
}
|
|
userMap, err := GetUserMap(uids)
|
|
if err != nil {
|
|
logger.Error("user map err:", err)
|
|
return list
|
|
}
|
|
for i, _ := range list {
|
|
v, ok := userMap[list[i].Uid]
|
|
if ok {
|
|
list[i].User = v
|
|
}
|
|
}
|
|
return list
|
|
}
|