518 lines
14 KiB
Go
518 lines
14 KiB
Go
package goodsmanage
|
|
|
|
import (
|
|
"errors"
|
|
"github.com/gin-gonic/gin"
|
|
"go-admin/app/admin/models"
|
|
orm "go-admin/common/global"
|
|
"go-admin/logger"
|
|
aliyun "go-admin/tools/ali"
|
|
"go-admin/tools/app"
|
|
"net/http"
|
|
"strings"
|
|
)
|
|
|
|
func GameCardList(c *gin.Context) {
|
|
req := struct {
|
|
Page int `json:"pageIndex"`
|
|
PageSize int `json:"pageSize"`
|
|
GameType int `json:"gameTypeId"`
|
|
Status int `json:"status"`
|
|
NameKey string `json:"nameKey"`
|
|
}{
|
|
Page: 1,
|
|
PageSize: 20,
|
|
}
|
|
if c.ShouldBindJSON(&req) != nil {
|
|
logger.Errorf("para err")
|
|
app.Error(c, http.StatusBadRequest, errors.New("para err"), "参数错误")
|
|
return
|
|
}
|
|
|
|
cardList, _, count, err := models.GetGameCardList(req.GameType, req.Status, req.Page, req.PageSize, req.NameKey)
|
|
|
|
if err != nil {
|
|
logger.Errorf("err:", logger.Field("err", err))
|
|
app.Error(c, http.StatusInternalServerError, err, "查询失败")
|
|
return
|
|
}
|
|
|
|
ret := map[string]interface{}{
|
|
"count": count,
|
|
"list": cardList,
|
|
"pageIndex": req.Page,
|
|
"total_page": req.PageSize,
|
|
}
|
|
app.OK(c, ret, "")
|
|
}
|
|
|
|
func GameCardGoodsList(c *gin.Context) {
|
|
req := models.GetGameCardGoodsListReq{}
|
|
if c.ShouldBindJSON(&req) != nil {
|
|
logger.Errorf("para err")
|
|
app.Error(c, http.StatusBadRequest, errors.New("para err"), "参数错误")
|
|
return
|
|
}
|
|
|
|
resp, err := req.GetGameCardGoodsList()
|
|
if err != nil {
|
|
logger.Errorf("err:", logger.Field("err", err))
|
|
app.Error(c, http.StatusInternalServerError, err, "查询失败")
|
|
return
|
|
}
|
|
|
|
app.OK(c, resp, "")
|
|
}
|
|
|
|
func GameCardAdd(c *gin.Context) {
|
|
req := struct {
|
|
Name string `json:"name" gorm:"column:name;index"` // 名称
|
|
Price uint32 `json:"price" gorm:"column:price;index"` // 价格
|
|
CoverImg string `json:"coverImg" gorm:"column:cover_img"` // 封面
|
|
OrderCount uint32 `json:"orderCount" gorm:"column:order_count;index"` // 订单数
|
|
NewProducts uint8 `json:"newProducts"` // 新品: 1-新品 2-非新品
|
|
Status uint8 `json:"status"` // 状态: 1-上架 2-下架
|
|
GameTypeId []int `json:"gameTypeId"` // 游戏类型id
|
|
GoodsGalleryUrl string `json:"goodsGalleryUrl"` // 轮播图
|
|
ViewCount uint32 `json:"viewCount"` // 查看人数
|
|
Playability uint32 `json:"playability"` // 耐玩度
|
|
Playfulness uint32 `json:"playfulness"` // 好玩度
|
|
GameTime uint32 `json:"gameTime"` // 游戏时间
|
|
Likes uint32 `json:"likes"` // 点赞
|
|
DetailInfo string `json:"detailInfo"` // 详情描述
|
|
DetailImg string `json:"detailImg"` // 详情图片
|
|
Labels []string `json:"labels"` // 游戏标签
|
|
RealPrice uint32 `json:"real_price"` // 真实价格
|
|
VideoLink string `json:"video_link"` // 链接
|
|
|
|
}{}
|
|
if c.ShouldBindJSON(&req) != nil {
|
|
logger.Errorf("para err")
|
|
app.Error(c, http.StatusBadRequest, errors.New("para err"), "参数错误")
|
|
return
|
|
}
|
|
|
|
card := &models.GameCard{
|
|
Name: req.Name,
|
|
Price: req.Price,
|
|
CoverImg: req.CoverImg,
|
|
NewProducts: req.NewProducts,
|
|
Status: req.Status,
|
|
GoodsGalleryUrl: req.GoodsGalleryUrl,
|
|
Playability: req.Playability,
|
|
Playfulness: req.Playfulness,
|
|
GameTime: req.GameTime,
|
|
DetailInfo: req.DetailInfo,
|
|
DetailImg: req.DetailImg,
|
|
RealPrice: req.RealPrice,
|
|
VideoLink: req.VideoLink,
|
|
}
|
|
err := card.Add()
|
|
if err != nil {
|
|
logger.Errorf("err:", logger.Field("err", err))
|
|
app.Error(c, http.StatusBadRequest, err, "参数错误")
|
|
return
|
|
}
|
|
err = models.GameCardAddType(req.GameTypeId, int(card.ID))
|
|
if err != nil {
|
|
logger.Errorf("err:", logger.Field("err", err))
|
|
app.Error(c, http.StatusBadRequest, err, "参数错误")
|
|
return
|
|
}
|
|
|
|
for i, label := range req.Labels {
|
|
label = strings.Replace(label, " ", "", -1)
|
|
label = strings.Replace(label, "\n", "", -1)
|
|
req.Labels[i] = label
|
|
}
|
|
labelMap := make(map[string]uint32)
|
|
for i, _ := range req.Labels {
|
|
labelMap[req.Labels[i]] = uint32(i)
|
|
}
|
|
for k, _ := range labelMap {
|
|
if k == "" {
|
|
continue
|
|
}
|
|
err := orm.Eloquent.Create(&models.GameCardLabel{
|
|
GameCardId: card.ID,
|
|
GameLabel: k,
|
|
}).Error
|
|
if err != nil {
|
|
logger.Error("create game card label err")
|
|
}
|
|
}
|
|
|
|
app.OK(c, nil, "添加成功")
|
|
}
|
|
|
|
func GameCardModify(c *gin.Context) {
|
|
card := models.GameCard{}
|
|
if c.ShouldBindJSON(&card) != nil {
|
|
logger.Errorf("para err")
|
|
app.Error(c, http.StatusBadRequest, errors.New("para err"), "参数错误")
|
|
return
|
|
}
|
|
|
|
err := card.Modify()
|
|
if err != nil {
|
|
logger.Errorf("err:", logger.Field("err", err))
|
|
app.Error(c, http.StatusBadRequest, err, "参数错误")
|
|
return
|
|
}
|
|
app.OK(c, nil, "修改成功")
|
|
}
|
|
|
|
func GameCardModifyType(c *gin.Context) {
|
|
req := struct {
|
|
GameCardId int `json:"gameCardId"`
|
|
GameTypeId []int `json:"gameTypeId"`
|
|
}{}
|
|
if c.ShouldBindJSON(&req) != nil {
|
|
logger.Errorf("para err")
|
|
app.Error(c, http.StatusBadRequest, errors.New("para err"), "参数错误")
|
|
return
|
|
}
|
|
|
|
err := models.GameType{GameCardId: uint64(req.GameCardId)}.GameCardTypeModify(req.GameTypeId)
|
|
if err != nil {
|
|
logger.Errorf("err:", logger.Field("err", err))
|
|
app.Error(c, http.StatusBadRequest, err, "参数错误")
|
|
return
|
|
}
|
|
app.OK(c, nil, "修改成功")
|
|
}
|
|
|
|
func GameCardMDel(c *gin.Context) {
|
|
req := struct {
|
|
Id []uint32 `json:"id"`
|
|
}{}
|
|
if c.ShouldBindJSON(&req) != nil {
|
|
logger.Errorf("para err")
|
|
app.Error(c, http.StatusBadRequest, errors.New("para err"), "参数错误")
|
|
return
|
|
}
|
|
data := models.GameCard{}
|
|
err := data.MDel(req.Id)
|
|
if err != nil {
|
|
logger.Errorf("err:", logger.Field("err", err))
|
|
app.Error(c, http.StatusBadRequest, err, "参数错误")
|
|
return
|
|
}
|
|
app.OK(c, nil, "删除成功")
|
|
}
|
|
|
|
func GameCardTypeList(c *gin.Context) {
|
|
typeList, err := models.GetGameCardTypeList()
|
|
if err != nil {
|
|
logger.Errorf("err:", logger.Field("err", err))
|
|
app.Error(c, http.StatusBadRequest, err, "参数错误")
|
|
return
|
|
}
|
|
|
|
app.OK(c, typeList, "")
|
|
}
|
|
|
|
func GameCardTypeModify(c *gin.Context) {
|
|
cardType := &models.GameCardType{}
|
|
if c.ShouldBindJSON(cardType) != nil {
|
|
logger.Errorf("para err")
|
|
app.Error(c, http.StatusBadRequest, errors.New("para err"), "参数错误")
|
|
return
|
|
}
|
|
|
|
err := cardType.Modify()
|
|
if err != nil {
|
|
logger.Errorf("err:", logger.Field("err", err))
|
|
app.Error(c, http.StatusBadRequest, err, "参数错误")
|
|
return
|
|
}
|
|
|
|
app.OK(c, "", "修改成功")
|
|
}
|
|
|
|
func GameCardTypeAdd(c *gin.Context) {
|
|
cardType := &models.GameCardType{}
|
|
if c.ShouldBindJSON(cardType) != nil {
|
|
logger.Errorf("para err")
|
|
app.Error(c, http.StatusBadRequest, errors.New("para err"), "参数错误")
|
|
return
|
|
}
|
|
|
|
err := cardType.Add()
|
|
if err != nil {
|
|
logger.Errorf("err:", logger.Field("err", err))
|
|
app.Error(c, http.StatusBadRequest, err, "参数错误")
|
|
return
|
|
}
|
|
app.OK(c, nil, "添加成功")
|
|
}
|
|
|
|
func GameCardTypeDel(c *gin.Context) {
|
|
req := struct {
|
|
Id []uint32 `json:"id"`
|
|
}{}
|
|
if c.ShouldBindJSON(&req) != nil {
|
|
logger.Errorf("para err")
|
|
app.Error(c, http.StatusBadRequest, errors.New("para err"), "参数错误")
|
|
return
|
|
}
|
|
data := &models.GameCardType{}
|
|
err := data.MDel(req.Id)
|
|
if err != nil {
|
|
logger.Errorf("err:", logger.Field("err", err))
|
|
app.Error(c, http.StatusBadRequest, err, "参数错误")
|
|
return
|
|
}
|
|
app.OK(c, nil, "删除成功")
|
|
}
|
|
|
|
func GameTypeAdd(c *gin.Context) {
|
|
req := struct {
|
|
GameCardId int `json:"gameCardId"`
|
|
Id []int `json:"id"`
|
|
}{}
|
|
if c.ShouldBindJSON(&req) != nil {
|
|
logger.Errorf("para err")
|
|
app.Error(c, http.StatusBadRequest, errors.New("para err"), "参数错误")
|
|
return
|
|
}
|
|
err := models.GameCardAddType(req.Id, req.GameCardId)
|
|
if err != nil {
|
|
logger.Error("err:", logger.Field("err", err))
|
|
app.Error(c, http.StatusInternalServerError, err, "")
|
|
return
|
|
}
|
|
app.OK(c, nil, "添加成功")
|
|
return
|
|
}
|
|
|
|
func GameCardTypes(c *gin.Context) {
|
|
req := struct {
|
|
GameCardId int `json:"gameCardId"`
|
|
}{}
|
|
if c.ShouldBindJSON(&req) != nil {
|
|
logger.Errorf("para err")
|
|
app.Error(c, http.StatusBadRequest, errors.New("para err"), "参数错误")
|
|
return
|
|
}
|
|
card := models.GameCard{}
|
|
card.ID = uint32(req.GameCardId)
|
|
cardTypes, err := card.GetGameType()
|
|
if err != nil {
|
|
logger.Error("err:", logger.Field("err", err))
|
|
app.Error(c, http.StatusInternalServerError, err, "")
|
|
return
|
|
}
|
|
|
|
app.OK(c, cardTypes, "")
|
|
return
|
|
}
|
|
|
|
func AliyunStsTokenGet(c *gin.Context) {
|
|
uploadInfo, err := aliyun.GenStsToken("21000505")
|
|
if err != nil {
|
|
logger.Error("err", logger.Field("err", err))
|
|
return
|
|
}
|
|
|
|
stsToken := models.RspAliyunStsToken{
|
|
AccessKeyId: uploadInfo.AccessKeyId,
|
|
AccessKeySecret: uploadInfo.AccessKeySecret,
|
|
SecurityToken: uploadInfo.SecurityToken,
|
|
BucketName: uploadInfo.BucketName,
|
|
Expiration: uint64(uploadInfo.Expiration),
|
|
}
|
|
|
|
ret := map[string]interface{}{
|
|
"stsToken": stsToken,
|
|
"ossUrl": aliyun.AliyunOssUrl,
|
|
}
|
|
app.OK(c, ret, "")
|
|
return
|
|
}
|
|
|
|
func BatchStandUpDown(c *gin.Context) {
|
|
req := struct {
|
|
StandType uint32 `json:"stand_type"` // 批量:1-上架 2-下架
|
|
}{}
|
|
if c.ShouldBindJSON(&req) != nil {
|
|
logger.Errorf("para err")
|
|
app.Error(c, http.StatusBadRequest, errors.New("para err"), "参数错误")
|
|
return
|
|
}
|
|
err := models.GameCardBatchStand(req.StandType)
|
|
if err != nil {
|
|
logger.Error("err:", logger.Field("err", err))
|
|
app.Error(c, http.StatusInternalServerError, err, "")
|
|
return
|
|
}
|
|
app.OK(c, nil, "成功")
|
|
return
|
|
}
|
|
|
|
func BatchStandUp(c *gin.Context) {
|
|
req := struct {
|
|
GameCardId []uint32 `json:"game_card_id"` // 批量上架
|
|
}{}
|
|
if c.ShouldBindJSON(&req) != nil {
|
|
logger.Errorf("para err")
|
|
app.Error(c, http.StatusBadRequest, errors.New("para err"), "参数错误")
|
|
return
|
|
}
|
|
err := models.GameCardBatchStandUp(req.GameCardId)
|
|
if err != nil {
|
|
logger.Error("err:", logger.Field("err", err))
|
|
app.Error(c, http.StatusInternalServerError, err, "")
|
|
return
|
|
}
|
|
app.OK(c, nil, "成功")
|
|
return
|
|
}
|
|
|
|
func OrderAndStockAnalysis(c *gin.Context) {
|
|
req := struct {
|
|
StoreId uint32 `json:"store_id"`
|
|
}{}
|
|
if c.ShouldBindJSON(&req) != nil {
|
|
logger.Errorf("para err")
|
|
app.Error(c, http.StatusBadRequest, errors.New("para err"), "参数错误")
|
|
return
|
|
}
|
|
|
|
poolData, err := models.CardPoolData(req.StoreId)
|
|
if err != nil {
|
|
logger.Error("err:", logger.Field("err", err))
|
|
app.Error(c, http.StatusInternalServerError, err, "")
|
|
return
|
|
}
|
|
orderRank, err := models.GameCardOrderRank(req.StoreId)
|
|
if err != nil {
|
|
logger.Error("err:", logger.Field("err", err))
|
|
app.Error(c, http.StatusInternalServerError, err, "")
|
|
return
|
|
}
|
|
ret := make(map[string]interface{}, 0)
|
|
ret["pool_data"] = poolData
|
|
ret["order_rank"] = orderRank
|
|
app.OK(c, ret, "成功")
|
|
return
|
|
}
|
|
|
|
func GameCardStockAnalysis(c *gin.Context) {
|
|
req := struct {
|
|
SortType uint32 `json:"sort_type"` // 1-总库存 2-库存 3-用户持有 4-订单数量
|
|
SortDirection uint32 `json:"sort_direction"` // 1-升序 2-降序
|
|
StoreId uint32 `json:"store_id"`
|
|
PageNum uint32 `json:"pageIndex"`
|
|
PageSize uint32 `json:"page_size"`
|
|
Name string `json:"name"`
|
|
}{}
|
|
if c.ShouldBindJSON(&req) != nil {
|
|
logger.Errorf("para err")
|
|
app.Error(c, http.StatusBadRequest, errors.New("para err"), "参数错误")
|
|
return
|
|
}
|
|
|
|
resp, err := models.GameCardStockList(req.Name, req.SortType, req.SortDirection, req.StoreId, req.PageNum, req.PageSize)
|
|
if err != nil {
|
|
logger.Error("err:", logger.Field("err", err))
|
|
app.Error(c, http.StatusInternalServerError, err, "")
|
|
return
|
|
}
|
|
//ret := make(map[string]interface{}, 0)
|
|
//ret["list"] = stockList
|
|
//ret["count"] = total
|
|
//ret["page_index"] = req.PageNum
|
|
app.OK(c, resp, "")
|
|
return
|
|
}
|
|
|
|
func GameCardLabelAdd(c *gin.Context) {
|
|
req := struct {
|
|
GameCardId uint32 `json:"game_card_id"`
|
|
Labels []string `json:"labels"`
|
|
}{}
|
|
if c.ShouldBindJSON(&req) != nil {
|
|
logger.Errorf("para err")
|
|
app.Error(c, http.StatusBadRequest, errors.New("para err"), "参数错误")
|
|
return
|
|
}
|
|
for i, label := range req.Labels {
|
|
label = strings.Replace(label, " ", "", -1)
|
|
label = strings.Replace(label, "\n", "", -1)
|
|
req.Labels[i] = label
|
|
}
|
|
var gameLabels []models.GameCardLabel
|
|
err := orm.Eloquent.Table("game_card_label").Where("game_card_id=?", req.GameCardId).
|
|
//Where("game_label in (?)", req.Labels).Find(&gameLabels).Error
|
|
Find(&gameLabels).Error
|
|
if err != nil {
|
|
logger.Errorf("err:", logger.Field("err", err))
|
|
app.Error(c, http.StatusInternalServerError, err, "查询失败")
|
|
return
|
|
}
|
|
isRepeat := false
|
|
labelMap := make(map[string]uint32)
|
|
if len(gameLabels) > 0 {
|
|
isRepeat = true
|
|
for i, _ := range gameLabels {
|
|
labelMap[gameLabels[i].GameLabel] = gameLabels[i].GameCardId
|
|
}
|
|
}
|
|
|
|
for i, _ := range req.Labels {
|
|
if isRepeat {
|
|
_, ok := labelMap[req.Labels[i]]
|
|
if ok {
|
|
continue
|
|
}
|
|
}
|
|
if req.Labels[i] == "" {
|
|
continue
|
|
}
|
|
|
|
err := orm.Eloquent.Create(&models.GameCardLabel{
|
|
GameCardId: req.GameCardId,
|
|
GameLabel: req.Labels[i],
|
|
}).Error
|
|
if err != nil {
|
|
logger.Error("create game card label err")
|
|
}
|
|
}
|
|
for i, _ := range req.Labels {
|
|
delete(labelMap, req.Labels[i])
|
|
}
|
|
labs := make([]string, 0)
|
|
for k, _ := range labelMap {
|
|
labs = append(labs, k)
|
|
}
|
|
err = orm.Eloquent.Table("game_card_label").Where("game_card_id=?", req.GameCardId).
|
|
Where("game_label in (?)", labs).Delete(&models.GameCardLabel{}).Error
|
|
if err != nil {
|
|
logger.Error("delete game card label err:", logger.Field("err", err))
|
|
}
|
|
|
|
app.OK(c, nil, "操作成功")
|
|
}
|
|
|
|
func GameCardLabelList(c *gin.Context) {
|
|
req := struct {
|
|
GameCardId uint32 `json:"game_card_id"`
|
|
}{}
|
|
if c.ShouldBindJSON(&req) != nil {
|
|
logger.Errorf("para err")
|
|
app.Error(c, http.StatusBadRequest, errors.New("para err"), "参数错误")
|
|
return
|
|
}
|
|
var gameLabels []models.GameCardLabel
|
|
err := orm.Eloquent.Table("game_card_label").Where("game_card_id=?", req.GameCardId).
|
|
Find(&gameLabels).Error
|
|
if err != nil {
|
|
logger.Errorf("err:", logger.Field("err", err))
|
|
app.Error(c, http.StatusInternalServerError, err, "查询失败")
|
|
return
|
|
}
|
|
|
|
app.OK(c, gameLabels, "")
|
|
}
|