1. form

  1. package forms
  3. type CategoryForm struct {
  4.     Name    string `form:"name" json:"name" binding:"required,min=3,max=20"`
  5.     ParentCategory int32 `form:"parent" json:"parent"`
  6.     Level int32 `form:"level" json:"level" binding:"required,oneof=1 2 3"`
  7.     IsTab *bool `form:"is_tab" json:"is_tab" binding:"required"`
  8. }
  10. type UpdateCategoryForm struct {
  11.     Name    string `form:"name" json:"name" binding:"required,min=3,max=20"`
  12.     IsTab *bool `form:"is_tab" json:"is_tab"`
  13. }

2. handler

  1. package category
  3. import (
  4.     "context"
  5.     "encoding/json"
  6.     "github.com/gin-gonic/gin"
  7.     "github.com/go-playground/validator/v10"
  8.     empty "github.com/golang/protobuf/ptypes/empty"
  9.     "go.uber.org/zap"
  10.     "google.golang.org/grpc/codes"
  11.     "google.golang.org/grpc/status"
  12.     "mxshop-api/goods-web/forms"
  13.     "mxshop-api/goods-web/global"
  14.     "mxshop-api/goods-web/proto"
  15.     "net/http"
  16.     "strconv"
  17.     "strings"
  18. )
  20. func removeTopStruct(fileds map[string]string) map[string]string{
  21.     rsp := map[string]string{}
  22.     for field, err := range fileds {
  23.         rsp[field[strings.Index(field, ".")+1:]] = err
  24.     }
  25.     return rsp
  26. }
  29. func HandleGrpcErrorToHttp(err error, c *gin.Context) {
  30.     //将grpc的code转换成http的状态码
  31.     if err != nil {
  32.         if e, ok := status.FromError(err); ok {
  33.             switch e.Code() {
  34.             case codes.NotFound:
  35.                 c.JSON(http.StatusNotFound, gin.H{
  36.                     "msg": e.Message(),
  37.                 })
  38.             case codes.Internal:
  39.                 c.JSON(http.StatusInternalServerError, gin.H{
  40.                     "msg:": "内部错误",
  41.                 })
  42.             case codes.InvalidArgument:
  43.                 c.JSON(http.StatusBadRequest, gin.H{
  44.                     "msg": "参数错误",
  45.                 })
  46.             case codes.Unavailable:
  47.                 c.JSON(http.StatusInternalServerError, gin.H{
  48.                     "msg": "用户服务不可用",
  49.                 })
  50.             default:
  51.                 c.JSON(http.StatusInternalServerError, gin.H{
  52.                     "msg": e.Code(),
  53.                 })
  54.             }
  55.             return
  56.         }
  57.     }
  58. }
  60. func HandleValidatorError(c *gin.Context, err error){
  61.     errs, ok := err.(validator.ValidationErrors)
  62.     if !ok {
  63.         c.JSON(http.StatusOK, gin.H{
  64.             "msg":err.Error(),
  65.         })
  66.     }
  67.     c.JSON(http.StatusBadRequest, gin.H{
  68.         "error": removeTopStruct(errs.Translate(global.Trans)),
  69.     })
  70.     return
  71. }
  74. func List(ctx *gin.Context) {
  75.     r, err := global.GoodsSrvClient.GetAllCategorysList(context.Background(), &empty.Empty{})
  76.     if err != nil {
  77.         HandleGrpcErrorToHttp(err, ctx)
  78.         return
  79.     }
  81.     data := make([]interface{}, 0)
  82.     err = json.Unmarshal([]byte(r.JsonData), &data)
  83.     if err != nil {
  84.         zap.S().Errorw("[List] 查询 【分类列表】失败： ", err.Error())
  85.     }
  87.     ctx.JSON(http.StatusOK, data)
  88. }
  90. func Detail(ctx *gin.Context) {
  91.     id := ctx.Param("id")
  92.     i, err := strconv.ParseInt(id, 10, 32)
  93.     if err != nil {
  94.         ctx.Status(http.StatusNotFound)
  95.         return
  96.     }
  98.     reMap := make(map[string]interface{})
  99.     subCategorys := make([]interface{}, 0)
  100.     if r, err := global.GoodsSrvClient.GetSubCategory(context.Background(), &proto.CategoryListRequest{
  101.         Id: int32(i),
  102.     });err != nil {
  103.         HandleGrpcErrorToHttp(err, ctx)
  104.         return
  105.     }else{
  106.         for _, value := range r.SubCategorys{
  107.             subCategorys = append(subCategorys, map[string]interface{}{
  108.                 "id": value.Id,
  109.                 "name": value.Name,
  110.                 "level": value.Level,
  111.                 "parent_category": value.ParentCategory,
  112.                 "is_tab": value.IsTab,
  113.             })
  114.         }
  115.         reMap["id"] = r.Info.Id
  116.         reMap["name"] = r.Info.Name
  117.         reMap["level"] = r.Info.Level
  118.         reMap["parent_category"] = r.Info.ParentCategory
  119.         reMap["is_tab"] = r.Info.IsTab
  120.         reMap["sub_categorys"] = subCategorys
  122.         ctx.JSON(http.StatusOK, reMap)
  123.     }
  124.     return
  125. }
  127. func New(ctx *gin.Context) {
  128.     categoryForm := forms.CategoryForm{}
  129.     if err := ctx.ShouldBindJSON(&categoryForm); err != nil {
  130.         HandleValidatorError(ctx, err)
  131.         return
  132.     }
  134.     rsp, err := global.GoodsSrvClient.CreateCategory(context.Background(), &proto.CategoryInfoRequest{
  135.         Name:                 categoryForm.Name,
  136.         IsTab:                *categoryForm.IsTab,
  137.         Level: categoryForm.Level,
  138.         ParentCategory: categoryForm.ParentCategory,
  139.     })
  141.     if err != nil {
  142.         HandleGrpcErrorToHttp(err, ctx)
  143.         return
  144.     }
  146.     request := make(map[string]interface{})
  147.     request["id"] = rsp.Id
  148.     request["name"] = rsp.Name
  149.     request["parent"] = rsp.ParentCategory
  150.     request["level"] = rsp.Level
  151.     request["is_tab"] = rsp.IsTab
  153.     ctx.JSON(http.StatusOK, request)
  154. }
  156. func Delete(ctx *gin.Context) {
  157.     id := ctx.Param("id")
  158.     i, err := strconv.ParseInt(id, 10, 32)
  159.     if err != nil {
  160.         ctx.Status(http.StatusNotFound)
  161.         return
  162.     }
  163.     _, err = global.GoodsSrvClient.DeleteCategory(context.Background(), &proto.DeleteCategoryRequest{Id: int32(i)})
  164.     if err != nil {
  165.         HandleGrpcErrorToHttp(err, ctx)
  166.         return
  167.     }
  169.     ctx.Status(http.StatusOK)
  170. }
  172. func Update(ctx *gin.Context) {
  173.     categoryForm := forms.UpdateCategoryForm{}
  174.     if err := ctx.ShouldBindJSON(&categoryForm); err != nil {
  175.         HandleValidatorError(ctx, err)
  176.         return
  177.     }
  179.     id := ctx.Param("id")
  180.     i, err := strconv.ParseInt(id, 10, 32)
  181.     if err != nil {
  182.         ctx.Status(http.StatusNotFound)
  183.         return
  184.     }
  186.     request := &proto.CategoryInfoRequest{
  187.         Id: int32(i),
  188.         Name: categoryForm.Name,
  189.     }
  190.     if categoryForm.IsTab != nil {
  191.         request.IsTab = *categoryForm.IsTab
  192.     }
  193.     _, err = global.GoodsSrvClient.UpdateCategory(context.Background(), request)
  194.     if err != nil {
  195.         HandleGrpcErrorToHttp(err, ctx)
  196.         return
  197.     }
  199.     ctx.Status(http.StatusOK)
  200. }

3. router

  1. package router
  3. import (
  4.     "github.com/gin-gonic/gin"
  5.     "mxshop-api/goods-web/api/category"
  6. )
  8. func InitCategoryRouter(Router *gin.RouterGroup) {
  9.     CategoryRouter := Router.Group("categorys")
  10.     {
  11.         CategoryRouter.GET("", category.List)          // 商品类别列表页
  12.         CategoryRouter.DELETE("/:id", category.Delete) // 删除分类
  13.         CategoryRouter.GET("/:id", category.Detail) // 获取分类详情
  14.         CategoryRouter.POST("", category.New)       //新建分类
  15.         CategoryRouter.PUT("/:id", category.Update) //修改分类信息
  16.     }
  17. }

4. 将router调用