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

change router struct

Browse Source
This commit is contained in:
kenneth
2025-06-17 10:49:53 +08:00
parent a8bc73ae99
commit 6c3b4ec367
42 changed files with 1268 additions and 1308 deletions
Download Patch File Download Diff File Expand all files Collapse all files

26
internal/erpserver/handler/system/audit.go → internal/erpserver/handler/system/audit/audit.go
View File

@@ -1,32 +1,32 @@
package system
package audit
import (
"net/http"
"management/internal/erpserver/handler"
"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 AuditHandler struct {
*handler.Handler
type App struct {
render render.Renderer
auditLogService v1.AuditLogService
}
func NewAuditHandler(handler *handler.Handler, auditLogService v1.AuditLogService) *AuditHandler {
return &AuditHandler{
Handler: handler,
func NewApp(render render.Renderer, auditLogService v1.AuditLogService) *App {
return &App{
render: render,
auditLogService: auditLogService,
}
}
func (h *AuditHandler) List(w http.ResponseWriter, r *http.Request) {
func (a *App) list(w http.ResponseWriter, r *http.Request) {
switch r.Method {
case http.MethodGet:
ctx := r.Context()
h.Render(ctx, w, auditlog.List(ctx))
a.render.Render(ctx, w, auditlog.List(ctx))
case http.MethodPost:
var q dto.SearchDto
q.SearchTimeBegin, q.SearchTimeEnd = convertor.DefaultStartTimeAndEndTime(r.PostFormValue("timeBegin"), r.PostFormValue("timeEnd"))
@@ -34,19 +34,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.auditLogService.List(r.Context(), q)
res, count, err := a.auditLogService.List(r.Context(), q)
if err != nil {
h.JSONErr(w, err.Error())
a.render.JSONErr(w, err.Error())
return
}
data := handler.ResponseList{
data := render.ResponseList{
Code: 0,
Message: "ok",
Count: count,
Data: res,
}
h.JSON(w, data)
a.render.JSON(w, data)
default:
http.Error(w, "Method Not Allowed", http.StatusMethodNotAllowed)
}

25
internal/erpserver/handler/system/audit/route.go Normal file
View File

@@ -0,0 +1,25 @@
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)
})
}

97
internal/erpserver/handler/system/auth/auth.go Normal file
View File

@@ -0,0 +1,97 @@
package auth
import (
"io"
"log"
"net/http"
"management/internal/erpserver/model/form"
v1 "management/internal/erpserver/service/v1"
"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
}
func NewApp(
log *logger.Logger,
sm session.Manager,
render render.Renderer,
captchaService v1.CaptchaService,
userService v1.UserService,
) *App {
return &App{
log: log,
sm: sm,
render: render,
captchaService: captchaService,
userService: userService,
}
}
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)
if err != nil {
log.Println(err)
a.render.JSONErr(w, err.Error())
return
}
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)
}

29
internal/erpserver/handler/system/auth/route.go Normal file
View File

@@ -0,0 +1,29 @@
package auth
import (
v1 "management/internal/erpserver/service/v1"
"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
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)
r.Get("/", app.login)
r.Post("/login", app.login)
r.With(mid.Authorize(cfg.Sm, cfg.MenuService)).Get("/logout", app.logout)
}

82
internal/erpserver/handler/system/config.go → internal/erpserver/handler/system/config/config.go
View File

@@ -1,11 +1,10 @@
package system
package config
import (
"encoding/json"
"net/http"
"strings"
"management/internal/erpserver/handler"
"management/internal/erpserver/model/dto"
systemModel "management/internal/erpserver/model/system"
"management/internal/erpserver/model/view"
@@ -13,25 +12,26 @@ import (
"management/internal/erpserver/templ/system/config"
"management/internal/pkg/convertor"
"management/internal/pkg/database"
"management/internal/pkg/render"
)
type ConfigHandler struct {
*handler.Handler
type App struct {
render render.Renderer
configService systemService.ConfigService
}
func NewConfigHandler(handler *handler.Handler, configService systemService.ConfigService) *ConfigHandler {
return &ConfigHandler{
Handler: handler,
func NewApp(render render.Renderer, configService systemService.ConfigService) *App {
return &App{
render: render,
configService: configService,
}
}
func (h *ConfigHandler) List(w http.ResponseWriter, r *http.Request) {
func (a *App) list(w http.ResponseWriter, r *http.Request) {
switch r.Method {
case http.MethodGet:
ctx := r.Context()
h.Render(ctx, w, config.List(ctx))
a.render.Render(ctx, w, config.List(ctx))
case http.MethodPost:
var q dto.SearchDto
q.SearchTimeBegin, q.SearchTimeEnd = convertor.DefaultStartTimeAndEndTime(r.PostFormValue("timeBegin"), r.PostFormValue("timeEnd"))
@@ -39,54 +39,54 @@ func (h *ConfigHandler) List(w http.ResponseWriter, r *http.Request) {
q.Page = convertor.ConvertInt(r.PostFormValue("page"), 1)
q.Rows = convertor.ConvertInt(r.PostFormValue("rows"), 10)
ctx := r.Context()
res, count, err := h.configService.List(ctx, q)
res, count, err := a.configService.List(ctx, q)
if err != nil {
h.JSONErr(w, err.Error())
a.render.JSONErr(w, err.Error())
return
}
data := handler.ResponseList{
data := render.ResponseList{
Code: 0,
Message: "ok",
Count: count,
Data: res,
}
h.JSON(w, data)
a.render.JSON(w, data)
default:
http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
}
}
func (h *ConfigHandler) Add(w http.ResponseWriter, r *http.Request) {
func (a *App) add(w http.ResponseWriter, r *http.Request) {
ctx := r.Context()
h.Render(ctx, w, config.Edit(ctx, &view.EditSysConfig{Config: &systemModel.Config{}}))
a.render.Render(ctx, w, config.Edit(ctx, &view.EditSysConfig{Config: &systemModel.Config{}}))
}
func (h *ConfigHandler) Edit(w http.ResponseWriter, r *http.Request) {
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 := h.configService.Get(r.Context(), id); err == nil {
if conf, err := a.configService.Get(r.Context(), id); err == nil {
vm.Config = conf
b, _ := json.Marshal(&conf.Value)
vm.Result = string(b)
}
}
h.Render(ctx, w, config.Edit(ctx, vm))
a.render.Render(ctx, w, config.Edit(ctx, vm))
}
func (h *ConfigHandler) Save(w http.ResponseWriter, r *http.Request) {
func (a *App) 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不能为空")
a.render.JSONErr(w, "Key不能为空")
return
}
if len(value) == 0 {
h.JSONErr(w, "Value不能为空")
a.render.JSONErr(w, "Value不能为空")
return
}
@@ -96,61 +96,61 @@ func (h *ConfigHandler) Save(w http.ResponseWriter, r *http.Request) {
Key: key,
Value: []byte(value),
}
err := h.configService.Create(ctx, arg)
err := a.configService.Create(ctx, arg)
if err != nil {
if database.IsUniqueViolation(err) {
h.JSONErr(w, "数据已存在")
a.render.JSONErr(w, "数据已存在")
return
}
h.JSONErr(w, err.Error())
a.render.JSONErr(w, err.Error())
return
}
h.JSONOk(w, "添加成功")
a.render.JSONOk(w, "添加成功")
} else {
res, err := h.configService.Get(ctx, id)
res, err := a.configService.Get(ctx, id)
if err != nil {
h.JSONErr(w, err.Error())
a.render.JSONErr(w, err.Error())
return
}
res.Value = []byte(value)
err = h.configService.Update(ctx, res)
err = a.configService.Update(ctx, res)
if err != nil {
h.JSONErr(w, err.Error())
a.render.JSONErr(w, err.Error())
return
}
h.JSONOk(w, "更新成功")
a.render.JSONOk(w, "更新成功")
}
}
func (h *ConfigHandler) RefreshCache(w http.ResponseWriter, r *http.Request) {
func (a *App) refreshCache(w http.ResponseWriter, r *http.Request) {
key := r.FormValue("key")
err := h.configService.RefreshCache(r.Context(), strings.ToLower(key))
err := a.configService.RefreshCache(r.Context(), strings.ToLower(key))
if err != nil {
h.JSONErr(w, err.Error())
a.render.JSONErr(w, err.Error())
return
}
h.JSONOk(w, "刷新成功")
a.render.JSONOk(w, "刷新成功")
}
func (h *ConfigHandler) ResetPear(w http.ResponseWriter, r *http.Request) {
err := h.configService.ResetPear(r.Context())
func (a *App) resetPear(w http.ResponseWriter, r *http.Request) {
err := a.configService.ResetPear(r.Context())
if err != nil {
h.JSONErr(w, err.Error())
a.render.JSONErr(w, err.Error())
return
}
h.JSONOk(w, "重置成功")
a.render.JSONOk(w, "重置成功")
}
func (h *ConfigHandler) Pear(w http.ResponseWriter, r *http.Request) {
pear, err := h.configService.Pear(r.Context())
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
}
h.JSON(w, pear)
a.render.JSON(w, pear)
}

35
internal/erpserver/handler/system/config/route.go Normal file
View File

@@ -0,0 +1,35 @@
package config
import (
v1 "management/internal/erpserver/service/v1"
"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
MenuService v1.MenuService
ConfigService v1.ConfigService
}
func Routes(r chi.Router, cfg Config) {
app := NewApp(cfg.Render, cfg.ConfigService)
r.Get("/pear.json", app.pear)
r.Route("/config", func(r chi.Router) {
r.Use(mid.Audit(cfg.Sm, cfg.Log))
r.Get("/list", app.list)
r.Post("/list", app.list)
r.Get("/add", app.add)
r.Get("/edit", app.edit)
r.Post("/save", app.save)
r.Post("/refresh_cache", app.refreshCache)
r.Post("/reset_pear", app.resetPear)
})
}

86
internal/erpserver/handler/system/department.go → internal/erpserver/handler/system/department/department.go
View File

@@ -1,9 +1,8 @@
package system
package department
import (
"net/http"
"management/internal/erpserver/handler"
"management/internal/erpserver/model/dto"
"management/internal/erpserver/model/form"
systemmodel "management/internal/erpserver/model/system"
@@ -11,25 +10,26 @@ import (
"management/internal/erpserver/templ/system/department"
"management/internal/pkg/binding"
"management/internal/pkg/convertor"
"management/internal/pkg/render"
)
type DepartmentHandler struct {
*handler.Handler
type App struct {
render render.Renderer
departmentService v1.DepartmentService
}
func NewDepartmentHandler(handler *handler.Handler, departmentService v1.DepartmentService) *DepartmentHandler {
return &DepartmentHandler{
Handler: handler,
func NewApp(render render.Renderer, departmentService v1.DepartmentService) *App {
return &App{
render: render,
departmentService: departmentService,
}
}
func (h *DepartmentHandler) List(w http.ResponseWriter, r *http.Request) {
func (a *App) list(w http.ResponseWriter, r *http.Request) {
switch r.Method {
case http.MethodGet:
ctx := r.Context()
h.Render(ctx, w, department.List(ctx))
a.render.Render(ctx, w, department.List(ctx))
case http.MethodPost:
var q dto.SearchDto
q.SearchTimeBegin, q.SearchTimeEnd = convertor.DefaultStartTimeAndEndTime(r.PostFormValue("timeBegin"), r.PostFormValue("timeEnd"))
@@ -39,114 +39,114 @@ 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.departmentService.List(r.Context(), q)
res, count, err := a.departmentService.List(r.Context(), q)
if err != nil {
h.JSONErr(w, err.Error())
a.render.JSONErr(w, err.Error())
return
}
data := handler.ResponseList{
data := render.ResponseList{
Code: 0,
Message: "ok",
Count: count,
Data: res,
}
h.JSON(w, data)
a.render.JSON(w, data)
default:
http.Error(w, "Method Not Allowed", http.StatusMethodNotAllowed)
}
}
func (h *DepartmentHandler) Add(w http.ResponseWriter, r *http.Request) {
func (a *App) add(w http.ResponseWriter, r *http.Request) {
ctx := r.Context()
h.Render(ctx, w, department.Edit(ctx, &systemmodel.Department{Sort: 6666}))
a.render.Render(ctx, w, department.Edit(ctx, &systemmodel.Department{Sort: 6666}))
}
func (h *DepartmentHandler) AddChildren(w http.ResponseWriter, r *http.Request) {
func (a *App) addChildren(w http.ResponseWriter, r *http.Request) {
vars := r.URL.Query()
parentID := convertor.QueryInt[int32](vars, "parentID", 0)
vm := &systemmodel.Department{ParentID: parentID, Sort: 6666}
ctx := r.Context()
h.Render(ctx, w, department.Edit(ctx, vm))
a.render.Render(ctx, w, department.Edit(ctx, vm))
}
func (h *DepartmentHandler) Edit(w http.ResponseWriter, r *http.Request) {
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 := &systemmodel.Department{Sort: 6666}
if id > 0 {
vm, _ = h.departmentService.Get(r.Context(), id)
vm, _ = a.departmentService.Get(r.Context(), id)
}
h.Render(ctx, w, department.Edit(ctx, vm))
a.render.Render(ctx, w, department.Edit(ctx, vm))
}
func (h *DepartmentHandler) Save(w http.ResponseWriter, r *http.Request) {
func (a *App) save(w http.ResponseWriter, r *http.Request) {
var req form.Department
if err := binding.Form.Bind(r, &req); err != nil {
h.JSONErr(w, binding.ValidatorErrors(err))
a.render.JSONErr(w, binding.ValidatorErrors(err))
return
}
ctx := r.Context()
if *req.ID == 0 {
err := h.departmentService.Create(ctx, &req)
err := a.departmentService.Create(ctx, &req)
if err != nil {
h.JSONErr(w, err.Error())
a.render.JSONErr(w, err.Error())
return
}
h.JSONOk(w, "添加成功")
a.render.JSONOk(w, "添加成功")
} else {
err := h.departmentService.Update(ctx, &req)
err := a.departmentService.Update(ctx, &req)
if err != nil {
h.JSONErr(w, err.Error())
a.render.JSONErr(w, err.Error())
return
}
h.JSONOk(w, "更新成功")
a.render.JSONOk(w, "更新成功")
}
}
func (h *DepartmentHandler) Data(w http.ResponseWriter, r *http.Request) {
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 := h.departmentService.Tree(ctx, 0)
res, err := a.departmentService.Tree(ctx, 0)
if err != nil {
h.JSONErr(w, err.Error())
a.render.JSONErr(w, err.Error())
return
}
h.JSON(w, res)
a.render.JSON(w, res)
} else if t == "xm_select_tree" {
res, err := h.departmentService.XmSelectTree(ctx, 0)
res, err := a.departmentService.XmSelectTree(ctx, 0)
if err != nil {
h.JSONErr(w, err.Error())
a.render.JSONErr(w, err.Error())
return
}
h.JSON(w, res)
a.render.JSON(w, res)
}
}
func (h *DepartmentHandler) RefreshCache(w http.ResponseWriter, r *http.Request) {
err := h.departmentService.RefreshCache(r.Context())
func (a *App) refreshCache(w http.ResponseWriter, r *http.Request) {
err := a.departmentService.RefreshCache(r.Context())
if err != nil {
h.JSONErr(w, err.Error())
a.render.JSONErr(w, err.Error())
return
}
h.JSONOk(w, "缓存刷新成功")
a.render.JSONOk(w, "缓存刷新成功")
}
func (h *DepartmentHandler) RebuildParentPath(w http.ResponseWriter, r *http.Request) {
func (a *App) rebuildParentPath(w http.ResponseWriter, r *http.Request) {
ctx := r.Context()
err := h.departmentService.RebuildParentPath(ctx)
err := a.departmentService.RebuildParentPath(ctx)
if err != nil {
h.JSONErr(w, err.Error())
a.render.JSONErr(w, err.Error())
return
}
h.JSONOk(w, "重建成功")
a.render.JSONOk(w, "重建成功")
}

36
internal/erpserver/handler/system/department/route.go Normal file
View File

@@ -0,0 +1,36 @@
package department
import (
v1 "management/internal/erpserver/service/v1"
"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
MenuService v1.MenuService
DepartmentService v1.DepartmentService
}
func Routes(r chi.Router, cfg Config) {
app := NewApp(cfg.Render, cfg.DepartmentService)
r.Route("/department", func(r chi.Router) {
r.Use(mid.Audit(cfg.Sm, cfg.Log))
r.Get("/list", app.list)
r.Post("/list", app.list)
r.Get("/add", app.add)
r.Get("/add_children", app.addChildren)
r.Get("/edit", app.edit)
r.Post("/save", app.save)
r.Post("/data", app.data)
r.Post("/refresh_cache", app.refreshCache)
r.Post("/rebuild_parent_path", app.rebuildParentPath)
})
}

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

@@ -1,41 +0,0 @@
package system
import (
"net/http"
"management/internal/erpserver/handler"
v1 "management/internal/erpserver/service/v1"
"management/internal/erpserver/templ/home"
)
type HomeHandler struct {
*handler.Handler
userService v1.UserService
loginLogService v1.LoginLogService
}
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) {
ctx := r.Context()
h.Render(ctx, w, home.Home(ctx))
}
func (h *HomeHandler) Dashboard(w http.ResponseWriter, r *http.Request) {
ctx := r.Context()
auth := h.AuthUser(ctx)
//user, _ := h.userService.Get(ctx, auth.ID)
lt, _ := h.loginLogService.LoginTime(ctx, auth.Email)
c := h.loginLogService.LoginCount(ctx, auth.Email)
h.Render(ctx, w, home.Dashboard(ctx, int(c), lt.ThisLoginTime, lt.LastLoginTime))
}

44
internal/erpserver/handler/system/home/home.go Normal file
View File

@@ -0,0 +1,44 @@
package home
import (
"net/http"
v1 "management/internal/erpserver/service/v1"
"management/internal/erpserver/templ/home"
"management/internal/pkg/mid"
"management/internal/pkg/render"
)
type App struct {
render render.Renderer
userService v1.UserService
menuService v1.MenuService
loginLogService v1.LoginLogService
}
func NewApp(
render render.Renderer,
userService v1.UserService,
menuService v1.MenuService,
loginLogService v1.LoginLogService,
) *App {
return &App{
render: render,
userService: userService,
menuService: menuService,
loginLogService: loginLogService,
}
}
func (a *App) home(w http.ResponseWriter, r *http.Request) {
ctx := r.Context()
a.render.Render(ctx, w, home.Home(ctx))
}
func (a *App) dashboard(w http.ResponseWriter, r *http.Request) {
ctx := r.Context()
auth := mid.GetUser(ctx)
lt, _ := a.loginLogService.LoginTime(ctx, auth.Email)
c := a.loginLogService.LoginCount(ctx, auth.Email)
a.render.Render(ctx, w, home.Dashboard(ctx, int(c), lt.ThisLoginTime, lt.LastLoginTime))
}

25
internal/erpserver/handler/system/home/route.go Normal file
View File

@@ -0,0 +1,25 @@
package home
import (
v1 "management/internal/erpserver/service/v1"
"management/internal/pkg/mid"
"management/internal/pkg/render"
"management/internal/pkg/session"
"github.com/go-chi/chi/v5"
)
type Config struct {
Sm session.Manager
Render render.Renderer
UserService v1.UserService
MenuService v1.MenuService
LoginLogService v1.LoginLogService
}
func Routes(r chi.Router, cfg Config) {
app := NewApp(cfg.Render, cfg.UserService, cfg.MenuService, cfg.LoginLogService)
r.With(mid.Authorize(cfg.Sm, cfg.MenuService)).Get("/home.html", app.home)
r.With(mid.Authorize(cfg.Sm, cfg.MenuService)).Get("/dashboard", app.dashboard)
}

26
internal/erpserver/handler/system/login_log.go → internal/erpserver/handler/system/loginlog/login_log.go
View File

@@ -1,51 +1,51 @@
package system
package loginlog
import (
"net/http"
"management/internal/erpserver/handler"
"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 LoginLogHandler struct {
*handler.Handler
type App struct {
render render.Renderer
loginLogService v1.LoginLogService
}
func NewLoginLogHandler(handler *handler.Handler, loginLogService v1.LoginLogService) *LoginLogHandler {
return &LoginLogHandler{
Handler: handler,
func NewApp(render render.Renderer, loginLogService v1.LoginLogService) *App {
return &App{
render: render,
loginLogService: loginLogService,
}
}
func (h *LoginLogHandler) List(w http.ResponseWriter, r *http.Request) {
func (a *App) list(w http.ResponseWriter, r *http.Request) {
switch r.Method {
case http.MethodGet:
ctx := r.Context()
h.Render(ctx, w, loginlog.List(ctx))
a.render.Render(ctx, w, loginlog.List(ctx))
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.loginLogService.List(r.Context(), q)
res, count, err := a.loginLogService.List(r.Context(), q)
if err != nil {
h.JSONErr(w, err.Error())
a.render.JSONErr(w, err.Error())
return
}
data := handler.ResponseList{
data := render.ResponseList{
Code: 0,
Message: "ok",
Count: count,
Data: res,
}
h.JSON(w, data)
a.render.JSON(w, data)
default:
http.Error(w, "Method Not Allowed", http.StatusMethodNotAllowed)
}

25
internal/erpserver/handler/system/loginlog/route.go Normal file
View File

@@ -0,0 +1,25 @@
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)
})
}

103
internal/erpserver/handler/system/menu.go → internal/erpserver/handler/system/menu/menu.go
View File

@@ -1,4 +1,4 @@
package system
package menu
import (
"net/http"
@@ -6,77 +6,78 @@ import (
"strings"
"time"
"management/internal/erpserver/handler"
systemmodel "management/internal/erpserver/model/system"
v1 "management/internal/erpserver/service/v1"
"management/internal/erpserver/templ/system/menu"
"management/internal/pkg/convertor"
"management/internal/pkg/database"
"management/internal/pkg/mid"
"management/internal/pkg/render"
"github.com/google/uuid"
)
const style = "layui-btn-primary layui-btn-sm"
type MenuHandler struct {
*handler.Handler
type App struct {
render render.Renderer
menuService v1.MenuService
}
func NewMenuHandler(handler *handler.Handler, menuService v1.MenuService) *MenuHandler {
return &MenuHandler{
Handler: handler,
func NewApp(render render.Renderer, menuService v1.MenuService) *App {
return &App{
render: render,
menuService: menuService,
}
}
func (h *MenuHandler) Menus(w http.ResponseWriter, r *http.Request) {
func (a *App) menus(w http.ResponseWriter, r *http.Request) {
ctx := r.Context()
user := h.AuthUser(ctx)
menus, err := h.menuService.OwerMenus(ctx, user.RoleID)
user := mid.GetUser(ctx)
menus, err := a.menuService.OwerMenus(ctx, user.RoleID)
if err != nil {
h.JSONErr(w, err.Error())
a.render.JSONErr(w, err.Error())
return
}
h.JSON(w, menus)
a.render.JSON(w, menus)
}
func (h *MenuHandler) List(w http.ResponseWriter, r *http.Request) {
func (a *App) list(w http.ResponseWriter, r *http.Request) {
switch r.Method {
case http.MethodGet:
ctx := r.Context()
h.Render(ctx, w, menu.List(ctx))
a.render.Render(ctx, w, menu.List(ctx))
case http.MethodPost:
res, err := h.menuService.ListMenuTree(r.Context())
res, err := a.menuService.ListMenuTree(r.Context())
if err != nil {
h.JSONErr(w, err.Error())
a.render.JSONErr(w, err.Error())
return
}
data := handler.ResponseList{
data := render.ResponseList{
Code: 0,
Message: "ok",
Count: 0,
Data: res,
}
h.JSON(w, data)
a.render.JSON(w, data)
default:
h.JSONErr(w, "method not allowed")
a.render.JSONErr(w, "method not allowed")
}
}
func (h *MenuHandler) Add(w http.ResponseWriter, r *http.Request) {
func (a *App) add(w http.ResponseWriter, r *http.Request) {
ctx := r.Context()
h.Render(ctx, w, menu.Edit(ctx, &systemmodel.Menu{Style: style, Visible: true, Sort: 6666}))
a.render.Render(ctx, w, menu.Edit(ctx, &systemmodel.Menu{Style: style, Visible: true, Sort: 6666}))
}
func (h *MenuHandler) AddChildren(w http.ResponseWriter, r *http.Request) {
func (a *App) addChildren(w http.ResponseWriter, r *http.Request) {
ctx := r.Context()
vars := r.URL.Query()
parentID := convertor.QueryInt[int32](vars, "parentID", 0)
vm := &systemmodel.Menu{ParentID: parentID, Style: style, Visible: true, Sort: 6666}
parent, err := h.menuService.Get(ctx, parentID)
parent, err := a.menuService.Get(ctx, parentID)
if err == nil {
if parent.Type == "node" {
vm.Type = "menu"
@@ -84,21 +85,21 @@ func (h *MenuHandler) AddChildren(w http.ResponseWriter, r *http.Request) {
vm.Type = "btn"
}
}
h.Render(ctx, w, menu.Edit(ctx, vm))
a.render.Render(ctx, w, menu.Edit(ctx, vm))
}
func (h *MenuHandler) Edit(w http.ResponseWriter, r *http.Request) {
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 := &systemmodel.Menu{Style: style, Sort: 6666}
if id > 0 {
vm, _ = h.menuService.Get(r.Context(), id)
vm, _ = a.menuService.Get(r.Context(), id)
}
h.Render(ctx, w, menu.Edit(ctx, vm))
a.render.Render(ctx, w, menu.Edit(ctx, vm))
}
func (h *MenuHandler) Save(w http.ResponseWriter, r *http.Request) {
func (a *App) save(w http.ResponseWriter, r *http.Request) {
id := convertor.ConvertInt[int32](r.PostFormValue("ID"), 0)
name := r.PostFormValue("Name")
displayName := r.PostFormValue("DisplayName")
@@ -122,9 +123,9 @@ func (h *MenuHandler) Save(w http.ResponseWriter, r *http.Request) {
parentPath := ""
if parentID > 0 {
parent, err := h.menuService.Get(ctx, parentID)
parent, err := a.menuService.Get(ctx, parentID)
if err != nil {
h.JSONErr(w, err.Error())
a.render.JSONErr(w, err.Error())
return
}
parentPath = parent.ParentPath + "," + strconv.Itoa(int(parentID)) + ","
@@ -148,21 +149,21 @@ func (h *MenuHandler) Save(w http.ResponseWriter, r *http.Request) {
CreatedAt: time.Now(),
UpdatedAt: time.Now(),
}
err := h.menuService.Create(ctx, arg)
err := a.menuService.Create(ctx, arg)
if err != nil {
if database.IsUniqueViolation(err) {
h.JSONErr(w, "菜单已存在")
a.render.JSONErr(w, "菜单已存在")
return
}
h.JSONErr(w, err.Error())
a.render.JSONErr(w, err.Error())
return
}
h.JSONOk(w, "添加成功")
a.render.JSONOk(w, "添加成功")
} else {
res, err := h.menuService.Get(ctx, id)
res, err := a.menuService.Get(ctx, id)
if err != nil {
h.JSONErr(w, err.Error())
a.render.JSONErr(w, err.Error())
return
}
@@ -179,48 +180,48 @@ func (h *MenuHandler) Save(w http.ResponseWriter, r *http.Request) {
res.Status = status
res.Sort = sort
res.UpdatedAt = time.Now()
err = h.menuService.Update(ctx, res)
err = a.menuService.Update(ctx, res)
if err != nil {
h.JSONErr(w, err.Error())
a.render.JSONErr(w, err.Error())
return
}
h.JSONOk(w, "更新成功")
a.render.JSONOk(w, "更新成功")
}
}
func (h *MenuHandler) Data(w http.ResponseWriter, r *http.Request) {
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 := h.menuService.Tree(ctx, 0)
res, err := a.menuService.Tree(ctx, 0)
if err != nil {
h.JSONErr(w, err.Error())
a.render.JSONErr(w, err.Error())
return
}
h.JSON(w, res)
a.render.JSON(w, res)
return
} else if t == "xm_select_tree" {
res, err := h.menuService.XmSelectTree(ctx, 0)
res, err := a.menuService.XmSelectTree(ctx, 0)
if err != nil {
h.JSONErr(w, err.Error())
a.render.JSONErr(w, err.Error())
return
}
h.JSON(w, res)
a.render.JSON(w, res)
return
}
h.JSON(w, nil)
a.render.JSON(w, nil)
}
func (h *MenuHandler) RefreshCache(w http.ResponseWriter, r *http.Request) {
err := h.menuService.RefreshCache(r.Context())
func (a *App) refreshCache(w http.ResponseWriter, r *http.Request) {
err := a.menuService.RefreshCache(r.Context())
if err != nil {
h.JSONErr(w, err.Error())
a.render.JSONErr(w, err.Error())
return
}
h.JSONOk(w, "缓存刷新成功")
a.render.JSONOk(w, "缓存刷新成功")
}

35
internal/erpserver/handler/system/menu/route.go Normal file
View File

@@ -0,0 +1,35 @@
package menu
import (
v1 "management/internal/erpserver/service/v1"
"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
MenuService v1.MenuService
}
func Routes(r chi.Router, cfg Config) {
app := NewApp(cfg.Render, cfg.MenuService)
r.Get("/menus", app.menus)
r.Route("/menu", func(r chi.Router) {
r.Use(mid.Audit(cfg.Sm, cfg.Log))
r.Get("/list", app.list)
r.Post("/list", app.list)
r.Get("/add", app.add)
r.Get("/add_children", app.addChildren)
r.Get("/edit", app.edit)
r.Post("/save", app.save)
r.Post("/data", app.data)
r.Post("/refresh_cache", app.refreshCache)
})
}

138
internal/erpserver/handler/system/role.go → internal/erpserver/handler/system/role/role.go
View File

@@ -1,10 +1,9 @@
package system
package role
import (
"net/http"
"strings"
"management/internal/erpserver/handler"
"management/internal/erpserver/model/dto"
"management/internal/erpserver/model/form"
"management/internal/erpserver/model/system"
@@ -13,27 +12,28 @@ import (
"management/internal/erpserver/templ/system/role"
"management/internal/pkg/binding"
"management/internal/pkg/convertor"
"management/internal/pkg/render"
)
type RoleHandler struct {
*handler.Handler
type App struct {
render render.Renderer
roleService v1.RoleService
menuService v1.MenuService
}
func NewRoleHandler(handler *handler.Handler, roleService v1.RoleService, menuService v1.MenuService) *RoleHandler {
return &RoleHandler{
Handler: handler,
func NewApp(render render.Renderer, roleService v1.RoleService, menuService v1.MenuService) *App {
return &App{
render: render,
roleService: roleService,
menuService: menuService,
}
}
func (h *RoleHandler) List(w http.ResponseWriter, r *http.Request) {
func (a *App) list(w http.ResponseWriter, r *http.Request) {
switch r.Method {
case http.MethodGet:
ctx := r.Context()
h.Render(ctx, w, role.List(ctx))
a.render.Render(ctx, w, role.List(ctx))
case http.MethodPost:
var q dto.SearchDto
q.SearchTimeBegin, q.SearchTimeEnd = convertor.DefaultStartTimeAndEndTime(r.PostFormValue("timeBegin"), r.PostFormValue("timeEnd"))
@@ -43,155 +43,155 @@ 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.roleService.List(r.Context(), q)
res, count, err := a.roleService.List(r.Context(), q)
if err != nil {
h.JSONErr(w, err.Error())
a.render.JSONErr(w, err.Error())
return
}
data := handler.ResponseList{
data := render.ResponseList{
Code: 0,
Message: "ok",
Count: count,
Data: res,
}
h.JSON(w, data)
a.render.JSON(w, data)
default:
http.Error(w, "Method Not Allowed", http.StatusMethodNotAllowed)
}
}
func (h *RoleHandler) Add(w http.ResponseWriter, r *http.Request) {
func (a *App) add(w http.ResponseWriter, r *http.Request) {
ctx := r.Context()
h.Render(ctx, w, role.Edit(ctx, &system.Role{Sort: 6666}))
a.render.Render(ctx, w, role.Edit(ctx, &system.Role{Sort: 6666}))
}
func (h *RoleHandler) AddChildren(w http.ResponseWriter, r *http.Request) {
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()
h.Render(ctx, w, role.Edit(ctx, vm))
a.render.Render(ctx, w, role.Edit(ctx, vm))
}
func (h *RoleHandler) Edit(w http.ResponseWriter, r *http.Request) {
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, _ = h.roleService.Get(ctx, id)
vm, _ = a.roleService.Get(ctx, id)
}
h.Render(ctx, w, role.Edit(ctx, vm))
a.render.Render(ctx, w, role.Edit(ctx, vm))
}
func (h *RoleHandler) Save(w http.ResponseWriter, r *http.Request) {
func (a *App) save(w http.ResponseWriter, r *http.Request) {
var req form.Role
if err := binding.Form.Bind(r, &req); err != nil {
h.JSONErr(w, binding.ValidatorErrors(err))
a.render.JSONErr(w, binding.ValidatorErrors(err))
return
}
ctx := r.Context()
if *req.ID == 0 {
err := h.roleService.Create(ctx, &req)
err := a.roleService.Create(ctx, &req)
if err != nil {
h.JSONErr(w, err.Error())
a.render.JSONErr(w, err.Error())
return
}
h.JSONOk(w, "添加成功")
a.render.JSONOk(w, "添加成功")
} else {
err := h.roleService.Update(ctx, &req)
err := a.roleService.Update(ctx, &req)
if err != nil {
h.JSONErr(w, err.Error())
a.render.JSONErr(w, err.Error())
return
}
h.JSONOk(w, "更新成功")
a.render.JSONOk(w, "更新成功")
}
}
func (h *RoleHandler) Data(w http.ResponseWriter, r *http.Request) {
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 := h.roleService.Tree(ctx, 0)
res, err := a.roleService.Tree(ctx, 0)
if err != nil {
h.JSONErr(w, err.Error())
a.render.JSONErr(w, err.Error())
return
}
h.JSON(w, res)
a.render.JSON(w, res)
} else if t == "xm_select_tree" {
res, err := h.roleService.XmSelectTree(ctx, 0)
res, err := a.roleService.XmSelectTree(ctx, 0)
if err != nil {
h.JSONErr(w, err.Error())
a.render.JSONErr(w, err.Error())
return
}
h.JSON(w, res)
a.render.JSON(w, res)
}
}
func (h *RoleHandler) RefreshCache(w http.ResponseWriter, r *http.Request) {
err := h.roleService.RefreshCache(r.Context())
func (a *App) refreshCache(w http.ResponseWriter, r *http.Request) {
err := a.roleService.RefreshCache(r.Context())
if err != nil {
h.JSONErr(w, err.Error())
a.render.JSONErr(w, err.Error())
return
}
h.JSONOk(w, "缓存刷新成功")
a.render.JSONOk(w, "缓存刷新成功")
}
func (h *RoleHandler) RebuildParentPath(w http.ResponseWriter, r *http.Request) {
func (a *App) rebuildParentPath(w http.ResponseWriter, r *http.Request) {
ctx := r.Context()
err := h.roleService.RebuildParentPath(ctx)
err := a.roleService.RebuildParentPath(ctx)
if err != nil {
h.JSONErr(w, err.Error())
a.render.JSONErr(w, err.Error())
return
}
h.JSONOk(w, "重建成功")
a.render.JSONOk(w, "重建成功")
}
func (h *RoleHandler) RefreshRoleMenus(w http.ResponseWriter, r *http.Request) {
func (a *App) refreshRoleMenus(w http.ResponseWriter, r *http.Request) {
ctx := r.Context()
// 获取需要刷新的角色ID
roleID := convertor.ConvertInt[int32](r.PostFormValue("roleID"), 0)
roleModel, err := h.roleService.Get(ctx, roleID)
roleModel, err := a.roleService.Get(ctx, roleID)
if err != nil {
h.JSONErr(w, err.Error())
a.render.JSONErr(w, err.Error())
return
}
if roleModel == nil {
h.JSONErr(w, "角色不存在")
a.render.JSONErr(w, "角色不存在")
return
}
// 刷新角色菜单 (角色所拥有的菜单集合)
_, err = h.menuService.SetListByRoleID(ctx, roleModel.ID)
_, err = a.menuService.SetListByRoleID(ctx, roleModel.ID)
if err != nil {
h.JSONErr(w, err.Error())
a.render.JSONErr(w, err.Error())
return
}
// 刷新角色菜单 (角色所拥有的菜单集合)
_, err = h.menuService.SetListByRoleIDToMap(ctx, roleModel.ID)
_, err = a.menuService.SetListByRoleIDToMap(ctx, roleModel.ID)
if err != nil {
h.JSONErr(w, err.Error())
a.render.JSONErr(w, err.Error())
return
}
// 刷新角色菜单树 (pear admin layui 使用的格式)
_, err = h.menuService.SetOwerMenus(ctx, roleModel.ID)
_, err = a.menuService.SetOwerMenus(ctx, roleModel.ID)
if err != nil {
h.JSONErr(w, err.Error())
a.render.JSONErr(w, err.Error())
return
}
h.JSONOk(w, "刷新成功")
a.render.JSONOk(w, "刷新成功")
}
func (h *RoleHandler) SetMenu(w http.ResponseWriter, r *http.Request) {
func (a *App) setMenu(w http.ResponseWriter, r *http.Request) {
switch r.Method {
case http.MethodGet:
vars := r.URL.Query()
@@ -203,33 +203,33 @@ func (h *RoleHandler) SetMenu(w http.ResponseWriter, r *http.Request) {
ctx := r.Context()
if id > 0 {
var err error
vm.Role, err = h.roleService.Get(ctx, id)
vm.Role, err = a.roleService.Get(ctx, id)
if err == nil {
vm.Menus, _ = h.menuService.MenuViewData(ctx, vm.Role.ID)
vm.Menus, _ = a.menuService.MenuViewData(ctx, vm.Role.ID)
}
}
h.Render(ctx, w, role.SetMenu(ctx, vm))
a.render.Render(ctx, w, role.SetMenu(ctx, vm))
case http.MethodPost:
ctx := r.Context()
id := convertor.ConvertInt[int32](r.PostFormValue("ID"), 0)
if id == 0 {
h.JSONErr(w, "角色异常, 请刷新重试")
a.render.JSONErr(w, "角色异常, 请刷新重试")
return
}
roleModel, err := h.roleService.Get(ctx, id)
roleModel, err := a.roleService.Get(ctx, id)
if err != nil {
h.JSONErr(w, err.Error())
a.render.JSONErr(w, err.Error())
return
}
menus := r.PostFormValue("roleMenu")
if len(menus) == 0 {
h.JSONErr(w, "请选择菜单")
a.render.JSONErr(w, "请选择菜单")
return
}
menuArr := strings.Split(menus, ",")
if len(menuArr) == 0 {
h.JSONErr(w, "请选择菜单")
a.render.JSONErr(w, "请选择菜单")
return
}
@@ -237,9 +237,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.menuService.Get(ctx, int32(menuID))
menu, err := a.menuService.Get(ctx, int32(menuID))
if err != nil {
h.JSONErr(w, err.Error())
a.render.JSONErr(w, err.Error())
return
}
@@ -251,17 +251,17 @@ func (h *RoleHandler) SetMenu(w http.ResponseWriter, r *http.Request) {
}
if len(rms) == 0 {
h.JSONErr(w, "请选择正确的菜单")
a.render.JSONErr(w, "请选择正确的菜单")
return
}
err = h.menuService.SetRoleMenu(ctx, id, rms)
err = a.menuService.SetRoleMenu(ctx, id, rms)
if err != nil {
h.JSONErr(w, err.Error())
a.render.JSONErr(w, err.Error())
return
}
h.JSONOk(w, "设置成功")
a.render.JSONOk(w, "设置成功")
default:
http.Error(w, "Method Not Allowed", http.StatusMethodNotAllowed)
}

39
internal/erpserver/handler/system/role/route.go Normal file
View File

@@ -0,0 +1,39 @@
package role
import (
v1 "management/internal/erpserver/service/v1"
"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
RoleService v1.RoleService
MenuService v1.MenuService
}
func Routes(r chi.Router, cfg Config) {
app := NewApp(cfg.Render, cfg.RoleService, cfg.MenuService)
r.Route("/role", func(r chi.Router) {
r.Use(mid.Audit(cfg.Sm, cfg.Log))
r.Get("/list", app.list)
r.Post("/list", app.list)
r.Get("/add", app.add)
r.Get("/add_children", app.addChildren)
r.Get("/edit", app.edit)
r.Post("/save", app.save)
r.Post("/data", app.data)
r.Post("/refresh_cache", app.refreshCache)
r.Post("/rebuild_parent_path", app.rebuildParentPath)
r.Post("/refresh_role_menus", app.refreshRoleMenus)
r.Get("/set_menu", app.setMenu)
r.Post("/set_menu", app.setMenu)
})
}

145
internal/erpserver/handler/system/router.go
View File

@@ -1,145 +0,0 @@
package system
//
//import (
// v1 "management/internal/erpserver/service/v1"
// mi "management/internal/pkg/mid"
// "management/internal/pkg/session"
//
// "github.com/go-chi/chi/v5"
//)
//
//type HandlerGroup struct {
// sm session.Manager
// menuService v1.MenuService
// HomeHandler *HomeHandler
// ConfigHandler *ConfigHandler
// UserHandler *UserHandler
// LoginLogHandler *LoginLogHandler
// AuditHandler *AuditHandler
// MenuHandler *MenuHandler
// RoleHandler *RoleHandler
// DepartmentHandler *DepartmentHandler
//}
//
//func NewHandlerGroup(
// sm session.Manager,
// menuService v1.MenuService,
// homeHandler *HomeHandler,
// configHandler *ConfigHandler,
// userHandler *UserHandler,
// loginLogHandler *LoginLogHandler,
// auditHandler *AuditHandler,
// menuHandler *MenuHandler,
// roleHandler *RoleHandler,
// departmentHandler *DepartmentHandler,
//) *HandlerGroup {
// return &HandlerGroup{
// sm: sm,
// HomeHandler: homeHandler,
// ConfigHandler: configHandler,
// UserHandler: userHandler,
// LoginLogHandler: loginLogHandler,
// AuditHandler: auditHandler,
// MenuHandler: menuHandler,
// RoleHandler: roleHandler,
// DepartmentHandler: departmentHandler,
// }
//}
//
//func (g *HandlerGroup) Register(r chi.Router) {
// //r.Get("/captcha", g.CaptchaHandler.Captcha)
// //r.Post("/login", userHandler.Login)
//
// r.Get("/", g.UserHandler.Login)
// r.Group(func(r chi.Router) {
// r.Use(mi.Authorize(g.sm, menuService))
//
// r.Get("/logout", userHandler.Logout)
//
// r.Get("/home.html", homeHandler.Home)
// r.Get("/dashboard", homeHandler.Dashboard)
// r.Get("/pear.json", configHandler.Pear)
//
// r.Route("/upload", func(r chi.Router) {
// r.Use(mi.Audit(sm, auditLogService, log))
// r.Get("/img", uploadHandler.Img)
// r.Get("/file", uploadHandler.File)
// r.Get("/multi_files", uploadHandler.MultiFiles)
// })
//
// r.Route("/system", func(r chi.Router) {
// r.Use(mi.Audit(sm, auditLogService, log))
//
// r.Get("/menus", menuHandler.Menus)
//
// r.Route("/config", func(r chi.Router) {
// r.Get("/list", configHandler.List)
// r.Post("/list", configHandler.List)
// r.Get("/add", configHandler.Add)
// r.Get("/edit", configHandler.Edit)
// r.Post("/save", configHandler.Save)
// r.Post("/refresh_cache", configHandler.RefreshCache)
// r.Post("/reset_pear", configHandler.ResetPear)
// })
//
// r.Route("/menu", func(r chi.Router) {
// 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.Get("/list", departmentHandler.List)
// r.Post("/list", departmentHandler.List)
// r.Get("/add", departmentHandler.Add)
// r.Get("/add_children", departmentHandler.AddChildren)
// r.Get("/edit", departmentHandler.Edit)
// r.Post("/save", departmentHandler.Save)
// r.Post("/data", departmentHandler.Data)
// r.Post("/refresh_cache", departmentHandler.RefreshCache)
// r.Post("/rebuild_parent_path", departmentHandler.RebuildParentPath)
// })
//
// r.Route("/role", func(r chi.Router) {
// r.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)
// })
//
// r.Route("/login_log", func(r chi.Router) {
// r.Get("/list", loginLogHandler.List)
// r.Post("/list", loginLogHandler.List)
// })
//
// r.Route("/audit_log", func(r chi.Router) {
// r.Get("/list", auditHandler.List)
// r.Post("/list", auditHandler.List)
// })
// })
// })
//}

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

@@ -1,212 +0,0 @@
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/erpserver/templ/auth"
"management/internal/erpserver/templ/system/user"
"management/internal/pkg/binding"
"management/internal/pkg/convertor"
)
type UserHandler struct {
*handler.Handler
captchaService v1.CaptchaService
userService v1.UserService
roleService v1.RoleService
departmentService v1.DepartmentService
}
func NewUserHandler(
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) {
ctx := r.Context()
h.Render(ctx, w, user.Edit(ctx, &systemmodel.User{HashedPassword: nil}))
}
func (h *UserHandler) Edit(w http.ResponseWriter, r *http.Request) {
ctx := r.Context()
vars := r.URL.Query()
id := convertor.QueryInt[int32](vars, "id", 0)
vm := &systemmodel.User{}
if id > 0 {
if u, err := h.userService.Get(ctx, id); err == nil {
vm.HashedPassword = []byte("********")
vm = u
}
}
h.Render(ctx, w, user.Edit(ctx, vm))
}
func (h *UserHandler) Save(w http.ResponseWriter, r *http.Request) {
var req form.User
if err := binding.Form.Bind(r, &req); err != nil {
h.JSONErr(w, binding.ValidatorErrors(err))
return
}
ctx := r.Context()
if req.DepartmentID > 0 {
if _, err := h.departmentService.Get(ctx, req.DepartmentID); err != nil {
h.JSONErr(w, "部门数据错误")
return
}
}
if req.RoleID > 0 {
if _, err := h.roleService.Get(ctx, req.RoleID); err != nil {
h.JSONErr(w, "角色数据错误")
return
}
}
if *req.ID == 0 {
err := h.userService.Create(ctx, &req)
if err != nil {
h.JSONErr(w, err.Error())
return
}
h.JSONOk(w, "添加成功")
} else {
err := h.userService.Update(ctx, &req)
if err != nil {
h.JSONErr(w, err.Error())
return
}
h.JSONOk(w, "更新成功")
}
}
func (h *UserHandler) List(w http.ResponseWriter, r *http.Request) {
switch r.Method {
case http.MethodGet:
ctx := r.Context()
h.Render(ctx, w, user.List(ctx))
case http.MethodPost:
var q dto.SearchDto
q.SearchTimeBegin, q.SearchTimeEnd = convertor.DefaultStartTimeAndEndTime(r.PostFormValue("timeBegin"), r.PostFormValue("timeEnd"))
q.SearchStatus = convertor.ConvertInt(r.PostFormValue("status"), 9999)
q.SearchName = r.PostFormValue("name")
q.SearchEmail = r.PostFormValue("email")
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.userService.List(r.Context(), q)
if err != nil {
h.JSONErr(w, err.Error())
return
}
data := handler.ResponseList{
Code: 0,
Message: "ok",
Count: count,
Data: res,
}
h.JSON(w, data)
default:
http.Error(w, "Method Not Allowed", http.StatusMethodNotAllowed)
}
}
func (h *UserHandler) Profile(w http.ResponseWriter, r *http.Request) {
ctx := r.Context()
u := h.AuthUser(ctx)
vm, _ := h.userService.Get(ctx, u.ID)
h.Render(ctx, w, user.Profile(ctx, vm))
}
func (h *UserHandler) Data(w http.ResponseWriter, r *http.Request) {
vars := r.URL.Query()
t := vars.Get("type")
if t == "xm_select" {
res, err := h.userService.XmSelect(r.Context())
if err != nil {
h.JSONErr(w, err.Error())
return
}
h.JSON(w, res)
return
}
h.JSON(w, nil)
}
func (h *UserHandler) Login(w http.ResponseWriter, r *http.Request) {
ctx := r.Context()
switch r.Method {
case http.MethodGet:
u := h.AuthUser(ctx)
if u.ID > 0 {
if err := h.RenewToken(ctx); err == nil {
http.Redirect(w, r, "/home.html", http.StatusFound)
return
}
}
_ = h.Destroy(ctx)
component := auth.Login(ctx)
h.Render(ctx, w, component)
case http.MethodPost:
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.JSONErr(w, e)
return
}
if !h.captchaService.Verify(req.CaptchaID, req.Captcha, true) {
h.JSONErr(w, "验证码错误")
return
}
req = req.SetAttributes(r)
err := h.userService.Login(ctx, &req)
if err != nil {
log.Println(err)
h.JSONErr(w, err.Error())
return
}
h.JSONOk(w, "login successfully")
default:
http.Error(w, "Method Not Allowed", http.StatusMethodNotAllowed)
}
}
func (h *UserHandler) Logout(w http.ResponseWriter, r *http.Request) {
err := h.Destroy(r.Context())
if err != nil {
h.Log.Error(err.Error(), err)
}
http.Redirect(w, r, "/", http.StatusFound)
}

43
internal/erpserver/handler/system/user/route.go Normal file
View File

@@ -0,0 +1,43 @@
package user
import (
v1 "management/internal/erpserver/service/v1"
"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
UserService v1.UserService
RoleService v1.RoleService
MenuService v1.MenuService
DepartmentService v1.DepartmentService
}
func Routes(r chi.Router, cfg Config) {
app := NewApp(
cfg.Log,
cfg.Sm,
cfg.Render,
cfg.UserService,
cfg.RoleService,
cfg.DepartmentService,
)
r.Route("/user", func(r chi.Router) {
r.Use(mid.Audit(cfg.Sm, cfg.Log))
r.Get("/list", app.list)
r.Post("/list", app.list)
r.Get("/add", app.add)
r.Get("/edit", app.edit)
r.Post("/save", app.save)
r.Get("/profile", app.profile)
r.Post("/data", app.data)
})
}

160
internal/erpserver/handler/system/user/user.go Normal file
View File

@@ -0,0 +1,160 @@
package user
import (
"net/http"
"management/internal/erpserver/model/dto"
"management/internal/erpserver/model/form"
systemmodel "management/internal/erpserver/model/system"
v1 "management/internal/erpserver/service/v1"
"management/internal/erpserver/templ/system/user"
"management/internal/pkg/binding"
"management/internal/pkg/convertor"
"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
userService v1.UserService
roleService v1.RoleService
departmentService v1.DepartmentService
}
func NewApp(
log *logger.Logger,
sm session.Manager,
render render.Renderer,
userService v1.UserService,
roleService v1.RoleService,
departmentService v1.DepartmentService,
) *App {
return &App{
log: log,
sm: sm,
render: render,
userService: userService,
roleService: roleService,
departmentService: departmentService,
}
}
func (a *App) add(w http.ResponseWriter, r *http.Request) {
ctx := r.Context()
a.render.Render(ctx, w, user.Edit(ctx, &systemmodel.User{HashedPassword: nil}))
}
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 := &systemmodel.User{}
if id > 0 {
if u, err := a.userService.Get(ctx, id); err == nil {
vm.HashedPassword = []byte("********")
vm = u
}
}
a.render.Render(ctx, w, user.Edit(ctx, vm))
}
func (a *App) save(w http.ResponseWriter, r *http.Request) {
var req form.User
if err := binding.Form.Bind(r, &req); err != nil {
a.render.JSONErr(w, binding.ValidatorErrors(err))
return
}
ctx := r.Context()
if req.DepartmentID > 0 {
if _, err := a.departmentService.Get(ctx, req.DepartmentID); err != nil {
a.render.JSONErr(w, "部门数据错误")
return
}
}
if req.RoleID > 0 {
if _, err := a.roleService.Get(ctx, req.RoleID); err != nil {
a.render.JSONErr(w, "角色数据错误")
return
}
}
if *req.ID == 0 {
err := a.userService.Create(ctx, &req)
if err != nil {
a.render.JSONErr(w, err.Error())
return
}
a.render.JSONOk(w, "添加成功")
} else {
err := a.userService.Update(ctx, &req)
if err != nil {
a.render.JSONErr(w, err.Error())
return
}
a.render.JSONOk(w, "更新成功")
}
}
func (a *App) list(w http.ResponseWriter, r *http.Request) {
switch r.Method {
case http.MethodGet:
ctx := r.Context()
a.render.Render(ctx, w, user.List(ctx))
case http.MethodPost:
var q dto.SearchDto
q.SearchTimeBegin, q.SearchTimeEnd = convertor.DefaultStartTimeAndEndTime(r.PostFormValue("timeBegin"), r.PostFormValue("timeEnd"))
q.SearchStatus = convertor.ConvertInt(r.PostFormValue("status"), 9999)
q.SearchName = r.PostFormValue("name")
q.SearchEmail = r.PostFormValue("email")
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 := a.userService.List(r.Context(), q)
if err != nil {
a.render.JSONErr(w, err.Error())
return
}
data := render.ResponseList{
Code: 0,
Message: "ok",
Count: count,
Data: res,
}
a.render.JSON(w, data)
default:
http.Error(w, "Method Not Allowed", http.StatusMethodNotAllowed)
}
}
func (a *App) profile(w http.ResponseWriter, r *http.Request) {
ctx := r.Context()
u := mid.GetUser(ctx)
vm, _ := a.userService.Get(ctx, u.ID)
a.render.Render(ctx, w, user.Profile(ctx, vm))
}
func (a *App) data(w http.ResponseWriter, r *http.Request) {
vars := r.URL.Query()
t := vars.Get("type")
if t == "xm_select" {
res, err := a.userService.XmSelect(r.Context())
if err != nil {
a.render.JSONErr(w, err.Error())
return
}
a.render.JSON(w, res)
return
}
a.render.JSON(w, nil)
}