chore: initial commit

internal/handler/category.go

@@ -0,0 +1,96 @@
+package handler
+
+import (
+	"net/http"
+	"server/internal/model/common"
+	"server/internal/model/request"
+	"server/internal/pkg/httputil"
+	"server/internal/service"
+)
+
+type CategoryHandler struct {
+	categoryService *service.CategoryService
+}
+
+func NewCategoryHandler(categoryService *service.CategoryService) *CategoryHandler {
+	return &CategoryHandler{categoryService: categoryService}
+}
+
+func (h *CategoryHandler) ListPage(w http.ResponseWriter, r *http.Request) {
+	pagination := httputil.Pagination(r)
+	list, total, err := h.categoryService.ListPage(r.Context(), pagination)
+	if err != nil {
+		httputil.Fail(w, err)
+		return
+	}
+
+	resp := common.PageResponse{
+		Page:     pagination.Page,
+		PageSize: pagination.PageSize,
+		List:     list,
+		Total:    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/module.go

@@ -0,0 +1,20 @@
+package handler
+
+import (
+	"go.uber.org/fx"
+)
+
+var Module = fx.Module("handlers",
+	fx.Provide(
+		NewSysUserHandler,
+		NewSysRoleHandler,
+		NewSysMenuHandler,
+		NewSysApiHandler,
+		NewSysFileHandler,
+		NewSysPostHandler,
+		NewCategoryHandler,
+
+		NewPostHandler,
+		NewWebHandler,
+	),
+)

internal/handler/post.go

@@ -0,0 +1,83 @@
+package handler
+
+import (
+	"net/http"
+	"net/netip"
+	"server/internal/model/common"
+	"server/internal/pkg/errs"
+	"server/internal/pkg/httputil"
+	"server/internal/service"
+	"server/internal/utils"
+
+	"github.com/go-chi/chi/v5"
+)
+
+type PostHandler struct {
+	postService *service.PostService
+}
+
+func NewPostHandler(postService *service.PostService) *PostHandler {
+	return &PostHandler{postService: postService}
+}
+
+func (h *PostHandler) ListPage(w http.ResponseWriter, r *http.Request) {
+	pagination := httputil.Pagination(r)
+
+	list, total, err := h.postService.ListPage(r.Context(), pagination)
+	if err != nil {
+		httputil.Fail(w, err)
+		return
+	}
+
+	resp := common.PageResponse{
+		Page:     pagination.Page,
+		PageSize: pagination.PageSize,
+		List:     list,
+		Total:    total,
+	}
+
+	httputil.OkWithPage(w, &resp)
+}
+
+func (h *PostHandler) GetPost(w http.ResponseWriter, r *http.Request) {
+	slug := chi.URLParam(r, "slug")
+
+	if slug == "" {
+		httputil.Fail(w, errs.ErrSlugRequired)
+		return
+	}
+
+	ip, err := netip.ParseAddr(utils.ClientIP(r))
+	if err != nil {
+		httputil.Fail(w, err)
+		return
+	}
+
+	post, err := h.postService.GetPost(r.Context(), slug, ip)
+	if err != nil {
+		httputil.Fail(w, err)
+		return
+	}
+
+	httputil.Ok(w, post)
+}
+
+func (h *PostHandler) ListCategoryStats(w http.ResponseWriter, r *http.Request) {
+	list, err := h.postService.ListCategoryStats(r.Context())
+	if err != nil {
+		httputil.Fail(w, err)
+		return
+	}
+
+	httputil.Ok(w, list)
+}
+
+func (h *PostHandler) ListArchives(w http.ResponseWriter, r *http.Request) {
+	list, err := h.postService.ListArchives(r.Context())
+	if err != nil {
+		httputil.Fail(w, err)
+		return
+	}
+
+	httputil.Ok(w, list)
+}

internal/handler/sys_api.go

@@ -0,0 +1,112 @@
+package handler
+
+import (
+	"net/http"
+	"server/internal/model/common"
+	"server/internal/model/request"
+	"server/internal/pkg/httputil"
+	"server/internal/service"
+)
+
+type SysApiHandler struct {
+	apiService *service.SysApiService
+}
+
+func NewSysApiHandler(apiService *service.SysApiService) *SysApiHandler {
+	return &SysApiHandler{apiService: apiService}
+}
+
+func (h *SysApiHandler) ListPage(w http.ResponseWriter, r *http.Request) {
+	pagination := httputil.Pagination(r)
+
+	list, total, err := h.apiService.ListPage(r.Context(), pagination)
+
+	if err != nil {
+		httputil.Fail(w, err)
+		return
+	}
+
+	resp := common.PageResponse{
+		Page:     pagination.Page,
+		PageSize: pagination.PageSize,
+		List:     list,
+		Total:    total,
+	}
+
+	httputil.OkWithPage(w, &resp)
+}
+
+func (h *SysApiHandler) GetAllSysApis(w http.ResponseWriter, r *http.Request) {
+	list, err := h.apiService.GetAllSysApis(r.Context())
+
+	if err != nil {
+		httputil.Fail(w, err)
+		return
+	}
+
+	httputil.Ok(w, list)
+}
+
+func (h *SysApiHandler) GetApiGroupNames(w http.ResponseWriter, r *http.Request) {
+	list, err := h.apiService.GetApiGroupNames(r.Context())
+
+	if err != nil {
+		httputil.Fail(w, err)
+		return
+	}
+
+	httputil.Ok(w, list)
+}
+
+func (h *SysApiHandler) Create(w http.ResponseWriter, r *http.Request) {
+	var req request.CreateSysApiRequest
+
+	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 *SysApiHandler) Update(w http.ResponseWriter, r *http.Request) {
+	var req request.UpdateSysApiRequest
+
+	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 *SysApiHandler) 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/sys_file.go

@@ -0,0 +1,58 @@
+package handler
+
+import (
+	"net/http"
+	"server/internal/model/common"
+	"server/internal/pkg/httputil"
+	"server/internal/service"
+)
+
+type SysFileHandler struct {
+	service *service.SysFileService
+}
+
+func NewSysFileHandler(service *service.SysFileService) *SysFileHandler {
+	return &SysFileHandler{
+		service: service,
+	}
+}
+
+func (h *SysFileHandler) ListPage(w http.ResponseWriter, r *http.Request) {
+	pagination := httputil.Pagination(r)
+
+	list, total, err := h.service.ListPage(r.Context(), pagination)
+	if err != nil {
+		httputil.Fail(w, err)
+		return
+	}
+
+	resp := common.PageResponse{
+		Page:     pagination.Page,
+		PageSize: pagination.PageSize,
+		List:     list,
+		Total:    total,
+	}
+
+	httputil.OkWithPage(w, &resp)
+}
+
+func (h *SysFileHandler) 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/sys_menu.go

@@ -0,0 +1,100 @@
+package handler
+
+import (
+	"net/http"
+	"server/internal/model/common"
+	"server/internal/model/request"
+	"server/internal/pkg/httputil"
+	"server/internal/service"
+)
+
+type SysMenuHandler struct {
+	menuService *service.SysMenuService
+}
+
+func NewSysMenuHandler(menuService *service.SysMenuService) *SysMenuHandler {
+	return &SysMenuHandler{menuService: menuService}
+}
+
+func (h *SysMenuHandler) ListPage(w http.ResponseWriter, r *http.Request) {
+	pagination := httputil.Pagination(r)
+
+	list, total, err := h.menuService.ListPage(r.Context(), pagination)
+	if err != nil {
+		httputil.Fail(w, err)
+		return
+	}
+
+	resp := common.PageResponse{
+		Page:     pagination.Page,
+		PageSize: pagination.PageSize,
+		List:     list,
+		Total:    total,
+	}
+
+	httputil.OkWithPage(w, &resp)
+}
+
+func (h *SysMenuHandler) GetMenus(w http.ResponseWriter, r *http.Request) {
+	list, err := h.menuService.GetMenus(r.Context())
+	if err != nil {
+		httputil.Fail(w, err)
+		return
+	}
+
+	httputil.Ok(w, list)
+}
+
+func (h *SysMenuHandler) Create(w http.ResponseWriter, r *http.Request) {
+	var req request.CreateSysMenuRequest
+
+	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 *SysMenuHandler) Update(w http.ResponseWriter, r *http.Request) {
+	var req request.UpdateSysMenuRequest
+
+	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 *SysMenuHandler) 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/sys_post.go

@@ -0,0 +1,108 @@
+package handler
+
+import (
+	"net/http"
+	"server/internal/model/common"
+	"server/internal/model/request"
+	"server/internal/pkg/httputil"
+	"server/internal/service"
+)
+
+type SysPostHandler struct {
+	sysPostService *service.SysPostService
+}
+
+func NewSysPostHandler(postService *service.SysPostService) *SysPostHandler {
+	return &SysPostHandler{sysPostService: postService}
+}
+
+func (h *SysPostHandler) ListPage(w http.ResponseWriter, r *http.Request) {
+	pagination := httputil.Pagination(r)
+
+	list, total, err := h.sysPostService.ListPage(r.Context(), pagination)
+	if err != nil {
+		httputil.Fail(w, err)
+	}
+
+	resp := common.PageResponse{
+		Page:     pagination.Page,
+		PageSize: pagination.PageSize,
+		List:     list,
+		Total:    total,
+	}
+
+	httputil.OkWithPage(w, &resp)
+}
+
+func (h *SysPostHandler) GetPostById(w http.ResponseWriter, r *http.Request) {
+	id, err := httputil.URLParamInt32(r, "id")
+	if err != nil {
+		httputil.Fail(w, err)
+		return
+	}
+
+	post, err := h.sysPostService.FindByID(r.Context(), id)
+	if err != nil {
+		httputil.Fail(w, err)
+		return
+	}
+
+	httputil.Ok(w, post)
+}
+
+func (h *SysPostHandler) 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.sysPostService.Create(r.Context(), req)
+
+	if err != nil {
+		httputil.Fail(w, err)
+		return
+	}
+
+	httputil.Ok(w, map[string]int32{
+		"post_id": postID,
+	})
+}
+
+func (h *SysPostHandler) 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.sysPostService.Update(r.Context(), id, req); err != nil {
+		httputil.Fail(w, err)
+		return
+	}
+
+	httputil.Ok(w)
+}
+
+func (h *SysPostHandler) Delete(w http.ResponseWriter, r *http.Request) {
+	id, err := httputil.URLParamInt32(r, "id")
+	if err != nil {
+		httputil.Fail(w, err)
+		return
+	}
+
+	if err = h.sysPostService.Delete(r.Context(), id); err != nil {
+		httputil.Fail(w, err)
+		return
+	}
+
+	httputil.Ok(w)
+}

internal/handler/sys_role.go

@@ -0,0 +1,177 @@
+package handler
+
+import (
+	"net/http"
+	"server/internal/model/common"
+	"server/internal/model/request"
+	"server/internal/pkg/httputil"
+	"server/internal/service"
+)
+
+type SysRoleHandler struct {
+	roleService *service.SysRoleService
+}
+
+func NewSysRoleHandler(roleService *service.SysRoleService) *SysRoleHandler {
+	return &SysRoleHandler{roleService: roleService}
+}
+
+func (h *SysRoleHandler) ListPage(w http.ResponseWriter, r *http.Request) {
+	pagination := httputil.Pagination(r)
+
+	list, total, err := h.roleService.ListPage(r.Context(), pagination)
+
+	if err != nil {
+		httputil.Fail(w, err)
+		return
+	}
+
+	resp := common.PageResponse{
+		Page:     pagination.Page,
+		PageSize: pagination.PageSize,
+		List:     list,
+		Total:    total,
+	}
+
+	httputil.OkWithPage(w, &resp)
+}
+
+func (h *SysRoleHandler) GetRoleMenus(w http.ResponseWriter, r *http.Request) {
+	id, err := httputil.URLParamInt32(r, "id")
+	if err != nil {
+		httputil.Fail(w, err)
+		return
+	}
+
+	list, err := h.roleService.GetRoleMenus(r.Context(), id)
+	if err != nil {
+		httputil.Fail(w, err)
+		return
+	}
+
+	httputil.Ok(w, list)
+}
+
+func (h *SysRoleHandler) GetRoleApis(w http.ResponseWriter, r *http.Request) {
+	id, err := httputil.URLParamInt32(r, "id")
+	if err != nil {
+		httputil.Fail(w, err)
+		return
+	}
+
+	list, err := h.roleService.GetRoleApis(r.Context(), id)
+	if err != nil {
+		httputil.Fail(w, err)
+		return
+	}
+
+	httputil.Ok(w, list)
+}
+
+func (h *SysRoleHandler) GetRoles(w http.ResponseWriter, r *http.Request) {
+	roles, err := h.roleService.GetRoles(r.Context())
+	if err != nil {
+		httputil.Fail(w, err)
+		return
+	}
+
+	httputil.Ok(w, roles)
+}
+
+func (h *SysRoleHandler) Create(w http.ResponseWriter, r *http.Request) {
+	var req request.CreateSysRoleRequest
+
+	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 *SysRoleHandler) Update(w http.ResponseWriter, r *http.Request) {
+	var req request.UpdateSysRoleRequest
+
+	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 *SysRoleHandler) SetRoleMenus(w http.ResponseWriter, r *http.Request) {
+	var req request.SetSysRoleMenusRequest
+
+	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 *SysRoleHandler) SetRoleApis(w http.ResponseWriter, r *http.Request) {
+	var req request.SetSysRoleApisRequest
+
+	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 *SysRoleHandler) 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/sys_user.go

@@ -0,0 +1,239 @@
+package handler
+
+import (
+	"net/http"
+	"server/internal/middleware"
+	"server/internal/model/common"
+	"server/internal/model/request"
+	"server/internal/pkg/errs"
+	"server/internal/pkg/httputil"
+	"server/internal/service"
+	"time"
+)
+
+type SysUserHandler struct {
+	userService *service.SysUserService
+}
+
+func NewSysUserHandler(userService *service.SysUserService) *SysUserHandler {
+	return &SysUserHandler{
+		userService: userService,
+	}
+}
+
+func (h *SysUserHandler) 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.userService.Login(r.Context(), req)
+	if err != nil {
+		httputil.Fail(w, err)
+		return
+	}
+
+	http.SetCookie(w, &http.Cookie{
+		Name:     "refresh_token",
+		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 *SysUserHandler) Logout(w http.ResponseWriter, r *http.Request) {
+	http.SetCookie(w, &http.Cookie{
+		Name:     "refresh_token",
+		Value:    "",
+		Path:     "/",
+		HttpOnly: true,
+		Secure:   true,
+		SameSite: http.SameSiteNoneMode,
+		MaxAge:   -1,
+		Expires:  time.Unix(0, 0),
+	})
+
+	httputil.Ok(w)
+}
+
+func (h *SysUserHandler) RefreshToken(w http.ResponseWriter, r *http.Request) {
+	cookie, err := r.Cookie("refresh_token")
+	if err != nil {
+		httputil.Fail(w, errs.ErrInvalidRefreshToken)
+		return
+	}
+
+	res, err := h.userService.RefreshToken(r.Context(), cookie.Value)
+	if err != nil {
+		httputil.Fail(w, err)
+		return
+	}
+
+	httputil.Ok(w, map[string]any{
+		"access_token":     res.AccessToken,
+		"access_token_exp": res.AccessTokenExp,
+	})
+}
+
+func (h *SysUserHandler) ListPage(w http.ResponseWriter, r *http.Request) {
+	pagination := httputil.Pagination(r)
+
+	list, total, err := h.userService.ListPage(r.Context(), pagination)
+	if err != nil {
+		httputil.Fail(w, err)
+		return
+	}
+
+	resp := common.PageResponse{
+		Page:     pagination.Page,
+		PageSize: pagination.PageSize,
+		List:     list,
+		Total:    total,
+	}
+
+	httputil.OkWithPage(w, &resp)
+}
+
+func (h *SysUserHandler) GetUserInfo(w http.ResponseWriter, r *http.Request) {
+	claims, ok := middleware.GetClaims(r.Context())
+
+	if !ok || claims.UserID == 0 {
+		httputil.Fail(w, errs.ErrUnauthorized)
+		return
+	}
+
+	isAdmin, _ := r.Context().Value(middleware.IsAdminKey).(bool)
+	uid := claims.UserID
+
+	user, err := h.userService.GetUserInfo(r.Context(), uid, isAdmin)
+	if err != nil {
+		httputil.Fail(w, err)
+		return
+	}
+
+	httputil.Ok(w, user)
+}
+
+func (h *SysUserHandler) GetRoles(w http.ResponseWriter, r *http.Request) {
+	id, err := httputil.URLParamInt32(r, "id")
+	if err != nil {
+		httputil.Fail(w, err)
+		return
+	}
+
+	list, err := h.userService.GetRoles(r.Context(), id)
+	if err != nil {
+		httputil.Fail(w, err)
+		return
+	}
+
+	httputil.Ok(w, list)
+}
+
+func (h *SysUserHandler) Create(w http.ResponseWriter, r *http.Request) {
+	var req request.CreateSysUserRequest
+
+	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 *SysUserHandler) Update(w http.ResponseWriter, r *http.Request) {
+	var req request.UpdateSysUserRequest
+
+	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 *SysUserHandler) SetRoles(w http.ResponseWriter, r *http.Request) {
+	var req request.SetSysUserRolesRequest
+
+	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 *SysUserHandler) UpdatePassword(w http.ResponseWriter, r *http.Request) {
+	var req request.UpdateSysUserPassword
+
+	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 *SysUserHandler) 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)
+}

internal/handler/web.go

@@ -0,0 +1,30 @@
+package handler
+
+import (
+	"net/http"
+	"server/internal/pkg/httputil"
+	"server/internal/utils"
+)
+
+type WebHandler struct {
+}
+
+func NewWebHandler() *WebHandler {
+	return &WebHandler{}
+}
+
+func (h *WebHandler) GetClientInfo(w http.ResponseWriter, r *http.Request) {
+	ip := utils.ClientIP(r)
+	userAgent := r.UserAgent()
+
+	httputil.Ok(w, map[string]any{
+		"ip":             ip,
+		"userAgent":      userAgent,
+		"method":         r.Method,
+		"host":           r.Host,
+		"path":           r.URL.Path,
+		"origin":         r.Header.Get("Origin"),
+		"accept":         r.Header.Get("Accept"),
+		"acceptLanguage": r.Header.Get("Accept-Language"),
+	})
+}