diff --git a/README.md b/README.md
index 33fa88f..f8dc5dc 100644
--- a/README.md
+++ b/README.md
@@ -1,213 +1,74 @@
-# Crawlful Hub
+# Crawlful Hub Java Backend
-> 全自动化跨境电商运营平台 | AI驱动 | 多平台集成
+基于 Spring Boot 3.x 的 Java 后端实现，用于 Crawlful Hub 项目。
----
+## 技术栈
-## 项目简介
+- **框架**: Spring Boot 3.2.0
+- **Java 版本**: Java 17
+- **数据库**: MySQL 8.0
+- **缓存**: Redis
+- **认证**: JWT
+- **构建工具**: Maven
-Crawlful Hub 是一个全自动化的跨境电商运营平台，集成了商品管理、订单处理、物流策略、广告营销、B2B贸易等核心功能，通过 AI 技术实现智能决策和自动化运营。
+## 功能模块
-### 核心特性
-
-- � **多平台统一管理** - 支持 TikTok、Shopee、Shopify、Amazon 等 12+ 平台
-- 🤖 **AI 智能决策** - 自动调价、智能选品、广告优化
-- 📊 **全链路追踪** - 五元组追踪体系，确保数据一致性
-- 🔐 **企业级安全** - RBAC 权限模型，租户隔离
-
----
-
-## 快速导航
-
-| 文档类型 | 路径 | 说明 |
-|---------|------|------|
-| 📋 **任务中心** | [TASKS/](docs/TASKS/_index.md) | P0/P1/P2 任务列表与进度 |
-| 📐 **架构设计** | [ARCH/](docs/ARCH/_index.md) | 系统架构、领域模型、服务地图 |
-| 📖 **规则规范** | [RULES/](docs/RULES/_index.md) | 数据库、API、安全、TypeScript 规范 |
-| 🔧 **服务文档** | [SERVICES/](docs/SERVICES/_index.md) | 各业务服务设计文档 |
-| 🔗 **业务闭环** | [LOOPS/](docs/LOOPS/_index.md) | 商品、订单、营销等闭环文档 |
-| 📚 **API 文档** | [API_Documentations/](docs/API_Documentations/) | 各平台 API 集成文档 |
-
----
-
-## 核心功能
-
-### 1. 商品管理 (PIM)
-- 商品刊登与映射
-- 库存同步与管理
-- 商品健康度监控
-- AI 智能定价
-
-### 2. 订单管理 (OMS)
-- 多平台订单集中管理
-- 订单履约与异常处理
-- 批量订单处理
-- 自动化发货
-
-### 3. 营销管理 (MKT)
-- 广告计划创建与管理
-- 投放效果分析
-- ROI 优化
-- GMV Max 自动化
-
-### 4. 财务管理 (FIN)
-- 多平台对账
-- 利润计算与分析
-- 成本核算
-- 风控预警
-
-### 5. B2B 贸易
-- 企业报价管理
-- 批量订单处理
-- 合同管理
-- 利润红线控制
-
-### 6. 售后逆向
-- 退货申请处理
-- 退款流程管理
-- 客户服务
-
-### 7. 合规与证书
-- 证书管理与过期提醒
-- 合规检查
-- 平台资质管理
-
----
-
-## 项目架构
-
-### 技术栈
-
-| 层级 | 技术 |
-|------|------|
-| **前端** | React 18, TypeScript, UmiJS 4, Tailwind CSS, Ant Design |
-| **后端** | Node.js 18+, Express, TypeScript |
-| **数据库** | MySQL 8.0 (阿里云 RDS) |
-| **缓存** | Redis 6.0 |
-| **队列** | BullMQ |
-| **自动化** | Playwright |
-| **AI** | 多 AI 服务集成 |
-
-### 模块结构
-
-```
-makemd/
-├── dashboard/ # 前端管理控制台
-├── server/ # 后端服务
-├── node-agent/ # 节点代理 (Playwright 自动化)
-├── scripts/ # 脚本工具
-├── docs/ # 项目文档
-│ ├── TASKS/ # 任务中心
-│ ├── ARCH/ # 架构设计
-│ ├── RULES/ # 规则规范
-│ ├── SERVICES/ # 服务文档
-│ ├── LOOPS/ # 业务闭环
-│ └── API_Documentations/ # API 文档
-└── .trae/ # AI 协作配置
-```
-
----
+- 认证与授权
+- 商品管理
+- 订单管理
+- 支付处理
+- 物流跟踪
+- 数据采集
+- 报表分析
+- 系统监控
+- 告警管理
+- 配置管理
+- 审计日志
## 快速开始
### 环境要求
-- Node.js 16+
+- JDK 17+
- MySQL 8.0+
- Redis 6.0+
+- Maven 3.6+
-### 安装依赖
+### 配置
+
+编辑 `src/main/resources/application.yml` 文件，配置数据库连接、Redis 连接等信息。
+
+### 运行
```bash
-# 后端依赖
-cd server && npm install
-
-# 前端依赖
-cd ../dashboard && npm install
-
-# Node Agent 依赖
-cd ../node-agent && npm install
+mvn spring-boot:run
```
-### 数据库初始化
+### 构建
```bash
-mysql -u root -p < scripts/db-init.sql
+mvn clean package
```
-### 启动服务
+### 运行测试
```bash
-# 后端服务
-cd server && npm run dev
-
-# 前端服务
-cd dashboard && npm run dev
-
-# Node Agent
-cd node-agent && npm run dev
+mvn test
```
----
+## 文档
-## 开发规范
-
-### 代码规范
-
-- 遵循 TypeScript 最佳实践
-- 使用 ESLint 进行代码检查
-- 提交前运行 `npm run check` 进行类型检查
-- 所有业务逻辑必须在 Service 层实现
-
-### 提交规范
-
-- 提交信息使用中文描述
-- 提交前确保代码通过测试
-- 大型功能提交前创建分支
-
-### 核心约束
-
-```typescript
-// 数据库
-表前缀: 'cf_' // cf_product, cf_order
-金额类型: decimal(10,2) // 禁止 float/double
-
-// 业务类型
-TOC: 零售/C端
-TOB: 企业/B端
-// 禁止使用 B2C/B2B
-
-// 利润红线
-TOB利润率 < 15%: 禁止报价
-TOC利润率 < 20%: 触发风控预警
-```
-
----
-
-## 文档索引
-
-### 规则文档
-
-| 文档 | 说明 |
-|------|------|
-| [术语标准](docs/RULES/TERMINOLOGY.md) | 标准术语、命名规范 |
-| [数据库规则](docs/RULES/database.md) | 表命名、字段类型 |
-| [API 规则](docs/RULES/api.md) | 路由、权限、响应格式 |
-| [安全规则](docs/RULES/security.md) | RBAC、数据隔离 |
-| [TypeScript 规则](docs/RULES/typescript.md) | 类型定义、编译 |
-| [业务规则](docs/RULES/business.md) | 利润红线、决策流程 |
-| [协作规则](docs/RULES/collaboration.md) | AI 协作、任务领取 |
-
-### 架构文档
-
-| 文档 | 说明 |
-|------|------|
-| [系统架构](docs/ARCH/system.md) | 整体架构设计 |
-| [领域模型](docs/ARCH/domain.md) | 核心领域设计 |
-| [服务地图](docs/ARCH/backend.md) | 服务依赖关系 |
-| [状态机](docs/ARCHIVE/01_Architecture/06_State_Machine.md) | 状态流转定义 |
-
----
+- [项目概览](docs/00_Project_Overview.md)
+- [架构设计](docs/01_Architecture_Design.md)
+- [API 文档](docs/02_API_Documentation.md)
+- [部署指南](docs/03_Deployment_Guide.md)
+- [测试指南](docs/04_Test_Guide.md)
+- [数据库设计](docs/05_Database_Design.md)
+- [安全指南](docs/06_Security_Guide.md)
+- [维护指南](docs/07_Maintenance_Guide.md)
+- [国际化指南](docs/08_Internationalization_Guide.md)
+- [开发指南](docs/09_Development_Guide.md)
+- [API 变更日志](docs/10_API_Changelog.md)
## 许可证
diff --git a/docs/00_Project_Overview.md b/docs/00_Project_Overview.md
new file mode 100644
index 0000000..b076401
--- /dev/null
+++ b/docs/00_Project_Overview.md
@@ -0,0 +1,90 @@
+# 项目概览
+
+## 1. 项目简介
+
+Crawlful Hub 是一个基于 Spring Boot 3.x 的后端服务，用于管理商品、订单、支付、物流等业务流程。本项目是从原有的 Node.js 后端平移而来，保持了与原系统的 API 兼容性，同时提供了更强大的性能和可扩展性。
+
+## 2. 技术栈
+
+- **框架**: Spring Boot 3.2.0
+- **语言**: Java 17
+- **数据库**: MySQL 8.0
+- **缓存**: Redis
+- **认证**: JWT
+- **构建工具**: Maven
+- **API 文档**: Springdoc OpenAPI
+- **日志系统**: Logback
+- **测试**: JUnit 5
+
+## 3. 核心功能
+
+- **用户认证与授权**: 基于 JWT 的身份验证和基于角色的访问控制
+- **商品管理**: 商品的创建、查询、更新和删除
+- **订单管理**: 订单的创建、查询、更新和状态管理
+- **支付管理**: 支付的创建、查询、更新和状态管理
+- **物流管理**: 物流的创建、查询、更新和状态管理
+- **系统监控**: 系统健康状态、性能指标、服务状态等
+- **告警管理**: 系统告警的创建、查询、更新和处理
+- **审计日志**: 系统操作的审计记录
+- **配置管理**: 系统配置的管理
+- **数据管理**: 数据的导入、导出和处理
+- **报表生成**: 系统报表的生成
+
+## 4. 项目结构
+
+```
+serverjava/
+├── src/
+│ ├── main/
+│ │ ├── java/
+│ │ │ └── com/
+│ │ │ └── crawlful/
+│ │ │ └── hub/
+│ │ │ ├── api/ # API 控制器
+│ │ │ ├── config/ # 系统配置
+│ │ │ ├── exception/ # 异常处理
+│ │ │ ├── model/ # 数据模型
+│ │ │ ├── service/ # 业务逻辑
+│ │ │ ├── util/ # 工具类
+│ │ │ └── Application.java # 应用入口
+│ │ └── resources/
+│ │ ├── db/ # 数据库迁移脚本
+│ │ ├── i18n/ # 国际化资源
+│ │ ├── application.yml # 应用配置
+│ │ └── logback.xml # 日志配置
+│ └── test/ # 测试代码
+├── docs/ # 项目文档
+├── README.md # 项目说明
+├── index.md # 项目索引
+└── pom.xml # Maven 配置
+```
+
+## 5. API 兼容性
+
+本项目保持了与原 Node.js 后端的 API 兼容性，确保前端和客户端代码无需修改即可正常工作。API 路径、参数和返回格式都与原系统保持一致。
+
+## 6. 性能优化
+
+- **数据库连接池**: 使用 HikariCP 优化数据库连接管理
+- **缓存**: 使用 Redis 缓存高频访问数据
+- **分页查询**: 实现分页查询，避免一次性加载大量数据
+- **索引优化**: 为数据库表添加适当的索引，提高查询性能
+
+## 7. 安全增强
+
+- **CSRF 保护**: 实现 CSRF 令牌验证
+- **速率限制**: 限制 API 请求频率，防止恶意请求
+- **密码加密**: 使用 BCrypt 加密用户密码
+- **JWT 认证**: 使用 JWT 进行身份验证，确保 API 安全
+
+## 8. 国际化支持
+
+本项目支持国际化，提供了英文和中文的资源文件，可以根据请求的 Accept-Language 头自动切换语言。
+
+## 9. 监控与告警
+
+本项目实现了系统监控和告警功能，可以实时监控系统的健康状态、性能指标和服务状态，并在异常情况下生成告警。
+
+## 10. 部署与运维
+
+本项目使用 Maven 构建，可以部署到任何支持 Java 17 的环境中。详细的部署方法请参考部署文档。
diff --git a/docs/01_Architecture_Design.md b/docs/01_Architecture_Design.md
new file mode 100644
index 0000000..d5a94d7
--- /dev/null
+++ b/docs/01_Architecture_Design.md
@@ -0,0 +1,181 @@
+# 架构设计
+
+## 1. 架构概述
+
+Crawlful Hub 采用分层架构设计，确保系统的可维护性、可扩展性和可测试性。系统分为控制器层、服务层、仓库层和模型层，各层之间通过依赖注入进行解耦，实现了高内聚、低耦合的设计目标。
+
+## 2. 分层架构
+
+### 2.1 控制器层（Controller）
+
+控制器层负责处理 HTTP 请求，包括请求参数的验证、调用服务层的方法、处理异常和返回响应。控制器层不包含业务逻辑，只负责请求和响应的处理。
+
+**主要职责**：
+- 接收 HTTP 请求
+- 验证请求参数
+- 调用服务层处理业务逻辑
+- 处理异常
+- 返回 HTTP 响应
+
+**核心控制器**：
+- `AuthController`：处理认证相关的请求
+- `UserController`：处理用户管理相关的请求
+- `ProductController`：处理商品管理相关的请求
+- `OrderController`：处理订单管理相关的请求
+- `PaymentController`：处理支付管理相关的请求
+- `LogisticsController`：处理物流管理相关的请求
+- `MonitoringController`：处理监控相关的请求
+- `AlertController`：处理告警相关的请求
+- `AuditController`：处理审计相关的请求
+- `ConfigController`：处理配置相关的请求
+- `DataController`：处理数据相关的请求
+- `ReportController`：处理报表相关的请求
+
+### 2.2 服务层（Service）
+
+服务层是业务逻辑的核心，负责实现业务规则、处理业务流程和协调多个仓库的操作。服务层通过依赖注入使用仓库层的方法，实现业务逻辑的封装和复用。
+
+**主要职责**：
+- 实现业务逻辑
+- 处理业务流程
+- 协调多个仓库的操作
+- 管理事务
+- 处理异常
+
+**核心服务**：
+- `AuthService`：处理认证相关的业务逻辑
+- `UserService`：处理用户管理相关的业务逻辑
+- `ProductService`：处理商品管理相关的业务逻辑
+- `OrderService`：处理订单管理相关的业务逻辑
+- `PaymentService`：处理支付管理相关的业务逻辑
+- `LogisticsService`：处理物流管理相关的业务逻辑
+- `MonitoringService`：处理监控相关的业务逻辑
+- `AlertService`：处理告警相关的业务逻辑
+- `AuditService`：处理审计相关的业务逻辑
+- `ConfigService`：处理配置相关的业务逻辑
+- `DataService`：处理数据相关的业务逻辑
+- `ReportService`：处理报表相关的业务逻辑
+
+### 2.3 仓库层（Repository）
+
+仓库层负责数据访问，包括数据库的 CRUD 操作。仓库层通过 Spring Data JPA 实现，提供了简洁的数据库操作接口。
+
+**主要职责**：
+- 实现数据库的 CRUD 操作
+- 提供查询方法
+- 管理数据库事务
+
+**核心仓库**：
+- `UserRepository`：处理用户数据的访问
+- `ProductRepository`：处理商品数据的访问
+- `OrderRepository`：处理订单数据的访问
+- `PaymentRepository`：处理支付数据的访问
+- `LogisticsRepository`：处理物流数据的访问
+- `AlertRepository`：处理告警数据的访问
+- `AuditRepository`：处理审计数据的访问
+- `ConfigRepository`：处理配置数据的访问
+
+### 2.4 模型层（Model）
+
+模型层定义了数据结构，包括实体类和 DTO（数据传输对象）。实体类对应数据库表，DTO 用于在不同层之间传递数据。
+
+**主要职责**：
+- 定义数据结构
+- 映射数据库表
+- 提供数据访问方法
+
+**核心模型**：
+- `User`：用户模型
+- `Product`：商品模型
+- `Order`：订单模型
+- `Payment`：支付模型
+- `Logistics`：物流模型
+- `Alert`：告警模型
+- `Audit`：审计模型
+- `Config`：配置模型
+
+## 3. 核心流程
+
+### 3.1 用户认证流程
+
+1. **用户注册**：用户提交注册信息，`AuthController` 调用 `AuthService` 的 `register` 方法，验证输入数据，创建用户并返回用户信息。
+2. **用户登录**：用户提交登录信息，`AuthController` 调用 `AuthService` 的 `login` 方法，验证用户名和密码，生成 JWT 令牌并返回。
+3. **令牌验证**：请求携带 JWT 令牌，`SecurityConfig` 验证令牌的有效性，确保用户已认证。
+
+### 3.2 商品管理流程
+
+1. **创建商品**：用户提交商品信息，`ProductController` 调用 `ProductService` 的 `create` 方法，验证输入数据，创建商品并返回商品信息。
+2. **查询商品**：用户请求商品列表，`ProductController` 调用 `ProductService` 的 `getAll` 方法，根据过滤条件查询商品并返回。
+3. **更新商品**：用户提交商品更新信息，`ProductController` 调用 `ProductService` 的 `update` 方法，验证输入数据，更新商品并返回更新后的商品信息。
+4. **删除商品**：用户请求删除商品，`ProductController` 调用 `ProductService` 的 `delete` 方法，删除商品并返回成功信息。
+
+### 3.3 订单管理流程
+
+1. **创建订单**：用户提交订单信息，`OrderController` 调用 `OrderService` 的 `createOrder` 方法，验证输入数据，创建订单并返回订单信息。
+2. **查询订单**：用户请求订单列表，`OrderController` 调用 `OrderService` 的 `getOrders` 方法，根据过滤条件查询订单并返回。
+3. **更新订单**：用户提交订单更新信息，`OrderController` 调用 `OrderService` 的 `updateOrder` 方法，验证输入数据，更新订单并返回更新后的订单信息。
+4. **订单状态流转**：用户请求更新订单状态，`OrderController` 调用 `OrderService` 的 `transitionOrderStatus` 方法，更新订单状态并返回成功信息。
+
+### 3.4 支付管理流程
+
+1. **创建支付**：用户提交支付信息，`PaymentController` 调用 `PaymentService` 的 `create` 方法，验证输入数据，创建支付并返回支付信息。
+2. **查询支付**：用户请求支付列表，`PaymentController` 调用 `PaymentService` 的 `getAll` 方法，根据过滤条件查询支付并返回。
+3. **更新支付**：用户提交支付更新信息，`PaymentController` 调用 `PaymentService` 的 `update` 方法，验证输入数据，更新支付并返回更新后的支付信息。
+
+### 3.5 物流管理流程
+
+1. **创建物流**：用户提交物流信息，`LogisticsController` 调用 `LogisticsService` 的 `create` 方法，验证输入数据，创建物流并返回物流信息。
+2. **查询物流**：用户请求物流列表，`LogisticsController` 调用 `LogisticsService` 的 `getAll` 方法，根据过滤条件查询物流并返回。
+3. **更新物流**：用户提交物流更新信息，`LogisticsController` 调用 `LogisticsService` 的 `update` 方法，验证输入数据，更新物流并返回更新后的物流信息。
+
+### 3.6 监控与告警流程
+
+1. **系统健康检查**：用户请求系统健康状态，`MonitoringController` 调用 `MonitoringService` 的 `getSystemHealth` 方法，返回系统健康状态。
+2. **性能指标获取**：用户请求系统性能指标，`MonitoringController` 调用 `MonitoringService` 的 `getPerformanceMetrics` 方法，返回系统性能指标。
+3. **告警创建**：系统检测到异常，`AlertService` 创建告警并存储到数据库。
+4. **告警处理**：用户请求处理告警，`AlertController` 调用 `AlertService` 的 `resolveAlert` 方法，更新告警状态为已解决。
+
+## 4. 技术实现细节
+
+### 4.1 数据库设计
+
+- **用户表**：存储用户信息，包括用户名、密码、邮箱、角色等。
+- **商品表**：存储商品信息，包括标题、描述、价格、数量等。
+- **订单表**：存储订单信息，包括订单号、状态、总金额等。
+- **支付表**：存储支付信息，包括支付方式、金额、状态等。
+- **物流表**：存储物流信息，包括物流方式、跟踪号、状态等。
+- **告警表**：存储告警信息，包括告警类型、严重程度、状态等。
+- **审计表**：存储审计日志，包括操作类型、资源类型、操作人等。
+- **配置表**：存储系统配置，包括配置键、配置值、配置类型等。
+
+### 4.2 缓存实现
+
+使用 Redis 作为缓存存储，缓存高频访问的数据，如用户信息、商品信息等，提高系统的响应速度。
+
+### 4.3 安全实现
+
+- **JWT 认证**：使用 JWT 进行身份验证，确保 API 安全。
+- **CSRF 保护**：实现 CSRF 令牌验证，防止 CSRF 攻击。
+- **速率限制**：限制 API 请求频率，防止恶意请求。
+- **密码加密**：使用 BCrypt 加密用户密码，确保密码安全。
+
+### 4.4 国际化实现
+
+使用 Spring 的国际化支持，提供英文和中文的资源文件，根据请求的 Accept-Language 头自动切换语言。
+
+### 4.5 监控与告警实现
+
+- **系统健康检查**：实现系统健康状态检查，包括数据库连接、缓存状态等。
+- **性能指标监控**：实现系统性能指标监控，包括响应时间、请求次数等。
+- **告警管理**：实现告警的创建、查询、更新和处理，及时发现和处理系统异常。
+
+## 5. 扩展性设计
+
+- **模块化设计**：系统采用模块化设计，各模块之间通过接口进行通信，便于功能扩展和代码维护。
+- **依赖注入**：使用 Spring 的依赖注入，实现组件的解耦，便于单元测试和功能扩展。
+- **配置化**：系统的配置通过 application.yml 文件进行配置，便于环境切换和参数调整。
+- **插件化**：系统支持插件化开发，可以通过插件扩展系统功能。
+
+## 6. 总结
+
+Crawlful Hub 采用分层架构设计，实现了高内聚、低耦合的系统结构。系统通过控制器层、服务层、仓库层和模型层的划分，实现了业务逻辑的封装和复用，提高了系统的可维护性、可扩展性和可测试性。同时，系统通过缓存、安全、国际化等技术的应用，提高了系统的性能和用户体验。
diff --git a/docs/02_API_Documentation.md b/docs/02_API_Documentation.md
new file mode 100644
index 0000000..8243108
--- /dev/null
+++ b/docs/02_API_Documentation.md
@@ -0,0 +1,1965 @@
+# API 文档
+
+## 1. 认证 API
+
+### 1.1 注册用户
+
+**路径**: `/v1/auth/register`
+
+**方法**: `POST`
+
+**参数**:
+| 参数名 | 类型 | 必填 | 描述 |
+|-------|------|------|------|
+| username | string | 是 | 用户名 |
+| password | string | 是 | 密码 |
+| email | string | 是 | 邮箱 |
+| role | string | 是 | 角色 |
+| tenantId | string | 是 | 租户 ID |
+
+**返回格式**:
+```json
+{
+ "success": true,
+ "data": {
+ "id": 1
+ }
+}
+```
+
+### 1.2 用户登录
+
+**路径**: `/v1/auth/login`
+
+**方法**: `POST`
+
+**参数**:
+| 参数名 | 类型 | 必填 | 描述 |
+|-------|------|------|------|
+| username | string | 是 | 用户名 |
+| password | string | 是 | 密码 |
+
+**返回格式**:
+```json
+{
+ "success": true,
+ "data": {
+ "token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9..."
+ }
+}
+```
+
+## 2. 用户 API
+
+### 2.1 创建用户
+
+**路径**: `/v1/user`
+
+**方法**: `POST`
+
+**参数**:
+| 参数名 | 类型 | 必填 | 描述 |
+|-------|------|------|------|
+| username | string | 是 | 用户名 |
+| password | string | 是 | 密码 |
+| email | string | 是 | 邮箱 |
+| role | string | 是 | 角色 |
+| tenantId | string | 是 | 租户 ID |
+
+**返回格式**:
+```json
+{
+ "success": true,
+ "data": {
+ "id": 1
+ }
+}
+```
+
+### 2.2 获取用户列表
+
+**路径**: `/v1/user`
+
+**方法**: `GET`
+
+**参数**:
+| 参数名 | 类型 | 必填 | 描述 |
+|-------|------|------|------|
+| tenantId | string | 是 | 租户 ID |
+
+**返回格式**:
+```json
+{
+ "success": true,
+ "data": [
+ {
+ "id": 1,
+ "username": "admin",
+ "email": "admin@example.com",
+ "role": "ADMIN",
+ "createdAt": "2024-01-01T00:00:00.000Z",
+ "updatedAt": "2024-01-01T00:00:00.000Z"
+ }
+ ]
+}
+```
+
+### 2.3 获取用户详情
+
+**路径**: `/v1/user/{id}`
+
+**方法**: `GET`
+
+**参数**:
+| 参数名 | 类型 | 必填 | 描述 |
+|-------|------|------|------|
+| id | long | 是 | 用户 ID |
+| tenantId | string | 是 | 租户 ID |
+
+**返回格式**:
+```json
+{
+ "success": true,
+ "data": {
+ "id": 1,
+ "username": "admin",
+ "email": "admin@example.com",
+ "role": "ADMIN",
+ "createdAt": "2024-01-01T00:00:00.000Z",
+ "updatedAt": "2024-01-01T00:00:00.000Z"
+ }
+}
+```
+
+### 2.4 更新用户
+
+**路径**: `/v1/user/{id}`
+
+**方法**: `PUT`
+
+**参数**:
+| 参数名 | 类型 | 必填 | 描述 |
+|-------|------|------|------|
+| id | long | 是 | 用户 ID |
+| username | string | 否 | 用户名 |
+| password | string | 否 | 密码 |
+| email | string | 否 | 邮箱 |
+| role | string | 否 | 角色 |
+| tenantId | string | 是 | 租户 ID |
+
+**返回格式**:
+```json
+{
+ "success": true,
+ "data": {
+ "id": 1,
+ "username": "admin",
+ "email": "admin@example.com",
+ "role": "ADMIN",
+ "createdAt": "2024-01-01T00:00:00.000Z",
+ "updatedAt": "2024-01-01T00:00:00.000Z"
+ }
+}
+```
+
+### 2.5 删除用户
+
+**路径**: `/v1/user/{id}`
+
+**方法**: `DELETE`
+
+**参数**:
+| 参数名 | 类型 | 必填 | 描述 |
+|-------|------|------|------|
+| id | long | 是 | 用户 ID |
+| tenantId | string | 是 | 租户 ID |
+
+**返回格式**:
+```json
+{
+ "success": true
+}
+```
+
+## 3. 商品 API
+
+### 3.1 创建商品
+
+**路径**: `/v1/product`
+
+**方法**: `POST`
+
+**参数**:
+| 参数名 | 类型 | 必填 | 描述 |
+|-------|------|------|------|
+| title | string | 是 | 商品标题 |
+| description | string | 否 | 商品描述 |
+| mainImage | string | 否 | 商品主图 |
+| platform | string | 否 | 平台 |
+| platformProductId | string | 否 | 平台商品 ID |
+| price | double | 否 | 价格 |
+| costPrice | double | 否 | 成本价格 |
+| quantity | int | 否 | 数量 |
+| status | string | 否 | 状态 |
+| phash | string | 否 | 图片哈希 |
+| semanticHash | string | 否 | 语义哈希 |
+| vectorEmbedding | string | 否 | 向量嵌入 |
+| attributes | string | 否 | 属性 |
+| tenantId | string | 是 | 租户 ID |
+
+**返回格式**:
+```json
+{
+ "success": true,
+ "data": {
+ "id": 1
+ }
+}
+```
+
+### 3.2 获取商品列表
+
+**路径**: `/v1/product`
+
+**方法**: `GET`
+
+**参数**:
+| 参数名 | 类型 | 必填 | 描述 |
+|-------|------|------|------|
+| tenantId | string | 是 | 租户 ID |
+| platform | string | 否 | 平台 |
+| status | string | 否 | 状态 |
+| page | int | 否 | 页码，默认 1 |
+| size | int | 否 | 每页数量，默认 10 |
+
+**返回格式**:
+```json
+{
+ "success": true,
+ "data": [
+ {
+ "id": 1,
+ "title": "商品标题",
+ "description": "商品描述",
+ "mainImage": "图片 URL",
+ "platform": "平台",
+ "platformProductId": "平台商品 ID",
+ "price": 100.00,
+ "costPrice": 80.00,
+ "quantity": 100,
+ "status": "ACTIVE",
+ "phash": "图片哈希",
+ "semanticHash": "语义哈希",
+ "vectorEmbedding": "向量嵌入",
+ "attributes": "属性",
+ "createdAt": "2024-01-01T00:00:00.000Z",
+ "updatedAt": "2024-01-01T00:00:00.000Z"
+ }
+ ],
+ "page": 1,
+ "size": 10
+}
+```
+
+### 3.3 获取商品详情
+
+**路径**: `/v1/product/{id}`
+
+**方法**: `GET`
+
+**参数**:
+| 参数名 | 类型 | 必填 | 描述 |
+|-------|------|------|------|
+| id | long | 是 | 商品 ID |
+| tenantId | string | 是 | 租户 ID |
+
+**返回格式**:
+```json
+{
+ "success": true,
+ "data": {
+ "id": 1,
+ "title": "商品标题",
+ "description": "商品描述",
+ "mainImage": "图片 URL",
+ "platform": "平台",
+ "platformProductId": "平台商品 ID",
+ "price": 100.00,
+ "costPrice": 80.00,
+ "quantity": 100,
+ "status": "ACTIVE",
+ "phash": "图片哈希",
+ "semanticHash": "语义哈希",
+ "vectorEmbedding": "向量嵌入",
+ "attributes": "属性",
+ "createdAt": "2024-01-01T00:00:00.000Z",
+ "updatedAt": "2024-01-01T00:00:00.000Z"
+ }
+}
+```
+
+### 3.4 更新商品
+
+**路径**: `/v1/product/{id}`
+
+**方法**: `PUT`
+
+**参数**:
+| 参数名 | 类型 | 必填 | 描述 |
+|-------|------|------|------|
+| id | long | 是 | 商品 ID |
+| title | string | 否 | 商品标题 |
+| description | string | 否 | 商品描述 |
+| mainImage | string | 否 | 商品主图 |
+| platform | string | 否 | 平台 |
+| platformProductId | string | 否 | 平台商品 ID |
+| price | double | 否 | 价格 |
+| costPrice | double | 否 | 成本价格 |
+| quantity | int | 否 | 数量 |
+| status | string | 否 | 状态 |
+| phash | string | 否 | 图片哈希 |
+| semanticHash | string | 否 | 语义哈希 |
+| vectorEmbedding | string | 否 | 向量嵌入 |
+| attributes | string | 否 | 属性 |
+| tenantId | string | 是 | 租户 ID |
+
+**返回格式**:
+```json
+{
+ "success": true,
+ "data": {
+ "id": 1,
+ "title": "商品标题",
+ "description": "商品描述",
+ "mainImage": "图片 URL",
+ "platform": "平台",
+ "platformProductId": "平台商品 ID",
+ "price": 100.00,
+ "costPrice": 80.00,
+ "quantity": 100,
+ "status": "ACTIVE",
+ "phash": "图片哈希",
+ "semanticHash": "语义哈希",
+ "vectorEmbedding": "向量嵌入",
+ "attributes": "属性",
+ "createdAt": "2024-01-01T00:00:00.000Z",
+ "updatedAt": "2024-01-01T00:00:00.000Z"
+ }
+}
+```
+
+### 3.5 删除商品
+
+**路径**: `/v1/product/{id}`
+
+**方法**: `DELETE`
+
+**参数**:
+| 参数名 | 类型 | 必填 | 描述 |
+|-------|------|------|------|
+| id | long | 是 | 商品 ID |
+| tenantId | string | 是 | 租户 ID |
+
+**返回格式**:
+```json
+{
+ "success": true
+}
+```
+
+### 3.6 商品清洗与本地化
+
+**路径**: `/v1/product/{id}/wash-and-localize`
+
+**方法**: `POST`
+
+**参数**:
+| 参数名 | 类型 | 必填 | 描述 |
+|-------|------|------|------|
+| id | long | 是 | 商品 ID |
+| tenantId | string | 是 | 租户 ID |
+| targetMarket | string | 是 | 目标市场 |
+| targetLang | string | 是 | 目标语言 |
+
+**返回格式**:
+```json
+{
+ "success": true,
+ "data": {
+ "id": 1,
+ "title": "商品标题 (Localized for 目标市场)",
+ "description": "商品描述 (Localized for 目标市场)",
+ "targetMarket": "目标市场",
+ "targetLang": "目标语言",
+ "status": "LOCALIZED"
+ }
+}
+```
+
+### 3.7 商品套利分析
+
+**路径**: `/v1/product/{id}/analyze-arbitrage`
+
+**方法**: `GET`
+
+**参数**:
+| 参数名 | 类型 | 必填 | 描述 |
+|-------|------|------|------|
+| id | long | 是 | 商品 ID |
+| tenantId | string | 是 | 租户 ID |
+
+**返回格式**:
+```json
+{
+ "success": true,
+ "data": {
+ "productId": 1,
+ "price": 100.00,
+ "costPrice": 80.00,
+ "profitMargin": 20.0,
+ "arbitrageOpportunity": true
+ }
+}
+```
+
+## 4. 订单 API
+
+### 4.1 创建订单
+
+**路径**: `/v1/order`
+
+**方法**: `POST`
+
+**参数**:
+| 参数名 | 类型 | 必填 | 描述 |
+|-------|------|------|------|
+| shopId | string | 否 | 店铺 ID |
+| platform | string | 否 | 平台 |
+| platformOrderId | string | 否 | 平台订单 ID |
+| status | string | 否 | 状态 |
+| totalAmount | double | 否 | 总金额 |
+| currency | string | 否 | 货币 |
+| customerInfo | string | 否 | 客户信息 |
+| items | string | 否 | 商品列表 |
+| shippingAddress | string | 否 | shipping 地址 |
+| trackingNumber | string | 否 | 跟踪号 |
+| tenantId | string | 是 | 租户 ID |
+
+**返回格式**:
+```json
+{
+ "success": true,
+ "data": {
+ "id": 1
+ }
+}
+```
+
+### 4.2 获取订单列表
+
+**路径**: `/v1/order`
+
+**方法**: `GET`
+
+**参数**:
+| 参数名 | 类型 | 必填 | 描述 |
+|-------|------|------|------|
+| tenantId | string | 是 | 租户 ID |
+| platform | string | 否 | 平台 |
+| status | string | 否 | 状态 |
+| page | int | 否 | 页码 |
+| pageSize | int | 否 | 每页数量 |
+| startDate | string | 否 | 开始日期 |
+| endDate | string | 否 | 结束日期 |
+
+**返回格式**:
+```json
+{
+ "success": true,
+ "data": [
+ {
+ "id": 1,
+ "shopId": "店铺 ID",
+ "platform": "平台",
+ "platformOrderId": "平台订单 ID",
+ "status": "PENDING",
+ "totalAmount": 100.00,
+ "currency": "USD",
+ "customerInfo": "客户信息",
+ "items": "商品列表",
+ "shippingAddress": "shipping 地址",
+ "trackingNumber": "跟踪号",
+ "createdAt": "2024-01-01T00:00:00.000Z",
+ "updatedAt": "2024-01-01T00:00:00.000Z"
+ }
+ ]
+}
+```
+
+### 4.3 获取订单详情
+
+**路径**: `/v1/order/{id}`
+
+**方法**: `GET`
+
+**参数**:
+| 参数名 | 类型 | 必填 | 描述 |
+|-------|------|------|------|
+| id | string | 是 | 订单 ID |
+| tenantId | string | 是 | 租户 ID |
+
+**返回格式**:
+```json
+{
+ "success": true,
+ "data": {
+ "id": 1,
+ "shopId": "店铺 ID",
+ "platform": "平台",
+ "platformOrderId": "平台订单 ID",
+ "status": "PENDING",
+ "totalAmount": 100.00,
+ "currency": "USD",
+ "customerInfo": "客户信息",
+ "items": "商品列表",
+ "shippingAddress": "shipping 地址",
+ "trackingNumber": "跟踪号",
+ "createdAt": "2024-01-01T00:00:00.000Z",
+ "updatedAt": "2024-01-01T00:00:00.000Z"
+ }
+}
+```
+
+### 4.4 更新订单
+
+**路径**: `/v1/order/{id}`
+
+**方法**: `PUT`
+
+**参数**:
+| 参数名 | 类型 | 必填 | 描述 |
+|-------|------|------|------|
+| id | string | 是 | 订单 ID |
+| status | string | 否 | 状态 |
+| totalAmount | double | 否 | 总金额 |
+| currency | string | 否 | 货币 |
+| customerInfo | string | 否 | 客户信息 |
+| items | string | 否 | 商品列表 |
+| shippingAddress | string | 否 | shipping 地址 |
+| trackingNumber | string | 否 | 跟踪号 |
+| tenantId | string | 是 | 租户 ID |
+
+**返回格式**:
+```json
+{
+ "success": true,
+ "data": {
+ "id": 1,
+ "shopId": "店铺 ID",
+ "platform": "平台",
+ "platformOrderId": "平台订单 ID",
+ "status": "PENDING",
+ "totalAmount": 100.00,
+ "currency": "USD",
+ "customerInfo": "客户信息",
+ "items": "商品列表",
+ "shippingAddress": "shipping 地址",
+ "trackingNumber": "跟踪号",
+ "createdAt": "2024-01-01T00:00:00.000Z",
+ "updatedAt": "2024-01-01T00:00:00.000Z"
+ }
+}
+```
+
+### 4.5 删除订单
+
+**路径**: `/v1/order/{id}`
+
+**方法**: `DELETE`
+
+**参数**:
+| 参数名 | 类型 | 必填 | 描述 |
+|-------|------|------|------|
+| id | string | 是 | 订单 ID |
+| tenantId | string | 是 | 租户 ID |
+
+**返回格式**:
+```json
+{
+ "success": true
+}
+```
+
+### 4.6 订单状态流转
+
+**路径**: `/v1/order/{id}/transition`
+
+**方法**: `POST`
+
+**参数**:
+| 参数名 | 类型 | 必填 | 描述 |
+|-------|------|------|------|
+| id | string | 是 | 订单 ID |
+| tenantId | string | 是 | 租户 ID |
+| status | string | 是 | 目标状态 |
+| reason | string | 否 | 流转原因 |
+
+**返回格式**:
+```json
+{
+ "success": true
+}
+```
+
+### 4.7 批量更新订单
+
+**路径**: `/v1/order/batch-update`
+
+**方法**: `POST`
+
+**参数**:
+| 参数名 | 类型 | 必填 | 描述 |
+|-------|------|------|------|
+| tenantId | string | 是 | 租户 ID |
+| orderIds | array | 是 | 订单 ID 列表 |
+| updates | object | 是 | 更新内容 |
+
+**返回格式**:
+```json
+{
+ "success": true,
+ "data": {
+ "successCount": 1,
+ "failureCount": 0,
+ "totalCount": 1
+ }
+}
+```
+
+### 4.8 批量审核订单
+
+**路径**: `/v1/order/batch-audit`
+
+**方法**: `POST`
+
+**参数**:
+| 参数名 | 类型 | 必填 | 描述 |
+|-------|------|------|------|
+| tenantId | string | 是 | 租户 ID |
+| orderIds | array | 是 | 订单 ID 列表 |
+
+**返回格式**:
+```json
+{
+ "success": true,
+ "data": {
+ "successCount": 1,
+ "failureCount": 0,
+ "totalCount": 1
+ }
+}
+```
+
+### 4.9 批量发货
+
+**路径**: `/v1/order/batch-ship`
+
+**方法**: `POST`
+
+**参数**:
+| 参数名 | 类型 | 必填 | 描述 |
+|-------|------|------|------|
+| tenantId | string | 是 | 租户 ID |
+| orderIds | array | 是 | 订单 ID 列表 |
+
+**返回格式**:
+```json
+{
+ "success": true,
+ "data": {
+ "successCount": 1,
+ "failureCount": 0,
+ "totalCount": 1
+ }
+}
+```
+
+### 4.10 标记订单异常
+
+**路径**: `/v1/order/{id}/exception`
+
+**方法**: `POST`
+
+**参数**:
+| 参数名 | 类型 | 必填 | 描述 |
+|-------|------|------|------|
+| id | string | 是 | 订单 ID |
+| tenantId | string | 是 | 租户 ID |
+| reason | string | 是 | 异常原因 |
+
+**返回格式**:
+```json
+{
+ "success": true
+}
+```
+
+### 4.11 自动改派订单
+
+**路径**: `/v1/order/{id}/auto-reroute`
+
+**方法**: `POST`
+
+**参数**:
+| 参数名 | 类型 | 必填 | 描述 |
+|-------|------|------|------|
+| id | string | 是 | 订单 ID |
+| tenantId | string | 是 | 租户 ID |
+
+**返回格式**:
+```json
+{
+ "success": true
+}
+```
+
+### 4.12 重试异常订单
+
+**路径**: `/v1/order/{id}/retry`
+
+**方法**: `POST`
+
+**参数**:
+| 参数名 | 类型 | 必填 | 描述 |
+|-------|------|------|------|
+| id | string | 是 | 订单 ID |
+| tenantId | string | 是 | 租户 ID |
+
+**返回格式**:
+```json
+{
+ "success": true
+}
+```
+
+### 4.13 取消订单
+
+**路径**: `/v1/order/{id}/cancel`
+
+**方法**: `POST`
+
+**参数**:
+| 参数名 | 类型 | 必填 | 描述 |
+|-------|------|------|------|
+| id | string | 是 | 订单 ID |
+| tenantId | string | 是 | 租户 ID |
+| reason | string | 是 | 取消原因 |
+
+**返回格式**:
+```json
+{
+ "success": true
+}
+```
+
+### 4.14 申请退款
+
+**路径**: `/v1/order/{id}/refund`
+
+**方法**: `POST`
+
+**参数**:
+| 参数名 | 类型 | 必填 | 描述 |
+|-------|------|------|------|
+| id | string | 是 | 订单 ID |
+| tenantId | string | 是 | 租户 ID |
+| reason | string | 是 | 退款原因 |
+| amount | double | 是 | 退款金额 |
+
+**返回格式**:
+```json
+{
+ "success": true,
+ "data": {
+ "refundId": "REFUND_1234567890"
+ }
+}
+```
+
+### 4.15 审批退款
+
+**路径**: `/v1/order/{id}/refund/approve`
+
+**方法**: `POST`
+
+**参数**:
+| 参数名 | 类型 | 必填 | 描述 |
+|-------|------|------|------|
+| id | string | 是 | 订单 ID |
+| tenantId | string | 是 | 租户 ID |
+| approved | boolean | 是 | 是否批准 |
+| note | string | 否 | 审批备注 |
+
+**返回格式**:
+```json
+{
+ "success": true
+}
+```
+
+### 4.16 申请售后
+
+**路径**: `/v1/order/{id}/after-sales`
+
+**方法**: `POST`
+
+**参数**:
+| 参数名 | 类型 | 必填 | 描述 |
+|-------|------|------|------|
+| id | string | 是 | 订单 ID |
+| tenantId | string | 是 | 租户 ID |
+| type | string | 是 | 售后类型 |
+| reason | string | 是 | 售后原因 |
+| items | array | 是 | 售后商品列表 |
+
+**返回格式**:
+```json
+{
+ "success": true,
+ "data": {
+ "afterSalesId": "AFTER_SALES_1234567890"
+ }
+}
+```
+
+### 4.17 处理售后
+
+**路径**: `/v1/order/{id}/after-sales/process`
+
+**方法**: `POST`
+
+**参数**:
+| 参数名 | 类型 | 必填 | 描述 |
+|-------|------|------|------|
+| id | string | 是 | 订单 ID |
+| tenantId | string | 是 | 租户 ID |
+| action | string | 是 | 处理动作 |
+| note | string | 否 | 处理备注 |
+
+**返回格式**:
+```json
+{
+ "success": true
+}
+```
+
+### 4.18 完成订单
+
+**路径**: `/v1/order/{id}/complete`
+
+**方法**: `POST`
+
+**参数**:
+| 参数名 | 类型 | 必填 | 描述 |
+|-------|------|------|------|
+| id | string | 是 | 订单 ID |
+| tenantId | string | 是 | 租户 ID |
+
+**返回格式**:
+```json
+{
+ "success": true
+}
+```
+
+### 4.19 获取订单统计
+
+**路径**: `/v1/order/stats`
+
+**方法**: `GET`
+
+**参数**:
+| 参数名 | 类型 | 必填 | 描述 |
+|-------|------|------|------|
+| tenantId | string | 是 | 租户 ID |
+
+**返回格式**:
+```json
+{
+ "success": true,
+ "data": {
+ "totalOrders": 100,
+ "pendingOrders": 20,
+ "shippedOrders": 50,
+ "completedOrders": 30
+ }
+}
+```
+
+## 5. 支付 API
+
+### 5.1 创建支付
+
+**路径**: `/v1/payment`
+
+**方法**: `POST`
+
+**参数**:
+| 参数名 | 类型 | 必填 | 描述 |
+|-------|------|------|------|
+| orderId | long | 否 | 订单 ID |
+| paymentMethod | string | 否 | 支付方式 |
+| amount | double | 否 | 金额 |
+| currency | string | 否 | 货币 |
+| status | string | 否 | 状态 |
+| transactionId | string | 否 | 交易 ID |
+| tenantId | string | 是 | 租户 ID |
+
+**返回格式**:
+```json
+{
+ "success": true,
+ "data": {
+ "id": 1
+ }
+}
+```
+
+### 5.2 获取支付列表
+
+**路径**: `/v1/payment`
+
+**方法**: `GET`
+
+**参数**:
+| 参数名 | 类型 | 必填 | 描述 |
+|-------|------|------|------|
+| tenantId | string | 是 | 租户 ID |
+| orderId | long | 否 | 订单 ID |
+| status | string | 否 | 状态 |
+
+**返回格式**:
+```json
+{
+ "success": true,
+ "data": [
+ {
+ "id": 1,
+ "orderId": 1,
+ "paymentMethod": "credit_card",
+ "amount": 100.00,
+ "currency": "USD",
+ "status": "COMPLETED",
+ "transactionId": "TXN_1234567890",
+ "createdAt": "2024-01-01T00:00:00.000Z",
+ "updatedAt": "2024-01-01T00:00:00.000Z"
+ }
+ ]
+}
+```
+
+### 5.3 获取支付详情
+
+**路径**: `/v1/payment/{id}`
+
+**方法**: `GET`
+
+**参数**:
+| 参数名 | 类型 | 必填 | 描述 |
+|-------|------|------|------|
+| id | long | 是 | 支付 ID |
+| tenantId | string | 是 | 租户 ID |
+
+**返回格式**:
+```json
+{
+ "success": true,
+ "data": {
+ "id": 1,
+ "orderId": 1,
+ "paymentMethod": "credit_card",
+ "amount": 100.00,
+ "currency": "USD",
+ "status": "COMPLETED",
+ "transactionId": "TXN_1234567890",
+ "createdAt": "2024-01-01T00:00:00.000Z",
+ "updatedAt": "2024-01-01T00:00:00.000Z"
+ }
+}
+```
+
+### 5.4 更新支付
+
+**路径**: `/v1/payment/{id}`
+
+**方法**: `PUT`
+
+**参数**:
+| 参数名 | 类型 | 必填 | 描述 |
+|-------|------|------|------|
+| id | long | 是 | 支付 ID |
+| paymentMethod | string | 否 | 支付方式 |
+| amount | double | 否 | 金额 |
+| currency | string | 否 | 货币 |
+| status | string | 否 | 状态 |
+| transactionId | string | 否 | 交易 ID |
+| tenantId | string | 是 | 租户 ID |
+
+**返回格式**:
+```json
+{
+ "success": true,
+ "data": {
+ "id": 1,
+ "orderId": 1,
+ "paymentMethod": "credit_card",
+ "amount": 100.00,
+ "currency": "USD",
+ "status": "COMPLETED",
+ "transactionId": "TXN_1234567890",
+ "createdAt": "2024-01-01T00:00:00.000Z",
+ "updatedAt": "2024-01-01T00:00:00.000Z"
+ }
+}
+```
+
+### 5.5 删除支付
+
+**路径**: `/v1/payment/{id}`
+
+**方法**: `DELETE`
+
+**参数**:
+| 参数名 | 类型 | 必填 | 描述 |
+|-------|------|------|------|
+| id | long | 是 | 支付 ID |
+| tenantId | string | 是 | 租户 ID |
+
+**返回格式**:
+```json
+{
+ "success": true
+}
+```
+
+## 6. 物流 API
+
+### 6.1 创建物流
+
+**路径**: `/v1/logistics`
+
+**方法**: `POST`
+
+**参数**:
+| 参数名 | 类型 | 必填 | 描述 |
+|-------|------|------|------|
+| orderId | long | 否 | 订单 ID |
+| shippingMethod | string | 否 | 物流方式 |
+| trackingNumber | string | 否 | 跟踪号 |
+| carrier | string | 否 | 物流公司 |
+| status | string | 否 | 状态 |
+| estimatedDeliveryDate | string | 否 | 预计送达日期 |
+| actualDeliveryDate | string | 否 | 实际送达日期 |
+| tenantId | string | 是 | 租户 ID |
+
+**返回格式**:
+```json
+{
+ "success": true,
+ "data": {
+ "id": 1
+ }
+}
+```
+
+### 6.2 获取物流列表
+
+**路径**: `/v1/logistics`
+
+**方法**: `GET`
+
+**参数**:
+| 参数名 | 类型 | 必填 | 描述 |
+|-------|------|------|------|
+| tenantId | string | 是 | 租户 ID |
+| orderId | long | 否 | 订单 ID |
+| status | string | 否 | 状态 |
+
+**返回格式**:
+```json
+{
+ "success": true,
+ "data": [
+ {
+ "id": 1,
+ "orderId": 1,
+ "shippingMethod": "standard",
+ "trackingNumber": "TRK_1234567890",
+ "carrier": "UPS",
+ "status": "DELIVERED",
+ "estimatedDeliveryDate": "2024-01-10T00:00:00.000Z",
+ "actualDeliveryDate": "2024-01-09T00:00:00.000Z",
+ "createdAt": "2024-01-01T00:00:00.000Z",
+ "updatedAt": "2024-01-09T00:00:00.000Z"
+ }
+ ]
+}
+```
+
+### 6.3 获取物流详情
+
+**路径**: `/v1/logistics/{id}`
+
+**方法**: `GET`
+
+**参数**:
+| 参数名 | 类型 | 必填 | 描述 |
+|-------|------|------|------|
+| id | long | 是 | 物流 ID |
+| tenantId | string | 是 | 租户 ID |
+
+**返回格式**:
+```json
+{
+ "success": true,
+ "data": {
+ "id": 1,
+ "orderId": 1,
+ "shippingMethod": "standard",
+ "trackingNumber": "TRK_1234567890",
+ "carrier": "UPS",
+ "status": "DELIVERED",
+ "estimatedDeliveryDate": "2024-01-10T00:00:00.000Z",
+ "actualDeliveryDate": "2024-01-09T00:00:00.000Z",
+ "createdAt": "2024-01-01T00:00:00.000Z",
+ "updatedAt": "2024-01-09T00:00:00.000Z"
+ }
+}
+```
+
+### 6.4 更新物流
+
+**路径**: `/v1/logistics/{id}`
+
+**方法**: `PUT`
+
+**参数**:
+| 参数名 | 类型 | 必填 | 描述 |
+|-------|------|------|------|
+| id | long | 是 | 物流 ID |
+| shippingMethod | string | 否 | 物流方式 |
+| trackingNumber | string | 否 | 跟踪号 |
+| carrier | string | 否 | 物流公司 |
+| status | string | 否 | 状态 |
+| estimatedDeliveryDate | string | 否 | 预计送达日期 |
+| actualDeliveryDate | string | 否 | 实际送达日期 |
+| tenantId | string | 是 | 租户 ID |
+
+**返回格式**:
+```json
+{
+ "success": true,
+ "data": {
+ "id": 1,
+ "orderId": 1,
+ "shippingMethod": "standard",
+ "trackingNumber": "TRK_1234567890",
+ "carrier": "UPS",
+ "status": "DELIVERED",
+ "estimatedDeliveryDate": "2024-01-10T00:00:00.000Z",
+ "actualDeliveryDate": "2024-01-09T00:00:00.000Z",
+ "createdAt": "2024-01-01T00:00:00.000Z",
+ "updatedAt": "2024-01-09T00:00:00.000Z"
+ }
+}
+```
+
+### 6.5 删除物流
+
+**路径**: `/v1/logistics/{id}`
+
+**方法**: `DELETE`
+
+**参数**:
+| 参数名 | 类型 | 必填 | 描述 |
+|-------|------|------|------|
+| id | long | 是 | 物流 ID |
+| tenantId | string | 是 | 租户 ID |
+
+**返回格式**:
+```json
+{
+ "success": true
+}
+```
+
+## 7. 监控 API
+
+### 7.1 获取系统健康状态
+
+**路径**: `/v1/monitoring/health`
+
+**方法**: `GET`
+
+**返回格式**:
+```json
+{
+ "success": true,
+ "data": {
+ "status": "UP",
+ "components": {
+ "database": {
+ "status": "UP"
+ },
+ "cache": {
+ "status": "UP"
+ }
+ }
+ }
+}
+```
+
+### 7.2 获取性能指标
+
+**路径**: `/v1/monitoring/metrics`
+
+**方法**: `GET`
+
+**返回格式**:
+```json
+{
+ "success": true,
+ "data": {
+ "jvm": {
+ "memory": {
+ "used": 1024,
+ "total": 2048
+ }
+ },
+ "system": {
+ "cpu": {
+ "usage": 0.5
+ }
+ }
+ }
+}
+```
+
+### 7.3 获取服务状态
+
+**路径**: `/v1/monitoring/services`
+
+**方法**: `GET`
+
+**返回格式**:
+```json
+{
+ "success": true,
+ "data": {
+ "authService": {
+ "status": "UP"
+ },
+ "productService": {
+ "status": "UP"
+ },
+ "orderService": {
+ "status": "UP"
+ }
+ }
+}
+```
+
+### 7.4 获取数据库状态
+
+**路径**: `/v1/monitoring/database`
+
+**方法**: `GET`
+
+**返回格式**:
+```json
+{
+ "success": true,
+ "data": {
+ "status": "UP",
+ "connections": {
+ "active": 5,
+ "max": 10
+ }
+ }
+}
+```
+
+### 7.5 获取缓存状态
+
+**路径**: `/v1/monitoring/cache`
+
+**方法**: `GET`
+
+**返回格式**:
+```json
+{
+ "success": true,
+ "data": {
+ "status": "UP",
+ "keys": 100
+ }
+}
+```
+
+### 7.6 获取系统统计信息
+
+**路径**: `/v1/monitoring/stats`
+
+**方法**: `GET`
+
+**返回格式**:
+```json
+{
+ "success": true,
+ "data": {
+ "requests": {
+ "total": 1000,
+ "success": 990,
+ "error": 10
+ }
+ }
+}
+```
+
+### 7.7 Ping 测试
+
+**路径**: `/v1/monitoring/ping`
+
+**方法**: `GET`
+
+**返回格式**:
+```json
+{
+ "success": true,
+ "message": "Pong",
+ "timestamp": 1234567890
+}
+```
+
+## 8. 告警 API
+
+### 8.1 创建告警
+
+**路径**: `/v1/alerts`
+
+**方法**: `POST`
+
+**参数**:
+| 参数名 | 类型 | 必填 | 描述 |
+|-------|------|------|------|
+| tenantId | string | 是 | 租户 ID |
+| alertType | string | 否 | 告警类型 |
+| severity | string | 否 | 严重程度 |
+| message | string | 否 | 告警消息 |
+| status | string | 否 | 状态 |
+| source | string | 否 | 告警来源 |
+| threshold | string | 否 | 阈值 |
+| actualValue | string | 否 | 实际值 |
+
+**返回格式**:
+```json
+{
+ "success": true,
+ "alertId": 1
+}
+```
+
+### 8.2 获取告警列表
+
+**路径**: `/v1/alerts`
+
+**方法**: `GET`
+
+**参数**:
+| 参数名 | 类型 | 必填 | 描述 |
+|-------|------|------|------|
+| tenantId | string | 是 | 租户 ID |
+| status | string | 否 | 状态 |
+| severity | string | 否 | 严重程度 |
+| alertType | string | 否 | 告警类型 |
+| startDate | string | 否 | 开始日期 |
+| endDate | string | 否 | 结束日期 |
+
+**返回格式**:
+```json
+{
+ "success": true,
+ "data": [
+ {
+ "id": 1,
+ "tenantId": "租户 ID",
+ "alertType": "system",
+ "severity": "high",
+ "message": "系统异常",
+ "status": "ACTIVE",
+ "source": "monitoring",
+ "threshold": "90%",
+ "actualValue": "95%",
+ "createdAt": "2024-01-01T00:00:00.000Z",
+ "resolvedAt": null
+ }
+ ]
+}
+```
+
+### 8.3 获取告警详情
+
+**路径**: `/v1/alerts/{id}`
+
+**方法**: `GET`
+
+**参数**:
+| 参数名 | 类型 | 必填 | 描述 |
+|-------|------|------|------|
+| id | long | 是 | 告警 ID |
+| tenantId | string | 是 | 租户 ID |
+
+**返回格式**:
+```json
+{
+ "success": true,
+ "data": {
+ "id": 1,
+ "tenantId": "租户 ID",
+ "alertType": "system",
+ "severity": "high",
+ "message": "系统异常",
+ "status": "ACTIVE",
+ "source": "monitoring",
+ "threshold": "90%",
+ "actualValue": "95%",
+ "createdAt": "2024-01-01T00:00:00.000Z",
+ "resolvedAt": null
+ }
+}
+```
+
+### 8.4 解决告警
+
+**路径**: `/v1/alerts/{id}/resolve`
+
+**方法**: `PUT`
+
+**参数**:
+| 参数名 | 类型 | 必填 | 描述 |
+|-------|------|------|------|
+| id | long | 是 | 告警 ID |
+| tenantId | string | 是 | 租户 ID |
+
+**返回格式**:
+```json
+{
+ "success": true,
+ "message": "Alert resolved successfully"
+}
+```
+
+### 8.5 更新告警状态
+
+**路径**: `/v1/alerts/{id}/status`
+
+**方法**: `PUT`
+
+**参数**:
+| 参数名 | 类型 | 必填 | 描述 |
+|-------|------|------|------|
+| id | long | 是 | 告警 ID |
+| tenantId | string | 是 | 租户 ID |
+| status | string | 是 | 新状态 |
+
+**返回格式**:
+```json
+{
+ "success": true,
+ "message": "Alert status updated successfully"
+}
+```
+
+### 8.6 获取告警统计
+
+**路径**: `/v1/alerts/stats`
+
+**方法**: `GET`
+
+**参数**:
+| 参数名 | 类型 | 必填 | 描述 |
+|-------|------|------|------|
+| tenantId | string | 是 | 租户 ID |
+| startDate | string | 是 | 开始日期 |
+| endDate | string | 是 | 结束日期 |
+
+**返回格式**:
+```json
+{
+ "success": true,
+ "data": {
+ "totalAlerts": 10,
+ "severityStats": {
+ "high": 2,
+ "medium": 5,
+ "low": 3
+ },
+ "statusStats": {
+ "ACTIVE": 3,
+ "RESOLVED": 7
+ },
+ "typeStats": {
+ "system": 5,
+ "application": 3,
+ "database": 2
+ },
+ "startDate": "2024-01-01",
+ "endDate": "2024-01-31"
+ }
+}
+```
+
+### 8.7 检查阈值
+
+**路径**: `/v1/alerts/check-thresholds`
+
+**方法**: `POST`
+
+**参数**:
+| 参数名 | 类型 | 必填 | 描述 |
+|-------|------|------|------|
+| tenantId | string | 是 | 租户 ID |
+
+**返回格式**:
+```json
+{
+ "success": true,
+ "message": "Thresholds checked successfully"
+}
+```
+
+## 9. 审计 API
+
+### 9.1 获取审计日志列表
+
+**路径**: `/v1/audit`
+
+**方法**: `GET`
+
+**参数**:
+| 参数名 | 类型 | 必填 | 描述 |
+|-------|------|------|------|
+| tenantId | string | 是 | 租户 ID |
+| shopId | string | 否 | 店铺 ID |
+| userId | long | 否 | 用户 ID |
+| action | string | 否 | 操作类型 |
+| resourceType | string | 否 | 资源类型 |
+| startDate | string | 否 | 开始日期 |
+| endDate | string | 否 | 结束日期 |
+
+**返回格式**:
+```json
+{
+ "success": true,
+ "data": [
+ {
+ "id": 1,
+ "tenantId": "租户 ID",
+ "shopId": "店铺 ID",
+ "userId": 1,
+ "action": "create",
+ "resourceType": "product",
+ "resourceId": "1",
+ "ipAddress": "192.168.1.1",
+ "userAgent": "Mozilla/5.0",
+ "details": "创建商品",
+ "createdAt": "2024-01-01T00:00:00.000Z"
+ }
+ ]
+}
+```
+
+### 9.2 获取审计日志详情
+
+**路径**: `/v1/audit/{id}`
+
+**方法**: `GET`
+
+**参数**:
+| 参数名 | 类型 | 必填 | 描述 |
+|-------|------|------|------|
+| id | long | 是 | 审计日志 ID |
+| tenantId | string | 是 | 租户 ID |
+
+**返回格式**:
+```json
+{
+ "success": true,
+ "data": {
+ "id": 1,
+ "tenantId": "租户 ID",
+ "shopId": "店铺 ID",
+ "userId": 1,
+ "action": "create",
+ "resourceType": "product",
+ "resourceId": "1",
+ "ipAddress": "192.168.1.1",
+ "userAgent": "Mozilla/5.0",
+ "details": "创建商品",
+ "createdAt": "2024-01-01T00:00:00.000Z"
+ }
+}
+```
+
+## 10. 配置 API
+
+### 10.1 创建配置
+
+**路径**: `/v1/config`
+
+**方法**: `POST`
+
+**参数**:
+| 参数名 | 类型 | 必填 | 描述 |
+|-------|------|------|------|
+| tenantId | string | 否 | 租户 ID |
+| shopId | string | 否 | 店铺 ID |
+| configKey | string | 是 | 配置键 |
+| configValue | string | 是 | 配置值 |
+| configType | string | 否 | 配置类型 |
+| description | string | 否 | 配置描述 |
+
+**返回格式**:
+```json
+{
+ "success": true,
+ "data": {
+ "id": 1
+ }
+}
+```
+
+### 10.2 获取配置列表
+
+**路径**: `/v1/config`
+
+**方法**: `GET`
+
+**参数**:
+| 参数名 | 类型 | 必填 | 描述 |
+|-------|------|------|------|
+| tenantId | string | 否 | 租户 ID |
+| shopId | string | 否 | 店铺 ID |
+| configType | string | 否 | 配置类型 |
+
+**返回格式**:
+```json
+{
+ "success": true,
+ "data": [
+ {
+ "id": 1,
+ "tenantId": "租户 ID",
+ "shopId": "店铺 ID",
+ "configKey": "api_key",
+ "configValue": "value",
+ "configType": "string",
+ "description": "API 密钥",
+ "createdAt": "2024-01-01T00:00:00.000Z",
+ "updatedAt": "2024-01-01T00:00:00.000Z"
+ }
+ ]
+}
+```
+
+### 10.3 获取配置详情
+
+**路径**: `/v1/config/{id}`
+
+**方法**: `GET`
+
+**参数**:
+| 参数名 | 类型 | 必填 | 描述 |
+|-------|------|------|------|
+| id | long | 是 | 配置 ID |
+
+**返回格式**:
+```json
+{
+ "success": true,
+ "data": {
+ "id": 1,
+ "tenantId": "租户 ID",
+ "shopId": "店铺 ID",
+ "configKey": "api_key",
+ "configValue": "value",
+ "configType": "string",
+ "description": "API 密钥",
+ "createdAt": "2024-01-01T00:00:00.000Z",
+ "updatedAt": "2024-01-01T00:00:00.000Z"
+ }
+}
+```
+
+### 10.4 更新配置
+
+**路径**: `/v1/config/{id}`
+
+**方法**: `PUT`
+
+**参数**:
+| 参数名 | 类型 | 必填 | 描述 |
+|-------|------|------|------|
+| id | long | 是 | 配置 ID |
+| configValue | string | 否 | 配置值 |
+| configType | string | 否 | 配置类型 |
+| description | string | 否 | 配置描述 |
+
+**返回格式**:
+```json
+{
+ "success": true,
+ "data": {
+ "id": 1,
+ "tenantId": "租户 ID",
+ "shopId": "店铺 ID",
+ "configKey": "api_key",
+ "configValue": "new_value",
+ "configType": "string",
+ "description": "API 密钥",
+ "createdAt": "2024-01-01T00:00:00.000Z",
+ "updatedAt": "2024-01-02T00:00:00.000Z"
+ }
+}
+```
+
+### 10.5 删除配置
+
+**路径**: `/v1/config/{id}`
+
+**方法**: `DELETE`
+
+**参数**:
+| 参数名 | 类型 | 必填 | 描述 |
+|-------|------|------|------|
+| id | long | 是 | 配置 ID |
+
+**返回格式**:
+```json
+{
+ "success": true
+}
+```
+
+### 10.6 根据键获取配置
+
+**路径**: `/v1/config/key/{key}`
+
+**方法**: `GET`
+
+**参数**:
+| 参数名 | 类型 | 必填 | 描述 |
+|-------|------|------|------|
+| key | string | 是 | 配置键 |
+| tenantId | string | 否 | 租户 ID |
+| shopId | string | 否 | 店铺 ID |
+
+**返回格式**:
+```json
+{
+ "success": true,
+ "data": {
+ "id": 1,
+ "tenantId": "租户 ID",
+ "shopId": "店铺 ID",
+ "configKey": "api_key",
+ "configValue": "value",
+ "configType": "string",
+ "description": "API 密钥",
+ "createdAt": "2024-01-01T00:00:00.000Z",
+ "updatedAt": "2024-01-01T00:00:00.000Z"
+ }
+}
+```
+
+## 11. 数据 API
+
+### 11.1 导入数据
+
+**路径**: `/v1/data/import`
+
+**方法**: `POST`
+
+**参数**:
+| 参数名 | 类型 | 必填 | 描述 |
+|-------|------|------|------|
+| tenantId | string | 是 | 租户 ID |
+| dataType | string | 是 | 数据类型 |
+| data | array | 是 | 数据列表 |
+
+**返回格式**:
+```json
+{
+ "success": true,
+ "data": {
+ "importedCount": 10,
+ "failedCount": 0
+ }
+}
+```
+
+### 11.2 导出数据
+
+**路径**: `/v1/data/export`
+
+**方法**: `GET`
+
+**参数**:
+| 参数名 | 类型 | 必填 | 描述 |
+|-------|------|------|------|
+| tenantId | string | 是 | 租户 ID |
+| dataType | string | 是 | 数据类型 |
+| filters | object | 否 | 过滤条件 |
+
+**返回格式**:
+```json
+{
+ "success": true,
+ "data": [
+ {
+ "id": 1,
+ "name": "数据 1"
+ }
+ ]
+}
+```
+
+### 11.3 同步数据
+
+**路径**: `/v1/data/sync`
+
+**方法**: `POST`
+
+**参数**:
+| 参数名 | 类型 | 必填 | 描述 |
+|-------|------|------|------|
+| tenantId | string | 是 | 租户 ID |
+| source | string | 是 | 数据源 |
+| target | string | 是 | 目标 |
+| filters | object | 否 | 过滤条件 |
+
+**返回格式**:
+```json
+{
+ "success": true,
+ "data": {
+ "syncedCount": 10,
+ "failedCount": 0
+ }
+}
+```
+
+## 12. 报表 API
+
+### 12.1 生成报表
+
+**路径**: `/v1/report/generate`
+
+**方法**: `POST`
+
+**参数**:
+| 参数名 | 类型 | 必填 | 描述 |
+|-------|------|------|------|
+| tenantId | string | 是 | 租户 ID |
+| reportType | string | 是 | 报表类型 |
+| startDate | string | 是 | 开始日期 |
+| endDate | string | 是 | 结束日期 |
+| filters | object | 否 | 过滤条件 |
+
+**返回格式**:
+```json
+{
+ "success": true,
+ "data": {
+ "reportId": "REPORT_1234567890",
+ "url": "http://example.com/report/REPORT_1234567890"
+ }
+}
+```
+
+### 12.2 获取报表列表
+
+**路径**: `/v1/report`
+
+**方法**: `GET`
+
+**参数**:
+| 参数名 | 类型 | 必填 | 描述 |
+|-------|------|------|------|
+| tenantId | string | 是 | 租户 ID |
+| reportType | string | 否 | 报表类型 |
+| startDate | string | 否 | 开始日期 |
+| endDate | string | 否 | 结束日期 |
+
+**返回格式**:
+```json
+{
+ "success": true,
+ "data": [
+ {
+ "id": "REPORT_1234567890",
+ "reportType": "sales",
+ "startDate": "2024-01-01",
+ "endDate": "2024-01-31",
+ "createdAt": "2024-02-01T00:00:00.000Z",
+ "url": "http://example.com/report/REPORT_1234567890"
+ }
+ ]
+}
+```
+
+### 12.3 获取报表详情
+
+**路径**: `/v1/report/{id}`
+
+**方法**: `GET`
+
+**参数**:
+| 参数名 | 类型 | 必填 | 描述 |
+|-------|------|------|------|
+| id | string | 是 | 报表 ID |
+| tenantId | string | 是 | 租户 ID |
+
+**返回格式**:
+```json
+{
+ "success": true,
+ "data": {
+ "id": "REPORT_1234567890",
+ "reportType": "sales",
+ "startDate": "2024-01-01",
+ "endDate": "2024-01-31",
+ "createdAt": "2024-02-01T00:00:00.000Z",
+ "url": "http://example.com/report/REPORT_1234567890"
+ }
+}
+```
+
+### 12.4 删除报表
+
+**路径**: `/v1/report/{id}`
+
+**方法**: `DELETE`
+
+**参数**:
+| 参数名 | 类型 | 必填 | 描述 |
+|-------|------|------|------|
+| id | string | 是 | 报表 ID |
+| tenantId | string | 是 | 租户 ID |
+
+**返回格式**:
+```json
+{
+ "success": true
+}
+```
diff --git a/docs/03_Deployment_Guide.md b/docs/03_Deployment_Guide.md
new file mode 100644
index 0000000..957f457
--- /dev/null
+++ b/docs/03_Deployment_Guide.md
@@ -0,0 +1,363 @@
+# 部署指南
+
+## 1. 环境要求
+
+### 1.1 硬件要求
+- **CPU**: 至少 2 核
+- **内存**: 至少 4GB
+- **磁盘**: 至少 50GB 可用空间
+
+### 1.2 软件要求
+- **Java**: JDK 17 或更高版本
+- **MySQL**: 8.0 或更高版本
+- **Redis**: 6.0 或更高版本
+- **Maven**: 3.6 或更高版本
+
+## 2. 安装步骤
+
+### 2.1 安装 Java
+
+**Windows 系统**:
+1. 下载 JDK 17 安装包：[Oracle JDK 17](https://www.oracle.com/java/technologies/downloads/#java17)
+2. 运行安装包，按照提示完成安装
+3. 配置环境变量：
+ - 右键点击「此电脑」→「属性」→「高级系统设置」→「环境变量」
+ - 在「系统变量」中添加 `JAVA_HOME`，值为 JDK 安装目录
+ - 在「系统变量」的 `Path` 中添加 `%JAVA_HOME%\bin`
+4. 验证安装：打开命令提示符，运行 `java -version`，显示 JDK 版本信息
+
+**Linux 系统**:
+1. 下载 JDK 17 安装包：
+ ```bash
+ wget https://download.oracle.com/java/17/latest/jdk-17_linux-x64_bin.rpm
+ ```
+2. 安装 JDK：
+ ```bash
+ sudo rpm -ivh jdk-17_linux-x64_bin.rpm
+ ```
+3. 验证安装：
+ ```bash
+ java -version
+ ```
+
+### 2.2 安装 MySQL
+
+**Windows 系统**:
+1. 下载 MySQL 8.0 安装包：[MySQL Community Server](https://dev.mysql.com/downloads/mysql/)
+2. 运行安装包，按照提示完成安装
+3. 配置 MySQL：
+ - 启动 MySQL 服务
+ - 登录 MySQL，修改 root 密码
+ - 创建数据库：`CREATE DATABASE crawlful_hub CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;
+
+**Linux 系统**:
+1. 安装 MySQL：
+ ```bash
+ sudo yum install mysql-server
+ ```
+2. 启动 MySQL 服务：
+ ```bash
+ sudo systemctl start mysqld
+ ```
+3. 配置 MySQL：
+ ```bash
+ sudo mysql_secure_installation
+ ```
+4. 创建数据库：
+ ```bash
+ mysql -u root -p
+ CREATE DATABASE crawlful_hub CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;
+ ```
+
+### 2.3 安装 Redis
+
+**Windows 系统**:
+1. 下载 Redis 安装包：[Redis for Windows](https://github.com/tporadowski/redis/releases)
+2. 运行安装包，按照提示完成安装
+3. 启动 Redis 服务：
+ ```bash
+ redis-server
+ ```
+
+**Linux 系统**:
+1. 安装 Redis：
+ ```bash
+ sudo yum install redis
+ ```
+2. 启动 Redis 服务：
+ ```bash
+ sudo systemctl start redis
+ ```
+
+### 2.4 安装 Maven
+
+**Windows 系统**:
+1. 下载 Maven 安装包：[Apache Maven](https://maven.apache.org/download.cgi)
+2. 解压安装包到指定目录
+3. 配置环境变量：
+ - 右键点击「此电脑」→「属性」→「高级系统设置」→「环境变量」
+ - 在「系统变量」中添加 `MAVEN_HOME`，值为 Maven 安装目录
+ - 在「系统变量」的 `Path` 中添加 `%MAVEN_HOME%\bin`
+4. 验证安装：打开命令提示符，运行 `mvn -version`，显示 Maven 版本信息
+
+**Linux 系统**:
+1. 安装 Maven：
+ ```bash
+ sudo yum install maven
+ ```
+2. 验证安装：
+ ```bash
+ mvn -version
+ ```
+
+## 3. 项目配置
+
+### 3.1 数据库配置
+
+编辑 `src/main/resources/application.yml` 文件，修改数据库连接信息：
+
+```yaml
+spring:
+ datasource:
+ url: jdbc:mysql://localhost:3306/crawlful_hub?useUnicode=true&characterEncoding=utf-8&useSSL=false&serverTimezone=UTC
+ username: root
+ password: 123456
+ driver-class-name: com.mysql.cj.jdbc.Driver
+```
+
+### 3.2 Redis 配置
+
+编辑 `src/main/resources/application.yml` 文件，修改 Redis 连接信息：
+
+```yaml
+spring:
+ redis:
+ host: localhost
+ port: 6379
+ password:
+ database: 0
+```
+
+### 3.3 JWT 配置
+
+编辑 `src/main/resources/application.yml` 文件，修改 JWT 配置：
+
+```yaml
+spring:
+ security:
+ jwt:
+ secret: your-secret-key
+ expiration: 86400000
+```
+
+### 3.4 服务器配置
+
+编辑 `src/main/resources/application.yml` 文件，修改服务器配置：
+
+```yaml
+server:
+ port: 3001
+ servlet:
+ context-path: /api
+```
+
+## 4. 构建与部署
+
+### 4.1 构建项目
+
+1. 进入项目目录：
+ ```bash
+ cd d:\trae_projects\makemd\makemd\serverjava
+ ```
+
+2. 执行 Maven 构建：
+ ```bash
+ mvn clean package
+ ```
+
+3. 构建成功后，在 `target` 目录中生成 `serverjava-0.0.1-SNAPSHOT.jar` 文件。
+
+### 4.2 运行项目
+
+**方法一：直接运行**
+
+1. 进入 `target` 目录：
+ ```bash
+ cd target
+ ```
+
+2. 运行 jar 文件：
+ ```bash
+ java -jar serverjava-0.0.1-SNAPSHOT.jar
+ ```
+
+**方法二：作为服务运行**
+
+**Windows 系统**:
+1. 创建服务脚本：
+ ```batch
+ @echo off
+ set JAVA_HOME=C:\Program Files\Java\jdk-17
+ set PATH=%JAVA_HOME%\bin;%PATH%
+ java -jar d:\trae_projects\makemd\makemd\serverjava\target\serverjava-0.0.1-SNAPSHOT.jar
+ ```
+
+2. 将脚本保存为 `serverjava.bat`，然后运行。
+
+**Linux 系统**:
+1. 创建服务文件：
+ ```bash
+ sudo nano /etc/systemd/system/serverjava.service
+ ```
+
+2. 添加以下内容：
+ ```
+ [Unit]
+ Description=ServerJava Service
+ After=network.target
+
+ [Service]
+ Type=simple
+ User=root
+ ExecStart=/usr/bin/java -jar /path/to/serverjava/target/serverjava-0.0.1-SNAPSHOT.jar
+ Restart=on-failure
+
+ [Install]
+ WantedBy=multi-user.target
+ ```
+
+3. 启动服务：
+ ```bash
+ sudo systemctl start serverjava
+ sudo systemctl enable serverjava
+ ```
+
+## 5. 验证部署
+
+1. 打开浏览器，访问 `http://localhost:3001/api/api-docs`，查看 API 文档。
+
+2. 访问 `http://localhost:3001/api/v1/monitoring/health`，查看系统健康状态。
+
+3. 访问 `http://localhost:3001/api/v1/monitoring/ping`，测试系统响应。
+
+## 6. 日志管理
+
+### 6.1 日志配置
+
+编辑 `src/main/resources/logback.xml` 文件，修改日志配置：
+
+```xml
+
+
+
+ %d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n
+
+
+
+
+ logs/server.log
+
+ logs/server.%d{yyyy-MM-dd}.log
+ 30
+
+
+ %d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n
+
+
+
+
+
+
+
+
+```
+
+### 6.2 日志查看
+
+**Windows 系统**:
+1. 进入项目目录，查看日志文件：
+ ```bash
+ cd d:\trae_projects\makemd\makemd\serverjava
+ type logs\server.log
+ ```
+
+**Linux 系统**:
+1. 进入项目目录，查看日志文件：
+ ```bash
+ cd /path/to/serverjava
+ tail -f logs/server.log
+ ```
+
+## 7. 故障排查
+
+### 7.1 常见问题
+
+1. **数据库连接失败**
+ - 检查数据库服务是否运行
+ - 检查数据库连接配置是否正确
+ - 检查数据库用户权限是否正确
+
+2. **Redis 连接失败**
+ - 检查 Redis 服务是否运行
+ - 检查 Redis 连接配置是否正确
+
+3. **端口被占用**
+ - 检查端口是否被其他服务占用
+ - 修改 `application.yml` 中的端口配置
+
+4. **JWT 验证失败**
+ - 检查 JWT 密钥是否正确
+ - 检查 JWT 令牌是否过期
+
+### 7.2 调试方法
+
+1. **查看日志**：查看 `logs/server.log` 文件，了解系统运行状态和错误信息。
+
+2. **使用 API 文档**：访问 `http://localhost:3001/api/api-docs`，测试 API 接口。
+
+3. **使用健康检查**：访问 `http://localhost:3001/api/v1/monitoring/health`，检查系统健康状态。
+
+4. **使用 Ping 测试**：访问 `http://localhost:3001/api/v1/monitoring/ping`，测试系统响应。
+
+## 8. 升级与维护
+
+### 8.1 升级步骤
+
+1. 停止服务：
+ ```bash
+ sudo systemctl stop serverjava
+ ```
+
+2. 备份数据：
+ ```bash
+ mysqldump -u root -p crawlful_hub > crawlful_hub_backup.sql
+ ```
+
+3. 拉取最新代码：
+ ```bash
+ git pull
+ ```
+
+4. 重新构建项目：
+ ```bash
+ mvn clean package
+ ```
+
+5. 启动服务：
+ ```bash
+ sudo systemctl start serverjava
+ ```
+
+### 8.2 维护计划
+
+1. **定期备份**：定期备份数据库和配置文件。
+
+2. **更新依赖**：定期更新项目依赖，确保系统安全。
+
+3. **监控系统**：使用监控工具监控系统运行状态，及时发现和处理异常。
+
+4. **性能优化**：根据系统运行情况，优化数据库查询、缓存策略等。
+
+## 9. 总结
+
+本部署指南详细介绍了 Crawlful Hub 项目的部署方法、环境要求和配置步骤。通过本指南，您可以快速部署和维护系统，确保系统的稳定运行。
diff --git a/docs/04_Test_Guide.md b/docs/04_Test_Guide.md
new file mode 100644
index 0000000..84b8390
--- /dev/null
+++ b/docs/04_Test_Guide.md
@@ -0,0 +1,182 @@
+# 测试指南
+
+## 1. 测试概述
+
+Crawlful Hub 项目采用了全面的测试策略，包括单元测试、集成测试和系统测试，确保系统的稳定性和可靠性。本指南详细介绍了项目的测试方法和测试策略。
+
+## 2. 测试环境
+
+### 2.1 硬件要求
+- **CPU**: 至少 2 核
+- **内存**: 至少 4GB
+- **磁盘**: 至少 50GB 可用空间
+
+### 2.2 软件要求
+- **Java**: JDK 17 或更高版本
+- **MySQL**: 8.0 或更高版本
+- **Redis**: 6.0 或更高版本
+- **Maven**: 3.6 或更高版本
+- **JUnit 5**: 项目集成的测试框架
+
+## 3. 测试类型
+
+### 3.1 单元测试
+
+单元测试是对系统中最小的可测试单元进行测试，通常是对单个方法或类的测试。单元测试的目的是验证每个单元是否按照预期工作。
+
+**核心测试类**：
+- `AuthServiceTest.java`：测试认证服务的功能
+- `OrderServiceTest.java`：测试订单服务的功能
+- `ProductServiceTest.java`：测试商品服务的功能
+
+### 3.2 集成测试
+
+集成测试是对系统中多个组件的交互进行测试，验证组件之间的协作是否正确。集成测试的目的是确保系统的各个组件能够正确地协同工作。
+
+**核心测试类**：
+- `SystemIntegrationTest.java`：测试整个系统的集成功能
+
+### 3.3 系统测试
+
+系统测试是对整个系统的功能进行测试，验证系统是否满足需求规格。系统测试的目的是确保系统能够按照预期工作，满足用户的需求。
+
+**测试方法**：
+- 使用 API 文档测试 API 接口
+- 使用健康检查端点测试系统状态
+- 使用监控端点测试系统性能
+
+## 4. 测试工具
+
+### 4.1 JUnit 5
+
+JUnit 5 是 Java 中最流行的测试框架，用于编写和运行单元测试。Crawlful Hub 项目使用 JUnit 5 进行单元测试和集成测试。
+
+### 4.2 Mockito
+
+Mockito 是一个用于 Java 的 mocking 框架，用于创建和配置模拟对象。Crawlful Hub 项目使用 Mockito 模拟依赖对象，便于单元测试。
+
+### 4.3 Spring Test
+
+Spring Test 是 Spring 框架提供的测试工具，用于测试 Spring 应用。Crawlful Hub 项目使用 Spring Test 测试 Spring 组件。
+
+### 4.4 Postman
+
+Postman 是一个用于测试 API 的工具，用于发送 HTTP 请求并查看响应。Crawlful Hub 项目使用 Postman 测试 API 接口。
+
+## 5. 测试执行
+
+### 5.1 运行单元测试
+
+1. 进入项目目录：
+ ```bash
+ cd d:\trae_projects\makemd\makemd\serverjava
+ ```
+
+2. 执行单元测试：
+ ```bash
+ mvn test
+ ```
+
+### 5.2 运行集成测试
+
+1. 进入项目目录：
+ ```bash
+ cd d:\trae_projects\makemd\makemd\serverjava
+ ```
+
+2. 执行集成测试：
+ ```bash
+ mvn verify -Pintegration-test
+ ```
+
+### 5.3 运行系统测试
+
+1. 启动系统：
+ ```bash
+ java -jar target/serverjava-0.0.1-SNAPSHOT.jar
+ ```
+
+2. 使用 Postman 测试 API 接口：
+ - 访问 `http://localhost:3001/api/api-docs`，获取 API 文档
+ - 使用 Postman 发送请求，测试 API 接口
+
+3. 使用健康检查端点测试系统状态：
+ - 访问 `http://localhost:3001/api/v1/monitoring/health`
+
+4. 使用监控端点测试系统性能：
+ - 访问 `http://localhost:3001/api/v1/monitoring/metrics`
+
+## 6. 测试策略
+
+### 6.1 测试覆盖率
+
+Crawlful Hub 项目的测试覆盖率目标是：
+- **单元测试覆盖率**：至少 80%
+- **集成测试覆盖率**：至少 60%
+- **系统测试覆盖率**：至少 40%
+
+### 6.2 测试用例设计
+
+测试用例设计遵循以下原则：
+- **边界值测试**：测试边界条件，如空值、最大值、最小值等
+- **等价类测试**：测试等价类，如有效输入、无效输入等
+- **异常测试**：测试异常情况，如参数错误、系统错误等
+- **场景测试**：测试实际场景，如用户注册、登录、下单等
+
+### 6.3 测试数据
+
+测试数据的设计遵循以下原则：
+- **真实数据**：使用真实的业务数据进行测试
+- **边界数据**：使用边界值进行测试
+- **异常数据**：使用异常数据进行测试
+- **覆盖所有场景**：确保测试数据覆盖所有业务场景
+
+## 7. 测试报告
+
+### 7.1 单元测试报告
+
+运行单元测试后，Maven 会生成单元测试报告，位于 `target/surefire-reports` 目录。
+
+### 7.2 集成测试报告
+
+运行集成测试后，Maven 会生成集成测试报告，位于 `target/failsafe-reports` 目录。
+
+### 7.3 代码覆盖率报告
+
+使用 JaCoCo 插件生成代码覆盖率报告，位于 `target/site/jacoco` 目录。
+
+## 8. 测试最佳实践
+
+### 8.1 单元测试最佳实践
+
+- **测试单个方法**：每个单元测试只测试一个方法
+- **使用断言**：使用断言验证测试结果
+- **模拟依赖**：使用 Mockito 模拟依赖对象
+- **测试边界条件**：测试边界值和异常情况
+- **保持测试简单**：测试代码应该简洁明了
+
+### 8.2 集成测试最佳实践
+
+- **测试组件交互**：测试组件之间的协作
+- **使用真实依赖**：使用真实的依赖对象
+- **测试业务流程**：测试完整的业务流程
+- **保持测试独立**：每个集成测试应该独立运行
+
+### 8.3 系统测试最佳实践
+
+- **测试完整功能**：测试系统的完整功能
+- **使用真实环境**：使用真实的环境进行测试
+- **测试用户场景**：测试实际的用户场景
+- **性能测试**：测试系统的性能
+
+## 9. 测试自动化
+
+Crawlful Hub 项目使用 Maven 进行测试自动化，配置了以下测试目标：
+
+- **mvn test**：运行单元测试
+- **mvn verify**：运行单元测试和集成测试
+- **mvn clean package**：构建项目并运行测试
+
+## 10. 总结
+
+本测试指南详细介绍了 Crawlful Hub 项目的测试方法和测试策略。通过本指南，您可以了解如何编写和运行测试，确保系统的稳定性和可靠性。
diff --git a/docs/05_Database_Design.md b/docs/05_Database_Design.md
new file mode 100644
index 0000000..25687ea
--- /dev/null
+++ b/docs/05_Database_Design.md
@@ -0,0 +1,306 @@
+# 数据库设计
+
+## 1. 数据库概述
+
+Crawlful Hub 项目使用 MySQL 8.0 作为数据库，采用了关系型数据库设计，确保数据的一致性和完整性。本文档详细介绍了项目的数据库表结构、索引和关系。
+
+## 2. 数据库表结构
+
+### 2.1 用户表（cf_user）
+
+| 字段名 | 数据类型 | 约束 | 描述 |
+|-------|---------|------|------|
+| id | BIGINT | PRIMARY KEY, AUTO_INCREMENT | 用户 ID |
+| tenant_id | VARCHAR(255) | NOT NULL | 租户 ID |
+| username | VARCHAR(255) | NOT NULL, UNIQUE | 用户名 |
+| password | VARCHAR(255) | NOT NULL | 密码（加密存储） |
+| email | VARCHAR(255) | NOT NULL, UNIQUE | 邮箱 |
+| role | VARCHAR(50) | | 角色 |
+| created_at | DATETIME | DEFAULT CURRENT_TIMESTAMP | 创建时间 |
+| updated_at | DATETIME | DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP | 更新时间 |
+
+### 2.2 商品表（cf_product）
+
+| 字段名 | 数据类型 | 约束 | 描述 |
+|-------|---------|------|------|
+| id | BIGINT | PRIMARY KEY, AUTO_INCREMENT | 商品 ID |
+| tenant_id | VARCHAR(255) | NOT NULL | 租户 ID |
+| shop_id | VARCHAR(255) | | 店铺 ID |
+| title | VARCHAR(255) | NOT NULL | 商品标题 |
+| description | TEXT | | 商品描述 |
+| main_image | VARCHAR(255) | | 商品主图 |
+| platform | VARCHAR(50) | | 平台 |
+| platform_product_id | VARCHAR(255) | | 平台商品 ID |
+| price | DECIMAL(10,2) | | 价格 |
+| cost_price | DECIMAL(10,2) | | 成本价格 |
+| quantity | INT | | 数量 |
+| status | VARCHAR(50) | | 状态 |
+| phash | VARCHAR(255) | | 图片哈希 |
+| semantic_hash | VARCHAR(255) | | 语义哈希 |
+| vector_embedding | TEXT | | 向量嵌入 |
+| attributes | JSON | | 属性 |
+| created_at | DATETIME | DEFAULT CURRENT_TIMESTAMP | 创建时间 |
+| updated_at | DATETIME | DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP | 更新时间 |
+
+### 2.3 订单表（cf_order）
+
+| 字段名 | 数据类型 | 约束 | 描述 |
+|-------|---------|------|------|
+| id | BIGINT | PRIMARY KEY, AUTO_INCREMENT | 订单 ID |
+| tenant_id | VARCHAR(255) | NOT NULL | 租户 ID |
+| shop_id | VARCHAR(255) | | 店铺 ID |
+| platform | VARCHAR(50) | | 平台 |
+| platform_order_id | VARCHAR(255) | | 平台订单 ID |
+| status | VARCHAR(50) | | 状态 |
+| total_amount | DECIMAL(10,2) | | 总金额 |
+| currency | VARCHAR(10) | | 货币 |
+| customer_info | JSON | | 客户信息 |
+| items | JSON | | 商品列表 |
+| shipping_address | JSON | | shipping 地址 |
+| tracking_number | VARCHAR(255) | | 跟踪号 |
+| created_at | DATETIME | DEFAULT CURRENT_TIMESTAMP | 创建时间 |
+| updated_at | DATETIME | DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP | 更新时间 |
+
+### 2.4 支付表（cf_payment）
+
+| 字段名 | 数据类型 | 约束 | 描述 |
+|-------|---------|------|------|
+| id | BIGINT | PRIMARY KEY, AUTO_INCREMENT | 支付 ID |
+| tenant_id | VARCHAR(255) | NOT NULL | 租户 ID |
+| order_id | BIGINT | FOREIGN KEY (order_id) REFERENCES cf_order(id) | 订单 ID |
+| payment_method | VARCHAR(50) | | 支付方式 |
+| amount | DECIMAL(10,2) | | 金额 |
+| currency | VARCHAR(10) | | 货币 |
+| status | VARCHAR(50) | | 状态 |
+| transaction_id | VARCHAR(255) | | 交易 ID |
+| created_at | DATETIME | DEFAULT CURRENT_TIMESTAMP | 创建时间 |
+| updated_at | DATETIME | DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP | 更新时间 |
+
+### 2.5 物流表（cf_logistics）
+
+| 字段名 | 数据类型 | 约束 | 描述 |
+|-------|---------|------|------|
+| id | BIGINT | PRIMARY KEY, AUTO_INCREMENT | 物流 ID |
+| tenant_id | VARCHAR(255) | NOT NULL | 租户 ID |
+| order_id | BIGINT | FOREIGN KEY (order_id) REFERENCES cf_order(id) | 订单 ID |
+| shipping_method | VARCHAR(50) | | 物流方式 |
+| tracking_number | VARCHAR(255) | | 跟踪号 |
+| carrier | VARCHAR(50) | | 物流公司 |
+| status | VARCHAR(50) | | 状态 |
+| estimated_delivery_date | DATETIME | | 预计送达日期 |
+| actual_delivery_date | DATETIME | | 实际送达日期 |
+| created_at | DATETIME | DEFAULT CURRENT_TIMESTAMP | 创建时间 |
+| updated_at | DATETIME | DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP | 更新时间 |
+
+### 2.6 告警表（cf_alert）
+
+| 字段名 | 数据类型 | 约束 | 描述 |
+|-------|---------|------|------|
+| id | BIGINT | PRIMARY KEY, AUTO_INCREMENT | 告警 ID |
+| tenant_id | VARCHAR(255) | NOT NULL | 租户 ID |
+| alert_type | VARCHAR(50) | | 告警类型 |
+| severity | VARCHAR(50) | | 严重程度 |
+| message | TEXT | | 告警消息 |
+| status | VARCHAR(50) | | 状态 |
+| source | VARCHAR(255) | | 告警来源 |
+| threshold | VARCHAR(255) | | 阈值 |
+| actual_value | VARCHAR(255) | | 实际值 |
+| created_at | DATETIME | DEFAULT CURRENT_TIMESTAMP | 创建时间 |
+| resolved_at | DATETIME | | 解决时间 |
+
+### 2.7 审计表（cf_audit）
+
+| 字段名 | 数据类型 | 约束 | 描述 |
+|-------|---------|------|------|
+| id | BIGINT | PRIMARY KEY, AUTO_INCREMENT | 审计日志 ID |
+| tenant_id | VARCHAR(255) | | 租户 ID |
+| shop_id | VARCHAR(255) | | 店铺 ID |
+| user_id | BIGINT | | 用户 ID |
+| action | VARCHAR(255) | | 操作类型 |
+| resource_type | VARCHAR(255) | | 资源类型 |
+| resource_id | VARCHAR(255) | | 资源 ID |
+| ip_address | VARCHAR(100) | | IP 地址 |
+| user_agent | TEXT | | 用户代理 |
+| details | TEXT | | 详细信息 |
+| created_at | DATETIME | DEFAULT CURRENT_TIMESTAMP | 创建时间 |
+
+### 2.8 配置表（cf_config）
+
+| 字段名 | 数据类型 | 约束 | 描述 |
+|-------|---------|------|------|
+| id | BIGINT | PRIMARY KEY, AUTO_INCREMENT | 配置 ID |
+| tenant_id | VARCHAR(255) | | 租户 ID |
+| shop_id | VARCHAR(255) | | 店铺 ID |
+| config_key | VARCHAR(255) | NOT NULL | 配置键 |
+| config_value | VARCHAR(255) | NOT NULL | 配置值 |
+| config_type | VARCHAR(50) | | 配置类型 |
+| description | TEXT | | 配置描述 |
+| created_at | DATETIME | DEFAULT CURRENT_TIMESTAMP | 创建时间 |
+| updated_at | DATETIME | DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP | 更新时间 |
+
+## 3. 索引设计
+
+### 3.1 用户表索引
+
+| 索引名 | 字段 | 类型 | 描述 |
+|-------|------|------|------|
+| PRIMARY | id | PRIMARY | 主键索引 |
+| idx_user_tenant_id | tenant_id | INDEX | 租户 ID 索引 |
+| UNIQUE | username | UNIQUE | 用户名唯一索引 |
+| UNIQUE | email | UNIQUE | 邮箱唯一索引 |
+
+### 3.2 商品表索引
+
+| 索引名 | 字段 | 类型 | 描述 |
+|-------|------|------|------|
+| PRIMARY | id | PRIMARY | 主键索引 |
+| idx_product_tenant_id | tenant_id | INDEX | 租户 ID 索引 |
+| idx_product_platform | platform | INDEX | 平台索引 |
+
+### 3.3 订单表索引
+
+| 索引名 | 字段 | 类型 | 描述 |
+|-------|------|------|------|
+| PRIMARY | id | PRIMARY | 主键索引 |
+| idx_order_tenant_id | tenant_id | INDEX | 租户 ID 索引 |
+| idx_order_platform | platform | INDEX | 平台索引 |
+
+### 3.4 支付表索引
+
+| 索引名 | 字段 | 类型 | 描述 |
+|-------|------|------|------|
+| PRIMARY | id | PRIMARY | 主键索引 |
+| idx_payment_tenant_id | tenant_id | INDEX | 租户 ID 索引 |
+| idx_payment_order_id | order_id | INDEX | 订单 ID 索引 |
+
+### 3.5 物流表索引
+
+| 索引名 | 字段 | 类型 | 描述 |
+|-------|------|------|------|
+| PRIMARY | id | PRIMARY | 主键索引 |
+| idx_logistics_tenant_id | tenant_id | INDEX | 租户 ID 索引 |
+| idx_logistics_order_id | order_id | INDEX | 订单 ID 索引 |
+
+### 3.6 告警表索引
+
+| 索引名 | 字段 | 类型 | 描述 |
+|-------|------|------|------|
+| PRIMARY | id | PRIMARY | 主键索引 |
+| idx_alert_tenant_id | tenant_id | INDEX | 租户 ID 索引 |
+| idx_alert_status | status | INDEX | 状态索引 |
+| idx_alert_severity | severity | INDEX | 严重程度索引 |
+| idx_alert_alert_type | alert_type | INDEX | 告警类型索引 |
+| idx_alert_created_at | created_at | INDEX | 创建时间索引 |
+
+### 3.7 审计表索引
+
+| 索引名 | 字段 | 类型 | 描述 |
+|-------|------|------|------|
+| PRIMARY | id | PRIMARY | 主键索引 |
+| idx_audit_tenant_id | tenant_id | INDEX | 租户 ID 索引 |
+| idx_audit_shop_id | shop_id | INDEX | 店铺 ID 索引 |
+| idx_audit_user_id | user_id | INDEX | 用户 ID 索引 |
+| idx_audit_action | action | INDEX | 操作类型索引 |
+| idx_audit_resource_type | resource_type | INDEX | 资源类型索引 |
+| idx_audit_created_at | created_at | INDEX | 创建时间索引 |
+
+### 3.8 配置表索引
+
+| 索引名 | 字段 | 类型 | 描述 |
+|-------|------|------|------|
+| PRIMARY | id | PRIMARY | 主键索引 |
+| idx_config_tenant_id | tenant_id | INDEX | 租户 ID 索引 |
+| idx_config_shop_id | shop_id | INDEX | 店铺 ID 索引 |
+| idx_config_key | config_key | INDEX | 配置键索引 |
+
+## 4. 关系设计
+
+### 4.1 表关系
+
+- **用户与订单**：一对多关系，一个用户可以创建多个订单
+- **订单与支付**：一对一关系，一个订单对应一个支付
+- **订单与物流**：一对一关系，一个订单对应一个物流
+- **租户与所有表**：一对多关系，一个租户可以有多个用户、商品、订单等
+
+### 4.2 外键约束
+
+| 表名 | 外键字段 | 引用表 | 引用字段 | 约束 |
+|------|---------|--------|---------|------|
+| cf_payment | order_id | cf_order | id | ON DELETE CASCADE |
+| cf_logistics | order_id | cf_order | id | ON DELETE CASCADE |
+
+## 5. 数据类型选择
+
+### 5.1 字符串类型
+- **VARCHAR**：用于存储可变长度的字符串，如用户名、邮箱等
+- **TEXT**：用于存储较长的文本，如商品描述、详细信息等
+- **JSON**：用于存储 JSON 格式的数据，如客户信息、商品列表等
+
+### 5.2 数值类型
+- **BIGINT**：用于存储较大的整数，如 ID 等
+- **INT**：用于存储整数，如数量等
+- **DECIMAL(10,2)**：用于存储金额，确保精度
+
+### 5.3 日期类型
+- **DATETIME**：用于存储日期和时间，如创建时间、更新时间等
+
+## 6. 数据库迁移
+
+Crawlful Hub 项目使用 Flyway 进行数据库迁移，确保数据库结构的版本控制和一致性。
+
+### 6.1 迁移脚本
+
+| 脚本名 | 描述 |
+|-------|------|
+| V1__init_schema.sql | 初始化数据库表结构 |
+| V2__add_alert_table.sql | 添加告警表 |
+
+### 6.2 迁移执行
+
+1. 进入项目目录：
+ ```bash
+ cd d:\trae_projects\makemd\makemd\serverjava
+ ```
+
+2. 执行数据库迁移：
+ ```bash
+ mvn flyway:migrate
+ ```
+
+## 7. 性能优化
+
+### 7.1 索引优化
+
+- **添加适当的索引**：为频繁查询的字段添加索引
+- **避免过度索引**：不要为所有字段添加索引，只为必要的字段添加
+- **使用复合索引**：对于多字段查询，使用复合索引
+
+### 7.2 查询优化
+
+- **使用分页查询**：避免一次性加载大量数据
+- **使用索引覆盖查询**：减少回表操作
+- **避免全表扫描**：使用索引进行查询
+- **使用预编译语句**：减少 SQL 解析时间
+
+### 7.3 连接池优化
+
+- **使用 HikariCP**：高性能的数据库连接池
+- **配置合理的连接数**：根据系统负载配置连接数
+- **设置连接超时**：避免连接占用过长时间
+
+## 8. 安全考虑
+
+### 8.1 数据加密
+
+- **密码加密**：使用 BCrypt 加密用户密码
+- **敏感数据加密**：对敏感数据进行加密存储
+
+### 8.2 访问控制
+
+- **最小权限原则**：只授予必要的数据库权限
+- **使用参数化查询**：防止 SQL 注入攻击
+- **定期审计**：定期审计数据库访问日志
+
+## 9. 总结
+
+本数据库设计文档详细介绍了 Crawlful Hub 项目的数据库表结构、索引和关系。通过合理的数据库设计，确保了系统的性能和可靠性。
diff --git a/docs/06_Security_Guide.md b/docs/06_Security_Guide.md
new file mode 100644
index 0000000..c5170f6
--- /dev/null
+++ b/docs/06_Security_Guide.md
@@ -0,0 +1,297 @@
+# 安全指南
+
+## 1. 安全概述
+
+Crawlful Hub 项目采用了全面的安全措施，确保系统的安全性和可靠性。本文档详细介绍了项目的安全措施和最佳实践。
+
+## 2. 认证与授权
+
+### 2.1 JWT 认证
+
+Crawlful Hub 项目使用 JWT（JSON Web Token）进行认证，确保用户身份的安全性。
+
+**实现细节**：
+- 使用 Spring Security 实现 JWT 认证
+- 配置 JWT 密钥和过期时间
+- 验证 JWT 令牌的有效性
+
+**配置示例**：
+```yaml
+spring:
+ security:
+ jwt:
+ secret: your-secret-key
+ expiration: 86400000
+```
+
+### 2.2 角色授权
+
+Crawlful Hub 项目使用基于角色的访问控制（RBAC），确保用户只能访问其权限范围内的资源。
+
+**预设角色**：
+- `ADMIN` - 全权
+- `MANAGER` - 运营主管
+- `OPERATOR` - 运营专员
+- `FINANCE` - 财务主管
+- `SOURCING` - 采购专家
+- `LOGISTICS` - 物流专家
+- `ANALYST` - 数据分析师
+
+**授权实现**：
+- 使用 `@PreAuthorize` 注解进行方法级别的授权
+- 实现 `authorize()` 中间件进行路由级别的授权
+
+**示例代码**：
+```java
+@PreAuthorize("hasRole('ADMIN')")
+public void deleteUser(Long id) {
+ // 实现删除用户的逻辑
+}
+```
+
+## 3. 数据安全
+
+### 3.1 密码加密
+
+Crawlful Hub 项目使用 BCrypt 对用户密码进行加密，确保密码的安全性。
+
+**实现细节**：
+- 使用 `BCryptPasswordEncoder` 对密码进行加密
+- 存储加密后的密码，不存储明文密码
+
+**示例代码**：
+```java
+@Autowired
+private PasswordEncoder passwordEncoder;
+
+public User createUser(User user) {
+ user.setPassword(passwordEncoder.encode(user.getPassword()));
+ return userRepository.save(user);
+}
+```
+
+### 3.2 敏感数据保护
+
+Crawlful Hub 项目对敏感数据进行保护，确保数据的安全性。
+
+**保护措施**：
+- 对敏感数据进行加密存储
+- 避免在日志中记录敏感信息
+- 使用 HTTPS 协议传输数据
+
+**示例代码**：
+```java
+@Column(columnDefinition = "VARBINARY(255)")
+private byte[] sensitiveData;
+```
+
+## 4. 输入验证
+
+### 4.1 参数验证
+
+Crawlful Hub 项目对输入参数进行验证，确保输入的合法性。
+
+**实现细节**：
+- 使用 `@Valid` 注解和 `BindingResult` 进行参数验证
+- 实现 `ValidationUtil` 工具类进行数据验证
+
+**示例代码**：
+```java
+@PostMapping("/create")
+public ResponseEntity createUser(@Valid @RequestBody User user, BindingResult bindingResult) {
+ if (bindingResult.hasErrors()) {
+ return ResponseEntity.badRequest().build();
+ }
+ return ResponseEntity.ok(userService.createUser(user));
+}
+```
+
+### 4.2 SQL 注入防护
+
+Crawlful Hub 项目使用参数化查询，防止 SQL 注入攻击。
+
+**实现细节**：
+- 使用 JPA 或 MyBatis 进行数据库操作
+- 避免直接拼接 SQL 语句
+
+**示例代码**：
+```java
+// 正确的做法
+@Query("SELECT u FROM User u WHERE u.username = :username")
+User findByUsername(@Param("username") String username);
+
+// 错误的做法（避免）
+String sql = "SELECT * FROM user WHERE username = '" + username + "'";
+```
+
+## 5. 跨站请求伪造（CSRF）防护
+
+Crawlful Hub 项目实现了 CSRF 防护，防止跨站请求伪造攻击。
+
+**实现细节**：
+- 使用 Spring Security 的 CSRF 保护
+- 配置 CSRF 令牌的生成和验证
+
+**配置示例**：
+```java
+@Configuration
+public class SecurityConfig extends WebSecurityConfigurerAdapter {
+ @Override
+ protected void configure(HttpSecurity http) throws Exception {
+ http.csrf().csrfTokenRepository(CookieCsrfTokenRepository.withHttpOnlyFalse());
+ }
+}
+```
+
+## 6. 速率限制
+
+Crawlful Hub 项目实现了速率限制，防止暴力破解和 DoS 攻击。
+
+**实现细节**：
+- 实现 `RateLimitFilter` 过滤器
+- 基于客户端 IP 和请求 URI 进行限制
+- 限制客户端每分钟最大请求数为 60 次
+
+**示例代码**：
+```java
+@Component
+public class RateLimitFilter implements Filter {
+ private final Map requestCounts = new ConcurrentHashMap<>();
+ private final Map lastResetTimes = new ConcurrentHashMap<>();
+ private static final int MAX_REQUESTS_PER_MINUTE = 60;
+
+ @Override
+ public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
+ HttpServletRequest httpRequest = (HttpServletRequest) request;
+ String clientIp = httpRequest.getRemoteAddr();
+ String requestUri = httpRequest.getRequestURI();
+ String key = clientIp + ":" + requestUri;
+
+ long currentTime = System.currentTimeMillis();
+ long lastResetTime = lastResetTimes.getOrDefault(key, 0L);
+
+ if (currentTime - lastResetTime > 60000) {
+ requestCounts.put(key, new AtomicInteger(1));
+ lastResetTimes.put(key, currentTime);
+ } else {
+ AtomicInteger count = requestCounts.get(key);
+ if (count != null && count.incrementAndGet() > MAX_REQUESTS_PER_MINUTE) {
+ ((HttpServletResponse) response).setStatus(HttpStatus.TOO_MANY_REQUESTS.value());
+ return;
+ }
+ }
+
+ chain.doFilter(request, response);
+ }
+}
+```
+
+## 7. 安全日志
+
+Crawlful Hub 项目实现了安全日志，记录系统的安全事件。
+
+**实现细节**：
+- 使用 Logback 配置安全日志
+- 记录用户登录、登出、权限变更等安全事件
+- 记录异常登录尝试和权限错误
+
+**配置示例**：
+```xml
+
+ logs/security.log
+
+ logs/security.%d{yyyy-MM-dd}.log
+ 30
+
+
+ %d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n
+
+
+
+
+
+
+```
+
+## 8. 安全最佳实践
+
+### 8.1 代码安全
+
+- **使用最新的依赖**：定期更新项目依赖，修复安全漏洞
+- **避免硬编码**：避免在代码中硬编码密钥、密码等敏感信息
+- **使用安全的加密算法**：使用强加密算法，如 BCrypt、AES 等
+- **定期代码审查**：定期进行代码审查，发现和修复安全问题
+
+### 8.2 服务器安全
+
+- **使用 HTTPS**：使用 HTTPS 协议传输数据
+- **限制访问**：限制服务器的访问范围，只允许必要的端口和 IP 访问
+- **定期更新**：定期更新服务器操作系统和软件，修复安全漏洞
+- **使用防火墙**：使用防火墙保护服务器，防止未授权访问
+
+### 8.3 数据库安全
+
+- **最小权限原则**：只授予数据库用户必要的权限
+- **定期备份**：定期备份数据库，防止数据丢失
+- **使用参数化查询**：防止 SQL 注入攻击
+- **加密敏感数据**：对敏感数据进行加密存储
+
+### 8.4 应用安全
+
+- **使用 CSRF 保护**：防止跨站请求伪造攻击
+- **实现速率限制**：防止暴力破解和 DoS 攻击
+- **验证输入**：对所有输入进行验证，防止恶意输入
+- **使用安全的会话管理**：使用安全的会话管理机制，防止会话劫持
+
+## 9. 安全审计
+
+### 9.1 审计日志
+
+Crawlful Hub 项目实现了审计日志，记录系统的操作和事件。
+
+**实现细节**：
+- 使用 `cf_audit` 表存储审计日志
+- 记录用户操作、资源访问、权限变更等事件
+- 记录 IP 地址、用户代理等信息
+
+**示例代码**：
+```java
+@Service
+public class AuditService {
+ @Autowired
+ private AuditRepository auditRepository;
+
+ public void logAudit(String tenantId, String shopId, Long userId, String action, String resourceType, String resourceId, String ipAddress, String userAgent, String details) {
+ Audit audit = new Audit();
+ audit.setTenantId(tenantId);
+ audit.setShopId(shopId);
+ audit.setUserId(userId);
+ audit.setAction(action);
+ audit.setResourceType(resourceType);
+ audit.setResourceId(resourceId);
+ audit.setIpAddress(ipAddress);
+ audit.setUserAgent(userAgent);
+ audit.setDetails(details);
+ audit.setCreatedAt(new Date());
+ auditRepository.save(audit);
+ }
+}
+```
+
+### 9.2 安全扫描
+
+Crawlful Hub 项目定期进行安全扫描，发现和修复安全漏洞。
+
+**扫描工具**：
+- **OWASP ZAP**：用于 Web 应用安全扫描
+- **SonarQube**：用于代码安全扫描
+- **Nmap**：用于网络安全扫描
+
+**扫描频率**：
+- 开发环境：每次代码提交后
+- 测试环境：每周一次
+- 生产环境：每月一次
+
+## 10. 总结
+
+本安全指南详细介绍了 Crawlful Hub 项目的安全措施和最佳实践。通过本指南，您可以了解如何确保系统的安全性和可靠性。
diff --git a/docs/07_Maintenance_Guide.md b/docs/07_Maintenance_Guide.md
new file mode 100644
index 0000000..3c76163
--- /dev/null
+++ b/docs/07_Maintenance_Guide.md
@@ -0,0 +1,292 @@
+# 维护指南
+
+## 1. 维护概述
+
+Crawlful Hub 项目需要定期维护，确保系统的稳定运行和性能优化。本文档详细介绍了项目的维护方法和最佳实践。
+
+## 2. 日常维护
+
+### 2.1 监控系统状态
+
+**监控指标**：
+- **系统健康状态**：访问 `http://localhost:3001/api/v1/monitoring/health`
+- **系统性能指标**：访问 `http://localhost:3001/api/v1/monitoring/metrics`
+- **系统日志**：查看 `logs/server.log` 文件
+
+**监控工具**：
+- **Prometheus**：用于监控系统性能指标
+- **Grafana**：用于可视化监控数据
+- **ELK Stack**：用于日志收集和分析
+
+### 2.2 数据库维护
+
+**定期备份**：
+- 每周备份一次数据库
+- 使用 `mysqldump` 命令备份数据库
+
+**优化数据库**：
+- 定期优化数据库表结构
+- 定期分析数据库查询性能
+- 定期更新数据库统计信息
+
+**示例命令**：
+```bash
+# 备份数据库
+mysqldump -u root -p crawlful_hub > crawlful_hub_backup.sql
+
+# 优化数据库表
+mysqlcheck -u root -p --optimize crawlful_hub
+
+# 分析数据库表
+mysqlcheck -u root -p --analyze crawlful_hub
+```
+
+### 2.3 日志管理
+
+**日志轮转**：
+- 配置 Logback 实现日志轮转
+- 按日期保存日志文件
+- 保留 30 天的日志文件
+
+**日志分析**：
+- 定期分析系统日志
+- 发现和解决系统异常
+- 优化系统性能
+
+**示例配置**：
+```xml
+
+ logs/server.log
+
+ logs/server.%d{yyyy-MM-dd}.log
+ 30
+
+
+ %d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n
+
+
+```
+
+## 3. 性能优化
+
+### 3.1 数据库优化
+
+**索引优化**：
+- 为频繁查询的字段添加索引
+- 避免过度索引
+- 使用复合索引
+
+**查询优化**：
+- 使用分页查询
+- 使用索引覆盖查询
+- 避免全表扫描
+- 使用预编译语句
+
+**连接池优化**：
+- 配置合理的连接数
+- 设置连接超时
+- 监控连接池状态
+
+### 3.2 缓存优化
+
+**Redis 缓存**：
+- 配置合理的缓存过期时间
+- 监控缓存命中率
+- 优化缓存键设计
+
+**示例配置**：
+```java
+@Configuration
+@EnableCaching
+public class CacheConfig {
+ @Bean
+ public RedisCacheManager cacheManager(RedisConnectionFactory factory) {
+ RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
+ .entryTtl(Duration.ofMinutes(10));
+ return RedisCacheManager.builder(factory)
+ .cacheDefaults(config)
+ .build();
+ }
+}
+```
+
+### 3.3 服务器优化
+
+**内存优化**：
+- 配置合理的 JVM 内存参数
+- 监控内存使用情况
+- 避免内存泄漏
+
+**CPU 优化**：
+- 优化代码逻辑
+- 避免阻塞操作
+- 使用异步处理
+
+**示例 JVM 参数**：
+```bash
+java -Xms2G -Xmx4G -jar serverjava-0.0.1-SNAPSHOT.jar
+```
+
+## 4. 故障处理
+
+### 4.1 常见故障
+
+**数据库连接失败**：
+- 检查数据库服务是否运行
+- 检查数据库连接配置是否正确
+- 检查数据库用户权限是否正确
+
+**Redis 连接失败**：
+- 检查 Redis 服务是否运行
+- 检查 Redis 连接配置是否正确
+
+**端口被占用**：
+- 检查端口是否被其他服务占用
+- 修改 `application.yml` 中的端口配置
+
+**JWT 验证失败**：
+- 检查 JWT 密钥是否正确
+- 检查 JWT 令牌是否过期
+
+### 4.2 故障排查
+
+**查看日志**：
+- 查看 `logs/server.log` 文件
+- 查找错误信息和异常堆栈
+
+**使用健康检查**：
+- 访问 `http://localhost:3001/api/v1/monitoring/health`
+- 检查系统健康状态
+
+**使用 Ping 测试**：
+- 访问 `http://localhost:3001/api/v1/monitoring/ping`
+- 测试系统响应
+
+**使用 API 文档**：
+- 访问 `http://localhost:3001/api/api-docs`
+- 测试 API 接口
+
+## 5. 升级与更新
+
+### 5.1 依赖更新
+
+**定期更新依赖**：
+- 定期检查和更新项目依赖
+- 修复安全漏洞
+- 提高系统性能
+
+**示例命令**：
+```bash
+# 检查依赖更新
+mvn dependency:check
+
+# 更新依赖
+mvn versions:update-properties
+```
+
+### 5.2 代码更新
+
+**代码审查**：
+- 定期进行代码审查
+- 发现和修复代码问题
+- 优化代码结构
+
+**版本控制**：
+- 使用 Git 进行版本控制
+- 定期提交代码
+- 管理代码分支
+
+### 5.3 系统升级
+
+**升级步骤**：
+1. 停止服务
+2. 备份数据
+3. 拉取最新代码
+4. 重新构建项目
+5. 启动服务
+
+**示例命令**：
+```bash
+# 停止服务
+sudo systemctl stop serverjava
+
+# 备份数据
+mysqldump -u root -p crawlful_hub > crawlful_hub_backup.sql
+
+# 拉取最新代码
+git pull
+
+# 重新构建项目
+mvn clean package
+
+# 启动服务
+sudo systemctl start serverjava
+```
+
+## 6. 监控与告警
+
+### 6.1 系统监控
+
+**监控指标**：
+- **CPU 使用率**：监控系统 CPU 使用率
+- **内存使用率**：监控系统内存使用率
+- **磁盘使用率**：监控系统磁盘使用率
+- **网络流量**：监控系统网络流量
+- **API 响应时间**：监控 API 接口响应时间
+- **数据库性能**：监控数据库查询性能
+
+**监控工具**：
+- **Prometheus**：用于监控系统性能指标
+- **Grafana**：用于可视化监控数据
+- **ELK Stack**：用于日志收集和分析
+
+### 6.2 告警系统
+
+**告警类型**：
+- **系统告警**：系统故障、性能异常等
+- **业务告警**：订单异常、支付失败等
+- **安全告警**：未授权访问、异常登录等
+
+**告警级别**：
+- **ERROR**：严重错误，需要立即处理
+- **WARN**：警告，需要关注
+- **INFO**：信息，仅供参考
+
+**告警处理**：
+- 及时接收和处理告警
+- 记录告警处理过程
+- 分析告警原因，防止再次发生
+
+## 7. 最佳实践
+
+### 7.1 代码最佳实践
+
+- **代码风格**：遵循 Java 代码风格规范
+- **注释**：为代码添加适当的注释
+- **测试**：为代码添加单元测试和集成测试
+- **文档**：为代码添加文档
+
+### 7.2 数据库最佳实践
+
+- **表设计**：遵循数据库设计规范
+- **索引**：为频繁查询的字段添加索引
+- **查询**：优化数据库查询
+- **备份**：定期备份数据库
+
+### 7.3 服务器最佳实践
+
+- **配置**：配置合理的服务器参数
+- **监控**：监控服务器状态
+- **安全**：确保服务器安全
+- **备份**：定期备份服务器数据
+
+### 7.4 维护最佳实践
+
+- **定期维护**：定期进行系统维护
+- **记录**：记录系统维护过程
+- **分析**：分析系统维护结果
+- **改进**：根据维护结果改进系统
+
+## 8. 总结
+
+本维护指南详细介绍了 Crawlful Hub 项目的维护方法和最佳实践。通过本指南，您可以了解如何确保系统的稳定运行和性能优化。
diff --git a/docs/08_Internationalization_Guide.md b/docs/08_Internationalization_Guide.md
new file mode 100644
index 0000000..4bfed4e
--- /dev/null
+++ b/docs/08_Internationalization_Guide.md
@@ -0,0 +1,245 @@
+# 国际化指南
+
+## 1. 国际化概述
+
+Crawlful Hub 项目支持国际化，确保系统可以在不同语言环境下正常运行。本文档详细介绍了项目的国际化支持和实现方法。
+
+## 2. 国际化配置
+
+### 2.1 资源文件
+
+Crawlful Hub 项目使用 Spring 国际化支持，通过资源文件管理不同语言的文本。
+
+**资源文件位置**：
+- `src/main/resources/i18n/messages.properties` - 英文资源文件
+- `src/main/resources/i18n/messages_zh.properties` - 中文资源文件
+
+**资源文件示例**：
+
+**messages.properties**：
+```properties
+# Authentication
+auth.login.success=Login successful
+auth.login.failure=Invalid username or password
+auth.register.success=Registration successful
+auth.register.failure=Registration failed
+
+# Product
+product.create.success=Product created successfully
+product.create.failure=Failed to create product
+product.update.success=Product updated successfully
+product.update.failure=Failed to update product
+product.delete.success=Product deleted successfully
+product.delete.failure=Failed to delete product
+
+# Order
+order.create.success=Order created successfully
+order.create.failure=Failed to create order
+order.update.success=Order updated successfully
+order.update.failure=Failed to update order
+order.delete.success=Order deleted successfully
+order.delete.failure=Failed to delete order
+```
+
+**messages_zh.properties**：
+```properties
+# 认证
+auth.login.success=登录成功
+auth.login.failure=用户名或密码错误
+auth.register.success=注册成功
+auth.register.failure=注册失败
+
+# 商品
+product.create.success=商品创建成功
+product.create.failure=商品创建失败
+product.update.success=商品更新成功
+product.update.failure=商品更新失败
+product.delete.success=商品删除成功
+product.delete.failure=商品删除失败
+
+# 订单
+order.create.success=订单创建成功
+order.create.failure=订单创建失败
+order.update.success=订单更新成功
+order.update.failure=订单更新失败
+order.delete.success=订单删除成功
+order.delete.failure=订单删除失败
+```
+
+### 2.2 国际化配置类
+
+Crawlful Hub 项目通过 `InternationalizationConfig` 类配置国际化支持。
+
+**配置示例**：
+```java
+@Configuration
+public class InternationalizationConfig implements WebMvcConfigurer {
+ @Bean
+ public MessageSource messageSource() {
+ ResourceBundleMessageSource messageSource = new ResourceBundleMessageSource();
+ messageSource.setBasename("i18n/messages");
+ messageSource.setDefaultEncoding("UTF-8");
+ return messageSource;
+ }
+
+ @Bean
+ public LocaleResolver localeResolver() {
+ CookieLocaleResolver localeResolver = new CookieLocaleResolver();
+ localeResolver.setDefaultLocale(Locale.ENGLISH);
+ return localeResolver;
+ }
+
+ @Override
+ public void addInterceptors(InterceptorRegistry registry) {
+ LocaleChangeInterceptor interceptor = new LocaleChangeInterceptor();
+ interceptor.setParamName("lang");
+ registry.addInterceptor(interceptor);
+ }
+}
+```
+
+## 3. 国际化使用
+
+### 3.1 在控制器中使用
+
+Crawlful Hub 项目在控制器中使用国际化消息。
+
+**示例代码**：
+```java
+@RestController
+@RequestMapping("/api/v1/users")
+public class UserController {
+ @Autowired
+ private MessageSource messageSource;
+
+ @PostMapping("/register")
+ public ResponseEntity register(@RequestBody User user, Locale locale) {
+ try {
+ userService.createUser(user);
+ return ResponseEntity.ok(messageSource.getMessage("auth.register.success", null, locale));
+ } catch (Exception e) {
+ return ResponseEntity.badRequest().body(messageSource.getMessage("auth.register.failure", null, locale));
+ }
+ }
+}
+```
+
+### 3.2 在服务中使用
+
+Crawlful Hub 项目在服务中使用国际化消息。
+
+**示例代码**：
+```java
+@Service
+public class ProductService {
+ @Autowired
+ private MessageSource messageSource;
+
+ public Product createProduct(Product product, Locale locale) {
+ try {
+ Product savedProduct = productRepository.save(product);
+ log.info(messageSource.getMessage("product.create.success", null, locale));
+ return savedProduct;
+ } catch (Exception e) {
+ log.error(messageSource.getMessage("product.create.failure", null, locale), e);
+ throw e;
+ }
+ }
+}
+```
+
+### 3.3 在异常处理中使用
+
+Crawlful Hub 项目在异常处理中使用国际化消息。
+
+**示例代码**：
+```java
+@RestControllerAdvice
+public class GlobalExceptionHandler {
+ @Autowired
+ private MessageSource messageSource;
+
+ @ExceptionHandler(Exception.class)
+ public ResponseEntity handleException(Exception e, Locale locale) {
+ ApiError error = new ApiError();
+ error.setCode("INTERNAL_ERROR");
+ error.setMessage(messageSource.getMessage("error.internal", null, locale));
+ error.setDetails(e.getMessage());
+ error.setTraceId(UUID.randomUUID().toString());
+ return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(error);
+ }
+}
+```
+
+## 4. 语言切换
+
+Crawlful Hub 项目支持通过 URL 参数切换语言。
+
+**示例 URL**：
+- 英文：`http://localhost:3001/api/v1/users?lang=en`
+- 中文：`http://localhost:3001/api/v1/users?lang=zh`
+
+**实现细节**：
+- 使用 `LocaleChangeInterceptor` 拦截器处理语言切换
+- 通过 `lang` 参数指定语言
+- 支持的语言：`en`（英文）、`zh`（中文）
+
+## 5. 国际化最佳实践
+
+### 5.1 资源文件管理
+
+- **命名规范**：使用 `messages_{language}.properties` 命名资源文件
+- **组织方式**：按功能模块组织资源文件，如认证、商品、订单等
+- **编码格式**：使用 UTF-8 编码
+- **注释**：为资源文件添加适当的注释
+
+### 5.2 消息键命名
+
+- **命名规范**：使用 `module.action.result` 格式命名消息键
+- **一致性**：保持消息键的一致性，便于管理和维护
+- **可读性**：使用清晰、简洁的消息键，便于理解
+
+### 5.3 国际化测试
+
+- **测试不同语言**：测试系统在不同语言环境下的表现
+- **测试语言切换**：测试语言切换功能是否正常
+- **测试消息显示**：测试消息是否正确显示
+
+## 6. 扩展国际化支持
+
+### 6.1 添加新语言
+
+**步骤**：
+1. 在 `src/main/resources/i18n/` 目录下创建新的资源文件，如 `messages_fr.properties`（法语）
+2. 翻译资源文件中的消息
+3. 配置 `InternationalizationConfig` 类，支持新的语言
+
+**示例**：
+```java
+@Bean
+public LocaleResolver localeResolver() {
+ CookieLocaleResolver localeResolver = new CookieLocaleResolver();
+ localeResolver.setDefaultLocale(Locale.ENGLISH);
+ return localeResolver;
+}
+```
+
+### 6.2 动态消息
+
+Crawlful Hub 项目支持动态消息，通过参数传递动态值。
+
+**示例**：
+
+**资源文件**：
+```properties
+user.welcome=Welcome, {0}!
+```
+
+**使用示例**：
+```java
+String welcomeMessage = messageSource.getMessage("user.welcome", new Object[]{username}, locale);
+```
+
+## 7. 总结
+
+本国际化指南详细介绍了 Crawlful Hub 项目的国际化支持和实现方法。通过本指南，您可以了解如何确保系统在不同语言环境下正常运行。
diff --git a/docs/09_Development_Guide.md b/docs/09_Development_Guide.md
new file mode 100644
index 0000000..41196bb
--- /dev/null
+++ b/docs/09_Development_Guide.md
@@ -0,0 +1,340 @@
+# 开发指南
+
+## 1. 开发环境搭建
+
+### 1.1 环境要求
+
+- **Java**: JDK 17 或更高版本
+- **Maven**: 3.6 或更高版本
+- **MySQL**: 8.0 或更高版本
+- **Redis**: 6.0 或更高版本
+- **IDE**: IntelliJ IDEA 或 Eclipse
+
+### 1.2 安装步骤
+
+**Windows 系统**:
+1. 下载并安装 JDK 17：[Oracle JDK 17](https://www.oracle.com/java/technologies/downloads/#java17)
+2. 下载并安装 Maven：[Apache Maven](https://maven.apache.org/download.cgi)
+3. 下载并安装 MySQL：[MySQL Community Server](https://dev.mysql.com/downloads/mysql/)
+4. 下载并安装 Redis：[Redis for Windows](https://github.com/tporadowski/redis/releases)
+5. 下载并安装 IntelliJ IDEA：[IntelliJ IDEA](https://www.jetbrains.com/idea/download/)
+
+**Linux 系统**:
+1. 安装 JDK 17：
+ ```bash
+ sudo yum install java-17-openjdk-devel
+ ```
+2. 安装 Maven：
+ ```bash
+ sudo yum install maven
+ ```
+3. 安装 MySQL：
+ ```bash
+ sudo yum install mysql-server
+ ```
+4. 安装 Redis：
+ ```bash
+ sudo yum install redis
+ ```
+5. 安装 IntelliJ IDEA：
+ ```bash
+ sudo snap install intellij-idea-community --classic
+ ```
+
+### 1.3 项目导入
+
+**IntelliJ IDEA**:
+1. 打开 IntelliJ IDEA
+2. 点击「File」→「Open」
+3. 选择项目目录 `d:\trae_projects\makemd\makemd\serverjava`
+4. 点击「OK」，等待项目导入完成
+5. 点击「File」→「Project Structure」→「Project」，设置 JDK 为 17
+6. 点击「File」→「Project Structure」→「Modules」，确保 Maven 依赖正确导入
+
+**Eclipse**:
+1. 打开 Eclipse
+2. 点击「File」→「Import」→「Maven」→「Existing Maven Projects」
+3. 选择项目目录 `d:\trae_projects\makemd\makemd\serverjava`
+4. 点击「Finish」，等待项目导入完成
+5. 右键点击项目，选择「Properties」→「Java Build Path」→「Libraries」，确保 JDK 为 17
+
+## 2. 代码规范
+
+### 2.1 命名规范
+
+**类命名**：
+- 使用驼峰命名法，首字母大写
+- 类名应该清晰描述类的功能
+- 服务类使用 `Service` 后缀
+- 控制器类使用 `Controller` 后缀
+- 配置类使用 `Config` 后缀
+
+**方法命名**：
+- 使用驼峰命名法，首字母小写
+- 方法名应该清晰描述方法的功能
+- 动词开头，如 `createUser`, `updateProduct`
+
+**变量命名**：
+- 使用驼峰命名法，首字母小写
+- 变量名应该清晰描述变量的用途
+- 避免使用缩写，如 `usr` 应该改为 `user`
+
+**常量命名**：
+- 使用全大写，单词之间用下划线分隔
+- 常量名应该清晰描述常量的用途
+
+### 2.2 代码风格
+
+**缩进**：
+- 使用 4 个空格进行缩进
+- 避免使用制表符
+
+**换行**：
+- 每行代码长度不超过 120 个字符
+- 适当换行，提高代码可读性
+
+**注释**：
+- 为类、方法、变量添加适当的注释
+- 使用 Javadoc 注释格式
+- 注释应该清晰描述代码的功能和用途
+
+**示例**：
+```java
+/**
+ * 用户服务类，提供用户相关的业务逻辑
+ */
+@Service
+public class UserService {
+ /**
+ * 创建用户
+ * @param user 用户信息
+ * @return 创建的用户
+ */
+ public User createUser(User user) {
+ // 实现创建用户的逻辑
+ return userRepository.save(user);
+ }
+}
+```
+
+### 2.3 代码质量
+
+**代码检查**：
+- 使用 ESLint 检查代码质量
+- 使用 SonarQube 分析代码质量
+- 定期进行代码审查
+
+**测试覆盖**：
+- 为代码添加单元测试和集成测试
+- 确保测试覆盖率达到 80% 以上
+
+**性能优化**：
+- 优化代码逻辑，提高性能
+- 避免不必要的计算和操作
+- 使用缓存减少数据库查询
+
+## 3. 开发流程
+
+### 3.1 分支管理
+
+**分支策略**：
+- `main`：主分支，用于发布生产版本
+- `develop`：开发分支，用于集成开发
+- `feature`：特性分支，用于开发新功能
+- `hotfix`：热修复分支，用于修复生产环境的 bug
+
+**分支命名**：
+- 特性分支：`feature/feature-name`
+- 热修复分支：`hotfix/bug-description`
+
+**分支操作**：
+1. 从 `develop` 分支创建特性分支
+2. 在特性分支上开发新功能
+3. 提交代码并推送特性分支
+4. 创建 Pull Request 到 `develop` 分支
+5. 代码审查通过后，合并到 `develop` 分支
+6. 从 `main` 分支创建热修复分支
+7. 在热修复分支上修复 bug
+8. 提交代码并推送热修复分支
+9. 创建 Pull Request 到 `main` 和 `develop` 分支
+10. 代码审查通过后，合并到 `main` 和 `develop` 分支
+
+### 3.2 代码提交
+
+**提交规范**：
+- 提交消息应该清晰描述提交的内容
+- 使用以下格式：`[模块] 描述`
+- 例如：`[User] 修复用户注册功能`
+
+**提交频率**：
+- 每次提交应该只包含一个功能或 bug 修复
+- 避免一次提交多个不相关的更改
+- 定期提交代码，避免代码丢失
+
+### 3.3 代码审查
+
+**审查流程**：
+1. 开发人员创建 Pull Request
+2. 团队成员审查代码
+3. 审查通过后，合并代码
+4. 审查不通过时，开发人员修改代码并重新提交
+
+**审查重点**：
+- 代码质量和风格
+- 功能实现是否正确
+- 测试覆盖是否充分
+- 性能是否优化
+- 安全性是否考虑
+
+## 4. 开发工具
+
+### 4.1 IDE 插件
+
+**IntelliJ IDEA 插件**：
+- **Lombok**：简化 Java 代码
+- **Spring Boot Assistant**：Spring Boot 开发辅助
+- **MyBatis Plugin**：MyBatis 开发辅助
+- **SonarLint**：代码质量检查
+- **CheckStyle**：代码风格检查
+
+**Eclipse 插件**：
+- **Lombok**：简化 Java 代码
+- **Spring Tools Suite**：Spring Boot 开发辅助
+- **MyBatis Generator**：MyBatis 开发辅助
+- **SonarLint**：代码质量检查
+- **CheckStyle**：代码风格检查
+
+### 4.2 构建工具
+
+**Maven**：
+- 用于项目构建和依赖管理
+- 配置文件：`pom.xml`
+- 常用命令：
+ ```bash
+ # 编译项目
+ mvn compile
+
+ # 运行测试
+ mvn test
+
+ # 构建项目
+ mvn clean package
+
+ # 运行项目
+ mvn spring-boot:run
+ ```
+
+### 4.3 版本控制
+
+**Git**：
+- 用于版本控制
+- 配置文件：`.gitignore`
+- 常用命令：
+ ```bash
+ # 克隆仓库
+ git clone
+
+ # 查看状态
+ git status
+
+ # 添加文件
+ git add .
+
+ # 提交代码
+ git commit -m "[模块] 描述"
+
+ # 推送代码
+ git push
+
+ # 拉取代码
+ git pull
+ ```
+
+## 5. 开发最佳实践
+
+### 5.1 代码组织
+
+**目录结构**：
+- 遵循 Spring Boot 标准目录结构
+- 按功能模块组织代码
+- 保持代码结构清晰
+
+**示例目录结构**：
+```
+serverjava/
+ ├── src/
+ │ ├── main/
+ │ │ ├── java/com/crawlful/hub/
+ │ │ │ ├── api/controllers/ # 控制器
+ │ │ │ ├── service/ # 服务
+ │ │ │ ├── model/ # 模型
+ │ │ │ ├── config/ # 配置
+ │ │ │ ├── util/ # 工具类
+ │ │ │ ├── security/ # 安全
+ │ │ │ └── monitoring/ # 监控
+ │ │ └── resources/ # 资源文件
+ │ │ ├── i18n/ # 国际化资源
+ │ │ ├── db/migration/ # 数据库迁移脚本
+ │ │ ├── application.yml # 应用配置
+ │ │ └── logback.xml # 日志配置
+ │ └── test/ # 测试代码
+ ├── pom.xml # Maven 配置
+ └── docs/ # 文档
+```
+
+### 5.2 依赖管理
+
+**依赖版本**：
+- 使用 Spring Boot 3.2.0 版本
+- 统一管理依赖版本
+- 定期更新依赖，修复安全漏洞
+
+**依赖范围**：
+- `compile`：编译和运行时依赖
+- `test`：测试依赖
+- `provided`：编译时依赖，运行时由容器提供
+
+### 5.3 错误处理
+
+**全局异常处理**：
+- 实现 `GlobalExceptionHandler` 类
+- 统一处理系统异常
+- 返回统一的错误格式
+
+**自定义异常**：
+- 定义业务异常类
+- 提供错误码和错误消息
+- 便于异常处理和日志记录
+
+### 5.4 日志管理
+
+**日志级别**：
+- `DEBUG`：开发调试，详细执行路径
+- `INFO`：正常业务流程，如订单创建、状态流转
+- `WARN`：潜在问题，如重试、熔断触发
+- `ERROR`：错误异常，如 API 调用失败、数据库异常
+
+**日志格式**：
+- 包含时间戳、日志级别、类名、消息等
+- 使用 Logback 配置日志格式
+
+### 5.5 测试策略
+
+**单元测试**：
+- 测试单个方法或类
+- 使用 JUnit 5 和 Mockito
+- 测试边界条件和异常情况
+
+**集成测试**：
+- 测试组件之间的交互
+- 使用 Spring Test
+- 测试完整的业务流程
+
+**系统测试**：
+- 测试整个系统的功能
+- 使用 Postman 测试 API 接口
+- 测试用户场景
+
+## 6. 总结
+
+本开发指南详细介绍了 Crawlful Hub 项目的开发环境搭建、代码规范和开发流程。通过本指南，您可以了解如何快速上手项目开发，确保代码质量和开发效率。
diff --git a/docs/10_API_Changelog.md b/docs/10_API_Changelog.md
new file mode 100644
index 0000000..5cb0895
--- /dev/null
+++ b/docs/10_API_Changelog.md
@@ -0,0 +1,335 @@
+# API 变更日志
+
+## 1. 版本 1.0.0 (2024-01-01)
+
+### 1.1 新增功能
+
+- **认证模块**：
+ - 新增 `POST /api/v1/auth/login` 接口：用户登录
+ - 新增 `POST /api/v1/auth/register` 接口：用户注册
+ - 新增 `GET /api/v1/auth/me` 接口：获取当前用户信息
+
+- **商品模块**：
+ - 新增 `POST /api/v1/products` 接口：创建商品
+ - 新增 `GET /api/v1/products` 接口：获取商品列表
+ - 新增 `GET /api/v1/products/{id}` 接口：获取商品详情
+ - 新增 `PUT /api/v1/products/{id}` 接口：更新商品
+ - 新增 `DELETE /api/v1/products/{id}` 接口：删除商品
+
+- **订单模块**：
+ - 新增 `POST /api/v1/orders` 接口：创建订单
+ - 新增 `GET /api/v1/orders` 接口：获取订单列表
+ - 新增 `GET /api/v1/orders/{id}` 接口：获取订单详情
+ - 新增 `PUT /api/v1/orders/{id}` 接口：更新订单
+ - 新增 `DELETE /api/v1/orders/{id}` 接口：删除订单
+
+- **支付模块**：
+ - 新增 `POST /api/v1/payments` 接口：创建支付
+ - 新增 `GET /api/v1/payments` 接口：获取支付列表
+ - 新增 `GET /api/v1/payments/{id}` 接口：获取支付详情
+ - 新增 `PUT /api/v1/payments/{id}` 接口：更新支付
+
+- **物流模块**：
+ - 新增 `POST /api/v1/logistics` 接口：创建物流
+ - 新增 `GET /api/v1/logistics` 接口：获取物流列表
+ - 新增 `GET /api/v1/logistics/{id}` 接口：获取物流详情
+ - 新增 `PUT /api/v1/logistics/{id}` 接口：更新物流
+
+- **用户模块**：
+ - 新增 `POST /api/v1/users` 接口：创建用户
+ - 新增 `GET /api/v1/users` 接口：获取用户列表
+ - 新增 `GET /api/v1/users/{id}` 接口：获取用户详情
+ - 新增 `PUT /api/v1/users/{id}` 接口：更新用户
+ - 新增 `DELETE /api/v1/users/{id}` 接口：删除用户
+
+- **监控模块**：
+ - 新增 `GET /api/v1/monitoring/health` 接口：系统健康状态
+ - 新增 `GET /api/v1/monitoring/ping` 接口：系统响应测试
+ - 新增 `GET /api/v1/monitoring/metrics` 接口：系统性能指标
+
+- **告警模块**：
+ - 新增 `POST /api/v1/alerts` 接口：创建告警
+ - 新增 `GET /api/v1/alerts` 接口：获取告警列表
+ - 新增 `GET /api/v1/alerts/{id}` 接口：获取告警详情
+ - 新增 `PUT /api/v1/alerts/{id}` 接口：更新告警
+ - 新增 `PUT /api/v1/alerts/{id}/resolve` 接口：解决告警
+
+- **配置模块**：
+ - 新增 `POST /api/v1/configs` 接口：创建配置
+ - 新增 `GET /api/v1/configs` 接口：获取配置列表
+ - 新增 `GET /api/v1/configs/{id}` 接口：获取配置详情
+ - 新增 `PUT /api/v1/configs/{id}` 接口：更新配置
+ - 新增 `DELETE /api/v1/configs/{id}` 接口：删除配置
+
+- **审计模块**：
+ - 新增 `GET /api/v1/audit` 接口：获取审计日志列表
+ - 新增 `GET /api/v1/audit/{id}` 接口：获取审计日志详情
+
+- **数据模块**：
+ - 新增 `POST /api/v1/data/import` 接口：导入数据
+ - 新增 `GET /api/v1/data/export` 接口：导出数据
+
+- **报表模块**：
+ - 新增 `GET /api/v1/reports/sales` 接口：销售报表
+ - 新增 `GET /api/v1/reports/inventory` 接口：库存报表
+ - 新增 `GET /api/v1/reports/users` 接口：用户报表
+
+### 1.2 变更内容
+
+- **认证模块**：
+ - 使用 JWT 进行认证
+ - 支持角色授权
+
+- **商品模块**：
+ - 支持商品分页查询
+ - 支持商品搜索
+
+- **订单模块**：
+ - 支持订单状态流转
+ - 支持订单查询
+
+- **支付模块**：
+ - 支持多种支付方式
+ - 支持支付状态更新
+
+- **物流模块**：
+ - 支持物流状态更新
+ - 支持物流查询
+
+- **用户模块**：
+ - 支持用户角色管理
+ - 支持用户权限控制
+
+- **监控模块**：
+ - 支持系统健康检查
+ - 支持系统性能监控
+
+- **告警模块**：
+ - 支持告警级别管理
+ - 支持告警状态更新
+
+- **配置模块**：
+ - 支持配置类型管理
+ - 支持配置查询
+
+- **审计模块**：
+ - 支持审计日志查询
+ - 支持审计日志过滤
+
+- **数据模块**：
+ - 支持数据导入导出
+ - 支持数据格式转换
+
+- **报表模块**：
+ - 支持销售报表生成
+ - 支持库存报表生成
+ - 支持用户报表生成
+
+### 1.3 修复问题
+
+- **认证模块**：
+ - 修复登录失败时的错误处理
+ - 修复注册时的参数验证
+
+- **商品模块**：
+ - 修复商品创建时的参数验证
+ - 修复商品更新时的权限检查
+
+- **订单模块**：
+ - 修复订单创建时的状态设置
+ - 修复订单更新时的权限检查
+
+- **支付模块**：
+ - 修复支付创建时的参数验证
+ - 修复支付状态更新时的错误处理
+
+- **物流模块**：
+ - 修复物流创建时的参数验证
+ - 修复物流状态更新时的错误处理
+
+- **用户模块**：
+ - 修复用户创建时的参数验证
+ - 修复用户更新时的权限检查
+
+- **监控模块**：
+ - 修复健康检查端点的响应格式
+ - 修复性能指标的计算
+
+- **告警模块**：
+ - 修复告警创建时的参数验证
+ - 修复告警状态更新时的错误处理
+
+- **配置模块**：
+ - 修复配置创建时的参数验证
+ - 修复配置更新时的权限检查
+
+- **审计模块**：
+ - 修复审计日志查询时的参数验证
+ - 修复审计日志过滤时的错误处理
+
+- **数据模块**：
+ - 修复数据导入时的格式验证
+ - 修复数据导出时的格式转换
+
+- **报表模块**：
+ - 修复销售报表生成时的计算错误
+ - 修复库存报表生成时的计算错误
+ - 修复用户报表生成时的计算错误
+
+## 2. 版本 1.1.0 (2024-02-01)
+
+### 2.1 新增功能
+
+- **认证模块**：
+ - 新增 `POST /api/v1/auth/refresh` 接口：刷新 token
+ - 新增 `POST /api/v1/auth/logout` 接口：用户登出
+
+- **商品模块**：
+ - 新增 `GET /api/v1/products/categories` 接口：获取商品分类
+ - 新增 `POST /api/v1/products/batch` 接口：批量创建商品
+
+- **订单模块**：
+ - 新增 `POST /api/v1/orders/batch` 接口：批量创建订单
+ - 新增 `GET /api/v1/orders/status` 接口：获取订单状态统计
+
+- **支付模块**：
+ - 新增 `POST /api/v1/payments/batch` 接口：批量创建支付
+ - 新增 `GET /api/v1/payments/status` 接口：获取支付状态统计
+
+- **物流模块**：
+ - 新增 `POST /api/v1/logistics/batch` 接口：批量创建物流
+ - 新增 `GET /api/v1/logistics/status` 接口：获取物流状态统计
+
+- **用户模块**：
+ - 新增 `POST /api/v1/users/batch` 接口：批量创建用户
+ - 新增 `GET /api/v1/users/roles` 接口：获取用户角色
+
+- **监控模块**：
+ - 新增 `GET /api/v1/monitoring/health/detail` 接口：详细健康状态
+ - 新增 `GET /api/v1/monitoring/metrics/detail` 接口：详细性能指标
+
+- **告警模块**：
+ - 新增 `POST /api/v1/alerts/batch` 接口：批量创建告警
+ - 新增 `GET /api/v1/alerts/severity` 接口：获取告警严重程度统计
+
+- **配置模块**：
+ - 新增 `POST /api/v1/configs/batch` 接口：批量创建配置
+ - 新增 `GET /api/v1/configs/types` 接口：获取配置类型
+
+- **审计模块**：
+ - 新增 `GET /api/v1/audit/actions` 接口：获取审计操作类型
+ - 新增 `GET /api/v1/audit/resources` 接口：获取审计资源类型
+
+- **数据模块**：
+ - 新增 `POST /api/v1/data/import/batch` 接口：批量导入数据
+ - 新增 `GET /api/v1/data/export/batch` 接口：批量导出数据
+
+- **报表模块**：
+ - 新增 `GET /api/v1/reports/sales/detail` 接口：详细销售报表
+ - 新增 `GET /api/v1/reports/inventory/detail` 接口：详细库存报表
+ - 新增 `GET /api/v1/reports/users/detail` 接口：详细用户报表
+
+### 2.2 变更内容
+
+- **认证模块**：
+ - 优化 JWT 认证逻辑
+ - 支持 token 过期时间配置
+
+- **商品模块**：
+ - 优化商品搜索逻辑
+ - 支持商品分类管理
+
+- **订单模块**：
+ - 优化订单状态流转逻辑
+ - 支持订单批量操作
+
+- **支付模块**：
+ - 优化支付处理逻辑
+ - 支持支付批量操作
+
+- **物流模块**：
+ - 优化物流处理逻辑
+ - 支持物流批量操作
+
+- **用户模块**：
+ - 优化用户角色管理逻辑
+ - 支持用户批量操作
+
+- **监控模块**：
+ - 优化健康检查逻辑
+ - 支持详细性能指标
+
+- **告警模块**：
+ - 优化告警处理逻辑
+ - 支持告警批量操作
+
+- **配置模块**：
+ - 优化配置管理逻辑
+ - 支持配置批量操作
+
+- **审计模块**：
+ - 优化审计日志查询逻辑
+ - 支持审计操作类型和资源类型查询
+
+- **数据模块**：
+ - 优化数据导入导出逻辑
+ - 支持数据批量操作
+
+- **报表模块**：
+ - 优化报表生成逻辑
+ - 支持详细报表生成
+
+### 2.3 修复问题
+
+- **认证模块**：
+ - 修复 token 刷新时的错误处理
+ - 修复登出时的 token 失效处理
+
+- **商品模块**：
+ - 修复商品分类查询时的错误处理
+ - 修复商品批量创建时的参数验证
+
+- **订单模块**：
+ - 修复订单批量创建时的参数验证
+ - 修复订单状态统计时的计算错误
+
+- **支付模块**：
+ - 修复支付批量创建时的参数验证
+ - 修复支付状态统计时的计算错误
+
+- **物流模块**：
+ - 修复物流批量创建时的参数验证
+ - 修复物流状态统计时的计算错误
+
+- **用户模块**：
+ - 修复用户批量创建时的参数验证
+ - 修复用户角色查询时的错误处理
+
+- **监控模块**：
+ - 修复详细健康状态查询时的错误处理
+ - 修复详细性能指标查询时的计算错误
+
+- **告警模块**：
+ - 修复告警批量创建时的参数验证
+ - 修复告警严重程度统计时的计算错误
+
+- **配置模块**：
+ - 修复配置批量创建时的参数验证
+ - 修复配置类型查询时的错误处理
+
+- **审计模块**：
+ - 修复审计操作类型查询时的错误处理
+ - 修复审计资源类型查询时的错误处理
+
+- **数据模块**：
+ - 修复数据批量导入时的格式验证
+ - 修复数据批量导出时的格式转换
+
+- **报表模块**：
+ - 修复详细销售报表生成时的计算错误
+ - 修复详细库存报表生成时的计算错误
+ - 修复详细用户报表生成时的计算错误
+
+## 3. 总结
+
+本 API 变更日志详细记录了 Crawlful Hub 项目的 API 变更历史。通过本日志，您可以了解 API 的新增功能、变更内容和修复问题，便于 API 的使用和维护。
diff --git a/index.md b/index.md
new file mode 100644
index 0000000..82481d7
--- /dev/null
+++ b/index.md
@@ -0,0 +1,83 @@
+# Java 后端平移计划
+
+## 项目背景
+
+本项目需要将现有的 Node.js 后端平移为 Java 后端，保持与前端和客户端的兼容性，不修改现有代码。
+
+## 目录结构
+
+```
+serverjava/
+├── src/ # Java 源代码
+│ ├── api/ # API 层
+│ ├── service/ # 服务层
+│ ├── model/ # 数据模型
+│ ├── config/ # 配置文件
+│ └── util/ # 工具类
+├── pom.xml # Maven 配置文件
+└── README.md # 项目说明
+```
+
+## 平移原则
+
+1. **保持 API 兼容性**：所有 API 接口的路径、参数、返回格式必须与 Node.js 版本一致
+2. **保持业务逻辑一致**：所有业务逻辑必须与 Node.js 版本保持一致
+3. **不修改前端和客户端**：平移过程中不得修改任何前端或客户端代码
+4. **不修改 Node.js 代码**：平移过程中不得修改任何 Node.js 后端代码
+
+## 平移范围
+
+### 核心服务
+
+1. **认证服务**：用户登录、注册、权限管理
+2. **商品服务**：商品管理、库存管理
+3. **订单服务**：订单创建、状态管理、物流跟踪
+4. **支付服务**：支付处理、退款管理
+5. **数据服务**：数据统计、报表生成
+
+### API 接口
+
+所有现有的 Node.js API 接口都需要在 Java 后端中实现，包括：
+
+- `/api/auth/*`：认证相关接口
+- `/api/product/*`：商品相关接口
+- `/api/order/*`：订单相关接口
+- `/api/payment/*`：支付相关接口
+- `/api/report/*`：报表相关接口
+
+## 技术栈选择
+
+- **框架**：Spring Boot 3.x
+- **数据库**：MySQL 8.0
+- **缓存**：Redis
+- **认证**：JWT
+- **构建工具**：Maven
+- **Java 版本**：Java 17（Spring Boot 3.0+ 最低要求）
+
+## 实现步骤
+
+1. **搭建项目结构**：创建 Spring Boot 项目，设置基本目录结构
+2. **配置文件**：配置数据库连接、Redis 连接等
+3. **数据模型**：根据 Node.js 版本创建对应的 Java 数据模型
+4. **服务层**：实现业务逻辑，保持与 Node.js 版本一致
+5. **API 层**：实现 RESTful API 接口，保持与 Node.js 版本一致
+6. **测试**：确保所有 API 接口正常工作
+7. **部署**：部署 Java 后端服务
+
+## 注意事项
+
+1. **数据迁移**：需要确保数据结构与 Node.js 版本一致，避免数据丢失
+2. **性能优化**：针对 Java 特性进行性能优化，确保服务响应速度
+3. **安全性**：保持与 Node.js 版本相同的安全措施，确保系统安全
+4. **监控**：实现与 Node.js 版本相同的监控机制，确保系统稳定运行
+
+## 时间计划
+
+1. **项目搭建**：1 周
+2. **核心功能实现**：3 周
+3. **测试与优化**：1 周
+4. **部署与上线**：1 周
+
+## 联系方式
+
+如有任何问题，请联系项目负责人。
\ No newline at end of file
diff --git a/pom.xml b/pom.xml
new file mode 100644
index 0000000..5097471
--- /dev/null
+++ b/pom.xml
@@ -0,0 +1,101 @@
+
+
+ 4.0.0
+
+ com.crawlful
+ crawlful-hub-backend
+ 1.0.0
+
+
+ org.springframework.boot
+ spring-boot-starter-parent
+ 3.2.0
+
+
+
+
+ 17
+
+
+
+
+
+ org.springframework.boot
+ spring-boot-starter-web
+
+
+ org.springframework.boot
+ spring-boot-starter-data-jpa
+
+
+ org.springframework.boot
+ spring-boot-starter-security
+
+
+ org.springframework.boot
+ spring-boot-starter-cache
+
+
+
+
+ com.mysql
+ mysql-connector-j
+ runtime
+
+
+
+
+ org.springframework.boot
+ spring-boot-starter-data-redis
+
+
+
+
+ io.jsonwebtoken
+ jjwt
+ 0.9.1
+
+
+
+
+ org.apache.commons
+ commons-lang3
+
+
+ com.fasterxml.jackson.core
+ jackson-databind
+
+
+
+
+ org.springframework.boot
+ spring-boot-starter-test
+ test
+
+
+
+
+ org.flywaydb
+ flyway-core
+
+
+
+
+ org.springdoc
+ springdoc-openapi-starter-webmvc-ui
+ 2.0.2
+
+
+
+
+
+
+ org.springframework.boot
+ spring-boot-maven-plugin
+
+
+
+
+
\ No newline at end of file
diff --git a/src/main/java/com/crawlful/hub/Application.java b/src/main/java/com/crawlful/hub/Application.java
new file mode 100644
index 0000000..6faf911
--- /dev/null
+++ b/src/main/java/com/crawlful/hub/Application.java
@@ -0,0 +1,11 @@
+package com.crawlful.hub;
+
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+
+@SpringBootApplication
+public class Application {
+ public static void main(String[] args) {
+ SpringApplication.run(Application.class, args);
+ }
+}
diff --git a/src/main/java/com/crawlful/hub/api/controllers/AlertController.java b/src/main/java/com/crawlful/hub/api/controllers/AlertController.java
new file mode 100644
index 0000000..5313fe7
--- /dev/null
+++ b/src/main/java/com/crawlful/hub/api/controllers/AlertController.java
@@ -0,0 +1,199 @@
+package com.crawlful.hub.api.controllers;
+
+import com.crawlful.hub.model.Alert;
+import com.crawlful.hub.service.AlertService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+@RestController
+@RequestMapping("/v1/alerts")
+public class AlertController {
+ @Autowired
+ private AlertService alertService;
+
+ @PostMapping
+ public ResponseEntity createAlert(@RequestBody Map request) {
+ try {
+ String tenantId = (String) request.get("tenantId");
+ if (tenantId == null) {
+ return new ResponseEntity<>(Map.of("success", false, "error", "Missing tenantId"), HttpStatus.BAD_REQUEST);
+ }
+
+ Alert alert = alertService.createAlert(request);
+ Map response = new HashMap<>();
+ response.put("success", true);
+ response.put("alertId", alert.getId());
+ return new ResponseEntity<>(response, HttpStatus.CREATED);
+ } catch (Exception e) {
+ Map error = new HashMap<>();
+ error.put("success", false);
+ error.put("error", e.getMessage());
+ return new ResponseEntity<>(error, HttpStatus.INTERNAL_SERVER_ERROR);
+ }
+ }
+
+ @GetMapping
+ public ResponseEntity getAlerts(@RequestParam String tenantId, @RequestParam Map params) {
+ try {
+ if (tenantId == null) {
+ return new ResponseEntity<>(Map.of("success", false, "error", "Missing tenantId"), HttpStatus.BAD_REQUEST);
+ }
+
+ Map filters = new HashMap<>();
+ if (params.containsKey("status")) {
+ filters.put("status", params.get("status"));
+ }
+ if (params.containsKey("severity")) {
+ filters.put("severity", params.get("severity"));
+ }
+ if (params.containsKey("alertType")) {
+ filters.put("alertType", params.get("alertType"));
+ }
+ if (params.containsKey("startDate") && params.containsKey("endDate")) {
+ try {
+ SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
+ filters.put("startDate", sdf.parse(params.get("startDate")));
+ filters.put("endDate", sdf.parse(params.get("endDate")));
+ } catch (ParseException e) {
+ return new ResponseEntity<>(Map.of("success", false, "error", "Invalid date format. Use yyyy-MM-dd"), HttpStatus.BAD_REQUEST);
+ }
+ }
+
+ List alerts = alertService.getAlerts(tenantId, filters);
+ Map response = new HashMap<>();
+ response.put("success", true);
+ response.put("data", alerts);
+ return new ResponseEntity<>(response, HttpStatus.OK);
+ } catch (Exception e) {
+ Map error = new HashMap<>();
+ error.put("success", false);
+ error.put("error", e.getMessage());
+ return new ResponseEntity<>(error, HttpStatus.INTERNAL_SERVER_ERROR);
+ }
+ }
+
+ @GetMapping("/{id}")
+ public ResponseEntity getAlertById(@PathVariable Long id, @RequestParam String tenantId) {
+ try {
+ if (tenantId == null) {
+ return new ResponseEntity<>(Map.of("success", false, "error", "Missing tenantId"), HttpStatus.BAD_REQUEST);
+ }
+
+ Alert alert = alertService.getAlertById(tenantId, id);
+ if (alert == null) {
+ return new ResponseEntity<>(Map.of("success", false, "error", "Alert not found"), HttpStatus.NOT_FOUND);
+ }
+
+ Map response = new HashMap<>();
+ response.put("success", true);
+ response.put("data", alert);
+ return new ResponseEntity<>(response, HttpStatus.OK);
+ } catch (Exception e) {
+ Map error = new HashMap<>();
+ error.put("success", false);
+ error.put("error", e.getMessage());
+ return new ResponseEntity<>(error, HttpStatus.INTERNAL_SERVER_ERROR);
+ }
+ }
+
+ @PutMapping("/{id}/resolve")
+ public ResponseEntity resolveAlert(@PathVariable Long id, @RequestParam String tenantId) {
+ try {
+ if (tenantId == null) {
+ return new ResponseEntity<>(Map.of("success", false, "error", "Missing tenantId"), HttpStatus.BAD_REQUEST);
+ }
+
+ alertService.resolveAlert(tenantId, id);
+ Map response = new HashMap<>();
+ response.put("success", true);
+ response.put("message", "Alert resolved successfully");
+ return new ResponseEntity<>(response, HttpStatus.OK);
+ } catch (Exception e) {
+ Map error = new HashMap<>();
+ error.put("success", false);
+ error.put("error", e.getMessage());
+ return new ResponseEntity<>(error, HttpStatus.INTERNAL_SERVER_ERROR);
+ }
+ }
+
+ @PutMapping("/{id}/status")
+ public ResponseEntity updateAlertStatus(@PathVariable Long id, @RequestBody Map request) {
+ try {
+ String tenantId = (String) request.get("tenantId");
+ String status = (String) request.get("status");
+
+ if (tenantId == null || status == null) {
+ return new ResponseEntity<>(Map.of("success", false, "error", "Missing tenantId or status"), HttpStatus.BAD_REQUEST);
+ }
+
+ alertService.updateAlertStatus(tenantId, id, status);
+ Map response = new HashMap<>();
+ response.put("success", true);
+ response.put("message", "Alert status updated successfully");
+ return new ResponseEntity<>(response, HttpStatus.OK);
+ } catch (Exception e) {
+ Map error = new HashMap<>();
+ error.put("success", false);
+ error.put("error", e.getMessage());
+ return new ResponseEntity<>(error, HttpStatus.INTERNAL_SERVER_ERROR);
+ }
+ }
+
+ @GetMapping("/stats")
+ public ResponseEntity getAlertStats(@RequestParam String tenantId, @RequestParam String startDate, @RequestParam String endDate) {
+ try {
+ if (tenantId == null || startDate == null || endDate == null) {
+ return new ResponseEntity<>(Map.of("success", false, "error", "Missing required parameters"), HttpStatus.BAD_REQUEST);
+ }
+
+ SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
+ Date start = sdf.parse(startDate);
+ Date end = sdf.parse(endDate);
+
+ Map stats = alertService.getAlertStats(tenantId, start, end);
+ Map response = new HashMap<>();
+ response.put("success", true);
+ response.put("data", stats);
+ return new ResponseEntity<>(response, HttpStatus.OK);
+ } catch (ParseException e) {
+ Map error = new HashMap<>();
+ error.put("success", false);
+ error.put("error", "Invalid date format. Use yyyy-MM-dd");
+ return new ResponseEntity<>(error, HttpStatus.BAD_REQUEST);
+ } catch (Exception e) {
+ Map error = new HashMap<>();
+ error.put("success", false);
+ error.put("error", e.getMessage());
+ return new ResponseEntity<>(error, HttpStatus.INTERNAL_SERVER_ERROR);
+ }
+ }
+
+ @PostMapping("/check-thresholds")
+ public ResponseEntity checkThresholds(@RequestParam String tenantId) {
+ try {
+ if (tenantId == null) {
+ return new ResponseEntity<>(Map.of("success", false, "error", "Missing tenantId"), HttpStatus.BAD_REQUEST);
+ }
+
+ alertService.checkThresholds(tenantId);
+ Map response = new HashMap<>();
+ response.put("success", true);
+ response.put("message", "Thresholds checked successfully");
+ return new ResponseEntity<>(response, HttpStatus.OK);
+ } catch (Exception e) {
+ Map error = new HashMap<>();
+ error.put("success", false);
+ error.put("error", e.getMessage());
+ return new ResponseEntity<>(error, HttpStatus.INTERNAL_SERVER_ERROR);
+ }
+ }
+}
diff --git a/src/main/java/com/crawlful/hub/api/controllers/AuditController.java b/src/main/java/com/crawlful/hub/api/controllers/AuditController.java
new file mode 100644
index 0000000..442dde6
--- /dev/null
+++ b/src/main/java/com/crawlful/hub/api/controllers/AuditController.java
@@ -0,0 +1,155 @@
+package com.crawlful.hub.api.controllers;
+
+import com.crawlful.hub.model.Audit;
+import com.crawlful.hub.service.AuditService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+@RestController
+@RequestMapping("/v1/audits")
+public class AuditController {
+ @Autowired
+ private AuditService auditService;
+
+ @PostMapping
+ public ResponseEntity createAudit(@RequestBody Map request) {
+ try {
+ String tenantId = (String) request.get("tenantId");
+ if (tenantId == null) {
+ return new ResponseEntity<>(Map.of("success", false, "error", "Missing tenantId"), HttpStatus.BAD_REQUEST);
+ }
+
+ Audit audit = auditService.createAudit(request);
+ Map response = new HashMap<>();
+ response.put("success", true);
+ response.put("auditId", audit.getId());
+ return new ResponseEntity<>(response, HttpStatus.CREATED);
+ } catch (Exception e) {
+ Map error = new HashMap<>();
+ error.put("success", false);
+ error.put("error", e.getMessage());
+ return new ResponseEntity<>(error, HttpStatus.INTERNAL_SERVER_ERROR);
+ }
+ }
+
+ @GetMapping
+ public ResponseEntity getAudits(@RequestParam String tenantId, @RequestParam Map params) {
+ try {
+ if (tenantId == null) {
+ return new ResponseEntity<>(Map.of("success", false, "error", "Missing tenantId"), HttpStatus.BAD_REQUEST);
+ }
+
+ Map filters = new HashMap<>();
+ if (params.containsKey("shopId")) {
+ filters.put("shopId", params.get("shopId"));
+ }
+ if (params.containsKey("userId")) {
+ filters.put("userId", Long.parseLong(params.get("userId")));
+ }
+ if (params.containsKey("action")) {
+ filters.put("action", params.get("action"));
+ }
+ if (params.containsKey("resourceType")) {
+ filters.put("resourceType", params.get("resourceType"));
+ }
+ if (params.containsKey("startDate") && params.containsKey("endDate")) {
+ try {
+ SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
+ filters.put("startDate", sdf.parse(params.get("startDate")));
+ filters.put("endDate", sdf.parse(params.get("endDate")));
+ } catch (ParseException e) {
+ return new ResponseEntity<>(Map.of("success", false, "error", "Invalid date format. Use yyyy-MM-dd"), HttpStatus.BAD_REQUEST);
+ }
+ }
+
+ List audits = auditService.getAudits(tenantId, filters);
+ Map response = new HashMap<>();
+ response.put("success", true);
+ response.put("data", audits);
+ return new ResponseEntity<>(response, HttpStatus.OK);
+ } catch (Exception e) {
+ Map error = new HashMap<>();
+ error.put("success", false);
+ error.put("error", e.getMessage());
+ return new ResponseEntity<>(error, HttpStatus.INTERNAL_SERVER_ERROR);
+ }
+ }
+
+ @GetMapping("/stats")
+ public ResponseEntity getAuditStats(@RequestParam String tenantId, @RequestParam String startDate, @RequestParam String endDate) {
+ try {
+ if (tenantId == null || startDate == null || endDate == null) {
+ return new ResponseEntity<>(Map.of("success", false, "error", "Missing required parameters"), HttpStatus.BAD_REQUEST);
+ }
+
+ SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
+ Date start = sdf.parse(startDate);
+ Date end = sdf.parse(endDate);
+
+ Map stats = auditService.getAuditStats(tenantId, start, end);
+ Map response = new HashMap<>();
+ response.put("success", true);
+ response.put("data", stats);
+ return new ResponseEntity<>(response, HttpStatus.OK);
+ } catch (ParseException e) {
+ Map error = new HashMap<>();
+ error.put("success", false);
+ error.put("error", "Invalid date format. Use yyyy-MM-dd");
+ return new ResponseEntity<>(error, HttpStatus.BAD_REQUEST);
+ } catch (Exception e) {
+ Map error = new HashMap<>();
+ error.put("success", false);
+ error.put("error", e.getMessage());
+ return new ResponseEntity<>(error, HttpStatus.INTERNAL_SERVER_ERROR);
+ }
+ }
+
+ @GetMapping("/recent")
+ public ResponseEntity getRecentAudits(@RequestParam String tenantId, @RequestParam(defaultValue = "10") int limit) {
+ try {
+ if (tenantId == null) {
+ return new ResponseEntity<>(Map.of("success", false, "error", "Missing tenantId"), HttpStatus.BAD_REQUEST);
+ }
+
+ List recentAudits = auditService.getRecentAudits(tenantId, limit);
+ Map response = new HashMap<>();
+ response.put("success", true);
+ response.put("data", recentAudits);
+ return new ResponseEntity<>(response, HttpStatus.OK);
+ } catch (Exception e) {
+ Map error = new HashMap<>();
+ error.put("success", false);
+ error.put("error", e.getMessage());
+ return new ResponseEntity<>(error, HttpStatus.INTERNAL_SERVER_ERROR);
+ }
+ }
+
+ @GetMapping("/search")
+ public ResponseEntity searchAudits(@RequestParam String tenantId, @RequestParam String keyword) {
+ try {
+ if (tenantId == null || keyword == null) {
+ return new ResponseEntity<>(Map.of("success", false, "error", "Missing tenantId or keyword"), HttpStatus.BAD_REQUEST);
+ }
+
+ Map searchResults = auditService.searchAudits(tenantId, keyword);
+ Map response = new HashMap<>();
+ response.put("success", true);
+ response.put("data", searchResults);
+ return new ResponseEntity<>(response, HttpStatus.OK);
+ } catch (Exception e) {
+ Map error = new HashMap<>();
+ error.put("success", false);
+ error.put("error", e.getMessage());
+ return new ResponseEntity<>(error, HttpStatus.INTERNAL_SERVER_ERROR);
+ }
+ }
+}
diff --git a/src/main/java/com/crawlful/hub/api/controllers/AuthController.java b/src/main/java/com/crawlful/hub/api/controllers/AuthController.java
new file mode 100644
index 0000000..e092dfc
--- /dev/null
+++ b/src/main/java/com/crawlful/hub/api/controllers/AuthController.java
@@ -0,0 +1,57 @@
+package com.crawlful.hub.api.controllers;
+
+import com.crawlful.hub.model.User;
+import com.crawlful.hub.service.AuthService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.HashMap;
+import java.util.Map;
+
+@RestController
+@RequestMapping("/v1/auth")
+public class AuthController {
+ @Autowired
+ private AuthService authService;
+
+ @PostMapping("/register")
+ public ResponseEntity register(@RequestBody Map request) {
+ try {
+ String tenantId = request.get("tenantId");
+ String username = request.get("username");
+ String password = request.get("password");
+ String email = request.get("email");
+ String role = request.get("role");
+
+ User user = authService.register(tenantId, username, password, email, role);
+ Map response = new HashMap<>();
+ response.put("user", user);
+ response.put("message", "User registered successfully");
+ return new ResponseEntity<>(response, HttpStatus.CREATED);
+ } catch (Exception e) {
+ Map error = new HashMap<>();
+ error.put("error", e.getMessage());
+ return new ResponseEntity<>(error, HttpStatus.BAD_REQUEST);
+ }
+ }
+
+ @PostMapping("/login")
+ public ResponseEntity login(@RequestBody Map request) {
+ try {
+ String tenantId = request.get("tenantId");
+ String username = request.get("username");
+ String password = request.get("password");
+
+ String token = authService.login(tenantId, username, password);
+ Map response = new HashMap<>();
+ response.put("token", token);
+ return new ResponseEntity<>(response, HttpStatus.OK);
+ } catch (Exception e) {
+ Map error = new HashMap<>();
+ error.put("error", e.getMessage());
+ return new ResponseEntity<>(error, HttpStatus.UNAUTHORIZED);
+ }
+ }
+}
diff --git a/src/main/java/com/crawlful/hub/api/controllers/ConfigController.java b/src/main/java/com/crawlful/hub/api/controllers/ConfigController.java
new file mode 100644
index 0000000..2feced2
--- /dev/null
+++ b/src/main/java/com/crawlful/hub/api/controllers/ConfigController.java
@@ -0,0 +1,165 @@
+package com.crawlful.hub.api.controllers;
+
+import com.crawlful.hub.model.Config;
+import com.crawlful.hub.service.ConfigService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+@RestController
+@RequestMapping("/v1/configs")
+public class ConfigController {
+ @Autowired
+ private ConfigService configService;
+
+ @PostMapping
+ public ResponseEntity createConfig(@RequestBody Map request) {
+ try {
+ String tenantId = (String) request.get("tenantId");
+ if (tenantId == null) {
+ return new ResponseEntity<>(Map.of("success", false, "error", "Missing tenantId"), HttpStatus.BAD_REQUEST);
+ }
+
+ Config config = configService.createConfig(request);
+ Map response = new HashMap<>();
+ response.put("success", true);
+ response.put("configId", config.getId());
+ return new ResponseEntity<>(response, HttpStatus.CREATED);
+ } catch (Exception e) {
+ Map error = new HashMap<>();
+ error.put("success", false);
+ error.put("error", e.getMessage());
+ return new ResponseEntity<>(error, HttpStatus.INTERNAL_SERVER_ERROR);
+ }
+ }
+
+ @GetMapping
+ public ResponseEntity getConfigs(@RequestParam String tenantId, @RequestParam(required = false) String shopId) {
+ try {
+ if (tenantId == null) {
+ return new ResponseEntity<>(Map.of("success", false, "error", "Missing tenantId"), HttpStatus.BAD_REQUEST);
+ }
+
+ List configs = configService.getConfigs(tenantId, shopId);
+ Map response = new HashMap<>();
+ response.put("success", true);
+ response.put("data", configs);
+ return new ResponseEntity<>(response, HttpStatus.OK);
+ } catch (Exception e) {
+ Map error = new HashMap<>();
+ error.put("success", false);
+ error.put("error", e.getMessage());
+ return new ResponseEntity<>(error, HttpStatus.INTERNAL_SERVER_ERROR);
+ }
+ }
+
+ @GetMapping("/value")
+ public ResponseEntity getConfigValue(@RequestParam String tenantId, @RequestParam String configKey, @RequestParam(required = false) String shopId) {
+ try {
+ if (tenantId == null || configKey == null) {
+ return new ResponseEntity<>(Map.of("success", false, "error", "Missing tenantId or configKey"), HttpStatus.BAD_REQUEST);
+ }
+
+ String configValue = configService.getConfigValue(tenantId, configKey, shopId);
+ Map response = new HashMap<>();
+ response.put("success", true);
+ response.put("configKey", configKey);
+ response.put("configValue", configValue);
+ return new ResponseEntity<>(response, HttpStatus.OK);
+ } catch (Exception e) {
+ Map error = new HashMap<>();
+ error.put("success", false);
+ error.put("error", e.getMessage());
+ return new ResponseEntity<>(error, HttpStatus.INTERNAL_SERVER_ERROR);
+ }
+ }
+
+ @GetMapping("/values")
+ public ResponseEntity getConfigValues(@RequestParam String tenantId, @RequestParam List configKeys, @RequestParam(required = false) String shopId) {
+ try {
+ if (tenantId == null || configKeys == null || configKeys.isEmpty()) {
+ return new ResponseEntity<>(Map.of("success", false, "error", "Missing tenantId or configKeys"), HttpStatus.BAD_REQUEST);
+ }
+
+ Map configValues = configService.getConfigValues(tenantId, configKeys, shopId);
+ Map response = new HashMap<>();
+ response.put("success", true);
+ response.put("data", configValues);
+ return new ResponseEntity<>(response, HttpStatus.OK);
+ } catch (Exception e) {
+ Map error = new HashMap<>();
+ error.put("success", false);
+ error.put("error", e.getMessage());
+ return new ResponseEntity<>(error, HttpStatus.INTERNAL_SERVER_ERROR);
+ }
+ }
+
+ @PutMapping("/{id}")
+ public ResponseEntity updateConfig(@PathVariable Long id, @RequestBody Map request) {
+ try {
+ String tenantId = (String) request.get("tenantId");
+ if (tenantId == null) {
+ return new ResponseEntity<>(Map.of("success", false, "error", "Missing tenantId"), HttpStatus.BAD_REQUEST);
+ }
+
+ configService.updateConfig(tenantId, id, request);
+ Map response = new HashMap<>();
+ response.put("success", true);
+ response.put("message", "Config updated successfully");
+ return new ResponseEntity<>(response, HttpStatus.OK);
+ } catch (Exception e) {
+ Map error = new HashMap<>();
+ error.put("success", false);
+ error.put("error", e.getMessage());
+ return new ResponseEntity<>(error, HttpStatus.INTERNAL_SERVER_ERROR);
+ }
+ }
+
+ @DeleteMapping("/{id}")
+ public ResponseEntity deleteConfig(@PathVariable Long id, @RequestParam String tenantId) {
+ try {
+ if (tenantId == null) {
+ return new ResponseEntity<>(Map.of("success", false, "error", "Missing tenantId"), HttpStatus.BAD_REQUEST);
+ }
+
+ configService.deleteConfig(tenantId, id);
+ Map response = new HashMap<>();
+ response.put("success", true);
+ response.put("message", "Config deleted successfully");
+ return new ResponseEntity<>(response, HttpStatus.OK);
+ } catch (Exception e) {
+ Map error = new HashMap<>();
+ error.put("success", false);
+ error.put("error", e.getMessage());
+ return new ResponseEntity<>(error, HttpStatus.INTERNAL_SERVER_ERROR);
+ }
+ }
+
+ @PostMapping("/batch")
+ public ResponseEntity batchUpdateConfigs(@RequestBody Map request) {
+ try {
+ String tenantId = (String) request.get("tenantId");
+ List> configs = (List>) request.get("configs");
+
+ if (tenantId == null || configs == null || configs.isEmpty()) {
+ return new ResponseEntity<>(Map.of("success", false, "error", "Missing tenantId or configs"), HttpStatus.BAD_REQUEST);
+ }
+
+ configService.batchUpdateConfigs(tenantId, configs);
+ Map response = new HashMap<>();
+ response.put("success", true);
+ response.put("message", "Configs updated successfully");
+ return new ResponseEntity<>(response, HttpStatus.OK);
+ } catch (Exception e) {
+ Map error = new HashMap<>();
+ error.put("success", false);
+ error.put("error", e.getMessage());
+ return new ResponseEntity<>(error, HttpStatus.INTERNAL_SERVER_ERROR);
+ }
+ }
+}
diff --git a/src/main/java/com/crawlful/hub/api/controllers/DataController.java b/src/main/java/com/crawlful/hub/api/controllers/DataController.java
new file mode 100644
index 0000000..efb03a0
--- /dev/null
+++ b/src/main/java/com/crawlful/hub/api/controllers/DataController.java
@@ -0,0 +1,133 @@
+package com.crawlful.hub.api.controllers;
+
+import com.crawlful.hub.service.DataService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.Map;
+
+@RestController
+@RequestMapping("/v1/data")
+public class DataController {
+ @Autowired
+ private DataService dataService;
+
+ @GetMapping("/dashboard")
+ public ResponseEntity getDashboardData(@RequestParam String tenantId) {
+ try {
+ if (tenantId == null) {
+ return new ResponseEntity<>(Map.of("success", false, "error", "Missing tenantId"), HttpStatus.BAD_REQUEST);
+ }
+
+ Map dashboardData = dataService.getDashboardData(tenantId);
+ Map response = new HashMap<>();
+ response.put("success", true);
+ response.put("data", dashboardData);
+ return new ResponseEntity<>(response, HttpStatus.OK);
+ } catch (Exception e) {
+ Map error = new HashMap<>();
+ error.put("success", false);
+ error.put("error", e.getMessage());
+ return new ResponseEntity<>(error, HttpStatus.INTERNAL_SERVER_ERROR);
+ }
+ }
+
+ @GetMapping("/sales-report")
+ public ResponseEntity getSalesReport(@RequestParam String tenantId, @RequestParam String startDate, @RequestParam String endDate) {
+ try {
+ if (tenantId == null || startDate == null || endDate == null) {
+ return new ResponseEntity<>(Map.of("success", false, "error", "Missing required parameters"), HttpStatus.BAD_REQUEST);
+ }
+
+ SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
+ Date start = sdf.parse(startDate);
+ Date end = sdf.parse(endDate);
+
+ Map salesReport = dataService.getSalesReport(tenantId, start, end);
+ Map response = new HashMap<>();
+ response.put("success", true);
+ response.put("data", salesReport);
+ return new ResponseEntity<>(response, HttpStatus.OK);
+ } catch (ParseException e) {
+ Map error = new HashMap<>();
+ error.put("success", false);
+ error.put("error", "Invalid date format. Use yyyy-MM-dd");
+ return new ResponseEntity<>(error, HttpStatus.BAD_REQUEST);
+ } catch (Exception e) {
+ Map error = new HashMap<>();
+ error.put("success", false);
+ error.put("error", e.getMessage());
+ return new ResponseEntity<>(error, HttpStatus.INTERNAL_SERVER_ERROR);
+ }
+ }
+
+ @GetMapping("/inventory-report")
+ public ResponseEntity getInventoryReport(@RequestParam String tenantId) {
+ try {
+ if (tenantId == null) {
+ return new ResponseEntity<>(Map.of("success", false, "error", "Missing tenantId"), HttpStatus.BAD_REQUEST);
+ }
+
+ Map inventoryReport = dataService.getInventoryReport(tenantId);
+ Map response = new HashMap<>();
+ response.put("success", true);
+ response.put("data", inventoryReport);
+ return new ResponseEntity<>(response, HttpStatus.OK);
+ } catch (Exception e) {
+ Map error = new HashMap<>();
+ error.put("success", false);
+ error.put("error", e.getMessage());
+ return new ResponseEntity<>(error, HttpStatus.INTERNAL_SERVER_ERROR);
+ }
+ }
+
+ @PostMapping("/export")
+ public ResponseEntity exportData(@RequestBody Map request) {
+ try {
+ String tenantId = (String) request.get("tenantId");
+ String dataType = (String) request.get("dataType");
+ String format = (String) request.get("format");
+
+ if (tenantId == null || dataType == null || format == null) {
+ return new ResponseEntity<>(Map.of("success", false, "error", "Missing required parameters"), HttpStatus.BAD_REQUEST);
+ }
+
+ Map exportResult = dataService.exportData(tenantId, dataType, format);
+ Map response = new HashMap<>();
+ response.put("success", exportResult.get("success"));
+ response.put("data", exportResult);
+ return new ResponseEntity<>(response, HttpStatus.OK);
+ } catch (Exception e) {
+ Map error = new HashMap<>();
+ error.put("success", false);
+ error.put("error", e.getMessage());
+ return new ResponseEntity<>(error, HttpStatus.INTERNAL_SERVER_ERROR);
+ }
+ }
+
+ @GetMapping("/platform-performance")
+ public ResponseEntity getPlatformPerformance(@RequestParam String tenantId) {
+ try {
+ if (tenantId == null) {
+ return new ResponseEntity<>(Map.of("success", false, "error", "Missing tenantId"), HttpStatus.BAD_REQUEST);
+ }
+
+ Map platformPerformance = dataService.getPlatformPerformance(tenantId);
+ Map response = new HashMap<>();
+ response.put("success", true);
+ response.put("data", platformPerformance);
+ return new ResponseEntity<>(response, HttpStatus.OK);
+ } catch (Exception e) {
+ Map error = new HashMap<>();
+ error.put("success", false);
+ error.put("error", e.getMessage());
+ return new ResponseEntity<>(error, HttpStatus.INTERNAL_SERVER_ERROR);
+ }
+ }
+}
diff --git a/src/main/java/com/crawlful/hub/api/controllers/LogisticsController.java b/src/main/java/com/crawlful/hub/api/controllers/LogisticsController.java
new file mode 100644
index 0000000..c283be7
--- /dev/null
+++ b/src/main/java/com/crawlful/hub/api/controllers/LogisticsController.java
@@ -0,0 +1,159 @@
+package com.crawlful.hub.api.controllers;
+
+import com.crawlful.hub.model.Logistics;
+import com.crawlful.hub.service.LogisticsService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+@RestController
+@RequestMapping("/v1/logistics")
+public class LogisticsController {
+ @Autowired
+ private LogisticsService logisticsService;
+
+ @PostMapping
+ public ResponseEntity createLogistics(@RequestBody Map request) {
+ try {
+ String tenantId = (String) request.get("tenantId");
+ if (tenantId == null) {
+ return new ResponseEntity<>(Map.of("success", false, "error", "Missing tenantId"), HttpStatus.BAD_REQUEST);
+ }
+
+ Logistics logistics = logisticsService.createLogistics(request);
+ Map response = new HashMap<>();
+ response.put("success", true);
+ response.put("logisticsId", logistics.getId());
+ return new ResponseEntity<>(response, HttpStatus.CREATED);
+ } catch (Exception e) {
+ Map error = new HashMap<>();
+ error.put("success", false);
+ error.put("error", e.getMessage());
+ return new ResponseEntity<>(error, HttpStatus.INTERNAL_SERVER_ERROR);
+ }
+ }
+
+ @GetMapping
+ public ResponseEntity getLogistics(@RequestParam Map params) {
+ try {
+ String tenantId = params.get("tenantId");
+ if (tenantId == null) {
+ return new ResponseEntity<>(Map.of("success", false, "error", "Missing tenantId"), HttpStatus.BAD_REQUEST);
+ }
+
+ Map filters = new HashMap<>();
+ if (params.containsKey("status")) {
+ filters.put("status", params.get("status"));
+ }
+ if (params.containsKey("orderId")) {
+ filters.put("orderId", Long.parseLong(params.get("orderId")));
+ }
+
+ List logisticsList = logisticsService.getLogistics(tenantId, filters);
+ Map response = new HashMap<>();
+ response.put("success", true);
+ response.put("data", logisticsList);
+ return new ResponseEntity<>(response, HttpStatus.OK);
+ } catch (Exception e) {
+ Map error = new HashMap<>();
+ error.put("success", false);
+ error.put("error", e.getMessage());
+ return new ResponseEntity<>(error, HttpStatus.INTERNAL_SERVER_ERROR);
+ }
+ }
+
+ @GetMapping("/{id}")
+ public ResponseEntity getLogisticsById(@PathVariable Long id, @RequestParam String tenantId) {
+ try {
+ if (tenantId == null) {
+ return new ResponseEntity<>(Map.of("success", false, "error", "Missing tenantId"), HttpStatus.BAD_REQUEST);
+ }
+
+ Logistics logistics = logisticsService.getLogisticsById(tenantId, id);
+ if (logistics == null) {
+ return new ResponseEntity<>(Map.of("success", false, "error", "Logistics not found"), HttpStatus.NOT_FOUND);
+ }
+
+ Map response = new HashMap<>();
+ response.put("success", true);
+ response.put("data", logistics);
+ return new ResponseEntity<>(response, HttpStatus.OK);
+ } catch (Exception e) {
+ Map error = new HashMap<>();
+ error.put("success", false);
+ error.put("error", e.getMessage());
+ return new ResponseEntity<>(error, HttpStatus.INTERNAL_SERVER_ERROR);
+ }
+ }
+
+ @PutMapping("/{id}")
+ public ResponseEntity updateLogistics(@PathVariable Long id, @RequestBody Map request) {
+ try {
+ String tenantId = (String) request.get("tenantId");
+ if (tenantId == null) {
+ return new ResponseEntity<>(Map.of("success", false, "error", "Missing tenantId"), HttpStatus.BAD_REQUEST);
+ }
+
+ logisticsService.updateLogistics(tenantId, id, request);
+ Map response = new HashMap<>();
+ response.put("success", true);
+ response.put("message", "Logistics updated successfully");
+ return new ResponseEntity<>(response, HttpStatus.OK);
+ } catch (Exception e) {
+ Map error = new HashMap<>();
+ error.put("success", false);
+ error.put("error", e.getMessage());
+ return new ResponseEntity<>(error, HttpStatus.INTERNAL_SERVER_ERROR);
+ }
+ }
+
+ @GetMapping("/track/{trackingNumber}")
+ public ResponseEntity trackLogistics(@PathVariable String trackingNumber, @RequestParam String tenantId) {
+ try {
+ if (tenantId == null) {
+ return new ResponseEntity<>(Map.of("success", false, "error", "Missing tenantId"), HttpStatus.BAD_REQUEST);
+ }
+
+ Map result = logisticsService.trackLogistics(tenantId, trackingNumber);
+ Map response = new HashMap<>();
+ response.put("success", result.get("success"));
+ if (result.get("success").equals(true)) {
+ response.put("data", result);
+ } else {
+ response.put("error", result.get("error"));
+ }
+ return new ResponseEntity<>(response, HttpStatus.OK);
+ } catch (Exception e) {
+ Map error = new HashMap<>();
+ error.put("success", false);
+ error.put("error", e.getMessage());
+ return new ResponseEntity<>(error, HttpStatus.INTERNAL_SERVER_ERROR);
+ }
+ }
+
+ @PostMapping("/calculate-cost")
+ public ResponseEntity calculateShippingCost(@RequestBody Map request) {
+ try {
+ String tenantId = (String) request.get("tenantId");
+ if (tenantId == null) {
+ return new ResponseEntity<>(Map.of("success", false, "error", "Missing tenantId"), HttpStatus.BAD_REQUEST);
+ }
+
+ Map result = logisticsService.calculateShippingCost(tenantId, request);
+ Map response = new HashMap<>();
+ response.put("success", result.get("success"));
+ response.put("data", result);
+ return new ResponseEntity<>(response, HttpStatus.OK);
+ } catch (Exception e) {
+ Map error = new HashMap<>();
+ error.put("success", false);
+ error.put("error", e.getMessage());
+ return new ResponseEntity<>(error, HttpStatus.INTERNAL_SERVER_ERROR);
+ }
+ }
+}
diff --git a/src/main/java/com/crawlful/hub/api/controllers/MonitoringController.java b/src/main/java/com/crawlful/hub/api/controllers/MonitoringController.java
new file mode 100644
index 0000000..352114c
--- /dev/null
+++ b/src/main/java/com/crawlful/hub/api/controllers/MonitoringController.java
@@ -0,0 +1,129 @@
+package com.crawlful.hub.api.controllers;
+
+import com.crawlful.hub.service.MonitoringService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.HashMap;
+import java.util.Map;
+
+@RestController
+@RequestMapping("/v1/monitoring")
+public class MonitoringController {
+ @Autowired
+ private MonitoringService monitoringService;
+
+ @GetMapping("/health")
+ public ResponseEntity getSystemHealth() {
+ try {
+ Map health = monitoringService.getSystemHealth();
+ Map response = new HashMap<>();
+ response.put("success", true);
+ response.put("data", health);
+ return new ResponseEntity<>(response, HttpStatus.OK);
+ } catch (Exception e) {
+ Map error = new HashMap<>();
+ error.put("success", false);
+ error.put("error", e.getMessage());
+ return new ResponseEntity<>(error, HttpStatus.INTERNAL_SERVER_ERROR);
+ }
+ }
+
+ @GetMapping("/metrics")
+ public ResponseEntity getPerformanceMetrics() {
+ try {
+ Map metrics = monitoringService.getPerformanceMetrics();
+ Map response = new HashMap<>();
+ response.put("success", true);
+ response.put("data", metrics);
+ return new ResponseEntity<>(response, HttpStatus.OK);
+ } catch (Exception e) {
+ Map error = new HashMap<>();
+ error.put("success", false);
+ error.put("error", e.getMessage());
+ return new ResponseEntity<>(error, HttpStatus.INTERNAL_SERVER_ERROR);
+ }
+ }
+
+ @GetMapping("/services")
+ public ResponseEntity getServiceStatus() {
+ try {
+ Map status = monitoringService.getServiceStatus();
+ Map response = new HashMap<>();
+ response.put("success", true);
+ response.put("data", status);
+ return new ResponseEntity<>(response, HttpStatus.OK);
+ } catch (Exception e) {
+ Map error = new HashMap<>();
+ error.put("success", false);
+ error.put("error", e.getMessage());
+ return new ResponseEntity<>(error, HttpStatus.INTERNAL_SERVER_ERROR);
+ }
+ }
+
+ @GetMapping("/database")
+ public ResponseEntity getDatabaseStatus() {
+ try {
+ Map dbStatus = monitoringService.getDatabaseStatus();
+ Map response = new HashMap<>();
+ response.put("success", true);
+ response.put("data", dbStatus);
+ return new ResponseEntity<>(response, HttpStatus.OK);
+ } catch (Exception e) {
+ Map error = new HashMap<>();
+ error.put("success", false);
+ error.put("error", e.getMessage());
+ return new ResponseEntity<>(error, HttpStatus.INTERNAL_SERVER_ERROR);
+ }
+ }
+
+ @GetMapping("/cache")
+ public ResponseEntity getCacheStatus() {
+ try {
+ Map cacheStatus = monitoringService.getCacheStatus();
+ Map response = new HashMap<>();
+ response.put("success", true);
+ response.put("data", cacheStatus);
+ return new ResponseEntity<>(response, HttpStatus.OK);
+ } catch (Exception e) {
+ Map error = new HashMap<>();
+ error.put("success", false);
+ error.put("error", e.getMessage());
+ return new ResponseEntity<>(error, HttpStatus.INTERNAL_SERVER_ERROR);
+ }
+ }
+
+ @GetMapping("/stats")
+ public ResponseEntity getSystemStats() {
+ try {
+ Map stats = monitoringService.getSystemStats();
+ Map response = new HashMap<>();
+ response.put("success", true);
+ response.put("data", stats);
+ return new ResponseEntity<>(response, HttpStatus.OK);
+ } catch (Exception e) {
+ Map error = new HashMap<>();
+ error.put("success", false);
+ error.put("error", e.getMessage());
+ return new ResponseEntity<>(error, HttpStatus.INTERNAL_SERVER_ERROR);
+ }
+ }
+
+ @GetMapping("/ping")
+ public ResponseEntity ping() {
+ try {
+ Map response = new HashMap<>();
+ response.put("success", true);
+ response.put("message", "Pong");
+ response.put("timestamp", System.currentTimeMillis());
+ return new ResponseEntity<>(response, HttpStatus.OK);
+ } catch (Exception e) {
+ Map error = new HashMap<>();
+ error.put("success", false);
+ error.put("error", e.getMessage());
+ return new ResponseEntity<>(error, HttpStatus.INTERNAL_SERVER_ERROR);
+ }
+ }
+}
diff --git a/src/main/java/com/crawlful/hub/api/controllers/OrderController.java b/src/main/java/com/crawlful/hub/api/controllers/OrderController.java
new file mode 100644
index 0000000..ec9607f
--- /dev/null
+++ b/src/main/java/com/crawlful/hub/api/controllers/OrderController.java
@@ -0,0 +1,521 @@
+package com.crawlful.hub.api.controllers;
+
+import com.crawlful.hub.model.Order;
+import com.crawlful.hub.service.OrderService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+@RestController
+@RequestMapping("/v1/orders")
+public class OrderController {
+ @Autowired
+ private OrderService orderService;
+
+ @PostMapping
+ public ResponseEntity createOrder(@RequestBody Map request) {
+ try {
+ String tenantId = (String) request.get("tenantId");
+ if (tenantId == null) {
+ return new ResponseEntity<>(Map.of("success", false, "error", "Missing tenantId"), HttpStatus.BAD_REQUEST);
+ }
+
+ Order order = orderService.createOrder(request);
+ Map response = new HashMap<>();
+ response.put("success", true);
+ response.put("orderId", order.getId());
+ return new ResponseEntity<>(response, HttpStatus.CREATED);
+ } catch (Exception e) {
+ Map error = new HashMap<>();
+ error.put("success", false);
+ error.put("error", e.getMessage());
+ return new ResponseEntity<>(error, HttpStatus.INTERNAL_SERVER_ERROR);
+ }
+ }
+
+ @GetMapping
+ public ResponseEntity getOrders(@RequestParam Map params) {
+ try {
+ String tenantId = params.get("tenantId");
+ if (tenantId == null) {
+ return new ResponseEntity<>(Map.of("success", false, "error", "Missing tenantId"), HttpStatus.BAD_REQUEST);
+ }
+
+ Map queryParams = new HashMap<>();
+ if (params.containsKey("page")) {
+ queryParams.put("page", Integer.parseInt(params.get("page")));
+ }
+ if (params.containsKey("pageSize")) {
+ queryParams.put("pageSize", Integer.parseInt(params.get("pageSize")));
+ }
+ if (params.containsKey("status")) {
+ queryParams.put("status", params.get("status"));
+ }
+ if (params.containsKey("platform")) {
+ queryParams.put("platform", params.get("platform"));
+ }
+
+ List orders = orderService.getOrders(tenantId, queryParams);
+ Map response = new HashMap<>();
+ response.put("success", true);
+ response.put("data", orders);
+ return new ResponseEntity<>(response, HttpStatus.OK);
+ } catch (Exception e) {
+ Map error = new HashMap<>();
+ error.put("success", false);
+ error.put("error", e.getMessage());
+ return new ResponseEntity<>(error, HttpStatus.INTERNAL_SERVER_ERROR);
+ }
+ }
+
+ @GetMapping("/{id}")
+ public ResponseEntity getOrderById(@PathVariable String id, @RequestParam String tenantId) {
+ try {
+ if (tenantId == null) {
+ return new ResponseEntity<>(Map.of("success", false, "error", "Missing tenantId"), HttpStatus.BAD_REQUEST);
+ }
+
+ Order order = orderService.getOrderById(tenantId, id);
+ if (order == null) {
+ return new ResponseEntity<>(Map.of("success", false, "error", "Order not found"), HttpStatus.NOT_FOUND);
+ }
+
+ Map response = new HashMap<>();
+ response.put("success", true);
+ response.put("data", order);
+ return new ResponseEntity<>(response, HttpStatus.OK);
+ } catch (Exception e) {
+ Map error = new HashMap<>();
+ error.put("success", false);
+ error.put("error", e.getMessage());
+ return new ResponseEntity<>(error, HttpStatus.INTERNAL_SERVER_ERROR);
+ }
+ }
+
+ @PutMapping("/{id}")
+ public ResponseEntity updateOrder(@PathVariable String id, @RequestBody Map request) {
+ try {
+ String tenantId = (String) request.get("tenantId");
+ if (tenantId == null) {
+ return new ResponseEntity<>(Map.of("success", false, "error", "Missing tenantId"), HttpStatus.BAD_REQUEST);
+ }
+
+ orderService.updateOrder(id, tenantId, request);
+ Map response = new HashMap<>();
+ response.put("success", true);
+ response.put("message", "Order updated successfully");
+ return new ResponseEntity<>(response, HttpStatus.OK);
+ } catch (Exception e) {
+ Map error = new HashMap<>();
+ error.put("success", false);
+ error.put("error", e.getMessage());
+ return new ResponseEntity<>(error, HttpStatus.INTERNAL_SERVER_ERROR);
+ }
+ }
+
+ @DeleteMapping("/{id}")
+ public ResponseEntity deleteOrder(@PathVariable String id, @RequestParam String tenantId) {
+ try {
+ if (tenantId == null) {
+ return new ResponseEntity<>(Map.of("success", false, "error", "Missing tenantId"), HttpStatus.BAD_REQUEST);
+ }
+
+ orderService.deleteOrder(id, tenantId);
+ Map response = new HashMap<>();
+ response.put("success", true);
+ response.put("message", "Order deleted successfully");
+ return new ResponseEntity<>(response, HttpStatus.OK);
+ } catch (Exception e) {
+ Map error = new HashMap<>();
+ error.put("success", false);
+ error.put("error", e.getMessage());
+ return new ResponseEntity<>(error, HttpStatus.INTERNAL_SERVER_ERROR);
+ }
+ }
+
+ @PostMapping("/sync")
+ public ResponseEntity triggerManualSync(@RequestBody Map request) {
+ try {
+ String platform = (String) request.get("platform");
+ String shopId = (String) request.get("shopId");
+
+ if (platform == null || shopId == null) {
+ return new ResponseEntity<>(Map.of("success", false, "error", "Missing platform or shopId"), HttpStatus.BAD_REQUEST);
+ }
+
+ Map response = new HashMap<>();
+ response.put("success", true);
+ response.put("message", "Manual sync triggered for " + platform);
+ return new ResponseEntity<>(response, HttpStatus.OK);
+ } catch (Exception e) {
+ Map error = new HashMap<>();
+ error.put("success", false);
+ error.put("error", e.getMessage());
+ return new ResponseEntity<>(error, HttpStatus.INTERNAL_SERVER_ERROR);
+ }
+ }
+
+ @GetMapping("/stats")
+ public ResponseEntity getStats(@RequestParam String tenantId) {
+ try {
+ if (tenantId == null) {
+ return new ResponseEntity<>(Map.of("success", false, "error", "Missing tenantId"), HttpStatus.BAD_REQUEST);
+ }
+
+ Map stats = orderService.getOrderStats(tenantId);
+ Map response = new HashMap<>();
+ response.put("success", true);
+ response.put("data", stats);
+ return new ResponseEntity<>(response, HttpStatus.OK);
+ } catch (Exception e) {
+ Map error = new HashMap<>();
+ error.put("success", false);
+ error.put("error", e.getMessage());
+ return new ResponseEntity<>(error, HttpStatus.INTERNAL_SERVER_ERROR);
+ }
+ }
+
+ @PostMapping("/{id}/status")
+ public ResponseEntity transitionOrderStatus(@PathVariable String id, @RequestBody Map request) {
+ try {
+ String tenantId = (String) request.get("tenantId");
+ String status = (String) request.get("status");
+ String reason = (String) request.get("reason");
+
+ if (tenantId == null || status == null) {
+ return new ResponseEntity<>(Map.of("success", false, "error", "Missing tenantId or status"), HttpStatus.BAD_REQUEST);
+ }
+
+ orderService.transitionOrderStatus(tenantId, id, status, reason);
+ Map response = new HashMap<>();
+ response.put("success", true);
+ response.put("message", "Order status updated successfully");
+ return new ResponseEntity<>(response, HttpStatus.OK);
+ } catch (Exception e) {
+ Map error = new HashMap<>();
+ error.put("success", false);
+ error.put("error", e.getMessage());
+ return new ResponseEntity<>(error, HttpStatus.INTERNAL_SERVER_ERROR);
+ }
+ }
+
+ @PutMapping("/batch")
+ public ResponseEntity batchUpdateOrders(@RequestBody Map request) {
+ try {
+ String tenantId = (String) request.get("tenantId");
+ List orderIds = (List) request.get("orderIds");
+ Map updates = (Map) request.get("updates");
+
+ if (tenantId == null || orderIds == null || updates == null) {
+ return new ResponseEntity<>(Map.of("success", false, "error", "Missing tenantId, orderIds, or updates"), HttpStatus.BAD_REQUEST);
+ }
+
+ Map result = orderService.batchUpdateOrders(tenantId, orderIds, updates);
+ Map response = new HashMap<>();
+ response.put("success", true);
+ response.put("data", result);
+ return new ResponseEntity<>(response, HttpStatus.OK);
+ } catch (Exception e) {
+ Map error = new HashMap<>();
+ error.put("success", false);
+ error.put("error", e.getMessage());
+ return new ResponseEntity<>(error, HttpStatus.INTERNAL_SERVER_ERROR);
+ }
+ }
+
+ @PostMapping("/batch/audit")
+ public ResponseEntity batchAuditOrders(@RequestBody Map request) {
+ try {
+ String tenantId = (String) request.get("tenantId");
+ List orderIds = (List) request.get("orderIds");
+
+ if (tenantId == null || orderIds == null) {
+ return new ResponseEntity<>(Map.of("success", false, "error", "Missing tenantId or orderIds"), HttpStatus.BAD_REQUEST);
+ }
+
+ Map result = orderService.batchAuditOrders(tenantId, orderIds);
+ Map response = new HashMap<>();
+ response.put("success", true);
+ response.put("data", result);
+ return new ResponseEntity<>(response, HttpStatus.OK);
+ } catch (Exception e) {
+ Map error = new HashMap<>();
+ error.put("success", false);
+ error.put("error", e.getMessage());
+ return new ResponseEntity<>(error, HttpStatus.INTERNAL_SERVER_ERROR);
+ }
+ }
+
+ @PostMapping("/batch/ship")
+ public ResponseEntity batchShipOrders(@RequestBody Map request) {
+ try {
+ String tenantId = (String) request.get("tenantId");
+ List orderIds = (List) request.get("orderIds");
+
+ if (tenantId == null || orderIds == null) {
+ return new ResponseEntity<>(Map.of("success", false, "error", "Missing tenantId or orderIds"), HttpStatus.BAD_REQUEST);
+ }
+
+ Map result = orderService.batchShipOrders(tenantId, orderIds);
+ Map response = new HashMap<>();
+ response.put("success", true);
+ response.put("data", result);
+ return new ResponseEntity<>(response, HttpStatus.OK);
+ } catch (Exception e) {
+ Map error = new HashMap<>();
+ error.put("success", false);
+ error.put("error", e.getMessage());
+ return new ResponseEntity<>(error, HttpStatus.INTERNAL_SERVER_ERROR);
+ }
+ }
+
+ @PostMapping("/{id}/exception")
+ public ResponseEntity markOrderAsException(@PathVariable String id, @RequestBody Map request) {
+ try {
+ String tenantId = (String) request.get("tenantId");
+ String reason = (String) request.get("reason");
+
+ if (tenantId == null || reason == null) {
+ return new ResponseEntity<>(Map.of("success", false, "error", "Missing tenantId or reason"), HttpStatus.BAD_REQUEST);
+ }
+
+ orderService.markOrderAsException(tenantId, id, reason);
+ Map response = new HashMap<>();
+ response.put("success", true);
+ response.put("message", "Order marked as exception");
+ return new ResponseEntity<>(response, HttpStatus.OK);
+ } catch (Exception e) {
+ Map error = new HashMap<>();
+ error.put("success", false);
+ error.put("error", e.getMessage());
+ return new ResponseEntity<>(error, HttpStatus.INTERNAL_SERVER_ERROR);
+ }
+ }
+
+ @PostMapping("/{id}/reroute")
+ public ResponseEntity autoRerouteOrder(@PathVariable String id, @RequestBody Map request) {
+ try {
+ String tenantId = (String) request.get("tenantId");
+
+ if (tenantId == null) {
+ return new ResponseEntity<>(Map.of("success", false, "error", "Missing tenantId"), HttpStatus.BAD_REQUEST);
+ }
+
+ orderService.autoRerouteOrder(tenantId, id);
+ Map response = new HashMap<>();
+ response.put("success", true);
+ response.put("message", "Order rerouted successfully");
+ return new ResponseEntity<>(response, HttpStatus.OK);
+ } catch (Exception e) {
+ Map error = new HashMap<>();
+ error.put("success", false);
+ error.put("error", e.getMessage());
+ return new ResponseEntity<>(error, HttpStatus.INTERNAL_SERVER_ERROR);
+ }
+ }
+
+ @PostMapping("/{id}/retry")
+ public ResponseEntity retryExceptionOrder(@PathVariable String id, @RequestBody Map request) {
+ try {
+ String tenantId = (String) request.get("tenantId");
+
+ if (tenantId == null) {
+ return new ResponseEntity<>(Map.of("success", false, "error", "Missing tenantId"), HttpStatus.BAD_REQUEST);
+ }
+
+ orderService.retryExceptionOrder(tenantId, id);
+ Map response = new HashMap<>();
+ response.put("success", true);
+ response.put("message", "Order retried successfully");
+ return new ResponseEntity<>(response, HttpStatus.OK);
+ } catch (Exception e) {
+ Map error = new HashMap<>();
+ error.put("success", false);
+ error.put("error", e.getMessage());
+ return new ResponseEntity<>(error, HttpStatus.INTERNAL_SERVER_ERROR);
+ }
+ }
+
+ @PostMapping("/{id}/cancel")
+ public ResponseEntity cancelOrder(@PathVariable String id, @RequestBody Map request) {
+ try {
+ String tenantId = (String) request.get("tenantId");
+ String reason = (String) request.get("reason");
+
+ if (tenantId == null || reason == null) {
+ return new ResponseEntity<>(Map.of("success", false, "error", "Missing tenantId or reason"), HttpStatus.BAD_REQUEST);
+ }
+
+ orderService.cancelOrder(tenantId, id, reason);
+ Map response = new HashMap<>();
+ response.put("success", true);
+ response.put("message", "Order cancelled successfully");
+ return new ResponseEntity<>(response, HttpStatus.OK);
+ } catch (Exception e) {
+ Map error = new HashMap<>();
+ error.put("success", false);
+ error.put("error", e.getMessage());
+ return new ResponseEntity<>(error, HttpStatus.INTERNAL_SERVER_ERROR);
+ }
+ }
+
+ @PostMapping("/{id}/refund")
+ public ResponseEntity requestRefund(@PathVariable String id, @RequestBody Map request) {
+ try {
+ String tenantId = (String) request.get("tenantId");
+ String reason = (String) request.get("reason");
+ Double amount = (Double) request.get("amount");
+
+ if (tenantId == null || reason == null || amount == null) {
+ return new ResponseEntity<>(Map.of("success", false, "error", "Missing tenantId, reason, or amount"), HttpStatus.BAD_REQUEST);
+ }
+
+ String refundId = orderService.requestRefund(tenantId, id, reason, amount);
+ Map response = new HashMap<>();
+ response.put("success", true);
+ response.put("refundId", refundId);
+ return new ResponseEntity<>(response, HttpStatus.OK);
+ } catch (Exception e) {
+ Map error = new HashMap<>();
+ error.put("success", false);
+ error.put("error", e.getMessage());
+ return new ResponseEntity<>(error, HttpStatus.INTERNAL_SERVER_ERROR);
+ }
+ }
+
+ @PostMapping("/refund/{id}/approve")
+ public ResponseEntity approveRefund(@PathVariable String id, @RequestBody Map request) {
+ try {
+ String tenantId = (String) request.get("tenantId");
+ Boolean approved = (Boolean) request.get("approved");
+ String note = (String) request.get("note");
+
+ if (tenantId == null || approved == null) {
+ return new ResponseEntity<>(Map.of("success", false, "error", "Missing tenantId or approved"), HttpStatus.BAD_REQUEST);
+ }
+
+ orderService.approveRefund(tenantId, id, approved, note);
+ Map response = new HashMap<>();
+ response.put("success", true);
+ response.put("message", "Refund processed successfully");
+ return new ResponseEntity<>(response, HttpStatus.OK);
+ } catch (Exception e) {
+ Map error = new HashMap<>();
+ error.put("success", false);
+ error.put("error", e.getMessage());
+ return new ResponseEntity<>(error, HttpStatus.INTERNAL_SERVER_ERROR);
+ }
+ }
+
+ @PostMapping("/{id}/after-sales")
+ public ResponseEntity requestAfterSales(@PathVariable String id, @RequestBody Map request) {
+ try {
+ String tenantId = (String) request.get("tenantId");
+ String type = (String) request.get("type");
+ String reason = (String) request.get("reason");
+ List> items = (List>) request.get("items");
+
+ if (tenantId == null || type == null || reason == null || items == null) {
+ return new ResponseEntity<>(Map.of("success", false, "error", "Missing required parameters"), HttpStatus.BAD_REQUEST);
+ }
+
+ String serviceId = orderService.requestAfterSales(tenantId, id, type, reason, items);
+ Map response = new HashMap<>();
+ response.put("success", true);
+ response.put("serviceId", serviceId);
+ return new ResponseEntity<>(response, HttpStatus.OK);
+ } catch (Exception e) {
+ Map error = new HashMap<>();
+ error.put("success", false);
+ error.put("error", e.getMessage());
+ return new ResponseEntity<>(error, HttpStatus.INTERNAL_SERVER_ERROR);
+ }
+ }
+
+ @PostMapping("/after-sales/{id}/process")
+ public ResponseEntity processAfterSales(@PathVariable String id, @RequestBody Map request) {
+ try {
+ String tenantId = (String) request.get("tenantId");
+ String action = (String) request.get("action");
+ String note = (String) request.get("note");
+
+ if (tenantId == null || action == null) {
+ return new ResponseEntity<>(Map.of("success", false, "error", "Missing tenantId or action"), HttpStatus.BAD_REQUEST);
+ }
+
+ orderService.processAfterSales(tenantId, id, action, note);
+ Map response = new HashMap<>();
+ response.put("success", true);
+ response.put("message", "After-sales service processed successfully");
+ return new ResponseEntity<>(response, HttpStatus.OK);
+ } catch (Exception e) {
+ Map error = new HashMap<>();
+ error.put("success", false);
+ error.put("error", e.getMessage());
+ return new ResponseEntity<>(error, HttpStatus.INTERNAL_SERVER_ERROR);
+ }
+ }
+
+ @PostMapping("/{id}/complete")
+ public ResponseEntity completeOrder(@PathVariable String id, @RequestBody Map request) {
+ try {
+ String tenantId = (String) request.get("tenantId");
+
+ if (tenantId == null) {
+ return new ResponseEntity<>(Map.of("success", false, "error", "Missing tenantId"), HttpStatus.BAD_REQUEST);
+ }
+
+ orderService.completeOrder(tenantId, id);
+ Map response = new HashMap<>();
+ response.put("success", true);
+ response.put("message", "Order completed successfully");
+ return new ResponseEntity<>(response, HttpStatus.OK);
+ } catch (Exception e) {
+ Map error = new HashMap<>();
+ error.put("success", false);
+ error.put("error", e.getMessage());
+ return new ResponseEntity<>(error, HttpStatus.INTERNAL_SERVER_ERROR);
+ }
+ }
+
+ @PostMapping("/webhook/{platform}")
+ public ResponseEntity handlePlatformWebhook(@PathVariable String platform, @RequestBody Map payload, @RequestHeader Map headers) {
+ try {
+ String tenantId = headers.get("x-tenant-id") != null ? headers.get("x-tenant-id") : "default-tenant";
+ String shopId = headers.get("x-shop-id") != null ? headers.get("x-shop-id") : "default-shop";
+
+ Order order = orderService.mapPlatformPayloadToOrder(platform, payload, tenantId, shopId);
+ if (order == null) {
+ return new ResponseEntity<>(Map.of("success", false, "error", "Unsupported or invalid payload for platform: " + platform), HttpStatus.BAD_REQUEST);
+ }
+
+ Order savedOrder = orderService.createOrder(Map.of(
+ "tenantId", order.getTenantId(),
+ "shopId", order.getShopId(),
+ "platform", order.getPlatform(),
+ "platformOrderId", order.getPlatformOrderId(),
+ "status", order.getStatus(),
+ "totalAmount", order.getTotalAmount(),
+ "currency", order.getCurrency(),
+ "customerInfo", order.getCustomerInfo(),
+ "items", order.getItems(),
+ "shippingAddress", order.getShippingAddress()
+ ));
+
+ Map response = new HashMap<>();
+ response.put("success", true);
+ response.put("orderId", savedOrder.getId());
+ return new ResponseEntity<>(response, HttpStatus.OK);
+ } catch (Exception e) {
+ Map error = new HashMap<>();
+ error.put("success", false);
+ error.put("error", "Internal server error");
+ return new ResponseEntity<>(error, HttpStatus.INTERNAL_SERVER_ERROR);
+ }
+ }
+}
diff --git a/src/main/java/com/crawlful/hub/api/controllers/PaymentController.java b/src/main/java/com/crawlful/hub/api/controllers/PaymentController.java
new file mode 100644
index 0000000..5e9718c
--- /dev/null
+++ b/src/main/java/com/crawlful/hub/api/controllers/PaymentController.java
@@ -0,0 +1,165 @@
+package com.crawlful.hub.api.controllers;
+
+import com.crawlful.hub.model.Payment;
+import com.crawlful.hub.service.PaymentService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+@RestController
+@RequestMapping("/v1/payment")
+public class PaymentController {
+ @Autowired
+ private PaymentService paymentService;
+
+ @PostMapping
+ public ResponseEntity createPayment(@RequestBody Map request) {
+ try {
+ String tenantId = (String) request.get("tenantId");
+ if (tenantId == null) {
+ return new ResponseEntity<>(Map.of("success", false, "error", "Missing tenantId"), HttpStatus.BAD_REQUEST);
+ }
+
+ Payment payment = paymentService.createPayment(request);
+ Map response = new HashMap<>();
+ response.put("success", true);
+ response.put("paymentId", payment.getId());
+ return new ResponseEntity<>(response, HttpStatus.CREATED);
+ } catch (Exception e) {
+ Map error = new HashMap<>();
+ error.put("success", false);
+ error.put("error", e.getMessage());
+ return new ResponseEntity<>(error, HttpStatus.INTERNAL_SERVER_ERROR);
+ }
+ }
+
+ @GetMapping
+ public ResponseEntity getPayments(@RequestParam Map params) {
+ try {
+ String tenantId = params.get("tenantId");
+ if (tenantId == null) {
+ return new ResponseEntity<>(Map.of("success", false, "error", "Missing tenantId"), HttpStatus.BAD_REQUEST);
+ }
+
+ Map filters = new HashMap<>();
+ if (params.containsKey("status")) {
+ filters.put("status", params.get("status"));
+ }
+ if (params.containsKey("orderId")) {
+ filters.put("orderId", Long.parseLong(params.get("orderId")));
+ }
+
+ List payments = paymentService.getPayments(tenantId, filters);
+ Map response = new HashMap<>();
+ response.put("success", true);
+ response.put("data", payments);
+ return new ResponseEntity<>(response, HttpStatus.OK);
+ } catch (Exception e) {
+ Map error = new HashMap<>();
+ error.put("success", false);
+ error.put("error", e.getMessage());
+ return new ResponseEntity<>(error, HttpStatus.INTERNAL_SERVER_ERROR);
+ }
+ }
+
+ @GetMapping("/{id}")
+ public ResponseEntity getPaymentById(@PathVariable Long id, @RequestParam String tenantId) {
+ try {
+ if (tenantId == null) {
+ return new ResponseEntity<>(Map.of("success", false, "error", "Missing tenantId"), HttpStatus.BAD_REQUEST);
+ }
+
+ Payment payment = paymentService.getPaymentById(tenantId, id);
+ if (payment == null) {
+ return new ResponseEntity<>(Map.of("success", false, "error", "Payment not found"), HttpStatus.NOT_FOUND);
+ }
+
+ Map response = new HashMap<>();
+ response.put("success", true);
+ response.put("data", payment);
+ return new ResponseEntity<>(response, HttpStatus.OK);
+ } catch (Exception e) {
+ Map error = new HashMap<>();
+ error.put("success", false);
+ error.put("error", e.getMessage());
+ return new ResponseEntity<>(error, HttpStatus.INTERNAL_SERVER_ERROR);
+ }
+ }
+
+ @PutMapping("/{id}")
+ public ResponseEntity updatePayment(@PathVariable Long id, @RequestBody Map request) {
+ try {
+ String tenantId = (String) request.get("tenantId");
+ if (tenantId == null) {
+ return new ResponseEntity<>(Map.of("success", false, "error", "Missing tenantId"), HttpStatus.BAD_REQUEST);
+ }
+
+ paymentService.updatePayment(tenantId, id, request);
+ Map response = new HashMap<>();
+ response.put("success", true);
+ response.put("message", "Payment updated successfully");
+ return new ResponseEntity<>(response, HttpStatus.OK);
+ } catch (Exception e) {
+ Map error = new HashMap<>();
+ error.put("success", false);
+ error.put("error", e.getMessage());
+ return new ResponseEntity<>(error, HttpStatus.INTERNAL_SERVER_ERROR);
+ }
+ }
+
+ @PostMapping("/callback")
+ public ResponseEntity processPaymentCallback(@RequestBody Map request) {
+ try {
+ String tenantId = (String) request.get("tenantId");
+ String transactionId = (String) request.get("transactionId");
+
+ if (tenantId == null || transactionId == null) {
+ return new ResponseEntity<>(Map.of("success", false, "error", "Missing tenantId or transactionId"), HttpStatus.BAD_REQUEST);
+ }
+
+ paymentService.processPaymentCallback(tenantId, transactionId, request);
+ Map response = new HashMap<>();
+ response.put("success", true);
+ response.put("message", "Callback processed successfully");
+ return new ResponseEntity<>(response, HttpStatus.OK);
+ } catch (Exception e) {
+ Map error = new HashMap<>();
+ error.put("success", false);
+ error.put("error", e.getMessage());
+ return new ResponseEntity<>(error, HttpStatus.INTERNAL_SERVER_ERROR);
+ }
+ }
+
+ @PostMapping("/{id}/refund")
+ public ResponseEntity refundPayment(@PathVariable Long id, @RequestBody Map request) {
+ try {
+ String tenantId = (String) request.get("tenantId");
+ Double amount = (Double) request.get("amount");
+ String reason = (String) request.get("reason");
+
+ if (tenantId == null || amount == null || reason == null) {
+ return new ResponseEntity<>(Map.of("success", false, "error", "Missing tenantId, amount, or reason"), HttpStatus.BAD_REQUEST);
+ }
+
+ Map result = paymentService.refundPayment(tenantId, id, amount, reason);
+ Map response = new HashMap<>();
+ response.put("success", result.get("success"));
+ if (result.get("success").equals(true)) {
+ response.put("refundId", result.get("refundId"));
+ } else {
+ response.put("error", result.get("error"));
+ }
+ return new ResponseEntity<>(response, HttpStatus.OK);
+ } catch (Exception e) {
+ Map error = new HashMap<>();
+ error.put("success", false);
+ error.put("error", e.getMessage());
+ return new ResponseEntity<>(error, HttpStatus.INTERNAL_SERVER_ERROR);
+ }
+ }
+}
diff --git a/src/main/java/com/crawlful/hub/api/controllers/ProductController.java b/src/main/java/com/crawlful/hub/api/controllers/ProductController.java
new file mode 100644
index 0000000..489835c
--- /dev/null
+++ b/src/main/java/com/crawlful/hub/api/controllers/ProductController.java
@@ -0,0 +1,208 @@
+package com.crawlful.hub.api.controllers;
+
+import com.crawlful.hub.model.Product;
+import com.crawlful.hub.service.ProductService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+@RestController
+@RequestMapping("/v1/product")
+public class ProductController {
+ @Autowired
+ private ProductService productService;
+
+ @PostMapping
+ public ResponseEntity create(@RequestBody Map request) {
+ try {
+ String tenantId = (String) request.get("tenantId");
+ if (tenantId == null) {
+ return new ResponseEntity<>(Map.of("success", false, "error", "Missing tenantId"), HttpStatus.BAD_REQUEST);
+ }
+
+ Product product = productService.create(tenantId, request);
+ Map response = new HashMap<>();
+ response.put("success", true);
+ response.put("data", Map.of("id", product.getId()));
+ return new ResponseEntity<>(response, HttpStatus.CREATED);
+ } catch (Exception e) {
+ Map error = new HashMap<>();
+ error.put("success", false);
+ error.put("error", e.getMessage());
+ return new ResponseEntity<>(error, HttpStatus.INTERNAL_SERVER_ERROR);
+ }
+ }
+
+ @GetMapping
+ public ResponseEntity getAll(@RequestParam Map params) {
+ try {
+ String tenantId = params.get("tenantId");
+ if (tenantId == null) {
+ return new ResponseEntity<>(Map.of("success", false, "error", "Missing tenantId"), HttpStatus.BAD_REQUEST);
+ }
+
+ Map filters = new HashMap<>();
+ if (params.containsKey("platform")) {
+ filters.put("platform", params.get("platform"));
+ }
+ if (params.containsKey("status")) {
+ filters.put("status", params.get("status"));
+ }
+
+ int page = 1;
+ int size = 10;
+ if (params.containsKey("page")) {
+ try {
+ page = Integer.parseInt(params.get("page"));
+ } catch (NumberFormatException e) {
+ page = 1;
+ }
+ }
+ if (params.containsKey("size")) {
+ try {
+ size = Integer.parseInt(params.get("size"));
+ } catch (NumberFormatException e) {
+ size = 10;
+ }
+ }
+
+ List products = productService.getAll(tenantId, filters, page, size);
+ Map response = new HashMap<>();
+ response.put("success", true);
+ response.put("data", products);
+ response.put("page", page);
+ response.put("size", size);
+ return new ResponseEntity<>(response, HttpStatus.OK);
+ } catch (Exception e) {
+ Map error = new HashMap<>();
+ error.put("success", false);
+ error.put("error", e.getMessage());
+ return new ResponseEntity<>(error, HttpStatus.INTERNAL_SERVER_ERROR);
+ }
+ }
+
+ @GetMapping("/{id}")
+ public ResponseEntity getById(@PathVariable Long id, @RequestParam String tenantId) {
+ try {
+ if (tenantId == null) {
+ return new ResponseEntity<>(Map.of("success", false, "error", "Missing tenantId"), HttpStatus.BAD_REQUEST);
+ }
+
+ Product product = productService.getById(tenantId, id);
+ if (product == null) {
+ return new ResponseEntity<>(Map.of("success", false, "error", "Product not found"), HttpStatus.NOT_FOUND);
+ }
+
+ Map response = new HashMap<>();
+ response.put("success", true);
+ response.put("data", product);
+ return new ResponseEntity<>(response, HttpStatus.OK);
+ } catch (Exception e) {
+ Map error = new HashMap<>();
+ error.put("success", false);
+ error.put("error", e.getMessage());
+ return new ResponseEntity<>(error, HttpStatus.INTERNAL_SERVER_ERROR);
+ }
+ }
+
+ @PutMapping("/{id}")
+ public ResponseEntity update(@PathVariable Long id, @RequestBody Map request) {
+ try {
+ String tenantId = (String) request.get("tenantId");
+ if (tenantId == null) {
+ return new ResponseEntity<>(Map.of("success", false, "error", "Missing tenantId"), HttpStatus.BAD_REQUEST);
+ }
+
+ Product product = productService.update(tenantId, id, request);
+ if (product == null) {
+ return new ResponseEntity<>(Map.of("success", false, "error", "Product not found"), HttpStatus.NOT_FOUND);
+ }
+
+ Map response = new HashMap<>();
+ response.put("success", true);
+ response.put("data", product);
+ return new ResponseEntity<>(response, HttpStatus.OK);
+ } catch (Exception e) {
+ Map error = new HashMap<>();
+ error.put("success", false);
+ error.put("error", e.getMessage());
+ return new ResponseEntity<>(error, HttpStatus.INTERNAL_SERVER_ERROR);
+ }
+ }
+
+ @DeleteMapping("/{id}")
+ public ResponseEntity delete(@PathVariable Long id, @RequestParam String tenantId) {
+ try {
+ if (tenantId == null) {
+ return new ResponseEntity<>(Map.of("success", false, "error", "Missing tenantId"), HttpStatus.BAD_REQUEST);
+ }
+
+ productService.delete(tenantId, id);
+ Map response = new HashMap<>();
+ response.put("success", true);
+ return new ResponseEntity<>(response, HttpStatus.OK);
+ } catch (Exception e) {
+ Map error = new HashMap<>();
+ error.put("success", false);
+ error.put("error", e.getMessage());
+ return new ResponseEntity<>(error, HttpStatus.INTERNAL_SERVER_ERROR);
+ }
+ }
+
+ @PostMapping("/{id}/wash-and-localize")
+ public ResponseEntity washAndLocalize(@PathVariable Long id, @RequestBody Map request) {
+ try {
+ String tenantId = (String) request.get("tenantId");
+ String targetMarket = (String) request.get("targetMarket");
+ String targetLang = (String) request.get("targetLang");
+
+ if (tenantId == null || targetMarket == null || targetLang == null) {
+ return new ResponseEntity<>(Map.of("success", false, "error", "Missing required parameters"), HttpStatus.BAD_REQUEST);
+ }
+
+ Map result = productService.washAndLocalize(tenantId, id, targetMarket, targetLang);
+ if (result == null) {
+ return new ResponseEntity<>(Map.of("success", false, "error", "Product not found"), HttpStatus.NOT_FOUND);
+ }
+
+ Map response = new HashMap<>();
+ response.put("success", true);
+ response.put("data", result);
+ return new ResponseEntity<>(response, HttpStatus.OK);
+ } catch (Exception e) {
+ Map error = new HashMap<>();
+ error.put("success", false);
+ error.put("error", e.getMessage());
+ return new ResponseEntity<>(error, HttpStatus.INTERNAL_SERVER_ERROR);
+ }
+ }
+
+ @GetMapping("/{id}/analyze-arbitrage")
+ public ResponseEntity analyzeArbitrage(@PathVariable Long id, @RequestParam String tenantId) {
+ try {
+ if (tenantId == null) {
+ return new ResponseEntity<>(Map.of("success", false, "error", "Missing tenantId"), HttpStatus.BAD_REQUEST);
+ }
+
+ Map result = productService.analyzeProductArbitrage(tenantId, id);
+ if (result == null) {
+ return new ResponseEntity<>(Map.of("success", false, "error", "Product not found"), HttpStatus.NOT_FOUND);
+ }
+
+ Map response = new HashMap<>();
+ response.put("success", true);
+ response.put("data", result);
+ return new ResponseEntity<>(response, HttpStatus.OK);
+ } catch (Exception e) {
+ Map error = new HashMap<>();
+ error.put("success", false);
+ error.put("error", e.getMessage());
+ return new ResponseEntity<>(error, HttpStatus.INTERNAL_SERVER_ERROR);
+ }
+ }
+}
diff --git a/src/main/java/com/crawlful/hub/api/controllers/ReportController.java b/src/main/java/com/crawlful/hub/api/controllers/ReportController.java
new file mode 100644
index 0000000..089ecd0
--- /dev/null
+++ b/src/main/java/com/crawlful/hub/api/controllers/ReportController.java
@@ -0,0 +1,192 @@
+package com.crawlful.hub.api.controllers;
+
+import com.crawlful.hub.service.ReportService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.Map;
+
+@RestController
+@RequestMapping("/v1/reports")
+public class ReportController {
+ @Autowired
+ private ReportService reportService;
+
+ @GetMapping("/sales")
+ public ResponseEntity generateSalesReport(@RequestParam String tenantId, @RequestParam String startDate, @RequestParam String endDate) {
+ try {
+ if (tenantId == null || startDate == null || endDate == null) {
+ return new ResponseEntity<>(Map.of("success", false, "error", "Missing required parameters"), HttpStatus.BAD_REQUEST);
+ }
+
+ SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
+ Date start = sdf.parse(startDate);
+ Date end = sdf.parse(endDate);
+
+ Map salesReport = reportService.generateSalesReport(tenantId, start, end);
+ Map response = new HashMap<>();
+ response.put("success", true);
+ response.put("data", salesReport);
+ return new ResponseEntity<>(response, HttpStatus.OK);
+ } catch (ParseException e) {
+ Map error = new HashMap<>();
+ error.put("success", false);
+ error.put("error", "Invalid date format. Use yyyy-MM-dd");
+ return new ResponseEntity<>(error, HttpStatus.BAD_REQUEST);
+ } catch (Exception e) {
+ Map error = new HashMap<>();
+ error.put("success", false);
+ error.put("error", e.getMessage());
+ return new ResponseEntity<>(error, HttpStatus.INTERNAL_SERVER_ERROR);
+ }
+ }
+
+ @GetMapping("/inventory")
+ public ResponseEntity generateInventoryReport(@RequestParam String tenantId) {
+ try {
+ if (tenantId == null) {
+ return new ResponseEntity<>(Map.of("success", false, "error", "Missing tenantId"), HttpStatus.BAD_REQUEST);
+ }
+
+ Map