#20 add web-authorized

internal/api/code/code.go

@@ -15,6 +15,7 @@ const (
 	CallHTTPError      = 10105
 	ResubmitError      = 10106
 	ResubmitMsg        = 10107
+	HashIdsDecodeError = 10108
 
 	// 模块级错误码 - 用户模块
 	IllegalUserName = 20101
@@ -22,7 +23,15 @@ const (
 	UserUpdateError = 20103
 	UserSearchError = 20104
 
-	// ...
+	// 授权调用方
+	AuthorizedCreateError    = 30101
+	AuthorizedListError      = 30102
+	AuthorizedDeleteError    = 30103
+	AuthorizedUpdateError    = 30104
+	AuthorizedDetailError    = 30105
+	AuthorizedCreateAPIError = 30106
+	AuthorizedListAPIError   = 30107
+	AuthorizedDeleteAPIError = 30108
 )
 
 var codeText = map[int]string{
@@ -33,11 +42,21 @@ var codeText = map[int]string{
 	CallHTTPError:      "调用第三方 HTTP 接口失败",
 	ResubmitError:      "Resubmit Error",
 	ResubmitMsg:        "请勿重复提交",
+	HashIdsDecodeError: "ID 参数有误",
 
 	IllegalUserName: "非法用户名",
 	UserCreateError: "创建用户失败",
 	UserUpdateError: "更新用户失败",
 	UserSearchError: "查询用户失败",
+
+	AuthorizedCreateError:    "创建调用方失败",
+	AuthorizedListError:      "获取调用方列表页失败",
+	AuthorizedDeleteError:    "删除调用方失败",
+	AuthorizedUpdateError:    "更新调用方失败",
+	AuthorizedDetailError:    "获取调用方详情失败",
+	AuthorizedCreateAPIError: "创建调用方API地址失败",
+	AuthorizedListAPIError:   "获取调用方API地址列表失败",
+	AuthorizedDeleteAPIError: "删除调用方API地址失败",
 }
 
 func Text(code int) string {

internal/api/controller/authorized_handler/func_create.go

@@ -0,0 +1,63 @@
+package authorized_handler
+
+import (
+	"net/http"
+
+	"github.com/xinliangnote/go-gin-api/internal/api/code"
+	"github.com/xinliangnote/go-gin-api/internal/api/service/authorized_service"
+	"github.com/xinliangnote/go-gin-api/internal/pkg/core"
+	"github.com/xinliangnote/go-gin-api/pkg/errno"
+)
+
+type createRequest struct {
+	BusinessKey       string `json:"business_key"`       // 调用方key
+	BusinessDeveloper string `json:"business_developer"` // 调用方对接人
+	Remark            string `json:"remark"`             // 备注
+}
+
+type createResponse struct {
+	Id int32 `json:"id"` // 主键ID
+}
+
+// Create 新增调用方
+// @Summary 新增调用方
+// @Description 新增调用方
+// @Tags API.authorized
+// @Accept json
+// @Produce json
+// @Param Request body createRequest true "请求信息"
+// @Success 200 {object} createResponse
+// @Failure 400 {object} code.Failure
+// @Router /api/authorized [post]
+func (h *handler) Create() core.HandlerFunc {
+	return func(c core.Context) {
+		req := new(createRequest)
+		res := new(createResponse)
+		if err := c.ShouldBindJSON(req); err != nil {
+			c.AbortWithError(errno.NewError(
+				http.StatusBadRequest,
+				code.ParamBindError,
+				code.Text(code.ParamBindError)).WithErr(err),
+			)
+			return
+		}
+
+		createData := new(authorized_service.CreateAuthorizedData)
+		createData.BusinessKey = req.BusinessKey
+		createData.BusinessDeveloper = req.BusinessDeveloper
+		createData.Remark = req.Remark
+
+		id, err := h.authorizedService.Create(c, createData)
+		if err != nil {
+			c.AbortWithError(errno.NewError(
+				http.StatusBadRequest,
+				code.AuthorizedCreateError,
+				code.Text(code.AuthorizedCreateError)).WithErr(err),
+			)
+			return
+		}
+
+		res.Id = id
+		c.Payload(res)
+	}
+}

internal/api/controller/authorized_handler/func_createapi.go

@@ -0,0 +1,86 @@
+package authorized_handler
+
+import (
+	"net/http"
+
+	"github.com/xinliangnote/go-gin-api/internal/api/code"
+	"github.com/xinliangnote/go-gin-api/internal/api/service/authorized_service"
+	"github.com/xinliangnote/go-gin-api/internal/pkg/core"
+	"github.com/xinliangnote/go-gin-api/pkg/errno"
+)
+
+type createAPIRequest struct {
+	Id     string `json:"id"`     // HashID
+	Method string `json:"method"` // 请求方法
+	API    string `json:"api"`    // 请求地址
+}
+
+type createAPIResponse struct {
+	Id int32 `json:"id"` // 主键ID
+}
+
+// CreateAPI 授权调用方接口地址
+// @Summary 授权调用方接口地址
+// @Description 授权调用方接口地址
+// @Tags API.authorized
+// @Accept json
+// @Produce json
+// @Param Request body createAPIRequest true "请求信息"
+// @Success 200 {object} createAPIResponse
+// @Failure 400 {object} code.Failure
+// @Router /api/authorized_api [post]
+func (h *handler) CreateAPI() core.HandlerFunc {
+	return func(c core.Context) {
+		req := new(createAPIRequest)
+		res := new(createAPIResponse)
+		if err := c.ShouldBindJSON(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])
+
+		// 通过 id 查询出 business_key
+		authorizedInfo, err := h.authorizedService.Detail(c, id)
+		if err != nil {
+			c.AbortWithError(errno.NewError(
+				http.StatusBadRequest,
+				code.AuthorizedDetailError,
+				code.Text(code.AuthorizedDetailError)).WithErr(err),
+			)
+			return
+		}
+
+		createAPIData := new(authorized_service.CreateAuthorizedAPIData)
+		createAPIData.BusinessKey = authorizedInfo.BusinessKey
+		createAPIData.Method = req.Method
+		createAPIData.API = req.API
+
+		createId, err := h.authorizedService.CreateAPI(c, createAPIData)
+		if err != nil {
+			c.AbortWithError(errno.NewError(
+				http.StatusBadRequest,
+				code.AuthorizedCreateAPIError,
+				code.Text(code.AuthorizedCreateAPIError)).WithErr(err),
+			)
+			return
+		}
+
+		res.Id = createId
+		c.Payload(res)
+	}
+}

internal/api/controller/authorized_handler/func_delete.go

@@ -0,0 +1,67 @@
+package authorized_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 deleteRequest struct {
+	Id string `uri:"id"` // HashID
+}
+
+type deleteResponse struct {
+	Id int32 `json:"id"` // 主键ID
+}
+
+// Delete 删除调用方
+// @Summary 删除调用方
+// @Description 删除调用方
+// @Tags API.authorized
+// @Accept json
+// @Produce json
+// @Param id path string true "hashId"
+// @Success 200 {object} deleteResponse
+// @Failure 400 {object} code.Failure
+// @Router /api/authorized/{id} [delete]
+func (h *handler) Delete() core.HandlerFunc {
+	return func(c core.Context) {
+		req := new(deleteRequest)
+		res := new(deleteResponse)
+		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.authorizedService.Delete(c, id)
+		if err != nil {
+			c.AbortWithError(errno.NewError(
+				http.StatusBadRequest,
+				code.AuthorizedDeleteError,
+				code.Text(code.AuthorizedDeleteError)).WithErr(err),
+			)
+			return
+		}
+
+		res.Id = id
+		c.Payload(res)
+	}
+}

internal/api/controller/authorized_handler/func_deleteapi.go

@@ -0,0 +1,67 @@
+package authorized_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 deleteAPIRequest struct {
+	Id string `uri:"id"` // HashID
+}
+
+type deleteAPIResponse struct {
+	Id int32 `json:"id"` // 主键ID
+}
+
+// DeleteAPI 删除调用方接口地址
+// @Summary 删除调用方接口地址
+// @Description 删除调用方接口地址
+// @Tags API.authorized
+// @Accept json
+// @Produce json
+// @Param id path int true "主键ID"
+// @Success 200 {object} deleteAPIResponse
+// @Failure 400 {object} code.Failure
+// @Router /api/authorized_api/{id} [delete]
+func (h *handler) DeleteAPI() core.HandlerFunc {
+	return func(c core.Context) {
+		req := new(deleteAPIRequest)
+		res := new(deleteAPIResponse)
+		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.authorizedService.DeleteAPI(c, id)
+		if err != nil {
+			c.AbortWithError(errno.NewError(
+				http.StatusBadRequest,
+				code.AuthorizedDeleteAPIError,
+				code.Text(code.AuthorizedDeleteAPIError)).WithErr(err),
+			)
+			return
+		}
+
+		res.Id = id
+		c.Payload(res)
+	}
+}

internal/api/controller/authorized_handler/func_list.go

@@ -0,0 +1,142 @@
+package authorized_handler
+
+import (
+	"net/http"
+
+	"github.com/xinliangnote/go-gin-api/internal/api/code"
+	"github.com/xinliangnote/go-gin-api/internal/api/service/authorized_service"
+	"github.com/xinliangnote/go-gin-api/internal/pkg/core"
+	"github.com/xinliangnote/go-gin-api/pkg/errno"
+	"github.com/xinliangnote/go-gin-api/pkg/time_parse"
+
+	"github.com/spf13/cast"
+	"go.uber.org/zap"
+)
+
+type listRequest struct {
+	Page              int    `form:"page"`               // 第几页
+	PageSize          int    `form:"page_size"`          // 每页显示条数
+	BusinessKey       string `form:"business_key"`       // 调用方key
+	BusinessSecret    string `form:"business_secret"`    // 调用方secret
+	BusinessDeveloper string `form:"business_developer"` // 调用方对接人
+	Remark            string `form:"remark"`             // 备注
+}
+
+type listData struct {
+	Id                int    `json:"id"`                 // ID
+	HashID            string `json:"hashid"`             // hashid
+	BusinessKey       string `json:"business_key"`       // 调用方key
+	BusinessSecret    string `json:"business_secret"`    // 调用方secret
+	BusinessDeveloper string `json:"business_developer"` // 调用方对接人
+	Remark            string `json:"remark"`             // 备注
+	IsUsed            int    `json:"is_used"`            // 是否启用 1:是 -1:否
+	CreatedAt         string `json:"created_at"`         // 创建时间
+	CreatedUser       string `json:"created_user"`       // 创建人
+	UpdatedAt         string `json:"updated_at"`         // 更新时间
+	UpdatedUser       string `json:"updated_user"`       // 更新人
+}
+
+type listResponse struct {
+	List       []listData `json:"list"`
+	Pagination struct {
+		Total        int `json:"total"`
+		CurrentPage  int `json:"current_page"`
+		PrePageCount int `json:"pre_page_count"`
+	} `json:"pagination"`
+}
+
+// List 调用方列表
+// @Summary 调用方列表
+// @Description 调用方列表
+// @Tags API.authorized
+// @Accept json
+// @Produce json
+// @Param page query int false "第几页"
+// @Param page_size query string false "每页显示条数"
+// @Param business_key query string false "调用方key"
+// @Param business_secret query string false "调用方secret"
+// @Param business_developer query string false "调用方对接人"
+// @Param remark path string false "备注"
+// @Success 200 {object} listResponse
+// @Failure 400 {object} code.Failure
+// @Router /api/authorized [get]
+func (h *handler) List() core.HandlerFunc {
+	return func(c core.Context) {
+		req := new(listRequest)
+		res := new(listResponse)
+		if err := c.ShouldBindForm(req); err != nil {
+			c.AbortWithError(errno.NewError(
+				http.StatusBadRequest,
+				code.ParamBindError,
+				code.Text(code.ParamBindError)).WithErr(err),
+			)
+			return
+		}
+
+		page := req.Page
+		if page == 0 {
+			page = 1
+		}
+
+		pageSize := req.PageSize
+		if pageSize == 0 {
+			pageSize = 10
+		}
+
+		searchData := new(authorized_service.SearchData)
+		searchData.Page = page
+		searchData.PageSize = pageSize
+		searchData.BusinessKey = req.BusinessKey
+		searchData.BusinessSecret = req.BusinessSecret
+		searchData.Remark = req.Remark
+
+		resListData, err := h.authorizedService.PageList(c, searchData)
+		if err != nil {
+			c.AbortWithError(errno.NewError(
+				http.StatusBadRequest,
+				code.AuthorizedListError,
+				code.Text(code.AuthorizedListError)).WithErr(err),
+			)
+			return
+		}
+
+		resCountData, err := h.authorizedService.PageListCount(c, searchData)
+		if err != nil {
+			c.AbortWithError(errno.NewError(
+				http.StatusBadRequest,
+				code.AuthorizedListError,
+				code.Text(code.AuthorizedListError)).WithErr(err),
+			)
+			return
+		}
+		res.Pagination.Total = cast.ToInt(resCountData)
+		res.Pagination.PrePageCount = pageSize
+		res.Pagination.CurrentPage = page
+		res.List = make([]listData, 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 := listData{
+				Id:                cast.ToInt(v.Id),
+				HashID:            hashId,
+				BusinessKey:       v.BusinessKey,
+				BusinessSecret:    v.BusinessSecret,
+				BusinessDeveloper: v.BusinessDeveloper,
+				Remark:            v.Remark,
+				IsUsed:            cast.ToInt(v.IsUsed),
+				CreatedAt:         v.CreatedAt.Format(time_parse.CSTLayout),
+				CreatedUser:       v.CreatedUser,
+				UpdatedAt:         v.UpdatedAt.Format(time_parse.CSTLayout),
+				UpdatedUser:       v.UpdatedUser,
+			}
+
+			res.List[k] = data
+		}
+
+		c.Payload(res)
+	}
+}

internal/api/controller/authorized_handler/func_listapi.go

@@ -0,0 +1,109 @@
+package authorized_handler
+
+import (
+	"net/http"
+
+	"github.com/xinliangnote/go-gin-api/internal/api/code"
+	"github.com/xinliangnote/go-gin-api/internal/api/service/authorized_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 listAPIRequest struct {
+	Id string `form:"id"` // hashID
+}
+
+type listAPIData struct {
+	HashId      string `json:"hash_id"`      // hashID
+	BusinessKey string `json:"business_key"` // 调用方key
+	Method      string `json:"method"`       // 调用方secret
+	API         string `json:"api"`          // 调用方对接人
+}
+
+type listAPIResponse struct {
+	List []listAPIData `json:"list"`
+}
+
+// ListAPI 调用方接口地址列表
+// @Summary 调用方接口地址列表
+// @Description 调用方接口地址列表
+// @Tags API.authorized
+// @Accept json
+// @Produce json
+// @Param business_key query string false "调用方key"
+// @Success 200 {object} listAPIResponse
+// @Failure 400 {object} code.Failure
+// @Router /api/authorized_api [get]
+func (h *handler) ListAPI() core.HandlerFunc {
+	return func(c core.Context) {
+		req := new(listAPIRequest)
+		res := new(listAPIResponse)
+		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])
+
+		// 通过 id 查询出 business_key
+		authorizedInfo, err := h.authorizedService.Detail(c, id)
+		if err != nil {
+			c.AbortWithError(errno.NewError(
+				http.StatusBadRequest,
+				code.AuthorizedDetailError,
+				code.Text(code.AuthorizedDetailError)).WithErr(err),
+			)
+			return
+		}
+
+		searchAPIData := new(authorized_service.SearchAPIData)
+		searchAPIData.BusinessKey = authorizedInfo.BusinessKey
+
+		resListData, err := h.authorizedService.ListAPI(c, searchAPIData)
+		if err != nil {
+			c.AbortWithError(errno.NewError(
+				http.StatusBadRequest,
+				code.AuthorizedListAPIError,
+				code.Text(code.AuthorizedListAPIError)).WithErr(err),
+			)
+			return
+		}
+
+		res.List = make([]listAPIData, 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 := listAPIData{
+				HashId:      hashId,
+				BusinessKey: v.BusinessKey,
+				Method:      v.Method,
+				API:         v.Api,
+			}
+
+			res.List[k] = data
+		}
+
+		c.Payload(res)
+	}
+}

internal/api/controller/authorized_handler/func_updateused.go

@@ -0,0 +1,68 @@
+package authorized_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 updateUsedRequest struct {
+	Id   string `json:"id"`   // 主键ID
+	Used int32  `json:"used"` // 是否启用 1:是 -1:否
+}
+
+type updateUsedResponse struct {
+	Id int32 `json:"id"` // 主键ID
+}
+
+// UpdateUsed 更新调用方为启用/禁用
+// @Summary 更新调用方为启用/禁用
+// @Description 更新调用方为启用/禁用
+// @Tags API.authorized
+// @Accept json
+// @Produce json
+// @Param Request body updateUsedRequest true "请求信息"
+// @Success 200 {object} updateUsedResponse
+// @Failure 400 {object} code.Failure
+// @Router /api/authorized/used [patch]
+func (h *handler) UpdateUsed() core.HandlerFunc {
+	return func(c core.Context) {
+		req := new(updateUsedRequest)
+		res := new(updateUsedResponse)
+		if err := c.ShouldBindJSON(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.authorizedService.UpdateUsed(c, id, req.Used)
+		if err != nil {
+			c.AbortWithError(errno.NewError(
+				http.StatusBadRequest,
+				code.AuthorizedUpdateError,
+				code.Text(code.AuthorizedUpdateError)).WithErr(err),
+			)
+			return
+		}
+
+		res.Id = id
+		c.Payload(res)
+	}
+}

internal/api/controller/authorized_handler/handler.go

@@ -0,0 +1,71 @@
+package authorized_handler
+
+import (
+	"github.com/xinliangnote/go-gin-api/configs"
+	"github.com/xinliangnote/go-gin-api/internal/api/service/authorized_service"
+	"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"
+	"github.com/xinliangnote/go-gin-api/pkg/hash"
+
+	"go.uber.org/zap"
+)
+
+var _ Handler = (*handler)(nil)
+
+type Handler interface {
+	i()
+
+	// Create 新增调用方
+	// @Tags API.authorized
+	// @Router /api/authorized [post]
+	Create() core.HandlerFunc
+
+	// CreateAPI 授权调用方接口地址
+	// @Tags API.authorized
+	// @Router /api/authorized_api [post]
+	CreateAPI() core.HandlerFunc
+
+	// List 调用方列表
+	// @Tags API.authorized
+	// @Router /api/authorized [get]
+	List() core.HandlerFunc
+
+	// ListAPI 调用方接口地址列表
+	// @Tags API.authorized
+	// @Router /api/authorized_api [get]
+	ListAPI() core.HandlerFunc
+
+	// Delete 删除调用方
+	// @Tags API.authorized
+	// @Router /api/authorized/{id} [delete]
+	Delete() core.HandlerFunc
+
+	// DeleteAPI 删除调用方接口地址
+	// @Tags API.authorized
+	// @Router /api/authorized_api/{id} [delete]
+	DeleteAPI() core.HandlerFunc
+
+	// UpdateUsed 更新调用方为启用/禁用
+	// @Tags API.authorized
+	// @Router /api/authorized/used [patch]
+	UpdateUsed() core.HandlerFunc
+}
+
+type handler struct {
+	logger            *zap.Logger
+	cache             cache.Repo
+	authorizedService authorized_service.Service
+	hashids           hash.Hash
+}
+
+func New(logger *zap.Logger, db db.Repo, cache cache.Repo) Handler {
+	return &handler{
+		logger:            logger,
+		cache:             cache,
+		authorizedService: authorized_service.New(db, cache),
+		hashids:           hash.New(configs.Get().HashIds.Secret, configs.Get().HashIds.Length),
+	}
+}
+
+func (h *handler) i() {}

internal/api/controller/tool_handler/func_hashidsdecode.go

@@ -0,0 +1,56 @@
+package tool_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 hashIdsDecodeRequest struct {
+	Id string `uri:"id"` // 需解密的密文
+}
+
+type hashIdsDecodeResponse struct {
+	Val int `json:"val"` // 解密后的值
+}
+
+// HashIdsDecode HashIds 解密
+// @Summary HashIds 解密
+// @Description HashIds 解密
+// @Tags API.tool
+// @Accept json
+// @Produce json
+// @Param id path string true "需解密的密文"
+// @Success 200 {object} hashIdsDecodeResponse
+// @Failure 400 {object} code.Failure
+// @Router /api/tool/hashids/decode/{id} [get]
+func (h *handler) HashIdsDecode() core.HandlerFunc {
+	return func(c core.Context) {
+		req := new(hashIdsDecodeRequest)
+		res := new(hashIdsDecodeResponse)
+		if err := c.ShouldBindURI(req); err != nil {
+			c.AbortWithError(errno.NewError(
+				http.StatusBadRequest,
+				code.ParamBindError,
+				code.Text(code.ParamBindError)).WithErr(err),
+			)
+			return
+		}
+
+		hashId, err := h.hashids.HashidsDecode(req.Id)
+		if err != nil {
+			c.AbortWithError(errno.NewError(
+				http.StatusBadRequest,
+				code.HashIdsDecodeError,
+				code.Text(code.HashIdsDecodeError)).WithErr(err),
+			)
+			return
+		}
+
+		res.Val = hashId[0]
+
+		c.Payload(res)
+	}
+}

internal/api/controller/tool_handler/func_hashidsencode.go

@@ -0,0 +1,58 @@
+package tool_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"
+
+	"github.com/spf13/cast"
+)
+
+type hashIdsEncodeRequest struct {
+	Id int32 `uri:"id"` // 需加密的数字
+}
+
+type hashIdsEncodeResponse struct {
+	Val string `json:"val"` // 加密后的值
+}
+
+// HashIdsEncode HashIds 加密
+// @Summary HashIds 加密
+// @Description HashIds 加密
+// @Tags API.tool
+// @Accept json
+// @Produce json
+// @Param id path string true "需加密的数字"
+// @Success 200 {object} hashIdsEncodeResponse
+// @Failure 400 {object} code.Failure
+// @Router /api/tool/hashids/encode/{id} [get]
+func (h *handler) HashIdsEncode() core.HandlerFunc {
+	return func(c core.Context) {
+		req := new(hashIdsEncodeRequest)
+		res := new(hashIdsEncodeResponse)
+		if err := c.ShouldBindURI(req); err != nil {
+			c.AbortWithError(errno.NewError(
+				http.StatusBadRequest,
+				code.ParamBindError,
+				code.Text(code.ParamBindError)).WithErr(err),
+			)
+			return
+		}
+
+		hashId, err := h.hashids.HashidsEncode([]int{cast.ToInt(req.Id)})
+		if err != nil {
+			c.AbortWithError(errno.NewError(
+				http.StatusBadRequest,
+				code.HashIdsDecodeError,
+				code.Text(code.HashIdsDecodeError)).WithErr(err),
+			)
+			return
+		}
+
+		res.Val = hashId
+
+		c.Payload(res)
+	}
+}

internal/api/controller/tool_handler/handler.go

@@ -0,0 +1,43 @@
+package tool_handler
+
+import (
+	"github.com/xinliangnote/go-gin-api/configs"
+	"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"
+	"github.com/xinliangnote/go-gin-api/pkg/hash"
+
+	"go.uber.org/zap"
+)
+
+var _ Handler = (*handler)(nil)
+
+type Handler interface {
+	i()
+
+	// HashIdsEncode HashIds 加密
+	// @Tags API.tool
+	// @Router /api/tool/hashids/encode/{id} [get]
+	HashIdsEncode() core.HandlerFunc
+
+	// HashIdsDecode HashIds 解密
+	// @Tags API.tool
+	// @Router /api/tool/hashids/decode/{id} [get]
+	HashIdsDecode() core.HandlerFunc
+}
+
+type handler struct {
+	logger  *zap.Logger
+	cache   cache.Repo
+	hashids hash.Hash
+}
+
+func New(logger *zap.Logger, db db.Repo, cache cache.Repo) Handler {
+	return &handler{
+		logger:  logger,
+		cache:   cache,
+		hashids: hash.New(configs.Get().HashIds.Secret, configs.Get().HashIds.Length),
+	}
+}
+
+func (h *handler) i() {}

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

@@ -0,0 +1,497 @@
+///////////////////////////////////////////////////////////
+// THIS FILE IS AUTO GENERATED by gormgen, DON'T EDIT IT //
+//        ANY CHANGES DONE HERE WILL BE LOST             //
+///////////////////////////////////////////////////////////
+
+package authorized_api_repo
+
+import (
+	"fmt"
+	"time"
+
+	"github.com/xinliangnote/go-gin-api/internal/api/repository/db_repo"
+
+	"github.com/pkg/errors"
+	"gorm.io/gorm"
+)
+
+func NewModel() *AuthorizedApi {
+	return new(AuthorizedApi)
+}
+
+func NewQueryBuilder() *authorizedApiRepoQueryBuilder {
+	return new(authorizedApiRepoQueryBuilder)
+}
+
+func (t *AuthorizedApi) 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
+}
+
+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 {
+		prefix string
+		value  interface{}
+	}
+	limit  int
+	offset int
+}
+
+func (qb *authorizedApiRepoQueryBuilder) 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 *authorizedApiRepoQueryBuilder) Count(db *gorm.DB) (int64, error) {
+	var c int64
+	res := qb.buildQuery(db).Model(&AuthorizedApi{}).Count(&c)
+	if res.Error != nil && res.Error == gorm.ErrRecordNotFound {
+		c = 0
+	}
+	return c, res.Error
+}
+
+func (qb *authorizedApiRepoQueryBuilder) First(db *gorm.DB) (*AuthorizedApi, error) {
+	ret := &AuthorizedApi{}
+	res := qb.buildQuery(db).First(ret)
+	if res.Error != nil && res.Error == gorm.ErrRecordNotFound {
+		ret = nil
+	}
+	return ret, res.Error
+}
+
+func (qb *authorizedApiRepoQueryBuilder) QueryOne(db *gorm.DB) (*AuthorizedApi, error) {
+	qb.limit = 1
+	ret, err := qb.QueryAll(db)
+	if len(ret) > 0 {
+		return ret[0], err
+	}
+	return nil, err
+}
+
+func (qb *authorizedApiRepoQueryBuilder) QueryAll(db *gorm.DB) ([]*AuthorizedApi, error) {
+	var ret []*AuthorizedApi
+	err := qb.buildQuery(db).Find(&ret).Error
+	return ret, err
+}
+
+func (qb *authorizedApiRepoQueryBuilder) Limit(limit int) *authorizedApiRepoQueryBuilder {
+	qb.limit = limit
+	return qb
+}
+
+func (qb *authorizedApiRepoQueryBuilder) Offset(offset int) *authorizedApiRepoQueryBuilder {
+	qb.offset = offset
+	return qb
+}
+
+func (qb *authorizedApiRepoQueryBuilder) WhereId(p db_repo.Predicate, value int32) *authorizedApiRepoQueryBuilder {
+	qb.where = append(qb.where, struct {
+		prefix string
+		value  interface{}
+	}{
+		fmt.Sprintf("%v %v ?", "id", p),
+		value,
+	})
+	return qb
+}
+
+func (qb *authorizedApiRepoQueryBuilder) WhereIdIn(value []int32) *authorizedApiRepoQueryBuilder {
+	qb.where = append(qb.where, struct {
+		prefix string
+		value  interface{}
+	}{
+		fmt.Sprintf("%v %v ?", "id", "IN"),
+		value,
+	})
+	return qb
+}
+
+func (qb *authorizedApiRepoQueryBuilder) WhereIdNotIn(value []int32) *authorizedApiRepoQueryBuilder {
+	qb.where = append(qb.where, struct {
+		prefix string
+		value  interface{}
+	}{
+		fmt.Sprintf("%v %v ?", "id", "NOT IN"),
+		value,
+	})
+	return qb
+}
+
+func (qb *authorizedApiRepoQueryBuilder) OrderById(asc bool) *authorizedApiRepoQueryBuilder {
+	order := "DESC"
+	if asc {
+		order = "ASC"
+	}
+
+	qb.order = append(qb.order, "id "+order)
+	return qb
+}
+
+func (qb *authorizedApiRepoQueryBuilder) WhereBusinessKey(p db_repo.Predicate, value string) *authorizedApiRepoQueryBuilder {
+	qb.where = append(qb.where, struct {
+		prefix string
+		value  interface{}
+	}{
+		fmt.Sprintf("%v %v ?", "business_key", p),
+		value,
+	})
+	return qb
+}
+
+func (qb *authorizedApiRepoQueryBuilder) WhereBusinessKeyIn(value []string) *authorizedApiRepoQueryBuilder {
+	qb.where = append(qb.where, struct {
+		prefix string
+		value  interface{}
+	}{
+		fmt.Sprintf("%v %v ?", "business_key", "IN"),
+		value,
+	})
+	return qb
+}
+
+func (qb *authorizedApiRepoQueryBuilder) WhereBusinessKeyNotIn(value []string) *authorizedApiRepoQueryBuilder {
+	qb.where = append(qb.where, struct {
+		prefix string
+		value  interface{}
+	}{
+		fmt.Sprintf("%v %v ?", "business_key", "NOT IN"),
+		value,
+	})
+	return qb
+}
+
+func (qb *authorizedApiRepoQueryBuilder) OrderByBusinessKey(asc bool) *authorizedApiRepoQueryBuilder {
+	order := "DESC"
+	if asc {
+		order = "ASC"
+	}
+
+	qb.order = append(qb.order, "business_key "+order)
+	return qb
+}
+
+func (qb *authorizedApiRepoQueryBuilder) WhereMethod(p db_repo.Predicate, value string) *authorizedApiRepoQueryBuilder {
+	qb.where = append(qb.where, struct {
+		prefix string
+		value  interface{}
+	}{
+		fmt.Sprintf("%v %v ?", "method", p),
+		value,
+	})
+	return qb
+}
+
+func (qb *authorizedApiRepoQueryBuilder) WhereMethodIn(value []string) *authorizedApiRepoQueryBuilder {
+	qb.where = append(qb.where, struct {
+		prefix string
+		value  interface{}
+	}{
+		fmt.Sprintf("%v %v ?", "method", "IN"),
+		value,
+	})
+	return qb
+}
+
+func (qb *authorizedApiRepoQueryBuilder) WhereMethodNotIn(value []string) *authorizedApiRepoQueryBuilder {
+	qb.where = append(qb.where, struct {
+		prefix string
+		value  interface{}
+	}{
+		fmt.Sprintf("%v %v ?", "method", "NOT IN"),
+		value,
+	})
+	return qb
+}
+
+func (qb *authorizedApiRepoQueryBuilder) OrderByMethod(asc bool) *authorizedApiRepoQueryBuilder {
+	order := "DESC"
+	if asc {
+		order = "ASC"
+	}
+
+	qb.order = append(qb.order, "method "+order)
+	return qb
+}
+
+func (qb *authorizedApiRepoQueryBuilder) WhereApi(p db_repo.Predicate, value string) *authorizedApiRepoQueryBuilder {
+	qb.where = append(qb.where, struct {
+		prefix string
+		value  interface{}
+	}{
+		fmt.Sprintf("%v %v ?", "api", p),
+		value,
+	})
+	return qb
+}
+
+func (qb *authorizedApiRepoQueryBuilder) WhereApiIn(value []string) *authorizedApiRepoQueryBuilder {
+	qb.where = append(qb.where, struct {
+		prefix string
+		value  interface{}
+	}{
+		fmt.Sprintf("%v %v ?", "api", "IN"),
+		value,
+	})
+	return qb
+}
+
+func (qb *authorizedApiRepoQueryBuilder) WhereApiNotIn(value []string) *authorizedApiRepoQueryBuilder {
+	qb.where = append(qb.where, struct {
+		prefix string
+		value  interface{}
+	}{
+		fmt.Sprintf("%v %v ?", "api", "NOT IN"),
+		value,
+	})
+	return qb
+}
+
+func (qb *authorizedApiRepoQueryBuilder) OrderByApi(asc bool) *authorizedApiRepoQueryBuilder {
+	order := "DESC"
+	if asc {
+		order = "ASC"
+	}
+
+	qb.order = append(qb.order, "api "+order)
+	return qb
+}
+
+func (qb *authorizedApiRepoQueryBuilder) WhereIsDeleted(p db_repo.Predicate, value int32) *authorizedApiRepoQueryBuilder {
+	qb.where = append(qb.where, struct {
+		prefix string
+		value  interface{}
+	}{
+		fmt.Sprintf("%v %v ?", "is_deleted", p),
+		value,
+	})
+	return qb
+}
+
+func (qb *authorizedApiRepoQueryBuilder) WhereIsDeletedIn(value []int32) *authorizedApiRepoQueryBuilder {
+	qb.where = append(qb.where, struct {
+		prefix string
+		value  interface{}
+	}{
+		fmt.Sprintf("%v %v ?", "is_deleted", "IN"),
+		value,
+	})
+	return qb
+}
+
+func (qb *authorizedApiRepoQueryBuilder) WhereIsDeletedNotIn(value []int32) *authorizedApiRepoQueryBuilder {
+	qb.where = append(qb.where, struct {
+		prefix string
+		value  interface{}
+	}{
+		fmt.Sprintf("%v %v ?", "is_deleted", "NOT IN"),
+		value,
+	})
+	return qb
+}
+
+func (qb *authorizedApiRepoQueryBuilder) OrderByIsDeleted(asc bool) *authorizedApiRepoQueryBuilder {
+	order := "DESC"
+	if asc {
+		order = "ASC"
+	}
+
+	qb.order = append(qb.order, "is_deleted "+order)
+	return qb
+}
+
+func (qb *authorizedApiRepoQueryBuilder) WhereCreatedAt(p db_repo.Predicate, value time.Time) *authorizedApiRepoQueryBuilder {
+	qb.where = append(qb.where, struct {
+		prefix string
+		value  interface{}
+	}{
+		fmt.Sprintf("%v %v ?", "created_at", p),
+		value,
+	})
+	return qb
+}
+
+func (qb *authorizedApiRepoQueryBuilder) WhereCreatedAtIn(value []time.Time) *authorizedApiRepoQueryBuilder {
+	qb.where = append(qb.where, struct {
+		prefix string
+		value  interface{}
+	}{
+		fmt.Sprintf("%v %v ?", "created_at", "IN"),
+		value,
+	})
+	return qb
+}
+
+func (qb *authorizedApiRepoQueryBuilder) WhereCreatedAtNotIn(value []time.Time) *authorizedApiRepoQueryBuilder {
+	qb.where = append(qb.where, struct {
+		prefix string
+		value  interface{}
+	}{
+		fmt.Sprintf("%v %v ?", "created_at", "NOT IN"),
+		value,
+	})
+	return qb
+}
+
+func (qb *authorizedApiRepoQueryBuilder) OrderByCreatedAt(asc bool) *authorizedApiRepoQueryBuilder {
+	order := "DESC"
+	if asc {
+		order = "ASC"
+	}
+
+	qb.order = append(qb.order, "created_at "+order)
+	return qb
+}
+
+func (qb *authorizedApiRepoQueryBuilder) WhereCreatedUser(p db_repo.Predicate, value string) *authorizedApiRepoQueryBuilder {
+	qb.where = append(qb.where, struct {
+		prefix string
+		value  interface{}
+	}{
+		fmt.Sprintf("%v %v ?", "created_user", p),
+		value,
+	})
+	return qb
+}
+
+func (qb *authorizedApiRepoQueryBuilder) WhereCreatedUserIn(value []string) *authorizedApiRepoQueryBuilder {
+	qb.where = append(qb.where, struct {
+		prefix string
+		value  interface{}
+	}{
+		fmt.Sprintf("%v %v ?", "created_user", "IN"),
+		value,
+	})
+	return qb
+}
+
+func (qb *authorizedApiRepoQueryBuilder) WhereCreatedUserNotIn(value []string) *authorizedApiRepoQueryBuilder {
+	qb.where = append(qb.where, struct {
+		prefix string
+		value  interface{}
+	}{
+		fmt.Sprintf("%v %v ?", "created_user", "NOT IN"),
+		value,
+	})
+	return qb
+}
+
+func (qb *authorizedApiRepoQueryBuilder) OrderByCreatedUser(asc bool) *authorizedApiRepoQueryBuilder {
+	order := "DESC"
+	if asc {
+		order = "ASC"
+	}
+
+	qb.order = append(qb.order, "created_user "+order)
+	return qb
+}
+
+func (qb *authorizedApiRepoQueryBuilder) WhereUpdatedAt(p db_repo.Predicate, value time.Time) *authorizedApiRepoQueryBuilder {
+	qb.where = append(qb.where, struct {
+		prefix string
+		value  interface{}
+	}{
+		fmt.Sprintf("%v %v ?", "updated_at", p),
+		value,
+	})
+	return qb
+}
+
+func (qb *authorizedApiRepoQueryBuilder) WhereUpdatedAtIn(value []time.Time) *authorizedApiRepoQueryBuilder {
+	qb.where = append(qb.where, struct {
+		prefix string
+		value  interface{}
+	}{
+		fmt.Sprintf("%v %v ?", "updated_at", "IN"),
+		value,
+	})
+	return qb
+}
+
+func (qb *authorizedApiRepoQueryBuilder) WhereUpdatedAtNotIn(value []time.Time) *authorizedApiRepoQueryBuilder {
+	qb.where = append(qb.where, struct {
+		prefix string
+		value  interface{}
+	}{
+		fmt.Sprintf("%v %v ?", "updated_at", "NOT IN"),
+		value,
+	})
+	return qb
+}
+
+func (qb *authorizedApiRepoQueryBuilder) OrderByUpdatedAt(asc bool) *authorizedApiRepoQueryBuilder {
+	order := "DESC"
+	if asc {
+		order = "ASC"
+	}
+
+	qb.order = append(qb.order, "updated_at "+order)
+	return qb
+}
+
+func (qb *authorizedApiRepoQueryBuilder) WhereUpdatedUser(p db_repo.Predicate, value string) *authorizedApiRepoQueryBuilder {
+	qb.where = append(qb.where, struct {
+		prefix string
+		value  interface{}
+	}{
+		fmt.Sprintf("%v %v ?", "updated_user", p),
+		value,
+	})
+	return qb
+}
+
+func (qb *authorizedApiRepoQueryBuilder) WhereUpdatedUserIn(value []string) *authorizedApiRepoQueryBuilder {
+	qb.where = append(qb.where, struct {
+		prefix string
+		value  interface{}
+	}{
+		fmt.Sprintf("%v %v ?", "updated_user", "IN"),
+		value,
+	})
+	return qb
+}
+
+func (qb *authorizedApiRepoQueryBuilder) WhereUpdatedUserNotIn(value []string) *authorizedApiRepoQueryBuilder {
+	qb.where = append(qb.where, struct {
+		prefix string
+		value  interface{}
+	}{
+		fmt.Sprintf("%v %v ?", "updated_user", "NOT IN"),
+		value,
+	})
+	return qb
+}
+
+func (qb *authorizedApiRepoQueryBuilder) OrderByUpdatedUser(asc bool) *authorizedApiRepoQueryBuilder {
+	order := "DESC"
+	if asc {
+		order = "ASC"
+	}
+
+	qb.order = append(qb.order, "updated_user "+order)
+	return qb
+}

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

@@ -0,0 +1,17 @@
+package authorized_api_repo
+
+import "time"
+
+// 已授权的调用方表
+//go:generate gormgen -structs AuthorizedApi -input .
+type AuthorizedApi struct {
+	Id          int32     // 主键
+	BusinessKey string    // 调用方key
+	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/authorized_api_repo/gen_table.md

@@ -0,0 +1,14 @@
+#### go_gin_api.authorized_api 
+已授权的调用方表
+
+| 序号 | 名称 | 描述 | 类型 | 键 | 为空 | 额外 | 默认值 |
+| :--: | :--: | :--: | :--: | :--: | :--: | :--: | :--: |
+| 1 | id | 主键 | int(11) unsigned | PRI | NO | auto_increment |  |
+| 2 | business_key | 调用方key | varchar(30) |  | NO |  |  |
+| 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/authorized_repo/gen_authorized.go

@@ -0,0 +1,583 @@
+///////////////////////////////////////////////////////////
+// THIS FILE IS AUTO GENERATED by gormgen, DON'T EDIT IT //
+//        ANY CHANGES DONE HERE WILL BE LOST             //
+///////////////////////////////////////////////////////////
+
+package authorized_repo
+
+import (
+	"fmt"
+	"time"
+
+	"github.com/xinliangnote/go-gin-api/internal/api/repository/db_repo"
+
+	"github.com/pkg/errors"
+	"gorm.io/gorm"
+)
+
+func NewModel() *Authorized {
+	return new(Authorized)
+}
+
+func NewQueryBuilder() *authorizedRepoQueryBuilder {
+	return new(authorizedRepoQueryBuilder)
+}
+
+func (t *Authorized) 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
+}
+
+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 {
+		prefix string
+		value  interface{}
+	}
+	limit  int
+	offset int
+}
+
+func (qb *authorizedRepoQueryBuilder) 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 *authorizedRepoQueryBuilder) Count(db *gorm.DB) (int64, error) {
+	var c int64
+	res := qb.buildQuery(db).Model(&Authorized{}).Count(&c)
+	if res.Error != nil && res.Error == gorm.ErrRecordNotFound {
+		c = 0
+	}
+	return c, res.Error
+}
+
+func (qb *authorizedRepoQueryBuilder) First(db *gorm.DB) (*Authorized, error) {
+	ret := &Authorized{}
+	res := qb.buildQuery(db).First(ret)
+	if res.Error != nil && res.Error == gorm.ErrRecordNotFound {
+		ret = nil
+	}
+	return ret, res.Error
+}
+
+func (qb *authorizedRepoQueryBuilder) QueryOne(db *gorm.DB) (*Authorized, error) {
+	qb.limit = 1
+	ret, err := qb.QueryAll(db)
+	if len(ret) > 0 {
+		return ret[0], err
+	}
+	return nil, err
+}
+
+func (qb *authorizedRepoQueryBuilder) QueryAll(db *gorm.DB) ([]*Authorized, error) {
+	var ret []*Authorized
+	err := qb.buildQuery(db).Find(&ret).Error
+	return ret, err
+}
+
+func (qb *authorizedRepoQueryBuilder) Limit(limit int) *authorizedRepoQueryBuilder {
+	qb.limit = limit
+	return qb
+}
+
+func (qb *authorizedRepoQueryBuilder) Offset(offset int) *authorizedRepoQueryBuilder {
+	qb.offset = offset
+	return qb
+}
+
+func (qb *authorizedRepoQueryBuilder) WhereId(p db_repo.Predicate, value int32) *authorizedRepoQueryBuilder {
+	qb.where = append(qb.where, struct {
+		prefix string
+		value  interface{}
+	}{
+		fmt.Sprintf("%v %v ?", "id", p),
+		value,
+	})
+	return qb
+}
+
+func (qb *authorizedRepoQueryBuilder) WhereIdIn(value []int32) *authorizedRepoQueryBuilder {
+	qb.where = append(qb.where, struct {
+		prefix string
+		value  interface{}
+	}{
+		fmt.Sprintf("%v %v ?", "id", "IN"),
+		value,
+	})
+	return qb
+}
+
+func (qb *authorizedRepoQueryBuilder) WhereIdNotIn(value []int32) *authorizedRepoQueryBuilder {
+	qb.where = append(qb.where, struct {
+		prefix string
+		value  interface{}
+	}{
+		fmt.Sprintf("%v %v ?", "id", "NOT IN"),
+		value,
+	})
+	return qb
+}
+
+func (qb *authorizedRepoQueryBuilder) OrderById(asc bool) *authorizedRepoQueryBuilder {
+	order := "DESC"
+	if asc {
+		order = "ASC"
+	}
+
+	qb.order = append(qb.order, "id "+order)
+	return qb
+}
+
+func (qb *authorizedRepoQueryBuilder) WhereBusinessKey(p db_repo.Predicate, value string) *authorizedRepoQueryBuilder {
+	qb.where = append(qb.where, struct {
+		prefix string
+		value  interface{}
+	}{
+		fmt.Sprintf("%v %v ?", "business_key", p),
+		value,
+	})
+	return qb
+}
+
+func (qb *authorizedRepoQueryBuilder) WhereBusinessKeyIn(value []string) *authorizedRepoQueryBuilder {
+	qb.where = append(qb.where, struct {
+		prefix string
+		value  interface{}
+	}{
+		fmt.Sprintf("%v %v ?", "business_key", "IN"),
+		value,
+	})
+	return qb
+}
+
+func (qb *authorizedRepoQueryBuilder) WhereBusinessKeyNotIn(value []string) *authorizedRepoQueryBuilder {
+	qb.where = append(qb.where, struct {
+		prefix string
+		value  interface{}
+	}{
+		fmt.Sprintf("%v %v ?", "business_key", "NOT IN"),
+		value,
+	})
+	return qb
+}
+
+func (qb *authorizedRepoQueryBuilder) OrderByBusinessKey(asc bool) *authorizedRepoQueryBuilder {
+	order := "DESC"
+	if asc {
+		order = "ASC"
+	}
+
+	qb.order = append(qb.order, "business_key "+order)
+	return qb
+}
+
+func (qb *authorizedRepoQueryBuilder) WhereBusinessSecret(p db_repo.Predicate, value string) *authorizedRepoQueryBuilder {
+	qb.where = append(qb.where, struct {
+		prefix string
+		value  interface{}
+	}{
+		fmt.Sprintf("%v %v ?", "business_secret", p),
+		value,
+	})
+	return qb
+}
+
+func (qb *authorizedRepoQueryBuilder) WhereBusinessSecretIn(value []string) *authorizedRepoQueryBuilder {
+	qb.where = append(qb.where, struct {
+		prefix string
+		value  interface{}
+	}{
+		fmt.Sprintf("%v %v ?", "business_secret", "IN"),
+		value,
+	})
+	return qb
+}
+
+func (qb *authorizedRepoQueryBuilder) WhereBusinessSecretNotIn(value []string) *authorizedRepoQueryBuilder {
+	qb.where = append(qb.where, struct {
+		prefix string
+		value  interface{}
+	}{
+		fmt.Sprintf("%v %v ?", "business_secret", "NOT IN"),
+		value,
+	})
+	return qb
+}
+
+func (qb *authorizedRepoQueryBuilder) OrderByBusinessSecret(asc bool) *authorizedRepoQueryBuilder {
+	order := "DESC"
+	if asc {
+		order = "ASC"
+	}
+
+	qb.order = append(qb.order, "business_secret "+order)
+	return qb
+}
+
+func (qb *authorizedRepoQueryBuilder) WhereBusinessDeveloper(p db_repo.Predicate, value string) *authorizedRepoQueryBuilder {
+	qb.where = append(qb.where, struct {
+		prefix string
+		value  interface{}
+	}{
+		fmt.Sprintf("%v %v ?", "business_developer", p),
+		value,
+	})
+	return qb
+}
+
+func (qb *authorizedRepoQueryBuilder) WhereBusinessDeveloperIn(value []string) *authorizedRepoQueryBuilder {
+	qb.where = append(qb.where, struct {
+		prefix string
+		value  interface{}
+	}{
+		fmt.Sprintf("%v %v ?", "business_developer", "IN"),
+		value,
+	})
+	return qb
+}
+
+func (qb *authorizedRepoQueryBuilder) WhereBusinessDeveloperNotIn(value []string) *authorizedRepoQueryBuilder {
+	qb.where = append(qb.where, struct {
+		prefix string
+		value  interface{}
+	}{
+		fmt.Sprintf("%v %v ?", "business_developer", "NOT IN"),
+		value,
+	})
+	return qb
+}
+
+func (qb *authorizedRepoQueryBuilder) OrderByBusinessDeveloper(asc bool) *authorizedRepoQueryBuilder {
+	order := "DESC"
+	if asc {
+		order = "ASC"
+	}
+
+	qb.order = append(qb.order, "business_developer "+order)
+	return qb
+}
+
+func (qb *authorizedRepoQueryBuilder) WhereRemark(p db_repo.Predicate, value string) *authorizedRepoQueryBuilder {
+	qb.where = append(qb.where, struct {
+		prefix string
+		value  interface{}
+	}{
+		fmt.Sprintf("%v %v ?", "remark", p),
+		value,
+	})
+	return qb
+}
+
+func (qb *authorizedRepoQueryBuilder) WhereRemarkIn(value []string) *authorizedRepoQueryBuilder {
+	qb.where = append(qb.where, struct {
+		prefix string
+		value  interface{}
+	}{
+		fmt.Sprintf("%v %v ?", "remark", "IN"),
+		value,
+	})
+	return qb
+}
+
+func (qb *authorizedRepoQueryBuilder) WhereRemarkNotIn(value []string) *authorizedRepoQueryBuilder {
+	qb.where = append(qb.where, struct {
+		prefix string
+		value  interface{}
+	}{
+		fmt.Sprintf("%v %v ?", "remark", "NOT IN"),
+		value,
+	})
+	return qb
+}
+
+func (qb *authorizedRepoQueryBuilder) OrderByRemark(asc bool) *authorizedRepoQueryBuilder {
+	order := "DESC"
+	if asc {
+		order = "ASC"
+	}
+
+	qb.order = append(qb.order, "remark "+order)
+	return qb
+}
+
+func (qb *authorizedRepoQueryBuilder) WhereIsUsed(p db_repo.Predicate, value int32) *authorizedRepoQueryBuilder {
+	qb.where = append(qb.where, struct {
+		prefix string
+		value  interface{}
+	}{
+		fmt.Sprintf("%v %v ?", "is_used", p),
+		value,
+	})
+	return qb
+}
+
+func (qb *authorizedRepoQueryBuilder) WhereIsUsedIn(value []int32) *authorizedRepoQueryBuilder {
+	qb.where = append(qb.where, struct {
+		prefix string
+		value  interface{}
+	}{
+		fmt.Sprintf("%v %v ?", "is_used", "IN"),
+		value,
+	})
+	return qb
+}
+
+func (qb *authorizedRepoQueryBuilder) WhereIsUsedNotIn(value []int32) *authorizedRepoQueryBuilder {
+	qb.where = append(qb.where, struct {
+		prefix string
+		value  interface{}
+	}{
+		fmt.Sprintf("%v %v ?", "is_used", "NOT IN"),
+		value,
+	})
+	return qb
+}
+
+func (qb *authorizedRepoQueryBuilder) OrderByIsUsed(asc bool) *authorizedRepoQueryBuilder {
+	order := "DESC"
+	if asc {
+		order = "ASC"
+	}
+
+	qb.order = append(qb.order, "is_used "+order)
+	return qb
+}
+
+func (qb *authorizedRepoQueryBuilder) WhereIsDeleted(p db_repo.Predicate, value int32) *authorizedRepoQueryBuilder {
+	qb.where = append(qb.where, struct {
+		prefix string
+		value  interface{}
+	}{
+		fmt.Sprintf("%v %v ?", "is_deleted", p),
+		value,
+	})
+	return qb
+}
+
+func (qb *authorizedRepoQueryBuilder) WhereIsDeletedIn(value []int32) *authorizedRepoQueryBuilder {
+	qb.where = append(qb.where, struct {
+		prefix string
+		value  interface{}
+	}{
+		fmt.Sprintf("%v %v ?", "is_deleted", "IN"),
+		value,
+	})
+	return qb
+}
+
+func (qb *authorizedRepoQueryBuilder) WhereIsDeletedNotIn(value []int32) *authorizedRepoQueryBuilder {
+	qb.where = append(qb.where, struct {
+		prefix string
+		value  interface{}
+	}{
+		fmt.Sprintf("%v %v ?", "is_deleted", "NOT IN"),
+		value,
+	})
+	return qb
+}
+
+func (qb *authorizedRepoQueryBuilder) OrderByIsDeleted(asc bool) *authorizedRepoQueryBuilder {
+	order := "DESC"
+	if asc {
+		order = "ASC"
+	}
+
+	qb.order = append(qb.order, "is_deleted "+order)
+	return qb
+}
+
+func (qb *authorizedRepoQueryBuilder) WhereCreatedAt(p db_repo.Predicate, value time.Time) *authorizedRepoQueryBuilder {
+	qb.where = append(qb.where, struct {
+		prefix string
+		value  interface{}
+	}{
+		fmt.Sprintf("%v %v ?", "created_at", p),
+		value,
+	})
+	return qb
+}
+
+func (qb *authorizedRepoQueryBuilder) WhereCreatedAtIn(value []time.Time) *authorizedRepoQueryBuilder {
+	qb.where = append(qb.where, struct {
+		prefix string
+		value  interface{}
+	}{
+		fmt.Sprintf("%v %v ?", "created_at", "IN"),
+		value,
+	})
+	return qb
+}
+
+func (qb *authorizedRepoQueryBuilder) WhereCreatedAtNotIn(value []time.Time) *authorizedRepoQueryBuilder {
+	qb.where = append(qb.where, struct {
+		prefix string
+		value  interface{}
+	}{
+		fmt.Sprintf("%v %v ?", "created_at", "NOT IN"),
+		value,
+	})
+	return qb
+}
+
+func (qb *authorizedRepoQueryBuilder) OrderByCreatedAt(asc bool) *authorizedRepoQueryBuilder {
+	order := "DESC"
+	if asc {
+		order = "ASC"
+	}
+
+	qb.order = append(qb.order, "created_at "+order)
+	return qb
+}
+
+func (qb *authorizedRepoQueryBuilder) WhereCreatedUser(p db_repo.Predicate, value string) *authorizedRepoQueryBuilder {
+	qb.where = append(qb.where, struct {
+		prefix string
+		value  interface{}
+	}{
+		fmt.Sprintf("%v %v ?", "created_user", p),
+		value,
+	})
+	return qb
+}
+
+func (qb *authorizedRepoQueryBuilder) WhereCreatedUserIn(value []string) *authorizedRepoQueryBuilder {
+	qb.where = append(qb.where, struct {
+		prefix string
+		value  interface{}
+	}{
+		fmt.Sprintf("%v %v ?", "created_user", "IN"),
+		value,
+	})
+	return qb
+}
+
+func (qb *authorizedRepoQueryBuilder) WhereCreatedUserNotIn(value []string) *authorizedRepoQueryBuilder {
+	qb.where = append(qb.where, struct {
+		prefix string
+		value  interface{}
+	}{
+		fmt.Sprintf("%v %v ?", "created_user", "NOT IN"),
+		value,
+	})
+	return qb
+}
+
+func (qb *authorizedRepoQueryBuilder) OrderByCreatedUser(asc bool) *authorizedRepoQueryBuilder {
+	order := "DESC"
+	if asc {
+		order = "ASC"
+	}
+
+	qb.order = append(qb.order, "created_user "+order)
+	return qb
+}
+
+func (qb *authorizedRepoQueryBuilder) WhereUpdatedAt(p db_repo.Predicate, value time.Time) *authorizedRepoQueryBuilder {
+	qb.where = append(qb.where, struct {
+		prefix string
+		value  interface{}
+	}{
+		fmt.Sprintf("%v %v ?", "updated_at", p),
+		value,
+	})
+	return qb
+}
+
+func (qb *authorizedRepoQueryBuilder) WhereUpdatedAtIn(value []time.Time) *authorizedRepoQueryBuilder {
+	qb.where = append(qb.where, struct {
+		prefix string
+		value  interface{}
+	}{
+		fmt.Sprintf("%v %v ?", "updated_at", "IN"),
+		value,
+	})
+	return qb
+}
+
+func (qb *authorizedRepoQueryBuilder) WhereUpdatedAtNotIn(value []time.Time) *authorizedRepoQueryBuilder {
+	qb.where = append(qb.where, struct {
+		prefix string
+		value  interface{}
+	}{
+		fmt.Sprintf("%v %v ?", "updated_at", "NOT IN"),
+		value,
+	})
+	return qb
+}
+
+func (qb *authorizedRepoQueryBuilder) OrderByUpdatedAt(asc bool) *authorizedRepoQueryBuilder {
+	order := "DESC"
+	if asc {
+		order = "ASC"
+	}
+
+	qb.order = append(qb.order, "updated_at "+order)
+	return qb
+}
+
+func (qb *authorizedRepoQueryBuilder) WhereUpdatedUser(p db_repo.Predicate, value string) *authorizedRepoQueryBuilder {
+	qb.where = append(qb.where, struct {
+		prefix string
+		value  interface{}
+	}{
+		fmt.Sprintf("%v %v ?", "updated_user", p),
+		value,
+	})
+	return qb
+}
+
+func (qb *authorizedRepoQueryBuilder) WhereUpdatedUserIn(value []string) *authorizedRepoQueryBuilder {
+	qb.where = append(qb.where, struct {
+		prefix string
+		value  interface{}
+	}{
+		fmt.Sprintf("%v %v ?", "updated_user", "IN"),
+		value,
+	})
+	return qb
+}
+
+func (qb *authorizedRepoQueryBuilder) WhereUpdatedUserNotIn(value []string) *authorizedRepoQueryBuilder {
+	qb.where = append(qb.where, struct {
+		prefix string
+		value  interface{}
+	}{
+		fmt.Sprintf("%v %v ?", "updated_user", "NOT IN"),
+		value,
+	})
+	return qb
+}
+
+func (qb *authorizedRepoQueryBuilder) OrderByUpdatedUser(asc bool) *authorizedRepoQueryBuilder {
+	order := "DESC"
+	if asc {
+		order = "ASC"
+	}
+
+	qb.order = append(qb.order, "updated_user "+order)
+	return qb
+}

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

@@ -0,0 +1,19 @@
+package authorized_repo
+
+import "time"
+
+// 已授权的调用方表
+//go:generate gormgen -structs Authorized -input .
+type Authorized struct {
+	Id                int32     // 主键
+	BusinessKey       string    // 调用方key
+	BusinessSecret    string    // 调用方secret
+	BusinessDeveloper string    // 调用方对接人
+	Remark            string    // 备注
+	IsUsed            int32     // 是否启用 1:是  -1:否
+	IsDeleted         int32     // 是否删除 1:是  -1:否
+	CreatedAt         time.Time `gorm:"time"` // 创建时间
+	CreatedUser       string    // 创建人
+	UpdatedAt         time.Time `gorm:"time"` // 更新时间
+	UpdatedUser       string    // 更新人
+}

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

@@ -0,0 +1,16 @@
+#### go_gin_api.authorized 
+已授权的调用方表
+
+| 序号 | 名称 | 描述 | 类型 | 键 | 为空 | 额外 | 默认值 |
+| :--: | :--: | :--: | :--: | :--: | :--: | :--: | :--: |
+| 1 | id | 主键 | int(11) unsigned | PRI | NO | auto_increment |  |
+| 2 | business_key | 调用方key | varchar(32) |  | NO |  |  |
+| 3 | business_secret | 调用方secret | varchar(60) |  | NO |  |  |
+| 4 | business_developer | 调用方对接人 | varchar(60) |  | NO |  |  |
+| 5 | remark | 备注 | varchar(255) |  | NO |  |  |
+| 6 | is_used | 是否启用 1:是  -1:否 | tinyint(1) |  | NO |  | -1 |
+| 7 | is_deleted | 是否删除 1:是  -1:否 | tinyint(1) |  | NO |  | -1 |
+| 8 | created_at | 创建时间 | timestamp |  | NO |  | CURRENT_TIMESTAMP |
+| 9 | created_user | 创建人 | varchar(60) |  | NO |  |  |
+| 10 | updated_at | 更新时间 | timestamp |  | NO | on update CURRENT_TIMESTAMP | CURRENT_TIMESTAMP |
+| 11 | updated_user | 更新人 | varchar(60) |  | NO |  |  |

internal/api/service/authorized_service/service.go

@@ -0,0 +1,41 @@
+package authorized_service
+
+import (
+	"github.com/xinliangnote/go-gin-api/internal/api/repository/db_repo/authorized_api_repo"
+	"github.com/xinliangnote/go-gin-api/internal/api/repository/db_repo/authorized_repo"
+	"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"
+)
+
+var _ Service = (*service)(nil)
+
+type Service interface {
+	i()
+
+	Create(ctx core.Context, authorizedData *CreateAuthorizedData) (id int32, err error)
+	List(ctx core.Context, searchData *SearchData) (listData []*authorized_repo.Authorized, err error)
+	PageList(ctx core.Context, searchData *SearchData) (listData []*authorized_repo.Authorized, err error)
+	PageListCount(ctx core.Context, searchData *SearchData) (total int64, err error)
+	UpdateUsed(ctx core.Context, id int32, used int32) (err error)
+	Delete(ctx core.Context, id int32) (err error)
+	Detail(ctx core.Context, id int32) (info *authorized_repo.Authorized, err error)
+
+	CreateAPI(ctx core.Context, authorizedAPIData *CreateAuthorizedAPIData) (id int32, err error)
+	ListAPI(ctx core.Context, searchAPIData *SearchAPIData) (listData []*authorized_api_repo.AuthorizedApi, err error)
+	DeleteAPI(ctx core.Context, id int32) (err error)
+}
+
+type service struct {
+	db    db.Repo
+	cache cache.Repo
+}
+
+func New(db db.Repo, cache cache.Repo) Service {
+	return &service{
+		db:    db,
+		cache: cache,
+	}
+}
+
+func (s *service) i() {}

internal/api/service/authorized_service/service_create.go

@@ -0,0 +1,37 @@
+package authorized_service
+
+import (
+	"crypto/rand"
+	"encoding/hex"
+	"io"
+
+	"github.com/xinliangnote/go-gin-api/internal/api/repository/db_repo/authorized_repo"
+	"github.com/xinliangnote/go-gin-api/internal/pkg/core"
+)
+
+type CreateAuthorizedData struct {
+	BusinessKey       string `json:"business_key"`       // 调用方key
+	BusinessDeveloper string `json:"business_developer"` // 调用方对接人
+	Remark            string `json:"remark"`             // 备注
+}
+
+func (s *service) Create(ctx core.Context, authorizedData *CreateAuthorizedData) (id int32, err error) {
+	buf := make([]byte, 10)
+	io.ReadFull(rand.Reader, buf)
+	secret := string(hex.EncodeToString(buf))
+
+	model := authorized_repo.NewModel()
+	model.BusinessKey = authorizedData.BusinessKey
+	model.BusinessSecret = secret
+	model.BusinessDeveloper = authorizedData.BusinessDeveloper
+	model.Remark = authorizedData.Remark
+	model.CreatedUser = "system" // TODO
+	model.IsUsed = 1
+	model.IsDeleted = -1
+
+	id, err = model.Create(s.db.GetDbW().WithContext(ctx.RequestContext()))
+	if err != nil {
+		return 0, err
+	}
+	return
+}

internal/api/service/authorized_service/service_createapi.go

@@ -0,0 +1,27 @@
+package authorized_service
+
+import (
+	"github.com/xinliangnote/go-gin-api/internal/api/repository/db_repo/authorized_api_repo"
+	"github.com/xinliangnote/go-gin-api/internal/pkg/core"
+)
+
+type CreateAuthorizedAPIData struct {
+	BusinessKey string `json:"business_key"` // 调用方key
+	Method      string `json:"method"`       // 请求方法
+	API         string `json:"api"`          // 请求地址
+}
+
+func (s *service) CreateAPI(ctx core.Context, authorizedAPIData *CreateAuthorizedAPIData) (id int32, err error) {
+	model := authorized_api_repo.NewModel()
+	model.BusinessKey = authorizedAPIData.BusinessKey
+	model.Method = authorizedAPIData.Method
+	model.Api = authorizedAPIData.API
+	model.CreatedUser = "system" // TODO
+	model.IsDeleted = -1
+
+	id, err = model.Create(s.db.GetDbW().WithContext(ctx.RequestContext()))
+	if err != nil {
+		return 0, err
+	}
+	return
+}

internal/api/service/authorized_service/service_delete.go

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

internal/api/service/authorized_service/service_deleteapi.go

@@ -0,0 +1,23 @@
+package authorized_service
+
+import (
+	"github.com/xinliangnote/go-gin-api/internal/api/repository/db_repo/authorized_api_repo"
+	"github.com/xinliangnote/go-gin-api/internal/pkg/core"
+)
+
+func (s *service) DeleteAPI(ctx core.Context, id int32) (err error) {
+	model := authorized_api_repo.NewModel()
+	model.Id = id
+
+	data := map[string]interface{}{
+		"is_deleted":   1,
+		"updated_user": "system", // TODO
+	}
+
+	err = model.Updates(s.db.GetDbW().WithContext(ctx.RequestContext()), data)
+	if err != nil {
+		return err
+	}
+
+	return
+}

internal/api/service/authorized_service/service_detail.go

@@ -0,0 +1,21 @@
+package authorized_service
+
+import (
+	"github.com/xinliangnote/go-gin-api/internal/api/repository/db_repo"
+	"github.com/xinliangnote/go-gin-api/internal/api/repository/db_repo/authorized_repo"
+	"github.com/xinliangnote/go-gin-api/internal/pkg/core"
+)
+
+func (s *service) Detail(ctx core.Context, id int32) (info *authorized_repo.Authorized, err error) {
+	qb := authorized_repo.NewQueryBuilder()
+	qb = qb.WhereIsDeleted(db_repo.EqualPredicate, -1)
+
+	qb.WhereId(db_repo.EqualPredicate, id)
+
+	info, err = qb.First(s.db.GetDbR().WithContext(ctx.RequestContext()))
+	if err != nil {
+		return nil, err
+	}
+
+	return
+}

internal/api/service/authorized_service/service_list.go

@@ -0,0 +1,34 @@
+package authorized_service
+
+import (
+	"github.com/xinliangnote/go-gin-api/internal/api/repository/db_repo"
+	"github.com/xinliangnote/go-gin-api/internal/api/repository/db_repo/authorized_repo"
+	"github.com/xinliangnote/go-gin-api/internal/pkg/core"
+)
+
+func (s *service) List(ctx core.Context, searchData *SearchData) (listData []*authorized_repo.Authorized, err error) {
+
+	qb := authorized_repo.NewQueryBuilder()
+	qb = qb.WhereIsDeleted(db_repo.EqualPredicate, -1)
+
+	if searchData.BusinessKey != "" {
+		qb.WhereBusinessKey(db_repo.EqualPredicate, searchData.BusinessKey)
+	}
+
+	if searchData.BusinessSecret != "" {
+		qb.WhereBusinessSecret(db_repo.EqualPredicate, searchData.BusinessSecret)
+	}
+
+	if searchData.BusinessDeveloper != "" {
+		qb.WhereBusinessDeveloper(db_repo.EqualPredicate, searchData.BusinessDeveloper)
+	}
+
+	listData, err = qb.
+		OrderById(false).
+		QueryAll(s.db.GetDbR().WithContext(ctx.RequestContext()))
+	if err != nil {
+		return nil, err
+	}
+
+	return
+}

internal/api/service/authorized_service/service_listapi.go

@@ -0,0 +1,30 @@
+package authorized_service
+
+import (
+	"github.com/xinliangnote/go-gin-api/internal/api/repository/db_repo"
+	"github.com/xinliangnote/go-gin-api/internal/api/repository/db_repo/authorized_api_repo"
+	"github.com/xinliangnote/go-gin-api/internal/pkg/core"
+)
+
+type SearchAPIData struct {
+	BusinessKey string `json:"business_key"` // 调用方key
+}
+
+func (s *service) ListAPI(ctx core.Context, searchAPIData *SearchAPIData) (listData []*authorized_api_repo.AuthorizedApi, err error) {
+
+	qb := authorized_api_repo.NewQueryBuilder()
+	qb = qb.WhereIsDeleted(db_repo.EqualPredicate, -1)
+
+	if searchAPIData.BusinessKey != "" {
+		qb.WhereBusinessKey(db_repo.EqualPredicate, searchAPIData.BusinessKey)
+	}
+
+	listData, err = qb.
+		OrderById(false).
+		QueryAll(s.db.GetDbR().WithContext(ctx.RequestContext()))
+	if err != nil {
+		return nil, err
+	}
+
+	return
+}

internal/api/service/authorized_service/service_pagelist.go

@@ -0,0 +1,57 @@
+package authorized_service
+
+import (
+	"github.com/xinliangnote/go-gin-api/internal/api/repository/db_repo"
+	"github.com/xinliangnote/go-gin-api/internal/api/repository/db_repo/authorized_repo"
+	"github.com/xinliangnote/go-gin-api/internal/pkg/core"
+)
+
+type SearchData struct {
+	Page              int    `json:"page"`               // 第几页
+	PageSize          int    `json:"page_size"`          // 每页显示条数
+	BusinessKey       string `json:"business_key"`       // 调用方key
+	BusinessSecret    string `json:"business_secret"`    // 调用方secret
+	BusinessDeveloper string `json:"business_developer"` // 调用方对接人
+	Remark            string `json:"remark"`             // 备注
+}
+
+func (s *service) PageList(ctx core.Context, searchData *SearchData) (listData []*authorized_repo.Authorized, err error) {
+
+	page := searchData.Page
+	if page == 0 {
+		page = 1
+	}
+
+	pageSize := searchData.PageSize
+	if pageSize == 0 {
+		pageSize = 10
+	}
+
+	offset := (page - 1) * pageSize
+
+	qb := authorized_repo.NewQueryBuilder()
+	qb = qb.WhereIsDeleted(db_repo.EqualPredicate, -1)
+
+	if searchData.BusinessKey != "" {
+		qb.WhereBusinessKey(db_repo.EqualPredicate, searchData.BusinessKey)
+	}
+
+	if searchData.BusinessSecret != "" {
+		qb.WhereBusinessSecret(db_repo.EqualPredicate, searchData.BusinessSecret)
+	}
+
+	if searchData.BusinessDeveloper != "" {
+		qb.WhereBusinessDeveloper(db_repo.EqualPredicate, searchData.BusinessDeveloper)
+	}
+
+	listData, err = qb.
+		Limit(pageSize).
+		Offset(offset).
+		OrderById(false).
+		QueryAll(s.db.GetDbR().WithContext(ctx.RequestContext()))
+	if err != nil {
+		return nil, err
+	}
+
+	return
+}

internal/api/service/authorized_service/service_pagelistcount.go

@@ -0,0 +1,31 @@
+package authorized_service
+
+import (
+	"github.com/xinliangnote/go-gin-api/internal/api/repository/db_repo"
+	"github.com/xinliangnote/go-gin-api/internal/api/repository/db_repo/authorized_repo"
+	"github.com/xinliangnote/go-gin-api/internal/pkg/core"
+)
+
+func (s *service) PageListCount(ctx core.Context, searchData *SearchData) (total int64, err error) {
+	qb := authorized_repo.NewQueryBuilder()
+	qb = qb.WhereIsDeleted(db_repo.EqualPredicate, -1)
+
+	if searchData.BusinessKey != "" {
+		qb.WhereBusinessKey(db_repo.EqualPredicate, searchData.BusinessKey)
+	}
+
+	if searchData.BusinessSecret != "" {
+		qb.WhereBusinessSecret(db_repo.EqualPredicate, searchData.BusinessSecret)
+	}
+
+	if searchData.BusinessDeveloper != "" {
+		qb.WhereBusinessDeveloper(db_repo.EqualPredicate, searchData.BusinessDeveloper)
+	}
+
+	total, err = qb.Count(s.db.GetDbR().WithContext(ctx.RequestContext()))
+	if err != nil {
+		return 0, err
+	}
+
+	return
+}

internal/api/service/authorized_service/service_updateused.go

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

internal/router/router_api.go

@@ -1,7 +1,9 @@
 package router
 
 import (
+	"github.com/xinliangnote/go-gin-api/internal/api/controller/authorized_handler"
 	"github.com/xinliangnote/go-gin-api/internal/api/controller/demo_handler"
+	"github.com/xinliangnote/go-gin-api/internal/api/controller/tool_handler"
 	"github.com/xinliangnote/go-gin-api/internal/api/controller/user_handler"
 	"github.com/xinliangnote/go-gin-api/internal/pkg/core"
 )
@@ -33,4 +35,24 @@ func setApiRouter(r *resource) {
 		user.PATCH("/delete/:id", userHandler.Delete())
 		user.GET("/info/:username", core.AliasForRecordMetrics("/user/info"), userHandler.Detail())
 	}
+
+	// api
+	api := r.mux.Group("/api")
+	{
+		// authorized
+		authorizedHandler := authorized_handler.New(r.logger, r.db, r.cache)
+		api.POST("/authorized", authorizedHandler.Create())
+		api.GET("/authorized", authorizedHandler.List())
+		api.PATCH("/authorized/used", authorizedHandler.UpdateUsed())
+		api.DELETE("/authorized/:id", authorizedHandler.Delete())
+
+		api.POST("/authorized_api", authorizedHandler.CreateAPI())
+		api.GET("/authorized_list", authorizedHandler.ListAPI())
+		api.DELETE("/authorized_api/:id", authorizedHandler.DeleteAPI())
+
+		// 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())
+	}
 }

internal/router/router_web.go

@@ -1,10 +1,12 @@
 package router
 
 import (
+	"github.com/xinliangnote/go-gin-api/internal/web/controller/authorized_handler"
 	"github.com/xinliangnote/go-gin-api/internal/web/controller/configinfo_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/index_handler"
+	"github.com/xinliangnote/go-gin-api/internal/web/controller/tool_handler"
 )
 
 func setWebRouter(r *resource) {
@@ -13,6 +15,8 @@ func setWebRouter(r *resource) {
 	dashboardHandler := dashboard_handler.New(r.logger, r.db, r.cache)
 	genCodeHandler := gencode_handler.New(r.logger, r.db, r.cache)
 	configInfoHandler := configinfo_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)
 
 	web := r.mux.Group("", r.middles.DisableLog())
 	{
@@ -35,5 +39,13 @@ func setWebRouter(r *resource) {
 		web.GET("/handlergen", genCodeHandler.HandlerView())
 		web.POST("/handlergen_exec", genCodeHandler.HandlerExecute())
 
+		// 调用方
+		web.GET("/authorized/list", authorizedHandler.ListView())
+		web.GET("/authorized/add", authorizedHandler.AddView())
+		web.GET("/authorized/api/:id", authorizedHandler.ApiView())
+
+		// 工具箱
+		web.GET("/tool/hashids", toolHandler.HashIdsView())
+
 	}
 }

internal/web/controller/authorized_handler/func_addview.go

@@ -0,0 +1,9 @@
+package authorized_handler
+
+import "github.com/xinliangnote/go-gin-api/internal/pkg/core"
+
+func (h *handler) AddView() core.HandlerFunc {
+	return func(c core.Context) {
+		c.HTML("authorized_add", nil)
+	}
+}

internal/web/controller/authorized_handler/func_apiview.go

@@ -0,0 +1,36 @@
+package authorized_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 apiViewRequest struct {
+	Id string `uri:"id"` // 主键ID
+}
+
+type apiViewResponse struct {
+	HashID string `json:"hash_id"` // hashID
+}
+
+func (h *handler) ApiView() core.HandlerFunc {
+	return func(c core.Context) {
+		req := new(apiViewRequest)
+		if err := c.ShouldBindURI(req); err != nil {
+			c.AbortWithError(errno.NewError(
+				http.StatusBadRequest,
+				code.ParamBindError,
+				code.Text(code.ParamBindError)).WithErr(err),
+			)
+			return
+		}
+
+		obj := new(apiViewResponse)
+		obj.HashID = req.Id
+
+		c.HTML("authorized_api", obj)
+	}
+}

internal/web/controller/authorized_handler/func_listview.go

@@ -0,0 +1,9 @@
+package authorized_handler
+
+import "github.com/xinliangnote/go-gin-api/internal/pkg/core"
+
+func (h *handler) ListView() core.HandlerFunc {
+	return func(c core.Context) {
+		c.HTML("authorized_list", nil)
+	}
+}

internal/web/controller/authorized_handler/handler.go

@@ -0,0 +1,35 @@
+package authorized_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()
+
+	AddView() core.HandlerFunc
+	ApiView() core.HandlerFunc
+	ListView() 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() {}

internal/web/controller/tool_handler/func_hashidsview.go

@@ -0,0 +1,12 @@
+package tool_handler
+
+import (
+	"github.com/xinliangnote/go-gin-api/configs"
+	"github.com/xinliangnote/go-gin-api/internal/pkg/core"
+)
+
+func (h *handler) HashIdsView() core.HandlerFunc {
+	return func(c core.Context) {
+		c.HTML("tool_hashids", configs.Get())
+	}
+}

internal/web/controller/tool_handler/handler.go

@@ -0,0 +1,31 @@
+package tool_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()
+
+	HashIdsView() core.HandlerFunc
+}
+
+type handler struct {
+	logger *zap.Logger
+	cache  cache.Repo
+}
+
+func New(logger *zap.Logger, db db.Repo, cache cache.Repo) Handler {
+	return &handler{
+		logger: logger,
+		cache:  cache,
+	}
+}
+
+func (h *handler) i() {}