zijing/study-api-v2
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat(system): 添加系统菜单、角色菜单关联和用户角色关联功能- 新增系统菜单模型、控制器、请求验证和业务逻辑

Browse Source 
- 新增角色菜单关联模型、控制器、请求验证和业务逻辑
- 新增用户角色关联模型、控制器、请求验证和业务逻辑
- 更新系统角色模型，增加与用户和菜单的关联
- 更新用户模型，增加与角色的关联和相关方法
- 在路由文件中添加新功能的路由定义
This commit is contained in:
hx 2025-07-15 01:14:15 +08:00
parent c1a1e455b1
commit a621de91ff
17 changed files with 21448 additions and 41 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

19546
_ide_helper.php Executable file
View File

File diff suppressed because it is too large Load Diff

106
app/Http/Controllers/Admin/System/SystemMenuController.php Normal file
View File

@ -0,0 +1,106 @@
<?php
namespace App\Http\Controllers\Admin\System;
use App\Http\Controllers\BaseController;
use App\Http\Requests\Admin\System\SystemMenuRequest;
use App\Services\System\SystemMenuService;
use Illuminate\Http\JsonResponse;
/**
* 系统菜单控制器
*/
class SystemMenuController extends BaseController
{
public function __construct(
private SystemMenuService $systemMenuService
) {}
/**
* 获取系统菜单列表
*/
public function list(SystemMenuRequest $request): JsonResponse
{
$params = $request->validated();
$result = $this->systemMenuService->getList($params);
return $this->SuccessPage($result->items(), $result->total());
}
/**
* 获取简单列表
*/
public function simpleList(): JsonResponse
{
$result = $this->systemMenuService->getSimpleList();
return $this->Success($result);
}
/**
* 获取树形菜单
*/
public function tree(): JsonResponse
{
$result = $this->systemMenuService->getMenuTree();
return $this->Success($result);
}
/**
* 获取父级菜单列表
*/
public function parentMenus(): JsonResponse
{
$result = $this->systemMenuService->getParentMenus();
return $this->Success($result);
}
/**
* 获取系统菜单详情
*/
public function detail(SystemMenuRequest $request): JsonResponse
{
$params = $request->validated();
$result = $this->systemMenuService->detail($params['id']);
return $this->Success($result);
}
/**
* 创建系统菜单
*/
public function create(SystemMenuRequest $request): JsonResponse
{
$data = $request->validated();
$result = $this->systemMenuService->create($data);
return $this->Success($result);
}
/**
* 更新系统菜单
*/
public function update(SystemMenuRequest $request): JsonResponse
{
$params = $request->validated();
$result = $this->systemMenuService->update($params['id'], $params);
return $this->Success($result);
}
/**
* 删除系统菜单
*/
public function delete(SystemMenuRequest $request): JsonResponse
{
$params = $request->validated();
$this->systemMenuService->delete($params['id']);
return $this->Success();
}
/**
* 批量删除系统菜单
*/
public function batchDelete(SystemMenuRequest $request): JsonResponse
{
$params = $request->validated();
$this->systemMenuService->batchDelete($params['ids']);
return $this->Success();
}
}

102
app/Http/Controllers/Admin/System/SystemRoleMenuController.php Normal file
View File

@ -0,0 +1,102 @@
<?php
namespace App\Http\Controllers\Admin\System;
use App\Http\Controllers\BaseController;
use App\Http\Requests\Admin\System\SystemRoleMenuRequest;
use App\Services\System\SystemRoleMenuService;
use Illuminate\Http\JsonResponse;
/**
* 系统角色菜单关联控制器
*/
class SystemRoleMenuController extends BaseController
{
public function __construct(
private SystemRoleMenuService $systemRoleMenuService
) {}
/**
* 获取角色菜单关联列表
*/
public function list(SystemRoleMenuRequest $request): JsonResponse
{
$params = $request->validated();
$result = $this->systemRoleMenuService->getList($params);
return $this->SuccessPage($result->items(), $result->total());
}
/**
* 获取角色的菜单列表
*/
public function getRoleMenus(SystemRoleMenuRequest $request): JsonResponse
{
$params = $request->validated();
$result = $this->systemRoleMenuService->getRoleMenus($params['role_id']);
return $this->Success($result);
}
/**
* 获取菜单的角色列表
*/
public function getMenuRoles(SystemRoleMenuRequest $request): JsonResponse
{
$params = $request->validated();
$result = $this->systemRoleMenuService->getMenuRoles($params['menu_id']);
return $this->Success($result);
}
/**
* 获取角色的菜单树
*/
public function getRoleMenuTree(SystemRoleMenuRequest $request): JsonResponse
{
$params = $request->validated();
$result = $this->systemRoleMenuService->getRoleMenuTree($params['role_id']);
return $this->Success($result);
}
/**
* 设置角色菜单权限
*/
public function setRoleMenus(SystemRoleMenuRequest $request): JsonResponse
{
$params = $request->validated();
$result = $this->systemRoleMenuService->setRoleMenus(
$params['role_id'],
$params['menu_ids'] ?? []
);
return $this->Success($result);
}
/**
* 批量设置角色菜单权限
*/
public function batchSetRoleMenus(SystemRoleMenuRequest $request): JsonResponse
{
$params = $request->validated();
$result = $this->systemRoleMenuService->batchSetRoleMenus($params['role_menu_data']);
return $this->Success($result);
}
/**
* 清除角色的所有菜单权限
*/
public function clearRoleMenus(SystemRoleMenuRequest $request): JsonResponse
{
$params = $request->validated();
$this->systemRoleMenuService->clearRoleMenus($params['role_id']);
return $this->Success();
}
/**
* 清除菜单的所有角色关联
*/
public function clearMenuRoles(SystemRoleMenuRequest $request): JsonResponse
{
$params = $request->validated();
$this->systemRoleMenuService->clearMenuRoles($params['menu_id']);
return $this->Success();
}
}

135
app/Http/Controllers/Admin/System/SystemUserRoleController.php Normal file
View File

@ -0,0 +1,135 @@
<?php
namespace App\Http\Controllers\Admin\System;
use App\Http\Controllers\BaseController;
use App\Http\Requests\Admin\System\SystemUserRoleRequest;
use App\Services\System\SystemUserRoleService;
use Illuminate\Http\JsonResponse;
/**
* 系统用户角色关联控制器
*/
class SystemUserRoleController extends BaseController
{
public function __construct(
private SystemUserRoleService $systemUserRoleService
) {}
/**
* 获取用户角色关联列表
*/
public function list(SystemUserRoleRequest $request): JsonResponse
{
$params = $request->validated();
$result = $this->systemUserRoleService->getList($params);
return $this->SuccessPage($result->items(), $result->total());
}
/**
* 获取用户的角色列表
*/
public function getUserRoles(SystemUserRoleRequest $request): JsonResponse
{
$params = $request->validated();
$result = $this->systemUserRoleService->getUserRoles($params['user_id']);
return $this->Success($result);
}
/**
* 获取角色的用户列表
*/
public function getRoleUsers(SystemUserRoleRequest $request): JsonResponse
{
$params = $request->validated();
$result = $this->systemUserRoleService->getRoleUsers($params['role_id']);
return $this->Success($result);
}
/**
* 获取用户的角色详情
*/
public function getUserRoleDetails(SystemUserRoleRequest $request): JsonResponse
{
$params = $request->validated();
$result = $this->systemUserRoleService->getUserRoleDetails($params['user_id']);
return $this->Success($result);
}
/**
* 设置用户角色
*/
public function setUserRoles(SystemUserRoleRequest $request): JsonResponse
{
$params = $request->validated();
$result = $this->systemUserRoleService->setUserRoles(
$params['user_id'],
$params['role_ids'] ?? []
);
return $this->Success($result);
}
/**
* 为角色分配用户
*/
public function setRoleUsers(SystemUserRoleRequest $request): JsonResponse
{
$params = $request->validated();
$result = $this->systemUserRoleService->setRoleUsers(
$params['role_id'],
$params['user_ids'] ?? []
);
return $this->Success($result);
}
/**
* 批量设置用户角色
*/
public function batchSetUserRoles(SystemUserRoleRequest $request): JsonResponse
{
$params = $request->validated();
$result = $this->systemUserRoleService->batchSetUserRoles($params['user_role_data']);
return $this->Success($result);
}
/**
* 检查用户是否拥有角色
*/
public function hasRole(SystemUserRoleRequest $request): JsonResponse
{
$params = $request->validated();
$result = $this->systemUserRoleService->hasRole($params['user_id'], $params['role_id']);
return $this->Success(['has_role' => $result]);
}
/**
* 检查用户是否拥有角色编码
*/
public function hasRoleCode(SystemUserRoleRequest $request): JsonResponse
{
$params = $request->validated();
$result = $this->systemUserRoleService->hasRoleCode($params['user_id'], $params['role_code']);
return $this->Success(['has_role' => $result]);
}
/**
* 清除用户的所有角色
*/
public function clearUserRoles(SystemUserRoleRequest $request): JsonResponse
{
$params = $request->validated();
$this->systemUserRoleService->clearUserRoles($params['user_id']);
return $this->Success();
}
/**
* 清除角色的所有用户关联
*/
public function clearRoleUsers(SystemUserRoleRequest $request): JsonResponse
{
$params = $request->validated();
$this->systemUserRoleService->clearRoleUsers($params['role_id']);
return $this->Success();
}
}

175
app/Http/Requests/Admin/System/SystemMenuRequest.php Normal file
View File

@ -0,0 +1,175 @@
<?php
namespace App\Http\Requests\Admin\System;
use App\Http\Requests\BaseRequest;
/**
* 系统菜单请求验证
*/
class SystemMenuRequest extends BaseRequest
{
/**
* 获取特定验证规则
*/
protected function getSpecificRules(): array
{
$action = $this->route()->getActionMethod();
return match($action) {
'list' => $this->listRules(),
'detail' => $this->detailRules(),
'create' => $this->createRules(),
'update' => $this->updateRules(),
'delete' => $this->deleteRules(),
'batchDelete' => $this->batchDeleteRules(),
'simpleList', 'tree', 'parentMenus' => [],
default => []
};
}
/**
* 获取分页验证规则
*/
private function getPaginationRules(): array
{
return [
'page' => ['sometimes', 'integer', 'min:1'],
'page_size' => ['sometimes', 'integer', 'min:1', 'max:100'],
];
}
/**
* 列表查询验证规则
*/
private function listRules(): array
{
return array_merge($this->getPaginationRules(), [
'keyword' => ['sometimes', 'string', 'max:50'],
'status' => ['sometimes', 'integer', 'in:0,1'],
'type' => ['sometimes', 'integer', 'in:1,2,3'],
'parent_id' => ['sometimes', 'integer', 'min:0'],
'visible' => ['sometimes', 'integer', 'in:0,1'],
]);
}
/**
* 详情查询验证规则
*/
private function detailRules(): array
{
return [
'id' => ['required', 'integer', 'exists:system_menu,id'],
];
}
/**
* 创建验证规则
*/
private function createRules(): array
{
return [
'name' => ['required', 'string', 'max:50'],
'parent_id' => ['sometimes', 'integer', 'min:0'],
'type' => ['required', 'integer', 'in:1,2,3'],
'path' => ['sometimes', 'string', 'max:200'],
'icon' => ['sometimes', 'string', 'max:100'],
'component' => ['sometimes', 'string', 'max:200'],
'component_name' => ['sometimes', 'string', 'max:50'],
'status' => ['sometimes', 'integer', 'in:0,1'],
'visible' => ['sometimes', 'integer', 'in:0,1'],
'keep_alive' => ['sometimes', 'integer', 'in:0,1'],
'always_show' => ['sometimes', 'integer', 'in:0,1'],
'sort' => ['sometimes', 'integer', 'min:0'],
];
}
/**
* 更新验证规则
*/
private function updateRules(): array
{
return [
'id' => ['required', 'integer', 'exists:system_menu,id'],
'name' => ['required', 'string', 'max:50'],
'parent_id' => ['sometimes', 'integer', 'min:0'],
'type' => ['required', 'integer', 'in:1,2,3'],
'path' => ['sometimes', 'string', 'max:200'],
'icon' => ['sometimes', 'string', 'max:100'],
'component' => ['sometimes', 'string', 'max:200'],
'component_name' => ['sometimes', 'string', 'max:50'],
'status' => ['sometimes', 'integer', 'in:0,1'],
'visible' => ['sometimes', 'integer', 'in:0,1'],
'keep_alive' => ['sometimes', 'integer', 'in:0,1'],
'always_show' => ['sometimes', 'integer', 'in:0,1'],
'sort' => ['sometimes', 'integer', 'min:0'],
];
}
/**
* 删除验证规则
*/
private function deleteRules(): array
{
return [
'id' => ['required', 'integer', 'exists:system_menu,id'],
];
}
/**
* 批量删除验证规则
*/
private function batchDeleteRules(): array
{
return [
'ids' => ['required', 'array', 'min:1'],
'ids.*' => ['integer', 'exists:system_menu,id'],
];
}
/**
* 获取验证错误消息
*/
protected function getSpecificMessages(): array
{
return [
'name.required' => '菜单名称不能为空',
'name.max' => '菜单名称不能超过50个字符',
'type.required' => '菜单类型不能为空',
'type.in' => '菜单类型值无效（1目录 2菜单 3按钮）',
'parent_id.min' => '父级菜单ID不能小于0',
'path.max' => '路由地址不能超过200个字符',
'icon.max' => '菜单图标不能超过100个字符',
'component.max' => '组件路径不能超过200个字符',
'component_name.max' => '组件名不能超过50个字符',
'status.in' => '菜单状态值无效（0正常 1停用）',
'visible.in' => '显示状态值无效（0显示 1隐藏）',
'keep_alive.in' => '缓存状态值无效（0缓存 1不缓存）',
'always_show.in' => '总是显示状态值无效',
'sort.min' => '排序值不能小于0',
'ids.required' => '请选择要删除的菜单',
'ids.min' => '至少选择一条记录进行删除',
];
}
/**
* 字段别名
*/
public function attributes(): array
{
return [
'name' => '菜单名称',
'parent_id' => '父级菜单',
'type' => '菜单类型',
'path' => '路由地址',
'icon' => '菜单图标',
'component' => '组件路径',
'component_name' => '组件名称',
'status' => '菜单状态',
'visible' => '显示状态',
'keep_alive' => '缓存状态',
'always_show' => '总是显示',
'sort' => '排序',
];
}
}

168
app/Http/Requests/Admin/System/SystemRoleMenuRequest.php Normal file
View File

@ -0,0 +1,168 @@
<?php
namespace App\Http\Requests\Admin\System;
use App\Http\Requests\BaseRequest;
/**
* 系统角色菜单关联请求验证
*/
class SystemRoleMenuRequest extends BaseRequest
{
/**
* 获取特定验证规则
*/
protected function getSpecificRules(): array
{
$action = $this->route()->getActionMethod();
return match($action) {
'list' => $this->listRules(),
'getRoleMenus' => $this->getRoleMenusRules(),
'getMenuRoles' => $this->getMenuRolesRules(),
'getRoleMenuTree' => $this->getRoleMenuTreeRules(),
'setRoleMenus' => $this->setRoleMenusRules(),
'batchSetRoleMenus' => $this->batchSetRoleMenusRules(),
'clearRoleMenus' => $this->clearRoleMenusRules(),
'clearMenuRoles' => $this->clearMenuRolesRules(),
default => []
};
}
/**
* 获取分页验证规则
*/
private function getPaginationRules(): array
{
return [
'page' => ['sometimes', 'integer', 'min:1'],
'page_size' => ['sometimes', 'integer', 'min:1', 'max:100'],
];
}
/**
* 列表查询验证规则
*/
private function listRules(): array
{
return array_merge($this->getPaginationRules(), [
'role_id' => ['sometimes', 'integer', 'exists:system_role,id'],
'menu_id' => ['sometimes', 'integer', 'exists:system_menu,id'],
]);
}
/**
* 获取角色菜单验证规则
*/
private function getRoleMenusRules(): array
{
return [
'role_id' => ['required', 'integer', 'exists:system_role,id'],
];
}
/**
* 获取菜单角色验证规则
*/
private function getMenuRolesRules(): array
{
return [
'menu_id' => ['required', 'integer', 'exists:system_menu,id'],
];
}
/**
* 获取角色菜单树验证规则
*/
private function getRoleMenuTreeRules(): array
{
return [
'role_id' => ['required', 'integer', 'exists:system_role,id'],
];
}
/**
* 设置角色菜单验证规则
*/
private function setRoleMenusRules(): array
{
return [
'role_id' => ['required', 'integer', 'exists:system_role,id'],
'menu_ids' => ['sometimes', 'array'],
'menu_ids.*' => ['integer', 'exists:system_menu,id'],
];
}
/**
* 批量设置角色菜单验证规则
*/
private function batchSetRoleMenusRules(): array
{
return [
'role_menu_data' => ['required', 'array', 'min:1'],
'role_menu_data.*.role_id' => ['required', 'integer', 'exists:system_role,id'],
'role_menu_data.*.menu_ids' => ['sometimes', 'array'],
'role_menu_data.*.menu_ids.*' => ['integer', 'exists:system_menu,id'],
];
}
/**
* 清除角色菜单验证规则
*/
private function clearRoleMenusRules(): array
{
return [
'role_id' => ['required', 'integer', 'exists:system_role,id'],
];
}
/**
* 清除菜单角色验证规则
*/
private function clearMenuRolesRules(): array
{
return [
'menu_id' => ['required', 'integer', 'exists:system_menu,id'],
];
}
/**
* 获取验证错误消息
*/
protected function getSpecificMessages(): array
{
return [
'role_id.required' => '角色ID不能为空',
'role_id.integer' => '角色ID必须是整数',
'role_id.exists' => '指定的角色不存在',
'menu_id.required' => '菜单ID不能为空',
'menu_id.integer' => '菜单ID必须是整数',
'menu_id.exists' => '指定的菜单不存在',
'menu_ids.array' => '菜单ID列表必须是数组',
'menu_ids.*.integer' => '菜单ID必须是整数',
'menu_ids.*.exists' => '指定的菜单不存在',
'role_menu_data.required' => '角色菜单数据不能为空',
'role_menu_data.array' => '角色菜单数据必须是数组',
'role_menu_data.min' => '至少需要一组角色菜单数据',
'role_menu_data.*.role_id.required' => '角色ID不能为空',
'role_menu_data.*.role_id.integer' => '角色ID必须是整数',
'role_menu_data.*.role_id.exists' => '指定的角色不存在',
'role_menu_data.*.menu_ids.array' => '菜单ID列表必须是数组',
'role_menu_data.*.menu_ids.*.integer' => '菜单ID必须是整数',
'role_menu_data.*.menu_ids.*.exists' => '指定的菜单不存在',
];
}
/**
* 字段别名
*/
public function attributes(): array
{
return [
'role_id' => '角色',
'menu_id' => '菜单',
'menu_ids' => '菜单列表',
'role_menu_data' => '角色菜单数据',
];
}
}

213
app/Http/Requests/Admin/System/SystemUserRoleRequest.php Normal file
View File

@ -0,0 +1,213 @@
<?php
namespace App\Http\Requests\Admin\System;
use App\Http\Requests\BaseRequest;
/**
* 系统用户角色关联请求验证
*/
class SystemUserRoleRequest extends BaseRequest
{
/**
* 获取特定验证规则
*/
protected function getSpecificRules(): array
{
$action = $this->route()->getActionMethod();
return match($action) {
'list' => $this->listRules(),
'getUserRoles' => $this->getUserRolesRules(),
'getRoleUsers' => $this->getRoleUsersRules(),
'getUserRoleDetails' => $this->getUserRoleDetailsRules(),
'setUserRoles' => $this->setUserRolesRules(),
'setRoleUsers' => $this->setRoleUsersRules(),
'batchSetUserRoles' => $this->batchSetUserRolesRules(),
'hasRole' => $this->hasRoleRules(),
'hasRoleCode' => $this->hasRoleCodeRules(),
'clearUserRoles' => $this->clearUserRolesRules(),
'clearRoleUsers' => $this->clearRoleUsersRules(),
default => []
};
}
/**
* 获取分页验证规则
*/
private function getPaginationRules(): array
{
return [
'page' => ['sometimes', 'integer', 'min:1'],
'page_size' => ['sometimes', 'integer', 'min:1', 'max:100'],
];
}
/**
* 列表查询验证规则
*/
private function listRules(): array
{
return array_merge($this->getPaginationRules(), [
'user_id' => ['sometimes', 'integer', 'exists:system_users,id'],
'role_id' => ['sometimes', 'integer', 'exists:system_role,id'],
]);
}
/**
* 获取用户角色验证规则
*/
private function getUserRolesRules(): array
{
return [
'user_id' => ['required', 'integer', 'exists:system_users,id'],
];
}
/**
* 获取角色用户验证规则
*/
private function getRoleUsersRules(): array
{
return [
'role_id' => ['required', 'integer', 'exists:system_role,id'],
];
}
/**
* 获取用户角色详情验证规则
*/
private function getUserRoleDetailsRules(): array
{
return [
'user_id' => ['required', 'integer', 'exists:system_users,id'],
];
}
/**
* 设置用户角色验证规则
*/
private function setUserRolesRules(): array
{
return [
'user_id' => ['required', 'integer', 'exists:system_users,id'],
'role_ids' => ['sometimes', 'array'],
'role_ids.*' => ['integer', 'exists:system_role,id'],
];
}
/**
* 设置角色用户验证规则
*/
private function setRoleUsersRules(): array
{
return [
'role_id' => ['required', 'integer', 'exists:system_role,id'],
'user_ids' => ['sometimes', 'array'],
'user_ids.*' => ['integer', 'exists:system_users,id'],
];
}
/**
* 批量设置用户角色验证规则
*/
private function batchSetUserRolesRules(): array
{
return [
'user_role_data' => ['required', 'array', 'min:1'],
'user_role_data.*.user_id' => ['required', 'integer', 'exists:system_users,id'],
'user_role_data.*.role_ids' => ['sometimes', 'array'],
'user_role_data.*.role_ids.*' => ['integer', 'exists:system_role,id'],
];
}
/**
* 检查用户角色验证规则
*/
private function hasRoleRules(): array
{
return [
'user_id' => ['required', 'integer', 'exists:system_users,id'],
'role_id' => ['required', 'integer', 'exists:system_role,id'],
];
}
/**
* 检查用户角色编码验证规则
*/
private function hasRoleCodeRules(): array
{
return [
'user_id' => ['required', 'integer', 'exists:system_users,id'],
'role_code' => ['required', 'string', 'exists:system_role,code'],
];
}
/**
* 清除用户角色验证规则
*/
private function clearUserRolesRules(): array
{
return [
'user_id' => ['required', 'integer', 'exists:system_users,id'],
];
}
/**
* 清除角色用户验证规则
*/
private function clearRoleUsersRules(): array
{
return [
'role_id' => ['required', 'integer', 'exists:system_role,id'],
];
}
/**
* 获取验证错误消息
*/
protected function getSpecificMessages(): array
{
return [
'user_id.required' => '用户ID不能为空',
'user_id.integer' => '用户ID必须是整数',
'user_id.exists' => '指定的用户不存在',
'role_id.required' => '角色ID不能为空',
'role_id.integer' => '角色ID必须是整数',
'role_id.exists' => '指定的角色不存在',
'role_code.required' => '角色编码不能为空',
'role_code.string' => '角色编码必须是字符串',
'role_code.exists' => '指定的角色编码不存在',
'role_ids.array' => '角色ID列表必须是数组',
'role_ids.*.integer' => '角色ID必须是整数',
'role_ids.*.exists' => '指定的角色不存在',
'user_ids.array' => '用户ID列表必须是数组',
'user_ids.*.integer' => '用户ID必须是整数',
'user_ids.*.exists' => '指定的用户不存在',
'user_role_data.required' => '用户角色数据不能为空',
'user_role_data.array' => '用户角色数据必须是数组',
'user_role_data.min' => '至少需要一组用户角色数据',
'user_role_data.*.user_id.required' => '用户ID不能为空',
'user_role_data.*.user_id.integer' => '用户ID必须是整数',
'user_role_data.*.user_id.exists' => '指定的用户不存在',
'user_role_data.*.role_ids.array' => '角色ID列表必须是数组',
'user_role_data.*.role_ids.*.integer' => '角色ID必须是整数',
'user_role_data.*.role_ids.*.exists' => '指定的角色不存在',
];
}
/**
* 字段别名
*/
public function attributes(): array
{
return [
'user_id' => '用户',
'role_id' => '角色',
'role_code' => '角色编码',
'role_ids' => '角色列表',
'user_ids' => '用户列表',
'user_role_data' => '用户角色数据',
];
}
}

101
app/Models/System/SystemMenu.php Normal file
View File

@ -0,0 +1,101 @@
<?php
namespace App\Models\System;
use App\Models\BaseModel;
/**
* 系统菜单模型
*
* @property int $id 菜单ID
* @property string $name 菜单名称
* @property int $parent_id 父菜单ID
* @property int $type 菜单类型（1目录 2菜单 3按钮）
* @property string $path 路由地址
* @property string $icon 菜单图标
* @property string $component 组件路径
* @property string $component_name 组件名
* @property int $status 菜单状态（0正常 1停用）
* @property int $visible 显示状态（0显示 1隐藏）
* @property int $keep_alive 是否缓存（0缓存 1不缓存）
* @property int $always_show 是否总是显示根路由
* @property string $creator 创建者
* @property string $create_time 创建时间
* @property string $updater 更新者
* @property string $update_time 更新时间
* @property int $deleted 删除标识
* @property int $tenant_id 租户ID
* @property int $sort 显示顺序
*/
class SystemMenu extends BaseModel
{
protected $table = 'system_menu';
protected $fillable = [
'name',
'parent_id',
'type',
'path',
'icon',
'component',
'component_name',
'status',
'visible',
'keep_alive',
'always_show',
'sort',
];
protected $hidden = [
'deleted',
];
protected $casts = [
'id' => 'integer',
'parent_id' => 'integer',
'type' => 'integer',
'status' => 'integer',
'visible' => 'integer',
'keep_alive' => 'integer',
'always_show' => 'integer',
'sort' => 'integer',
'creator' => 'integer',
'updater' => 'integer',
'deleted' => 'integer',
'tenant_id' => 'integer',
'create_time' => 'datetime',
'update_time' => 'datetime',
];
/**
* 父级菜单
*/
public function parent()
{
return $this->belongsTo(SystemMenu::class, 'parent_id');
}
/**
* 子级菜单
*/
public function children()
{
return $this->hasMany(SystemMenu::class, 'parent_id');
}
/**
* 菜单角色关联
*/
public function roleMenus()
{
return $this->hasMany(SystemRoleMenu::class, 'menu_id');
}
/**
* 菜单的角色（多对多）
*/
public function roles()
{
return $this->belongsToMany(SystemRole::class, 'system_role_menu', 'menu_id', 'role_id');
}
}

32
app/Models/System/SystemRole.php
View File

@ -55,4 +55,36 @@ class SystemRole extends BaseModel
'create_time' => 'datetime',
'update_time' => 'datetime',
];
/**
* 角色用户关联
*/
public function userRoles()
{
return $this->hasMany(SystemUserRole::class, 'role_id');
}
/**
* 角色的用户（多对多）
*/
public function users()
{
return $this->belongsToMany(\App\Models\User::class, 'system_user_role', 'role_id', 'user_id');
}
/**
* 角色菜单关联
*/
public function roleMenus()
{
return $this->hasMany(SystemRoleMenu::class, 'role_id');
}
/**
* 角色的菜单（多对多）
*/
public function menus()
{
return $this->belongsToMany(SystemMenu::class, 'system_role_menu', 'role_id', 'menu_id');
}
}

60
app/Models/System/SystemRoleMenu.php Normal file
View File

@ -0,0 +1,60 @@
<?php
namespace App\Models\System;
use App\Models\BaseModel;
/**
* 系统角色菜单关联模型
*
* @property int $id 主键ID
* @property int $role_id 角色ID
* @property int $menu_id 菜单ID
* @property string $creator 创建者
* @property string $create_time 创建时间
* @property string $updater 更新者
* @property string $update_time 更新时间
* @property int $deleted 删除标识
* @property int $tenant_id 租户ID
*/
class SystemRoleMenu extends BaseModel
{
protected $table = 'system_role_menu';
protected $fillable = [
'role_id',
'menu_id',
];
protected $hidden = [
'deleted',
];
protected $casts = [
'id' => 'integer',
'role_id' => 'integer',
'menu_id' => 'integer',
'creator' => 'integer',
'updater' => 'integer',
'deleted' => 'integer',
'tenant_id' => 'integer',
'create_time' => 'datetime',
'update_time' => 'datetime',
];
/**
* 关联角色
*/
public function role()
{
return $this->belongsTo(SystemRole::class, 'role_id');
}
/**
* 关联菜单
*/
public function menu()
{
return $this->belongsTo(SystemMenu::class, 'menu_id');
}
}

60
app/Models/System/SystemUserRole.php Normal file
View File

@ -0,0 +1,60 @@
<?php
namespace App\Models\System;
use App\Models\BaseModel;
/**
* 系统用户角色关联模型
*
* @property int $id 主键ID
* @property int $user_id 用户ID
* @property int $role_id 角色ID
* @property string $creator 创建者
* @property string $create_time 创建时间
* @property string $updater 更新者
* @property string $update_time 更新时间
* @property int $deleted 删除标识
* @property int $tenant_id 租户ID
*/
class SystemUserRole extends BaseModel
{
protected $table = 'system_user_role';
protected $fillable = [
'user_id',
'role_id',
];
protected $hidden = [
'deleted',
];
protected $casts = [
'id' => 'integer',
'user_id' => 'integer',
'role_id' => 'integer',
'creator' => 'integer',
'updater' => 'integer',
'deleted' => 'integer',
'tenant_id' => 'integer',
'create_time' => 'datetime',
'update_time' => 'datetime',
];
/**
* 关联用户
*/
public function user()
{
return $this->belongsTo(\App\Models\User::class, 'user_id');
}
/**
* 关联角色
*/
public function role()
{
return $this->belongsTo(SystemRole::class, 'role_id');
}
}

84
app/Models/User.php
View File

@ -2,6 +2,9 @@
namespace App\Models;
use App\Models\BaseModel;
use App\Models\System\SystemRole;
use App\Models\System\SystemUserRole;
use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Foundation\Auth\User as Authenticatable;
use Illuminate\Notifications\Notifiable;
@ -88,4 +91,85 @@ class User extends Authenticatable
'password' => 'hashed',
];
}
/**
* 用户角色关联
*/
public function userRoles()
{
return $this->hasMany(SystemUserRole::class, 'user_id');
}
/**
* 用户的角色（多对多）
*/
public function roles()
{
return $this->belongsToMany(SystemRole::class, 'system_user_role', 'user_id', 'role_id');
}
/**
* 获取用户的角色ID列表
*/
public function getRoleIds(): array
{
return $this->userRoles()->pluck('role_id')->toArray();
}
/**
* 获取用户的角色编码列表
*/
public function getRoleCodes(): array
{
return $this->roles()->pluck('code')->toArray();
}
/**
* 检查用户是否拥有指定角色
*/
public function hasRole(int $roleId): bool
{
return $this->userRoles()->where('role_id', $roleId)->exists();
}
/**
* 检查用户是否拥有指定角色编码
*/
public function hasRoleCode(string $roleCode): bool
{
return $this->roles()->where('code', $roleCode)->exists();
}
/**
* 检查用户是否拥有任一角色
*/
public function hasAnyRole(array $roleIds): bool
{
return $this->userRoles()->whereIn('role_id', $roleIds)->exists();
}
/**
* 检查用户是否拥有任一角色编码
*/
public function hasAnyRoleCode(array $roleCodes): bool
{
return $this->roles()->whereIn('code', $roleCodes)->exists();
}
/**
* 检查用户是否拥有所有角色
*/
public function hasAllRoles(array $roleIds): bool
{
$userRoleIds = $this->getRoleIds();
return empty(array_diff($roleIds, $userRoleIds));
}
/**
* 获取用户权限范围内的租户ID
*/
public function getCurrentTenantId(): ?int
{
return $this->tenant_id;
}
}

155
app/Services/System/SystemMenuService.php Normal file
View File

@ -0,0 +1,155 @@
<?php
namespace App\Services\System;
use App\Models\System\SystemMenu;
use App\Services\BaseService;
use Illuminate\Pagination\LengthAwarePaginator;
/**
* 系统菜单服务类
*/
class SystemMenuService extends BaseService
{
protected string $modelClass = SystemMenu::class;
/**
* 获取系统菜单列表
*/
public function getList(array $params): LengthAwarePaginator
{
$query = SystemMenu::query();
// 搜索条件
if (!empty($params['keyword'])) {
$query->where(function ($q) use ($params) {
$q->where('name', 'like', '%' . $params['keyword'] . '%')
->orWhere('path', 'like', '%' . $params['keyword'] . '%')
->orWhere('component', 'like', '%' . $params['keyword'] . '%');
});
}
// 状态筛选
if (isset($params['status'])) {
$query->where('status', $params['status']);
}
// 菜单类型筛选
if (isset($params['type'])) {
$query->where('type', $params['type']);
}
// 父级菜单筛选
if (isset($params['parent_id'])) {
$query->where('parent_id', $params['parent_id']);
}
// 显示状态筛选
if (isset($params['visible'])) {
$query->where('visible', $params['visible']);
}
// 排序
$query->orderBy('sort', 'asc')
->orderBy('id', 'desc');
return $query->paginate($params['page_size'] ?? 15);
}
/**
* 获取简单列表（用于下拉选择等）
*/
public function getSimpleList(): array
{
return SystemMenu::select('id', 'name', 'parent_id')
->where('status', 1)
->orderBy('sort', 'asc')
->get()
->toArray();
}
/**
* 获取树形菜单结构
*/
public function getMenuTree(): array
{
$menus = SystemMenu::where('status', 1)
->orderBy('sort', 'asc')
->get()
->toArray();
return $this->buildTree($menus);
}
/**
* 获取父级菜单列表
*/
public function getParentMenus(): array
{
return SystemMenu::where('type', '!=', 3) // 排除按钮类型
->where('status', 1)
->select('id', 'name', 'parent_id')
->orderBy('sort', 'asc')
->get()
->toArray();
}
/**
* 构建树形结构
*/
private function buildTree(array $menus, int $parentId = 0): array
{
$tree = [];
foreach ($menus as $menu) {
if ($menu['parent_id'] == $parentId) {
$children = $this->buildTree($menus, $menu['id']);
if (!empty($children)) {
$menu['children'] = $children;
}
$tree[] = $menu;
}
}
return $tree;
}
/**
* 创建前的数据处理
*/
protected function beforeCreate(array &$data): void
{
// 如果没有设置排序，则设置为最大值+1
if (!isset($data['sort'])) {
$maxSort = SystemMenu::max('sort') ?? 0;
$data['sort'] = $maxSort + 1;
}
// 如果没有设置状态，默认为启用
if (!isset($data['status'])) {
$data['status'] = 1;
}
// 如果没有设置显示状态，默认为显示
if (!isset($data['visible'])) {
$data['visible'] = 0;
}
// 如果没有设置父级ID，默认为0
if (!isset($data['parent_id'])) {
$data['parent_id'] = 0;
}
}
/**
* 更新前的数据处理
*/
protected function beforeUpdate(array &$data, $model): void
{
// 不能将自己设置为自己的父级
if (isset($data['parent_id']) && $data['parent_id'] == $model->id) {
throw new \App\Exceptions\BusinessException(
\App\Helpers\ResponseEnum::CLIENT_PARAMETER_ERROR,
'不能将自己设置为父级菜单'
);
}
}
}

168
app/Services/System/SystemRoleMenuService.php Normal file
View File

@ -0,0 +1,168 @@
<?php
namespace App\Services\System;
use App\Models\System\SystemRoleMenu;
use App\Models\System\SystemRole;
use App\Models\System\SystemMenu;
use App\Services\BaseService;
use Illuminate\Pagination\LengthAwarePaginator;
use Illuminate\Support\Facades\DB;
/**
* 系统角色菜单关联服务类
*/
class SystemRoleMenuService extends BaseService
{
protected string $modelClass = SystemRoleMenu::class;
/**
* 获取角色菜单关联列表
*/
public function getList(array $params): LengthAwarePaginator
{
$query = SystemRoleMenu::query()
->with(['role:id,name', 'menu:id,name,type']);
// 角色筛选
if (isset($params['role_id'])) {
$query->where('role_id', $params['role_id']);
}
// 菜单筛选
if (isset($params['menu_id'])) {
$query->where('menu_id', $params['menu_id']);
}
// 排序
$query->orderBy('role_id', 'asc')
->orderBy('menu_id', 'asc');
return $query->paginate($params['page_size'] ?? 15);
}
/**
* 获取角色的菜单列表
*/
public function getRoleMenus(int $roleId): array
{
return SystemRoleMenu::where('role_id', $roleId)
->pluck('menu_id')
->toArray();
}
/**
* 获取菜单的角色列表
*/
public function getMenuRoles(int $menuId): array
{
return SystemRoleMenu::where('menu_id', $menuId)
->pluck('role_id')
->toArray();
}
/**
* 设置角色菜单权限
*/
public function setRoleMenus(int $roleId, array $menuIds): bool
{
return DB::transaction(function () use ($roleId, $menuIds) {
// 删除现有关联
SystemRoleMenu::where('role_id', $roleId)->delete();
// 批量插入新关联
if (!empty($menuIds)) {
$data = [];
foreach ($menuIds as $menuId) {
$data[] = [
'role_id' => $roleId,
'menu_id' => $menuId,
'creator' => auth('admin')->id() ?? 0,
'create_time' => now(),
'tenant_id' => $this->getCurrentTenantId() ?? 0,
'deleted' => 0,
];
}
SystemRoleMenu::insert($data);
}
return true;
});
}
/**
* 获取角色的菜单树
*/
public function getRoleMenuTree(int $roleId): array
{
$menuIds = $this->getRoleMenus($roleId);
if (empty($menuIds)) {
return [];
}
$menus = SystemMenu::whereIn('id', $menuIds)
->where('status', 1)
->orderBy('sort', 'asc')
->get()
->toArray();
return $this->buildMenuTree($menus);
}
/**
* 构建菜单树
*/
private function buildMenuTree(array $menus, int $parentId = 0): array
{
$tree = [];
foreach ($menus as $menu) {
if ($menu['parent_id'] == $parentId) {
$children = $this->buildMenuTree($menus, $menu['id']);
if (!empty($children)) {
$menu['children'] = $children;
}
$tree[] = $menu;
}
}
return $tree;
}
/**
* 批量设置多个角色的菜单权限
*/
public function batchSetRoleMenus(array $roleMenuData): bool
{
return DB::transaction(function () use ($roleMenuData) {
foreach ($roleMenuData as $data) {
$this->setRoleMenus($data['role_id'], $data['menu_ids'] ?? []);
}
return true;
});
}
/**
* 删除角色的所有菜单权限
*/
public function clearRoleMenus(int $roleId): bool
{
return SystemRoleMenu::where('role_id', $roleId)->delete();
}
/**
* 删除菜单的所有角色关联
*/
public function clearMenuRoles(int $menuId): bool
{
return SystemRoleMenu::where('menu_id', $menuId)->delete();
}
/**
* 获取当前租户ID
*/
protected function getCurrentTenantId(): ?int
{
$user = auth('admin')->user();
return $user ? $user->tenant_id : null;
}
}

193
app/Services/System/SystemUserRoleService.php Normal file
View File

@ -0,0 +1,193 @@
<?php
namespace App\Services\System;
use App\Models\System\SystemUserRole;
use App\Models\System\SystemRole;
use App\Models\User;
use App\Services\BaseService;
use Illuminate\Pagination\LengthAwarePaginator;
use Illuminate\Support\Facades\DB;
/**
* 系统用户角色关联服务类
*/
class SystemUserRoleService extends BaseService
{
protected string $modelClass = SystemUserRole::class;
/**
* 获取用户角色关联列表
*/
public function getList(array $params): LengthAwarePaginator
{
$query = SystemUserRole::query()
->with(['user:id,username,nickname', 'role:id,name,code']);
// 用户筛选
if (isset($params['user_id'])) {
$query->where('user_id', $params['user_id']);
}
// 角色筛选
if (isset($params['role_id'])) {
$query->where('role_id', $params['role_id']);
}
// 排序
$query->orderBy('user_id', 'asc')
->orderBy('role_id', 'asc');
return $query->paginate($params['page_size'] ?? 15);
}
/**
* 获取用户的角色列表
*/
public function getUserRoles(int $userId): array
{
return SystemUserRole::where('user_id', $userId)
->pluck('role_id')
->toArray();
}
/**
* 获取角色的用户列表
*/
public function getRoleUsers(int $roleId): array
{
return SystemUserRole::where('role_id', $roleId)
->pluck('user_id')
->toArray();
}
/**
* 设置用户角色
*/
public function setUserRoles(int $userId, array $roleIds): bool
{
return DB::transaction(function () use ($userId, $roleIds) {
// 删除现有关联
SystemUserRole::where('user_id', $userId)->delete();
// 批量插入新关联
if (!empty($roleIds)) {
$data = [];
foreach ($roleIds as $roleId) {
$data[] = [
'user_id' => $userId,
'role_id' => $roleId,
'creator' => auth('admin')->id() ?? 0,
'create_time' => now(),
'tenant_id' => $this->getCurrentTenantId() ?? 0,
'deleted' => 0,
];
}
SystemUserRole::insert($data);
}
return true;
});
}
/**
* 获取用户的角色详情（包含角色信息）
*/
public function getUserRoleDetails(int $userId): array
{
return SystemUserRole::where('user_id', $userId)
->with('role:id,name,code,data_scope,status')
->get()
->pluck('role')
->toArray();
}
/**
* 检查用户是否拥有指定角色
*/
public function hasRole(int $userId, int $roleId): bool
{
return SystemUserRole::where('user_id', $userId)
->where('role_id', $roleId)
->exists();
}
/**
* 检查用户是否拥有指定角色编码
*/
public function hasRoleCode(int $userId, string $roleCode): bool
{
return SystemUserRole::where('user_id', $userId)
->whereHas('role', function ($query) use ($roleCode) {
$query->where('code', $roleCode)->where('status', 1);
})
->exists();
}
/**
* 批量设置多个用户的角色
*/
public function batchSetUserRoles(array $userRoleData): bool
{
return DB::transaction(function () use ($userRoleData) {
foreach ($userRoleData as $data) {
$this->setUserRoles($data['user_id'], $data['role_ids'] ?? []);
}
return true;
});
}
/**
* 为角色批量分配用户
*/
public function setRoleUsers(int $roleId, array $userIds): bool
{
return DB::transaction(function () use ($roleId, $userIds) {
// 删除现有关联
SystemUserRole::where('role_id', $roleId)->delete();
// 批量插入新关联
if (!empty($userIds)) {
$data = [];
foreach ($userIds as $userId) {
$data[] = [
'user_id' => $userId,
'role_id' => $roleId,
'creator' => auth('admin')->id() ?? 0,
'create_time' => now(),
'tenant_id' => $this->getCurrentTenantId() ?? 0,
'deleted' => 0,
];
}
SystemUserRole::insert($data);
}
return true;
});
}
/**
* 删除用户的所有角色
*/
public function clearUserRoles(int $userId): bool
{
return SystemUserRole::where('user_id', $userId)->delete();
}
/**
* 删除角色的所有用户关联
*/
public function clearRoleUsers(int $roleId): bool
{
return SystemUserRole::where('role_id', $roleId)->delete();
}
/**
* 获取当前租户ID
*/
protected function getCurrentTenantId(): ?int
{
$user = auth('admin')->user();
return $user ? $user->tenant_id : null;
}
}

46
docs/CRUD代码生成模板.md
View File

@ -1,19 +1,22 @@
# Laravel CRUD代码生成模板（优化版）
# Laravel CRUD 代码生成模板（优化版）
## 架构说明
### 分层架构
- **BaseModel.php**：提供通用的权限控制（tenant_id自动过滤）、软删除、时间戳等基础功能
- **BaseService.php**：提供标准的CRUD操作，统一事务处理和异常处理
- **BaseModel.php**：提供通用的权限控制（tenant_id 自动过滤）、软删除、时间戳等基础功能
- **BaseService.php**：提供标准的 CRUD 操作，统一事务处理和异常处理
- **BaseController.php**：提供统一的响应格式（Success、SuccessPage、Field）和参数获取方法
- **Controllers**：只负责参数验证和调用服务层，无需关心权限控制和异常处理
### 权限控制机制
- **查询时**：BaseModel的全局作用域自动过滤当前用户的tenant_id数据
- **创建时**：BaseModel的creating钩子自动设置当前用户的tenant_id
- **更新/删除时**：BaseService在操作前验证记录的tenant_id权限
- **查询时**：BaseModel 的全局作用域自动过滤当前用户的 tenant_id 数据
- **创建时**：BaseModel 的 creating 钩子自动设置当前用户的 tenant_id
- **更新/删除时**：BaseService 在操作前验证记录的 tenant_id 权限
### 目录结构规范
```
app/
├── Models/
@ -36,6 +39,14 @@ app/
└── [模块名]_route.php
```
### 模型命名规范
- **模型名必须与数据库表名保持一致的大驼峰格式**
- 例如：`system_users` 表 → `SystemUsers` 模型
- 例如：`system_role` 表 → `SystemRole` 模型
- 例如：`user_profile` 表 → `UserProfile` 模型
- **不要使用简化名称**，严格按照表名转换大驼峰
## 模板文件
### 1. 模型文件模板
@ -408,9 +419,10 @@ Route::middleware("admin")->group(function () {
## 使用示例
假设我们要为`school_class`表生成CRUD代码：
假设我们要为`school_class`表生成 CRUD 代码：
### 替换变量说明
- `[模块名]` → `Schools`
- `[表名]` → `SchoolClass`
- `[表名变量]` → `schoolClass`
@ -419,6 +431,7 @@ Route::middleware("admin")->group(function () {
- `[路由前缀]` → `school/class`
### 生成的文件结构
```
app/
├── Models/Schools/SchoolClass.php
@ -430,16 +443,19 @@ app/
```
### 控制器方法命名规范
- `list()` - 获取列表（替代index）
- `detail()` - 获取详情（替代show）
- `create()` - 创建（替代store）
- `list()` - 获取列表（替代 index）
- `detail()` - 获取详情（替代 show）
- `create()` - 创建（替代 store）
- `update()` - 更新
- `delete()` - 删除（替代destroy）
- `delete()` - 删除（替代 destroy）
- `batchDelete()` - 批量删除
- `simpleList()` - 获取简单列表
### 验证规则命名规范
验证方法根据控制器方法名自动匹配：
- `listRules()` - 列表查询验证
- `detailRules()` - 详情查询验证
- `createRules()` - 创建验证
@ -449,9 +465,9 @@ app/
## 核心优势
1. **代码量减少60%以上**：通过BaseModel、BaseService提供通用功能
2. **权限控制自动化**：tenant_id完全由框架层自动处理
3. **异常处理统一化**：控制器无需try-catch，全局异常处理器统一处理
4. **命名更加直观**：使用功能性命名而非传统RESTful命名
1. **代码量减少 60%以上**：通过 BaseModel、BaseService 提供通用功能
2. **权限控制自动化**：tenant_id 完全由框架层自动处理
3. **异常处理统一化**：控制器无需 try-catch，全局异常处理器统一处理
4. **命名更加直观**：使用功能性命名而非传统 RESTful 命名
5. **开发效率极高**：新模块只需实现特殊业务逻辑
6. **维护成本降低**：统一的代码结构和规范

93
routes/admin/system_route.php
View File

@ -31,3 +31,96 @@ Route::middleware("admin")->group(function () {
// 检查角色编码是否存在
Route::match(['get', 'post'], "system/role/check/code", [App\Http\Controllers\Admin\System\SystemRoleController::class, 'checkCode']);
});
/** -------------------------- 系统菜单 ----------------------- */
Route::middleware("admin")->group(function () {
// 获取系统菜单详情
Route::match(['get', 'post'], "system/menu/detail", [App\Http\Controllers\Admin\System\SystemMenuController::class, 'detail']);
// 创建系统菜单
Route::match(['get', 'post'], "system/menu/create", [App\Http\Controllers\Admin\System\SystemMenuController::class, 'create']);
// 更新系统菜单
Route::match(['put', 'post'], "system/menu/update", [App\Http\Controllers\Admin\System\SystemMenuController::class, 'update']);
// 删除系统菜单
Route::match(['delete', 'post'], "system/menu/delete", [App\Http\Controllers\Admin\System\SystemMenuController::class, 'delete']);
// 获取系统菜单列表
Route::match(['get', 'post'], "system/menu/list", [App\Http\Controllers\Admin\System\SystemMenuController::class, 'list']);
// 获取简单列表
Route::match(['get', 'post'], "system/menu/simple/list", [App\Http\Controllers\Admin\System\SystemMenuController::class, 'simpleList']);
// 获取菜单树
Route::match(['get', 'post'], "system/menu/tree", [App\Http\Controllers\Admin\System\SystemMenuController::class, 'tree']);
// 获取父级菜单列表
Route::match(['get', 'post'], "system/menu/parent/list", [App\Http\Controllers\Admin\System\SystemMenuController::class, 'parentMenus']);
// 批量删除系统菜单
Route::match(['delete', 'post'], "system/menu/batch/delete", [App\Http\Controllers\Admin\System\SystemMenuController::class, 'batchDelete']);
});
/** -------------------------- 角色菜单关联 ----------------------- */
Route::middleware("admin")->group(function () {
// 获取角色菜单关联列表
Route::match(['get', 'post'], "system/role-menu/list", [App\Http\Controllers\Admin\System\SystemRoleMenuController::class, 'list']);
// 获取角色的菜单列表
Route::match(['get', 'post'], "system/role-menu/role-menus", [App\Http\Controllers\Admin\System\SystemRoleMenuController::class, 'getRoleMenus']);
// 获取菜单的角色列表
Route::match(['get', 'post'], "system/role-menu/menu-roles", [App\Http\Controllers\Admin\System\SystemRoleMenuController::class, 'getMenuRoles']);
// 获取角色的菜单树
Route::match(['get', 'post'], "system/role-menu/role-menu-tree", [App\Http\Controllers\Admin\System\SystemRoleMenuController::class, 'getRoleMenuTree']);
// 设置角色菜单权限
Route::match(['put', 'post'], "system/role-menu/set-role-menus", [App\Http\Controllers\Admin\System\SystemRoleMenuController::class, 'setRoleMenus']);
// 批量设置角色菜单权限
Route::match(['put', 'post'], "system/role-menu/batch-set", [App\Http\Controllers\Admin\System\SystemRoleMenuController::class, 'batchSetRoleMenus']);
// 清除角色的所有菜单权限
Route::match(['delete', 'post'], "system/role-menu/clear-role-menus", [App\Http\Controllers\Admin\System\SystemRoleMenuController::class, 'clearRoleMenus']);
// 清除菜单的所有角色关联
Route::match(['delete', 'post'], "system/role-menu/clear-menu-roles", [App\Http\Controllers\Admin\System\SystemRoleMenuController::class, 'clearMenuRoles']);
});
/** -------------------------- 用户角色关联 ----------------------- */
Route::middleware("admin")->group(function () {
// 获取用户角色关联列表
Route::match(['get', 'post'], "system/user-role/list", [App\Http\Controllers\Admin\System\SystemUserRoleController::class, 'list']);
// 获取用户的角色列表
Route::match(['get', 'post'], "system/user-role/user-roles", [App\Http\Controllers\Admin\System\SystemUserRoleController::class, 'getUserRoles']);
// 获取角色的用户列表
Route::match(['get', 'post'], "system/user-role/role-users", [App\Http\Controllers\Admin\System\SystemUserRoleController::class, 'getRoleUsers']);
// 获取用户的角色详情
Route::match(['get', 'post'], "system/user-role/user-role-details", [App\Http\Controllers\Admin\System\SystemUserRoleController::class, 'getUserRoleDetails']);
// 设置用户角色
Route::match(['put', 'post'], "system/user-role/set-user-roles", [App\Http\Controllers\Admin\System\SystemUserRoleController::class, 'setUserRoles']);
// 为角色分配用户
Route::match(['put', 'post'], "system/user-role/set-role-users", [App\Http\Controllers\Admin\System\SystemUserRoleController::class, 'setRoleUsers']);
// 批量设置用户角色
Route::match(['put', 'post'], "system/user-role/batch-set", [App\Http\Controllers\Admin\System\SystemUserRoleController::class, 'batchSetUserRoles']);
// 检查用户是否拥有角色
Route::match(['get', 'post'], "system/user-role/has-role", [App\Http\Controllers\Admin\System\SystemUserRoleController::class, 'hasRole']);
// 检查用户是否拥有角色编码
Route::match(['get', 'post'], "system/user-role/has-role-code", [App\Http\Controllers\Admin\System\SystemUserRoleController::class, 'hasRoleCode']);
// 清除用户的所有角色
Route::match(['delete', 'post'], "system/user-role/clear-user-roles", [App\Http\Controllers\Admin\System\SystemUserRoleController::class, 'clearUserRoles']);
// 清除角色的所有用户关联
Route::match(['delete', 'post'], "system/user-role/clear-role-users", [App\Http\Controllers\Admin\System\SystemUserRoleController::class, 'clearRoleUsers']);
});