zhouhui.jiang / test_cursor

Go to a project
Toggle navigation Toggle navigation pinning
zhouhui.jiang
0b10de4b 1 parent 3e35a6ed

初始化代码

Expand all
Inline Side-by-side
Showing 167 changed files with 4857 additions and 0 deletions
# Apple经销商ERP系统 - 后端项目
## 项目简介
这是Apple经销商ERP系统的后端服务，基于Spring Boot框架开发，提供RESTful API接口。
## 技术栈
- **框架**: Spring Boot 2.7.x
- **数据库**: MySQL 8.0
- **缓存**: Redis 6.0
- **ORM**: MyBatis Plus 3.5.x
- **安全**: Spring Security + JWT
- **构建工具**: Maven 3.8.x
- **JDK版本**: OpenJDK 8
## 项目结构
```
backend/
├── src/
│ ├── main/
│ │ ├── java/
│ │ │ └── com/apple/erp/
│ │ │ ├── AppleErpApplication.java
│ │ │ ├── config/ # 配置类
│ │ │ ├── controller/ # 控制器层
│ │ │ ├── service/ # 服务层
│ │ │ ├── mapper/ # 数据访问层
│ │ │ ├── entity/ # 实体类
│ │ │ ├── dto/ # 数据传输对象
│ │ │ ├── vo/ # 视图对象
│ │ │ ├── utils/ # 工具类
│ │ │ ├── exception/ # 异常处理
│ │ │ ├── aspect/ # 切面
│ │ │ └── enums/ # 枚举类
│ │ └── resources/
│ │ ├── application.yml # 主配置文件
│ │ ├── mapper/ # MyBatis映射文件
│ │ ├── static/ # 静态资源
│ │ └── templates/ # 模板文件
│ └── test/ # 测试代码
├── target/ # 编译输出目录
├── pom.xml # Maven配置文件
└── README.md # 项目说明
```
## 核心功能模块
### 系统管理模块
- 用户管理 (SysUser)
- 角色管理 (SysRole)
- 菜单管理 (SysMenu)
- 字典管理 (SysDict)
- 日志管理 (SysLog)
### 业务功能模块
- 订单管理 (Order)
- 出库管理 (Delivery)
- 发票管理 (Invoice)
- 返利管理 (Rebate)
- 异常处理 (Exception)
- 产品管理 (Product)
- 经销商管理 (Dealer)
## 开发规范
### 代码规范
- 遵循阿里巴巴Java开发手册
- 使用统一的代码格式化配置
- 类名使用大驼峰命名
- 方法名和变量名使用小驼峰命名
- 常量使用全大写下划线分隔
### 接口规范
- RESTful API设计
- 统一返回格式
- 统一异常处理
- 接口文档使用Swagger
### 数据库规范
- 表名使用下划线分隔
- 字段名使用下划线分隔
- 主键统一使用id
- 创建时间字段：create_time
- 更新时间字段：update_time
- 逻辑删除字段：deleted
## 环境配置
### 开发环境
```yaml
spring:
datasource:
url: jdbc:mysql://localhost:3306/apple_erp?useUnicode=true&characterEncoding=utf8&serverTimezone=Asia/Shanghai
username: root
password: MySQL@123
driver-class-name: com.mysql.cj.jdbc.Driver
```
### 测试环境
```yaml
spring:
datasource:
url: jdbc:mysql://test-server:3306/apple_erp?useUnicode=true&characterEncoding=utf8&serverTimezone=Asia/Shanghai
username: test_user
password: test_password
driver-class-name: com.mysql.cj.jdbc.Driver
```
### 生产环境
```yaml
spring:
datasource:
url: jdbc:mysql://prod-server:3306/apple_erp?useUnicode=true&characterEncoding=utf8&serverTimezone=Asia/Shanghai
username: prod_user
password: ${DB_PASSWORD}
driver-class-name: com.mysql.cj.jdbc.Driver
```
## 快速开始
### 1. 环境准备
- 安装JDK 8+
- 安装Maven 3.8+
- 安装MySQL 8.0+
- 安装Redis 6.0+
### 2. 数据库初始化
```bash
# 创建数据库
mysql -u root -p < ../database/scripts/init/01_create_database.sql
# 创建表结构
mysql -u root -p apple_erp < ../database/scripts/init/02_create_tables.sql
# 初始化数据
mysql -u root -p apple_erp < ../database/scripts/data/01_init_system_data.sql
```
### 3. 启动服务
```bash
# 编译项目
mvn clean compile
# 运行测试
mvn test
# 启动服务
mvn spring-boot:run
```
### 4. 访问接口
- 服务地址: http://localhost:8083
- API文档: http://localhost:8083/swagger-ui.html
- 健康检查: http://localhost:8083/actuator/health
## 开发指南
### 1. 新增业务模块
1. 创建Entity实体类
2. 创建Mapper接口和XML文件
3. 创建Service接口和实现类
4. 创建Controller控制器
5. 创建DTO和VO类
6. 编写单元测试
### 2. 数据库操作
- 使用MyBatis Plus进行数据库操作
- 复杂查询使用XML映射文件
- 简单CRUD使用注解方式
### 3. 异常处理
- 使用全局异常处理器
- 自定义业务异常类
- 统一错误码定义
### 4. 日志记录
- 使用SLF4J + Logback
- 操作日志使用AOP记录
- 错误日志记录详细堆栈信息
## 测试
### 单元测试
```bash
mvn test
```
### 集成测试
```bash
mvn verify
```
### 性能测试
```bash
mvn test -Dtest=PerformanceTest
```
## 部署
### Docker部署
```bash
# 构建镜像
docker build -t apple-erp-backend .
# 运行容器
docker run -d -p 8083:8083 apple-erp-backend
```
### 传统部署
```bash
# 打包
mvn clean package
# 运行
java -jar target/apple-erp-backend.jar
```
## 监控
### 健康检查
- Spring Boot Actuator
- 自定义健康检查指标
### 日志监控
- 应用日志
- 访问日志
- 错误日志
### 性能监控
- JVM监控
- 数据库监控
- 接口性能监控
## 常见问题
### 1. 数据库连接问题
- 检查数据库服务是否启动
- 检查连接配置是否正确
- 检查网络连接是否正常
### 2. Redis连接问题
- 检查Redis服务是否启动
- 检查连接配置是否正确
- 检查防火墙设置
### 3. 端口占用问题
- 检查端口是否被占用
- 修改配置文件中的端口号
- 停止占用端口的进程
## 更新日志
### v1.0.0 (2024-01-01)
- 初始版本发布
- 基础功能模块完成
- 系统管理模块完成
## 贡献指南
1. Fork项目
2. 创建功能分支
3. 提交代码
4. 创建Pull Request
## 许可证
MIT License
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.7.18</version>
<relativePath/>
</parent>
<groupId>com.apple</groupId>
<artifactId>apple-erp-backend</artifactId>
<version>1.0.0</version>
<name>Apple经销商ERP系统后端</name>
<description>Apple经销商ERP系统后端服务</description>
<packaging>jar</packaging>
<properties>
<java.version>8</java.version>
<maven.compiler.source>8</maven.compiler.source>
<maven.compiler.target>8</maven.compiler.target>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
<!-- 依赖版本管理 -->
<mybatis-plus.version>3.5.3.1</mybatis-plus.version>
<druid.version>1.2.18</druid.version>
<jwt.version>0.11.5</jwt.version>
<hutool.version>5.8.20</hutool.version>
<fastjson.version>2.0.32</fastjson.version>
<poi.version>5.2.3</poi.version>
<knife4j.version>3.0.3</knife4j.version>
<springdoc.version>1.7.0</springdoc.version>
</properties>
<dependencies>
<!-- Spring Boot Web Starter -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<!-- Spring Boot Security Starter -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-security</artifactId>
</dependency>
<!-- Spring Boot Validation Starter -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-validation</artifactId>
</dependency>
<!-- Spring Boot Data Redis Starter -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<!-- Spring Boot AOP Starter -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-aop</artifactId>
</dependency>
<!-- Spring Boot Mail Starter -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-mail</artifactId>
</dependency>
<!-- Spring Boot Quartz Starter -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-quartz</artifactId>
</dependency>
<!-- MySQL Driver -->
<dependency>
<groupId>com.mysql</groupId>
<artifactId>mysql-connector-j</artifactId>
<scope>runtime</scope>
</dependency>
<!-- H2 Database for testing -->
<dependency>
<groupId>com.h2database</groupId>
<artifactId>h2</artifactId>
<scope>runtime</scope>
</dependency>
<!-- Druid 数据库连接池 -->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid-spring-boot-starter</artifactId>
<version>${druid.version}</version>
</dependency>
<!-- MyBatis Plus -->
<dependency>
<groupId>com.baomidou</groupId>
<artifactId>mybatis-plus-boot-starter</artifactId>
<version>${mybatis-plus.version}</version>
</dependency>
<!-- MyBatis Plus 代码生成器 -->
<dependency>
<groupId>com.baomidou</groupId>
<artifactId>mybatis-plus-generator</artifactId>
<version>${mybatis-plus.version}</version>
</dependency>
<!-- JWT -->
<dependency>
<groupId>io.jsonwebtoken</groupId>
<artifactId>jjwt-api</artifactId>
<version>${jwt.version}</version>
</dependency>
<dependency>
<groupId>io.jsonwebtoken</groupId>
<artifactId>jjwt-impl</artifactId>
<version>${jwt.version}</version>
<scope>runtime</scope>
</dependency>
<dependency>
<groupId>io.jsonwebtoken</groupId>
<artifactId>jjwt-jackson</artifactId>
<version>${jwt.version}</version>
<scope>runtime</scope>
</dependency>
<!-- Hutool 工具类 -->
<dependency>
<groupId>cn.hutool</groupId>
<artifactId>hutool-all</artifactId>
<version>${hutool.version}</version>
</dependency>
<!-- FastJSON -->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>${fastjson.version}</version>
</dependency>
<!-- Apache POI Excel处理 -->
<dependency>
<groupId>org.apache.poi</groupId>
<artifactId>poi</artifactId>
<version>${poi.version}</version>
</dependency>
<dependency>
<groupId>org.apache.poi</groupId>
<artifactId>poi-ooxml</artifactId>
<version>${poi.version}</version>
</dependency>
<!-- Knife4j API文档 - 暂时移除 -->
<!-- <dependency>
<groupId>com.github.xiaoymin</groupId>
<artifactId>knife4j-spring-boot-starter</artifactId>
<version>${knife4j.version}</version>
</dependency> -->
<!-- SpringDoc OpenAPI -->
<dependency>
<groupId>org.springdoc</groupId>
<artifactId>springdoc-openapi-ui</artifactId>
<version>${springdoc.version}</version>
</dependency>
<!-- SpringDoc OpenAPI Security -->
<dependency>
<groupId>org.springdoc</groupId>
<artifactId>springdoc-openapi-security</artifactId>
<version>${springdoc.version}</version>
</dependency>
<!-- Spring Boot Actuator 监控 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
<!-- Lombok -->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<optional>true</optional>
</dependency>
<!-- Spring Boot Test Starter -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
<!-- Spring Security Test -->
<dependency>
<groupId>org.springframework.security</groupId>
<artifactId>spring-security-test</artifactId>
<scope>test</scope>
</dependency>
</dependencies>
<build>
<plugins>
<!-- Spring Boot Maven Plugin -->
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
<version>2.7.18</version>
<configuration>
<excludes>
<exclude>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
</exclude>
</excludes>
</configuration>
</plugin>
<!-- Maven Compiler Plugin -->
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.8.1</version>
<configuration>
<source>8</source>
<target>8</target>
<encoding>UTF-8</encoding>
</configuration>
</plugin>
<!-- Maven Surefire Plugin -->
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-surefire-plugin</artifactId>
<version>2.22.2</version>
<configuration>
<skipTests>false</skipTests>
</configuration>
</plugin>
</plugins>
</build>
<!-- 仓库配置 -->
<repositories>
<repository>
<id>central</id>
<name>Central Repository</name>
<url>https://repo1.maven.org/maven2</url>
</repository>
<repository>
<id>aliyun</id>
<name>Aliyun Repository</name>
<url>https://maven.aliyun.com/repository/public</url>
</repository>
</repositories>
<pluginRepositories>
<pluginRepository>
<id>central</id>
<name>Central Repository</name>
<url>https://repo1.maven.org/maven2</url>
</pluginRepository>
<pluginRepository>
<id>aliyun</id>
<name>Aliyun Repository</name>
<url>https://maven.aliyun.com/repository/public</url>
</pluginRepository>
</pluginRepositories>
</project>
package com.apple.erp;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.transaction.annotation.EnableTransactionManagement;
/**
* Apple经销商ERP系统启动类
*
* @author Apple ERP Team
* @version 1.0.0
* @since 2024-01-01
*/
@SpringBootApplication
@EnableTransactionManagement
@EnableCaching
@EnableAsync
@EnableScheduling
public class AppleErpApplication {
public static void main(String[] args) {
// 设置系统属性
System.setProperty("spring.devtools.restart.enabled", "false");
System.setProperty("spring.devtools.livereload.enabled", "false");
// 启动Spring Boot应用
SpringApplication.run(AppleErpApplication.class, args);
System.out.println("=================================");
System.out.println("Apple经销商ERP系统启动成功！");
System.out.println("访问地址: http://localhost:8083");
System.out.println("API文档: http://localhost:8083/doc.html");
System.out.println("数据库监控: http://localhost:8083/druid");
System.out.println("=================================");
}
}
# Apple经销商ERP系统 - 数据库认证功能说明
## 概述
系统已成功从硬编码认证改为数据库认证，现在支持从数据库读取用户信息、角色和权限进行JWT认证。
## 主要变更
### 1. 新增文件
- `entity/SysUser.java` - 系统用户实体类
- `entity/SysRole.java` - 系统角色实体类
- `mapper/SysUserMapper.java` - 用户数据访问接口
- `service/SysUserService.java` - 用户服务接口
- `service/impl/SysUserServiceImpl.java` - 用户服务实现
- `resources/mapper/SysUserMapper.xml` - MyBatis映射文件
### 2. 修改文件
- `config/UserDetailsServiceImpl.java` - 改为从数据库读取用户信息
- `controller/AuthController.java` - 添加登录信息记录功能
## 功能特性
### 1. 数据库认证
- ✅ 从`t_sys_user`表读取用户信息
- ✅ 支持BCrypt密码加密验证
- ✅ 动态角色和权限管理
- ✅ 用户状态检查（启用/停用）
### 2. 权限管理
- ✅ 从`t_sys_role`表获取用户角色
- ✅ 从`t_sys_menu`表获取菜单权限
- ✅ 支持角色-菜单关联权限
- ✅ 动态权限加载
### 3. 登录记录
- ✅ 记录用户最后登录时间
- ✅ 记录用户最后登录IP
- ✅ 支持获取客户端真实IP
## 默认账号
| 用户名 | 密码 | 角色 | 权限说明 |
|--------|------|------|----------|
| admin | admin123 | 系统管理员 | 拥有所有权限 |
| operator | operator123 | 运营人员 | 拥有业务操作权限 |
| auditor | auditor123 | 审核人员 | 拥有审核权限 |
## 数据库表结构
### 核心表
- `t_sys_user` - 系统用户表
- `t_sys_role` - 系统角色表
- `t_sys_user_role` - 用户角色关联表
- `t_sys_menu` - 系统菜单表
- `t_sys_role_menu` - 角色菜单关联表
### 认证流程
1. 用户登录时，系统从`t_sys_user`表查询用户信息
2. 验证BCrypt加密的密码
3. 查询用户关联的角色信息
4. 查询角色关联的菜单权限
5. 构建Spring Security的UserDetails对象
6. 生成JWT令牌
## API接口
### 登录接口
```http
POST /api/auth/login
Content-Type: application/json
{
"username": "admin",
"password": "admin123"
}
```
### 响应示例
```json
{
"code": 200,
"message": "登录成功",
"data": {
"token": "eyJhbGciOiJIUzUxMiJ9...",
"refreshToken": "eyJhbGciOiJIUzUxMiJ9...",
"username": "admin"
}
}
```
## 测试方法
### 1. 数据库测试
执行测试脚本验证数据库结构：
```sql
-- 执行测试脚本
source database/scripts/05_test_database_auth.sql
```
### 2. API测试
使用Postman或curl测试登录接口：
```bash
curl -X POST http://localhost:8080/api/auth/login \
-H "Content-Type: application/json" \
-d '{"username":"admin","password":"admin123"}'
```
### 3. 权限测试
登录后使用JWT令牌访问受保护的接口：
```bash
curl -X GET http://localhost:8080/api/auth/userinfo \
-H "Authorization: Bearer YOUR_JWT_TOKEN"
```
## 配置说明
### 1. 数据库配置
确保`application.yml`中配置了正确的数据库连接：
```yaml
spring:
datasource:
url: jdbc:mysql://localhost:3306/apple_erp
username: apple_erp
password: apple_erp123
```
### 2. MyBatis配置
确保`application.yml`中配置了MyBatis映射文件路径：
```yaml
mybatis-plus:
mapper-locations: classpath:mapper/*.xml
```
## 安全特性
### 1. 密码安全
- 使用BCrypt加密存储密码
- 支持密码强度验证
- 防止密码明文存储
### 2. 权限控制
- 基于角色的访问控制(RBAC)
- 细粒度权限管理
- 动态权限加载
### 3. 会话管理
- JWT令牌认证
- 令牌过期机制
- 刷新令牌支持
## 故障排除
### 1. 认证失败
- 检查用户名和密码是否正确
- 确认用户状态为启用(status=1)
- 验证数据库连接是否正常
### 2. 权限不足
- 检查用户是否分配了角色
- 确认角色是否关联了菜单权限
- 验证角色和菜单状态是否启用
### 3. 数据库连接问题
- 检查数据库服务是否启动
- 验证连接配置是否正确
- 确认数据库表是否创建完成
## 扩展功能
### 1. 添加新用户
```sql
INSERT INTO t_sys_user (username, real_name, password, phone, email, status, remark, create_by)
VALUES ('newuser', '新用户', '$2a$10$...', '13800138000', 'newuser@example.com', 1, '新用户', 'admin');
```
### 2. 分配角色
```sql
INSERT INTO t_sys_user_role (user_id, role_id, create_by)
VALUES (用户ID, 角色ID, 'admin');
```
### 3. 修改密码
```sql
UPDATE t_sys_user
SET password = '$2a$10$新的BCrypt哈希'
WHERE username = '用户名';
```
## 注意事项
1. **密码加密**: 所有密码必须使用BCrypt加密存储
2. **软删除**: 使用`del_flag`字段进行软删除，不要物理删除数据
3. **状态管理**: 用户和角色都有状态字段，停用后无法登录
4. **权限缓存**: 权限信息在用户登录时加载，修改权限后需要重新登录生效
5. **日志记录**: 系统会记录用户登录时间和IP，便于安全审计
---
**文档版本**: v1.0
**创建时间**: 2025-01-27
**维护人员**: 开发团队
package com.apple.erp.aspect;
import com.apple.erp.service.SysLogService;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
import javax.servlet.http.HttpServletRequest;
import java.time.LocalDateTime;
import java.util.Arrays;
/**
* 操作日志切面
*
* @author Apple ERP Team
* @version 1.0.0
* @since 2024-01-01
*/
@Aspect
@Component
@Slf4j
public class LogAspect {
@Autowired
private SysLogService sysLogService;
@Autowired
private ObjectMapper objectMapper;
/**
* 定义切点：拦截所有Controller层的public方法
*/
@Pointcut("execution(public * com.apple.erp.controller..*(..))")
public void logPointcut() {}
/**
* 环绕通知：记录操作日志
*/
@Around("logPointcut()")
public Object around(ProceedingJoinPoint point) throws Throwable {
long startTime = System.currentTimeMillis();
Object result = null;
Exception exception = null;
try {
result = point.proceed();
} catch (Exception e) {
exception = e;
throw e;
} finally {
long endTime = System.currentTimeMillis();
long executeTime = endTime - startTime;
// 记录操作日志
recordOperationLog(point, result, exception, executeTime);
}
return result;
}
/**
* 记录操作日志
*/
private void recordOperationLog(ProceedingJoinPoint point, Object result, Exception exception, long executeTime) {
try {
// 获取请求信息
ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
if (attributes == null) {
return;
}
HttpServletRequest request = attributes.getRequest();
// 获取用户信息
Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
String username = "anonymous";
Long userId = null;
if (authentication != null && authentication.isAuthenticated() &&
!"anonymousUser".equals(authentication.getName())) {
username = authentication.getName();
// 这里可以根据需要获取用户ID，暂时设为null
userId = null;
}
// 获取方法信息
String className = point.getTarget().getClass().getSimpleName();
String methodName = point.getSignature().getName();
String operation = className + "." + methodName;
// 获取模块信息（从类名推断）
String module = getModuleFromClassName(className);
// 获取请求参数
String requestParam = getRequestParam(point);
// 获取IP地址
String ip = getClientIpAddress(request);
// 判断操作结果
Integer status = exception == null ? 1 : 0;
String errorMsg = exception != null ? exception.getMessage() : null;
// 记录日志
sysLogService.recordLog(
"0", // 操作日志
userId,
username,
module,
operation,
ip,
status,
errorMsg,
requestParam
);
} catch (Exception e) {
log.error("记录操作日志失败", e);
}
}
/**
* 从类名获取模块名
*/
private String getModuleFromClassName(String className) {
if (className.contains("User")) {
return "用户管理";
} else if (className.contains("Role")) {
return "角色管理";
} else if (className.contains("Menu")) {
return "菜单管理";
} else if (className.contains("Dict")) {
return "字典管理";
} else if (className.contains("Log")) {
return "日志管理";
} else if (className.contains("Auth")) {
return "认证管理";
} else {
return "系统管理";
}
}
/**
* 获取请求参数
*/
private String getRequestParam(ProceedingJoinPoint point) {
try {
Object[] args = point.getArgs();
if (args == null || args.length == 0) {
return null;
}
// 过滤掉HttpServletRequest、HttpServletResponse等参数
Object[] filteredArgs = Arrays.stream(args)
.filter(arg -> !isExcludedParam(arg))
.toArray();
if (filteredArgs.length == 0) {
return null;
}
// 如果只有一个参数，直接序列化
if (filteredArgs.length == 1) {
return objectMapper.writeValueAsString(filteredArgs[0]);
} else {
// 多个参数，序列化为数组
return objectMapper.writeValueAsString(filteredArgs);
}
} catch (JsonProcessingException e) {
log.warn("序列化请求参数失败", e);
return "参数序列化失败";
}
}
/**
* 判断是否为需要排除的参数
*/
private boolean isExcludedParam(Object arg) {
if (arg == null) {
return true;
}
String className = arg.getClass().getName();
return className.startsWith("javax.servlet.") ||
className.startsWith("org.springframework.web.") ||
className.startsWith("org.springframework.security.") ||
className.contains("MultipartFile") ||
className.contains("Part");
}
/**
* 获取客户端IP地址
*/
private String getClientIpAddress(HttpServletRequest request) {
String ip = request.getHeader("X-Forwarded-For");
if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
ip = request.getHeader("Proxy-Client-IP");
}
if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
ip = request.getHeader("WL-Proxy-Client-IP");
}
if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
ip = request.getHeader("HTTP_CLIENT_IP");
}
if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
ip = request.getHeader("HTTP_X_FORWARDED_FOR");
}
if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
ip = request.getRemoteAddr();
}
return ip;
}
}
package com.apple.erp.config;
import com.apple.erp.utils.JwtUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.web.authentication.WebAuthenticationDetailsSource;
import org.springframework.stereotype.Component;
import org.springframework.web.filter.OncePerRequestFilter;
import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
/**
* JWT认证过滤器
*
* @author Apple ERP Team
* @version 1.0.0
* @since 2024-01-01
*/
@Component
public class JwtAuthenticationFilter extends OncePerRequestFilter {
@Autowired
private JwtUtils jwtUtils;
@Autowired
private UserDetailsService userDetailsService;
@Override
protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response,
FilterChain filterChain) throws ServletException, IOException {
String authHeader = request.getHeader(jwtUtils.getHeader());
String token = jwtUtils.getTokenFromHeader(authHeader);
if (token != null && SecurityContextHolder.getContext().getAuthentication() == null) {
try {
String username = jwtUtils.getUsernameFromToken(token);
if (username != null && jwtUtils.validateToken(token, username)) {
UserDetails userDetails = userDetailsService.loadUserByUsername(username);
UsernamePasswordAuthenticationToken authentication =
new UsernamePasswordAuthenticationToken(userDetails, null, userDetails.getAuthorities());
authentication.setDetails(new WebAuthenticationDetailsSource().buildDetails(request));
SecurityContextHolder.getContext().setAuthentication(authentication);
}
} catch (Exception e) {
logger.error("JWT认证失败: " + e.getMessage());
}
}
filterChain.doFilter(request, response);
}
}
package com.apple.erp.config;
import com.baomidou.mybatisplus.annotation.DbType;
import com.baomidou.mybatisplus.extension.plugins.MybatisPlusInterceptor;
import com.baomidou.mybatisplus.extension.plugins.inner.PaginationInnerInterceptor;
import com.baomidou.mybatisplus.extension.plugins.inner.OptimisticLockerInnerInterceptor;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
/**
* MyBatis Plus配置类
*
* @author Apple ERP Team
* @version 1.0.0
* @since 2024-01-01
*/
@Configuration
@MapperScan("com.apple.erp.mapper")
public class MybatisPlusConfig {
/**
* MyBatis Plus拦截器配置
*/
@Bean
public MybatisPlusInterceptor mybatisPlusInterceptor() {
MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
// 分页插件
PaginationInnerInterceptor paginationInterceptor = new PaginationInnerInterceptor(DbType.MYSQL);
// 设置最大单页限制数量，默认 500 条，-1 不受限制
paginationInterceptor.setMaxLimit(1000L);
// 设置溢出总页数后是否进行处理
paginationInterceptor.setOverflow(false);
interceptor.addInnerInterceptor(paginationInterceptor);
// 乐观锁插件
interceptor.addInnerInterceptor(new OptimisticLockerInnerInterceptor());
return interceptor;
}
}
package com.apple.erp.config;
import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.jsontype.impl.LaissezFaireSubTypeValidator;
import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheConfiguration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializationContext;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import java.time.Duration;
/**
* Redis配置类
*
* @author Apple ERP Team
* @version 1.0.0
* @since 2024-01-01
*/
@Configuration
@EnableCaching
public class RedisConfig {
/**
* RedisTemplate配置
*/
@Bean
public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory connectionFactory) {
RedisTemplate<String, Object> template = new RedisTemplate<>();
template.setConnectionFactory(connectionFactory);
// 使用Jackson2JsonRedisSerializer来序列化和反序列化redis的value值
Jackson2JsonRedisSerializer<Object> serializer = new Jackson2JsonRedisSerializer<>(Object.class);
ObjectMapper mapper = new ObjectMapper();
mapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
mapper.activateDefaultTyping(LaissezFaireSubTypeValidator.instance, ObjectMapper.DefaultTyping.NON_FINAL);
// 注册Java 8时间模块
mapper.registerModule(new JavaTimeModule());
// 禁用时间戳序列化
mapper.disable(com.fasterxml.jackson.databind.SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);
serializer.setObjectMapper(mapper);
// 使用StringRedisSerializer来序列化和反序列化redis的key值
template.setKeySerializer(new StringRedisSerializer());
template.setValueSerializer(serializer);
// Hash的key也采用StringRedisSerializer的序列化方式
template.setHashKeySerializer(new StringRedisSerializer());
template.setHashValueSerializer(serializer);
template.afterPropertiesSet();
return template;
}
/**
* 缓存管理器配置
*/
@Bean
public CacheManager cacheManager(RedisConnectionFactory connectionFactory) {
// 配置序列化
Jackson2JsonRedisSerializer<Object> cacheSerializer = new Jackson2JsonRedisSerializer<>(Object.class);
ObjectMapper cacheMapper = new ObjectMapper();
cacheMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
cacheMapper.activateDefaultTyping(LaissezFaireSubTypeValidator.instance, ObjectMapper.DefaultTyping.NON_FINAL);
// 注册Java 8时间模块
cacheMapper.registerModule(new JavaTimeModule());
// 禁用时间戳序列化
cacheMapper.disable(com.fasterxml.jackson.databind.SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);
cacheSerializer.setObjectMapper(cacheMapper);
RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
.entryTtl(Duration.ofHours(1)) // 设置缓存有效期1小时
.serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(new StringRedisSerializer()))
.serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(cacheSerializer))
.disableCachingNullValues(); // 不缓存空值
return RedisCacheManager.builder(connectionFactory)
.cacheDefaults(config)
.build();
}
}
\ No newline at end of file
package com.apple.erp.config;
import com.apple.erp.utils.JwtUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.config.annotation.authentication.configuration.AuthenticationConfiguration;
import org.springframework.security.config.annotation.method.configuration.EnableGlobalMethodSecurity;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.http.SessionCreationPolicy;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.web.SecurityFilterChain;
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;
import org.springframework.web.cors.CorsConfiguration;
import org.springframework.web.cors.CorsConfigurationSource;
import org.springframework.web.cors.UrlBasedCorsConfigurationSource;
import java.util.Arrays;
/**
* Spring Security配置类
*
* @author Apple ERP Team
* @version 1.0.0
* @since 2024-01-01
*/
@Configuration
@EnableWebSecurity
@EnableGlobalMethodSecurity(prePostEnabled = true)
public class SecurityConfig {
@Autowired
private JwtUtils jwtUtils;
@Autowired
private JwtAuthenticationFilter jwtAuthenticationFilter;
@Autowired
private UserDetailsService userDetailsService;
/**
* 密码编码器
*/
@Bean
public PasswordEncoder passwordEncoder() {
return new BCryptPasswordEncoder();
}
/**
* 认证管理器
*/
@Bean
public AuthenticationManager authenticationManager(AuthenticationConfiguration config) throws Exception {
return config.getAuthenticationManager();
}
/**
* 安全过滤器链
*/
@Bean
public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
http.cors().and().csrf().disable()
.sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
.and()
.userDetailsService(userDetailsService)
.authorizeRequests(authz -> authz
// 允许访问的路径
.antMatchers("/api/auth/**").permitAll()
.antMatchers("/api/public/**").permitAll()
.antMatchers("/api/test/public").permitAll() // 允许测试接口
.antMatchers("/actuator/**").permitAll()
.antMatchers("/druid/**").permitAll()
.antMatchers("/swagger-ui/**").permitAll()
.antMatchers("/swagger-ui.html").permitAll()
.antMatchers("/v3/api-docs/**").permitAll()
.antMatchers("/api-docs/**").permitAll()
.antMatchers("/doc.html").permitAll()
.antMatchers("/favicon.ico").permitAll()
// 其他请求需要认证
.anyRequest().authenticated()
)
.exceptionHandling()
.authenticationEntryPoint((request, response, authException) -> {
response.setContentType("application/json;charset=UTF-8");
response.setStatus(401);
response.getWriter().write("{\"code\":401,\"message\":\"未授权访问\",\"data\":null}");
})
.accessDeniedHandler((request, response, accessDeniedException) -> {
response.setContentType("application/json;charset=UTF-8");
response.setStatus(403);
response.getWriter().write("{\"code\":403,\"message\":\"权限不足\",\"data\":null}");
});
// 添加JWT过滤器
http.addFilterBefore(jwtAuthenticationFilter, UsernamePasswordAuthenticationFilter.class);
return http.build();
}
/**
* CORS配置
*/
@Bean
public CorsConfigurationSource corsConfigurationSource() {
CorsConfiguration configuration = new CorsConfiguration();
configuration.setAllowedOriginPatterns(Arrays.asList("*"));
configuration.setAllowedMethods(Arrays.asList("GET", "POST", "PUT", "DELETE", "OPTIONS"));
configuration.setAllowedHeaders(Arrays.asList("*"));
configuration.setAllowCredentials(true);
configuration.setMaxAge(3600L);
UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
source.registerCorsConfiguration("/**", configuration);
return source;
}
}
package com.apple.erp.config;
import io.swagger.v3.oas.models.OpenAPI;
import io.swagger.v3.oas.models.info.Contact;
import io.swagger.v3.oas.models.info.Info;
import io.swagger.v3.oas.models.info.License;
import io.swagger.v3.oas.models.security.SecurityRequirement;
import io.swagger.v3.oas.models.security.SecurityScheme;
import io.swagger.v3.oas.models.Components;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
/**
* Swagger配置类
*
* @author Apple ERP Team
* @version 1.0.0
* @since 2024-01-01
*/
@Configuration
public class SwaggerConfig {
/**
* OpenAPI配置
*/
@Bean
public OpenAPI customOpenAPI() {
return new OpenAPI()
.info(new Info()
.title("Apple经销商ERP系统API文档")
.description("Apple经销商ERP系统后端API接口文档")
.version("1.0.0")
.contact(new Contact()
.name("Apple ERP Team")
.email("developer@apple-erp.com")
.url("https://www.apple-erp.com"))
.license(new License()
.name("MIT License")
.url("https://opensource.org/licenses/MIT")))
.addSecurityItem(new SecurityRequirement().addList("Bearer Authentication"))
.components(new Components()
.addSecuritySchemes("Bearer Authentication",
new SecurityScheme()
.type(SecurityScheme.Type.HTTP)
.scheme("bearer")
.bearerFormat("JWT")
.description("请输入JWT令牌，格式：Bearer {token}")));
}
}
package com.apple.erp.config;
import com.apple.erp.entity.SysUser;
import com.apple.erp.service.SysUserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.security.core.userdetails.User;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.core.userdetails.UsernameNotFoundException;
import org.springframework.stereotype.Service;
import java.util.ArrayList;
import java.util.List;
/**
* 用户详情服务实现类
*
* @author Apple ERP Team
* @version 1.0.0
* @since 2024-01-01
*/
@Service
public class UserDetailsServiceImpl implements UserDetailsService {
@Autowired
private SysUserService sysUserService;
@Override
public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
// 从数据库查询用户信息
SysUser sysUser = sysUserService.findByUsername(username);
if (sysUser == null) {
throw new UsernameNotFoundException("用户不存在: " + username);
}
// 检查用户状态
if (sysUser.getStatus() == 0) {
throw new UsernameNotFoundException("用户已被停用: " + username);
}
// 获取用户权限
List<String> permissions = sysUserService.getUserPermissions(username);
List<SimpleGrantedAuthority> authorities = new ArrayList<>();
// 添加角色权限
if (sysUser.getRoles() != null) {
sysUser.getRoles().forEach(role -> {
authorities.add(new SimpleGrantedAuthority("ROLE_" + role.getRoleCode()));
});
}
// 添加功能权限
if (permissions != null) {
permissions.forEach(permission -> {
if (permission != null && !permission.trim().isEmpty()) {
authorities.add(new SimpleGrantedAuthority(permission));
}
});
}
// 构建UserDetails对象
return User.builder()
.username(sysUser.getUsername())
.password(sysUser.getPassword()) // 密码已经是BCrypt加密的
.authorities(authorities)
.accountExpired(false)
.accountLocked(false)
.credentialsExpired(false)
.disabled(sysUser.getStatus() == 0)
.build();
}
}
package com.apple.erp.controller;
import com.apple.erp.dto.request.LoginReq;
import com.apple.erp.dto.request.RefreshTokenReq;
import com.apple.erp.dto.response.ApiRes;
import com.apple.erp.dto.response.LoginRes;
import com.apple.erp.dto.response.UserInfoRes;
import com.apple.erp.entity.SysUser;
import com.apple.erp.service.SysUserService;
import com.apple.erp.service.SysLogService;
import com.apple.erp.utils.JwtUtils;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.Parameter;
import io.swagger.v3.oas.annotations.tags.Tag;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpServletRequest;
import javax.validation.Valid;
/**
* 认证控制器
*
* @author Apple ERP Team
* @version 1.0.0
* @since 2024-01-01
*/
@Slf4j
@RestController
@RequestMapping("/api/auth")
@CrossOrigin(origins = "*")
@Tag(name = "认证管理", description = "用户认证相关接口")
public class AuthController {
@Autowired
private AuthenticationManager authenticationManager;
@Autowired
private JwtUtils jwtUtils;
@Autowired
private SysUserService sysUserService;
@Autowired
private SysLogService sysLogService;
/**
* 用户登录
*/
@Operation(summary = "用户登录", description = "用户登录获取JWT令牌")
@PostMapping("/login")
public ResponseEntity<ApiRes<LoginRes>> login(
@Parameter(description = "登录信息", required = true)
@Valid @RequestBody LoginReq loginRequest,
HttpServletRequest request) {
try {
String username = loginRequest.getUsername();
String password = loginRequest.getPassword();
// 添加调试日志
System.out.println("尝试登录 - 用户名: " + username + ", 密码: " + password);
// 认证
Authentication authentication = authenticationManager.authenticate(
new UsernamePasswordAuthenticationToken(username, password)
);
System.out.println("认证成功: " + authentication.getName());
SecurityContextHolder.getContext().setAuthentication(authentication);
// 更新用户最后登录信息并记录登录日志
try {
SysUser user = sysUserService.findByUsername(username);
if (user != null) {
String clientIp = getClientIp(request);
sysUserService.updateLastLoginInfo(user.getUserId(), clientIp);
// 记录登录成功日志
sysLogService.recordLoginLog(user.getUserId(), username, clientIp, 1, null);
}
} catch (Exception e) {
// 记录日志但不影响登录流程
System.err.println("更新用户登录信息失败: " + e.getMessage());
}
// 生成JWT令牌
String token = jwtUtils.generateToken(username);
String refreshToken = jwtUtils.generateRefreshToken(username);
LoginRes loginResponse = new LoginRes(token, refreshToken, username);
ApiRes<LoginRes> response = ApiRes.success("登录成功", loginResponse);
return ResponseEntity.ok(response);
} catch (Exception ex) {
System.err.println(ex.getStackTrace());
log.error(ex.getMessage());
// 记录登录失败日志
try {
String clientIp = getClientIp(request);
sysLogService.recordLoginLog(null, loginRequest.getUsername(), clientIp, 0, ex.getMessage());
} catch (Exception e) {
log.error("记录登录失败日志失败", e);
}
ApiRes<LoginRes> response = ApiRes.error("用户名或密码错误");
return ResponseEntity.status(401).body(response);
}
}
/**
* 刷新令牌
*/
@Operation(summary = "刷新令牌", description = "使用刷新令牌获取新的访问令牌")
@PostMapping("/refresh")
public ResponseEntity<ApiRes<LoginRes>> refreshToken(
@Parameter(description = "刷新令牌信息", required = true)
@Valid @RequestBody RefreshTokenReq refreshRequest) {
try {
String refreshToken = refreshRequest.getRefreshToken();
String username = jwtUtils.getUsernameFromToken(refreshToken);
if (jwtUtils.validateToken(refreshToken, username)) {
String newToken = jwtUtils.generateToken(username);
String newRefreshToken = jwtUtils.generateRefreshToken(username);
LoginRes loginResponse = new LoginRes(newToken, newRefreshToken, username);
ApiRes<LoginRes> response = ApiRes.success("令牌刷新成功", loginResponse);
return ResponseEntity.ok(response);
} else {
throw new Exception("无效的刷新令牌");
}
} catch (Exception e) {
ApiRes<LoginRes> response = ApiRes.error("令牌刷新失败");
return ResponseEntity.status(401).body(response);
}
}
/**
* 用户登出
*/
@Operation(summary = "用户登出", description = "用户登出清除认证信息和缓存")
@PostMapping("/logout")
public ResponseEntity<ApiRes<Void>> logout(HttpServletRequest request) {
try {
// 获取当前用户信息
Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
String username = null;
Long userId = null;
if (authentication != null && authentication.isAuthenticated() &&
!"anonymousUser".equals(authentication.getName())) {
username = authentication.getName();
// 获取用户ID
try {
SysUser user = sysUserService.findByUsername(username);
if (user != null) {
userId = user.getUserId();
}
} catch (Exception e) {
log.warn("获取用户信息失败: " + e.getMessage());
}
}
// 清除Redis中的用户权限缓存
if (username != null) {
try {
sysUserService.clearUserCache(username);
log.info("用户 {} 的权限缓存已清除", username);
} catch (Exception e) {
log.error("清除用户权限缓存失败: " + e.getMessage());
}
}
// 记录登出日志
if (username != null) {
try {
String clientIp = getClientIp(request);
sysLogService.recordLoginLog(userId, username, clientIp, 1, null);
log.info("用户 {} 登出日志已记录", username);
} catch (Exception e) {
log.error("记录登出日志失败: " + e.getMessage());
}
}
// 清除Spring Security上下文
SecurityContextHolder.clearContext();
ApiRes<Void> response = ApiRes.success("登出成功", null);
return ResponseEntity.ok(response);
} catch (Exception e) {
log.error("用户登出失败", e);
ApiRes<Void> response = ApiRes.error("登出失败");
return ResponseEntity.status(500).body(response);
}
}
/**
* 获取当前用户信息
*/
@Operation(summary = "获取用户信息", description = "获取当前登录用户的详细信息")
@GetMapping("/userinfo")
public ResponseEntity<ApiRes<UserInfoRes>> getUserInfo() {
Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
if (authentication != null && authentication.isAuthenticated()) {
String username = authentication.getName();
UserInfoRes userInfo = new UserInfoRes(username, authentication.getAuthorities());
ApiRes<UserInfoRes> response = ApiRes.success("获取用户信息成功", userInfo);
return ResponseEntity.ok(response);
} else {
ApiRes<UserInfoRes> response = ApiRes.error("未认证");
return ResponseEntity.status(401).body(response);
}
}
/**
* 获取客户端IP地址
*/
private String getClientIp(HttpServletRequest request) {
String xForwardedFor = request.getHeader("X-Forwarded-For");
if (xForwardedFor != null && !xForwardedFor.isEmpty() && !"unknown".equalsIgnoreCase(xForwardedFor)) {
return xForwardedFor.split(",")[0];
}
String xRealIp = request.getHeader("X-Real-IP");
if (xRealIp != null && !xRealIp.isEmpty() && !"unknown".equalsIgnoreCase(xRealIp)) {
return xRealIp;
}
return request.getRemoteAddr();
}
}
package com.apple.erp.controller;
import com.apple.erp.dto.request.DictItemAddReq;
import com.apple.erp.dto.request.DictItemQueryReq;
import com.apple.erp.dto.request.DictItemUpdateReq;
import com.apple.erp.dto.response.ApiRes;
import com.apple.erp.dto.response.DictItemRes;
import com.apple.erp.entity.SysDictItem;
import com.apple.erp.service.SysDictItemService;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.Parameter;
import io.swagger.v3.oas.annotations.tags.Tag;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
import javax.validation.Valid;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
/**
* 系统字典项管理Controller
*
* @author Apple ERP Team
* @version 1.0.0
* @since 2024-01-01
*/
@Tag(name = "系统字典项管理", description = "系统字典项管理相关接口")
@RestController
@RequestMapping("/api/system/dict/item")
@Validated
public class SysDictItemController {
@Autowired
private SysDictItemService sysDictItemService;
/**
* 获取字典项列表
* 分页查询字典项信息，支持按字典类型ID、字典标签、字典值等条件筛选
*
* @param queryReq 查询条件
* @return 字典项分页列表
*/
@Operation(summary = "获取字典项列表", description = "分页查询字典项信息，支持多条件筛选")
@GetMapping("/list")
@PreAuthorize("hasAuthority('sys:dict:list')")
public ApiRes<Page<DictItemRes>> list(DictItemQueryReq queryReq) {
// 构建查询条件
SysDictItem dictItem = new SysDictItem();
BeanUtils.copyProperties(queryReq, dictItem);
LambdaQueryWrapper<SysDictItem> wrapper = sysDictItemService.getQueryWrapper(dictItem);
// 分页查询
Page<SysDictItem> page = new Page<>(queryReq.getPageNum(), queryReq.getPageSize());
Page<SysDictItem> dictItemPage = sysDictItemService.page(page, wrapper);
// 转换为响应DTO
List<DictItemRes> dictItemResList = dictItemPage.getRecords().stream()
.map(this::convertToDictItemRes).collect(Collectors.toList());
Page<DictItemRes> resultPage = new Page<>(dictItemPage.getCurrent(), dictItemPage.getSize(), dictItemPage.getTotal());
resultPage.setRecords(dictItemResList);
return ApiRes.success(resultPage);
}
/**
* 根据字典类型获取字典项列表
* 获取指定字典类型下的所有字典项
*
* @param dictType 字典类型编码
* @return 字典项列表
*/
@Operation(summary = "根据字典类型获取字典项列表", description = "获取指定字典类型下的所有字典项")
@GetMapping("/type/{dictType}")
@PreAuthorize("hasAuthority('sys:dict:list')")
public ApiRes<List<DictItemRes>> getDictItemsByType(@Parameter(description = "字典类型编码") @PathVariable String dictType) {
List<SysDictItem> dictItems = sysDictItemService.getDictItemsByType(dictType);
List<DictItemRes> dictItemResList = dictItems.stream()
.map(this::convertToDictItemRes).collect(Collectors.toList());
return ApiRes.success(dictItemResList);
}
/**
* 获取字典项详情
* 根据字典项ID获取字典项详细信息
*
* @param dictItemId 字典项ID
* @return 字典项详情
*/
@Operation(summary = "获取字典项详情", description = "根据字典项ID获取字典项详细信息")
@GetMapping("/{dictItemId}")
@PreAuthorize("hasAuthority('sys:dict:query')")
public ApiRes<DictItemRes> getInfo(@Parameter(description = "字典项ID") @PathVariable Long dictItemId) {
SysDictItem dictItem = sysDictItemService.getById(dictItemId);
if (dictItem == null) {
return ApiRes.error("字典项不存在");
}
return ApiRes.success(convertToDictItemRes(dictItem));
}
/**
* 新增字典项
* 创建新的字典项
*
* @param addReq 字典项新增请求
* @return 操作结果
*/
@Operation(summary = "新增字典项", description = "创建新的字典项")
@PostMapping
@PreAuthorize("hasAuthority('sys:dict:add')")
public ApiRes<Void> add(@Valid @RequestBody DictItemAddReq addReq) {
// 检查字典标签是否唯一
if (!sysDictItemService.checkDictLabelUnique(addReq.getDictLabel(), addReq.getDictTypeId(), null)) {
return ApiRes.error("字典标签已存在");
}
// 检查字典值是否唯一
if (!sysDictItemService.checkDictValueUnique(addReq.getDictValue(), addReq.getDictTypeId(), null)) {
return ApiRes.error("字典值已存在");
}
// 转换并保存
SysDictItem dictItem = new SysDictItem();
BeanUtils.copyProperties(addReq, dictItem);
dictItem.setSort(addReq.getSort() != null ? addReq.getSort() : 0);
boolean success = sysDictItemService.save(dictItem);
return success ? ApiRes.success(null) : ApiRes.error("新增字典项失败");
}
/**
* 修改字典项
* 更新字典项信息
*
* @param updateReq 字典项更新请求
* @return 操作结果
*/
@Operation(summary = "修改字典项", description = "更新字典项信息")
@PutMapping
@PreAuthorize("hasAuthority('sys:dict:edit')")
public ApiRes<Void> edit(@Valid @RequestBody DictItemUpdateReq updateReq) {
// 检查字典项是否存在
SysDictItem existDictItem = sysDictItemService.getById(updateReq.getDictItemId());
if (existDictItem == null) {
return ApiRes.error("字典项不存在");
}
// 检查字典标签是否唯一
if (!sysDictItemService.checkDictLabelUnique(updateReq.getDictLabel(), updateReq.getDictTypeId(), updateReq.getDictItemId())) {
return ApiRes.error("字典标签已存在");
}
// 检查字典值是否唯一
if (!sysDictItemService.checkDictValueUnique(updateReq.getDictValue(), updateReq.getDictTypeId(), updateReq.getDictItemId())) {
return ApiRes.error("字典值已存在");
}
// 转换并更新
SysDictItem dictItem = new SysDictItem();
BeanUtils.copyProperties(updateReq, dictItem);
dictItem.setSort(updateReq.getSort() != null ? updateReq.getSort() : 0);
boolean success = sysDictItemService.updateById(dictItem);
return success ? ApiRes.success(null) : ApiRes.error("修改字典项失败");
}
/**
* 删除字典项
* 批量删除字典项
*
* @param dictItemIds 字典项ID列表（逗号分隔）
* @return 操作结果
*/
@Operation(summary = "删除字典项", description = "批量删除字典项")
@DeleteMapping("/{dictItemIds}")
@PreAuthorize("hasAuthority('sys:dict:remove')")
public ApiRes<Void> remove(@Parameter(description = "字典项ID列表") @PathVariable String dictItemIds) {
try {
List<Long> ids = Arrays.stream(dictItemIds.split(","))
.map(Long::valueOf)
.collect(Collectors.toList());
boolean success = sysDictItemService.removeByIds(ids);
return success ? ApiRes.success(null) : ApiRes.error("删除字典项失败");
} catch (NumberFormatException e) {
return ApiRes.error("字典项ID格式错误");
}
}
/**
* 转换SysDictItem为DictItemRes
*
* @param dictItem 字典项实体
* @return 字典项响应DTO
*/
private DictItemRes convertToDictItemRes(SysDictItem dictItem) {
DictItemRes dictItemRes = new DictItemRes();
BeanUtils.copyProperties(dictItem, dictItemRes);
// TODO: 设置字典类型名称（需要关联查询）
// dictItemRes.setDictType(dictTypeName);
return dictItemRes;
}
}
package com.apple.erp.controller;
import com.apple.erp.dto.request.DictTypeAddReq;
import com.apple.erp.dto.request.DictTypeQueryReq;
import com.apple.erp.dto.request.DictTypeUpdateReq;
import com.apple.erp.dto.response.ApiRes;
import com.apple.erp.dto.response.DictTypeRes;
import com.apple.erp.entity.SysDictType;
import com.apple.erp.service.SysDictTypeService;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.Parameter;
import io.swagger.v3.oas.annotations.tags.Tag;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
import javax.validation.Valid;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
/**
* 系统字典类型管理Controller
*
* @author Apple ERP Team
* @version 1.0.0
* @since 2024-01-01
*/
@Tag(name = "系统字典类型管理", description = "系统字典类型管理相关接口")
@RestController
@RequestMapping("/api/system/dict/type")
@Validated
public class SysDictTypeController {
@Autowired
private SysDictTypeService sysDictTypeService;
/**
* 获取字典类型列表
* 分页查询字典类型信息，支持按字典类型、字典名称、状态等条件筛选
*
* @param queryReq 查询条件
* @return 字典类型分页列表
*/
@Operation(summary = "获取字典类型列表", description = "分页查询字典类型信息，支持多条件筛选")
@GetMapping("/list")
@PreAuthorize("hasAuthority('sys:dict:list')")
public ApiRes<Page<DictTypeRes>> list(DictTypeQueryReq queryReq) {
// 构建查询条件
SysDictType dictType = new SysDictType();
BeanUtils.copyProperties(queryReq, dictType);
LambdaQueryWrapper<SysDictType> wrapper = sysDictTypeService.getQueryWrapper(dictType);
// 分页查询
Page<SysDictType> page = new Page<>(queryReq.getPageNum(), queryReq.getPageSize());
Page<SysDictType> dictTypePage = sysDictTypeService.page(page, wrapper);
// 转换为响应DTO
List<DictTypeRes> dictTypeResList = dictTypePage.getRecords().stream()
.map(this::convertToDictTypeRes).collect(Collectors.toList());
Page<DictTypeRes> resultPage = new Page<>(dictTypePage.getCurrent(), dictTypePage.getSize(), dictTypePage.getTotal());
resultPage.setRecords(dictTypeResList);
return ApiRes.success(resultPage);
}
/**
* 获取字典类型详情
* 根据字典类型ID获取字典类型详细信息
*
* @param dictTypeId 字典类型ID
* @return 字典类型详情
*/
@Operation(summary = "获取字典类型详情", description = "根据字典类型ID获取字典类型详细信息")
@GetMapping("/{dictTypeId}")
@PreAuthorize("hasAuthority('sys:dict:query')")
public ApiRes<DictTypeRes> getInfo(@Parameter(description = "字典类型ID") @PathVariable Long dictTypeId) {
SysDictType dictType = sysDictTypeService.getById(dictTypeId);
if (dictType == null) {
return ApiRes.error("字典类型不存在");
}
return ApiRes.success(convertToDictTypeRes(dictType));
}
/**
* 新增字典类型
* 创建新的字典类型
*
* @param addReq 字典类型新增请求
* @return 操作结果
*/
@Operation(summary = "新增字典类型", description = "创建新的字典类型")
@PostMapping
@PreAuthorize("hasAuthority('sys:dict:add')")
public ApiRes<Void> add(@Valid @RequestBody DictTypeAddReq addReq) {
// 检查字典类型是否唯一
if (!sysDictTypeService.checkDictTypeUnique(addReq.getDictType(), null)) {
return ApiRes.error("字典类型已存在");
}
// 转换并保存
SysDictType dictType = new SysDictType();
BeanUtils.copyProperties(addReq, dictType);
dictType.setStatus(addReq.getStatus() != null ? addReq.getStatus() : 1);
boolean success = sysDictTypeService.save(dictType);
return success ? ApiRes.success(null) : ApiRes.error("新增字典类型失败");
}
/**
* 修改字典类型
* 更新字典类型信息
*
* @param updateReq 字典类型更新请求
* @return 操作结果
*/
@Operation(summary = "修改字典类型", description = "更新字典类型信息")
@PutMapping
@PreAuthorize("hasAuthority('sys:dict:edit')")
public ApiRes<Void> edit(@Valid @RequestBody DictTypeUpdateReq updateReq) {
// 检查字典类型是否存在
SysDictType existDictType = sysDictTypeService.getById(updateReq.getDictTypeId());
if (existDictType == null) {
return ApiRes.error("字典类型不存在");
}
// 检查字典类型是否唯一
if (!sysDictTypeService.checkDictTypeUnique(updateReq.getDictType(), updateReq.getDictTypeId())) {
return ApiRes.error("字典类型已存在");
}
// 转换并更新
SysDictType dictType = new SysDictType();
BeanUtils.copyProperties(updateReq, dictType);
dictType.setStatus(updateReq.getStatus() != null ? updateReq.getStatus() : 1);
boolean success = sysDictTypeService.updateById(dictType);
return success ? ApiRes.success(null) : ApiRes.error("修改字典类型失败");
}
/**
* 删除字典类型
* 批量删除字典类型
*
* @param dictTypeIds 字典类型ID列表（逗号分隔）
* @return 操作结果
*/
@Operation(summary = "删除字典类型", description = "批量删除字典类型")
@DeleteMapping("/{dictTypeIds}")
@PreAuthorize("hasAuthority('sys:dict:remove')")
public ApiRes<Void> remove(@Parameter(description = "字典类型ID列表") @PathVariable String dictTypeIds) {
try {
List<Long> ids = Arrays.stream(dictTypeIds.split(","))
.map(Long::valueOf)
.collect(Collectors.toList());
// 检查是否被字典项使用
for (Long dictTypeId : ids) {
if (sysDictTypeService.checkDictTypeExistItem(dictTypeId)) {
return ApiRes.error("字典类型已分配，不允许删除");
}
}
boolean success = sysDictTypeService.removeByIds(ids);
return success ? ApiRes.success(null) : ApiRes.error("删除字典类型失败");
} catch (NumberFormatException e) {
return ApiRes.error("字典类型ID格式错误");
}
}
/**
* 刷新字典缓存
* 清除字典相关的缓存数据
*
* @return 操作结果
*/
@Operation(summary = "刷新字典缓存", description = "清除字典相关的缓存数据")
@DeleteMapping("/refreshCache")
@PreAuthorize("hasAuthority('sys:dict:remove')")
public ApiRes<Void> refreshCache() {
// TODO: 实现字典缓存刷新逻辑
return ApiRes.success(null);
}
/**
* 获取字典选择框列表
* 获取所有可用的字典类型列表
*
* @return 字典类型列表
*/
@Operation(summary = "获取字典选择框列表", description = "获取所有可用的字典类型列表")
@GetMapping("/optionselect")
@PreAuthorize("hasAuthority('sys:dict:list')")
public ApiRes<List<DictTypeRes>> optionselect() {
LambdaQueryWrapper<SysDictType> wrapper = new LambdaQueryWrapper<>();
wrapper.eq(SysDictType::getStatus, 1)
.eq(SysDictType::getDelFlag, "0")
.orderByAsc(SysDictType::getDictType);
List<SysDictType> dictTypes = sysDictTypeService.list(wrapper);
List<DictTypeRes> dictTypeResList = dictTypes.stream()
.map(this::convertToDictTypeRes).collect(Collectors.toList());
return ApiRes.success(dictTypeResList);
}
/**
* 转换SysDictType为DictTypeRes
*
* @param dictType 字典类型实体
* @return 字典类型响应DTO
*/
private DictTypeRes convertToDictTypeRes(SysDictType dictType) {
DictTypeRes dictTypeRes = new DictTypeRes();
BeanUtils.copyProperties(dictType, dictTypeRes);
// 设置状态描述
if (dictType.getStatus() != null) {
dictTypeRes.setStatusText(dictType.getStatus() == 1 ? "启用" : "停用");
}
return dictTypeRes;
}
}
package com.apple.erp.controller;
import com.apple.erp.dto.response.ApiRes;
import com.apple.erp.dto.request.LogQueryReq;
import com.apple.erp.dto.response.LogDetailRes;
import com.apple.erp.dto.response.LogRes;
import com.apple.erp.service.SysLogService;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.Parameter;
import io.swagger.v3.oas.annotations.tags.Tag;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.web.bind.annotation.*;
import java.time.LocalDateTime;
import java.util.List;
/**
* 系统日志Controller
*
* @author Apple ERP Team
* @version 1.0.0
* @since 2024-01-01
*/
@Tag(name = "系统日志管理", description = "系统日志相关接口")
@RestController
@RequestMapping("/api/system/log")
public class SysLogController {
@Autowired
private SysLogService sysLogService;
/**
* 分页查询日志列表
*/
@Operation(summary = "分页查询日志列表", description = "根据条件分页查询系统日志")
@GetMapping("/page")
@PreAuthorize("hasAuthority('system:log:list')")
public ApiRes<Page<LogRes>> getLogPage(LogQueryReq queryReq) {
Page<LogRes> page = sysLogService.getLogPage(queryReq);
return ApiRes.success(page);
}
/**
* 获取日志详情
*/
@Operation(summary = "获取日志详情", description = "根据日志ID获取日志详细信息")
@GetMapping("/{logId}")
@PreAuthorize("hasAuthority('system:log:query')")
public ApiRes<LogDetailRes> getLogDetail(
@Parameter(description = "日志ID", required = true)
@PathVariable Long logId) {
LogDetailRes logDetail = sysLogService.getLogDetail(logId);
if (logDetail == null) {
return ApiRes.error("日志不存在");
}
return ApiRes.success(logDetail);
}
/**
* 根据用户ID查询登录日志
*/
@Operation(summary = "查询用户登录日志", description = "根据用户ID查询登录日志")
@GetMapping("/login/{userId}")
@PreAuthorize("hasAuthority('system:log:list')")
public ApiRes<List<LogRes>> getLoginLogsByUserId(
@Parameter(description = "用户ID", required = true)
@PathVariable Long userId,
@Parameter(description = "开始时间")
@RequestParam(required = false) LocalDateTime startTime,
@Parameter(description = "结束时间")
@RequestParam(required = false) LocalDateTime endTime) {
List<LogRes> loginLogs = sysLogService.getLoginLogsByUserId(userId, startTime, endTime);
return ApiRes.success(loginLogs);
}
/**
* 清理过期日志
*/
@Operation(summary = "清理过期日志", description = "清理指定天数之前的日志")
@DeleteMapping("/clean")
@PreAuthorize("hasAuthority('system:log:clean')")
public ApiRes<String> cleanExpiredLogs(
@Parameter(description = "过期天数", required = true)
@RequestParam int expireDays) {
if (expireDays <= 0) {
return ApiRes.error("过期天数必须大于0");
}
int cleanedCount = sysLogService.cleanExpiredLogs(expireDays);
return ApiRes.success("成功清理 " + cleanedCount + " 条过期日志");
}
/**
* 统计日志数量
*/
@Operation(summary = "统计日志数量", description = "根据条件统计日志数量")
@GetMapping("/count")
@PreAuthorize("hasAuthority('system:log:count')")
public ApiRes<Integer> countLogs(
@Parameter(description = "日志类型")
@RequestParam(required = false) String logType,
@Parameter(description = "开始时间")
@RequestParam(required = false) LocalDateTime startTime,
@Parameter(description = "结束时间")
@RequestParam(required = false) LocalDateTime endTime) {
int count = sysLogService.countLogs(logType, startTime, endTime);
return ApiRes.success(count);
}
/**
* 删除日志
*/
@Operation(summary = "删除日志", description = "根据日志ID删除日志")
@DeleteMapping("/{logId}")
@PreAuthorize("hasAuthority('system:log:remove')")
public ApiRes<String> deleteLog(
@Parameter(description = "日志ID", required = true)
@PathVariable Long logId) {
boolean success = sysLogService.removeById(logId);
if (success) {
return ApiRes.success("删除成功");
} else {
return ApiRes.error("删除失败");
}
}
/**
* 批量删除日志
*/
@Operation(summary = "批量删除日志", description = "根据日志ID列表批量删除日志")
@DeleteMapping("/batch")
@PreAuthorize("hasAuthority('system:log:remove')")
public ApiRes<String> deleteLogs(
@Parameter(description = "日志ID列表", required = true)
@RequestBody List<Long> logIds) {
if (logIds == null || logIds.isEmpty()) {
return ApiRes.error("日志ID列表不能为空");
}
boolean success = sysLogService.removeByIds(logIds);
if (success) {
return ApiRes.success("批量删除成功");
} else {
return ApiRes.error("批量删除失败");
}
}
}
package com.apple.erp.controller;
import com.apple.erp.vo.ResultVO;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.security.SecurityRequirement;
import io.swagger.v3.oas.annotations.tags.Tag;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.web.bind.annotation.*;
import java.util.HashMap;
import java.util.Map;
/**
* 测试控制器
*
* @author Apple ERP Team
* @version 1.0.0
* @since 2024-01-01
*/
@RestController
@RequestMapping("/api/test")
@CrossOrigin(origins = "*")
@Tag(name = "测试接口", description = "JWT认证功能测试接口")
public class TestController {
/**
* 公开接口测试
*/
@Operation(summary = "公开接口测试", description = "无需认证的公开接口")
@GetMapping("/public")
public ResultVO<Map<String, Object>> publicTest() {
Map<String, Object> data = new HashMap<>();
data.put("message", "这是一个公开接口");
data.put("timestamp", System.currentTimeMillis());
return ResultVO.success("公开接口测试成功", data);
}
/**
* 需要认证的接口测试
*/
@Operation(summary = "认证接口测试", description = "需要JWT令牌认证的接口")
@SecurityRequirement(name = "Bearer Authentication")
@GetMapping("/auth")
public ResultVO<Map<String, Object>> authTest() {
Map<String, Object> data = new HashMap<>();
data.put("message", "这是一个需要认证的接口");
data.put("timestamp", System.currentTimeMillis());
return ResultVO.success("认证接口测试成功", data);
}
/**
* 需要管理员权限的接口测试
*/
@Operation(summary = "管理员接口测试", description = "需要ADMIN角色权限的接口")
@SecurityRequirement(name = "Bearer Authentication")
@GetMapping("/admin")
@PreAuthorize("hasRole('ADMIN')")
public ResultVO<Map<String, Object>> adminTest() {
Map<String, Object> data = new HashMap<>();
data.put("message", "这是一个需要管理员权限的接口");
data.put("timestamp", System.currentTimeMillis());
return ResultVO.success("管理员接口测试成功", data);
}
/**
* 需要特定权限的接口测试
*/
@Operation(summary = "权限接口测试", description = "需要特定权限的接口")
@SecurityRequirement(name = "Bearer Authentication")
@GetMapping("/permission")
@PreAuthorize("hasAuthority('sys:user:list')")
public ResultVO<Map<String, Object>> permissionTest() {
Map<String, Object> data = new HashMap<>();
data.put("message", "这是一个需要特定权限的接口");
data.put("timestamp", System.currentTimeMillis());
return ResultVO.success("权限接口测试成功", data);
}
}
package com.apple.erp.dto.request;
import lombok.Data;
import javax.validation.constraints.NotBlank;
import javax.validation.constraints.NotNull;
import javax.validation.constraints.Size;
/**
* 字典项新增请求DTO
*
* @author Apple ERP Team
* @version 1.0.0
* @since 2024-01-01
*/
@Data
public class DictItemAddReq {
/**
* 字典类型ID
*/
@NotNull(message = "字典类型ID不能为空")
private Long dictTypeId;
/**
* 字典标签
*/
@NotBlank(message = "字典标签不能为空")
@Size(max = 100, message = "字典标签长度不能超过100个字符")
private String dictLabel;
/**
* 字典值
*/
@NotBlank(message = "字典值不能为空")
@Size(max = 50, message = "字典值长度不能超过50个字符")
private String dictValue;
/**
* 排序号
*/
private Integer sort;
/**
* 备注
*/
@Size(max = 500, message = "备注长度不能超过500个字符")
private String remark;
}
package com.apple.erp.dto.request;
import lombok.Data;
/**
* 字典项查询请求DTO
*
* @author Apple ERP Team
* @version 1.0.0
* @since 2024-01-01
*/
@Data
public class DictItemQueryReq {
/**
* 页码
*/
private Long pageNum = 1L;
/**
* 每页大小
*/
private Long pageSize = 10L;
/**
* 字典类型ID
*/
private Long dictTypeId;
/**
* 字典标签
*/
private String dictLabel;
/**
* 字典值
*/
private String dictValue;
}
package com.apple.erp.dto.request;
import lombok.Data;
import javax.validation.constraints.NotBlank;
import javax.validation.constraints.NotNull;
import javax.validation.constraints.Size;
/**
* 字典项更新请求DTO
*
* @author Apple ERP Team
* @version 1.0.0
* @since 2024-01-01
*/
@Data
public class DictItemUpdateReq {
/**
* 字典项ID
*/
@NotNull(message = "字典项ID不能为空")
private Long dictItemId;
/**
* 字典类型ID
*/
@NotNull(message = "字典类型ID不能为空")
private Long dictTypeId;
/**
* 字典标签
*/
@NotBlank(message = "字典标签不能为空")
@Size(max = 100, message = "字典标签长度不能超过100个字符")
private String dictLabel;
/**
* 字典值
*/
@NotBlank(message = "字典值不能为空")
@Size(max = 50, message = "字典值长度不能超过50个字符")
private String dictValue;
/**
* 排序号
*/
private Integer sort;
/**
* 备注
*/
@Size(max = 500, message = "备注长度不能超过500个字符")
private String remark;
}
package com.apple.erp.dto.request;
import lombok.Data;
import javax.validation.constraints.NotBlank;
import javax.validation.constraints.Pattern;
import javax.validation.constraints.Size;
/**
* 字典类型新增请求DTO
*
* @author Apple ERP Team
* @version 1.0.0
* @since 2024-01-01
*/
@Data
public class DictTypeAddReq {
/**
* 字典类型
*/
@NotBlank(message = "字典类型不能为空")
@Pattern(regexp = "^[a-z][a-z0-9_]*$", message = "字典类型只能包含小写字母、数字和下划线，且必须以字母开头")
@Size(max = 50, message = "字典类型长度不能超过50个字符")
private String dictType;
/**
* 字典名称
*/
@NotBlank(message = "字典名称不能为空")
@Size(max = 100, message = "字典名称长度不能超过100个字符")
private String dictName;
/**
* 状态（0-停用/1-启用）
*/
private Integer status;
/**
* 备注
*/
@Size(max = 500, message = "备注长度不能超过500个字符")
private String remark;
}
package com.apple.erp.dto.request;
import lombok.Data;
/**
* 字典类型查询请求DTO
*
* @author Apple ERP Team
* @version 1.0.0
* @since 2024-01-01
*/
@Data
public class DictTypeQueryReq {
/**
* 页码
*/
private Long pageNum = 1L;
/**
* 每页大小
*/
private Long pageSize = 10L;
/**
* 字典类型
*/
private String dictType;
/**
* 字典名称
*/
private String dictName;
/**
* 状态（0-停用/1-启用）
*/
private Integer status;
}
package com.apple.erp.dto.request;
import lombok.Data;
import javax.validation.constraints.NotBlank;
import javax.validation.constraints.NotNull;
import javax.validation.constraints.Pattern;
import javax.validation.constraints.Size;
/**
* 字典类型更新请求DTO
*
* @author Apple ERP Team
* @version 1.0.0
* @since 2024-01-01
*/
@Data
public class DictTypeUpdateReq {
/**
* 字典类型ID
*/
@NotNull(message = "字典类型ID不能为空")
private Long dictTypeId;
/**
* 字典类型
*/
@NotBlank(message = "字典类型不能为空")
@Pattern(regexp = "^[a-z][a-z0-9_]*$", message = "字典类型只能包含小写字母、数字和下划线，且必须以字母开头")
@Size(max = 50, message = "字典类型长度不能超过50个字符")
private String dictType;
/**
* 字典名称
*/
@NotBlank(message = "字典名称不能为空")
@Size(max = 100, message = "字典名称长度不能超过100个字符")
private String dictName;
/**
* 状态（0-停用/1-启用）
*/
private Integer status;
/**
* 备注
*/
@Size(max = 500, message = "备注长度不能超过500个字符")
private String remark;
}
package com.apple.erp.dto.request;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
import java.time.LocalDateTime;
/**
* 日志查询请求DTO
*
* @author Apple ERP Team
* @version 1.0.0
* @since 2024-01-01
*/
@Data
@Schema(description = "日志查询请求")
public class LogQueryReq {
@Schema(description = "日志类型（0-操作日志/1-异常日志/2-登录日志）")
private String logType;
@Schema(description = "用户ID")
private Long userId;
@Schema(description = "用户名")
private String username;
@Schema(description = "操作模块")
private String module;
@Schema(description = "操作内容")
private String operation;
@Schema(description = "操作IP")
private String ip;
@Schema(description = "操作结果（0-失败/1-成功）")
private Integer status;
@Schema(description = "开始时间")
private LocalDateTime startTime;
@Schema(description = "结束时间")
private LocalDateTime endTime;
@Schema(description = "页码", example = "1")
private Integer pageNum = 1;
@Schema(description = "每页大小", example = "10")
private Integer pageSize = 10;
}
package com.apple.erp.dto.request;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
import javax.validation.constraints.NotBlank;
import javax.validation.constraints.Size;
/**
* 登录请求对象
*
* @author Apple ERP Team
* @version 1.0.0
* @since 2024-01-01
*/
@Data
@Schema(description = "用户登录请求")
public class LoginReq {
@NotBlank(message = "用户名不能为空")
@Size(min = 2, max = 50, message = "用户名长度必须在2-50个字符之间")
@Schema(description = "用户名", example = "admin", required = true)
private String username;
@NotBlank(message = "密码不能为空")
@Size(min = 6, max = 100, message = "密码长度必须在6-100个字符之间")
@Schema(description = "密码", example = "password", required = true)
private String password;
}
package com.apple.erp.dto.request;
import lombok.Data;
import javax.validation.constraints.NotBlank;
import javax.validation.constraints.NotNull;
import javax.validation.constraints.Size;
/**
* 菜单新增请求DTO
*
* @author Apple ERP Team
* @version 1.0.0
* @since 2024-01-01
*/
@Data
public class MenuAddReq {
/**
* 父菜单ID
*/
private Long parentId;
/**
* 菜单名称
*/
@NotBlank(message = "菜单名称不能为空")
@Size(max = 100, message = "菜单名称长度不能超过100个字符")
private String menuName;
/**
* 菜单类型（0-目录/1-菜单/2-按钮）
*/
@NotNull(message = "菜单类型不能为空")
private String menuType;
/**
* 菜单路径
*/
@Size(max = 200, message = "菜单路径长度不能超过200个字符")
private String path;
/**
* 菜单图标
*/
@Size(max = 50, message = "菜单图标长度不能超过50个字符")
private String icon;
/**
* 排序号
*/
private Integer sort;
/**
* 状态（0-隐藏/1-显示）
*/
private Integer status;
/**
* 权限标识
*/
@Size(max = 100, message = "权限标识长度不能超过100个字符")
private String perms;
}
package com.apple.erp.dto.request;
import lombok.Data;
/**
* 菜单查询请求DTO
*
* @author Apple ERP Team
* @version 1.0.0
* @since 2024-01-01
*/
@Data
public class MenuQueryReq {
/**
* 页码
*/
private Long pageNum = 1L;
/**
* 每页大小
*/
private Long pageSize = 10L;
/**
* 菜单名称
*/
private String menuName;
/**
* 菜单ID
*/
private Long menuId;
/**
* 菜单路径
*/
private String path;
/**
* 菜单类型（0-目录/1-菜单/2-按钮）
*/
private String menuType;
/**
* 状态（0-隐藏/1-显示）
*/
private Integer status;
}
package com.apple.erp.dto.request;
import lombok.Data;
import javax.validation.constraints.NotBlank;
import javax.validation.constraints.NotNull;
import javax.validation.constraints.Size;
/**
* 菜单更新请求DTO
*
* @author Apple ERP Team
* @version 1.0.0
* @since 2024-01-01
*/
@Data
public class MenuUpdateReq {
/**
* 菜单ID
*/
@NotNull(message = "菜单ID不能为空")
private Long menuId;
/**
* 父菜单ID
*/
private Long parentId;
/**
* 菜单名称
*/
@NotBlank(message = "菜单名称不能为空")
@Size(max = 100, message = "菜单名称长度不能超过100个字符")
private String menuName;
/**
* 菜单类型（0-目录/1-菜单/2-按钮）
*/
@NotNull(message = "菜单类型不能为空")
private String menuType;
/**
* 菜单路径
*/
@Size(max = 200, message = "菜单路径长度不能超过200个字符")
private String path;
/**
* 菜单图标
*/
@Size(max = 50, message = "菜单图标长度不能超过50个字符")
private String icon;
/**
* 排序号
*/
private Integer sort;
/**
* 状态（0-隐藏/1-显示）
*/
private Integer status;
/**
* 权限标识
*/
@Size(max = 100, message = "权限标识长度不能超过100个字符")
private String perms;
}
package com.apple.erp.dto.request;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
import javax.validation.constraints.NotBlank;
/**
* 刷新令牌请求对象
*
* @author Apple ERP Team
* @version 1.0.0
* @since 2024-01-01
*/
@Data
@Schema(description = "刷新令牌请求")
public class RefreshTokenReq {
@NotBlank(message = "刷新令牌不能为空")
@Schema(description = "刷新令牌", example = "eyJhbGciOiJIUzUxMiJ9...", required = true)
private String refreshToken;
}
package com.apple.erp.dto.request;
import lombok.Data;
import javax.validation.constraints.NotBlank;
import javax.validation.constraints.Size;
import java.util.List;
/**
* 角色新增请求DTO
*
* @author Apple ERP Team
* @version 1.0.0
* @since 2024-01-01
*/
@Data
public class RoleAddReq {
/**
* 角色编码
*/
@NotBlank(message = "角色编码不能为空")
@Size(max = 50, message = "角色编码长度不能超过50个字符")
private String roleCode;
/**
* 角色名称
*/
@NotBlank(message = "角色名称不能为空")
@Size(max = 50, message = "角色名称长度不能超过50个字符")
private String roleName;
/**
* 状态（0-停用/1-启用）
*/
private Integer status;
/**
* 备注
*/
@Size(max = 500, message = "备注长度不能超过500个字符")
private String remark;
/**
* 菜单ID列表
*/
private List<Long> menuIds;
}
package com.apple.erp.dto.request;
import lombok.Data;
/**
* 角色查询请求DTO
*
* @author Apple ERP Team
* @version 1.0.0
* @since 2024-01-01
*/
@Data
public class RoleQueryReq {
/**
* 角色编码
*/
private String roleCode;
/**
* 角色名称
*/
private String roleName;
/**
* 状态（0-停用/1-启用）
*/
private Integer status;
/**
* 页码
*/
private Integer pageNum = 1;
/**
* 每页大小
*/
private Integer pageSize = 10;
}
package com.apple.erp.dto.request;
import lombok.Data;
import javax.validation.constraints.NotBlank;
import javax.validation.constraints.NotNull;
import javax.validation.constraints.Size;
import java.util.List;
/**
* 角色更新请求DTO
*
* @author Apple ERP Team
* @version 1.0.0
* @since 2024-01-01
*/
@Data
public class RoleUpdateReq {
/**
* 角色ID
*/
@NotNull(message = "角色ID不能为空")
private Long roleId;
/**
* 角色编码
*/
@NotBlank(message = "角色编码不能为空")
@Size(max = 50, message = "角色编码长度不能超过50个字符")
private String roleCode;
/**
* 角色名称
*/
@NotBlank(message = "角色名称不能为空")
@Size(max = 50, message = "角色名称长度不能超过50个字符")
private String roleName;
/**
* 状态（0-停用/1-启用）
*/
private Integer status;
/**
* 备注
*/
@Size(max = 500, message = "备注长度不能超过500个字符")
private String remark;
/**
* 菜单ID列表
*/
private List<Long> menuIds;
}
package com.apple.erp.dto.request;
import lombok.Data;
import javax.validation.constraints.Email;
import javax.validation.constraints.NotBlank;
import javax.validation.constraints.Pattern;
import javax.validation.constraints.Size;
import java.util.List;
/**
* 用户新增请求DTO
*
* @author Apple ERP Team
* @version 1.0.0
* @since 2024-01-01
*/
@Data
public class UserAddReq {
/**
* 用户名
*/
@NotBlank(message = "用户名不能为空")
@Size(min = 2, max = 50, message = "用户名长度必须在2-50个字符之间")
private String username;
/**
* 密码
*/
@NotBlank(message = "密码不能为空")
@Size(min = 6, max = 20, message = "密码长度必须在6-20个字符之间")
private String password;
/**
* 真实姓名
*/
@NotBlank(message = "真实姓名不能为空")
@Size(max = 100, message = "真实姓名长度不能超过100个字符")
private String realName;
/**
* 手机号
*/
@Pattern(regexp = "^1[3-9]\\d{9}$", message = "手机号格式不正确")
private String phone;
/**
* 邮箱
*/
@Email(message = "邮箱格式不正确")
@Size(max = 100, message = "邮箱长度不能超过100个字符")
private String email;
/**
* 状态（0-停用/1-启用）
*/
private Integer status;
/**
* 备注
*/
@Size(max = 500, message = "备注长度不能超过500个字符")
private String remark;
/**
* 角色ID列表
*/
private List<Long> roleIds;
}
package com.apple.erp.dto.request;
import lombok.Data;
import javax.validation.constraints.NotBlank;
import javax.validation.constraints.NotNull;
import javax.validation.constraints.Size;
/**
* 用户密码重置请求DTO
*
* @author Apple ERP Team
* @version 1.0.0
* @since 2024-01-01
*/
@Data
public class UserPasswordResetReq {
/**
* 用户ID
*/
@NotNull(message = "用户ID不能为空")
private Long userId;
/**
* 新密码
*/
@NotBlank(message = "新密码不能为空")
@Size(min = 6, max = 20, message = "密码长度必须在6-20个字符之间")
private String newPassword;
}
package com.apple.erp.dto.request;
import lombok.Data;
/**
* 用户查询请求DTO
*
* @author Apple ERP Team
* @version 1.0.0
* @since 2024-01-01
*/
@Data
public class UserQueryReq {
/**
* 用户名
*/
private String username;
/**
* 真实姓名
*/
private String realName;
/**
* 手机号
*/
private String phone;
/**
* 邮箱
*/
private String email;
/**
* 状态（0-停用/1-启用）
*/
private Integer status;
/**
* 页码
*/
private Integer pageNum = 1;
/**
* 每页大小
*/
private Integer pageSize = 10;
}
package com.apple.erp.dto.request;
import lombok.Data;
import javax.validation.constraints.Email;
import javax.validation.constraints.NotBlank;
import javax.validation.constraints.NotNull;
import javax.validation.constraints.Pattern;
import javax.validation.constraints.Size;
import java.util.List;
/**
* 用户更新请求DTO
*
* @author Apple ERP Team
* @version 1.0.0
* @since 2024-01-01
*/
@Data
public class UserUpdateReq {
/**
* 用户ID
*/
@NotNull(message = "用户ID不能为空")
private Long userId;
/**
* 用户名
*/
@NotBlank(message = "用户名不能为空")
@Size(min = 2, max = 50, message = "用户名长度必须在2-50个字符之间")
private String username;
/**
* 真实姓名
*/
@NotBlank(message = "真实姓名不能为空")
@Size(max = 100, message = "真实姓名长度不能超过100个字符")
private String realName;
/**
* 手机号
*/
@Pattern(regexp = "^1[3-9]\\d{9}$", message = "手机号格式不正确")
private String phone;
/**
* 邮箱
*/
@Email(message = "邮箱格式不正确")
@Size(max = 100, message = "邮箱长度不能超过100个字符")
private String email;
/**
* 状态（0-停用/1-启用）
*/
private Integer status;
/**
* 备注
*/
@Size(max = 500, message = "备注长度不能超过500个字符")
private String remark;
/**
* 角色ID列表
*/
private List<Long> roleIds;
}
package com.apple.erp.dto.response;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
/**
* 统一API响应对象
*
* @author Apple ERP Team
* @version 1.0.0
* @since 2024-01-01
*/
@Data
@Schema(description = "统一API响应")
public class ApiRes<T> {
@Schema(description = "响应码", example = "200")
private Integer code;
@Schema(description = "响应消息", example = "操作成功")
private String message;
@Schema(description = "响应数据")
private T data;
public ApiRes() {}
public ApiRes(Integer code, String message, T data) {
this.code = code;
this.message = message;
this.data = data;
}
/**
* 成功响应
*/
public static <T> ApiRes<T> success(T data) {
return new ApiRes<>(200, "操作成功", data);
}
/**
* 成功响应（带消息）
*/
public static <T> ApiRes<T> success(String message, T data) {
return new ApiRes<>(200, message, data);
}
/**
* 失败响应
*/
public static <T> ApiRes<T> error(Integer code, String message) {
return new ApiRes<>(code, message, null);
}
/**
* 失败响应（默认401）
*/
public static <T> ApiRes<T> error(String message) {
return new ApiRes<>(401, message, null);
}
}
package com.apple.erp.dto.response;
import lombok.Data;
import java.time.LocalDateTime;
/**
* 字典项响应DTO
*
* @author Apple ERP Team
* @version 1.0.0
* @since 2024-01-01
*/
@Data
public class DictItemRes {
/**
* 字典项ID
*/
private Long dictItemId;
/**
* 字典类型ID
*/
private Long dictTypeId;
/**
* 字典类型
*/
private String dictType;
/**
* 字典标签
*/
private String dictLabel;
/**
* 字典值
*/
private String dictValue;
/**
* 排序号
*/
private Integer sort;
/**
* 备注
*/
private String remark;
/**
* 创建者
*/
private String createBy;
/**
* 创建时间
*/
private LocalDateTime createTime;
/**
* 更新者
*/
private String updateBy;
/**
* 更新时间
*/
private LocalDateTime updateTime;
}
package com.apple.erp.dto.response;
import lombok.Data;
import java.time.LocalDateTime;
/**
* 字典类型响应DTO
*
* @author Apple ERP Team
* @version 1.0.0
* @since 2024-01-01
*/
@Data
public class DictTypeRes {
/**
* 字典类型ID
*/
private Long dictTypeId;
/**
* 字典类型
*/
private String dictType;
/**
* 字典名称
*/
private String dictName;
/**
* 状态（0-停用/1-启用）
*/
private Integer status;
/**
* 状态描述
*/
private String statusText;
/**
* 备注
*/
private String remark;
/**
* 创建者
*/
private String createBy;
/**
* 创建时间
*/
private LocalDateTime createTime;
/**
* 更新者
*/
private String updateBy;
/**
* 更新时间
*/
private LocalDateTime updateTime;
}
package com.apple.erp.dto.response;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
import java.time.LocalDateTime;
/**
* 日志详情响应DTO
*
* @author Apple ERP Team
* @version 1.0.0
* @since 2024-01-01
*/
@Data
@Schema(description = "日志详情响应")
public class LogDetailRes {
@Schema(description = "日志ID")
private Long logId;
@Schema(description = "日志类型（0-操作日志/1-异常日志/2-登录日志）")
private String logType;
@Schema(description = "日志类型描述")
private String logTypeText;
@Schema(description = "用户ID")
private Long userId;
@Schema(description = "用户名")
private String username;
@Schema(description = "操作模块")
private String module;
@Schema(description = "操作内容")
private String operation;
@Schema(description = "操作IP")
private String ip;
@Schema(description = "日志时间")
private LocalDateTime logTime;
@Schema(description = "操作结果（0-失败/1-成功）")
private Integer status;
@Schema(description = "操作结果描述")
private String statusText;
@Schema(description = "错误信息")
private String errorMsg;
@Schema(description = "请求参数")
private String requestParam;
@Schema(description = "创建者")
private String createBy;
@Schema(description = "创建时间")
private LocalDateTime createTime;
@Schema(description = "更新者")
private String updateBy;
@Schema(description = "更新时间")
private LocalDateTime updateTime;
}
package com.apple.erp.dto.response;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
import java.time.LocalDateTime;
/**
* 日志响应DTO
*
* @author Apple ERP Team
* @version 1.0.0
* @since 2024-01-01
*/
@Data
@Schema(description = "日志响应")
public class LogRes {
@Schema(description = "日志ID")
private Long logId;
@Schema(description = "日志类型（0-操作日志/1-异常日志/2-登录日志）")
private String logType;
@Schema(description = "日志类型描述")
private String logTypeText;
@Schema(description = "用户ID")
private Long userId;
@Schema(description = "用户名")
private String username;
@Schema(description = "操作模块")
private String module;
@Schema(description = "操作内容")
private String operation;
@Schema(description = "操作IP")
private String ip;
@Schema(description = "日志时间")
private LocalDateTime logTime;
@Schema(description = "操作结果（0-失败/1-成功）")
private Integer status;
@Schema(description = "操作结果描述")
private String statusText;
@Schema(description = "错误信息")
private String errorMsg;
@Schema(description = "请求参数")
private String requestParam;
@Schema(description = "创建者")
private String createBy;
@Schema(description = "创建时间")
private LocalDateTime createTime;
@Schema(description = "更新者")
private String updateBy;
@Schema(description = "更新时间")
private LocalDateTime updateTime;
}
package com.apple.erp.dto.response;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
/**
* 登录响应对象
*
* @author Apple ERP Team
* @version 1.0.0
* @since 2024-01-01
*/
@Data
@Schema(description = "用户登录响应")
public class LoginRes {
@Schema(description = "访问令牌", example = "eyJhbGciOiJIUzUxMiJ9...")
private String token;
@Schema(description = "刷新令牌", example = "eyJhbGciOiJIUzUxMiJ9...")
private String refreshToken;
@Schema(description = "用户名", example = "admin")
private String username;
public LoginRes() {}
public LoginRes(String token, String refreshToken, String username) {
this.token = token;
this.refreshToken = refreshToken;
this.username = username;
}
}
package com.apple.erp.dto.response;
import lombok.Data;
import java.time.LocalDateTime;
import java.util.List;
/**
* 菜单响应DTO
*
* @author Apple ERP Team
* @version 1.0.0
* @since 2024-01-01
*/
@Data
public class MenuRes {
/**
* 菜单ID
*/
private Long menuId;
/**
* 父菜单ID
*/
private Long parentId;
/**
* 菜单名称
*/
private String menuName;
/**
* 菜单类型（0-目录/1-菜单/2-按钮）
*/
private String menuType;
/**
* 菜单类型描述
*/
private String menuTypeText;
/**
* 菜单路径
*/
private String path;
/**
* 菜单图标
*/
private String icon;
/**
* 排序号
*/
private Integer sort;
/**
* 状态（0-隐藏/1-显示）
*/
private Integer status;
/**
* 状态描述
*/
private String statusText;
/**
* 权限标识
*/
private String perms;
/**
* 创建者
*/
private String createBy;
/**
* 创建时间
*/
private LocalDateTime createTime;
/**
* 更新者
*/
private String updateBy;
/**
* 更新时间
*/
private LocalDateTime updateTime;
/**
* 子菜单列表
*/
private List<MenuRes> children;
}
\ No newline at end of file
package com.apple.erp.dto.response;
import lombok.Data;
import java.time.LocalDateTime;
import java.util.List;
/**
* 角色响应DTO
*
* @author Apple ERP Team
* @version 1.0.0
* @since 2024-01-01
*/
@Data
public class RoleRes {
/**
* 角色ID
*/
private Long roleId;
/**
* 角色编码
*/
private String roleCode;
/**
* 角色名称
*/
private String roleName;
/**
* 状态（0-停用/1-启用）
*/
private Integer status;
/**
* 状态描述
*/
private String statusText;
/**
* 备注
*/
private String remark;
/**
* 创建者
*/
private String createBy;
/**
* 创建时间
*/
private LocalDateTime createTime;
/**
* 更新者
*/
private String updateBy;
/**
* 更新时间
*/
private LocalDateTime updateTime;
/**
* 菜单列表
*/
private List<MenuRes> menus;
}
package com.apple.erp.dto.response;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
import org.springframework.security.core.GrantedAuthority;
import java.util.Collection;
/**
* 用户信息响应对象
*
* @author Apple ERP Team
* @version 1.0.0
* @since 2024-01-01
*/
@Data
@Schema(description = "用户信息响应")
public class UserInfoRes {
@Schema(description = "用户名", example = "admin")
private String username;
@Schema(description = "用户权限列表")
private Collection<? extends GrantedAuthority> authorities;
public UserInfoRes() {}
public UserInfoRes(String username, Collection<? extends GrantedAuthority> authorities) {
this.username = username;
this.authorities = authorities;
}
}
package com.apple.erp.dto.response;
import lombok.Data;
import java.time.LocalDateTime;
import java.util.List;
/**
* 用户响应DTO
*
* @author Apple ERP Team
* @version 1.0.0
* @since 2024-01-01
*/
@Data
public class UserRes {
/**
* 用户ID
*/
private Long userId;
/**
* 用户名
*/
private String username;
/**
* 真实姓名
*/
private String realName;
/**
* 手机号
*/
private String phone;
/**
* 邮箱
*/
private String email;
/**
* 状态（0-停用/1-启用）
*/
private Integer status;
/**
* 状态描述
*/
private String statusText;
/**
* 备注
*/
private String remark;
/**
* 创建者
*/
private String createBy;
/**
* 创建时间
*/
private LocalDateTime createTime;
/**
* 更新者
*/
private String updateBy;
/**
* 更新时间
*/
private LocalDateTime updateTime;
/**
* 最后登录时间
*/
private LocalDateTime lastLoginTime;
/**
* 最后登录IP
*/
private String lastLoginIp;
/**
* 角色列表
*/
private List<RoleRes> roles;
}
package com.apple.erp.entity;
import com.baomidou.mybatisplus.annotation.*;
import lombok.Data;
import java.time.LocalDateTime;
/**
* 系统字典项实体类
*
* @author Apple ERP Team
* @version 1.0.0
* @since 2024-01-01
*/
@Data
@TableName("t_sys_dict_item")
public class SysDictItem {
/**
* 字典项ID
*/
@TableId(value = "dict_item_id", type = IdType.AUTO)
private Long dictItemId;
/**
* 字典类型ID
*/
@TableField("dict_type_id")
private Long dictTypeId;
/**
* 字典标签
*/
@TableField("dict_label")
private String dictLabel;
/**
* 字典值
*/
@TableField("dict_value")
private String dictValue;
/**
* 排序号
*/
@TableField("sort")
private Integer sort;
/**
* 备注
*/
@TableField("remark")
private String remark;
/**
* 创建者
*/
@TableField("create_by")
private String createBy;
/**
* 创建时间
*/
@TableField(value = "create_time", fill = FieldFill.INSERT)
private LocalDateTime createTime;
/**
* 更新者
*/
@TableField("update_by")
private String updateBy;
/**
* 更新时间
*/
@TableField(value = "update_time", fill = FieldFill.INSERT_UPDATE)
private LocalDateTime updateTime;
/**
* 删除标志（0代表存在 2代表删除）
*/
@TableField("del_flag")
@TableLogic
private String delFlag;
}
package com.apple.erp.entity;
import com.baomidou.mybatisplus.annotation.*;
import lombok.Data;
import java.time.LocalDateTime;
/**
* 系统字典类型实体类
*
* @author Apple ERP Team
* @version 1.0.0
* @since 2024-01-01
*/
@Data
@TableName("t_sys_dict_type")
public class SysDictType {
/**
* 字典类型ID
*/
@TableId(value = "dict_type_id", type = IdType.AUTO)
private Long dictTypeId;
/**
* 字典类型
*/
@TableField("dict_type")
private String dictType;
/**
* 字典名称
*/
@TableField("dict_name")
private String dictName;
/**
* 状态（0-停用/1-启用）
*/
@TableField("status")
private Integer status;
/**
* 备注
*/
@TableField("remark")
private String remark;
/**
* 创建者
*/
@TableField("create_by")
private String createBy;
/**
* 创建时间
*/
@TableField(value = "create_time", fill = FieldFill.INSERT)
private LocalDateTime createTime;
/**
* 更新者
*/
@TableField("update_by")
private String updateBy;
/**
* 更新时间
*/
@TableField(value = "update_time", fill = FieldFill.INSERT_UPDATE)
private LocalDateTime updateTime;
/**
* 删除标志（0代表存在 2代表删除）
*/
@TableField("del_flag")
@TableLogic
private String delFlag;
}
package com.apple.erp.entity;
import com.baomidou.mybatisplus.annotation.*;
import lombok.Data;
import lombok.EqualsAndHashCode;
import java.time.LocalDateTime;
/**
* 系统日志实体类
*
* @author Apple ERP Team
* @version 1.0.0
* @since 2024-01-01
*/
@Data
@EqualsAndHashCode(callSuper = false)
@TableName("t_sys_log")
public class SysLog {
/**
* 日志ID
*/
@TableId(value = "log_id", type = IdType.AUTO)
private Long logId;
/**
* 日志类型（0-操作日志/1-异常日志/2-登录日志）
*/
@TableField("log_type")
private String logType;
/**
* 用户ID
*/
@TableField("user_id")
private Long userId;
/**
* 用户名
*/
@TableField("username")
private String username;
/**
* 操作模块
*/
@TableField("module")
private String module;
/**
* 操作内容
*/
@TableField("operation")
private String operation;
/**
* 操作IP
*/
@TableField("ip")
private String ip;
/**
* 日志时间
*/
@TableField("log_time")
private LocalDateTime logTime;
/**
* 操作结果（0-失败/1-成功）
*/
@TableField("status")
private Integer status;
/**
* 错误信息
*/
@TableField("error_msg")
private String errorMsg;
/**
* 请求参数
*/
@TableField("request_param")
private String requestParam;
/**
* 创建者
*/
@TableField("create_by")
private String createBy;
/**
* 创建时间
*/
@TableField(value = "create_time", fill = FieldFill.INSERT)
private LocalDateTime createTime;
/**
* 更新者
*/
@TableField("update_by")
private String updateBy;
/**
* 更新时间
*/
@TableField(value = "update_time", fill = FieldFill.INSERT_UPDATE)
private LocalDateTime updateTime;
/**
* 删除标志（0代表存在 2代表删除）
*/
@TableField("del_flag")
@TableLogic
private String delFlag;
}
package com.apple.erp.entity;
import com.baomidou.mybatisplus.annotation.*;
import lombok.Data;
import lombok.EqualsAndHashCode;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.List;
/**
* 系统菜单实体类
*
* @author Apple ERP Team
* @version 1.0.0
* @since 2024-01-01
*/
@Data
@EqualsAndHashCode(callSuper = false)
@TableName("t_sys_menu")
public class SysMenu {
/**
* 菜单ID
*/
@TableId(value = "menu_id", type = IdType.AUTO)
private Long menuId;
/**
* 菜单名称
*/
@TableField("menu_name")
private String menuName;
/**
* 父菜单ID
*/
@TableField("parent_id")
private Long parentId;
/**
* 排序号
*/
@TableField("sort")
private Integer sort;
/**
* 路由地址
*/
@TableField("path")
private String path;
/**
* 菜单类型（0-目录/1-菜单/2-按钮）
*/
@TableField("menu_type")
private String menuType;
/**
* 菜单状态（0-隐藏/1-显示）
*/
@TableField("status")
private String status;
/**
* 权限标识
*/
@TableField("perms")
private String perms;
/**
* 菜单图标
*/
@TableField("icon")
private String icon;
/**
* 创建者
*/
@TableField("create_by")
private String createBy;
/**
* 创建时间
*/
@TableField(value = "create_time", fill = FieldFill.INSERT)
private LocalDateTime createTime;
/**
* 更新者
*/
@TableField("update_by")
private String updateBy;
/**
* 更新时间
*/
@TableField(value = "update_time", fill = FieldFill.INSERT_UPDATE)
private LocalDateTime updateTime;
/**
* 删除标志（0代表存在 2代表删除）
*/
@TableField("del_flag")
@TableLogic
private String delFlag;
/**
* 子菜单列表
* 用于构建菜单树结构，不映射到数据库字段
*/
@TableField(exist = false)
private List<SysMenu> children = new ArrayList<>();
}
package com.apple.erp.entity;
import com.baomidou.mybatisplus.annotation.*;
import lombok.Data;
import lombok.EqualsAndHashCode;
import java.time.LocalDateTime;
/**
* 系统角色实体类
*
* @author Apple ERP Team
* @version 1.0.0
* @since 2024-01-01
*/
@Data
@EqualsAndHashCode(callSuper = false)
@TableName("t_sys_role")
public class SysRole {
/**
* 角色ID
*/
@TableId(value = "role_id", type = IdType.AUTO)
private Long roleId;
/**
* 角色编码
*/
@TableField("role_code")
private String roleCode;
/**
* 角色名称
*/
@TableField("role_name")
private String roleName;
/**
* 状态（0-停用/1-启用）
*/
@TableField("status")
private Integer status;
/**
* 备注
*/
@TableField("remark")
private String remark;
/**
* 创建者
*/
@TableField("create_by")
private String createBy;
/**
* 创建时间
*/
@TableField(value = "create_time", fill = FieldFill.INSERT)
private LocalDateTime createTime;
/**
* 更新者
*/
@TableField("update_by")
private String updateBy;
/**
* 更新时间
*/
@TableField(value = "update_time", fill = FieldFill.INSERT_UPDATE)
private LocalDateTime updateTime;
/**
* 删除标志（0代表存在 2代表删除）
*/
@TableField("del_flag")
@TableLogic
private String delFlag;
}
package com.apple.erp.entity;
import com.baomidou.mybatisplus.annotation.*;
import lombok.Data;
import lombok.EqualsAndHashCode;
import java.time.LocalDateTime;
/**
* 角色菜单关联实体类
*
* @author Apple ERP Team
* @version 1.0.0
* @since 2024-01-01
*/
@Data
@EqualsAndHashCode(callSuper = false)
@TableName("t_sys_role_menu")
public class SysRoleMenu {
/**
* 关联ID
*/
@TableId(value = "id", type = IdType.AUTO)
private Long id;
/**
* 角色ID
*/
@TableField("role_id")
private Long roleId;
/**
* 菜单ID
*/
@TableField("menu_id")
private Long menuId;
/**
* 创建者
*/
@TableField("create_by")
private String createBy;
/**
* 创建时间
*/
@TableField(value = "create_time", fill = FieldFill.INSERT)
private LocalDateTime createTime;
/**
* 更新者
*/
@TableField("update_by")
private String updateBy;
/**
* 更新时间
*/
@TableField(value = "update_time", fill = FieldFill.INSERT_UPDATE)
private LocalDateTime updateTime;
/**
* 删除标志（0代表存在 2代表删除）
*/
@TableField("del_flag")
@TableLogic
private String delFlag;
}
package com.apple.erp.entity;
import com.baomidou.mybatisplus.annotation.*;
import lombok.Data;
import lombok.EqualsAndHashCode;
import java.time.LocalDateTime;
import java.util.List;
/**
* 系统用户实体类
*
* @author Apple ERP Team
* @version 1.0.0
* @since 2024-01-01
*/
@Data
@EqualsAndHashCode(callSuper = false)
@TableName("t_sys_user")
public class SysUser {
/**
* 用户ID
*/
@TableId(value = "user_id", type = IdType.AUTO)
private Long userId;
/**
* 用户名
*/
@TableField("username")
private String username;
/**
* 真实姓名
*/
@TableField("real_name")
private String realName;
/**
* 密码
*/
@TableField("password")
private String password;
/**
* 手机号
*/
@TableField("phone")
private String phone;
/**
* 邮箱
*/
@TableField("email")
private String email;
/**
* 状态（0-停用/1-启用）
*/
@TableField("status")
private Integer status;
/**
* 最后登录时间
*/
@TableField("last_login_time")
private LocalDateTime lastLoginTime;
/**
* 最后登录IP
*/
@TableField("last_login_ip")
private String lastLoginIp;
/**
* 备注
*/
@TableField("remark")
private String remark;
/**
* 创建者
*/
@TableField("create_by")
private String createBy;
/**
* 创建时间
*/
@TableField(value = "create_time", fill = FieldFill.INSERT)
private LocalDateTime createTime;
/**
* 更新者
*/
@TableField("update_by")
private String updateBy;
/**
* 更新时间
*/
@TableField(value = "update_time", fill = FieldFill.INSERT_UPDATE)
private LocalDateTime updateTime;
/**
* 删除标志（0代表存在 2代表删除）
*/
@TableField("del_flag")
@TableLogic
private String delFlag;
/**
* 用户角色列表（非数据库字段）
*/
@TableField(exist = false)
private List<SysRole> roles;
/**
* 用户权限列表（非数据库字段）
*/
@TableField(exist = false)
private List<String> permissions;
}
package com.apple.erp.entity;
import com.baomidou.mybatisplus.annotation.*;
import lombok.Data;
import lombok.EqualsAndHashCode;
import java.time.LocalDateTime;
/**
* 用户角色关联实体类
*
* @author Apple ERP Team
* @version 1.0.0
* @since 2024-01-01
*/
@Data
@EqualsAndHashCode(callSuper = false)
@TableName("t_sys_user_role")
public class SysUserRole {
/**
* 关联ID
*/
@TableId(value = "id", type = IdType.AUTO)
private Long id;
/**
* 用户ID
*/
@TableField("user_id")
private Long userId;
/**
* 角色ID
*/
@TableField("role_id")
private Long roleId;
/**
* 创建者
*/
@TableField("create_by")
private String createBy;
/**
* 创建时间
*/
@TableField(value = "create_time", fill = FieldFill.INSERT)
private LocalDateTime createTime;
/**
* 更新者
*/
@TableField("update_by")
private String updateBy;
/**
* 更新时间
*/
@TableField(value = "update_time", fill = FieldFill.INSERT_UPDATE)
private LocalDateTime updateTime;
/**
* 删除标志（0代表存在 2代表删除）
*/
@TableField("del_flag")
@TableLogic
private String delFlag;
}
package com.apple.erp.exception;
/**
* 业务异常类
*
* @author Apple ERP Team
* @version 1.0.0
* @since 2024-01-01
*/
public class BusinessException extends RuntimeException {
private Integer code;
public BusinessException() {
super();
}
public BusinessException(String message) {
super(message);
this.code = 500;
}
public BusinessException(Integer code, String message) {
super(message);
this.code = code;
}
public BusinessException(String message, Throwable cause) {
super(message, cause);
this.code = 500;
}
public BusinessException(Integer code, String message, Throwable cause) {
super(message, cause);
this.code = code;
}
public Integer getCode() {
return code;
}
public void setCode(Integer code) {
this.code = code;
}
}
package com.apple.erp.exception;
import com.apple.erp.vo.ResultVO;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.http.HttpStatus;
import org.springframework.security.access.AccessDeniedException;
import org.springframework.security.authentication.BadCredentialsException;
import org.springframework.security.core.AuthenticationException;
import org.springframework.validation.BindException;
import org.springframework.validation.FieldError;
import org.springframework.web.bind.MethodArgumentNotValidException;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseStatus;
import org.springframework.web.bind.annotation.RestControllerAdvice;
import javax.servlet.http.HttpServletRequest;
import java.util.HashMap;
import java.util.Map;
/**
* 全局异常处理器
*
* @author Apple ERP Team
* @version 1.0.0
* @since 2024-01-01
*/
@RestControllerAdvice
public class GlobalExceptionHandler {
private static final Logger logger = LoggerFactory.getLogger(GlobalExceptionHandler.class);
/**
* 业务异常处理
*/
@ExceptionHandler(BusinessException.class)
@ResponseStatus(HttpStatus.BAD_REQUEST)
public ResultVO<Object> handleBusinessException(BusinessException e, HttpServletRequest request) {
logger.warn("业务异常: {} - {}", request.getRequestURI(), e.getMessage());
return ResultVO.error(e.getCode(), e.getMessage());
}
/**
* 参数验证异常处理
*/
@ExceptionHandler(MethodArgumentNotValidException.class)
@ResponseStatus(HttpStatus.BAD_REQUEST)
public ResultVO<Object> handleValidationException(MethodArgumentNotValidException e) {
Map<String, String> errors = new HashMap<>();
e.getBindingResult().getAllErrors().forEach(error -> {
String fieldName = ((FieldError) error).getField();
String errorMessage = error.getDefaultMessage();
errors.put(fieldName, errorMessage);
});
return ResultVO.error(400, "参数验证失败", errors);
}
/**
* 绑定异常处理
*/
@ExceptionHandler(BindException.class)
@ResponseStatus(HttpStatus.BAD_REQUEST)
public ResultVO<Object> handleBindException(BindException e) {
Map<String, String> errors = new HashMap<>();
e.getBindingResult().getAllErrors().forEach(error -> {
String fieldName = ((FieldError) error).getField();
String errorMessage = error.getDefaultMessage();
errors.put(fieldName, errorMessage);
});
return ResultVO.error(400, "参数绑定失败", errors);
}
/**
* 认证异常处理
*/
@ExceptionHandler(AuthenticationException.class)
@ResponseStatus(HttpStatus.UNAUTHORIZED)
public ResultVO<Object> handleAuthenticationException(AuthenticationException e, HttpServletRequest request) {
logger.warn("认证异常: {} - {}", request.getRequestURI(), e.getMessage());
return ResultVO.error(401, "认证失败");
}
/**
* 授权异常处理
*/
@ExceptionHandler(AccessDeniedException.class)
@ResponseStatus(HttpStatus.FORBIDDEN)
public ResultVO<Object> handleAccessDeniedException(AccessDeniedException e, HttpServletRequest request) {
logger.warn("授权异常: {} - {}", request.getRequestURI(), e.getMessage());
return ResultVO.error(403, "权限不足");
}
/**
* 密码错误异常处理
*/
@ExceptionHandler(BadCredentialsException.class)
@ResponseStatus(HttpStatus.UNAUTHORIZED)
public ResultVO<Object> handleBadCredentialsException(BadCredentialsException e, HttpServletRequest request) {
logger.warn("密码错误: {} - {}", request.getRequestURI(), e.getMessage());
return ResultVO.error(401, "用户名或密码错误");
}
/**
* 非法参数异常处理
*/
@ExceptionHandler(IllegalArgumentException.class)
@ResponseStatus(HttpStatus.BAD_REQUEST)
public ResultVO<Object> handleIllegalArgumentException(IllegalArgumentException e, HttpServletRequest request) {
logger.warn("非法参数: {} - {}", request.getRequestURI(), e.getMessage());
return ResultVO.error(400, "参数错误: " + e.getMessage());
}
/**
* 空指针异常处理
*/
@ExceptionHandler(NullPointerException.class)
@ResponseStatus(HttpStatus.INTERNAL_SERVER_ERROR)
public ResultVO<Object> handleNullPointerException(NullPointerException e, HttpServletRequest request) {
logger.error("空指针异常: {} - {}", request.getRequestURI(), e.getMessage(), e);
return ResultVO.error(500, "系统内部错误");
}
/**
* 通用异常处理
*/
@ExceptionHandler(Exception.class)
@ResponseStatus(HttpStatus.INTERNAL_SERVER_ERROR)
public ResultVO<Object> handleException(Exception e, HttpServletRequest request) {
logger.error("系统异常: {} - {}", request.getRequestURI(), e.getMessage(), e);
return ResultVO.error(500, "系统内部错误");
}
}
This diff is collapsed. Click to expand it.
This diff is collapsed. Click to expand it.
This diff is collapsed. Click to expand it.
This diff is collapsed. Click to expand it.
This diff is collapsed. Click to expand it.
This diff is collapsed. Click to expand it.
This diff is collapsed. Click to expand it.
This diff is collapsed. Click to expand it.
This diff is collapsed. Click to expand it.
This diff is collapsed. Click to expand it.
This diff is collapsed. Click to expand it.
This diff is collapsed. Click to expand it.
This diff is collapsed. Click to expand it.
This diff is collapsed. Click to expand it.
This diff is collapsed. Click to expand it.
This diff is collapsed. Click to expand it.
This diff is collapsed. Click to expand it.
This diff is collapsed. Click to expand it.
This diff is collapsed. Click to expand it.
This diff is collapsed. Click to expand it.
This diff is collapsed. Click to expand it.
This diff is collapsed. Click to expand it.
This diff is collapsed. Click to expand it.
This diff is collapsed. Click to expand it.
This diff is collapsed. Click to expand it.
This diff is collapsed. Click to expand it.
This diff is collapsed. Click to expand it.
This diff is collapsed. Click to expand it.
This diff is collapsed. Click to expand it.
This diff is collapsed. Click to expand it.
This diff is collapsed. Click to expand it.
This diff is collapsed. Click to expand it.
This diff is collapsed. Click to expand it.
This diff is collapsed. Click to expand it.
This diff is collapsed. Click to expand it.
This diff is collapsed. Click to expand it.
This diff is collapsed. Click to expand it.
This diff is collapsed. Click to expand it.
This diff is collapsed. Click to expand it.
This diff is collapsed. Click to expand it.
This diff is collapsed. Click to expand it.
This diff is collapsed. Click to expand it.
This diff is collapsed. Click to expand it.
This diff is collapsed. Click to expand it.
This diff is collapsed. Click to expand it.
This diff is collapsed. Click to expand it.
This diff is collapsed. Click to expand it.
This diff is collapsed. Click to expand it.
This diff could not be displayed because it is too large.
This diff is collapsed. Click to expand it.
This diff is collapsed. Click to expand it.
This diff is collapsed. Click to expand it.
This diff is collapsed. Click to expand it.
This diff is collapsed. Click to expand it.
This diff is collapsed. Click to expand it.
This diff is collapsed. Click to expand it.
This diff is collapsed. Click to expand it.
This diff is collapsed. Click to expand it.
This diff is collapsed. Click to expand it.
This diff is collapsed. Click to expand it.
This diff is collapsed. Click to expand it.
This diff is collapsed. Click to expand it.
This diff is collapsed. Click to expand it.
This diff is collapsed. Click to expand it.
This diff is collapsed. Click to expand it.
This diff is collapsed. Click to expand it.
This diff is collapsed. Click to expand it.
This diff is collapsed. Click to expand it.
This diff is collapsed. Click to expand it.
This diff is collapsed. Click to expand it.
This diff is collapsed. Click to expand it.
This diff is collapsed. Click to expand it.
This diff is collapsed. Click to expand it.
This diff is collapsed. Click to expand it.
This diff is collapsed. Click to expand it.
This diff is collapsed. Click to expand it.
This diff is collapsed. Click to expand it.
This diff is collapsed. Click to expand it.
This diff is collapsed. Click to expand it.
This diff is collapsed. Click to expand it.
This diff is collapsed. Click to expand it.
This diff is collapsed. Click to expand it.
This diff is collapsed. Click to expand it.
This diff is collapsed. Click to expand it.
This diff is collapsed. Click to expand it.
This diff is collapsed. Click to expand it.
This diff is collapsed. Click to expand it.
This diff is collapsed. Click to expand it.
This diff is collapsed. Click to expand it.