1.新增首页分类相关接口；

app/admin/apis/goodsmanage/index.go

@@ -5,6 +5,7 @@ import (
 	"github.com/gin-gonic/gin"
 	"go-admin/app/admin/models"
 	"go-admin/logger"
+	"go-admin/tools"
 	"go-admin/tools/app"
 	"net/http"
 )
@@ -71,3 +72,129 @@ func HomeCarouselModify(c *gin.Context) {
 	}
 	app.OK(c, carousel, "")
 }
+
+// HomeCategoryList 首页分类-列表
+// @Summary 首页分类-列表
+// @Tags 首页分类，V1.4.5
+// @Produce json
+// @Accept json
+// @Param request body models.HomeCategoryListReq true "首页分类-列表模型"
+// @Success 200 {object} models.HomeCategoryListResp
+// @Router /api/v1/home_category/list [post]
+func HomeCategoryList(c *gin.Context) {
+	req := &models.HomeCategoryListReq{}
+	if err := c.ShouldBindJSON(&req); err != nil {
+		logger.Error("ShouldBindJSON err:", logger.Field("err", err))
+		app.Error(c, http.StatusBadRequest, errors.New("para err"), "参数错误")
+		return
+	}
+
+	resp, err := req.List()
+	if err != nil {
+		logger.Error("HomeCategoryList err:", logger.Field("err", err))
+		app.Error(c, http.StatusInternalServerError, err, "获取失败"+err.Error())
+		return
+	}
+
+	app.OK(c, resp, "OK")
+	return
+}
+
+// HomeCategoryAdd 首页分类-新增
+// @Summary 首页分类-新增
+// @Tags 首页分类，V1.4.5
+// @Produce json
+// @Accept json
+// @Param request body models.HomeCategoryAddReq true "首页分类-新增模型"
+// @Success 200 {object} app.Response
+// @Router /api/v1/home_category/add [post]
+func HomeCategoryAdd(c *gin.Context) {
+	req := new(models.HomeCategoryAddReq)
+	if err := c.ShouldBindJSON(&req); err != nil {
+		logger.Error("ShouldBindJSON err:", logger.Field("err", err))
+		app.Error(c, http.StatusBadRequest, errors.New("para err"), "参数错误"+err.Error())
+		return
+	}
+
+	err := tools.Validate(req) //必填参数校验
+	if err != nil {
+		app.Error(c, http.StatusBadRequest, err, err.Error())
+		return
+	}
+
+	err = models.CreateHomeCategory(req)
+	if err != nil {
+		logger.Error("CreateErpMarketingCoupon err:", logger.Field("err", err))
+		app.Error(c, http.StatusInternalServerError, err, err.Error())
+		return
+	}
+
+	app.OK(c, nil, "新增成功")
+	return
+}
+
+// HomeCategoryEdit 首页分类-编辑
+// @Summary 首页分类-编辑
+// @Tags 首页分类，V1.4.5
+// @Produce json
+// @Accept json
+// @Param request body models.HomeCategoryEditReq true "首页分类-编辑模型"
+// @Success 200 {object} models.HomeCategory
+// @Router /api/v1/home_category/edit [post]
+func HomeCategoryEdit(c *gin.Context) {
+	req := new(models.HomeCategoryEditReq)
+	if err := c.ShouldBindJSON(&req); err != nil {
+		logger.Error("ShouldBindJSON err:", logger.Field("err", err))
+		app.Error(c, http.StatusBadRequest, errors.New("para err"), "参数错误"+err.Error())
+		return
+	}
+
+	err := tools.Validate(req) //必填参数校验
+	if err != nil {
+		app.Error(c, http.StatusBadRequest, err, err.Error())
+		return
+	}
+
+	// 更新订单信息
+	homeCategory, err := models.EditHomeCategory(req)
+	if err != nil {
+		logger.Error("EditErpPurchaseOrder err:", logger.Field("err", err))
+		app.Error(c, http.StatusInternalServerError, err, "编辑失败:"+err.Error())
+		return
+	}
+
+	app.OK(c, homeCategory, "success")
+}
+
+// HomeCategoryDelete 首页分类-删除
+// @Summary  首页分类-删除
+// @Tags 首页分类，V1.4.5
+// @Produce json
+// @Accept json
+// @Param request body models.HomeCategoryDeleteReq true " 首页分类-删除模型"
+// @Success 200 {object} app.Response
+// @Router /api/v1/home_category/delete [post]
+func HomeCategoryDelete(c *gin.Context) {
+	var req = new(models.HomeCategoryDeleteReq)
+	if err := c.ShouldBindJSON(&req); err != nil {
+		logger.Error("ShouldBindJSON err:", logger.Field("err", err))
+		app.Error(c, http.StatusBadRequest, err, "参数错误:"+err.Error())
+		return
+	}
+
+	err := tools.Validate(req) //必填参数校验
+	if err != nil {
+		app.Error(c, http.StatusBadRequest, err, err.Error())
+		return
+	}
+
+	err = models.DeleteHomeCategory(req)
+	if err != nil {
+		logger.Error("DeleteErpMonthEndClosing err:", logger.Field("err", err))
+		app.Error(c, http.StatusInternalServerError, err, err.Error())
+		return
+	}
+
+	app.OK(c, nil, "删除成功")
+	return
+}

app/admin/models/home_category.go

@@ -0,0 +1,297 @@
+package models
+
+import (
+	"errors"
+	orm "go-admin/common/global"
+	"go-admin/logger"
+)
+
+// HomeCategory 首页分类表结构体
+type HomeCategory struct {
+	Model
+
+	Name      string         `json:"name"  gorm:"index"`       // 分类名称
+	SortOrder uint32         `json:"sort_order"  gorm:"index"` // 排序序号
+	State     uint32         `json:"state"  gorm:"index"`      // 状态：1-启用；2-隐藏
+	Games     []HomeGameList `json:"games" gorm:"-"`           // 关联的游戏
+}
+
+// HomeGameList 首页分类归属游戏
+type HomeGameList struct {
+	GameID    uint32 `json:"game_id"`    // 游戏ID
+	SortOrder uint32 `json:"sort_order"` // 排序序号
+	GameName  string `json:"game_name"`  // 游戏名称
+}
+
+// HomeCategoryGame 分类与游戏关联表结构体
+type HomeCategoryGame struct {
+	Model
+
+	HomeCategoryID uint32 `json:"home_category_id" gorm:"index"` // 首页分类ID，外键关联 HomeCategory
+	GameID         uint32 `json:"game_id"  gorm:"index"`         // 游戏ID，外键关联 GameCard
+	GameName       string `json:"game_name"`                     // 游戏名称
+	SortOrder      int    `json:"sort_order"  gorm:"index"`      // 归属游戏中排序序号
+}
+
+// HomeCategoryListReq 首页分类列表入参
+type HomeCategoryListReq struct {
+	Name      string `json:"name"`      // 优惠券名称
+	State     uint32 `json:"state"`     // 状态：1-启用；2-隐藏
+	PageIndex int    `json:"pageIndex"` // 页码
+	PageSize  int    `json:"pageSize"`  // 页面条数
+}
+
+// HomeCategoryListResp 首页分类列表出参
+type HomeCategoryListResp struct {
+	List      []HomeCategory `json:"list"`
+	Total     int            `json:"total"`     // 总条数
+	PageIndex int            `json:"pageIndex"` // 页码
+	PageSize  int            `json:"pageSize"`  // 页面条数
+}
+
+// List 查询采购订单列表
+func (m *HomeCategoryListReq) List() (*HomeCategoryListResp, error) {
+	resp := &HomeCategoryListResp{
+		PageIndex: m.PageIndex,
+		PageSize:  m.PageSize,
+	}
+	page := m.PageIndex - 1
+	if page < 0 {
+		page = 0
+	}
+	if m.PageSize == 0 {
+		m.PageSize = 10
+	}
+	qs := orm.Eloquent.Table("home_category")
+
+	if m.Name != "" {
+		qs = qs.Where("name=?", m.Name)
+	}
+	if m.State != 0 {
+		qs = qs.Where("state=?", m.State)
+	}
+
+	var count int64
+	err := qs.Count(&count).Error
+	if err != nil {
+		logger.Error("count err:", logger.Field("err", err))
+		return resp, err
+	}
+
+	resp.Total = int(count)
+	var orders []HomeCategory
+	err = qs.Order("id DESC").Offset(page * m.PageSize).Limit(m.PageSize).Find(&orders).Error
+	if err != nil && err != RecordNotFound {
+		logger.Error("home_category list err:", logger.Field("err", err))
+		return resp, err
+	}
+
+	// 组合关联的游戏数据
+	for i := range orders {
+		var games []HomeCategoryGame
+		err = orm.Eloquent.Table("home_category_game").Where("home_category_id = ?", orders[i].ID).Find(&games).Error
+		if err != nil {
+			logger.Error("home_category_game list err:", logger.Field("err", err))
+			return resp, err
+		}
+
+		// 将 HomeCategoryGame 转换为 HomeGameList
+		for _, game := range games {
+			orders[i].Games = append(orders[i].Games, HomeGameList{
+				GameID:    game.GameID,
+				SortOrder: uint32(game.SortOrder),
+				GameName:  game.GameName,
+			})
+		}
+	}
+
+	resp.List = orders
+	return resp, nil
+}
+
+// HomeCategoryAddReq 新增首页分类入参
+type HomeCategoryAddReq struct {
+	Name      string         `json:"name" validate:"required"`       // 分类名称
+	SortOrder uint32         `json:"sort_order" validate:"required"` // 排序序号
+	State     uint32         `json:"state" validate:"required"`      // 状态：1-启用；2-隐藏
+	Games     []HomeGameList `json:"games"`                          // 关联的游戏
+}
+
+// CreateHomeCategory 新增分类
+func CreateHomeCategory(req *HomeCategoryAddReq) error {
+	// 初始化首页分类数据
+	newHomeCategory := &HomeCategory{
+		Name:      req.Name,
+		SortOrder: req.SortOrder,
+		State:     req.State,
+	}
+
+	// 开启事务
+	tx := orm.Eloquent.Begin()
+	defer func() {
+		if r := recover(); r != nil {
+			tx.Rollback()
+		}
+	}()
+
+	// 插入首页分类记录
+	err := tx.Create(newHomeCategory).Error
+	if err != nil {
+		logger.Error("create home category err:", logger.Field("err", err))
+		tx.Rollback()
+		return err
+	}
+
+	// 如果 Games 不为空，插入分类与游戏关联记录
+	if len(req.Games) > 0 {
+		var homeCategoryGames []HomeCategoryGame
+		for _, game := range req.Games {
+			homeCategoryGames = append(homeCategoryGames, HomeCategoryGame{
+				HomeCategoryID: newHomeCategory.ID,
+				GameID:         game.GameID,
+				SortOrder:      int(game.SortOrder),
+				GameName:       game.GameName,
+			})
+		}
+
+		// 批量插入关联记录
+		err = tx.Create(&homeCategoryGames).Error
+		if err != nil {
+			logger.Error("create home category games err:", logger.Field("err", err))
+			tx.Rollback()
+			return err
+		}
+	}
+
+	// 提交事务
+	err = tx.Commit().Error
+	if err != nil {
+		logger.Error("commit transaction err:", logger.Field("err", err))
+		return err
+	}
+
+	return nil
+}
+
+// HomeCategoryDeleteReq 首页分类删除-入参
+type HomeCategoryDeleteReq struct {
+	HomeCategoryID uint32 `json:"home_category_id" validate:"required"` // 首页分类id
+}
+
+// DeleteHomeCategory 删除首页分类
+func DeleteHomeCategory(req *HomeCategoryDeleteReq) error {
+	// 开始事务
+	tx := orm.Eloquent.Begin()
+
+	defer func() {
+		if r := recover(); r != nil {
+			tx.Rollback()
+			panic(r)
+		}
+	}()
+
+	var categoryInfo HomeCategory
+
+	// 查询首页分类信息
+	err := tx.Table("home_category").Where("id = ?", req.HomeCategoryID).Find(&categoryInfo).Error
+	if err != nil {
+		logger.Error("home_category delete err:", logger.Field("err", err))
+		tx.Rollback()
+		return errors.New("未查询到分类")
+	}
+
+	// 删除关联的 HomeCategoryGame 数据
+	err = tx.Table("home_category_game").Where("home_category_id = ?", req.HomeCategoryID).Delete(&HomeCategoryGame{}).Error
+	if err != nil {
+		logger.Error("home_category_game delete err:", logger.Field("err", err))
+		tx.Rollback()
+		return errors.New("删除分类关联游戏失败")
+	}
+
+	// 删除首页分类数据
+	err = tx.Delete(&categoryInfo).Error
+	if err != nil {
+		logger.Error("home_category delete2 err:", logger.Field("err", err))
+		tx.Rollback()
+		return err
+	}
+
+	// 提交事务
+	err = tx.Commit().Error
+	if err != nil {
+		logger.Error("transaction commit err:", logger.Field("err", err))
+		return errors.New("事务提交失败")
+	}
+
+	return nil
+}
+
+// HomeCategoryEditReq 编辑首页分类-入参
+type HomeCategoryEditReq struct {
+	HomeCategoryID uint32         `json:"home_category_id" validate:"required"` // 首页分类id
+	Name           string         `json:"name" validate:"required"`             // 分类名称
+	SortOrder      uint32         `json:"sort_order" validate:"required"`       // 排序序号
+	State          uint32         `json:"state" validate:"required"`            // 状态：1-启用；2-隐藏
+	Games          []HomeGameList `json:"games"`                                // 关联的游戏
+}
+
+// EditHomeCategory 编辑首页分类
+func EditHomeCategory(req *HomeCategoryEditReq) (*HomeCategory, error) {
+	// 查询分类信息
+	var homeCategory HomeCategory
+	err := orm.Eloquent.Table("home_category").Where("id = ?", req.HomeCategoryID).Find(&homeCategory).Error
+	if err != nil {
+		logger.Error("home_category err:", logger.Field("err", err))
+		return nil, err
+	}
+
+	// 更新分类信息
+	homeCategory.Name = req.Name
+	homeCategory.SortOrder = req.SortOrder
+	homeCategory.State = req.State
+	err = orm.Eloquent.Table("home_category").Save(&homeCategory).Error
+	if err != nil {
+		logger.Error("update home_category err:", logger.Field("err", err))
+		return nil, err
+	}
+
+	// 删除旧的 HomeCategoryGame 数据
+	err = orm.Eloquent.Table("home_category_game").Where("home_category_id = ?", homeCategory.ID).Delete(&HomeCategoryGame{}).Error
+	if err != nil {
+		logger.Error("delete home_category_game err:", logger.Field("err", err))
+		return nil, err
+	}
+
+	// 插入新的 HomeCategoryGame 数据
+	var newGames []HomeCategoryGame
+	for _, game := range req.Games {
+		newGames = append(newGames, HomeCategoryGame{
+			HomeCategoryID: homeCategory.ID,
+			GameID:         game.GameID,
+			GameName:       game.GameName,
+			SortOrder:      int(game.SortOrder),
+		})
+	}
+
+	if len(newGames) > 0 {
+		err = orm.Eloquent.Table("home_category_game").Create(&newGames).Error
+		if err != nil {
+			logger.Error("insert home_category_game err:", logger.Field("err", err))
+			return nil, err
+		}
+	}
+
+	// 将 HomeCategoryGame 转换为 HomeGameList
+	var gameList []HomeGameList
+	for _, game := range newGames {
+		gameList = append(gameList, HomeGameList{
+			GameID:    game.GameID,
+			SortOrder: uint32(game.SortOrder),
+			GameName:  game.GameName,
+		})
+	}
+
+	homeCategory.Games = gameList
+
+	return &homeCategory, nil
+}

app/admin/router/goodsmanage.go

@@ -61,4 +61,11 @@ func registerGoodsManageUnAuthRouter(v1 *gin.RouterGroup) {
 		slideshow.POST("/modify", goodsmanage.HomeCarouselModify) // 轮播图修改
 	}
 
+	homeCategory := v1.Group("/home_category") // 首页分类
+	{
+		homeCategory.POST("/list", goodsmanage.HomeCategoryList)     // 列表
+		homeCategory.POST("/add", goodsmanage.HomeCategoryAdd)       // 新增
+		homeCategory.POST("/edit", goodsmanage.HomeCategoryEdit)     // 编辑
+		homeCategory.POST("/delete", goodsmanage.HomeCategoryDelete) // 删除
+	}
 }

docs/docs.go

@@ -3101,6 +3101,138 @@ const docTemplate = `{
                 }
             }
         },
+        "/api/v1/home_category/add": {
+            "post": {
+                "consumes": [
+                    "application/json"
+                ],
+                "produces": [
+                    "application/json"
+                ],
+                "tags": [
+                    "首页分类，V1.4.5"
+                ],
+                "summary": "首页分类-新增",
+                "parameters": [
+                    {
+                        "description": "首页分类-新增模型",
+                        "name": "request",
+                        "in": "body",
+                        "required": true,
+                        "schema": {
+                            "$ref": "#/definitions/models.HomeCategoryAddReq"
+                        }
+                    }
+                ],
+                "responses": {
+                    "200": {
+                        "description": "OK",
+                        "schema": {
+                            "$ref": "#/definitions/app.Response"
+                        }
+                    }
+                }
+            }
+        },
+        "/api/v1/home_category/delete": {
+            "post": {
+                "consumes": [
+                    "application/json"
+                ],
+                "produces": [
+                    "application/json"
+                ],
+                "tags": [
+                    "首页分类，V1.4.5"
+                ],
+                "summary": "首页分类-删除",
+                "parameters": [
+                    {
+                        "description": " 首页分类-删除模型",
+                        "name": "request",
+                        "in": "body",
+                        "required": true,
+                        "schema": {
+                            "$ref": "#/definitions/models.HomeCategoryDeleteReq"
+                        }
+                    }
+                ],
+                "responses": {
+                    "200": {
+                        "description": "OK",
+                        "schema": {
+                            "$ref": "#/definitions/app.Response"
+                        }
+                    }
+                }
+            }
+        },
+        "/api/v1/home_category/edit": {
+            "post": {
+                "consumes": [
+                    "application/json"
+                ],
+                "produces": [
+                    "application/json"
+                ],
+                "tags": [
+                    "首页分类，V1.4.5"
+                ],
+                "summary": "首页分类-编辑",
+                "parameters": [
+                    {
+                        "description": "首页分类-编辑模型",
+                        "name": "request",
+                        "in": "body",
+                        "required": true,
+                        "schema": {
+                            "$ref": "#/definitions/models.HomeCategoryEditReq"
+                        }
+                    }
+                ],
+                "responses": {
+                    "200": {
+                        "description": "OK",
+                        "schema": {
+                            "$ref": "#/definitions/models.HomeCategory"
+                        }
+                    }
+                }
+            }
+        },
+        "/api/v1/home_category/list": {
+            "post": {
+                "consumes": [
+                    "application/json"
+                ],
+                "produces": [
+                    "application/json"
+                ],
+                "tags": [
+                    "首页分类，V1.4.5"
+                ],
+                "summary": "首页分类-列表",
+                "parameters": [
+                    {
+                        "description": "首页分类-列表模型",
+                        "name": "request",
+                        "in": "body",
+                        "required": true,
+                        "schema": {
+                            "$ref": "#/definitions/models.HomeCategoryListReq"
+                        }
+                    }
+                ],
+                "responses": {
+                    "200": {
+                        "description": "OK",
+                        "schema": {
+                            "$ref": "#/definitions/models.HomeCategoryListResp"
+                        }
+                    }
+                }
+            }
+        },
         "/api/v1/inventory/add_remark": {
             "post": {
                 "consumes": [
@@ -14046,6 +14178,178 @@ const docTemplate = `{
                 }
             }
         },
+        "models.HomeCategory": {
+            "type": "object",
+            "properties": {
+                "createdAt": {
+                    "description": "创建时间",
+                    "type": "string"
+                },
+                "games": {
+                    "description": "关联的游戏",
+                    "type": "array",
+                    "items": {
+                        "$ref": "#/definitions/models.HomeGameList"
+                    }
+                },
+                "id": {
+                    "description": "数据库记录编号",
+                    "type": "integer"
+                },
+                "name": {
+                    "description": "分类名称",
+                    "type": "string"
+                },
+                "sort_order": {
+                    "description": "排序序号",
+                    "type": "integer"
+                },
+                "state": {
+                    "description": "状态：1-启用；2-隐藏",
+                    "type": "integer"
+                },
+                "updatedAt": {
+                    "description": "更新时间",
+                    "type": "string"
+                }
+            }
+        },
+        "models.HomeCategoryAddReq": {
+            "type": "object",
+            "required": [
+                "name",
+                "sort_order",
+                "state"
+            ],
+            "properties": {
+                "games": {
+                    "description": "关联的游戏",
+                    "type": "array",
+                    "items": {
+                        "$ref": "#/definitions/models.HomeGameList"
+                    }
+                },
+                "name": {
+                    "description": "分类名称",
+                    "type": "string"
+                },
+                "sort_order": {
+                    "description": "排序序号",
+                    "type": "integer"
+                },
+                "state": {
+                    "description": "状态：1-启用；2-隐藏",
+                    "type": "integer"
+                }
+            }
+        },
+        "models.HomeCategoryDeleteReq": {
+            "type": "object",
+            "required": [
+                "home_category_id"
+            ],
+            "properties": {
+                "home_category_id": {
+                    "description": "首页分类id",
+                    "type": "integer"
+                }
+            }
+        },
+        "models.HomeCategoryEditReq": {
+            "type": "object",
+            "required": [
+                "home_category_id",
+                "name",
+                "sort_order",
+                "state"
+            ],
+            "properties": {
+                "games": {
+                    "description": "关联的游戏",
+                    "type": "array",
+                    "items": {
+                        "$ref": "#/definitions/models.HomeGameList"
+                    }
+                },
+                "home_category_id": {
+                    "description": "首页分类id",
+                    "type": "integer"
+                },
+                "name": {
+                    "description": "分类名称",
+                    "type": "string"
+                },
+                "sort_order": {
+                    "description": "排序序号",
+                    "type": "integer"
+                },
+                "state": {
+                    "description": "状态：1-启用；2-隐藏",
+                    "type": "integer"
+                }
+            }
+        },
+        "models.HomeCategoryListReq": {
+            "type": "object",
+            "properties": {
+                "name": {
+                    "description": "优惠券名称",
+                    "type": "string"
+                },
+                "pageIndex": {
+                    "description": "页码",
+                    "type": "integer"
+                },
+                "pageSize": {
+                    "description": "页面条数",
+                    "type": "integer"
+                },
+                "state": {
+                    "description": "状态：1-启用；2-隐藏",
+                    "type": "integer"
+                }
+            }
+        },
+        "models.HomeCategoryListResp": {
+            "type": "object",
+            "properties": {
+                "list": {
+                    "type": "array",
+                    "items": {
+                        "$ref": "#/definitions/models.HomeCategory"
+                    }
+                },
+                "pageIndex": {
+                    "description": "页码",
+                    "type": "integer"
+                },
+                "pageSize": {
+                    "description": "页面条数",
+                    "type": "integer"
+                },
+                "total": {
+                    "description": "总条数",
+                    "type": "integer"
+                }
+            }
+        },
+        "models.HomeGameList": {
+            "type": "object",
+            "properties": {
+                "game_id": {
+                    "description": "游戏ID",
+                    "type": "integer"
+                },
+                "game_name": {
+                    "description": "游戏名称",
+                    "type": "string"
+                },
+                "sort_order": {
+                    "description": "排序序号",
+                    "type": "integer"
+                }
+            }
+        },
         "models.InsertSysUserReq": {
             "type": "object",
             "properties": {

docs/swagger.json

@@ -3090,6 +3090,138 @@
                 }
             }
         },
+        "/api/v1/home_category/add": {
+            "post": {
+                "consumes": [
+                    "application/json"
+                ],
+                "produces": [
+                    "application/json"
+                ],
+                "tags": [
+                    "首页分类，V1.4.5"
+                ],
+                "summary": "首页分类-新增",
+                "parameters": [
+                    {
+                        "description": "首页分类-新增模型",
+                        "name": "request",
+                        "in": "body",
+                        "required": true,
+                        "schema": {
+                            "$ref": "#/definitions/models.HomeCategoryAddReq"
+                        }
+                    }
+                ],
+                "responses": {
+                    "200": {
+                        "description": "OK",
+                        "schema": {
+                            "$ref": "#/definitions/app.Response"
+                        }
+                    }
+                }
+            }
+        },
+        "/api/v1/home_category/delete": {
+            "post": {
+                "consumes": [
+                    "application/json"
+                ],
+                "produces": [
+                    "application/json"
+                ],
+                "tags": [
+                    "首页分类，V1.4.5"
+                ],
+                "summary": "首页分类-删除",
+                "parameters": [
+                    {
+                        "description": " 首页分类-删除模型",
+                        "name": "request",
+                        "in": "body",
+                        "required": true,
+                        "schema": {
+                            "$ref": "#/definitions/models.HomeCategoryDeleteReq"
+                        }
+                    }
+                ],
+                "responses": {
+                    "200": {
+                        "description": "OK",
+                        "schema": {
+                            "$ref": "#/definitions/app.Response"
+                        }
+                    }
+                }
+            }
+        },
+        "/api/v1/home_category/edit": {
+            "post": {
+                "consumes": [
+                    "application/json"
+                ],
+                "produces": [
+                    "application/json"
+                ],
+                "tags": [
+                    "首页分类，V1.4.5"
+                ],
+                "summary": "首页分类-编辑",
+                "parameters": [
+                    {
+                        "description": "首页分类-编辑模型",
+                        "name": "request",
+                        "in": "body",
+                        "required": true,
+                        "schema": {
+                            "$ref": "#/definitions/models.HomeCategoryEditReq"
+                        }
+                    }
+                ],
+                "responses": {
+                    "200": {
+                        "description": "OK",
+                        "schema": {
+                            "$ref": "#/definitions/models.HomeCategory"
+                        }
+                    }
+                }
+            }
+        },
+        "/api/v1/home_category/list": {
+            "post": {
+                "consumes": [
+                    "application/json"
+                ],
+                "produces": [
+                    "application/json"
+                ],
+                "tags": [
+                    "首页分类，V1.4.5"
+                ],
+                "summary": "首页分类-列表",
+                "parameters": [
+                    {
+                        "description": "首页分类-列表模型",
+                        "name": "request",
+                        "in": "body",
+                        "required": true,
+                        "schema": {
+                            "$ref": "#/definitions/models.HomeCategoryListReq"
+                        }
+                    }
+                ],
+                "responses": {
+                    "200": {
+                        "description": "OK",
+                        "schema": {
+                            "$ref": "#/definitions/models.HomeCategoryListResp"
+                        }
+                    }
+                }
+            }
+        },
         "/api/v1/inventory/add_remark": {
             "post": {
                 "consumes": [
@@ -14035,6 +14167,178 @@
                 }
             }
         },
+        "models.HomeCategory": {
+            "type": "object",
+            "properties": {
+                "createdAt": {
+                    "description": "创建时间",
+                    "type": "string"
+                },
+                "games": {
+                    "description": "关联的游戏",
+                    "type": "array",
+                    "items": {
+                        "$ref": "#/definitions/models.HomeGameList"
+                    }
+                },
+                "id": {
+                    "description": "数据库记录编号",
+                    "type": "integer"
+                },
+                "name": {
+                    "description": "分类名称",
+                    "type": "string"
+                },
+                "sort_order": {
+                    "description": "排序序号",
+                    "type": "integer"
+                },
+                "state": {
+                    "description": "状态：1-启用；2-隐藏",
+                    "type": "integer"
+                },
+                "updatedAt": {
+                    "description": "更新时间",
+                    "type": "string"
+                }
+            }
+        },
+        "models.HomeCategoryAddReq": {
+            "type": "object",
+            "required": [
+                "name",
+                "sort_order",
+                "state"
+            ],
+            "properties": {
+                "games": {
+                    "description": "关联的游戏",
+                    "type": "array",
+                    "items": {
+                        "$ref": "#/definitions/models.HomeGameList"
+                    }
+                },
+                "name": {
+                    "description": "分类名称",
+                    "type": "string"
+                },
+                "sort_order": {
+                    "description": "排序序号",
+                    "type": "integer"
+                },
+                "state": {
+                    "description": "状态：1-启用；2-隐藏",
+                    "type": "integer"
+                }
+            }
+        },
+        "models.HomeCategoryDeleteReq": {
+            "type": "object",
+            "required": [
+                "home_category_id"
+            ],
+            "properties": {
+                "home_category_id": {
+                    "description": "首页分类id",
+                    "type": "integer"
+                }
+            }
+        },
+        "models.HomeCategoryEditReq": {
+            "type": "object",
+            "required": [
+                "home_category_id",
+                "name",
+                "sort_order",
+                "state"
+            ],
+            "properties": {
+                "games": {
+                    "description": "关联的游戏",
+                    "type": "array",
+                    "items": {
+                        "$ref": "#/definitions/models.HomeGameList"
+                    }
+                },
+                "home_category_id": {
+                    "description": "首页分类id",
+                    "type": "integer"
+                },
+                "name": {
+                    "description": "分类名称",
+                    "type": "string"
+                },
+                "sort_order": {
+                    "description": "排序序号",
+                    "type": "integer"
+                },
+                "state": {
+                    "description": "状态：1-启用；2-隐藏",
+                    "type": "integer"
+                }
+            }
+        },
+        "models.HomeCategoryListReq": {
+            "type": "object",
+            "properties": {
+                "name": {
+                    "description": "优惠券名称",
+                    "type": "string"
+                },
+                "pageIndex": {
+                    "description": "页码",
+                    "type": "integer"
+                },
+                "pageSize": {
+                    "description": "页面条数",
+                    "type": "integer"
+                },
+                "state": {
+                    "description": "状态：1-启用；2-隐藏",
+                    "type": "integer"
+                }
+            }
+        },
+        "models.HomeCategoryListResp": {
+            "type": "object",
+            "properties": {
+                "list": {
+                    "type": "array",
+                    "items": {
+                        "$ref": "#/definitions/models.HomeCategory"
+                    }
+                },
+                "pageIndex": {
+                    "description": "页码",
+                    "type": "integer"
+                },
+                "pageSize": {
+                    "description": "页面条数",
+                    "type": "integer"
+                },
+                "total": {
+                    "description": "总条数",
+                    "type": "integer"
+                }
+            }
+        },
+        "models.HomeGameList": {
+            "type": "object",
+            "properties": {
+                "game_id": {
+                    "description": "游戏ID",
+                    "type": "integer"
+                },
+                "game_name": {
+                    "description": "游戏名称",
+                    "type": "string"
+                },
+                "sort_order": {
+                    "description": "排序序号",
+                    "type": "integer"
+                }
+            }
+        },
         "models.InsertSysUserReq": {
             "type": "object",
             "properties": {

docs/swagger.yaml

@@ -5193,6 +5193,129 @@ definitions:
         description: 1-所有用户 2-会员 3-非会员 4-指定用户
         type: integer
     type: object
+  models.HomeCategory:
+    properties:
+      createdAt:
+        description: 创建时间
+        type: string
+      games:
+        description: 关联的游戏
+        items:
+          $ref: '#/definitions/models.HomeGameList'
+        type: array
+      id:
+        description: 数据库记录编号
+        type: integer
+      name:
+        description: 分类名称
+        type: string
+      sort_order:
+        description: 排序序号
+        type: integer
+      state:
+        description: 状态：1-启用；2-隐藏
+        type: integer
+      updatedAt:
+        description: 更新时间
+        type: string
+    type: object
+  models.HomeCategoryAddReq:
+    properties:
+      games:
+        description: 关联的游戏
+        items:
+          $ref: '#/definitions/models.HomeGameList'
+        type: array
+      name:
+        description: 分类名称
+        type: string
+      sort_order:
+        description: 排序序号
+        type: integer
+      state:
+        description: 状态：1-启用；2-隐藏
+        type: integer
+    required:
+    - name
+    - sort_order
+    - state
+    type: object
+  models.HomeCategoryDeleteReq:
+    properties:
+      home_category_id:
+        description: 首页分类id
+        type: integer
+    required:
+    - home_category_id
+    type: object
+  models.HomeCategoryEditReq:
+    properties:
+      games:
+        description: 关联的游戏
+        items:
+          $ref: '#/definitions/models.HomeGameList'
+        type: array
+      home_category_id:
+        description: 首页分类id
+        type: integer
+      name:
+        description: 分类名称
+        type: string
+      sort_order:
+        description: 排序序号
+        type: integer
+      state:
+        description: 状态：1-启用；2-隐藏
+        type: integer
+    required:
+    - home_category_id
+    - name
+    - sort_order
+    - state
+    type: object
+  models.HomeCategoryListReq:
+    properties:
+      name:
+        description: 优惠券名称
+        type: string
+      pageIndex:
+        description: 页码
+        type: integer
+      pageSize:
+        description: 页面条数
+        type: integer
+      state:
+        description: 状态：1-启用；2-隐藏
+        type: integer
+    type: object
+  models.HomeCategoryListResp:
+    properties:
+      list:
+        items:
+          $ref: '#/definitions/models.HomeCategory'
+        type: array
+      pageIndex:
+        description: 页码
+        type: integer
+      pageSize:
+        description: 页面条数
+        type: integer
+      total:
+        description: 总条数
+        type: integer
+    type: object
+  models.HomeGameList:
+    properties:
+      game_id:
+        description: 游戏ID
+        type: integer
+      game_name:
+        description: 游戏名称
+        type: string
+      sort_order:
+        description: 排序序号
+        type: integer
+    type: object
   models.InsertSysUserReq:
     properties:
       account_type:
@@ -11187,6 +11310,90 @@ paths:
       tags:
       - 短信群发
       - V1.2.0
+  /api/v1/home_category/add:
+    post:
+      consumes:
+      - application/json
+      parameters:
+      - description: 首页分类-新增模型
+        in: body
+        name: request
+        required: true
+        schema:
+          $ref: '#/definitions/models.HomeCategoryAddReq'
+      produces:
+      - application/json
+      responses:
+        "200":
+          description: OK
+          schema:
+            $ref: '#/definitions/app.Response'
+      summary: 首页分类-新增
+      tags:
+      - 首页分类，V1.4.5
+  /api/v1/home_category/delete:
+    post:
+      consumes:
+      - application/json
+      parameters:
+      - description: ' 首页分类-删除模型'
+        in: body
+        name: request
+        required: true
+        schema:
+          $ref: '#/definitions/models.HomeCategoryDeleteReq'
+      produces:
+      - application/json
+      responses:
+        "200":
+          description: OK
+          schema:
+            $ref: '#/definitions/app.Response'
+      summary: 首页分类-删除
+      tags:
+      - 首页分类，V1.4.5
+  /api/v1/home_category/edit:
+    post:
+      consumes:
+      - application/json
+      parameters:
+      - description: 首页分类-编辑模型
+        in: body
+        name: request
+        required: true
+        schema:
+          $ref: '#/definitions/models.HomeCategoryEditReq'
+      produces:
+      - application/json
+      responses:
+        "200":
+          description: OK
+          schema:
+            $ref: '#/definitions/models.HomeCategory'
+      summary: 首页分类-编辑
+      tags:
+      - 首页分类，V1.4.5
+  /api/v1/home_category/list:
+    post:
+      consumes:
+      - application/json
+      parameters:
+      - description: 首页分类-列表模型
+        in: body
+        name: request
+        required: true
+        schema:
+          $ref: '#/definitions/models.HomeCategoryListReq'
+      produces:
+      - application/json
+      responses:
+        "200":
+          description: OK
+          schema:
+            $ref: '#/definitions/models.HomeCategoryListResp'
+      summary: 首页分类-列表
+      tags:
+      - 首页分类，V1.4.5
   /api/v1/inventory/add_remark:
     post:
       consumes: