gorm wire

internal/erpserver/handler/system/audit.go

@@ -3,28 +3,29 @@ package system
 import (
 	"net/http"
 
+	"management/internal/erpserver/handler"
 	"management/internal/erpserver/model/dto"
 	v1 "management/internal/erpserver/service/v1"
 	"management/internal/pkg/convertor"
-	"management/internal/pkg/tpl"
+	"management/internal/pkg/render"
 )
 
-type auditHandler struct {
-	render tpl.Renderer
-	svc    v1.AuditLogService
+type AuditHandler struct {
+	*handler.Handler
+	auditLogService v1.AuditLogService
 }
 
-func NewAuditHandler(render tpl.Renderer, svc v1.AuditLogService) *auditHandler {
-	return &auditHandler{
-		render: render,
-		svc:    svc,
+func NewAuditHandler(handler *handler.Handler, auditLogService v1.AuditLogService) *AuditHandler {
+	return &AuditHandler{
+		Handler:         handler,
+		auditLogService: auditLogService,
 	}
 }
 
-func (h *auditHandler) List(w http.ResponseWriter, r *http.Request) {
+func (h *AuditHandler) List(w http.ResponseWriter, r *http.Request) {
 	switch r.Method {
 	case http.MethodGet:
-		h.render.HTML(w, r, "audit_log/list.tmpl", nil)
+		h.HTML(w, r, "audit_log/list.tmpl", nil)
 	case http.MethodPost:
 		var q dto.SearchDto
 		q.SearchTimeBegin, q.SearchTimeEnd = convertor.DefaultStartTimeAndEndTime(r.PostFormValue("timeBegin"), r.PostFormValue("timeEnd"))
@@ -32,19 +33,19 @@ func (h *auditHandler) List(w http.ResponseWriter, r *http.Request) {
 		q.SearchEmail = r.PostFormValue("email")
 		q.Page = convertor.ConvertInt(r.PostFormValue("page"), 1)
 		q.Rows = convertor.ConvertInt(r.PostFormValue("rows"), 10)
-		res, count, err := h.svc.List(r.Context(), q)
+		res, count, err := h.auditLogService.List(r.Context(), q)
 		if err != nil {
-			http.Error(w, err.Error(), http.StatusInternalServerError)
+			h.JSONErr(w, err.Error())
 			return
 		}
 
-		data := tpl.ResponseList{
+		data := render.ResponseList{
 			Code:    0,
 			Message: "ok",
 			Count:   count,
 			Data:    res,
 		}
-		h.render.JSON(w, data)
+		h.JSON(w, data)
 	default:
 		http.Error(w, "Method Not Allowed", http.StatusMethodNotAllowed)
 	}

internal/erpserver/handler/system/config.go

@@ -1,171 +1,163 @@
 package system
 
 import (
+	"encoding/json"
 	"net/http"
 	"strings"
 
+	"management/internal/erpserver/handler"
 	"management/internal/erpserver/model/dto"
-	systemmodel "management/internal/erpserver/model/system"
-	systemsvc "management/internal/erpserver/service/v1"
+	systemModel "management/internal/erpserver/model/system"
+	systemService "management/internal/erpserver/service/v1"
 	"management/internal/pkg/convertor"
 	"management/internal/pkg/database"
-	"management/internal/pkg/redis"
-	"management/internal/pkg/tpl"
+	"management/internal/pkg/render"
 )
 
-type configHandler struct {
-	render    tpl.Renderer
-	redis     redis.RedisCache
-	configsvc systemsvc.ConfigService
+type ConfigHandler struct {
+	*handler.Handler
+	configService systemService.ConfigService
 }
 
-func NewConfigHandler(render tpl.Renderer, redis redis.RedisCache, configsvc systemsvc.ConfigService) *configHandler {
-	return &configHandler{
-		render:    render,
-		redis:     redis,
-		configsvc: configsvc,
+func NewConfigHandler(handler *handler.Handler, configService systemService.ConfigService) *ConfigHandler {
+	return &ConfigHandler{
+		Handler:       handler,
+		configService: configService,
 	}
 }
 
-func (h *configHandler) Add(w http.ResponseWriter, r *http.Request) {
-	h.render.HTML(w, r, "config/edit.tmpl", map[string]any{
-		"Item":   &systemmodel.Config{},
-		"Result": "",
-	})
-}
-
-type EditSysConfig struct {
-	*systemmodel.Config
-	Result string
-}
-
-func (h *configHandler) Edit(w http.ResponseWriter, r *http.Request) {
-	vars := r.URL.Query()
-	id := convertor.QueryInt[int32](vars, "id", 0)
-	vm := &EditSysConfig{}
-	if id > 0 {
-		if conf, err := h.configsvc.Get(r.Context(), id); err == nil {
-			vm.Config = conf
-			vm.Result = string(conf.Value)
-		}
-	}
-	h.render.HTML(w, r, "config/edit.tmpl", map[string]any{
-		"Item":   vm.Config,
-		"Result": vm.Result,
-	})
-}
-
-func (h *configHandler) Save(w http.ResponseWriter, r *http.Request) {
-	id := convertor.ConvertInt[int32](r.PostFormValue("ID"), 0)
-	key := r.PostFormValue("Key")
-	value := r.PostFormValue("Value")
-	if len(key) == 0 {
-		h.render.JSONERR(w, "Key不能为空")
-		return
-	}
-	if len(value) == 0 {
-		h.render.JSONERR(w, "Value不能为空")
-		return
-	}
-
-	ctx := r.Context()
-	if id == 0 {
-		arg := &systemmodel.Config{
-			Key:   key,
-			Value: []byte(value),
-		}
-		err := h.configsvc.Create(ctx, arg)
-		if err != nil {
-			if database.IsUniqueViolation(err) {
-				h.render.JSONERR(w, "数据已存在")
-				return
-			}
-			h.render.JSONERR(w, err.Error())
-			return
-		}
-
-		h.render.JSONOK(w, "添加成功")
-	} else {
-		res, err := h.configsvc.Get(ctx, id)
-		if err != nil {
-			h.render.JSONERR(w, err.Error())
-			return
-		}
-
-		res.Value = []byte(value)
-		err = h.configsvc.Update(ctx, res)
-		if err != nil {
-			h.render.JSONERR(w, err.Error())
-			return
-		}
-
-		h.render.JSONOK(w, "更新成功")
-	}
-}
-
-func (h *configHandler) List(w http.ResponseWriter, r *http.Request) {
+func (h *ConfigHandler) List(w http.ResponseWriter, r *http.Request) {
 	switch r.Method {
 	case http.MethodGet:
-		h.render.HTML(w, r, "config/list.tmpl", nil)
+		h.HTML(w, r, "config/list.tmpl", nil)
 	case http.MethodPost:
 		var q dto.SearchDto
+		q.SearchTimeBegin, q.SearchTimeEnd = convertor.DefaultStartTimeAndEndTime(r.PostFormValue("timeBegin"), r.PostFormValue("timeEnd"))
 		q.SearchName = r.PostFormValue("name")
 		q.Page = convertor.ConvertInt(r.PostFormValue("page"), 1)
 		q.Rows = convertor.ConvertInt(r.PostFormValue("rows"), 10)
 		ctx := r.Context()
-		res, count, err := h.configsvc.List(ctx, q)
+		res, count, err := h.configService.List(ctx, q)
 		if err != nil {
-			h.render.JSONERR(w, err.Error())
+			h.JSONErr(w, err.Error())
 			return
 		}
 
-		data := tpl.ResponseList{
+		data := render.ResponseList{
 			Code:    0,
 			Message: "ok",
 			Count:   count,
 			Data:    res,
 		}
-		h.render.JSON(w, data)
+		h.JSON(w, data)
 	default:
 		http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
 	}
 }
 
-func (h *configHandler) Refresh(w http.ResponseWriter, r *http.Request) {
-	key := r.FormValue("key")
-	err := h.redis.Del(r.Context(), strings.ToLower(key))
-	if err != nil {
-		h.render.JSONERR(w, err.Error())
+func (h *ConfigHandler) Add(w http.ResponseWriter, r *http.Request) {
+	h.HTML(w, r, "config/edit.tmpl", map[string]any{
+		"Item":   &systemModel.Config{},
+		"Result": "",
+	})
+}
+
+type EditSysConfig struct {
+	*systemModel.Config
+	Result string
+}
+
+func (h *ConfigHandler) Edit(w http.ResponseWriter, r *http.Request) {
+	vars := r.URL.Query()
+	id := convertor.QueryInt[int32](vars, "id", 0)
+	vm := &EditSysConfig{}
+	if id > 0 {
+		if conf, err := h.configService.Get(r.Context(), id); err == nil {
+			vm.Config = conf
+			b, _ := json.Marshal(&conf.Value)
+			vm.Result = string(b)
+		}
+	}
+	h.HTML(w, r, "config/edit.tmpl", map[string]any{
+		"Item":   vm.Config,
+		"Result": vm.Result,
+	})
+}
+
+func (h *ConfigHandler) Save(w http.ResponseWriter, r *http.Request) {
+	id := convertor.ConvertInt[int32](r.PostFormValue("ID"), 0)
+	key := r.PostFormValue("Key")
+	value := r.PostFormValue("Value")
+	if len(key) == 0 {
+		h.JSONErr(w, "Key不能为空")
+		return
+	}
+	if len(value) == 0 {
+		h.JSONErr(w, "Value不能为空")
 		return
 	}
 
-	h.render.JSONOK(w, "刷新成功")
+	ctx := r.Context()
+	if id == 0 {
+		arg := &systemModel.Config{
+			Key:   key,
+			Value: value,
+		}
+		err := h.configService.Create(ctx, arg)
+		if err != nil {
+			if database.IsUniqueViolation(err) {
+				h.JSONErr(w, "数据已存在")
+				return
+			}
+			h.JSONErr(w, err.Error())
+			return
+		}
+
+		h.JSONOk(w, "添加成功")
+	} else {
+		res, err := h.configService.Get(ctx, id)
+		if err != nil {
+			h.JSONErr(w, err.Error())
+			return
+		}
+
+		res.Value = value
+		err = h.configService.Update(ctx, res)
+		if err != nil {
+			h.JSONErr(w, err.Error())
+			return
+		}
+
+		h.JSONOk(w, "更新成功")
+	}
 }
 
-func (h *configHandler) ResetPear(w http.ResponseWriter, r *http.Request) {
-	// b, err := json.Marshal(pearadmin.PearJson)
-	// if err != nil {
-	// 	h.render.JSONERR(w, err.Error())
-	// 	return
-	// }
+func (h *ConfigHandler) RefreshCache(w http.ResponseWriter, r *http.Request) {
+	key := r.FormValue("key")
+	err := h.configService.RefreshCache(r.Context(), strings.ToLower(key))
+	if err != nil {
+		h.JSONErr(w, err.Error())
+		return
+	}
 
-	// err = h.configsvc.Update(r.Context(), &db.UpdateSysConfigByKeyParams{
-	// 	Key:   pearadmin.PearKey,
-	// 	Value: b,
-	// })
-	// if err != nil {
-	// 	h.render.JSONERR(w, err.Error())
-	// 	return
-	// }
-	h.render.JSONOK(w, "重置成功")
+	h.JSONOk(w, "刷新成功")
 }
 
-func (h *configHandler) Pear(w http.ResponseWriter, r *http.Request) {
-	pear, err := h.configsvc.Pear(r.Context())
+func (h *ConfigHandler) ResetPear(w http.ResponseWriter, r *http.Request) {
+	err := h.configService.ResetPear(r.Context())
+	if err != nil {
+		h.JSONErr(w, err.Error())
+		return
+	}
+	h.JSONOk(w, "重置成功")
+}
+
+func (h *ConfigHandler) Pear(w http.ResponseWriter, r *http.Request) {
+	pear, err := h.configService.Pear(r.Context())
 	if err != nil {
 		http.Error(w, err.Error(), http.StatusInternalServerError)
 		return
 	}
 
-	h.render.JSON(w, pear)
+	h.JSON(w, pear)
 }

internal/erpserver/handler/system/department.go

@@ -3,31 +3,32 @@ package system
 import (
 	"net/http"
 
+	"management/internal/erpserver/handler"
 	"management/internal/erpserver/model/dto"
 	"management/internal/erpserver/model/form"
 	systemmodel "management/internal/erpserver/model/system"
 	v1 "management/internal/erpserver/service/v1"
 	"management/internal/pkg/binding"
 	"management/internal/pkg/convertor"
-	"management/internal/pkg/tpl"
+	"management/internal/pkg/render"
 )
 
-type departmentHandler struct {
-	render tpl.Renderer
-	svc    v1.DepartmentService
+type DepartmentHandler struct {
+	*handler.Handler
+	departmentService v1.DepartmentService
 }
 
-func NewDepartmentHandler(render tpl.Renderer, svc v1.DepartmentService) *departmentHandler {
-	return &departmentHandler{
-		render: render,
-		svc:    svc,
+func NewDepartmentHandler(handler *handler.Handler, departmentService v1.DepartmentService) *DepartmentHandler {
+	return &DepartmentHandler{
+		Handler:           handler,
+		departmentService: departmentService,
 	}
 }
 
-func (h *departmentHandler) List(w http.ResponseWriter, r *http.Request) {
+func (h *DepartmentHandler) List(w http.ResponseWriter, r *http.Request) {
 	switch r.Method {
 	case http.MethodGet:
-		h.render.HTML(w, r, "department/list.tmpl", nil)
+		h.HTML(w, r, "department/list.tmpl", nil)
 	case http.MethodPost:
 		var q dto.SearchDto
 		q.SearchTimeBegin, q.SearchTimeEnd = convertor.DefaultStartTimeAndEndTime(r.PostFormValue("timeBegin"), r.PostFormValue("timeEnd"))
@@ -37,117 +38,117 @@ func (h *departmentHandler) List(w http.ResponseWriter, r *http.Request) {
 		q.SearchID = convertor.ConvertInt[int64](r.PostFormValue("id"), 0)
 		q.Page = convertor.ConvertInt(r.PostFormValue("page"), 1)
 		q.Rows = convertor.ConvertInt(r.PostFormValue("rows"), 10)
-		res, count, err := h.svc.List(r.Context(), q)
+		res, count, err := h.departmentService.List(r.Context(), q)
 		if err != nil {
-			http.Error(w, err.Error(), http.StatusInternalServerError)
+			h.JSONErr(w, err.Error())
 			return
 		}
 
-		data := tpl.ResponseList{
+		data := render.ResponseList{
 			Code:    0,
 			Message: "ok",
 			Count:   count,
 			Data:    res,
 		}
-		h.render.JSON(w, data)
+		h.JSON(w, data)
 	default:
 		http.Error(w, "Method Not Allowed", http.StatusMethodNotAllowed)
 	}
 }
 
-func (h *departmentHandler) Add(w http.ResponseWriter, r *http.Request) {
-	h.render.HTML(w, r, "department/edit.tmpl", map[string]any{
+func (h *DepartmentHandler) Add(w http.ResponseWriter, r *http.Request) {
+	h.HTML(w, r, "department/edit.tmpl", map[string]any{
 		"Item": &systemmodel.Department{Sort: 6666},
 	})
 }
 
-func (h *departmentHandler) AddChildren(w http.ResponseWriter, r *http.Request) {
+func (h *DepartmentHandler) AddChildren(w http.ResponseWriter, r *http.Request) {
 	vars := r.URL.Query()
-	parentID := convertor.QueryInt(vars, "parentID", 0)
-	vm := &systemmodel.Department{ParentID: int32(parentID), Sort: 6666}
-	h.render.HTML(w, r, "department/edit.tmpl", map[string]any{
+	parentID := convertor.QueryInt[int32](vars, "parentID", 0)
+	vm := &systemmodel.Department{ParentID: parentID, Sort: 6666}
+	h.HTML(w, r, "department/edit.tmpl", map[string]any{
 		"Item": vm,
 	})
 }
 
-func (h *departmentHandler) Edit(w http.ResponseWriter, r *http.Request) {
+func (h *DepartmentHandler) Edit(w http.ResponseWriter, r *http.Request) {
 	vars := r.URL.Query()
 	id := convertor.QueryInt[int32](vars, "id", 0)
 	vm := &systemmodel.Department{Sort: 6666}
 	if id > 0 {
-		vm, _ = h.svc.Get(r.Context(), id)
+		vm, _ = h.departmentService.Get(r.Context(), id)
 	}
-	h.render.HTML(w, r, "department/edit.tmpl", map[string]any{
+	h.HTML(w, r, "department/edit.tmpl", map[string]any{
 		"Item": vm,
 	})
 }
 
-func (h *departmentHandler) Save(w http.ResponseWriter, r *http.Request) {
+func (h *DepartmentHandler) Save(w http.ResponseWriter, r *http.Request) {
 	var req form.Department
 	if err := binding.Form.Bind(r, &req); err != nil {
-		h.render.JSONERR(w, binding.ValidatorErrors(err))
+		h.JSONErr(w, binding.ValidatorErrors(err))
 		return
 	}
 
 	ctx := r.Context()
 	if *req.ID == 0 {
-		err := h.svc.Create(ctx, &req)
+		err := h.departmentService.Create(ctx, &req)
 		if err != nil {
-			h.render.JSONERR(w, err.Error())
+			h.JSONErr(w, err.Error())
 			return
 		}
-		h.render.JSONOK(w, "添加成功")
+		h.JSONOk(w, "添加成功")
 	} else {
-		err := h.svc.Update(ctx, &req)
+		err := h.departmentService.Update(ctx, &req)
 		if err != nil {
-			h.render.JSONERR(w, err.Error())
+			h.JSONErr(w, err.Error())
 			return
 		}
 
-		h.render.JSONOK(w, "更新成功")
+		h.JSONOk(w, "更新成功")
 	}
 }
 
-func (h *departmentHandler) Data(w http.ResponseWriter, r *http.Request) {
+func (h *DepartmentHandler) Data(w http.ResponseWriter, r *http.Request) {
 	ctx := r.Context()
 	vars := r.URL.Query()
 	t := vars.Get("type")
 	if t == "tree" {
-		res, err := h.svc.Tree(ctx, 0)
+		res, err := h.departmentService.Tree(ctx, 0)
 		if err != nil {
-			h.render.JSONERR(w, err.Error())
+			h.JSONErr(w, err.Error())
 			return
 		}
 
-		h.render.JSON(w, res)
-	} else if t == "xmselect_tree" {
-		res, err := h.svc.XmSelectTree(ctx, 0)
+		h.JSON(w, res)
+	} else if t == "xm_select_tree" {
+		res, err := h.departmentService.XmSelectTree(ctx, 0)
 		if err != nil {
-			h.render.JSONERR(w, err.Error())
+			h.JSONErr(w, err.Error())
 			return
 		}
 
-		h.render.JSON(w, res)
+		h.JSON(w, res)
 	}
 }
 
-func (h *departmentHandler) RefreshCache(w http.ResponseWriter, r *http.Request) {
-	err := h.svc.RefreshCache(r.Context())
+func (h *DepartmentHandler) RefreshCache(w http.ResponseWriter, r *http.Request) {
+	err := h.departmentService.RefreshCache(r.Context())
 	if err != nil {
-		h.render.JSONERR(w, err.Error())
+		h.JSONErr(w, err.Error())
 		return
 	}
 
-	h.render.JSONOK(w, "缓存刷新成功")
+	h.JSONOk(w, "缓存刷新成功")
 }
 
-func (h *departmentHandler) RebuildParentPath(w http.ResponseWriter, r *http.Request) {
+func (h *DepartmentHandler) RebuildParentPath(w http.ResponseWriter, r *http.Request) {
 	ctx := r.Context()
-	err := h.svc.RebuildParentPath(ctx)
+	err := h.departmentService.RebuildParentPath(ctx)
 	if err != nil {
-		h.render.JSONERR(w, err.Error())
+		h.JSONErr(w, err.Error())
 		return
 	}
 
-	h.render.JSONOK(w, "重建成功")
+	h.JSONOk(w, "重建成功")
 }

internal/erpserver/handler/system/home.go

@@ -3,38 +3,39 @@ package system
 import (
 	"net/http"
 
+	"management/internal/erpserver/handler"
 	v1 "management/internal/erpserver/service/v1"
-	"management/internal/pkg/middleware"
-	"management/internal/pkg/tpl"
 )
 
-type homeHandler struct {
-	render      tpl.Renderer
-	mi          middleware.Middleware
-	usersvc     v1.UserService
-	loginLogsvc v1.LoginLogService
+type HomeHandler struct {
+	*handler.Handler
+	userService     v1.UserService
+	loginLogService v1.LoginLogService
 }
 
-func NewHomeHandler(render tpl.Renderer, mi middleware.Middleware, usersvc v1.UserService, loginLogsvc v1.LoginLogService) *homeHandler {
-	return &homeHandler{
-		render:      render,
-		mi:          mi,
-		usersvc:     usersvc,
-		loginLogsvc: loginLogsvc,
+func NewHomeHandler(
+	handler *handler.Handler,
+	userService v1.UserService,
+	loginLogService v1.LoginLogService,
+) *HomeHandler {
+	return &HomeHandler{
+		Handler:         handler,
+		userService:     userService,
+		loginLogService: loginLogService,
 	}
 }
 
-func (h *homeHandler) Home(w http.ResponseWriter, r *http.Request) {
-	h.render.HTML(w, r, "home/home.tmpl", nil)
+func (h *HomeHandler) Home(w http.ResponseWriter, r *http.Request) {
+	h.HTML(w, r, "home/home.tmpl", nil)
 }
 
-func (h *homeHandler) Dashboard(w http.ResponseWriter, r *http.Request) {
+func (h *HomeHandler) Dashboard(w http.ResponseWriter, r *http.Request) {
 	ctx := r.Context()
-	auth := h.mi.AuthUser(ctx)
-	user, _ := h.usersvc.Get(ctx, auth.ID)
-	t := h.loginLogsvc.LoginLatestTime(ctx, auth.Email)
-	c := h.loginLogsvc.LoginCount(ctx, auth.Email)
-	h.render.HTML(w, r, "home/dashboard.tmpl", map[string]any{
+	auth := h.AuthUser(ctx)
+	user, _ := h.userService.Get(ctx, auth.ID)
+	t := h.loginLogService.LoginLatestTime(ctx, auth.Email)
+	c := h.loginLogService.LoginCount(ctx, auth.Email)
+	h.HTML(w, r, "home/dashboard.tmpl", map[string]any{
 		"Auth":          auth,
 		"User":          user,
 		"LastLoginTime": t,

internal/erpserver/handler/system/login_log.go

@@ -3,47 +3,48 @@ package system
 import (
 	"net/http"
 
+	"management/internal/erpserver/handler"
 	"management/internal/erpserver/model/dto"
 	v1 "management/internal/erpserver/service/v1"
 	"management/internal/pkg/convertor"
-	"management/internal/pkg/tpl"
+	"management/internal/pkg/render"
 )
 
-type loginLogHandler struct {
-	render tpl.Renderer
-	svc    v1.LoginLogService
+type LoginLogHandler struct {
+	*handler.Handler
+	loginLogService v1.LoginLogService
 }
 
-func NewLoginLogHandler(render tpl.Renderer, svc v1.LoginLogService) *loginLogHandler {
-	return &loginLogHandler{
-		render: render,
-		svc:    svc,
+func NewLoginLogHandler(handler *handler.Handler, loginLogService v1.LoginLogService) *LoginLogHandler {
+	return &LoginLogHandler{
+		Handler:         handler,
+		loginLogService: loginLogService,
 	}
 }
 
-func (h *loginLogHandler) List(w http.ResponseWriter, r *http.Request) {
+func (h *LoginLogHandler) List(w http.ResponseWriter, r *http.Request) {
 	switch r.Method {
 	case http.MethodGet:
-		h.render.HTML(w, r, "login_log/list.tmpl", nil)
+		h.HTML(w, r, "login_log/list.tmpl", nil)
 	case http.MethodPost:
 		var q dto.SearchDto
 		q.SearchTimeBegin, q.SearchTimeEnd = convertor.DefaultStartTimeAndEndTime(r.PostFormValue("timeBegin"), r.PostFormValue("timeEnd"))
 		q.SearchEmail = r.PostFormValue("email")
 		q.Page = convertor.ConvertInt(r.PostFormValue("page"), 1)
 		q.Rows = convertor.ConvertInt(r.PostFormValue("rows"), 10)
-		res, count, err := h.svc.List(r.Context(), q)
+		res, count, err := h.loginLogService.List(r.Context(), q)
 		if err != nil {
-			http.Error(w, err.Error(), http.StatusInternalServerError)
+			h.JSONErr(w, err.Error())
 			return
 		}
 
-		data := tpl.ResponseList{
+		data := render.ResponseList{
 			Code:    0,
 			Message: "ok",
 			Count:   count,
 			Data:    res,
 		}
-		h.render.JSON(w, data)
+		h.JSON(w, data)
 	default:
 		http.Error(w, "Method Not Allowed", http.StatusMethodNotAllowed)
 	}

internal/erpserver/handler/system/menu.go

@@ -6,79 +6,76 @@ import (
 	"strings"
 	"time"
 
+	"management/internal/erpserver/handler"
 	systemmodel "management/internal/erpserver/model/system"
 	v1 "management/internal/erpserver/service/v1"
 	"management/internal/pkg/convertor"
 	"management/internal/pkg/database"
-	"management/internal/pkg/middleware"
-	"management/internal/pkg/tpl"
+	"management/internal/pkg/render"
 
 	"github.com/google/uuid"
 )
 
 const style = "layui-btn-primary layui-btn-sm"
 
-type menuHandler struct {
-	render tpl.Renderer
-	mi     middleware.Middleware
-
-	svc v1.MenuService
+type MenuHandler struct {
+	*handler.Handler
+	menuService v1.MenuService
 }
 
-func NewMenuHandler(render tpl.Renderer, mi middleware.Middleware, svc v1.MenuService) *menuHandler {
-	return &menuHandler{
-		render: render,
-		mi:     mi,
-		svc:    svc,
+func NewMenuHandler(handler *handler.Handler, menuService v1.MenuService) *MenuHandler {
+	return &MenuHandler{
+		Handler:     handler,
+		menuService: menuService,
 	}
 }
 
-func (h *menuHandler) Menus(w http.ResponseWriter, r *http.Request) {
+func (h *MenuHandler) Menus(w http.ResponseWriter, r *http.Request) {
 	ctx := r.Context()
-	user := h.mi.AuthUser(ctx)
-	menus, err := h.svc.OwerMenus(ctx, user.RoleID)
+	user := h.AuthUser(ctx)
+	menus, err := h.menuService.OwerMenus(ctx, user.RoleID)
 	if err != nil {
-		h.render.JSONERR(w, err.Error())
+		h.JSONErr(w, err.Error())
 		return
 	}
 
-	h.render.JSON(w, menus)
+	h.JSON(w, menus)
 }
 
-func (h *menuHandler) List(w http.ResponseWriter, r *http.Request) {
+func (h *MenuHandler) List(w http.ResponseWriter, r *http.Request) {
 	switch r.Method {
 	case http.MethodGet:
-		h.render.HTML(w, r, "menu/list.tmpl", nil)
+		h.HTML(w, r, "menu/list.tmpl", nil)
 	case http.MethodPost:
-		res, err := h.svc.ListMenuTree(r.Context())
+		res, err := h.menuService.ListMenuTree(r.Context())
 		if err != nil {
-			h.render.JSONERR(w, err.Error())
+			h.JSONErr(w, err.Error())
 			return
 		}
 
-		data := tpl.ResponseList{
+		data := render.ResponseList{
 			Code:    0,
 			Message: "ok",
 			Count:   0,
 			Data:    res,
 		}
-		h.render.JSON(w, data)
+		h.JSON(w, data)
 	default:
-		h.render.JSONERR(w, "method not allowed")
+		h.JSONErr(w, "method not allowed")
 	}
 }
 
-func (h *menuHandler) Add(w http.ResponseWriter, r *http.Request) {
-	h.render.HTML(w, r, "menu/edit.tmpl", map[string]any{
+func (h *MenuHandler) Add(w http.ResponseWriter, r *http.Request) {
+	h.HTML(w, r, "menu/edit.tmpl", map[string]any{
 		"Item": &systemmodel.Menu{Style: style, Visible: true, Sort: 6666},
 	})
 }
 
-func (h *menuHandler) AddChildren(w http.ResponseWriter, r *http.Request) {
+func (h *MenuHandler) AddChildren(w http.ResponseWriter, r *http.Request) {
 	vars := r.URL.Query()
 	parentID := convertor.QueryInt[int32](vars, "parentID", 0)
-	vm := &systemmodel.Menu{ParentID: int32(parentID), Style: style, Visible: true, Sort: 6666}
-	parent, err := h.svc.Get(r.Context(), parentID)
+	vm := &systemmodel.Menu{ParentID: parentID, Style: style, Visible: true, Sort: 6666}
+	parent, err := h.menuService.Get(r.Context(), parentID)
 	if err == nil {
 		if parent.Type == "node" {
 			vm.Type = "menu"
@@ -86,27 +83,27 @@ func (h *menuHandler) AddChildren(w http.ResponseWriter, r *http.Request) {
 			vm.Type = "btn"
 		}
 	}
-	h.render.HTML(w, r, "menu/edit.tmpl", map[string]any{
+	h.HTML(w, r, "menu/edit.tmpl", map[string]any{
 		"Item": vm,
 	})
 }
 
-func (h *menuHandler) Edit(w http.ResponseWriter, r *http.Request) {
+func (h *MenuHandler) Edit(w http.ResponseWriter, r *http.Request) {
 	vars := r.URL.Query()
 	id := convertor.QueryInt[int32](vars, "id", 0)
 	vm := &systemmodel.Menu{Style: style, Sort: 6666}
 	if id > 0 {
-		vm, _ = h.svc.Get(r.Context(), id)
+		vm, _ = h.menuService.Get(r.Context(), id)
 	}
-	h.render.HTML(w, r, "menu/edit.tmpl", map[string]any{
+	h.HTML(w, r, "menu/edit.tmpl", map[string]any{
 		"Item": vm,
 	})
 }
 
-func (h *menuHandler) Save(w http.ResponseWriter, r *http.Request) {
+func (h *MenuHandler) Save(w http.ResponseWriter, r *http.Request) {
 	id := convertor.ConvertInt[int32](r.PostFormValue("ID"), 0)
 	name := r.PostFormValue("Name")
-	dispalyName := r.PostFormValue("DisplayName")
+	displayName := r.PostFormValue("DisplayName")
 	t := r.PostFormValue("Type")
 	url := r.PostFormValue("Url")
 	if len(url) == 0 {
@@ -127,9 +124,9 @@ func (h *menuHandler) Save(w http.ResponseWriter, r *http.Request) {
 
 	parentPath := ""
 	if parentID > 0 {
-		parent, err := h.svc.Get(ctx, parentID)
+		parent, err := h.menuService.Get(ctx, parentID)
 		if err != nil {
-			h.render.JSONERR(w, err.Error())
+			h.JSONErr(w, err.Error())
 			return
 		}
 		parentPath = parent.ParentPath + "," + strconv.Itoa(int(parentID)) + ","
@@ -139,10 +136,10 @@ func (h *menuHandler) Save(w http.ResponseWriter, r *http.Request) {
 	if id == 0 {
 		arg := &systemmodel.Menu{
 			Name:        name,
-			DisplayName: dispalyName,
+			DisplayName: displayName,
 			Url:         url,
 			Type:        t,
-			ParentID:    int32(parentID),
+			ParentID:    parentID,
 			ParentPath:  parentPath,
 			Avatar:      avatar,
 			Style:       style,
@@ -153,26 +150,26 @@ func (h *menuHandler) Save(w http.ResponseWriter, r *http.Request) {
 			CreatedAt:   time.Now(),
 			UpdatedAt:   time.Now(),
 		}
-		err := h.svc.Create(ctx, arg)
+		err := h.menuService.Create(ctx, arg)
 		if err != nil {
 			if database.IsUniqueViolation(err) {
-				h.render.JSONERR(w, "菜单已存在")
+				h.JSONErr(w, "菜单已存在")
 				return
 			}
-			h.render.JSONERR(w, err.Error())
+			h.JSONErr(w, err.Error())
 			return
 		}
 
-		h.render.JSONOK(w, "添加成功")
+		h.JSONOk(w, "添加成功")
 	} else {
-		res, err := h.svc.Get(ctx, id)
+		res, err := h.menuService.Get(ctx, id)
 		if err != nil {
-			h.render.JSONERR(w, err.Error())
+			h.JSONErr(w, err.Error())
 			return
 		}
 
 		res.Name = name
-		res.DisplayName = dispalyName
+		res.DisplayName = displayName
 		res.Url = url
 		res.Type = t
 		res.ParentID = parentID
@@ -184,48 +181,48 @@ func (h *menuHandler) Save(w http.ResponseWriter, r *http.Request) {
 		res.Status = status
 		res.Sort = sort
 		res.UpdatedAt = time.Now()
-		err = h.svc.Update(ctx, res)
+		err = h.menuService.Update(ctx, res)
 		if err != nil {
-			h.render.JSONERR(w, err.Error())
+			h.JSONErr(w, err.Error())
 			return
 		}
 
-		h.render.JSONOK(w, "更新成功")
+		h.JSONOk(w, "更新成功")
 	}
 }
 
-func (h *menuHandler) Data(w http.ResponseWriter, r *http.Request) {
+func (h *MenuHandler) Data(w http.ResponseWriter, r *http.Request) {
 	ctx := r.Context()
 	vars := r.URL.Query()
 	t := vars.Get("type")
 	if t == "tree" {
-		res, err := h.svc.Tree(ctx, 0)
+		res, err := h.menuService.Tree(ctx, 0)
 		if err != nil {
-			h.render.JSONERR(w, err.Error())
+			h.JSONErr(w, err.Error())
 			return
 		}
 
-		h.render.JSON(w, res)
+		h.JSON(w, res)
 		return
-	} else if t == "xmselect_tree" {
-		res, err := h.svc.XmSelectTree(ctx, 0)
+	} else if t == "xm_select_tree" {
+		res, err := h.menuService.XmSelectTree(ctx, 0)
 		if err != nil {
-			h.render.JSONERR(w, err.Error())
+			h.JSONErr(w, err.Error())
 			return
 		}
 
-		h.render.JSON(w, res)
+		h.JSON(w, res)
 		return
 	}
-	h.render.JSON(w, nil)
+	h.JSON(w, nil)
 }
 
-func (h *menuHandler) RefreshCache(w http.ResponseWriter, r *http.Request) {
-	err := h.svc.RefreshCache(r.Context())
+func (h *MenuHandler) RefreshCache(w http.ResponseWriter, r *http.Request) {
+	err := h.menuService.RefreshCache(r.Context())
 	if err != nil {
-		h.render.JSONERR(w, err.Error())
+		h.JSONErr(w, err.Error())
 		return
 	}
 
-	h.render.JSONOK(w, "缓存刷新成功")
+	h.JSONOk(w, "缓存刷新成功")
 }

internal/erpserver/handler/system/role.go

@@ -4,33 +4,34 @@ import (
 	"net/http"
 	"strings"
 
+	"management/internal/erpserver/handler"
 	"management/internal/erpserver/model/dto"
 	"management/internal/erpserver/model/form"
 	"management/internal/erpserver/model/system"
 	v1 "management/internal/erpserver/service/v1"
 	"management/internal/pkg/binding"
 	"management/internal/pkg/convertor"
-	"management/internal/pkg/tpl"
+	"management/internal/pkg/render"
 )
 
-type roleHandler struct {
-	render  tpl.Renderer
-	svc     v1.RoleService
-	menusvc v1.MenuService
+type RoleHandler struct {
+	*handler.Handler
+	roleService v1.RoleService
+	menuService v1.MenuService
 }
 
-func NewRoleHandler(render tpl.Renderer, svc v1.RoleService, menusvc v1.MenuService) *roleHandler {
-	return &roleHandler{
-		render:  render,
-		svc:     svc,
-		menusvc: menusvc,
+func NewRoleHandler(handler *handler.Handler, roleService v1.RoleService, menuService v1.MenuService) *RoleHandler {
+	return &RoleHandler{
+		Handler:     handler,
+		roleService: roleService,
+		menuService: menuService,
 	}
 }
 
-func (h *roleHandler) List(w http.ResponseWriter, r *http.Request) {
+func (h *RoleHandler) List(w http.ResponseWriter, r *http.Request) {
 	switch r.Method {
 	case http.MethodGet:
-		h.render.HTML(w, r, "role/list.tmpl", nil)
+		h.HTML(w, r, "role/list.tmpl", nil)
 	case http.MethodPost:
 		var q dto.SearchDto
 		q.SearchTimeBegin, q.SearchTimeEnd = convertor.DefaultStartTimeAndEndTime(r.PostFormValue("timeBegin"), r.PostFormValue("timeEnd"))
@@ -40,159 +41,163 @@ func (h *roleHandler) List(w http.ResponseWriter, r *http.Request) {
 		q.SearchID = convertor.ConvertInt[int64](r.PostFormValue("id"), 0)
 		q.Page = convertor.ConvertInt(r.PostFormValue("page"), 1)
 		q.Rows = convertor.ConvertInt(r.PostFormValue("rows"), 10)
-		res, count, err := h.svc.List(r.Context(), q)
+		res, count, err := h.roleService.List(r.Context(), q)
 		if err != nil {
-			http.Error(w, err.Error(), http.StatusInternalServerError)
+			h.JSONErr(w, err.Error())
 			return
 		}
 
-		data := tpl.ResponseList{
+		data := render.ResponseList{
 			Code:    0,
 			Message: "ok",
 			Count:   count,
 			Data:    res,
 		}
-		h.render.JSON(w, data)
+		h.JSON(w, data)
 	default:
 		http.Error(w, "Method Not Allowed", http.StatusMethodNotAllowed)
 	}
 }
 
-func (h *roleHandler) Add(w http.ResponseWriter, r *http.Request) {
-	h.render.HTML(w, r, "role/edit.tmpl", map[string]any{
+func (h *RoleHandler) Add(w http.ResponseWriter, r *http.Request) {
+	h.HTML(w, r, "role/edit.tmpl", map[string]any{
 		"Item": &system.Role{Sort: 6666},
 	})
 }
 
-func (h *roleHandler) AddChildren(w http.ResponseWriter, r *http.Request) {
+func (h *RoleHandler) AddChildren(w http.ResponseWriter, r *http.Request) {
 	vars := r.URL.Query()
-	parentID := convertor.QueryInt(vars, "parentID", 0)
-	vm := &system.Role{ParentID: int32(parentID), Sort: 6666}
-	h.render.HTML(w, r, "role/edit.tmpl", map[string]any{
+	parentID := convertor.QueryInt[int32](vars, "parentID", 0)
+	vm := &system.Role{ParentID: parentID, Sort: 6666}
+	h.HTML(w, r, "role/edit.tmpl", map[string]any{
 		"Item": vm,
 	})
 }
 
-func (h *roleHandler) Edit(w http.ResponseWriter, r *http.Request) {
+func (h *RoleHandler) Edit(w http.ResponseWriter, r *http.Request) {
 	vars := r.URL.Query()
 	id := convertor.QueryInt[int32](vars, "id", 0)
 	vm := &system.Role{Sort: 6666}
 	if id > 0 {
-		vm, _ = h.svc.Get(r.Context(), id)
+		vm, _ = h.roleService.Get(r.Context(), id)
 	}
-	h.render.HTML(w, r, "role/edit.tmpl", map[string]any{
+	h.HTML(w, r, "role/edit.tmpl", map[string]any{
 		"Item": vm,
 	})
 }
 
-func (h *roleHandler) Save(w http.ResponseWriter, r *http.Request) {
+func (h *RoleHandler) Save(w http.ResponseWriter, r *http.Request) {
 	var req form.Role
 	if err := binding.Form.Bind(r, &req); err != nil {
-		h.render.JSONERR(w, binding.ValidatorErrors(err))
+		h.JSONErr(w, binding.ValidatorErrors(err))
 		return
 	}
 
 	ctx := r.Context()
 	if *req.ID == 0 {
-		err := h.svc.Create(ctx, &req)
+		err := h.roleService.Create(ctx, &req)
 		if err != nil {
-			h.render.JSONERR(w, err.Error())
+			h.JSONErr(w, err.Error())
 			return
 		}
-		h.render.JSONOK(w, "添加成功")
+		h.JSONOk(w, "添加成功")
 	} else {
-		err := h.svc.Update(ctx, &req)
+		err := h.roleService.Update(ctx, &req)
 		if err != nil {
-			h.render.JSONERR(w, err.Error())
+			h.JSONErr(w, err.Error())
 			return
 		}
 
-		h.render.JSONOK(w, "更新成功")
+		h.JSONOk(w, "更新成功")
 	}
 }
 
-func (h *roleHandler) Data(w http.ResponseWriter, r *http.Request) {
+func (h *RoleHandler) Data(w http.ResponseWriter, r *http.Request) {
 	ctx := r.Context()
 	vars := r.URL.Query()
 	t := vars.Get("type")
 	if t == "tree" {
-		res, err := h.svc.Tree(ctx, 0)
+		res, err := h.roleService.Tree(ctx, 0)
 		if err != nil {
-			h.render.JSONERR(w, err.Error())
+			h.JSONErr(w, err.Error())
 			return
 		}
 
-		h.render.JSON(w, res)
+		h.JSON(w, res)
 		return
-	} else if t == "xmselect_tree" {
-		res, err := h.svc.XmSelectTree(ctx, 0)
+	} else if t == "xm_select_tree" {
+		res, err := h.roleService.XmSelectTree(ctx, 0)
 		if err != nil {
-			h.render.JSONERR(w, err.Error())
+			h.JSONErr(w, err.Error())
 			return
 		}
 
-		h.render.JSON(w, res)
+		h.JSON(w, res)
 		return
 	}
 }
 
-func (h *roleHandler) RefreshCache(w http.ResponseWriter, r *http.Request) {
-	err := h.svc.RefreshCache(r.Context())
+func (h *RoleHandler) RefreshCache(w http.ResponseWriter, r *http.Request) {
+	err := h.roleService.RefreshCache(r.Context())
 	if err != nil {
-		h.render.JSONERR(w, err.Error())
+		h.JSONErr(w, err.Error())
 		return
 	}
 
-	h.render.JSONOK(w, "缓存刷新成功")
+	h.JSONOk(w, "缓存刷新成功")
 }
 
-func (h *roleHandler) RebuildParentPath(w http.ResponseWriter, r *http.Request) {
+func (h *RoleHandler) RebuildParentPath(w http.ResponseWriter, r *http.Request) {
 	ctx := r.Context()
-	err := h.svc.RebuildParentPath(ctx)
+	err := h.roleService.RebuildParentPath(ctx)
 	if err != nil {
-		h.render.JSONERR(w, err.Error())
+		h.JSONErr(w, err.Error())
 		return
 	}
 
-	h.render.JSONOK(w, "重建成功")
+	h.JSONOk(w, "重建成功")
 }
 
-func (h *roleHandler) RefreshRoleMenus(w http.ResponseWriter, r *http.Request) {
+func (h *RoleHandler) RefreshRoleMenus(w http.ResponseWriter, r *http.Request) {
 	ctx := r.Context()
 
 	// 获取需要刷新的角色ID
 	roleID := convertor.ConvertInt[int32](r.PostFormValue("roleID"), 0)
-	role, err := h.svc.Get(ctx, int32(roleID))
-	if err != nil || role == nil {
-		h.render.JSONERR(w, err.Error())
+	role, err := h.roleService.Get(ctx, roleID)
+	if err != nil {
+		h.JSONErr(w, err.Error())
+		return
+	}
+	if role == nil {
+		h.JSONErr(w, "角色不存在")
 		return
 	}
 
 	// 刷新角色菜单 (角色所拥有的菜单集合)
-	_, err = h.menusvc.SetListByRoleID(ctx, role.ID)
+	_, err = h.menuService.SetListByRoleID(ctx, role.ID)
 	if err != nil {
-		h.render.JSONERR(w, err.Error())
+		h.JSONErr(w, err.Error())
 		return
 	}
 
 	// 刷新角色菜单 (角色所拥有的菜单集合)
-	_, err = h.menusvc.SetListByRoleIDToMap(ctx, role.ID)
+	_, err = h.menuService.SetListByRoleIDToMap(ctx, role.ID)
 	if err != nil {
-		h.render.JSONERR(w, err.Error())
+		h.JSONErr(w, err.Error())
 		return
 	}
 
 	// 刷新角色菜单树 (pear admin layui 使用的格式)
-	_, err = h.menusvc.SetOwerMenus(ctx, role.ID)
+	_, err = h.menuService.SetOwerMenus(ctx, role.ID)
 	if err != nil {
-		h.render.JSONERR(w, err.Error())
+		h.JSONErr(w, err.Error())
 		return
 	}
 
-	h.render.JSONOK(w, "刷新成功")
+	h.JSONOk(w, "刷新成功")
 }
 
-func (h *roleHandler) SetMenu(w http.ResponseWriter, r *http.Request) {
+func (h *RoleHandler) SetMenu(w http.ResponseWriter, r *http.Request) {
 	switch r.Method {
 	case http.MethodGet:
 		vars := r.URL.Query()
@@ -204,36 +209,36 @@ func (h *roleHandler) SetMenu(w http.ResponseWriter, r *http.Request) {
 		if id > 0 {
 			ctx := r.Context()
 			var err error
-			vm.Role, err = h.svc.Get(ctx, id)
+			vm.Role, err = h.roleService.Get(ctx, id)
 			if err == nil {
-				vm.Menus, _ = h.menusvc.MenuViewData(ctx, vm.Role.ID)
+				vm.Menus, _ = h.menuService.MenuViewData(ctx, vm.Role.ID)
 			}
 		}
 
-		h.render.HTML(w, r, "role/set_menu.tmpl", map[string]any{
+		h.HTML(w, r, "role/set_menu.tmpl", map[string]any{
 			"Item": vm,
 		})
 	case http.MethodPost:
 		ctx := r.Context()
 		id := convertor.ConvertInt[int32](r.PostFormValue("ID"), 0)
 		if id == 0 {
-			h.render.JSONERR(w, "角色异常, 请刷新重试")
+			h.JSONErr(w, "角色异常, 请刷新重试")
 			return
 		}
-		role, err := h.svc.Get(ctx, id)
+		role, err := h.roleService.Get(ctx, id)
 		if err != nil {
-			h.render.JSONERR(w, err.Error())
+			h.JSONErr(w, err.Error())
 			return
 		}
 
 		menus := r.PostFormValue("roleMenu")
 		if len(menus) == 0 {
-			h.render.JSONERR(w, "请选择菜单")
+			h.JSONErr(w, "请选择菜单")
 			return
 		}
 		menuArr := strings.Split(menus, ",")
 		if len(menuArr) == 0 {
-			h.render.JSONERR(w, "请选择菜单")
+			h.JSONErr(w, "请选择菜单")
 			return
 		}
 
@@ -241,9 +246,9 @@ func (h *roleHandler) SetMenu(w http.ResponseWriter, r *http.Request) {
 		for _, v := range menuArr {
 			menuID := convertor.ConvertInt(v, 0)
 			if menuID > 0 {
-				menu, err := h.menusvc.Get(ctx, int32(menuID))
+				menu, err := h.menuService.Get(ctx, int32(menuID))
 				if err != nil {
-					h.render.JSONERR(w, err.Error())
+					h.JSONErr(w, err.Error())
 					return
 				}
 
@@ -255,17 +260,17 @@ func (h *roleHandler) SetMenu(w http.ResponseWriter, r *http.Request) {
 		}
 
 		if len(rms) == 0 {
-			h.render.JSONERR(w, "请选择正确的菜单")
+			h.JSONErr(w, "请选择正确的菜单")
 			return
 		}
 
-		err = h.menusvc.SetRoleMenu(ctx, id, rms)
+		err = h.menuService.SetRoleMenu(ctx, id, rms)
 		if err != nil {
-			h.render.JSONERR(w, err.Error())
+			h.JSONErr(w, err.Error())
 			return
 		}
 
-		h.render.JSONOK(w, "设置成功")
+		h.JSONOk(w, "设置成功")
 	default:
 		http.Error(w, "Method Not Allowed", http.StatusMethodNotAllowed)
 	}

internal/erpserver/handler/system/user.go

@@ -1,117 +1,113 @@
 package system
 
 import (
+	"io"
 	"log"
 	"net/http"
 
+	"management/internal/erpserver/handler"
 	"management/internal/erpserver/model/dto"
 	"management/internal/erpserver/model/form"
 	systemmodel "management/internal/erpserver/model/system"
 	v1 "management/internal/erpserver/service/v1"
 	"management/internal/pkg/binding"
 	"management/internal/pkg/convertor"
-	"management/internal/pkg/middleware"
-	"management/internal/pkg/tpl"
-	"management/internal/pkg/tpl/html"
+	"management/internal/pkg/render"
+	"management/internal/pkg/render/html"
 )
 
-// userHandler 是 UserHandler 接口的实现.
-type userHandler struct {
-	render tpl.Renderer
-	mi     middleware.Middleware
-
-	captchasvc    v1.CaptchaService
-	usersvc       v1.UserService
-	rolesvc       v1.RoleService
-	departmentsvc v1.DepartmentService
+type UserHandler struct {
+	*handler.Handler
+	captchaService    v1.CaptchaService
+	userService       v1.UserService
+	roleService       v1.RoleService
+	departmentService v1.DepartmentService
 }
 
 func NewUserHandler(
-	render tpl.Renderer,
-	mi middleware.Middleware,
-	captchasvc v1.CaptchaService,
-	usersvc v1.UserService,
-	rolesvc v1.RoleService,
-	departmentsvc v1.DepartmentService,
-) *userHandler {
-	return &userHandler{
-		render:        render,
-		mi:            mi,
-		captchasvc:    captchasvc,
-		usersvc:       usersvc,
-		rolesvc:       rolesvc,
-		departmentsvc: departmentsvc,
+	handler *handler.Handler,
+	captchaService v1.CaptchaService,
+	userService v1.UserService,
+	roleService v1.RoleService,
+	departmentService v1.DepartmentService,
+) *UserHandler {
+	return &UserHandler{
+		Handler:           handler,
+		captchaService:    captchaService,
+		userService:       userService,
+		roleService:       roleService,
+		departmentService: departmentService,
 	}
 }
 
-func (h *userHandler) Add(w http.ResponseWriter, r *http.Request) {
-	h.render.HTML(w, r, "user/edit.tmpl", map[string]any{
+func (h *UserHandler) Add(w http.ResponseWriter, r *http.Request) {
+	h.HTML(w, r, "user/edit.tmpl", map[string]any{
 		"Item": &systemmodel.User{
 			HashedPassword: nil,
 		},
 	})
 }
 
-func (h *userHandler) Edit(w http.ResponseWriter, r *http.Request) {
+func (h *UserHandler) Edit(w http.ResponseWriter, r *http.Request) {
 	vars := r.URL.Query()
 	id := convertor.QueryInt[int32](vars, "id", 0)
 	user := &systemmodel.User{}
 	if id > 0 {
 		ctx := r.Context()
-		if u, err := h.usersvc.Get(ctx, id); err == nil {
+		if u, err := h.userService.Get(ctx, id); err == nil {
 			user.HashedPassword = []byte("********")
 			user = u
 		}
 	}
-	h.render.HTML(w, r, "user/edit.tmpl", map[string]any{
+	h.HTML(w, r, "user/edit.tmpl", map[string]any{
 		"Item": user,
 	})
 }
 
-func (h *userHandler) Save(w http.ResponseWriter, r *http.Request) {
+func (h *UserHandler) Save(w http.ResponseWriter, r *http.Request) {
 	var req form.User
 	if err := binding.Form.Bind(r, &req); err != nil {
-		h.render.JSONERR(w, binding.ValidatorErrors(err))
+		h.JSONErr(w, binding.ValidatorErrors(err))
 		return
 	}
 
 	ctx := r.Context()
 	if req.DepartmentID > 0 {
-		if _, err := h.departmentsvc.Get(ctx, req.DepartmentID); err != nil {
-			h.render.JSONERR(w, "部门数据错误")
+		if _, err := h.departmentService.Get(ctx, req.DepartmentID); err != nil {
+			h.JSONErr(w, "部门数据错误")
 			return
 		}
 	}
 	if req.RoleID > 0 {
-		if _, err := h.rolesvc.Get(ctx, req.RoleID); err != nil {
-			h.render.JSONERR(w, "角色数据错误")
+		if _, err := h.roleService.Get(ctx, req.RoleID); err != nil {
+			h.JSONErr(w, "角色数据错误")
 			return
 		}
 	}
 
 	if *req.ID == 0 {
-		err := h.usersvc.Create(ctx, &req)
+		err := h.userService.Create(ctx, &req)
 		if err != nil {
-			h.render.JSONERR(w, err.Error())
+			h.JSONErr(w, err.Error())
 			return
 		}
 
-		h.render.JSONOK(w, "添加成功")
+		h.JSONOk(w, "添加成功")
 	} else {
-		err := h.usersvc.Update(ctx, &req)
+		err := h.userService.Update(ctx, &req)
 		if err != nil {
-			h.render.JSONERR(w, err.Error())
+			h.JSONErr(w, err.Error())
 			return
 		}
 
-		h.render.JSONOK(w, "更新成功")
+		h.JSONOk(w, "更新成功")
 	}
 }
 
-func (h *userHandler) List(w http.ResponseWriter, r *http.Request) {
+func (h *UserHandler) List(w http.ResponseWriter, r *http.Request) {
 	switch r.Method {
 	case http.MethodGet:
-		h.render.HTML(w, r, "user/list.tmpl", map[string]any{
+		h.HTML(w, r, "user/list.tmpl", map[string]any{
 			"Statuses": html.NewSelectControls(html.SearchStatuses, "0"),
 		})
 	case http.MethodPost:
@@ -123,89 +119,97 @@ func (h *userHandler) List(w http.ResponseWriter, r *http.Request) {
 		q.SearchID = convertor.ConvertInt[int64](r.PostFormValue("id"), 0)
 		q.Page = convertor.ConvertInt(r.PostFormValue("page"), 1)
 		q.Rows = convertor.ConvertInt(r.PostFormValue("rows"), 10)
-		res, count, err := h.usersvc.List(r.Context(), q)
+		res, count, err := h.userService.List(r.Context(), q)
 		if err != nil {
-			h.render.JSONERR(w, err.Error())
+			h.JSONErr(w, err.Error())
 			return
 		}
 
-		data := tpl.ResponseList{
+		data := render.ResponseList{
 			Code:    0,
 			Message: "ok",
 			Count:   count,
 			Data:    res,
 		}
-		h.render.JSON(w, data)
+		h.JSON(w, data)
 	default:
 		http.Error(w, "Method Not Allowed", http.StatusMethodNotAllowed)
 	}
 }
 
-func (h *userHandler) Profile(w http.ResponseWriter, r *http.Request) {
+func (h *UserHandler) Profile(w http.ResponseWriter, r *http.Request) {
 	ctx := r.Context()
-	user := h.mi.AuthUser(ctx)
-	vm, _ := h.usersvc.Get(ctx, user.ID)
-	h.render.HTML(w, r, "user/profile.tmpl", map[string]any{
+	user := h.AuthUser(ctx)
+	vm, _ := h.userService.Get(ctx, user.ID)
+	h.HTML(w, r, "user/profile.tmpl", map[string]any{
 		"Item": vm,
 	})
 }
 
-func (h *userHandler) Data(w http.ResponseWriter, r *http.Request) {
+func (h *UserHandler) Data(w http.ResponseWriter, r *http.Request) {
 	vars := r.URL.Query()
 	t := vars.Get("type")
-	if t == "xmselect" {
-		res, err := h.usersvc.XmSelect(r.Context())
+	if t == "xm_select" {
+		res, err := h.userService.XmSelect(r.Context())
 		if err != nil {
-			h.render.JSONERR(w, err.Error())
+			h.JSONErr(w, err.Error())
 			return
 		}
 
-		h.render.JSON(w, res)
+		h.JSON(w, res)
 		return
 	}
 
-	h.render.JSON(w, nil)
+	h.JSON(w, nil)
 }
 
-func (h *userHandler) Login(w http.ResponseWriter, r *http.Request) {
+func (h *UserHandler) Login(w http.ResponseWriter, r *http.Request) {
 	ctx := r.Context()
 	switch r.Method {
 	case http.MethodGet:
-		if h.mi.IsAuth(ctx) && h.mi.RefreshToken(ctx) {
+		if h.Middleware.IsAuth(ctx) && h.Middleware.RefreshToken(ctx) {
 			http.Redirect(w, r, "/home.html", http.StatusFound)
 			return
 		}
-		_ = h.mi.Destroy(ctx)
-		h.render.HTML(w, r, "oauth/login.tmpl", nil)
+		_ = h.Middleware.Destroy(ctx)
+		h.HTML(w, r, "oauth/login.tmpl", nil)
 	case http.MethodPost:
-		defer r.Body.Close()
+		defer func(Body io.ReadCloser) {
+			err := Body.Close()
+			if err != nil {
+				h.Log.Error(err.Error(), err)
+			}
+		}(r.Body)
 		var req form.Login
 		if err := binding.Form.Bind(r, &req); err != nil {
 			e := binding.ValidatorErrors(err)
-			h.render.JSONERR(w, e)
+			h.JSONErr(w, e)
 			return
 		}
 
-		if !h.captchasvc.Verify(req.CaptchaID, req.Captcha, true) {
-			h.render.JSONERR(w, "验证码错误")
+		if !h.captchaService.Verify(req.CaptchaID, req.Captcha, true) {
+			h.JSONErr(w, "验证码错误")
 			return
 		}
 
 		req = req.SetAttributes(r)
-		err := h.usersvc.Login(ctx, &req)
+		err := h.userService.Login(ctx, &req)
 		if err != nil {
 			log.Println(err)
-			h.render.JSONERR(w, err.Error())
+			h.JSONErr(w, err.Error())
 			return
 		}
 
-		h.render.JSONOK(w, "login successfully")
+		h.JSONOk(w, "login successfully")
 	default:
 		http.Error(w, "Method Not Allowed", http.StatusMethodNotAllowed)
 	}
 }
 
-func (h *userHandler) Logout(w http.ResponseWriter, r *http.Request) {
-	h.mi.Destroy(r.Context())
+func (h *UserHandler) Logout(w http.ResponseWriter, r *http.Request) {
+	err := h.Middleware.Destroy(r.Context())
+	if err != nil {
+		h.Log.Error(err.Error(), err)
+	}
 	http.Redirect(w, r, "/", http.StatusFound)
 }