upgrade

internal/api/code/code.go

@@ -45,6 +45,8 @@ const (
 	AdminLogOutError             = 20307
 	AdminModifyPasswordError     = 20308
 	AdminModifyPersonalInfoError = 20309
+	AdminMenuListError           = 20310
+	AdminMenuCreateError         = 20311
 
 	// 配置
 	ConfigEmailError        = 20401
@@ -61,11 +63,14 @@ const (
 	SearchMySQLError = 20504
 
 	// 菜单栏
-	MenuCreateError = 20601
-	MenuUpdateError = 20602
-	MenuListError   = 20603
-	MenuDeleteError = 20604
-	MenuDetailError = 20605
+	MenuCreateError       = 20601
+	MenuUpdateError       = 20602
+	MenuListError         = 20603
+	MenuDeleteError       = 20604
+	MenuDetailError       = 20605
+	MenuCreateActionError = 20606
+	MenuListActionError   = 20607
+	MenuDeleteActionError = 20608
 )
 
 var codeText = map[int]string{
@@ -102,6 +107,8 @@ var codeText = map[int]string{
 	AdminLogOutError:             "退出失败",
 	AdminModifyPasswordError:     "修改密码失败",
 	AdminModifyPersonalInfoError: "修改个人信息失败",
+	AdminMenuListError:           "获取管理员菜单授权列表失败",
+	AdminMenuCreateError:         "管理员菜单授权失败",
 
 	ConfigEmailError:        "修改邮箱配置失败",
 	ConfigSaveError:         "写入配置文件失败",
@@ -115,11 +122,14 @@ var codeText = map[int]string{
 	SearchRedisEmpty: "查询的 Redis Key 不存在",
 	SearchMySQLError: "查询 MySQL 失败",
 
-	MenuCreateError: "创建菜单失败",
-	MenuUpdateError: "更新菜单失败",
-	MenuDeleteError: "删除菜单失败",
-	MenuListError:   "获取菜单列表页失败",
-	MenuDetailError: "获取菜单详情失败",
+	MenuCreateError:       "创建菜单失败",
+	MenuUpdateError:       "更新菜单失败",
+	MenuDeleteError:       "删除菜单失败",
+	MenuListError:         "获取菜单列表页失败",
+	MenuDetailError:       "获取菜单详情失败",
+	MenuCreateActionError: "创建菜单栏功能权限失败",
+	MenuListActionError:   "获取菜单栏功能权限列表失败",
+	MenuDeleteActionError: "删除菜单栏功能权限失败",
 }
 
 func Text(code int) string {

internal/api/controller/admin_handler/func_createadminmenu.go

@@ -0,0 +1,72 @@
+package admin_handler
+
+import (
+	"net/http"
+
+	"github.com/xinliangnote/go-gin-api/internal/api/code"
+	"github.com/xinliangnote/go-gin-api/internal/api/service/admin_service"
+	"github.com/xinliangnote/go-gin-api/internal/pkg/core"
+	"github.com/xinliangnote/go-gin-api/pkg/errno"
+)
+
+type createAdminMenuRequest struct {
+	Id      string `form:"id"`      // HashID
+	Actions string `form:"actions"` // 功能权限ID,多个用,分割
+}
+
+type createAdminMenuResponse struct {
+	Id int32 `json:"id"` // 主键ID
+}
+
+// CreateAdminMenu 提交菜单授权
+// @Summary 提交菜单授权
+// @Description 提交菜单授权
+// @Tags API.admin
+// @Accept multipart/form-data
+// @Produce json
+// @Param id formData string true "Hashid"
+// @Param actions formData string true "功能权限ID,多个用,分割"
+// @Success 200 {object} createResponse
+// @Failure 400 {object} code.Failure
+// @Router /api/admin/menu [post]
+func (h *handler) CreateAdminMenu() core.HandlerFunc {
+	return func(c core.Context) {
+		req := new(createAdminMenuRequest)
+		res := new(createAdminMenuResponse)
+		if err := c.ShouldBindForm(req); err != nil {
+			c.AbortWithError(errno.NewError(
+				http.StatusBadRequest,
+				code.ParamBindError,
+				code.Text(code.ParamBindError)).WithErr(err),
+			)
+			return
+		}
+
+		ids, err := h.hashids.HashidsDecode(req.Id)
+		if err != nil {
+			c.AbortWithError(errno.NewError(
+				http.StatusBadRequest,
+				code.HashIdsDecodeError,
+				code.Text(code.HashIdsDecodeError)).WithErr(err),
+			)
+			return
+		}
+
+		createData := new(admin_service.CreateMenuData)
+		createData.AdminId = int32(ids[0])
+		createData.Actions = req.Actions
+
+		err = h.adminService.CreateMenu(c, createData)
+		if err != nil {
+			c.AbortWithError(errno.NewError(
+				http.StatusBadRequest,
+				code.AdminMenuCreateError,
+				code.Text(code.AdminMenuCreateError)).WithErr(err),
+			)
+			return
+		}
+
+		res.Id = int32(ids[0])
+		c.Payload(res)
+	}
+}

internal/api/controller/admin_handler/func_list.go

@@ -47,7 +47,7 @@ type listResponse struct {
 // @Summary 管理员列表
 // @Description 管理员列表
 // @Tags API.admin
-// @Accept json
+// @Accept multipart/form-data
 // @Produce json
 // @Param page query int false "第几页"
 // @Param page_size query string false "每页显示条数"

internal/api/controller/admin_handler/func_listadminmenu.go

@@ -0,0 +1,86 @@
+package admin_handler
+
+import (
+	"net/http"
+
+	"github.com/xinliangnote/go-gin-api/internal/api/code"
+	"github.com/xinliangnote/go-gin-api/internal/api/service/admin_service"
+	"github.com/xinliangnote/go-gin-api/internal/pkg/core"
+	"github.com/xinliangnote/go-gin-api/pkg/errno"
+)
+
+type listAdminMenuRequest struct {
+	Id string `uri:"id"` // HashID
+}
+
+type listAdminMenuResponse struct {
+	List     []admin_service.ListMenuData `json:"list"`
+	UserName string                       `json:"username"`
+}
+
+// ListAdminMenu 菜单授权列表
+// @Summary 菜单授权列表
+// @Description 菜单授权列表
+// @Tags API.admin
+// @Accept json
+// @Produce json
+// @Param id path string true "hashId"
+// @Success 200 {object} listAdminMenuResponse
+// @Failure 400 {object} code.Failure
+// @Router /api/admin/menu/:id [get]
+func (h *handler) ListAdminMenu() core.HandlerFunc {
+	return func(c core.Context) {
+		req := new(listAdminMenuRequest)
+		res := new(listAdminMenuResponse)
+		if err := c.ShouldBindURI(req); err != nil {
+			c.AbortWithError(errno.NewError(
+				http.StatusBadRequest,
+				code.ParamBindError,
+				code.Text(code.ParamBindError)).WithErr(err),
+			)
+			return
+		}
+
+		ids, err := h.hashids.HashidsDecode(req.Id)
+		if err != nil {
+			c.AbortWithError(errno.NewError(
+				http.StatusBadRequest,
+				code.HashIdsDecodeError,
+				code.Text(code.HashIdsDecodeError)).WithErr(err),
+			)
+			return
+		}
+
+		searchOneData := new(admin_service.SearchOneData)
+		searchOneData.Id = int32(ids[0])
+		searchOneData.IsUsed = 1
+
+		info, err := h.adminService.Detail(c, searchOneData)
+		if err != nil {
+			c.AbortWithError(errno.NewError(
+				http.StatusBadRequest,
+				code.AdminMenuListError,
+				code.Text(code.AdminMenuListError)).WithErr(err),
+			)
+			return
+		}
+
+		res.UserName = info.Username
+
+		searchData := new(admin_service.SearchListMenuData)
+		searchData.AdminId = int32(ids[0])
+
+		listData, err := h.adminService.ListMenu(c, searchData)
+		if err != nil {
+			c.AbortWithError(errno.NewError(
+				http.StatusBadRequest,
+				code.AdminMenuListError,
+				code.Text(code.AdminMenuListError)).WithErr(err),
+			)
+			return
+		}
+
+		res.List = listData
+		c.Payload(res)
+	}
+}

internal/api/controller/admin_handler/handler.go

@@ -65,6 +65,16 @@ type Handler interface {
 	// @Tags API.admin
 	// @Router /api/admin/reset_password/{id} [patch]
 	ResetPassword() core.HandlerFunc
+
+	// CreateAdminMenu 提交菜单授权
+	// @Tags API.admin
+	// @Router /api/admin/menu [post]
+	CreateAdminMenu() core.HandlerFunc
+
+	// ListAdminMenu 菜单授权列表
+	// @Tags API.admin
+	// @Router /api/admin/menu/:id [get]
+	ListAdminMenu() core.HandlerFunc
 }
 
 type handler struct {

internal/api/controller/authorized_handler/func_listapi.go

@@ -24,16 +24,17 @@ type listAPIData struct {
 }
 
 type listAPIResponse struct {
-	List []listAPIData `json:"list"`
+	BusinessKey string        `json:"business_key"` // 调用方key
+	List        []listAPIData `json:"list"`
 }
 
 // ListAPI 调用方接口地址列表
 // @Summary 调用方接口地址列表
 // @Description 调用方接口地址列表
 // @Tags API.authorized
-// @Accept json
+// @Accept multipart/form-data
 // @Produce json
-// @Param business_key query string false "调用方key"
+// @Param id query string true "hashID"
 // @Success 200 {object} listAPIResponse
 // @Failure 400 {object} code.Failure
 // @Router /api/authorized_api [get]
@@ -73,6 +74,8 @@ func (h *handler) ListAPI() core.HandlerFunc {
 			return
 		}
 
+		res.BusinessKey = authorizedInfo.BusinessKey
+
 		searchAPIData := new(authorized_service.SearchAPIData)
 		searchAPIData.BusinessKey = authorizedInfo.BusinessKey
 

internal/api/controller/menu_handler/func_createaction.go

@@ -0,0 +1,89 @@
+package menu_handler
+
+import (
+	"net/http"
+
+	"github.com/xinliangnote/go-gin-api/internal/api/code"
+	"github.com/xinliangnote/go-gin-api/internal/api/service/menu_service"
+	"github.com/xinliangnote/go-gin-api/internal/pkg/core"
+	"github.com/xinliangnote/go-gin-api/pkg/errno"
+)
+
+type createActionRequest struct {
+	Id     string `form:"id"`     // HashID
+	Method string `form:"method"` // 请求方法
+	API    string `form:"api"`    // 请求地址
+}
+
+type createActionResponse struct {
+	Id int32 `json:"id"` // 主键ID
+}
+
+// CreateAction 创建功能权限
+// @Summary 创建功能权限
+// @Description 创建功能权限
+// @Tags API.menu
+// @Accept multipart/form-data
+// @Produce json
+// @Param id formData string true "HashID"
+// @Param method formData string true "请求方法"
+// @Param api formData string true "请求地址"
+// @Success 200 {object} createActionResponse
+// @Failure 400 {object} code.Failure
+// @Router /api/menu_action [post]
+func (h *handler) CreateAction() core.HandlerFunc {
+	return func(c core.Context) {
+		req := new(createActionRequest)
+		res := new(createActionResponse)
+		if err := c.ShouldBindForm(req); err != nil {
+			c.AbortWithError(errno.NewError(
+				http.StatusBadRequest,
+				code.ParamBindError,
+				code.Text(code.ParamBindError)).WithErr(err),
+			)
+			return
+		}
+
+		ids, err := h.hashids.HashidsDecode(req.Id)
+		if err != nil {
+			c.AbortWithError(errno.NewError(
+				http.StatusBadRequest,
+				code.HashIdsDecodeError,
+				code.Text(code.HashIdsDecodeError)).WithErr(err),
+			)
+			return
+		}
+
+		id := int32(ids[0])
+
+		searchOneData := new(menu_service.SearchOneData)
+		searchOneData.Id = id
+		menuInfo, err := h.menuService.Detail(c, searchOneData)
+		if err != nil {
+			c.AbortWithError(errno.NewError(
+				http.StatusBadRequest,
+				code.MenuDetailError,
+				code.Text(code.MenuDetailError)).WithErr(err),
+			)
+			return
+		}
+
+		createActionData := new(menu_service.CreateMenuActionData)
+		createActionData.MenuId = menuInfo.Id
+		createActionData.Method = req.Method
+		createActionData.API = req.API
+
+		createId, err := h.menuService.CreateAction(c, createActionData)
+		if err != nil {
+			c.AbortWithError(errno.NewError(
+				http.StatusBadRequest,
+				code.MenuCreateActionError,
+				code.Text(code.MenuCreateActionError)).WithErr(err),
+			)
+			return
+		}
+
+		res.Id = createId
+		c.Payload(res)
+	}
+}

internal/api/controller/menu_handler/func_deleteaction.go

@@ -0,0 +1,67 @@
+package menu_handler
+
+import (
+	"net/http"
+
+	"github.com/xinliangnote/go-gin-api/internal/api/code"
+	"github.com/xinliangnote/go-gin-api/internal/pkg/core"
+	"github.com/xinliangnote/go-gin-api/pkg/errno"
+)
+
+type deleteActionRequest struct {
+	Id string `uri:"id"` // HashID
+}
+
+type deleteActionResponse struct {
+	Id int32 `json:"id"` // 主键ID
+}
+
+// DeleteAction 删除功能权限
+// @Summary 删除功能权限
+// @Description 删除功能权限
+// @Tags API.menu
+// @Accept json
+// @Produce json
+// @Param id path string true "hashId"
+// @Success 200 {object} deleteActionResponse
+// @Failure 400 {object} code.Failure
+// @Router /api/menu_action/{id} [delete]
+func (h *handler) DeleteAction() core.HandlerFunc {
+	return func(c core.Context) {
+		req := new(deleteActionRequest)
+		res := new(deleteActionResponse)
+		if err := c.ShouldBindURI(req); err != nil {
+			c.AbortWithError(errno.NewError(
+				http.StatusBadRequest,
+				code.ParamBindError,
+				code.Text(code.ParamBindError)).WithErr(err),
+			)
+			return
+		}
+
+		ids, err := h.hashids.HashidsDecode(req.Id)
+		if err != nil {
+			c.AbortWithError(errno.NewError(
+				http.StatusBadRequest,
+				code.HashIdsDecodeError,
+				code.Text(code.HashIdsDecodeError)).WithErr(err),
+			)
+			return
+		}
+
+		id := int32(ids[0])
+
+		err = h.menuService.DeleteAction(c, id)
+		if err != nil {
+			c.AbortWithError(errno.NewError(
+				http.StatusBadRequest,
+				code.MenuDeleteActionError,
+				code.Text(code.MenuDeleteActionError)).WithErr(err),
+			)
+			return
+		}
+
+		res.Id = id
+		c.Payload(res)
+	}
+}

internal/api/controller/menu_handler/func_detail.go

@@ -15,6 +15,7 @@ type detailRequest struct {
 
 type detailResponse struct {
 	Id   int32  `json:"id"`   // 主键ID
+	Pid  int32  `json:"pid"`  // 父类ID
 	Name string `json:"name"` // 菜单名称
 	Link string `json:"link"` // 链接地址
 	Icon string `json:"icon"` // 图标
@@ -69,6 +70,7 @@ func (h *handler) Detail() core.HandlerFunc {
 		}
 
 		res.Id = info.Id
+		res.Pid = info.Pid
 		res.Name = info.Name
 		res.Link = info.Link
 		res.Icon = info.Icon

internal/api/controller/menu_handler/func_listaction.go

@@ -0,0 +1,114 @@
+package menu_handler
+
+import (
+	"net/http"
+
+	"github.com/xinliangnote/go-gin-api/internal/api/code"
+	"github.com/xinliangnote/go-gin-api/internal/api/service/menu_service"
+	"github.com/xinliangnote/go-gin-api/internal/pkg/core"
+	"github.com/xinliangnote/go-gin-api/pkg/errno"
+
+	"github.com/spf13/cast"
+	"go.uber.org/zap"
+)
+
+type listActionRequest struct {
+	Id string `form:"id"` // hashID
+}
+
+type listActionData struct {
+	HashId string `json:"hash_id"` // hashID
+	MenuId int32  `json:"menu_id"` // 菜单栏ID
+	Method string `json:"method"`  // 调用方secret
+	API    string `json:"api"`     // 调用方对接人
+}
+
+type listActionResponse struct {
+	MenuName string           `json:"menu_name"`
+	List     []listActionData `json:"list"`
+}
+
+// ListAction 功能权限列表
+// @Summary 功能权限列表
+// @Description 功能权限列表
+// @Tags API.menu
+// @Accept multipart/form-data
+// @Produce json
+// @Param id query string true "hashID"
+// @Success 200 {object} listActionResponse
+// @Failure 400 {object} code.Failure
+// @Router /api/menu_action [get]
+func (h *handler) ListAction() core.HandlerFunc {
+	return func(c core.Context) {
+		req := new(listActionRequest)
+		res := new(listActionResponse)
+		if err := c.ShouldBindForm(req); err != nil {
+			c.AbortWithError(errno.NewError(
+				http.StatusBadRequest,
+				code.ParamBindError,
+				code.Text(code.ParamBindError)).WithErr(err),
+			)
+			return
+		}
+
+		ids, err := h.hashids.HashidsDecode(req.Id)
+		if err != nil {
+			c.AbortWithError(errno.NewError(
+				http.StatusBadRequest,
+				code.HashIdsDecodeError,
+				code.Text(code.HashIdsDecodeError)).WithErr(err),
+			)
+			return
+		}
+
+		id := int32(ids[0])
+
+		searchOneData := new(menu_service.SearchOneData)
+		searchOneData.Id = id
+
+		menuInfo, err := h.menuService.Detail(c, searchOneData)
+		if err != nil {
+			c.AbortWithError(errno.NewError(
+				http.StatusBadRequest,
+				code.MenuDetailError,
+				code.Text(code.MenuDetailError)).WithErr(err),
+			)
+			return
+		}
+
+		res.MenuName = menuInfo.Name
+
+		searchListData := new(menu_service.SearchListActionData)
+		searchListData.MenuId = menuInfo.Id
+
+		resListData, err := h.menuService.ListAction(c, searchListData)
+		if err != nil {
+			c.AbortWithError(errno.NewError(
+				http.StatusBadRequest,
+				code.AuthorizedListAPIError,
+				code.Text(code.AuthorizedListAPIError)).WithErr(err),
+			)
+			return
+		}
+
+		res.List = make([]listActionData, len(resListData))
+
+		for k, v := range resListData {
+			hashId, err := h.hashids.HashidsEncode([]int{cast.ToInt(v.Id)})
+			if err != nil {
+				h.logger.Info("hashids err", zap.Error(err))
+			}
+
+			data := listActionData{
+				HashId: hashId,
+				MenuId: v.MenuId,
+				Method: v.Method,
+				API:    v.Api,
+			}
+
+			res.List[k] = data
+		}
+
+		c.Payload(res)
+	}
+}

internal/api/controller/menu_handler/handler.go

@@ -40,6 +40,21 @@ type Handler interface {
 	// @Tags API.menu
 	// @Router /api/menu [get]
 	List() core.HandlerFunc
+
+	// CreateAction 创建功能权限
+	// @Tags API.menu
+	// @Router /api/menu_action [post]
+	CreateAction() core.HandlerFunc
+
+	// ListAction 功能权限列表
+	// @Tags API.menu
+	// @Router /api/menu_action [get]
+	ListAction() core.HandlerFunc
+
+	// DeleteAction 删除功能权限
+	// @Tags API.menu
+	// @Router /api/menu_action/{id} [delete]
+	DeleteAction() core.HandlerFunc
 }
 
 type handler struct {

internal/api/repository/README.md

@@ -20,6 +20,3 @@
 - 包名应以 `_repo` 结尾；
 - `./db_repo` 目录下的包名以 `数据表名`+ `_repo` 命名；
 
-#### 脚本生成 MySQL CURD
-
-- 使用脚本自动生成基于表结构的 CURD 代码，见文档：`./cmd/gormgen/README.md`

internal/api/repository/db_repo/README.md

@@ -34,18 +34,4 @@ model.Mobile = user.Mobile
 
 id, err = model.Create(u.db.GetDbW().WithContext(ctx.RequestContext()))
 
-// 编辑
-model := user_demo_repo.NewModel()
-model.Id = id
-
-data := map[string]interface{}{
-    "nick_name": nickname,
-}
-
-err = model.Updates(u.db.GetDbW().WithContext(ctx.RequestContext()), data)
-
-// 删除
-model := user_demo_repo.NewModel()
-model.Id = id
-err = model.Delete(u.db.GetDbW().WithContext(ctx.RequestContext()))
 ```

internal/api/repository/db_repo/admin_menu_repo/gen_admin_menu.go

@@ -0,0 +1,335 @@
+///////////////////////////////////////////////////////////
+// THIS FILE IS AUTO GENERATED by gormgen, DON'T EDIT IT //
+//        ANY CHANGES DONE HERE WILL BE LOST             //
+///////////////////////////////////////////////////////////
+
+package admin_menu_repo
+
+import (
+	"fmt"
+	"time"
+
+	"github.com/xinliangnote/go-gin-api/internal/api/repository/db_repo"
+
+	"github.com/pkg/errors"
+	"gorm.io/gorm"
+)
+
+func NewModel() *AdminMenu {
+	return new(AdminMenu)
+}
+
+func NewQueryBuilder() *adminMenuRepoQueryBuilder {
+	return new(adminMenuRepoQueryBuilder)
+}
+
+func (t *AdminMenu) Create(db *gorm.DB) (id int32, err error) {
+	if err = db.Create(t).Error; err != nil {
+		return 0, errors.Wrap(err, "create err")
+	}
+	return t.Id, nil
+}
+
+type adminMenuRepoQueryBuilder struct {
+	order []string
+	where []struct {
+		prefix string
+		value  interface{}
+	}
+	limit  int
+	offset int
+}
+
+func (qb *adminMenuRepoQueryBuilder) buildQuery(db *gorm.DB) *gorm.DB {
+	ret := db
+	for _, where := range qb.where {
+		ret = ret.Where(where.prefix, where.value)
+	}
+	for _, order := range qb.order {
+		ret = ret.Order(order)
+	}
+	ret = ret.Limit(qb.limit).Offset(qb.offset)
+	return ret
+}
+
+func (qb *adminMenuRepoQueryBuilder) Updates(db *gorm.DB, m map[string]interface{}) (err error) {
+	db = db.Model(&AdminMenu{})
+
+	for _, where := range qb.where {
+		db.Where(where.prefix, where.value)
+	}
+
+	if err = db.Updates(m).Error; err != nil {
+		return errors.Wrap(err, "updates err")
+	}
+	return nil
+}
+
+func (qb *adminMenuRepoQueryBuilder) Delete(db *gorm.DB) (err error) {
+	for _, where := range qb.where {
+		db = db.Where(where.prefix, where.value)
+	}
+
+	if err = db.Delete(&AdminMenu{}).Error; err != nil {
+		return errors.Wrap(err, "delete err")
+	}
+	return nil
+}
+
+func (qb *adminMenuRepoQueryBuilder) Count(db *gorm.DB) (int64, error) {
+	var c int64
+	res := qb.buildQuery(db).Model(&AdminMenu{}).Count(&c)
+	if res.Error != nil && res.Error == gorm.ErrRecordNotFound {
+		c = 0
+	}
+	return c, res.Error
+}
+
+func (qb *adminMenuRepoQueryBuilder) First(db *gorm.DB) (*AdminMenu, error) {
+	ret := &AdminMenu{}
+	res := qb.buildQuery(db).First(ret)
+	if res.Error != nil && res.Error == gorm.ErrRecordNotFound {
+		ret = nil
+	}
+	return ret, res.Error
+}
+
+func (qb *adminMenuRepoQueryBuilder) QueryOne(db *gorm.DB) (*AdminMenu, error) {
+	qb.limit = 1
+	ret, err := qb.QueryAll(db)
+	if len(ret) > 0 {
+		return ret[0], err
+	}
+	return nil, err
+}
+
+func (qb *adminMenuRepoQueryBuilder) QueryAll(db *gorm.DB) ([]*AdminMenu, error) {
+	var ret []*AdminMenu
+	err := qb.buildQuery(db).Find(&ret).Error
+	return ret, err
+}
+
+func (qb *adminMenuRepoQueryBuilder) Limit(limit int) *adminMenuRepoQueryBuilder {
+	qb.limit = limit
+	return qb
+}
+
+func (qb *adminMenuRepoQueryBuilder) Offset(offset int) *adminMenuRepoQueryBuilder {
+	qb.offset = offset
+	return qb
+}
+
+func (qb *adminMenuRepoQueryBuilder) WhereId(p db_repo.Predicate, value int32) *adminMenuRepoQueryBuilder {
+	qb.where = append(qb.where, struct {
+		prefix string
+		value  interface{}
+	}{
+		fmt.Sprintf("%v %v ?", "id", p),
+		value,
+	})
+	return qb
+}
+
+func (qb *adminMenuRepoQueryBuilder) WhereIdIn(value []int32) *adminMenuRepoQueryBuilder {
+	qb.where = append(qb.where, struct {
+		prefix string
+		value  interface{}
+	}{
+		fmt.Sprintf("%v %v ?", "id", "IN"),
+		value,
+	})
+	return qb
+}
+
+func (qb *adminMenuRepoQueryBuilder) WhereIdNotIn(value []int32) *adminMenuRepoQueryBuilder {
+	qb.where = append(qb.where, struct {
+		prefix string
+		value  interface{}
+	}{
+		fmt.Sprintf("%v %v ?", "id", "NOT IN"),
+		value,
+	})
+	return qb
+}
+
+func (qb *adminMenuRepoQueryBuilder) OrderById(asc bool) *adminMenuRepoQueryBuilder {
+	order := "DESC"
+	if asc {
+		order = "ASC"
+	}
+
+	qb.order = append(qb.order, "id "+order)
+	return qb
+}
+
+func (qb *adminMenuRepoQueryBuilder) WhereAdminId(p db_repo.Predicate, value int32) *adminMenuRepoQueryBuilder {
+	qb.where = append(qb.where, struct {
+		prefix string
+		value  interface{}
+	}{
+		fmt.Sprintf("%v %v ?", "admin_id", p),
+		value,
+	})
+	return qb
+}
+
+func (qb *adminMenuRepoQueryBuilder) WhereAdminIdIn(value []int32) *adminMenuRepoQueryBuilder {
+	qb.where = append(qb.where, struct {
+		prefix string
+		value  interface{}
+	}{
+		fmt.Sprintf("%v %v ?", "admin_id", "IN"),
+		value,
+	})
+	return qb
+}
+
+func (qb *adminMenuRepoQueryBuilder) WhereAdminIdNotIn(value []int32) *adminMenuRepoQueryBuilder {
+	qb.where = append(qb.where, struct {
+		prefix string
+		value  interface{}
+	}{
+		fmt.Sprintf("%v %v ?", "admin_id", "NOT IN"),
+		value,
+	})
+	return qb
+}
+
+func (qb *adminMenuRepoQueryBuilder) OrderByAdminId(asc bool) *adminMenuRepoQueryBuilder {
+	order := "DESC"
+	if asc {
+		order = "ASC"
+	}
+
+	qb.order = append(qb.order, "admin_id "+order)
+	return qb
+}
+
+func (qb *adminMenuRepoQueryBuilder) WhereMenuId(p db_repo.Predicate, value int32) *adminMenuRepoQueryBuilder {
+	qb.where = append(qb.where, struct {
+		prefix string
+		value  interface{}
+	}{
+		fmt.Sprintf("%v %v ?", "menu_id", p),
+		value,
+	})
+	return qb
+}
+
+func (qb *adminMenuRepoQueryBuilder) WhereMenuIdIn(value []int32) *adminMenuRepoQueryBuilder {
+	qb.where = append(qb.where, struct {
+		prefix string
+		value  interface{}
+	}{
+		fmt.Sprintf("%v %v ?", "menu_id", "IN"),
+		value,
+	})
+	return qb
+}
+
+func (qb *adminMenuRepoQueryBuilder) WhereMenuIdNotIn(value []int32) *adminMenuRepoQueryBuilder {
+	qb.where = append(qb.where, struct {
+		prefix string
+		value  interface{}
+	}{
+		fmt.Sprintf("%v %v ?", "menu_id", "NOT IN"),
+		value,
+	})
+	return qb
+}
+
+func (qb *adminMenuRepoQueryBuilder) OrderByMenuId(asc bool) *adminMenuRepoQueryBuilder {
+	order := "DESC"
+	if asc {
+		order = "ASC"
+	}
+
+	qb.order = append(qb.order, "menu_id "+order)
+	return qb
+}
+
+func (qb *adminMenuRepoQueryBuilder) WhereCreatedAt(p db_repo.Predicate, value time.Time) *adminMenuRepoQueryBuilder {
+	qb.where = append(qb.where, struct {
+		prefix string
+		value  interface{}
+	}{
+		fmt.Sprintf("%v %v ?", "created_at", p),
+		value,
+	})
+	return qb
+}
+
+func (qb *adminMenuRepoQueryBuilder) WhereCreatedAtIn(value []time.Time) *adminMenuRepoQueryBuilder {
+	qb.where = append(qb.where, struct {
+		prefix string
+		value  interface{}
+	}{
+		fmt.Sprintf("%v %v ?", "created_at", "IN"),
+		value,
+	})
+	return qb
+}
+
+func (qb *adminMenuRepoQueryBuilder) WhereCreatedAtNotIn(value []time.Time) *adminMenuRepoQueryBuilder {
+	qb.where = append(qb.where, struct {
+		prefix string
+		value  interface{}
+	}{
+		fmt.Sprintf("%v %v ?", "created_at", "NOT IN"),
+		value,
+	})
+	return qb
+}
+
+func (qb *adminMenuRepoQueryBuilder) OrderByCreatedAt(asc bool) *adminMenuRepoQueryBuilder {
+	order := "DESC"
+	if asc {
+		order = "ASC"
+	}
+
+	qb.order = append(qb.order, "created_at "+order)
+	return qb
+}
+
+func (qb *adminMenuRepoQueryBuilder) WhereCreatedUser(p db_repo.Predicate, value string) *adminMenuRepoQueryBuilder {
+	qb.where = append(qb.where, struct {
+		prefix string
+		value  interface{}
+	}{
+		fmt.Sprintf("%v %v ?", "created_user", p),
+		value,
+	})
+	return qb
+}
+
+func (qb *adminMenuRepoQueryBuilder) WhereCreatedUserIn(value []string) *adminMenuRepoQueryBuilder {
+	qb.where = append(qb.where, struct {
+		prefix string
+		value  interface{}
+	}{
+		fmt.Sprintf("%v %v ?", "created_user", "IN"),
+		value,
+	})
+	return qb
+}
+
+func (qb *adminMenuRepoQueryBuilder) WhereCreatedUserNotIn(value []string) *adminMenuRepoQueryBuilder {
+	qb.where = append(qb.where, struct {
+		prefix string
+		value  interface{}
+	}{
+		fmt.Sprintf("%v %v ?", "created_user", "NOT IN"),
+		value,
+	})
+	return qb
+}
+
+func (qb *adminMenuRepoQueryBuilder) OrderByCreatedUser(asc bool) *adminMenuRepoQueryBuilder {
+	order := "DESC"
+	if asc {
+		order = "ASC"
+	}
+
+	qb.order = append(qb.order, "created_user "+order)
+	return qb
+}

internal/api/repository/db_repo/admin_menu_repo/gen_model.go

@@ -0,0 +1,13 @@
+package admin_menu_repo
+
+import "time"
+
+// 管理员菜单栏表
+//go:generate gormgen -structs AdminMenu -input .
+type AdminMenu struct {
+	Id          int32     // 主键
+	AdminId     int32     // 管理员ID
+	MenuId      int32     // 菜单栏ID
+	CreatedAt   time.Time `gorm:"time"` // 创建时间
+	CreatedUser string    // 创建人
+}

internal/api/repository/db_repo/admin_menu_repo/gen_table.md

@@ -0,0 +1,10 @@
+#### go_gin_api.admin_menu 
+管理员菜单栏表
+
+| 序号 | 名称 | 描述 | 类型 | 键 | 为空 | 额外 | 默认值 |
+| :--: | :--: | :--: | :--: | :--: | :--: | :--: | :--: |
+| 1 | id | 主键 | int(11) unsigned | PRI | NO | auto_increment |  |
+| 2 | admin_id | 管理员ID | int(11) unsigned | MUL | NO |  | 0 |
+| 3 | menu_id | 菜单栏ID | int(11) unsigned |  | NO |  | 0 |
+| 4 | created_at | 创建时间 | timestamp |  | NO |  | CURRENT_TIMESTAMP |
+| 5 | created_user | 创建人 | varchar(60) |  | NO |  |  |

internal/api/repository/db_repo/admin_repo/gen_admin.go

@@ -30,20 +30,6 @@ func (t *Admin) Create(db *gorm.DB) (id int32, err error) {
 	return t.Id, nil
 }
 
-func (t *Admin) Delete(db *gorm.DB) (err error) {
-	if err = db.Delete(t).Error; err != nil {
-		return errors.Wrap(err, "delete err")
-	}
-	return nil
-}
-
-func (t *Admin) Updates(db *gorm.DB, m map[string]interface{}) (err error) {
-	if err = db.Model(&Admin{}).Where("id = ?", t.Id).Updates(m).Error; err != nil {
-		return errors.Wrap(err, "updates err")
-	}
-	return nil
-}
-
 type adminRepoQueryBuilder struct {
 	order []string
 	where []struct {
@@ -66,6 +52,30 @@ func (qb *adminRepoQueryBuilder) buildQuery(db *gorm.DB) *gorm.DB {
 	return ret
 }
 
+func (qb *adminRepoQueryBuilder) Updates(db *gorm.DB, m map[string]interface{}) (err error) {
+	db = db.Model(&Admin{})
+
+	for _, where := range qb.where {
+		db.Where(where.prefix, where.value)
+	}
+
+	if err = db.Updates(m).Error; err != nil {
+		return errors.Wrap(err, "updates err")
+	}
+	return nil
+}
+
+func (qb *adminRepoQueryBuilder) Delete(db *gorm.DB) (err error) {
+	for _, where := range qb.where {
+		db = db.Where(where.prefix, where.value)
+	}
+
+	if err = db.Delete(&Admin{}).Error; err != nil {
+		return errors.Wrap(err, "delete err")
+	}
+	return nil
+}
+
 func (qb *adminRepoQueryBuilder) Count(db *gorm.DB) (int64, error) {
 	var c int64
 	res := qb.buildQuery(db).Model(&Admin{}).Count(&c)

internal/api/repository/db_repo/admin_repo/gen_table.md

@@ -5,7 +5,7 @@
 | :--: | :--: | :--: | :--: | :--: | :--: | :--: | :--: |
 | 1 | id | 主键 | int(11) unsigned | PRI | NO | auto_increment |  |
 | 2 | username | 用户名 | varchar(32) | UNI | NO |  |  |
-| 3 | password | 密码 | varchar(32) |  | NO |  |  |
+| 3 | password | 密码 | varchar(100) |  | NO |  |  |
 | 4 | nickname | 昵称 | varchar(60) |  | NO |  |  |
 | 5 | mobile | 手机号 | varchar(20) |  | NO |  |  |
 | 6 | is_used | 是否启用 1:是  -1:否 | tinyint(1) |  | NO |  | 1 |

internal/api/repository/db_repo/authorized_api_repo/gen_authorized_api.go

@@ -30,20 +30,6 @@ func (t *AuthorizedApi) Create(db *gorm.DB) (id int32, err error) {
 	return t.Id, nil
 }
 
-func (t *AuthorizedApi) Delete(db *gorm.DB) (err error) {
-	if err = db.Delete(t).Error; err != nil {
-		return errors.Wrap(err, "delete err")
-	}
-	return nil
-}
-
-func (t *AuthorizedApi) Updates(db *gorm.DB, m map[string]interface{}) (err error) {
-	if err = db.Model(&AuthorizedApi{}).Where("id = ?", t.Id).Updates(m).Error; err != nil {
-		return errors.Wrap(err, "updates err")
-	}
-	return nil
-}
-
 type authorizedApiRepoQueryBuilder struct {
 	order []string
 	where []struct {
@@ -66,6 +52,30 @@ func (qb *authorizedApiRepoQueryBuilder) buildQuery(db *gorm.DB) *gorm.DB {
 	return ret
 }
 
+func (qb *authorizedApiRepoQueryBuilder) Updates(db *gorm.DB, m map[string]interface{}) (err error) {
+	db = db.Model(&AuthorizedApi{})
+
+	for _, where := range qb.where {
+		db.Where(where.prefix, where.value)
+	}
+
+	if err = db.Updates(m).Error; err != nil {
+		return errors.Wrap(err, "updates err")
+	}
+	return nil
+}
+
+func (qb *authorizedApiRepoQueryBuilder) Delete(db *gorm.DB) (err error) {
+	for _, where := range qb.where {
+		db = db.Where(where.prefix, where.value)
+	}
+
+	if err = db.Delete(&AuthorizedApi{}).Error; err != nil {
+		return errors.Wrap(err, "delete err")
+	}
+	return nil
+}
+
 func (qb *authorizedApiRepoQueryBuilder) Count(db *gorm.DB) (int64, error) {
 	var c int64
 	res := qb.buildQuery(db).Model(&AuthorizedApi{}).Count(&c)

internal/api/repository/db_repo/authorized_repo/gen_authorized.go

@@ -30,20 +30,6 @@ func (t *Authorized) Create(db *gorm.DB) (id int32, err error) {
 	return t.Id, nil
 }
 
-func (t *Authorized) Delete(db *gorm.DB) (err error) {
-	if err = db.Delete(t).Error; err != nil {
-		return errors.Wrap(err, "delete err")
-	}
-	return nil
-}
-
-func (t *Authorized) Updates(db *gorm.DB, m map[string]interface{}) (err error) {
-	if err = db.Model(&Authorized{}).Where("id = ?", t.Id).Updates(m).Error; err != nil {
-		return errors.Wrap(err, "updates err")
-	}
-	return nil
-}
-
 type authorizedRepoQueryBuilder struct {
 	order []string
 	where []struct {
@@ -66,6 +52,30 @@ func (qb *authorizedRepoQueryBuilder) buildQuery(db *gorm.DB) *gorm.DB {
 	return ret
 }
 
+func (qb *authorizedRepoQueryBuilder) Updates(db *gorm.DB, m map[string]interface{}) (err error) {
+	db = db.Model(&Authorized{})
+
+	for _, where := range qb.where {
+		db.Where(where.prefix, where.value)
+	}
+
+	if err = db.Updates(m).Error; err != nil {
+		return errors.Wrap(err, "updates err")
+	}
+	return nil
+}
+
+func (qb *authorizedRepoQueryBuilder) Delete(db *gorm.DB) (err error) {
+	for _, where := range qb.where {
+		db = db.Where(where.prefix, where.value)
+	}
+
+	if err = db.Delete(&Authorized{}).Error; err != nil {
+		return errors.Wrap(err, "delete err")
+	}
+	return nil
+}
+
 func (qb *authorizedRepoQueryBuilder) Count(db *gorm.DB) (int64, error) {
 	var c int64
 	res := qb.buildQuery(db).Model(&Authorized{}).Count(&c)

internal/api/repository/db_repo/menu_action_repo/gen_menu_action.go

@@ -0,0 +1,507 @@
+///////////////////////////////////////////////////////////
+// THIS FILE IS AUTO GENERATED by gormgen, DON'T EDIT IT //
+//        ANY CHANGES DONE HERE WILL BE LOST             //
+///////////////////////////////////////////////////////////
+
+package menu_action_repo
+
+import (
+	"fmt"
+	"time"
+
+	"github.com/xinliangnote/go-gin-api/internal/api/repository/db_repo"
+
+	"github.com/pkg/errors"
+	"gorm.io/gorm"
+)
+
+func NewModel() *MenuAction {
+	return new(MenuAction)
+}
+
+func NewQueryBuilder() *menuActionRepoQueryBuilder {
+	return new(menuActionRepoQueryBuilder)
+}
+
+func (t *MenuAction) Create(db *gorm.DB) (id int32, err error) {
+	if err = db.Create(t).Error; err != nil {
+		return 0, errors.Wrap(err, "create err")
+	}
+	return t.Id, nil
+}
+
+type menuActionRepoQueryBuilder struct {
+	order []string
+	where []struct {
+		prefix string
+		value  interface{}
+	}
+	limit  int
+	offset int
+}
+
+func (qb *menuActionRepoQueryBuilder) buildQuery(db *gorm.DB) *gorm.DB {
+	ret := db
+	for _, where := range qb.where {
+		ret = ret.Where(where.prefix, where.value)
+	}
+	for _, order := range qb.order {
+		ret = ret.Order(order)
+	}
+	ret = ret.Limit(qb.limit).Offset(qb.offset)
+	return ret
+}
+
+func (qb *menuActionRepoQueryBuilder) Updates(db *gorm.DB, m map[string]interface{}) (err error) {
+	db = db.Model(&MenuAction{})
+
+	for _, where := range qb.where {
+		db.Where(where.prefix, where.value)
+	}
+
+	if err = db.Updates(m).Error; err != nil {
+		return errors.Wrap(err, "updates err")
+	}
+	return nil
+}
+
+func (qb *menuActionRepoQueryBuilder) Delete(db *gorm.DB) (err error) {
+	for _, where := range qb.where {
+		db = db.Where(where.prefix, where.value)
+	}
+
+	if err = db.Delete(&MenuAction{}).Error; err != nil {
+		return errors.Wrap(err, "delete err")
+	}
+	return nil
+}
+
+func (qb *menuActionRepoQueryBuilder) Count(db *gorm.DB) (int64, error) {
+	var c int64
+	res := qb.buildQuery(db).Model(&MenuAction{}).Count(&c)
+	if res.Error != nil && res.Error == gorm.ErrRecordNotFound {
+		c = 0
+	}
+	return c, res.Error
+}
+
+func (qb *menuActionRepoQueryBuilder) First(db *gorm.DB) (*MenuAction, error) {
+	ret := &MenuAction{}
+	res := qb.buildQuery(db).First(ret)
+	if res.Error != nil && res.Error == gorm.ErrRecordNotFound {
+		ret = nil
+	}
+	return ret, res.Error
+}
+
+func (qb *menuActionRepoQueryBuilder) QueryOne(db *gorm.DB) (*MenuAction, error) {
+	qb.limit = 1
+	ret, err := qb.QueryAll(db)
+	if len(ret) > 0 {
+		return ret[0], err
+	}
+	return nil, err
+}
+
+func (qb *menuActionRepoQueryBuilder) QueryAll(db *gorm.DB) ([]*MenuAction, error) {
+	var ret []*MenuAction
+	err := qb.buildQuery(db).Find(&ret).Error
+	return ret, err
+}
+
+func (qb *menuActionRepoQueryBuilder) Limit(limit int) *menuActionRepoQueryBuilder {
+	qb.limit = limit
+	return qb
+}
+
+func (qb *menuActionRepoQueryBuilder) Offset(offset int) *menuActionRepoQueryBuilder {
+	qb.offset = offset
+	return qb
+}
+
+func (qb *menuActionRepoQueryBuilder) WhereId(p db_repo.Predicate, value int32) *menuActionRepoQueryBuilder {
+	qb.where = append(qb.where, struct {
+		prefix string
+		value  interface{}
+	}{
+		fmt.Sprintf("%v %v ?", "id", p),
+		value,
+	})
+	return qb
+}
+
+func (qb *menuActionRepoQueryBuilder) WhereIdIn(value []int32) *menuActionRepoQueryBuilder {
+	qb.where = append(qb.where, struct {
+		prefix string
+		value  interface{}
+	}{
+		fmt.Sprintf("%v %v ?", "id", "IN"),
+		value,
+	})
+	return qb
+}
+
+func (qb *menuActionRepoQueryBuilder) WhereIdNotIn(value []int32) *menuActionRepoQueryBuilder {
+	qb.where = append(qb.where, struct {
+		prefix string
+		value  interface{}
+	}{
+		fmt.Sprintf("%v %v ?", "id", "NOT IN"),
+		value,
+	})
+	return qb
+}
+
+func (qb *menuActionRepoQueryBuilder) OrderById(asc bool) *menuActionRepoQueryBuilder {
+	order := "DESC"
+	if asc {
+		order = "ASC"
+	}
+
+	qb.order = append(qb.order, "id "+order)
+	return qb
+}
+
+func (qb *menuActionRepoQueryBuilder) WhereMenuId(p db_repo.Predicate, value int32) *menuActionRepoQueryBuilder {
+	qb.where = append(qb.where, struct {
+		prefix string
+		value  interface{}
+	}{
+		fmt.Sprintf("%v %v ?", "menu_id", p),
+		value,
+	})
+	return qb
+}
+
+func (qb *menuActionRepoQueryBuilder) WhereMenuIdIn(value []int32) *menuActionRepoQueryBuilder {
+	qb.where = append(qb.where, struct {
+		prefix string
+		value  interface{}
+	}{
+		fmt.Sprintf("%v %v ?", "menu_id", "IN"),
+		value,
+	})
+	return qb
+}
+
+func (qb *menuActionRepoQueryBuilder) WhereMenuIdNotIn(value []int32) *menuActionRepoQueryBuilder {
+	qb.where = append(qb.where, struct {
+		prefix string
+		value  interface{}
+	}{
+		fmt.Sprintf("%v %v ?", "menu_id", "NOT IN"),
+		value,
+	})
+	return qb
+}
+
+func (qb *menuActionRepoQueryBuilder) OrderByMenuId(asc bool) *menuActionRepoQueryBuilder {
+	order := "DESC"
+	if asc {
+		order = "ASC"
+	}
+
+	qb.order = append(qb.order, "menu_id "+order)
+	return qb
+}
+
+func (qb *menuActionRepoQueryBuilder) WhereMethod(p db_repo.Predicate, value string) *menuActionRepoQueryBuilder {
+	qb.where = append(qb.where, struct {
+		prefix string
+		value  interface{}
+	}{
+		fmt.Sprintf("%v %v ?", "method", p),
+		value,
+	})
+	return qb
+}
+
+func (qb *menuActionRepoQueryBuilder) WhereMethodIn(value []string) *menuActionRepoQueryBuilder {
+	qb.where = append(qb.where, struct {
+		prefix string
+		value  interface{}
+	}{
+		fmt.Sprintf("%v %v ?", "method", "IN"),
+		value,
+	})
+	return qb
+}
+
+func (qb *menuActionRepoQueryBuilder) WhereMethodNotIn(value []string) *menuActionRepoQueryBuilder {
+	qb.where = append(qb.where, struct {
+		prefix string
+		value  interface{}
+	}{
+		fmt.Sprintf("%v %v ?", "method", "NOT IN"),
+		value,
+	})
+	return qb
+}
+
+func (qb *menuActionRepoQueryBuilder) OrderByMethod(asc bool) *menuActionRepoQueryBuilder {
+	order := "DESC"
+	if asc {
+		order = "ASC"
+	}
+
+	qb.order = append(qb.order, "method "+order)
+	return qb
+}
+
+func (qb *menuActionRepoQueryBuilder) WhereApi(p db_repo.Predicate, value string) *menuActionRepoQueryBuilder {
+	qb.where = append(qb.where, struct {
+		prefix string
+		value  interface{}
+	}{
+		fmt.Sprintf("%v %v ?", "api", p),
+		value,
+	})
+	return qb
+}
+
+func (qb *menuActionRepoQueryBuilder) WhereApiIn(value []string) *menuActionRepoQueryBuilder {
+	qb.where = append(qb.where, struct {
+		prefix string
+		value  interface{}
+	}{
+		fmt.Sprintf("%v %v ?", "api", "IN"),
+		value,
+	})
+	return qb
+}
+
+func (qb *menuActionRepoQueryBuilder) WhereApiNotIn(value []string) *menuActionRepoQueryBuilder {
+	qb.where = append(qb.where, struct {
+		prefix string
+		value  interface{}
+	}{
+		fmt.Sprintf("%v %v ?", "api", "NOT IN"),
+		value,
+	})
+	return qb
+}
+
+func (qb *menuActionRepoQueryBuilder) OrderByApi(asc bool) *menuActionRepoQueryBuilder {
+	order := "DESC"
+	if asc {
+		order = "ASC"
+	}
+
+	qb.order = append(qb.order, "api "+order)
+	return qb
+}
+
+func (qb *menuActionRepoQueryBuilder) WhereIsDeleted(p db_repo.Predicate, value int32) *menuActionRepoQueryBuilder {
+	qb.where = append(qb.where, struct {
+		prefix string
+		value  interface{}
+	}{
+		fmt.Sprintf("%v %v ?", "is_deleted", p),
+		value,
+	})
+	return qb
+}
+
+func (qb *menuActionRepoQueryBuilder) WhereIsDeletedIn(value []int32) *menuActionRepoQueryBuilder {
+	qb.where = append(qb.where, struct {
+		prefix string
+		value  interface{}
+	}{
+		fmt.Sprintf("%v %v ?", "is_deleted", "IN"),
+		value,
+	})
+	return qb
+}
+
+func (qb *menuActionRepoQueryBuilder) WhereIsDeletedNotIn(value []int32) *menuActionRepoQueryBuilder {
+	qb.where = append(qb.where, struct {
+		prefix string
+		value  interface{}
+	}{
+		fmt.Sprintf("%v %v ?", "is_deleted", "NOT IN"),
+		value,
+	})
+	return qb
+}
+
+func (qb *menuActionRepoQueryBuilder) OrderByIsDeleted(asc bool) *menuActionRepoQueryBuilder {
+	order := "DESC"
+	if asc {
+		order = "ASC"
+	}
+
+	qb.order = append(qb.order, "is_deleted "+order)
+	return qb
+}
+
+func (qb *menuActionRepoQueryBuilder) WhereCreatedAt(p db_repo.Predicate, value time.Time) *menuActionRepoQueryBuilder {
+	qb.where = append(qb.where, struct {
+		prefix string
+		value  interface{}
+	}{
+		fmt.Sprintf("%v %v ?", "created_at", p),
+		value,
+	})
+	return qb
+}
+
+func (qb *menuActionRepoQueryBuilder) WhereCreatedAtIn(value []time.Time) *menuActionRepoQueryBuilder {
+	qb.where = append(qb.where, struct {
+		prefix string
+		value  interface{}
+	}{
+		fmt.Sprintf("%v %v ?", "created_at", "IN"),
+		value,
+	})
+	return qb
+}
+
+func (qb *menuActionRepoQueryBuilder) WhereCreatedAtNotIn(value []time.Time) *menuActionRepoQueryBuilder {
+	qb.where = append(qb.where, struct {
+		prefix string
+		value  interface{}
+	}{
+		fmt.Sprintf("%v %v ?", "created_at", "NOT IN"),
+		value,
+	})
+	return qb
+}
+
+func (qb *menuActionRepoQueryBuilder) OrderByCreatedAt(asc bool) *menuActionRepoQueryBuilder {
+	order := "DESC"
+	if asc {
+		order = "ASC"
+	}
+
+	qb.order = append(qb.order, "created_at "+order)
+	return qb
+}
+
+func (qb *menuActionRepoQueryBuilder) WhereCreatedUser(p db_repo.Predicate, value string) *menuActionRepoQueryBuilder {
+	qb.where = append(qb.where, struct {
+		prefix string
+		value  interface{}
+	}{
+		fmt.Sprintf("%v %v ?", "created_user", p),
+		value,
+	})
+	return qb
+}
+
+func (qb *menuActionRepoQueryBuilder) WhereCreatedUserIn(value []string) *menuActionRepoQueryBuilder {
+	qb.where = append(qb.where, struct {
+		prefix string
+		value  interface{}
+	}{
+		fmt.Sprintf("%v %v ?", "created_user", "IN"),
+		value,
+	})
+	return qb
+}
+
+func (qb *menuActionRepoQueryBuilder) WhereCreatedUserNotIn(value []string) *menuActionRepoQueryBuilder {
+	qb.where = append(qb.where, struct {
+		prefix string
+		value  interface{}
+	}{
+		fmt.Sprintf("%v %v ?", "created_user", "NOT IN"),
+		value,
+	})
+	return qb
+}
+
+func (qb *menuActionRepoQueryBuilder) OrderByCreatedUser(asc bool) *menuActionRepoQueryBuilder {
+	order := "DESC"
+	if asc {
+		order = "ASC"
+	}
+
+	qb.order = append(qb.order, "created_user "+order)
+	return qb
+}
+
+func (qb *menuActionRepoQueryBuilder) WhereUpdatedAt(p db_repo.Predicate, value time.Time) *menuActionRepoQueryBuilder {
+	qb.where = append(qb.where, struct {
+		prefix string
+		value  interface{}
+	}{
+		fmt.Sprintf("%v %v ?", "updated_at", p),
+		value,
+	})
+	return qb
+}
+
+func (qb *menuActionRepoQueryBuilder) WhereUpdatedAtIn(value []time.Time) *menuActionRepoQueryBuilder {
+	qb.where = append(qb.where, struct {
+		prefix string
+		value  interface{}
+	}{
+		fmt.Sprintf("%v %v ?", "updated_at", "IN"),
+		value,
+	})
+	return qb
+}
+
+func (qb *menuActionRepoQueryBuilder) WhereUpdatedAtNotIn(value []time.Time) *menuActionRepoQueryBuilder {
+	qb.where = append(qb.where, struct {
+		prefix string
+		value  interface{}
+	}{
+		fmt.Sprintf("%v %v ?", "updated_at", "NOT IN"),
+		value,
+	})
+	return qb
+}
+
+func (qb *menuActionRepoQueryBuilder) OrderByUpdatedAt(asc bool) *menuActionRepoQueryBuilder {
+	order := "DESC"
+	if asc {
+		order = "ASC"
+	}
+
+	qb.order = append(qb.order, "updated_at "+order)
+	return qb
+}
+
+func (qb *menuActionRepoQueryBuilder) WhereUpdatedUser(p db_repo.Predicate, value string) *menuActionRepoQueryBuilder {
+	qb.where = append(qb.where, struct {
+		prefix string
+		value  interface{}
+	}{
+		fmt.Sprintf("%v %v ?", "updated_user", p),
+		value,
+	})
+	return qb
+}
+
+func (qb *menuActionRepoQueryBuilder) WhereUpdatedUserIn(value []string) *menuActionRepoQueryBuilder {
+	qb.where = append(qb.where, struct {
+		prefix string
+		value  interface{}
+	}{
+		fmt.Sprintf("%v %v ?", "updated_user", "IN"),
+		value,
+	})
+	return qb
+}
+
+func (qb *menuActionRepoQueryBuilder) WhereUpdatedUserNotIn(value []string) *menuActionRepoQueryBuilder {
+	qb.where = append(qb.where, struct {
+		prefix string
+		value  interface{}
+	}{
+		fmt.Sprintf("%v %v ?", "updated_user", "NOT IN"),
+		value,
+	})
+	return qb
+}
+
+func (qb *menuActionRepoQueryBuilder) OrderByUpdatedUser(asc bool) *menuActionRepoQueryBuilder {
+	order := "DESC"
+	if asc {
+		order = "ASC"
+	}
+
+	qb.order = append(qb.order, "updated_user "+order)
+	return qb
+}

internal/api/repository/db_repo/menu_action_repo/gen_model.go

@@ -0,0 +1,17 @@
+package menu_action_repo
+
+import "time"
+
+// 功能权限表
+//go:generate gormgen -structs MenuAction -input .
+type MenuAction struct {
+	Id          int32     // 主键
+	MenuId      int32     // 菜单栏ID
+	Method      string    // 请求方式
+	Api         string    // 请求地址
+	IsDeleted   int32     // 是否删除 1:是  -1:否
+	CreatedAt   time.Time `gorm:"time"` // 创建时间
+	CreatedUser string    // 创建人
+	UpdatedAt   time.Time `gorm:"time"` // 更新时间
+	UpdatedUser string    // 更新人
+}

internal/api/repository/db_repo/menu_action_repo/gen_table.md

@@ -0,0 +1,14 @@
+#### go_gin_api.menu_action 
+功能权限表
+
+| 序号 | 名称 | 描述 | 类型 | 键 | 为空 | 额外 | 默认值 |
+| :--: | :--: | :--: | :--: | :--: | :--: | :--: | :--: |
+| 1 | id | 主键 | int(11) unsigned | PRI | NO | auto_increment |  |
+| 2 | menu_id | 菜单栏ID | int(11) unsigned | MUL | NO |  | 0 |
+| 3 | method | 请求方式 | varchar(30) |  | NO |  |  |
+| 4 | api | 请求地址 | varchar(100) |  | NO |  |  |
+| 5 | is_deleted | 是否删除 1:是  -1:否 | tinyint(1) |  | NO |  | -1 |
+| 6 | created_at | 创建时间 | timestamp |  | NO |  | CURRENT_TIMESTAMP |
+| 7 | created_user | 创建人 | varchar(60) |  | NO |  |  |
+| 8 | updated_at | 更新时间 | timestamp |  | NO | on update CURRENT_TIMESTAMP | CURRENT_TIMESTAMP |
+| 9 | updated_user | 更新人 | varchar(60) |  | NO |  |  |

internal/api/repository/db_repo/menu_repo/gen_menu.go

@@ -30,20 +30,6 @@ func (t *Menu) Create(db *gorm.DB) (id int32, err error) {
 	return t.Id, nil
 }
 
-func (t *Menu) Delete(db *gorm.DB) (err error) {
-	if err = db.Delete(t).Error; err != nil {
-		return errors.Wrap(err, "delete err")
-	}
-	return nil
-}
-
-func (t *Menu) Updates(db *gorm.DB, m map[string]interface{}) (err error) {
-	if err = db.Model(&Menu{}).Where("id = ?", t.Id).Updates(m).Error; err != nil {
-		return errors.Wrap(err, "updates err")
-	}
-	return nil
-}
-
 type menuRepoQueryBuilder struct {
 	order []string
 	where []struct {
@@ -66,6 +52,30 @@ func (qb *menuRepoQueryBuilder) buildQuery(db *gorm.DB) *gorm.DB {
 	return ret
 }
 
+func (qb *menuRepoQueryBuilder) Updates(db *gorm.DB, m map[string]interface{}) (err error) {
+	db = db.Model(&Menu{})
+
+	for _, where := range qb.where {
+		db.Where(where.prefix, where.value)
+	}
+
+	if err = db.Updates(m).Error; err != nil {
+		return errors.Wrap(err, "updates err")
+	}
+	return nil
+}
+
+func (qb *menuRepoQueryBuilder) Delete(db *gorm.DB) (err error) {
+	for _, where := range qb.where {
+		db = db.Where(where.prefix, where.value)
+	}
+
+	if err = db.Delete(&Menu{}).Error; err != nil {
+		return errors.Wrap(err, "delete err")
+	}
+	return nil
+}
+
 func (qb *menuRepoQueryBuilder) Count(db *gorm.DB) (int64, error) {
 	var c int64
 	res := qb.buildQuery(db).Model(&Menu{}).Count(&c)

internal/api/service/admin_service/service.go

@@ -17,7 +17,7 @@ type Service interface {
 	i()
 	CacheKeyPrefix() (pre string)
 
-	Create(ctx core.Context, authorizedData *CreateAdminData) (id int32, err error)
+	Create(ctx core.Context, adminData *CreateAdminData) (id int32, err error)
 	PageList(ctx core.Context, searchData *SearchData) (listData []*admin_repo.Admin, err error)
 	PageListCount(ctx core.Context, searchData *SearchData) (total int64, err error)
 	UpdateUsed(ctx core.Context, id int32, used int32) (err error)
@@ -26,6 +26,9 @@ type Service interface {
 	ResetPassword(ctx core.Context, id int32) (err error)
 	ModifyPassword(ctx core.Context, id int32, newPassword string) (err error)
 	ModifyPersonalInfo(ctx core.Context, id int32, modifyData *ModifyData) (err error)
+
+	CreateMenu(ctx core.Context, menuData *CreateMenuData) (err error)
+	ListMenu(ctx core.Context, searchData *SearchListMenuData) (menuData []ListMenuData, err error)
 }
 
 type service struct {

internal/api/service/admin_service/service_createmenu.go

@@ -0,0 +1,39 @@
+package admin_service
+
+import (
+	"strings"
+
+	"github.com/xinliangnote/go-gin-api/internal/api/repository/db_repo"
+	"github.com/xinliangnote/go-gin-api/internal/api/repository/db_repo/admin_menu_repo"
+	"github.com/xinliangnote/go-gin-api/internal/pkg/core"
+
+	"github.com/spf13/cast"
+)
+
+type CreateMenuData struct {
+	AdminId int32  `form:"admin_id"` // AdminID
+	Actions string `form:"actions"`  // 功能权限ID,多个用,分割
+}
+
+func (s *service) CreateMenu(ctx core.Context, menuData *CreateMenuData) (err error) {
+	qb := admin_menu_repo.NewQueryBuilder()
+	qb.WhereAdminId(db_repo.EqualPredicate, menuData.AdminId)
+	if err = qb.Delete(s.db.GetDbW().WithContext(ctx.RequestContext())); err != nil {
+		return
+	}
+
+	ActionArr := strings.Split(menuData.Actions, ",")
+	for _, v := range ActionArr {
+		createModel := admin_menu_repo.NewModel()
+		createModel.AdminId = menuData.AdminId
+		createModel.MenuId = cast.ToInt32(v)
+		createModel.CreatedUser = ctx.UserName()
+
+		_, err = createModel.Create(s.db.GetDbW().WithContext(ctx.RequestContext()))
+		if err != nil {
+			return
+		}
+	}
+
+	return
+}

internal/api/service/admin_service/service_delete.go

@@ -1,6 +1,7 @@
 package admin_service
 
 import (
+	"github.com/xinliangnote/go-gin-api/internal/api/repository/db_repo"
 	"github.com/xinliangnote/go-gin-api/internal/api/repository/db_repo/admin_repo"
 	"github.com/xinliangnote/go-gin-api/internal/pkg/cache"
 	"github.com/xinliangnote/go-gin-api/internal/pkg/core"
@@ -8,15 +9,14 @@ import (
 )
 
 func (s *service) Delete(ctx core.Context, id int32) (err error) {
-	model := admin_repo.NewModel()
-	model.Id = id
-
 	data := map[string]interface{}{
 		"is_deleted":   1,
 		"updated_user": ctx.UserName(),
 	}
 
-	err = model.Updates(s.db.GetDbW().WithContext(ctx.RequestContext()), data)
+	qb := admin_repo.NewQueryBuilder()
+	qb.WhereId(db_repo.EqualPredicate, id)
+	err = qb.Updates(s.db.GetDbW().WithContext(ctx.RequestContext()), data)
 	if err != nil {
 		return err
 	}

internal/api/service/admin_service/service_listmenu.go

@@ -0,0 +1,72 @@
+package admin_service
+
+import (
+	"github.com/xinliangnote/go-gin-api/internal/api/repository/db_repo"
+	"github.com/xinliangnote/go-gin-api/internal/api/repository/db_repo/admin_menu_repo"
+	"github.com/xinliangnote/go-gin-api/internal/api/repository/db_repo/menu_repo"
+	"github.com/xinliangnote/go-gin-api/internal/pkg/core"
+)
+
+type SearchListMenuData struct {
+	AdminId int32 `json:"admin_id"` // 管理员ID
+}
+
+type ListMenuData struct {
+	Id     int32  `json:"id"`      // ID
+	Pid    int32  `json:"pid"`     // 父类ID
+	Name   string `json:"name"`    // 菜单名称
+	IsHave int32  `json:"is_have"` // 是否已拥有权限
+}
+
+func (s *service) ListMenu(ctx core.Context, searchData *SearchListMenuData) (menuData []ListMenuData, err error) {
+	menuQb := menu_repo.NewQueryBuilder()
+	menuQb.WhereIsDeleted(db_repo.EqualPredicate, -1)
+	menuListData, err := menuQb.
+		OrderById(false).
+		QueryAll(s.db.GetDbR().WithContext(ctx.RequestContext()))
+	if err != nil {
+		return nil, err
+	}
+
+	if len(menuListData) <= 0 {
+		return
+	}
+
+	menuData = make([]ListMenuData, len(menuListData))
+	for k, v := range menuListData {
+		data := ListMenuData{
+			Id:     v.Id,
+			Pid:    v.Pid,
+			Name:   v.Name,
+			IsHave: 0,
+		}
+
+		menuData[k] = data
+	}
+
+	adminMenuQb := admin_menu_repo.NewQueryBuilder()
+	if searchData.AdminId != 0 {
+		adminMenuQb.WhereAdminId(db_repo.EqualPredicate, searchData.AdminId)
+	}
+
+	adminMenuListData, err := adminMenuQb.
+		OrderById(false).
+		QueryAll(s.db.GetDbR().WithContext(ctx.RequestContext()))
+	if err != nil {
+		return nil, err
+	}
+
+	if len(adminMenuListData) <= 0 {
+		return
+	}
+
+	for k, v := range menuData {
+		for _, haveV := range adminMenuListData {
+			if haveV.MenuId == v.Id {
+				menuData[k].IsHave = 1
+			}
+		}
+	}
+
+	return
+}

internal/api/service/admin_service/service_modifypassword.go

@@ -1,6 +1,7 @@
 package admin_service
 
 import (
+	"github.com/xinliangnote/go-gin-api/internal/api/repository/db_repo"
 	"github.com/xinliangnote/go-gin-api/internal/api/repository/db_repo/admin_repo"
 	"github.com/xinliangnote/go-gin-api/internal/pkg/cache"
 	"github.com/xinliangnote/go-gin-api/internal/pkg/core"
@@ -8,15 +9,14 @@ import (
 )
 
 func (s *service) ModifyPassword(ctx core.Context, id int32, newPassword string) (err error) {
-	model := admin_repo.NewModel()
-	model.Id = id
-
 	data := map[string]interface{}{
 		"password":     password.GeneratePassword(newPassword),
 		"updated_user": ctx.UserName(),
 	}
 
-	err = model.Updates(s.db.GetDbW().WithContext(ctx.RequestContext()), data)
+	qb := admin_repo.NewQueryBuilder()
+	qb.WhereId(db_repo.EqualPredicate, id)
+	err = qb.Updates(s.db.GetDbW().WithContext(ctx.RequestContext()), data)
 	if err != nil {
 		return err
 	}

internal/api/service/admin_service/service_modifypersonalinfo.go

@@ -1,6 +1,7 @@
 package admin_service
 
 import (
+	"github.com/xinliangnote/go-gin-api/internal/api/repository/db_repo"
 	"github.com/xinliangnote/go-gin-api/internal/api/repository/db_repo/admin_repo"
 	"github.com/xinliangnote/go-gin-api/internal/pkg/core"
 )
@@ -11,16 +12,15 @@ type ModifyData struct {
 }
 
 func (s *service) ModifyPersonalInfo(ctx core.Context, id int32, modifyData *ModifyData) (err error) {
-	model := admin_repo.NewModel()
-	model.Id = id
-
 	data := map[string]interface{}{
 		"nickname":     modifyData.Nickname,
 		"mobile":       modifyData.Mobile,
 		"updated_user": ctx.UserName(),
 	}
 
-	err = model.Updates(s.db.GetDbW().WithContext(ctx.RequestContext()), data)
+	qb := admin_repo.NewQueryBuilder()
+	qb.WhereId(db_repo.EqualPredicate, id)
+	err = qb.Updates(s.db.GetDbW().WithContext(ctx.RequestContext()), data)
 	if err != nil {
 		return err
 	}

internal/api/service/admin_service/service_resetpassword.go

@@ -1,6 +1,7 @@
 package admin_service
 
 import (
+	"github.com/xinliangnote/go-gin-api/internal/api/repository/db_repo"
 	"github.com/xinliangnote/go-gin-api/internal/api/repository/db_repo/admin_repo"
 	"github.com/xinliangnote/go-gin-api/internal/pkg/cache"
 	"github.com/xinliangnote/go-gin-api/internal/pkg/core"
@@ -8,15 +9,14 @@ import (
 )
 
 func (s *service) ResetPassword(ctx core.Context, id int32) (err error) {
-	model := admin_repo.NewModel()
-	model.Id = id
-
 	data := map[string]interface{}{
 		"password":     password.ResetPassword(),
 		"updated_user": ctx.UserName(),
 	}
 
-	err = model.Updates(s.db.GetDbW().WithContext(ctx.RequestContext()), data)
+	qb := admin_repo.NewQueryBuilder()
+	qb.WhereId(db_repo.EqualPredicate, id)
+	err = qb.Updates(s.db.GetDbW().WithContext(ctx.RequestContext()), data)
 	if err != nil {
 		return err
 	}

internal/api/service/admin_service/service_updateused.go

@@ -1,6 +1,7 @@
 package admin_service
 
 import (
+	"github.com/xinliangnote/go-gin-api/internal/api/repository/db_repo"
 	"github.com/xinliangnote/go-gin-api/internal/api/repository/db_repo/admin_repo"
 	"github.com/xinliangnote/go-gin-api/internal/pkg/cache"
 	"github.com/xinliangnote/go-gin-api/internal/pkg/core"
@@ -8,15 +9,14 @@ import (
 )
 
 func (s *service) UpdateUsed(ctx core.Context, id int32, used int32) (err error) {
-	model := admin_repo.NewModel()
-	model.Id = id
-
 	data := map[string]interface{}{
 		"is_used":      used,
 		"updated_user": ctx.UserName(),
 	}
 
-	err = model.Updates(s.db.GetDbW().WithContext(ctx.RequestContext()), data)
+	qb := admin_repo.NewQueryBuilder()
+	qb.WhereId(db_repo.EqualPredicate, id)
+	err = qb.Updates(s.db.GetDbW().WithContext(ctx.RequestContext()), data)
 	if err != nil {
 		return err
 	}

internal/api/service/authorized_service/service_delete.go

@@ -20,15 +20,14 @@ func (s *service) Delete(ctx core.Context, id int32) (err error) {
 		return nil
 	}
 
-	model := authorized_repo.NewModel()
-	model.Id = id
-
 	data := map[string]interface{}{
 		"is_deleted":   1,
 		"updated_user": ctx.UserName(),
 	}
 
-	err = model.Updates(s.db.GetDbW().WithContext(ctx.RequestContext()), data)
+	qb := authorized_repo.NewQueryBuilder()
+	qb.WhereId(db_repo.EqualPredicate, id)
+	err = qb.Updates(s.db.GetDbW().WithContext(ctx.RequestContext()), data)
 	if err != nil {
 		return err
 	}

internal/api/service/authorized_service/service_deleteapi.go

@@ -20,15 +20,14 @@ func (s *service) DeleteAPI(ctx core.Context, id int32) (err error) {
 		return nil
 	}
 
-	model := authorized_api_repo.NewModel()
-	model.Id = id
-
 	data := map[string]interface{}{
 		"is_deleted":   1,
 		"updated_user": ctx.UserName(),
 	}
 
-	err = model.Updates(s.db.GetDbW().WithContext(ctx.RequestContext()), data)
+	qb := authorized_api_repo.NewQueryBuilder()
+	qb.WhereId(db_repo.EqualPredicate, id)
+	err = qb.Updates(s.db.GetDbW().WithContext(ctx.RequestContext()), data)
 	if err != nil {
 		return err
 	}

internal/api/service/authorized_service/service_updateused.go

@@ -19,15 +19,14 @@ func (s *service) UpdateUsed(ctx core.Context, id int32, used int32) (err error)
 		return nil
 	}
 
-	model := authorized_repo.NewModel()
-	model.Id = id
-
 	data := map[string]interface{}{
 		"is_used":      used,
 		"updated_user": ctx.UserName(),
 	}
 
-	err = model.Updates(s.db.GetDbW().WithContext(ctx.RequestContext()), data)
+	qb := authorized_repo.NewQueryBuilder()
+	qb.WhereId(db_repo.EqualPredicate, id)
+	err = qb.Updates(s.db.GetDbW().WithContext(ctx.RequestContext()), data)
 	if err != nil {
 		return err
 	}

internal/api/service/menu_service/service.go

@@ -2,6 +2,7 @@ package menu_service
 
 import (
 	"github.com/xinliangnote/go-gin-api/configs"
+	"github.com/xinliangnote/go-gin-api/internal/api/repository/db_repo/menu_action_repo"
 	"github.com/xinliangnote/go-gin-api/internal/api/repository/db_repo/menu_repo"
 	"github.com/xinliangnote/go-gin-api/internal/pkg/cache"
 	"github.com/xinliangnote/go-gin-api/internal/pkg/core"
@@ -23,6 +24,10 @@ type Service interface {
 	UpdateUsed(ctx core.Context, id int32, used int32) (err error)
 	Delete(ctx core.Context, id int32) (err error)
 	Detail(ctx core.Context, searchOneData *SearchOneData) (info *menu_repo.Menu, err error)
+
+	CreateAction(ctx core.Context, menuActionData *CreateMenuActionData) (id int32, err error)
+	ListAction(ctx core.Context, searchListActionData *SearchListActionData) (listData []*menu_action_repo.MenuAction, err error)
+	DeleteAction(ctx core.Context, id int32) (err error)
 }
 
 type service struct {

internal/api/service/menu_service/service_createaction.go

@@ -0,0 +1,27 @@
+package menu_service
+
+import (
+	"github.com/xinliangnote/go-gin-api/internal/api/repository/db_repo/menu_action_repo"
+	"github.com/xinliangnote/go-gin-api/internal/pkg/core"
+)
+
+type CreateMenuActionData struct {
+	MenuId int32  `json:"menu_id"` // 菜单栏ID
+	Method string `json:"method"`  // 请求方法
+	API    string `json:"api"`     // 请求地址
+}
+
+func (s *service) CreateAction(ctx core.Context, menuActionData *CreateMenuActionData) (id int32, err error) {
+	model := menu_action_repo.NewModel()
+	model.MenuId = menuActionData.MenuId
+	model.Method = menuActionData.Method
+	model.Api = menuActionData.API
+	model.CreatedUser = ctx.UserName()
+	model.IsDeleted = -1
+
+	id, err = model.Create(s.db.GetDbW().WithContext(ctx.RequestContext()))
+	if err != nil {
+		return 0, err
+	}
+	return
+}

internal/api/service/menu_service/service_delete.go

@@ -1,20 +1,20 @@
 package menu_service
 
 import (
+	"github.com/xinliangnote/go-gin-api/internal/api/repository/db_repo"
 	"github.com/xinliangnote/go-gin-api/internal/api/repository/db_repo/menu_repo"
 	"github.com/xinliangnote/go-gin-api/internal/pkg/core"
 )
 
 func (s *service) Delete(ctx core.Context, id int32) (err error) {
-	model := menu_repo.NewModel()
-	model.Id = id
-
 	data := map[string]interface{}{
 		"is_deleted":   1,
 		"updated_user": ctx.UserName(),
 	}
 
-	err = model.Updates(s.db.GetDbW().WithContext(ctx.RequestContext()), data)
+	qb := menu_repo.NewQueryBuilder()
+	qb.WhereId(db_repo.EqualPredicate, id)
+	err = qb.Updates(s.db.GetDbW().WithContext(ctx.RequestContext()), data)
 	if err != nil {
 		return err
 	}

internal/api/service/menu_service/service_deleteaction.go

@@ -0,0 +1,35 @@
+package menu_service
+
+import (
+	"github.com/xinliangnote/go-gin-api/internal/api/repository/db_repo"
+	"github.com/xinliangnote/go-gin-api/internal/api/repository/db_repo/menu_action_repo"
+	"github.com/xinliangnote/go-gin-api/internal/pkg/core"
+
+	"gorm.io/gorm"
+)
+
+func (s *service) DeleteAction(ctx core.Context, id int32) (err error) {
+	// 先查询 id 是否存在
+	_, err = menu_action_repo.NewQueryBuilder().
+		WhereIsDeleted(db_repo.EqualPredicate, -1).
+		WhereId(db_repo.EqualPredicate, id).
+		First(s.db.GetDbR().WithContext(ctx.RequestContext()))
+
+	if err == gorm.ErrRecordNotFound {
+		return nil
+	}
+
+	data := map[string]interface{}{
+		"is_deleted":   1,
+		"updated_user": ctx.UserName(),
+	}
+
+	qb := menu_action_repo.NewQueryBuilder()
+	qb.WhereId(db_repo.EqualPredicate, id)
+	err = qb.Updates(s.db.GetDbW().WithContext(ctx.RequestContext()), data)
+	if err != nil {
+		return err
+	}
+
+	return
+}

internal/api/service/menu_service/service_listaction.go

@@ -0,0 +1,30 @@
+package menu_service
+
+import (
+	"github.com/xinliangnote/go-gin-api/internal/api/repository/db_repo"
+	"github.com/xinliangnote/go-gin-api/internal/api/repository/db_repo/menu_action_repo"
+	"github.com/xinliangnote/go-gin-api/internal/pkg/core"
+)
+
+type SearchListActionData struct {
+	MenuId int32 `json:"menu_id"` // 菜单栏ID
+}
+
+func (s *service) ListAction(ctx core.Context, searchData *SearchListActionData) (listData []*menu_action_repo.MenuAction, err error) {
+
+	qb := menu_action_repo.NewQueryBuilder()
+	qb.WhereIsDeleted(db_repo.EqualPredicate, -1)
+
+	if searchData.MenuId != 0 {
+		qb.WhereMenuId(db_repo.EqualPredicate, searchData.MenuId)
+	}
+
+	listData, err = qb.
+		OrderById(false).
+		QueryAll(s.db.GetDbR().WithContext(ctx.RequestContext()))
+	if err != nil {
+		return nil, err
+	}
+
+	return
+}

internal/api/service/menu_service/service_modify.go

@@ -1,6 +1,7 @@
 package menu_service
 
 import (
+	"github.com/xinliangnote/go-gin-api/internal/api/repository/db_repo"
 	"github.com/xinliangnote/go-gin-api/internal/api/repository/db_repo/menu_repo"
 	"github.com/xinliangnote/go-gin-api/internal/pkg/core"
 )
@@ -12,9 +13,6 @@ type UpdateMenuData struct {
 }
 
 func (s *service) Modify(ctx core.Context, id int32, menuData *UpdateMenuData) (err error) {
-	model := menu_repo.NewModel()
-	model.Id = id
-
 	data := map[string]interface{}{
 		"name":         menuData.Name,
 		"link":         menuData.Link,
@@ -22,7 +20,9 @@ func (s *service) Modify(ctx core.Context, id int32, menuData *UpdateMenuData) (
 		"updated_user": ctx.UserName(),
 	}
 
-	err = model.Updates(s.db.GetDbW().WithContext(ctx.RequestContext()), data)
+	qb := menu_repo.NewQueryBuilder()
+	qb.WhereId(db_repo.EqualPredicate, id)
+	err = qb.Updates(s.db.GetDbW().WithContext(ctx.RequestContext()), data)
 	if err != nil {
 		return err
 	}

internal/api/service/menu_service/service_updateused.go

@@ -1,20 +1,20 @@
 package menu_service
 
 import (
+	"github.com/xinliangnote/go-gin-api/internal/api/repository/db_repo"
 	"github.com/xinliangnote/go-gin-api/internal/api/repository/db_repo/menu_repo"
 	"github.com/xinliangnote/go-gin-api/internal/pkg/core"
 )
 
 func (s *service) UpdateUsed(ctx core.Context, id int32, used int32) (err error) {
-	model := menu_repo.NewModel()
-	model.Id = id
-
 	data := map[string]interface{}{
 		"is_used":      used,
 		"updated_user": ctx.UserName(),
 	}
 
-	err = model.Updates(s.db.GetDbW().WithContext(ctx.RequestContext()), data)
+	qb := menu_repo.NewQueryBuilder()
+	qb.WhereId(db_repo.EqualPredicate, id)
+	err = qb.Updates(s.db.GetDbW().WithContext(ctx.RequestContext()), data)
 	if err != nil {
 		return err
 	}

internal/router/router_api.go

@@ -14,13 +14,22 @@ func setApiRouter(r *resource) {
 	// admin
 	adminHandler := admin_handler.New(r.logger, r.db, r.cache)
 
-	// login
-	login := r.mux.Group("/login", r.middles.Signature())
+	// 需要签名验证，无需登录验证，无需 RBAC 权限验证
+	login := r.mux.Group("/api", r.middles.Signature())
 	{
-		login.POST("/web", adminHandler.Login())
+		login.POST("/login", adminHandler.Login())
 	}
 
-	// api
+	// 需要签名验证、登录验证，无需 RBAC 权限验证
+	notRBAC := r.mux.Group("/api", core.WrapAuthHandler(r.middles.Token), r.middles.Signature())
+	{
+		notRBAC.POST("/admin/logout", adminHandler.Logout())
+		notRBAC.PATCH("/admin/modify_password", adminHandler.ModifyPassword())
+		notRBAC.GET("/admin/info", adminHandler.Detail())
+		notRBAC.PATCH("/admin/modify_personal_info", adminHandler.ModifyPersonalInfo())
+	}
+
+	// 需要签名验证、登录验证、RBAC 权限验证
 	api := r.mux.Group("/api", core.WrapAuthHandler(r.middles.Token), r.middles.Signature())
 	{
 		// authorized
@@ -37,25 +46,27 @@ func setApiRouter(r *resource) {
 		api.POST("/admin", adminHandler.Create())
 		api.GET("/admin", adminHandler.List())
 		api.PATCH("/admin/used", adminHandler.UpdateUsed())
-		api.PATCH("/admin/reset_password/:id", adminHandler.ResetPassword())
-		api.DELETE("/admin/:id", adminHandler.Delete())
-		api.POST("/admin/logout", adminHandler.Logout())
-		api.PATCH("/admin/modify_password", adminHandler.ModifyPassword())
-		api.GET("/admin/info", adminHandler.Detail())
-		api.PATCH("/admin/modify_personal_info", adminHandler.ModifyPersonalInfo())
+		api.PATCH("/admin/reset_password/:id", core.AliasForRecordMetrics("/api/admin/reset_password"), adminHandler.ResetPassword())
+		api.DELETE("/admin/:id", core.AliasForRecordMetrics("/api/admin"), adminHandler.Delete())
+
+		api.POST("/admin/menu", adminHandler.CreateAdminMenu())
+		api.GET("/admin/menu/:id", core.AliasForRecordMetrics("/api/admin/menu"), adminHandler.ListAdminMenu())
 
 		// menu
 		menuHandler := menu_handler.New(r.logger, r.db, r.cache)
 		api.POST("/menu", menuHandler.Create())
 		api.GET("/menu", menuHandler.List())
-		api.GET("/menu/:id", menuHandler.Detail())
+		api.GET("/menu/:id", core.AliasForRecordMetrics("/api/menu"), menuHandler.Detail())
 		api.PATCH("/menu/used", menuHandler.UpdateUsed())
-		api.DELETE("/menu/:id", menuHandler.Delete())
+		api.DELETE("/menu/:id", core.AliasForRecordMetrics("/api/menu"), menuHandler.Delete())
+		api.POST("/menu_action", menuHandler.CreateAction())
+		api.GET("/menu_action", menuHandler.ListAction())
+		api.DELETE("/menu_action/:id", core.AliasForRecordMetrics("/api/menu_action"), menuHandler.DeleteAction())
 
 		// tool
 		toolHandler := tool_handler.New(r.logger, r.db, r.cache)
-		api.GET("/tool/hashids/encode/:id", toolHandler.HashIdsEncode())
-		api.GET("/tool/hashids/decode/:id", toolHandler.HashIdsDecode())
+		api.GET("/tool/hashids/encode/:id", core.AliasForRecordMetrics("/api/tool/hashids/encode"), toolHandler.HashIdsEncode())
+		api.GET("/tool/hashids/decode/:id", core.AliasForRecordMetrics("/api/tool/hashids/decode"), toolHandler.HashIdsDecode())
 		api.POST("/tool/cache/search", toolHandler.SearchCache())
 		api.PATCH("/tool/cache/clear", toolHandler.ClearCache())
 		api.GET("/tool/data/dbs", toolHandler.Dbs())

internal/router/router_web.go

@@ -5,10 +5,11 @@ import (
 	"github.com/xinliangnote/go-gin-api/internal/web/controller/authorized_handler"
 	"github.com/xinliangnote/go-gin-api/internal/web/controller/config_handler"
 	"github.com/xinliangnote/go-gin-api/internal/web/controller/dashboard_handler"
-	"github.com/xinliangnote/go-gin-api/internal/web/controller/gencode_handler"
+	"github.com/xinliangnote/go-gin-api/internal/web/controller/generator_handler"
 	"github.com/xinliangnote/go-gin-api/internal/web/controller/index_handler"
 	"github.com/xinliangnote/go-gin-api/internal/web/controller/install_handler"
 	"github.com/xinliangnote/go-gin-api/internal/web/controller/tool_handler"
+	"github.com/xinliangnote/go-gin-api/internal/web/controller/upgrade_handler"
 )
 
 func setWebRouter(r *resource) {
@@ -16,35 +17,46 @@ func setWebRouter(r *resource) {
 	installHandler := install_handler.New(r.logger)
 	indexHandler := index_handler.New(r.logger, r.db, r.cache)
 	dashboardHandler := dashboard_handler.New(r.logger, r.db, r.cache)
-	genCodeHandler := gencode_handler.New(r.logger, r.db, r.cache)
+	generatorHandler := generator_handler.New(r.logger, r.db, r.cache)
 	configInfoHandler := config_handler.New(r.logger, r.db, r.cache)
 	authorizedHandler := authorized_handler.New(r.logger, r.db, r.cache)
 	toolHandler := tool_handler.New(r.logger, r.db, r.cache)
 	adminHandler := admin_handler.New(r.logger, r.db, r.cache)
+	upgradeHandler := upgrade_handler.New(r.logger, r.db, r.cache)
 
-	web := r.mux.Group("", r.middles.DisableLog())
+	// 无需记录日志，无需 RBAC 权限验证
+	notRBAC := r.mux.Group("", r.middles.DisableLog())
 	{
 		// 首页
-		web.GET("", indexHandler.View())
-
-		// 安装
-		web.GET("/install", installHandler.View())
-		web.POST("/install/execute", installHandler.Execute())
-		web.POST("/install/restart", installHandler.Restart())
+		notRBAC.GET("", indexHandler.View())
 
 		// 仪表盘
-		web.GET("/dashboard", dashboardHandler.View())
+		notRBAC.GET("/dashboard", dashboardHandler.View())
 
+		// 安装
+		notRBAC.GET("/install", installHandler.View())
+		notRBAC.POST("/install/execute", installHandler.Execute())
+		notRBAC.POST("/install/restart", installHandler.Restart())
+
+		// 管理员
+		notRBAC.GET("/login", adminHandler.LoginView())
+		notRBAC.GET("/admin/modify_password", adminHandler.ModifyPasswordView())
+		notRBAC.GET("/admin/modify_info", adminHandler.ModifyInfoView())
+	}
+
+	// 无需记录日志，需要 RBAC 权限验证
+	web := r.mux.Group("", r.middles.DisableLog())
+	{
 		// 配置信息
 		web.GET("/config/email", configInfoHandler.EmailView())
 		web.GET("/config/code", configInfoHandler.CodeView())
 
-		// 代码生成工具
-		web.GET("/gormgen", genCodeHandler.GormView())
-		web.POST("/gormgen_exec", genCodeHandler.GormExecute())
+		// 代码生成器
+		web.GET("/generator/gorm", generatorHandler.GormView())
+		web.POST("/generator/gorm/execute", generatorHandler.GormExecute())
 
-		web.GET("/handlergen", genCodeHandler.HandlerView())
-		web.POST("/handlergen_exec", genCodeHandler.HandlerExecute())
+		web.GET("/generator/handler", generatorHandler.HandlerView())
+		web.POST("/generator/handler/execute", generatorHandler.HandlerExecute())
 
 		// 调用方
 		web.GET("/authorized/list", authorizedHandler.ListView())
@@ -55,10 +67,13 @@ func setWebRouter(r *resource) {
 		// 管理员
 		web.GET("/admin/list", adminHandler.ListView())
 		web.GET("/admin/add", adminHandler.AddView())
-		web.GET("/admin/modify_password", adminHandler.ModifyPasswordView())
-		web.GET("/admin/modify_info", adminHandler.ModifyInfoView())
-		web.GET("/login", adminHandler.LoginView())
 		web.GET("/admin/menu", adminHandler.MenuView())
+		web.GET("/admin/menu_action/:id", adminHandler.MenuActionView())
+		web.GET("/admin/action/:id", adminHandler.AdminMenuView())
+
+		// 升级
+		web.GET("/upgrade", upgradeHandler.UpgradeView())
+		web.POST("/upgrade/execute", upgradeHandler.UpgradeExecute())
 
 		// 工具箱
 		web.GET("/tool/hashids", toolHandler.HashIdsView())

internal/web/controller/admin_handler/func_adminmenuview.go

@@ -0,0 +1,36 @@
+package admin_handler
+
+import (
+	"net/http"
+
+	"github.com/xinliangnote/go-gin-api/internal/api/code"
+	"github.com/xinliangnote/go-gin-api/internal/pkg/core"
+	"github.com/xinliangnote/go-gin-api/pkg/errno"
+)
+
+type adminMenuViewRequest struct {
+	Id string `uri:"id"` // 主键ID
+}
+
+type adminMenuViewResponse struct {
+	HashID string `json:"hash_id"` // hashID
+}
+
+func (h *handler) AdminMenuView() core.HandlerFunc {
+	return func(c core.Context) {
+		req := new(adminMenuViewRequest)
+		if err := c.ShouldBindURI(req); err != nil {
+			c.AbortWithError(errno.NewError(
+				http.StatusBadRequest,
+				code.ParamBindError,
+				code.Text(code.ParamBindError)).WithErr(err),
+			)
+			return
+		}
+
+		obj := new(adminMenuViewResponse)
+		obj.HashID = req.Id
+
+		c.HTML("admin_menu", obj)
+	}
+}

internal/web/controller/admin_handler/func_menuactionview.go

@@ -0,0 +1,36 @@
+package admin_handler
+
+import (
+	"net/http"
+
+	"github.com/xinliangnote/go-gin-api/internal/api/code"
+	"github.com/xinliangnote/go-gin-api/internal/pkg/core"
+	"github.com/xinliangnote/go-gin-api/pkg/errno"
+)
+
+type menuActionViewRequest struct {
+	Id string `uri:"id"` // 主键ID
+}
+
+type menuActionViewResponse struct {
+	HashID string `json:"hash_id"` // hashID
+}
+
+func (h *handler) MenuActionView() core.HandlerFunc {
+	return func(c core.Context) {
+		req := new(menuActionViewRequest)
+		if err := c.ShouldBindURI(req); err != nil {
+			c.AbortWithError(errno.NewError(
+				http.StatusBadRequest,
+				code.ParamBindError,
+				code.Text(code.ParamBindError)).WithErr(err),
+			)
+			return
+		}
+
+		obj := new(menuActionViewResponse)
+		obj.HashID = req.Id
+
+		c.HTML("menu_action", obj)
+	}
+}

internal/web/controller/admin_handler/handler.go

@@ -19,6 +19,8 @@ type Handler interface {
 	ModifyPasswordView() core.HandlerFunc
 	ModifyInfoView() core.HandlerFunc
 	MenuView() core.HandlerFunc
+	MenuActionView() core.HandlerFunc
+	AdminMenuView() core.HandlerFunc
 }
 
 type handler struct {

internal/web/controller/generator_handler/func_gormexecute.go

@@ -1,4 +1,4 @@
-package gencode_handler
+package generator_handler
 
 import (
 	"bytes"

internal/web/controller/generator_handler/func_gormview.go

@@ -1,4 +1,4 @@
-package gencode_handler
+package generator_handler
 
 import (
 	"fmt"
@@ -21,7 +21,7 @@ func (h *handler) GormView() core.HandlerFunc {
 		sqlTables := fmt.Sprintf("SELECT `table_name`,`table_comment` FROM `information_schema`.`tables` WHERE `table_schema`= '%s'", mysqlConf.Name)
 		rows, err := h.db.GetDbR().Raw(sqlTables).Rows()
 		if err != nil {
-			c.HTML("gencode_gorm", tableCollect)
+			c.HTML("generator_gorm", tableCollect)
 			return
 		}
 		defer rows.Close()
@@ -37,6 +37,6 @@ func (h *handler) GormView() core.HandlerFunc {
 			tableCollect = append(tableCollect, info)
 		}
 
-		c.HTML("gencode_gorm", tableCollect)
+		c.HTML("generator_gorm", tableCollect)
 	}
 }

internal/web/controller/generator_handler/func_handlerexecute.go

@@ -1,4 +1,4 @@
-package gencode_handler
+package generator_handler
 
 import (
 	"bytes"

internal/web/controller/generator_handler/func_handlerview.go

@@ -1,4 +1,4 @@
-package gencode_handler
+package generator_handler
 
 import (
 	"github.com/xinliangnote/go-gin-api/internal/pkg/core"
@@ -6,6 +6,6 @@ import (
 
 func (h *handler) HandlerView() core.HandlerFunc {
 	return func(c core.Context) {
-		c.HTML("gencode_handler", nil)
+		c.HTML("generator_handler", nil)
 	}
 }

internal/web/controller/generator_handler/handler.go

@@ -1,4 +1,4 @@
-package gencode_handler
+package generator_handler
 
 import (
 	"github.com/xinliangnote/go-gin-api/internal/pkg/cache"

internal/web/controller/install_handler/func_execute.go

@@ -209,6 +209,56 @@ func (h *handler) Execute() core.HandlerFunc {
 		}
 		outPutString += "初始化 MySQL 数据表：menu 成功。\n"
 
+		if err = db.Exec(mysql_table.CreateMenuTableDataSql()).Error; err != nil {
+			c.AbortWithError(errno.NewError(
+				http.StatusBadRequest,
+				code.ConfigMySQLInstallError,
+				"MySQL "+err.Error()).WithErr(err),
+			)
+			return
+		}
+		outPutString += "初始化 MySQL 数据表：menu 默认数据成功。\n"
+
+		if err = db.Exec(mysql_table.CreateMenuActionTableSql()).Error; err != nil {
+			c.AbortWithError(errno.NewError(
+				http.StatusBadRequest,
+				code.ConfigMySQLInstallError,
+				"MySQL "+err.Error()).WithErr(err),
+			)
+			return
+		}
+		outPutString += "初始化 MySQL 数据表：menu_action 成功。\n"
+
+		if err = db.Exec(mysql_table.CreateMenuActionTableDataSql()).Error; err != nil {
+			c.AbortWithError(errno.NewError(
+				http.StatusBadRequest,
+				code.ConfigMySQLInstallError,
+				"MySQL "+err.Error()).WithErr(err),
+			)
+			return
+		}
+		outPutString += "初始化 MySQL 数据表：menu_action 默认数据成功。\n"
+
+		if err = db.Exec(mysql_table.CreateAdminMenuTableSql()).Error; err != nil {
+			c.AbortWithError(errno.NewError(
+				http.StatusBadRequest,
+				code.ConfigMySQLInstallError,
+				"MySQL "+err.Error()).WithErr(err),
+			)
+			return
+		}
+		outPutString += "初始化 MySQL 数据表：admin_menu 成功。\n"
+
+		if err = db.Exec(mysql_table.CreateAdminMenuTableDataSql()).Error; err != nil {
+			c.AbortWithError(errno.NewError(
+				http.StatusBadRequest,
+				code.ConfigMySQLInstallError,
+				"MySQL "+err.Error()).WithErr(err),
+			)
+			return
+		}
+		outPutString += "初始化 MySQL 数据表：admin_menu 默认数据成功。\n"
+
 		// 生成 install 完成标识
 		f, err := os.Create(configs.ProjectInstallFile())
 		if err != nil {

internal/web/controller/install_handler/mysql_table/table_admin_menu.go

@@ -0,0 +1,53 @@
+package mysql_table
+
+//CREATE TABLE `admin_menu` (
+//`id` int(11) unsigned NOT NULL AUTO_INCREMENT COMMENT '主键',
+//`admin_id` int(11) unsigned NOT NULL DEFAULT '0' COMMENT '管理员ID',
+//`menu_id` int(11) unsigned NOT NULL DEFAULT '0' COMMENT '菜单栏ID',
+//`created_at` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
+//`created_user` varchar(60) NOT NULL DEFAULT '' COMMENT '创建人',
+//PRIMARY KEY (`id`),
+//KEY `idx_admin_id` (`admin_id`)
+//) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='管理员菜单栏表';
+
+func CreateAdminMenuTableSql() (sql string) {
+	sql = "CREATE TABLE `admin_menu` ("
+	sql += "`id` int(11) unsigned NOT NULL AUTO_INCREMENT COMMENT '主键',"
+	sql += "`admin_id` int(11) unsigned NOT NULL DEFAULT '0' COMMENT '管理员ID',"
+	sql += "`menu_id` int(11) unsigned NOT NULL DEFAULT '0' COMMENT '菜单栏ID',"
+	sql += "`created_at` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',"
+	sql += "`created_user` varchar(60) NOT NULL DEFAULT '' COMMENT '创建人',"
+	sql += "PRIMARY KEY (`id`),"
+	sql += "KEY `idx_admin_id` (`admin_id`)"
+	sql += ") ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='管理员菜单栏表';"
+
+	return
+}
+
+func CreateAdminMenuTableDataSql() (sql string) {
+	sql = "INSERT INTO `admin_menu` (`id`, `admin_id`, `menu_id`, `created_user`) VALUES"
+	sql += "(1, 1, 16, 'init'),"
+	sql += "(2, 1, 21, 'init'),"
+	sql += "(3, 1, 20, 'init'),"
+	sql += "(4, 1, 19, 'init'),"
+	sql += "(5, 1, 18, 'init'),"
+	sql += "(6, 1, 17, 'init'),"
+	sql += "(7, 1, 13, 'init'),"
+	sql += "(8, 1, 15, 'init'),"
+	sql += "(9, 1, 14, 'init'),"
+	sql += "(10, 1, 10, 'init'),"
+	sql += "(11, 1, 12, 'init'),"
+	sql += "(12, 1, 11, 'init'),"
+	sql += "(13, 1, 7, 'init'),"
+	sql += "(14, 1, 9, 'init'),"
+	sql += "(15, 1, 8, 'init'),"
+	sql += "(16, 1, 4, 'init'),"
+	sql += "(17, 1, 6, 'init'),"
+	sql += "(18, 1, 5, 'init'),"
+	sql += "(19, 1, 1, 'init'),"
+	sql += "(20, 1, 3, 'init'),"
+	sql += "(21, 1, 2, 'init'),"
+	sql += "(22, 1, 22, 'init');"
+
+	return
+}

internal/web/controller/install_handler/mysql_table/table_menu.go

@@ -35,3 +35,31 @@ func CreateMenuTableSql() (sql string) {
 
 	return
 }
+
+func CreateMenuTableDataSql() (sql string) {
+	sql = "INSERT INTO `menu` (`id`, `pid`, `name`, `link`, `icon`, `level`, `created_user`) VALUES"
+	sql += "(1, 0, '配置信息', '', 'mdi-settings-box', 1, 'init'),"
+	sql += "(2, 1, '告警邮箱', '/config/email', '', 2, 'init'),"
+	sql += "(3, 1, '错误码', '/config/code', '', 2, 'init'),"
+	sql += "(4, 0, '代码生成器', '', 'mdi-code-not-equal-variant', 1, 'init'),"
+	sql += "(5, 4, '生成数据表 CURD', '/generator/gorm', '', 2, 'init'),"
+	sql += "(6, 4, '生成控制器方法', '/generator/handler', '', 2, 'init'),"
+	sql += "(7, 0, '授权调用方', '', 'mdi-playlist-check', 1, 'init'),"
+	sql += "(8, 7, '调用方', '/authorized/list', '', 2, 'init'),"
+	sql += "(9, 7, '使用说明', '/authorized/demo', '', 2, 'init'),"
+	sql += "(10, 0, '系统管理员', '', 'mdi-account', 1, 'init'),"
+	sql += "(11, 10, '管理员', '/admin/list', '', 2, 'init'),"
+	sql += "(12, 10, '菜单管理', '/admin/menu', '', 2, 'init'),"
+	sql += "(13, 0, '查询小助手', '', 'mdi-database-search', 1, 'init'),"
+	sql += "(14, 13, '查询缓存', '/tool/cache', '', 2, 'init'),"
+	sql += "(15, 13, '查询数据', '/tool/data', '', 2, 'init'),"
+	sql += "(16, 0, '实用工具箱', '', 'mdi-tools', 1, 'init'),"
+	sql += "(17, 16, 'Hashids', '/tool/hashids', '', 2, 'init'),"
+	sql += "(18, 16, '调用日志', '/tool/logs', '', 2, 'init'),"
+	sql += "(19, 16, '接口文档', '/swagger/index.html', '', 2, 'init'),"
+	sql += "(20, 16, 'GraphQL', '/graphql', '', 2, 'init'),"
+	sql += "(21, 16, '接口指标', '/metrics', '', 2, 'init'),"
+	sql += "(22, 16, '服务升级', '/upgrade', '', 2, 'init');"
+
+	return
+}

internal/web/controller/install_handler/mysql_table/table_menu_action.go

@@ -0,0 +1,76 @@
+package mysql_table
+
+//CREATE TABLE `menu_action` (
+//`id` int(11) unsigned NOT NULL AUTO_INCREMENT COMMENT '主键',
+//`menu_id` int(11) unsigned NOT NULL DEFAULT '0' COMMENT '菜单栏ID',
+//`method` varchar(30) NOT NULL DEFAULT '' COMMENT '请求方式',
+//`api` varchar(100) NOT NULL DEFAULT '' COMMENT '请求地址',
+//`is_deleted` tinyint(1) NOT NULL DEFAULT '-1' COMMENT '是否删除 1:是  -1:否',
+//`created_at` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
+//`created_user` varchar(60) NOT NULL DEFAULT '' COMMENT '创建人',
+//`updated_at` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
+//`updated_user` varchar(60) NOT NULL DEFAULT '' COMMENT '更新人',
+//PRIMARY KEY (`id`),
+//KEY `idx_menu_id` (`menu_id`)
+//) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='功能权限表';
+
+func CreateMenuActionTableSql() (sql string) {
+	sql = "CREATE TABLE `menu_action` ("
+	sql += "`id` int(11) unsigned NOT NULL AUTO_INCREMENT COMMENT '主键',"
+	sql += "`menu_id` int(11) unsigned NOT NULL DEFAULT '0' COMMENT '菜单栏ID',"
+	sql += "`method` varchar(30) NOT NULL DEFAULT '' COMMENT '请求方式',"
+	sql += "`api` varchar(100) NOT NULL DEFAULT '' COMMENT '请求地址',"
+	sql += "`is_deleted` tinyint(1) NOT NULL DEFAULT '-1' COMMENT '是否删除 1:是  -1:否',"
+	sql += "`created_at` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',"
+	sql += "`created_user` varchar(60) NOT NULL DEFAULT '' COMMENT '创建人',"
+	sql += "`updated_at` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',"
+	sql += "`updated_user` varchar(60) NOT NULL DEFAULT '' COMMENT '更新人',"
+	sql += "PRIMARY KEY (`id`),"
+	sql += "KEY `idx_menu_id` (`menu_id`)"
+	sql += ") ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='功能权限表';"
+
+	return
+}
+
+func CreateMenuActionTableDataSql() (sql string) {
+	sql = "INSERT INTO `menu_action` (`id`, `menu_id`, `method`, `api`, `created_user`) VALUES"
+	sql += "(1, 17, 'GET', '/api/tool/hashids/**', 'init'),"
+	sql += "(2, 14, 'POST', '/api/tool/cache/search', 'init'),"
+	sql += "(3, 14, 'PATCH', '/api/tool/cache/clear', 'init'),"
+	sql += "(4, 15, 'GET', '/api/tool/data/dbs', 'init'),"
+	sql += "(5, 15, 'POST', '/api/tool/data/mysql', 'init'),"
+	sql += "(6, 15, 'POST', '/api/tool/data/tables', 'init'),"
+	sql += "(7, 2, 'PATCH', '/api/config/email', 'init'),"
+	sql += "(8, 5, 'POST', '/generator/gorm/execute', 'init'),"
+	sql += "(9, 6, 'POST', '/generator/handler/execute', 'init'),"
+	sql += "(10, 8, 'GET', '/authorized/add', 'init'),"
+	sql += "(11, 8, 'GET', '/authorized/api/*', 'init'),"
+	sql += "(12, 8, 'GET', '/api/authorized', 'init'),"
+	sql += "(13, 8, 'PATCH', '/api/authorized/used', 'init'),"
+	sql += "(14, 8, 'DELETE', '/api/authorized/*', 'init'),"
+	sql += "(15, 8, 'POST', '/api/authorized', 'init'),"
+	sql += "(16, 8, 'GET', '/api/authorized_api', 'init'),"
+	sql += "(17, 8, 'POST', '/api/authorized_api', 'init'),"
+	sql += "(18, 8, 'DELETE', '/api/authorized_api/*', 'init'),"
+	sql += "(19, 11, 'GET', '/admin/add', 'init'),"
+	sql += "(20, 11, 'POST', '/api/admin', 'init'),"
+	sql += "(21, 11, 'GET', '/api/admin', 'init'),"
+	sql += "(22, 11, 'PATCH', '/api/admin/used', 'init'),"
+	sql += "(23, 11, 'PATCH', '/api/admin/reset_password/*', 'init'),"
+	sql += "(24, 11, 'DELETE', '/api/admin/*', 'init'),"
+	sql += "(25, 11, 'GET', '/admin/action/*', 'init'),"
+	sql += "(26, 11, 'GET', '/api/admin/menu/*', 'init'),"
+	sql += "(27, 11, 'POST', '/api/admin/menu', 'init'),"
+	sql += "(28, 12, 'GET', '/admin/menu_action/*', 'init'),"
+	sql += "(29, 12, 'GET', '/api/menu', 'init'),"
+	sql += "(30, 12, 'DELETE', '/api/menu/*', 'init'),"
+	sql += "(31, 12, 'GET', '/api/menu/*', 'init'),"
+	sql += "(32, 12, 'PATCH', '/api/menu/used', 'init'),"
+	sql += "(33, 12, 'POST', '/api/menu', 'init'),"
+	sql += "(34, 12, 'GET', '/api/menu_action', 'init'),"
+	sql += "(35, 12, 'POST', '/api/menu_action', 'init'),"
+	sql += "(36, 12, 'DELETE', '/api/menu_action/*', 'init'),"
+	sql += "(37, 22, 'POST', '/upgrade/execute', 'init');"
+
+	return
+}

internal/web/controller/upgrade_handler/func_upgradeexecute.go

@@ -0,0 +1,178 @@
+package upgrade_handler
+
+import (
+	"net/http"
+
+	"github.com/xinliangnote/go-gin-api/internal/api/code"
+	"github.com/xinliangnote/go-gin-api/internal/pkg/core"
+	"github.com/xinliangnote/go-gin-api/internal/web/controller/install_handler/mysql_table"
+	"github.com/xinliangnote/go-gin-api/pkg/errno"
+)
+
+type upgradeExecuteRequest struct {
+	TableName string `form:"table_name"` // 数据表
+	Op        string `form:"op"`         // 操作类型
+}
+
+func (h *handler) UpgradeExecute() core.HandlerFunc {
+	return func(c core.Context) {
+		req := new(upgradeExecuteRequest)
+		if err := c.ShouldBindForm(req); err != nil {
+			c.AbortWithError(errno.NewError(
+				http.StatusBadRequest,
+				code.ParamBindError,
+				code.Text(code.ParamBindError)).WithErr(err),
+			)
+			return
+		}
+
+		outPutString := ""
+		db := h.db.GetDbW()
+
+		if req.TableName == "authorized" && req.Op == "table" {
+			if err := db.Exec(mysql_table.CreateAuthorizedTableSql()).Error; err != nil {
+				c.AbortWithError(errno.NewError(
+					http.StatusBadRequest,
+					code.ConfigMySQLInstallError,
+					"MySQL "+err.Error()).WithErr(err),
+				)
+				return
+			}
+			outPutString = "初始化 MySQL 数据表：authorized 成功。"
+		}
+
+		if req.TableName == "authorized" && req.Op == "table_data" {
+			if err := db.Exec(mysql_table.CreateAuthorizedTableDataSql()).Error; err != nil {
+				c.AbortWithError(errno.NewError(
+					http.StatusBadRequest,
+					code.ConfigMySQLInstallError,
+					"MySQL "+err.Error()).WithErr(err),
+				)
+				return
+			}
+			outPutString = "初始化 MySQL 数据表：authorized 默认数据成功。"
+		}
+
+		if req.TableName == "authorized_api" && req.Op == "table" {
+			if err := db.Exec(mysql_table.CreateAuthorizedAPITableSql()).Error; err != nil {
+				c.AbortWithError(errno.NewError(
+					http.StatusBadRequest,
+					code.ConfigMySQLInstallError,
+					"MySQL "+err.Error()).WithErr(err),
+				)
+				return
+			}
+			outPutString = "初始化 MySQL 数据表：authorized_api 成功。"
+		}
+
+		if req.TableName == "authorized_api" && req.Op == "table_data" {
+			if err := db.Exec(mysql_table.CreateAuthorizedAPITableDataSql()).Error; err != nil {
+				c.AbortWithError(errno.NewError(
+					http.StatusBadRequest,
+					code.ConfigMySQLInstallError,
+					"MySQL "+err.Error()).WithErr(err),
+				)
+				return
+			}
+			outPutString = "初始化 MySQL 数据表：authorized_api 默认数据成功。"
+		}
+
+		if req.TableName == "admin" && req.Op == "table" {
+			if err := db.Exec(mysql_table.CreateAdminTableSql()).Error; err != nil {
+				c.AbortWithError(errno.NewError(
+					http.StatusBadRequest,
+					code.ConfigMySQLInstallError,
+					"MySQL "+err.Error()).WithErr(err),
+				)
+				return
+			}
+			outPutString = "初始化 MySQL 数据表：admin 成功。"
+		}
+
+		if req.TableName == "admin" && req.Op == "table_data" {
+			if err := db.Exec(mysql_table.CreateAdminTableDataSql()).Error; err != nil {
+				c.AbortWithError(errno.NewError(
+					http.StatusBadRequest,
+					code.ConfigMySQLInstallError,
+					"MySQL "+err.Error()).WithErr(err),
+				)
+				return
+			}
+			outPutString = "初始化 MySQL 数据表：admin 默认数据成功。"
+		}
+
+		if req.TableName == "menu" && req.Op == "table" {
+			if err := db.Exec(mysql_table.CreateMenuTableSql()).Error; err != nil {
+				c.AbortWithError(errno.NewError(
+					http.StatusBadRequest,
+					code.ConfigMySQLInstallError,
+					"MySQL "+err.Error()).WithErr(err),
+				)
+				return
+			}
+			outPutString = "初始化 MySQL 数据表：menu 成功。"
+		}
+
+		if req.TableName == "menu" && req.Op == "table_data" {
+			if err := db.Exec(mysql_table.CreateMenuTableDataSql()).Error; err != nil {
+				c.AbortWithError(errno.NewError(
+					http.StatusBadRequest,
+					code.ConfigMySQLInstallError,
+					"MySQL "+err.Error()).WithErr(err),
+				)
+				return
+			}
+			outPutString = "初始化 MySQL 数据表：menu 默认数据成功。"
+		}
+
+		if req.TableName == "menu_action" && req.Op == "table" {
+			if err := db.Exec(mysql_table.CreateMenuActionTableSql()).Error; err != nil {
+				c.AbortWithError(errno.NewError(
+					http.StatusBadRequest,
+					code.ConfigMySQLInstallError,
+					"MySQL "+err.Error()).WithErr(err),
+				)
+				return
+			}
+			outPutString = "初始化 MySQL 数据表：menu_action 成功。"
+		}
+
+		if req.TableName == "menu_action" && req.Op == "table_data" {
+			if err := db.Exec(mysql_table.CreateMenuActionTableDataSql()).Error; err != nil {
+				c.AbortWithError(errno.NewError(
+					http.StatusBadRequest,
+					code.ConfigMySQLInstallError,
+					"MySQL "+err.Error()).WithErr(err),
+				)
+				return
+			}
+			outPutString = "初始化 MySQL 数据表：menu_action 默认数据成功。"
+		}
+
+		if req.TableName == "admin_menu" && req.Op == "table" {
+			if err := db.Exec(mysql_table.CreateAdminMenuTableSql()).Error; err != nil {
+				c.AbortWithError(errno.NewError(
+					http.StatusBadRequest,
+					code.ConfigMySQLInstallError,
+					"MySQL "+err.Error()).WithErr(err),
+				)
+				return
+			}
+			outPutString = "初始化 MySQL 数据表：admin_menu 成功。"
+		}
+
+		if req.TableName == "admin_menu" && req.Op == "table_data" {
+			if err := db.Exec(mysql_table.CreateAdminMenuTableDataSql()).Error; err != nil {
+				c.AbortWithError(errno.NewError(
+					http.StatusBadRequest,
+					code.ConfigMySQLInstallError,
+					"MySQL "+err.Error()).WithErr(err),
+				)
+				return
+			}
+			outPutString = "初始化 MySQL 数据表：admin_menu 默认数据成功。"
+		}
+
+		c.Payload(outPutString)
+	}
+}

internal/web/controller/upgrade_handler/func_upgradeview.go

@@ -0,0 +1,73 @@
+package upgrade_handler
+
+import (
+	"fmt"
+
+	"github.com/xinliangnote/go-gin-api/configs"
+	"github.com/xinliangnote/go-gin-api/internal/pkg/core"
+)
+
+type upgradeViewResponse struct {
+	List []upgradeViewData `json:"list"`
+}
+
+type upgradeViewData struct {
+	TableName string `json:"table_name"` // 表名称
+	IsHave    int32  `json:"is_have"`    // 是否已存在 1=存在 -1=不存在
+}
+
+var tableList = []string{"authorized", "authorized_api", "admin", "menu", "menu_action", "admin_menu"}
+
+func (h *handler) UpgradeView() core.HandlerFunc {
+	return func(c core.Context) {
+
+		type tableInfo struct {
+			Name    string // name
+			Comment string // comment
+		}
+
+		var tableCollect []tableInfo
+
+		mysqlConf := configs.Get().MySQL.Read
+		sqlTables := fmt.Sprintf("SELECT `table_name`,`table_comment` FROM `information_schema`.`tables` WHERE `table_schema`= '%s'", mysqlConf.Name)
+		rows, err := h.db.GetDbR().Raw(sqlTables).Rows()
+		if err != nil {
+			c.HTML("upgrade_view", tableCollect)
+			return
+		}
+		defer rows.Close()
+
+		for rows.Next() {
+			var info tableInfo
+			err = rows.Scan(&info.Name, &info.Comment)
+			if err != nil {
+				fmt.Printf("execute query tables action error,had ignored, detail is [%v]\n", err.Error())
+				continue
+			}
+
+			tableCollect = append(tableCollect, info)
+		}
+
+		tableData := make([]upgradeViewData, len(tableList))
+		for k, v := range tableList {
+			data := upgradeViewData{
+				TableName: v,
+				IsHave:    -1,
+			}
+
+			tableData[k] = data
+		}
+
+		for k, v := range tableData {
+			for _, haveV := range tableCollect {
+				if haveV.Name == v.TableName {
+					tableData[k].IsHave = 1
+				}
+			}
+		}
+
+		obj := new(upgradeViewResponse)
+		obj.List = tableData
+		c.HTML("upgrade_view", obj)
+	}
+}

internal/web/controller/upgrade_handler/handler.go

@@ -0,0 +1,34 @@
+package upgrade_handler
+
+import (
+	"github.com/xinliangnote/go-gin-api/internal/pkg/cache"
+	"github.com/xinliangnote/go-gin-api/internal/pkg/core"
+	"github.com/xinliangnote/go-gin-api/internal/pkg/db"
+
+	"go.uber.org/zap"
+)
+
+var _ Handler = (*handler)(nil)
+
+type Handler interface {
+	i()
+
+	UpgradeView() core.HandlerFunc
+	UpgradeExecute() core.HandlerFunc
+}
+
+type handler struct {
+	db     db.Repo
+	logger *zap.Logger
+	cache  cache.Repo
+}
+
+func New(logger *zap.Logger, db db.Repo, cache cache.Repo) Handler {
+	return &handler{
+		logger: logger,
+		cache:  cache,
+		db:     db,
+	}
+}
+
+func (h *handler) i() {}