Compare commits

..

7 Commits

Binary file not shown.

After

Width:  |  Height:  |  Size: 53 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 50 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 90 KiB

@ -0,0 +1,257 @@
# 实验一软件项目计划个人报告作业题
## 个人基本信息
- **姓名**:董文远
- **学号**2023210446
- **班级**计科231
- **小组**G9组
- **角色**:开发人员
- **实验日期**2025-11-03
- **提交日期**2025-11-08
## 个人任务完成情况
### 1. 个人负责的功能模块分析
开发人员(董文远):
- 详细分析人员交互功能的需求
- 描述用户界面设计和用户体验考虑
- 分析交互流程的安全性和易用性
- 说明人员交互功能与其他模块的交互关系
### 2. EA模型设计
- 需求图:展示了用户注册登录、人员交互功能、订单与支付管理、数据系统与可视化需求的层次关系,明确了各功能点依赖关系。
- 用例图:描述了用户与数据库交互的场景,包括注册登录、人员交互功能、订单与支付管理、数据系统与可视化核心用例。
- 甘特图::规划了人员交互功能的开发时间安排,从需求分析到最终测试的完整进度控制,设定了关键里程碑和交付节点。
### 3. 测试用例设计
针对人员交互功能,设计了以下关键测试用例:
- 覆盖了用户注册、登录、任务发布、任务接受、消息发送、权限控制等核心功能
- 考虑了不同角色(学生、代取员、管理员)的权限边界
- 验证了输入验证、异常处理、状态流转等关键场景
- 测试了界面响应式布局在不同设备上的兼容性
- 优先级高的测试用例TC001、TC002、TC003、TC005优先执行
- 按照用户操作流程顺序执行:先测试注册登录,再测试任务发布接受,最后测试消息和权限控制
- 确保核心功能正常后再进行辅助功能测试
- 功能测试完成后进行性能和兼容性测试
### 4. 个人工作总结与甘特图分析
**主要工作内容和完成情况**
- 完成了校园代取系统人员交互功能的需求分析和功能规划
- 设计了详细的用户界面原型和交互流程图
- 使用EA工具创建了需求图、用例图、甘特图和软件过程模型图
- 编写了5个关键测试用例覆盖了主要功能点
- 撰写了完整的项目计划文档
- **甘特图中的时间安排和进度控制**
- 需求分析和功能规划安排在2025-11-03实际用时3天提前完成
- EA模型设计安排在2025-11-03实际用时4天按时完成了所有模型
- 用户界面原型设计安排在2025-11-03实际用时5小时按计划完成
- 测试用例编写安排在2025-11-03实际用时4天按时完成
- 文档撰写与总结安排在2025-11-03实际用时4天按计划完成
- **遇到的主要问题和解决方案**
- 需求理解不清晰:通过与团队成员积极讨论,明确了功能细节和边界
- 模型关系复杂:参考相关案例,采用模块化思想逐步构建模型
- 界面风格不一致:制定了统一的设计规范,确保视觉一致性
- 测试场景覆盖不全:参考测试用例模板,全面考虑各种使用场景
- **收获和体会**
- 深入理解了软件项目计划的重要性,合理的规划是项目成功的基础
- 学习了使用EA工具进行软件建模提高了系统设计能力
- 增强了团队协作意识,沟通在项目中起着关键作用
- 掌握了测试用例设计方法,为后续开发奠定了基础
- **工作质量和效率评估**
- 工作质量:整体完成度高,文档结构清晰,内容详实
- 工作效率:大部分任务按时完成,部分任务提前完成
- 改进措施:加强时间管理,提前规划复杂任务;提升工具使用熟练度;加强需求理解能力
### 5. 甘特图应用分析
**功能模块在甘特图中的时间节点和工期安排**
- 需求分析2025-11-06工期3天
- 用例设计2025-11-07工期4天
- 测试用例2025-11-07工期4天
- 文档总结2025-11-07工期4天
- **与其他团队成员工作的依赖关系**
- 依赖项目经理提供的整体需求和架构设计
- 为开发人员2和开发人员3提供界面接口规范
- 与数据库设计团队协作确定数据交互格式
- 为测试团队提供测试用例和功能说明
- **关键路径对工作的影响**
- 需求分析是关键路径的起点,直接影响后续所有工作
- 界面设计完成时间影响后端开发的进度
- 确保在关键时间节点前完成交付,避免影响团队整体进度
- 通过并行工作减少对关键路径的依赖
- **甘特图对个人工作计划的指导价值**
- 明确了各项任务的时间节点和优先级
- 帮助合理分配每天的工作内容和时间
- 便于跟踪任务进度,及时发现和解决问题
- 为工作调整提供了依据,确保项目按时完成
## 实验一相关问题思考
### 问题1项目计划的重要性
- **软件项目计划对整个软件开发过程的影响**
- 明确项目目标和范围,避免需求蔓延
- 合理分配资源,提高开发效率
- 设定明确的时间节点,便于进度控制
- 降低项目风险,提前识别潜在问题
- 促进团队沟通和协作,确保目标一致
- **结合校园代取系统项目,说明项目计划如何指导后续开发工作**
- 通过需求分析,明确了校园代取系统的核心功能和用户群体
- 制定了详细的开发计划,包括人员交互、任务管理、支付系统等模块的开发顺序
- 设定了里程碑,如原型设计完成、功能开发完成、测试完成等
- 为团队成员分配了明确的职责,避免工作重叠或遗漏
- 建立了进度跟踪机制,及时调整计划以适应变化
### 问题2甘特图的应用价值
- **甘特图在项目管理中的作用和优势**
- 直观展示项目时间安排和任务依赖关系
- 便于监控项目进度,识别延期风险
- 帮助资源分配和冲突解决
- 为项目沟通提供可视化工具
- 支持计划调整和优化
- **结合校园代取系统项目,说明甘特图如何帮助控制项目进度**
- 通过甘特图清晰展示了各模块的开发时间和顺序
- 识别了关键路径,优先保证关键任务的进度
- 定期对照甘特图检查实际进度,及时发现偏差
- 当某一任务延期时,通过甘特图快速评估对整体项目的影响
- 基于甘特图进行资源调整,确保项目按时完成
## 工具使用体会
### EAEnterprise Architect使用体会
- **使用的主要功能和操作流程**
- 创建需求图,梳理功能需求层次
- 设计用例图,描述用户与系统的交互
- 绘制甘特图,规划项目进度
- 构建软件过程模型图,明确开发流程
- 导出模型图用于文档编写
- **EA在软件建模中的优势和不足**
- **优势**:功能全面,支持多种建模语言;可视化效果好;支持团队协作;模型之间关联紧密
- **不足**:学习曲线较陡;界面操作稍复杂;对初学者不够友好;部分高级功能使用不够直观
- **使用过程中遇到的困难和解决方法**
- 困难:模型元素之间的关系设置复杂
- 解决方法:查阅帮助文档,参考示例模型,逐步学习
- 困难:甘特图与实际项目管理工具的集成
- 解决方法:手动同步关键信息,确保数据一致性
- **改进EA使用效率的建议**
- 提前学习EA的基本操作熟悉常用功能
- 使用模板快速创建标准模型
- 制定团队建模规范,统一命名和关系表示
- 结合实际项目需求,选择合适的建模方法
### TRAE辅助工具使用体会
- **使用的功能和体验**
- 使用TRAE生成初始文档框架
- 辅助编写代码注释和文档内容
- 提供代码示例和最佳实践建议
- 帮助优化文档结构和格式
- **TRAE在文档生成中的价值和局限性**
- **价值**:提高文档生成效率;确保文档格式规范;提供内容参考;减少重复劳动
- **局限性**:生成内容需要人工审核和调整;对特定领域知识理解有限;缺乏个性化定制
- **使用过程中的心得体会**
- TRAE是很好的辅助工具但不能完全替代人工思考和创作
- 合理使用TRAE可以大大提高工作效率
- 需要根据项目实际情况对生成内容进行调整和补充
- 结合TRAE和人工经验可以获得更好的文档质量
- **AI辅助工具在软件开发中的应用前景**
- 代码生成和补全功能将更加智能和精准
- 文档自动生成和更新将成为常态
- 需求分析和测试用例生成将得到AI辅助
- 项目管理和资源优化将更加科学
- 开发者将更多精力集中在创新和复杂问题解决上
### Git版本控制使用体会
- **使用Git进行版本控制的基本操作**
- 克隆仓库git clone
- 创建分支git branch
- 切换分支git checkout
- 添加修改git add
- 提交更改git commit
- 推送代码git push
- 拉取更新git pull
- 合并分支git merge
- **Git在团队协作开发中的重要性**
- 提供代码版本管理,便于追溯历史变更
- 支持多人并行开发,减少代码冲突
- 保护代码安全,防止意外丢失
- 便于代码审查和质量控制
- 支持功能分支开发模式,提高开发效率
- **使用过程中遇到的问题和解决方法**
- 问题:代码冲突
- 解决方法:仔细分析冲突原因,手动解决冲突,然后提交
- 问题:误操作导致代码丢失
- 解决方法使用git reflog和git reset找回丢失的提交
- 问题:分支管理混乱
- 解决方法:制定分支管理规范,定期清理无用分支
- **Git分支管理策略的优缺点**
- **主分支+功能分支策略**
- 优点:结构清晰,职责明确;便于功能隔离和并行开发
- 缺点:分支合并可能产生冲突;需要良好的分支管理
- **Git Flow策略**
- 优点:流程规范,适合大型项目;版本发布管理清晰
- 缺点:分支较多,管理复杂;学习成本较高
- **GitHub Flow策略**
- 优点:简单直观,适合快速迭代;易于理解和使用
- 缺点:缺乏长期分支支持;对版本发布管理不够完善
## 附录
### 附录A个人设计的EA模型图
需求图截图:![alt text](a44f4811949f78473cdfd54f84d10652-2.png)
用例图截图:![alt text](ff24d1800bda69b38e4095a575840421-1.png)
甘特图截图:![alt text](1f32761f9e61a0bd5e9f706eaec99ea0.png)
### 附录B个人测试用例表
| 测试用例ID | 测试功能 | 测试目的 | 输入数据 | 预期结果 | 测试步骤 | 优先级 |
|-----------|---------|---------|---------|---------|---------|--------|
| TC001 | 用户注册 | 验证学生注册功能的正确性 | 手机号13800138000<br>密码Aa123456<br>验证码123456 | 注册成功,自动登录并跳转至个人中心 | 1. 访问注册页面<br>2. 选择学生角色<br>3. 输入手机号、密码、验证码<br>4. 点击注册按钮<br>5. 验证跳转和登录状态 | 高 |
| TC002 | 任务发布 | 验证学生发布代取任务的功能 | 任务类型:快递<br>地点:南门快递点<br>报酬10元<br>描述取快递尾号1234 | 任务发布成功,显示在任务列表中 | 1. 登录学生账号<br>2. 进入任务发布页面<br>3. 填写任务信息<br>4. 点击发布按钮<br>5. 验证任务是否显示在列表中 | 高 |
| TC003 | 任务接受 | 验证代取员接受任务的功能 | 选择任务IDTASK001 | 任务状态变为已接受,显示在代取员进行中任务列表 | 1. 登录代取员账号<br>2. 浏览任务列表<br>3. 选择任务并点击接受<br>4. 确认接受<br>5. 验证任务状态 | 高 |
| TC004 | 消息发送 | 验证用户间消息发送功能 | 接收者user123<br>消息内容:您好,我是代取员 | 消息发送成功,显示在聊天记录中 | 1. 登录任一账号<br>2. 进入消息页面<br>3. 选择联系人<br>4. 输入消息内容<br>5. 点击发送<br>6. 验证消息显示 | 中 |
| TC005 | 权限控制 | 验证不同角色权限隔离 | 尝试以学生身份访问管理员功能 | 系统拒绝访问,显示权限不足提示 | 1. 登录学生账号<br>2. 尝试直接访问管理员URL<br>3. 验证系统响应 | 高 |
### 附录C个人工作日志
| 日期 | 工作内容 | 工作时长 | 完成情况 | 遇到的问题 | 解决方案 |
|------|---------|---------|---------|-----------|---------|
| 2025-11-06 | 需求分析与功能规划 | 3天 | 完成 | 需求理解不清晰 | 与项目经理和团队成员讨论,明确需求细节 |
| 2025-11-07 | EA模型设计 | 4天 | 完成 | 模型关系复杂 | 参考相关案例,逐步构建模型 |
| 2025-11-07 | 用户界面原型设计 | 4天 | 完成 | 界面风格不一致 | 制定统一的设计规范 |
| 2025-11-07 | 测试用例编写 | 4天 | 完成 | 测试场景覆盖不全 | 参考测试用例模板,逐步完善 |
| 2025-11-07| 文档撰写与总结 | 4天 | 完成 | 内容组织不合理 | 重新梳理文档结构,突出重点 |
---
**提交要求**
1. 请将本报告保存为Markdown格式文件命名为"实验一软件项目计划个人报告_姓名.md"
2. 在头歌平台的个人功能分支中提交报告文件
3. 提交Pull Request给组长审查
4. 截止日期2025年11月10日
**评分标准**
1. 个人任务完成情况30分
2. EA模型设计30分
3. 实验一相关问题思考20分
4. 工具使用体会10分
5. 个人学习计划10分

@ -0,0 +1,3 @@
# 默认忽略的文件
/shelf/
/workspace.xml

@ -0,0 +1,13 @@
<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
<component name="CompilerConfiguration">
<annotationProcessing>
<profile name="Maven default annotation processors profile" enabled="true">
<sourceOutputDir name="target/generated-sources/annotations" />
<sourceTestOutputDir name="target/generated-test-sources/test-annotations" />
<outputRelativeToContentRoot value="true" />
<module name="cstatm206004" />
</profile>
</annotationProcessing>
</component>
</project>

@ -0,0 +1,7 @@
<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
<component name="Encoding">
<file url="file://$PROJECT_DIR$/src/main/java" charset="UTF-8" />
<file url="file://$PROJECT_DIR$/src/main/resources" charset="UTF-8" />
</component>
</project>

@ -0,0 +1,20 @@
<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
<component name="RemoteRepositoriesConfiguration">
<remote-repository>
<option name="id" value="central" />
<option name="name" value="Central Repository" />
<option name="url" value="https://repo.maven.apache.org/maven2" />
</remote-repository>
<remote-repository>
<option name="id" value="central" />
<option name="name" value="Maven Central repository" />
<option name="url" value="https://repo1.maven.org/maven2" />
</remote-repository>
<remote-repository>
<option name="id" value="jboss.community" />
<option name="name" value="JBoss Community repository" />
<option name="url" value="https://repository.jboss.org/nexus/content/repositories/public/" />
</remote-repository>
</component>
</project>

@ -0,0 +1,12 @@
<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
<component name="ExternalStorageConfigurationManager" enabled="true" />
<component name="MavenProjectsManager">
<option name="originalFiles">
<list>
<option value="$PROJECT_DIR$/pom.xml" />
</list>
</option>
</component>
<component name="ProjectRootManager" version="2" languageLevel="JDK_25" default="true" project-jdk-name="openjdk-25" project-jdk-type="JavaSDK" />
</project>

@ -0,0 +1,6 @@
<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
<component name="VcsDirectoryMappings">
<mapping directory="$PROJECT_DIR$/.." vcs="Git" />
</component>
</project>

@ -0,0 +1,2 @@
# cstatm206004

@ -0,0 +1,68 @@
-- cstatm-mte 数据库SQL脚本
-- 适用于MySQL数据库
-- 1. 创建数据库(如果不存在)
CREATE DATABASE IF NOT EXISTS `cstatm-mte` CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;
-- 使用创建的数据库
USE `cstatm-mte`;
-- 2. 创建客户表 customer
CREATE TABLE `customer` (
`cid` VARCHAR(7) PRIMARY KEY, -- 客户ID7位数字
`cpin` VARCHAR(7) NOT NULL, -- 客户密码7位数字
`cname` VARCHAR(100) NOT NULL, -- 客户姓名
-- 添加7位数字约束
CHECK (`cid` REGEXP '^[0-9]{7}$'),
CHECK (`cpin` REGEXP '^[0-9]{7}$')
);
-- 3. 创建人员表 person根据之前创建的Person模型
CREATE TABLE `person` (
`pid` VARCHAR(7) PRIMARY KEY, -- 人员ID7位数字
`pname` VARCHAR(100) NOT NULL, -- 人员姓名
`page` VARCHAR(3), -- 人员年龄
`pphone` VARCHAR(20), -- 联系电话
-- 添加7位数字约束
CHECK (`pid` REGEXP '^[0-9]{7}$')
);
-- 6. 插入customer表的示例数据
INSERT INTO `customer` (`cid`, `cpin`, `cname`) VALUES
('1234567', '1234567', '张三'),
('2345678', '2345678', '李四'),
('3456789', '3456789', '王五'),
('4567890', '4567890', '赵六'),
('5678901', '5678901', '钱七');
-- 7. 插入person表的示例数据
INSERT INTO `person` (`pid`, `pname`, `page`, `pphone`) VALUES
('1000001', '管理员', '30', '13800138001'),
('1000002', '操作员A', '25', '13800138002'),
('1000003', '操作员B', '28', '13800138003'),
('1000004', '技术员', '35', '13800138004'),
('1000005', '客服人员', '22', '13800138005');
-- 8. 创建索引以提高查询性能
CREATE INDEX `idx_customer_cid` ON `customer`(`cid`);
CREATE INDEX `idx_person_pid` ON `person`(`pid`);
-- 9. 权限设置(可选)
-- 为root用户授予所有权限如果需要的话
-- GRANT ALL PRIVILEGES ON `cstatm-mte`.* TO 'root'@'localhost';
-- FLUSH PRIVILEGES;
-- 11. 显示创建的表信息
SELECT 'Tables created successfully:' AS message;
SELECT table_name FROM information_schema.tables WHERE table_schema = 'public';
-- 执行说明:
-- 1. 使用MySQL客户端连接到MySQL服务器用户名root密码root
-- 2. 直接执行此SQL脚本它会自动
-- a. 检查并创建数据库(如果不存在)
-- b. 切换到该数据库
-- c. 创建表结构和约束
-- d. 插入示例数据
-- e. 创建索引
-- 3. MySQL默认会自动提交语句不需要显式的COMMIT命令
-- 4. 确保MySQL服务正在运行端口为3306

@ -0,0 +1,117 @@
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<!-- 修改cstatm206004,可批量替换 -->
<!-- 1修改groupId:org.atm -->
<groupId>org.atm</groupId>
<!-- 修改cstatm206004 -->
<artifactId>cstatm206004</artifactId>
<version>0.0.1-SNAPSHOT</version>
<packaging>jar</packaging>
<!-- 修改cstatm206004 -->
<name>cstatm206004</name>
<description>期中考试 cstatm206004</description>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<project.report.outputEncoding>UTF-8</project.report.outputEncoding>
<maven.compiler.source>17</maven.compiler.source>
<maven.compiler.target>17</maven.compiler.target>
<maven.compiler.release>17</maven.compiler.release>
</properties>
<dependencies>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>8.0.30</version>
</dependency>
<dependency>
<groupId>org.hamcrest</groupId>
<artifactId>hamcrest-all</artifactId>
<version>1.3</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.13.1</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-surefire-plugin</artifactId>
<version>3.1.2</version>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.sonarsource.scanner.maven</groupId>
<artifactId>sonar-maven-plugin</artifactId>
<version>3.10.0.2594</version>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-assembly-plugin</artifactId>
<version>3.6.0</version>
<executions>
<execution>
<phase>package</phase>
<goals>
<goal>single</goal>
</goals>
<configuration>
<archive>
<manifest>
<!-- 2修改主类com.atm.view.gui.Gui -->
<mainClass>
org.atm.view.gui.Gui
</mainClass>
</manifest>
</archive>
<descriptorRefs>
<descriptorRef>jar-with-dependencies</descriptorRef>
</descriptorRefs>
</configuration>
</execution>
</executions>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-surefire-plugin</artifactId>
<version>3.1.2</version>
<configuration>
<skipTests>false</skipTests>
<argLine>${argLine} -Dfile.encoding=UTF-8</argLine>
</configuration>
</plugin>
<plugin>
<groupId>org.jacoco</groupId>
<artifactId>jacoco-maven-plugin</artifactId>
<version>0.8.11</version>
<configuration>
<skip>false</skip>
<destFile>target/coverage-reports/jacoco-unit.exec</destFile>
<dataFile>target/coverage-reports/jacoco-unit.exec</dataFile>
</configuration>
<executions>
<execution>
<id>jacoco-initialize</id>
<goals>
<goal>prepare-agent</goal>
</goals>
</execution>
<execution>
<id>jacoco-site</id>
<phase>test</phase>
<goals>
<goal>report</goal>
</goals>
</execution>
</executions>
</plugin>
</plugins>
</build>
</project>

@ -0,0 +1,46 @@
package org.atm.ctrl;
import org.atm.model.Person;
import org.atm.dao.PersonDAO;
import java.util.List;
public class PersonController {
private PersonDAO personDAO;
public PersonController() {
this.personDAO = new PersonDAO();
}
public boolean addPerson(Person person) {
if (Validate.is7RandNumeric(person.getPid()) && person.getPname() != null && !person.getPname().isEmpty()) {
return personDAO.addPerson(person);
}
return false;
}
public boolean updatePerson(Person person) {
if (Validate.is7RandNumeric(person.getPid())) {
return personDAO.updatePerson(person);
}
return false;
}
public boolean deletePerson(String pid) {
if (Validate.is7RandNumeric(pid)) {
return personDAO.deletePerson(pid);
}
return false;
}
public Person getPersonById(String pid) {
if (Validate.is7RandNumeric(pid)) {
return personDAO.getPersonById(pid);
}
return null;
}
public List<Person> getAllPersons() {
return personDAO.getAllPersons();
}
}

@ -0,0 +1,15 @@
package org.atm.ctrl;
public class Validate {
private static final int len = 7;
public static boolean is7RandNumeric(String str) {
boolean flag = str != null && str.matches("\\d{" + len + "}");
if (!flag) {
System.out.println(str + " must is " + len + " Numeric!");
return false;
} else
return true;
}
}// end Validate

@ -0,0 +1,80 @@
package org.atm.dao;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
public class DbUtil {
protected static PreparedStatement ps = null;
protected static ResultSet rs = null;
protected static Connection conn = null;
public static synchronized Connection getConn() {
try {
Class.forName("com.mysql.cj.jdbc.Driver");
conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/cstatm-mte?useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC", "root", "root");
} catch (Exception e) {
System.err.println("Load com.mysql.cj.jdbc.Driver FailedCheck MySQL JDBC jar is not Exist!");
return null;
}
return conn;
}
public static void close() {
try {
if (rs != null)
rs.close();
if (ps != null)
ps.close();
if (conn != null)
conn.close();
} catch (SQLException e) {
System.err.println("Close DB link Failed!");
return;
}
}
public static PreparedStatement executePreparedStatement(String sql) {
try {
ps = getConn().prepareStatement(sql);
} catch (Exception e) {
System.err.println("Create PreparedStatement Failed!");
return null;
}
return ps;
}
public static ResultSet executeQuery(String sql) {
try {
ps = executePreparedStatement(sql);
rs = ps.executeQuery();
} catch (SQLException e) {
System.err.println("Execute Query Failed!");
return null;
}
return rs;
}
public static void executeUpdate(String sql) {
try {
ps = executePreparedStatement(sql);
ps.executeUpdate();
} catch (SQLException e) {
System.err.println("Execute Update Failed!");
} finally {
try {
if (ps != null)
ps.close();
} catch (SQLException e) {
System.err.println("Close Resources Failed!");
return;
}
}
}
}// end DbUtil

@ -0,0 +1,34 @@
package org.atm.dao;
import java.sql.ResultSet;
import java.sql.SQLException;
import org.atm.model.Customer;
public class Login {
/**
*
* @param c
*/
public Customer login(Customer c) {
Customer returnCustomer = null;
try {
ResultSet rs = DbUtil.executeQuery(
"select * from customer where cid='" + c.getCid() + "' and cpin='" + c.getCpin() + "'");
if (rs!=null && rs.next()) {
returnCustomer = new Customer();
returnCustomer.setCid(rs.getString("cid"));
returnCustomer.setCpin(rs.getString("cpin"));
returnCustomer.setCname(rs.getString("cname"));
System.out.println("welcome," + rs.getString("cname"));
return returnCustomer;
}
} catch (SQLException e) {
System.err.println("Fetch ResultSet Failed!");
return returnCustomer;
}
System.out.println("No Customer!");
return returnCustomer;
}
}// end Login

@ -0,0 +1,85 @@
package org.atm.dao;
import org.atm.model.Person;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
public class PersonDAO {
public boolean addPerson(Person person) {
String sql = "INSERT INTO person (pid, pname, page, pphone) VALUES ('" +
person.getPid() + "', '" + person.getPname() + "', '" +
person.getPage() + "', '" + person.getPphone() + "')";
try {
DbUtil.executeUpdate(sql);
return true;
} catch (Exception e) {
System.err.println("Add Person Failed! " + e.getMessage());
return false;
}
}
public boolean updatePerson(Person person) {
String sql = "UPDATE person SET pname='" + person.getPname() +
"', page='" + person.getPage() +
"', pphone='" + person.getPphone() +
"' WHERE pid='" + person.getPid() + "'";
try {
DbUtil.executeUpdate(sql);
return true;
} catch (Exception e) {
System.err.println("Update Person Failed! " + e.getMessage());
return false;
}
}
public boolean deletePerson(String pid) {
String sql = "DELETE FROM person WHERE pid='" + pid + "'";
try {
DbUtil.executeUpdate(sql);
return true;
} catch (Exception e) {
System.err.println("Delete Person Failed! " + e.getMessage());
return false;
}
}
public Person getPersonById(String pid) {
String sql = "SELECT * FROM person WHERE pid='" + pid + "'";
try {
ResultSet rs = DbUtil.executeQuery(sql);
if (rs != null && rs.next()) {
Person person = new Person();
person.setPid(rs.getString("pid"));
person.setPname(rs.getString("pname"));
person.setPage(rs.getString("page"));
person.setPphone(rs.getString("pphone"));
return person;
}
} catch (SQLException e) {
System.err.println("Get Person Failed! " + e.getMessage());
}
return null;
}
public List<Person> getAllPersons() {
List<Person> persons = new ArrayList<>();
String sql = "SELECT * FROM person";
try {
ResultSet rs = DbUtil.executeQuery(sql);
while (rs != null && rs.next()) {
Person person = new Person();
person.setPid(rs.getString("pid"));
person.setPname(rs.getString("pname"));
person.setPage(rs.getString("page"));
person.setPphone(rs.getString("pphone"));
persons.add(person);
}
} catch (SQLException e) {
System.err.println("Get All Persons Failed! " + e.getMessage());
}
return persons;
}
}

@ -0,0 +1,77 @@
package org.atm.model;
public class Customer {
private String cid;
private String cname;
private String cpin;
public Customer() {
}
/**
*
* @param cid
* @param cpin
*/
public Customer(String cid, String cpin) {
this.cid = cid;
this.cpin = cpin;
this.cname = "";
}
/**
*
* @param cid
* @param cpin
* @param cname
*/
public Customer(String cid, String cpin, String cname) {
this.cid = cid;
this.cpin = cpin;
this.cname = cname;
}
/**
* @return String return the cid
*/
public String getCid() {
return cid;
}
/**
* @param cid the cid to set
*/
public void setCid(String cid) {
this.cid = cid;
}
/**
* @return String return the cname
*/
public String getCname() {
return cname;
}
/**
* @param cname the cname to set
*/
public void setCname(String cname) {
this.cname = cname;
}
/**
* @return String return the cpin
*/
public String getCpin() {
return cpin;
}
/**
* @param cpin the cpin to set
*/
public void setCpin(String cpin) {
this.cpin = cpin;
}
}

@ -0,0 +1,51 @@
package org.atm.model;
public class Person {
private String pid;
private String pname;
private String page;
private String pphone;
public Person() {
}
public Person(String pid, String pname, String page, String pphone) {
this.pid = pid;
this.pname = pname;
this.page = page;
this.pphone = pphone;
}
public String getPid() {
return pid;
}
public void setPid(String pid) {
this.pid = pid;
}
public String getPname() {
return pname;
}
public void setPname(String pname) {
this.pname = pname;
}
public String getPage() {
return page;
}
public void setPage(String page) {
this.page = page;
}
public String getPphone() {
return pphone;
}
public void setPphone(String pphone) {
this.pphone = pphone;
}
}

@ -0,0 +1,93 @@
package org.atm.view.gui;
import org.atm.model.Customer;
import org.atm.ctrl.Validate;
import org.atm.dao.Login;
import javax.swing.JOptionPane;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JTextField;
import javax.swing.JPasswordField;
import java.awt.Color;
import java.awt.Font;
import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
public class Gui extends JFrame {
private JButton jButtonLogin;
private JLabel jLabelCid;
private JLabel jLabelCpin;
private JPanel jPanel;
private JPanel jPanelBtn;
private JPanel jPanelCid;
private JPanel jPanelCpin;
private JTextField jTextFieldCid;
private JPasswordField jTextFieldCpin;
public Gui() {
this.setTitle("GUI ATM MTE From EA For CS231");
this.setSize(300, 200);
this.setLocationRelativeTo(null);
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
this.setResizable(false);
jPanel = new JPanel(new GridLayout(3, 1));
jPanelCid = new JPanel();
jLabelCid = new JLabel("CID");
jLabelCid.setForeground(Color.RED);
jLabelCid.setFont(new Font("", Font.BOLD, 15));
jTextFieldCid = new JTextField(15);
jPanelCid.add(jLabelCid);
jPanelCid.add(jTextFieldCid);
jPanelCpin = new JPanel();
jLabelCpin = new JLabel("CPIN");
jLabelCpin.setForeground(Color.RED);
jLabelCpin.setFont(new Font("", Font.BOLD, 15));
jTextFieldCpin = new JPasswordField(15);
jPanelCpin.add(jLabelCpin);
jPanelCpin.add(jTextFieldCpin);
jPanelBtn = new JPanel();
jButtonLogin = new JButton("LOGIN");
jPanelBtn.add(jButtonLogin);
jPanel.add(jPanelCid);
jPanel.add(jPanelCpin);
jPanel.add(jPanelBtn);
this.add(jPanel);
this.setVisible(true);
jButtonLogin.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
String cid = new String(jTextFieldCid.getText());
if (cid.length() <= 0) {
JOptionPane.showMessageDialog(null, "CID NULL");
System.out.println("CID NULL");
} else {
String cpin = new String(jTextFieldCpin.getPassword());
Customer inputCustomer = new Customer(cid, cpin);
Customer returnCustomer = null;
if (Validate.is7RandNumeric(cid) && Validate.is7RandNumeric(cpin))
returnCustomer = new Login().login(inputCustomer);
if (returnCustomer != null) {
JOptionPane.showMessageDialog(null, "LOGIN SUCCEEDED!", "PROMPT",
JOptionPane.INFORMATION_MESSAGE);
} else {
JOptionPane.showMessageDialog(null, "ID OR PIN ERROR!", "PROMPT",
JOptionPane.INFORMATION_MESSAGE);
}
}
}
});
}
public static void main(String[] args) {
new Gui();
}
}// end Gui

@ -0,0 +1,252 @@
package org.atm.view.gui;
import org.atm.model.Person;
import org.atm.ctrl.PersonController;
import org.atm.ctrl.Validate;
import javax.swing.*;
import javax.swing.table.DefaultTableModel;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.List;
public class PersonGui extends JFrame {
private JButton btnAdd, btnUpdate, btnDelete, btnViewAll, btnClear;
private JTextField txtPid, txtPname, txtPage, txtPphone;
private JLabel lblPid, lblPname, lblPage, lblPphone;
private JTable tablePersons;
private DefaultTableModel tableModel;
private JScrollPane scrollPane;
private PersonController personController;
public PersonGui() {
personController = new PersonController();
initializeComponents();
setupLayout();
setupEventListeners();
setTitle("人员管理系统");
setSize(800, 600);
setLocationRelativeTo(null);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setResizable(true);
setVisible(true);
}
private void initializeComponents() {
// 创建标签
lblPid = new JLabel("人员ID");
lblPid.setForeground(Color.RED);
lblPid.setFont(new Font("", Font.BOLD, 14));
lblPname = new JLabel("人员姓名");
lblPname.setForeground(Color.RED);
lblPname.setFont(new Font("", Font.BOLD, 14));
lblPage = new JLabel("人员年龄");
lblPage.setForeground(Color.RED);
lblPage.setFont(new Font("", Font.BOLD, 14));
lblPphone = new JLabel("联系电话");
lblPphone.setForeground(Color.RED);
lblPphone.setFont(new Font("", Font.BOLD, 14));
// 创建文本框
txtPid = new JTextField(15);
txtPname = new JTextField(15);
txtPage = new JTextField(15);
txtPphone = new JTextField(15);
// 创建按钮
btnAdd = new JButton("添加");
btnUpdate = new JButton("更新");
btnDelete = new JButton("删除");
btnViewAll = new JButton("查看全部");
btnClear = new JButton("清空");
// 创建表格
String[] columnNames = {"人员ID", "人员姓名", "人员年龄", "联系电话"};
tableModel = new DefaultTableModel(columnNames, 0);
tablePersons = new JTable(tableModel);
tablePersons.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
scrollPane = new JScrollPane(tablePersons);
}
private void setupLayout() {
// 创建主面板
JPanel mainPanel = new JPanel(new BorderLayout());
// 创建表单面板
JPanel formPanel = new JPanel(new GridLayout(5, 2, 10, 10));
formPanel.setBorder(BorderFactory.createEmptyBorder(20, 20, 20, 20));
formPanel.add(lblPid);
formPanel.add(txtPid);
formPanel.add(lblPname);
formPanel.add(txtPname);
formPanel.add(lblPage);
formPanel.add(txtPage);
formPanel.add(lblPphone);
formPanel.add(txtPphone);
formPanel.add(new JLabel()); // 空白标签用于对齐
// 创建按钮面板
JPanel buttonPanel = new JPanel(new FlowLayout(FlowLayout.CENTER, 10, 10));
buttonPanel.add(btnAdd);
buttonPanel.add(btnUpdate);
buttonPanel.add(btnDelete);
buttonPanel.add(btnViewAll);
buttonPanel.add(btnClear);
formPanel.add(buttonPanel);
// 添加组件到主面板
mainPanel.add(formPanel, BorderLayout.NORTH);
mainPanel.add(scrollPane, BorderLayout.CENTER);
// 添加主面板到框架
add(mainPanel);
}
private void setupEventListeners() {
btnAdd.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
addPerson();
}
});
btnUpdate.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
updatePerson();
}
});
btnDelete.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
deletePerson();
}
});
btnViewAll.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
viewAllPersons();
}
});
btnClear.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
clearFields();
}
});
tablePersons.getSelectionModel().addListSelectionListener(e -> {
if (!e.getValueIsAdjusting() && tablePersons.getSelectedRow() != -1) {
fillFieldsFromTable();
}
});
}
private void addPerson() {
String pid = txtPid.getText();
String pname = txtPname.getText();
String page = txtPage.getText();
String pphone = txtPphone.getText();
if (pid.isEmpty() || pname.isEmpty()) {
JOptionPane.showMessageDialog(this, "人员ID和姓名不能为空", "提示", JOptionPane.WARNING_MESSAGE);
return;
}
if (!Validate.is7RandNumeric(pid)) {
JOptionPane.showMessageDialog(this, "人员ID必须是7位数字", "提示", JOptionPane.WARNING_MESSAGE);
return;
}
Person person = new Person(pid, pname, page, pphone);
if (personController.addPerson(person)) {
JOptionPane.showMessageDialog(this, "添加成功!", "提示", JOptionPane.INFORMATION_MESSAGE);
clearFields();
viewAllPersons();
} else {
JOptionPane.showMessageDialog(this, "添加失败!", "提示", JOptionPane.ERROR_MESSAGE);
}
}
private void updatePerson() {
String pid = txtPid.getText();
String pname = txtPname.getText();
String page = txtPage.getText();
String pphone = txtPphone.getText();
if (pid.isEmpty()) {
JOptionPane.showMessageDialog(this, "请输入人员ID", "提示", JOptionPane.WARNING_MESSAGE);
return;
}
Person person = new Person(pid, pname, page, pphone);
if (personController.updatePerson(person)) {
JOptionPane.showMessageDialog(this, "更新成功!", "提示", JOptionPane.INFORMATION_MESSAGE);
clearFields();
viewAllPersons();
} else {
JOptionPane.showMessageDialog(this, "更新失败!", "提示", JOptionPane.ERROR_MESSAGE);
}
}
private void deletePerson() {
String pid = txtPid.getText();
if (pid.isEmpty()) {
JOptionPane.showMessageDialog(this, "请输入人员ID", "提示", JOptionPane.WARNING_MESSAGE);
return;
}
int confirm = JOptionPane.showConfirmDialog(this, "确定要删除该人员吗?", "确认", JOptionPane.YES_NO_OPTION);
if (confirm == JOptionPane.YES_OPTION) {
if (personController.deletePerson(pid)) {
JOptionPane.showMessageDialog(this, "删除成功!", "提示", JOptionPane.INFORMATION_MESSAGE);
clearFields();
viewAllPersons();
} else {
JOptionPane.showMessageDialog(this, "删除失败!", "提示", JOptionPane.ERROR_MESSAGE);
}
}
}
private void viewAllPersons() {
tableModel.setRowCount(0); // 清空表格
List<Person> persons = personController.getAllPersons();
for (Person person : persons) {
Object[] row = {person.getPid(), person.getPname(), person.getPage(), person.getPphone()};
tableModel.addRow(row);
}
}
private void clearFields() {
txtPid.setText("");
txtPname.setText("");
txtPage.setText("");
txtPphone.setText("");
tablePersons.clearSelection();
}
private void fillFieldsFromTable() {
int selectedRow = tablePersons.getSelectedRow();
if (selectedRow != -1) {
txtPid.setText(tableModel.getValueAt(selectedRow, 0).toString());
txtPname.setText(tableModel.getValueAt(selectedRow, 1).toString());
txtPage.setText(tableModel.getValueAt(selectedRow, 2).toString());
txtPphone.setText(tableModel.getValueAt(selectedRow, 3).toString());
}
}
public static void main(String[] args) {
SwingUtilities.invokeLater(() -> new PersonGui());
}
}

@ -0,0 +1,58 @@
package org.atm.ctrl;
import org.junit.Assert;
import org.atm.ctrl.Validate;
public class ValidateTest extends junit.framework.TestCase {
/**
*
* @param arg0
*/
public ValidateTest(String arg0) {
super(arg0);
}
/**
*
* @param args
*/
public static void main(String[] args) {
}
/**
*
* @exception Exception
*/
protected void setUp()
throws Exception {
super.setUp();
}
/**
*
* @exception Exception
*/
protected void tearDown()
throws Exception {
super.tearDown();
}
public final void testIsNumeric_01_7() {
Assert.assertTrue(Validate.is7RandNumeric("2060041"));
}
public final void testIsNumeric_02_d() {
Assert.assertFalse(Validate.is7RandNumeric("123456d"));
}
public final void testIsNumeric_03_8() {
Assert.assertFalse(Validate.is7RandNumeric("12345678"));
}
public final void testIsNumeric_04_null() {
Assert.assertFalse(Validate.is7RandNumeric(""));
}
public final void testIsNumeric_05_6() {
Assert.assertFalse(Validate.is7RandNumeric("123456"));
}
}// end ValidateTest

@ -0,0 +1,16 @@
package org.atm.dao;
import org.junit.runners.Suite;
import org.junit.runner.RunWith;
import junit.framework.TestSuite;
import junit.framework.Test;
@RunWith(Suite.class)
@Suite.SuiteClasses({org.atm.ctrl.ValidateTest.class, org.atm.dao.LoginTest.class})
public class LoginIntegratedTest {
public static Test suit() {
TestSuite suite = new TestSuite();
return suite;
}
}// end LoginITest

@ -0,0 +1,15 @@
package org.atm.dao;
import org.junit.Assert;
import org.atm.dao.Login;
import org.atm.model.Customer;
public class LoginTest extends junit.framework.TestCase {
public final void testLogin_01() {
Assert.assertNotNull(new Login().login(new Customer("2060041", "2060041")));
}
public final void testLogin_02() {
Assert.assertNull(new Login().login(new Customer("1234578", "1234589")));
}
}

@ -0,0 +1,96 @@
package org.atm.dao;
import org.atm.model.Person;
import org.atm.ctrl.PersonController;
import org.junit.Test;
import static org.junit.Assert.*;
import java.util.List;
public class PersonTest {
private PersonController personController = new PersonController();
@Test
public void testAddPerson() {
// 创建测试人员
Person person = new Person("1234567", "测试人员", "30", "13800138000");
boolean result = personController.addPerson(person);
System.out.println("添加人员测试结果: " + (result ? "成功" : "失败"));
// 验证添加是否成功
Person addedPerson = personController.getPersonById("1234567");
assertNotNull("添加的人员应该存在", addedPerson);
assertEquals("人员姓名应该匹配", "测试人员", addedPerson.getPname());
}
@Test
public void testGetPersonById() {
// 先添加一个测试人员
Person person = new Person("2345678", "测试查询", "25", "13900139000");
personController.addPerson(person);
// 测试查询
Person retrievedPerson = personController.getPersonById("2345678");
assertNotNull("通过ID查询的人员应该存在", retrievedPerson);
assertEquals("人员ID应该匹配", "2345678", retrievedPerson.getPid());
}
@Test
public void testUpdatePerson() {
// 先添加一个测试人员
Person person = new Person("3456789", "测试更新", "35", "13700137000");
personController.addPerson(person);
// 更新人员信息
person.setPname("已更新人员");
person.setPage("36");
boolean result = personController.updatePerson(person);
System.out.println("更新人员测试结果: " + (result ? "成功" : "失败"));
// 验证更新是否成功
Person updatedPerson = personController.getPersonById("3456789");
assertEquals("人员姓名应该已更新", "已更新人员", updatedPerson.getPname());
assertEquals("人员年龄应该已更新", "36", updatedPerson.getPage());
}
@Test
public void testDeletePerson() {
// 先添加一个测试人员
Person person = new Person("4567890", "测试删除", "40", "13600136000");
personController.addPerson(person);
// 删除人员
boolean result = personController.deletePerson("4567890");
System.out.println("删除人员测试结果: " + (result ? "成功" : "失败"));
// 验证删除是否成功
Person deletedPerson = personController.getPersonById("4567890");
assertNull("删除的人员应该不存在", deletedPerson);
}
@Test
public void testGetAllPersons() {
// 确保有一些测试数据
personController.addPerson(new Person("5678901", "人员1", "28", "13500135001"));
personController.addPerson(new Person("6789012", "人员2", "32", "13500135002"));
// 获取所有人员
List<Person> persons = personController.getAllPersons();
assertNotNull("人员列表不应该为空", persons);
System.out.println("获取到的人员数量: " + persons.size());
assertTrue("人员列表应该至少包含2个人员", persons.size() >= 2);
}
@Test
public void testValidation() {
// 测试无效的ID
Person invalidPerson = new Person("123", "无效ID", "25", "13800138000");
boolean result = personController.addPerson(invalidPerson);
assertFalse("无效ID的人员不应添加成功", result);
// 测试空姓名
Person emptyNamePerson = new Person("7890123", "", "25", "13800138000");
result = personController.addPerson(emptyNamePerson);
assertFalse("空姓名的人员不应添加成功", result);
}
}

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff

@ -0,0 +1 @@
EAConnectString:D:\CS231_SEB09\CHZU_CS231_SEBG09\实验一软件项目计划个人报告作.qea

@ -0,0 +1,242 @@
# 校园代取系统 - 人员交互功能说明文档
## 1. 功能概述
人员交互功能是校园代取系统的核心功能之一,负责处理用户之间的交流、消息传递和评价管理。该功能由董文远负责开发。
## 2. 系统架构
系统采用分层架构设计,包括以下层次:
- **模型层 (Model)**: 定义了用户、消息和评价的实体类
- **数据访问层 (DAO)**: 负责与数据库交互,实现数据的持久化
- **服务层 (Service)**: 实现业务逻辑,处理各种业务规则
- **控制层 (Controller)**: 处理用户请求,协调各层之间的交互
- **视图层 (View)**: 提供用户界面,处理用户输入和输出
## 3. 目录结构
```
校园代取系统/
├── src/
│ ├── main/
│ │ └── java/
│ │ └── com/
│ │ └── campus/
│ │ └── pickup/
│ │ ├── model/ # 模型层
│ │ │ ├── User.java
│ │ │ ├── Message.java
│ │ │ └── Review.java
│ │ ├── dao/ # 数据访问层
│ │ │ ├── UserDao.java
│ │ │ ├── MessageDao.java
│ │ │ └── ReviewDao.java
│ │ ├── service/ # 服务层
│ │ │ ├── UserService.java
│ │ │ ├── MessageService.java
│ │ │ └── ReviewService.java
│ │ ├── controller/ # 控制层
│ │ │ ├── UserController.java
│ │ │ ├── MessageController.java
│ │ │ └── ReviewController.java
│ │ ├── view/ # 视图层
│ │ │ ├── UserView.java
│ │ │ ├── MessageView.java
│ │ │ ├── ReviewView.java
│ │ │ └── MainView.java
│ │ └── util/ # 工具类
│ │ └── DatabaseUtil.java
│ └── test/
│ └── java/
│ └── com/
│ └── campus/
│ └── pickup/
│ ├── model/ # 模型层测试
│ ├── service/ # 服务层测试
│ └── PersonnelInteractionTestSuite.java # 测试套件
├── lib/ # 依赖库
├── bin/ # 编译输出目录
├── run.bat # 运行脚本
└── test.bat # 测试脚本
```
## 4. 功能模块
### 4.1 用户管理
- **用户注册**: 新用户可以创建账户
- **用户登录**: 已注册用户可以登录系统
- **个人信息管理**: 用户可以查看和更新个人信息
- **密码修改**: 用户可以修改登录密码
### 4.2 消息管理
- **发送消息**: 用户之间可以发送消息
- **查看消息**: 用户可以查看收到的消息
- **消息状态管理**: 支持已读/未读状态标记
- **系统通知**: 系统可以向用户发送通知
### 4.3 评价管理
- **添加评价**: 用户可以对服务进行评价
- **查看评价**: 用户可以查看收到的评价
- **评价统计**: 系统可以计算用户的平均评分
- **评价更新**: 用户可以修改自己的评价
## 5. 数据库设计
### 5.1 用户表 (users)
| 字段名 | 类型 | 说明 |
|--------|------|------|
| user_id | VARCHAR(32) | 用户ID主键 |
| username | VARCHAR(50) | 用户名,唯一 |
| password | VARCHAR(50) | 密码 |
| real_name | VARCHAR(50) | 真实姓名 |
| phone | VARCHAR(20) | 手机号 |
| email | VARCHAR(100) | 邮箱 |
| student_id | VARCHAR(20) | 学号 |
| dormitory | VARCHAR(100) | 宿舍地址 |
| create_time | TIMESTAMP | 创建时间 |
| update_time | TIMESTAMP | 更新时间 |
| status | INT | 状态0-正常1-禁用 |
### 5.2 消息表 (messages)
| 字段名 | 类型 | 说明 |
|--------|------|------|
| message_id | VARCHAR(32) | 消息ID主键 |
| sender_id | VARCHAR(32) | 发送者ID |
| receiver_id | VARCHAR(32) | 接收者ID |
| content | TEXT | 消息内容 |
| send_time | TIMESTAMP | 发送时间 |
| read_time | TIMESTAMP | 阅读时间 |
| status | INT | 状态0-未读1-已读2-已删除 |
| type | INT | 消息类型0-系统通知1-用户消息2-订单消息3-评价消息 |
### 5.3 评价表 (reviews)
| 字段名 | 类型 | 说明 |
|--------|------|------|
| review_id | VARCHAR(32) | 评价ID主键 |
| order_id | VARCHAR(32) | 订单ID |
| reviewer_id | VARCHAR(32) | 评价人ID |
| reviewed_id | VARCHAR(32) | 被评价人ID |
| rating | INT | 评分1-5星 |
| content | TEXT | 评价内容 |
| create_time | TIMESTAMP | 创建时间 |
| update_time | TIMESTAMP | 更新时间 |
| status | INT | 状态0-正常1-已删除 |
## 6. 环境要求
- **JDK**: Java 8 或更高版本
- **数据库**: PostgreSQL
- **测试框架**: JUnit 5
- **构建工具**: 无需Maven/Gradle使用javac编译
## 7. 运行说明
### 7.1 准备工作
1. 确保已安装Java 8或更高版本
2. 安装PostgreSQL数据库
3. 创建数据库并执行SQL脚本创建表结构
4. 修改`DatabaseUtil.java`中的数据库连接信息
### 7.2 运行应用程序
1. 双击运行`run.bat`脚本
2. 或在命令行中执行以下命令:
```
javac -d bin -cp "lib/*" src/main/java/com/campus/pickup/**/*.java
java -cp "bin;lib/*" com.campus.pickup.view.MainView
```
### 7.3 运行单元测试
1. 双击运行`test.bat`脚本
2. 或在命令行中执行以下命令:
```
javac -d bin -cp "lib/*;junit-platform-console-standalone-1.7.0.jar" src/main/java/com/campus/pickup/**/*.java src/test/java/com/campus/pickup/**/*.java
java -jar junit-platform-console-standalone-1.7.0.jar --class-path "bin" --scan-class-path
```
## 8. 使用说明
### 8.1 用户注册
1. 启动应用程序
2. 选择"用户注册"
3. 按照提示输入用户信息
4. 注册成功后系统会分配一个用户ID
### 8.2 用户登录
1. 在主菜单选择"用户登录"
2. 输入用户名和密码
3. 登录成功后进入用户主菜单
### 8.3 发送消息
1. 登录后选择"消息管理"
2. 选择"发送消息"
3. 输入接收者ID和消息内容
4. 选择消息类型并发送
### 8.4 添加评价
1. 登录后选择"评价管理"
2. 选择"添加评价"
3. 输入订单ID、被评价人ID、评分和评价内容
4. 提交评价
## 9. 开发说明
### 9.1 代码规范
- 遵循Java命名规范
- 使用Javadoc注释
- 每个方法都有适当的异常处理
- 数据库操作使用PreparedStatement防止SQL注入
### 9.2 测试覆盖
- 实体类测试测试getter/setter方法和toString方法
- 服务层测试使用Mockito模拟DAO层测试业务逻辑
- 测试覆盖率达到80%以上
### 9.3 扩展性
- 采用分层架构,便于功能扩展
- 使用接口编程,降低耦合度
- 数据库操作封装在DAO层便于更换数据库
## 10. 常见问题
### 10.1 数据库连接失败
- 检查PostgreSQL服务是否启动
- 检查`DatabaseUtil.java`中的连接信息是否正确
- 确保数据库用户有足够的权限
### 10.2 编译错误
- 确保JDK版本正确
- 检查依赖库是否完整
- 确保源代码路径正确
### 10.3 测试失败
- 检查JUnit库是否正确配置
- 确保测试类路径正确
- 检查Mockito库是否正确配置
## 11. 版本历史
- v1.0 (2023-12-21): 初始版本,实现基本的人员交互功能
## 12. 联系方式
如有问题或建议,请联系开发人员董文远。

@ -0,0 +1,146 @@
-- 校园代取系统数据库初始化脚本
-- 人员交互功能相关表结构
-- 创建数据库(如果不存在)
-- CREATE DATABASE campus_pickup;
-- \c campus_pickup;
-- 创建用户表
CREATE TABLE IF NOT EXISTS users (
user_id VARCHAR(32) PRIMARY KEY,
username VARCHAR(50) NOT NULL UNIQUE,
password VARCHAR(50) NOT NULL,
real_name VARCHAR(50),
phone VARCHAR(20),
email VARCHAR(100),
student_id VARCHAR(20),
dormitory VARCHAR(100),
create_time TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
update_time TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
status INT DEFAULT 0 CHECK (status IN (0, 1)) -- 0-正常1-禁用
);
-- 创建消息表
CREATE TABLE IF NOT EXISTS messages (
message_id VARCHAR(32) PRIMARY KEY,
sender_id VARCHAR(32) NOT NULL,
receiver_id VARCHAR(32) NOT NULL,
content TEXT NOT NULL,
send_time TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
read_time TIMESTAMP,
status INT DEFAULT 0 CHECK (status IN (0, 1, 2)), -- 0-未读1-已读2-已删除
type INT DEFAULT 1 CHECK (type IN (0, 1, 2, 3)), -- 0-系统通知1-用户消息2-订单消息3-评价消息
FOREIGN KEY (sender_id) REFERENCES users(user_id),
FOREIGN KEY (receiver_id) REFERENCES users(user_id)
);
-- 创建评价表
CREATE TABLE IF NOT EXISTS reviews (
review_id VARCHAR(32) PRIMARY KEY,
order_id VARCHAR(32) NOT NULL,
reviewer_id VARCHAR(32) NOT NULL,
reviewed_id VARCHAR(32) NOT NULL,
rating INT NOT NULL CHECK (rating BETWEEN 1 AND 5), -- 1-5星评分
content TEXT,
create_time TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
update_time TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
status INT DEFAULT 0 CHECK (status IN (0, 1)), -- 0-正常1-已删除
FOREIGN KEY (reviewer_id) REFERENCES users(user_id),
FOREIGN KEY (reviewed_id) REFERENCES users(user_id),
UNIQUE (order_id) -- 每个订单只能有一个评价
);
-- 创建订单表
CREATE TABLE IF NOT EXISTS orders (
order_id VARCHAR(32) PRIMARY KEY,
order_number VARCHAR(50) NOT NULL UNIQUE,
customer_id VARCHAR(32) NOT NULL,
delivery_person_id VARCHAR(32),
item_type VARCHAR(50) NOT NULL,
description TEXT NOT NULL,
pickup_location VARCHAR(200) NOT NULL,
delivery_location VARCHAR(200) NOT NULL,
fee DECIMAL(10,2) DEFAULT 0.00,
pickup_time TIMESTAMP,
delivery_time TIMESTAMP,
create_time TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
update_time TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
status INT DEFAULT 0 CHECK (status IN (0, 1, 2, 3, 4, 5)), -- 0-待接单1-已接单2-已取件3-配送中4-已完成5-已取消
remarks TEXT,
FOREIGN KEY (customer_id) REFERENCES users(user_id),
FOREIGN KEY (delivery_person_id) REFERENCES users(user_id)
);
-- 创建索引以提高查询性能
CREATE INDEX IF NOT EXISTS idx_users_username ON users(username);
CREATE INDEX IF NOT EXISTS idx_messages_sender_id ON messages(sender_id);
CREATE INDEX IF NOT EXISTS idx_messages_receiver_id ON messages(receiver_id);
CREATE INDEX IF NOT EXISTS idx_reviews_reviewer_id ON reviews(reviewer_id);
CREATE INDEX IF NOT EXISTS idx_reviews_reviewed_id ON reviews(reviewed_id);
CREATE INDEX IF NOT EXISTS idx_reviews_order_id ON reviews(order_id);
CREATE INDEX IF NOT EXISTS idx_orders_customer_id ON orders(customer_id);
CREATE INDEX IF NOT EXISTS idx_orders_delivery_person_id ON orders(delivery_person_id);
CREATE INDEX IF NOT EXISTS idx_orders_status ON orders(status);
CREATE INDEX IF NOT EXISTS idx_orders_create_time ON orders(create_time);
-- 插入示例数据
-- 插入示例用户
INSERT INTO users (user_id, username, password, real_name, phone, email, student_id, dormitory) VALUES
('user001', 'zhangsan', '123456', '张三', '13800138001', 'zhangsan@example.com', '20210001', '东区1号楼101'),
('user002', 'lisi', '123456', '李四', '13800138002', 'lisi@example.com', '20210002', '东区1号楼102'),
('user003', 'wangwu', '123456', '王五', '13800138003', 'wangwu@example.com', '20210003', '东区1号楼103');
-- 插入示例消息
INSERT INTO messages (message_id, sender_id, receiver_id, content, type) VALUES
('msg001', 'user001', 'user002', '你好,可以帮我代取快递吗?', 1),
('msg002', 'user002', 'user001', '可以的,什么时候方便?', 1),
('msg003', 'system', 'user001', '您的订单已创建', 0);
-- 插入示例评价
INSERT INTO reviews (review_id, order_id, reviewer_id, reviewed_id, rating, content) VALUES
('review001', 'order001', 'user001', 'user002', 5, '服务很好,非常满意!'),
('review002', 'order002', 'user002', 'user003', 4, '服务不错,下次还会找你');
-- 插入示例订单
INSERT INTO orders (order_id, order_number, customer_id, delivery_person_id, item_type, description, pickup_location, delivery_location, fee, pickup_time, status, remarks) VALUES
('order001', 'ORD20231201001', 'user001', 'user002', '快递', '包含书籍和衣物,中等大小包裹', '北区快递中心', '东区1号楼101', 5.00, '2023-12-01 14:00:00', 4, '已送达,客户满意'),
('order002', 'ORD20231201002', 'user002', 'user003', '外卖', '麻辣烫套餐,请注意保温', '南区美食广场', '西区2号楼205', 3.50, '2023-12-01 18:30:00', 4, '已送达,食物完好'),
('order003', 'ORD20231202001', 'user003', NULL, '文件', '重要文件,请小心保管', '行政楼A座', '图书馆三楼', 2.00, '2023-12-02 10:00:00', 0, '待接单'),
('order004', 'ORD20231202002', 'user001', 'user003', '快递', '大件物品,需要两人搬运', '东区快递站', '北区体育馆', 15.00, '2023-12-02 15:00:00', 2, '已取件,正在配送中');
-- 创建更新时间触发器函数
CREATE OR REPLACE FUNCTION update_modified_column()
RETURNS TRIGGER AS $$
BEGIN
NEW.update_time = CURRENT_TIMESTAMP;
RETURN NEW;
END;
$$ language 'plpgsql';
-- 为users表创建更新时间触发器
CREATE TRIGGER update_users_modtime
BEFORE UPDATE ON users
FOR EACH ROW EXECUTE FUNCTION update_modified_column();
-- 为reviews表创建更新时间触发器
CREATE TRIGGER update_reviews_modtime
BEFORE UPDATE ON reviews
FOR EACH ROW EXECUTE FUNCTION update_modified_column();
-- 为orders表创建更新时间触发器
CREATE TRIGGER update_orders_modtime
BEFORE UPDATE ON orders
FOR EACH ROW EXECUTE FUNCTION update_modified_column();
-- 查询示例数据
SELECT 'Users表示例数据' as info;
SELECT * FROM users LIMIT 3;
SELECT 'Messages表示例数据' as info;
SELECT * FROM messages LIMIT 3;
SELECT 'Reviews表示例数据' as info;
SELECT * FROM reviews LIMIT 3;
SELECT 'Orders表示例数据' as info;
SELECT * FROM orders LIMIT 3;

@ -0,0 +1,21 @@
@echo off
echo ========================================
echo 校园代取系统 - 人员交互功能
echo ========================================
echo.
echo 正在编译Java源文件...
javac -d bin -cp "lib/*" src/main/java/com/campus/pickup/**/*.java
if %ERRORLEVEL% NEQ 0 (
echo 编译失败,请检查代码!
pause
exit /b 1
)
echo 编译成功!
echo.
echo 正在运行校园代取系统...
java -cp "bin;lib/*" com.campus.pickup.view.MainView
pause

@ -0,0 +1,69 @@
package com.campus.pickup.controller;
import com.campus.pickup.model.User;
import com.campus.pickup.model.Message;
import com.campus.pickup.model.Review;
import com.campus.pickup.service.UserService;
import com.campus.pickup.service.MessageService;
import com.campus.pickup.service.ReviewService;
import java.util.List;
/**
*
*/
public class ControllerMainCode {
// ========== 用户控制器核心功能 ==========
public boolean register(String username, String password, String realName, String phone, String email, String studentId, String dormitory) {
User user = new User();
user.setUserId(java.util.UUID.randomUUID().toString().replace("-", ""));
user.setUsername(username);
user.setPassword(password);
user.setRealName(realName);
user.setPhone(phone);
user.setEmail(email);
user.setStudentId(studentId);
user.setDormitory(dormitory);
return new UserService().register(user);
}
public User login(String username, String password) {
return new UserService().login(username, password);
}
public User getUserInfo(String userId) {
return new UserService().getUserById(userId);
}
// ========== 消息控制器核心功能 ==========
public boolean sendMessage(String senderId, String receiverId, String content, int typeCode) {
Message.MessageType type = Message.MessageType.fromCode(typeCode);
return new MessageService().sendMessage(senderId, receiverId, content, type);
}
public List<Message> getReceivedMessages(String receiverId) {
return new MessageService().getReceivedMessages(receiverId);
}
public int getUnreadMessageCount(String receiverId) {
return new MessageService().getUnreadMessageCount(receiverId);
}
// ========== 评价控制器核心功能 ==========
public boolean addReview(String orderId, String reviewerId, String reviewedId, int rating, String content) {
return new ReviewService().addReview(orderId, reviewerId, reviewedId, rating, content);
}
public List<Review> getReviewsReceivedByUser(String userId) {
return new ReviewService().getReviewsReceivedByUser(userId);
}
public double getAverageRatingForUser(String userId) {
return new ReviewService().getAverageRatingForUser(userId);
}
}

@ -0,0 +1,285 @@
package com.campus.pickup.controller;
import com.campus.pickup.model.Message;
import com.campus.pickup.service.MessageService;
import com.campus.pickup.util.DatabaseUtil;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
*
*
*/
public class MessageController {
private MessageService messageService;
/**
*
*/
public MessageController() {
this.messageService = new MessageService();
}
/**
*
* @param senderId ID
* @param receiverId ID
* @param content
* @param typeCode
* @return
*/
public Map<String, Object> sendMessage(String senderId, String receiverId, String content, int typeCode) {
Map<String, Object> result = new HashMap<>();
try {
// 检查输入参数
if (senderId == null || senderId.isEmpty() || receiverId == null ||
receiverId.isEmpty() || content == null || content.isEmpty()) {
result.put("success", false);
result.put("message", "发送者ID、接收者ID和消息内容不能为空");
return result;
}
// 获取消息类型
Message.MessageType type = Message.MessageType.fromCode(typeCode);
if (type == null) {
result.put("success", false);
result.put("message", "无效的消息类型");
return result;
}
// 调用服务层发送消息
boolean success = messageService.sendMessage(senderId, receiverId, content, type);
if (success) {
result.put("success", true);
result.put("message", "消息发送成功");
} else {
result.put("success", false);
result.put("message", "消息发送失败");
}
} catch (Exception e) {
result.put("success", false);
result.put("message", "发送消息过程中发生异常: " + e.getMessage());
}
return result;
}
/**
*
* @param receiverId ID
* @param content
* @return
*/
public Map<String, Object> sendSystemNotification(String receiverId, String content) {
Map<String, Object> result = new HashMap<>();
try {
// 检查输入参数
if (receiverId == null || receiverId.isEmpty() || content == null || content.isEmpty()) {
result.put("success", false);
result.put("message", "接收者ID和通知内容不能为空");
return result;
}
// 调用服务层发送系统通知
boolean success = messageService.sendSystemNotification(receiverId, content);
if (success) {
result.put("success", true);
result.put("message", "系统通知发送成功");
} else {
result.put("success", false);
result.put("message", "系统通知发送失败");
}
} catch (Exception e) {
result.put("success", false);
result.put("message", "发送系统通知过程中发生异常: " + e.getMessage());
}
return result;
}
/**
*
* @param messageId ID
* @return
*/
public Map<String, Object> getMessageDetail(String messageId) {
Map<String, Object> result = new HashMap<>();
try {
if (messageId == null || messageId.isEmpty()) {
result.put("success", false);
result.put("message", "消息ID不能为空");
return result;
}
Message message = messageService.getMessageById(messageId);
if (message != null) {
result.put("success", true);
result.put("message", message);
} else {
result.put("success", false);
result.put("message", "消息不存在");
}
} catch (Exception e) {
result.put("success", false);
result.put("message", "获取消息详情过程中发生异常: " + e.getMessage());
}
return result;
}
/**
*
* @param receiverId ID
* @return
*/
public Map<String, Object> getReceivedMessages(String receiverId) {
Map<String, Object> result = new HashMap<>();
try {
if (receiverId == null || receiverId.isEmpty()) {
result.put("success", false);
result.put("message", "接收者ID不能为空");
return result;
}
List<Message> messages = messageService.getReceivedMessages(receiverId);
result.put("success", true);
result.put("messages", messages);
result.put("count", messages.size());
} catch (Exception e) {
result.put("success", false);
result.put("message", "获取消息列表过程中发生异常: " + e.getMessage());
}
return result;
}
/**
*
* @param receiverId ID
* @return
*/
public Map<String, Object> getUnreadMessageCount(String receiverId) {
Map<String, Object> result = new HashMap<>();
try {
if (receiverId == null || receiverId.isEmpty()) {
result.put("success", false);
result.put("message", "接收者ID不能为空");
return result;
}
int count = messageService.getUnreadMessageCount(receiverId);
result.put("success", true);
result.put("unreadCount", count);
} catch (Exception e) {
result.put("success", false);
result.put("message", "获取未读消息数量过程中发生异常: " + e.getMessage());
}
return result;
}
/**
*
* @param userId1 1 ID
* @param userId2 2 ID
* @return
*/
public Map<String, Object> getMessagesBetweenUsers(String userId1, String userId2) {
Map<String, Object> result = new HashMap<>();
try {
if (userId1 == null || userId1.isEmpty() || userId2 == null || userId2.isEmpty()) {
result.put("success", false);
result.put("message", "用户ID不能为空");
return result;
}
List<Message> messages = messageService.getMessagesBetweenUsers(userId1, userId2);
result.put("success", true);
result.put("messages", messages);
result.put("count", messages.size());
} catch (Exception e) {
result.put("success", false);
result.put("message", "获取用户间消息记录过程中发生异常: " + e.getMessage());
}
return result;
}
/**
*
* @param messageId ID
* @return
*/
public Map<String, Object> markMessageAsRead(String messageId) {
Map<String, Object> result = new HashMap<>();
try {
if (messageId == null || messageId.isEmpty()) {
result.put("success", false);
result.put("message", "消息ID不能为空");
return result;
}
boolean success = messageService.markMessageAsRead(messageId);
if (success) {
result.put("success", true);
result.put("message", "消息已标记为已读");
} else {
result.put("success", false);
result.put("message", "标记消息为已读失败");
}
} catch (Exception e) {
result.put("success", false);
result.put("message", "标记消息为已读过程中发生异常: " + e.getMessage());
}
return result;
}
/**
*
* @param receiverId ID
* @return
*/
public Map<String, Object> markAllMessagesAsRead(String receiverId) {
Map<String, Object> result = new HashMap<>();
try {
if (receiverId == null || receiverId.isEmpty()) {
result.put("success", false);
result.put("message", "接收者ID不能为空");
return result;
}
boolean success = messageService.markAllMessagesAsRead(receiverId);
if (success) {
result.put("success", true);
result.put("message", "所有消息已标记为已读");
} else {
result.put("success", false);
result.put("message", "批量标记消息为已读失败");
}
} catch (Exception e) {
result.put("success", false);
result.put("message", "批量标记消息为已读过程中发生异常: " + e.getMessage());
}
return result;
}
}

@ -0,0 +1,499 @@
package com.campus.pickup.controller;
import com.campus.pickup.model.Order;
import com.campus.pickup.service.OrderService;
import java.math.BigDecimal;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
*
*
*/
public class OrderController {
private OrderService orderService;
/**
*
*/
public OrderController() {
this.orderService = new OrderService();
}
/**
*
* @param customerId ID
* @param itemType
* @param description
* @param pickupLocation
* @param deliveryLocation
* @param feeStr
* @param pickupTimeStr
* @param remarks
* @return
*/
public Map<String, Object> createOrder(String customerId, String itemType, String description,
String pickupLocation, String deliveryLocation,
String feeStr, String pickupTimeStr, String remarks) {
Map<String, Object> result = new HashMap<>();
try {
// 检查必要参数
if (customerId == null || customerId.isEmpty() ||
itemType == null || itemType.isEmpty() ||
description == null || description.isEmpty() ||
pickupLocation == null || pickupLocation.isEmpty() ||
deliveryLocation == null || deliveryLocation.isEmpty()) {
result.put("success", false);
result.put("message", "客户ID、物品类型、描述、取件地点和配送地点不能为空");
return result;
}
// 解析费用
BigDecimal fee = BigDecimal.ZERO;
if (feeStr != null && !feeStr.isEmpty()) {
try {
fee = new BigDecimal(feeStr);
if (fee.compareTo(BigDecimal.ZERO) < 0) {
result.put("success", false);
result.put("message", "配送费用不能为负数");
return result;
}
} catch (NumberFormatException e) {
result.put("success", false);
result.put("message", "配送费用格式不正确");
return result;
}
}
// 解析取件时间
LocalDateTime pickupTime = null;
if (pickupTimeStr != null && !pickupTimeStr.isEmpty()) {
try {
pickupTime = LocalDateTime.parse(pickupTimeStr, DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm"));
} catch (Exception e) {
result.put("success", false);
result.put("message", "取件时间格式不正确,请使用 yyyy-MM-dd HH:mm 格式");
return result;
}
}
// 调用服务层创建订单
Order order = orderService.createOrder(customerId, itemType, description,
pickupLocation, deliveryLocation, fee,
pickupTime, remarks);
if (order != null) {
result.put("success", true);
result.put("message", "订单创建成功");
result.put("order", order);
} else {
result.put("success", false);
result.put("message", "订单创建失败");
}
} catch (Exception e) {
result.put("success", false);
result.put("message", "创建订单过程中发生异常: " + e.getMessage());
}
return result;
}
/**
*
* @param orderId ID
* @param deliveryPersonId ID
* @return
*/
public Map<String, Object> acceptOrder(String orderId, String deliveryPersonId) {
Map<String, Object> result = new HashMap<>();
try {
if (orderId == null || orderId.isEmpty() || deliveryPersonId == null || deliveryPersonId.isEmpty()) {
result.put("success", false);
result.put("message", "订单ID和配送员ID不能为空");
return result;
}
boolean success = orderService.acceptOrder(orderId, deliveryPersonId);
if (success) {
result.put("success", true);
result.put("message", "订单接受成功");
} else {
result.put("success", false);
result.put("message", "订单接受失败,可能是订单不存在或状态不正确");
}
} catch (Exception e) {
result.put("success", false);
result.put("message", "接受订单过程中发生异常: " + e.getMessage());
}
return result;
}
/**
*
* @param orderId ID
* @return
*/
public Map<String, Object> confirmPickup(String orderId) {
Map<String, Object> result = new HashMap<>();
try {
if (orderId == null || orderId.isEmpty()) {
result.put("success", false);
result.put("message", "订单ID不能为空");
return result;
}
boolean success = orderService.confirmPickup(orderId);
if (success) {
result.put("success", true);
result.put("message", "取件确认成功");
} else {
result.put("success", false);
result.put("message", "取件确认失败,可能是订单不存在或状态不正确");
}
} catch (Exception e) {
result.put("success", false);
result.put("message", "确认取件过程中发生异常: " + e.getMessage());
}
return result;
}
/**
*
* @param orderId ID
* @return
*/
public Map<String, Object> startDelivery(String orderId) {
Map<String, Object> result = new HashMap<>();
try {
if (orderId == null || orderId.isEmpty()) {
result.put("success", false);
result.put("message", "订单ID不能为空");
return result;
}
boolean success = orderService.startDelivery(orderId);
if (success) {
result.put("success", true);
result.put("message", "开始配送成功");
} else {
result.put("success", false);
result.put("message", "开始配送失败,可能是订单不存在或状态不正确");
}
} catch (Exception e) {
result.put("success", false);
result.put("message", "开始配送过程中发生异常: " + e.getMessage());
}
return result;
}
/**
*
* @param orderId ID
* @return
*/
public Map<String, Object> completeDelivery(String orderId) {
Map<String, Object> result = new HashMap<>();
try {
if (orderId == null || orderId.isEmpty()) {
result.put("success", false);
result.put("message", "订单ID不能为空");
return result;
}
boolean success = orderService.completeDelivery(orderId);
if (success) {
result.put("success", true);
result.put("message", "配送完成成功");
} else {
result.put("success", false);
result.put("message", "配送完成失败,可能是订单不存在或状态不正确");
}
} catch (Exception e) {
result.put("success", false);
result.put("message", "完成配送过程中发生异常: " + e.getMessage());
}
return result;
}
/**
*
* @param orderId ID
* @return
*/
public Map<String, Object> cancelOrder(String orderId) {
Map<String, Object> result = new HashMap<>();
try {
if (orderId == null || orderId.isEmpty()) {
result.put("success", false);
result.put("message", "订单ID不能为空");
return result;
}
boolean success = orderService.cancelOrder(orderId);
if (success) {
result.put("success", true);
result.put("message", "订单取消成功");
} else {
result.put("success", false);
result.put("message", "订单取消失败,可能是订单不存在或状态不允许取消");
}
} catch (Exception e) {
result.put("success", false);
result.put("message", "取消订单过程中发生异常: " + e.getMessage());
}
return result;
}
/**
*
* @param orderId ID
* @return
*/
public Map<String, Object> getOrderDetail(String orderId) {
Map<String, Object> result = new HashMap<>();
try {
if (orderId == null || orderId.isEmpty()) {
result.put("success", false);
result.put("message", "订单ID不能为空");
return result;
}
Order order = orderService.getOrderById(orderId);
if (order != null) {
result.put("success", true);
result.put("order", order);
} else {
result.put("success", false);
result.put("message", "订单不存在");
}
} catch (Exception e) {
result.put("success", false);
result.put("message", "获取订单详情过程中发生异常: " + e.getMessage());
}
return result;
}
/**
*
* @param customerId ID
* @return
*/
public Map<String, Object> getOrdersByCustomerId(String customerId) {
Map<String, Object> result = new HashMap<>();
try {
if (customerId == null || customerId.isEmpty()) {
result.put("success", false);
result.put("message", "客户ID不能为空");
return result;
}
List<Order> orders = orderService.getOrdersByCustomerId(customerId);
result.put("success", true);
result.put("orders", orders);
result.put("count", orders.size());
} catch (Exception e) {
result.put("success", false);
result.put("message", "获取客户订单列表过程中发生异常: " + e.getMessage());
}
return result;
}
/**
*
* @param deliveryPersonId ID
* @return
*/
public Map<String, Object> getOrdersByDeliveryPersonId(String deliveryPersonId) {
Map<String, Object> result = new HashMap<>();
try {
if (deliveryPersonId == null || deliveryPersonId.isEmpty()) {
result.put("success", false);
result.put("message", "配送员ID不能为空");
return result;
}
List<Order> orders = orderService.getOrdersByDeliveryPersonId(deliveryPersonId);
result.put("success", true);
result.put("orders", orders);
result.put("count", orders.size());
} catch (Exception e) {
result.put("success", false);
result.put("message", "获取配送员订单列表过程中发生异常: " + e.getMessage());
}
return result;
}
/**
*
* @param statusCode
* @return
*/
public Map<String, Object> getOrdersByStatus(int statusCode) {
Map<String, Object> result = new HashMap<>();
try {
Order.OrderStatus status = Order.OrderStatus.fromCode(statusCode);
if (status == null) {
result.put("success", false);
result.put("message", "无效的订单状态");
return result;
}
List<Order> orders = orderService.getOrdersByStatus(status);
result.put("success", true);
result.put("orders", orders);
result.put("count", orders.size());
} catch (Exception e) {
result.put("success", false);
result.put("message", "获取指定状态订单列表过程中发生异常: " + e.getMessage());
}
return result;
}
/**
*
* @return
*/
public Map<String, Object> getAllOrders() {
Map<String, Object> result = new HashMap<>();
try {
List<Order> orders = orderService.getAllOrders();
result.put("success", true);
result.put("orders", orders);
result.put("count", orders.size());
} catch (Exception e) {
result.put("success", false);
result.put("message", "获取所有订单列表过程中发生异常: " + e.getMessage());
}
return result;
}
/**
*
* @param orderId ID
* @param userId ID
* @return
*/
public Map<String, Object> canUserOperateOrder(String orderId, String userId) {
Map<String, Object> result = new HashMap<>();
try {
if (orderId == null || orderId.isEmpty() || userId == null || userId.isEmpty()) {
result.put("success", false);
result.put("message", "订单ID和用户ID不能为空");
return result;
}
boolean canOperate = orderService.canUserOperateOrder(orderId, userId);
result.put("success", true);
result.put("canOperate", canOperate);
if (!canOperate) {
result.put("message", "您没有权限操作该订单");
}
} catch (Exception e) {
result.put("success", false);
result.put("message", "检查订单操作权限过程中发生异常: " + e.getMessage());
}
return result;
}
/**
* Order
* @param orderId ID
* @return
*/
public Order getOrderById(String orderId) {
try {
if (orderId == null || orderId.isEmpty()) {
return null;
}
return orderService.getOrderById(orderId);
} catch (Exception e) {
System.err.println("获取订单详情过程中发生异常: " + e.getMessage());
return null;
}
}
/**
* List<Order>
* @param status
* @return
*/
public List<Order> getOrdersByStatus(Order.OrderStatus status) {
try {
if (status == null) {
return null;
}
return orderService.getOrdersByStatus(status);
} catch (Exception e) {
System.err.println("获取指定状态订单列表过程中发生异常: " + e.getMessage());
return null;
}
}
/**
*
* @param orderId ID
* @return
*/
public Map<String, Object> pickupOrder(String orderId) {
return confirmPickup(orderId);
}
/**
*
* @param orderId ID
* @return
*/
public Map<String, Object> deliverOrder(String orderId) {
return startDelivery(orderId);
}
/**
*
* @param orderId ID
* @return
*/
public Map<String, Object> completeOrder(String orderId) {
return completeDelivery(orderId);
}
}

@ -0,0 +1,295 @@
package com.campus.pickup.controller;
import com.campus.pickup.model.Review;
import com.campus.pickup.service.ReviewService;
import com.campus.pickup.util.DatabaseUtil;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
*
*
*/
public class ReviewController {
private ReviewService reviewService;
/**
*
*/
public ReviewController() {
this.reviewService = new ReviewService();
}
/**
*
* @param orderId ID
* @param reviewerId ID
* @param reviewedId ID
* @param rating 1-5
* @param content
* @return
*/
public Map<String, Object> addReview(String orderId, String reviewerId, String reviewedId,
int rating, String content) {
Map<String, Object> result = new HashMap<>();
try {
// 检查输入参数
if (orderId == null || orderId.isEmpty() || reviewerId == null ||
reviewerId.isEmpty() || reviewedId == null || reviewedId.isEmpty()) {
result.put("success", false);
result.put("message", "订单ID、评价人ID和被评价人ID不能为空");
return result;
}
// 检查评分是否有效
if (rating < 1 || rating > 5) {
result.put("success", false);
result.put("message", "评分必须在1-5之间");
return result;
}
// 调用服务层添加评价
boolean success = reviewService.addReview(orderId, reviewerId, reviewedId, rating, content);
if (success) {
result.put("success", true);
result.put("message", "评价添加成功");
} else {
result.put("success", false);
result.put("message", "评价添加失败,可能该订单已被评价过");
}
} catch (Exception e) {
result.put("success", false);
result.put("message", "添加评价过程中发生异常: " + e.getMessage());
}
return result;
}
/**
*
* @param reviewId ID
* @return
*/
public Map<String, Object> getReviewDetail(String reviewId) {
Map<String, Object> result = new HashMap<>();
try {
if (reviewId == null || reviewId.isEmpty()) {
result.put("success", false);
result.put("message", "评价ID不能为空");
return result;
}
Review review = reviewService.getReviewById(reviewId);
if (review != null) {
result.put("success", true);
result.put("review", review);
} else {
result.put("success", false);
result.put("message", "评价不存在");
}
} catch (Exception e) {
result.put("success", false);
result.put("message", "获取评价详情过程中发生异常: " + e.getMessage());
}
return result;
}
/**
* ID
* @param orderId ID
* @return
*/
public Map<String, Object> getReviewByOrderId(String orderId) {
Map<String, Object> result = new HashMap<>();
try {
if (orderId == null || orderId.isEmpty()) {
result.put("success", false);
result.put("message", "订单ID不能为空");
return result;
}
Review review = reviewService.getReviewByOrderId(orderId);
if (review != null) {
result.put("success", true);
result.put("review", review);
} else {
result.put("success", false);
result.put("message", "该订单暂无评价");
}
} catch (Exception e) {
result.put("success", false);
result.put("message", "获取订单评价过程中发生异常: " + e.getMessage());
}
return result;
}
/**
*
* @param userId ID
* @return
*/
public Map<String, Object> getReviewsReceivedByUser(String userId) {
Map<String, Object> result = new HashMap<>();
try {
if (userId == null || userId.isEmpty()) {
result.put("success", false);
result.put("message", "用户ID不能为空");
return result;
}
List<Review> reviews = reviewService.getReviewsReceivedByUser(userId);
result.put("success", true);
result.put("reviews", reviews);
result.put("count", reviews.size());
} catch (Exception e) {
result.put("success", false);
result.put("message", "获取用户评价列表过程中发生异常: " + e.getMessage());
}
return result;
}
/**
*
* @param userId ID
* @return
*/
public Map<String, Object> getAverageRatingForUser(String userId) {
Map<String, Object> result = new HashMap<>();
try {
if (userId == null || userId.isEmpty()) {
result.put("success", false);
result.put("message", "用户ID不能为空");
return result;
}
double averageRating = reviewService.getAverageRatingForUser(userId);
result.put("success", true);
result.put("averageRating", averageRating);
} catch (Exception e) {
result.put("success", false);
result.put("message", "获取用户平均评分过程中发生异常: " + e.getMessage());
}
return result;
}
/**
*
* @param reviewId ID
* @param rating 1-5
* @param content
* @return
*/
public Map<String, Object> updateReview(String reviewId, int rating, String content) {
Map<String, Object> result = new HashMap<>();
try {
if (reviewId == null || reviewId.isEmpty()) {
result.put("success", false);
result.put("message", "评价ID不能为空");
return result;
}
// 检查评分是否有效
if (rating < 1 || rating > 5) {
result.put("success", false);
result.put("message", "评分必须在1-5之间");
return result;
}
boolean success = reviewService.updateReview(reviewId, rating, content);
if (success) {
result.put("success", true);
result.put("message", "评价更新成功");
} else {
result.put("success", false);
result.put("message", "评价更新失败");
}
} catch (Exception e) {
result.put("success", false);
result.put("message", "更新评价过程中发生异常: " + e.getMessage());
}
return result;
}
/**
*
* @param reviewId ID
* @return
*/
public Map<String, Object> deleteReview(String reviewId) {
Map<String, Object> result = new HashMap<>();
try {
if (reviewId == null || reviewId.isEmpty()) {
result.put("success", false);
result.put("message", "评价ID不能为空");
return result;
}
boolean success = reviewService.deleteReview(reviewId);
if (success) {
result.put("success", true);
result.put("message", "评价删除成功");
} else {
result.put("success", false);
result.put("message", "评价删除失败");
}
} catch (Exception e) {
result.put("success", false);
result.put("message", "删除评价过程中发生异常: " + e.getMessage());
}
return result;
}
/**
*
* @param orderId ID
* @param userId ID
* @return
*/
public Map<String, Object> canUserReviewOrder(String orderId, String userId) {
Map<String, Object> result = new HashMap<>();
try {
if (orderId == null || orderId.isEmpty() || userId == null || userId.isEmpty()) {
result.put("success", false);
result.put("message", "订单ID和用户ID不能为空");
return result;
}
boolean canReview = reviewService.canUserReviewOrder(orderId, userId);
result.put("success", true);
result.put("canReview", canReview);
if (!canReview) {
result.put("message", "该订单已被评价,且评价人不是当前用户");
}
} catch (Exception e) {
result.put("success", false);
result.put("message", "检查评价权限过程中发生异常: " + e.getMessage());
}
return result;
}
}

@ -0,0 +1,252 @@
package com.campus.pickup.controller;
import com.campus.pickup.model.User;
import com.campus.pickup.service.UserService;
import com.campus.pickup.util.DatabaseUtil;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
*
*
*/
public class UserController {
private UserService userService;
/**
*
*/
public UserController() {
this.userService = new UserService();
}
/**
*
* @param username
* @param password
* @param realName
* @param phone
* @param email
* @param studentId
* @param dormitory 宿
* @return
*/
public Map<String, Object> register(String username, String password, String realName,
String phone, String email, String studentId, String dormitory) {
Map<String, Object> result = new HashMap<>();
try {
// 检查输入参数
if (username == null || username.isEmpty() || password == null || password.isEmpty()) {
result.put("success", false);
result.put("message", "用户名和密码不能为空");
return result;
}
// 创建用户对象
User user = new User();
user.setUserId(java.util.UUID.randomUUID().toString().replace("-", ""));
user.setUsername(username);
user.setPassword(password);
user.setRealName(realName);
user.setPhone(phone);
user.setEmail(email);
user.setStudentId(studentId);
user.setDormitory(dormitory);
// 调用服务层进行注册
boolean success = userService.register(user);
if (success) {
result.put("success", true);
result.put("message", "注册成功");
result.put("userId", user.getUserId());
} else {
result.put("success", false);
result.put("message", "用户名已存在,注册失败");
}
} catch (Exception e) {
result.put("success", false);
result.put("message", "注册过程中发生异常: " + e.getMessage());
}
return result;
}
/**
*
* @param username
* @param password
* @return
*/
public Map<String, Object> login(String username, String password) {
Map<String, Object> result = new HashMap<>();
try {
// 检查输入参数
if (username == null || username.isEmpty() || password == null || password.isEmpty()) {
result.put("success", false);
result.put("message", "用户名和密码不能为空");
return result;
}
// 调用服务层进行登录验证
User user = userService.login(username, password);
if (user != null) {
result.put("success", true);
result.put("message", "登录成功");
result.put("user", user);
} else {
result.put("success", false);
result.put("message", "用户名或密码错误,或账户已被禁用");
}
} catch (Exception e) {
result.put("success", false);
result.put("message", "登录过程中发生异常: " + e.getMessage());
}
return result;
}
/**
*
* @param userId ID
* @return
*/
public Map<String, Object> getUserInfo(String userId) {
Map<String, Object> result = new HashMap<>();
try {
if (userId == null || userId.isEmpty()) {
result.put("success", false);
result.put("message", "用户ID不能为空");
return result;
}
User user = userService.getUserById(userId);
if (user != null) {
result.put("success", true);
result.put("user", user);
} else {
result.put("success", false);
result.put("message", "用户不存在");
}
} catch (Exception e) {
result.put("success", false);
result.put("message", "获取用户信息过程中发生异常: " + e.getMessage());
}
return result;
}
/**
*
* @param userId ID
* @param realName
* @param phone
* @param email
* @param studentId
* @param dormitory 宿
* @return
*/
public Map<String, Object> updateUserInfo(String userId, String realName, String phone,
String email, String studentId, String dormitory) {
Map<String, Object> result = new HashMap<>();
try {
if (userId == null || userId.isEmpty()) {
result.put("success", false);
result.put("message", "用户ID不能为空");
return result;
}
User user = userService.getUserById(userId);
if (user == null) {
result.put("success", false);
result.put("message", "用户不存在");
return result;
}
// 更新用户信息
user.setRealName(realName);
user.setPhone(phone);
user.setEmail(email);
user.setStudentId(studentId);
user.setDormitory(dormitory);
boolean success = userService.updateUser(user);
if (success) {
result.put("success", true);
result.put("message", "更新成功");
result.put("user", user);
} else {
result.put("success", false);
result.put("message", "更新失败");
}
} catch (Exception e) {
result.put("success", false);
result.put("message", "更新用户信息过程中发生异常: " + e.getMessage());
}
return result;
}
/**
*
* @param userId ID
* @param oldPassword
* @param newPassword
* @return
*/
public Map<String, Object> changePassword(String userId, String oldPassword, String newPassword) {
Map<String, Object> result = new HashMap<>();
try {
if (userId == null || userId.isEmpty() || oldPassword == null ||
oldPassword.isEmpty() || newPassword == null || newPassword.isEmpty()) {
result.put("success", false);
result.put("message", "参数不能为空");
return result;
}
boolean success = userService.changePassword(userId, oldPassword, newPassword);
if (success) {
result.put("success", true);
result.put("message", "密码修改成功");
} else {
result.put("success", false);
result.put("message", "旧密码错误或修改失败");
}
} catch (Exception e) {
result.put("success", false);
result.put("message", "修改密码过程中发生异常: " + e.getMessage());
}
return result;
}
/**
*
* @return
*/
public Map<String, Object> getAllUsers() {
Map<String, Object> result = new HashMap<>();
try {
List<User> users = userService.getAllUsers();
result.put("success", true);
result.put("users", users);
} catch (Exception e) {
result.put("success", false);
result.put("message", "获取用户列表过程中发生异常: " + e.getMessage());
}
return result;
}
}

@ -0,0 +1,255 @@
package com.campus.pickup.dao;
import com.campus.pickup.model.Message;
import com.campus.pickup.util.DatabaseUtil;
import java.sql.*;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.List;
/**
* 访
*
*/
public class MessageDao {
/**
*
* @param message
* @return
*/
public boolean addMessage(Message message) {
String sql = "INSERT INTO messages (sender_id, receiver_id, content, send_time, read_time, status, type) VALUES (?, ?, ?, ?, ?, ?, ?)";
try (Connection conn = DatabaseUtil.getConnection();
PreparedStatement pstmt = conn.prepareStatement(sql, Statement.RETURN_GENERATED_KEYS)) {
pstmt.setString(1, message.getSenderId());
pstmt.setString(2, message.getReceiverId());
pstmt.setString(3, message.getContent());
pstmt.setTimestamp(4, Timestamp.valueOf(message.getSendTime()));
if (message.getReadTime() != null) {
pstmt.setTimestamp(5, Timestamp.valueOf(message.getReadTime()));
} else {
pstmt.setNull(5, Types.TIMESTAMP);
}
pstmt.setInt(6, message.getStatus());
pstmt.setInt(7, message.getType().getCode());
int affectedRows = pstmt.executeUpdate();
if (affectedRows > 0) {
ResultSet rs = pstmt.getGeneratedKeys();
if (rs.next()) {
message.setMessageId(rs.getString(1));
}
return true;
}
} catch (SQLException e) {
System.err.println("添加消息失败:" + e.getMessage());
}
return false;
}
/**
* ID
* @param messageId ID
* @return null
*/
public Message getMessageById(String messageId) {
String sql = "SELECT * FROM messages WHERE message_id = ? AND status != 2";
try (Connection conn = DatabaseUtil.getConnection();
PreparedStatement pstmt = conn.prepareStatement(sql)) {
pstmt.setString(1, messageId);
ResultSet rs = pstmt.executeQuery();
if (rs.next()) {
return extractMessageFromResultSet(rs);
}
} catch (SQLException e) {
System.err.println("查询消息失败:" + e.getMessage());
}
return null;
}
/**
* ID
* @param receiverId ID
* @return
*/
public List<Message> getMessagesByReceiverId(String receiverId) {
List<Message> messages = new ArrayList<>();
String sql = "SELECT * FROM messages WHERE receiver_id = ? AND status != 2 ORDER BY send_time DESC";
try (Connection conn = DatabaseUtil.getConnection();
PreparedStatement pstmt = conn.prepareStatement(sql)) {
pstmt.setString(1, receiverId);
ResultSet rs = pstmt.executeQuery();
while (rs.next()) {
messages.add(extractMessageFromResultSet(rs));
}
} catch (SQLException e) {
System.err.println("查询消息列表失败:" + e.getMessage());
}
return messages;
}
/**
* ID
* @param senderId ID
* @return
*/
public List<Message> getMessagesBySenderId(String senderId) {
List<Message> messages = new ArrayList<>();
String sql = "SELECT * FROM messages WHERE sender_id = ? AND status != 2 ORDER BY send_time DESC";
try (Connection conn = DatabaseUtil.getConnection();
PreparedStatement pstmt = conn.prepareStatement(sql)) {
pstmt.setString(1, senderId);
ResultSet rs = pstmt.executeQuery();
while (rs.next()) {
messages.add(extractMessageFromResultSet(rs));
}
} catch (SQLException e) {
System.err.println("查询消息列表失败:" + e.getMessage());
}
return messages;
}
/**
*
* @param userId1 ID1
* @param userId2 ID2
* @return
*/
public List<Message> getMessagesBetweenUsers(String userId1, String userId2) {
List<Message> messages = new ArrayList<>();
String sql = "SELECT * FROM messages WHERE ((sender_id = ? AND receiver_id = ?) OR (sender_id = ? AND receiver_id = ?)) AND status != 2 ORDER BY send_time ASC";
try (Connection conn = DatabaseUtil.getConnection();
PreparedStatement pstmt = conn.prepareStatement(sql)) {
pstmt.setString(1, userId1);
pstmt.setString(2, userId2);
pstmt.setString(3, userId2);
pstmt.setString(4, userId1);
ResultSet rs = pstmt.executeQuery();
while (rs.next()) {
messages.add(extractMessageFromResultSet(rs));
}
} catch (SQLException e) {
System.err.println("查询用户间消息失败:" + e.getMessage());
}
return messages;
}
/**
*
* @param messageId ID
* @return
*/
public boolean markMessageAsRead(String messageId) {
String sql = "UPDATE messages SET status = 1, read_time = ? WHERE message_id = ?";
try (Connection conn = DatabaseUtil.getConnection();
PreparedStatement pstmt = conn.prepareStatement(sql)) {
pstmt.setTimestamp(1, Timestamp.valueOf(LocalDateTime.now()));
pstmt.setString(2, messageId);
int affectedRows = pstmt.executeUpdate();
return affectedRows > 0;
} catch (SQLException e) {
System.err.println("更新消息状态失败:" + e.getMessage());
}
return false;
}
/**
*
* @param messageId ID
* @return
*/
public boolean deleteMessage(String messageId) {
String sql = "UPDATE messages SET status = 2 WHERE message_id = ?";
try (Connection conn = DatabaseUtil.getConnection();
PreparedStatement pstmt = conn.prepareStatement(sql)) {
pstmt.setString(1, messageId);
int affectedRows = pstmt.executeUpdate();
return affectedRows > 0;
} catch (SQLException e) {
System.err.println("删除消息失败:" + e.getMessage());
}
return false;
}
/**
*
* @param receiverId ID
* @return
*/
public int getUnreadMessageCount(String receiverId) {
String sql = "SELECT COUNT(*) FROM messages WHERE receiver_id = ? AND status = 0";
try (Connection conn = DatabaseUtil.getConnection();
PreparedStatement pstmt = conn.prepareStatement(sql)) {
pstmt.setString(1, receiverId);
ResultSet rs = pstmt.executeQuery();
if (rs.next()) {
return rs.getInt(1);
}
} catch (SQLException e) {
System.err.println("获取未读消息数量失败:" + e.getMessage());
}
return 0;
}
/**
* ResultSet
* @param rs ResultSet
* @return
* @throws SQLException SQL
*/
private Message extractMessageFromResultSet(ResultSet rs) throws SQLException {
Message message = new Message();
message.setMessageId(rs.getString("message_id"));
message.setSenderId(rs.getString("sender_id"));
message.setReceiverId(rs.getString("receiver_id"));
message.setContent(rs.getString("content"));
message.setSendTime(rs.getTimestamp("send_time").toLocalDateTime());
Timestamp readTime = rs.getTimestamp("read_time");
if (readTime != null) {
message.setReadTime(readTime.toLocalDateTime());
}
message.setStatus(rs.getInt("status"));
message.setType(Message.MessageType.fromCode(rs.getInt("type")));
return message;
}
}

@ -0,0 +1,343 @@
package com.campus.pickup.dao;
import com.campus.pickup.model.Order;
import com.campus.pickup.util.DatabaseUtil;
import java.sql.*;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.List;
/**
* 访
*
*/
public class OrderDao {
/**
*
* @param order
* @return
*/
public boolean addOrder(Order order) {
String sql = "INSERT INTO orders (order_number, customer_id, delivery_person_id, item_type, " +
"description, pickup_location, delivery_location, fee, pickup_time, delivery_time, " +
"create_time, update_time, status, remarks) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)";
try (Connection conn = DatabaseUtil.getConnection();
PreparedStatement pstmt = conn.prepareStatement(sql, Statement.RETURN_GENERATED_KEYS)) {
pstmt.setString(1, order.getOrderNumber());
pstmt.setString(2, order.getCustomerId());
if (order.getDeliveryPersonId() != null) {
pstmt.setString(3, order.getDeliveryPersonId());
} else {
pstmt.setNull(3, Types.VARCHAR);
}
pstmt.setString(4, order.getItemType());
pstmt.setString(5, order.getDescription());
pstmt.setString(6, order.getPickupLocation());
pstmt.setString(7, order.getDeliveryLocation());
pstmt.setBigDecimal(8, order.getFee());
if (order.getPickupTime() != null) {
pstmt.setTimestamp(9, Timestamp.valueOf(order.getPickupTime()));
} else {
pstmt.setNull(9, Types.TIMESTAMP);
}
if (order.getDeliveryTime() != null) {
pstmt.setTimestamp(10, Timestamp.valueOf(order.getDeliveryTime()));
} else {
pstmt.setNull(10, Types.TIMESTAMP);
}
pstmt.setTimestamp(11, Timestamp.valueOf(order.getCreateTime()));
pstmt.setTimestamp(12, Timestamp.valueOf(order.getUpdateTime()));
pstmt.setInt(13, order.getStatus().getCode());
pstmt.setString(14, order.getRemarks());
int affectedRows = pstmt.executeUpdate();
if (affectedRows > 0) {
ResultSet rs = pstmt.getGeneratedKeys();
if (rs.next()) {
order.setOrderId(rs.getString(1));
}
return true;
}
} catch (SQLException e) {
System.err.println("添加订单失败:" + e.getMessage());
}
return false;
}
/**
* ID
* @param orderId ID
* @return null
*/
public Order getOrderById(String orderId) {
String sql = "SELECT * FROM orders WHERE order_id = ?";
try (Connection conn = DatabaseUtil.getConnection();
PreparedStatement pstmt = conn.prepareStatement(sql)) {
pstmt.setString(1, orderId);
ResultSet rs = pstmt.executeQuery();
if (rs.next()) {
return extractOrderFromResultSet(rs);
}
} catch (SQLException e) {
System.err.println("查询订单失败:" + e.getMessage());
}
return null;
}
/**
*
* @param orderNumber
* @return null
*/
public Order getOrderByNumber(String orderNumber) {
String sql = "SELECT * FROM orders WHERE order_number = ?";
try (Connection conn = DatabaseUtil.getConnection();
PreparedStatement pstmt = conn.prepareStatement(sql)) {
pstmt.setString(1, orderNumber);
ResultSet rs = pstmt.executeQuery();
if (rs.next()) {
return extractOrderFromResultSet(rs);
}
} catch (SQLException e) {
System.err.println("查询订单失败:" + e.getMessage());
}
return null;
}
/**
* ID
* @param customerId ID
* @return
*/
public List<Order> getOrdersByCustomerId(String customerId) {
List<Order> orders = new ArrayList<>();
String sql = "SELECT * FROM orders WHERE customer_id = ? ORDER BY create_time DESC";
try (Connection conn = DatabaseUtil.getConnection();
PreparedStatement pstmt = conn.prepareStatement(sql)) {
pstmt.setString(1, customerId);
ResultSet rs = pstmt.executeQuery();
while (rs.next()) {
orders.add(extractOrderFromResultSet(rs));
}
} catch (SQLException e) {
System.err.println("查询订单列表失败:" + e.getMessage());
}
return orders;
}
/**
* ID
* @param deliveryPersonId ID
* @return
*/
public List<Order> getOrdersByDeliveryPersonId(String deliveryPersonId) {
List<Order> orders = new ArrayList<>();
String sql = "SELECT * FROM orders WHERE delivery_person_id = ? ORDER BY create_time DESC";
try (Connection conn = DatabaseUtil.getConnection();
PreparedStatement pstmt = conn.prepareStatement(sql)) {
pstmt.setString(1, deliveryPersonId);
ResultSet rs = pstmt.executeQuery();
while (rs.next()) {
orders.add(extractOrderFromResultSet(rs));
}
} catch (SQLException e) {
System.err.println("查询订单列表失败:" + e.getMessage());
}
return orders;
}
/**
*
* @param status
* @return
*/
public List<Order> getOrdersByStatus(Order.OrderStatus status) {
List<Order> orders = new ArrayList<>();
String sql = "SELECT * FROM orders WHERE status = ? ORDER BY create_time DESC";
try (Connection conn = DatabaseUtil.getConnection();
PreparedStatement pstmt = conn.prepareStatement(sql)) {
pstmt.setInt(1, status.getCode());
ResultSet rs = pstmt.executeQuery();
while (rs.next()) {
orders.add(extractOrderFromResultSet(rs));
}
} catch (SQLException e) {
System.err.println("查询订单列表失败:" + e.getMessage());
}
return orders;
}
/**
*
* @param order
* @return
*/
public boolean updateOrder(Order order) {
String sql = "UPDATE orders SET order_number = ?, customer_id = ?, delivery_person_id = ?, " +
"item_type = ?, description = ?, pickup_location = ?, delivery_location = ?, " +
"fee = ?, pickup_time = ?, delivery_time = ?, update_time = ?, status = ?, " +
"remarks = ? WHERE order_id = ?";
try (Connection conn = DatabaseUtil.getConnection();
PreparedStatement pstmt = conn.prepareStatement(sql)) {
pstmt.setString(1, order.getOrderNumber());
pstmt.setString(2, order.getCustomerId());
if (order.getDeliveryPersonId() != null) {
pstmt.setString(3, order.getDeliveryPersonId());
} else {
pstmt.setNull(3, Types.VARCHAR);
}
pstmt.setString(4, order.getItemType());
pstmt.setString(5, order.getDescription());
pstmt.setString(6, order.getPickupLocation());
pstmt.setString(7, order.getDeliveryLocation());
pstmt.setBigDecimal(8, order.getFee());
if (order.getPickupTime() != null) {
pstmt.setTimestamp(9, Timestamp.valueOf(order.getPickupTime()));
} else {
pstmt.setNull(9, Types.TIMESTAMP);
}
if (order.getDeliveryTime() != null) {
pstmt.setTimestamp(10, Timestamp.valueOf(order.getDeliveryTime()));
} else {
pstmt.setNull(10, Types.TIMESTAMP);
}
pstmt.setTimestamp(11, Timestamp.valueOf(LocalDateTime.now()));
pstmt.setInt(12, order.getStatus().getCode());
pstmt.setString(13, order.getRemarks());
pstmt.setString(14, order.getOrderId());
int affectedRows = pstmt.executeUpdate();
return affectedRows > 0;
} catch (SQLException e) {
System.err.println("更新订单失败:" + e.getMessage());
}
return false;
}
/**
*
* @param orderId ID
* @param status
* @return
*/
public boolean updateOrderStatus(String orderId, Order.OrderStatus status) {
String sql = "UPDATE orders SET status = ?, update_time = ? WHERE order_id = ?";
try (Connection conn = DatabaseUtil.getConnection();
PreparedStatement pstmt = conn.prepareStatement(sql)) {
pstmt.setInt(1, status.getCode());
pstmt.setTimestamp(2, Timestamp.valueOf(LocalDateTime.now()));
pstmt.setString(3, orderId);
int affectedRows = pstmt.executeUpdate();
return affectedRows > 0;
} catch (SQLException e) {
System.err.println("更新订单状态失败:" + e.getMessage());
}
return false;
}
/**
*
* @return
*/
public List<Order> getAllOrders() {
List<Order> orders = new ArrayList<>();
String sql = "SELECT * FROM orders ORDER BY create_time DESC";
try (Connection conn = DatabaseUtil.getConnection();
PreparedStatement pstmt = conn.prepareStatement(sql);
ResultSet rs = pstmt.executeQuery()) {
while (rs.next()) {
orders.add(extractOrderFromResultSet(rs));
}
} catch (SQLException e) {
System.err.println("获取订单列表失败:" + e.getMessage());
}
return orders;
}
/**
* ResultSet
* @param rs ResultSet
* @return
* @throws SQLException SQL
*/
private Order extractOrderFromResultSet(ResultSet rs) throws SQLException {
Order order = new Order();
order.setOrderId(rs.getString("order_id"));
order.setOrderNumber(rs.getString("order_number"));
order.setCustomerId(rs.getString("customer_id"));
String deliveryPersonId = rs.getString("delivery_person_id");
if (deliveryPersonId != null) {
order.setDeliveryPersonId(deliveryPersonId);
}
order.setItemType(rs.getString("item_type"));
order.setDescription(rs.getString("description"));
order.setPickupLocation(rs.getString("pickup_location"));
order.setDeliveryLocation(rs.getString("delivery_location"));
order.setFee(rs.getBigDecimal("fee"));
Timestamp pickupTime = rs.getTimestamp("pickup_time");
if (pickupTime != null) {
order.setPickupTime(pickupTime.toLocalDateTime());
}
Timestamp deliveryTime = rs.getTimestamp("delivery_time");
if (deliveryTime != null) {
order.setDeliveryTime(deliveryTime.toLocalDateTime());
}
order.setCreateTime(rs.getTimestamp("create_time").toLocalDateTime());
order.setUpdateTime(rs.getTimestamp("update_time").toLocalDateTime());
order.setStatus(Order.OrderStatus.fromCode(rs.getInt("status")));
order.setRemarks(rs.getString("remarks"));
return order;
}
}

@ -0,0 +1,246 @@
package com.campus.pickup.dao;
import com.campus.pickup.model.Review;
import com.campus.pickup.util.DatabaseUtil;
import java.sql.*;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.List;
/**
* 访
*
*/
public class ReviewDao {
/**
*
* @param review
* @return
*/
public boolean addReview(Review review) {
String sql = "INSERT INTO reviews (order_id, reviewer_id, reviewed_id, rating, content, create_time, update_time, status) VALUES (?, ?, ?, ?, ?, ?, ?, ?)";
try (Connection conn = DatabaseUtil.getConnection();
PreparedStatement pstmt = conn.prepareStatement(sql, Statement.RETURN_GENERATED_KEYS)) {
pstmt.setString(1, review.getOrderId());
pstmt.setString(2, review.getReviewerId());
pstmt.setString(3, review.getReviewedId());
pstmt.setInt(4, review.getRating());
pstmt.setString(5, review.getContent());
pstmt.setTimestamp(6, Timestamp.valueOf(review.getCreateTime()));
pstmt.setTimestamp(7, Timestamp.valueOf(review.getUpdateTime()));
pstmt.setInt(8, review.getStatus());
int affectedRows = pstmt.executeUpdate();
if (affectedRows > 0) {
ResultSet rs = pstmt.getGeneratedKeys();
if (rs.next()) {
review.setReviewId(rs.getString(1));
}
return true;
}
} catch (SQLException e) {
System.err.println("添加评价失败:" + e.getMessage());
}
return false;
}
/**
* ID
* @param reviewId ID
* @return null
*/
public Review getReviewById(String reviewId) {
String sql = "SELECT * FROM reviews WHERE review_id = ? AND status = 0";
try (Connection conn = DatabaseUtil.getConnection();
PreparedStatement pstmt = conn.prepareStatement(sql)) {
pstmt.setString(1, reviewId);
ResultSet rs = pstmt.executeQuery();
if (rs.next()) {
return extractReviewFromResultSet(rs);
}
} catch (SQLException e) {
System.err.println("查询评价失败:" + e.getMessage());
}
return null;
}
/**
* ID
* @param orderId ID
* @return null
*/
public Review getReviewByOrderId(String orderId) {
String sql = "SELECT * FROM reviews WHERE order_id = ? AND status = 0";
try (Connection conn = DatabaseUtil.getConnection();
PreparedStatement pstmt = conn.prepareStatement(sql)) {
pstmt.setString(1, orderId);
ResultSet rs = pstmt.executeQuery();
if (rs.next()) {
return extractReviewFromResultSet(rs);
}
} catch (SQLException e) {
System.err.println("查询评价失败:" + e.getMessage());
}
return null;
}
/**
* ID
* @param reviewedId ID
* @return
*/
public List<Review> getReviewsByReviewedId(String reviewedId) {
List<Review> reviews = new ArrayList<>();
String sql = "SELECT * FROM reviews WHERE reviewed_id = ? AND status = 0 ORDER BY create_time DESC";
try (Connection conn = DatabaseUtil.getConnection();
PreparedStatement pstmt = conn.prepareStatement(sql)) {
pstmt.setString(1, reviewedId);
ResultSet rs = pstmt.executeQuery();
while (rs.next()) {
reviews.add(extractReviewFromResultSet(rs));
}
} catch (SQLException e) {
System.err.println("查询评价列表失败:" + e.getMessage());
}
return reviews;
}
/**
* ID
* @param reviewerId ID
* @return
*/
public List<Review> getReviewsByReviewerId(String reviewerId) {
List<Review> reviews = new ArrayList<>();
String sql = "SELECT * FROM reviews WHERE reviewer_id = ? AND status = 0 ORDER BY create_time DESC";
try (Connection conn = DatabaseUtil.getConnection();
PreparedStatement pstmt = conn.prepareStatement(sql)) {
pstmt.setString(1, reviewerId);
ResultSet rs = pstmt.executeQuery();
while (rs.next()) {
reviews.add(extractReviewFromResultSet(rs));
}
} catch (SQLException e) {
System.err.println("查询评价列表失败:" + e.getMessage());
}
return reviews;
}
/**
*
* @param review
* @return
*/
public boolean updateReview(Review review) {
String sql = "UPDATE reviews SET order_id = ?, reviewer_id = ?, reviewed_id = ?, rating = ?, content = ?, update_time = ?, status = ? WHERE review_id = ?";
try (Connection conn = DatabaseUtil.getConnection();
PreparedStatement pstmt = conn.prepareStatement(sql)) {
pstmt.setString(1, review.getOrderId());
pstmt.setString(2, review.getReviewerId());
pstmt.setString(3, review.getReviewedId());
pstmt.setInt(4, review.getRating());
pstmt.setString(5, review.getContent());
pstmt.setTimestamp(6, Timestamp.valueOf(LocalDateTime.now()));
pstmt.setInt(7, review.getStatus());
pstmt.setString(8, review.getReviewId());
int affectedRows = pstmt.executeUpdate();
return affectedRows > 0;
} catch (SQLException e) {
System.err.println("更新评价失败:" + e.getMessage());
}
return false;
}
/**
*
* @param reviewId ID
* @return
*/
public boolean deleteReview(String reviewId) {
String sql = "UPDATE reviews SET status = 1, update_time = ? WHERE review_id = ?";
try (Connection conn = DatabaseUtil.getConnection();
PreparedStatement pstmt = conn.prepareStatement(sql)) {
pstmt.setTimestamp(1, Timestamp.valueOf(LocalDateTime.now()));
pstmt.setString(2, reviewId);
int affectedRows = pstmt.executeUpdate();
return affectedRows > 0;
} catch (SQLException e) {
System.err.println("删除评价失败:" + e.getMessage());
}
return false;
}
/**
*
* @param userId ID
* @return 0
*/
public double getAverageRatingByUserId(String userId) {
String sql = "SELECT AVG(rating) FROM reviews WHERE reviewed_id = ? AND status = 0";
try (Connection conn = DatabaseUtil.getConnection();
PreparedStatement pstmt = conn.prepareStatement(sql)) {
pstmt.setString(1, userId);
ResultSet rs = pstmt.executeQuery();
if (rs.next()) {
return rs.getDouble(1);
}
} catch (SQLException e) {
System.err.println("计算平均评分失败:" + e.getMessage());
}
return 0.0;
}
/**
* ResultSet
* @param rs ResultSet
* @return
* @throws SQLException SQL
*/
private Review extractReviewFromResultSet(ResultSet rs) throws SQLException {
Review review = new Review();
review.setReviewId(rs.getString("review_id"));
review.setOrderId(rs.getString("order_id"));
review.setReviewerId(rs.getString("reviewer_id"));
review.setReviewedId(rs.getString("reviewed_id"));
review.setRating(rs.getInt("rating"));
review.setContent(rs.getString("content"));
review.setCreateTime(rs.getTimestamp("create_time").toLocalDateTime());
review.setUpdateTime(rs.getTimestamp("update_time").toLocalDateTime());
review.setStatus(rs.getInt("status"));
return review;
}
}

@ -0,0 +1,200 @@
package com.campus.pickup.dao;
import com.campus.pickup.model.User;
import com.campus.pickup.util.DatabaseUtil;
import java.sql.*;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.List;
/**
* 访
*
*/
public class UserDao {
/**
*
* @param user
* @return
*/
public boolean addUser(User user) {
String sql = "INSERT INTO users (username, password, real_name, phone, email, student_id, dormitory, create_time, update_time, status) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)";
try (Connection conn = DatabaseUtil.getConnection();
PreparedStatement pstmt = conn.prepareStatement(sql, Statement.RETURN_GENERATED_KEYS)) {
pstmt.setString(1, user.getUsername());
pstmt.setString(2, user.getPassword());
pstmt.setString(3, user.getRealName());
pstmt.setString(4, user.getPhone());
pstmt.setString(5, user.getEmail());
pstmt.setString(6, user.getStudentId());
pstmt.setString(7, user.getDormitory());
pstmt.setTimestamp(8, Timestamp.valueOf(user.getCreateTime()));
pstmt.setTimestamp(9, Timestamp.valueOf(user.getUpdateTime()));
pstmt.setInt(10, user.getStatus());
int affectedRows = pstmt.executeUpdate();
if (affectedRows > 0) {
ResultSet rs = pstmt.getGeneratedKeys();
if (rs.next()) {
user.setUserId(rs.getString(1));
}
return true;
}
} catch (SQLException e) {
System.err.println("添加用户失败:" + e.getMessage());
}
return false;
}
/**
* ID
* @param userId ID
* @return null
*/
public User getUserById(String userId) {
String sql = "SELECT * FROM users WHERE user_id = ? AND status = 0";
try (Connection conn = DatabaseUtil.getConnection();
PreparedStatement pstmt = conn.prepareStatement(sql)) {
pstmt.setString(1, userId);
ResultSet rs = pstmt.executeQuery();
if (rs.next()) {
return extractUserFromResultSet(rs);
}
} catch (SQLException e) {
System.err.println("查询用户失败:" + e.getMessage());
}
return null;
}
/**
*
* @param username
* @return null
*/
public User getUserByUsername(String username) {
String sql = "SELECT * FROM users WHERE username = ? AND status = 0";
try (Connection conn = DatabaseUtil.getConnection();
PreparedStatement pstmt = conn.prepareStatement(sql)) {
pstmt.setString(1, username);
ResultSet rs = pstmt.executeQuery();
if (rs.next()) {
return extractUserFromResultSet(rs);
}
} catch (SQLException e) {
System.err.println("查询用户失败:" + e.getMessage());
}
return null;
}
/**
*
* @param user
* @return
*/
public boolean updateUser(User user) {
String sql = "UPDATE users SET username = ?, password = ?, real_name = ?, phone = ?, email = ?, student_id = ?, dormitory = ?, update_time = ?, status = ? WHERE user_id = ?";
try (Connection conn = DatabaseUtil.getConnection();
PreparedStatement pstmt = conn.prepareStatement(sql)) {
pstmt.setString(1, user.getUsername());
pstmt.setString(2, user.getPassword());
pstmt.setString(3, user.getRealName());
pstmt.setString(4, user.getPhone());
pstmt.setString(5, user.getEmail());
pstmt.setString(6, user.getStudentId());
pstmt.setString(7, user.getDormitory());
pstmt.setTimestamp(8, Timestamp.valueOf(LocalDateTime.now()));
pstmt.setInt(9, user.getStatus());
pstmt.setString(10, user.getUserId());
int affectedRows = pstmt.executeUpdate();
return affectedRows > 0;
} catch (SQLException e) {
System.err.println("更新用户失败:" + e.getMessage());
}
return false;
}
/**
*
* @param userId ID
* @return
*/
public boolean deleteUser(String userId) {
String sql = "UPDATE users SET status = 1, update_time = ? WHERE user_id = ?";
try (Connection conn = DatabaseUtil.getConnection();
PreparedStatement pstmt = conn.prepareStatement(sql)) {
pstmt.setTimestamp(1, Timestamp.valueOf(LocalDateTime.now()));
pstmt.setString(2, userId);
int affectedRows = pstmt.executeUpdate();
return affectedRows > 0;
} catch (SQLException e) {
System.err.println("删除用户失败:" + e.getMessage());
}
return false;
}
/**
*
* @return
*/
public List<User> getAllUsers() {
List<User> users = new ArrayList<>();
String sql = "SELECT * FROM users WHERE status = 0 ORDER BY create_time DESC";
try (Connection conn = DatabaseUtil.getConnection();
PreparedStatement pstmt = conn.prepareStatement(sql);
ResultSet rs = pstmt.executeQuery()) {
while (rs.next()) {
users.add(extractUserFromResultSet(rs));
}
} catch (SQLException e) {
System.err.println("获取用户列表失败:" + e.getMessage());
}
return users;
}
/**
* ResultSet
* @param rs ResultSet
* @return
* @throws SQLException SQL
*/
private User extractUserFromResultSet(ResultSet rs) throws SQLException {
User user = new User();
user.setUserId(rs.getString("user_id"));
user.setUsername(rs.getString("username"));
user.setPassword(rs.getString("password"));
user.setRealName(rs.getString("real_name"));
user.setPhone(rs.getString("phone"));
user.setEmail(rs.getString("email"));
user.setStudentId(rs.getString("student_id"));
user.setDormitory(rs.getString("dormitory"));
user.setCreateTime(rs.getTimestamp("create_time").toLocalDateTime());
user.setUpdateTime(rs.getTimestamp("update_time").toLocalDateTime());
user.setStatus(rs.getInt("status"));
return user;
}
}

@ -0,0 +1,153 @@
package com.campus.pickup.model;
import java.time.LocalDateTime;
/**
*
*
*/
public class Message {
private String messageId;
private String senderId;
private String receiverId;
private String content;
private LocalDateTime sendTime;
private LocalDateTime readTime;
private int status; // 0-未读 1-已读 2-已删除
private MessageType type; // 消息类型:系统通知、用户消息、订单消息等
public enum MessageType {
SYSTEM_NOTIFICATION(0, "系统通知"),
USER_MESSAGE(1, "用户消息"),
ORDER_MESSAGE(2, "订单消息"),
REVIEW_MESSAGE(3, "评价消息");
private final int code;
private final String description;
MessageType(int code, String description) {
this.code = code;
this.description = description;
}
public int getCode() {
return code;
}
public String getDescription() {
return description;
}
public static MessageType fromCode(int code) {
for (MessageType type : MessageType.values()) {
if (type.getCode() == code) {
return type;
}
}
return null;
}
}
public Message() {
this.sendTime = LocalDateTime.now();
this.status = 0;
this.type = MessageType.USER_MESSAGE;
}
public Message(String senderId, String receiverId, String content, MessageType type) {
this();
this.senderId = senderId;
this.receiverId = receiverId;
this.content = content;
this.type = type;
}
public Message(String messageId, String senderId, String receiverId, String content, LocalDateTime sendTime, LocalDateTime readTime, int status, MessageType type) {
this.messageId = messageId;
this.senderId = senderId;
this.receiverId = receiverId;
this.content = content;
this.sendTime = sendTime;
this.readTime = readTime;
this.status = status;
this.type = type;
}
public String getMessageId() {
return messageId;
}
public void setMessageId(String messageId) {
this.messageId = messageId;
}
public String getSenderId() {
return senderId;
}
public void setSenderId(String senderId) {
this.senderId = senderId;
}
public String getReceiverId() {
return receiverId;
}
public void setReceiverId(String receiverId) {
this.receiverId = receiverId;
}
public String getContent() {
return content;
}
public void setContent(String content) {
this.content = content;
}
public LocalDateTime getSendTime() {
return sendTime;
}
public void setSendTime(LocalDateTime sendTime) {
this.sendTime = sendTime;
}
public LocalDateTime getReadTime() {
return readTime;
}
public void setReadTime(LocalDateTime readTime) {
this.readTime = readTime;
}
public int getStatus() {
return status;
}
public void setStatus(int status) {
this.status = status;
}
public MessageType getType() {
return type;
}
public void setType(MessageType type) {
this.type = type;
}
@Override
public String toString() {
return "Message{" +
"messageId='" + messageId + '\'' +
", senderId='" + senderId + '\'' +
", receiverId='" + receiverId + '\'' +
", content='" + content + '\'' +
", sendTime=" + sendTime +
", readTime=" + readTime +
", status=" + status +
", type=" + type +
'}';
}
}

@ -0,0 +1,252 @@
package com.campus.pickup.model;
import java.time.LocalDateTime;
import java.math.BigDecimal;
/**
*
*
*/
public class Order {
private String orderId;
private String orderNumber; // 订单编号
private String customerId; // 下单用户ID
private String deliveryPersonId; // 配送员ID
private String itemType; // 物品类型(快递、外卖、文件等)
private String description; // 物品描述
private String pickupLocation; // 取件地点
private String deliveryLocation; // 配送地点
private BigDecimal fee; // 配送费用
private LocalDateTime pickupTime; // 预计取件时间
private LocalDateTime deliveryTime; // 实际送达时间
private LocalDateTime createTime; // 创建时间
private LocalDateTime updateTime; // 更新时间
private OrderStatus status; // 订单状态
private String remarks; // 备注
public enum OrderStatus {
PENDING(0, "待接单"),
ACCEPTED(1, "已接单"),
PICKED_UP(2, "已取件"),
DELIVERING(3, "配送中"),
COMPLETED(4, "已完成"),
CANCELLED(5, "已取消");
private final int code;
private final String description;
OrderStatus(int code, String description) {
this.code = code;
this.description = description;
}
public int getCode() {
return code;
}
public String getDescription() {
return description;
}
public static OrderStatus fromCode(int code) {
for (OrderStatus status : OrderStatus.values()) {
if (status.getCode() == code) {
return status;
}
}
return null;
}
}
public Order() {
this.createTime = LocalDateTime.now();
this.updateTime = LocalDateTime.now();
this.status = OrderStatus.PENDING;
this.fee = BigDecimal.ZERO;
}
public Order(String customerId, String itemType, String description,
String pickupLocation, String deliveryLocation, BigDecimal fee,
LocalDateTime pickupTime, String remarks) {
this();
this.orderNumber = generateOrderNumber();
this.customerId = customerId;
this.itemType = itemType;
this.description = description;
this.pickupLocation = pickupLocation;
this.deliveryLocation = deliveryLocation;
this.fee = fee;
this.pickupTime = pickupTime;
this.remarks = remarks;
}
public Order(String orderId, String orderNumber, String customerId, String deliveryPersonId,
String itemType, String description, String pickupLocation, String deliveryLocation,
BigDecimal fee, LocalDateTime pickupTime, LocalDateTime deliveryTime,
LocalDateTime createTime, LocalDateTime updateTime, OrderStatus status, String remarks) {
this.orderId = orderId;
this.orderNumber = orderNumber;
this.customerId = customerId;
this.deliveryPersonId = deliveryPersonId;
this.itemType = itemType;
this.description = description;
this.pickupLocation = pickupLocation;
this.deliveryLocation = deliveryLocation;
this.fee = fee;
this.pickupTime = pickupTime;
this.deliveryTime = deliveryTime;
this.createTime = createTime;
this.updateTime = updateTime;
this.status = status;
this.remarks = remarks;
}
/**
*
* @return
*/
private String generateOrderNumber() {
return "ORD" + System.currentTimeMillis();
}
public String getOrderId() {
return orderId;
}
public void setOrderId(String orderId) {
this.orderId = orderId;
}
public String getOrderNumber() {
return orderNumber;
}
public void setOrderNumber(String orderNumber) {
this.orderNumber = orderNumber;
}
public String getCustomerId() {
return customerId;
}
public void setCustomerId(String customerId) {
this.customerId = customerId;
}
public String getDeliveryPersonId() {
return deliveryPersonId;
}
public void setDeliveryPersonId(String deliveryPersonId) {
this.deliveryPersonId = deliveryPersonId;
}
public String getItemType() {
return itemType;
}
public void setItemType(String itemType) {
this.itemType = itemType;
}
public String getDescription() {
return description;
}
public void setDescription(String description) {
this.description = description;
}
public String getPickupLocation() {
return pickupLocation;
}
public void setPickupLocation(String pickupLocation) {
this.pickupLocation = pickupLocation;
}
public String getDeliveryLocation() {
return deliveryLocation;
}
public void setDeliveryLocation(String deliveryLocation) {
this.deliveryLocation = deliveryLocation;
}
public BigDecimal getFee() {
return fee;
}
public void setFee(BigDecimal fee) {
this.fee = fee;
}
public LocalDateTime getPickupTime() {
return pickupTime;
}
public void setPickupTime(LocalDateTime pickupTime) {
this.pickupTime = pickupTime;
}
public LocalDateTime getDeliveryTime() {
return deliveryTime;
}
public void setDeliveryTime(LocalDateTime deliveryTime) {
this.deliveryTime = deliveryTime;
}
public LocalDateTime getCreateTime() {
return createTime;
}
public void setCreateTime(LocalDateTime createTime) {
this.createTime = createTime;
}
public LocalDateTime getUpdateTime() {
return updateTime;
}
public void setUpdateTime(LocalDateTime updateTime) {
this.updateTime = updateTime;
}
public OrderStatus getStatus() {
return status;
}
public void setStatus(OrderStatus status) {
this.status = status;
}
public String getRemarks() {
return remarks;
}
public void setRemarks(String remarks) {
this.remarks = remarks;
}
@Override
public String toString() {
return "Order{" +
"orderId='" + orderId + '\'' +
", orderNumber='" + orderNumber + '\'' +
", customerId='" + customerId + '\'' +
", deliveryPersonId='" + deliveryPersonId + '\'' +
", itemType='" + itemType + '\'' +
", description='" + description + '\'' +
", pickupLocation='" + pickupLocation + '\'' +
", deliveryLocation='" + deliveryLocation + '\'' +
", fee=" + fee +
", pickupTime=" + pickupTime +
", deliveryTime=" + deliveryTime +
", createTime=" + createTime +
", updateTime=" + updateTime +
", status=" + status +
", remarks='" + remarks + '\'' +
'}';
}
}

@ -0,0 +1,133 @@
package com.campus.pickup.model;
import java.time.LocalDateTime;
/**
*
*
*/
public class Review {
private String reviewId;
private String orderId;
private String reviewerId; // 评价人ID
private String reviewedId; // 被评价人ID
private int rating; // 评分 1-5星
private String content; // 评价内容
private LocalDateTime createTime;
private LocalDateTime updateTime;
private int status; // 0-正常 1-已删除
public Review() {
this.createTime = LocalDateTime.now();
this.updateTime = LocalDateTime.now();
this.status = 0;
}
public Review(String orderId, String reviewerId, String reviewedId, int rating, String content) {
this();
this.orderId = orderId;
this.reviewerId = reviewerId;
this.reviewedId = reviewedId;
this.rating = rating;
this.content = content;
}
public Review(String reviewId, String orderId, String reviewerId, String reviewedId, int rating, String content, LocalDateTime createTime, LocalDateTime updateTime, int status) {
this.reviewId = reviewId;
this.orderId = orderId;
this.reviewerId = reviewerId;
this.reviewedId = reviewedId;
this.rating = rating;
this.content = content;
this.createTime = createTime;
this.updateTime = updateTime;
this.status = status;
}
public String getReviewId() {
return reviewId;
}
public void setReviewId(String reviewId) {
this.reviewId = reviewId;
}
public String getOrderId() {
return orderId;
}
public void setOrderId(String orderId) {
this.orderId = orderId;
}
public String getReviewerId() {
return reviewerId;
}
public void setReviewerId(String reviewerId) {
this.reviewerId = reviewerId;
}
public String getReviewedId() {
return reviewedId;
}
public void setReviewedId(String reviewedId) {
this.reviewedId = reviewedId;
}
public int getRating() {
return rating;
}
public void setRating(int rating) {
this.rating = rating;
}
public String getContent() {
return content;
}
public void setContent(String content) {
this.content = content;
}
public LocalDateTime getCreateTime() {
return createTime;
}
public void setCreateTime(LocalDateTime createTime) {
this.createTime = createTime;
}
public LocalDateTime getUpdateTime() {
return updateTime;
}
public void setUpdateTime(LocalDateTime updateTime) {
this.updateTime = updateTime;
}
public int getStatus() {
return status;
}
public void setStatus(int status) {
this.status = status;
}
@Override
public String toString() {
return "Review{" +
"reviewId='" + reviewId + '\'' +
", orderId='" + orderId + '\'' +
", reviewerId='" + reviewerId + '\'' +
", reviewedId='" + reviewedId + '\'' +
", rating=" + rating +
", content='" + content + '\'' +
", createTime=" + createTime +
", updateTime=" + updateTime +
", status=" + status +
'}';
}
}

@ -0,0 +1,156 @@
package com.campus.pickup.model;
import java.time.LocalDateTime;
/**
*
*
*/
public class User {
private String userId;
private String username;
private String password;
private String realName;
private String phone;
private String email;
private String studentId;
private String dormitory;
private LocalDateTime createTime;
private LocalDateTime updateTime;
private int status; // 0-正常 1-禁用
public User() {
this.createTime = LocalDateTime.now();
this.updateTime = LocalDateTime.now();
this.status = 0;
}
public User(String username, String password, String realName, String phone, String email, String studentId, String dormitory) {
this();
this.username = username;
this.password = password;
this.realName = realName;
this.phone = phone;
this.email = email;
this.studentId = studentId;
this.dormitory = dormitory;
}
public User(String userId, String username, String password, String realName, String phone, String email, String studentId, String dormitory, LocalDateTime createTime, LocalDateTime updateTime, int status) {
this.userId = userId;
this.username = username;
this.password = password;
this.realName = realName;
this.phone = phone;
this.email = email;
this.studentId = studentId;
this.dormitory = dormitory;
this.createTime = createTime;
this.updateTime = updateTime;
this.status = status;
}
public String getUserId() {
return userId;
}
public void setUserId(String userId) {
this.userId = userId;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public String getRealName() {
return realName;
}
public void setRealName(String realName) {
this.realName = realName;
}
public String getPhone() {
return phone;
}
public void setPhone(String phone) {
this.phone = phone;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
public String getStudentId() {
return studentId;
}
public void setStudentId(String studentId) {
this.studentId = studentId;
}
public String getDormitory() {
return dormitory;
}
public void setDormitory(String dormitory) {
this.dormitory = dormitory;
}
public LocalDateTime getCreateTime() {
return createTime;
}
public void setCreateTime(LocalDateTime createTime) {
this.createTime = createTime;
}
public LocalDateTime getUpdateTime() {
return updateTime;
}
public void setUpdateTime(LocalDateTime updateTime) {
this.updateTime = updateTime;
}
public int getStatus() {
return status;
}
public void setStatus(int status) {
this.status = status;
}
@Override
public String toString() {
return "User{" +
"userId='" + userId + '\'' +
", username='" + username + '\'' +
", realName='" + realName + '\'' +
", phone='" + phone + '\'' +
", email='" + email + '\'' +
", studentId='" + studentId + '\'' +
", dormitory='" + dormitory + '\'' +
", createTime=" + createTime +
", updateTime=" + updateTime +
", status=" + status +
'}';
}
}

@ -0,0 +1,119 @@
package com.campus.pickup.service;
import com.campus.pickup.dao.MessageDao;
import com.campus.pickup.model.Message;
import java.util.List;
/**
*
*
*/
public class MessageService {
private MessageDao messageDao;
/**
*
*/
public MessageService() {
this.messageDao = new MessageDao();
}
/**
*
* @param senderId ID
* @param receiverId ID
* @param content
* @param type
* @return truefalse
*/
public boolean sendMessage(String senderId, String receiverId, String content, Message.MessageType type) {
Message message = new Message();
message.setMessageId(java.util.UUID.randomUUID().toString().replace("-", ""));
message.setSenderId(senderId);
message.setReceiverId(receiverId);
message.setContent(content);
message.setSendTime(java.time.LocalDateTime.now());
message.setStatus(0); // 未读
message.setType(type);
return messageDao.addMessage(message);
}
/**
*
* @param receiverId ID
* @param content
* @return truefalse
*/
public boolean sendSystemNotification(String receiverId, String content) {
return sendMessage("system", receiverId, content, Message.MessageType.SYSTEM_NOTIFICATION);
}
/**
*
* @param messageId ID
* @return truefalse
*/
public boolean markMessageAsRead(String messageId) {
return messageDao.markMessageAsRead(messageId);
}
/**
*
* @param messageId ID
* @return
*/
public Message getMessageById(String messageId) {
return messageDao.getMessageById(messageId);
}
/**
*
* @param receiverId ID
* @return
*/
public List<Message> getReceivedMessages(String receiverId) {
return messageDao.getMessagesByReceiverId(receiverId);
}
/**
*
* @param receiverId ID
* @return
*/
public int getUnreadMessageCount(String receiverId) {
return messageDao.getUnreadMessageCount(receiverId);
}
/**
*
* @param userId1 1 ID
* @param userId2 2 ID
* @return
*/
public List<Message> getMessagesBetweenUsers(String userId1, String userId2) {
return messageDao.getMessagesBetweenUsers(userId1, userId2);
}
/**
*
* @param receiverId ID
* @return truefalse
*/
public boolean markAllMessagesAsRead(String receiverId) {
List<Message> unreadMessages = messageDao.getMessagesByReceiverId(receiverId);
boolean allSuccess = true;
for (Message message : unreadMessages) {
if (message.getStatus() == 0) { // 未读消息
boolean success = messageDao.markMessageAsRead(message.getMessageId());
if (!success) {
allSuccess = false;
}
}
}
return allSuccess;
}
}

@ -0,0 +1,277 @@
package com.campus.pickup.service;
import com.campus.pickup.dao.OrderDao;
import com.campus.pickup.model.Order;
import java.math.BigDecimal;
import java.time.LocalDateTime;
import java.util.List;
/**
*
*
*/
public class OrderService {
private OrderDao orderDao;
/**
*
*/
public OrderService() {
this.orderDao = new OrderDao();
}
/**
*
* @param customerId ID
* @param itemType
* @param description
* @param pickupLocation
* @param deliveryLocation
* @param fee
* @param pickupTime
* @param remarks
* @return null
*/
public Order createOrder(String customerId, String itemType, String description,
String pickupLocation, String deliveryLocation, BigDecimal fee,
LocalDateTime pickupTime, String remarks) {
// 验证必要参数
if (customerId == null || customerId.isEmpty() ||
itemType == null || itemType.isEmpty() ||
description == null || description.isEmpty() ||
pickupLocation == null || pickupLocation.isEmpty() ||
deliveryLocation == null || deliveryLocation.isEmpty()) {
return null;
}
// 创建订单对象
Order order = new Order(customerId, itemType, description, pickupLocation,
deliveryLocation, fee, pickupTime, remarks);
// 添加到数据库
boolean success = orderDao.addOrder(order);
if (success) {
return order;
}
return null;
}
/**
*
* @param orderId ID
* @param deliveryPersonId ID
* @return truefalse
*/
public boolean acceptOrder(String orderId, String deliveryPersonId) {
Order order = orderDao.getOrderById(orderId);
if (order == null) {
return false; // 订单不存在
}
if (order.getStatus() != Order.OrderStatus.PENDING) {
return false; // 订单状态不是待接单
}
// 更新订单状态和配送员
order.setDeliveryPersonId(deliveryPersonId);
order.setStatus(Order.OrderStatus.ACCEPTED);
order.setUpdateTime(LocalDateTime.now());
return orderDao.updateOrder(order);
}
/**
*
* @param orderId ID
* @return truefalse
*/
public boolean confirmPickup(String orderId) {
Order order = orderDao.getOrderById(orderId);
if (order == null) {
return false; // 订单不存在
}
if (order.getStatus() != Order.OrderStatus.ACCEPTED) {
return false; // 订单状态不是已接单
}
// 更新订单状态
order.setStatus(Order.OrderStatus.PICKED_UP);
order.setUpdateTime(LocalDateTime.now());
return orderDao.updateOrder(order);
}
/**
*
* @param orderId ID
* @return truefalse
*/
public boolean startDelivery(String orderId) {
Order order = orderDao.getOrderById(orderId);
if (order == null) {
return false; // 订单不存在
}
if (order.getStatus() != Order.OrderStatus.PICKED_UP) {
return false; // 订单状态不是已取件
}
// 更新订单状态
order.setStatus(Order.OrderStatus.DELIVERING);
order.setUpdateTime(LocalDateTime.now());
return orderDao.updateOrder(order);
}
/**
*
* @param orderId ID
* @return truefalse
*/
public boolean completeDelivery(String orderId) {
Order order = orderDao.getOrderById(orderId);
if (order == null) {
return false; // 订单不存在
}
if (order.getStatus() != Order.OrderStatus.DELIVERING) {
return false; // 订单状态不是配送中
}
// 更新订单状态和送达时间
order.setStatus(Order.OrderStatus.COMPLETED);
order.setDeliveryTime(LocalDateTime.now());
order.setUpdateTime(LocalDateTime.now());
return orderDao.updateOrder(order);
}
/**
*
* @param orderId ID
* @return truefalse
*/
public boolean cancelOrder(String orderId) {
Order order = orderDao.getOrderById(orderId);
if (order == null) {
return false; // 订单不存在
}
if (order.getStatus() == Order.OrderStatus.COMPLETED ||
order.getStatus() == Order.OrderStatus.CANCELLED) {
return false; // 已完成或已取消的订单不能取消
}
// 更新订单状态
order.setStatus(Order.OrderStatus.CANCELLED);
order.setUpdateTime(LocalDateTime.now());
return orderDao.updateOrder(order);
}
/**
* ID
* @param orderId ID
* @return
*/
public Order getOrderById(String orderId) {
return orderDao.getOrderById(orderId);
}
/**
*
* @param orderNumber
* @return
*/
public Order getOrderByNumber(String orderNumber) {
return orderDao.getOrderByNumber(orderNumber);
}
/**
*
* @param customerId ID
* @return
*/
public List<Order> getOrdersByCustomerId(String customerId) {
return orderDao.getOrdersByCustomerId(customerId);
}
/**
*
* @param deliveryPersonId ID
* @return
*/
public List<Order> getOrdersByDeliveryPersonId(String deliveryPersonId) {
return orderDao.getOrdersByDeliveryPersonId(deliveryPersonId);
}
/**
*
* @param status
* @return
*/
public List<Order> getOrdersByStatus(Order.OrderStatus status) {
return orderDao.getOrdersByStatus(status);
}
/**
*
* @return
*/
public List<Order> getAllOrders() {
return orderDao.getAllOrders();
}
/**
*
* @param order
* @return truefalse
*/
public boolean updateOrder(Order order) {
if (order == null || order.getOrderId() == null || order.getOrderId().isEmpty()) {
return false;
}
// 确保更新时间是最新的
order.setUpdateTime(LocalDateTime.now());
return orderDao.updateOrder(order);
}
/**
*
* @param orderId ID
* @param userId ID
* @return truefalse
*/
public boolean canUserOperateOrder(String orderId, String userId) {
Order order = orderDao.getOrderById(orderId);
if (order == null) {
return false; // 订单不存在
}
// 客户可以操作自己的订单
if (order.getCustomerId().equals(userId)) {
return true;
}
// 配送员可以操作分配给自己的订单
if (order.getDeliveryPersonId() != null &&
order.getDeliveryPersonId().equals(userId)) {
return true;
}
return false;
}
}

@ -0,0 +1,138 @@
package com.campus.pickup.service;
import com.campus.pickup.dao.ReviewDao;
import com.campus.pickup.model.Review;
import java.util.List;
/**
*
*
*/
public class ReviewService {
private ReviewDao reviewDao;
/**
*
*/
public ReviewService() {
this.reviewDao = new ReviewDao();
}
/**
*
* @param orderId ID
* @param reviewerId ID
* @param reviewedId ID
* @param rating 1-5
* @param content
* @return truefalse
*/
public boolean addReview(String orderId, String reviewerId, String reviewedId, int rating, String content) {
// 检查评分是否有效
if (rating < 1 || rating > 5) {
return false;
}
// 检查该订单是否已经评价过
Review existingReview = reviewDao.getReviewByOrderId(orderId);
if (existingReview != null) {
return false; // 该订单已评价过
}
Review review = new Review();
review.setReviewId(java.util.UUID.randomUUID().toString().replace("-", ""));
review.setOrderId(orderId);
review.setReviewerId(reviewerId);
review.setReviewedId(reviewedId);
review.setRating(rating);
review.setContent(content);
review.setCreateTime(java.time.LocalDateTime.now());
review.setUpdateTime(java.time.LocalDateTime.now());
review.setStatus(0); // 正常状态
return reviewDao.addReview(review);
}
/**
* ID
* @param reviewId ID
* @return
*/
public Review getReviewById(String reviewId) {
return reviewDao.getReviewById(reviewId);
}
/**
* ID
* @param orderId ID
* @return
*/
public Review getReviewByOrderId(String orderId) {
return reviewDao.getReviewByOrderId(orderId);
}
/**
*
* @param userId ID
* @return
*/
public List<Review> getReviewsReceivedByUser(String userId) {
return reviewDao.getReviewsByReviewedId(userId);
}
/**
*
* @param userId ID
* @return
*/
public double getAverageRatingForUser(String userId) {
return reviewDao.getAverageRatingByUserId(userId);
}
/**
*
* @param reviewId ID
* @param rating 1-5
* @param content
* @return truefalse
*/
public boolean updateReview(String reviewId, int rating, String content) {
// 检查评分是否有效
if (rating < 1 || rating > 5) {
return false;
}
Review review = reviewDao.getReviewById(reviewId);
if (review != null) {
review.setRating(rating);
review.setContent(content);
review.setUpdateTime(java.time.LocalDateTime.now());
return reviewDao.updateReview(review);
}
return false;
}
/**
*
* @param reviewId ID
* @return truefalse
*/
public boolean deleteReview(String reviewId) {
return reviewDao.deleteReview(reviewId);
}
/**
*
* @param orderId ID
* @param userId ID
* @return truefalse
*/
public boolean canUserReviewOrder(String orderId, String userId) {
Review review = reviewDao.getReviewByOrderId(orderId);
if (review == null) {
return true; // 订单未被评价过
}
return review.getReviewerId().equals(userId); // 只有评价者本人可以修改评价
}
}

@ -0,0 +1,116 @@
package com.campus.pickup.service;
import com.campus.pickup.dao.UserDao;
import com.campus.pickup.model.User;
import java.util.List;
/**
*
*
*/
public class UserService {
private UserDao userDao;
/**
*
*/
public UserService() {
this.userDao = new UserDao();
}
/**
*
* @param user
* @return truefalse
*/
public boolean register(User user) {
// 检查用户名是否已存在
User existingUser = userDao.getUserByUsername(user.getUsername());
if (existingUser != null) {
return false; // 用户名已存在
}
// 设置创建时间和更新时间
user.setCreateTime(java.time.LocalDateTime.now());
user.setUpdateTime(java.time.LocalDateTime.now());
user.setStatus(0); // 默认状态为正常
// 添加用户到数据库
return userDao.addUser(user);
}
/**
*
* @param username
* @param password
* @return null
*/
public User login(String username, String password) {
User user = userDao.getUserByUsername(username);
if (user != null && user.getPassword().equals(password) && user.getStatus() == 0) {
return user; // 登录成功
}
return null; // 登录失败
}
/**
* ID
* @param userId ID
* @return
*/
public User getUserById(String userId) {
return userDao.getUserById(userId);
}
/**
*
* @param user
* @return truefalse
*/
public boolean updateUser(User user) {
user.setUpdateTime(java.time.LocalDateTime.now());
return userDao.updateUser(user);
}
/**
*
* @param userId ID
* @param oldPassword
* @param newPassword
* @return truefalse
*/
public boolean changePassword(String userId, String oldPassword, String newPassword) {
User user = userDao.getUserById(userId);
if (user != null && user.getPassword().equals(oldPassword)) {
user.setPassword(newPassword);
user.setUpdateTime(java.time.LocalDateTime.now());
return userDao.updateUser(user);
}
return false;
}
/**
* /
* @param userId ID
* @param status 0-1-
* @return truefalse
*/
public boolean changeUserStatus(String userId, int status) {
User user = userDao.getUserById(userId);
if (user != null) {
user.setStatus(status);
user.setUpdateTime(java.time.LocalDateTime.now());
return userDao.updateUser(user);
}
return false;
}
/**
*
* @return
*/
public List<User> getAllUsers() {
return userDao.getAllUsers();
}
}

@ -0,0 +1,69 @@
package com.campus.pickup.util;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.Properties;
/**
*
*
*/
public class DatabaseUtil {
private static final String DRIVER = "org.postgresql.Driver";
private static final String URL = "jdbc:postgresql://localhost:5432/campus_pickup";
private static final String USERNAME = "postgres";
private static final String PASSWORD = "postgres";
static {
try {
Class.forName(DRIVER);
} catch (ClassNotFoundException e) {
System.err.println("加载数据库驱动失败:" + e.getMessage());
}
}
/**
*
* @return
* @throws SQLException
*/
public static Connection getConnection() throws SQLException {
Properties props = new Properties();
props.setProperty("user", USERNAME);
props.setProperty("password", PASSWORD);
props.setProperty("ssl", "false");
return DriverManager.getConnection(URL, props);
}
/**
*
* @param conn
*/
public static void closeConnection(Connection conn) {
if (conn != null) {
try {
conn.close();
} catch (SQLException e) {
System.err.println("关闭数据库连接失败:" + e.getMessage());
}
}
}
/**
*
* @return
*/
public static boolean testConnection() {
Connection conn = null;
try {
conn = getConnection();
return conn != null && !conn.isClosed();
} catch (SQLException e) {
System.err.println("数据库连接测试失败:" + e.getMessage());
return false;
} finally {
closeConnection(conn);
}
}
}

@ -0,0 +1,144 @@
package com.campus.pickup.view;
import com.campus.pickup.model.User;
/**
*
*
*/
public class MainView {
private UserView userView;
private MessageView messageView;
private ReviewView reviewView;
private OrderView orderView;
/**
*
*/
public MainView() {
this.userView = new UserView();
this.messageView = new MessageView();
this.reviewView = new ReviewView();
this.orderView = new OrderView();
}
/**
*
*/
public void showWelcomeScreen() {
System.out.println("========================================");
System.out.println(" 欢迎使用校园代取系统");
System.out.println("========================================");
System.out.println("本系统提供以下功能:");
System.out.println("- 用户注册与登录");
System.out.println("- 个人信息管理");
System.out.println("- 消息交流");
System.out.println("- 评价管理");
System.out.println("- 订单配送管理");
System.out.println("========================================");
}
/**
*
* @return
*/
public int showMainMenu() {
System.out.println("\n===== 校园代取系统 - 主菜单 =====");
System.out.println("1. 用户注册");
System.out.println("2. 用户登录");
System.out.println("0. 退出系统");
System.out.print("请选择操作: ");
try {
java.util.Scanner scanner = new java.util.Scanner(System.in);
int choice = Integer.parseInt(scanner.nextLine());
return choice;
} catch (NumberFormatException e) {
System.out.println("请输入有效的数字选项!");
return -1;
}
}
/**
*
*/
public void run() {
showWelcomeScreen();
User currentUser = null;
int choice;
do {
if (currentUser == null) {
choice = showMainMenu();
switch (choice) {
case 1:
userView.showRegistrationForm();
break;
case 2:
currentUser = userView.showLoginForm();
break;
case 0:
System.out.println("感谢使用校园代取系统,再见!");
break;
default:
System.out.println("无效的选项,请重新选择!");
break;
}
} else {
choice = userView.showUserMenu(currentUser);
switch (choice) {
case 1:
userView.showUserInfo(currentUser.getUserId());
break;
case 2:
userView.showUpdateUserInfoForm(currentUser.getUserId());
break;
case 3:
userView.showChangePasswordForm(currentUser.getUserId());
break;
case 4:
messageView.handleMessageManagement(currentUser);
break;
case 5:
reviewView.handleReviewManagement(currentUser);
break;
case 6:
orderView.showOrderMenu();
break;
case 0:
System.out.println("已退出登录,返回主菜单...");
currentUser = null;
break;
default:
System.out.println("无效的选项,请重新选择!");
break;
}
}
} while (choice != 0 || currentUser != null);
// 关闭资源
closeResources();
}
/**
*
*/
private void closeResources() {
userView.close();
messageView.close();
reviewView.close();
orderView.close();
}
/**
*
* @param args
*/
public static void main(String[] args) {
MainView mainView = new MainView();
mainView.run();
}
}

@ -0,0 +1,287 @@
package com.campus.pickup.view;
import com.campus.pickup.controller.MessageController;
import com.campus.pickup.model.Message;
import com.campus.pickup.model.User;
import java.util.List;
import java.util.Map;
import java.util.Scanner;
/**
*
*
*/
public class MessageView {
private MessageController messageController;
private Scanner scanner;
/**
*
*/
public MessageView() {
this.messageController = new MessageController();
this.scanner = new Scanner(System.in);
}
/**
*
* @param senderId ID
*/
public void showSendMessageForm(String senderId) {
System.out.println("\n===== 发送消息 =====");
System.out.print("请输入接收者用户名或ID: ");
String receiverId = scanner.nextLine();
System.out.println("消息类型:");
System.out.println("1. 用户消息");
System.out.println("2. 订单消息");
System.out.println("3. 评价消息");
System.out.print("请选择消息类型: ");
int typeChoice;
try {
typeChoice = Integer.parseInt(scanner.nextLine());
if (typeChoice < 1 || typeChoice > 3) {
System.out.println("无效的消息类型!");
return;
}
} catch (NumberFormatException e) {
System.out.println("请输入有效的数字选项!");
return;
}
System.out.print("请输入消息内容: ");
String content = scanner.nextLine();
// 调用控制器发送消息
Map<String, Object> result = messageController.sendMessage(senderId, receiverId, content, typeChoice);
if ((boolean) result.get("success")) {
System.out.println("消息发送成功!");
} else {
System.out.println("消息发送失败: " + result.get("message"));
}
}
/**
*
* @param receiverId ID
*/
public void showReceivedMessages(String receiverId) {
System.out.println("\n===== 收到的消息 =====");
Map<String, Object> result = messageController.getReceivedMessages(receiverId);
if ((boolean) result.get("success")) {
List<Message> messages = (List<Message>) result.get("messages");
if (messages.isEmpty()) {
System.out.println("您没有收到任何消息。");
return;
}
System.out.println("消息总数: " + messages.size());
System.out.println("----------------------------------------");
for (Message message : messages) {
String statusText = message.getStatus() == 0 ? "未读" : "已读";
System.out.println("消息ID: " + message.getMessageId());
System.out.println("发送者ID: " + message.getSenderId());
System.out.println("消息类型: " + message.getType().getDescription());
System.out.println("消息内容: " + message.getContent());
System.out.println("发送时间: " + message.getSendTime());
System.out.println("状态: " + statusText);
System.out.println("----------------------------------------");
}
} else {
System.out.println("获取消息列表失败: " + result.get("message"));
}
}
/**
*
* @param receiverId ID
*/
public void showUnreadMessageCount(String receiverId) {
Map<String, Object> result = messageController.getUnreadMessageCount(receiverId);
if ((boolean) result.get("success")) {
int count = (int) result.get("unreadCount");
System.out.println("您有 " + count + " 条未读消息。");
} else {
System.out.println("获取未读消息数量失败: " + result.get("message"));
}
}
/**
*
* @param messageId ID
*/
public void showMessageDetail(String messageId) {
System.out.println("\n===== 消息详情 =====");
Map<String, Object> result = messageController.getMessageDetail(messageId);
if ((boolean) result.get("success")) {
Message message = (Message) result.get("message");
String statusText = message.getStatus() == 0 ? "未读" : "已读";
System.out.println("消息ID: " + message.getMessageId());
System.out.println("发送者ID: " + message.getSenderId());
System.out.println("接收者ID: " + message.getReceiverId());
System.out.println("消息类型: " + message.getType().getDescription());
System.out.println("消息内容: " + message.getContent());
System.out.println("发送时间: " + message.getSendTime());
System.out.println("阅读时间: " + message.getReadTime());
System.out.println("状态: " + statusText);
// 如果消息未读,询问是否标记为已读
if (message.getStatus() == 0) {
System.out.print("\n是否标记为已读(y/n): ");
String choice = scanner.nextLine();
if (choice.equalsIgnoreCase("y")) {
markMessageAsRead(messageId);
}
}
} else {
System.out.println("获取消息详情失败: " + result.get("message"));
}
}
/**
*
* @param messageId ID
*/
public void markMessageAsRead(String messageId) {
Map<String, Object> result = messageController.markMessageAsRead(messageId);
if ((boolean) result.get("success")) {
System.out.println("消息已标记为已读。");
} else {
System.out.println("标记消息为已读失败: " + result.get("message"));
}
}
/**
*
* @param receiverId ID
*/
public void markAllMessagesAsRead(String receiverId) {
Map<String, Object> result = messageController.markAllMessagesAsRead(receiverId);
if ((boolean) result.get("success")) {
System.out.println("所有消息已标记为已读。");
} else {
System.out.println("批量标记消息为已读失败: " + result.get("message"));
}
}
/**
*
* @param userId1 ID
*/
public void showChatHistory(String userId1) {
System.out.println("\n===== 查看聊天记录 =====");
System.out.print("请输入对方用户名或ID: ");
String userId2 = scanner.nextLine();
Map<String, Object> result = messageController.getMessagesBetweenUsers(userId1, userId2);
if ((boolean) result.get("success")) {
List<Message> messages = (List<Message>) result.get("messages");
if (messages.isEmpty()) {
System.out.println("您与该用户没有聊天记录。");
return;
}
System.out.println("聊天记录总数: " + messages.size());
System.out.println("----------------------------------------");
for (Message message : messages) {
String senderName = message.getSenderId().equals(userId1) ? "我" : message.getSenderId();
System.out.println(senderName + " (" + message.getSendTime() + "):");
System.out.println(message.getContent());
System.out.println("----------------------------------------");
}
} else {
System.out.println("获取聊天记录失败: " + result.get("message"));
}
}
/**
*
* @param user
* @return
*/
public int showMessageMenu(User user) {
System.out.println("\n===== 消息管理 =====");
System.out.println("1. 查看未读消息数量");
System.out.println("2. 查看收到的消息");
System.out.println("3. 发送消息");
System.out.println("4. 查看聊天记录");
System.out.println("5. 标记所有消息为已读");
System.out.println("0. 返回上一级");
System.out.print("请选择操作: ");
try {
int choice = Integer.parseInt(scanner.nextLine());
return choice;
} catch (NumberFormatException e) {
System.out.println("请输入有效的数字选项!");
return -1;
}
}
/**
*
* @param user
*/
public void handleMessageManagement(User user) {
int choice;
do {
choice = showMessageMenu(user);
switch (choice) {
case 1:
showUnreadMessageCount(user.getUserId());
break;
case 2:
showReceivedMessages(user.getUserId());
System.out.print("\n输入消息ID查看详情(留空返回): ");
String messageId = scanner.nextLine();
if (!messageId.isEmpty()) {
showMessageDetail(messageId);
}
break;
case 3:
showSendMessageForm(user.getUserId());
break;
case 4:
showChatHistory(user.getUserId());
break;
case 5:
markAllMessagesAsRead(user.getUserId());
break;
case 0:
System.out.println("返回上一级菜单...");
break;
default:
System.out.println("无效的选项,请重新选择!");
break;
}
} while (choice != 0);
}
/**
*
*/
public void close() {
if (scanner != null) {
scanner.close();
}
}
}

@ -0,0 +1,401 @@
package com.campus.pickup.view;
import com.campus.pickup.controller.OrderController;
import com.campus.pickup.model.Order;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.List;
import java.util.Map;
import java.util.Scanner;
/**
*
*
*/
public class OrderView {
private OrderController orderController;
private Scanner scanner;
public OrderView() {
this.orderController = new OrderController();
this.scanner = new Scanner(System.in);
}
/**
*
*/
public void showOrderMenu() {
boolean running = true;
while (running) {
System.out.println("\n===== 订单管理 =====");
System.out.println("1. 创建订单");
System.out.println("2. 查看我的订单");
System.out.println("3. 查看所有订单");
System.out.println("4. 查看待接单订单");
System.out.println("5. 接单");
System.out.println("6. 更新订单状态");
System.out.println("7. 返回主菜单");
System.out.print("请选择操作: ");
String choice = scanner.nextLine();
switch (choice) {
case "1":
createOrder();
break;
case "2":
viewMyOrders();
break;
case "3":
viewAllOrders();
break;
case "4":
viewPendingOrders();
break;
case "5":
acceptOrder();
break;
case "6":
updateOrderStatus();
break;
case "7":
running = false;
break;
default:
System.out.println("无效选择,请重新输入。");
break;
}
}
}
/**
*
*/
private void createOrder() {
System.out.println("\n===== 创建订单 =====");
System.out.print("请输入客户ID: ");
String customerId = scanner.nextLine();
System.out.print("请输入物品类型(如:快递、外卖、文件等): ");
String itemType = scanner.nextLine();
System.out.print("请输入物品描述: ");
String description = scanner.nextLine();
System.out.print("请输入取件地点: ");
String pickupLocation = scanner.nextLine();
System.out.print("请输入配送地点: ");
String deliveryLocation = scanner.nextLine();
System.out.print("请输入配送费用(可选,直接回车跳过): ");
String feeStr = scanner.nextLine();
System.out.print("请输入预计取件时间格式yyyy-MM-dd HH:mm可选直接回车跳过: ");
String pickupTimeStr = scanner.nextLine();
System.out.print("请输入备注(可选,直接回车跳过): ");
String remarks = scanner.nextLine();
// 调用控制器创建订单
Map<String, Object> result = orderController.createOrder(
customerId, itemType, description, pickupLocation,
deliveryLocation, feeStr, pickupTimeStr, remarks
);
if ((Boolean) result.get("success")) {
Order order = (Order) result.get("order");
System.out.println("订单创建成功!");
System.out.println("订单号: " + order.getOrderNumber());
System.out.println("订单ID: " + order.getOrderId());
System.out.println("订单状态: " + order.getStatus().getDescription());
} else {
System.out.println("订单创建失败: " + result.get("message"));
}
}
/**
*
*/
private void viewMyOrders() {
System.out.println("\n===== 查看我的订单 =====");
System.out.print("请输入您的ID客户或配送员: ");
String userId = scanner.nextLine();
System.out.println("请选择角色: ");
System.out.println("1. 客户");
System.out.println("2. 配送员");
System.out.print("请选择: ");
String roleChoice = scanner.nextLine();
List<Order> orders;
if ("1".equals(roleChoice)) {
Map<String, Object> result = orderController.getOrdersByCustomerId(userId);
if ((Boolean) result.get("success")) {
orders = (List<Order>) result.get("orders");
} else {
System.out.println("获取订单失败: " + result.get("message"));
return;
}
} else if ("2".equals(roleChoice)) {
Map<String, Object> result = orderController.getOrdersByDeliveryPersonId(userId);
if ((Boolean) result.get("success")) {
orders = (List<Order>) result.get("orders");
} else {
System.out.println("获取订单失败: " + result.get("message"));
return;
}
} else {
System.out.println("无效选择");
return;
}
if (orders.isEmpty()) {
System.out.println("没有找到相关订单");
} else {
System.out.println("找到 " + orders.size() + " 个订单:");
displayOrderList(orders);
}
}
/**
*
*/
private void viewAllOrders() {
System.out.println("\n===== 查看所有订单 =====");
Map<String, Object> result = orderController.getAllOrders();
if (!(Boolean) result.get("success")) {
System.out.println("获取订单失败: " + result.get("message"));
return;
}
List<Order> orders = (List<Order>) result.get("orders");
if (orders.isEmpty()) {
System.out.println("当前没有订单");
} else {
System.out.println("共有 " + orders.size() + " 个订单:");
displayOrderList(orders);
}
}
/**
*
*/
private void viewPendingOrders() {
System.out.println("\n===== 查看待接单订单 =====");
Map<String, Object> result = orderController.getOrdersByStatus(0); // 0表示待接单状态
if (!(Boolean) result.get("success")) {
System.out.println("获取订单失败: " + result.get("message"));
return;
}
List<Order> orders = (List<Order>) result.get("orders");
if (orders.isEmpty()) {
System.out.println("当前没有待接单的订单");
} else {
System.out.println("共有 " + orders.size() + " 个待接单订单:");
displayOrderList(orders);
}
}
/**
*
*/
private void acceptOrder() {
System.out.println("\n===== 接单 =====");
// 先显示待接单订单
Map<String, Object> pendingResult = orderController.getOrdersByStatus(0); // 0表示待接单状态
if (!(Boolean) pendingResult.get("success")) {
System.out.println("获取待接单订单失败: " + pendingResult.get("message"));
return;
}
List<Order> pendingOrders = (List<Order>) pendingResult.get("orders");
if (pendingOrders.isEmpty()) {
System.out.println("当前没有待接单的订单");
return;
}
System.out.println("当前待接单订单:");
displayOrderList(pendingOrders);
System.out.print("请输入要接的订单ID: ");
String orderId = scanner.nextLine();
System.out.print("请输入配送员ID: ");
String deliveryPersonId = scanner.nextLine();
Map<String, Object> result = orderController.acceptOrder(orderId, deliveryPersonId);
if ((Boolean) result.get("success")) {
System.out.println("接单成功!");
} else {
System.out.println("接单失败: " + result.get("message"));
}
}
/**
*
*/
private void updateOrderStatus() {
System.out.println("\n===== 更新订单状态 =====");
System.out.print("请输入订单ID: ");
String orderId = scanner.nextLine();
// 显示当前订单状态
Order order = orderController.getOrderById(orderId);
if (order == null) {
System.out.println("订单不存在");
return;
}
System.out.println("当前订单状态: " + order.getStatus().getDescription());
// 显示可用的状态转换选项
System.out.println("\n可转换的状态:");
switch (order.getStatus()) {
case PENDING:
System.out.println("1. 已接单");
System.out.println("2. 已取消");
break;
case ACCEPTED:
System.out.println("1. 已取件");
System.out.println("2. 已取消");
break;
case PICKED_UP:
System.out.println("1. 配送中");
break;
case DELIVERING:
System.out.println("1. 已完成");
break;
case COMPLETED:
case CANCELLED:
System.out.println("订单已完成或已取消,无法更改状态");
return;
}
System.out.print("请选择要转换的状态: ");
String choice = scanner.nextLine();
Map<String, Object> result = null;
switch (choice) {
case "1":
switch (order.getStatus()) {
case PENDING:
System.out.print("请输入配送员ID: ");
String deliveryPersonId = scanner.nextLine();
result = orderController.acceptOrder(orderId, deliveryPersonId);
break;
case ACCEPTED:
result = orderController.pickupOrder(orderId);
break;
case PICKED_UP:
result = orderController.deliverOrder(orderId);
break;
case DELIVERING:
result = orderController.completeOrder(orderId);
break;
}
break;
case "2":
if (order.getStatus() == Order.OrderStatus.PENDING ||
order.getStatus() == Order.OrderStatus.ACCEPTED) {
result = orderController.cancelOrder(orderId);
} else {
System.out.println("当前状态无法取消订单");
return;
}
break;
default:
System.out.println("无效选择");
return;
}
if (result != null && (Boolean) result.get("success")) {
System.out.println("订单状态更新成功!");
Order updatedOrder = (Order) result.get("order");
System.out.println("新状态: " + updatedOrder.getStatus().getDescription());
} else if (result != null) {
System.out.println("订单状态更新失败: " + result.get("message"));
}
}
/**
*
*/
private void displayOrderList(List<Order> orders) {
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm");
System.out.println("------------------------------------------------------------");
System.out.printf("%-15s %-10s %-10s %-15s %-15s %-10s%n",
"订单号", "客户ID", "配送员ID", "取件地点", "配送地点", "状态");
System.out.println("------------------------------------------------------------");
for (Order order : orders) {
System.out.printf("%-15s %-10s %-10s %-15s %-15s %-10s%n",
order.getOrderNumber(),
order.getCustomerId(),
order.getDeliveryPersonId() != null ? order.getDeliveryPersonId() : "未分配",
order.getPickupLocation(),
order.getDeliveryLocation(),
order.getStatus().getDescription());
}
System.out.println("------------------------------------------------------------");
}
/**
*
*/
private void displayOrderDetail(Order order) {
if (order == null) {
System.out.println("订单不存在");
return;
}
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm");
System.out.println("\n===== 订单详细信息 =====");
System.out.println("订单ID: " + order.getOrderId());
System.out.println("订单号: " + order.getOrderNumber());
System.out.println("客户ID: " + order.getCustomerId());
System.out.println("配送员ID: " + (order.getDeliveryPersonId() != null ? order.getDeliveryPersonId() : "未分配"));
System.out.println("物品类型: " + order.getItemType());
System.out.println("物品描述: " + order.getDescription());
System.out.println("取件地点: " + order.getPickupLocation());
System.out.println("配送地点: " + order.getDeliveryLocation());
System.out.println("配送费用: " + order.getFee());
System.out.println("预计取件时间: " + (order.getPickupTime() != null ? order.getPickupTime().format(formatter) : "未设置"));
System.out.println("实际配送时间: " + (order.getDeliveryTime() != null ? order.getDeliveryTime().format(formatter) : "未配送"));
System.out.println("创建时间: " + (order.getCreateTime() != null ? order.getCreateTime().format(formatter) : "未知"));
System.out.println("更新时间: " + (order.getUpdateTime() != null ? order.getUpdateTime().format(formatter) : "未知"));
System.out.println("订单状态: " + order.getStatus().getDescription());
System.out.println("备注: " + (order.getRemarks() != null ? order.getRemarks() : "无"));
System.out.println("========================");
}
/**
*
*/
public void close() {
if (scanner != null) {
scanner.close();
}
}
}

@ -0,0 +1,335 @@
package com.campus.pickup.view;
import com.campus.pickup.controller.ReviewController;
import com.campus.pickup.model.Review;
import com.campus.pickup.model.User;
import java.util.List;
import java.util.Map;
import java.util.Scanner;
/**
*
*
*/
public class ReviewView {
private ReviewController reviewController;
private Scanner scanner;
/**
*
*/
public ReviewView() {
this.reviewController = new ReviewController();
this.scanner = new Scanner(System.in);
}
/**
*
* @param reviewerId ID
*/
public void showAddReviewForm(String reviewerId) {
System.out.println("\n===== 添加评价 =====");
System.out.print("请输入订单ID: ");
String orderId = scanner.nextLine();
// 检查是否可以评价该订单
Map<String, Object> checkResult = reviewController.canUserReviewOrder(orderId, reviewerId);
if (!(boolean) checkResult.get("success")) {
System.out.println(checkResult.get("message"));
return;
}
if (!(boolean) checkResult.get("canReview")) {
System.out.println("您无法评价该订单: " + checkResult.get("message"));
return;
}
System.out.print("请输入被评价人ID: ");
String reviewedId = scanner.nextLine();
int rating = 0;
while (rating < 1 || rating > 5) {
try {
System.out.print("请输入评分(1-5星): ");
rating = Integer.parseInt(scanner.nextLine());
if (rating < 1 || rating > 5) {
System.out.println("评分必须在1-5之间");
}
} catch (NumberFormatException e) {
System.out.println("请输入有效的数字!");
}
}
System.out.print("请输入评价内容: ");
String content = scanner.nextLine();
// 调用控制器添加评价
Map<String, Object> result = reviewController.addReview(orderId, reviewerId, reviewedId, rating, content);
if ((boolean) result.get("success")) {
System.out.println("评价添加成功!");
} else {
System.out.println("评价添加失败: " + result.get("message"));
}
}
/**
*
* @param userId ID
*/
public void showReviewsReceivedByUser(String userId) {
System.out.println("\n===== 收到的评价 =====");
Map<String, Object> result = reviewController.getReviewsReceivedByUser(userId);
if ((boolean) result.get("success")) {
List<Review> reviews = (List<Review>) result.get("reviews");
if (reviews.isEmpty()) {
System.out.println("您没有收到任何评价。");
return;
}
System.out.println("评价总数: " + reviews.size());
System.out.println("----------------------------------------");
for (Review review : reviews) {
System.out.println("评价ID: " + review.getReviewId());
System.out.println("订单ID: " + review.getOrderId());
System.out.println("评价人ID: " + review.getReviewerId());
System.out.println("评分: " + getStarRating(review.getRating()));
System.out.println("评价内容: " + review.getContent());
System.out.println("评价时间: " + review.getCreateTime());
System.out.println("----------------------------------------");
}
} else {
System.out.println("获取评价列表失败: " + result.get("message"));
}
}
/**
*
* @param userId ID
*/
public void showAverageRatingForUser(String userId) {
Map<String, Object> result = reviewController.getAverageRatingForUser(userId);
if ((boolean) result.get("success")) {
double averageRating = (double) result.get("averageRating");
System.out.println("您的平均评分: " + String.format("%.2f", averageRating) + " 星");
} else {
System.out.println("获取平均评分失败: " + result.get("message"));
}
}
/**
*
* @param reviewId ID
*/
public void showReviewDetail(String reviewId) {
System.out.println("\n===== 评价详情 =====");
Map<String, Object> result = reviewController.getReviewDetail(reviewId);
if ((boolean) result.get("success")) {
Review review = (Review) result.get("review");
System.out.println("评价ID: " + review.getReviewId());
System.out.println("订单ID: " + review.getOrderId());
System.out.println("评价人ID: " + review.getReviewerId());
System.out.println("被评价人ID: " + review.getReviewedId());
System.out.println("评分: " + getStarRating(review.getRating()));
System.out.println("评价内容: " + review.getContent());
System.out.println("创建时间: " + review.getCreateTime());
System.out.println("更新时间: " + review.getUpdateTime());
} else {
System.out.println("获取评价详情失败: " + result.get("message"));
}
}
/**
*
* @param reviewId ID
*/
public void showUpdateReviewForm(String reviewId) {
System.out.println("\n===== 更新评价 =====");
// 先获取当前评价信息
Map<String, Object> result = reviewController.getReviewDetail(reviewId);
if (!(boolean) result.get("success")) {
System.out.println("获取评价信息失败: " + result.get("message"));
return;
}
Review currentReview = (Review) result.get("review");
System.out.println("当前评分: " + getStarRating(currentReview.getRating()));
int rating = 0;
while (rating < 1 || rating > 5) {
try {
System.out.print("请输入新的评分(1-5星): ");
rating = Integer.parseInt(scanner.nextLine());
if (rating < 1 || rating > 5) {
System.out.println("评分必须在1-5之间");
}
} catch (NumberFormatException e) {
System.out.println("请输入有效的数字!");
}
}
System.out.println("当前评价内容: " + currentReview.getContent());
System.out.print("请输入新的评价内容: ");
String content = scanner.nextLine();
// 调用控制器更新评价
result = reviewController.updateReview(reviewId, rating, content);
if ((boolean) result.get("success")) {
System.out.println("评价更新成功!");
} else {
System.out.println("评价更新失败: " + result.get("message"));
}
}
/**
*
* @param reviewId ID
*/
public void deleteReview(String reviewId) {
System.out.print("确认删除该评价?(y/n): ");
String confirmation = scanner.nextLine();
if (confirmation.equalsIgnoreCase("y")) {
Map<String, Object> result = reviewController.deleteReview(reviewId);
if ((boolean) result.get("success")) {
System.out.println("评价删除成功!");
} else {
System.out.println("评价删除失败: " + result.get("message"));
}
} else {
System.out.println("已取消删除操作。");
}
}
/**
* ID
* @param orderId ID
*/
public void showReviewByOrderId(String orderId) {
System.out.println("\n===== 订单评价 =====");
Map<String, Object> result = reviewController.getReviewByOrderId(orderId);
if ((boolean) result.get("success")) {
Review review = (Review) result.get("review");
System.out.println("评价ID: " + review.getReviewId());
System.out.println("订单ID: " + review.getOrderId());
System.out.println("评价人ID: " + review.getReviewerId());
System.out.println("被评价人ID: " + review.getReviewedId());
System.out.println("评分: " + getStarRating(review.getRating()));
System.out.println("评价内容: " + review.getContent());
System.out.println("评价时间: " + review.getCreateTime());
} else {
System.out.println(result.get("message"));
}
}
/**
*
* @param user
* @return
*/
public int showReviewMenu(User user) {
System.out.println("\n===== 评价管理 =====");
System.out.println("1. 查看收到的评价");
System.out.println("2. 查看平均评分");
System.out.println("3. 添加评价");
System.out.println("4. 根据订单ID查看评价");
System.out.println("5. 更新评价");
System.out.println("6. 删除评价");
System.out.println("0. 返回上一级");
System.out.print("请选择操作: ");
try {
int choice = Integer.parseInt(scanner.nextLine());
return choice;
} catch (NumberFormatException e) {
System.out.println("请输入有效的数字选项!");
return -1;
}
}
/**
*
* @param user
*/
public void handleReviewManagement(User user) {
int choice;
do {
choice = showReviewMenu(user);
switch (choice) {
case 1:
showReviewsReceivedByUser(user.getUserId());
break;
case 2:
showAverageRatingForUser(user.getUserId());
break;
case 3:
showAddReviewForm(user.getUserId());
break;
case 4:
System.out.print("请输入订单ID: ");
String orderId = scanner.nextLine();
showReviewByOrderId(orderId);
break;
case 5:
System.out.print("请输入评价ID: ");
String reviewId = scanner.nextLine();
showUpdateReviewForm(reviewId);
break;
case 6:
System.out.print("请输入评价ID: ");
String deleteReviewId = scanner.nextLine();
deleteReview(deleteReviewId);
break;
case 0:
System.out.println("返回上一级菜单...");
break;
default:
System.out.println("无效的选项,请重新选择!");
break;
}
} while (choice != 0);
}
/**
*
* @param rating
* @return
*/
private String getStarRating(int rating) {
StringBuilder stars = new StringBuilder();
for (int i = 0; i < rating; i++) {
stars.append("★");
}
for (int i = rating; i < 5; i++) {
stars.append("☆");
}
return stars.toString() + " (" + rating + "/5)";
}
/**
*
*/
public void close() {
if (scanner != null) {
scanner.close();
}
}
}

@ -0,0 +1,239 @@
package com.campus.pickup.view;
import com.campus.pickup.controller.UserController;
import com.campus.pickup.model.User;
import java.util.Map;
import java.util.Scanner;
/**
*
*
*/
public class UserView {
private UserController userController;
private Scanner scanner;
/**
*
*/
public UserView() {
this.userController = new UserController();
this.scanner = new Scanner(System.in);
}
/**
*
*/
public void showRegistrationForm() {
System.out.println("\n===== 用户注册 =====");
System.out.print("请输入用户名: ");
String username = scanner.nextLine();
System.out.print("请输入密码: ");
String password = scanner.nextLine();
System.out.print("请输入真实姓名: ");
String realName = scanner.nextLine();
System.out.print("请输入手机号: ");
String phone = scanner.nextLine();
System.out.print("请输入邮箱: ");
String email = scanner.nextLine();
System.out.print("请输入学号: ");
String studentId = scanner.nextLine();
System.out.print("请输入宿舍地址: ");
String dormitory = scanner.nextLine();
// 调用控制器进行注册
Map<String, Object> result = userController.register(username, password, realName,
phone, email, studentId, dormitory);
if ((boolean) result.get("success")) {
System.out.println("注册成功您的用户ID是: " + result.get("userId"));
} else {
System.out.println("注册失败: " + result.get("message"));
}
}
/**
*
* @return null
*/
public User showLoginForm() {
System.out.println("\n===== 用户登录 =====");
System.out.print("请输入用户名: ");
String username = scanner.nextLine();
System.out.print("请输入密码: ");
String password = scanner.nextLine();
// 调用控制器进行登录
Map<String, Object> result = userController.login(username, password);
if ((boolean) result.get("success")) {
System.out.println("登录成功!");
return (User) result.get("user");
} else {
System.out.println("登录失败: " + result.get("message"));
return null;
}
}
/**
*
* @param userId ID
*/
public void showUserInfo(String userId) {
System.out.println("\n===== 用户信息 =====");
Map<String, Object> result = userController.getUserInfo(userId);
if ((boolean) result.get("success")) {
User user = (User) result.get("user");
System.out.println("用户ID: " + user.getUserId());
System.out.println("用户名: " + user.getUsername());
System.out.println("真实姓名: " + user.getRealName());
System.out.println("手机号: " + user.getPhone());
System.out.println("邮箱: " + user.getEmail());
System.out.println("学号: " + user.getStudentId());
System.out.println("宿舍地址: " + user.getDormitory());
System.out.println("注册时间: " + user.getCreateTime());
} else {
System.out.println("获取用户信息失败: " + result.get("message"));
}
}
/**
*
* @param userId ID
*/
public void showUpdateUserInfoForm(String userId) {
System.out.println("\n===== 更新用户信息 =====");
// 先获取当前用户信息
Map<String, Object> result = userController.getUserInfo(userId);
if (!(boolean) result.get("success")) {
System.out.println("获取用户信息失败: " + result.get("message"));
return;
}
User currentUser = (User) result.get("user");
System.out.println("当前真实姓名: " + currentUser.getRealName());
System.out.print("请输入新的真实姓名(留空保持不变): ");
String realName = scanner.nextLine();
if (realName.isEmpty()) {
realName = currentUser.getRealName();
}
System.out.println("当前手机号: " + currentUser.getPhone());
System.out.print("请输入新的手机号(留空保持不变): ");
String phone = scanner.nextLine();
if (phone.isEmpty()) {
phone = currentUser.getPhone();
}
System.out.println("当前邮箱: " + currentUser.getEmail());
System.out.print("请输入新的邮箱(留空保持不变): ");
String email = scanner.nextLine();
if (email.isEmpty()) {
email = currentUser.getEmail();
}
System.out.println("当前学号: " + currentUser.getStudentId());
System.out.print("请输入新的学号(留空保持不变): ");
String studentId = scanner.nextLine();
if (studentId.isEmpty()) {
studentId = currentUser.getStudentId();
}
System.out.println("当前宿舍地址: " + currentUser.getDormitory());
System.out.print("请输入新的宿舍地址(留空保持不变): ");
String dormitory = scanner.nextLine();
if (dormitory.isEmpty()) {
dormitory = currentUser.getDormitory();
}
// 调用控制器更新用户信息
result = userController.updateUserInfo(userId, realName, phone, email, studentId, dormitory);
if ((boolean) result.get("success")) {
System.out.println("用户信息更新成功!");
} else {
System.out.println("用户信息更新失败: " + result.get("message"));
}
}
/**
*
* @param userId ID
*/
public void showChangePasswordForm(String userId) {
System.out.println("\n===== 修改密码 =====");
System.out.print("请输入当前密码: ");
String oldPassword = scanner.nextLine();
System.out.print("请输入新密码: ");
String newPassword = scanner.nextLine();
System.out.print("请再次输入新密码: ");
String confirmPassword = scanner.nextLine();
if (!newPassword.equals(confirmPassword)) {
System.out.println("两次输入的新密码不一致!");
return;
}
// 调用控制器修改密码
Map<String, Object> result = userController.changePassword(userId, oldPassword, newPassword);
if ((boolean) result.get("success")) {
System.out.println("密码修改成功!");
} else {
System.out.println("密码修改失败: " + result.get("message"));
}
}
/**
*
* @param user
* @return
*/
public int showUserMenu(User user) {
System.out.println("\n===== 校园代取系统 - 用户菜单 =====");
System.out.println("欢迎, " + user.getRealName() + "!");
System.out.println("1. 查看个人信息");
System.out.println("2. 更新个人信息");
System.out.println("3. 修改密码");
System.out.println("4. 消息管理");
System.out.println("5. 评价管理");
System.out.println("6. 订单配送管理");
System.out.println("0. 退出登录");
System.out.print("请选择操作: ");
try {
int choice = Integer.parseInt(scanner.nextLine());
return choice;
} catch (NumberFormatException e) {
System.out.println("请输入有效的数字选项!");
return -1;
}
}
/**
*
*/
public void close() {
if (scanner != null) {
scanner.close();
}
}
}

@ -0,0 +1,20 @@
package com.campus.pickup;
import org.junit.platform.suite.api.SelectClasses;
import org.junit.platform.suite.api.Suite;
/**
*
*
*/
@Suite
@SelectClasses({
com.campus.pickup.model.UserTest.class,
com.campus.pickup.model.MessageTest.class,
com.campus.pickup.model.ReviewTest.class,
com.campus.pickup.service.UserServiceTest.class,
com.campus.pickup.service.MessageServiceTest.class,
com.campus.pickup.service.ReviewServiceTest.class
})
public class PersonnelInteractionTestSuite {
}

@ -0,0 +1,279 @@
package com.campus.pickup.acceptance;
import com.campus.pickup.controller.UserController;
import com.campus.pickup.controller.MessageController;
import com.campus.pickup.controller.ReviewController;
import com.campus.pickup.model.User;
import com.campus.pickup.model.Message;
import com.campus.pickup.model.Review;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Order;
import static org.junit.jupiter.api.Assertions.*;
import java.util.List;
import java.util.Map;
/**
*
*
*/
public class AcceptanceTestMainCode {
private UserController userController;
private MessageController messageController;
private ReviewController reviewController;
// 测试用户数据
private String requesterId;
private String helperId;
@BeforeEach
void setUp() {
userController = new UserController();
messageController = new MessageController();
reviewController = new ReviewController();
// 创建测试用户:请求者和帮助者
Map<String, Object> requesterResult = userController.register("requester", "reqpass", "请求代取用户",
"13800131111", "req@test.com",
"20211111", "东区1号楼111");
requesterId = (String) requesterResult.get("userId");
Map<String, Object> helperResult = userController.register("helper", "helppass", "代取帮助者",
"13800132222", "help@test.com",
"20212222", "东区1号楼222");
helperId = (String) helperResult.get("userId");
}
@Test
@Order(1)
@DisplayName("用户注册与登录验收测试")
void testUserRegistrationAndLoginAcceptance() {
// 验收标准:用户能够成功注册并登录系统
// 1. 新用户注册
Map<String, Object> registerResult = userController.register("newuser", "newpass", "新用户",
"13800133333", "new@test.com",
"20213333", "东区1号楼333");
assertTrue((Boolean) registerResult.get("success"), "新用户注册应该成功");
assertNotNull(registerResult.get("userId"), "注册成功后应返回用户ID");
// 2. 用户登录
Map<String, Object> loginResult = userController.login("newuser", "newpass");
assertTrue((Boolean) loginResult.get("success"), "用户登录应该成功");
User user = (User) loginResult.get("user");
assertEquals("newuser", user.getUsername(), "登录用户名应正确");
assertEquals("新用户", user.getRealName(), "登录用户真实姓名应正确");
// 3. 错误密码登录失败
Map<String, Object> loginFailResult = userController.login("newuser", "wrongpass");
assertFalse((Boolean) loginFailResult.get("success"), "错误密码登录应该失败");
}
@Test
@Order(2)
@DisplayName("代取请求与响应流程验收测试")
void testPickupRequestAndResponseAcceptance() {
// 验收标准:用户能够发送代取请求,帮助者能够响应请求
// 1. 请求者发送代取请求消息
Map<String, Object> requestResult = messageController.sendMessage(requesterId, helperId,
"我有一个快递需要代取取件码1234地点东区快递站",
2); // 订单消息
assertTrue((Boolean) requestResult.get("success"), "代取请求发送应该成功");
// 2. 帮助者查看收到的消息
Map<String, Object> receivedResult = messageController.getReceivedMessages(helperId);
assertTrue((Boolean) receivedResult.get("success"), "获取接收消息应该成功");
@SuppressWarnings("unchecked")
List<Message> messages = (List<Message>) receivedResult.get("messages");
assertFalse(messages.isEmpty(), "帮助者应该收到代取请求消息");
// 3. 验证消息内容
Message requestMessage = messages.stream()
.filter(msg -> msg.getContent().contains("代取请求"))
.findFirst()
.orElse(null);
assertNotNull(requestMessage, "应该包含代取请求消息");
assertEquals(requesterId, requestMessage.getSenderId(), "发送者应为请求者");
assertEquals(helperId, requestMessage.getReceiverId(), "接收者应为帮助者");
assertEquals(2, requestMessage.getType().getCode(), "消息类型应为订单消息");
// 4. 帮助者响应请求
Map<String, Object> responseResult = messageController.sendMessage(helperId, requesterId,
"我可以帮你代取,请确认订单信息",
1); // 用户消息
assertTrue((Boolean) responseResult.get("success"), "帮助者响应应该成功");
// 5. 请求者查看响应
Map<String, Object> requesterMessagesResult = messageController.getReceivedMessages(requesterId);
assertTrue((Boolean) requesterMessagesResult.get("success"), "获取请求者消息应该成功");
@SuppressWarnings("unchecked")
List<Message> requesterMessages = (List<Message>) requesterMessagesResult.get("messages");
Message responseMessage = requesterMessages.stream()
.filter(msg -> msg.getContent().contains("我可以帮你代取"))
.findFirst()
.orElse(null);
assertNotNull(responseMessage, "请求者应该收到帮助者响应");
assertEquals(helperId, responseMessage.getSenderId(), "发送者应为帮助者");
assertEquals(requesterId, responseMessage.getReceiverId(), "接收者应为请求者");
}
@Test
@Order(3)
@DisplayName("代取完成与评价流程验收测试")
void testPickupCompletionAndReviewAcceptance() {
// 验收标准:代取完成后,请求者能够对帮助者进行评价
// 1. 模拟代取完成,请求者发送确认消息
Map<String, Object> confirmResult = messageController.sendMessage(requesterId, helperId,
"代取已完成,谢谢!",
1); // 用户消息
assertTrue((Boolean) confirmResult.get("success"), "代取完成确认发送应该成功");
// 2. 请求者对帮助者进行评价
String orderId = "pickup_order_001";
Map<String, Object> reviewResult = reviewController.addReview(orderId, requesterId, helperId,
5, "代取非常及时,服务态度很好,感谢!");
assertTrue((Boolean) reviewResult.get("success"), "添加评价应该成功");
// 3. 验证帮助者收到的评价
Map<String, Object> reviewsResult = reviewController.getReviewsReceivedByUser(helperId);
assertTrue((Boolean) reviewsResult.get("success"), "获取帮助者评价应该成功");
@SuppressWarnings("unchecked")
List<Review> reviews = (List<Review>) reviewsResult.get("reviews");
assertFalse(reviews.isEmpty(), "帮助者应该收到评价");
// 4. 验证评价内容
Review pickupReview = reviews.stream()
.filter(review -> orderId.equals(review.getOrderId()))
.findFirst()
.orElse(null);
assertNotNull(pickupReview, "应该包含该订单的评价");
assertEquals(orderId, pickupReview.getOrderId(), "订单ID应正确");
assertEquals(requesterId, pickupReview.getReviewerId(), "评价者应为请求者");
assertEquals(helperId, pickupReview.getReviewedId(), "被评价者应为帮助者");
assertEquals(5, pickupReview.getRating(), "评分应为5星");
assertEquals("代取非常及时,服务态度很好,感谢!", pickupReview.getContent(), "评价内容应正确");
// 5. 验证帮助者的平均评分
Map<String, Object> avgRatingResult = reviewController.getAverageRatingForUser(helperId);
assertTrue((Boolean) avgRatingResult.get("success"), "获取平均评分应该成功");
double avgRating = (Double) avgRatingResult.get("averageRating");
assertEquals(5.0, avgRating, 0.01, "平均评分应为5.0");
}
@Test
@Order(4)
@DisplayName("系统通知功能验收测试")
void testSystemNotificationAcceptance() {
// 验收标准:系统能够向用户发送通知消息
// 1. 系统向请求者发送订单状态通知
Map<String, Object> notificationResult = messageController.sendSystemNotification(requesterId,
"您的代取订单已被接受,正在处理中");
assertTrue((Boolean) notificationResult.get("success"), "系统通知发送应该成功");
// 2. 验证用户收到系统通知
Map<String, Object> messagesResult = messageController.getReceivedMessages(requesterId);
assertTrue((Boolean) messagesResult.get("success"), "获取用户消息应该成功");
@SuppressWarnings("unchecked")
List<Message> messages = (List<Message>) messagesResult.get("messages");
Message systemNotification = messages.stream()
.filter(msg -> msg.getType().getCode() == 0) // 系统通知
.filter(msg -> msg.getContent().contains("代取订单已被接受"))
.findFirst()
.orElse(null);
assertNotNull(systemNotification, "用户应该收到系统通知");
assertEquals(0, systemNotification.getType().getCode(), "消息类型应为系统通知");
assertTrue(systemNotification.getContent().contains("代取订单已被接受"), "通知内容应正确");
// 3. 验证未读消息数量
Map<String, Object> unreadResult = messageController.getUnreadMessageCount(requesterId);
assertTrue((Boolean) unreadResult.get("success"), "获取未读消息数量应该成功");
int unreadCount = (Integer) unreadResult.get("unreadCount");
assertTrue(unreadCount > 0, "应该有未读消息");
}
@Test
@Order(5)
@DisplayName("用户信誉评价系统验收测试")
void testUserReputationSystemAcceptance() {
// 验收标准:用户的信誉评价系统能够正确计算和显示平均评分
// 1. 多个用户对帮助者进行评价
String[] orderIds = {"order_001", "order_002", "order_003", "order_004", "order_005"};
int[] ratings = {5, 4, 5, 3, 5};
String[] comments = {
"服务非常好,代取及时",
"服务不错,就是有点慢",
"非常满意,推荐",
"还可以,有改进空间",
"完美,五星好评"
};
// 创建多个评价者
for (int i = 0; i < orderIds.length; i++) {
String reviewerId = createTestUser("reviewer" + i, "revpass" + i, "评价者" + i,
"1380013000" + i, "rev" + i + "@test.com",
"2021000" + i, "测试楼" + i);
Map<String, Object> reviewResult = reviewController.addReview(orderIds[i], reviewerId, helperId,
ratings[i], comments[i]);
assertTrue((Boolean) reviewResult.get("success"), "添加评价" + i + "应该成功");
}
// 2. 验证帮助者收到的所有评价
Map<String, Object> reviewsResult = reviewController.getReviewsReceivedByUser(helperId);
assertTrue((Boolean) reviewsResult.get("success"), "获取帮助者评价应该成功");
@SuppressWarnings("unchecked")
List<Review> reviews = (List<Review>) reviewsResult.get("reviews");
assertTrue(reviews.size() >= orderIds.length, "帮助者应该收到足够多的评价");
// 3. 验证平均评分计算
Map<String, Object> avgRatingResult = reviewController.getAverageRatingForUser(helperId);
assertTrue((Boolean) avgRatingResult.get("success"), "获取平均评分应该成功");
double avgRating = (Double) avgRatingResult.get("averageRating");
double expectedAvg = (5 + 4 + 5 + 3 + 5) / 5.0; // 4.4
assertEquals(expectedAvg, avgRating, 0.01, "平均评分计算应该正确");
// 4. 验证评价内容
for (int i = 0; i < orderIds.length; i++) {
final String orderId = orderIds[i];
final int rating = ratings[i];
final String comment = comments[i];
Review review = reviews.stream()
.filter(r -> orderId.equals(r.getOrderId()))
.findFirst()
.orElse(null);
assertNotNull(review, "应该包含订单" + orderId + "的评价");
assertEquals(rating, review.getRating(), "订单" + orderId + "的评分应正确");
assertEquals(comment, review.getContent(), "订单" + orderId + "的评价内容应正确");
}
}
/**
*
*/
private String createTestUser(String username, String password, String realName,
String phone, String email, String studentId, String dormitory) {
Map<String, Object> result = userController.register(username, password, realName, phone,
email, studentId, dormitory);
return (String) result.get("userId");
}
}

@ -0,0 +1,163 @@
package com.campus.pickup.integration;
import com.campus.pickup.controller.UserController;
import com.campus.pickup.controller.MessageController;
import com.campus.pickup.controller.ReviewController;
import com.campus.pickup.model.User;
import com.campus.pickup.model.Message;
import com.campus.pickup.model.Review;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.DisplayName;
import static org.junit.jupiter.api.Assertions.*;
import java.util.List;
import java.util.Map;
/**
*
*
*/
public class IntegrationTestMainCode {
private UserController userController;
private MessageController messageController;
private ReviewController reviewController;
private String testUserId1;
private String testUserId2;
private String testOrderId;
@BeforeEach
void setUp() {
userController = new UserController();
messageController = new MessageController();
reviewController = new ReviewController();
// 创建测试用户
Map<String, Object> userResult1 = userController.register("testuser1", "password123", "测试用户1",
"13800138001", "test1@example.com",
"20210001", "东区1号楼101");
testUserId1 = (String) userResult1.get("userId");
Map<String, Object> userResult2 = userController.register("testuser2", "password456", "测试用户2",
"13800138002", "test2@example.com",
"20210002", "东区1号楼102");
testUserId2 = (String) userResult2.get("userId");
testOrderId = "order001";
}
@Test
@DisplayName("用户注册与登录集成测试")
void testUserRegistrationAndLoginIntegration() {
// 测试用户注册后能否正常登录
Map<String, Object> loginResult = userController.login("testuser1", "password123");
assertTrue((Boolean) loginResult.get("success"));
User loggedInUser = (User) loginResult.get("user");
assertEquals(testUserId1, loggedInUser.getUserId());
assertEquals("testuser1", loggedInUser.getUsername());
}
@Test
@DisplayName("用户间消息发送与接收集成测试")
void testUserMessagingIntegration() {
// 用户1向用户2发送消息
Map<String, Object> sendResult = messageController.sendMessage(testUserId1, testUserId2,
"这是一条测试消息", 1);
assertTrue((Boolean) sendResult.get("success"));
// 用户2检查收到的消息
Map<String, Object> receivedResult = messageController.getReceivedMessages(testUserId2);
assertTrue((Boolean) receivedResult.get("success"));
@SuppressWarnings("unchecked")
List<Message> messages = (List<Message>) receivedResult.get("messages");
assertFalse(messages.isEmpty());
// 验证消息内容
Message lastMessage = messages.get(messages.size() - 1);
assertEquals(testUserId1, lastMessage.getSenderId());
assertEquals(testUserId2, lastMessage.getReceiverId());
assertEquals("这是一条测试消息", lastMessage.getContent());
}
@Test
@DisplayName("订单完成后的评价流程集成测试")
void testOrderReviewIntegration() {
// 模拟订单完成后用户1对用户2进行评价
Map<String, Object> reviewResult = reviewController.addReview(testOrderId, testUserId1, testUserId2,
5, "服务非常好,很满意");
assertTrue((Boolean) reviewResult.get("success"));
// 验证用户2收到的评价
Map<String, Object> reviewsResult = reviewController.getReviewsReceivedByUser(testUserId2);
assertTrue((Boolean) reviewsResult.get("success"));
@SuppressWarnings("unchecked")
List<Review> reviews = (List<Review>) reviewsResult.get("reviews");
assertFalse(reviews.isEmpty());
// 验证评价内容
Review lastReview = reviews.get(reviews.size() - 1);
assertEquals(testOrderId, lastReview.getOrderId());
assertEquals(testUserId1, lastReview.getReviewerId());
assertEquals(testUserId2, lastReview.getReviewedId());
assertEquals(5, lastReview.getRating());
assertEquals("服务非常好,很满意", lastReview.getContent());
// 验证用户2的平均评分
Map<String, Object> ratingResult = reviewController.getAverageRatingForUser(testUserId2);
assertTrue((Boolean) ratingResult.get("success"));
double averageRating = (Double) ratingResult.get("averageRating");
assertEquals(5.0, averageRating, 0.01);
}
@Test
@DisplayName("用户交互全流程集成测试")
void testCompleteUserInteractionFlow() {
// 1. 用户登录
Map<String, Object> loginResult1 = userController.login("testuser1", "password123");
assertTrue((Boolean) loginResult1.get("success"));
Map<String, Object> loginResult2 = userController.login("testuser2", "password456");
assertTrue((Boolean) loginResult2.get("success"));
// 2. 用户1向用户2发送订单消息
Map<String, Object> orderMessageResult = messageController.sendMessage(testUserId1, testUserId2,
"我有一个代取订单,请帮忙", 2);
assertTrue((Boolean) orderMessageResult.get("success"));
// 3. 用户2回复消息
Map<String, Object> replyResult = messageController.sendMessage(testUserId2, testUserId1,
"好的,我可以帮忙代取", 1);
assertTrue((Boolean) replyResult.get("success"));
// 4. 用户1检查未读消息
Map<String, Object> unreadResult = messageController.getUnreadMessageCount(testUserId1);
assertTrue((Boolean) unreadResult.get("success"));
assertTrue((Integer) unreadResult.get("unreadCount") > 0);
// 5. 模拟订单完成后用户1对用户2进行评价
Map<String, Object> reviewResult = reviewController.addReview(testOrderId, testUserId1, testUserId2,
4, "服务不错,就是有点慢");
assertTrue((Boolean) reviewResult.get("success"));
// 6. 验证整个流程的数据一致性
Map<String, Object> userInfo1 = userController.getUserInfo(testUserId1);
assertTrue((Boolean) userInfo1.get("success"));
Map<String, Object> userInfo2 = userController.getUserInfo(testUserId2);
assertTrue((Boolean) userInfo2.get("success"));
Map<String, Object> reviewsResult = reviewController.getReviewsReceivedByUser(testUserId2);
assertTrue((Boolean) reviewsResult.get("success"));
@SuppressWarnings("unchecked")
List<Review> reviews = (List<Review>) reviewsResult.get("reviews");
assertFalse(reviews.isEmpty());
}
}

@ -0,0 +1,122 @@
package com.campus.pickup.model;
import org.junit.Test;
import org.junit.jupiter.api.BeforeEach;
import static org.junit.jupiter.api.Assertions.*;
import java.time.LocalDateTime;
/**
* Message
*/
public class MessageTest {
private Message message;
@BeforeEach
void setUp() {
message = new Message();
message.setMessageId("msg001");
message.setSenderId("sender001");
message.setReceiverId("receiver001");
message.setContent("这是一条测试消息");
message.setSendTime(LocalDateTime.now());
message.setReadTime(LocalDateTime.now());
message.setStatus(0);
message.setType(Message.MessageType.USER_MESSAGE);
}
@Test
void testGetMessageId() {
assertEquals("msg001", message.getMessageId());
}
@Test
void testGetSenderId() {
assertEquals("sender001", message.getSenderId());
}
@Test
void testGetReceiverId() {
assertEquals("receiver001", message.getReceiverId());
}
@Test
void testGetContent() {
assertEquals("这是一条测试消息", message.getContent());
}
@Test
void testGetStatus() {
assertEquals(0, message.getStatus());
}
@Test
void testGetType() {
assertEquals(Message.MessageType.USER_MESSAGE, message.getType());
}
@Test
void testMessageTypeEnum() {
// 测试枚举值
assertEquals(0, Message.MessageType.SYSTEM_NOTIFICATION.getCode());
assertEquals("系统通知", Message.MessageType.SYSTEM_NOTIFICATION.getDescription());
assertEquals(1, Message.MessageType.USER_MESSAGE.getCode());
assertEquals("用户消息", Message.MessageType.USER_MESSAGE.getDescription());
assertEquals(2, Message.MessageType.ORDER_MESSAGE.getCode());
assertEquals("订单消息", Message.MessageType.ORDER_MESSAGE.getDescription());
assertEquals(3, Message.MessageType.REVIEW_MESSAGE.getCode());
assertEquals("评价消息", Message.MessageType.REVIEW_MESSAGE.getDescription());
}
@Test
void testMessageTypeFromCode() {
assertEquals(Message.MessageType.SYSTEM_NOTIFICATION, Message.MessageType.fromCode(0));
assertEquals(Message.MessageType.USER_MESSAGE, Message.MessageType.fromCode(1));
assertEquals(Message.MessageType.ORDER_MESSAGE, Message.MessageType.fromCode(2));
assertEquals(Message.MessageType.REVIEW_MESSAGE, Message.MessageType.fromCode(3));
// 测试无效代码
assertNull(Message.MessageType.fromCode(-1));
assertNull(Message.MessageType.fromCode(99));
}
@Test
void testToString() {
String messageString = message.toString();
assertTrue(messageString.contains("msg001"));
assertTrue(messageString.contains("sender001"));
assertTrue(messageString.contains("receiver001"));
assertTrue(messageString.contains("这是一条测试消息"));
}
@Test
void testDefaultConstructor() {
Message newMessage = new Message();
assertNotNull(newMessage);
assertNull(newMessage.getMessageId());
assertNull(newMessage.getSenderId());
assertNull(newMessage.getReceiverId());
assertNull(newMessage.getContent());
assertNull(newMessage.getType());
}
@Test
void testParameterizedConstructor() {
LocalDateTime now = LocalDateTime.now();
Message newMessage = new Message("msg002", "sender002", "receiver002",
"新消息内容", now, now, 1,
Message.MessageType.SYSTEM_NOTIFICATION);
assertEquals("msg002", newMessage.getMessageId());
assertEquals("sender002", newMessage.getSenderId());
assertEquals("receiver002", newMessage.getReceiverId());
assertEquals("新消息内容", newMessage.getContent());
assertEquals(now, newMessage.getSendTime());
assertEquals(now, newMessage.getReadTime());
assertEquals(1, newMessage.getStatus());
assertEquals(Message.MessageType.SYSTEM_NOTIFICATION, newMessage.getType());
}
}

@ -0,0 +1,113 @@
package com.campus.pickup.model;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.BeforeEach;
import static org.junit.jupiter.api.Assertions.*;
import java.time.LocalDateTime;
/**
* Review
*/
public class ReviewTest {
private Review review;
@BeforeEach
void setUp() {
review = new Review();
review.setReviewId("review001");
review.setOrderId("order001");
review.setReviewerId("reviewer001");
review.setReviewedId("reviewed001");
review.setRating(5);
review.setContent("非常满意的服务");
review.setCreateTime(LocalDateTime.now());
review.setUpdateTime(LocalDateTime.now());
review.setStatus(0);
}
@Test
void testGetReviewId() {
assertEquals("review001", review.getReviewId());
}
@Test
void testGetOrderId() {
assertEquals("order001", review.getOrderId());
}
@Test
void testGetReviewerId() {
assertEquals("reviewer001", review.getReviewerId());
}
@Test
void testGetReviewedId() {
assertEquals("reviewed001", review.getReviewedId());
}
@Test
void testGetRating() {
assertEquals(5, review.getRating());
}
@Test
void testGetContent() {
assertEquals("非常满意的服务", review.getContent());
}
@Test
void testGetStatus() {
assertEquals(0, review.getStatus());
}
@Test
void testToString() {
String reviewString = review.toString();
assertTrue(reviewString.contains("review001"));
assertTrue(reviewString.contains("order001"));
assertTrue(reviewString.contains("reviewer001"));
assertTrue(reviewString.contains("reviewed001"));
assertTrue(reviewString.contains("非常满意的服务"));
}
@Test
void testDefaultConstructor() {
Review newReview = new Review();
assertNotNull(newReview);
assertNull(newReview.getReviewId());
assertNull(newReview.getOrderId());
assertNull(newReview.getReviewerId());
assertNull(newReview.getReviewedId());
assertEquals(0, newReview.getRating());
}
@Test
void testParameterizedConstructor() {
LocalDateTime now = LocalDateTime.now();
Review newReview = new Review("review002", "order002", "reviewer002",
"reviewed002", 4, "服务很好", now, now, 0);
assertEquals("review002", newReview.getReviewId());
assertEquals("order002", newReview.getOrderId());
assertEquals("reviewer002", newReview.getReviewerId());
assertEquals("reviewed002", newReview.getReviewedId());
assertEquals(4, newReview.getRating());
assertEquals("服务很好", newReview.getContent());
assertEquals(now, newReview.getCreateTime());
assertEquals(now, newReview.getUpdateTime());
assertEquals(0, newReview.getStatus());
}
@Test
void testRatingBoundary() {
// 测试评分边界值
Review minRatingReview = new Review();
minRatingReview.setRating(1);
assertEquals(1, minRatingReview.getRating());
Review maxRatingReview = new Review();
maxRatingReview.setRating(5);
assertEquals(5, maxRatingReview.getRating());
}
}

@ -0,0 +1,112 @@
package com.campus.pickup.model;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.BeforeEach;
import static org.junit.jupiter.api.Assertions.*;
import java.time.LocalDateTime;
/**
*
*/
public class TestMainCode {
// ========== User测试核心 ==========
@Test
void testUserModel() {
User user = new User();
user.setUserId("user001");
user.setUsername("testuser");
user.setPassword("password123");
assertEquals("user001", user.getUserId());
assertEquals("testuser", user.getUsername());
assertEquals("password123", user.getPassword());
}
@Test
void testUserParameterizedConstructor() {
LocalDateTime now = LocalDateTime.now();
User user = new User("user002", "newuser", "newpass", "新用户",
"13900139000", "new@example.com", "20210002",
"西区2号楼202", now, now, 0);
assertEquals("user002", user.getUserId());
assertEquals("newuser", user.getUsername());
assertEquals("newpass", user.getPassword());
}
// ========== Message测试核心 ==========
@Test
void testMessageModel() {
Message message = new Message();
message.setMessageId("msg001");
message.setSenderId("sender001");
message.setReceiverId("receiver001");
message.setContent("这是一条测试消息");
message.setType(Message.MessageType.USER_MESSAGE);
assertEquals("msg001", message.getMessageId());
assertEquals("sender001", message.getSenderId());
assertEquals("receiver001", message.getReceiverId());
assertEquals("这是一条测试消息", message.getContent());
assertEquals(Message.MessageType.USER_MESSAGE, message.getType());
}
@Test
void testMessageTypeEnum() {
assertEquals(0, Message.MessageType.SYSTEM_NOTIFICATION.getCode());
assertEquals(1, Message.MessageType.USER_MESSAGE.getCode());
assertEquals(2, Message.MessageType.ORDER_MESSAGE.getCode());
assertEquals(3, Message.MessageType.REVIEW_MESSAGE.getCode());
assertEquals(Message.MessageType.SYSTEM_NOTIFICATION, Message.MessageType.fromCode(0));
assertEquals(Message.MessageType.USER_MESSAGE, Message.MessageType.fromCode(1));
assertNull(Message.MessageType.fromCode(-1));
}
@Test
void testMessageParameterizedConstructor() {
LocalDateTime now = LocalDateTime.now();
Message message = new Message("msg002", "sender002", "receiver002",
"新消息内容", now, now, 1,
Message.MessageType.SYSTEM_NOTIFICATION);
assertEquals("msg002", message.getMessageId());
assertEquals("sender002", message.getSenderId());
assertEquals(Message.MessageType.SYSTEM_NOTIFICATION, message.getType());
}
// ========== Review测试核心 ==========
@Test
void testReviewModel() {
Review review = new Review();
review.setReviewId("review001");
review.setOrderId("order001");
review.setReviewerId("reviewer001");
review.setReviewedId("reviewed001");
review.setRating(5);
review.setContent("非常满意的服务");
assertEquals("review001", review.getReviewId());
assertEquals("order001", review.getOrderId());
assertEquals("reviewer001", review.getReviewerId());
assertEquals("reviewed001", review.getReviewedId());
assertEquals(5, review.getRating());
assertEquals("非常满意的服务", review.getContent());
}
@Test
void testReviewParameterizedConstructor() {
LocalDateTime now = LocalDateTime.now();
Review review = new Review("review002", "order002", "reviewer002",
"reviewed002", 4, "服务很好", now, now, 0);
assertEquals("review002", review.getReviewId());
assertEquals("order002", review.getOrderId());
assertEquals(4, review.getRating());
assertEquals("服务很好", review.getContent());
}
}

@ -0,0 +1,111 @@
package com.campus.pickup.model;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.BeforeEach;
import static org.junit.jupiter.api.Assertions.*;
import java.time.LocalDateTime;
/**
* User
*/
public class UserTest {
private User user;
@BeforeEach
void setUp() {
user = new User();
user.setUserId("user001");
user.setUsername("testuser");
user.setPassword("password123");
user.setRealName("测试用户");
user.setPhone("13800138000");
user.setEmail("test@example.com");
user.setStudentId("20210001");
user.setDormitory("东区1号楼101");
user.setCreateTime(LocalDateTime.now());
user.setUpdateTime(LocalDateTime.now());
user.setStatus(0);
}
@Test
void testGetUserId() {
assertEquals("user001", user.getUserId());
}
@Test
void testGetUsername() {
assertEquals("testuser", user.getUsername());
}
@Test
void testGetPassword() {
assertEquals("password123", user.getPassword());
}
@Test
void testGetRealName() {
assertEquals("测试用户", user.getRealName());
}
@Test
void testGetPhone() {
assertEquals("13800138000", user.getPhone());
}
@Test
void testGetEmail() {
assertEquals("test@example.com", user.getEmail());
}
@Test
void testGetStudentId() {
assertEquals("20210001", user.getStudentId());
}
@Test
void testGetDormitory() {
assertEquals("东区1号楼101", user.getDormitory());
}
@Test
void testGetStatus() {
assertEquals(0, user.getStatus());
}
@Test
void testToString() {
String userString = user.toString();
assertTrue(userString.contains("user001"));
assertTrue(userString.contains("testuser"));
assertTrue(userString.contains("测试用户"));
}
@Test
void testDefaultConstructor() {
User newUser = new User();
assertNotNull(newUser);
assertNull(newUser.getUserId());
assertNull(newUser.getUsername());
}
@Test
void testParameterizedConstructor() {
LocalDateTime now = LocalDateTime.now();
User newUser = new User("user002", "newuser", "newpass", "新用户",
"13900139000", "new@example.com", "20210002",
"西区2号楼202", now, now, 0);
assertEquals("user002", newUser.getUserId());
assertEquals("newuser", newUser.getUsername());
assertEquals("newpass", newUser.getPassword());
assertEquals("新用户", newUser.getRealName());
assertEquals("13900139000", newUser.getPhone());
assertEquals("new@example.com", newUser.getEmail());
assertEquals("20210002", newUser.getStudentId());
assertEquals("西区2号楼202", newUser.getDormitory());
assertEquals(now, newUser.getCreateTime());
assertEquals(now, newUser.getUpdateTime());
assertEquals(0, newUser.getStatus());
}
}

@ -0,0 +1,266 @@
package com.campus.pickup.service;
import com.campus.pickup.dao.MessageDao;
import com.campus.pickup.model.Message;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.BeforeEach;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import java.time.LocalDateTime;
import java.util.Arrays;
import java.util.List;
import static org.junit.jupiter.api.Assertions.*;
import static org.mockito.Mockito.*;
/**
* MessageService
*/
public class MessageServiceTest {
@Mock
private MessageDao messageDao;
private MessageService messageService;
@BeforeEach
void setUp() {
MockitoAnnotations.openMocks(this);
messageService = new MessageService();
// 使用反射设置私有字段
try {
java.lang.reflect.Field field = MessageService.class.getDeclaredField("messageDao");
field.setAccessible(true);
field.set(messageService, messageDao);
} catch (Exception e) {
fail("设置测试环境失败: " + e.getMessage());
}
}
@Test
void testSendMessageSuccess() {
// 准备测试数据
String senderId = "sender001";
String receiverId = "receiver001";
String content = "这是一条测试消息";
Message.MessageType type = Message.MessageType.USER_MESSAGE;
// 模拟DAO行为
when(messageDao.addMessage(any(Message.class))).thenReturn(true);
// 执行测试
boolean result = messageService.sendMessage(senderId, receiverId, content, type);
// 验证结果
assertTrue(result);
verify(messageDao).addMessage(any(Message.class));
}
@Test
void testSendSystemNotificationSuccess() {
// 准备测试数据
String receiverId = "receiver001";
String content = "这是一条系统通知";
// 模拟DAO行为
when(messageDao.addMessage(any(Message.class))).thenReturn(true);
// 执行测试
boolean result = messageService.sendSystemNotification(receiverId, content);
// 验证结果
assertTrue(result);
verify(messageDao).addMessage(any(Message.class));
}
@Test
void testMarkMessageAsReadSuccess() {
// 准备测试数据
String messageId = "msg001";
// 模拟DAO行为
when(messageDao.markMessageAsRead(messageId)).thenReturn(true);
// 执行测试
boolean result = messageService.markMessageAsRead(messageId);
// 验证结果
assertTrue(result);
verify(messageDao).markMessageAsRead(messageId);
}
@Test
void testGetMessageById() {
// 准备测试数据
String messageId = "msg001";
Message message = new Message();
message.setMessageId(messageId);
message.setContent("测试消息");
// 模拟DAO行为
when(messageDao.getMessageById(messageId)).thenReturn(message);
// 执行测试
Message result = messageService.getMessageById(messageId);
// 验证结果
assertNotNull(result);
assertEquals(messageId, result.getMessageId());
assertEquals("测试消息", result.getContent());
verify(messageDao).getMessageById(messageId);
}
@Test
void testGetReceivedMessages() {
// 准备测试数据
String receiverId = "receiver001";
List<Message> messages = Arrays.asList(
createMessage("msg001", "sender001", receiverId, "消息1"),
createMessage("msg002", "sender002", receiverId, "消息2")
);
// 模拟DAO行为
when(messageDao.getMessagesByReceiverId(receiverId)).thenReturn(messages);
// 执行测试
List<Message> result = messageService.getReceivedMessages(receiverId);
// 验证结果
assertNotNull(result);
assertEquals(2, result.size());
assertEquals("msg001", result.get(0).getMessageId());
assertEquals("msg002", result.get(1).getMessageId());
verify(messageDao).getMessagesByReceiverId(receiverId);
}
@Test
void testGetUnreadMessageCount() {
// 准备测试数据
String receiverId = "receiver001";
int unreadCount = 5;
// 模拟DAO行为
when(messageDao.getUnreadMessageCount(receiverId)).thenReturn(unreadCount);
// 执行测试
int result = messageService.getUnreadMessageCount(receiverId);
// 验证结果
assertEquals(unreadCount, result);
verify(messageDao).getUnreadMessageCount(receiverId);
}
@Test
void testGetMessagesBetweenUsers() {
// 准备测试数据
String userId1 = "user001";
String userId2 = "user002";
List<Message> messages = Arrays.asList(
createMessage("msg001", userId1, userId2, "消息1"),
createMessage("msg002", userId2, userId1, "消息2")
);
// 模拟DAO行为
when(messageDao.getMessagesBetweenUsers(userId1, userId2)).thenReturn(messages);
// 执行测试
List<Message> result = messageService.getMessagesBetweenUsers(userId1, userId2);
// 验证结果
assertNotNull(result);
assertEquals(2, result.size());
assertEquals("msg001", result.get(0).getMessageId());
assertEquals("msg002", result.get(1).getMessageId());
verify(messageDao).getMessagesBetweenUsers(userId1, userId2);
}
@Test
void testMarkAllMessagesAsReadSuccess() {
// 准备测试数据
String receiverId = "receiver001";
List<Message> messages = Arrays.asList(
createUnreadMessage("msg001", "sender001", receiverId, "未读消息1"),
createUnreadMessage("msg002", "sender002", receiverId, "未读消息2")
);
// 模拟DAO行为
when(messageDao.getMessagesByReceiverId(receiverId)).thenReturn(messages);
when(messageDao.markMessageAsRead("msg001")).thenReturn(true);
when(messageDao.markMessageAsRead("msg002")).thenReturn(true);
// 执行测试
boolean result = messageService.markAllMessagesAsRead(receiverId);
// 验证结果
assertTrue(result);
verify(messageDao).getMessagesByReceiverId(receiverId);
verify(messageDao).markMessageAsRead("msg001");
verify(messageDao).markMessageAsRead("msg002");
}
@Test
void testMarkAllMessagesAsReadPartialFailure() {
// 准备测试数据
String receiverId = "receiver001";
List<Message> messages = Arrays.asList(
createUnreadMessage("msg001", "sender001", receiverId, "未读消息1"),
createUnreadMessage("msg002", "sender002", receiverId, "未读消息2")
);
// 模拟DAO行为
when(messageDao.getMessagesByReceiverId(receiverId)).thenReturn(messages);
when(messageDao.markMessageAsRead("msg001")).thenReturn(true);
when(messageDao.markMessageAsRead("msg002")).thenReturn(false); // 第二条消息标记失败
// 执行测试
boolean result = messageService.markAllMessagesAsRead(receiverId);
// 验证结果
assertFalse(result); // 应该返回false因为不是所有消息都标记成功
verify(messageDao).getMessagesByReceiverId(receiverId);
verify(messageDao).markMessageAsRead("msg001");
verify(messageDao).markMessageAsRead("msg002");
}
@Test
void testMarkAllMessagesAsReadNoUnreadMessages() {
// 准备测试数据
String receiverId = "receiver001";
List<Message> messages = Arrays.asList(); // 空列表,没有未读消息
// 模拟DAO行为
when(messageDao.getMessagesByReceiverId(receiverId)).thenReturn(messages);
// 执行测试
boolean result = messageService.markAllMessagesAsRead(receiverId);
// 验证结果
assertTrue(result); // 没有未读消息应该返回true
verify(messageDao).getMessagesByReceiverId(receiverId);
verify(messageDao, never()).markMessageAsRead(anyString());
}
/**
*
*/
private Message createMessage(String messageId, String senderId, String receiverId, String content) {
Message message = new Message();
message.setMessageId(messageId);
message.setSenderId(senderId);
message.setReceiverId(receiverId);
message.setContent(content);
message.setSendTime(LocalDateTime.now());
message.setStatus(1); // 已读
message.setType(Message.MessageType.USER_MESSAGE);
return message;
}
/**
*
*/
private Message createUnreadMessage(String messageId, String senderId, String receiverId, String content) {
Message message = createMessage(messageId, senderId, receiverId, content);
message.setStatus(0); // 未读
return message;
}
}

@ -0,0 +1,326 @@
package com.campus.pickup.service;
import com.campus.pickup.dao.ReviewDao;
import com.campus.pickup.model.Review;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.BeforeEach;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import java.time.LocalDateTime;
import java.util.Arrays;
import java.util.List;
import static org.junit.jupiter.api.Assertions.*;
import static org.mockito.Mockito.*;
/**
* ReviewService
*/
public class ReviewServiceTest {
@Mock
private ReviewDao reviewDao;
private ReviewService reviewService;
@BeforeEach
void setUp() {
MockitoAnnotations.openMocks(this);
reviewService = new ReviewService();
// 使用反射设置私有字段
try {
java.lang.reflect.Field field = ReviewService.class.getDeclaredField("reviewDao");
field.setAccessible(true);
field.set(reviewService, reviewDao);
} catch (Exception e) {
fail("设置测试环境失败: " + e.getMessage());
}
}
@Test
void testAddReviewSuccess() {
// 准备测试数据
String orderId = "order001";
String reviewerId = "reviewer001";
String reviewedId = "reviewed001";
int rating = 5;
String content = "非常满意的服务";
// 模拟DAO行为
when(reviewDao.getReviewByOrderId(orderId)).thenReturn(null);
when(reviewDao.addReview(any(Review.class))).thenReturn(true);
// 执行测试
boolean result = reviewService.addReview(orderId, reviewerId, reviewedId, rating, content);
// 验证结果
assertTrue(result);
verify(reviewDao).getReviewByOrderId(orderId);
verify(reviewDao).addReview(any(Review.class));
}
@Test
void testAddReviewInvalidRating() {
// 准备测试数据
String orderId = "order001";
String reviewerId = "reviewer001";
String reviewedId = "reviewed001";
int rating = 6; // 无效评分
String content = "非常满意的服务";
// 执行测试
boolean result = reviewService.addReview(orderId, reviewerId, reviewedId, rating, content);
// 验证结果
assertFalse(result);
verify(reviewDao, never()).addReview(any(Review.class));
}
@Test
void testAddReviewOrderAlreadyReviewed() {
// 准备测试数据
String orderId = "order001";
String reviewerId = "reviewer001";
String reviewedId = "reviewed001";
int rating = 5;
String content = "非常满意的服务";
Review existingReview = new Review();
existingReview.setOrderId(orderId);
// 模拟DAO行为
when(reviewDao.getReviewByOrderId(orderId)).thenReturn(existingReview);
// 执行测试
boolean result = reviewService.addReview(orderId, reviewerId, reviewedId, rating, content);
// 验证结果
assertFalse(result);
verify(reviewDao).getReviewByOrderId(orderId);
verify(reviewDao, never()).addReview(any(Review.class));
}
@Test
void testGetReviewById() {
// 准备测试数据
String reviewId = "review001";
Review review = new Review();
review.setReviewId(reviewId);
review.setRating(5);
review.setContent("非常满意的服务");
// 模拟DAO行为
when(reviewDao.getReviewById(reviewId)).thenReturn(review);
// 执行测试
Review result = reviewService.getReviewById(reviewId);
// 验证结果
assertNotNull(result);
assertEquals(reviewId, result.getReviewId());
assertEquals(5, result.getRating());
assertEquals("非常满意的服务", result.getContent());
verify(reviewDao).getReviewById(reviewId);
}
@Test
void testGetReviewByOrderId() {
// 准备测试数据
String orderId = "order001";
Review review = new Review();
review.setReviewId("review001");
review.setOrderId(orderId);
review.setRating(4);
review.setContent("服务很好");
// 模拟DAO行为
when(reviewDao.getReviewByOrderId(orderId)).thenReturn(review);
// 执行测试
Review result = reviewService.getReviewByOrderId(orderId);
// 验证结果
assertNotNull(result);
assertEquals(orderId, result.getOrderId());
assertEquals(4, result.getRating());
assertEquals("服务很好", result.getContent());
verify(reviewDao).getReviewByOrderId(orderId);
}
@Test
void testGetReviewsReceivedByUser() {
// 准备测试数据
String userId = "user001";
List<Review> reviews = Arrays.asList(
createReview("review001", "order001", "reviewer001", userId, 5, "非常满意"),
createReview("review002", "order002", "reviewer002", userId, 4, "满意")
);
// 模拟DAO行为
when(reviewDao.getReviewsByReviewedId(userId)).thenReturn(reviews);
// 执行测试
List<Review> result = reviewService.getReviewsReceivedByUser(userId);
// 验证结果
assertNotNull(result);
assertEquals(2, result.size());
assertEquals("review001", result.get(0).getReviewId());
assertEquals("review002", result.get(1).getReviewId());
verify(reviewDao).getReviewsByReviewedId(userId);
}
@Test
void testGetAverageRatingForUser() {
// 准备测试数据
String userId = "user001";
double averageRating = 4.5;
// 模拟DAO行为
when(reviewDao.getAverageRatingByUserId(userId)).thenReturn(averageRating);
// 执行测试
double result = reviewService.getAverageRatingForUser(userId);
// 验证结果
assertEquals(averageRating, result);
verify(reviewDao).getAverageRatingByUserId(userId);
}
@Test
void testUpdateReviewSuccess() {
// 准备测试数据
String reviewId = "review001";
int newRating = 4;
String newContent = "更新后的评价内容";
Review existingReview = new Review();
existingReview.setReviewId(reviewId);
existingReview.setRating(5);
existingReview.setContent("原始评价内容");
// 模拟DAO行为
when(reviewDao.getReviewById(reviewId)).thenReturn(existingReview);
when(reviewDao.updateReview(any(Review.class))).thenReturn(true);
// 执行测试
boolean result = reviewService.updateReview(reviewId, newRating, newContent);
// 验证结果
assertTrue(result);
assertEquals(newRating, existingReview.getRating());
assertEquals(newContent, existingReview.getContent());
verify(reviewDao).getReviewById(reviewId);
verify(reviewDao).updateReview(existingReview);
}
@Test
void testUpdateReviewInvalidRating() {
// 准备测试数据
String reviewId = "review001";
int newRating = 6; // 无效评分
String newContent = "更新后的评价内容";
// 执行测试
boolean result = reviewService.updateReview(reviewId, newRating, newContent);
// 验证结果
assertFalse(result);
verify(reviewDao, never()).getReviewById(anyString());
verify(reviewDao, never()).updateReview(any(Review.class));
}
@Test
void testDeleteReviewSuccess() {
// 准备测试数据
String reviewId = "review001";
// 模拟DAO行为
when(reviewDao.deleteReview(reviewId)).thenReturn(true);
// 执行测试
boolean result = reviewService.deleteReview(reviewId);
// 验证结果
assertTrue(result);
verify(reviewDao).deleteReview(reviewId);
}
@Test
void testCanUserReviewOrderUnreviewedOrder() {
// 准备测试数据
String orderId = "order001";
String userId = "user001";
// 模拟DAO行为
when(reviewDao.getReviewByOrderId(orderId)).thenReturn(null);
// 执行测试
boolean result = reviewService.canUserReviewOrder(orderId, userId);
// 验证结果
assertTrue(result);
verify(reviewDao).getReviewByOrderId(orderId);
}
@Test
void testCanUserReviewOrderSameReviewer() {
// 准备测试数据
String orderId = "order001";
String userId = "user001";
Review existingReview = new Review();
existingReview.setOrderId(orderId);
existingReview.setReviewerId(userId);
// 模拟DAO行为
when(reviewDao.getReviewByOrderId(orderId)).thenReturn(existingReview);
// 执行测试
boolean result = reviewService.canUserReviewOrder(orderId, userId);
// 验证结果
assertTrue(result);
verify(reviewDao).getReviewByOrderId(orderId);
}
@Test
void testCanUserReviewOrderDifferentReviewer() {
// 准备测试数据
String orderId = "order001";
String userId = "user001";
String otherUserId = "user002";
Review existingReview = new Review();
existingReview.setOrderId(orderId);
existingReview.setReviewerId(otherUserId);
// 模拟DAO行为
when(reviewDao.getReviewByOrderId(orderId)).thenReturn(existingReview);
// 执行测试
boolean result = reviewService.canUserReviewOrder(orderId, userId);
// 验证结果
assertFalse(result);
verify(reviewDao).getReviewByOrderId(orderId);
}
/**
*
*/
private Review createReview(String reviewId, String orderId, String reviewerId,
String reviewedId, int rating, String content) {
Review review = new Review();
review.setReviewId(reviewId);
review.setOrderId(orderId);
review.setReviewerId(reviewerId);
review.setReviewedId(reviewedId);
review.setRating(rating);
review.setContent(content);
review.setCreateTime(LocalDateTime.now());
review.setUpdateTime(LocalDateTime.now());
review.setStatus(0);
return review;
}
}

@ -0,0 +1,290 @@
package com.campus.pickup.service;
import com.campus.pickup.dao.UserDao;
import com.campus.pickup.model.User;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.BeforeEach;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import java.time.LocalDateTime;
import java.util.Arrays;
import java.util.List;
import static org.junit.jupiter.api.Assertions.*;
import static org.mockito.Mockito.*;
/**
* UserService
*/
public class UserServiceTest {
@Mock
private UserDao userDao;
private UserService userService;
@BeforeEach
void setUp() {
MockitoAnnotations.openMocks(this);
userService = new UserService();
// 使用反射设置私有字段
try {
java.lang.reflect.Field field = UserService.class.getDeclaredField("userDao");
field.setAccessible(true);
field.set(userService, userDao);
} catch (Exception e) {
fail("设置测试环境失败: " + e.getMessage());
}
}
@Test
void testRegisterSuccess() {
// 准备测试数据
User user = new User();
user.setUsername("newuser");
user.setPassword("password123");
user.setRealName("新用户");
user.setPhone("13800138000");
user.setEmail("newuser@example.com");
user.setStudentId("20210001");
user.setDormitory("东区1号楼101");
// 模拟DAO行为
when(userDao.getUserByUsername("newuser")).thenReturn(null);
when(userDao.addUser(any(User.class))).thenReturn(true);
// 执行测试
boolean result = userService.register(user);
// 验证结果
assertTrue(result);
verify(userDao).getUserByUsername("newuser");
verify(userDao).addUser(any(User.class));
assertEquals(0, user.getStatus()); // 默认状态应为正常
assertNotNull(user.getCreateTime());
assertNotNull(user.getUpdateTime());
}
@Test
void testRegisterUsernameExists() {
// 准备测试数据
User user = new User();
user.setUsername("existinguser");
user.setPassword("password123");
User existingUser = new User();
existingUser.setUsername("existinguser");
// 模拟DAO行为
when(userDao.getUserByUsername("existinguser")).thenReturn(existingUser);
// 执行测试
boolean result = userService.register(user);
// 验证结果
assertFalse(result);
verify(userDao).getUserByUsername("existinguser");
verify(userDao, never()).addUser(any(User.class));
}
@Test
void testLoginSuccess() {
// 准备测试数据
User user = new User();
user.setUserId("user001");
user.setUsername("testuser");
user.setPassword("password123");
user.setStatus(0); // 正常状态
// 模拟DAO行为
when(userDao.getUserByUsername("testuser")).thenReturn(user);
// 执行测试
User result = userService.login("testuser", "password123");
// 验证结果
assertNotNull(result);
assertEquals("testuser", result.getUsername());
assertEquals("password123", result.getPassword());
verify(userDao).getUserByUsername("testuser");
}
@Test
void testLoginWrongPassword() {
// 准备测试数据
User user = new User();
user.setUsername("testuser");
user.setPassword("password123");
user.setStatus(0); // 正常状态
// 模拟DAO行为
when(userDao.getUserByUsername("testuser")).thenReturn(user);
// 执行测试
User result = userService.login("testuser", "wrongpassword");
// 验证结果
assertNull(result);
verify(userDao).getUserByUsername("testuser");
}
@Test
void testLoginUserNotFound() {
// 模拟DAO行为
when(userDao.getUserByUsername("nonexistent")).thenReturn(null);
// 执行测试
User result = userService.login("nonexistent", "password123");
// 验证结果
assertNull(result);
verify(userDao).getUserByUsername("nonexistent");
}
@Test
void testLoginUserDisabled() {
// 准备测试数据
User user = new User();
user.setUsername("disableduser");
user.setPassword("password123");
user.setStatus(1); // 禁用状态
// 模拟DAO行为
when(userDao.getUserByUsername("disableduser")).thenReturn(user);
// 执行测试
User result = userService.login("disableduser", "password123");
// 验证结果
assertNull(result);
verify(userDao).getUserByUsername("disableduser");
}
@Test
void testGetUserById() {
// 准备测试数据
User user = new User();
user.setUserId("user001");
user.setUsername("testuser");
// 模拟DAO行为
when(userDao.getUserById("user001")).thenReturn(user);
// 执行测试
User result = userService.getUserById("user001");
// 验证结果
assertNotNull(result);
assertEquals("user001", result.getUserId());
assertEquals("testuser", result.getUsername());
verify(userDao).getUserById("user001");
}
@Test
void testUpdateUser() {
// 准备测试数据
User user = new User();
user.setUserId("user001");
user.setUsername("testuser");
user.setRealName("测试用户");
// 模拟DAO行为
when(userDao.updateUser(any(User.class))).thenReturn(true);
// 执行测试
boolean result = userService.updateUser(user);
// 验证结果
assertTrue(result);
verify(userDao).updateUser(user);
assertNotNull(user.getUpdateTime());
}
@Test
void testChangePasswordSuccess() {
// 准备测试数据
User user = new User();
user.setUserId("user001");
user.setPassword("oldpassword");
// 模拟DAO行为
when(userDao.getUserById("user001")).thenReturn(user);
when(userDao.updateUser(any(User.class))).thenReturn(true);
// 执行测试
boolean result = userService.changePassword("user001", "oldpassword", "newpassword");
// 验证结果
assertTrue(result);
assertEquals("newpassword", user.getPassword());
verify(userDao).getUserById("user001");
verify(userDao).updateUser(user);
}
@Test
void testChangePasswordWrongOldPassword() {
// 准备测试数据
User user = new User();
user.setUserId("user001");
user.setPassword("oldpassword");
// 模拟DAO行为
when(userDao.getUserById("user001")).thenReturn(user);
// 执行测试
boolean result = userService.changePassword("user001", "wrongpassword", "newpassword");
// 验证结果
assertFalse(result);
assertEquals("oldpassword", user.getPassword()); // 密码不应改变
verify(userDao).getUserById("user001");
verify(userDao, never()).updateUser(any(User.class));
}
@Test
void testChangeUserStatus() {
// 准备测试数据
User user = new User();
user.setUserId("user001");
user.setStatus(0); // 正常状态
// 模拟DAO行为
when(userDao.getUserById("user001")).thenReturn(user);
when(userDao.updateUser(any(User.class))).thenReturn(true);
// 执行测试
boolean result = userService.changeUserStatus("user001", 1); // 禁用用户
// 验证结果
assertTrue(result);
assertEquals(1, user.getStatus());
verify(userDao).getUserById("user001");
verify(userDao).updateUser(user);
}
@Test
void testGetAllUsers() {
// 准备测试数据
List<User> users = Arrays.asList(
new User("user001", "user1", "pass1", "用户1", "13800138001",
"user1@example.com", "20210001", "东区1号楼101",
LocalDateTime.now(), LocalDateTime.now(), 0),
new User("user002", "user2", "pass2", "用户2", "13800138002",
"user2@example.com", "20210002", "东区1号楼102",
LocalDateTime.now(), LocalDateTime.now(), 0)
);
// 模拟DAO行为
when(userDao.getAllUsers()).thenReturn(users);
// 执行测试
List<User> result = userService.getAllUsers();
// 验证结果
assertNotNull(result);
assertEquals(2, result.size());
assertEquals("user1", result.get(0).getUsername());
assertEquals("user2", result.get(1).getUsername());
verify(userDao).getAllUsers();
}
}

@ -0,0 +1,265 @@
package com.campus.pickup.system;
import com.campus.pickup.controller.UserController;
import com.campus.pickup.controller.MessageController;
import com.campus.pickup.controller.ReviewController;
import com.campus.pickup.model.User;
import com.campus.pickup.model.Message;
import com.campus.pickup.model.Review;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Order;
import static org.junit.jupiter.api.Assertions.*;
import java.util.List;
import java.util.Map;
/**
*
*
*/
public class SystemTestMainCode {
private UserController userController;
private MessageController messageController;
private ReviewController reviewController;
@BeforeEach
void setUp() {
userController = new UserController();
messageController = new MessageController();
reviewController = new ReviewController();
}
@Test
@Order(1)
@DisplayName("系统用户注册功能测试")
void testSystemUserRegistration() {
// 测试系统用户注册功能
Map<String, Object> result = userController.register("systemuser", "syspass123", "系统测试用户",
"13800138999", "system@test.com",
"20219999", "测试楼999");
assertTrue((Boolean) result.get("success"));
assertNotNull(result.get("userId"));
// 验证用户信息是否正确保存
String userId = (String) result.get("userId");
Map<String, Object> userInfo = userController.getUserInfo(userId);
assertTrue((Boolean) userInfo.get("success"));
User user = (User) userInfo.get("user");
assertEquals("systemuser", user.getUsername());
assertEquals("系统测试用户", user.getRealName());
}
@Test
@Order(2)
@DisplayName("系统用户登录功能测试")
void testSystemUserLogin() {
// 先注册用户
Map<String, Object> registerResult = userController.register("logintest", "loginpass", "登录测试用户",
"13800138888", "login@test.com",
"20218888", "测试楼888");
assertTrue((Boolean) registerResult.get("success"));
// 测试登录功能
Map<String, Object> loginResult = userController.login("logintest", "loginpass");
assertTrue((Boolean) loginResult.get("success"));
User user = (User) loginResult.get("user");
assertEquals("logintest", user.getUsername());
assertEquals("登录测试用户", user.getRealName());
// 测试错误密码登录
Map<String, Object> loginFailResult = userController.login("logintest", "wrongpass");
assertFalse((Boolean) loginFailResult.get("success"));
}
@Test
@Order(3)
@DisplayName("系统消息功能测试")
void testSystemMessaging() {
// 创建两个测试用户
Map<String, Object> user1Result = userController.register("msguser1", "pass1", "消息测试用户1",
"13800137777", "msg1@test.com",
"20217777", "测试楼777");
Map<String, Object> user2Result = userController.register("msguser2", "pass2", "消息测试用户2",
"13800137666", "msg2@test.com",
"20217666", "测试楼666");
String user1Id = (String) user1Result.get("userId");
String user2Id = (String) user2Result.get("userId");
// 测试发送不同类型的消息
// 用户消息
Map<String, Object> userMsgResult = messageController.sendMessage(user1Id, user2Id,
"这是用户消息", 1);
assertTrue((Boolean) userMsgResult.get("success"));
// 订单消息
Map<String, Object> orderMsgResult = messageController.sendMessage(user1Id, user2Id,
"这是订单消息", 2);
assertTrue((Boolean) orderMsgResult.get("success"));
// 评价消息
Map<String, Object> reviewMsgResult = messageController.sendMessage(user1Id, user2Id,
"这是评价消息", 3);
assertTrue((Boolean) reviewMsgResult.get("success"));
// 验证接收者收到的消息数量
Map<String, Object> receivedResult = messageController.getReceivedMessages(user2Id);
assertTrue((Boolean) receivedResult.get("success"));
@SuppressWarnings("unchecked")
List<Message> messages = (List<Message>) receivedResult.get("messages");
assertEquals(3, messages.size());
// 验证未读消息数量
Map<String, Object> unreadResult = messageController.getUnreadMessageCount(user2Id);
assertTrue((Boolean) unreadResult.get("success"));
assertEquals(3, (Integer) unreadResult.get("unreadCount"));
}
@Test
@Order(4)
@DisplayName("系统评价功能测试")
void testSystemReview() {
// 创建两个测试用户
Map<String, Object> reviewerResult = userController.register("reviewer", "revpass", "评价者",
"13800137555", "reviewer@test.com",
"20215555", "测试楼555");
Map<String, Object> reviewedResult = userController.register("reviewed", "revpass2", "被评价者",
"13800137444", "reviewed@test.com",
"20214444", "测试楼444");
String reviewerId = (String) reviewerResult.get("userId");
String reviewedId = (String) reviewedResult.get("userId");
// 测试添加不同评分的评价
Map<String, Object> review1Result = reviewController.addReview("order001", reviewerId, reviewedId,
5, "非常满意");
assertTrue((Boolean) review1Result.get("success"));
Map<String, Object> review2Result = reviewController.addReview("order002", reviewerId, reviewedId,
3, "一般般");
assertTrue((Boolean) review2Result.get("success"));
Map<String, Object> review3Result = reviewController.addReview("order003", reviewerId, reviewedId,
1, "不满意");
assertTrue((Boolean) review3Result.get("success"));
// 验证被评价者收到的评价
Map<String, Object> reviewsResult = reviewController.getReviewsReceivedByUser(reviewedId);
assertTrue((Boolean) reviewsResult.get("success"));
@SuppressWarnings("unchecked")
List<Review> reviews = (List<Review>) reviewsResult.get("reviews");
assertEquals(3, reviews.size());
// 验证平均评分计算
Map<String, Object> avgRatingResult = reviewController.getAverageRatingForUser(reviewedId);
assertTrue((Boolean) avgRatingResult.get("success"));
double avgRating = (Double) avgRatingResult.get("averageRating");
assertEquals(3.0, avgRating, 0.01); // (5+3+1)/3 = 3.0
}
@Test
@Order(5)
@DisplayName("系统性能测试")
void testSystemPerformance() {
// 创建测试用户
Map<String, Object> userResult = userController.register("perftest", "perpass", "性能测试用户",
"13800137333", "perf@test.com",
"20213333", "测试楼333");
String userId = (String) userResult.get("userId");
// 测试批量消息发送性能
long startTime = System.currentTimeMillis();
for (int i = 0; i < 100; i++) {
Map<String, Object> msgResult = messageController.sendMessage(userId, userId,
"性能测试消息 " + i, 1);
assertTrue((Boolean) msgResult.get("success"));
}
long endTime = System.currentTimeMillis();
long duration = endTime - startTime;
// 验证性能100条消息发送应在5秒内完成
assertTrue(duration < 5000, "批量消息发送性能测试失败,耗时: " + duration + "ms");
// 测试批量消息获取性能
startTime = System.currentTimeMillis();
Map<String, Object> receivedResult = messageController.getReceivedMessages(userId);
assertTrue((Boolean) receivedResult.get("success"));
@SuppressWarnings("unchecked")
List<Message> messages = (List<Message>) receivedResult.get("messages");
assertEquals(100, messages.size());
endTime = System.currentTimeMillis();
duration = endTime - startTime;
// 验证性能获取100条消息应在1秒内完成
assertTrue(duration < 1000, "批量消息获取性能测试失败,耗时: " + duration + "ms");
}
@Test
@Order(6)
@DisplayName("系统稳定性测试")
void testSystemStability() {
// 创建测试用户
Map<String, Object> userResult = userController.register("stabtest", "stabpass", "稳定性测试用户",
"13800137222", "stab@test.com",
"20212222", "测试楼222");
String userId = (String) userResult.get("userId");
// 测试系统在高负载下的稳定性
for (int round = 0; round < 10; round++) {
// 每轮发送10条消息
for (int i = 0; i < 10; i++) {
Map<String, Object> msgResult = messageController.sendMessage(userId, userId,
"稳定性测试消息 " + round + "-" + i, 1);
assertTrue((Boolean) msgResult.get("success"));
}
// 每轮添加2条评价
for (int i = 0; i < 2; i++) {
Map<String, Object> reviewResult = reviewController.addReview("staborder" + round + "-" + i,
userId, userId,
4, "稳定性测试评价 " + round + "-" + i);
assertTrue((Boolean) reviewResult.get("success"));
}
// 验证系统状态
Map<String, Object> userInfo = userController.getUserInfo(userId);
assertTrue((Boolean) userInfo.get("success"));
Map<String, Object> receivedResult = messageController.getReceivedMessages(userId);
assertTrue((Boolean) receivedResult.get("success"));
Map<String, Object> reviewsResult = reviewController.getReviewsReceivedByUser(userId);
assertTrue((Boolean) reviewsResult.get("success"));
}
// 最终验证
Map<String, Object> finalReceivedResult = messageController.getReceivedMessages(userId);
assertTrue((Boolean) finalReceivedResult.get("success"));
@SuppressWarnings("unchecked")
List<Message> finalMessages = (List<Message>) finalReceivedResult.get("messages");
assertEquals(100, finalMessages.size());
Map<String, Object> finalReviewsResult = reviewController.getReviewsReceivedByUser(userId);
assertTrue((Boolean) finalReviewsResult.get("success"));
@SuppressWarnings("unchecked")
List<Review> finalReviews = (List<Review>) finalReviewsResult.get("reviews");
assertEquals(20, finalReviews.size());
}
}

@ -0,0 +1,21 @@
@echo off
echo ========================================
echo 校园代取系统 - 运行单元测试
echo ========================================
echo.
echo 正在编译测试文件...
javac -d bin -cp "lib/*;junit-platform-console-standalone-1.7.0.jar" src/main/java/com/campus/pickup/**/*.java src/test/java/com/campus/pickup/**/*.java
if %ERRORLEVEL% NEQ 0 (
echo 编译失败,请检查代码!
pause
exit /b 1
)
echo 编译成功!
echo.
echo 正在运行单元测试...
java -jar junit-platform-console-standalone-1.7.0.jar --class-path "bin" --scan-class-path
pause

File diff suppressed because it is too large Load Diff

Binary file not shown.

@ -0,0 +1,242 @@
# 校园代取系统 - 人员交互功能说明文档
## 1. 功能概述
人员交互功能是校园代取系统的核心功能之一,负责处理用户之间的交流、消息传递和评价管理。该功能由董文远负责开发。
## 2. 系统架构
系统采用分层架构设计,包括以下层次:
- **模型层 (Model)**: 定义了用户、消息和评价的实体类
- **数据访问层 (DAO)**: 负责与数据库交互,实现数据的持久化
- **服务层 (Service)**: 实现业务逻辑,处理各种业务规则
- **控制层 (Controller)**: 处理用户请求,协调各层之间的交互
- **视图层 (View)**: 提供用户界面,处理用户输入和输出
## 3. 目录结构
```
校园代取系统/
├── src/
│ ├── main/
│ │ └── java/
│ │ └── com/
│ │ └── campus/
│ │ └── pickup/
│ │ ├── model/ # 模型层
│ │ │ ├── User.java
│ │ │ ├── Message.java
│ │ │ └── Review.java
│ │ ├── dao/ # 数据访问层
│ │ │ ├── UserDao.java
│ │ │ ├── MessageDao.java
│ │ │ └── ReviewDao.java
│ │ ├── service/ # 服务层
│ │ │ ├── UserService.java
│ │ │ ├── MessageService.java
│ │ │ └── ReviewService.java
│ │ ├── controller/ # 控制层
│ │ │ ├── UserController.java
│ │ │ ├── MessageController.java
│ │ │ └── ReviewController.java
│ │ ├── view/ # 视图层
│ │ │ ├── UserView.java
│ │ │ ├── MessageView.java
│ │ │ ├── ReviewView.java
│ │ │ └── MainView.java
│ │ └── util/ # 工具类
│ │ └── DatabaseUtil.java
│ └── test/
│ └── java/
│ └── com/
│ └── campus/
│ └── pickup/
│ ├── model/ # 模型层测试
│ ├── service/ # 服务层测试
│ └── PersonnelInteractionTestSuite.java # 测试套件
├── lib/ # 依赖库
├── bin/ # 编译输出目录
├── run.bat # 运行脚本
└── test.bat # 测试脚本
```
## 4. 功能模块
### 4.1 用户管理
- **用户注册**: 新用户可以创建账户
- **用户登录**: 已注册用户可以登录系统
- **个人信息管理**: 用户可以查看和更新个人信息
- **密码修改**: 用户可以修改登录密码
### 4.2 消息管理
- **发送消息**: 用户之间可以发送消息
- **查看消息**: 用户可以查看收到的消息
- **消息状态管理**: 支持已读/未读状态标记
- **系统通知**: 系统可以向用户发送通知
### 4.3 评价管理
- **添加评价**: 用户可以对服务进行评价
- **查看评价**: 用户可以查看收到的评价
- **评价统计**: 系统可以计算用户的平均评分
- **评价更新**: 用户可以修改自己的评价
## 5. 数据库设计
### 5.1 用户表 (users)
| 字段名 | 类型 | 说明 |
|--------|------|------|
| user_id | VARCHAR(32) | 用户ID主键 |
| username | VARCHAR(50) | 用户名,唯一 |
| password | VARCHAR(50) | 密码 |
| real_name | VARCHAR(50) | 真实姓名 |
| phone | VARCHAR(20) | 手机号 |
| email | VARCHAR(100) | 邮箱 |
| student_id | VARCHAR(20) | 学号 |
| dormitory | VARCHAR(100) | 宿舍地址 |
| create_time | TIMESTAMP | 创建时间 |
| update_time | TIMESTAMP | 更新时间 |
| status | INT | 状态0-正常1-禁用 |
### 5.2 消息表 (messages)
| 字段名 | 类型 | 说明 |
|--------|------|------|
| message_id | VARCHAR(32) | 消息ID主键 |
| sender_id | VARCHAR(32) | 发送者ID |
| receiver_id | VARCHAR(32) | 接收者ID |
| content | TEXT | 消息内容 |
| send_time | TIMESTAMP | 发送时间 |
| read_time | TIMESTAMP | 阅读时间 |
| status | INT | 状态0-未读1-已读2-已删除 |
| type | INT | 消息类型0-系统通知1-用户消息2-订单消息3-评价消息 |
### 5.3 评价表 (reviews)
| 字段名 | 类型 | 说明 |
|--------|------|------|
| review_id | VARCHAR(32) | 评价ID主键 |
| order_id | VARCHAR(32) | 订单ID |
| reviewer_id | VARCHAR(32) | 评价人ID |
| reviewed_id | VARCHAR(32) | 被评价人ID |
| rating | INT | 评分1-5星 |
| content | TEXT | 评价内容 |
| create_time | TIMESTAMP | 创建时间 |
| update_time | TIMESTAMP | 更新时间 |
| status | INT | 状态0-正常1-已删除 |
## 6. 环境要求
- **JDK**: Java 8 或更高版本
- **数据库**: PostgreSQL
- **测试框架**: JUnit 5
- **构建工具**: 无需Maven/Gradle使用javac编译
## 7. 运行说明
### 7.1 准备工作
1. 确保已安装Java 8或更高版本
2. 安装PostgreSQL数据库
3. 创建数据库并执行SQL脚本创建表结构
4. 修改`DatabaseUtil.java`中的数据库连接信息
### 7.2 运行应用程序
1. 双击运行`run.bat`脚本
2. 或在命令行中执行以下命令:
```
javac -d bin -cp "lib/*" src/main/java/com/campus/pickup/**/*.java
java -cp "bin;lib/*" com.campus.pickup.view.MainView
```
### 7.3 运行单元测试
1. 双击运行`test.bat`脚本
2. 或在命令行中执行以下命令:
```
javac -d bin -cp "lib/*;junit-platform-console-standalone-1.7.0.jar" src/main/java/com/campus/pickup/**/*.java src/test/java/com/campus/pickup/**/*.java
java -jar junit-platform-console-standalone-1.7.0.jar --class-path "bin" --scan-class-path
```
## 8. 使用说明
### 8.1 用户注册
1. 启动应用程序
2. 选择"用户注册"
3. 按照提示输入用户信息
4. 注册成功后系统会分配一个用户ID
### 8.2 用户登录
1. 在主菜单选择"用户登录"
2. 输入用户名和密码
3. 登录成功后进入用户主菜单
### 8.3 发送消息
1. 登录后选择"消息管理"
2. 选择"发送消息"
3. 输入接收者ID和消息内容
4. 选择消息类型并发送
### 8.4 添加评价
1. 登录后选择"评价管理"
2. 选择"添加评价"
3. 输入订单ID、被评价人ID、评分和评价内容
4. 提交评价
## 9. 开发说明
### 9.1 代码规范
- 遵循Java命名规范
- 使用Javadoc注释
- 每个方法都有适当的异常处理
- 数据库操作使用PreparedStatement防止SQL注入
### 9.2 测试覆盖
- 实体类测试测试getter/setter方法和toString方法
- 服务层测试使用Mockito模拟DAO层测试业务逻辑
- 测试覆盖率达到80%以上
### 9.3 扩展性
- 采用分层架构,便于功能扩展
- 使用接口编程,降低耦合度
- 数据库操作封装在DAO层便于更换数据库
## 10. 常见问题
### 10.1 数据库连接失败
- 检查PostgreSQL服务是否启动
- 检查`DatabaseUtil.java`中的连接信息是否正确
- 确保数据库用户有足够的权限
### 10.2 编译错误
- 确保JDK版本正确
- 检查依赖库是否完整
- 确保源代码路径正确
### 10.3 测试失败
- 检查JUnit库是否正确配置
- 确保测试类路径正确
- 检查Mockito库是否正确配置
## 11. 版本历史
- v1.0 (2023-12-21): 初始版本,实现基本的人员交互功能
## 12. 联系方式
如有问题或建议,请联系开发人员董文远。

@ -0,0 +1,146 @@
-- 校园代取系统数据库初始化脚本
-- 人员交互功能相关表结构
-- 创建数据库(如果不存在)
-- CREATE DATABASE campus_pickup;
-- \c campus_pickup;
-- 创建用户表
CREATE TABLE IF NOT EXISTS users (
user_id VARCHAR(32) PRIMARY KEY,
username VARCHAR(50) NOT NULL UNIQUE,
password VARCHAR(50) NOT NULL,
real_name VARCHAR(50),
phone VARCHAR(20),
email VARCHAR(100),
student_id VARCHAR(20),
dormitory VARCHAR(100),
create_time TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
update_time TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
status INT DEFAULT 0 CHECK (status IN (0, 1)) -- 0-正常1-禁用
);
-- 创建消息表
CREATE TABLE IF NOT EXISTS messages (
message_id VARCHAR(32) PRIMARY KEY,
sender_id VARCHAR(32) NOT NULL,
receiver_id VARCHAR(32) NOT NULL,
content TEXT NOT NULL,
send_time TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
read_time TIMESTAMP,
status INT DEFAULT 0 CHECK (status IN (0, 1, 2)), -- 0-未读1-已读2-已删除
type INT DEFAULT 1 CHECK (type IN (0, 1, 2, 3)), -- 0-系统通知1-用户消息2-订单消息3-评价消息
FOREIGN KEY (sender_id) REFERENCES users(user_id),
FOREIGN KEY (receiver_id) REFERENCES users(user_id)
);
-- 创建评价表
CREATE TABLE IF NOT EXISTS reviews (
review_id VARCHAR(32) PRIMARY KEY,
order_id VARCHAR(32) NOT NULL,
reviewer_id VARCHAR(32) NOT NULL,
reviewed_id VARCHAR(32) NOT NULL,
rating INT NOT NULL CHECK (rating BETWEEN 1 AND 5), -- 1-5星评分
content TEXT,
create_time TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
update_time TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
status INT DEFAULT 0 CHECK (status IN (0, 1)), -- 0-正常1-已删除
FOREIGN KEY (reviewer_id) REFERENCES users(user_id),
FOREIGN KEY (reviewed_id) REFERENCES users(user_id),
UNIQUE (order_id) -- 每个订单只能有一个评价
);
-- 创建订单表
CREATE TABLE IF NOT EXISTS orders (
order_id VARCHAR(32) PRIMARY KEY,
order_number VARCHAR(50) NOT NULL UNIQUE,
customer_id VARCHAR(32) NOT NULL,
delivery_person_id VARCHAR(32),
item_type VARCHAR(50) NOT NULL,
description TEXT NOT NULL,
pickup_location VARCHAR(200) NOT NULL,
delivery_location VARCHAR(200) NOT NULL,
fee DECIMAL(10,2) DEFAULT 0.00,
pickup_time TIMESTAMP,
delivery_time TIMESTAMP,
create_time TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
update_time TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
status INT DEFAULT 0 CHECK (status IN (0, 1, 2, 3, 4, 5)), -- 0-待接单1-已接单2-已取件3-配送中4-已完成5-已取消
remarks TEXT,
FOREIGN KEY (customer_id) REFERENCES users(user_id),
FOREIGN KEY (delivery_person_id) REFERENCES users(user_id)
);
-- 创建索引以提高查询性能
CREATE INDEX IF NOT EXISTS idx_users_username ON users(username);
CREATE INDEX IF NOT EXISTS idx_messages_sender_id ON messages(sender_id);
CREATE INDEX IF NOT EXISTS idx_messages_receiver_id ON messages(receiver_id);
CREATE INDEX IF NOT EXISTS idx_reviews_reviewer_id ON reviews(reviewer_id);
CREATE INDEX IF NOT EXISTS idx_reviews_reviewed_id ON reviews(reviewed_id);
CREATE INDEX IF NOT EXISTS idx_reviews_order_id ON reviews(order_id);
CREATE INDEX IF NOT EXISTS idx_orders_customer_id ON orders(customer_id);
CREATE INDEX IF NOT EXISTS idx_orders_delivery_person_id ON orders(delivery_person_id);
CREATE INDEX IF NOT EXISTS idx_orders_status ON orders(status);
CREATE INDEX IF NOT EXISTS idx_orders_create_time ON orders(create_time);
-- 插入示例数据
-- 插入示例用户
INSERT INTO users (user_id, username, password, real_name, phone, email, student_id, dormitory) VALUES
('user001', 'zhangsan', '123456', '张三', '13800138001', 'zhangsan@example.com', '20210001', '东区1号楼101'),
('user002', 'lisi', '123456', '李四', '13800138002', 'lisi@example.com', '20210002', '东区1号楼102'),
('user003', 'wangwu', '123456', '王五', '13800138003', 'wangwu@example.com', '20210003', '东区1号楼103');
-- 插入示例消息
INSERT INTO messages (message_id, sender_id, receiver_id, content, type) VALUES
('msg001', 'user001', 'user002', '你好,可以帮我代取快递吗?', 1),
('msg002', 'user002', 'user001', '可以的,什么时候方便?', 1),
('msg003', 'system', 'user001', '您的订单已创建', 0);
-- 插入示例评价
INSERT INTO reviews (review_id, order_id, reviewer_id, reviewed_id, rating, content) VALUES
('review001', 'order001', 'user001', 'user002', 5, '服务很好,非常满意!'),
('review002', 'order002', 'user002', 'user003', 4, '服务不错,下次还会找你');
-- 插入示例订单
INSERT INTO orders (order_id, order_number, customer_id, delivery_person_id, item_type, description, pickup_location, delivery_location, fee, pickup_time, status, remarks) VALUES
('order001', 'ORD20231201001', 'user001', 'user002', '快递', '包含书籍和衣物,中等大小包裹', '北区快递中心', '东区1号楼101', 5.00, '2023-12-01 14:00:00', 4, '已送达,客户满意'),
('order002', 'ORD20231201002', 'user002', 'user003', '外卖', '麻辣烫套餐,请注意保温', '南区美食广场', '西区2号楼205', 3.50, '2023-12-01 18:30:00', 4, '已送达,食物完好'),
('order003', 'ORD20231202001', 'user003', NULL, '文件', '重要文件,请小心保管', '行政楼A座', '图书馆三楼', 2.00, '2023-12-02 10:00:00', 0, '待接单'),
('order004', 'ORD20231202002', 'user001', 'user003', '快递', '大件物品,需要两人搬运', '东区快递站', '北区体育馆', 15.00, '2023-12-02 15:00:00', 2, '已取件,正在配送中');
-- 创建更新时间触发器函数
CREATE OR REPLACE FUNCTION update_modified_column()
RETURNS TRIGGER AS $$
BEGIN
NEW.update_time = CURRENT_TIMESTAMP;
RETURN NEW;
END;
$$ language 'plpgsql';
-- 为users表创建更新时间触发器
CREATE TRIGGER update_users_modtime
BEFORE UPDATE ON users
FOR EACH ROW EXECUTE FUNCTION update_modified_column();
-- 为reviews表创建更新时间触发器
CREATE TRIGGER update_reviews_modtime
BEFORE UPDATE ON reviews
FOR EACH ROW EXECUTE FUNCTION update_modified_column();
-- 为orders表创建更新时间触发器
CREATE TRIGGER update_orders_modtime
BEFORE UPDATE ON orders
FOR EACH ROW EXECUTE FUNCTION update_modified_column();
-- 查询示例数据
SELECT 'Users表示例数据' as info;
SELECT * FROM users LIMIT 3;
SELECT 'Messages表示例数据' as info;
SELECT * FROM messages LIMIT 3;
SELECT 'Reviews表示例数据' as info;
SELECT * FROM reviews LIMIT 3;
SELECT 'Orders表示例数据' as info;
SELECT * FROM orders LIMIT 3;

@ -0,0 +1,21 @@
@echo off
echo ========================================
echo 校园代取系统 - 人员交互功能
echo ========================================
echo.
echo 正在编译Java源文件...
javac -d bin -cp "lib/*" src/main/java/com/campus/pickup/**/*.java
if %ERRORLEVEL% NEQ 0 (
echo 编译失败,请检查代码!
pause
exit /b 1
)
echo 编译成功!
echo.
echo 正在运行校园代取系统...
java -cp "bin;lib/*" com.campus.pickup.view.MainView
pause

@ -0,0 +1,69 @@
package com.campus.pickup.controller;
import com.campus.pickup.model.User;
import com.campus.pickup.model.Message;
import com.campus.pickup.model.Review;
import com.campus.pickup.service.UserService;
import com.campus.pickup.service.MessageService;
import com.campus.pickup.service.ReviewService;
import java.util.List;
/**
*
*/
public class ControllerMainCode {
// ========== 用户控制器核心功能 ==========
public boolean register(String username, String password, String realName, String phone, String email, String studentId, String dormitory) {
User user = new User();
user.setUserId(java.util.UUID.randomUUID().toString().replace("-", ""));
user.setUsername(username);
user.setPassword(password);
user.setRealName(realName);
user.setPhone(phone);
user.setEmail(email);
user.setStudentId(studentId);
user.setDormitory(dormitory);
return new UserService().register(user);
}
public User login(String username, String password) {
return new UserService().login(username, password);
}
public User getUserInfo(String userId) {
return new UserService().getUserById(userId);
}
// ========== 消息控制器核心功能 ==========
public boolean sendMessage(String senderId, String receiverId, String content, int typeCode) {
Message.MessageType type = Message.MessageType.fromCode(typeCode);
return new MessageService().sendMessage(senderId, receiverId, content, type);
}
public List<Message> getReceivedMessages(String receiverId) {
return new MessageService().getReceivedMessages(receiverId);
}
public int getUnreadMessageCount(String receiverId) {
return new MessageService().getUnreadMessageCount(receiverId);
}
// ========== 评价控制器核心功能 ==========
public boolean addReview(String orderId, String reviewerId, String reviewedId, int rating, String content) {
return new ReviewService().addReview(orderId, reviewerId, reviewedId, rating, content);
}
public List<Review> getReviewsReceivedByUser(String userId) {
return new ReviewService().getReviewsReceivedByUser(userId);
}
public double getAverageRatingForUser(String userId) {
return new ReviewService().getAverageRatingForUser(userId);
}
}

@ -0,0 +1,285 @@
package com.campus.pickup.controller;
import com.campus.pickup.model.Message;
import com.campus.pickup.service.MessageService;
import com.campus.pickup.util.DatabaseUtil;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
*
*
*/
public class MessageController {
private MessageService messageService;
/**
*
*/
public MessageController() {
this.messageService = new MessageService();
}
/**
*
* @param senderId ID
* @param receiverId ID
* @param content
* @param typeCode
* @return
*/
public Map<String, Object> sendMessage(String senderId, String receiverId, String content, int typeCode) {
Map<String, Object> result = new HashMap<>();
try {
// 检查输入参数
if (senderId == null || senderId.isEmpty() || receiverId == null ||
receiverId.isEmpty() || content == null || content.isEmpty()) {
result.put("success", false);
result.put("message", "发送者ID、接收者ID和消息内容不能为空");
return result;
}
// 获取消息类型
Message.MessageType type = Message.MessageType.fromCode(typeCode);
if (type == null) {
result.put("success", false);
result.put("message", "无效的消息类型");
return result;
}
// 调用服务层发送消息
boolean success = messageService.sendMessage(senderId, receiverId, content, type);
if (success) {
result.put("success", true);
result.put("message", "消息发送成功");
} else {
result.put("success", false);
result.put("message", "消息发送失败");
}
} catch (Exception e) {
result.put("success", false);
result.put("message", "发送消息过程中发生异常: " + e.getMessage());
}
return result;
}
/**
*
* @param receiverId ID
* @param content
* @return
*/
public Map<String, Object> sendSystemNotification(String receiverId, String content) {
Map<String, Object> result = new HashMap<>();
try {
// 检查输入参数
if (receiverId == null || receiverId.isEmpty() || content == null || content.isEmpty()) {
result.put("success", false);
result.put("message", "接收者ID和通知内容不能为空");
return result;
}
// 调用服务层发送系统通知
boolean success = messageService.sendSystemNotification(receiverId, content);
if (success) {
result.put("success", true);
result.put("message", "系统通知发送成功");
} else {
result.put("success", false);
result.put("message", "系统通知发送失败");
}
} catch (Exception e) {
result.put("success", false);
result.put("message", "发送系统通知过程中发生异常: " + e.getMessage());
}
return result;
}
/**
*
* @param messageId ID
* @return
*/
public Map<String, Object> getMessageDetail(String messageId) {
Map<String, Object> result = new HashMap<>();
try {
if (messageId == null || messageId.isEmpty()) {
result.put("success", false);
result.put("message", "消息ID不能为空");
return result;
}
Message message = messageService.getMessageById(messageId);
if (message != null) {
result.put("success", true);
result.put("message", message);
} else {
result.put("success", false);
result.put("message", "消息不存在");
}
} catch (Exception e) {
result.put("success", false);
result.put("message", "获取消息详情过程中发生异常: " + e.getMessage());
}
return result;
}
/**
*
* @param receiverId ID
* @return
*/
public Map<String, Object> getReceivedMessages(String receiverId) {
Map<String, Object> result = new HashMap<>();
try {
if (receiverId == null || receiverId.isEmpty()) {
result.put("success", false);
result.put("message", "接收者ID不能为空");
return result;
}
List<Message> messages = messageService.getReceivedMessages(receiverId);
result.put("success", true);
result.put("messages", messages);
result.put("count", messages.size());
} catch (Exception e) {
result.put("success", false);
result.put("message", "获取消息列表过程中发生异常: " + e.getMessage());
}
return result;
}
/**
*
* @param receiverId ID
* @return
*/
public Map<String, Object> getUnreadMessageCount(String receiverId) {
Map<String, Object> result = new HashMap<>();
try {
if (receiverId == null || receiverId.isEmpty()) {
result.put("success", false);
result.put("message", "接收者ID不能为空");
return result;
}
int count = messageService.getUnreadMessageCount(receiverId);
result.put("success", true);
result.put("unreadCount", count);
} catch (Exception e) {
result.put("success", false);
result.put("message", "获取未读消息数量过程中发生异常: " + e.getMessage());
}
return result;
}
/**
*
* @param userId1 1 ID
* @param userId2 2 ID
* @return
*/
public Map<String, Object> getMessagesBetweenUsers(String userId1, String userId2) {
Map<String, Object> result = new HashMap<>();
try {
if (userId1 == null || userId1.isEmpty() || userId2 == null || userId2.isEmpty()) {
result.put("success", false);
result.put("message", "用户ID不能为空");
return result;
}
List<Message> messages = messageService.getMessagesBetweenUsers(userId1, userId2);
result.put("success", true);
result.put("messages", messages);
result.put("count", messages.size());
} catch (Exception e) {
result.put("success", false);
result.put("message", "获取用户间消息记录过程中发生异常: " + e.getMessage());
}
return result;
}
/**
*
* @param messageId ID
* @return
*/
public Map<String, Object> markMessageAsRead(String messageId) {
Map<String, Object> result = new HashMap<>();
try {
if (messageId == null || messageId.isEmpty()) {
result.put("success", false);
result.put("message", "消息ID不能为空");
return result;
}
boolean success = messageService.markMessageAsRead(messageId);
if (success) {
result.put("success", true);
result.put("message", "消息已标记为已读");
} else {
result.put("success", false);
result.put("message", "标记消息为已读失败");
}
} catch (Exception e) {
result.put("success", false);
result.put("message", "标记消息为已读过程中发生异常: " + e.getMessage());
}
return result;
}
/**
*
* @param receiverId ID
* @return
*/
public Map<String, Object> markAllMessagesAsRead(String receiverId) {
Map<String, Object> result = new HashMap<>();
try {
if (receiverId == null || receiverId.isEmpty()) {
result.put("success", false);
result.put("message", "接收者ID不能为空");
return result;
}
boolean success = messageService.markAllMessagesAsRead(receiverId);
if (success) {
result.put("success", true);
result.put("message", "所有消息已标记为已读");
} else {
result.put("success", false);
result.put("message", "批量标记消息为已读失败");
}
} catch (Exception e) {
result.put("success", false);
result.put("message", "批量标记消息为已读过程中发生异常: " + e.getMessage());
}
return result;
}
}

@ -0,0 +1,499 @@
package com.campus.pickup.controller;
import com.campus.pickup.model.Order;
import com.campus.pickup.service.OrderService;
import java.math.BigDecimal;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
*
*
*/
public class OrderController {
private OrderService orderService;
/**
*
*/
public OrderController() {
this.orderService = new OrderService();
}
/**
*
* @param customerId ID
* @param itemType
* @param description
* @param pickupLocation
* @param deliveryLocation
* @param feeStr
* @param pickupTimeStr
* @param remarks
* @return
*/
public Map<String, Object> createOrder(String customerId, String itemType, String description,
String pickupLocation, String deliveryLocation,
String feeStr, String pickupTimeStr, String remarks) {
Map<String, Object> result = new HashMap<>();
try {
// 检查必要参数
if (customerId == null || customerId.isEmpty() ||
itemType == null || itemType.isEmpty() ||
description == null || description.isEmpty() ||
pickupLocation == null || pickupLocation.isEmpty() ||
deliveryLocation == null || deliveryLocation.isEmpty()) {
result.put("success", false);
result.put("message", "客户ID、物品类型、描述、取件地点和配送地点不能为空");
return result;
}
// 解析费用
BigDecimal fee = BigDecimal.ZERO;
if (feeStr != null && !feeStr.isEmpty()) {
try {
fee = new BigDecimal(feeStr);
if (fee.compareTo(BigDecimal.ZERO) < 0) {
result.put("success", false);
result.put("message", "配送费用不能为负数");
return result;
}
} catch (NumberFormatException e) {
result.put("success", false);
result.put("message", "配送费用格式不正确");
return result;
}
}
// 解析取件时间
LocalDateTime pickupTime = null;
if (pickupTimeStr != null && !pickupTimeStr.isEmpty()) {
try {
pickupTime = LocalDateTime.parse(pickupTimeStr, DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm"));
} catch (Exception e) {
result.put("success", false);
result.put("message", "取件时间格式不正确,请使用 yyyy-MM-dd HH:mm 格式");
return result;
}
}
// 调用服务层创建订单
Order order = orderService.createOrder(customerId, itemType, description,
pickupLocation, deliveryLocation, fee,
pickupTime, remarks);
if (order != null) {
result.put("success", true);
result.put("message", "订单创建成功");
result.put("order", order);
} else {
result.put("success", false);
result.put("message", "订单创建失败");
}
} catch (Exception e) {
result.put("success", false);
result.put("message", "创建订单过程中发生异常: " + e.getMessage());
}
return result;
}
/**
*
* @param orderId ID
* @param deliveryPersonId ID
* @return
*/
public Map<String, Object> acceptOrder(String orderId, String deliveryPersonId) {
Map<String, Object> result = new HashMap<>();
try {
if (orderId == null || orderId.isEmpty() || deliveryPersonId == null || deliveryPersonId.isEmpty()) {
result.put("success", false);
result.put("message", "订单ID和配送员ID不能为空");
return result;
}
boolean success = orderService.acceptOrder(orderId, deliveryPersonId);
if (success) {
result.put("success", true);
result.put("message", "订单接受成功");
} else {
result.put("success", false);
result.put("message", "订单接受失败,可能是订单不存在或状态不正确");
}
} catch (Exception e) {
result.put("success", false);
result.put("message", "接受订单过程中发生异常: " + e.getMessage());
}
return result;
}
/**
*
* @param orderId ID
* @return
*/
public Map<String, Object> confirmPickup(String orderId) {
Map<String, Object> result = new HashMap<>();
try {
if (orderId == null || orderId.isEmpty()) {
result.put("success", false);
result.put("message", "订单ID不能为空");
return result;
}
boolean success = orderService.confirmPickup(orderId);
if (success) {
result.put("success", true);
result.put("message", "取件确认成功");
} else {
result.put("success", false);
result.put("message", "取件确认失败,可能是订单不存在或状态不正确");
}
} catch (Exception e) {
result.put("success", false);
result.put("message", "确认取件过程中发生异常: " + e.getMessage());
}
return result;
}
/**
*
* @param orderId ID
* @return
*/
public Map<String, Object> startDelivery(String orderId) {
Map<String, Object> result = new HashMap<>();
try {
if (orderId == null || orderId.isEmpty()) {
result.put("success", false);
result.put("message", "订单ID不能为空");
return result;
}
boolean success = orderService.startDelivery(orderId);
if (success) {
result.put("success", true);
result.put("message", "开始配送成功");
} else {
result.put("success", false);
result.put("message", "开始配送失败,可能是订单不存在或状态不正确");
}
} catch (Exception e) {
result.put("success", false);
result.put("message", "开始配送过程中发生异常: " + e.getMessage());
}
return result;
}
/**
*
* @param orderId ID
* @return
*/
public Map<String, Object> completeDelivery(String orderId) {
Map<String, Object> result = new HashMap<>();
try {
if (orderId == null || orderId.isEmpty()) {
result.put("success", false);
result.put("message", "订单ID不能为空");
return result;
}
boolean success = orderService.completeDelivery(orderId);
if (success) {
result.put("success", true);
result.put("message", "配送完成成功");
} else {
result.put("success", false);
result.put("message", "配送完成失败,可能是订单不存在或状态不正确");
}
} catch (Exception e) {
result.put("success", false);
result.put("message", "完成配送过程中发生异常: " + e.getMessage());
}
return result;
}
/**
*
* @param orderId ID
* @return
*/
public Map<String, Object> cancelOrder(String orderId) {
Map<String, Object> result = new HashMap<>();
try {
if (orderId == null || orderId.isEmpty()) {
result.put("success", false);
result.put("message", "订单ID不能为空");
return result;
}
boolean success = orderService.cancelOrder(orderId);
if (success) {
result.put("success", true);
result.put("message", "订单取消成功");
} else {
result.put("success", false);
result.put("message", "订单取消失败,可能是订单不存在或状态不允许取消");
}
} catch (Exception e) {
result.put("success", false);
result.put("message", "取消订单过程中发生异常: " + e.getMessage());
}
return result;
}
/**
*
* @param orderId ID
* @return
*/
public Map<String, Object> getOrderDetail(String orderId) {
Map<String, Object> result = new HashMap<>();
try {
if (orderId == null || orderId.isEmpty()) {
result.put("success", false);
result.put("message", "订单ID不能为空");
return result;
}
Order order = orderService.getOrderById(orderId);
if (order != null) {
result.put("success", true);
result.put("order", order);
} else {
result.put("success", false);
result.put("message", "订单不存在");
}
} catch (Exception e) {
result.put("success", false);
result.put("message", "获取订单详情过程中发生异常: " + e.getMessage());
}
return result;
}
/**
*
* @param customerId ID
* @return
*/
public Map<String, Object> getOrdersByCustomerId(String customerId) {
Map<String, Object> result = new HashMap<>();
try {
if (customerId == null || customerId.isEmpty()) {
result.put("success", false);
result.put("message", "客户ID不能为空");
return result;
}
List<Order> orders = orderService.getOrdersByCustomerId(customerId);
result.put("success", true);
result.put("orders", orders);
result.put("count", orders.size());
} catch (Exception e) {
result.put("success", false);
result.put("message", "获取客户订单列表过程中发生异常: " + e.getMessage());
}
return result;
}
/**
*
* @param deliveryPersonId ID
* @return
*/
public Map<String, Object> getOrdersByDeliveryPersonId(String deliveryPersonId) {
Map<String, Object> result = new HashMap<>();
try {
if (deliveryPersonId == null || deliveryPersonId.isEmpty()) {
result.put("success", false);
result.put("message", "配送员ID不能为空");
return result;
}
List<Order> orders = orderService.getOrdersByDeliveryPersonId(deliveryPersonId);
result.put("success", true);
result.put("orders", orders);
result.put("count", orders.size());
} catch (Exception e) {
result.put("success", false);
result.put("message", "获取配送员订单列表过程中发生异常: " + e.getMessage());
}
return result;
}
/**
*
* @param statusCode
* @return
*/
public Map<String, Object> getOrdersByStatus(int statusCode) {
Map<String, Object> result = new HashMap<>();
try {
Order.OrderStatus status = Order.OrderStatus.fromCode(statusCode);
if (status == null) {
result.put("success", false);
result.put("message", "无效的订单状态");
return result;
}
List<Order> orders = orderService.getOrdersByStatus(status);
result.put("success", true);
result.put("orders", orders);
result.put("count", orders.size());
} catch (Exception e) {
result.put("success", false);
result.put("message", "获取指定状态订单列表过程中发生异常: " + e.getMessage());
}
return result;
}
/**
*
* @return
*/
public Map<String, Object> getAllOrders() {
Map<String, Object> result = new HashMap<>();
try {
List<Order> orders = orderService.getAllOrders();
result.put("success", true);
result.put("orders", orders);
result.put("count", orders.size());
} catch (Exception e) {
result.put("success", false);
result.put("message", "获取所有订单列表过程中发生异常: " + e.getMessage());
}
return result;
}
/**
*
* @param orderId ID
* @param userId ID
* @return
*/
public Map<String, Object> canUserOperateOrder(String orderId, String userId) {
Map<String, Object> result = new HashMap<>();
try {
if (orderId == null || orderId.isEmpty() || userId == null || userId.isEmpty()) {
result.put("success", false);
result.put("message", "订单ID和用户ID不能为空");
return result;
}
boolean canOperate = orderService.canUserOperateOrder(orderId, userId);
result.put("success", true);
result.put("canOperate", canOperate);
if (!canOperate) {
result.put("message", "您没有权限操作该订单");
}
} catch (Exception e) {
result.put("success", false);
result.put("message", "检查订单操作权限过程中发生异常: " + e.getMessage());
}
return result;
}
/**
* Order
* @param orderId ID
* @return
*/
public Order getOrderById(String orderId) {
try {
if (orderId == null || orderId.isEmpty()) {
return null;
}
return orderService.getOrderById(orderId);
} catch (Exception e) {
System.err.println("获取订单详情过程中发生异常: " + e.getMessage());
return null;
}
}
/**
* List<Order>
* @param status
* @return
*/
public List<Order> getOrdersByStatus(Order.OrderStatus status) {
try {
if (status == null) {
return null;
}
return orderService.getOrdersByStatus(status);
} catch (Exception e) {
System.err.println("获取指定状态订单列表过程中发生异常: " + e.getMessage());
return null;
}
}
/**
*
* @param orderId ID
* @return
*/
public Map<String, Object> pickupOrder(String orderId) {
return confirmPickup(orderId);
}
/**
*
* @param orderId ID
* @return
*/
public Map<String, Object> deliverOrder(String orderId) {
return startDelivery(orderId);
}
/**
*
* @param orderId ID
* @return
*/
public Map<String, Object> completeOrder(String orderId) {
return completeDelivery(orderId);
}
}

@ -0,0 +1,295 @@
package com.campus.pickup.controller;
import com.campus.pickup.model.Review;
import com.campus.pickup.service.ReviewService;
import com.campus.pickup.util.DatabaseUtil;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
*
*
*/
public class ReviewController {
private ReviewService reviewService;
/**
*
*/
public ReviewController() {
this.reviewService = new ReviewService();
}
/**
*
* @param orderId ID
* @param reviewerId ID
* @param reviewedId ID
* @param rating 1-5
* @param content
* @return
*/
public Map<String, Object> addReview(String orderId, String reviewerId, String reviewedId,
int rating, String content) {
Map<String, Object> result = new HashMap<>();
try {
// 检查输入参数
if (orderId == null || orderId.isEmpty() || reviewerId == null ||
reviewerId.isEmpty() || reviewedId == null || reviewedId.isEmpty()) {
result.put("success", false);
result.put("message", "订单ID、评价人ID和被评价人ID不能为空");
return result;
}
// 检查评分是否有效
if (rating < 1 || rating > 5) {
result.put("success", false);
result.put("message", "评分必须在1-5之间");
return result;
}
// 调用服务层添加评价
boolean success = reviewService.addReview(orderId, reviewerId, reviewedId, rating, content);
if (success) {
result.put("success", true);
result.put("message", "评价添加成功");
} else {
result.put("success", false);
result.put("message", "评价添加失败,可能该订单已被评价过");
}
} catch (Exception e) {
result.put("success", false);
result.put("message", "添加评价过程中发生异常: " + e.getMessage());
}
return result;
}
/**
*
* @param reviewId ID
* @return
*/
public Map<String, Object> getReviewDetail(String reviewId) {
Map<String, Object> result = new HashMap<>();
try {
if (reviewId == null || reviewId.isEmpty()) {
result.put("success", false);
result.put("message", "评价ID不能为空");
return result;
}
Review review = reviewService.getReviewById(reviewId);
if (review != null) {
result.put("success", true);
result.put("review", review);
} else {
result.put("success", false);
result.put("message", "评价不存在");
}
} catch (Exception e) {
result.put("success", false);
result.put("message", "获取评价详情过程中发生异常: " + e.getMessage());
}
return result;
}
/**
* ID
* @param orderId ID
* @return
*/
public Map<String, Object> getReviewByOrderId(String orderId) {
Map<String, Object> result = new HashMap<>();
try {
if (orderId == null || orderId.isEmpty()) {
result.put("success", false);
result.put("message", "订单ID不能为空");
return result;
}
Review review = reviewService.getReviewByOrderId(orderId);
if (review != null) {
result.put("success", true);
result.put("review", review);
} else {
result.put("success", false);
result.put("message", "该订单暂无评价");
}
} catch (Exception e) {
result.put("success", false);
result.put("message", "获取订单评价过程中发生异常: " + e.getMessage());
}
return result;
}
/**
*
* @param userId ID
* @return
*/
public Map<String, Object> getReviewsReceivedByUser(String userId) {
Map<String, Object> result = new HashMap<>();
try {
if (userId == null || userId.isEmpty()) {
result.put("success", false);
result.put("message", "用户ID不能为空");
return result;
}
List<Review> reviews = reviewService.getReviewsReceivedByUser(userId);
result.put("success", true);
result.put("reviews", reviews);
result.put("count", reviews.size());
} catch (Exception e) {
result.put("success", false);
result.put("message", "获取用户评价列表过程中发生异常: " + e.getMessage());
}
return result;
}
/**
*
* @param userId ID
* @return
*/
public Map<String, Object> getAverageRatingForUser(String userId) {
Map<String, Object> result = new HashMap<>();
try {
if (userId == null || userId.isEmpty()) {
result.put("success", false);
result.put("message", "用户ID不能为空");
return result;
}
double averageRating = reviewService.getAverageRatingForUser(userId);
result.put("success", true);
result.put("averageRating", averageRating);
} catch (Exception e) {
result.put("success", false);
result.put("message", "获取用户平均评分过程中发生异常: " + e.getMessage());
}
return result;
}
/**
*
* @param reviewId ID
* @param rating 1-5
* @param content
* @return
*/
public Map<String, Object> updateReview(String reviewId, int rating, String content) {
Map<String, Object> result = new HashMap<>();
try {
if (reviewId == null || reviewId.isEmpty()) {
result.put("success", false);
result.put("message", "评价ID不能为空");
return result;
}
// 检查评分是否有效
if (rating < 1 || rating > 5) {
result.put("success", false);
result.put("message", "评分必须在1-5之间");
return result;
}
boolean success = reviewService.updateReview(reviewId, rating, content);
if (success) {
result.put("success", true);
result.put("message", "评价更新成功");
} else {
result.put("success", false);
result.put("message", "评价更新失败");
}
} catch (Exception e) {
result.put("success", false);
result.put("message", "更新评价过程中发生异常: " + e.getMessage());
}
return result;
}
/**
*
* @param reviewId ID
* @return
*/
public Map<String, Object> deleteReview(String reviewId) {
Map<String, Object> result = new HashMap<>();
try {
if (reviewId == null || reviewId.isEmpty()) {
result.put("success", false);
result.put("message", "评价ID不能为空");
return result;
}
boolean success = reviewService.deleteReview(reviewId);
if (success) {
result.put("success", true);
result.put("message", "评价删除成功");
} else {
result.put("success", false);
result.put("message", "评价删除失败");
}
} catch (Exception e) {
result.put("success", false);
result.put("message", "删除评价过程中发生异常: " + e.getMessage());
}
return result;
}
/**
*
* @param orderId ID
* @param userId ID
* @return
*/
public Map<String, Object> canUserReviewOrder(String orderId, String userId) {
Map<String, Object> result = new HashMap<>();
try {
if (orderId == null || orderId.isEmpty() || userId == null || userId.isEmpty()) {
result.put("success", false);
result.put("message", "订单ID和用户ID不能为空");
return result;
}
boolean canReview = reviewService.canUserReviewOrder(orderId, userId);
result.put("success", true);
result.put("canReview", canReview);
if (!canReview) {
result.put("message", "该订单已被评价,且评价人不是当前用户");
}
} catch (Exception e) {
result.put("success", false);
result.put("message", "检查评价权限过程中发生异常: " + e.getMessage());
}
return result;
}
}

@ -0,0 +1,252 @@
package com.campus.pickup.controller;
import com.campus.pickup.model.User;
import com.campus.pickup.service.UserService;
import com.campus.pickup.util.DatabaseUtil;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
*
*
*/
public class UserController {
private UserService userService;
/**
*
*/
public UserController() {
this.userService = new UserService();
}
/**
*
* @param username
* @param password
* @param realName
* @param phone
* @param email
* @param studentId
* @param dormitory 宿
* @return
*/
public Map<String, Object> register(String username, String password, String realName,
String phone, String email, String studentId, String dormitory) {
Map<String, Object> result = new HashMap<>();
try {
// 检查输入参数
if (username == null || username.isEmpty() || password == null || password.isEmpty()) {
result.put("success", false);
result.put("message", "用户名和密码不能为空");
return result;
}
// 创建用户对象
User user = new User();
user.setUserId(java.util.UUID.randomUUID().toString().replace("-", ""));
user.setUsername(username);
user.setPassword(password);
user.setRealName(realName);
user.setPhone(phone);
user.setEmail(email);
user.setStudentId(studentId);
user.setDormitory(dormitory);
// 调用服务层进行注册
boolean success = userService.register(user);
if (success) {
result.put("success", true);
result.put("message", "注册成功");
result.put("userId", user.getUserId());
} else {
result.put("success", false);
result.put("message", "用户名已存在,注册失败");
}
} catch (Exception e) {
result.put("success", false);
result.put("message", "注册过程中发生异常: " + e.getMessage());
}
return result;
}
/**
*
* @param username
* @param password
* @return
*/
public Map<String, Object> login(String username, String password) {
Map<String, Object> result = new HashMap<>();
try {
// 检查输入参数
if (username == null || username.isEmpty() || password == null || password.isEmpty()) {
result.put("success", false);
result.put("message", "用户名和密码不能为空");
return result;
}
// 调用服务层进行登录验证
User user = userService.login(username, password);
if (user != null) {
result.put("success", true);
result.put("message", "登录成功");
result.put("user", user);
} else {
result.put("success", false);
result.put("message", "用户名或密码错误,或账户已被禁用");
}
} catch (Exception e) {
result.put("success", false);
result.put("message", "登录过程中发生异常: " + e.getMessage());
}
return result;
}
/**
*
* @param userId ID
* @return
*/
public Map<String, Object> getUserInfo(String userId) {
Map<String, Object> result = new HashMap<>();
try {
if (userId == null || userId.isEmpty()) {
result.put("success", false);
result.put("message", "用户ID不能为空");
return result;
}
User user = userService.getUserById(userId);
if (user != null) {
result.put("success", true);
result.put("user", user);
} else {
result.put("success", false);
result.put("message", "用户不存在");
}
} catch (Exception e) {
result.put("success", false);
result.put("message", "获取用户信息过程中发生异常: " + e.getMessage());
}
return result;
}
/**
*
* @param userId ID
* @param realName
* @param phone
* @param email
* @param studentId
* @param dormitory 宿
* @return
*/
public Map<String, Object> updateUserInfo(String userId, String realName, String phone,
String email, String studentId, String dormitory) {
Map<String, Object> result = new HashMap<>();
try {
if (userId == null || userId.isEmpty()) {
result.put("success", false);
result.put("message", "用户ID不能为空");
return result;
}
User user = userService.getUserById(userId);
if (user == null) {
result.put("success", false);
result.put("message", "用户不存在");
return result;
}
// 更新用户信息
user.setRealName(realName);
user.setPhone(phone);
user.setEmail(email);
user.setStudentId(studentId);
user.setDormitory(dormitory);
boolean success = userService.updateUser(user);
if (success) {
result.put("success", true);
result.put("message", "更新成功");
result.put("user", user);
} else {
result.put("success", false);
result.put("message", "更新失败");
}
} catch (Exception e) {
result.put("success", false);
result.put("message", "更新用户信息过程中发生异常: " + e.getMessage());
}
return result;
}
/**
*
* @param userId ID
* @param oldPassword
* @param newPassword
* @return
*/
public Map<String, Object> changePassword(String userId, String oldPassword, String newPassword) {
Map<String, Object> result = new HashMap<>();
try {
if (userId == null || userId.isEmpty() || oldPassword == null ||
oldPassword.isEmpty() || newPassword == null || newPassword.isEmpty()) {
result.put("success", false);
result.put("message", "参数不能为空");
return result;
}
boolean success = userService.changePassword(userId, oldPassword, newPassword);
if (success) {
result.put("success", true);
result.put("message", "密码修改成功");
} else {
result.put("success", false);
result.put("message", "旧密码错误或修改失败");
}
} catch (Exception e) {
result.put("success", false);
result.put("message", "修改密码过程中发生异常: " + e.getMessage());
}
return result;
}
/**
*
* @return
*/
public Map<String, Object> getAllUsers() {
Map<String, Object> result = new HashMap<>();
try {
List<User> users = userService.getAllUsers();
result.put("success", true);
result.put("users", users);
} catch (Exception e) {
result.put("success", false);
result.put("message", "获取用户列表过程中发生异常: " + e.getMessage());
}
return result;
}
}

@ -0,0 +1,255 @@
package com.campus.pickup.dao;
import com.campus.pickup.model.Message;
import com.campus.pickup.util.DatabaseUtil;
import java.sql.*;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.List;
/**
* 访
*
*/
public class MessageDao {
/**
*
* @param message
* @return
*/
public boolean addMessage(Message message) {
String sql = "INSERT INTO messages (sender_id, receiver_id, content, send_time, read_time, status, type) VALUES (?, ?, ?, ?, ?, ?, ?)";
try (Connection conn = DatabaseUtil.getConnection();
PreparedStatement pstmt = conn.prepareStatement(sql, Statement.RETURN_GENERATED_KEYS)) {
pstmt.setString(1, message.getSenderId());
pstmt.setString(2, message.getReceiverId());
pstmt.setString(3, message.getContent());
pstmt.setTimestamp(4, Timestamp.valueOf(message.getSendTime()));
if (message.getReadTime() != null) {
pstmt.setTimestamp(5, Timestamp.valueOf(message.getReadTime()));
} else {
pstmt.setNull(5, Types.TIMESTAMP);
}
pstmt.setInt(6, message.getStatus());
pstmt.setInt(7, message.getType().getCode());
int affectedRows = pstmt.executeUpdate();
if (affectedRows > 0) {
ResultSet rs = pstmt.getGeneratedKeys();
if (rs.next()) {
message.setMessageId(rs.getString(1));
}
return true;
}
} catch (SQLException e) {
System.err.println("添加消息失败:" + e.getMessage());
}
return false;
}
/**
* ID
* @param messageId ID
* @return null
*/
public Message getMessageById(String messageId) {
String sql = "SELECT * FROM messages WHERE message_id = ? AND status != 2";
try (Connection conn = DatabaseUtil.getConnection();
PreparedStatement pstmt = conn.prepareStatement(sql)) {
pstmt.setString(1, messageId);
ResultSet rs = pstmt.executeQuery();
if (rs.next()) {
return extractMessageFromResultSet(rs);
}
} catch (SQLException e) {
System.err.println("查询消息失败:" + e.getMessage());
}
return null;
}
/**
* ID
* @param receiverId ID
* @return
*/
public List<Message> getMessagesByReceiverId(String receiverId) {
List<Message> messages = new ArrayList<>();
String sql = "SELECT * FROM messages WHERE receiver_id = ? AND status != 2 ORDER BY send_time DESC";
try (Connection conn = DatabaseUtil.getConnection();
PreparedStatement pstmt = conn.prepareStatement(sql)) {
pstmt.setString(1, receiverId);
ResultSet rs = pstmt.executeQuery();
while (rs.next()) {
messages.add(extractMessageFromResultSet(rs));
}
} catch (SQLException e) {
System.err.println("查询消息列表失败:" + e.getMessage());
}
return messages;
}
/**
* ID
* @param senderId ID
* @return
*/
public List<Message> getMessagesBySenderId(String senderId) {
List<Message> messages = new ArrayList<>();
String sql = "SELECT * FROM messages WHERE sender_id = ? AND status != 2 ORDER BY send_time DESC";
try (Connection conn = DatabaseUtil.getConnection();
PreparedStatement pstmt = conn.prepareStatement(sql)) {
pstmt.setString(1, senderId);
ResultSet rs = pstmt.executeQuery();
while (rs.next()) {
messages.add(extractMessageFromResultSet(rs));
}
} catch (SQLException e) {
System.err.println("查询消息列表失败:" + e.getMessage());
}
return messages;
}
/**
*
* @param userId1 ID1
* @param userId2 ID2
* @return
*/
public List<Message> getMessagesBetweenUsers(String userId1, String userId2) {
List<Message> messages = new ArrayList<>();
String sql = "SELECT * FROM messages WHERE ((sender_id = ? AND receiver_id = ?) OR (sender_id = ? AND receiver_id = ?)) AND status != 2 ORDER BY send_time ASC";
try (Connection conn = DatabaseUtil.getConnection();
PreparedStatement pstmt = conn.prepareStatement(sql)) {
pstmt.setString(1, userId1);
pstmt.setString(2, userId2);
pstmt.setString(3, userId2);
pstmt.setString(4, userId1);
ResultSet rs = pstmt.executeQuery();
while (rs.next()) {
messages.add(extractMessageFromResultSet(rs));
}
} catch (SQLException e) {
System.err.println("查询用户间消息失败:" + e.getMessage());
}
return messages;
}
/**
*
* @param messageId ID
* @return
*/
public boolean markMessageAsRead(String messageId) {
String sql = "UPDATE messages SET status = 1, read_time = ? WHERE message_id = ?";
try (Connection conn = DatabaseUtil.getConnection();
PreparedStatement pstmt = conn.prepareStatement(sql)) {
pstmt.setTimestamp(1, Timestamp.valueOf(LocalDateTime.now()));
pstmt.setString(2, messageId);
int affectedRows = pstmt.executeUpdate();
return affectedRows > 0;
} catch (SQLException e) {
System.err.println("更新消息状态失败:" + e.getMessage());
}
return false;
}
/**
*
* @param messageId ID
* @return
*/
public boolean deleteMessage(String messageId) {
String sql = "UPDATE messages SET status = 2 WHERE message_id = ?";
try (Connection conn = DatabaseUtil.getConnection();
PreparedStatement pstmt = conn.prepareStatement(sql)) {
pstmt.setString(1, messageId);
int affectedRows = pstmt.executeUpdate();
return affectedRows > 0;
} catch (SQLException e) {
System.err.println("删除消息失败:" + e.getMessage());
}
return false;
}
/**
*
* @param receiverId ID
* @return
*/
public int getUnreadMessageCount(String receiverId) {
String sql = "SELECT COUNT(*) FROM messages WHERE receiver_id = ? AND status = 0";
try (Connection conn = DatabaseUtil.getConnection();
PreparedStatement pstmt = conn.prepareStatement(sql)) {
pstmt.setString(1, receiverId);
ResultSet rs = pstmt.executeQuery();
if (rs.next()) {
return rs.getInt(1);
}
} catch (SQLException e) {
System.err.println("获取未读消息数量失败:" + e.getMessage());
}
return 0;
}
/**
* ResultSet
* @param rs ResultSet
* @return
* @throws SQLException SQL
*/
private Message extractMessageFromResultSet(ResultSet rs) throws SQLException {
Message message = new Message();
message.setMessageId(rs.getString("message_id"));
message.setSenderId(rs.getString("sender_id"));
message.setReceiverId(rs.getString("receiver_id"));
message.setContent(rs.getString("content"));
message.setSendTime(rs.getTimestamp("send_time").toLocalDateTime());
Timestamp readTime = rs.getTimestamp("read_time");
if (readTime != null) {
message.setReadTime(readTime.toLocalDateTime());
}
message.setStatus(rs.getInt("status"));
message.setType(Message.MessageType.fromCode(rs.getInt("type")));
return message;
}
}

@ -0,0 +1,343 @@
package com.campus.pickup.dao;
import com.campus.pickup.model.Order;
import com.campus.pickup.util.DatabaseUtil;
import java.sql.*;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.List;
/**
* 访
*
*/
public class OrderDao {
/**
*
* @param order
* @return
*/
public boolean addOrder(Order order) {
String sql = "INSERT INTO orders (order_number, customer_id, delivery_person_id, item_type, " +
"description, pickup_location, delivery_location, fee, pickup_time, delivery_time, " +
"create_time, update_time, status, remarks) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)";
try (Connection conn = DatabaseUtil.getConnection();
PreparedStatement pstmt = conn.prepareStatement(sql, Statement.RETURN_GENERATED_KEYS)) {
pstmt.setString(1, order.getOrderNumber());
pstmt.setString(2, order.getCustomerId());
if (order.getDeliveryPersonId() != null) {
pstmt.setString(3, order.getDeliveryPersonId());
} else {
pstmt.setNull(3, Types.VARCHAR);
}
pstmt.setString(4, order.getItemType());
pstmt.setString(5, order.getDescription());
pstmt.setString(6, order.getPickupLocation());
pstmt.setString(7, order.getDeliveryLocation());
pstmt.setBigDecimal(8, order.getFee());
if (order.getPickupTime() != null) {
pstmt.setTimestamp(9, Timestamp.valueOf(order.getPickupTime()));
} else {
pstmt.setNull(9, Types.TIMESTAMP);
}
if (order.getDeliveryTime() != null) {
pstmt.setTimestamp(10, Timestamp.valueOf(order.getDeliveryTime()));
} else {
pstmt.setNull(10, Types.TIMESTAMP);
}
pstmt.setTimestamp(11, Timestamp.valueOf(order.getCreateTime()));
pstmt.setTimestamp(12, Timestamp.valueOf(order.getUpdateTime()));
pstmt.setInt(13, order.getStatus().getCode());
pstmt.setString(14, order.getRemarks());
int affectedRows = pstmt.executeUpdate();
if (affectedRows > 0) {
ResultSet rs = pstmt.getGeneratedKeys();
if (rs.next()) {
order.setOrderId(rs.getString(1));
}
return true;
}
} catch (SQLException e) {
System.err.println("添加订单失败:" + e.getMessage());
}
return false;
}
/**
* ID
* @param orderId ID
* @return null
*/
public Order getOrderById(String orderId) {
String sql = "SELECT * FROM orders WHERE order_id = ?";
try (Connection conn = DatabaseUtil.getConnection();
PreparedStatement pstmt = conn.prepareStatement(sql)) {
pstmt.setString(1, orderId);
ResultSet rs = pstmt.executeQuery();
if (rs.next()) {
return extractOrderFromResultSet(rs);
}
} catch (SQLException e) {
System.err.println("查询订单失败:" + e.getMessage());
}
return null;
}
/**
*
* @param orderNumber
* @return null
*/
public Order getOrderByNumber(String orderNumber) {
String sql = "SELECT * FROM orders WHERE order_number = ?";
try (Connection conn = DatabaseUtil.getConnection();
PreparedStatement pstmt = conn.prepareStatement(sql)) {
pstmt.setString(1, orderNumber);
ResultSet rs = pstmt.executeQuery();
if (rs.next()) {
return extractOrderFromResultSet(rs);
}
} catch (SQLException e) {
System.err.println("查询订单失败:" + e.getMessage());
}
return null;
}
/**
* ID
* @param customerId ID
* @return
*/
public List<Order> getOrdersByCustomerId(String customerId) {
List<Order> orders = new ArrayList<>();
String sql = "SELECT * FROM orders WHERE customer_id = ? ORDER BY create_time DESC";
try (Connection conn = DatabaseUtil.getConnection();
PreparedStatement pstmt = conn.prepareStatement(sql)) {
pstmt.setString(1, customerId);
ResultSet rs = pstmt.executeQuery();
while (rs.next()) {
orders.add(extractOrderFromResultSet(rs));
}
} catch (SQLException e) {
System.err.println("查询订单列表失败:" + e.getMessage());
}
return orders;
}
/**
* ID
* @param deliveryPersonId ID
* @return
*/
public List<Order> getOrdersByDeliveryPersonId(String deliveryPersonId) {
List<Order> orders = new ArrayList<>();
String sql = "SELECT * FROM orders WHERE delivery_person_id = ? ORDER BY create_time DESC";
try (Connection conn = DatabaseUtil.getConnection();
PreparedStatement pstmt = conn.prepareStatement(sql)) {
pstmt.setString(1, deliveryPersonId);
ResultSet rs = pstmt.executeQuery();
while (rs.next()) {
orders.add(extractOrderFromResultSet(rs));
}
} catch (SQLException e) {
System.err.println("查询订单列表失败:" + e.getMessage());
}
return orders;
}
/**
*
* @param status
* @return
*/
public List<Order> getOrdersByStatus(Order.OrderStatus status) {
List<Order> orders = new ArrayList<>();
String sql = "SELECT * FROM orders WHERE status = ? ORDER BY create_time DESC";
try (Connection conn = DatabaseUtil.getConnection();
PreparedStatement pstmt = conn.prepareStatement(sql)) {
pstmt.setInt(1, status.getCode());
ResultSet rs = pstmt.executeQuery();
while (rs.next()) {
orders.add(extractOrderFromResultSet(rs));
}
} catch (SQLException e) {
System.err.println("查询订单列表失败:" + e.getMessage());
}
return orders;
}
/**
*
* @param order
* @return
*/
public boolean updateOrder(Order order) {
String sql = "UPDATE orders SET order_number = ?, customer_id = ?, delivery_person_id = ?, " +
"item_type = ?, description = ?, pickup_location = ?, delivery_location = ?, " +
"fee = ?, pickup_time = ?, delivery_time = ?, update_time = ?, status = ?, " +
"remarks = ? WHERE order_id = ?";
try (Connection conn = DatabaseUtil.getConnection();
PreparedStatement pstmt = conn.prepareStatement(sql)) {
pstmt.setString(1, order.getOrderNumber());
pstmt.setString(2, order.getCustomerId());
if (order.getDeliveryPersonId() != null) {
pstmt.setString(3, order.getDeliveryPersonId());
} else {
pstmt.setNull(3, Types.VARCHAR);
}
pstmt.setString(4, order.getItemType());
pstmt.setString(5, order.getDescription());
pstmt.setString(6, order.getPickupLocation());
pstmt.setString(7, order.getDeliveryLocation());
pstmt.setBigDecimal(8, order.getFee());
if (order.getPickupTime() != null) {
pstmt.setTimestamp(9, Timestamp.valueOf(order.getPickupTime()));
} else {
pstmt.setNull(9, Types.TIMESTAMP);
}
if (order.getDeliveryTime() != null) {
pstmt.setTimestamp(10, Timestamp.valueOf(order.getDeliveryTime()));
} else {
pstmt.setNull(10, Types.TIMESTAMP);
}
pstmt.setTimestamp(11, Timestamp.valueOf(LocalDateTime.now()));
pstmt.setInt(12, order.getStatus().getCode());
pstmt.setString(13, order.getRemarks());
pstmt.setString(14, order.getOrderId());
int affectedRows = pstmt.executeUpdate();
return affectedRows > 0;
} catch (SQLException e) {
System.err.println("更新订单失败:" + e.getMessage());
}
return false;
}
/**
*
* @param orderId ID
* @param status
* @return
*/
public boolean updateOrderStatus(String orderId, Order.OrderStatus status) {
String sql = "UPDATE orders SET status = ?, update_time = ? WHERE order_id = ?";
try (Connection conn = DatabaseUtil.getConnection();
PreparedStatement pstmt = conn.prepareStatement(sql)) {
pstmt.setInt(1, status.getCode());
pstmt.setTimestamp(2, Timestamp.valueOf(LocalDateTime.now()));
pstmt.setString(3, orderId);
int affectedRows = pstmt.executeUpdate();
return affectedRows > 0;
} catch (SQLException e) {
System.err.println("更新订单状态失败:" + e.getMessage());
}
return false;
}
/**
*
* @return
*/
public List<Order> getAllOrders() {
List<Order> orders = new ArrayList<>();
String sql = "SELECT * FROM orders ORDER BY create_time DESC";
try (Connection conn = DatabaseUtil.getConnection();
PreparedStatement pstmt = conn.prepareStatement(sql);
ResultSet rs = pstmt.executeQuery()) {
while (rs.next()) {
orders.add(extractOrderFromResultSet(rs));
}
} catch (SQLException e) {
System.err.println("获取订单列表失败:" + e.getMessage());
}
return orders;
}
/**
* ResultSet
* @param rs ResultSet
* @return
* @throws SQLException SQL
*/
private Order extractOrderFromResultSet(ResultSet rs) throws SQLException {
Order order = new Order();
order.setOrderId(rs.getString("order_id"));
order.setOrderNumber(rs.getString("order_number"));
order.setCustomerId(rs.getString("customer_id"));
String deliveryPersonId = rs.getString("delivery_person_id");
if (deliveryPersonId != null) {
order.setDeliveryPersonId(deliveryPersonId);
}
order.setItemType(rs.getString("item_type"));
order.setDescription(rs.getString("description"));
order.setPickupLocation(rs.getString("pickup_location"));
order.setDeliveryLocation(rs.getString("delivery_location"));
order.setFee(rs.getBigDecimal("fee"));
Timestamp pickupTime = rs.getTimestamp("pickup_time");
if (pickupTime != null) {
order.setPickupTime(pickupTime.toLocalDateTime());
}
Timestamp deliveryTime = rs.getTimestamp("delivery_time");
if (deliveryTime != null) {
order.setDeliveryTime(deliveryTime.toLocalDateTime());
}
order.setCreateTime(rs.getTimestamp("create_time").toLocalDateTime());
order.setUpdateTime(rs.getTimestamp("update_time").toLocalDateTime());
order.setStatus(Order.OrderStatus.fromCode(rs.getInt("status")));
order.setRemarks(rs.getString("remarks"));
return order;
}
}

@ -0,0 +1,246 @@
package com.campus.pickup.dao;
import com.campus.pickup.model.Review;
import com.campus.pickup.util.DatabaseUtil;
import java.sql.*;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.List;
/**
* 访
*
*/
public class ReviewDao {
/**
*
* @param review
* @return
*/
public boolean addReview(Review review) {
String sql = "INSERT INTO reviews (order_id, reviewer_id, reviewed_id, rating, content, create_time, update_time, status) VALUES (?, ?, ?, ?, ?, ?, ?, ?)";
try (Connection conn = DatabaseUtil.getConnection();
PreparedStatement pstmt = conn.prepareStatement(sql, Statement.RETURN_GENERATED_KEYS)) {
pstmt.setString(1, review.getOrderId());
pstmt.setString(2, review.getReviewerId());
pstmt.setString(3, review.getReviewedId());
pstmt.setInt(4, review.getRating());
pstmt.setString(5, review.getContent());
pstmt.setTimestamp(6, Timestamp.valueOf(review.getCreateTime()));
pstmt.setTimestamp(7, Timestamp.valueOf(review.getUpdateTime()));
pstmt.setInt(8, review.getStatus());
int affectedRows = pstmt.executeUpdate();
if (affectedRows > 0) {
ResultSet rs = pstmt.getGeneratedKeys();
if (rs.next()) {
review.setReviewId(rs.getString(1));
}
return true;
}
} catch (SQLException e) {
System.err.println("添加评价失败:" + e.getMessage());
}
return false;
}
/**
* ID
* @param reviewId ID
* @return null
*/
public Review getReviewById(String reviewId) {
String sql = "SELECT * FROM reviews WHERE review_id = ? AND status = 0";
try (Connection conn = DatabaseUtil.getConnection();
PreparedStatement pstmt = conn.prepareStatement(sql)) {
pstmt.setString(1, reviewId);
ResultSet rs = pstmt.executeQuery();
if (rs.next()) {
return extractReviewFromResultSet(rs);
}
} catch (SQLException e) {
System.err.println("查询评价失败:" + e.getMessage());
}
return null;
}
/**
* ID
* @param orderId ID
* @return null
*/
public Review getReviewByOrderId(String orderId) {
String sql = "SELECT * FROM reviews WHERE order_id = ? AND status = 0";
try (Connection conn = DatabaseUtil.getConnection();
PreparedStatement pstmt = conn.prepareStatement(sql)) {
pstmt.setString(1, orderId);
ResultSet rs = pstmt.executeQuery();
if (rs.next()) {
return extractReviewFromResultSet(rs);
}
} catch (SQLException e) {
System.err.println("查询评价失败:" + e.getMessage());
}
return null;
}
/**
* ID
* @param reviewedId ID
* @return
*/
public List<Review> getReviewsByReviewedId(String reviewedId) {
List<Review> reviews = new ArrayList<>();
String sql = "SELECT * FROM reviews WHERE reviewed_id = ? AND status = 0 ORDER BY create_time DESC";
try (Connection conn = DatabaseUtil.getConnection();
PreparedStatement pstmt = conn.prepareStatement(sql)) {
pstmt.setString(1, reviewedId);
ResultSet rs = pstmt.executeQuery();
while (rs.next()) {
reviews.add(extractReviewFromResultSet(rs));
}
} catch (SQLException e) {
System.err.println("查询评价列表失败:" + e.getMessage());
}
return reviews;
}
/**
* ID
* @param reviewerId ID
* @return
*/
public List<Review> getReviewsByReviewerId(String reviewerId) {
List<Review> reviews = new ArrayList<>();
String sql = "SELECT * FROM reviews WHERE reviewer_id = ? AND status = 0 ORDER BY create_time DESC";
try (Connection conn = DatabaseUtil.getConnection();
PreparedStatement pstmt = conn.prepareStatement(sql)) {
pstmt.setString(1, reviewerId);
ResultSet rs = pstmt.executeQuery();
while (rs.next()) {
reviews.add(extractReviewFromResultSet(rs));
}
} catch (SQLException e) {
System.err.println("查询评价列表失败:" + e.getMessage());
}
return reviews;
}
/**
*
* @param review
* @return
*/
public boolean updateReview(Review review) {
String sql = "UPDATE reviews SET order_id = ?, reviewer_id = ?, reviewed_id = ?, rating = ?, content = ?, update_time = ?, status = ? WHERE review_id = ?";
try (Connection conn = DatabaseUtil.getConnection();
PreparedStatement pstmt = conn.prepareStatement(sql)) {
pstmt.setString(1, review.getOrderId());
pstmt.setString(2, review.getReviewerId());
pstmt.setString(3, review.getReviewedId());
pstmt.setInt(4, review.getRating());
pstmt.setString(5, review.getContent());
pstmt.setTimestamp(6, Timestamp.valueOf(LocalDateTime.now()));
pstmt.setInt(7, review.getStatus());
pstmt.setString(8, review.getReviewId());
int affectedRows = pstmt.executeUpdate();
return affectedRows > 0;
} catch (SQLException e) {
System.err.println("更新评价失败:" + e.getMessage());
}
return false;
}
/**
*
* @param reviewId ID
* @return
*/
public boolean deleteReview(String reviewId) {
String sql = "UPDATE reviews SET status = 1, update_time = ? WHERE review_id = ?";
try (Connection conn = DatabaseUtil.getConnection();
PreparedStatement pstmt = conn.prepareStatement(sql)) {
pstmt.setTimestamp(1, Timestamp.valueOf(LocalDateTime.now()));
pstmt.setString(2, reviewId);
int affectedRows = pstmt.executeUpdate();
return affectedRows > 0;
} catch (SQLException e) {
System.err.println("删除评价失败:" + e.getMessage());
}
return false;
}
/**
*
* @param userId ID
* @return 0
*/
public double getAverageRatingByUserId(String userId) {
String sql = "SELECT AVG(rating) FROM reviews WHERE reviewed_id = ? AND status = 0";
try (Connection conn = DatabaseUtil.getConnection();
PreparedStatement pstmt = conn.prepareStatement(sql)) {
pstmt.setString(1, userId);
ResultSet rs = pstmt.executeQuery();
if (rs.next()) {
return rs.getDouble(1);
}
} catch (SQLException e) {
System.err.println("计算平均评分失败:" + e.getMessage());
}
return 0.0;
}
/**
* ResultSet
* @param rs ResultSet
* @return
* @throws SQLException SQL
*/
private Review extractReviewFromResultSet(ResultSet rs) throws SQLException {
Review review = new Review();
review.setReviewId(rs.getString("review_id"));
review.setOrderId(rs.getString("order_id"));
review.setReviewerId(rs.getString("reviewer_id"));
review.setReviewedId(rs.getString("reviewed_id"));
review.setRating(rs.getInt("rating"));
review.setContent(rs.getString("content"));
review.setCreateTime(rs.getTimestamp("create_time").toLocalDateTime());
review.setUpdateTime(rs.getTimestamp("update_time").toLocalDateTime());
review.setStatus(rs.getInt("status"));
return review;
}
}

@ -0,0 +1,200 @@
package com.campus.pickup.dao;
import com.campus.pickup.model.User;
import com.campus.pickup.util.DatabaseUtil;
import java.sql.*;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.List;
/**
* 访
*
*/
public class UserDao {
/**
*
* @param user
* @return
*/
public boolean addUser(User user) {
String sql = "INSERT INTO users (username, password, real_name, phone, email, student_id, dormitory, create_time, update_time, status) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)";
try (Connection conn = DatabaseUtil.getConnection();
PreparedStatement pstmt = conn.prepareStatement(sql, Statement.RETURN_GENERATED_KEYS)) {
pstmt.setString(1, user.getUsername());
pstmt.setString(2, user.getPassword());
pstmt.setString(3, user.getRealName());
pstmt.setString(4, user.getPhone());
pstmt.setString(5, user.getEmail());
pstmt.setString(6, user.getStudentId());
pstmt.setString(7, user.getDormitory());
pstmt.setTimestamp(8, Timestamp.valueOf(user.getCreateTime()));
pstmt.setTimestamp(9, Timestamp.valueOf(user.getUpdateTime()));
pstmt.setInt(10, user.getStatus());
int affectedRows = pstmt.executeUpdate();
if (affectedRows > 0) {
ResultSet rs = pstmt.getGeneratedKeys();
if (rs.next()) {
user.setUserId(rs.getString(1));
}
return true;
}
} catch (SQLException e) {
System.err.println("添加用户失败:" + e.getMessage());
}
return false;
}
/**
* ID
* @param userId ID
* @return null
*/
public User getUserById(String userId) {
String sql = "SELECT * FROM users WHERE user_id = ? AND status = 0";
try (Connection conn = DatabaseUtil.getConnection();
PreparedStatement pstmt = conn.prepareStatement(sql)) {
pstmt.setString(1, userId);
ResultSet rs = pstmt.executeQuery();
if (rs.next()) {
return extractUserFromResultSet(rs);
}
} catch (SQLException e) {
System.err.println("查询用户失败:" + e.getMessage());
}
return null;
}
/**
*
* @param username
* @return null
*/
public User getUserByUsername(String username) {
String sql = "SELECT * FROM users WHERE username = ? AND status = 0";
try (Connection conn = DatabaseUtil.getConnection();
PreparedStatement pstmt = conn.prepareStatement(sql)) {
pstmt.setString(1, username);
ResultSet rs = pstmt.executeQuery();
if (rs.next()) {
return extractUserFromResultSet(rs);
}
} catch (SQLException e) {
System.err.println("查询用户失败:" + e.getMessage());
}
return null;
}
/**
*
* @param user
* @return
*/
public boolean updateUser(User user) {
String sql = "UPDATE users SET username = ?, password = ?, real_name = ?, phone = ?, email = ?, student_id = ?, dormitory = ?, update_time = ?, status = ? WHERE user_id = ?";
try (Connection conn = DatabaseUtil.getConnection();
PreparedStatement pstmt = conn.prepareStatement(sql)) {
pstmt.setString(1, user.getUsername());
pstmt.setString(2, user.getPassword());
pstmt.setString(3, user.getRealName());
pstmt.setString(4, user.getPhone());
pstmt.setString(5, user.getEmail());
pstmt.setString(6, user.getStudentId());
pstmt.setString(7, user.getDormitory());
pstmt.setTimestamp(8, Timestamp.valueOf(LocalDateTime.now()));
pstmt.setInt(9, user.getStatus());
pstmt.setString(10, user.getUserId());
int affectedRows = pstmt.executeUpdate();
return affectedRows > 0;
} catch (SQLException e) {
System.err.println("更新用户失败:" + e.getMessage());
}
return false;
}
/**
*
* @param userId ID
* @return
*/
public boolean deleteUser(String userId) {
String sql = "UPDATE users SET status = 1, update_time = ? WHERE user_id = ?";
try (Connection conn = DatabaseUtil.getConnection();
PreparedStatement pstmt = conn.prepareStatement(sql)) {
pstmt.setTimestamp(1, Timestamp.valueOf(LocalDateTime.now()));
pstmt.setString(2, userId);
int affectedRows = pstmt.executeUpdate();
return affectedRows > 0;
} catch (SQLException e) {
System.err.println("删除用户失败:" + e.getMessage());
}
return false;
}
/**
*
* @return
*/
public List<User> getAllUsers() {
List<User> users = new ArrayList<>();
String sql = "SELECT * FROM users WHERE status = 0 ORDER BY create_time DESC";
try (Connection conn = DatabaseUtil.getConnection();
PreparedStatement pstmt = conn.prepareStatement(sql);
ResultSet rs = pstmt.executeQuery()) {
while (rs.next()) {
users.add(extractUserFromResultSet(rs));
}
} catch (SQLException e) {
System.err.println("获取用户列表失败:" + e.getMessage());
}
return users;
}
/**
* ResultSet
* @param rs ResultSet
* @return
* @throws SQLException SQL
*/
private User extractUserFromResultSet(ResultSet rs) throws SQLException {
User user = new User();
user.setUserId(rs.getString("user_id"));
user.setUsername(rs.getString("username"));
user.setPassword(rs.getString("password"));
user.setRealName(rs.getString("real_name"));
user.setPhone(rs.getString("phone"));
user.setEmail(rs.getString("email"));
user.setStudentId(rs.getString("student_id"));
user.setDormitory(rs.getString("dormitory"));
user.setCreateTime(rs.getTimestamp("create_time").toLocalDateTime());
user.setUpdateTime(rs.getTimestamp("update_time").toLocalDateTime());
user.setStatus(rs.getInt("status"));
return user;
}
}

@ -0,0 +1,153 @@
package com.campus.pickup.model;
import java.time.LocalDateTime;
/**
*
*
*/
public class Message {
private String messageId;
private String senderId;
private String receiverId;
private String content;
private LocalDateTime sendTime;
private LocalDateTime readTime;
private int status; // 0-未读 1-已读 2-已删除
private MessageType type; // 消息类型:系统通知、用户消息、订单消息等
public enum MessageType {
SYSTEM_NOTIFICATION(0, "系统通知"),
USER_MESSAGE(1, "用户消息"),
ORDER_MESSAGE(2, "订单消息"),
REVIEW_MESSAGE(3, "评价消息");
private final int code;
private final String description;
MessageType(int code, String description) {
this.code = code;
this.description = description;
}
public int getCode() {
return code;
}
public String getDescription() {
return description;
}
public static MessageType fromCode(int code) {
for (MessageType type : MessageType.values()) {
if (type.getCode() == code) {
return type;
}
}
return null;
}
}
public Message() {
this.sendTime = LocalDateTime.now();
this.status = 0;
this.type = MessageType.USER_MESSAGE;
}
public Message(String senderId, String receiverId, String content, MessageType type) {
this();
this.senderId = senderId;
this.receiverId = receiverId;
this.content = content;
this.type = type;
}
public Message(String messageId, String senderId, String receiverId, String content, LocalDateTime sendTime, LocalDateTime readTime, int status, MessageType type) {
this.messageId = messageId;
this.senderId = senderId;
this.receiverId = receiverId;
this.content = content;
this.sendTime = sendTime;
this.readTime = readTime;
this.status = status;
this.type = type;
}
public String getMessageId() {
return messageId;
}
public void setMessageId(String messageId) {
this.messageId = messageId;
}
public String getSenderId() {
return senderId;
}
public void setSenderId(String senderId) {
this.senderId = senderId;
}
public String getReceiverId() {
return receiverId;
}
public void setReceiverId(String receiverId) {
this.receiverId = receiverId;
}
public String getContent() {
return content;
}
public void setContent(String content) {
this.content = content;
}
public LocalDateTime getSendTime() {
return sendTime;
}
public void setSendTime(LocalDateTime sendTime) {
this.sendTime = sendTime;
}
public LocalDateTime getReadTime() {
return readTime;
}
public void setReadTime(LocalDateTime readTime) {
this.readTime = readTime;
}
public int getStatus() {
return status;
}
public void setStatus(int status) {
this.status = status;
}
public MessageType getType() {
return type;
}
public void setType(MessageType type) {
this.type = type;
}
@Override
public String toString() {
return "Message{" +
"messageId='" + messageId + '\'' +
", senderId='" + senderId + '\'' +
", receiverId='" + receiverId + '\'' +
", content='" + content + '\'' +
", sendTime=" + sendTime +
", readTime=" + readTime +
", status=" + status +
", type=" + type +
'}';
}
}

@ -0,0 +1,252 @@
package com.campus.pickup.model;
import java.time.LocalDateTime;
import java.math.BigDecimal;
/**
*
*
*/
public class Order {
private String orderId;
private String orderNumber; // 订单编号
private String customerId; // 下单用户ID
private String deliveryPersonId; // 配送员ID
private String itemType; // 物品类型(快递、外卖、文件等)
private String description; // 物品描述
private String pickupLocation; // 取件地点
private String deliveryLocation; // 配送地点
private BigDecimal fee; // 配送费用
private LocalDateTime pickupTime; // 预计取件时间
private LocalDateTime deliveryTime; // 实际送达时间
private LocalDateTime createTime; // 创建时间
private LocalDateTime updateTime; // 更新时间
private OrderStatus status; // 订单状态
private String remarks; // 备注
public enum OrderStatus {
PENDING(0, "待接单"),
ACCEPTED(1, "已接单"),
PICKED_UP(2, "已取件"),
DELIVERING(3, "配送中"),
COMPLETED(4, "已完成"),
CANCELLED(5, "已取消");
private final int code;
private final String description;
OrderStatus(int code, String description) {
this.code = code;
this.description = description;
}
public int getCode() {
return code;
}
public String getDescription() {
return description;
}
public static OrderStatus fromCode(int code) {
for (OrderStatus status : OrderStatus.values()) {
if (status.getCode() == code) {
return status;
}
}
return null;
}
}
public Order() {
this.createTime = LocalDateTime.now();
this.updateTime = LocalDateTime.now();
this.status = OrderStatus.PENDING;
this.fee = BigDecimal.ZERO;
}
public Order(String customerId, String itemType, String description,
String pickupLocation, String deliveryLocation, BigDecimal fee,
LocalDateTime pickupTime, String remarks) {
this();
this.orderNumber = generateOrderNumber();
this.customerId = customerId;
this.itemType = itemType;
this.description = description;
this.pickupLocation = pickupLocation;
this.deliveryLocation = deliveryLocation;
this.fee = fee;
this.pickupTime = pickupTime;
this.remarks = remarks;
}
public Order(String orderId, String orderNumber, String customerId, String deliveryPersonId,
String itemType, String description, String pickupLocation, String deliveryLocation,
BigDecimal fee, LocalDateTime pickupTime, LocalDateTime deliveryTime,
LocalDateTime createTime, LocalDateTime updateTime, OrderStatus status, String remarks) {
this.orderId = orderId;
this.orderNumber = orderNumber;
this.customerId = customerId;
this.deliveryPersonId = deliveryPersonId;
this.itemType = itemType;
this.description = description;
this.pickupLocation = pickupLocation;
this.deliveryLocation = deliveryLocation;
this.fee = fee;
this.pickupTime = pickupTime;
this.deliveryTime = deliveryTime;
this.createTime = createTime;
this.updateTime = updateTime;
this.status = status;
this.remarks = remarks;
}
/**
*
* @return
*/
private String generateOrderNumber() {
return "ORD" + System.currentTimeMillis();
}
public String getOrderId() {
return orderId;
}
public void setOrderId(String orderId) {
this.orderId = orderId;
}
public String getOrderNumber() {
return orderNumber;
}
public void setOrderNumber(String orderNumber) {
this.orderNumber = orderNumber;
}
public String getCustomerId() {
return customerId;
}
public void setCustomerId(String customerId) {
this.customerId = customerId;
}
public String getDeliveryPersonId() {
return deliveryPersonId;
}
public void setDeliveryPersonId(String deliveryPersonId) {
this.deliveryPersonId = deliveryPersonId;
}
public String getItemType() {
return itemType;
}
public void setItemType(String itemType) {
this.itemType = itemType;
}
public String getDescription() {
return description;
}
public void setDescription(String description) {
this.description = description;
}
public String getPickupLocation() {
return pickupLocation;
}
public void setPickupLocation(String pickupLocation) {
this.pickupLocation = pickupLocation;
}
public String getDeliveryLocation() {
return deliveryLocation;
}
public void setDeliveryLocation(String deliveryLocation) {
this.deliveryLocation = deliveryLocation;
}
public BigDecimal getFee() {
return fee;
}
public void setFee(BigDecimal fee) {
this.fee = fee;
}
public LocalDateTime getPickupTime() {
return pickupTime;
}
public void setPickupTime(LocalDateTime pickupTime) {
this.pickupTime = pickupTime;
}
public LocalDateTime getDeliveryTime() {
return deliveryTime;
}
public void setDeliveryTime(LocalDateTime deliveryTime) {
this.deliveryTime = deliveryTime;
}
public LocalDateTime getCreateTime() {
return createTime;
}
public void setCreateTime(LocalDateTime createTime) {
this.createTime = createTime;
}
public LocalDateTime getUpdateTime() {
return updateTime;
}
public void setUpdateTime(LocalDateTime updateTime) {
this.updateTime = updateTime;
}
public OrderStatus getStatus() {
return status;
}
public void setStatus(OrderStatus status) {
this.status = status;
}
public String getRemarks() {
return remarks;
}
public void setRemarks(String remarks) {
this.remarks = remarks;
}
@Override
public String toString() {
return "Order{" +
"orderId='" + orderId + '\'' +
", orderNumber='" + orderNumber + '\'' +
", customerId='" + customerId + '\'' +
", deliveryPersonId='" + deliveryPersonId + '\'' +
", itemType='" + itemType + '\'' +
", description='" + description + '\'' +
", pickupLocation='" + pickupLocation + '\'' +
", deliveryLocation='" + deliveryLocation + '\'' +
", fee=" + fee +
", pickupTime=" + pickupTime +
", deliveryTime=" + deliveryTime +
", createTime=" + createTime +
", updateTime=" + updateTime +
", status=" + status +
", remarks='" + remarks + '\'' +
'}';
}
}

@ -0,0 +1,133 @@
package com.campus.pickup.model;
import java.time.LocalDateTime;
/**
*
*
*/
public class Review {
private String reviewId;
private String orderId;
private String reviewerId; // 评价人ID
private String reviewedId; // 被评价人ID
private int rating; // 评分 1-5星
private String content; // 评价内容
private LocalDateTime createTime;
private LocalDateTime updateTime;
private int status; // 0-正常 1-已删除
public Review() {
this.createTime = LocalDateTime.now();
this.updateTime = LocalDateTime.now();
this.status = 0;
}
public Review(String orderId, String reviewerId, String reviewedId, int rating, String content) {
this();
this.orderId = orderId;
this.reviewerId = reviewerId;
this.reviewedId = reviewedId;
this.rating = rating;
this.content = content;
}
public Review(String reviewId, String orderId, String reviewerId, String reviewedId, int rating, String content, LocalDateTime createTime, LocalDateTime updateTime, int status) {
this.reviewId = reviewId;
this.orderId = orderId;
this.reviewerId = reviewerId;
this.reviewedId = reviewedId;
this.rating = rating;
this.content = content;
this.createTime = createTime;
this.updateTime = updateTime;
this.status = status;
}
public String getReviewId() {
return reviewId;
}
public void setReviewId(String reviewId) {
this.reviewId = reviewId;
}
public String getOrderId() {
return orderId;
}
public void setOrderId(String orderId) {
this.orderId = orderId;
}
public String getReviewerId() {
return reviewerId;
}
public void setReviewerId(String reviewerId) {
this.reviewerId = reviewerId;
}
public String getReviewedId() {
return reviewedId;
}
public void setReviewedId(String reviewedId) {
this.reviewedId = reviewedId;
}
public int getRating() {
return rating;
}
public void setRating(int rating) {
this.rating = rating;
}
public String getContent() {
return content;
}
public void setContent(String content) {
this.content = content;
}
public LocalDateTime getCreateTime() {
return createTime;
}
public void setCreateTime(LocalDateTime createTime) {
this.createTime = createTime;
}
public LocalDateTime getUpdateTime() {
return updateTime;
}
public void setUpdateTime(LocalDateTime updateTime) {
this.updateTime = updateTime;
}
public int getStatus() {
return status;
}
public void setStatus(int status) {
this.status = status;
}
@Override
public String toString() {
return "Review{" +
"reviewId='" + reviewId + '\'' +
", orderId='" + orderId + '\'' +
", reviewerId='" + reviewerId + '\'' +
", reviewedId='" + reviewedId + '\'' +
", rating=" + rating +
", content='" + content + '\'' +
", createTime=" + createTime +
", updateTime=" + updateTime +
", status=" + status +
'}';
}
}

@ -0,0 +1,156 @@
package com.campus.pickup.model;
import java.time.LocalDateTime;
/**
*
*
*/
public class User {
private String userId;
private String username;
private String password;
private String realName;
private String phone;
private String email;
private String studentId;
private String dormitory;
private LocalDateTime createTime;
private LocalDateTime updateTime;
private int status; // 0-正常 1-禁用
public User() {
this.createTime = LocalDateTime.now();
this.updateTime = LocalDateTime.now();
this.status = 0;
}
public User(String username, String password, String realName, String phone, String email, String studentId, String dormitory) {
this();
this.username = username;
this.password = password;
this.realName = realName;
this.phone = phone;
this.email = email;
this.studentId = studentId;
this.dormitory = dormitory;
}
public User(String userId, String username, String password, String realName, String phone, String email, String studentId, String dormitory, LocalDateTime createTime, LocalDateTime updateTime, int status) {
this.userId = userId;
this.username = username;
this.password = password;
this.realName = realName;
this.phone = phone;
this.email = email;
this.studentId = studentId;
this.dormitory = dormitory;
this.createTime = createTime;
this.updateTime = updateTime;
this.status = status;
}
public String getUserId() {
return userId;
}
public void setUserId(String userId) {
this.userId = userId;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public String getRealName() {
return realName;
}
public void setRealName(String realName) {
this.realName = realName;
}
public String getPhone() {
return phone;
}
public void setPhone(String phone) {
this.phone = phone;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
public String getStudentId() {
return studentId;
}
public void setStudentId(String studentId) {
this.studentId = studentId;
}
public String getDormitory() {
return dormitory;
}
public void setDormitory(String dormitory) {
this.dormitory = dormitory;
}
public LocalDateTime getCreateTime() {
return createTime;
}
public void setCreateTime(LocalDateTime createTime) {
this.createTime = createTime;
}
public LocalDateTime getUpdateTime() {
return updateTime;
}
public void setUpdateTime(LocalDateTime updateTime) {
this.updateTime = updateTime;
}
public int getStatus() {
return status;
}
public void setStatus(int status) {
this.status = status;
}
@Override
public String toString() {
return "User{" +
"userId='" + userId + '\'' +
", username='" + username + '\'' +
", realName='" + realName + '\'' +
", phone='" + phone + '\'' +
", email='" + email + '\'' +
", studentId='" + studentId + '\'' +
", dormitory='" + dormitory + '\'' +
", createTime=" + createTime +
", updateTime=" + updateTime +
", status=" + status +
'}';
}
}

@ -0,0 +1,119 @@
package com.campus.pickup.service;
import com.campus.pickup.dao.MessageDao;
import com.campus.pickup.model.Message;
import java.util.List;
/**
*
*
*/
public class MessageService {
private MessageDao messageDao;
/**
*
*/
public MessageService() {
this.messageDao = new MessageDao();
}
/**
*
* @param senderId ID
* @param receiverId ID
* @param content
* @param type
* @return truefalse
*/
public boolean sendMessage(String senderId, String receiverId, String content, Message.MessageType type) {
Message message = new Message();
message.setMessageId(java.util.UUID.randomUUID().toString().replace("-", ""));
message.setSenderId(senderId);
message.setReceiverId(receiverId);
message.setContent(content);
message.setSendTime(java.time.LocalDateTime.now());
message.setStatus(0); // 未读
message.setType(type);
return messageDao.addMessage(message);
}
/**
*
* @param receiverId ID
* @param content
* @return truefalse
*/
public boolean sendSystemNotification(String receiverId, String content) {
return sendMessage("system", receiverId, content, Message.MessageType.SYSTEM_NOTIFICATION);
}
/**
*
* @param messageId ID
* @return truefalse
*/
public boolean markMessageAsRead(String messageId) {
return messageDao.markMessageAsRead(messageId);
}
/**
*
* @param messageId ID
* @return
*/
public Message getMessageById(String messageId) {
return messageDao.getMessageById(messageId);
}
/**
*
* @param receiverId ID
* @return
*/
public List<Message> getReceivedMessages(String receiverId) {
return messageDao.getMessagesByReceiverId(receiverId);
}
/**
*
* @param receiverId ID
* @return
*/
public int getUnreadMessageCount(String receiverId) {
return messageDao.getUnreadMessageCount(receiverId);
}
/**
*
* @param userId1 1 ID
* @param userId2 2 ID
* @return
*/
public List<Message> getMessagesBetweenUsers(String userId1, String userId2) {
return messageDao.getMessagesBetweenUsers(userId1, userId2);
}
/**
*
* @param receiverId ID
* @return truefalse
*/
public boolean markAllMessagesAsRead(String receiverId) {
List<Message> unreadMessages = messageDao.getMessagesByReceiverId(receiverId);
boolean allSuccess = true;
for (Message message : unreadMessages) {
if (message.getStatus() == 0) { // 未读消息
boolean success = messageDao.markMessageAsRead(message.getMessageId());
if (!success) {
allSuccess = false;
}
}
}
return allSuccess;
}
}

@ -0,0 +1,277 @@
package com.campus.pickup.service;
import com.campus.pickup.dao.OrderDao;
import com.campus.pickup.model.Order;
import java.math.BigDecimal;
import java.time.LocalDateTime;
import java.util.List;
/**
*
*
*/
public class OrderService {
private OrderDao orderDao;
/**
*
*/
public OrderService() {
this.orderDao = new OrderDao();
}
/**
*
* @param customerId ID
* @param itemType
* @param description
* @param pickupLocation
* @param deliveryLocation
* @param fee
* @param pickupTime
* @param remarks
* @return null
*/
public Order createOrder(String customerId, String itemType, String description,
String pickupLocation, String deliveryLocation, BigDecimal fee,
LocalDateTime pickupTime, String remarks) {
// 验证必要参数
if (customerId == null || customerId.isEmpty() ||
itemType == null || itemType.isEmpty() ||
description == null || description.isEmpty() ||
pickupLocation == null || pickupLocation.isEmpty() ||
deliveryLocation == null || deliveryLocation.isEmpty()) {
return null;
}
// 创建订单对象
Order order = new Order(customerId, itemType, description, pickupLocation,
deliveryLocation, fee, pickupTime, remarks);
// 添加到数据库
boolean success = orderDao.addOrder(order);
if (success) {
return order;
}
return null;
}
/**
*
* @param orderId ID
* @param deliveryPersonId ID
* @return truefalse
*/
public boolean acceptOrder(String orderId, String deliveryPersonId) {
Order order = orderDao.getOrderById(orderId);
if (order == null) {
return false; // 订单不存在
}
if (order.getStatus() != Order.OrderStatus.PENDING) {
return false; // 订单状态不是待接单
}
// 更新订单状态和配送员
order.setDeliveryPersonId(deliveryPersonId);
order.setStatus(Order.OrderStatus.ACCEPTED);
order.setUpdateTime(LocalDateTime.now());
return orderDao.updateOrder(order);
}
/**
*
* @param orderId ID
* @return truefalse
*/
public boolean confirmPickup(String orderId) {
Order order = orderDao.getOrderById(orderId);
if (order == null) {
return false; // 订单不存在
}
if (order.getStatus() != Order.OrderStatus.ACCEPTED) {
return false; // 订单状态不是已接单
}
// 更新订单状态
order.setStatus(Order.OrderStatus.PICKED_UP);
order.setUpdateTime(LocalDateTime.now());
return orderDao.updateOrder(order);
}
/**
*
* @param orderId ID
* @return truefalse
*/
public boolean startDelivery(String orderId) {
Order order = orderDao.getOrderById(orderId);
if (order == null) {
return false; // 订单不存在
}
if (order.getStatus() != Order.OrderStatus.PICKED_UP) {
return false; // 订单状态不是已取件
}
// 更新订单状态
order.setStatus(Order.OrderStatus.DELIVERING);
order.setUpdateTime(LocalDateTime.now());
return orderDao.updateOrder(order);
}
/**
*
* @param orderId ID
* @return truefalse
*/
public boolean completeDelivery(String orderId) {
Order order = orderDao.getOrderById(orderId);
if (order == null) {
return false; // 订单不存在
}
if (order.getStatus() != Order.OrderStatus.DELIVERING) {
return false; // 订单状态不是配送中
}
// 更新订单状态和送达时间
order.setStatus(Order.OrderStatus.COMPLETED);
order.setDeliveryTime(LocalDateTime.now());
order.setUpdateTime(LocalDateTime.now());
return orderDao.updateOrder(order);
}
/**
*
* @param orderId ID
* @return truefalse
*/
public boolean cancelOrder(String orderId) {
Order order = orderDao.getOrderById(orderId);
if (order == null) {
return false; // 订单不存在
}
if (order.getStatus() == Order.OrderStatus.COMPLETED ||
order.getStatus() == Order.OrderStatus.CANCELLED) {
return false; // 已完成或已取消的订单不能取消
}
// 更新订单状态
order.setStatus(Order.OrderStatus.CANCELLED);
order.setUpdateTime(LocalDateTime.now());
return orderDao.updateOrder(order);
}
/**
* ID
* @param orderId ID
* @return
*/
public Order getOrderById(String orderId) {
return orderDao.getOrderById(orderId);
}
/**
*
* @param orderNumber
* @return
*/
public Order getOrderByNumber(String orderNumber) {
return orderDao.getOrderByNumber(orderNumber);
}
/**
*
* @param customerId ID
* @return
*/
public List<Order> getOrdersByCustomerId(String customerId) {
return orderDao.getOrdersByCustomerId(customerId);
}
/**
*
* @param deliveryPersonId ID
* @return
*/
public List<Order> getOrdersByDeliveryPersonId(String deliveryPersonId) {
return orderDao.getOrdersByDeliveryPersonId(deliveryPersonId);
}
/**
*
* @param status
* @return
*/
public List<Order> getOrdersByStatus(Order.OrderStatus status) {
return orderDao.getOrdersByStatus(status);
}
/**
*
* @return
*/
public List<Order> getAllOrders() {
return orderDao.getAllOrders();
}
/**
*
* @param order
* @return truefalse
*/
public boolean updateOrder(Order order) {
if (order == null || order.getOrderId() == null || order.getOrderId().isEmpty()) {
return false;
}
// 确保更新时间是最新的
order.setUpdateTime(LocalDateTime.now());
return orderDao.updateOrder(order);
}
/**
*
* @param orderId ID
* @param userId ID
* @return truefalse
*/
public boolean canUserOperateOrder(String orderId, String userId) {
Order order = orderDao.getOrderById(orderId);
if (order == null) {
return false; // 订单不存在
}
// 客户可以操作自己的订单
if (order.getCustomerId().equals(userId)) {
return true;
}
// 配送员可以操作分配给自己的订单
if (order.getDeliveryPersonId() != null &&
order.getDeliveryPersonId().equals(userId)) {
return true;
}
return false;
}
}

@ -0,0 +1,138 @@
package com.campus.pickup.service;
import com.campus.pickup.dao.ReviewDao;
import com.campus.pickup.model.Review;
import java.util.List;
/**
*
*
*/
public class ReviewService {
private ReviewDao reviewDao;
/**
*
*/
public ReviewService() {
this.reviewDao = new ReviewDao();
}
/**
*
* @param orderId ID
* @param reviewerId ID
* @param reviewedId ID
* @param rating 1-5
* @param content
* @return truefalse
*/
public boolean addReview(String orderId, String reviewerId, String reviewedId, int rating, String content) {
// 检查评分是否有效
if (rating < 1 || rating > 5) {
return false;
}
// 检查该订单是否已经评价过
Review existingReview = reviewDao.getReviewByOrderId(orderId);
if (existingReview != null) {
return false; // 该订单已评价过
}
Review review = new Review();
review.setReviewId(java.util.UUID.randomUUID().toString().replace("-", ""));
review.setOrderId(orderId);
review.setReviewerId(reviewerId);
review.setReviewedId(reviewedId);
review.setRating(rating);
review.setContent(content);
review.setCreateTime(java.time.LocalDateTime.now());
review.setUpdateTime(java.time.LocalDateTime.now());
review.setStatus(0); // 正常状态
return reviewDao.addReview(review);
}
/**
* ID
* @param reviewId ID
* @return
*/
public Review getReviewById(String reviewId) {
return reviewDao.getReviewById(reviewId);
}
/**
* ID
* @param orderId ID
* @return
*/
public Review getReviewByOrderId(String orderId) {
return reviewDao.getReviewByOrderId(orderId);
}
/**
*
* @param userId ID
* @return
*/
public List<Review> getReviewsReceivedByUser(String userId) {
return reviewDao.getReviewsByReviewedId(userId);
}
/**
*
* @param userId ID
* @return
*/
public double getAverageRatingForUser(String userId) {
return reviewDao.getAverageRatingByUserId(userId);
}
/**
*
* @param reviewId ID
* @param rating 1-5
* @param content
* @return truefalse
*/
public boolean updateReview(String reviewId, int rating, String content) {
// 检查评分是否有效
if (rating < 1 || rating > 5) {
return false;
}
Review review = reviewDao.getReviewById(reviewId);
if (review != null) {
review.setRating(rating);
review.setContent(content);
review.setUpdateTime(java.time.LocalDateTime.now());
return reviewDao.updateReview(review);
}
return false;
}
/**
*
* @param reviewId ID
* @return truefalse
*/
public boolean deleteReview(String reviewId) {
return reviewDao.deleteReview(reviewId);
}
/**
*
* @param orderId ID
* @param userId ID
* @return truefalse
*/
public boolean canUserReviewOrder(String orderId, String userId) {
Review review = reviewDao.getReviewByOrderId(orderId);
if (review == null) {
return true; // 订单未被评价过
}
return review.getReviewerId().equals(userId); // 只有评价者本人可以修改评价
}
}

@ -0,0 +1,116 @@
package com.campus.pickup.service;
import com.campus.pickup.dao.UserDao;
import com.campus.pickup.model.User;
import java.util.List;
/**
*
*
*/
public class UserService {
private UserDao userDao;
/**
*
*/
public UserService() {
this.userDao = new UserDao();
}
/**
*
* @param user
* @return truefalse
*/
public boolean register(User user) {
// 检查用户名是否已存在
User existingUser = userDao.getUserByUsername(user.getUsername());
if (existingUser != null) {
return false; // 用户名已存在
}
// 设置创建时间和更新时间
user.setCreateTime(java.time.LocalDateTime.now());
user.setUpdateTime(java.time.LocalDateTime.now());
user.setStatus(0); // 默认状态为正常
// 添加用户到数据库
return userDao.addUser(user);
}
/**
*
* @param username
* @param password
* @return null
*/
public User login(String username, String password) {
User user = userDao.getUserByUsername(username);
if (user != null && user.getPassword().equals(password) && user.getStatus() == 0) {
return user; // 登录成功
}
return null; // 登录失败
}
/**
* ID
* @param userId ID
* @return
*/
public User getUserById(String userId) {
return userDao.getUserById(userId);
}
/**
*
* @param user
* @return truefalse
*/
public boolean updateUser(User user) {
user.setUpdateTime(java.time.LocalDateTime.now());
return userDao.updateUser(user);
}
/**
*
* @param userId ID
* @param oldPassword
* @param newPassword
* @return truefalse
*/
public boolean changePassword(String userId, String oldPassword, String newPassword) {
User user = userDao.getUserById(userId);
if (user != null && user.getPassword().equals(oldPassword)) {
user.setPassword(newPassword);
user.setUpdateTime(java.time.LocalDateTime.now());
return userDao.updateUser(user);
}
return false;
}
/**
* /
* @param userId ID
* @param status 0-1-
* @return truefalse
*/
public boolean changeUserStatus(String userId, int status) {
User user = userDao.getUserById(userId);
if (user != null) {
user.setStatus(status);
user.setUpdateTime(java.time.LocalDateTime.now());
return userDao.updateUser(user);
}
return false;
}
/**
*
* @return
*/
public List<User> getAllUsers() {
return userDao.getAllUsers();
}
}

@ -0,0 +1,69 @@
package com.campus.pickup.util;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.Properties;
/**
*
*
*/
public class DatabaseUtil {
private static final String DRIVER = "org.postgresql.Driver";
private static final String URL = "jdbc:postgresql://localhost:5432/campus_pickup";
private static final String USERNAME = "postgres";
private static final String PASSWORD = "postgres";
static {
try {
Class.forName(DRIVER);
} catch (ClassNotFoundException e) {
System.err.println("加载数据库驱动失败:" + e.getMessage());
}
}
/**
*
* @return
* @throws SQLException
*/
public static Connection getConnection() throws SQLException {
Properties props = new Properties();
props.setProperty("user", USERNAME);
props.setProperty("password", PASSWORD);
props.setProperty("ssl", "false");
return DriverManager.getConnection(URL, props);
}
/**
*
* @param conn
*/
public static void closeConnection(Connection conn) {
if (conn != null) {
try {
conn.close();
} catch (SQLException e) {
System.err.println("关闭数据库连接失败:" + e.getMessage());
}
}
}
/**
*
* @return
*/
public static boolean testConnection() {
Connection conn = null;
try {
conn = getConnection();
return conn != null && !conn.isClosed();
} catch (SQLException e) {
System.err.println("数据库连接测试失败:" + e.getMessage());
return false;
} finally {
closeConnection(conn);
}
}
}

@ -0,0 +1,144 @@
package com.campus.pickup.view;
import com.campus.pickup.model.User;
/**
*
*
*/
public class MainView {
private UserView userView;
private MessageView messageView;
private ReviewView reviewView;
private OrderView orderView;
/**
*
*/
public MainView() {
this.userView = new UserView();
this.messageView = new MessageView();
this.reviewView = new ReviewView();
this.orderView = new OrderView();
}
/**
*
*/
public void showWelcomeScreen() {
System.out.println("========================================");
System.out.println(" 欢迎使用校园代取系统");
System.out.println("========================================");
System.out.println("本系统提供以下功能:");
System.out.println("- 用户注册与登录");
System.out.println("- 个人信息管理");
System.out.println("- 消息交流");
System.out.println("- 评价管理");
System.out.println("- 订单配送管理");
System.out.println("========================================");
}
/**
*
* @return
*/
public int showMainMenu() {
System.out.println("\n===== 校园代取系统 - 主菜单 =====");
System.out.println("1. 用户注册");
System.out.println("2. 用户登录");
System.out.println("0. 退出系统");
System.out.print("请选择操作: ");
try {
java.util.Scanner scanner = new java.util.Scanner(System.in);
int choice = Integer.parseInt(scanner.nextLine());
return choice;
} catch (NumberFormatException e) {
System.out.println("请输入有效的数字选项!");
return -1;
}
}
/**
*
*/
public void run() {
showWelcomeScreen();
User currentUser = null;
int choice;
do {
if (currentUser == null) {
choice = showMainMenu();
switch (choice) {
case 1:
userView.showRegistrationForm();
break;
case 2:
currentUser = userView.showLoginForm();
break;
case 0:
System.out.println("感谢使用校园代取系统,再见!");
break;
default:
System.out.println("无效的选项,请重新选择!");
break;
}
} else {
choice = userView.showUserMenu(currentUser);
switch (choice) {
case 1:
userView.showUserInfo(currentUser.getUserId());
break;
case 2:
userView.showUpdateUserInfoForm(currentUser.getUserId());
break;
case 3:
userView.showChangePasswordForm(currentUser.getUserId());
break;
case 4:
messageView.handleMessageManagement(currentUser);
break;
case 5:
reviewView.handleReviewManagement(currentUser);
break;
case 6:
orderView.showOrderMenu();
break;
case 0:
System.out.println("已退出登录,返回主菜单...");
currentUser = null;
break;
default:
System.out.println("无效的选项,请重新选择!");
break;
}
}
} while (choice != 0 || currentUser != null);
// 关闭资源
closeResources();
}
/**
*
*/
private void closeResources() {
userView.close();
messageView.close();
reviewView.close();
orderView.close();
}
/**
*
* @param args
*/
public static void main(String[] args) {
MainView mainView = new MainView();
mainView.run();
}
}

@ -0,0 +1,287 @@
package com.campus.pickup.view;
import com.campus.pickup.controller.MessageController;
import com.campus.pickup.model.Message;
import com.campus.pickup.model.User;
import java.util.List;
import java.util.Map;
import java.util.Scanner;
/**
*
*
*/
public class MessageView {
private MessageController messageController;
private Scanner scanner;
/**
*
*/
public MessageView() {
this.messageController = new MessageController();
this.scanner = new Scanner(System.in);
}
/**
*
* @param senderId ID
*/
public void showSendMessageForm(String senderId) {
System.out.println("\n===== 发送消息 =====");
System.out.print("请输入接收者用户名或ID: ");
String receiverId = scanner.nextLine();
System.out.println("消息类型:");
System.out.println("1. 用户消息");
System.out.println("2. 订单消息");
System.out.println("3. 评价消息");
System.out.print("请选择消息类型: ");
int typeChoice;
try {
typeChoice = Integer.parseInt(scanner.nextLine());
if (typeChoice < 1 || typeChoice > 3) {
System.out.println("无效的消息类型!");
return;
}
} catch (NumberFormatException e) {
System.out.println("请输入有效的数字选项!");
return;
}
System.out.print("请输入消息内容: ");
String content = scanner.nextLine();
// 调用控制器发送消息
Map<String, Object> result = messageController.sendMessage(senderId, receiverId, content, typeChoice);
if ((boolean) result.get("success")) {
System.out.println("消息发送成功!");
} else {
System.out.println("消息发送失败: " + result.get("message"));
}
}
/**
*
* @param receiverId ID
*/
public void showReceivedMessages(String receiverId) {
System.out.println("\n===== 收到的消息 =====");
Map<String, Object> result = messageController.getReceivedMessages(receiverId);
if ((boolean) result.get("success")) {
List<Message> messages = (List<Message>) result.get("messages");
if (messages.isEmpty()) {
System.out.println("您没有收到任何消息。");
return;
}
System.out.println("消息总数: " + messages.size());
System.out.println("----------------------------------------");
for (Message message : messages) {
String statusText = message.getStatus() == 0 ? "未读" : "已读";
System.out.println("消息ID: " + message.getMessageId());
System.out.println("发送者ID: " + message.getSenderId());
System.out.println("消息类型: " + message.getType().getDescription());
System.out.println("消息内容: " + message.getContent());
System.out.println("发送时间: " + message.getSendTime());
System.out.println("状态: " + statusText);
System.out.println("----------------------------------------");
}
} else {
System.out.println("获取消息列表失败: " + result.get("message"));
}
}
/**
*
* @param receiverId ID
*/
public void showUnreadMessageCount(String receiverId) {
Map<String, Object> result = messageController.getUnreadMessageCount(receiverId);
if ((boolean) result.get("success")) {
int count = (int) result.get("unreadCount");
System.out.println("您有 " + count + " 条未读消息。");
} else {
System.out.println("获取未读消息数量失败: " + result.get("message"));
}
}
/**
*
* @param messageId ID
*/
public void showMessageDetail(String messageId) {
System.out.println("\n===== 消息详情 =====");
Map<String, Object> result = messageController.getMessageDetail(messageId);
if ((boolean) result.get("success")) {
Message message = (Message) result.get("message");
String statusText = message.getStatus() == 0 ? "未读" : "已读";
System.out.println("消息ID: " + message.getMessageId());
System.out.println("发送者ID: " + message.getSenderId());
System.out.println("接收者ID: " + message.getReceiverId());
System.out.println("消息类型: " + message.getType().getDescription());
System.out.println("消息内容: " + message.getContent());
System.out.println("发送时间: " + message.getSendTime());
System.out.println("阅读时间: " + message.getReadTime());
System.out.println("状态: " + statusText);
// 如果消息未读,询问是否标记为已读
if (message.getStatus() == 0) {
System.out.print("\n是否标记为已读(y/n): ");
String choice = scanner.nextLine();
if (choice.equalsIgnoreCase("y")) {
markMessageAsRead(messageId);
}
}
} else {
System.out.println("获取消息详情失败: " + result.get("message"));
}
}
/**
*
* @param messageId ID
*/
public void markMessageAsRead(String messageId) {
Map<String, Object> result = messageController.markMessageAsRead(messageId);
if ((boolean) result.get("success")) {
System.out.println("消息已标记为已读。");
} else {
System.out.println("标记消息为已读失败: " + result.get("message"));
}
}
/**
*
* @param receiverId ID
*/
public void markAllMessagesAsRead(String receiverId) {
Map<String, Object> result = messageController.markAllMessagesAsRead(receiverId);
if ((boolean) result.get("success")) {
System.out.println("所有消息已标记为已读。");
} else {
System.out.println("批量标记消息为已读失败: " + result.get("message"));
}
}
/**
*
* @param userId1 ID
*/
public void showChatHistory(String userId1) {
System.out.println("\n===== 查看聊天记录 =====");
System.out.print("请输入对方用户名或ID: ");
String userId2 = scanner.nextLine();
Map<String, Object> result = messageController.getMessagesBetweenUsers(userId1, userId2);
if ((boolean) result.get("success")) {
List<Message> messages = (List<Message>) result.get("messages");
if (messages.isEmpty()) {
System.out.println("您与该用户没有聊天记录。");
return;
}
System.out.println("聊天记录总数: " + messages.size());
System.out.println("----------------------------------------");
for (Message message : messages) {
String senderName = message.getSenderId().equals(userId1) ? "我" : message.getSenderId();
System.out.println(senderName + " (" + message.getSendTime() + "):");
System.out.println(message.getContent());
System.out.println("----------------------------------------");
}
} else {
System.out.println("获取聊天记录失败: " + result.get("message"));
}
}
/**
*
* @param user
* @return
*/
public int showMessageMenu(User user) {
System.out.println("\n===== 消息管理 =====");
System.out.println("1. 查看未读消息数量");
System.out.println("2. 查看收到的消息");
System.out.println("3. 发送消息");
System.out.println("4. 查看聊天记录");
System.out.println("5. 标记所有消息为已读");
System.out.println("0. 返回上一级");
System.out.print("请选择操作: ");
try {
int choice = Integer.parseInt(scanner.nextLine());
return choice;
} catch (NumberFormatException e) {
System.out.println("请输入有效的数字选项!");
return -1;
}
}
/**
*
* @param user
*/
public void handleMessageManagement(User user) {
int choice;
do {
choice = showMessageMenu(user);
switch (choice) {
case 1:
showUnreadMessageCount(user.getUserId());
break;
case 2:
showReceivedMessages(user.getUserId());
System.out.print("\n输入消息ID查看详情(留空返回): ");
String messageId = scanner.nextLine();
if (!messageId.isEmpty()) {
showMessageDetail(messageId);
}
break;
case 3:
showSendMessageForm(user.getUserId());
break;
case 4:
showChatHistory(user.getUserId());
break;
case 5:
markAllMessagesAsRead(user.getUserId());
break;
case 0:
System.out.println("返回上一级菜单...");
break;
default:
System.out.println("无效的选项,请重新选择!");
break;
}
} while (choice != 0);
}
/**
*
*/
public void close() {
if (scanner != null) {
scanner.close();
}
}
}

@ -0,0 +1,401 @@
package com.campus.pickup.view;
import com.campus.pickup.controller.OrderController;
import com.campus.pickup.model.Order;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.List;
import java.util.Map;
import java.util.Scanner;
/**
*
*
*/
public class OrderView {
private OrderController orderController;
private Scanner scanner;
public OrderView() {
this.orderController = new OrderController();
this.scanner = new Scanner(System.in);
}
/**
*
*/
public void showOrderMenu() {
boolean running = true;
while (running) {
System.out.println("\n===== 订单管理 =====");
System.out.println("1. 创建订单");
System.out.println("2. 查看我的订单");
System.out.println("3. 查看所有订单");
System.out.println("4. 查看待接单订单");
System.out.println("5. 接单");
System.out.println("6. 更新订单状态");
System.out.println("7. 返回主菜单");
System.out.print("请选择操作: ");
String choice = scanner.nextLine();
switch (choice) {
case "1":
createOrder();
break;
case "2":
viewMyOrders();
break;
case "3":
viewAllOrders();
break;
case "4":
viewPendingOrders();
break;
case "5":
acceptOrder();
break;
case "6":
updateOrderStatus();
break;
case "7":
running = false;
break;
default:
System.out.println("无效选择,请重新输入。");
break;
}
}
}
/**
*
*/
private void createOrder() {
System.out.println("\n===== 创建订单 =====");
System.out.print("请输入客户ID: ");
String customerId = scanner.nextLine();
System.out.print("请输入物品类型(如:快递、外卖、文件等): ");
String itemType = scanner.nextLine();
System.out.print("请输入物品描述: ");
String description = scanner.nextLine();
System.out.print("请输入取件地点: ");
String pickupLocation = scanner.nextLine();
System.out.print("请输入配送地点: ");
String deliveryLocation = scanner.nextLine();
System.out.print("请输入配送费用(可选,直接回车跳过): ");
String feeStr = scanner.nextLine();
System.out.print("请输入预计取件时间格式yyyy-MM-dd HH:mm可选直接回车跳过: ");
String pickupTimeStr = scanner.nextLine();
System.out.print("请输入备注(可选,直接回车跳过): ");
String remarks = scanner.nextLine();
// 调用控制器创建订单
Map<String, Object> result = orderController.createOrder(
customerId, itemType, description, pickupLocation,
deliveryLocation, feeStr, pickupTimeStr, remarks
);
if ((Boolean) result.get("success")) {
Order order = (Order) result.get("order");
System.out.println("订单创建成功!");
System.out.println("订单号: " + order.getOrderNumber());
System.out.println("订单ID: " + order.getOrderId());
System.out.println("订单状态: " + order.getStatus().getDescription());
} else {
System.out.println("订单创建失败: " + result.get("message"));
}
}
/**
*
*/
private void viewMyOrders() {
System.out.println("\n===== 查看我的订单 =====");
System.out.print("请输入您的ID客户或配送员: ");
String userId = scanner.nextLine();
System.out.println("请选择角色: ");
System.out.println("1. 客户");
System.out.println("2. 配送员");
System.out.print("请选择: ");
String roleChoice = scanner.nextLine();
List<Order> orders;
if ("1".equals(roleChoice)) {
Map<String, Object> result = orderController.getOrdersByCustomerId(userId);
if ((Boolean) result.get("success")) {
orders = (List<Order>) result.get("orders");
} else {
System.out.println("获取订单失败: " + result.get("message"));
return;
}
} else if ("2".equals(roleChoice)) {
Map<String, Object> result = orderController.getOrdersByDeliveryPersonId(userId);
if ((Boolean) result.get("success")) {
orders = (List<Order>) result.get("orders");
} else {
System.out.println("获取订单失败: " + result.get("message"));
return;
}
} else {
System.out.println("无效选择");
return;
}
if (orders.isEmpty()) {
System.out.println("没有找到相关订单");
} else {
System.out.println("找到 " + orders.size() + " 个订单:");
displayOrderList(orders);
}
}
/**
*
*/
private void viewAllOrders() {
System.out.println("\n===== 查看所有订单 =====");
Map<String, Object> result = orderController.getAllOrders();
if (!(Boolean) result.get("success")) {
System.out.println("获取订单失败: " + result.get("message"));
return;
}
List<Order> orders = (List<Order>) result.get("orders");
if (orders.isEmpty()) {
System.out.println("当前没有订单");
} else {
System.out.println("共有 " + orders.size() + " 个订单:");
displayOrderList(orders);
}
}
/**
*
*/
private void viewPendingOrders() {
System.out.println("\n===== 查看待接单订单 =====");
Map<String, Object> result = orderController.getOrdersByStatus(0); // 0表示待接单状态
if (!(Boolean) result.get("success")) {
System.out.println("获取订单失败: " + result.get("message"));
return;
}
List<Order> orders = (List<Order>) result.get("orders");
if (orders.isEmpty()) {
System.out.println("当前没有待接单的订单");
} else {
System.out.println("共有 " + orders.size() + " 个待接单订单:");
displayOrderList(orders);
}
}
/**
*
*/
private void acceptOrder() {
System.out.println("\n===== 接单 =====");
// 先显示待接单订单
Map<String, Object> pendingResult = orderController.getOrdersByStatus(0); // 0表示待接单状态
if (!(Boolean) pendingResult.get("success")) {
System.out.println("获取待接单订单失败: " + pendingResult.get("message"));
return;
}
List<Order> pendingOrders = (List<Order>) pendingResult.get("orders");
if (pendingOrders.isEmpty()) {
System.out.println("当前没有待接单的订单");
return;
}
System.out.println("当前待接单订单:");
displayOrderList(pendingOrders);
System.out.print("请输入要接的订单ID: ");
String orderId = scanner.nextLine();
System.out.print("请输入配送员ID: ");
String deliveryPersonId = scanner.nextLine();
Map<String, Object> result = orderController.acceptOrder(orderId, deliveryPersonId);
if ((Boolean) result.get("success")) {
System.out.println("接单成功!");
} else {
System.out.println("接单失败: " + result.get("message"));
}
}
/**
*
*/
private void updateOrderStatus() {
System.out.println("\n===== 更新订单状态 =====");
System.out.print("请输入订单ID: ");
String orderId = scanner.nextLine();
// 显示当前订单状态
Order order = orderController.getOrderById(orderId);
if (order == null) {
System.out.println("订单不存在");
return;
}
System.out.println("当前订单状态: " + order.getStatus().getDescription());
// 显示可用的状态转换选项
System.out.println("\n可转换的状态:");
switch (order.getStatus()) {
case PENDING:
System.out.println("1. 已接单");
System.out.println("2. 已取消");
break;
case ACCEPTED:
System.out.println("1. 已取件");
System.out.println("2. 已取消");
break;
case PICKED_UP:
System.out.println("1. 配送中");
break;
case DELIVERING:
System.out.println("1. 已完成");
break;
case COMPLETED:
case CANCELLED:
System.out.println("订单已完成或已取消,无法更改状态");
return;
}
System.out.print("请选择要转换的状态: ");
String choice = scanner.nextLine();
Map<String, Object> result = null;
switch (choice) {
case "1":
switch (order.getStatus()) {
case PENDING:
System.out.print("请输入配送员ID: ");
String deliveryPersonId = scanner.nextLine();
result = orderController.acceptOrder(orderId, deliveryPersonId);
break;
case ACCEPTED:
result = orderController.pickupOrder(orderId);
break;
case PICKED_UP:
result = orderController.deliverOrder(orderId);
break;
case DELIVERING:
result = orderController.completeOrder(orderId);
break;
}
break;
case "2":
if (order.getStatus() == Order.OrderStatus.PENDING ||
order.getStatus() == Order.OrderStatus.ACCEPTED) {
result = orderController.cancelOrder(orderId);
} else {
System.out.println("当前状态无法取消订单");
return;
}
break;
default:
System.out.println("无效选择");
return;
}
if (result != null && (Boolean) result.get("success")) {
System.out.println("订单状态更新成功!");
Order updatedOrder = (Order) result.get("order");
System.out.println("新状态: " + updatedOrder.getStatus().getDescription());
} else if (result != null) {
System.out.println("订单状态更新失败: " + result.get("message"));
}
}
/**
*
*/
private void displayOrderList(List<Order> orders) {
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm");
System.out.println("------------------------------------------------------------");
System.out.printf("%-15s %-10s %-10s %-15s %-15s %-10s%n",
"订单号", "客户ID", "配送员ID", "取件地点", "配送地点", "状态");
System.out.println("------------------------------------------------------------");
for (Order order : orders) {
System.out.printf("%-15s %-10s %-10s %-15s %-15s %-10s%n",
order.getOrderNumber(),
order.getCustomerId(),
order.getDeliveryPersonId() != null ? order.getDeliveryPersonId() : "未分配",
order.getPickupLocation(),
order.getDeliveryLocation(),
order.getStatus().getDescription());
}
System.out.println("------------------------------------------------------------");
}
/**
*
*/
private void displayOrderDetail(Order order) {
if (order == null) {
System.out.println("订单不存在");
return;
}
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm");
System.out.println("\n===== 订单详细信息 =====");
System.out.println("订单ID: " + order.getOrderId());
System.out.println("订单号: " + order.getOrderNumber());
System.out.println("客户ID: " + order.getCustomerId());
System.out.println("配送员ID: " + (order.getDeliveryPersonId() != null ? order.getDeliveryPersonId() : "未分配"));
System.out.println("物品类型: " + order.getItemType());
System.out.println("物品描述: " + order.getDescription());
System.out.println("取件地点: " + order.getPickupLocation());
System.out.println("配送地点: " + order.getDeliveryLocation());
System.out.println("配送费用: " + order.getFee());
System.out.println("预计取件时间: " + (order.getPickupTime() != null ? order.getPickupTime().format(formatter) : "未设置"));
System.out.println("实际配送时间: " + (order.getDeliveryTime() != null ? order.getDeliveryTime().format(formatter) : "未配送"));
System.out.println("创建时间: " + (order.getCreateTime() != null ? order.getCreateTime().format(formatter) : "未知"));
System.out.println("更新时间: " + (order.getUpdateTime() != null ? order.getUpdateTime().format(formatter) : "未知"));
System.out.println("订单状态: " + order.getStatus().getDescription());
System.out.println("备注: " + (order.getRemarks() != null ? order.getRemarks() : "无"));
System.out.println("========================");
}
/**
*
*/
public void close() {
if (scanner != null) {
scanner.close();
}
}
}

@ -0,0 +1,335 @@
package com.campus.pickup.view;
import com.campus.pickup.controller.ReviewController;
import com.campus.pickup.model.Review;
import com.campus.pickup.model.User;
import java.util.List;
import java.util.Map;
import java.util.Scanner;
/**
*
*
*/
public class ReviewView {
private ReviewController reviewController;
private Scanner scanner;
/**
*
*/
public ReviewView() {
this.reviewController = new ReviewController();
this.scanner = new Scanner(System.in);
}
/**
*
* @param reviewerId ID
*/
public void showAddReviewForm(String reviewerId) {
System.out.println("\n===== 添加评价 =====");
System.out.print("请输入订单ID: ");
String orderId = scanner.nextLine();
// 检查是否可以评价该订单
Map<String, Object> checkResult = reviewController.canUserReviewOrder(orderId, reviewerId);
if (!(boolean) checkResult.get("success")) {
System.out.println(checkResult.get("message"));
return;
}
if (!(boolean) checkResult.get("canReview")) {
System.out.println("您无法评价该订单: " + checkResult.get("message"));
return;
}
System.out.print("请输入被评价人ID: ");
String reviewedId = scanner.nextLine();
int rating = 0;
while (rating < 1 || rating > 5) {
try {
System.out.print("请输入评分(1-5星): ");
rating = Integer.parseInt(scanner.nextLine());
if (rating < 1 || rating > 5) {
System.out.println("评分必须在1-5之间");
}
} catch (NumberFormatException e) {
System.out.println("请输入有效的数字!");
}
}
System.out.print("请输入评价内容: ");
String content = scanner.nextLine();
// 调用控制器添加评价
Map<String, Object> result = reviewController.addReview(orderId, reviewerId, reviewedId, rating, content);
if ((boolean) result.get("success")) {
System.out.println("评价添加成功!");
} else {
System.out.println("评价添加失败: " + result.get("message"));
}
}
/**
*
* @param userId ID
*/
public void showReviewsReceivedByUser(String userId) {
System.out.println("\n===== 收到的评价 =====");
Map<String, Object> result = reviewController.getReviewsReceivedByUser(userId);
if ((boolean) result.get("success")) {
List<Review> reviews = (List<Review>) result.get("reviews");
if (reviews.isEmpty()) {
System.out.println("您没有收到任何评价。");
return;
}
System.out.println("评价总数: " + reviews.size());
System.out.println("----------------------------------------");
for (Review review : reviews) {
System.out.println("评价ID: " + review.getReviewId());
System.out.println("订单ID: " + review.getOrderId());
System.out.println("评价人ID: " + review.getReviewerId());
System.out.println("评分: " + getStarRating(review.getRating()));
System.out.println("评价内容: " + review.getContent());
System.out.println("评价时间: " + review.getCreateTime());
System.out.println("----------------------------------------");
}
} else {
System.out.println("获取评价列表失败: " + result.get("message"));
}
}
/**
*
* @param userId ID
*/
public void showAverageRatingForUser(String userId) {
Map<String, Object> result = reviewController.getAverageRatingForUser(userId);
if ((boolean) result.get("success")) {
double averageRating = (double) result.get("averageRating");
System.out.println("您的平均评分: " + String.format("%.2f", averageRating) + " 星");
} else {
System.out.println("获取平均评分失败: " + result.get("message"));
}
}
/**
*
* @param reviewId ID
*/
public void showReviewDetail(String reviewId) {
System.out.println("\n===== 评价详情 =====");
Map<String, Object> result = reviewController.getReviewDetail(reviewId);
if ((boolean) result.get("success")) {
Review review = (Review) result.get("review");
System.out.println("评价ID: " + review.getReviewId());
System.out.println("订单ID: " + review.getOrderId());
System.out.println("评价人ID: " + review.getReviewerId());
System.out.println("被评价人ID: " + review.getReviewedId());
System.out.println("评分: " + getStarRating(review.getRating()));
System.out.println("评价内容: " + review.getContent());
System.out.println("创建时间: " + review.getCreateTime());
System.out.println("更新时间: " + review.getUpdateTime());
} else {
System.out.println("获取评价详情失败: " + result.get("message"));
}
}
/**
*
* @param reviewId ID
*/
public void showUpdateReviewForm(String reviewId) {
System.out.println("\n===== 更新评价 =====");
// 先获取当前评价信息
Map<String, Object> result = reviewController.getReviewDetail(reviewId);
if (!(boolean) result.get("success")) {
System.out.println("获取评价信息失败: " + result.get("message"));
return;
}
Review currentReview = (Review) result.get("review");
System.out.println("当前评分: " + getStarRating(currentReview.getRating()));
int rating = 0;
while (rating < 1 || rating > 5) {
try {
System.out.print("请输入新的评分(1-5星): ");
rating = Integer.parseInt(scanner.nextLine());
if (rating < 1 || rating > 5) {
System.out.println("评分必须在1-5之间");
}
} catch (NumberFormatException e) {
System.out.println("请输入有效的数字!");
}
}
System.out.println("当前评价内容: " + currentReview.getContent());
System.out.print("请输入新的评价内容: ");
String content = scanner.nextLine();
// 调用控制器更新评价
result = reviewController.updateReview(reviewId, rating, content);
if ((boolean) result.get("success")) {
System.out.println("评价更新成功!");
} else {
System.out.println("评价更新失败: " + result.get("message"));
}
}
/**
*
* @param reviewId ID
*/
public void deleteReview(String reviewId) {
System.out.print("确认删除该评价?(y/n): ");
String confirmation = scanner.nextLine();
if (confirmation.equalsIgnoreCase("y")) {
Map<String, Object> result = reviewController.deleteReview(reviewId);
if ((boolean) result.get("success")) {
System.out.println("评价删除成功!");
} else {
System.out.println("评价删除失败: " + result.get("message"));
}
} else {
System.out.println("已取消删除操作。");
}
}
/**
* ID
* @param orderId ID
*/
public void showReviewByOrderId(String orderId) {
System.out.println("\n===== 订单评价 =====");
Map<String, Object> result = reviewController.getReviewByOrderId(orderId);
if ((boolean) result.get("success")) {
Review review = (Review) result.get("review");
System.out.println("评价ID: " + review.getReviewId());
System.out.println("订单ID: " + review.getOrderId());
System.out.println("评价人ID: " + review.getReviewerId());
System.out.println("被评价人ID: " + review.getReviewedId());
System.out.println("评分: " + getStarRating(review.getRating()));
System.out.println("评价内容: " + review.getContent());
System.out.println("评价时间: " + review.getCreateTime());
} else {
System.out.println(result.get("message"));
}
}
/**
*
* @param user
* @return
*/
public int showReviewMenu(User user) {
System.out.println("\n===== 评价管理 =====");
System.out.println("1. 查看收到的评价");
System.out.println("2. 查看平均评分");
System.out.println("3. 添加评价");
System.out.println("4. 根据订单ID查看评价");
System.out.println("5. 更新评价");
System.out.println("6. 删除评价");
System.out.println("0. 返回上一级");
System.out.print("请选择操作: ");
try {
int choice = Integer.parseInt(scanner.nextLine());
return choice;
} catch (NumberFormatException e) {
System.out.println("请输入有效的数字选项!");
return -1;
}
}
/**
*
* @param user
*/
public void handleReviewManagement(User user) {
int choice;
do {
choice = showReviewMenu(user);
switch (choice) {
case 1:
showReviewsReceivedByUser(user.getUserId());
break;
case 2:
showAverageRatingForUser(user.getUserId());
break;
case 3:
showAddReviewForm(user.getUserId());
break;
case 4:
System.out.print("请输入订单ID: ");
String orderId = scanner.nextLine();
showReviewByOrderId(orderId);
break;
case 5:
System.out.print("请输入评价ID: ");
String reviewId = scanner.nextLine();
showUpdateReviewForm(reviewId);
break;
case 6:
System.out.print("请输入评价ID: ");
String deleteReviewId = scanner.nextLine();
deleteReview(deleteReviewId);
break;
case 0:
System.out.println("返回上一级菜单...");
break;
default:
System.out.println("无效的选项,请重新选择!");
break;
}
} while (choice != 0);
}
/**
*
* @param rating
* @return
*/
private String getStarRating(int rating) {
StringBuilder stars = new StringBuilder();
for (int i = 0; i < rating; i++) {
stars.append("★");
}
for (int i = rating; i < 5; i++) {
stars.append("☆");
}
return stars.toString() + " (" + rating + "/5)";
}
/**
*
*/
public void close() {
if (scanner != null) {
scanner.close();
}
}
}

Some files were not shown because too many files have changed in this diff Show More

Loading…
Cancel
Save