kenneth/projectx
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

gorm wire

Browse Source
This commit is contained in:
kenneth
2025-05-07 14:12:53 +08:00
parent 461531c308
commit 68606c76f9
111 changed files with 1726 additions and 5809 deletions
Download Patch File Download Diff File Expand all files Collapse all files

62
internal/erpserver/handler/app.go
View File

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

38
internal/erpserver/handler/common/captcha.go
View File

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

56
internal/erpserver/handler/common/upload.go
View File

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

65
internal/erpserver/handler/handler.go Normal file
View File

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

126
internal/erpserver/handler/router.go
View File

@@ -1,126 +0,0 @@
package handler
import (
"net/http"
"management/internal/erpserver/handler/common"
"management/internal/erpserver/handler/system"
"github.com/go-chi/chi/v5"
"github.com/go-chi/chi/v5/middleware"
)
func (ctx *AppContext) Router() *chi.Mux {
r := chi.NewRouter()
r.Use(middleware.RequestID)
r.Use(middleware.RealIP)
// r.Use(middleware.Logger)
r.Use(middleware.Recoverer)
staticServer := http.FileServer(http.Dir("./web/statics/"))
r.Handle("/statics/*", http.StripPrefix("/statics", staticServer))
uploadServer := http.FileServer(http.Dir("./upload/"))
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
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)
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)
configHandler := system.NewConfigHandler(ctx.Render, ctx.Redis, ctx.ConfigService)
r.With(ctx.Middleware.Authorize).Get("/pear.json", configHandler.Pear)
r.Route("/system", func(r chi.Router) {
r.Use(ctx.Middleware.Authorize)
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.Get("/list", menuHandler.List)
r.Post("/list", menuHandler.List)
r.Get("/add", menuHandler.Add)
r.Get("/add_children", menuHandler.AddChildren)
r.Get("/edit", menuHandler.Edit)
r.Post("/save", menuHandler.Save)
r.Post("/data", menuHandler.Data)
r.Post("/refresh_cache", menuHandler.RefreshCache)
})
r.Route("/department", func(r chi.Router) {
r.Use(ctx.Middleware.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.Route("/role", func(r chi.Router) {
r.Use(ctx.Middleware.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)
r.Get("/add_children", roleHandler.AddChildren)
r.Get("/edit", roleHandler.Edit)
r.Post("/save", roleHandler.Save)
r.Post("/data", roleHandler.Data)
r.Post("/refresh_cache", roleHandler.RefreshCache)
r.Post("/rebuild_parent_path", roleHandler.RebuildParentPath)
r.Post("/refresh_role_menus", roleHandler.RefreshRoleMenus)
r.Get("/set_menu", roleHandler.SetMenu)
r.Post("/set_menu", roleHandler.SetMenu)
})
r.Route("/user", func(r chi.Router) {
r.Get("/list", userHandler.List)
r.Post("/list", userHandler.List)
r.Get("/add", userHandler.Add)
r.Get("/edit", userHandler.Edit)
r.Post("/save", userHandler.Save)
r.Get("/profile", userHandler.Profile)
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)
})
})
})
return r
}

29
internal/erpserver/handler/system/audit.go
View File

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

230
internal/erpserver/handler/system/config.go
View File

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

95
internal/erpserver/handler/system/department.go
View File

@@ -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, "重建成功")
}

43
internal/erpserver/handler/system/home.go
View File

@@ -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,

29
internal/erpserver/handler/system/login_log.go
View File

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

121
internal/erpserver/handler/system/menu.go
View File

@@ -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, "缓存刷新成功")
}

155
internal/erpserver/handler/system/role.go
View File

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

148
internal/erpserver/handler/system/user.go
View File

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