gorm wire

internal/erpserver/handler/app.go

@@ -1,62 +0,0 @@
-package handler
-
-import (
-	systemrepo "management/internal/erpserver/model/system"
-	"management/internal/erpserver/repository"
-	systemsvc "management/internal/erpserver/service/v1"
-	"management/internal/pkg/config"
-	"management/internal/pkg/middleware"
-	"management/internal/pkg/redis"
-	"management/internal/pkg/session"
-	"management/internal/pkg/tpl"
-
-	"github.com/drhin/logger"
-	"gorm.io/gorm"
-)
-
-type AppContext struct {
-	// DB
-	DB *gorm.DB
-
-	// Store
-	Store repository.Store
-
-	// Cache
-	Redis redis.RedisCache
-
-	// session
-	Session session.Session
-
-	// middleware
-	Middleware middleware.Middleware
-
-	// render
-	Render tpl.Renderer
-
-	// config
-	Config *config.Config
-
-	// log
-	Log *logger.Logger
-
-	// repository
-	UserRepo       systemrepo.UserRepository
-	LoginLogRepo   systemrepo.LoginLogRepository
-	AuditLogRepo   systemrepo.AuditLogRepository
-	RoleRepo       systemrepo.RoleRepository
-	DepartmentRepo systemrepo.DepartmentRepository
-	ConfigRepo     systemrepo.ConfigRepository
-	MenuRepo       systemrepo.MenuRepository
-	RoleMenuRepo   systemrepo.RoleMenuRepository
-
-	// service
-	CaptchaService    systemsvc.CaptchaService
-	UserService       systemsvc.UserService
-	LoginLogService   systemsvc.LoginLogService
-	AuditLogService   systemsvc.AuditLogService
-	RoleService       systemsvc.RoleService
-	DepartmentService systemsvc.DepartmentService
-	ConfigService     systemsvc.ConfigService
-	MenuService       systemsvc.MenuService
-	RoleMenuService   systemsvc.RoleMenuService
-}

internal/erpserver/handler/common/captcha.go

@@ -3,22 +3,20 @@ package common
 import (
 	"net/http"
 
+	"management/internal/erpserver/handler"
 	v1 "management/internal/erpserver/service/v1"
-	"management/internal/pkg/config"
-	"management/internal/pkg/tpl"
+	"management/internal/pkg/render"
 )
 
-type captchaHandler struct {
-	conf   *config.Captcha
-	render tpl.Renderer
-	svc    v1.CaptchaService
+type CaptchaHandler struct {
+	*handler.Handler
+	captchaService v1.CaptchaService
 }
 
-func NewCaptchaHandler(conf *config.Captcha, render tpl.Renderer, svc v1.CaptchaService) *captchaHandler {
-	return &captchaHandler{
-		conf:   conf,
-		render: render,
-		svc:    svc,
+func NewCaptchaHandler(handler *handler.Handler, captchaService v1.CaptchaService) *CaptchaHandler {
+	return &CaptchaHandler{
+		Handler:        handler,
+		captchaService: captchaService,
 	}
 }
 
@@ -29,20 +27,22 @@ type CaptchaResponse struct {
 	OpenCaptcha   int    `json:"open_captcha"`
 }
 
-func (h *captchaHandler) Captcha(w http.ResponseWriter, r *http.Request) {
-	keyLong := h.conf.KeyLong
-	oc := h.conf.OpenCaptcha
-	id, b64s, _, err := h.svc.Generate(h.conf.ImgHeight, h.conf.ImgWidth, keyLong, 0.7, 80)
+func (h *CaptchaHandler) Captcha(w http.ResponseWriter, _ *http.Request) {
+	id, b64s, _, err := h.captchaService.Generate(
+		h.Config.Captcha.ImgHeight,
+		h.Config.Captcha.ImgWidth,
+		h.Config.Captcha.KeyLong,
+		0.7, 80)
 	if err != nil {
-		h.render.JSON(w, tpl.Response{Success: false, Message: "获取验证码失败"})
+		h.JSONErr(w, "获取验证码失败")
 		return
 	}
 
 	rsp := CaptchaResponse{
 		CaptchaID:     id,
 		PicPath:       b64s,
-		CaptchaLength: keyLong,
-		OpenCaptcha:   oc,
+		CaptchaLength: h.Config.Captcha.KeyLong,
+		OpenCaptcha:   h.Config.Captcha.OpenCaptcha,
 	}
-	h.render.JSON(w, tpl.Response{Success: true, Message: "ok", Data: rsp})
+	h.JSON(w, render.Response{Success: true, Message: "ok", Data: rsp})
 }

internal/erpserver/handler/common/upload.go

@@ -1,59 +1,70 @@
 package common
 
 import (
+	"io"
 	"mime/multipart"
 	"net/http"
 
+	"management/internal/erpserver/handler"
 	fileutil "management/internal/pkg/file"
-	"management/internal/pkg/tpl"
 )
 
-type uploadHandler struct {
-	render tpl.Renderer
+type UploadHandler struct {
+	*handler.Handler
 }
 
-func NewUploadHandler(render tpl.Renderer) *uploadHandler {
-	return &uploadHandler{
-		render: render,
+func NewUploadHandler(handler *handler.Handler) *UploadHandler {
+	return &UploadHandler{
+		Handler: handler,
 	}
 }
 
 const maxImageSize = 100 << 20 // 100 MB
 
-func (h *uploadHandler) Img(w http.ResponseWriter, r *http.Request) {
-	defer r.Body.Close()
+func (h *UploadHandler) Img(w http.ResponseWriter, r *http.Request) {
+	defer func(Body io.ReadCloser) {
+		err := Body.Close()
+		if err != nil {
+			h.Log.Error(err.Error(), err)
+		}
+	}(r.Body)
 
 	_, fh, err := r.FormFile("files")
 	if err != nil {
-		h.render.JSONERR(w, err.Error())
+		h.JSONErr(w, err.Error())
 		return
 	}
 
 	path, err := fileutil.UploadFile(fh, fileutil.IMG)
 	if err != nil {
-		h.render.JSONERR(w, err.Error())
+		h.JSONErr(w, err.Error())
 		return
 	}
 
-	h.render.JSON(w, tpl.Response{Success: true, Message: "ok", Data: path})
+	h.JSONObj(w, "ok", path)
 }
 
-func (h *uploadHandler) File(w http.ResponseWriter, r *http.Request) {
-	defer r.Body.Close()
+func (h *UploadHandler) File(w http.ResponseWriter, r *http.Request) {
+	defer func(Body io.ReadCloser) {
+		err := Body.Close()
+		if err != nil {
+			h.Log.Error(err.Error(), err)
+		}
+	}(r.Body)
 
 	_, fh, err := r.FormFile("files")
 	if err != nil {
-		h.render.JSONERR(w, err.Error())
+		h.JSONErr(w, err.Error())
 		return
 	}
 
 	path, err := fileutil.UploadFile(fh, fileutil.ALL)
 	if err != nil {
-		h.render.JSONERR(w, err.Error())
+		h.JSONErr(w, err.Error())
 		return
 	}
 
-	h.render.JSON(w, tpl.Response{Success: true, Message: "ok", Data: path})
+	h.JSONObj(w, "ok", path)
 }
 
 type UploadFileRes struct {
@@ -61,8 +72,13 @@ type UploadFileRes struct {
 	Path string `json:"path"`
 }
 
-func (h *uploadHandler) MutilFiles(w http.ResponseWriter, r *http.Request) {
-	defer r.Body.Close()
+func (h *UploadHandler) MultiFiles(w http.ResponseWriter, r *http.Request) {
+	defer func(Body io.ReadCloser) {
+		err := Body.Close()
+		if err != nil {
+			h.Log.Error(err.Error(), err)
+		}
+	}(r.Body)
 
 	err := r.ParseMultipartForm(int64(maxImageSize))
 	if err != nil {
@@ -80,7 +96,7 @@ func (h *uploadHandler) MutilFiles(w http.ResponseWriter, r *http.Request) {
 
 			filePath, err := fileutil.UploadFile(item, fileutil.ALL)
 			if err != nil {
-				h.render.JSONERR(w, err.Error())
+				h.JSONErr(w, err.Error())
 				return
 			}
 
@@ -99,5 +115,5 @@ func (h *uploadHandler) MutilFiles(w http.ResponseWriter, r *http.Request) {
 		}
 	}
 
-	h.render.JSON(w, tpl.Response{Success: true, Message: "ok", Data: res})
+	h.JSONObj(w, "ok", res)
 }

internal/erpserver/handler/handler.go

@@ -0,0 +1,65 @@
+package handler
+
+import (
+	"context"
+	"net/http"
+
+	"management/internal/erpserver/model/dto"
+	"management/internal/pkg/config"
+	"management/internal/pkg/middleware"
+	"management/internal/pkg/render"
+
+	"github.com/drhin/logger"
+)
+
+type Handler struct {
+	Config     *config.Config
+	Log        *logger.Logger
+	Middleware middleware.Middleware
+
+	render render.Render
+}
+
+func NewHandler(
+	config *config.Config,
+	log *logger.Logger,
+	middleware middleware.Middleware,
+	render render.Render,
+) *Handler {
+	return &Handler{
+		Config:     config,
+		Log:        log,
+		Middleware: middleware,
+		render:     render,
+	}
+}
+
+// =====================================================================================================================
+// middleware 帮助方法
+
+func (h *Handler) AuthUser(ctx context.Context) dto.AuthorizeUser {
+	return h.Middleware.AuthUser(ctx)
+}
+
+// =====================================================================================================================
+// render 帮助方法
+
+func (h *Handler) HTML(w http.ResponseWriter, r *http.Request, name string, data map[string]any) {
+	h.render.HTML(w, r, name, data)
+}
+
+func (h *Handler) JSON(w http.ResponseWriter, data any) {
+	h.render.JSON(w, data)
+}
+
+func (h *Handler) JSONObj(w http.ResponseWriter, message string, data any) {
+	h.render.JSONObj(w, message, data)
+}
+
+func (h *Handler) JSONOk(w http.ResponseWriter, message string) {
+	h.render.JSONOk(w, message)
+}
+
+func (h *Handler) JSONErr(w http.ResponseWriter, message string) {
+	h.render.JSONErr(w, message)
+}

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)
 }

internal/erpserver/http.go

@@ -1,16 +1,29 @@
-package handler
+package erpserver
 
 import (
 	"net/http"
 
 	"management/internal/erpserver/handler/common"
 	"management/internal/erpserver/handler/system"
+	mi "management/internal/pkg/middleware"
 
 	"github.com/go-chi/chi/v5"
 	"github.com/go-chi/chi/v5/middleware"
 )
 
-func (ctx *AppContext) Router() *chi.Mux {
+func NewHTTPServer(
+	mi mi.Middleware,
+	captchaHandler *common.CaptchaHandler,
+	uploadHandler *common.UploadHandler,
+	configHandler *system.ConfigHandler,
+	homeHandler *system.HomeHandler,
+	userHandler *system.UserHandler,
+	loginLogHandler *system.LoginLogHandler,
+	auditHandler *system.AuditHandler,
+	menuHandler *system.MenuHandler,
+	roleHandler *system.RoleHandler,
+	departmentHandler *system.DepartmentHandler,
+) *chi.Mux {
 	r := chi.NewRouter()
 
 	r.Use(middleware.RequestID)
@@ -25,36 +38,41 @@ func (ctx *AppContext) Router() *chi.Mux {
 	r.Handle("/upload/*", http.StripPrefix("/upload", uploadServer))
 
 	r.Group(func(r chi.Router) {
-		r.Use(ctx.Middleware.NoSurf)      // CSRF
-		r.Use(ctx.Middleware.LoadSession) // Session
+		r.Use(mi.NoSurf)      // CSRF
+		r.Use(mi.LoadSession) // Session
 
-		captchaHandler := common.NewCaptchaHandler(&ctx.Config.Captcha, ctx.Render, ctx.CaptchaService)
 		r.Get("/captcha", captchaHandler.Captcha)
 
-		uploadHandler := common.NewUploadHandler(ctx.Render)
-		r.With(ctx.Middleware.Authorize, ctx.Middleware.Audit).Post("/upload/img", uploadHandler.Img)
-		r.With(ctx.Middleware.Authorize, ctx.Middleware.Audit).Post("/upload/file", uploadHandler.File)
-		r.With(ctx.Middleware.Authorize, ctx.Middleware.Audit).Post("/upload/mutilfile", uploadHandler.MutilFiles)
+		r.With(mi.Authorize, mi.Audit).Post("/upload/img", uploadHandler.Img)
+		r.With(mi.Authorize, mi.Audit).Post("/upload/file", uploadHandler.File)
+		r.With(mi.Authorize, mi.Audit).Post("/upload/multi_files", uploadHandler.MultiFiles)
 
-		userHandler := system.NewUserHandler(ctx.Render, ctx.Middleware, ctx.CaptchaService, ctx.UserService, ctx.RoleService, ctx.DepartmentService)
 		r.Get("/", userHandler.Login)
 		r.Post("/login", userHandler.Login)
 		r.Get("/logout", userHandler.Logout)
 
-		homeHandler := system.NewHomeHandler(ctx.Render, ctx.Middleware, ctx.UserService, ctx.LoginLogService)
-		r.With(ctx.Middleware.Authorize).Get("/home.html", homeHandler.Home)
-		r.With(ctx.Middleware.Authorize).Get("/dashboard", homeHandler.Dashboard)
+		r.With(mi.Authorize).Get("/home.html", homeHandler.Home)
+		r.With(mi.Authorize).Get("/dashboard", homeHandler.Dashboard)
 
-		configHandler := system.NewConfigHandler(ctx.Render, ctx.Redis, ctx.ConfigService)
-		r.With(ctx.Middleware.Authorize).Get("/pear.json", configHandler.Pear)
+		r.With(mi.Authorize).Get("/pear.json", configHandler.Pear)
 
 		r.Route("/system", func(r chi.Router) {
-			r.Use(ctx.Middleware.Authorize)
+			r.Use(mi.Authorize)
+
+			r.Route("/config", func(r chi.Router) {
+				r.Use(mi.Audit)
+				r.Get("/list", configHandler.List)
+				r.Post("/list", configHandler.List)
+				r.Get("/add", configHandler.Add)
+				r.Get("/edit", configHandler.Edit)
+				r.Post("/save", configHandler.Save)
+				r.Post("/refresh_cache", configHandler.RefreshCache)
+				r.Post("/reset_pear", configHandler.ResetPear)
+			})
 
-			menuHandler := system.NewMenuHandler(ctx.Render, ctx.Middleware, ctx.MenuService)
 			r.Get("/menus", menuHandler.Menus)
 			r.Route("/menu", func(r chi.Router) {
-				r.Use(ctx.Middleware.Audit)
+				r.Use(mi.Audit)
 				r.Get("/list", menuHandler.List)
 				r.Post("/list", menuHandler.List)
 				r.Get("/add", menuHandler.Add)
@@ -66,24 +84,22 @@ func (ctx *AppContext) Router() *chi.Mux {
 			})
 
 			r.Route("/department", func(r chi.Router) {
-				r.Use(ctx.Middleware.Audit)
+				r.Use(mi.Audit)
 
-				departHandler := system.NewDepartmentHandler(ctx.Render, ctx.DepartmentService)
-				r.Get("/list", departHandler.List)
-				r.Post("/list", departHandler.List)
-				r.Get("/add", departHandler.Add)
-				r.Get("/add_children", departHandler.AddChildren)
-				r.Get("/edit", departHandler.Edit)
-				r.Post("/save", departHandler.Save)
-				r.Post("/data", departHandler.Data)
-				r.Post("/refresh_cache", departHandler.RefreshCache)
-				r.Post("/rebuild_parent_path", departHandler.RebuildParentPath)
+				r.Get("/list", departmentHandler.List)
+				r.Post("/list", departmentHandler.List)
+				r.Get("/add", departmentHandler.Add)
+				r.Get("/add_children", departmentHandler.AddChildren)
+				r.Get("/edit", departmentHandler.Edit)
+				r.Post("/save", departmentHandler.Save)
+				r.Post("/data", departmentHandler.Data)
+				r.Post("/refresh_cache", departmentHandler.RefreshCache)
+				r.Post("/rebuild_parent_path", departmentHandler.RebuildParentPath)
 			})
 
 			r.Route("/role", func(r chi.Router) {
-				r.Use(ctx.Middleware.Audit)
+				r.Use(mi.Audit)
 
-				roleHandler := system.NewRoleHandler(ctx.Render, ctx.RoleService, ctx.MenuService)
 				r.Get("/list", roleHandler.List)
 				r.Post("/list", roleHandler.List)
 				r.Get("/add", roleHandler.Add)
@@ -108,13 +124,11 @@ func (ctx *AppContext) Router() *chi.Mux {
 				r.Post("/data", userHandler.Data)
 			})
 
-			loginLogHandler := system.NewLoginLogHandler(ctx.Render, ctx.LoginLogService)
 			r.Route("/login_log", func(r chi.Router) {
 				r.Get("/list", loginLogHandler.List)
 				r.Post("/list", loginLogHandler.List)
 			})
 
-			auditHandler := system.NewAuditHandler(ctx.Render, ctx.AuditLogService)
 			r.Route("/audit_log", func(r chi.Router) {
 				r.Get("/list", auditHandler.List)
 				r.Post("/list", auditHandler.List)

internal/erpserver/model/system/config.go

@@ -18,7 +18,7 @@ type ConfigRepository interface {
 type Config struct {
 	ID        int32     `json:"id" gorm:"primaryKey;autoIncrement;not null"`
 	Key       string    `json:"key" gorm:"type:varchar(200);not null;uniqueIndex"`
-	Value     []byte    `json:"value" gorm:"type:bytea;not null;"`
+	Value     string    `json:"value" gorm:"type:jsonb;not null;"`
 	CreatedAt time.Time `json:"created_at" gorm:"type:timestamptz;not null;default:'now()'"`
 	UpdatedAt time.Time `json:"updated_at" gorm:"type:timestamptz;not null;default:'0001-01-01 00:00:00+8';"`
 }

internal/erpserver/repository/store.go

@@ -2,58 +2,136 @@ package repository
 
 import (
 	"context"
-	"sync"
+	"fmt"
+	"time"
 
+	"management/internal/pkg/config"
+
+	"github.com/drhin/logger"
+	"gorm.io/driver/postgres"
 	"gorm.io/gorm"
 )
 
-var (
-	once sync.Once
-	// 全局变量，方便其它包直接调用已初始化好的 datastore 实例.
-	engine *datastore
-)
+type txCtxKey struct{}
 
-type Store interface {
-	DB(ctx context.Context) *gorm.DB
-	TX(ctx context.Context, fn func(ctx context.Context) error) error
+type Repository struct {
+	db     *gorm.DB
+	logger *logger.Logger
 }
 
-// transactionKey 用于在 context.Context 中存储事务上下文的键.
-type transactionKey struct{}
-
-// datastore 是 Storer 的具体实现.
-type datastore struct {
-	core *gorm.DB
+func NewRepository(db *gorm.DB, logger *logger.Logger) *Repository {
+	return &Repository{
+		db:     db,
+		logger: logger,
+	}
 }
 
-// 确保 datastore 实现了 Storer 接口.
-var _ Store = (*datastore)(nil)
+type Transaction interface {
+	Transaction(ctx context.Context, fn func(ctx context.Context) error) error
+}
 
-// NewStore 创建一个 Storer 类型的实例.
-func NewStore(db *gorm.DB) *datastore {
-	// 确保 engine 只被初始化一次
-	once.Do(func() {
-		engine = &datastore{db}
+func NewTransaction(r *Repository) Transaction {
+	return r
+}
+
+func (r *Repository) DB(ctx context.Context) *gorm.DB {
+	v := ctx.Value(txCtxKey{})
+	if v != nil {
+		if tx, ok := v.(*gorm.DB); ok {
+			return tx
+		}
+	}
+	return r.db.WithContext(ctx)
+}
+
+func (r *Repository) Transaction(ctx context.Context, fn func(ctx context.Context) error) error {
+	return r.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
+		ctx = context.WithValue(ctx, txCtxKey{}, tx)
+		return fn(ctx)
 	})
-
-	return engine
 }
 
-func (store *datastore) DB(ctx context.Context) *gorm.DB {
-	db := store.core
-	// 从上下文中提取事务实例
-	if tx, ok := ctx.Value(transactionKey{}).(*gorm.DB); ok {
-		db = tx
+func NewDB(log *logger.Logger, config *config.Config) (*gorm.DB, func(), error) {
+	dsn := fmt.Sprintf("host=%s user=%s password=%s dbname=%s port=%d sslmode=disable TimeZone=Asia/Shanghai",
+		config.DB.Host,
+		config.DB.Username,
+		config.DB.Password,
+		config.DB.DBName,
+		config.DB.Port,
+	)
+	db, err := gorm.Open(postgres.New(postgres.Config{
+		DSN:                  dsn,
+		PreferSimpleProtocol: true, // disables implicit prepared statement usage
+	}), &gorm.Config{})
+	if err != nil {
+		return nil, nil, err
 	}
 
-	return db
+	db = db.Debug()
+
+	// Connection Pool config
+	sqlDB, err := db.DB()
+	if err != nil {
+		return nil, nil, err
+	}
+
+	sqlDB.SetMaxIdleConns(10)
+	sqlDB.SetMaxOpenConns(100)
+	sqlDB.SetConnMaxLifetime(time.Hour)
+
+	cleanup := func() {
+		if err := sqlDB.Close(); err != nil {
+			log.Error("sql db close error", err)
+		}
+	}
+
+	return db, cleanup, nil
 }
 
-func (store *datastore) TX(ctx context.Context, fn func(ctx context.Context) error) error {
-	return store.core.WithContext(ctx).Transaction(
-		func(tx *gorm.DB) error {
-			ctx = context.WithValue(ctx, transactionKey{}, tx)
-			return fn(ctx)
-		},
-	)
-}
+//var (
+//	once sync.Once
+//	// 全局变量，方便其它包直接调用已初始化好的 datastore 实例.
+//	engine *datastore
+//)
+//
+//type Store interface {
+//	DB(ctx context.Context) *gorm.DB
+//	TX(ctx context.Context, fn func(ctx context.Context) error) error
+//}
+//
+//// transactionKey 用于在 context.Context 中存储事务上下文的键.
+//type transactionKey struct{}
+//
+//// datastore 是 Store 的具体实现.
+//type datastore struct {
+//	core *gorm.DB
+//}
+//
+//// NewStore 创建一个 Store 类型的实例.
+//func NewStore(db *gorm.DB) Store {
+//	// 确保 engine 只被初始化一次
+//	once.Do(func() {
+//		engine = &datastore{db}
+//	})
+//
+//	return engine
+//}
+//
+//func (store *datastore) DB(ctx context.Context) *gorm.DB {
+//	db := store.core
+//	// 从上下文中提取事务实例
+//	if tx, ok := ctx.Value(transactionKey{}).(*gorm.DB); ok {
+//		db = tx
+//	}
+//
+//	return db
+//}
+//
+//func (store *datastore) TX(ctx context.Context, fn func(ctx context.Context) error) error {
+//	return store.core.WithContext(ctx).Transaction(
+//		func(tx *gorm.DB) error {
+//			ctx = context.WithValue(ctx, transactionKey{}, tx)
+//			return fn(ctx)
+//		},
+//	)
+//}

internal/erpserver/repository/system/audit_log.go

@@ -9,23 +9,21 @@ import (
 )
 
 type auditLogRepository struct {
-	store repository.Store
+	repo *repository.Repository
 }
 
-var _ system.AuditLogRepository = (*auditLogRepository)(nil)
-
-func NewAuditLogRepository(store repository.Store) *auditLogRepository {
+func NewAuditLogRepository(repo *repository.Repository) system.AuditLogRepository {
 	return &auditLogRepository{
-		store: store,
+		repo: repo,
 	}
 }
 
 func (s *auditLogRepository) Create(ctx context.Context, obj *system.AuditLog) error {
-	return s.store.DB(ctx).Create(obj).Error
+	return s.repo.DB(ctx).Create(obj).Error
 }
 
 func (s *auditLogRepository) List(ctx context.Context, q dto.SearchDto) ([]*system.AuditLog, int64, error) {
-	query := s.store.DB(ctx).
+	query := s.repo.DB(ctx).
 		Model(&system.AuditLog{}).
 		Where("created_at BETWEEN ? AND ?", q.SearchTimeBegin, q.SearchTimeEnd)
 	if q.SearchEmail != "" {

internal/erpserver/repository/system/config.go

@@ -9,28 +9,26 @@ import (
 )
 
 type configRepository struct {
-	store repository.Store
+	repo *repository.Repository
 }
 
-var _ system.ConfigRepository = (*configRepository)(nil)
-
-func NewConfigRepository(store repository.Store) *configRepository {
+func NewConfigRepository(repo *repository.Repository) system.ConfigRepository {
 	return &configRepository{
-		store: store,
+		repo: repo,
 	}
 }
 
 func (r *configRepository) Create(ctx context.Context, obj *system.Config) error {
-	return r.store.DB(ctx).Create(obj).Error
+	return r.repo.DB(ctx).Create(obj).Error
 }
 
 func (r *configRepository) Update(ctx context.Context, obj *system.Config) error {
-	return r.store.DB(ctx).Save(obj).Error
+	return r.repo.DB(ctx).Save(obj).Error
 }
 
 func (r *configRepository) Get(ctx context.Context, id int32) (*system.Config, error) {
 	var obj system.Config
-	err := r.store.DB(ctx).First(&obj, id).Error
+	err := r.repo.DB(ctx).First(&obj, id).Error
 	if err != nil {
 		return nil, err
 	}
@@ -39,7 +37,7 @@ func (r *configRepository) Get(ctx context.Context, id int32) (*system.Config, e
 
 func (r *configRepository) GetByKey(ctx context.Context, key string) (*system.Config, error) {
 	var obj system.Config
-	err := r.store.DB(ctx).Where("key = ?", key).First(&obj).Error
+	err := r.repo.DB(ctx).Where("key = ?", key).First(&obj).Error
 	if err != nil {
 		return nil, err
 	}
@@ -47,5 +45,25 @@ func (r *configRepository) GetByKey(ctx context.Context, key string) (*system.Co
 }
 
 func (r *configRepository) List(ctx context.Context, q dto.SearchDto) ([]*system.Config, int64, error) {
-	return nil, 0, nil
+	query := r.repo.DB(ctx).
+		Model(&system.Config{}).
+		Where("created_at BETWEEN ? AND ?", q.SearchTimeBegin, q.SearchTimeEnd)
+
+	var count int64
+	err := query.Count(&count).Error
+	if err != nil {
+		return nil, 0, err
+	}
+
+	var configs []*system.Config
+	err = query.
+		Order("id DESC").
+		Offset((q.Page - 1) * q.Rows).
+		Limit(q.Rows).
+		Find(&configs).
+		Error
+	if err != nil {
+		return nil, 0, err
+	}
+	return configs, count, nil
 }

internal/erpserver/repository/system/department.go

@@ -9,28 +9,26 @@ import (
 )
 
 type departmentRepository struct {
-	store repository.Store
+	repo *repository.Repository
 }
 
-var _ system.DepartmentRepository = (*departmentRepository)(nil)
-
-func NewDepartmentRepository(store repository.Store) *departmentRepository {
+func NewDepartmentRepository(repo *repository.Repository) system.DepartmentRepository {
 	return &departmentRepository{
-		store: store,
+		repo: repo,
 	}
 }
 
 func (r *departmentRepository) Create(ctx context.Context, obj *system.Department) error {
-	return r.store.DB(ctx).Create(obj).Error
+	return r.repo.DB(ctx).Create(obj).Error
 }
 
 func (r *departmentRepository) Update(ctx context.Context, obj *system.Department) error {
-	return r.store.DB(ctx).Save(obj).Error
+	return r.repo.DB(ctx).Save(obj).Error
 }
 
 func (r *departmentRepository) Get(ctx context.Context, id int32) (*system.Department, error) {
 	var obj system.Department
-	err := r.store.DB(ctx).First(&obj, id).Error
+	err := r.repo.DB(ctx).First(&obj, id).Error
 	if err != nil {
 		return nil, err
 	}
@@ -39,7 +37,7 @@ func (r *departmentRepository) Get(ctx context.Context, id int32) (*system.Depar
 
 func (r *departmentRepository) All(ctx context.Context) ([]*system.Department, error) {
 	var departs []*system.Department
-	err := r.store.DB(ctx).Find(&departs).Error
+	err := r.repo.DB(ctx).Find(&departs).Error
 	if err != nil {
 		return nil, err
 	}
@@ -47,7 +45,7 @@ func (r *departmentRepository) All(ctx context.Context) ([]*system.Department, e
 }
 
 func (r *departmentRepository) List(ctx context.Context, q dto.SearchDto) ([]*system.Department, int64, error) {
-	query := r.store.DB(ctx).
+	query := r.repo.DB(ctx).
 		Model(&system.Department{}).
 		Where("created_at BETWEEN ? AND ?", q.SearchTimeBegin, q.SearchTimeEnd)
 	if q.SearchID != 0 {
@@ -96,5 +94,5 @@ SET parent_path = (SELECT ',' || string_agg(cast(t.parent_id AS VARCHAR), ',') |
                          FROM temp
                          ORDER BY id) AS t)
 WHERE tm.status = 0;`
-	return r.store.DB(ctx).Exec(query).Error
+	return r.repo.DB(ctx).Exec(query).Error
 }

internal/erpserver/repository/system/login_log.go

@@ -9,24 +9,22 @@ import (
 )
 
 type loginLogRepository struct {
-	store repository.Store
+	repo *repository.Repository
 }
 
-var _ system.LoginLogRepository = (*loginLogRepository)(nil)
-
-func NewLoginLogRepository(store repository.Store) *loginLogRepository {
+func NewLoginLogRepository(repo *repository.Repository) system.LoginLogRepository {
 	return &loginLogRepository{
-		store: store,
+		repo: repo,
 	}
 }
 
 func (s *loginLogRepository) Create(ctx context.Context, obj *system.LoginLog) error {
-	return s.store.DB(ctx).Create(obj).Error
+	return s.repo.DB(ctx).Create(obj).Error
 }
 
 func (s *loginLogRepository) GetLatest(ctx context.Context, email string) (*system.LoginLog, error) {
 	var log system.LoginLog
-	err := s.store.DB(ctx).
+	err := s.repo.DB(ctx).
 		Where("email = ?", email).
 		Order("id DESC").
 		First(&log).
@@ -38,7 +36,7 @@ func (s *loginLogRepository) GetLatest(ctx context.Context, email string) (*syst
 }
 
 func (s *loginLogRepository) List(ctx context.Context, q dto.SearchDto) ([]*system.LoginLog, int64, error) {
-	query := s.store.DB(ctx).
+	query := s.repo.DB(ctx).
 		Model(&system.LoginLog{}).
 		Where("created_at BETWEEN ? AND ?", q.SearchTimeBegin, q.SearchTimeEnd)
 	if q.SearchEmail != "" {
@@ -66,7 +64,7 @@ func (s *loginLogRepository) List(ctx context.Context, q dto.SearchDto) ([]*syst
 
 func (s *loginLogRepository) Count(ctx context.Context, email string) (int64, error) {
 	var count int64
-	err := s.store.DB(ctx).
+	err := s.repo.DB(ctx).
 		Model(&system.LoginLog{}).
 		Where("email = ?", email).
 		Count(&count).

internal/erpserver/repository/system/menu.go

@@ -8,28 +8,26 @@ import (
 )
 
 type menuRepository struct {
-	store repository.Store
+	repo *repository.Repository
 }
 
-var _ system.MenuRepository = (*menuRepository)(nil)
-
-func NewMenuRepository(store repository.Store) *menuRepository {
+func NewMenuRepository(repo *repository.Repository) system.MenuRepository {
 	return &menuRepository{
-		store: store,
+		repo: repo,
 	}
 }
 
 func (r *menuRepository) Create(ctx context.Context, obj *system.Menu) error {
-	return r.store.DB(ctx).Create(obj).Error
+	return r.repo.DB(ctx).Create(obj).Error
 }
 
 func (r *menuRepository) Update(ctx context.Context, obj *system.Menu) error {
-	return r.store.DB(ctx).Save(obj).Error
+	return r.repo.DB(ctx).Save(obj).Error
 }
 
 func (r *menuRepository) Get(ctx context.Context, id int32) (*system.Menu, error) {
 	var menu system.Menu
-	err := r.store.DB(ctx).Where("id = ?", id).First(&menu).Error
+	err := r.repo.DB(ctx).Where("id = ?", id).First(&menu).Error
 	if err != nil {
 		return nil, err
 	}
@@ -38,7 +36,7 @@ func (r *menuRepository) Get(ctx context.Context, id int32) (*system.Menu, error
 
 func (r *menuRepository) GetByUrl(ctx context.Context, url string) (*system.Menu, error) {
 	var menu system.Menu
-	err := r.store.DB(ctx).Where("url = ?", url).First(&menu).Error
+	err := r.repo.DB(ctx).Where("url = ?", url).First(&menu).Error
 	if err != nil {
 		return nil, err
 	}
@@ -47,7 +45,7 @@ func (r *menuRepository) GetByUrl(ctx context.Context, url string) (*system.Menu
 
 func (r *menuRepository) All(ctx context.Context) ([]*system.Menu, error) {
 	var menus []*system.Menu
-	err := r.store.DB(ctx).Find(&menus).Error
+	err := r.repo.DB(ctx).Find(&menus).Error
 	if err != nil {
 		return nil, err
 	}
@@ -69,5 +67,5 @@ func (r *menuRepository) RebuildParentPath(ctx context.Context) error {
 							 FROM temp
 							 ORDER BY id) AS t)
 	WHERE tm.status = 0;`
-	return r.store.DB(ctx).Exec(query).Error
+	return r.repo.DB(ctx).Exec(query).Error
 }

internal/erpserver/repository/system/role.go

@@ -9,28 +9,26 @@ import (
 )
 
 type roleRepository struct {
-	store repository.Store
+	repo *repository.Repository
 }
 
-var _ system.RoleRepository = (*roleRepository)(nil)
-
-func NewRoleRepository(store repository.Store) *roleRepository {
+func NewRoleRepository(repo *repository.Repository) system.RoleRepository {
 	return &roleRepository{
-		store: store,
+		repo: repo,
 	}
 }
 
 func (r *roleRepository) Create(ctx context.Context, obj *system.Role) error {
-	return r.store.DB(ctx).Create(obj).Error
+	return r.repo.DB(ctx).Create(obj).Error
 }
 
 func (r *roleRepository) Update(ctx context.Context, obj *system.Role) error {
-	return r.store.DB(ctx).Save(obj).Error
+	return r.repo.DB(ctx).Save(obj).Error
 }
 
 func (r *roleRepository) Get(ctx context.Context, id int32) (*system.Role, error) {
 	var role system.Role
-	err := r.store.DB(ctx).Where("id = ?", id).First(&role).Error
+	err := r.repo.DB(ctx).Where("id = ?", id).First(&role).Error
 	if err != nil {
 		return nil, err
 	}
@@ -39,7 +37,7 @@ func (r *roleRepository) Get(ctx context.Context, id int32) (*system.Role, error
 
 func (r *roleRepository) All(ctx context.Context) ([]*system.Role, error) {
 	var roles []*system.Role
-	err := r.store.DB(ctx).Find(&roles).Error
+	err := r.repo.DB(ctx).Find(&roles).Error
 	if err != nil {
 		return nil, err
 	}
@@ -47,7 +45,7 @@ func (r *roleRepository) All(ctx context.Context) ([]*system.Role, error) {
 }
 
 func (r *roleRepository) List(ctx context.Context, q dto.SearchDto) ([]*system.Role, int64, error) {
-	query := r.store.DB(ctx).
+	query := r.repo.DB(ctx).
 		Model(&system.Role{}).
 		Where("created_at BETWEEN ? AND ?", q.SearchTimeBegin, q.SearchTimeEnd)
 	if q.SearchID != 0 {
@@ -96,5 +94,5 @@ func (r *roleRepository) RebuildParentPath(ctx context.Context) error {
 							 FROM temp
 							 ORDER BY id) AS t)
 	WHERE tm.status = 0;`
-	return r.store.DB(ctx).Exec(query).Error
+	return r.repo.DB(ctx).Exec(query).Error
 }

internal/erpserver/repository/system/role_menu.go

@@ -8,28 +8,26 @@ import (
 )
 
 type roleMenuRepository struct {
-	store repository.Store
+	repo *repository.Repository
 }
 
-var _ system.RoleMenuRepository = (*roleMenuRepository)(nil)
-
-func NewRoleMenuRepository(store repository.Store) *roleMenuRepository {
+func NewRoleMenuRepository(repo *repository.Repository) system.RoleMenuRepository {
 	return &roleMenuRepository{
-		store: store,
+		repo: repo,
 	}
 }
 
 func (r *roleMenuRepository) Create(ctx context.Context, obj []*system.RoleMenu) error {
-	return r.store.DB(ctx).Create(obj).Error
+	return r.repo.DB(ctx).Create(obj).Error
 }
 
 func (r *roleMenuRepository) DeleteByRoleID(ctx context.Context, roleID int32) error {
-	return r.store.DB(ctx).Where("role_id = ?", roleID).Delete(&system.RoleMenu{}).Error
+	return r.repo.DB(ctx).Where("role_id = ?", roleID).Delete(&system.RoleMenu{}).Error
 }
 
 func (r *roleMenuRepository) ListByRoleID(ctx context.Context, roleID int32) ([]*system.RoleMenu, error) {
 	var roleMenus []*system.RoleMenu
-	err := r.store.DB(ctx).Where("role_id = ?", roleID).Find(&roleMenus).Error
+	err := r.repo.DB(ctx).Where("role_id = ?", roleID).Find(&roleMenus).Error
 	if err != nil {
 		return nil, err
 	}

internal/erpserver/repository/system/user.go

@@ -9,28 +9,26 @@ import (
 )
 
 type userRepository struct {
-	store repository.Store
+	repo *repository.Repository
 }
 
-var _ system.UserRepository = (*userRepository)(nil)
-
-func NewUserRepository(store repository.Store) *userRepository {
+func NewUserRepository(repo *repository.Repository) system.UserRepository {
 	return &userRepository{
-		store: store,
+		repo: repo,
 	}
 }
 
 func (s *userRepository) Create(ctx context.Context, obj *system.User) error {
-	return s.store.DB(ctx).Create(obj).Error
+	return s.repo.DB(ctx).Create(obj).Error
 }
 
 func (s *userRepository) Update(ctx context.Context, obj *system.User) error {
-	return s.store.DB(ctx).Save(obj).Error
+	return s.repo.DB(ctx).Save(obj).Error
 }
 
 func (s *userRepository) Get(ctx context.Context, id int32) (*system.User, error) {
 	var user system.User
-	err := s.store.DB(ctx).Where("id = ?", id).First(&user).Error
+	err := s.repo.DB(ctx).Where("id = ?", id).First(&user).Error
 	if err != nil {
 		return nil, err
 	}
@@ -39,7 +37,7 @@ func (s *userRepository) Get(ctx context.Context, id int32) (*system.User, error
 
 func (s *userRepository) GetByEmail(ctx context.Context, email string) (*system.User, error) {
 	var user system.User
-	err := s.store.DB(ctx).Where("email = ?", email).First(&user).Error
+	err := s.repo.DB(ctx).Where("email = ?", email).First(&user).Error
 	if err != nil {
 		return nil, err
 	}
@@ -48,7 +46,7 @@ func (s *userRepository) GetByEmail(ctx context.Context, email string) (*system.
 
 func (s *userRepository) All(ctx context.Context) ([]*system.User, error) {
 	var users []*system.User
-	err := s.store.DB(ctx).Find(&users).Error
+	err := s.repo.DB(ctx).Find(&users).Error
 	if err != nil {
 		return nil, err
 	}
@@ -56,7 +54,7 @@ func (s *userRepository) All(ctx context.Context) ([]*system.User, error) {
 }
 
 func (s *userRepository) List(ctx context.Context, q dto.SearchDto) ([]*system.User, int64, error) {
-	query := s.store.DB(ctx).
+	query := s.repo.DB(ctx).
 		Model(&system.User{}).
 		Preload("Role").
 		Preload("Department").

internal/erpserver/service/service.go

@@ -0,0 +1,30 @@
+package service
+
+import (
+	"management/internal/erpserver/repository"
+	"management/internal/pkg/redis"
+	"management/internal/pkg/session"
+
+	"github.com/drhin/logger"
+)
+
+type Service struct {
+	Log     *logger.Logger
+	Tx      repository.Transaction
+	Session session.Session
+	Redis   redis.Cache
+}
+
+func NewService(
+	log *logger.Logger,
+	tx repository.Transaction,
+	session session.Session,
+	redis redis.Cache,
+) *Service {
+	return &Service{
+		Log:     log,
+		Tx:      tx,
+		Session: session,
+		Redis:   redis,
+	}
+}

internal/erpserver/service/v1/common/captcha.go

@@ -8,13 +8,11 @@ import (
 
 type captchaService struct{}
 
-var _ v1.CaptchaService = (*captchaService)(nil)
-
-func NewCaptchaService() *captchaService {
+func NewCaptchaService() v1.CaptchaService {
 	return &captchaService{}
 }
 
-var captchaStore base64Captcha.Store = base64Captcha.DefaultMemStore
+var captchaStore = base64Captcha.DefaultMemStore
 
 func (b *captchaService) Generate(height int, width int, length int, maxSkew float64, dotCount int) (id, b64s, answer string, err error) {
 	driver := base64Captcha.NewDriverDigit(height, width, length, maxSkew, dotCount)

internal/erpserver/service/v1/service.go

@@ -21,6 +21,9 @@ type ConfigService interface {
 	Get(ctx context.Context, id int32) (*system.Config, error)
 	List(ctx context.Context, q dto.SearchDto) ([]*system.Config, int64, error)
 	Pear(ctx context.Context) (*dto.PearConfig, error)
+
+	RefreshCache(ctx context.Context, key string) error
+	ResetPear(ctx context.Context) error
 }
 
 type UserService interface {

internal/erpserver/service/v1/system/audit_log.go

@@ -5,18 +5,19 @@ import (
 
 	"management/internal/erpserver/model/dto"
 	"management/internal/erpserver/model/system"
+	"management/internal/erpserver/service"
 	v1 "management/internal/erpserver/service/v1"
 )
 
 type auditLogService struct {
+	*service.Service
 	repo system.AuditLogRepository
 }
 
-var _ v1.AuditLogService = (*auditLogService)(nil)
-
-func NewAuditLogService(repo system.AuditLogRepository) *auditLogService {
+func NewAuditLogService(service *service.Service, repo system.AuditLogRepository) v1.AuditLogService {
 	return &auditLogService{
-		repo: repo,
+		Service: service,
+		repo:    repo,
 	}
 }
 

internal/erpserver/service/v1/system/config.go

@@ -3,27 +3,28 @@ package system
 import (
 	"context"
 	"encoding/json"
+	"errors"
 	"time"
 
 	"management/internal/erpserver/model/dto"
 	"management/internal/erpserver/model/system"
+	"management/internal/erpserver/service"
 	v1 "management/internal/erpserver/service/v1"
 	"management/internal/pkg/know"
 	"management/internal/pkg/know/pearadmin"
-	"management/internal/pkg/redis"
+
+	"gorm.io/gorm"
 )
 
 type configService struct {
-	repo  system.ConfigRepository
-	redis redis.RedisCache
+	*service.Service
+	repo system.ConfigRepository
 }
 
-var _ v1.ConfigService = (*configService)(nil)
-
-func NewConfigService(repo system.ConfigRepository, redis redis.RedisCache) *configService {
+func NewConfigService(service *service.Service, repo system.ConfigRepository) v1.ConfigService {
 	return &configService{
-		repo:  repo,
-		redis: redis,
+		Service: service,
+		repo:    repo,
 	}
 }
 
@@ -46,7 +47,7 @@ func (s *configService) List(ctx context.Context, q dto.SearchDto) ([]*system.Co
 func (s *configService) Pear(ctx context.Context) (*dto.PearConfig, error) {
 	// 判断redis是否存储
 	key := know.GetManageKey(ctx, know.PearAdmin)
-	bs, err := s.redis.GetBytes(ctx, key)
+	bs, err := s.Redis.GetBytes(ctx, key)
 	if err == nil {
 		var res *dto.PearConfig
 		if err := json.Unmarshal(bs, &res); err == nil {
@@ -60,10 +61,48 @@ func (s *configService) Pear(ctx context.Context) (*dto.PearConfig, error) {
 	}
 
 	var pear dto.PearConfig
-	if err := json.Unmarshal(conf.Value, &pear); err != nil {
+	if err := json.Unmarshal([]byte(conf.Value), &pear); err != nil {
 		return nil, err
 	}
 
-	_ = s.redis.Set(ctx, key, conf.Value, time.Hour*6)
+	_ = s.Redis.Set(ctx, key, conf.Value, time.Hour*6)
 	return &pear, nil
 }
+
+func (s *configService) RefreshCache(ctx context.Context, key string) error {
+	return s.Redis.Del(ctx, key)
+}
+
+func (s *configService) ResetPear(ctx context.Context) error {
+	b, err := json.Marshal(pearadmin.PearJson)
+	if err != nil {
+		return err
+	}
+
+	conf, err := s.repo.GetByKey(ctx, pearadmin.PearKey)
+	if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
+		return err
+	}
+
+	if errors.Is(err, gorm.ErrRecordNotFound) {
+		// create
+		conf = &system.Config{
+			Key:   pearadmin.PearKey,
+			Value: string(b),
+		}
+		err = s.Create(ctx, conf)
+		if err != nil {
+			return err
+		}
+	} else {
+		// update
+		conf.Value = string(b)
+		conf.UpdatedAt = time.Now()
+		err = s.Update(ctx, conf)
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}

internal/erpserver/service/v1/system/department.go

@@ -12,22 +12,22 @@ import (
 	"management/internal/erpserver/model/form"
 	"management/internal/erpserver/model/system"
 	"management/internal/erpserver/model/view"
+	"management/internal/erpserver/service"
 	v1 "management/internal/erpserver/service/v1"
 	"management/internal/pkg/convertor"
 	"management/internal/pkg/database"
 	"management/internal/pkg/know"
-	"management/internal/pkg/redis"
 )
 
 type departmentService struct {
+	*service.Service
 	repo system.DepartmentRepository
 }
 
-var _ v1.DepartmentService = (*departmentService)(nil)
-
-func NewDepartmentService(repo system.DepartmentRepository) *departmentService {
+func NewDepartmentService(service *service.Service, repo system.DepartmentRepository) v1.DepartmentService {
 	return &departmentService{
-		repo: repo,
+		Service: service,
+		repo:    repo,
 	}
 }
 
@@ -108,7 +108,7 @@ func (s *departmentService) Get(ctx context.Context, id int32) (*system.Departme
 
 func (s *departmentService) All(ctx context.Context) ([]*system.Department, error) {
 	key := know.GetManageKey(ctx, know.AllDepartments)
-	bs, err := redis.GetBytes(ctx, key)
+	bs, err := s.Redis.GetBytes(ctx, key)
 	if err == nil {
 		var res []*system.Department
 		if err := json.Unmarshal(bs, &res); err == nil {
@@ -126,7 +126,7 @@ func (s *departmentService) All(ctx context.Context) ([]*system.Department, erro
 		return nil, err
 	}
 
-	_ = redis.Set(ctx, key, bs, time.Hour*6)
+	_ = s.Redis.Set(ctx, key, bs, time.Hour*6)
 	return res, nil
 }
 
@@ -146,7 +146,7 @@ func (s *departmentService) RefreshCache(ctx context.Context) error {
 		return err
 	}
 
-	_ = redis.Set(ctx, key, b, time.Hour*6)
+	_ = s.Redis.Set(ctx, key, b, time.Hour*6)
 	return nil
 }
 

internal/erpserver/service/v1/system/login_log.go

@@ -6,18 +6,19 @@ import (
 
 	"management/internal/erpserver/model/dto"
 	"management/internal/erpserver/model/system"
+	"management/internal/erpserver/service"
 	v1 "management/internal/erpserver/service/v1"
 )
 
 type loginLogService struct {
+	*service.Service
 	repo system.LoginLogRepository
 }
 
-var _ v1.LoginLogService = (*loginLogService)(nil)
-
-func NewLoginLogService(repo system.LoginLogRepository) *loginLogService {
+func NewLoginLogService(service *service.Service, repo system.LoginLogRepository) v1.LoginLogService {
 	return &loginLogService{
-		repo: repo,
+		Service: service,
+		repo:    repo,
 	}
 }
 

internal/erpserver/service/v1/system/menu.go

@@ -10,29 +10,29 @@ import (
 	"management/internal/erpserver/model/dto"
 	"management/internal/erpserver/model/system"
 	"management/internal/erpserver/model/view"
-	"management/internal/erpserver/repository"
+	"management/internal/erpserver/service"
 	v1 "management/internal/erpserver/service/v1"
 	"management/internal/pkg/know"
-	"management/internal/pkg/redis"
 )
 
 type menuService struct {
-	redis       redis.RedisCache
-	store       repository.Store
-	repo        system.MenuRepository
-	rolesvc     v1.RoleService
-	rolemenusvc v1.RoleMenuService
+	*service.Service
+	repo            system.MenuRepository
+	roleService     v1.RoleService
+	roleMenuService v1.RoleMenuService
 }
 
-var _ v1.MenuService = (*menuService)(nil)
-
-func NewMenuService(redis redis.RedisCache, store repository.Store, repo system.MenuRepository, rolesvc v1.RoleService, rolemenusvc v1.RoleMenuService) *menuService {
+func NewMenuService(
+	service *service.Service,
+	repo system.MenuRepository,
+	roleService v1.RoleService,
+	roleMenuService v1.RoleMenuService,
+) v1.MenuService {
 	return &menuService{
-		redis:       redis,
-		store:       store,
-		repo:        repo,
-		rolesvc:     rolesvc,
-		rolemenusvc: rolemenusvc,
+		Service:         service,
+		repo:            repo,
+		roleService:     roleService,
+		roleMenuService: roleMenuService,
 	}
 }
 
@@ -54,7 +54,7 @@ func (s *menuService) GetByUrl(ctx context.Context, url string) (*system.Menu, e
 
 func (s *menuService) All(ctx context.Context) ([]*system.Menu, error) {
 	key := know.GetManageKey(ctx, know.AllMenus)
-	b, err := s.redis.GetBytes(ctx, key)
+	b, err := s.Redis.GetBytes(ctx, key)
 	if err == nil {
 		var res []*system.Menu
 		if err := json.Unmarshal(b, &res); err == nil {
@@ -72,7 +72,7 @@ func (s *menuService) All(ctx context.Context) ([]*system.Menu, error) {
 		return nil, err
 	}
 
-	_ = s.redis.Set(ctx, key, b, time.Hour*6)
+	_ = s.Redis.Set(ctx, key, b, time.Hour*6)
 	return res, nil
 }
 
@@ -87,7 +87,7 @@ func (s *menuService) ListMenuTree(ctx context.Context) ([]*view.MenuTree, error
 
 func (s *menuService) ListByRoleID(ctx context.Context, roleID int32) ([]*dto.OwnerMenuDto, error) {
 	key := know.GetManageKey(ctx, know.OwnerMenus, roleID)
-	bs, err := s.redis.GetBytes(ctx, key)
+	bs, err := s.Redis.GetBytes(ctx, key)
 	if err == nil {
 		var res []*dto.OwnerMenuDto
 		if err := json.Unmarshal(bs, &res); err == nil {
@@ -111,13 +111,13 @@ func (s *menuService) SetListByRoleID(ctx context.Context, roleID int32) ([]*dto
 		return nil, err
 	}
 
-	_ = s.redis.Set(ctx, key, b, time.Hour*6)
+	_ = s.Redis.Set(ctx, key, b, time.Hour*6)
 	return res, nil
 }
 
 func (s *menuService) ListByRoleIDToMap(ctx context.Context, roleID int32) (map[string]*dto.OwnerMenuDto, error) {
 	key := know.GetManageKey(ctx, know.OwnerMenusMap, roleID)
-	bs, err := s.redis.GetBytes(ctx, key)
+	bs, err := s.Redis.GetBytes(ctx, key)
 	if err == nil {
 		var res map[string]*dto.OwnerMenuDto
 		if err := json.Unmarshal(bs, &res); err == nil {
@@ -141,13 +141,13 @@ func (s *menuService) SetListByRoleIDToMap(ctx context.Context, roleID int32) (m
 		return nil, err
 	}
 
-	_ = s.redis.Set(ctx, key, b, time.Hour*6)
+	_ = s.Redis.Set(ctx, key, b, time.Hour*6)
 	return res, nil
 }
 
 func (s *menuService) OwerMenus(ctx context.Context, roleID int32) ([]*dto.MenuUIDto, error) {
 	key := know.GetManageKey(ctx, know.AdminMenus, roleID)
-	bs, err := s.redis.GetBytes(ctx, key)
+	bs, err := s.Redis.GetBytes(ctx, key)
 	if err == nil {
 		var res []*dto.MenuUIDto
 		if err := json.Unmarshal(bs, &res); err == nil {
@@ -172,7 +172,7 @@ func (s *menuService) SetOwerMenus(ctx context.Context, roleID int32) ([]*dto.Me
 		return nil, err
 	}
 
-	_ = s.redis.Set(ctx, key, b, time.Hour*6)
+	_ = s.Redis.Set(ctx, key, b, time.Hour*6)
 	return res, nil
 }
 
@@ -193,15 +193,15 @@ func (s *menuService) MenuViewData(ctx context.Context, roleID int32) ([]*dto.Se
 
 func (s *menuService) SetRoleMenu(ctx context.Context, roleID int32, rms []*system.RoleMenu) error {
 	// 开启事务
-	return s.store.TX(ctx, func(ctx context.Context) error {
+	return s.Tx.Transaction(ctx, func(ctx context.Context) error {
 		// 先删除该角色的所有权限
-		err := s.rolemenusvc.DeleteByRoleID(ctx, roleID)
+		err := s.roleMenuService.DeleteByRoleID(ctx, roleID)
 		if err != nil {
 			return err
 		}
 
 		// 再添加该角色的所有权限
-		return s.rolemenusvc.Create(ctx, rms)
+		return s.roleMenuService.Create(ctx, rms)
 	})
 }
 
@@ -217,7 +217,7 @@ func (s *menuService) RefreshCache(ctx context.Context) error {
 		return err
 	}
 
-	_ = redis.Set(ctx, key, b, time.Hour*6)
+	_ = s.Redis.Set(ctx, key, b, time.Hour*6)
 	return nil
 }
 
@@ -245,7 +245,7 @@ func (s *menuService) XmSelectTree(ctx context.Context, id int32) ([]*view.XmSel
 
 // listByRoleID 获取该角色所拥有的菜单集合
 func (s *menuService) listByRoleID(ctx context.Context, roleID int32) ([]*system.Menu, error) {
-	role, err := s.rolesvc.Get(ctx, roleID)
+	role, err := s.roleService.Get(ctx, roleID)
 	if err != nil {
 		return nil, err
 	}
@@ -260,7 +260,7 @@ func (s *menuService) listByRoleID(ctx context.Context, roleID int32) ([]*system
 	}
 
 	// 通过角色获取所拥有的权限
-	roleMenus, err := s.rolemenusvc.ListByRoleID(ctx, roleID)
+	roleMenus, err := s.roleMenuService.ListByRoleID(ctx, roleID)
 	if err != nil {
 		return nil, err
 	}

internal/erpserver/service/v1/system/role.go

@@ -12,22 +12,22 @@ import (
 	"management/internal/erpserver/model/form"
 	"management/internal/erpserver/model/system"
 	"management/internal/erpserver/model/view"
+	"management/internal/erpserver/service"
 	v1 "management/internal/erpserver/service/v1"
 	"management/internal/pkg/convertor"
 	"management/internal/pkg/database"
 	"management/internal/pkg/know"
-	"management/internal/pkg/redis"
 )
 
 type roleService struct {
+	*service.Service
 	repo system.RoleRepository
 }
 
-var _ v1.RoleService = (*roleService)(nil)
-
-func NewRoleService(repo system.RoleRepository) *roleService {
+func NewRoleService(service *service.Service, repo system.RoleRepository) v1.RoleService {
 	return &roleService{
-		repo: repo,
+		Service: service,
+		repo:    repo,
 	}
 }
 
@@ -111,7 +111,7 @@ func (s *roleService) Get(ctx context.Context, id int32) (*system.Role, error) {
 
 func (s *roleService) All(ctx context.Context) ([]*system.Role, error) {
 	key := know.GetManageKey(ctx, know.AllRoles)
-	bs, err := redis.GetBytes(ctx, key)
+	bs, err := s.Redis.GetBytes(ctx, key)
 	if err == nil {
 		var res []*system.Role
 		if err := json.Unmarshal(bs, &res); err == nil {
@@ -129,7 +129,7 @@ func (s *roleService) All(ctx context.Context) ([]*system.Role, error) {
 		return nil, err
 	}
 
-	_ = redis.Set(ctx, key, bs, time.Hour*6)
+	_ = s.Redis.Set(ctx, key, bs, time.Hour*6)
 	return res, nil
 }
 
@@ -149,7 +149,7 @@ func (s *roleService) RefreshCache(ctx context.Context) error {
 		return err
 	}
 
-	_ = redis.Set(ctx, key, b, time.Hour*6)
+	_ = s.Redis.Set(ctx, key, b, time.Hour*6)
 	return nil
 }
 

internal/erpserver/service/v1/system/role_menu.go

@@ -4,18 +4,19 @@ import (
 	"context"
 
 	"management/internal/erpserver/model/system"
+	"management/internal/erpserver/service"
 	v1 "management/internal/erpserver/service/v1"
 )
 
 type roleMenuService struct {
+	*service.Service
 	repo system.RoleMenuRepository
 }
 
-var _ v1.RoleMenuService = (*roleMenuService)(nil)
-
-func NewRoleMenuService(repo system.RoleMenuRepository) *roleMenuService {
+func NewRoleMenuService(service *service.Service, repo system.RoleMenuRepository) v1.RoleMenuService {
 	return &roleMenuService{
-		repo: repo,
+		Service: service,
+		repo:    repo,
 	}
 }
 

internal/erpserver/service/v1/system/user.go

@@ -11,39 +11,39 @@ import (
 	"management/internal/erpserver/model/form"
 	"management/internal/erpserver/model/system"
 	"management/internal/erpserver/model/view"
+	"management/internal/erpserver/service"
 	v1 "management/internal/erpserver/service/v1"
 	"management/internal/pkg/crypto"
 	"management/internal/pkg/database"
 	"management/internal/pkg/know"
 	"management/internal/pkg/rand"
-	"management/internal/pkg/session"
 
-	"github.com/drhin/logger"
 	"github.com/google/uuid"
 	"go.uber.org/zap"
 )
 
 type userService struct {
-	session         session.Session
-	log             *logger.Logger
+	*service.Service
 	repo            system.UserRepository
 	roleService     v1.RoleService
 	loginLogService v1.LoginLogService
 }
 
-var _ v1.UserService = (*userService)(nil)
-
-func NewUserService(session session.Session, log *logger.Logger, repo system.UserRepository, roleService v1.RoleService, loginLogService v1.LoginLogService) *userService {
+func NewUserService(
+	service *service.Service,
+	repo system.UserRepository,
+	roleService v1.RoleService,
+	loginLogService v1.LoginLogService,
+) v1.UserService {
 	return &userService{
-		session:         session,
-		log:             log,
+		Service:         service,
 		repo:            repo,
 		roleService:     roleService,
 		loginLogService: loginLogService,
 	}
 }
 
-func (b *userService) Create(ctx context.Context, req *form.User) error {
+func (s *userService) Create(ctx context.Context, req *form.User) error {
 	salt, err := rand.String(10)
 	if err != nil {
 		return err
@@ -74,7 +74,7 @@ func (b *userService) Create(ctx context.Context, req *form.User) error {
 		CreatedAt:        time.Now(),
 		UpdatedAt:        time.Now(),
 	}
-	err = b.repo.Create(ctx, user)
+	err = s.repo.Create(ctx, user)
 	if err != nil {
 		if database.IsUniqueViolation(err) {
 			return errors.New("用户已经存在")
@@ -84,8 +84,8 @@ func (b *userService) Create(ctx context.Context, req *form.User) error {
 	return nil
 }
 
-func (b *userService) Update(ctx context.Context, req *form.User) error {
-	user, err := b.repo.Get(ctx, *req.ID)
+func (s *userService) Update(ctx context.Context, req *form.User) error {
+	user, err := s.repo.Get(ctx, *req.ID)
 	if err != nil {
 		return err
 	}
@@ -105,23 +105,23 @@ func (b *userService) Update(ctx context.Context, req *form.User) error {
 		user.HashedPassword = hashedPassword
 		user.ChangePasswordAt = time.Now()
 	}
-	return b.repo.Update(ctx, user)
+	return s.repo.Update(ctx, user)
 }
 
-func (b *userService) All(ctx context.Context) ([]*system.User, error) {
-	return b.repo.All(ctx)
+func (s *userService) All(ctx context.Context) ([]*system.User, error) {
+	return s.repo.All(ctx)
 }
 
-func (b *userService) List(ctx context.Context, q dto.SearchDto) ([]*system.User, int64, error) {
-	return b.repo.List(ctx, q)
+func (s *userService) List(ctx context.Context, q dto.SearchDto) ([]*system.User, int64, error) {
+	return s.repo.List(ctx, q)
 }
 
-func (b *userService) Get(ctx context.Context, id int32) (*system.User, error) {
-	return b.repo.Get(ctx, id)
+func (s *userService) Get(ctx context.Context, id int32) (*system.User, error) {
+	return s.repo.Get(ctx, id)
 }
 
-func (b *userService) XmSelect(ctx context.Context) ([]*view.XmSelect, error) {
-	all, err := b.repo.All(ctx)
+func (s *userService) XmSelect(ctx context.Context) ([]*view.XmSelect, error) {
+	all, err := s.repo.All(ctx)
 	if err != nil || len(all) == 0 {
 		return nil, err
 	}
@@ -136,24 +136,24 @@ func (b *userService) XmSelect(ctx context.Context) ([]*view.XmSelect, error) {
 	return res, nil
 }
 
-func (b *userService) Login(ctx context.Context, req *form.Login) error {
+func (s *userService) Login(ctx context.Context, req *form.Login) error {
 	l := system.NewLoginLog(req.Email, req.Os, req.Ip, req.Browser, req.Url, req.Referrer)
-	err := b.login(ctx, req)
+	err := s.login(ctx, req)
 	if err != nil {
-		if err := b.loginLogService.Create(ctx, l.SetMessage(err.Error())); err != nil {
-			b.log.Error(err.Error(), err, zap.Any("login_log", l))
+		if err := s.loginLogService.Create(ctx, l.SetMessage(err.Error())); err != nil {
+			s.Log.Error(err.Error(), err, zap.Any("login_log", l))
 		}
 		return err
 	}
 
-	if err := b.loginLogService.Create(ctx, l.SetOk("登录成功")); err != nil {
-		b.log.Error(err.Error(), err, zap.Any("login_log", l))
+	if err := s.loginLogService.Create(ctx, l.SetOk("登录成功")); err != nil {
+		s.Log.Error(err.Error(), err, zap.Any("login_log", l))
 	}
 	return nil
 }
 
-func (b *userService) login(ctx context.Context, req *form.Login) error {
-	user, err := b.repo.GetByEmail(ctx, req.Email)
+func (s *userService) login(ctx context.Context, req *form.Login) error {
+	user, err := s.repo.GetByEmail(ctx, req.Email)
 	if err != nil {
 		return err
 	}
@@ -163,7 +163,7 @@ func (b *userService) login(ctx context.Context, req *form.Login) error {
 		return errors.New("账号或密码错误")
 	}
 
-	user.Role, err = b.roleService.Get(ctx, user.RoleID)
+	user.Role, err = s.roleService.Get(ctx, user.RoleID)
 	if err != nil {
 		return err
 	}
@@ -172,7 +172,7 @@ func (b *userService) login(ctx context.Context, req *form.Login) error {
 	}
 
 	// 登陆成功
-	err = b.loginSuccess(ctx, user, req)
+	err = s.loginSuccess(ctx, user, req)
 	if err != nil {
 		return err
 	}
@@ -180,7 +180,7 @@ func (b *userService) login(ctx context.Context, req *form.Login) error {
 	return nil
 }
 
-func (b *userService) loginSuccess(ctx context.Context, user *system.User, req *form.Login) error {
+func (s *userService) loginSuccess(ctx context.Context, user *system.User, req *form.Login) error {
 	auth := dto.AuthorizeUser{
 		ID:       user.ID,
 		Uuid:     user.Uuid,
@@ -198,6 +198,6 @@ func (b *userService) loginSuccess(ctx context.Context, user *system.User, req *
 		return err
 	}
 
-	b.session.Put(ctx, know.StoreName, gob)
+	s.Session.Put(ctx, know.StoreName, gob)
 	return nil
 }

internal/erpserver/wire.go

@@ -0,0 +1,82 @@
+//go:build wireinject
+// +build wireinject
+
+package erpserver
+
+import (
+	"management/internal/erpserver/handler"
+	commonHandler "management/internal/erpserver/handler/common"
+	systemHandler "management/internal/erpserver/handler/system"
+	"management/internal/erpserver/repository"
+	systemRepo "management/internal/erpserver/repository/system"
+	"management/internal/erpserver/service"
+	commonService "management/internal/erpserver/service/v1/common"
+	systemService "management/internal/erpserver/service/v1/system"
+	"management/internal/pkg/config"
+	"management/internal/pkg/middleware"
+	"management/internal/pkg/redis"
+	"management/internal/pkg/render"
+	"management/internal/pkg/session"
+
+	"github.com/drhin/logger"
+	"github.com/go-chi/chi/v5"
+	"github.com/google/wire"
+)
+
+var repositorySet = wire.NewSet(
+	repository.NewDB,
+	repository.NewRepository,
+	repository.NewTransaction,
+	systemRepo.NewUserRepository,
+	systemRepo.NewLoginLogRepository,
+	systemRepo.NewAuditLogRepository,
+	systemRepo.NewRoleRepository,
+	systemRepo.NewMenuRepository,
+	systemRepo.NewRoleMenuRepository,
+	systemRepo.NewDepartmentRepository,
+	systemRepo.NewConfigRepository,
+)
+
+var serviceSet = wire.NewSet(
+	service.NewService,
+	commonService.NewCaptchaService,
+	systemService.NewUserService,
+	systemService.NewLoginLogService,
+	systemService.NewAuditLogService,
+	systemService.NewRoleService,
+	systemService.NewMenuService,
+	systemService.NewRoleMenuService,
+	systemService.NewDepartmentService,
+	systemService.NewConfigService,
+)
+
+var handlerSet = wire.NewSet(
+	handler.NewHandler,
+	commonHandler.NewCaptchaHandler,
+	commonHandler.NewUploadHandler,
+	systemHandler.NewHomeHandler,
+	systemHandler.NewUserHandler,
+	systemHandler.NewLoginLogHandler,
+	systemHandler.NewAuditHandler,
+	systemHandler.NewRoleHandler,
+	systemHandler.NewMenuHandler,
+	systemHandler.NewDepartmentHandler,
+	systemHandler.NewConfigHandler,
+)
+
+var serverSet = wire.NewSet(
+	NewHTTPServer,
+)
+
+func NewWire(*config.Config, *logger.Logger) (*chi.Mux, func(), error) {
+	panic(wire.Build(
+		repositorySet,
+		redis.New,
+		session.New,
+		serviceSet,
+		middleware.New,
+		render.New,
+		handlerSet,
+		serverSet,
+	))
+}

internal/erpserver/wire_gen.go

@@ -0,0 +1,96 @@
+// Code generated by Wire. DO NOT EDIT.
+
+//go:generate go run -mod=mod github.com/google/wire/cmd/wire
+//go:build !wireinject
+// +build !wireinject
+
+package erpserver
+
+import (
+	"github.com/drhin/logger"
+	"github.com/go-chi/chi/v5"
+	"github.com/google/wire"
+	"management/internal/erpserver/handler"
+	common2 "management/internal/erpserver/handler/common"
+	system3 "management/internal/erpserver/handler/system"
+	"management/internal/erpserver/repository"
+	"management/internal/erpserver/repository/system"
+	"management/internal/erpserver/service"
+	"management/internal/erpserver/service/v1/common"
+	system2 "management/internal/erpserver/service/v1/system"
+	"management/internal/pkg/config"
+	"management/internal/pkg/middleware"
+	"management/internal/pkg/redis"
+	"management/internal/pkg/render"
+	"management/internal/pkg/session"
+)
+
+// Injectors from wire.go:
+
+func NewWire(configConfig *config.Config, loggerLogger *logger.Logger) (*chi.Mux, func(), error) {
+	db, cleanup, err := repository.NewDB(loggerLogger, configConfig)
+	if err != nil {
+		return nil, nil, err
+	}
+	sessionSession := session.New(db, configConfig)
+	repositoryRepository := repository.NewRepository(db, loggerLogger)
+	transaction := repository.NewTransaction(repositoryRepository)
+	cache, cleanup2, err := redis.New(configConfig, loggerLogger)
+	if err != nil {
+		cleanup()
+		return nil, nil, err
+	}
+	serviceService := service.NewService(loggerLogger, transaction, sessionSession, cache)
+	menuRepository := system.NewMenuRepository(repositoryRepository)
+	roleRepository := system.NewRoleRepository(repositoryRepository)
+	roleService := system2.NewRoleService(serviceService, roleRepository)
+	roleMenuRepository := system.NewRoleMenuRepository(repositoryRepository)
+	roleMenuService := system2.NewRoleMenuService(serviceService, roleMenuRepository)
+	menuService := system2.NewMenuService(serviceService, menuRepository, roleService, roleMenuService)
+	auditLogRepository := system.NewAuditLogRepository(repositoryRepository)
+	auditLogService := system2.NewAuditLogService(serviceService, auditLogRepository)
+	middlewareMiddleware := middleware.New(sessionSession, menuService, auditLogService)
+	renderRender, err := render.New(sessionSession, menuService)
+	if err != nil {
+		cleanup2()
+		cleanup()
+		return nil, nil, err
+	}
+	handlerHandler := handler.NewHandler(configConfig, loggerLogger, middlewareMiddleware, renderRender)
+	captchaService := common.NewCaptchaService()
+	captchaHandler := common2.NewCaptchaHandler(handlerHandler, captchaService)
+	uploadHandler := common2.NewUploadHandler(handlerHandler)
+	configRepository := system.NewConfigRepository(repositoryRepository)
+	configService := system2.NewConfigService(serviceService, configRepository)
+	configHandler := system3.NewConfigHandler(handlerHandler, configService)
+	userRepository := system.NewUserRepository(repositoryRepository)
+	loginLogRepository := system.NewLoginLogRepository(repositoryRepository)
+	loginLogService := system2.NewLoginLogService(serviceService, loginLogRepository)
+	userService := system2.NewUserService(serviceService, userRepository, roleService, loginLogService)
+	homeHandler := system3.NewHomeHandler(handlerHandler, userService, loginLogService)
+	departmentRepository := system.NewDepartmentRepository(repositoryRepository)
+	departmentService := system2.NewDepartmentService(serviceService, departmentRepository)
+	userHandler := system3.NewUserHandler(handlerHandler, captchaService, userService, roleService, departmentService)
+	loginLogHandler := system3.NewLoginLogHandler(handlerHandler, loginLogService)
+	auditHandler := system3.NewAuditHandler(handlerHandler, auditLogService)
+	menuHandler := system3.NewMenuHandler(handlerHandler, menuService)
+	roleHandler := system3.NewRoleHandler(handlerHandler, roleService, menuService)
+	departmentHandler := system3.NewDepartmentHandler(handlerHandler, departmentService)
+	mux := NewHTTPServer(middlewareMiddleware, captchaHandler, uploadHandler, configHandler, homeHandler, userHandler, loginLogHandler, auditHandler, menuHandler, roleHandler, departmentHandler)
+	return mux, func() {
+		cleanup2()
+		cleanup()
+	}, nil
+}
+
+// wire.go:
+
+var repositorySet = wire.NewSet(repository.NewDB, repository.NewRepository, repository.NewTransaction, system.NewUserRepository, system.NewLoginLogRepository, system.NewAuditLogRepository, system.NewRoleRepository, system.NewMenuRepository, system.NewRoleMenuRepository, system.NewDepartmentRepository, system.NewConfigRepository)
+
+var serviceSet = wire.NewSet(service.NewService, common.NewCaptchaService, system2.NewUserService, system2.NewLoginLogService, system2.NewAuditLogService, system2.NewRoleService, system2.NewMenuService, system2.NewRoleMenuService, system2.NewDepartmentService, system2.NewConfigService)
+
+var handlerSet = wire.NewSet(handler.NewHandler, common2.NewCaptchaHandler, common2.NewUploadHandler, system3.NewHomeHandler, system3.NewUserHandler, system3.NewLoginLogHandler, system3.NewAuditHandler, system3.NewRoleHandler, system3.NewMenuHandler, system3.NewDepartmentHandler, system3.NewConfigHandler)
+
+var serverSet = wire.NewSet(
+	NewHTTPServer,
+)