452 lines
13 KiB
Go
452 lines
13 KiB
Go
package model
|
|
|
|
import (
|
|
"fmt"
|
|
"github.com/codinl/go-logger"
|
|
"strings"
|
|
)
|
|
|
|
//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"` // 库存
|
|
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"` // 详情图片
|
|
}
|
|
|
|
func (*GameCard) TableName() string {
|
|
return "game_card"
|
|
}
|
|
|
|
// 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"`
|
|
}
|
|
|
|
func (*HomeCarousel) TableName() string {
|
|
return "home_carousel"
|
|
}
|
|
|
|
type CardInfo struct {
|
|
GameCardId uint32 `json:"game_card_id"`
|
|
Count uint32 `json:"count"`
|
|
}
|
|
|
|
func GetGameCardList(sortType, page, pageSize int, gameTypeIds []uint64, storeId uint32) ([]GameCard, uint32, error) {
|
|
var (
|
|
cards []GameCard = make([]GameCard, 0)
|
|
totalPage uint32
|
|
count int
|
|
err error
|
|
)
|
|
page -= 1
|
|
if page < 0 {
|
|
page = 0
|
|
//return cards, 0, errors.New("page is err")
|
|
}
|
|
//count, err := NewGameCardQuerySet(DB).Count()
|
|
//if err != nil {
|
|
// logger.Error("NewGameCardQuerySet err:", err)
|
|
// return cards, 0, err
|
|
//}
|
|
|
|
qs := NewGameCardQuerySet(DB)
|
|
switch sortType {
|
|
case 1:
|
|
// 排序类型 1-默认
|
|
//qs = qs.OrderDescByCreatedAt()
|
|
case 2:
|
|
// 排序类型 2-新品
|
|
qs = qs.NewProductsEq(1)
|
|
//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
|
|
}
|
|
}
|
|
if storeId != 0 {
|
|
var cardStocks []GameCardGoodsStock
|
|
err := NewGameCardGoodsStockQuerySet(DB).StoreIdEq(uint64(storeId)).RentStockGt(0).All(&cardStocks)
|
|
if err != nil {
|
|
logger.Error("GetGameIdByType err:", err)
|
|
return cards, 0, err
|
|
}
|
|
if len(cardStocks) <= 0 {
|
|
return cards, 0, nil
|
|
}
|
|
gameIds := make([]uint32, 0)
|
|
for i, _ := range cardStocks {
|
|
gameIds = append(gameIds, uint32(cardStocks[i].GameCardId))
|
|
}
|
|
if len(gameIds) <= 0 {
|
|
return cards, 0, nil
|
|
}
|
|
|
|
qs = qs.IDIn(gameIds...)
|
|
}
|
|
|
|
if count == 0 {
|
|
count, err = qs.Count()
|
|
}
|
|
|
|
err = qs.OrderDescByCreatedAt().Offset(page * pageSize).Limit(pageSize).All(&cards)
|
|
if err != nil && err != RecordNotFound {
|
|
logger.Error("err:", err)
|
|
return cards, 0, err
|
|
}
|
|
totalPage = uint32(count/pageSize + 1)
|
|
|
|
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
|
|
}
|
|
}
|
|
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 // 客户持有
|
|
)
|
|
|
|
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 uint8 `json:"status"` // 状态:1-库存中 2-在途 3-客户持有
|
|
StoreId uint64 `json:"store_id"` // 门店id
|
|
Provider string `json:"provider"` // 供应商
|
|
CardType string `json:"card_type" gorm:"index"` //
|
|
}
|
|
|
|
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"`
|
|
Name string `json:"name" gorm:"-"` // 名称
|
|
CoverImg string `json:"coverImg" gorm:"-"` // 封面
|
|
}
|
|
|
|
func (*GameCardGoodsStock) TableName() string {
|
|
return "game_card_goods_stock"
|
|
}
|
|
|
|
func GetGameCardInfo(id uint64) (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 cardStocks []GameCardGoodsStock
|
|
err = NewGameCardGoodsStockQuerySet(DB).GameCardIdEq(uint64(game.ID)).All(&cardStocks)
|
|
if err != nil {
|
|
logger.Error("err:", err)
|
|
}
|
|
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
|
|
}
|
|
sqlStore := ""
|
|
if storeId != 0 {
|
|
var gameStocks []GameCardGoodsStock
|
|
err := NewGameCardGoodsStockQuerySet(DB).StoreIdEq(uint64(storeId)).All(&gameStocks)
|
|
if err != nil {
|
|
|
|
}
|
|
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 game_card.* FROM game_card WHERE game_card.name LIKE '%" + name + "%'"
|
|
countSql := "SELECT COUNT(id) AS count FROM game_card WHERE status=1 AND game_card.name LIKE '%" + name + "%'" + sqlStore
|
|
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 + "%'" + sqlStore + fmt.Sprintf(" LIMIT %d,%d;", page*pageSize, pageSize)
|
|
//sql := fmt.Sprintf(`SELECT * FROM game_card WHERE name LIKE '%%s%';`)
|
|
err = DB.Raw(sql).Scan(&cards).Error
|
|
if err != nil {
|
|
logger.Error("err:", err)
|
|
return cards, 0, err
|
|
}
|
|
|
|
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
|
|
}
|
|
}
|
|
|
|
totalPage = cardCount.Count/uint32(pageSize) + 1
|
|
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"`
|
|
}
|