mh_server/model/game_card.go

package model

import (
	"fmt"
	"github.com/codinl/go-logger"
	"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"`                                      // 库存
	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"`                                       // 真实价格
}

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"`
}

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, uid 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
	//}
	user := GetUserByUid(uid)

	qs := NewGameCardQuerySet(DB).IDNe(914)
	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 user.MemberExpire.After(time.Now().AddDate(0, 0, -14)) {
		qs = qs.RealPriceLte(30000)
	}
	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-客户持有 4-调拨 5-待收回 6-已收回
	StoreId         uint64 `json:"store_id"`                   // 门店id
	Provider        string `json:"provider"`                   // 供应商
	CardType        string `json:"card_type" gorm:"index"`     // -用户共享  -公共
	FunctionState   uint32 `json:"function_state"`             // 1-异常 2-正常
	ShareProfitType uint32 `json:"share_profit_type"`          // 1-非共享收益卡 2-共享收益卡
}

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"`
}