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

v2

Browse Source
This commit is contained in:
kenneth
2025-03-28 17:51:34 +08:00
parent da612380e0
commit 5c8802d2f0
68 changed files with 3422 additions and 630 deletions
Download Patch File Download Diff File Expand all files Collapse all files

31
internal/erpserver/biz/v1/system/audit.go Normal file
View File

@@ -0,0 +1,31 @@
package system
import (
"context"
db "management/internal/db/sqlc"
)
type AuditBiz interface {
Create(ctx context.Context, arg *db.CreateSysAuditLogParams) error
AuditExpansion
}
type AuditExpansion interface{}
type auditBiz struct {
store db.Store
}
var _ AuditBiz = (*auditBiz)(nil)
func NewAudit(store db.Store) *auditBiz {
return &auditBiz{
store: store,
}
}
func (b *auditBiz) Create(ctx context.Context, arg *db.CreateSysAuditLogParams) error {
return b.store.CreateSysAuditLog(ctx, arg)
}

63
internal/erpserver/biz/v1/system/config.go Normal file
View File

@@ -0,0 +1,63 @@
package system
import (
"context"
"encoding/json"
"time"
"management/internal/db/model/dto"
db "management/internal/db/sqlc"
"management/internal/global/keys"
"management/internal/global/pearadmin"
"management/internal/pkg/redis"
"management/internal/pkg/session"
)
type ConfigBiz interface {
ConfigExpansion
}
type ConfigExpansion interface {
Pear(ctx context.Context) (*dto.PearConfig, error)
}
type configBiz struct {
store db.Store
redis redis.IRedis
session session.ISession
}
var _ ConfigBiz = (*configBiz)(nil)
func NewConfig(store db.Store, redis redis.IRedis, session session.ISession) *configBiz {
return &configBiz{
store: store,
redis: redis,
session: session,
}
}
func (b *configBiz) Pear(ctx context.Context) (*dto.PearConfig, error) {
// 判断redis是否存储
key := keys.GetManageKey(ctx, keys.PearAdmin)
bs, err := b.redis.GetBytes(ctx, key)
if err == nil {
var res *dto.PearConfig
if err := json.Unmarshal(bs, &res); err == nil {
return res, nil
}
}
conf, err := b.store.GetSysConfigByKey(ctx, pearadmin.PearKey)
if err != nil {
return nil, err
}
var pear dto.PearConfig
if err := json.Unmarshal(conf.Value, &pear); err != nil {
return nil, err
}
_ = b.redis.Set(ctx, key, conf.Value, time.Hour*6)
return &pear, nil
}

183
internal/erpserver/biz/v1/system/department.go Normal file
View File

@@ -0,0 +1,183 @@
package system
import (
"context"
"encoding/json"
"strconv"
"time"
"management/internal/db/model/dto"
db "management/internal/db/sqlc"
"management/internal/erpserver/model/view"
"management/internal/global/keys"
"management/internal/pkg/redis"
"management/internal/pkg/session"
)
type DepartmentBiz interface {
Create(ctx context.Context, arg *db.CreateSysDepartmentParams) (*db.SysDepartment, error)
Update(ctx context.Context, arg *db.UpdateSysDepartmentParams) (*db.SysDepartment, error)
All(ctx context.Context) ([]*db.SysDepartment, error)
List(ctx context.Context, q dto.SearchDto) ([]*db.SysDepartment, int64, error)
Get(ctx context.Context, id int32) (*db.SysDepartment, error)
Refresh(ctx context.Context) ([]*db.SysDepartment, error)
RebuildParentPath(ctx context.Context) error
Tree(ctx context.Context, id int32) ([]*view.LayuiTree, error)
XmSelect(ctx context.Context, id int32) ([]*view.XmSelectTree, error)
DepartmentExpansion
}
type DepartmentExpansion interface{}
type departmentBiz struct {
store db.Store
redis redis.IRedis
session session.ISession
}
var _ DepartmentBiz = (*departmentBiz)(nil)
func NewDepartment(store db.Store, redis redis.IRedis, session session.ISession) *departmentBiz {
return &departmentBiz{
store: store,
redis: redis,
session: session,
}
}
func (b *departmentBiz) All(ctx context.Context) ([]*db.SysDepartment, error) {
key := keys.GetManageKey(ctx, keys.AllDepartments)
bs, err := redis.GetBytes(ctx, key)
if err == nil {
var res []*db.SysDepartment
if err := json.Unmarshal(bs, &res); err == nil {
return res, nil
}
}
return b.Refresh(ctx)
}
func (b *departmentBiz) List(ctx context.Context, q dto.SearchDto) ([]*db.SysDepartment, int64, error) {
countArg := &db.CountSysDepartmentConditionParams{
IsStatus: q.SearchStatus != 9999,
Status: int32(q.SearchStatus),
IsID: q.SearchID != 0,
ID: int32(q.SearchID),
IsParentID: q.SearchParentID != 0,
ParentID: int32(q.SearchParentID),
Name: q.SearchName,
}
dataArg := &db.ListSysDepartmentConditionParams{
IsStatus: q.SearchStatus != 9999,
Status: int32(q.SearchStatus),
IsID: q.SearchID != 0,
ID: int32(q.SearchID),
IsParentID: q.SearchParentID != 0,
ParentID: int32(q.SearchParentID),
Name: q.SearchName,
Skip: (int32(q.Page) - 1) * int32(q.Rows),
Size: int32(q.Rows),
}
count, err := b.store.CountSysDepartmentCondition(ctx, countArg)
if err != nil {
return nil, 0, err
}
departs, err := b.store.ListSysDepartmentCondition(ctx, dataArg)
if err != nil {
return nil, 0, err
}
return departs, count, nil
}
func (b *departmentBiz) Get(ctx context.Context, id int32) (*db.SysDepartment, error) {
return b.store.GetSysDepartment(ctx, id)
}
func (b *departmentBiz) Create(ctx context.Context, arg *db.CreateSysDepartmentParams) (*db.SysDepartment, error) {
return b.store.CreateSysDepartment(ctx, arg)
}
func (b *departmentBiz) Update(ctx context.Context, arg *db.UpdateSysDepartmentParams) (*db.SysDepartment, error) {
return b.store.UpdateSysDepartment(ctx, arg)
}
func (b *departmentBiz) Refresh(ctx context.Context) ([]*db.SysDepartment, error) {
all, err := b.store.AllSysDepartment(ctx)
if err != nil {
return nil, err
}
bs, err := json.Marshal(all)
if err != nil {
return nil, err
}
key := keys.GetManageKey(ctx, keys.AllDepartments)
err = redis.Set(ctx, key, bs, time.Hour*6)
if err != nil {
return nil, err
}
return all, nil
}
func (h *departmentBiz) RebuildParentPath(ctx context.Context) error {
return h.store.SysDepartmentRebuildPath(ctx)
}
func (h *departmentBiz) Tree(ctx context.Context, id int32) ([]*view.LayuiTree, error) {
all, err := h.All(ctx)
if err != nil {
return nil, err
}
return toLayuiTree(id, all), nil
}
func (h *departmentBiz) XmSelect(ctx context.Context, id int32) ([]*view.XmSelectTree, error) {
all, err := h.All(ctx)
if err != nil {
return nil, err
}
return toXmSelectTree(id, all), nil
}
func toXmSelectTree(parentId int32, data []*db.SysDepartment) []*view.XmSelectTree {
var res []*view.XmSelectTree
for _, v := range data {
if v.ParentID == parentId {
item := view.XmSelectTree{
Name: v.Name,
Value: strconv.FormatInt(int64(v.ID), 10),
Children: toXmSelectTree(v.ID, data),
}
res = append(res, &item)
}
}
return res
}
func toLayuiTree(parentId int32, data []*db.SysDepartment) []*view.LayuiTree {
var res []*view.LayuiTree
for _, v := range data {
if v.ParentID == parentId {
item := view.LayuiTree{}
item.ID = strconv.FormatInt(int64(v.ID), 10)
item.Title = v.Name
item.Children = toLayuiTree(v.ID, data)
if v.ParentID == 0 {
item.Spread = true
}
res = append(res, &item)
}
}
return res
}

311
internal/erpserver/biz/v1/system/menu.go Normal file
View File

@@ -0,0 +1,311 @@
package system
import (
"context"
"encoding/json"
"strconv"
"strings"
"time"
"management/internal/db/model/dto"
db "management/internal/db/sqlc"
"management/internal/global/keys"
"management/internal/pkg/redis"
"management/internal/pkg/session"
)
type MenuBiz interface {
MenuExpansion
}
type MenuExpansion interface {
GetSysMenuByUrl(ctx context.Context, url string) (*db.SysMenu, error)
ListOwnerMenuByRoleID(ctx context.Context, roleID int32) ([]*dto.OwnerMenuDto, error)
RecursiveSysMenus(ctx context.Context, roleID int32) ([]*dto.MenuUIDto, error)
SetRecursiveSysMenus(ctx context.Context, roleID int32) ([]*dto.MenuUIDto, error)
MapOwnerMenuByRoleID(ctx context.Context, roleID int32) (map[string]*dto.OwnerMenuDto, error)
SetOwnerMapMenuByRoleID(ctx context.Context, roleID int32) (map[string]*dto.OwnerMenuDto, error)
}
type menuBiz struct {
store db.Store
redis redis.IRedis
session session.ISession
}
var _ MenuBiz = (*menuBiz)(nil)
func NewMenu(store db.Store, redis redis.IRedis, session session.ISession) *menuBiz {
return &menuBiz{
store: store,
redis: redis,
session: session,
}
}
func (b *menuBiz) GetSysMenuByUrl(ctx context.Context, url string) (*db.SysMenu, error) {
return b.store.GetSysMenuByUrl(ctx, url)
}
func (b *menuBiz) ListOwnerMenuByRoleID(ctx context.Context, roleID int32) ([]*dto.OwnerMenuDto, error) {
// 判断redis是否存储
key := keys.GetManageKey(ctx, keys.OwnerMenus, roleID)
bs, err := b.redis.GetBytes(ctx, key)
if err == nil {
var res []*dto.OwnerMenuDto
if err := json.Unmarshal(bs, &res); err == nil {
return res, nil
}
}
return b.SetOwnerListMenuByRoleID(ctx, roleID)
}
func (b *menuBiz) SetOwnerListMenuByRoleID(ctx context.Context, roleID int32) ([]*dto.OwnerMenuDto, error) {
menus, err := b.ownerMenusByRoleID(ctx, roleID)
if err != nil {
return nil, err
}
var res []*dto.OwnerMenuDto
for _, menu := range menus {
res = append(res, &dto.OwnerMenuDto{
ID: menu.ID,
DisplayName: menu.DisplayName,
Url: menu.Url,
ParentID: menu.ParentID,
Avatar: menu.Avatar,
Style: menu.Style,
IsList: menu.IsList,
})
}
bs, err := json.Marshal(res)
if err != nil {
return nil, err
}
key := keys.GetManageKey(ctx, keys.OwnerMenus, roleID)
_ = redis.Set(ctx, key, bs, time.Hour*6)
return res, nil
}
func (b *menuBiz) RecursiveSysMenus(ctx context.Context, roleID int32) ([]*dto.MenuUIDto, error) {
// 判断redis是否存储
key := keys.GetManageKey(ctx, keys.RecursiveMenus, roleID)
bs, err := b.redis.GetBytes(ctx, key)
if err == nil {
var res []*dto.MenuUIDto
if err := json.Unmarshal(bs, &res); err == nil {
return res, nil
}
}
return b.SetRecursiveSysMenus(ctx, roleID)
}
func (b *menuBiz) SetRecursiveSysMenus(ctx context.Context, roleID int32) ([]*dto.MenuUIDto, error) {
// 判断当前用户是否有vip角色
role, err := b.store.GetSysRole(ctx, roleID)
if err != nil {
return nil, err
}
var menus []*db.SysMenu
if role.Vip {
// vip 用户
all, err := b.store.RecursiveSysMenus(ctx)
if err != nil {
return nil, err
}
menus = convertToMenuUIDto(all)
} else {
// not vip
all, err := b.store.RecursiveSysMenusByRoleID(ctx, roleID)
if err != nil {
return nil, err
}
menus = convertToMenuUIDto2(all)
}
menuList := uniqueSysMenus(menus)
if len(menuList) == 0 {
return nil, nil
}
tree := convertToUITree(menuList, 0)
bs, err := json.Marshal(tree)
if err != nil {
return nil, err
}
key := keys.GetManageKey(ctx, keys.RecursiveMenus, roleID)
_ = redis.Set(ctx, key, bs, time.Hour*6)
return tree, nil
}
func (b *menuBiz) MapOwnerMenuByRoleID(ctx context.Context, roleID int32) (map[string]*dto.OwnerMenuDto, error) {
// 判断redis是否存储
key := keys.GetManageKey(ctx, keys.OwnerMenus, roleID)
bs, err := b.redis.GetBytes(ctx, key)
if err == nil {
var res map[string]*dto.OwnerMenuDto
if err := json.Unmarshal(bs, &res); err == nil {
return res, nil
}
}
return b.SetOwnerMapMenuByRoleID(ctx, roleID)
}
func (b *menuBiz) SetOwnerMapMenuByRoleID(ctx context.Context, roleID int32) (map[string]*dto.OwnerMenuDto, error) {
result := make(map[string]*dto.OwnerMenuDto)
menus, err := b.ownerMenusByRoleID(ctx, roleID)
if err != nil {
return result, err
}
for _, menu := range menus {
result[menu.Url] = &dto.OwnerMenuDto{
ID: menu.ID,
DisplayName: menu.DisplayName,
Url: menu.Url,
ParentID: menu.ParentID,
Avatar: menu.Avatar,
Style: menu.Style,
IsList: menu.IsList,
}
}
bs, err := json.Marshal(result)
if err != nil {
return nil, err
}
key := keys.GetManageKey(ctx, keys.OwnerMenus, roleID)
_ = redis.Set(ctx, key, bs, time.Hour*6)
return result, nil
}
func (b *menuBiz) ownerMenusByRoleID(ctx context.Context, roleID int32) ([]*db.SysMenu, error) {
// 判断当前用户是否有vip角色
role, err := b.store.GetSysRole(ctx, roleID)
if err != nil {
return nil, err
}
var e error
var menus []*db.SysMenu
if role.Vip {
// vip 用户
menus, e = b.store.AllSysMenu(ctx)
if e != nil {
return nil, err
}
} else {
// not vip
menus, e = b.store.ListSysMenuByRoleID(ctx, roleID)
if e != nil {
return nil, err
}
}
return menus, nil
}
func convertToMenuUIDto(data []*db.RecursiveSysMenusRow) []*db.SysMenu {
var res []*db.SysMenu
for _, item := range data {
temp := &db.SysMenu{
ID: item.ID,
Name: item.Name,
DisplayName: item.DisplayName,
Url: item.Url,
Type: item.Type,
ParentID: item.ParentID,
ParentPath: item.ParentPath,
Avatar: item.Avatar,
Style: item.Style,
Visible: item.Visible,
IsList: item.IsList,
Status: item.Status,
Sort: item.Sort,
CreatedAt: item.CreatedAt,
UpdatedAt: item.UpdatedAt,
}
res = append(res, temp)
}
return res
}
func convertToMenuUIDto2(data []*db.RecursiveSysMenusByRoleIDRow) []*db.SysMenu {
var res []*db.SysMenu
for _, item := range data {
temp := &db.SysMenu{
ID: item.ID,
Name: item.Name,
DisplayName: item.DisplayName,
Url: item.Url,
Type: item.Type,
ParentID: item.ParentID,
ParentPath: item.ParentPath,
Avatar: item.Avatar,
Style: item.Style,
Visible: item.Visible,
IsList: item.IsList,
Status: item.Status,
Sort: item.Sort,
CreatedAt: item.CreatedAt,
UpdatedAt: item.UpdatedAt,
}
res = append(res, temp)
}
return res
}
func convertToUITree(data []*db.SysMenu, parentID int32) []*dto.MenuUIDto {
var root []*dto.MenuUIDto
for _, item := range data {
if item.ParentID == parentID {
if item.IsList {
temp := &dto.MenuUIDto{
ID: strings.ToLower(item.Url),
Title: item.DisplayName,
Icon: item.Avatar,
Type: 1,
OpenType: "_iframe",
// OpenType: "_component",
Href: item.Url,
}
root = append(root, temp)
} else {
temp := &dto.MenuUIDto{
ID: strconv.Itoa(int(item.ID)),
Title: item.DisplayName,
Icon: item.Avatar,
Type: 0,
}
temp.Children = convertToUITree(data, item.ID)
root = append(root, temp)
}
}
}
return root
}
func uniqueSysMenus(sm []*db.SysMenu) []*db.SysMenu {
res := make([]*db.SysMenu, 0) // 返回的新切片
m1 := make(map[int32]byte) // 用来去重的临时map
for _, v := range sm {
if _, ok := m1[v.ID]; !ok {
m1[v.ID] = 1
res = append(res, v)
}
}
return res
}

51
internal/erpserver/biz/v1/system/system.go Normal file
View File

@@ -0,0 +1,51 @@
package system
import (
db "management/internal/db/sqlc"
"management/internal/pkg/redis"
"management/internal/pkg/session"
)
type SystemBiz interface {
UserBiz() UserBiz
MenuBiz() MenuBiz
DepartmentBiz() DepartmentBiz
AuditBiz() AuditBiz
ConfigBiz() ConfigBiz
}
type systemBiz struct {
store db.Store
redis redis.IRedis
session session.ISession
}
var _ SystemBiz = (*systemBiz)(nil)
func New(store db.Store, redis redis.IRedis, session session.ISession) *systemBiz {
return &systemBiz{
store: store,
redis: redis,
session: session,
}
}
func (b *systemBiz) UserBiz() UserBiz {
return NewUser(b.store, b.session)
}
func (b *systemBiz) MenuBiz() MenuBiz {
return NewMenu(b.store, b.redis, b.session)
}
func (b *systemBiz) DepartmentBiz() DepartmentBiz {
return NewDepartment(b.store, b.redis, b.session)
}
func (b *systemBiz) AuditBiz() AuditBiz {
return NewAudit(b.store)
}
func (b *systemBiz) ConfigBiz() ConfigBiz {
return NewConfig(b.store, b.redis, b.session)
}

117
internal/erpserver/biz/v1/system/user.go Normal file
View File

@@ -0,0 +1,117 @@
package system
import (
"context"
"encoding/json"
"errors"
"time"
"management/internal/db/model/dto"
db "management/internal/db/sqlc"
"management/internal/erpserver/model/req"
"management/internal/global/know"
"management/internal/pkg/crypto"
"management/internal/pkg/session"
)
// UserBiz 定义处理用户请求所需的方法.
type UserBiz interface {
Create(ctx context.Context, req *db.CreateSysUserParams) (*db.SysUser, error)
UserExpansion
}
// UserExpansion 定义用户操作的扩展方法.
type UserExpansion interface {
Login(ctx context.Context, req *req.Login) error
}
// userBiz 是 UserBiz 接口的实现.
type userBiz struct {
store db.Store
session session.ISession
}
// 确保 userBiz 实现了 UserBiz 接口.
var _ UserBiz = (*userBiz)(nil)
func NewUser(store db.Store, session session.ISession) *userBiz {
return &userBiz{
store: store,
session: session,
}
}
func (b *userBiz) Create(ctx context.Context, req *db.CreateSysUserParams) (*db.SysUser, error) {
return b.store.CreateSysUser(ctx, req)
}
func (b *userBiz) Login(ctx context.Context, req *req.Login) error {
log := &db.CreateSysUserLoginLogParams{
CreatedAt: time.Now(),
Email: req.Email,
IsSuccess: false,
RefererUrl: req.Referrer,
Url: req.Url,
Os: req.Os,
Ip: req.Ip,
Browser: req.Browser,
}
user, err := b.store.GetSysUserByEmail(ctx, req.Email)
if err != nil {
log.Message = err.Error()
_ = b.store.CreateSysUserLoginLog(ctx, log)
return err
}
log.UserUuid = user.Uuid
log.Username = user.Username
err = crypto.BcryptComparePassword(user.HashedPassword, req.Password+user.Salt)
if err != nil {
log.Message = "compare password failed"
_ = b.store.CreateSysUserLoginLog(ctx, log)
return errors.New(log.Message)
}
// 登陆成功
if user.RoleID == 0 {
log.Message = "账号没有配置角色, 请联系管理员"
_ = b.store.CreateSysUserLoginLog(ctx, log)
return errors.New(log.Message)
}
sysRole, err := b.store.GetSysRole(ctx, user.RoleID)
if err != nil {
log.Message = "账号配置的角色错误, 请联系管理员"
_ = b.store.CreateSysUserLoginLog(ctx, log)
return errors.New(log.Message)
}
auth := dto.AuthorizeUser{
ID: user.ID,
Uuid: user.Uuid,
Email: user.Email,
Username: user.Username,
RoleID: sysRole.ID,
RoleName: sysRole.Name,
OS: log.Os,
IP: log.Ip,
Browser: log.Browser,
}
gob, err := json.Marshal(auth)
if err != nil {
log.Message = err.Error()
_ = b.store.CreateSysUserLoginLog(ctx, log)
return err
}
b.session.Put(ctx, know.StoreName, gob)
log.IsSuccess = true
log.Message = "登陆成功"
_ = b.store.CreateSysUserLoginLog(ctx, log)
return nil
}