v1

internal/erpserver/handler/auth/auth.go

@@ -0,0 +1,67 @@
+package auth
+
+import (
+	"management/internal/erpserver/model/system/request"
+	v1 "management/internal/erpserver/service/v1"
+	authv1 "management/internal/erpserver/service/v1/auth"
+	"management/internal/pkg/gin/gu"
+
+	"github.com/drhin/logger"
+	"github.com/gin-gonic/gin"
+	"github.com/zhang2092/browser"
+)
+
+type app struct {
+	log            *logger.Logger
+	captchaService v1.CaptchaService
+	userService    v1.UserService
+	authService    *authv1.Auth
+}
+
+func newApp(
+	log *logger.Logger,
+	captchaService v1.CaptchaService,
+	userService v1.UserService,
+	authService *authv1.Auth,
+) *app {
+	return &app{
+		log:            log,
+		captchaService: captchaService,
+		userService:    userService,
+		authService:    authService,
+	}
+}
+
+func (a *app) login(c *gin.Context) {
+	var req request.Login
+	if err := c.ShouldBindJSON(&req); err != nil {
+		gu.ValidatorErrors(c, err)
+		return
+	}
+
+	if !a.captchaService.Verify(req.CaptchaID, req.Captcha, true) {
+		gu.Failed(c, "验证码错误")
+		return
+	}
+
+	req.Ip = c.ClientIP()
+	req.Url = c.Request.URL.String()
+	req.Referrer = c.Request.Referer()
+	br, err := browser.NewBrowser(c.Request.UserAgent())
+	if err == nil {
+		req.Os = br.Platform().Name()
+		req.Browser = br.Name()
+	}
+
+	risk, err := a.authService.Authenticate(c, req)
+	if err != nil {
+		gu.Failed(c, err.Error())
+		return
+	}
+
+	gu.Ok(c, risk)
+}
+
+func (a *app) logout(c *gin.Context) {
+	gu.Ok(c, nil)
+}

internal/erpserver/handler/auth/route.go

@@ -0,0 +1,25 @@
+package auth
+
+import (
+	v1 "management/internal/erpserver/service/v1"
+	"management/internal/erpserver/service/v1/auth"
+
+	"github.com/drhin/logger"
+	"github.com/gin-gonic/gin"
+)
+
+type Config struct {
+	Log            *logger.Logger
+	CaptchaService v1.CaptchaService
+	AuthService    *auth.Auth
+	UserService    v1.UserService
+	MenuService    v1.MenuService
+}
+
+func Routes(public *gin.RouterGroup, private *gin.RouterGroup, cfg Config) {
+	app := newApp(cfg.Log, cfg.CaptchaService, cfg.UserService, cfg.AuthService)
+
+	public.POST("/login", app.login)
+	private.GET("/logout", app.logout)
+
+}

internal/erpserver/handler/captcha/captcha.go

@@ -1,11 +1,12 @@
 package captcha
 
 import (
-	"net/http"
-
 	v1 "management/internal/erpserver/service/v1"
 	"management/internal/pkg/config"
+	"management/internal/pkg/gin/gu"
 	"management/internal/pkg/render"
+
+	"github.com/gin-gonic/gin"
 )
 
 type app struct {
@@ -29,14 +30,14 @@ type Response struct {
 	OpenCaptcha   int    `json:"open_captcha"`
 }
 
-func (a *app) captcha(w http.ResponseWriter, _ *http.Request) {
+func (a *app) captcha(ctx *gin.Context) {
 	id, b64s, _, err := a.captchaService.Generate(
 		a.config.Captcha.ImgHeight,
 		a.config.Captcha.ImgWidth,
 		a.config.Captcha.KeyLong,
 		0.7, 80)
 	if err != nil {
-		a.render.JSONErr(w, "获取验证码失败")
+		gu.Failed(ctx, "获取验证码失败")
 		return
 	}
 
@@ -46,5 +47,5 @@ func (a *app) captcha(w http.ResponseWriter, _ *http.Request) {
 		CaptchaLength: a.config.Captcha.KeyLong,
 		OpenCaptcha:   a.config.Captcha.OpenCaptcha,
 	}
-	a.render.JSONObj(w, "ok", rsp)
+	gu.Ok(ctx, rsp)
 }

internal/erpserver/handler/captcha/route.go

@@ -5,7 +5,7 @@ import (
 	"management/internal/pkg/config"
 	"management/internal/pkg/render"
 
-	"github.com/go-chi/chi/v5"
+	"github.com/gin-gonic/gin"
 )
 
 type Config struct {
@@ -14,7 +14,7 @@ type Config struct {
 	CaptchaService v1.CaptchaService
 }
 
-func Routes(r chi.Router, cfg Config) {
+func Routes(r *gin.RouterGroup, cfg Config) {
 	app := newApp(cfg.Conf, cfg.Render, cfg.CaptchaService)
-	r.Get("/captcha", app.captcha)
+	r.GET("/captcha", app.captcha)
 }

internal/erpserver/handler/route.go

@@ -3,35 +3,26 @@ package handler
 import (
 	"net/http"
 
-	"management/assets"
+	"management/internal/erpserver/handler/auth"
 	"management/internal/erpserver/handler/captcha"
-	"management/internal/erpserver/handler/system/audit"
-	"management/internal/erpserver/handler/system/auth"
-	configapp "management/internal/erpserver/handler/system/config"
-	"management/internal/erpserver/handler/system/department"
-	"management/internal/erpserver/handler/system/home"
-	"management/internal/erpserver/handler/system/loginlog"
-	"management/internal/erpserver/handler/system/menu"
-	"management/internal/erpserver/handler/system/role"
-	"management/internal/erpserver/handler/system/user"
+	"management/internal/erpserver/handler/system"
 	"management/internal/erpserver/handler/upload"
 	v1 "management/internal/erpserver/service/v1"
 	authv1 "management/internal/erpserver/service/v1/auth"
 	"management/internal/pkg/config"
 	"management/internal/pkg/mid"
 	"management/internal/pkg/render"
-	"management/internal/pkg/session"
+	"management/internal/pkg/token"
 	"management/internal/tasks"
 
 	"github.com/drhin/logger"
-	"github.com/go-chi/chi/v5"
-	"github.com/go-chi/chi/v5/middleware"
+	"github.com/gin-gonic/gin"
 )
 
 type Config struct {
 	Conf              *config.Config
 	Log               *logger.Logger
-	Sm                session.Manager
+	Token             token.Maker
 	Render            render.Renderer
 	TaskDistributor   tasks.TaskDistributor
 	CaptchaService    v1.CaptchaService
@@ -46,122 +37,64 @@ type Config struct {
 }
 
 func WebApp(cfg Config) http.Handler {
-	app := chi.NewRouter()
+	app := gin.New()
+	app.Use(gin.Recovery())
+	if gin.Mode() == gin.DebugMode {
+		app.Use(gin.Logger())
+	}
 
-	app.Use(middleware.RequestID)
-	app.Use(middleware.RealIP)
-	// r.Use(mid.Logger)
-	app.Use(middleware.Recoverer)
+	//app.Static("/public/*", "./public/")
 
-	staticServer := http.FileServer(http.FS(assets.FS))
-	app.Handle("/assets/*", http.StripPrefix("/assets", staticServer))
+	publishApp := app.Group("/api")
+	privateApp := app.Group("/api")
 
-	uploadServer := http.FileServer(http.Dir("./public/"))
-	app.Handle("/public/*", http.StripPrefix("/public", uploadServer))
+	privateApp.Use(mid.Authorize(cfg.Token, cfg.MenuService))
 
-	app.Group(func(r chi.Router) {
-		//r.Use(mid.NoSurf)              // CSRF
-		//r.Use(mid.NoSurfContext)       // CSRF Store Context
-		r.Use(mid.LoadSession(cfg.Sm)) // Session
+	{
+		// 健康监测
+		publishApp.GET("/health", func(c *gin.Context) {
+			c.JSON(http.StatusOK, "ok")
+		})
+	}
 
-		captcha.Routes(r, captcha.Config{
+	{
+		// 公共方法
+		captcha.Routes(publishApp, captcha.Config{
 			Conf:           cfg.Conf,
 			Render:         cfg.Render,
 			CaptchaService: cfg.CaptchaService,
 		})
 
-		upload.Routes(r, upload.Config{
+		upload.Routes(privateApp, upload.Config{
 			Conf:            cfg.Conf,
 			Log:             cfg.Log,
-			Sm:              cfg.Sm,
 			Render:          cfg.Render,
 			TaskDistributor: cfg.TaskDistributor,
 			MenuService:     cfg.MenuService,
 		})
+	}
 
-		home.Routes(r, home.Config{
-			Sm:              cfg.Sm,
-			Render:          cfg.Render,
-			UserService:     cfg.UserService,
-			MenuService:     cfg.MenuService,
-			LoginLogService: cfg.LoginLogService,
-		})
-
-		auth.Routes(r, auth.Config{
+	{
+		// 登陆
+		auth.Routes(publishApp, privateApp, auth.Config{
 			Log:            cfg.Log,
-			Sm:             cfg.Sm,
-			Render:         cfg.Render,
 			CaptchaService: cfg.CaptchaService,
 			AuthService:    cfg.AuthService,
 			UserService:    cfg.UserService,
 			MenuService:    cfg.MenuService,
 		})
+	}
 
-		r.Route("/system", func(r chi.Router) {
-
-			r.Use(mid.Authorize(cfg.Sm, cfg.MenuService))
-
-			user.Routes(r, user.Config{
-				Log:               cfg.Log,
-				Sm:                cfg.Sm,
-				Render:            cfg.Render,
-				TaskDistributor:   cfg.TaskDistributor,
-				UserService:       cfg.UserService,
-				RoleService:       cfg.RoleService,
-				MenuService:       cfg.MenuService,
-				DepartmentService: cfg.DepartmentService,
-			})
-
-			role.Routes(r, role.Config{
-				Log:             cfg.Log,
-				Sm:              cfg.Sm,
-				Render:          cfg.Render,
-				TaskDistributor: cfg.TaskDistributor,
-				RoleService:     cfg.RoleService,
-				MenuService:     cfg.MenuService,
-			})
-
-			menu.Routes(r, menu.Config{
-				Log:             cfg.Log,
-				Sm:              cfg.Sm,
-				Render:          cfg.Render,
-				TaskDistributor: cfg.TaskDistributor,
-				MenuService:     cfg.MenuService,
-			})
-
-			department.Routes(r, department.Config{
-				Log:               cfg.Log,
-				Sm:                cfg.Sm,
-				Render:            cfg.Render,
-				TaskDistributor:   cfg.TaskDistributor,
-				MenuService:       cfg.MenuService,
-				DepartmentService: cfg.DepartmentService,
-			})
-
-			configapp.Routes(r, configapp.Config{
-				Log:             cfg.Log,
-				Sm:              cfg.Sm,
-				Render:          cfg.Render,
-				TaskDistributor: cfg.TaskDistributor,
-				MenuService:     cfg.MenuService,
-				ConfigService:   cfg.ConfigService,
-			})
-
-			loginlog.Routes(r, loginlog.Config{
-				Sm:              cfg.Sm,
-				Render:          cfg.Render,
-				MenuService:     cfg.MenuService,
-				LoginLogService: cfg.LoginLogService,
-			})
-
-			audit.Routes(r, audit.Config{
-				Sm:              cfg.Sm,
-				Render:          cfg.Render,
-				MenuService:     cfg.MenuService,
-				AuditLogService: cfg.AuditLogService,
-			})
+	{
+		// 后台管理
+		system.Routes(privateApp, system.Config{
+			RoleService:     cfg.RoleService,
+			MenuService:     cfg.MenuService,
+			AuditLogService: cfg.AuditLogService,
+			LoginLogService: cfg.LoginLogService,
+			ConfigService:   cfg.ConfigService,
 		})
-	})
+	}
 
 	return app
 }

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

internal/erpserver/handler/upload/route.go

@@ -3,32 +3,27 @@ package upload
 import (
 	v1 "management/internal/erpserver/service/v1"
 	"management/internal/pkg/config"
-	"management/internal/pkg/mid"
 	"management/internal/pkg/render"
-	"management/internal/pkg/session"
 	"management/internal/tasks"
 
 	"github.com/drhin/logger"
-	"github.com/go-chi/chi/v5"
+	"github.com/gin-gonic/gin"
 )
 
 type Config struct {
 	Conf            *config.Config
 	Log             *logger.Logger
-	Sm              session.Manager
 	Render          render.Renderer
 	TaskDistributor tasks.TaskDistributor
 	MenuService     v1.MenuService
 }
 
-func Routes(r chi.Router, cfg Config) {
+func Routes(r *gin.RouterGroup, cfg Config) {
 	app := newApp(cfg.Log, cfg.Render)
 
-	r.Route("/upload", func(r chi.Router) {
-		r.Use(mid.Authorize(cfg.Sm, cfg.MenuService))
-		r.Use(mid.Audit(cfg.Sm, cfg.Log, cfg.TaskDistributor))
-		r.Post("/img", app.img)
-		r.Post("/file", app.file)
-		r.Post("/multi_files", app.multiFiles)
+	r.Group("/upload", func(ctx *gin.Context) {
+		r.POST("/img", app.img)
+		r.POST("/file", app.file)
+		r.POST("/multi_files", app.multiFiles)
 	})
 }

internal/erpserver/handler/upload/upload.go

@@ -1,14 +1,14 @@
 package upload
 
 import (
-	"io"
 	"mime/multipart"
-	"net/http"
 
 	fileutil "management/internal/pkg/file"
+	"management/internal/pkg/gin/gu"
 	"management/internal/pkg/render"
 
 	"github.com/drhin/logger"
+	"github.com/gin-gonic/gin"
 )
 
 type app struct {
@@ -23,52 +23,36 @@ func newApp(log *logger.Logger, render render.Renderer) *app {
 	}
 }
 
-const maxImageSize = 100 << 20 // 100 MB
-
-func (a *app) img(w http.ResponseWriter, r *http.Request) {
-	defer func(Body io.ReadCloser) {
-		err := Body.Close()
-		if err != nil {
-			a.log.Error(err.Error(), err)
-		}
-	}(r.Body)
-
-	_, fh, err := r.FormFile("files")
+func (a *app) img(ctx *gin.Context) {
+	fh, err := ctx.FormFile("files")
 	if err != nil {
-		a.render.JSONErr(w, err.Error())
+		gu.Failed(ctx, err.Error())
 		return
 	}
 
 	path, err := fileutil.UploadFile(fh, fileutil.IMG)
 	if err != nil {
-		a.render.JSONErr(w, err.Error())
+		gu.Failed(ctx, err.Error())
 		return
 	}
 
-	a.render.JSONObj(w, "ok", path)
+	gu.Ok(ctx, path)
 }
 
-func (a *app) file(w http.ResponseWriter, r *http.Request) {
-	defer func(Body io.ReadCloser) {
-		err := Body.Close()
-		if err != nil {
-			a.log.Error(err.Error(), err)
-		}
-	}(r.Body)
-
-	_, fh, err := r.FormFile("files")
+func (a *app) file(ctx *gin.Context) {
+	fh, err := ctx.FormFile("files")
 	if err != nil {
-		a.render.JSONErr(w, err.Error())
+		gu.Failed(ctx, err.Error())
 		return
 	}
 
 	path, err := fileutil.UploadFile(fh, fileutil.ALL)
 	if err != nil {
-		a.render.JSONErr(w, err.Error())
+		gu.Failed(ctx, err.Error())
 		return
 	}
 
-	a.render.JSONObj(w, "ok", path)
+	gu.Ok(ctx, path)
 }
 
 type FileRes struct {
@@ -76,19 +60,14 @@ type FileRes struct {
 	Path string `json:"path"`
 }
 
-func (a *app) multiFiles(w http.ResponseWriter, r *http.Request) {
-	defer func(Body io.ReadCloser) {
-		err := Body.Close()
-		if err != nil {
-			a.log.Error(err.Error(), err)
-		}
-	}(r.Body)
-
-	err := r.ParseMultipartForm(int64(maxImageSize))
+func (a *app) multiFiles(ctx *gin.Context) {
+	form, err := ctx.MultipartForm()
 	if err != nil {
+		gu.Failed(ctx, err.Error())
 		return
 	}
-	files := r.MultipartForm.File["files"]
+
+	files := form.File["files"]
 
 	var res []FileRes
 	c := make(chan FileRes, 2)
@@ -100,7 +79,7 @@ func (a *app) multiFiles(w http.ResponseWriter, r *http.Request) {
 
 			filePath, err := fileutil.UploadFile(item, fileutil.ALL)
 			if err != nil {
-				a.render.JSONErr(w, err.Error())
+				gu.Failed(ctx, err.Error())
 				return
 			}
 
@@ -119,5 +98,5 @@ func (a *app) multiFiles(w http.ResponseWriter, r *http.Request) {
 		}
 	}
 
-	a.render.JSONObj(w, "ok", res)
+	gu.Ok(ctx, res)
 }