wangys/schoolNews
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

权限

Browse Source
This commit is contained in:
wangys
2025-10-07 11:02:35 +08:00
parent c20b5af014
commit 8bd1edc75d
32 changed files with 1949 additions and 418 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
.vscode/launch.json vendored
View File

@@ -8,10 +8,12 @@
"mainClass": "org.xyzh.App",
"projectName": "admin",
"args": "",
"vmArgs": "-Dspring.profiles.active=dev -Dfile.encoding=UTF-8 -Dconsole.encoding=UTF-8 -Dstdout.encoding=UTF-8 -Dstderr.encoding=UTF-8 -Duser.timezone=Asia/Shanghai",
"vmArgs": "-Dspring.profiles.active=dev -Dfile.encoding=UTF-8 -Dconsole.encoding=UTF-8 -Dstdout.encoding=UTF-8 -Dstderr.encoding=UTF-8 -Duser.timezone=Asia/Shanghai -Dsun.stdout.encoding=UTF-8 -Dsun.stderr.encoding=UTF-8",
"console": "integratedTerminal",
"envFile": "${workspaceFolder}/.env",
"preLaunchTask": "set-console-utf8"
"env": {
"JAVA_TOOL_OPTIONS": "-Dfile.encoding=UTF-8"
}
},
{
"type": "java",

15
.vscode/settings.json vendored
View File

@@ -9,5 +9,18 @@
"editor.tabSize": 4
},
"maven.view": "hierarchical",
"java.compile.nullAnalysis.mode": "automatic"
"java.compile.nullAnalysis.mode": "automatic",
// 终端编码设置
"terminal.integrated.encoding": "utf8",
"terminal.integrated.defaultProfile.windows": "PowerShell",
"terminal.integrated.profiles.windows": {
"PowerShell": {
"source": "PowerShell",
"args": ["-NoExit", "-Command", "chcp 65001"]
},
"Command Prompt": {
"path": "cmd.exe",
"args": ["/k", "chcp 65001"]
}
}
}

18
.vscode/tasks.json vendored
View File

@@ -1,18 +0,0 @@
{
"version": "2.0.0",
"tasks": [
{
"label": "set-console-utf8",
"type": "shell",
"command": "chcp",
"args": ["65001"],
"group": "build",
"presentation": {
"echo": false,
"reveal": "silent",
"focus": false,
"panel": "shared"
}
}
]
}

10
schoolNewsServ/.bin/mysql/sql/createTablePermission.sql
View File

@@ -18,7 +18,8 @@ CREATE TABLE `tb_sys_dept` (
KEY `idx_dept_parent` (`parent_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_general_ci;
INSERT INTO `tb_sys_dept` (id,dept_id,name, description) VALUES ('1','default_department', '默认部门', '系统默认创建的部门');
INSERT INTO `tb_sys_dept` (id,dept_id,name, description) VALUES ('1','root_department', '超级部门', '系统超级部门');
INSERT INTO `tb_sys_dept` (id,dept_id,name, parent_id, description) VALUES ('2','default_department', '默认部门', 'root_department', '系统默认创建的部门');
-- 角色表
DROP TABLE IF EXISTS `tb_sys_role`;
@@ -38,6 +39,7 @@ CREATE TABLE `tb_sys_role` (
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_general_ci;
INSERT INTO `tb_sys_role` (id,role_id, name, description) VALUES ('1','admin', '管理员', '系统管理员角色');
INSERT INTO `tb_sys_role` (id,role_id, name, description) VALUES ('2','freedom', '自由角色', '自由角色');
-- 部门-角色关联
DROP TABLE IF EXISTS `tb_sys_dept_role`;
@@ -55,7 +57,9 @@ CREATE TABLE `tb_sys_dept_role` (
UNIQUE KEY `uk_dept_role` (`dept_id`, `role_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_general_ci;
INSERT INTO `tb_sys_dept_role` (id, dept_id, role_id) VALUES ('1', 'default_department', 'admin');
INSERT INTO `tb_sys_dept_role` (id, dept_id, role_id) VALUES
('1', 'root_department', 'admin'),
('2', 'default_department', 'freedom');
-- 用户-角色关联
DROP TABLE IF EXISTS `tb_sys_user_dept_role`;
@@ -74,7 +78,7 @@ CREATE TABLE `tb_sys_user_dept_role` (
UNIQUE KEY `uk_user_dept_role` (`user_id`, `dept_id`, `role_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_general_ci;
INSERT INTO `tb_sys_user_dept_role` (id, user_id, dept_id, role_id) VALUES ('1', '1', 'default_department', 'admin');
INSERT INTO `tb_sys_user_dept_role` (id, user_id, dept_id, role_id) VALUES ('1', '1', 'root_department', 'admin');
-- 权限表
DROP TABLE IF EXISTS `tb_sys_permission`;

2
schoolNewsServ/.bin/mysql/sql/createTableUser.sql
View File

@@ -43,7 +43,7 @@ CREATE TABLE `tb_sys_user_info` (
UNIQUE KEY `uk_user_info_user_id` (`user_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_general_ci;
INSERT INTO `tb_sys_user_info` (id, user_id, full_name) VALUES ('1', '1', '管理员');
INSERT INTO `tb_sys_user_info` (id, user_id, full_name, avatar) VALUES ('1', '1', '管理员', 'default');
DROP TABLE IF EXISTS `tb_sys_login_log`;
CREATE TABLE `tb_sys_login_log` (

2
schoolNewsServ/admin/src/main/java/org/xyzh/App.java
View File

@@ -3,6 +3,7 @@ package org.xyzh;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.transaction.annotation.EnableTransactionManagement;
/**
* @description 校园新闻管理系统主应用入口
@@ -11,6 +12,7 @@ import org.springframework.boot.autoconfigure.SpringBootApplication;
* @copyright xyzh
* @since 2025-10-05
*/
@EnableTransactionManagement
@SpringBootApplication(scanBasePackages = "org.xyzh")
@MapperScan({"org.xyzh.system.mapper", "org.xyzh.news.mapper"})
public class App {

132
schoolNewsServ/api/api-system/src/main/java/org/xyzh/api/system/permission/PermissionService.java
View File

@@ -6,6 +6,8 @@ import java.util.Set;
import org.xyzh.common.core.domain.ResultDomain;
import org.xyzh.common.dto.permission.TbSysPermission;
import org.xyzh.common.dto.role.TbSysRolePermission;
import org.xyzh.common.dto.menu.TbSysMenuPermission;
/**
* @description PermissionRemoteService.java文件描述 权限远程服务接口
@@ -17,6 +19,79 @@ import org.xyzh.common.dto.permission.TbSysPermission;
public interface PermissionService {
/**
* @description 创建权限
* @param permission 权限对象
* @return ResultDomain<TbSysPermission> 创建结果
* @author yslg
* @since 2025-09-28
*/
ResultDomain<TbSysPermission> createPermission(TbSysPermission permission);
/**
* @description 更新权限
* @param permission 权限对象
* @return ResultDomain<TbSysPermission> 更新结果
* @author yslg
* @since 2025-09-28
*/
ResultDomain<TbSysPermission> updatePermission(TbSysPermission permission);
/**
* @description 删除权限
* @param permissionId 权限ID
* @return ResultDomain<TbSysPermission> 删除结果
* @author yslg
* @since 2025-09-28
*/
ResultDomain<TbSysPermission> deletePermission(String permissionId);
// ----------------------角色权限管理--------------------------
// 角色权限绑定
ResultDomain<TbSysRolePermission> bindRolePermission(String roleId, String permissionId);
ResultDomain<TbSysRolePermission> batchBindRolePermission(List<String> roleIds, List<String> permissionIds);
// 角色权限解绑
ResultDomain<TbSysRolePermission> unbindRolePermission(String roleId, String permissionId);
ResultDomain<TbSysRolePermission> batchUnbindRolePermission(List<String> roleIds, List<String> permissionIds);
// ----------------------菜单权限管理--------------------------
// 菜单权限绑定
ResultDomain<TbSysMenuPermission> bindMenuPermission(String menuId, String permissionId);
ResultDomain<TbSysMenuPermission> batchBindMenuPermission(List<String> menuIds, List<String> permissionIds);
// 菜单权限解绑
ResultDomain<TbSysMenuPermission> unbindMenuPermission(String menuId, String permissionId);
ResultDomain<TbSysMenuPermission> batchUnbindMenuPermission(List<String> menuIds, List<String> permissionIds);
/**
* @description 检查权限名称是否存在
* @param permissionName 权限名称
* @param excludeId 排除的权限ID（用于更新时排除自身）
* @return ResultDomain<Boolean> 是否存在
* @author yslg
* @since 2025-09-28
*/
ResultDomain<Boolean> checkPermissionNameExists(String permissionName, String excludeId);
/**
* @description 检查权限编码是否存在
* @param permissionCode 权限编码
* @param excludeId 排除的权限ID（用于更新时排除自身）
* @return ResultDomain<Boolean> 是否存在
* @author yslg
* @since 2025-09-28
*/
ResultDomain<Boolean> checkPermissionCodeExists(String permissionCode, String excludeId);
/**
* @description 修改权限状态
* @param permissionId 权限ID
* @param status 新状态
* @return ResultDomain<TbSysPermission> 修改结果
* @author yslg
* @since 2025-09-28
*/
ResultDomain<TbSysPermission> changePermissionStatus(String permissionId, Integer status);
/**
* @description 获取所有权限
* @return ResultDomain<TbSysPermission> 权限列表
@@ -60,61 +135,4 @@ public interface PermissionService {
* @since 2025-09-28
*/
ResultDomain<TbSysPermission> getPermissionsByRoleId(String roleId);
/**
* @description 创建权限
* @param permission 权限对象
* @return ResultDomain<TbSysPermission> 创建结果
* @author yslg
* @since 2025-09-28
*/
ResultDomain<TbSysPermission> createPermission(TbSysPermission permission);
/**
* @description 更新权限
* @param permission 权限对象
* @return ResultDomain<TbSysPermission> 更新结果
* @author yslg
* @since 2025-09-28
*/
ResultDomain<TbSysPermission> updatePermission(TbSysPermission permission);
/**
* @description 删除权限
* @param permissionId 权限ID
* @return ResultDomain<TbSysPermission> 删除结果
* @author yslg
* @since 2025-09-28
*/
ResultDomain<TbSysPermission> deletePermission(String permissionId);
/**
* @description 检查权限名称是否存在
* @param permissionName 权限名称
* @param excludeId 排除的权限ID（用于更新时排除自身）
* @return ResultDomain<Boolean> 是否存在
* @author yslg
* @since 2025-09-28
*/
ResultDomain<Boolean> checkPermissionNameExists(String permissionName, String excludeId);
/**
* @description 检查权限编码是否存在
* @param permissionCode 权限编码
* @param excludeId 排除的权限ID（用于更新时排除自身）
* @return ResultDomain<Boolean> 是否存在
* @author yslg
* @since 2025-09-28
*/
ResultDomain<Boolean> checkPermissionCodeExists(String permissionCode, String excludeId);
/**
* @description 修改权限状态
* @param permissionId 权限ID
* @param status 新状态
* @return ResultDomain<TbSysPermission> 修改结果
* @author yslg
* @since 2025-09-28
*/
ResultDomain<TbSysPermission> changePermissionStatus(String permissionId, Integer status);
}

48
schoolNewsServ/api/api-system/src/main/java/org/xyzh/api/system/user/UserService.java
View File

@@ -16,6 +16,25 @@ import org.xyzh.common.dto.user.TbSysUserInfo;
*/
public interface UserService {
/**
* @description 注册用户
* @param user 用户对象
* @return ResultDomain<TbSysUser> 注册结果
* @author yslg
* @since 2025-10-07
*/
ResultDomain<TbSysUser> registerUser(TbSysUser user);
/**
* @description 检查用户是否已存在 用户邮箱、手机号、微信号之一与数据库中的用户信息匹配
* @param user 用户对象
* @return ResultDomain<Boolean> 是否存在
* @author yslg
* @since 2025-10-07
*/
ResultDomain<Boolean> checkUserExists(TbSysUser user);
/**
* @description 获取所有用户
* @return ResultDomain<TbSysUser> 用户列表
@@ -33,15 +52,6 @@ public interface UserService {
*/
ResultDomain<TbSysUser> getUserById(String userId);
/**
* @description 根据用户ID查询用户信息
* @param userId 用户ID
* @return ResultDomain<TbSysUserInfo> 用户信息
* @author yslg
* @since 2025-10-06
*/
ResultDomain<TbSysUserInfo> getUserInfoById(String userId);
/**
* @description 根据用户名查询用户
* @param username 用户名
@@ -137,4 +147,24 @@ public interface UserService {
* @since 2025-09-28
*/
ResultDomain<TbSysUser> resetPassword(String userId, String newPassword);
// ----------------用户信息相关--------------------------------
/**
* @description 根据用户ID查询用户信息
* @param userId 用户ID
* @return ResultDomain<TbSysUserInfo> 用户信息
* @author yslg
* @since 2025-10-06
*/
ResultDomain<TbSysUserInfo> getUserInfoById(String userId);
/**
* @description 更新用户信息
* @param userInfo 用户信息
* @return ResultDomain<TbSysUserInfo> 更新结果
* @author yslg
* @since 2025-10-06
*/
ResultDomain<TbSysUserInfo> updateUserInfo(TbSysUserInfo userInfo);
}

32
schoolNewsServ/common/common-dto/src/main/java/org/xyzh/common/dto/role/TbSysRolePermission.java
View File

@@ -39,6 +39,38 @@ public class TbSysRolePermission extends BaseDTO{
*/
public String updater;
public String getRoleID() {
return roleID;
}
public void setRoleID(String roleID) {
this.roleID = roleID;
}
public String getPermissionID() {
return permissionID;
}
public void setPermissionID(String permissionID) {
this.permissionID = permissionID;
}
public String getCreator() {
return creator;
}
public void setCreator(String creator) {
this.creator = creator;
}
public String getUpdater() {
return updater;
}
public void setUpdater(String updater) {
this.updater = updater;
}
@Override
public String toString() {
return "TbSysRolePermission{" +

7
schoolNewsServ/common/common-util/src/main/java/org/xyzh/Main.java
View File

@@ -1,7 +0,0 @@
package org.xyzh;
public class Main {
public static void main(String[] args) {
System.out.println("Hello world!");
}
}

189
schoolNewsServ/common/common-util/src/main/java/org/xyzh/common/utils/ServletUtil.java Normal file
View File

@@ -0,0 +1,189 @@
package org.xyzh.common.utils;
import org.springframework.http.HttpHeaders;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
/**
* @description ServletUtil.java文件描述 Servlet工具类
* @filename ServletUtil.java
* @author yslg
* @copyright xyzh
* @since 2025-10-07
*/
public class ServletUtil {
private static final String TOKEN_PREFIX = "Bearer ";
/**
* @description 获取当前请求对象
* @return HttpServletRequest 当前请求对象，无当前请求时返回null
* @author yslg
* @since 2025-10-07
*/
public static HttpServletRequest getRequest() {
ServletRequestAttributes requestAttributes =
(ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
return requestAttributes != null ? requestAttributes.getRequest() : null;
}
/**
* @description 获取当前响应对象
* @return HttpServletResponse 当前响应对象，无当前请求时返回null
* @author yslg
* @since 2025-10-07
*/
public static HttpServletResponse getResponse() {
ServletRequestAttributes requestAttributes =
(ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
return requestAttributes != null ? requestAttributes.getResponse() : null;
}
/**
* @description 从当前请求中获取token（无参方法）
* @return String token值，未找到返回null
* @author yslg
* @since 2025-10-07
*/
public static String getToken() {
HttpServletRequest request = getRequest();
return request != null ? extractTokenFromRequest(request) : null;
}
/**
* @description 从当前请求中获取指定请求头
* @param headerName 请求头名称
* @return String 请求头值，未找到返回null
* @author yslg
* @since 2025-10-07
*/
public static String getHeader(String headerName) {
HttpServletRequest request = getRequest();
return request != null ? request.getHeader(headerName) : null;
}
/**
* @description 从当前请求中获取指定请求参数
* @param paramName 参数名称
* @return String 参数值，未找到返回null
* @author yslg
* @since 2025-10-07
*/
public static String getParameter(String paramName) {
HttpServletRequest request = getRequest();
return request != null ? request.getParameter(paramName) : null;
}
/**
* @description 获取当前请求的客户端IP地址
* @return String IP地址，未找到返回null
* @author yslg
* @since 2025-10-07
*/
public static String getClientIpAddress() {
HttpServletRequest request = getRequest();
if (request == null) {
return null;
}
String ip = request.getHeader("X-Forwarded-For");
if (NonUtils.isNotEmpty(ip) && !"unknown".equalsIgnoreCase(ip)) {
// 多次反向代理后会有多个IP值，第一个为真实IP
int index = ip.indexOf(',');
if (index != -1) {
return ip.substring(0, index);
} else {
return ip;
}
}
ip = request.getHeader("X-Real-IP");
if (NonUtils.isNotEmpty(ip) && !"unknown".equalsIgnoreCase(ip)) {
return ip;
}
ip = request.getHeader("Proxy-Client-IP");
if (NonUtils.isNotEmpty(ip) && !"unknown".equalsIgnoreCase(ip)) {
return ip;
}
ip = request.getHeader("WL-Proxy-Client-IP");
if (NonUtils.isNotEmpty(ip) && !"unknown".equalsIgnoreCase(ip)) {
return ip;
}
ip = request.getHeader("HTTP_CLIENT_IP");
if (NonUtils.isNotEmpty(ip) && !"unknown".equalsIgnoreCase(ip)) {
return ip;
}
ip = request.getHeader("HTTP_X_FORWARDED_FOR");
if (NonUtils.isNotEmpty(ip) && !"unknown".equalsIgnoreCase(ip)) {
return ip;
}
return request.getRemoteAddr();
}
/**
* @description 获取当前请求的User-Agent
* @return String User-Agent值，未找到返回null
* @author yslg
* @since 2025-10-07
*/
public static String getUserAgent() {
return getHeader("User-Agent");
}
/**
* @description 获取当前请求的完整URL
* @return String 完整URL，无当前请求时返回null
* @author yslg
* @since 2025-10-07
*/
public static String getRequestUrl() {
HttpServletRequest request = getRequest();
if (request == null) {
return null;
}
StringBuffer url = request.getRequestURL();
String queryString = request.getQueryString();
if (NonUtils.isNotEmpty(queryString)) {
url.append('?').append(queryString);
}
return url.toString();
}
/**
* @description 从请求中提取token
* @param request HTTP请求对象
* @return String token
* @author yslg
* @since 2025-10-07
*/
private static String extractTokenFromRequest(HttpServletRequest request) {
// 优先从Authorization头获取
String authHeader = request.getHeader(HttpHeaders.AUTHORIZATION);
if (NonUtils.isNotEmpty(authHeader) && authHeader.startsWith(TOKEN_PREFIX)) {
return authHeader.substring(TOKEN_PREFIX.length());
}
// 从请求参数中获取token
String token = request.getParameter("token");
if (NonUtils.isNotEmpty(token)) {
return token;
}
// 从请求头中获取token
token = request.getHeader("token");
if (NonUtils.isNotEmpty(token)) {
return token;
}
return null;
}
}

58
schoolNewsServ/system/src/main/java/org/xyzh/system/controller/PermissionController.java Normal file
View File

@@ -0,0 +1,58 @@
package org.xyzh.system.controller;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.RestController;
import org.xyzh.api.system.permission.PermissionService;
import org.xyzh.common.core.domain.ResultDomain;
import org.xyzh.common.dto.permission.TbSysPermission;
import java.util.List;
@RestController
@RequestMapping("/permissions")
public class PermissionController {
private Logger logger = LoggerFactory.getLogger(PermissionController.class);
@Autowired
private PermissionService permissionService;
/**
* @description 创建权限
* @param permission
* @author yslg
* @ since 2025-10-06
*/
@PostMapping("/permission")
public ResultDomain<TbSysPermission> createPermission(TbSysPermission permission) {
return permissionService.createPermission(permission);
}
/**
* @description 更新权限
* @param permission
* @author yslg
* @ since 2025-10-06
*/
@PutMapping("/permission")
public ResultDomain<TbSysPermission> updatePermission(TbSysPermission permission) {
return permissionService.updatePermission(permission);
}
/**
* @description 删除权限
* @param permissionID
* @author yslg
* @ since 2025-10-06
*/
@DeleteMapping("/permission")
public ResultDomain<TbSysPermission> deletePermission(String permissionID) {
return permissionService.deletePermission(permissionID);
}
}

44
schoolNewsServ/system/src/main/java/org/xyzh/system/controller/UserController.java
View File

@@ -3,12 +3,16 @@ package org.xyzh.system.controller;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;
import org.xyzh.api.system.user.UserService;
import org.xyzh.common.annotation.HttpLogin;
import org.xyzh.common.core.domain.LoginDomain;
import org.xyzh.common.core.domain.ResultDomain;
import org.xyzh.common.dto.user.TbSysUser;
import org.xyzh.common.dto.user.TbSysUserInfo;
import org.springframework.web.bind.annotation.GetMapping;
@@ -29,6 +33,32 @@ public class UserController {
@Autowired
private UserService userService;
// ---------------- 用户 ----------------
@PostMapping("/register")
public ResultDomain<TbSysUser> registerUser(@RequestBody TbSysUser user){
return userService.registerUser(user);
}
// ---------------- 用户信息 ----------------
/**
* @description 获取用户信息
* @param loginDomain
* @author yslg
* @ since 2025-10-06
*/
@GetMapping("/userinfo")
public ResultDomain<TbSysUserInfo> getUserInfo(@HttpLogin LoginDomain loginDomain){
ResultDomain<TbSysUserInfo> result = new ResultDomain<>();
@@ -39,5 +69,19 @@ public class UserController {
result.setData(userInfo.getData());
return result;
}
/**
* @description 更新用户信息
* @param userInfo
* @author yslg
* @ since 2025-10-06
*/
@PutMapping("/userinfo")
public ResultDomain<TbSysUserInfo> updateUserInfo(@HttpLogin LoginDomain loginDomain, @RequestBody TbSysUserInfo userInfo) {
userInfo.setUserID(loginDomain.getUser().getID());
return userService.updateUserInfo(userInfo);
}
}

9
schoolNewsServ/system/src/main/java/org/xyzh/system/mapper/MenuMapper.java
View File

@@ -71,4 +71,13 @@ public interface MenuMapper extends BaseMapper<TbSysMenu> {
* @since 2025-09-28
*/
int batchDeleteByIds(@Param("menuIds") List<String> menuIds, @Param("updater") String updater);
/**
* @description 检查菜单是否存在
* @param menuIds 菜单ID列表
* @return List<TbSysMenu> 菜单列表
* @author yslg
* @since 2025-09-28
*/
List<TbSysMenu> checkMenuExists(@Param("menuIds") List<String> menuIds);
}

81
schoolNewsServ/system/src/main/java/org/xyzh/system/mapper/MenuPermissionMapper.java Normal file
View File

@@ -0,0 +1,81 @@
package org.xyzh.system.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import org.xyzh.common.dto.menu.TbSysMenuPermission;
import java.util.List;
/**
* @description MenuPermissionMapper.java文件描述 菜单权限关联数据访问层
* @filename MenuPermissionMapper.java
* @author yslg
* @copyright xyzh
* @since 2025-10-07
*/
@Mapper
public interface MenuPermissionMapper extends BaseMapper<TbSysMenuPermission> {
/**
* @description 批量绑定菜单权限
* @param menuPermissions 菜单权限列表
* @param creator 创建人
* @return int 影响行数
* @author yslg
* @since 2025-10-07
*/
int batchBindMenuPermission(@Param("menuPermissions") List<TbSysMenuPermission> menuPermissions);
/**
* @description 批量解绑菜单权限
* @param menuPermissions 菜单权限列表
* @param updater 更新人
* @return int 影响行数
* @author yslg
* @since 2025-10-07
*/
int batchUnbindMenuPermission(@Param("menuPermissions") List<TbSysMenuPermission> menuPermissions);
/**
* @description 根据菜单ID和权限ID查询关联关系
* @param menuId 菜单ID
* @param permissionId 权限ID
* @return TbSysMenuPermission 菜单权限关联信息
* @author yslg
* @since 2025-10-07
*/
TbSysMenuPermission selectByMenuIdAndPermissionId(@Param("menuId") String menuId,
@Param("permissionId") String permissionId);
/**
* @description 根据菜单ID查询权限关联列表
* @param menuId 菜单ID
* @return List<TbSysMenuPermission> 菜单权限关联列表
* @author yslg
* @since 2025-10-07
*/
List<TbSysMenuPermission> selectByMenuId(@Param("menuId") String menuId);
/**
* @description 根据权限ID查询菜单关联列表
* @param permissionId 权限ID
* @return List<TbSysMenuPermission> 菜单权限关联列表
* @author yslg
* @since 2025-10-07
*/
List<TbSysMenuPermission> selectByPermissionId(@Param("permissionId") String permissionId);
/**
* @description 删除菜单权限关联（逻辑删除）
* @param menuId 菜单ID
* @param permissionId 权限ID
* @param updater 更新人
* @return int 影响行数
* @author yslg
* @since 2025-10-07
*/
int deleteByMenuIdAndPermissionId(@Param("menuId") String menuId,
@Param("permissionId") String permissionId,
@Param("updater") String updater);
}

9
schoolNewsServ/system/src/main/java/org/xyzh/system/mapper/PermissionMapper.java
View File

@@ -73,4 +73,13 @@ public interface PermissionMapper extends BaseMapper<TbSysPermission> {
* @since 2025-09-28
*/
int batchDeleteByIds(@Param("permissionIds") List<String> permissionIds, @Param("updater") String updater);
/**
* @description 检查权限是否存在
* @param permissionIds 权限ID列表
* @return List<TbSysPermission> 权限列表
* @author yslg
* @since 2025-10-07
*/
List<TbSysPermission> checkPermissionExists(@Param("permissionIds") List<String> permissionIds);
}

9
schoolNewsServ/system/src/main/java/org/xyzh/system/mapper/RoleMapper.java
View File

@@ -65,4 +65,13 @@ public interface RoleMapper extends BaseMapper<TbSysRole> {
* @since 2025-09-28
*/
int batchDeleteByIds(@Param("roleIds") List<String> roleIds, @Param("updater") String updater);
/**
* @description 检查角色是否存在
* @param roleIds 角色ID列表
* @return List<TbSysRole> 角色列表
* @author yslg
* @since 2025-10-07
*/
List<TbSysRole> checkRoleExists(@Param("roleIds") List<String> roleIds);
}

79
schoolNewsServ/system/src/main/java/org/xyzh/system/mapper/RolePermissionMapper.java Normal file
View File

@@ -0,0 +1,79 @@
package org.xyzh.system.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import org.xyzh.common.dto.role.TbSysRolePermission;
import java.util.List;
/**
* @description RolePermissionMapper.java文件描述 角色权限关联数据访问层
* @filename RolePermissionMapper.java
* @author yslg
* @copyright xyzh
* @since 2025-10-07
*/
@Mapper
public interface RolePermissionMapper extends BaseMapper<TbSysRolePermission> {
/**
* @description 批量绑定角色权限
* @param rolePermissions 角色权限列表
* @return int 影响行数
* @author yslg
* @since 2025-10-07
*/
int batchBindRolePermission(@Param("rolePermissions") List<TbSysRolePermission> rolePermissions);
/**
* @description 批量解绑角色权限
* @param rolePermissions 角色权限列表
* @return int 影响行数
* @author yslg
* @since 2025-10-07
*/
int batchUnbindRolePermission(@Param("rolePermissions") List<TbSysRolePermission> rolePermissions);
/**
* @description 根据角色ID和权限ID查询关联关系
* @param roleId 角色ID
* @param permissionId 权限ID
* @return TbSysRolePermission 角色权限关联信息
* @author yslg
* @since 2025-10-07
*/
TbSysRolePermission selectByRoleIdAndPermissionId(@Param("roleId") String roleId,
@Param("permissionId") String permissionId);
/**
* @description 根据角色ID查询权限关联列表
* @param roleId 角色ID
* @return List<TbSysRolePermission> 角色权限关联列表
* @author yslg
* @since 2025-10-07
*/
List<TbSysRolePermission> selectByRoleId(@Param("roleId") String roleId);
/**
* @description 根据权限ID查询角色关联列表
* @param permissionId 权限ID
* @return List<TbSysRolePermission> 角色权限关联列表
* @author yslg
* @since 2025-10-07
*/
List<TbSysRolePermission> selectByPermissionId(@Param("permissionId") String permissionId);
/**
* @description 删除角色权限关联（逻辑删除）
* @param roleId 角色ID
* @param permissionId 权限ID
* @param updater 更新人
* @return int 影响行数
* @author yslg
* @since 2025-10-07
*/
int deleteByRoleIdAndPermissionId(@Param("roleId") String roleId,
@Param("permissionId") String permissionId,
@Param("updater") String updater);
}

10
schoolNewsServ/system/src/main/java/org/xyzh/system/mapper/UserDeptRoleMapper.java Normal file
View File

@@ -0,0 +1,10 @@
package org.xyzh.system.mapper;
import org.apache.ibatis.annotations.Mapper;
import org.xyzh.common.dto.user.TbSysUserDeptRole;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
@Mapper
public interface UserDeptRoleMapper extends BaseMapper<TbSysUserDeptRole> {
}

10
schoolNewsServ/system/src/main/java/org/xyzh/system/mapper/UserInfoMapper.java Normal file
View File

@@ -0,0 +1,10 @@
package org.xyzh.system.mapper;
import org.apache.ibatis.annotations.Mapper;
import org.xyzh.common.dto.user.TbSysUserInfo;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
@Mapper
public interface UserInfoMapper extends BaseMapper<TbSysUserInfo> {
}

29
schoolNewsServ/system/src/main/java/org/xyzh/system/mapper/UserMapper.java
View File

@@ -27,15 +27,6 @@ public interface UserMapper extends BaseMapper<TbSysUser> {
*/
TbSysUser selectByUsername(@Param("username") String username);
/**
* @description 根据用户ID查询用户信息
* @param userId 用户ID
* @return TbSysUserInfo 用户信息
* @author yslg
* @since 2025-10-06
*/
TbSysUserInfo selectUserInfoById(@Param("userId") String userId);
/**
* @description 根据邮箱查询用户
* @param email 邮箱
@@ -85,4 +76,24 @@ public interface UserMapper extends BaseMapper<TbSysUser> {
* @since 2025-09-28
*/
int batchDeleteByIds(@Param("userIds") List<String> userIds, @Param("updater") String updater);
// ----------------用户信息相关--------------------------------
/**
* @description 根据用户ID查询用户信息
* @param userId 用户ID
* @return TbSysUserInfo 用户信息
* @author yslg
* @since 2025-10-06
*/
TbSysUserInfo selectUserInfoById(@Param("userId") String userId);
/**
* @description 更新用户信息
* @param userInfo 用户信息
* @return int 影响行数
* @author yslg
* @since 2025-10-06
*/
int updateUserInfo(@Param("userInfo") TbSysUserInfo userInfo);
}

962
schoolNewsServ/system/src/main/java/org/xyzh/system/permission/service/impl/SysPermissionServiceImpl.java
View File

@@ -1,17 +1,33 @@
package org.xyzh.system.permission.service.impl;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.StringUtils;
import org.xyzh.api.system.menu.MenuService;
import org.xyzh.api.system.role.RoleService;
import org.xyzh.common.dto.user.TbSysUser;
import org.xyzh.common.core.domain.ResultDomain;
import org.xyzh.common.dto.permission.TbSysPermission;
import org.xyzh.common.dto.role.TbSysRole;
import org.xyzh.common.dto.role.TbSysRolePermission;
import org.xyzh.common.dto.menu.TbSysMenu;
import org.xyzh.common.dto.menu.TbSysMenuPermission;
import org.xyzh.common.utils.IDUtils;
import org.xyzh.system.mapper.MenuPermissionMapper;
import org.xyzh.system.mapper.MenuMapper;
import org.xyzh.system.mapper.PermissionMapper;
import org.xyzh.system.mapper.RolePermissionMapper;
import org.xyzh.system.mapper.RoleMapper;
import org.xyzh.system.permission.service.SysPermissionService;
import org.xyzh.system.utils.LoginUtil;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.List;
@@ -30,6 +46,676 @@ public class SysPermissionServiceImpl implements SysPermissionService {
@Autowired
private PermissionMapper permissionMapper;
@Autowired
private RolePermissionMapper rolePermissionMapper;
@Autowired
private MenuPermissionMapper menuPermissionMapper;
@Autowired
private RoleMapper roleMapper;
@Autowired
private MenuMapper menuMapper;
@Autowired
private RoleService roleService;
@Autowired
private MenuService menuService;
@Transactional
@Override
public ResultDomain<TbSysPermission> createPermission(TbSysPermission permission) {
ResultDomain<TbSysPermission> resultDomain = new ResultDomain<>();
try {
logger.info("开始创建权限：{}", permission.getName());
// 参数校验
if (!StringUtils.hasText(permission.getName())) {
resultDomain.fail("权限名称不能为空");
return resultDomain;
}
if (!StringUtils.hasText(permission.getCode())) {
resultDomain.fail("权限编码不能为空");
return resultDomain;
}
// 检查权限名称是否已存在
ResultDomain<Boolean> nameCheckResult = checkPermissionNameExists(permission.getName(), null);
if (!nameCheckResult.isSuccess()) {
resultDomain.fail(nameCheckResult.getMessage());
return resultDomain;
}
if (nameCheckResult.getData()) {
resultDomain.fail("权限名称已存在");
return resultDomain;
}
// 检查权限编码是否已存在
ResultDomain<Boolean> codeCheckResult = checkPermissionCodeExists(permission.getCode(), null);
if (!codeCheckResult.isSuccess()) {
resultDomain.fail(codeCheckResult.getMessage());
return resultDomain;
}
if (codeCheckResult.getData()) {
resultDomain.fail("权限编码已存在");
return resultDomain;
}
// 设置基础信息
permission.setID(IDUtils.generateID());
permission.setPermissionID(IDUtils.generateID());
permission.setCreateTime(new Date());
// 插入数据库
int result = permissionMapper.insert(permission);
if (result > 0) {
logger.info("创建权限成功：{}", permission.getName());
resultDomain.success("创建权限成功", permission);
return resultDomain;
} else {
logger.warn("创建权限失败：{}", permission.getName());
resultDomain.fail("创建权限失败");
}
return resultDomain;
} catch (Exception e) {
logger.error("创建权限异常：{}", permission.getName(), e);
resultDomain.fail("创建权限失败：" + e.getMessage());
return resultDomain;
}
}
@Transactional
@Override
public ResultDomain<TbSysPermission> updatePermission(TbSysPermission permission) {
ResultDomain<TbSysPermission> resultDomain = new ResultDomain<>();
try {
logger.info("开始更新权限：{}", permission.getPermissionID());
// 参数校验
if (!StringUtils.hasText(permission.getPermissionID())) {
resultDomain.fail("权限ID不能为空");
return resultDomain;
}
if (!StringUtils.hasText(permission.getName())) {
resultDomain.fail("权限名称不能为空");
return resultDomain;
}
if (!StringUtils.hasText(permission.getCode())) {
resultDomain.fail("权限编码不能为空");
return resultDomain;
}
// 检查权限是否存在
ResultDomain<TbSysPermission> existResult = getPermissionById(permission.getPermissionID());
if (!existResult.isSuccess()) {
resultDomain.fail(existResult.getMessage());
return resultDomain;
}
// 检查权限名称是否已存在（排除自身）
ResultDomain<Boolean> nameCheckResult = checkPermissionNameExists(permission.getName(), permission.getID());
if (!nameCheckResult.isSuccess()) {
resultDomain.fail(nameCheckResult.getMessage());
return resultDomain;
}
if (nameCheckResult.getData()) {
resultDomain.fail("权限名称已存在");
return resultDomain;
}
// 检查权限编码是否已存在（排除自身）
ResultDomain<Boolean> codeCheckResult = checkPermissionCodeExists(permission.getCode(), permission.getID());
if (!codeCheckResult.isSuccess()) {
resultDomain.fail(codeCheckResult.getMessage());
return resultDomain;
}
if (codeCheckResult.getData()) {
resultDomain.fail("权限编码已存在");
return resultDomain;
}
// 设置更新时间
permission.setUpdateTime(new Date());
// 更新数据库
int result = permissionMapper.updateById(permission);
if (result > 0) {
logger.info("更新权限成功：{}", permission.getPermissionID());
resultDomain.success("更新权限成功", permission);
return resultDomain;
} else {
logger.warn("更新权限失败：{}", permission.getPermissionID());
resultDomain.fail("更新权限失败");
return resultDomain;
}
} catch (Exception e) {
logger.error("更新权限异常：{}", permission.getPermissionID(), e);
resultDomain.fail("更新权限失败：" + e.getMessage());
return resultDomain;
}
}
@Transactional
@Override
public ResultDomain<TbSysPermission> deletePermission(String permissionId) {
ResultDomain<TbSysPermission> resultDomain = new ResultDomain<>();
try {
logger.info("开始删除权限：{}", permissionId);
if (!StringUtils.hasText(permissionId)) {
resultDomain.fail("权限ID不能为空");
return resultDomain;
}
// 检查权限是否存在
ResultDomain<TbSysPermission> existResult = getPermissionById(permissionId);
if (!existResult.isSuccess()) {
resultDomain.fail(existResult.getMessage());
return resultDomain;
}
// TODO: 检查权限是否被角色使用，如果被使用则不能删除
// 逻辑删除
TbSysPermission permission = existResult.getData();
permission.setDeleted(true);
permission.setDeleteTime(new Date());
int result = permissionMapper.updateById(permission);
if (result > 0) {
logger.info("删除权限成功：{}", permissionId);
resultDomain.success("删除权限成功", permission);
return resultDomain;
} else {
logger.warn("删除权限失败：{}", permissionId);
resultDomain.fail("删除权限失败");
return resultDomain;
}
} catch (Exception e) {
logger.error("删除权限异常：{}", permissionId, e);
resultDomain.fail("删除权限失败：" + e.getMessage());
return resultDomain;
}
}
// ----------------------角色权限管理--------------------------
/**
* @description 角色权限绑定
* @param
* @author yslg
* @ since 2025-10-07
*/
@Transactional
@Override
public ResultDomain<TbSysRolePermission> bindRolePermission(String roleId, String permissionId) {
ResultDomain<TbSysRolePermission> resultDomain = new ResultDomain<>();
TbSysUser user = LoginUtil.getCurrentUser();
if (user == null) {
resultDomain.fail("当前用户不存在");
return resultDomain;
}
// 检验权限存在
ResultDomain<TbSysPermission> permissionResult = getPermissionById(permissionId);
if (!permissionResult.isSuccess()) {
resultDomain.fail(permissionResult.getMessage());
return resultDomain;
}
// 校验角色存在
ResultDomain<TbSysRole> roleResult = roleService.getRoleById(roleId);
if (!roleResult.isSuccess()) {
resultDomain.fail(roleResult.getMessage());
return resultDomain;
}
// 绑定角色权限
TbSysRolePermission rolePermission = new TbSysRolePermission();
rolePermission.setID(IDUtils.generateID());
rolePermission.setRoleID(roleId);
rolePermission.setPermissionID(permissionId);
rolePermission.setCreator(user.getID());
rolePermission.setCreateTime(new Date());
int result = rolePermissionMapper.batchBindRolePermission(Arrays.asList(rolePermission));
if (result > 0) {
resultDomain.success("绑定角色权限成功", rolePermission);
} else {
resultDomain.fail("绑定角色权限失败");
}
return resultDomain;
}
/**
* @description 角色权限批量绑定
* @param
* @author yslg
* @ since 2025-10-07
*/
@Transactional
@Override
public ResultDomain<TbSysRolePermission> batchBindRolePermission(List<String> roleIds, List<String> permissionIds) {
ResultDomain<TbSysRolePermission> resultDomain = new ResultDomain<>();
TbSysUser user = LoginUtil.getCurrentUser();
if (user == null) {
resultDomain.fail("当前用户不存在");
return resultDomain;
}
// 检验权限存在
List<TbSysPermission> permissions = permissionMapper.checkPermissionExists(permissionIds);
if (permissions.isEmpty()) {
resultDomain.fail("权限不存在");
return resultDomain;
}
// 检验角色存在
List<TbSysRole> roles = roleMapper.checkRoleExists(roleIds);
if (roles.isEmpty()) {
resultDomain.fail("角色不存在");
return resultDomain;
}
// 批量绑定角色权限
List<TbSysRolePermission> rolePermissions = new ArrayList<>();
for (String roleId : roleIds) {
for (String permissionId : permissionIds) {
TbSysRolePermission rolePermission = new TbSysRolePermission();
rolePermission.setID(IDUtils.generateID());
rolePermission.setRoleID(roleId);
rolePermission.setPermissionID(permissionId);
rolePermission.setCreator(user.getID());
rolePermission.setCreateTime(new Date());
rolePermissions.add(rolePermission);
}
}
int result = rolePermissionMapper.batchBindRolePermission(rolePermissions);
if (result > 0) {
resultDomain.success("批量绑定角色权限成功", rolePermissions);
} else {
resultDomain.fail("批量绑定角色权限失败");
}
return resultDomain;
}
/**
* @description 角色权限解绑 真删除，避免再次绑定导致的报错问题
* @param
* @author yslg
* @ since 2025-10-07
*/
@Transactional
@Override
public ResultDomain<TbSysRolePermission> unbindRolePermission(String roleId, String permissionId) {
ResultDomain<TbSysRolePermission> resultDomain = new ResultDomain<>();
TbSysUser user = LoginUtil.getCurrentUser();
if (user == null) {
resultDomain.fail("当前用户不存在");
return resultDomain;
}
// 检验权限存在
ResultDomain<TbSysPermission> permissionResult = getPermissionById(permissionId);
if (!permissionResult.isSuccess()) {
resultDomain.fail(permissionResult.getMessage());
return resultDomain;
}
// 校验角色存在
ResultDomain<TbSysRole> roleResult = roleService.getRoleById(roleId);
if (!roleResult.isSuccess()) {
resultDomain.fail(roleResult.getMessage());
return resultDomain;
}
// 解绑角色权限
TbSysRolePermission rolePermission = new TbSysRolePermission();
rolePermission.setRoleID(roleId);
rolePermission.setPermissionID(permissionId);
rolePermission.setUpdater(user.getID());
rolePermission.setUpdateTime(new Date());
int result = rolePermissionMapper.batchUnbindRolePermission(Arrays.asList(rolePermission));
if (result > 0) {
resultDomain.success("解绑角色权限成功", rolePermission);
} else {
resultDomain.fail("解绑角色权限失败");
}
return resultDomain;
}
/**
* @description 角色权限批量解绑 真删除，避免再次绑定导致的报错问题
* @param
* @author yslg
* @ since 2025-10-07
*/
@Transactional
@Override
public ResultDomain<TbSysRolePermission> batchUnbindRolePermission(List<String> roleIds, List<String> permissionIds) {
ResultDomain<TbSysRolePermission> resultDomain = new ResultDomain<>();
TbSysUser user = LoginUtil.getCurrentUser();
if (user == null) {
resultDomain.fail("当前用户不存在");
return resultDomain;
}
// 检验权限存在
List<TbSysPermission> permissions = permissionMapper.checkPermissionExists(permissionIds);
if (permissions.isEmpty()) {
resultDomain.fail("权限不存在");
return resultDomain;
}
// 检验角色存在
List<TbSysRole> roles = roleMapper.checkRoleExists(roleIds);
if (roles.isEmpty()) {
resultDomain.fail("角色不存在");
return resultDomain;
}
// 批量解绑角色权限
List<TbSysRolePermission> rolePermissions = new ArrayList<>();
for (String roleId : roleIds) {
for (String permissionId : permissionIds) {
TbSysRolePermission rolePermission = new TbSysRolePermission();
rolePermission.setRoleID(roleId);
rolePermission.setPermissionID(permissionId);
rolePermission.setUpdater(user.getID());
rolePermission.setUpdateTime(new Date());
rolePermissions.add(rolePermission);
}
}
int result = rolePermissionMapper.batchUnbindRolePermission(rolePermissions);
if (result > 0) {
resultDomain.success("批量解绑角色权限成功", rolePermissions);
} else {
resultDomain.fail("批量解绑角色权限失败");
}
return resultDomain;
}
// ----------------------菜单权限管理--------------------------
/**
* @description 菜单权限绑定
* @param
* @author yslg
* @ since 2025-10-07
*/
@Transactional
@Override
public ResultDomain<TbSysMenuPermission> bindMenuPermission(String menuId, String permissionId) {
ResultDomain<TbSysMenuPermission> resultDomain = new ResultDomain<>();
TbSysUser user = LoginUtil.getCurrentUser();
if (user == null) {
resultDomain.fail("当前用户不存在");
return resultDomain;
}
// 检验菜单存在
ResultDomain<TbSysMenu> menuResult = menuService.getMenuById(menuId);
if (!menuResult.isSuccess()) {
resultDomain.fail(menuResult.getMessage());
return resultDomain;
}
// 检验权限存在
ResultDomain<TbSysPermission> permissionResult = getPermissionById(permissionId);
if (!permissionResult.isSuccess()) {
resultDomain.fail(permissionResult.getMessage());
return resultDomain;
}
// 绑定菜单权限
TbSysMenuPermission menuPermission = new TbSysMenuPermission();
menuPermission.setID(IDUtils.generateID());
menuPermission.setMenuID(menuId);
menuPermission.setPermissionID(permissionId);
menuPermission.setCreator(user.getID());
menuPermission.setCreateTime(new Date());
int result = menuPermissionMapper.batchBindMenuPermission(Arrays.asList(menuPermission));
if (result > 0) {
resultDomain.success("绑定菜单权限成功", menuPermission);
} else {
resultDomain.fail("绑定菜单权限失败");
}
return resultDomain;
}
/**
* @description 菜单权限批量绑定
* @param
* @author yslg
* @ since 2025-10-07
*/
@Transactional
@Override
public ResultDomain<TbSysMenuPermission> batchBindMenuPermission(List<String> menuIds, List<String> permissionIds) {
ResultDomain<TbSysMenuPermission> resultDomain = new ResultDomain<>();
TbSysUser user = LoginUtil.getCurrentUser();
if (user == null) {
resultDomain.fail("当前用户不存在");
return resultDomain;
}
// 检验菜单存在
List<TbSysMenu> menus = menuMapper.checkMenuExists(menuIds);
if (menus.isEmpty()) {
resultDomain.fail("菜单不存在");
return resultDomain;
}
// 检验权限存在
List<TbSysPermission> permissions = permissionMapper.checkPermissionExists(permissionIds);
if (permissions.isEmpty()) {
resultDomain.fail("权限不存在");
return resultDomain;
}
// 批量绑定菜单权限
List<TbSysMenuPermission> menuPermissions = new ArrayList<>();
for (String menuId : menuIds) {
for (String permissionId : permissionIds) {
TbSysMenuPermission menuPermission = new TbSysMenuPermission();
menuPermission.setID(IDUtils.generateID());
menuPermission.setMenuID(menuId);
menuPermission.setPermissionID(permissionId);
menuPermission.setCreator(user.getID());
menuPermission.setCreateTime(new Date());
menuPermissions.add(menuPermission);
}
}
int result = menuPermissionMapper.batchBindMenuPermission(menuPermissions);
if (result > 0) {
resultDomain.success("批量绑定菜单权限成功", menuPermissions);
} else {
resultDomain.fail("批量绑定菜单权限失败");
}
return resultDomain;
}
/**
* @description 菜单权限解绑
* @param
* @author yslg
* @ since 2025-10-07
*/
@Transactional
@Override
public ResultDomain<TbSysMenuPermission> unbindMenuPermission(String menuId, String permissionId) {
ResultDomain<TbSysMenuPermission> resultDomain = new ResultDomain<>();
TbSysUser user = LoginUtil.getCurrentUser();
if (user == null) {
resultDomain.fail("当前用户不存在");
return resultDomain;
}
// 检验菜单存在
ResultDomain<TbSysMenu> menuResult = menuService.getMenuById(menuId);
if (!menuResult.isSuccess()) {
resultDomain.fail(menuResult.getMessage());
return resultDomain;
}
// 检验权限存在
ResultDomain<TbSysPermission> permissionResult = getPermissionById(permissionId);
if (!permissionResult.isSuccess()) {
resultDomain.fail(permissionResult.getMessage());
return resultDomain;
}
// 解绑菜单权限
TbSysMenuPermission menuPermission = new TbSysMenuPermission();
menuPermission.setMenuID(menuId);
menuPermission.setPermissionID(permissionId);
menuPermission.setUpdater(user.getID());
menuPermission.setUpdateTime(new Date());
int result = menuPermissionMapper.batchUnbindMenuPermission(Arrays.asList(menuPermission));
if (result > 0) {
resultDomain.success("解绑菜单权限成功", menuPermission);
} else {
resultDomain.fail("解绑菜单权限失败");
}
return resultDomain;
}
/**
* @description 菜单权限批量解绑
* @param
* @author yslg
* @ since 2025-10-07
*/
@Transactional
@Override
public ResultDomain<TbSysMenuPermission> batchUnbindMenuPermission(List<String> menuIds, List<String> permissionIds) {
ResultDomain<TbSysMenuPermission> resultDomain = new ResultDomain<>();
TbSysUser user = LoginUtil.getCurrentUser();
if (user == null) {
resultDomain.fail("当前用户不存在");
return resultDomain;
}
// 检验菜单存在
List<TbSysMenu> menus = menuMapper.checkMenuExists(menuIds);
if (menus.isEmpty()) {
resultDomain.fail("菜单不存在");
return resultDomain;
}
// 检验权限存在
List<TbSysPermission> permissions = permissionMapper.checkPermissionExists(permissionIds);
if (permissions.isEmpty()) {
resultDomain.fail("权限不存在");
return resultDomain;
}
// 批量解绑菜单权限
List<TbSysMenuPermission> menuPermissions = new ArrayList<>();
for (String menuId : menuIds) {
for (String permissionId : permissionIds) {
TbSysMenuPermission menuPermission = new TbSysMenuPermission();
menuPermission.setMenuID(menuId);
menuPermission.setPermissionID(permissionId);
menuPermission.setUpdater(user.getID());
menuPermission.setUpdateTime(new Date());
menuPermissions.add(menuPermission);
}
}
int result = menuPermissionMapper.batchUnbindMenuPermission(menuPermissions);
if (result > 0) {
resultDomain.success("批量解绑菜单权限成功", menuPermissions);
} else {
resultDomain.fail("批量解绑菜单权限失败");
}
return resultDomain;
}
@Transactional
@Override
public ResultDomain<Boolean> checkPermissionNameExists(String permissionName, String excludeId) {
ResultDomain<Boolean> resultDomain = new ResultDomain<>();
try {
logger.info("检查权限名称是否存在：{}", permissionName);
if (!StringUtils.hasText(permissionName)) {
resultDomain.fail("权限名称不能为空");
return resultDomain;
}
int count = permissionMapper.countByPermissionName(permissionName, excludeId);
boolean exists = count > 0;
logger.info("权限名称存在性检查完成：{}，存在：{}", permissionName, exists);
resultDomain.success("检查完成", exists);
return resultDomain;
} catch (Exception e) {
logger.error("检查权限名称存在性失败：{}", permissionName, e);
resultDomain.fail("检查失败：" + e.getMessage());
return resultDomain;
}
}
@Override
public ResultDomain<Boolean> checkPermissionCodeExists(String permissionCode, String excludeId) {
ResultDomain<Boolean> resultDomain = new ResultDomain<>();
try {
logger.info("检查权限编码是否存在：{}", permissionCode);
if (!StringUtils.hasText(permissionCode)) {
resultDomain.fail("权限编码不能为空");
return resultDomain;
}
int count = permissionMapper.countByPermissionCode(permissionCode, excludeId);
boolean exists = count > 0;
logger.info("权限编码存在性检查完成：{}，存在：{}", permissionCode, exists);
resultDomain.success("检查完成", exists);
return resultDomain;
} catch (Exception e) {
logger.error("检查权限编码存在性失败：{}", permissionCode, e);
resultDomain.fail("检查失败：" + e.getMessage());
return resultDomain;
}
}
@Override
public ResultDomain<TbSysPermission> changePermissionStatus(String permissionId, Integer status) {
ResultDomain<TbSysPermission> resultDomain = new ResultDomain<>();
try {
logger.info("开始修改权限状态：{}，状态：{}", permissionId, status);
if (!StringUtils.hasText(permissionId)) {
resultDomain.fail("权限ID不能为空");
return resultDomain;
}
if (status == null) {
resultDomain.fail("权限状态不能为空");
return resultDomain;
}
// 检查权限是否存在
ResultDomain<TbSysPermission> existResult = getPermissionById(permissionId);
if (!existResult.isSuccess()) {
resultDomain.fail(existResult.getMessage());
return resultDomain;
}
TbSysPermission permission = existResult.getData();
permission.setUpdateTime(new Date());
int result = permissionMapper.updateById(permission);
if (result > 0) {
logger.info("修改权限状态成功：{}", permissionId);
resultDomain.success("修改权限状态成功", permission);
return resultDomain;
} else {
logger.warn("修改权限状态失败：{}", permissionId);
resultDomain.fail("修改权限状态失败");
return resultDomain;
}
} catch (Exception e) {
logger.error("修改权限状态异常：{}", permissionId, e);
resultDomain.fail("修改权限状态失败：" + e.getMessage());
return resultDomain;
}
}
@Override
public ResultDomain<TbSysPermission> getAllPermissions() {
ResultDomain<TbSysPermission> resultDomain = new ResultDomain<>();
@@ -166,280 +852,4 @@ public class SysPermissionServiceImpl implements SysPermissionService {
}
}
@Override
public ResultDomain<TbSysPermission> createPermission(TbSysPermission permission) {
ResultDomain<TbSysPermission> resultDomain = new ResultDomain<>();
try {
logger.info("开始创建权限：{}", permission.getName());
// 参数校验
if (!StringUtils.hasText(permission.getName())) {
resultDomain.fail("权限名称不能为空");
return resultDomain;
}
if (!StringUtils.hasText(permission.getCode())) {
resultDomain.fail("权限编码不能为空");
return resultDomain;
}
// 检查权限名称是否已存在
ResultDomain<Boolean> nameCheckResult = checkPermissionNameExists(permission.getName(), null);
if (!nameCheckResult.isSuccess()) {
resultDomain.fail(nameCheckResult.getMessage());
return resultDomain;
}
if (nameCheckResult.getData()) {
resultDomain.fail("权限名称已存在");
return resultDomain;
}
// 检查权限编码是否已存在
ResultDomain<Boolean> codeCheckResult = checkPermissionCodeExists(permission.getCode(), null);
if (!codeCheckResult.isSuccess()) {
resultDomain.fail(codeCheckResult.getMessage());
return resultDomain;
}
if (codeCheckResult.getData()) {
resultDomain.fail("权限编码已存在");
return resultDomain;
}
// 设置基础信息
permission.setID(IDUtils.generateID());
permission.setPermissionID(IDUtils.generateID());
permission.setCreateTime(new Date());
permission.setDeleted(false);
// 插入数据库
int result = permissionMapper.insert(permission);
if (result > 0) {
logger.info("创建权限成功：{}", permission.getName());
resultDomain.success("创建权限成功", permission);
return resultDomain;
} else {
logger.warn("创建权限失败：{}", permission.getName());
resultDomain.fail("创建权限失败");
}
return resultDomain;
} catch (Exception e) {
logger.error("创建权限异常：{}", permission.getName(), e);
resultDomain.fail("创建权限失败：" + e.getMessage());
return resultDomain;
}
}
@Override
public ResultDomain<TbSysPermission> updatePermission(TbSysPermission permission) {
ResultDomain<TbSysPermission> resultDomain = new ResultDomain<>();
try {
logger.info("开始更新权限：{}", permission.getPermissionID());
// 参数校验
if (!StringUtils.hasText(permission.getPermissionID())) {
resultDomain.fail("权限ID不能为空");
return resultDomain;
}
if (!StringUtils.hasText(permission.getName())) {
resultDomain.fail("权限名称不能为空");
return resultDomain;
}
if (!StringUtils.hasText(permission.getCode())) {
resultDomain.fail("权限编码不能为空");
return resultDomain;
}
// 检查权限是否存在
ResultDomain<TbSysPermission> existResult = getPermissionById(permission.getPermissionID());
if (!existResult.isSuccess()) {
resultDomain.fail(existResult.getMessage());
return resultDomain;
}
// 检查权限名称是否已存在（排除自身）
ResultDomain<Boolean> nameCheckResult = checkPermissionNameExists(permission.getName(), permission.getID());
if (!nameCheckResult.isSuccess()) {
resultDomain.fail(nameCheckResult.getMessage());
return resultDomain;
}
if (nameCheckResult.getData()) {
resultDomain.fail("权限名称已存在");
return resultDomain;
}
// 检查权限编码是否已存在（排除自身）
ResultDomain<Boolean> codeCheckResult = checkPermissionCodeExists(permission.getCode(), permission.getID());
if (!codeCheckResult.isSuccess()) {
resultDomain.fail(codeCheckResult.getMessage());
return resultDomain;
}
if (codeCheckResult.getData()) {
resultDomain.fail("权限编码已存在");
return resultDomain;
}
// 设置更新时间
permission.setUpdateTime(new Date());
// 更新数据库
int result = permissionMapper.updateById(permission);
if (result > 0) {
logger.info("更新权限成功：{}", permission.getPermissionID());
resultDomain.success("更新权限成功", permission);
return resultDomain;
} else {
logger.warn("更新权限失败：{}", permission.getPermissionID());
resultDomain.fail("更新权限失败");
return resultDomain;
}
} catch (Exception e) {
logger.error("更新权限异常：{}", permission.getPermissionID(), e);
resultDomain.fail("更新权限失败：" + e.getMessage());
return resultDomain;
}
}
@Override
public ResultDomain<TbSysPermission> deletePermission(String permissionId) {
ResultDomain<TbSysPermission> resultDomain = new ResultDomain<>();
try {
logger.info("开始删除权限：{}", permissionId);
if (!StringUtils.hasText(permissionId)) {
resultDomain.fail("权限ID不能为空");
return resultDomain;
}
// 检查权限是否存在
ResultDomain<TbSysPermission> existResult = getPermissionById(permissionId);
if (!existResult.isSuccess()) {
resultDomain.fail(existResult.getMessage());
return resultDomain;
}
// TODO: 检查权限是否被角色使用，如果被使用则不能删除
// 逻辑删除
TbSysPermission permission = existResult.getData();
permission.setDeleted(true);
permission.setDeleteTime(new Date());
int result = permissionMapper.updateById(permission);
if (result > 0) {
logger.info("删除权限成功：{}", permissionId);
resultDomain.success("删除权限成功", permission);
return resultDomain;
} else {
logger.warn("删除权限失败：{}", permissionId);
resultDomain.fail("删除权限失败");
return resultDomain;
}
} catch (Exception e) {
logger.error("删除权限异常：{}", permissionId, e);
resultDomain.fail("删除权限失败：" + e.getMessage());
return resultDomain;
}
}
@Override
public ResultDomain<Boolean> checkPermissionNameExists(String permissionName, String excludeId) {
ResultDomain<Boolean> resultDomain = new ResultDomain<>();
try {
logger.info("检查权限名称是否存在：{}", permissionName);
if (!StringUtils.hasText(permissionName)) {
resultDomain.fail("权限名称不能为空");
return resultDomain;
}
int count = permissionMapper.countByPermissionName(permissionName, excludeId);
boolean exists = count > 0;
logger.info("权限名称存在性检查完成：{}，存在：{}", permissionName, exists);
resultDomain.success("检查完成", exists);
return resultDomain;
} catch (Exception e) {
logger.error("检查权限名称存在性失败：{}", permissionName, e);
resultDomain.fail("检查失败：" + e.getMessage());
return resultDomain;
}
}
@Override
public ResultDomain<Boolean> checkPermissionCodeExists(String permissionCode, String excludeId) {
ResultDomain<Boolean> resultDomain = new ResultDomain<>();
try {
logger.info("检查权限编码是否存在：{}", permissionCode);
if (!StringUtils.hasText(permissionCode)) {
resultDomain.fail("权限编码不能为空");
return resultDomain;
}
int count = permissionMapper.countByPermissionCode(permissionCode, excludeId);
boolean exists = count > 0;
logger.info("权限编码存在性检查完成：{}，存在：{}", permissionCode, exists);
resultDomain.success("检查完成", exists);
return resultDomain;
} catch (Exception e) {
logger.error("检查权限编码存在性失败：{}", permissionCode, e);
resultDomain.fail("检查失败：" + e.getMessage());
return resultDomain;
}
}
@Override
public ResultDomain<TbSysPermission> changePermissionStatus(String permissionId, Integer status) {
ResultDomain<TbSysPermission> resultDomain = new ResultDomain<>();
try {
logger.info("开始修改权限状态：{}，状态：{}", permissionId, status);
if (!StringUtils.hasText(permissionId)) {
resultDomain.fail("权限ID不能为空");
return resultDomain;
}
if (status == null) {
resultDomain.fail("权限状态不能为空");
return resultDomain;
}
// 检查权限是否存在
ResultDomain<TbSysPermission> existResult = getPermissionById(permissionId);
if (!existResult.isSuccess()) {
resultDomain.fail(existResult.getMessage());
return resultDomain;
}
TbSysPermission permission = existResult.getData();
permission.setUpdateTime(new Date());
int result = permissionMapper.updateById(permission);
if (result > 0) {
logger.info("修改权限状态成功：{}", permissionId);
resultDomain.success("修改权限状态成功", permission);
return resultDomain;
} else {
logger.warn("修改权限状态失败：{}", permissionId);
resultDomain.fail("修改权限状态失败");
return resultDomain;
}
} catch (Exception e) {
logger.error("修改权限状态异常：{}", permissionId, e);
resultDomain.fail("修改权限状态失败：" + e.getMessage());
return resultDomain;
}
}
}

100
schoolNewsServ/system/src/main/java/org/xyzh/system/user/service/impl/SysUserServiceImpl.java
View File

@@ -5,12 +5,16 @@ import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.StringUtils;
import org.xyzh.common.core.domain.ResultDomain;
import org.xyzh.common.dto.user.TbSysUser;
import org.xyzh.common.dto.user.TbSysUserDeptRole;
import org.xyzh.common.dto.user.TbSysUserInfo;
import org.xyzh.common.utils.IDUtils;
import org.xyzh.system.mapper.UserMapper;
import org.xyzh.system.mapper.UserInfoMapper;
import org.xyzh.system.mapper.UserDeptRoleMapper;
import org.xyzh.system.user.service.SysUserService;
import java.util.Date;
@@ -31,6 +35,64 @@ public class SysUserServiceImpl implements SysUserService {
@Autowired
private UserMapper userMapper;
@Autowired
private UserInfoMapper userInfoMapper;
@Autowired
private UserDeptRoleMapper userDeptRoleMapper;
@Transactional
@Override
public ResultDomain<TbSysUser> registerUser(TbSysUser user) {
ResultDomain<TbSysUser> resultDomain = new ResultDomain<>();
try {
logger.info("开始注册用户：{}", user.getUsername());
// 检查用户是否已存在
ResultDomain<Boolean> checkResult = checkUserExists(user);
if (checkResult.isSuccess()) {
resultDomain.fail("用户已存在");
return resultDomain;
}
// 创建用户信息
TbSysUserInfo userInfo = new TbSysUserInfo();
userInfo.setUserID(user.getID());
userInfo.setCreateTime(new Date());
userInfo.setAvatar("default");
TbSysUserDeptRole userDeptRole = new TbSysUserDeptRole();
userDeptRole.setUserID(user.getID());
userDeptRole.setDeptID("-1");
userDeptRole.setRoleID("freedom");
userDeptRole.setCreateTime(new Date());
userMapper.insert(user);
userInfoMapper.insert(userInfo);
userDeptRoleMapper.insert(userDeptRole);
return resultDomain;
} catch (Exception e) {
logger.error("注册用户失败：{}", user.getUsername(), e);
resultDomain.fail("注册用户失败：" + e.getMessage());
return resultDomain;
}
}
@Override
public ResultDomain<Boolean> checkUserExists(TbSysUser user) {
ResultDomain<Boolean> resultDomain = new ResultDomain<>();
try {
logger.info("开始检查用户是否已存在：{}", user.getUsername());
} catch (Exception e) {
logger.error("检查用户是否已存在失败：{}", user.getUsername(), e);
resultDomain.fail("检查用户是否已存在失败：" + e.getMessage());
return resultDomain;
}
return resultDomain;
}
@Override
public ResultDomain<TbSysUser> getAllUsers() {
ResultDomain<TbSysUser> resultDomain = new ResultDomain<>();
@@ -514,6 +576,9 @@ public class SysUserServiceImpl implements SysUserService {
}
}
// ----------------用户信息相关--------------------------------
@Override
public ResultDomain<TbSysUserInfo> getUserInfoById(String userId) {
ResultDomain<TbSysUserInfo> resultDomain = new ResultDomain<>();
@@ -543,4 +608,37 @@ public class SysUserServiceImpl implements SysUserService {
}
}
}
@Override
public ResultDomain<TbSysUserInfo> updateUserInfo(TbSysUserInfo userInfo) {
ResultDomain<TbSysUserInfo> resultDomain = new ResultDomain<>();
try {
logger.info("开始更新用户信息：{}", userInfo.getUserID());
if (!StringUtils.hasText(userInfo.getUserID())) {
resultDomain.fail("用户ID不能为空");
return resultDomain;
}
userInfo.setUpdateTime(new Date());
int result = userMapper.updateUserInfo(userInfo);
if (result > 0) {
logger.info("更新用户信息成功：{}", userInfo.getUserID());
TbSysUserInfo newUserInfo = userMapper.selectUserInfoById(userInfo.getUserID());
resultDomain.success("更新用户信息成功", newUserInfo);
return resultDomain;
} else {
logger.warn("更新用户信息失败：{}", userInfo.getUserID());
resultDomain.fail("更新用户信息失败");
return resultDomain;
}
} catch (Exception e) {
logger.error("更新用户信息异常：{}", userInfo.getUserID(), e);
resultDomain.fail("更新用户信息失败：" + e.getMessage());
return resultDomain;
}
}
}

219
schoolNewsServ/system/src/main/java/org/xyzh/system/utils/LoginUtil.java Normal file
View File

@@ -0,0 +1,219 @@
package org.xyzh.system.utils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.xyzh.common.core.domain.LoginDomain;
import org.xyzh.common.core.security.TokenParser;
import org.xyzh.common.dto.user.TbSysUser;
import org.xyzh.common.dto.user.TbSysUserInfo;
import org.xyzh.common.redis.service.RedisService;
import org.xyzh.common.utils.NonUtils;
import org.xyzh.common.utils.ServletUtil;
/**
* @description LoginUtil.java文件描述 登录信息工具类
* @filename LoginUtil.java
* @author yslg
* @copyright xyzh
* @since 2025-10-07
*/
@Component
public class LoginUtil {
private static final String REDIS_LOGIN_PREFIX = "login:token:";
private static TokenParser tokenParser;
private static RedisService redisService;
@Autowired
public void setTokenParser(TokenParser tokenParser) {
LoginUtil.tokenParser = tokenParser;
}
@Autowired
public void setRedisService(RedisService redisService) {
LoginUtil.redisService = redisService;
}
/**
* @description 获取当前请求的LoginDomain（无参方法）
* @return LoginDomain 当前登录用户信息，未登录或登录过期返回null
* @author yslg
* @since 2025-10-07
*/
public static LoginDomain getCurrentLoginDomain() {
try {
// 从当前请求获取token
String token = ServletUtil.getToken();
if (NonUtils.isEmpty(token)) {
return null;
}
// 验证token
String userId = tokenParser.getUserIdFromToken(token);
if (NonUtils.isEmpty(userId) || !tokenParser.validateToken(token, userId)) {
return null;
}
// 从Redis获取LoginDomain
String redisKey = REDIS_LOGIN_PREFIX + userId;
LoginDomain loginDomain = (LoginDomain) redisService.get(redisKey);
if (loginDomain != null) {
// 更新token信息
loginDomain.setToken(token);
}
return loginDomain;
} catch (Exception e) {
// 记录日志但不抛出异常，返回null表示未登录
return null;
}
}
/**
* @description 获取当前登录用户
* @return TbSysUser 当前登录用户，未登录返回null
* @author yslg
* @since 2025-10-07
*/
public static TbSysUser getCurrentUser() {
LoginDomain loginDomain = getCurrentLoginDomain();
return loginDomain != null ? loginDomain.getUser() : null;
}
/**
* @description 获取当前登录用户详细信息
* @return TbSysUserInfo 当前登录用户详细信息，未登录返回null
* @author yslg
* @since 2025-10-07
*/
public static TbSysUserInfo getCurrentUserInfo() {
LoginDomain loginDomain = getCurrentLoginDomain();
return loginDomain != null ? loginDomain.getUserInfo() : null;
}
/**
* @description 获取当前登录用户ID
* @return String 用户ID，未登录返回null
* @author yslg
* @since 2025-10-07
*/
public static String getCurrentUserId() {
TbSysUser user = getCurrentUser();
return user != null ? user.getID() : null;
}
/**
* @description 获取当前登录用户名
* @return String 用户名，未登录返回null
* @author yslg
* @since 2025-10-07
*/
public static String getCurrentUsername() {
TbSysUser user = getCurrentUser();
return user != null ? user.getUsername() : null;
}
/**
* @description 获取当前登录用户邮箱
* @return String 邮箱，未登录返回null
* @author yslg
* @since 2025-10-07
*/
public static String getCurrentUserEmail() {
TbSysUser user = getCurrentUser();
return user != null ? user.getEmail() : null;
}
/**
* @description 获取当前登录用户手机号
* @return String 手机号，未登录返回null
* @author yslg
* @since 2025-10-07
*/
public static String getCurrentUserPhone() {
TbSysUser user = getCurrentUser();
return user != null ? user.getPhone() : null;
}
/**
* @description 检查当前用户是否已登录
* @return boolean true-已登录，false-未登录
* @author yslg
* @since 2025-10-07
*/
public static boolean isLoggedIn() {
return getCurrentLoginDomain() != null;
}
/**
* @description 检查当前用户是否具有指定权限
* @param permissionCode 权限编码
* @return boolean true-有权限，false-无权限
* @author yslg
* @since 2025-10-07
*/
public static boolean hasPermission(String permissionCode) {
LoginDomain loginDomain = getCurrentLoginDomain();
if (loginDomain == null || loginDomain.getPermissions() == null) {
return false;
}
return loginDomain.getPermissions().stream()
.anyMatch(permission -> permissionCode.equals(permission.getCode()));
}
/**
* @description 检查当前用户是否具有任意一个指定权限
* @param permissionCodes 权限编码数组
* @return boolean true-有任意一个权限，false-无权限
* @author yslg
* @since 2025-10-07
*/
public static boolean hasAnyPermission(String... permissionCodes) {
if (permissionCodes == null || permissionCodes.length == 0) {
return false;
}
for (String permissionCode : permissionCodes) {
if (hasPermission(permissionCode)) {
return true;
}
}
return false;
}
/**
* @description 检查当前用户是否具有所有指定权限
* @param permissionCodes 权限编码数组
* @return boolean true-有所有权限，false-缺少权限
* @author yslg
* @since 2025-10-07
*/
public static boolean hasAllPermissions(String... permissionCodes) {
if (permissionCodes == null || permissionCodes.length == 0) {
return true;
}
for (String permissionCode : permissionCodes) {
if (!hasPermission(permissionCode)) {
return false;
}
}
return true;
}
/**
* @description 获取当前用户的JWT令牌
* @return String JWT令牌，未登录返回null
* @author yslg
* @since 2025-10-07
*/
public static String getCurrentToken() {
return ServletUtil.getToken();
}
}

7
schoolNewsServ/system/src/main/resources/mapper/MenuMapper.xml
View File

@@ -168,4 +168,11 @@
WHERE id = #{id} AND deleted = 0
</update>
<!-- 检查菜单是否存在 -->
<select id="checkMenuExists">
SELECT * FROM tb_sys_menu WHERE id IN
<foreach collection="menuIds" item="menuId" open="(" separator="," close=")">
#{menuId}
</foreach>
</select>
</mapper>

89
schoolNewsServ/system/src/main/resources/mapper/MenuPermissionMapper.xml Normal file
View File

@@ -0,0 +1,89 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="org.xyzh.system.mapper.MenuPermissionMapper">
<!-- 基础结果映射 -->
<resultMap id="BaseResultMap" type="org.xyzh.common.dto.menu.TbSysMenuPermission">
<id column="id" property="id" jdbcType="VARCHAR"/>
<result column="menu_id" property="menuID" jdbcType="VARCHAR"/>
<result column="permission_id" property="permissionID" jdbcType="VARCHAR"/>
<result column="creator" property="creator" jdbcType="VARCHAR"/>
<result column="updater" property="updater" jdbcType="VARCHAR"/>
<result column="create_time" property="createTime" jdbcType="TIMESTAMP"/>
<result column="update_time" property="updateTime" jdbcType="TIMESTAMP"/>
<result column="delete_time" property="deleteTime" jdbcType="TIMESTAMP"/>
<result column="deleted" property="deleted" jdbcType="BOOLEAN"/>
</resultMap>
<!-- 基础字段 -->
<sql id="Base_Column_List">
id, menu_id, permission_id, creator, updater,
create_time, update_time, delete_time, deleted
</sql>
<!-- 批量绑定菜单权限 -->
<insert id="batchBindMenuPermission">
INSERT INTO tb_sys_menu_permission (id, menu_id, permission_id, creator, create_time, deleted)
VALUES
<foreach collection="menuPermissions" item="menuPermission" separator=",">
(#{menuPermission.id}, #{menuPermission.menuID}, #{menuPermission.permissionID}, #{menuPermission.creator}, #{menuPermission.createTime}, 0)
</foreach>
</insert>
<!-- 批量解绑菜单权限（真删除） -->
<delete id="batchUnbindMenuPermission">
DELETE FROM tb_sys_menu_permission
WHERE menu_id IN
<foreach collection="menuPermissions" item="menuPermission" open="(" separator="," close=")">
#{menuPermission.menuID}
</foreach>
AND permission_id IN
<foreach collection="menuPermissions" item="menuPermission" open="(" separator="," close=")">
#{menuPermission.permissionID}
</foreach>
AND deleted = 0
</delete>
<!-- 根据菜单ID和权限ID查询关联关系 -->
<select id="selectByMenuIdAndPermissionId" resultMap="BaseResultMap">
SELECT
<include refid="Base_Column_List"/>
FROM tb_sys_menu_permission
WHERE deleted = 0
AND menu_id = #{menuId}
AND permission_id = #{permissionId}
LIMIT 1
</select>
<!-- 根据菜单ID查询权限关联列表 -->
<select id="selectByMenuId" resultMap="BaseResultMap">
SELECT
<include refid="Base_Column_List"/>
FROM tb_sys_menu_permission
WHERE deleted = 0
AND menu_id = #{menuId}
ORDER BY create_time ASC
</select>
<!-- 根据权限ID查询菜单关联列表 -->
<select id="selectByPermissionId" resultMap="BaseResultMap">
SELECT
<include refid="Base_Column_List"/>
FROM tb_sys_menu_permission
WHERE deleted = 0
AND permission_id = #{permissionId}
ORDER BY create_time ASC
</select>
<!-- 删除菜单权限关联（逻辑删除） -->
<update id="deleteByMenuIdAndPermissionId">
UPDATE tb_sys_menu_permission
SET deleted = 1,
delete_time = NOW(),
updater = #{updater}
WHERE deleted = 0
AND menu_id = #{menuId}
AND permission_id = #{permissionId}
</update>
</mapper>

42
schoolNewsServ/system/src/main/resources/mapper/PermissionMapper.xml
View File

@@ -33,12 +33,6 @@
<if test="code != null and code != ''">
AND code = #{code}
</if>
<if test="permissionType != null">
AND permission_type = #{permissionType}
</if>
<if test="status != null">
AND status = #{status}
</if>
</where>
</sql>
@@ -73,32 +67,32 @@
</select>
<!-- 根据权限编码查询权限 -->
<select id="selectBycode" resultMap="BaseResultMap">
<select id="selectByPermissionCode" resultMap="BaseResultMap">
SELECT
<include refid="Base_Column_List"/>
FROM tb_sys_permission
WHERE deleted = 0
AND code = #{code}
AND code = #{permissionCode}
LIMIT 1
</select>
<!-- 检查权限名称是否存在 -->
<select id="countByname" resultType="int">
<select id="countByPermissionName" resultType="int">
SELECT COUNT(1)
FROM tb_sys_permission
WHERE deleted = 0
AND name = #{name}
AND name = #{permissionName}
<if test="excludeId != null and excludeId != ''">
AND id != #{excludeId}
</if>
</select>
<!-- 检查权限编码是否存在 -->
<select id="countBycode" resultType="int">
<select id="countByPermissionCode" resultType="int">
SELECT COUNT(1)
FROM tb_sys_permission
WHERE deleted = 0
AND code = #{code}
AND code = #{permissionCode}
<if test="excludeId != null and excludeId != ''">
AND id != #{excludeId}
</if>
@@ -125,11 +119,7 @@
<if test="permissionID != null">permission_id,</if>
<if test="name != null">name,</if>
<if test="code != null">code,</if>
<if test="permissionType != null">permission_type,</if>
<if test="resourceUrl != null">resource_url,</if>
<if test="httpMethod != null">http_method,</if>
<if test="description != null">description,</if>
<if test="status != null">status,</if>
<if test="creator != null">creator,</if>
<if test="createTime != null">create_time,</if>
deleted
@@ -139,11 +129,7 @@
<if test="permissionID != null">#{permissionID},</if>
<if test="name != null">#{name},</if>
<if test="code != null">#{code},</if>
<if test="permissionType != null">#{permissionType},</if>
<if test="resourceUrl != null">#{resourceUrl},</if>
<if test="httpMethod != null">#{httpMethod},</if>
<if test="description != null">#{description},</if>
<if test="status != null">#{status},</if>
<if test="creator != null">#{creator},</if>
<if test="createTime != null">#{createTime},</if>
0
@@ -157,11 +143,7 @@
<if test="permissionID != null">permission_id = #{permissionID},</if>
<if test="name != null">name = #{name},</if>
<if test="code != null">code = #{code},</if>
<if test="permissionType != null">permission_type = #{permissionType},</if>
<if test="resourceUrl != null">resource_url = #{resourceUrl},</if>
<if test="httpMethod != null">http_method = #{httpMethod},</if>
<if test="description != null">description = #{description},</if>
<if test="status != null">status = #{status},</if>
<if test="updater != null">updater = #{updater},</if>
update_time = NOW()
</set>
@@ -176,4 +158,16 @@
WHERE id = #{id} AND deleted = 0
</update>
<!-- checkPermissionExists -->
<select id="checkPermissionExists">
SELECT
<include refid="Base_Column_List"/>
FROM tb_sys_permission
WHERE deleted = 0
AND permission_id IN
<foreach collection="permissionIds" item="permissionId" open="(" separator="," close=")">
#{permissionId}
</foreach>
</select>
</mapper>

12
schoolNewsServ/system/src/main/resources/mapper/RoleMapper.xml
View File

@@ -177,4 +177,16 @@
WHERE id = #{id} AND deleted = 0
</update>
<!-- checkRoleExists -->
<select id="checkRoleExists">
SELECT
<include refid="TbSysRole_Column_List"/>
FROM tb_sys_role
WHERE deleted = 0
AND role_id IN
<foreach collection="roleIds" item="roleId" open="(" separator="," close=")">
#{roleId}
</foreach>
</select>
</mapper>

89
schoolNewsServ/system/src/main/resources/mapper/RolePermissionMapper.xml Normal file
View File

@@ -0,0 +1,89 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="org.xyzh.system.mapper.RolePermissionMapper">
<!-- 基础结果映射 -->
<resultMap id="BaseResultMap" type="org.xyzh.common.dto.role.TbSysRolePermission">
<id column="id" property="id" jdbcType="VARCHAR"/>
<result column="role_id" property="roleID" jdbcType="VARCHAR"/>
<result column="permission_id" property="permissionID" jdbcType="VARCHAR"/>
<result column="creator" property="creator" jdbcType="VARCHAR"/>
<result column="updater" property="updater" jdbcType="VARCHAR"/>
<result column="create_time" property="createTime" jdbcType="TIMESTAMP"/>
<result column="update_time" property="updateTime" jdbcType="TIMESTAMP"/>
<result column="delete_time" property="deleteTime" jdbcType="TIMESTAMP"/>
<result column="deleted" property="deleted" jdbcType="BOOLEAN"/>
</resultMap>
<!-- 基础字段 -->
<sql id="Base_Column_List">
id, role_id, permission_id, creator, updater,
create_time, update_time, delete_time, deleted
</sql>
<!-- 批量绑定角色权限 -->
<insert id="batchBindRolePermission">
INSERT INTO tb_sys_role_permission (id, role_id, permission_id, creator, create_time, deleted)
VALUES
<foreach collection="rolePermissions" item="rolePermission" separator=",">
(#{rolePermission.id}, #{rolePermission.roleID}, #{rolePermission.permissionID}, #{rolePermission.creator}, #{rolePermission.createTime}, 0)
</foreach>
</insert>
<!-- 批量解绑角色权限（真删除,避免批量绑定时报错存在的问题） -->
<delete id="batchUnbindRolePermission">
DELETE FROM tb_sys_role_permission
WHERE role_id IN
<foreach collection="rolePermissions" item="rolePermission" open="(" separator="," close=")">
#{rolePermission.roleID}
</foreach>
AND permission_id IN
<foreach collection="rolePermissions" item="rolePermission" open="(" separator="," close=")">
#{rolePermission.permissionID}
</foreach>
AND deleted = 0
</delete>
<!-- 根据角色ID和权限ID查询关联关系 -->
<select id="selectByRoleIdAndPermissionId" resultMap="BaseResultMap">
SELECT
<include refid="Base_Column_List"/>
FROM tb_sys_role_permission
WHERE deleted = 0
AND role_id = #{rolePermission.roleID}
AND permission_id = #{rolePermission.permissionID}
LIMIT 1
</select>
<!-- 根据角色ID查询权限关联列表 -->
<select id="selectByRoleId" resultMap="BaseResultMap">
SELECT
<include refid="Base_Column_List"/>
FROM tb_sys_role_permission
WHERE deleted = 0
AND role_id = #{rolePermission.roleID}
ORDER BY create_time ASC
</select>
<!-- 根据权限ID查询角色关联列表 -->
<select id="selectByPermissionId" resultMap="BaseResultMap">
SELECT
<include refid="Base_Column_List"/>
FROM tb_sys_role_permission
WHERE deleted = 0
AND permission_id = #{rolePermission.permissionID}
ORDER BY create_time ASC
</select>
<!-- 删除角色权限关联（逻辑删除） -->
<update id="deleteByRoleIdAndPermissionId">
UPDATE tb_sys_role_permission
SET deleted = 1,
delete_time = NOW(),
updater = #{updater}
WHERE deleted = 0
AND role_id = #{rolePermission.roleID}
AND permission_id = #{rolePermission.permissionID}
</update>
</mapper>

4
schoolNewsServ/system/src/main/resources/mapper/UserDeptRoleMapper.xml Normal file
View File

@@ -0,0 +1,4 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="org.xyzh.system.mapper.UserDeptRoleMapper">
</mapper>

5
schoolNewsServ/system/src/main/resources/mapper/UserInfoMapper.xml Normal file
View File

@@ -0,0 +1,5 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="org.xyzh.system.mapper.UserInfoMapper">
</mapper>

39
schoolNewsServ/system/src/main/resources/mapper/UserMapper.xml
View File

@@ -78,16 +78,6 @@
LIMIT 1
</select>
<!-- 根据用户ID查询用户信息 -->
<select id="selectUserInfoById" resultMap="UserInfoResultMap">
SELECT
<include refid="UserInfo_Column_List"/>
FROM tb_sys_user_info
WHERE deleted = 0
AND user_id = #{userId}
LIMIT 1
</select>
<!-- 根据邮箱查询用户 -->
<select id="selectByEmail" resultMap="BaseResultMap">
SELECT
@@ -227,4 +217,33 @@
WHERE id = #{id} AND deleted = 0
</update>
<!-- 用户信息相关 -->
<!-- 根据用户ID查询用户信息 -->
<select id="selectUserInfoById" resultMap="UserInfoResultMap">
SELECT
<include refid="UserInfo_Column_List"/>
FROM tb_sys_user_info
WHERE deleted = 0
AND user_id = #{userId}
LIMIT 1
</select>
<!-- 更新用户信息 -->
<update id="updateUserInfo">
UPDATE tb_sys_user_info
<set>
<if test="userInfo.avatar != null">avatar = #{userInfo.avatar},</if>
<if test="userInfo.gender != null">gender = #{userInfo.gender},</if>
<if test="userInfo.familyName != null">family_name = #{userInfo.familyName},</if>
<if test="userInfo.givenName != null">given_name = #{userInfo.givenName},</if>
<if test="userInfo.fullName != null">full_name = #{userInfo.fullName},</if>
<if test="userInfo.idCard != null">id_card = #{userInfo.idCard},</if>
<if test="userInfo.address != null">address = #{userInfo.address},</if>
<if test="userInfo.updateTime != null">update_time = #{userInfo.updateTime}</if>
<if test="userInfo.updateTime == null">update_time = NOW() </if>
</set>
WHERE user_id = #{userInfo.userID} AND deleted = 0
</update>
</mapper>