feat: 统一sql命名、函数命名

internal/handler/admin/api.go

@@ -0,0 +1,135 @@
+package admin
+
+import (
+	"net/http"
+	"server/internal/model/common"
+	"server/internal/model/request"
+	"server/internal/pkg/httputil"
+	"server/internal/router"
+	"server/internal/service/admin"
+
+	"github.com/go-chi/chi/v5"
+)
+
+type ApiHandler struct {
+	apiService *admin.ApiService
+}
+
+var _ router.Registrar = (*ApiHandler)(nil)
+
+func NewApiHandler(apiService *admin.ApiService) *ApiHandler {
+	return &ApiHandler{apiService: apiService}
+}
+
+func (h *ApiHandler) Register(r chi.Router) {
+	r.Route("/apis", func(r chi.Router) {
+		r.Get("/", h.List)
+		r.Get("/all", h.ListAll)
+		r.Get("/groups", h.ListApiGroups)
+		r.Post("/", h.Create)
+		r.Patch("/{id}", h.Update)
+		r.Delete("/{id}", h.Delete)
+	})
+}
+
+func (h *ApiHandler) List(w http.ResponseWriter, r *http.Request) {
+	pagination := httputil.Pagination(r)
+
+	params := request.SearchApiParams{
+		Pagination: *pagination,
+		Name:       r.URL.Query().Get("name"),
+		GroupName:  r.URL.Query().Get("group_name"),
+		Method:     r.URL.Query().Get("method"),
+	}
+
+	result, err := h.apiService.List(r.Context(), params)
+
+	if err != nil {
+		httputil.Fail(w, err)
+		return
+	}
+
+	resp := common.PageResponse{
+		Page:     pagination.Page,
+		PageSize: pagination.PageSize,
+		List:     result.List,
+		Total:    result.Total,
+	}
+
+	httputil.OkWithPage(w, &resp)
+}
+
+func (h *ApiHandler) ListAll(w http.ResponseWriter, r *http.Request) {
+	list, err := h.apiService.ListAll(r.Context())
+
+	if err != nil {
+		httputil.Fail(w, err)
+		return
+	}
+
+	httputil.Ok(w, list)
+}
+
+func (h *ApiHandler) ListApiGroups(w http.ResponseWriter, r *http.Request) {
+	list, err := h.apiService.ListApiGroups(r.Context())
+
+	if err != nil {
+		httputil.Fail(w, err)
+		return
+	}
+
+	httputil.Ok(w, list)
+}
+
+func (h *ApiHandler) Create(w http.ResponseWriter, r *http.Request) {
+	var req request.CreateApiRequest
+
+	if err := httputil.BindJson(r, &req); err != nil {
+		httputil.Fail(w, err)
+		return
+	}
+
+	if err := h.apiService.Create(r.Context(), req); err != nil {
+		httputil.Fail(w, err)
+		return
+	}
+
+	httputil.Ok(w)
+}
+
+func (h *ApiHandler) Update(w http.ResponseWriter, r *http.Request) {
+	var req request.UpdateApiRequest
+
+	id, err := httputil.URLParamInt32(r, "id")
+	if err != nil {
+		httputil.Fail(w, err)
+		return
+	}
+
+	if err = httputil.BindJson(r, &req); err != nil {
+		httputil.Fail(w, err)
+		return
+	}
+
+	if err = h.apiService.Update(r.Context(), id, req); err != nil {
+		httputil.Fail(w, err)
+		return
+	}
+
+	httputil.Ok(w)
+}
+
+func (h *ApiHandler) Delete(w http.ResponseWriter, r *http.Request) {
+	id, err := httputil.URLParamInt32(r, "id")
+	if err != nil {
+		httputil.Fail(w, err)
+		return
+	}
+
+	if err = h.apiService.Delete(r.Context(), id); err != nil {
+		httputil.Fail(w, err)
+		return
+	}
+
+	httputil.Ok(w)
+}

internal/handler/admin/auth.go

@@ -0,0 +1,109 @@
+package admin
+
+import (
+	"net/http"
+	"server/internal/config"
+	"server/internal/model/request"
+	"server/internal/pkg/errs"
+	"server/internal/pkg/httputil"
+	"server/internal/router"
+	"server/internal/service/admin"
+	"time"
+
+	"github.com/go-chi/chi/v5"
+)
+
+type AuthHandler struct {
+	authService *admin.AuthService
+	cfg         *config.Config
+}
+
+var _ router.Registrar = (*AuthHandler)(nil)
+
+func NewAuthHandler(authService *admin.AuthService, cfg *config.Config) *AuthHandler {
+	return &AuthHandler{authService: authService, cfg: cfg}
+}
+
+func (h *AuthHandler) Register(r chi.Router) {
+	r.Route("/auth", func(r chi.Router) {
+		r.Post("/login", h.Login)
+		r.Post("/refresh-token", h.RefreshToken)
+		r.Post("/logout", h.Logout)
+	})
+}
+
+func (h *AuthHandler) clearRefreshTokenCookie(w http.ResponseWriter) {
+	http.SetCookie(w, &http.Cookie{
+		Name:     h.cfg.JWTConfig.CookieName,
+		Value:    "",
+		Path:     "/",
+		HttpOnly: true,
+		Secure:   true,
+		SameSite: http.SameSiteNoneMode,
+		MaxAge:   -1,
+		Expires:  time.Unix(0, 0),
+	})
+}
+
+func (h *AuthHandler) Login(w http.ResponseWriter, r *http.Request) {
+	var req request.LoginRequest
+
+	if err := httputil.BindJson(r, &req); err != nil {
+		httputil.Fail(w, errs.ErrInvalidCredentials)
+		return
+	}
+
+	res, err := h.authService.Login(r.Context(), req)
+	if err != nil {
+		httputil.Fail(w, err)
+		return
+	}
+
+	http.SetCookie(w, &http.Cookie{
+		Name:     h.cfg.JWTConfig.CookieName,
+		Value:    res.RefreshToken,
+		Path:     "/",
+		HttpOnly: true,
+		Secure:   true,
+		SameSite: http.SameSiteNoneMode,
+		Expires:  res.RefreshTokenExp,
+	})
+
+	httputil.Ok(w, map[string]any{
+		"access_token":     res.AccessToken,
+		"access_token_exp": res.AccessTokenExp,
+	})
+}
+
+func (h *AuthHandler) Logout(w http.ResponseWriter, r *http.Request) {
+	cookie, err := r.Cookie(h.cfg.JWTConfig.CookieName)
+	if err == nil {
+		_ = h.authService.Logout(r.Context(), cookie.Value)
+	}
+
+	h.clearRefreshTokenCookie(w)
+	httputil.Ok(w)
+}
+
+func (h *AuthHandler) RefreshToken(w http.ResponseWriter, r *http.Request) {
+	cookie, err := r.Cookie(h.cfg.JWTConfig.CookieName)
+	if err != nil {
+		h.clearRefreshTokenCookie(w)
+		httputil.Fail(w, errs.ErrInvalidRefreshToken)
+		return
+	}
+
+	res, err := h.authService.RefreshToken(r.Context(), cookie.Value)
+	if err != nil {
+		// 用户被禁用 调用logout
+		_ = h.authService.Logout(r.Context(), cookie.Value)
+		h.clearRefreshTokenCookie(w)
+		httputil.Fail(w, err)
+		return
+	}
+
+	httputil.Ok(w, map[string]any{
+		"access_token":     res.AccessToken,
+		"access_token_exp": res.AccessTokenExp,
+	})
+}

internal/handler/admin/category.go

@@ -0,0 +1,111 @@
+package admin
+
+import (
+	"net/http"
+	"server/internal/model/common"
+	"server/internal/model/request"
+	"server/internal/pkg/httputil"
+	"server/internal/router"
+	"server/internal/service/admin"
+
+	"github.com/go-chi/chi/v5"
+)
+
+type CategoryHandler struct {
+	categoryService *admin.CategoryService
+}
+
+var _ router.Registrar = (*CategoryHandler)(nil)
+
+func NewCategoryHandler(categoryService *admin.CategoryService) *CategoryHandler {
+	return &CategoryHandler{categoryService: categoryService}
+}
+
+func (h *CategoryHandler) Register(r chi.Router) {
+	r.Route("/categories", func(r chi.Router) {
+		r.Get("/", h.List)
+		r.Get("/all", h.ListAll)
+		r.Post("/", h.Create)
+		r.Patch("/{id}", h.Update)
+		r.Delete("/{id}", h.Delete)
+	})
+}
+
+func (h *CategoryHandler) List(w http.ResponseWriter, r *http.Request) {
+	pagination := httputil.Pagination(r)
+	result, err := h.categoryService.List(r.Context(), pagination)
+	if err != nil {
+		httputil.Fail(w, err)
+		return
+	}
+
+	resp := common.PageResponse{
+		Page:     pagination.Page,
+		PageSize: pagination.PageSize,
+		List:     result.List,
+		Total:    result.Total,
+	}
+	httputil.OkWithPage(w, &resp)
+}
+
+func (h *CategoryHandler) ListAll(w http.ResponseWriter, r *http.Request) {
+	list, err := h.categoryService.ListAll(r.Context())
+	if err != nil {
+		httputil.Fail(w, err)
+		return
+	}
+
+	httputil.Ok(w, list)
+}
+
+func (h *CategoryHandler) Create(w http.ResponseWriter, r *http.Request) {
+	var req request.CreateCategoryRequest
+
+	if err := httputil.BindJson(r, &req); err != nil {
+		httputil.Fail(w, err)
+		return
+	}
+
+	if err := h.categoryService.Create(r.Context(), req); err != nil {
+		httputil.Fail(w, err)
+		return
+	}
+
+	httputil.Ok(w)
+}
+
+func (h *CategoryHandler) Update(w http.ResponseWriter, r *http.Request) {
+	id, err := httputil.URLParamInt32(r, "id")
+	if err != nil {
+		httputil.Fail(w, err)
+		return
+	}
+
+	var req request.UpdateCategoryRequest
+	if err = httputil.BindJson(r, &req); err != nil {
+		httputil.Fail(w, err)
+		return
+	}
+
+	if err = h.categoryService.Update(r.Context(), id, req); err != nil {
+		httputil.Fail(w, err)
+		return
+	}
+
+	httputil.Ok(w)
+}
+
+func (h *CategoryHandler) Delete(w http.ResponseWriter, r *http.Request) {
+	id, err := httputil.URLParamInt32(r, "id")
+	if err != nil {
+		httputil.Fail(w, err)
+		return
+	}
+
+	if err = h.categoryService.Delete(r.Context(), id); err != nil {
+		httputil.Fail(w, err)
+		return
+	}
+
+	httputil.Ok(w)
+}

internal/handler/admin/file.go

@@ -0,0 +1,70 @@
+package admin
+
+import (
+	"net/http"
+	"server/internal/model/common"
+	"server/internal/pkg/httputil"
+	"server/internal/router"
+	"server/internal/service/admin"
+
+	"github.com/go-chi/chi/v5"
+)
+
+type FileHandler struct {
+	service *admin.FileService
+}
+
+var _ router.Registrar = (*FileHandler)(nil)
+
+func NewFileHandler(service *admin.FileService) *FileHandler {
+	return &FileHandler{
+		service: service,
+	}
+}
+
+func (h *FileHandler) Register(r chi.Router) {
+	r.Route("/files", func(r chi.Router) {
+		r.Get("/", h.List)
+		r.Post("/", h.Upload)
+	})
+}
+
+func (h *FileHandler) List(w http.ResponseWriter, r *http.Request) {
+	pagination := httputil.Pagination(r)
+
+	result, err := h.service.List(r.Context(), pagination)
+	if err != nil {
+		httputil.Fail(w, err)
+		return
+	}
+
+	resp := common.PageResponse{
+		Page:     pagination.Page,
+		PageSize: pagination.PageSize,
+		List:     result.List,
+		Total:    result.Total,
+	}
+
+	httputil.OkWithPage(w, &resp)
+}
+
+func (h *FileHandler) Upload(w http.ResponseWriter, r *http.Request) {
+	folder := r.FormValue("folder")
+	if folder == "" {
+		folder = "/"
+	}
+
+	_, header, err := r.FormFile("file")
+	if err != nil {
+		httputil.Fail(w, err)
+		return
+	}
+
+	file, err := h.service.Upload(r.Context(), folder, header)
+	if err != nil {
+		httputil.Fail(w, err)
+		return
+	}
+
+	httputil.Ok(w, file)
+}

internal/handler/admin/menu.go

@@ -0,0 +1,115 @@
+package admin
+
+import (
+	"net/http"
+	"server/internal/model/common"
+	"server/internal/model/request"
+	"server/internal/pkg/httputil"
+	"server/internal/router"
+	"server/internal/service/admin"
+
+	"github.com/go-chi/chi/v5"
+)
+
+type MenuHandler struct {
+	menuService *admin.MenuService
+}
+
+var _ router.Registrar = (*MenuHandler)(nil)
+
+func NewMenuHandler(menuService *admin.MenuService) *MenuHandler {
+	return &MenuHandler{menuService: menuService}
+}
+
+func (h *MenuHandler) Register(r chi.Router) {
+	r.Route("/menus", func(r chi.Router) {
+		r.Get("/", h.List)
+		r.Get("/all", h.ListAll)
+		r.Post("/", h.Create)
+		r.Patch("/{id}", h.Update)
+		r.Delete("/{id}", h.Delete)
+	})
+}
+
+func (h *MenuHandler) List(w http.ResponseWriter, r *http.Request) {
+	pagination := httputil.Pagination(r)
+
+	result, err := h.menuService.List(r.Context(), pagination)
+	if err != nil {
+		httputil.Fail(w, err)
+		return
+	}
+
+	resp := common.PageResponse{
+		Page:     pagination.Page,
+		PageSize: pagination.PageSize,
+		List:     result.List,
+		Total:    result.Total,
+	}
+
+	httputil.OkWithPage(w, &resp)
+}
+
+func (h *MenuHandler) ListAll(w http.ResponseWriter, r *http.Request) {
+	list, err := h.menuService.ListAll(r.Context())
+	if err != nil {
+		httputil.Fail(w, err)
+		return
+	}
+
+	httputil.Ok(w, list)
+}
+
+func (h *MenuHandler) Create(w http.ResponseWriter, r *http.Request) {
+	var req request.CreateMenuRequest
+
+	if err := httputil.BindJson(r, &req); err != nil {
+		httputil.Fail(w, err)
+		return
+	}
+
+	if err := h.menuService.Create(r.Context(), req); err != nil {
+		httputil.Fail(w, err)
+		return
+	}
+
+	httputil.Ok(w)
+}
+
+func (h *MenuHandler) Update(w http.ResponseWriter, r *http.Request) {
+	var req request.UpdateMenuRequest
+
+	id, err := httputil.URLParamInt32(r, "id")
+	if err != nil {
+		httputil.Fail(w, err)
+		return
+	}
+
+	if err = httputil.BindJson(r, &req); err != nil {
+		httputil.Fail(w, err)
+		return
+	}
+
+	if err = h.menuService.Update(r.Context(), id, req); err != nil {
+		httputil.Fail(w, err)
+		return
+	}
+
+	httputil.Ok(w)
+}
+
+func (h *MenuHandler) Delete(w http.ResponseWriter, r *http.Request) {
+	id, err := httputil.URLParamInt32(r, "id")
+	if err != nil {
+		httputil.Fail(w, err)
+		return
+	}
+
+	if err = h.menuService.Delete(r.Context(), id); err != nil {
+		httputil.Fail(w, err)
+		return
+	}
+
+	httputil.Ok(w)
+
+}

internal/handler/admin/module.go

@@ -0,0 +1,24 @@
+package admin
+
+import (
+	"server/internal/router"
+
+	"go.uber.org/fx"
+)
+
+var Module = fx.Module("admin-handlers",
+	fx.Provide(
+		// 特殊路由 不用鉴权
+		router.AsRegistrar(router.AdminPublicRoutes, NewAuthHandler),
+
+		router.AsRegistrar(router.AdminRoutes, NewApiHandler),
+		router.AsRegistrar(router.AdminRoutes, NewCategoryHandler),
+		router.AsRegistrar(router.AdminRoutes, NewFileHandler),
+		router.AsRegistrar(router.AdminRoutes, NewMenuHandler),
+		router.AsRegistrar(router.AdminRoutes, NewPostHandler),
+		router.AsRegistrar(router.AdminRoutes, NewRoleHandler),
+		router.AsRegistrar(router.AdminRoutes, NewTagHandler),
+		router.AsRegistrar(router.AdminRoutes, NewUserHandler),
+		router.AsRegistrar(router.AdminRoutes, NewSystemHandler),
+	),
+)

internal/handler/admin/post.go

@@ -0,0 +1,123 @@
+package admin
+
+import (
+	"net/http"
+	"server/internal/model/common"
+	"server/internal/model/request"
+	"server/internal/pkg/httputil"
+	"server/internal/router"
+	"server/internal/service/admin"
+
+	"github.com/go-chi/chi/v5"
+)
+
+type PostHandler struct {
+	postService *admin.PostService
+}
+
+var _ router.Registrar = (*PostHandler)(nil)
+
+func NewPostHandler(postService *admin.PostService) *PostHandler {
+	return &PostHandler{postService: postService}
+}
+
+func (h *PostHandler) Register(r chi.Router) {
+	r.Route("/posts", func(r chi.Router) {
+		r.Get("/", h.List)
+		r.Get("/{id}", h.GetPostByID)
+		r.Post("/", h.Create)
+		r.Patch("/{id}", h.Update)
+		r.Delete("/{id}", h.Delete)
+	})
+}
+
+func (h *PostHandler) List(w http.ResponseWriter, r *http.Request) {
+	pagination := httputil.Pagination(r)
+
+	result, err := h.postService.List(r.Context(), pagination)
+	if err != nil {
+		httputil.Fail(w, err)
+	}
+
+	resp := common.PageResponse{
+		Page:     pagination.Page,
+		PageSize: pagination.PageSize,
+		List:     result.List,
+		Total:    result.Total,
+	}
+
+	httputil.OkWithPage(w, &resp)
+}
+
+func (h *PostHandler) GetPostByID(w http.ResponseWriter, r *http.Request) {
+	id, err := httputil.URLParamInt32(r, "id")
+	if err != nil {
+		httputil.Fail(w, err)
+		return
+	}
+
+	post, err := h.postService.FindByID(r.Context(), id)
+	if err != nil {
+		httputil.Fail(w, err)
+		return
+	}
+
+	httputil.Ok(w, post)
+}
+
+func (h *PostHandler) Create(w http.ResponseWriter, r *http.Request) {
+	var req request.CreatePostRequest
+
+	if err := httputil.BindJson(r, &req); err != nil {
+		httputil.Fail(w, err)
+		return
+	}
+
+	postID, err := h.postService.Create(r.Context(), req)
+
+	if err != nil {
+		httputil.Fail(w, err)
+		return
+	}
+
+	httputil.Ok(w, map[string]int32{
+		"post_id": postID,
+	})
+}
+
+func (h *PostHandler) Update(w http.ResponseWriter, r *http.Request) {
+	id, err := httputil.URLParamInt32(r, "id")
+	if err != nil {
+		httputil.Fail(w, err)
+		return
+	}
+
+	var req request.UpdatePostRequest
+
+	if err = httputil.BindJson(r, &req); err != nil {
+		httputil.Fail(w, err)
+		return
+	}
+
+	if err = h.postService.Update(r.Context(), id, req); err != nil {
+		httputil.Fail(w, err)
+		return
+	}
+
+	httputil.Ok(w)
+}
+
+func (h *PostHandler) Delete(w http.ResponseWriter, r *http.Request) {
+	id, err := httputil.URLParamInt32(r, "id")
+	if err != nil {
+		httputil.Fail(w, err)
+		return
+	}
+
+	if err = h.postService.Delete(r.Context(), id); err != nil {
+		httputil.Fail(w, err)
+		return
+	}
+
+	httputil.Ok(w)
+}

internal/handler/admin/role.go

@@ -0,0 +1,196 @@
+package admin
+
+import (
+	"net/http"
+	"server/internal/model/common"
+	"server/internal/model/request"
+	"server/internal/pkg/httputil"
+	"server/internal/router"
+	"server/internal/service/admin"
+
+	"github.com/go-chi/chi/v5"
+)
+
+type RoleHandler struct {
+	roleService *admin.RoleService
+}
+
+var _ router.Registrar = (*RoleHandler)(nil)
+
+func NewRoleHandler(roleService *admin.RoleService) *RoleHandler {
+	return &RoleHandler{roleService: roleService}
+}
+
+func (h *RoleHandler) Register(r chi.Router) {
+	r.Route("/roles", func(r chi.Router) {
+		r.Get("/", h.List)
+		r.Get("/{id}/menus", h.ListRoleMenus)
+		r.Get("/{id}/apis", h.ListRoleApis)
+		r.Get("/all", h.ListAll)
+		r.Post("/", h.Create)
+		r.Patch("/{id}", h.Update)
+		r.Put("/{id}/menus", h.SetRoleMenus)
+		r.Put("/{id}/apis", h.SetRoleApis)
+		r.Delete("/{id}", h.Delete)
+	})
+}
+
+func (h *RoleHandler) List(w http.ResponseWriter, r *http.Request) {
+	pagination := httputil.Pagination(r)
+
+	result, err := h.roleService.List(r.Context(), pagination)
+
+	if err != nil {
+		httputil.Fail(w, err)
+		return
+	}
+
+	resp := common.PageResponse{
+		Page:     pagination.Page,
+		PageSize: pagination.PageSize,
+		List:     result.List,
+		Total:    result.Total,
+	}
+
+	httputil.OkWithPage(w, &resp)
+}
+
+func (h *RoleHandler) ListRoleMenus(w http.ResponseWriter, r *http.Request) {
+	id, err := httputil.URLParamInt32(r, "id")
+	if err != nil {
+		httputil.Fail(w, err)
+		return
+	}
+
+	list, err := h.roleService.ListRoleMenus(r.Context(), id)
+	if err != nil {
+		httputil.Fail(w, err)
+		return
+	}
+
+	httputil.Ok(w, list)
+}
+
+func (h *RoleHandler) ListRoleApis(w http.ResponseWriter, r *http.Request) {
+	id, err := httputil.URLParamInt32(r, "id")
+	if err != nil {
+		httputil.Fail(w, err)
+		return
+	}
+
+	list, err := h.roleService.ListRoleApis(r.Context(), id)
+	if err != nil {
+		httputil.Fail(w, err)
+		return
+	}
+
+	httputil.Ok(w, list)
+}
+
+func (h *RoleHandler) ListAll(w http.ResponseWriter, r *http.Request) {
+	roles, err := h.roleService.ListAll(r.Context())
+	if err != nil {
+		httputil.Fail(w, err)
+		return
+	}
+
+	httputil.Ok(w, roles)
+}
+
+func (h *RoleHandler) Create(w http.ResponseWriter, r *http.Request) {
+	var req request.CreateRoleRequest
+
+	if err := httputil.BindJson(r, &req); err != nil {
+		httputil.Fail(w, err)
+		return
+	}
+
+	if err := h.roleService.Create(r.Context(), req); err != nil {
+		httputil.Fail(w, err)
+		return
+	}
+
+	httputil.Ok(w)
+}
+
+func (h *RoleHandler) Update(w http.ResponseWriter, r *http.Request) {
+	var req request.UpdateRoleRequest
+
+	id, err := httputil.URLParamInt32(r, "id")
+	if err != nil {
+		httputil.Fail(w, err)
+		return
+	}
+
+	if err = httputil.BindJson(r, &req); err != nil {
+		httputil.Fail(w, err)
+		return
+	}
+
+	if err = h.roleService.Update(r.Context(), id, req); err != nil {
+		httputil.Fail(w, err)
+		return
+	}
+
+	httputil.Ok(w)
+}
+
+func (h *RoleHandler) SetRoleMenus(w http.ResponseWriter, r *http.Request) {
+	var req request.SetRoleMenusRequest
+
+	id, err := httputil.URLParamInt32(r, "id")
+	if err != nil {
+		httputil.Fail(w, err)
+		return
+	}
+
+	if err = httputil.BindJson(r, &req); err != nil {
+		httputil.Fail(w, err)
+		return
+	}
+
+	if err = h.roleService.SetRoleMenus(r.Context(), id, req); err != nil {
+		httputil.Fail(w, err)
+		return
+	}
+
+	httputil.Ok(w)
+}
+
+func (h *RoleHandler) SetRoleApis(w http.ResponseWriter, r *http.Request) {
+	var req request.SetRoleApisRequest
+
+	id, err := httputil.URLParamInt32(r, "id")
+	if err != nil {
+		httputil.Fail(w, err)
+		return
+	}
+
+	if err = httputil.BindJson(r, &req); err != nil {
+		httputil.Fail(w, err)
+		return
+	}
+
+	if err = h.roleService.SetRoleApis(r.Context(), id, req); err != nil {
+		httputil.Fail(w, err)
+		return
+	}
+
+	httputil.Ok(w)
+
+}
+
+func (h *RoleHandler) Delete(w http.ResponseWriter, r *http.Request) {
+	id, err := httputil.URLParamInt32(r, "id")
+	if err != nil {
+		httputil.Fail(w, err)
+		return
+	}
+
+	if err = h.roleService.Delete(r.Context(), id); err != nil {
+		httputil.Fail(w, err)
+		return
+	}
+
+	httputil.Ok(w)
+}

internal/handler/admin/system.go

@@ -0,0 +1,24 @@
+package admin
+
+import (
+	"server/internal/router"
+
+	"github.com/go-chi/chi/v5"
+)
+
+type SystemHandler struct {
+}
+
+func NewSystemHandler() *SystemHandler {
+	return &SystemHandler{}
+}
+
+var _ router.Registrar = (*SystemHandler)(nil)
+
+func (h *SystemHandler) Register(r chi.Router) {
+
+}
+
+func (h *SystemHandler) ListRoutes() {
+
+}

internal/handler/admin/tag.go

@@ -0,0 +1,115 @@
+package admin
+
+import (
+	"net/http"
+	"server/internal/model/common"
+	"server/internal/model/request"
+	"server/internal/pkg/httputil"
+	"server/internal/router"
+	"server/internal/service/admin"
+
+	"github.com/go-chi/chi/v5"
+)
+
+type TagHandler struct {
+	tagService *admin.TagService
+}
+
+var _ router.Registrar = (*TagHandler)(nil)
+
+func NewTagHandler(tagService *admin.TagService) *TagHandler {
+	return &TagHandler{
+		tagService: tagService,
+	}
+}
+
+func (h *TagHandler) Register(r chi.Router) {
+	r.Route("/tags", func(r chi.Router) {
+		r.Get("/", h.List)
+		r.Get("/all", h.ListAll)
+		r.Post("/", h.Create)
+		r.Patch("/{id}", h.Update)
+		r.Delete("/{id}", h.Delete)
+	})
+}
+
+func (h *TagHandler) List(w http.ResponseWriter, r *http.Request) {
+	pagination := httputil.Pagination(r)
+	result, err := h.tagService.List(r.Context(), pagination)
+	if err != nil {
+		httputil.Fail(w, err)
+		return
+	}
+
+	resp := common.PageResponse{
+		Page:     pagination.Page,
+		PageSize: pagination.PageSize,
+		List:     result.List,
+		Total:    result.Total,
+	}
+
+	httputil.OkWithPage(w, &resp)
+}
+
+func (h *TagHandler) ListAll(w http.ResponseWriter, r *http.Request) {
+	list, err := h.tagService.ListAll(r.Context())
+	if err != nil {
+		httputil.Fail(w, err)
+		return
+	}
+
+	httputil.Ok(w, list)
+}
+
+func (h *TagHandler) Create(w http.ResponseWriter, r *http.Request) {
+	var req request.CreateTagRequest
+
+	if err := httputil.BindJson(r, &req); err != nil {
+		httputil.Fail(w, err)
+		return
+	}
+
+	if err := h.tagService.Create(r.Context(), req); err != nil {
+		httputil.Fail(w, err)
+		return
+	}
+
+	httputil.Ok(w)
+}
+
+func (h *TagHandler) Update(w http.ResponseWriter, r *http.Request) {
+	id, err := httputil.URLParamInt32(r, "id")
+	if err != nil {
+		httputil.Fail(w, err)
+		return
+	}
+
+	var req request.UpdateTagRequest
+
+	if err = httputil.BindJson(r, &req); err != nil {
+		httputil.Fail(w, err)
+		return
+	}
+
+	if err = h.tagService.Update(r.Context(), id, req); err != nil {
+		httputil.Fail(w, err)
+		return
+	}
+
+	httputil.Ok(w)
+}
+
+func (h *TagHandler) Delete(w http.ResponseWriter, r *http.Request) {
+	id, err := httputil.URLParamInt32(r, "id")
+	if err != nil {
+		httputil.Fail(w, err)
+		return
+	}
+
+	if err = h.tagService.Delete(r.Context(), id); err != nil {
+		httputil.Fail(w, err)
+		return
+	}
+
+	httputil.Ok(w)
+}

internal/handler/admin/user.go

@@ -0,0 +1,198 @@
+package admin
+
+import (
+	"net/http"
+	"server/internal/middleware"
+	"server/internal/model/common"
+	"server/internal/model/request"
+	"server/internal/pkg/errs"
+	"server/internal/pkg/httputil"
+	"server/internal/router"
+	"server/internal/service/admin"
+
+	"github.com/go-chi/chi/v5"
+)
+
+type UserHandler struct {
+	userService *admin.UserService
+}
+
+// 编译期接口断言
+var _ router.Registrar = (*UserHandler)(nil)
+
+func NewUserHandler(userService *admin.UserService) *UserHandler {
+	return &UserHandler{
+		userService: userService,
+	}
+}
+
+func (h *UserHandler) Register(r chi.Router) {
+	r.Route("/users", func(r chi.Router) {
+		r.Get("/", h.List)
+		r.Get("/me", h.GetCurrentUser)
+		r.Get("/{id}/roles", h.ListRoles)
+		r.Post("/", h.Create)
+		r.Patch("/{id}", h.Update)
+		r.Put("/{id}/roles", h.SetRoles)
+		r.Patch("/{id}/password", h.UpdatePassword)
+		r.Delete("/{id}", h.Delete)
+	})
+}
+
+func (h *UserHandler) GetCurrentUser(w http.ResponseWriter, r *http.Request) {
+	claims, ok := middleware.GetClaims(r.Context())
+
+	if !ok || claims.UserID == 0 {
+		httputil.Fail(w, errs.ErrUnauthorized)
+		return
+	}
+
+	isAdmin := middleware.IsAdmin(r.Context())
+	uid := claims.UserID
+
+	user, err := h.userService.GetCurrentUser(r.Context(), uid, isAdmin)
+	if err != nil {
+		httputil.Fail(w, err)
+		return
+	}
+
+	httputil.Ok(w, user)
+}
+
+func (h *UserHandler) List(w http.ResponseWriter, r *http.Request) {
+	pagination := httputil.Pagination(r)
+
+	params := request.SearchUserParams{
+		Pagination: *pagination,
+		Username:   r.URL.Query().Get("username"),
+	}
+
+	result, err := h.userService.List(r.Context(), params)
+	if err != nil {
+		httputil.Fail(w, err)
+		return
+	}
+
+	resp := common.PageResponse{
+		Page:     pagination.Page,
+		PageSize: pagination.PageSize,
+		List:     result.List,
+		Total:    result.Total,
+	}
+
+	httputil.OkWithPage(w, &resp)
+}
+
+func (h *UserHandler) ListRoles(w http.ResponseWriter, r *http.Request) {
+	id, err := httputil.URLParamInt32(r, "id")
+	if err != nil {
+		httputil.Fail(w, err)
+		return
+	}
+
+	list, err := h.userService.ListRoles(r.Context(), id)
+	if err != nil {
+		httputil.Fail(w, err)
+		return
+	}
+
+	httputil.Ok(w, list)
+}
+
+func (h *UserHandler) Create(w http.ResponseWriter, r *http.Request) {
+	var req request.CreateUserRequest
+
+	if err := httputil.BindJson(r, &req); err != nil {
+		httputil.Fail(w, err)
+		return
+	}
+
+	if err := h.userService.Create(r.Context(), req); err != nil {
+		httputil.Fail(w, err)
+		return
+	}
+
+	httputil.Ok(w)
+}
+
+func (h *UserHandler) Update(w http.ResponseWriter, r *http.Request) {
+	var req request.UpdateUserRequest
+
+	id, err := httputil.URLParamInt32(r, "id")
+	if err != nil {
+		httputil.Fail(w, err)
+		return
+	}
+
+	if err = httputil.BindJson(r, &req); err != nil {
+		httputil.Fail(w, err)
+		return
+	}
+
+	if err = h.userService.Update(r.Context(), id, req); err != nil {
+		httputil.Fail(w, err)
+		return
+	}
+
+	httputil.Ok(w)
+}
+
+func (h *UserHandler) SetRoles(w http.ResponseWriter, r *http.Request) {
+	var req request.SetUserRolesRequest
+
+	id, err := httputil.URLParamInt32(r, "id")
+	if err != nil {
+		httputil.Fail(w, err)
+		return
+	}
+
+	if err = httputil.BindJson(r, &req); err != nil {
+		httputil.Fail(w, err)
+		return
+	}
+
+	if err = h.userService.SetRoles(r.Context(), id, req); err != nil {
+		httputil.Fail(w, err)
+		return
+	}
+
+	httputil.Ok(w)
+
+}
+
+func (h *UserHandler) UpdatePassword(w http.ResponseWriter, r *http.Request) {
+	var req request.UpdateUserPassword
+
+	id, err := httputil.URLParamInt32(r, "id")
+	if err != nil {
+		httputil.Fail(w, err)
+		return
+	}
+
+	if err = httputil.BindJson(r, &req); err != nil {
+		httputil.Fail(w, err)
+		return
+	}
+
+	if err = h.userService.UpdatePassword(r.Context(), id, req); err != nil {
+		httputil.Fail(w, err)
+		return
+	}
+
+	httputil.Ok(w)
+}
+
+func (h *UserHandler) Delete(w http.ResponseWriter, r *http.Request) {
+	id, err := httputil.URLParamInt32(r, "id")
+	if err != nil {
+		httputil.Fail(w, err)
+		return
+	}
+
+	if err = h.userService.Delete(r.Context(), id); err != nil {
+		httputil.Fail(w, err)
+		return
+	}
+
+	httputil.Ok(w)
+}