v1

internal/erpserver/handler/system/audit.go

@@ -0,0 +1,35 @@
+package system
+
+import (
+	"management/internal/erpserver/model/system/request"
+	v1 "management/internal/erpserver/service/v1"
+	"management/internal/pkg/gin/gu"
+
+	"github.com/gin-gonic/gin"
+)
+
+type AuditApp struct {
+	auditLogService v1.AuditLogService
+}
+
+func NewAuditApp(auditLogService v1.AuditLogService) *AuditApp {
+	return &AuditApp{
+		auditLogService: auditLogService,
+	}
+}
+
+func (a *AuditApp) List(c *gin.Context) {
+	var req request.ListAudit
+	if err := c.ShouldBindQuery(&req); err != nil {
+		gu.ValidatorErrors(c, err)
+		return
+	}
+
+	res, count, err := a.auditLogService.List(c, req)
+	if err != nil {
+		gu.Failed(c, err.Error())
+		return
+	}
+
+	gu.Ok(c, gu.NewPageData(count, req.PageID, req.PageSize, res))
+}

internal/erpserver/handler/system/audit/audit.go

@@ -1,46 +0,0 @@
-package audit
-
-import (
-	"net/http"
-
-	"management/internal/erpserver/model/dto"
-	v1 "management/internal/erpserver/service/v1"
-	"management/internal/erpserver/templ/system/auditlog"
-	"management/internal/pkg/convertor"
-	"management/internal/pkg/render"
-)
-
-type app struct {
-	render          render.Renderer
-	auditLogService v1.AuditLogService
-}
-
-func newApp(render render.Renderer, auditLogService v1.AuditLogService) *app {
-	return &app{
-		render:          render,
-		auditLogService: auditLogService,
-	}
-}
-
-func (a *app) list(w http.ResponseWriter, r *http.Request) {
-	switch r.Method {
-	case http.MethodGet:
-		ctx := r.Context()
-		a.render.Render(ctx, w, auditlog.List(ctx))
-	case http.MethodPost:
-		var q dto.SearchDto
-		q.SearchTimeBegin, q.SearchTimeEnd = convertor.DefaultTime(r.PostFormValue("timeBegin"), r.PostFormValue("timeEnd"))
-		q.SearchName = r.PostFormValue("name")
-		q.SearchEmail = r.PostFormValue("email")
-		q.Page = convertor.Int(r.PostFormValue("page"), 1)
-		q.Rows = convertor.Int(r.PostFormValue("rows"), 10)
-		res, count, err := a.auditLogService.List(r.Context(), q)
-		if err != nil {
-			a.render.JSONErr(w, err.Error())
-			return
-		}
-		a.render.JSON(w, render.NewResponseList(count, res))
-	default:
-		http.Error(w, "Method Not Allowed", http.StatusMethodNotAllowed)
-	}
-}

internal/erpserver/handler/system/audit/route.go

@@ -1,25 +0,0 @@
-package audit
-
-import (
-	v1 "management/internal/erpserver/service/v1"
-	"management/internal/pkg/render"
-	"management/internal/pkg/session"
-
-	"github.com/go-chi/chi/v5"
-)
-
-type Config struct {
-	Sm              session.Manager
-	Render          render.Renderer
-	MenuService     v1.MenuService
-	AuditLogService v1.AuditLogService
-}
-
-func Routes(r chi.Router, cfg Config) {
-	app := newApp(cfg.Render, cfg.AuditLogService)
-
-	r.Route("/audit_log", func(r chi.Router) {
-		r.Get("/list", app.list)
-		r.Post("/list", app.list)
-	})
-}

internal/erpserver/handler/system/auth/auth.go

@@ -1,104 +0,0 @@
-package auth
-
-import (
-	"io"
-	"log"
-	"net/http"
-
-	"management/internal/erpserver/model/form"
-	v1 "management/internal/erpserver/service/v1"
-	authv1 "management/internal/erpserver/service/v1/auth"
-	"management/internal/erpserver/templ/auth"
-	"management/internal/pkg/binding"
-	"management/internal/pkg/mid"
-	"management/internal/pkg/render"
-	"management/internal/pkg/session"
-
-	"github.com/drhin/logger"
-)
-
-type app struct {
-	log            *logger.Logger
-	sm             session.Manager
-	render         render.Renderer
-	captchaService v1.CaptchaService
-	userService    v1.UserService
-	authService    *authv1.Auth
-}
-
-func newApp(
-	log *logger.Logger,
-	sm session.Manager,
-	render render.Renderer,
-	captchaService v1.CaptchaService,
-	userService v1.UserService,
-	authService *authv1.Auth,
-) *app {
-	return &app{
-		log:            log,
-		sm:             sm,
-		render:         render,
-		captchaService: captchaService,
-		userService:    userService,
-		authService:    authService,
-	}
-}
-
-func (a *app) login(w http.ResponseWriter, r *http.Request) {
-	ctx := r.Context()
-	switch r.Method {
-	case http.MethodGet:
-		u := mid.GetUser(ctx)
-		if u.ID > 0 {
-			if err := a.sm.RenewToken(ctx); err == nil {
-				http.Redirect(w, r, "/home.html", http.StatusFound)
-				return
-			}
-		}
-
-		_ = a.sm.Destroy(ctx)
-		component := auth.Login(ctx)
-		a.render.Render(ctx, w, component)
-	case http.MethodPost:
-		defer func(Body io.ReadCloser) {
-			err := Body.Close()
-			if err != nil {
-				a.log.Error(err.Error(), err)
-			}
-		}(r.Body)
-		var req form.Login
-		if err := binding.Form.Bind(r, &req); err != nil {
-			e := binding.ValidatorErrors(err)
-			a.render.JSONErr(w, e)
-			return
-		}
-
-		if !a.captchaService.Verify(req.CaptchaID, req.Captcha, true) {
-			a.render.JSONErr(w, "验证码错误")
-			return
-		}
-
-		req = req.SetAttributes(r)
-		//err := a.userService.Login(ctx, &req)
-		risk, err := a.authService.Authenticate(ctx, req)
-		if err != nil {
-			log.Println(err)
-			a.render.JSONErr(w, err.Error())
-			return
-		}
-
-		log.Println(risk)
-
-		a.render.JSONOk(w, "login successfully")
-	default:
-		http.Error(w, "Method Not Allowed", http.StatusMethodNotAllowed)
-	}
-}
-
-func (a *app) logout(w http.ResponseWriter, r *http.Request) {
-	err := a.sm.Destroy(r.Context())
-	if err != nil {
-		a.log.Error(err.Error(), err)
-	}
-	http.Redirect(w, r, "/", http.StatusFound)
-}

internal/erpserver/handler/system/auth/route.go

@@ -1,31 +0,0 @@
-package auth
-
-import (
-	v1 "management/internal/erpserver/service/v1"
-	"management/internal/erpserver/service/v1/auth"
-	"management/internal/pkg/mid"
-	"management/internal/pkg/render"
-	"management/internal/pkg/session"
-
-	"github.com/drhin/logger"
-	"github.com/go-chi/chi/v5"
-)
-
-type Config struct {
-	Log            *logger.Logger
-	Sm             session.Manager
-	Render         render.Renderer
-	CaptchaService v1.CaptchaService
-	AuthService    *auth.Auth
-	UserService    v1.UserService
-	MenuService    v1.MenuService
-}
-
-func Routes(r chi.Router, cfg Config) {
-	app := newApp(cfg.Log, cfg.Sm, cfg.Render, cfg.CaptchaService, cfg.UserService, cfg.AuthService)
-
-	r.Get("/", app.login)
-	r.Post("/login", app.login)
-	r.With(mid.Authorize(cfg.Sm, cfg.MenuService)).Get("/logout", app.logout)
-
-}

internal/erpserver/handler/system/config.go

@@ -0,0 +1,143 @@
+package system
+
+import (
+	"errors"
+	"net/http"
+	"strings"
+
+	"management/internal/erpserver/model/system"
+	"management/internal/erpserver/model/system/request"
+	"management/internal/erpserver/service/v1"
+	"management/internal/pkg/convertor"
+	"management/internal/pkg/gin/gu"
+	"management/internal/pkg/sqldb"
+
+	"github.com/gin-gonic/gin"
+)
+
+type ConfigApp struct {
+	configService v1.ConfigService
+}
+
+func NewConfigApp(configService v1.ConfigService) *ConfigApp {
+	return &ConfigApp{
+		configService: configService,
+	}
+}
+
+func (a *ConfigApp) Create(c *gin.Context) {
+	var req request.CreateAndUpdateConfig
+	if err := c.ShouldBindJSON(&req); err != nil {
+		gu.ValidatorErrors(c, err)
+		return
+	}
+
+	arg := system.Config{
+		Key:   req.Key,
+		Value: []byte(req.Value),
+	}
+	if err := a.configService.Create(c, &arg); err != nil {
+		if errors.Is(err, sqldb.ErrDBDuplicatedEntry) {
+			gu.FailedWithCode(c, http.StatusConflict, "配置已存在")
+			return
+		}
+
+		gu.Failed(c, err.Error())
+		return
+	}
+
+	gu.Ok(c, "添加成功")
+}
+
+func (a *ConfigApp) Update(c *gin.Context) {
+	var id request.GetID
+	if err := c.ShouldBindUri(&id); err != nil {
+		gu.ValidatorErrors(c, err)
+		return
+	}
+
+	var req request.CreateAndUpdateConfig
+	if err := c.ShouldBindJSON(&req); err != nil {
+		gu.ValidatorErrors(c, err)
+		return
+	}
+
+	arg := system.Config{
+		ID:    id.ID,
+		Key:   req.Key,
+		Value: []byte(req.Value),
+	}
+	if err := a.configService.Update(c, &arg); err != nil {
+		gu.Failed(c, err.Error())
+		return
+	}
+
+	gu.Ok(c, "更新成功")
+}
+
+func (a *ConfigApp) Get(c *gin.Context) {
+	id := convertor.Int[int32](c.Param("id"), 0)
+	if id == 0 {
+		gu.FailedWithCode(c, http.StatusBadRequest, "ID不能为空")
+		return
+	}
+
+	config, err := a.configService.Get(c, id)
+	if err != nil {
+		if errors.Is(err, sqldb.ErrDBNotFound) {
+			gu.FailedWithCode(c, http.StatusNotFound, "配置不存在")
+			return
+		}
+
+		gu.Failed(c, err.Error())
+		return
+	}
+
+	gu.Ok(c, config)
+}
+
+func (a *ConfigApp) List(c *gin.Context) {
+	var req request.ListConfig
+	if err := c.ShouldBindQuery(&req); err != nil {
+		gu.ValidatorErrors(c, err)
+		return
+	}
+
+	res, count, err := a.configService.List(c, req)
+	if err != nil {
+		gu.Failed(c, err.Error())
+		return
+	}
+
+	gu.Ok(c, gu.NewPageData(count, req.PageID, req.PageSize, res))
+}
+
+func (a *ConfigApp) Refresh(c *gin.Context) {
+	key := c.PostForm("key")
+	err := a.configService.RefreshCache(c, strings.ToLower(key))
+	if err != nil {
+		gu.Failed(c, err.Error())
+		return
+	}
+
+	gu.Ok(c, "刷新成功")
+}
+
+func (a *ConfigApp) ResetPear(c *gin.Context) {
+	err := a.configService.ResetPear(c)
+	if err != nil {
+		gu.Failed(c, err.Error())
+		return
+	}
+	gu.Ok(c, "重置成功")
+}
+
+func (a *ConfigApp) Pear(c *gin.Context) {
+	pear, err := a.configService.Pear(c)
+	if err != nil {
+		gu.Failed(c, err.Error())
+		return
+	}
+
+	gu.Ok(c, pear)
+}

internal/erpserver/handler/system/config/config.go

@@ -1,149 +0,0 @@
-package config
-
-import (
-	"encoding/json"
-	"net/http"
-	"strings"
-
-	"management/internal/erpserver/model/dto"
-	systemModel "management/internal/erpserver/model/system"
-	"management/internal/erpserver/model/view"
-	systemService "management/internal/erpserver/service/v1"
-	"management/internal/erpserver/templ/system/config"
-	"management/internal/pkg/convertor"
-	"management/internal/pkg/database"
-	"management/internal/pkg/render"
-)
-
-type app struct {
-	render        render.Renderer
-	configService systemService.ConfigService
-}
-
-func newApp(render render.Renderer, configService systemService.ConfigService) *app {
-	return &app{
-		render:        render,
-		configService: configService,
-	}
-}
-
-func (a *app) list(w http.ResponseWriter, r *http.Request) {
-	switch r.Method {
-	case http.MethodGet:
-		ctx := r.Context()
-		a.render.Render(ctx, w, config.List(ctx))
-	case http.MethodPost:
-		var q dto.SearchDto
-		q.SearchTimeBegin, q.SearchTimeEnd = convertor.DefaultTime(r.PostFormValue("timeBegin"), r.PostFormValue("timeEnd"))
-		q.SearchName = r.PostFormValue("name")
-		q.Page = convertor.Int(r.PostFormValue("page"), 1)
-		q.Rows = convertor.Int(r.PostFormValue("rows"), 10)
-		ctx := r.Context()
-		res, count, err := a.configService.List(ctx, q)
-		if err != nil {
-			a.render.JSONErr(w, err.Error())
-			return
-		}
-		a.render.JSON(w, render.NewResponseList(count, res))
-	default:
-		http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
-	}
-}
-
-func (a *app) add(w http.ResponseWriter, r *http.Request) {
-	ctx := r.Context()
-	a.render.Render(ctx, w, config.Edit(ctx, &view.EditSysConfig{Config: &systemModel.Config{}}))
-}
-
-func (a *app) edit(w http.ResponseWriter, r *http.Request) {
-	ctx := r.Context()
-	vars := r.URL.Query()
-	id := convertor.QueryInt[int32](vars, "id", 0)
-	vm := &view.EditSysConfig{}
-	if id > 0 {
-		if conf, err := a.configService.Get(r.Context(), id); err == nil {
-			vm.Config = conf
-			b, _ := json.Marshal(&conf.Value)
-			vm.Result = string(b)
-		}
-	}
-	a.render.Render(ctx, w, config.Edit(ctx, vm))
-}
-
-func (a *app) save(w http.ResponseWriter, r *http.Request) {
-	id := convertor.Int[int32](r.PostFormValue("ID"), 0)
-	key := r.PostFormValue("Key")
-	value := r.PostFormValue("Value")
-	if len(key) == 0 {
-		a.render.JSONErr(w, "Key不能为空")
-		return
-	}
-	if len(value) == 0 {
-		a.render.JSONErr(w, "Value不能为空")
-		return
-	}
-
-	ctx := r.Context()
-	if id == 0 {
-		arg := &systemModel.Config{
-			Key:   key,
-			Value: []byte(value),
-		}
-		err := a.configService.Create(ctx, arg)
-		if err != nil {
-			if database.IsUniqueViolation(err) {
-				a.render.JSONErr(w, "数据已存在")
-				return
-			}
-			a.render.JSONErr(w, err.Error())
-			return
-		}
-
-		a.render.JSONOk(w, "添加成功")
-	} else {
-		res, err := a.configService.Get(ctx, id)
-		if err != nil {
-			a.render.JSONErr(w, err.Error())
-			return
-		}
-
-		res.Value = []byte(value)
-		err = a.configService.Update(ctx, res)
-		if err != nil {
-			a.render.JSONErr(w, err.Error())
-			return
-		}
-
-		a.render.JSONOk(w, "更新成功")
-	}
-}
-
-func (a *app) refreshCache(w http.ResponseWriter, r *http.Request) {
-	key := r.FormValue("key")
-	err := a.configService.RefreshCache(r.Context(), strings.ToLower(key))
-	if err != nil {
-		a.render.JSONErr(w, err.Error())
-		return
-	}
-
-	a.render.JSONOk(w, "刷新成功")
-}
-
-func (a *app) resetPear(w http.ResponseWriter, r *http.Request) {
-	err := a.configService.ResetPear(r.Context())
-	if err != nil {
-		a.render.JSONErr(w, err.Error())
-		return
-	}
-	a.render.JSONOk(w, "重置成功")
-}
-
-func (a *app) pear(w http.ResponseWriter, r *http.Request) {
-	pear, err := a.configService.Pear(r.Context())
-	if err != nil {
-		http.Error(w, err.Error(), http.StatusInternalServerError)
-		return
-	}
-
-	a.render.JSON(w, pear)
-}

internal/erpserver/handler/system/login_log.go

@@ -0,0 +1,35 @@
+package system
+
+import (
+	"management/internal/erpserver/model/system/request"
+	"management/internal/erpserver/service/v1"
+	"management/internal/pkg/gin/gu"
+
+	"github.com/gin-gonic/gin"
+)
+
+type LoginLogApp struct {
+	loginLogService v1.LoginLogService
+}
+
+func NewLoginLogApp(loginLogService v1.LoginLogService) *LoginLogApp {
+	return &LoginLogApp{
+		loginLogService: loginLogService,
+	}
+}
+
+func (a *LoginLogApp) List(c *gin.Context) {
+	var req request.ListLoginLog
+	if err := c.ShouldBindQuery(&req); err != nil {
+		gu.ValidatorErrors(c, err)
+		return
+	}
+
+	res, count, err := a.loginLogService.List(c, req)
+	if err != nil {
+		gu.Failed(c, err.Error())
+		return
+	}
+
+	gu.Ok(c, gu.NewPageData(count, req.PageID, req.PageSize, res))
+}

internal/erpserver/handler/system/loginlog/login_log.go

@@ -1,45 +0,0 @@
-package loginlog
-
-import (
-	"net/http"
-
-	"management/internal/erpserver/model/dto"
-	v1 "management/internal/erpserver/service/v1"
-	"management/internal/erpserver/templ/system/loginlog"
-	"management/internal/pkg/convertor"
-	"management/internal/pkg/render"
-)
-
-type app struct {
-	render          render.Renderer
-	loginLogService v1.LoginLogService
-}
-
-func newApp(render render.Renderer, loginLogService v1.LoginLogService) *app {
-	return &app{
-		render:          render,
-		loginLogService: loginLogService,
-	}
-}
-
-func (a *app) list(w http.ResponseWriter, r *http.Request) {
-	switch r.Method {
-	case http.MethodGet:
-		ctx := r.Context()
-		a.render.Render(ctx, w, loginlog.List(ctx))
-	case http.MethodPost:
-		var q dto.SearchDto
-		q.SearchTimeBegin, q.SearchTimeEnd = convertor.DefaultTime(r.PostFormValue("timeBegin"), r.PostFormValue("timeEnd"))
-		q.SearchEmail = r.PostFormValue("email")
-		q.Page = convertor.Int(r.PostFormValue("page"), 1)
-		q.Rows = convertor.Int(r.PostFormValue("rows"), 10)
-		res, count, err := a.loginLogService.List(r.Context(), q)
-		if err != nil {
-			a.render.JSONErr(w, err.Error())
-			return
-		}
-		a.render.JSON(w, render.NewResponseList(count, res))
-	default:
-		http.Error(w, "Method Not Allowed", http.StatusMethodNotAllowed)
-	}
-}

internal/erpserver/handler/system/loginlog/route.go

@@ -1,25 +0,0 @@
-package loginlog
-
-import (
-	v1 "management/internal/erpserver/service/v1"
-	"management/internal/pkg/render"
-	"management/internal/pkg/session"
-
-	"github.com/go-chi/chi/v5"
-)
-
-type Config struct {
-	Sm              session.Manager
-	Render          render.Renderer
-	MenuService     v1.MenuService
-	LoginLogService v1.LoginLogService
-}
-
-func Routes(r chi.Router, cfg Config) {
-	app := newApp(cfg.Render, cfg.LoginLogService)
-
-	r.Route("/login_log", func(r chi.Router) {
-		r.Get("/list", app.list)
-		r.Post("/list", app.list)
-	})
-}

internal/erpserver/handler/system/role.go

@@ -0,0 +1,204 @@
+package system
+
+import (
+	"errors"
+	"net/http"
+
+	"management/internal/erpserver/model/system"
+	"management/internal/erpserver/model/system/request"
+	"management/internal/erpserver/service/v1"
+	"management/internal/pkg/convertor"
+	"management/internal/pkg/gin/gu"
+	"management/internal/pkg/sqldb"
+
+	"github.com/gin-gonic/gin"
+)
+
+type RoleApp struct {
+	roleService v1.RoleService
+	menuService v1.MenuService
+}
+
+func NewRoleApp(roleService v1.RoleService, menuService v1.MenuService) *RoleApp {
+	return &RoleApp{
+		roleService: roleService,
+		menuService: menuService,
+	}
+}
+
+func (a *RoleApp) Create(c *gin.Context) {
+	var req request.CreateAndUpdateRole
+	if err := c.ShouldBindJSON(&req); err != nil {
+		gu.ValidatorErrors(c, err)
+		return
+	}
+
+	if err := a.roleService.Create(c, &req); err != nil {
+		if errors.Is(err, sqldb.ErrDBDuplicatedEntry) {
+			gu.FailedWithCode(c, http.StatusConflict, "角色已存在")
+			return
+		}
+
+		gu.Failed(c, err.Error())
+		return
+	}
+
+	gu.Ok(c, "添加成功")
+}
+
+func (a *RoleApp) Update(c *gin.Context) {
+	var id request.GetRoleID
+	if err := c.ShouldBindUri(&id); err != nil {
+		gu.ValidatorErrors(c, err)
+		return
+	}
+
+	var req request.CreateAndUpdateRole
+	if err := c.ShouldBindJSON(&req); err != nil {
+		gu.ValidatorErrors(c, err)
+		return
+	}
+
+	req.ID = id.ID
+	if err := a.roleService.Update(c, &req); err != nil {
+		gu.Failed(c, err.Error())
+		return
+	}
+
+	gu.Ok(c, "更新成功")
+}
+
+func (a *RoleApp) Get(c *gin.Context) {
+	var id request.GetRoleID
+	if err := c.ShouldBindUri(&id); err != nil {
+		gu.ValidatorErrors(c, err)
+		return
+	}
+
+	config, err := a.roleService.Get(c, id.ID)
+	if err != nil {
+		if errors.Is(err, sqldb.ErrDBNotFound) {
+			gu.FailedWithCode(c, http.StatusNotFound, "配置不存在")
+			return
+		}
+
+		gu.Failed(c, err.Error())
+		return
+	}
+
+	gu.Ok(c, config)
+}
+
+func (a *RoleApp) List(c *gin.Context) {
+	var req request.ListRole
+	if err := c.ShouldBindQuery(&req); err != nil {
+		gu.ValidatorErrors(c, err)
+		return
+	}
+
+	res, count, err := a.roleService.List(c, req)
+	if err != nil {
+		gu.Failed(c, err.Error())
+		return
+	}
+
+	gu.Ok(c, gu.NewPageData(count, req.PageID, req.PageSize, res))
+}
+
+func (a *RoleApp) Refresh(c *gin.Context) {
+	err := a.roleService.RefreshCache(c)
+	if err != nil {
+		gu.Failed(c, err.Error())
+		return
+	}
+
+	gu.Ok(c, "缓存刷新成功")
+}
+
+func (a *RoleApp) RebuildParentPath(c *gin.Context) {
+	err := a.roleService.RebuildParentPath(c)
+	if err != nil {
+		gu.Failed(c, err.Error())
+		return
+	}
+
+	gu.Ok(c, "重建成功")
+}
+
+func (a *RoleApp) RefreshRoleMenus(c *gin.Context) {
+	// 获取需要刷新的角色ID
+	roleID := convertor.Int[int32](c.PostForm("roleID"), 0)
+	roleModel, err := a.roleService.Get(c, roleID)
+	if err != nil {
+		gu.Failed(c, err.Error())
+		return
+	}
+	if roleModel == nil {
+		gu.Failed(c, "角色不存在")
+		return
+	}
+
+	// 刷新角色菜单 (角色所拥有的菜单集合)
+	_, err = a.menuService.SetListByRoleID(c, roleModel.ID)
+	if err != nil {
+		gu.Failed(c, err.Error())
+		return
+	}
+
+	// 刷新角色菜单 (角色所拥有的菜单集合)
+	_, err = a.menuService.SetListByRoleIDToMap(c, roleModel.ID)
+	if err != nil {
+		gu.Failed(c, err.Error())
+		return
+	}
+
+	// 刷新角色菜单树 (pear admin layui 使用的格式)
+	_, err = a.menuService.SetOwerMenus(c, roleModel.ID)
+	if err != nil {
+		gu.Failed(c, err.Error())
+		return
+	}
+
+	gu.Ok(c, "刷新成功")
+}
+
+func (a *RoleApp) setMenu(c *gin.Context) {
+	var req request.SetMenu
+	if err := c.ShouldBindJSON(&req); err != nil {
+		gu.ValidatorErrors(c, err)
+		return
+	}
+
+	role, err := a.roleService.Get(c, req.RoleID)
+	if err != nil {
+		gu.Failed(c, err.Error())
+		return
+	}
+
+	var rms []*system.RoleMenu
+	for _, v := range req.MenuIDs {
+		menu, err := a.menuService.Get(c, v)
+		if err != nil {
+			gu.Failed(c, err.Error())
+			return
+		}
+
+		rms = append(rms, &system.RoleMenu{
+			RoleID: role.ID,
+			MenuID: menu.ID,
+		})
+	}
+
+	if len(rms) == 0 {
+		gu.Failed(c, "请选择正确的菜单")
+		return
+	}
+
+	err = a.menuService.SetRoleMenu(c, role.ID, rms)
+	if err != nil {
+		gu.Failed(c, err.Error())
+		return
+	}
+
+	gu.Ok(c, "设置成功")
+}

internal/erpserver/handler/system/role/role.go

@@ -1,261 +0,0 @@
-package role
-
-import (
-	"net/http"
-	"strings"
-
-	"management/internal/erpserver/model/dto"
-	"management/internal/erpserver/model/form"
-	"management/internal/erpserver/model/system"
-	"management/internal/erpserver/model/view"
-	v1 "management/internal/erpserver/service/v1"
-	"management/internal/erpserver/templ/system/role"
-	"management/internal/pkg/binding"
-	"management/internal/pkg/convertor"
-	"management/internal/pkg/render"
-)
-
-type app struct {
-	render      render.Renderer
-	roleService v1.RoleService
-	menuService v1.MenuService
-}
-
-func newApp(render render.Renderer, roleService v1.RoleService, menuService v1.MenuService) *app {
-	return &app{
-		render:      render,
-		roleService: roleService,
-		menuService: menuService,
-	}
-}
-
-func (a *app) list(w http.ResponseWriter, r *http.Request) {
-	switch r.Method {
-	case http.MethodGet:
-		ctx := r.Context()
-		a.render.Render(ctx, w, role.List(ctx))
-	case http.MethodPost:
-		var q dto.SearchDto
-		q.SearchTimeBegin, q.SearchTimeEnd = convertor.DefaultTime(r.PostFormValue("timeBegin"), r.PostFormValue("timeEnd"))
-		q.SearchStatus = convertor.Int(r.PostFormValue("status"), 9999)
-		q.SearchParentID = convertor.Int(r.PostFormValue("parentId"), 0)
-		q.SearchName = r.PostFormValue("name")
-		q.SearchID = convertor.Int[int64](r.PostFormValue("id"), 0)
-		q.Page = convertor.Int(r.PostFormValue("page"), 1)
-		q.Rows = convertor.Int(r.PostFormValue("rows"), 10)
-		res, count, err := a.roleService.List(r.Context(), q)
-		if err != nil {
-			a.render.JSONErr(w, err.Error())
-			return
-		}
-		a.render.JSON(w, render.NewResponseList(count, res))
-	default:
-		http.Error(w, "Method Not Allowed", http.StatusMethodNotAllowed)
-	}
-}
-
-func (a *app) add(w http.ResponseWriter, r *http.Request) {
-	ctx := r.Context()
-	a.render.Render(ctx, w, role.Edit(ctx, &system.Role{Sort: 6666}))
-}
-
-func (a *app) addChildren(w http.ResponseWriter, r *http.Request) {
-	vars := r.URL.Query()
-	parentID := convertor.QueryInt[int32](vars, "parentID", 0)
-	vm := &system.Role{ParentID: parentID, Sort: 6666}
-	ctx := r.Context()
-	a.render.Render(ctx, w, role.Edit(ctx, vm))
-}
-
-func (a *app) edit(w http.ResponseWriter, r *http.Request) {
-	ctx := r.Context()
-	vars := r.URL.Query()
-	id := convertor.QueryInt[int32](vars, "id", 0)
-	vm := &system.Role{Sort: 6666}
-	if id > 0 {
-		vm, _ = a.roleService.Get(ctx, id)
-	}
-	a.render.Render(ctx, w, role.Edit(ctx, vm))
-}
-
-func (a *app) save(w http.ResponseWriter, r *http.Request) {
-	var req form.Role
-	if err := binding.Form.Bind(r, &req); err != nil {
-		a.render.JSONErr(w, binding.ValidatorErrors(err))
-		return
-	}
-
-	ctx := r.Context()
-	if *req.ID == 0 {
-		err := a.roleService.Create(ctx, &req)
-		if err != nil {
-			a.render.JSONErr(w, err.Error())
-			return
-		}
-		a.render.JSONOk(w, "添加成功")
-	} else {
-		err := a.roleService.Update(ctx, &req)
-		if err != nil {
-			a.render.JSONErr(w, err.Error())
-			return
-		}
-		a.render.JSONOk(w, "更新成功")
-	}
-}
-
-func (a *app) data(w http.ResponseWriter, r *http.Request) {
-	ctx := r.Context()
-	vars := r.URL.Query()
-	t := vars.Get("type")
-	if t == "tree" {
-		res, err := a.roleService.Tree(ctx, 0)
-		if err != nil {
-			a.render.JSONErr(w, err.Error())
-			return
-		}
-		a.render.JSON(w, res)
-	} else if t == "xm_select_tree" {
-		res, err := a.roleService.XmSelectTree(ctx, 0)
-		if err != nil {
-			a.render.JSONErr(w, err.Error())
-			return
-		}
-		a.render.JSON(w, res)
-	}
-}
-
-func (a *app) refreshCache(w http.ResponseWriter, r *http.Request) {
-	err := a.roleService.RefreshCache(r.Context())
-	if err != nil {
-		a.render.JSONErr(w, err.Error())
-		return
-	}
-
-	a.render.JSONOk(w, "缓存刷新成功")
-}
-
-func (a *app) rebuildParentPath(w http.ResponseWriter, r *http.Request) {
-	ctx := r.Context()
-	err := a.roleService.RebuildParentPath(ctx)
-	if err != nil {
-		a.render.JSONErr(w, err.Error())
-		return
-	}
-
-	a.render.JSONOk(w, "重建成功")
-}
-
-func (a *app) refreshRoleMenus(w http.ResponseWriter, r *http.Request) {
-	ctx := r.Context()
-
-	// 获取需要刷新的角色ID
-	roleID := convertor.Int[int32](r.PostFormValue("roleID"), 0)
-	roleModel, err := a.roleService.Get(ctx, roleID)
-	if err != nil {
-		a.render.JSONErr(w, err.Error())
-		return
-	}
-	if roleModel == nil {
-		a.render.JSONErr(w, "角色不存在")
-		return
-	}
-
-	// 刷新角色菜单 (角色所拥有的菜单集合)
-	_, err = a.menuService.SetListByRoleID(ctx, roleModel.ID)
-	if err != nil {
-		a.render.JSONErr(w, err.Error())
-		return
-	}
-
-	// 刷新角色菜单 (角色所拥有的菜单集合)
-	_, err = a.menuService.SetListByRoleIDToMap(ctx, roleModel.ID)
-	if err != nil {
-		a.render.JSONErr(w, err.Error())
-		return
-	}
-
-	// 刷新角色菜单树 (pear admin layui 使用的格式)
-	_, err = a.menuService.SetOwerMenus(ctx, roleModel.ID)
-	if err != nil {
-		a.render.JSONErr(w, err.Error())
-		return
-	}
-
-	a.render.JSONOk(w, "刷新成功")
-}
-
-func (a *app) setMenu(w http.ResponseWriter, r *http.Request) {
-	switch r.Method {
-	case http.MethodGet:
-		vars := r.URL.Query()
-		id := convertor.QueryInt[int32](vars, "id", 0)
-		vm := &view.SetMenuView{
-			Role:  &system.Role{},
-			Menus: []*dto.SetMenuDto{},
-		}
-		ctx := r.Context()
-		if id > 0 {
-			var err error
-			vm.Role, err = a.roleService.Get(ctx, id)
-			if err == nil {
-				vm.Menus, _ = a.menuService.MenuViewData(ctx, vm.Role.ID)
-			}
-		}
-		a.render.Render(ctx, w, role.SetMenu(ctx, vm))
-	case http.MethodPost:
-		ctx := r.Context()
-		id := convertor.Int[int32](r.PostFormValue("ID"), 0)
-		if id == 0 {
-			a.render.JSONErr(w, "角色异常, 请刷新重试")
-			return
-		}
-		roleModel, err := a.roleService.Get(ctx, id)
-		if err != nil {
-			a.render.JSONErr(w, err.Error())
-			return
-		}
-
-		menus := r.PostFormValue("roleMenu")
-		if len(menus) == 0 {
-			a.render.JSONErr(w, "请选择菜单")
-			return
-		}
-		menuArr := strings.Split(menus, ",")
-		if len(menuArr) == 0 {
-			a.render.JSONErr(w, "请选择菜单")
-			return
-		}
-
-		var rms []*system.RoleMenu
-		for _, v := range menuArr {
-			menuID := convertor.Int(v, 0)
-			if menuID > 0 {
-				menu, err := a.menuService.Get(ctx, int32(menuID))
-				if err != nil {
-					a.render.JSONErr(w, err.Error())
-					return
-				}
-
-				rms = append(rms, &system.RoleMenu{
-					RoleID: roleModel.ID,
-					MenuID: menu.ID,
-				})
-			}
-		}
-
-		if len(rms) == 0 {
-			a.render.JSONErr(w, "请选择正确的菜单")
-			return
-		}
-
-		err = a.menuService.SetRoleMenu(ctx, id, rms)
-		if err != nil {
-			a.render.JSONErr(w, err.Error())
-			return
-		}
-
-		a.render.JSONOk(w, "设置成功")
-	default:
-		http.Error(w, "Method Not Allowed", http.StatusMethodNotAllowed)
-	}
-}

internal/erpserver/handler/system/route.go

@@ -0,0 +1,47 @@
+package system
+
+import (
+	v1 "management/internal/erpserver/service/v1"
+
+	"github.com/gin-gonic/gin"
+)
+
+type Config struct {
+	MenuService     v1.MenuService
+	AuditLogService v1.AuditLogService
+	ConfigService   v1.ConfigService
+	LoginLogService v1.LoginLogService
+	RoleService     v1.RoleService
+}
+
+func Routes(r *gin.RouterGroup, cfg Config) {
+
+	auditApp := NewAuditApp(cfg.AuditLogService)
+	loginLogApp := NewLoginLogApp(cfg.LoginLogService)
+	configApp := NewConfigApp(cfg.ConfigService)
+	roleApp := NewRoleApp(cfg.RoleService, cfg.MenuService)
+
+	r.Group("/system", func(ctx *gin.Context) {
+		// 审计日志
+		r.GET("/audit_log", auditApp.List)
+
+		// 登陆日志
+		r.GET("/login_log", loginLogApp.List)
+
+		// 配置
+		r.POST("/config", configApp.Create)
+		r.PUT("/config/:id", configApp.Update)
+		r.GET("/config/:id", configApp.Get)
+		r.GET("/config", configApp.List)
+
+		// 角色
+		r.POST("/role", roleApp.Create)
+		r.PUT("/role/:id", roleApp.Update)
+		r.GET("/role/:id", roleApp.Get)
+		r.GET("/role", roleApp.List)
+		r.POST("/role/refresh_cache", roleApp.Refresh)
+		r.POST("/role/rebuild_parent_path", roleApp.RebuildParentPath)
+		r.POST("/role/refresh_role_menus", roleApp.RefreshRoleMenus)
+		r.POST("/role/set_menu", roleApp.setMenu)
+	})
+}