1907 lines
58 KiB
Go
1907 lines
58 KiB
Go
package model
|
||
|
||
import (
|
||
"errors"
|
||
"fmt"
|
||
"github.com/codinl/go-logger"
|
||
"github.com/jinzhu/gorm"
|
||
"strings"
|
||
"time"
|
||
)
|
||
|
||
// gen:qs
|
||
//
|
||
//go:generate goqueryset -in game_card.go
|
||
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)
|
||
|
||
effectiveStoreList := GetAllEffectiveStoreMap()
|
||
if len(effectiveStoreList) == 0 {
|
||
logger.Error("effectiveStoreList is null")
|
||
return nil, 0, errors.New("无有效门店")
|
||
}
|
||
effectiveStoreListStr := fmt.Sprintf("(%s)", strings.Trim(strings.Join(strings.Fields(fmt.Sprint(effectiveStoreList)), ","), "[]"))
|
||
|
||
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.store_id IN %s AND a.rent_stock>0 ORDER BY b.id ASC;", storeId, effectiveStoreListStr)
|
||
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.store_id IN %s AND a.rent_stock>0 ORDER BY b.id ASC;", storeId, effectiveStoreListStr)
|
||
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 AND a.store_id IN %s ORDER BY b.id ASC;", effectiveStoreListStr)
|
||
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 AND a.store_id IN %s ORDER BY b.id ASC;", effectiveStoreListStr)
|
||
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 AND a.store_id IN %s ORDER BY b.id ASC;", effectiveStoreListStr)
|
||
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, effectiveStoreList)
|
||
} 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]
|
||
|
||
// 如果游戏列表有记录，但游戏库存列表无记录；则也添加到gameIds，库存记录为3无库存
|
||
_, ok := gameIdMap[cards[i].ID]
|
||
if !ok {
|
||
gameIds = append(gameIds, uint32(cards[i].ID))
|
||
gameIdMap[cards[i].ID] = 3
|
||
}
|
||
}
|
||
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
|
||
}
|
||
|
||
effectiveStoreList := GetAllEffectiveStoreMap()
|
||
if len(effectiveStoreList) == 0 {
|
||
logger.Error("effectiveStoreList is null")
|
||
return GameCard{}, errors.New("无有效门店")
|
||
}
|
||
|
||
var cardStock GameCardGoodsStock
|
||
if storeId != 0 {
|
||
err = NewGameCardGoodsStockQuerySet(DB).GameCardIdEq(uint64(game.ID)).StoreIdEq(uint64(storeId)).
|
||
StoreIdIn(uint32ToUint64(effectiveStoreList)...).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)).StoreIdIn(uint32ToUint64(effectiveStoreList)...).
|
||
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).
|
||
StoreIdIn(uint32ToUint64(effectiveStoreList)...).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, 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)
|
||
|
||
effectiveStoreInfo, err := GetUserEffectiveStore(m.Assistant.Uid)
|
||
if err != nil {
|
||
logger.Error("err:", err)
|
||
return reports, 0, 0, err
|
||
}
|
||
m.StoreId = uint32(effectiveStoreInfo.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, 0, err
|
||
}
|
||
//totalPage := int(count)/m.PageSize + 1
|
||
totalPage := (int(count) + m.PageSize - 1) / m.PageSize
|
||
|
||
err = qs.OrderDescByDateAndAscByStoreId().Offset(m.PageNum * m.PageSize).Limit(m.PageSize).All(&reports)
|
||
if err != nil && err != RecordNotFound {
|
||
logger.Error("err:", err)
|
||
return reports, totalPage, 0, err
|
||
}
|
||
|
||
reports = InviteMemberReportListSetUser(reports)
|
||
return reports, totalPage, count, nil
|
||
}
|
||
|
||
func uint32ToUint64(slice []uint32) []uint64 {
|
||
result := make([]uint64, len(slice))
|
||
for i, v := range slice {
|
||
result[i] = uint64(v)
|
||
}
|
||
return result
|
||
}
|
||
|
||
func GameCardListSetStockState(list []GameCard, storeId uint32, storeList []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).GameCardIdIn(gameCardIds...).StoreIdIn(uint32ToUint64(storeList)...).
|
||
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
|
||
}
|
||
}
|
||
|
||
err = NewGameCardGoodsStockQuerySet(DB).StoreIdNe(uint64(storeId)).StoreIdIn(uint32ToUint64(storeList)...).
|
||
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
|
||
//}
|
||
|
||
gameIdMap[uint32(cardStocks[i].GameCardId)] = 2
|
||
}
|
||
|
||
err = NewGameCardGoodsStockQuerySet(DB).StoreIdEq(uint64(storeId)).StoreIdIn(uint32ToUint64(storeList)...).
|
||
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
|
||
//}
|
||
|
||
gameIdMap[uint32(cardStocks[i].GameCardId)] = 1
|
||
}
|
||
} else {
|
||
var cardStocks []GameCardGoodsStock
|
||
err := NewGameCardGoodsStockQuerySet(DB).GameCardIdIn(gameCardIds...).StoreIdIn(uint32ToUint64(storeList)...).
|
||
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
|
||
}
|
||
}
|
||
|
||
err = NewGameCardGoodsStockQuerySet(DB).GameCardIdIn(gameCardIds...).StoreIdIn(uint32ToUint64(storeList)...).
|
||
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
|
||
//}
|
||
|
||
gameIdMap[uint32(cardStocks[i].GameCardId)] = 1
|
||
}
|
||
}
|
||
|
||
for i, _ := range list {
|
||
v, ok := gameIdMap[uint32(list[i].ID)]
|
||
if ok {
|
||
//gameIdMap[uint32(cardStocks[i].GameCardId)] = 3
|
||
list[i].StockState = v
|
||
} else {
|
||
list[i].StockState = 3 // 如果以上都没找到，则应该是没库存
|
||
}
|
||
//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
|
||
}
|