daihengshun/ArmedPolice
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

feat：完善项目

Browse Source
This commit is contained in:
henry
2021-11-02 16:22:07 +08:00
parent 690cd96bed
commit 20d81825e1
81 changed files with 5394 additions and 3700 deletions
Download Patch File Download Diff File Expand all files Collapse all files

87
app/controller/menu/base.go
View File

@ -1,87 +0,0 @@
package menu
import (
model2 "ArmedPolice/app/common/model"
"ArmedPolice/app/model"
)
type (
Tree struct {
*model2.SysMenu
Children []*Tree `json:"children"`
}
TreeChecked struct {
*model2.SysMenuBasic
Checked bool `json:"checked"`
Children []*TreeChecked `json:"children"`
}
)
// tree 树状筛选
func tree(src []*model2.SysMenu, parentID uint64) []*Tree {
out := make([]*Tree, 0)
for _, v := range src {
if v.ParentID == parentID {
out = append(out, &Tree{
SysMenu: v,
Children: tree(src, v.ID),
})
}
}
return out
}
// TreeCheckedFunc 树状筛选
func TreeCheckedFunc(src []*model.SysMenuScene, parentID uint64) []*TreeChecked {
out := make([]*TreeChecked, 0)
for _, v := range src {
if v.ParentID == parentID {
out = append(out, &TreeChecked{
SysMenuBasic: v.SysMenuBasic,
Checked: v.SceneID > 0,
Children: TreeCheckedFunc(src, v.ID),
})
}
}
return out
}
// menuForSystem 系统管理员菜单
func menuForSystem(iModel model2.IModel, where ...*model2.ModelWhere) ([]*Tree, error) {
out, err := iModel.(*model.SysMenu).SystemMenu(where...)
if err != nil {
return nil, err
}
return tree(out, 0), nil
}
// menuForTenant 租户人员菜单
func menuForTenant(iModel model2.IModel, tenantID uint64) ([]*TreeChecked, error) {
out, err := iModel.(*model.SysMenu).TenantMenu(tenantID)
if err != nil {
return nil, err
}
return TreeCheckedFunc(out, 0), nil
}
func menuForRole(iModel model2.IModel, tenantID uint64, roleID uint64) ([]*TreeChecked, error) {
out, err := iModel.(*model.SysMenu).RoleMenu(tenantID, roleID)
if err != nil {
return nil, err
}
return TreeCheckedFunc(out, 0), nil
}
// menuForUser 当前用户菜单
func menuForUser(iModel model2.IModel, tenantID uint64, uid uint64) ([]*TreeChecked, error) {
out, err := iModel.(*model.SysMenu).UserMenu(uid)
if err != nil {
return nil, err
}
return TreeCheckedFunc(out, 0), nil
}

28
app/controller/menu/instance.go Normal file
View File

@ -0,0 +1,28 @@
package menu
import (
"ArmedPolice/app/controller/basic"
"ArmedPolice/app/service"
)
type Instance struct{ *service.Session }
type InstanceHandle func(session *service.Session) *Instance
func (c *Instance) List() (*basic.ReturnPages, error) {
return &basic.ReturnPages{Data: nil, Count: 0}, nil
}
func (c *Instance) Form() error {
return nil
}
func (c *Instance) Delete() error {
return nil
}
func NewInstance() InstanceHandle {
return func(session *service.Session) *Instance {
return &Instance{session}
}
}

113
app/controller/menu/menu.go
View File

@ -1,113 +0,0 @@
package menu
import (
model2 "ArmedPolice/app/common/model"
"ArmedPolice/app/controller"
"ArmedPolice/app/model"
"ArmedPolice/app/service"
"errors"
"time"
)
// Instance 菜单管理
type Instance struct{ *controller.Platform }
type InstanceHandle func(session *service.Session) *Instance
type (
// InstanceParams 菜单参数
InstanceParams struct {
ID, ParentID uint64
Kind, Auth int
Name, Link, Component, Icon string
Sort, Status int
Remark string
}
)
// List 列表信息
func (c *Instance) List() ([]*Tree, error) {
mSysMenu := model.NewSysMenu()
auth := []model2.SysMenuAuth{model2.SysMenuAuthForOrdinary}
if c.IsAdmin {
auth = append(auth, model2.SysMenuAuthForSystem)
}
return menuForSystem(mSysMenu, model2.NewWhereIn("auth", auth))
}
// Data 数据操作
func (c *Instance) Data(params *InstanceParams) error {
if params.ID <= 0 {
return model2.Create(&model2.SysMenu{
SysMenuBasic: model2.SysMenuBasic{
ParentID: params.ParentID,
Name: params.Name,
Kind: model2.SysMenuKind(params.Kind),
Link: params.Link,
Component: params.Component,
Icon: params.Icon,
},
Auth: model2.SysMenuAuth(params.Auth),
Sort: params.Sort,
Status: model2.SysMenuStatusForNormal,
Remark: params.Remark,
})
}
out := model.NewSysMenu()
out.ID = params.ID
isExist, err := model2.FirstWhere(out.SysMenu)
if err != nil {
return err
} else if !isExist {
return errors.New("菜单信息不存在")
}
out.ParentID = params.ParentID
out.Name = params.Name
out.Kind = model2.SysMenuKind(params.Kind)
out.Link = params.Link
out.Component = params.Component
out.Icon = params.Icon
out.Auth = model2.SysMenuAuth(params.Auth)
out.Sort = params.Sort
out.Status = model2.SysMenuStatus(params.Status)
out.Remark = params.Remark
if err = model2.Save(out); err != nil {
return err
}
return nil
}
// Status 状态操作
func (c *Instance) Status(id uint64, status int) error {
mSysMenu := model.NewSysMenu()
mSysMenu.ID = id
if err := model2.Updates(mSysMenu.SysMenu, map[string]interface{}{
"status": status, "updated_at": time.Now(),
}); err != nil {
return err
}
return nil
}
// Delete 删除操作
func (c *Instance) Delete(id uint64) error {
mSysMenu := model.NewSysMenu()
mSysMenu.ID = id
if err := model2.Delete(mSysMenu.SysMenu); err != nil {
return err
}
return nil
}
func NewInstance() InstanceHandle {
return func(session *service.Session) *Instance {
return &Instance{Platform: &controller.Platform{Session: session}}
}
}

74
app/controller/menu/role.go
View File

@ -1,74 +0,0 @@
package menu
import (
model2 "ArmedPolice/app/common/model"
"ArmedPolice/app/controller"
"ArmedPolice/app/model"
"ArmedPolice/app/service"
"ArmedPolice/serve/orm"
"errors"
"gorm.io/gorm"
)
type Role struct{ *controller.Platform }
type RoleHandle func(session *service.Session) *Role
// List 列表信息
func (c *Role) List(roleID uint64) ([]*TreeChecked, error) {
mSysMenu := model.NewSysMenu()
return menuForRole(mSysMenu, c.TenantID, roleID)
}
// Bind 绑定菜单
func (c *Role) Bind(roleID uint64, menuIDs []uint64) error {
if len(menuIDs) > 0 {
var count int64
mSysMenu := model.NewSysMenu()
if err := model2.Count(mSysMenu.SysMenu, &count, model2.NewWhereIn("id", menuIDs),
model2.NewWhere("auth", model2.SysMenuAuthForSystem)); err != nil {
return err
} else if count > 0 {
return errors.New("不可设置超管菜单")
}
}
mSysRoleMenu := model.NewSysRoleMenu()
return orm.GetDB().Transaction(func(tx *gorm.DB) error {
err := model2.DeleteWhere(mSysRoleMenu.SysRoleMenu, []*model2.ModelWhere{model2.NewWhere("role_id", roleID)}, tx)
if err != nil {
return err
}
if len(menuIDs) <= 0 {
return nil
}
menus := make([]*model2.SysRoleMenu, 0)
mark := make(map[uint64]uint64, 0)
for _, v := range menuIDs {
if _, has := mark[v]; has {
continue
}
menus = append(menus, &model2.SysRoleMenu{
ModelTenant: model2.ModelTenant{TenantID: c.TenantID}, RoleID: roleID, MenuID: v,
})
mark[v] = v
}
if err = model2.Creates(mSysRoleMenu.SysRoleMenu, menus, tx); err != nil {
return err
}
return nil
})
}
func NewRole() RoleHandle {
return func(session *service.Session) *Role {
return &Role{Platform: &controller.Platform{Session: session}}
}
}

91
app/controller/menu/tenant.go
View File

@ -1,91 +0,0 @@
package menu
import (
model2 "ArmedPolice/app/common/model"
"ArmedPolice/app/controller"
"ArmedPolice/app/model"
"ArmedPolice/app/service"
"ArmedPolice/serve/orm"
"errors"
"gorm.io/gorm"
)
type Tenant struct{ *controller.Platform }
type TenantHandle func(session *service.Session) *Tenant
func (c *Tenant) auth() {
}
// List 列表信息
func (c *Tenant) List(tenantID uint64) ([]*TreeChecked, error) {
mSysMenu := model.NewSysMenu()
return menuForTenant(mSysMenu, tenantID)
}
// Bind 绑定菜单
func (c *Tenant) Bind(tenantID uint64, menuIDs []uint64) error {
if len(menuIDs) > 0 {
var count int64
mSysMenu := model.NewSysMenu()
if err := model2.Count(mSysMenu.SysMenu, &count, model2.NewWhereIn("id", menuIDs),
model2.NewWhere("auth", model2.SysMenuAuthForSystem)); err != nil {
return err
} else if count > 0 {
return errors.New("不可设置超管菜单")
}
}
mSysTenantMenu := model.NewSysTenantMenu()
return orm.GetDB().Transaction(func(tx *gorm.DB) error {
// TODO：先全部删除，后期考虑局部删除
err := model2.DeleteWhere(mSysTenantMenu.SysTenantMenu, []*model2.ModelWhere{model2.NewWhere("tenant_id", tenantID)}, tx)
if err != nil {
return err
}
// 租户角色的菜单
mSysRoleMenu := model.NewSysRoleMenu()
if len(menuIDs) <= 0 {
if err = model2.DeleteWhere(mSysRoleMenu.SysRoleMenu, []*model2.ModelWhere{model2.NewWhere("tenant_id", tenantID)}, tx); err != nil {
return err
}
return nil
}
menus := make([]*model2.SysTenantMenu, 0)
mark := make(map[uint64]uint64, 0)
for _, v := range menuIDs {
if _, has := mark[v]; has {
continue
}
menus = append(menus, &model2.SysTenantMenu{
ModelTenant: model2.ModelTenant{TenantID: tenantID}, MenuID: v,
})
mark[v] = v
}
if err = model2.Creates(mSysTenantMenu.SysTenantMenu, menus, tx); err != nil {
return err
}
// 删除租户下角色不存在的菜单
if err = model2.DeleteWhere(mSysRoleMenu.SysRoleMenu, []*model2.ModelWhere{
model2.NewWhere("tenant_id", tenantID),
model2.NewWhereNotIn("menu_id", menuIDs),
}); err != nil {
return err
}
return nil
})
}
func NewTenant() TenantHandle {
return func(session *service.Session) *Tenant {
return &Tenant{Platform: &controller.Platform{Session: session}}
}
}

42
app/controller/menu/user.go
View File

@ -1,42 +0,0 @@
package menu
import (
model2 "ArmedPolice/app/common/model"
"ArmedPolice/app/controller"
"ArmedPolice/app/model"
"ArmedPolice/app/service"
)
type User struct{ *controller.Platform }
type UserHandle func(session *service.Session) *User
// User 用户列表
func (c *User) List() (interface{}, error) {
mSysMenu := model.NewSysMenu()
if c.IsAdmin {
return menuForSystem(mSysMenu)
}
mSysUserTenant := model.NewSysUserTenant()
isExist, err := model2.FirstField(mSysUserTenant.SysUserTenant, []string{"id", "identity"},
model2.NewWhere("tenant_id", c.TenantID),
model2.NewWhere("uid", c.UID))
if err != nil {
return nil, err
} else if !isExist {
return nil, nil
}
if mSysUserTenant.Identity == model2.SysUserTenantIdentityForSystemAdmin {
return menuForTenant(mSysMenu, c.TenantID)
}
return menuForUser(mSysMenu, c.TenantID, c.UID)
}
func NewUser() UserHandle {
return func(session *service.Session) *User {
return &User{Platform: &controller.Platform{Session: session}}
}
}