cykj/hzdyjs
1
0 Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

学生考核数据上传-wei

Browse Source
This commit is contained in:
weizhong committed 2025-08-13 14:55:22 +08:00
2 parents 213db76eb8 1bf7f78c97
commit 6c6f272bb4
1200 files changed
+114413 -162324
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

.cursor/cursorrules-frontend.md
+40
View File
@@ -909,3 +909,43 @@ const pendingDeleteAttachmentIds = ref<string[]>([]); // 编辑时标
- **✅ 必须** 在新页面开发时引用本规范并注明 *附件管理统一规范* 版本
> **版本**: 2025-01-27 附件管理统一规范 v1.0
---
## 5. 构建问题解决方案
### 5.1 JavaScript heap out of memory 解决方案（2025-01-27）
#### 问题描述
在执行 `npm run build:prod` 时出现内存溢出错误：
```
FATAL ERROR: Reached heap limit Allocation failed - JavaScript heap out of memory
```
#### 根本原因
- 项目使用大量图标插件（unplugin-icons、svg-icons、element-plus图标等）
- 构建时需要加载大量图标文件到内存处理
- Node.js默认堆内存限制（~1.4GB）不足
#### 标准解决方案
修改 `package.json` 中的构建脚本，增加Node.js堆内存限制：
```json
{
"scripts": {
"build:prod": "node --max-old-space-size=8192 node_modules/vite/bin/vite.js build --mode production",
"build:dev": "node --max-old-space-size=8192 node_modules/vite/bin/vite.js build --mode development"
}
}
```
#### 参数说明
- `--max-old-space-size=8192`：设置堆内存限制为8GB
- 可根据项目规模和机器内存调整数值（4096=4GB, 8192=8GB）
#### 适用场景
- 大型前端项目构建
- 使用大量图标组件的项目
- 需要处理大量静态资源的项目
> **版本**: 2025-01-27 构建问题解决方案 v1.0
.cursor/cursorrules-mobile.md
+873 -823
View File
File diff suppressed because it is too large. Load diff
.cursor/cursorrules.md
+334
View File
@@ -0,0 +1,334 @@
# Cursor Rules - 项目开发规范总览
## 🎯 项目概述
**项目名称**: 校园管理系统 (hzdyjs_xg)
**技术架构**: 前后端分离 + 移动端
**工作目录**: `/Users/wuzilong/work/00code/hzdyjs_xg`
### 项目结构
- **前端工程**: `web/` (Vue 3 + TypeScript + Element Plus)
- **后端工程**: `backend/` (Spring Boot 3.4.6 + MyBatis-Plus)
- **移动端工程**: `mobile/` (Vue 2.6.14 + uni-app + uview-ui 2.0.38 - 智慧校园移动端)
- **文档管理**: `docs/` (完整的项目文档体系)
---
## 📚 规范文件引用
**重要说明**: 本项目的开发规范已按技术栈模块化拆分，请根据开发场景参考对应规范：
### 🔗 专门规范文件
```
.cursor/
├── cursorrules-docs.md # 📋 文档管理规范
├── cursorrules-frontend.md # 🎨 前端开发规范 (Vue 3)
├── cursorrules-backend.md # ⚙️ 后端开发规范 (Spring Boot)
├── cursorrules-mobile.md # 📱 移动端开发规范 (Vue 2 + uni-app + uview-ui)
├── cursorrules-workflow.md # 🔄 工作流开发规范 (Warm-Flow)
└── cursorrules-api-test.md # 🧪 API测试规范
```
### 📖 规范文件详情
#### 📋 文档管理规范 (.cursor/cursorrules-docs.md)
- 文档目录组织（中文化架构）
- **🚨 强制性文档同步更新规则**
- 变更记录管理规范（按日期和用户分文件）
- 业务模块文档管理（为AI提供完整上下文）
- **📊 API文档拆分管理规范** (2025-07-01新增，文件夹重组):
- **📁 文件夹结构**: 所有API文档统一存放在 `docs/开发文档/API/` 文件夹下
- **📝 文件组织**: 按业务模块拆分：基础规范、认证登录、物业报修、满意度调查
- **🔤 命名规范**: 中文文件命名，便于快速识别和查找
- **🔗 模块化管理**: 独立维护，减少冲突，交叉引用基础规范
- **📚 主入口**: API文档总览.md 作为统一导航入口
- **📋 模板支持**: API文档模板.md 用于新API文档生成
- **🔄 自动生成规则**: 新增API模块时，优先在API文件夹下创建对应文档
- 测试文档管理规范
#### 🎨 前端开发规范 (.cursor/cursorrules-frontend.md)
- Vue 3.5.13 + TypeScript 5.8.3 技术栈
- Art Design Pro UI 设计规范
- 轮廓式按钮设计系统
- 组件开发标准和页面模板
- API接口定义和状态管理
- 项目架构和性能优化
#### ⚙️ 后端开发规范 (.cursor/cursorrules-backend.md)
- Spring Boot 3.4.6 技术栈
- **🔴 数据库规范（强制性）** - 雪花ID、逻辑删除、多租户
- **🔴 API接口规范（强制性）** - 统一响应格式、Token认证
- **🔐 菜单界面和接口权限配置规范**
- 标准代码模板 (Controller/Service/Mapper)
#### 📱 移动端开发规范 (.cursor/cursorrules-mobile.md)
- **Vue 2.6.14 + uni-app + uview-ui 2.0.38 技术栈（智慧校园移动端）**
- **基于Vue 2的稳定架构（兼容性优先）**
- **uview-ui 2.0.38 成熟UI组件库（Vue 2版本）**
- **现代CSS变量设计系统和响应式布局适配**
- **完整的用户体验优化（动画、手势识别、无障碍访问）**
- **智能缓存策略和网络请求优化**
- **多端发布支持（H5、微信小程序、App、鸿蒙）**
- **iconfont图标系统（支持uview-ui的u-icon组件）**
#### 🔄 工作流开发规范 (.cursor/cursorrules-workflow.md)
- **Warm-Flow工作流框架** - 基于dromara社区开源的轻量级工作流引擎
- **🔴 强制性VO类规范（避免MyBatis映射错误）** - 所有工作流业务VO类必须包含四个基础字段
- **工作流状态管理** - 7种标准业务状态（draft、waiting、complete等）
- **标准工作流模式** - 普通流程、排他网关、并行网关、会签等6种模式
- **前端工作流组件** - approvalButton、submitVerify、approvalRecord标准组件使用
- **工作流权限配置** - @ConditionalOnEnable条件开启和Sa-Token权限控制
- **请假工作流示例** - 完整的工作流开发实践模板
#### 🧪 API测试规范 (.cursor/cursorrules-api-test.md)
- **✅ AES+RSA双重加密登录方法（已完全解决）**
- API测试最佳实践和通用测试方法
- 自动化测试脚本和性能测试
- 测试记录模板
---
## 🚨 核心开发原则（必须遵循）
### 1. 📝 强制性文档同步更新
**⚠️ 超级重要**: 每次代码调整都必须立即同步更新相应文档！
#### 必须更新的文档
- **API变更** → 按业务模块更新对应的API文档(2025-07-01重新组织到API文件夹):
- 基础规范变更 → `docs/开发文档/API/API文档基础规范.md`
- 认证登录变更 → `docs/开发文档/API/用户认证登录API.md`
- 物业报修变更 → `docs/开发文档/API/物业报修管理API.md`
- 满意度调查变更 → `docs/开发文档/API/后勤满意度调查API.md`
- API文档总览 → `docs/开发文档/API/API文档总览.md`
- **数据库变更** → `docs/设计文档/database/`
- **业务逻辑变更** → `docs/业务模块/[模块名称]/`
- **配置变更** → `docs/中间件配置/` 或 `docs/部署文档/`
- **📱 移动端变更** → 移动端工程相关文档必须同步更新:
- **移动端API新增/变更** → 相应的API文档必须补充移动端实现章节
- **移动端页面开发** → `docs/开发文档/` 移动端相关文档
- **移动端功能变更** → `docs/业务模块/[模块名称]/` 移动端部分
- **移动端技术规范变更** → `.cursor/cursorrules-mobile.md`
#### 变更记录规范
- **文件格式**: `docs/变更管理/code-adjust-record-YYYY-MM-DD-{username}.md`
- **排序要求**: 按时间倒序排列，最新记录在最上面
- **时间填写**: 必须填写真实的当前时间（YYYY-MM-DD HH:mm:ss）
### 2. 🔴 数据库开发强制要求
- **标准基础字段**: 所有业务表必须包含统一的基础字段
- **雪花ID主键**: 统一使用 `bigint(20)` 作为主键
- **逻辑删除**: 禁止物理删除，使用 `deleted` 字段
- **多租户支持**: 必须包含 `tenant_id` 字段
- **参考规范**: `docs/设计文档/database/mysql-database-standard.md`
### 3. 🔴 API接口开发强制要求
- **统一响应格式**: 分页用TableDataInfo，非分页用R类型
- **Token认证**: Bearer格式，包含clientid、referer等必需Header
- **权限注解**: 每个接口必须有@SaCheckPermission注解
- **参数验证**: 使用Bean Validation进行参数校验
### 4. 🎯 技术要求
- **Node.js**: 20.15.x+, npm 10.7.x+
- **Java**: JDK 17/21
- **前端访问**: http://localhost (默认80端口)
- **后端服务**: http://localhost:8080
- **移动端**: Vue 2.6.14 + uni-app + uview-ui 2.0.38（智慧校园移动端）
---
## 🔄 Cursor AI 工作流程
### 📋 开发工作流程
```
1. **确定开发场景** → 自动应用对应技术栈规范
2. **编写/修改代码** → 遵循相应的编码规范
3. **立即更新文档** → 同步更新API文档和相关文档
4. **记录变更日志** → 在当日变更文件中记录
5. **验证和测试** → 确保功能正常和文档准确
```
### 🤖 Cursor AI 规范应用
- **前端开发**: 自动参考 `cursorrules-frontend.md`
- **后端开发**: 自动参考 `cursorrules-backend.md`
- **移动端开发**: 自动参考 `cursorrules-mobile.md`
- **工作流开发**: 自动参考 `cursorrules-workflow.md`
- **文档更新**: 自动参考 `cursorrules-docs.md`
- **API测试**: 自动参考 `cursorrules-api-test.md`
### 👍 点赞后知识总结机制
**⚠️ 重要提醒：当用户对Cursor回答点赞时，请主动询问是否需要进行总结归档**
#### 点赞触发规则
- **触发条件**: 用户对Cursor的回答点赞（👍）
- **自动提醒**: "检测到您对本次回答满意，是否需要将相关经验总结归档到项目规范中？"
- **总结目标**: 将成功的解决方案、最佳实践、经验教训整理到规范文档中
#### 总结内容建议
1. **技术解决方案**: 将有效的技术方案整理到对应的cursorrules文档
2. **开发流程优化**: 将改进的工作流程补充到开发规范中
3. **最佳实践**: 将成功经验添加到最佳实践文档
4. **问题解决方案**: 将常见问题和解决方案整理到知识库
5. **规范完善**: 根据实际应用效果完善和优化现有规范
#### 总结文档位置
- **技术规范**: 对应的`.cursor/cursorrules-*.md`文件
- **最佳实践**: `docs/开发文档/API开发最佳实践总结.md`
- **项目知识库**: `docs/知识库/`目录
- **变更记录**: `docs/变更管理/code-adjust-record-YYYY-MM-DD-{username}.md`
#### 总结流程
```
用户点赞 → Cursor主动询问 → 确认总结 → 分析价值点 → 整理到规范 → 更新相关文档
```
#### 价值目标
- 📚 **知识积累**: 将零散的经验系统化整理
- 🔄 **规范优化**: 基于实际应用持续改进规范
- 📖 **团队共享**: 将个人经验转化为团队资产
- 🚀 **效率提升**: 为后续类似问题提供标准解决方案
### 💡 API开发最佳实践
**⚠️ 基于场地预约管理系统开发实践制定的标准流程**
#### 完整开发流程（6个阶段）
1. **需求分析和文档创建** → 业务需求+技术架构文档
2. **数据库设计和初始化** → 表结构+字典+权限+示例数据
3. **后端模块开发** → 完整ruoyi模块（16个API接口）
4. **API文档编写** → 400+行详细API文档
5. **自动化测试脚本** → 450+行Python测试脚本
6. **变更记录和验证** → 完整的变更日志
#### 16个标准API接口模式
- **基础管理接口（6个）**: list、详情、新增、修改、删除、可用选项
- **业务功能接口（4个）**: 我的数据、待处理、规则检查、审批
- **辅助功能接口（6个）**: 导出、导入、统计、批量、启用、禁用
#### 🔴 VO类基础字段统一规范（新增 2025-07-01）
**⚠️ 超级重要：所有VO类必须包含统一的基础字段！**
**背景问题**：
- MyBatis-Plus自动查询：不包含继承字段
- 自定义SQL查询：明确包含字段，VO类必须有对应属性
- 导致运行时字段缺失错误：`Could not set property 'createBy'`
**统一解决方案**：
```java
// 所有VO类必须包含的四个基础字段
private Long createBy; // 创建者
private Date createTime; // 创建时间（含JSON格式化）
private Long updateBy; // 更新者
private Date updateTime; // 更新时间（含JSON格式化）
```
**强制要求**：
- ✅ 新增VO类必须包含四个基础字段
- ✅ 修复现有VO类时必须补全缺失字段
- ✅ 时间字段使用`@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")`
- ✅ 详细规范见：`.cursor/cursorrules-backend.md` → "VO类基础字段规范"
#### 质量保证标准
- ✅ **完整交付物**: 2个需求文档+3个SQL脚本+18个代码文件+1个API文档+1个测试脚本
- ✅ **开发时长**: 约3.5天完成完整API模块
- ✅ **文档同步**: 代码完成立即更新相关文档
- ✅ **测试覆盖**: 强制AES+RSA加密登录+完整功能测试
- ✅ **VO类规范**: 所有VO类包含统一基础字段，避免MyBatis映射错误
#### 参考文档
- **完整实践总结**: `docs/开发文档/API开发最佳实践总结.md`
- **成功案例**: `docs/开发文档/API/场地预约管理API.md`
- **测试脚本模板**: `test/场地预约API测试脚本.py`
- **VO类规范**: `.cursor/cursorrules-backend.md` → "VO类基础字段规范（强制性）"
---
## 🎯 快速开始
### 💡 开发提示
1. **查看具体规范**: 打开对应的 `.cursor/cursorrules-*.md` 文件
2. **遵循强制要求**: 特别注意标记为🔴和🚨的强制性规范
3. **使用标准模板**: 参考各规范文件中的代码模板
4. **及时更新文档**: 代码完成后立即更新相关文档
### 📚 重要文档位置
- **项目启动指南**: `工程本地启动指导.md`
- **API文档拆分架构** (按业务模块拆分，2025-07-01优化并重新组织到API文件夹):
- 📚 **API文档总览**: `docs/开发文档/API/API文档总览.md` (主入口导航)
- 📋 **基础规范**: `docs/开发文档/API/API文档基础规范.md` (通用规范)
- 🔐 **认证登录**: `docs/开发文档/API/用户认证登录API.md` (登录、用户信息)
- 🛠️ **物业报修**: `docs/开发文档/API/物业报修管理API.md` (报修工单管理)
- 📊 **满意度调查**: `docs/开发文档/API/后勤满意度调查API.md` (问卷答题)
- 📝 **API文档模板**: `docs/开发文档/API/API文档模板.md` (新API文档生成模板)
- **数据库设计**: `docs/设计文档/database/`
- **业务模块文档**: `docs/业务模块/`
- **测试脚本**: `test/` 目录
---
## 📞 规范说明
### 🔧 规范更新
- **规范文件更新**: 直接编辑对应的专门文件
- **跨模块变更**: 需要在相关文件中保持一致
- **重大变更**: 需要同步更新本主配置文件
### 📋 使用原则
1. **技术栈导向**: 根据当前开发的技术栈参考对应规范
2. **强制性要求**: 必须严格遵循标记为强制性的规范
3. **文档同步**: 代码变更必须同步更新文档
4. **质量保证**: 确保代码和文档的一致性
---
**🎯 目标**: 通过模块化规范管理和强制性文档同步，为Cursor AI提供准确的开发上下文，确保高质量的代码生成和完善的项目文档！
**📝 维护**: 拆分完成于 2025-07-01，所有原有内容完整保留
**📁 文件**: 5个专门规范文件 + 1个主配置文件
**🔄 加载**: Cursor自动识别和应用相关规范
# 原型文件存放规范（2025-07-01 新增）
- 所有后续生成的原型文件（如HTML原型、交互原型等），必须统一存放在 docs/原型文件/ 目录下的相应子目录中。
- 子目录应按端（如 web、移动端、小程序等）或业务模块分类，确保结构清晰、便于查找和维护。
- 禁止将原型文件存放在源码目录（如 web/src、mobile/src 等）或其他非文档目录。
- 迁移或生成原型文件时，需同步更新目录结构说明文档（如 docs/原型文件/README.md ）。
# 移动端技术栈规范（2025-01-27 更新）
## 🚨 重要变更说明
**变更时间**: 2025-01-27
**变更内容**: 移动端技术栈从 Vue 3 + uview-plus 调整为 Vue 2 + uview-ui
**变更原因**: 基于项目实际技术配置和稳定性考虑
### 📱 移动端技术栈调整
#### 调整前（错误）
- Vue 3.4.21 + uview-plus 3.4.45
- 现代化架构但与实际项目不符
#### 调整后（正确）
- **Vue 2.6.14 + uview-ui 2.0.38**
- **基于uni-app的稳定架构**
- **与实际项目配置完全一致**
### 🔄 相关文档更新
- ✅ **主规范文件**: `.cursor/cursorrules.md` - 移动端技术栈描述已更新
- ✅ **移动端规范**: `.cursor/cursorrules-mobile.md` - 完整重写为Vue 2技术栈
- 📝 **变更记录**: 本次调整将记录在变更管理文档中
### 📋 开发者注意事项
1. **图标使用**: 支持 iconfont 图标系统 + uview-ui 的 u-icon 组件
2. **组件引用**: 使用 `<u-xxx>` 格式引用 uview-ui 组件
3. **页面配置**: easycom 自动注册：`"^u-(.*)": "uview-ui/components/u-$1/u-$1.vue"`
4. **样式导入**: `@import 'uview-ui/index.scss'`
### 🎯 技术选型原则
- **稳定性优先**: Vue 2 生态成熟稳定
- **兼容性考虑**: uview-ui 2.x 对 uni-app 兼容性更好
- **团队熟悉度**: 基于实际项目经验
- **维护成本**: 降低技术栈复杂度
.cursorrules
+9 -18
View File
@@ -9,7 +9,7 @@
### 项目结构
- **前端工程**: `web/` (Vue 3 + TypeScript + Element Plus)
- **后端工程**: `backend/` (Spring Boot 3.4.6 + MyBatis-Plus)
- **移动端工程**: `mobile/` (Vue 3.4.21 + uniapp + uview-plus 3.4.45 - 现代化智慧校园)
- **移动端工程**: `mobile/` (Vue 2.6.14 + uni-app 2.x + uview-ui 2.0.38 - 智慧校园移动应用)
- **文档管理**: `docs/` (完整的项目文档体系)
---
@@ -34,7 +34,6 @@
#### 📋 文档管理规范 (.cursor/cursorrules-docs.md)
- 文档目录组织（中文化架构）
- **🚨 强制性文档同步更新规则**
- 变更记录管理规范（按日期和用户分文件）
- 业务模块文档管理（为AI提供完整上下文）
- **📊 API文档拆分管理规范** (2025-07-01新增，文件夹重组):
- **📁 文件夹结构**: 所有API文档统一存放在 `docs/开发文档/API/` 文件夹下
@@ -62,8 +61,8 @@
- 标准代码模板 (Controller/Service/Mapper)
#### 📱 移动端开发规范 (.cursor/cursorrules-mobile.md)
- Vue 3.4.21 + uni-app + uview-plus 3.4.45 技术栈（现代化智慧校园）
- 纯净的Vue 3项目架构（无状态管理库，采用原生API）
- Vue 2.6.14 + uni-app 2.x + uview-ui 2.0.38 技术栈（智慧校园移动应用）
- 基于Vue 2的响应式项目架构（包含Vuex状态管理）
- 现代CSS变量设计系统和响应式布局适配
- 完整的用户体验优化（动画、手势识别、无障碍访问）
- 智能缓存策略和网络请求优化
@@ -107,11 +106,6 @@
- **移动端功能变更** → `docs/业务模块/[模块名称]/` 移动端部分
- **移动端技术规范变更** → `.cursor/cursorrules-mobile.md`
#### 变更记录规范
- **文件格式**: `docs/变更管理/code-adjust-record-YYYY-MM-DD-{username}.md`
- **排序要求**: 按时间倒序排列，最新记录在最上面
- **时间填写**: 必须填写真实的当前时间（YYYY-MM-DD HH:mm:ss）
### 2. 🔴 数据库开发强制要求
- **标准基础字段**: 所有业务表必须包含统一的基础字段
- **雪花ID主键**: 统一使用 `bigint(20)` 作为主键
@@ -130,7 +124,7 @@
- **Java**: JDK 17/21
- **前端访问**: http://localhost (默认80端口)
- **后端服务**: http://localhost:8080
- **移动端**: Vue 3.4.21 + uni-app + uview-plus 3.4.45（现代化智慧校园）
- **移动端**: Vue 2.6.14 + uni-app 2.x + uview-ui 2.0.38（智慧校园移动应用，端口8081）
---
@@ -141,8 +135,7 @@
1. **确定开发场景** → 自动应用对应技术栈规范
2. **编写/修改代码** → 遵循相应的编码规范
3. **立即更新文档** → 同步更新API文档和相关文档
4. **记录变更日志** → 在当日变更文件中记录
5. **验证和测试** → 确保功能正常和文档准确
4. **验证和测试** → 确保功能正常和文档准确
```
### 🤖 Cursor AI 规范应用
@@ -173,7 +166,6 @@
- **技术规范**: 对应的`.cursor/cursorrules-*.md`文件
- **最佳实践**: `docs/开发文档/API开发最佳实践总结.md`
- **项目知识库**: `docs/知识库/`目录
- **变更记录**: `docs/变更管理/code-adjust-record-YYYY-MM-DD-{username}.md`
#### 总结流程
```
@@ -190,13 +182,12 @@
**⚠️ 基于场地预约管理系统开发实践制定的标准流程**
#### 完整开发流程（6个阶段）
#### 完整开发流程（5个阶段）
1. **需求分析和文档创建** → 业务需求+技术架构文档
2. **数据库设计和初始化** → 表结构+字典+权限+示例数据
3. **后端模块开发** → 完整ruoyi模块（16个API接口）
4. **API文档编写** → 400+行详细API文档
5. **自动化测试脚本** → 450+行Python测试脚本
6. **变更记录和验证** → 完整的变更日志
#### 16个标准API接口模式
- **基础管理接口（6个）**: list、详情、新增、修改、删除、可用选项
@@ -292,12 +283,12 @@ private Date updateTime; // 更新时间（含JSON格式化）
- 禁止将原型文件存放在源码目录（如 web/src、mobile/src 等）或其他非文档目录。
- 迁移或生成原型文件时，需同步更新目录结构说明文档（如 docs/原型文件/README.md ）。
# uview-plus 图标组件规范（2025-07-01 新增）
- 移动端UI开发中，图标组件统一使用 <u-icon />（uview-plus 3.x 官方标准），禁止使用 <up-icon /> 或 <uv-icon />。
# uview-ui 图标组件规范（2025-01-03 更新）
- 移动端UI开发中，图标组件统一使用 <u-icon />（uview-ui 2.x 官方标准），同时支持iconfont自定义图标。
- 推荐通过 easycom 自动全局注册，无需手动 import。
- 标准用法示例：
```vue
<u-icon name="account" size="22" color="#b0b8c9" />
<u-icon name="lock-open" size="22" color="#b0b8c9" />
```
- 图标名称请参考 uview-plus 官方文档：https://v3.uviewui.com/components/icon.html
- 图标名称请参考 uview-ui 官方文档：https://www.uviewui.com/components/icon.html
.gitignore
+5 -4
View File
@@ -164,8 +164,9 @@ coverage/
excel/
# 吴自龙注释
test/
script/
test/*
script/*
stgl-api-test.js
update/
本地临时文件目录/
update/*
本地临时文件目录/*
docs/变更管理/
backend/pom.xml
+2 -2
View File
@@ -383,11 +383,11 @@
<version>${revision}</version>
</dependency>
<!-- 学工管理信息系统模块 -->
<dependency>
<!-- <dependency>
<groupId>org.dromara</groupId>
<artifactId>ruoyi-xg-xx</artifactId>
<version>${revision}</version>
</dependency>
</dependency> -->
<!-- 招生就业管理模块 -->
<dependency>
<groupId>org.dromara</groupId>
backend/quota_diagnosis_results.txt
+37
View File
@@ -0,0 +1,37 @@
mysql: [Warning] Using a password on the command line interface can be insecure.
info
=== 1. 班主任和班级信息检查 ===
info
=== 2. 奖学金批次信息检查 ===
batch_id batch_name batch_status start_time end_time create_time
1952730449122004993 2025-2026??????????????? ACTIVE 2025-08-05 00:00:00 2025-08-29 00:00:00 2025-08-05 21:56:34
1 2024-2025??????????? ACTIVE 2024-09-01 00:00:00 2024-12-31 23:59:59 2025-08-05 09:04:39
info
=== 3. 奖学金类型信息检查 ===
type_id type_name level_type type_status batch_id batch_name
1 ??????? FIRST 1 1953330495479644161 2025-2026?????????????
1 ??????? FIRST 1 1952730449122004993 2025-2026???????????????
5 ????????? FIRST 1 1952730449122004993 2025-2026???????????????
1953004971846852609 ??????? FIRST 1 1952730449122004993 2025-2026???????????????
6 ????????? FIRST 1 NULL NULL
2 ??????? SECOND 1 1953330495479644161 2025-2026?????????????
2 ??????? SECOND 1 1952730449122004993 2025-2026???????????????
1953005237862195202 ??????? SECOND 1 1952730449122004993 2025-2026???????????????
7 ????????? SECOND 1 NULL NULL
1953004602014097409 ??????? SPECIAL 1 1952730449122004993 2025-2026???????????????
4 ????????? SPECIAL 1 1952730449122004993 2025-2026???????????????
8 ??????? SPECIAL 1 NULL NULL
1952634577994387457 ????? SPECIAL 1 1952730449122004993 2025-2026???????????????
1953004324552499202 ?????? SPECIAL 1 1952730449122004993 2025-2026???????????????
3 ??????? THIRD 1 1952730449122004993 2025-2026???????????????
1953005415696490497 ??????? THIRD 1 1952730449122004993 2025-2026???????????????
info
=== 4. 班级名额分配情况检查 ===
quota_id batch_id batch_name scholarship_type_id type_name class_id class_name total_quota used_quota available_quota allocation_method status create_time
2001 1 2024-2025??????????? 1 ??????? 1001 NULL 2 0 2 MANUAL ACTIVE 2025-08-06 11:00:49
2003 1 2024-2025??????????? 2 ??????? 1001 NULL 3 0 2 MANUAL ACTIVE 2025-08-06 11:00:49
2002 1 2024-2025??????????? 1 ??????? 1002 NULL 1 0 1 MANUAL ACTIVE 2025-08-06 11:00:49
2004 1 2024-2025??????????? 2 ??????? 1002 NULL 2 0 2 MANUAL ACTIVE 2025-08-06 11:00:49
info
=== 5. 已使用名额情况检查 ===
ERROR 1054 (42S22) at line 87: Unknown column 'sa.applicant_class_id' in 'field list'
backend/ruoyi-admin/pom.xml
+8 -2
View File
@@ -113,11 +113,11 @@
<artifactId>ruoyi-xg</artifactId>
</dependency>
<!-- 学工管理-学生信息管理模块 -->
<dependency>
<!-- <dependency>
<groupId>org.dromara</groupId>
<artifactId>ruoyi-xg-xx</artifactId>
<version>${revision}</version>
</dependency>
</dependency> -->
<!-- 招生就业管理模块 -->
<dependency>
<groupId>org.dromara</groupId>
@@ -141,6 +141,12 @@
<artifactId>ruoyi-xskh</artifactId>
<version>${revision}</version>
</dependency>
<!-- 奖惩补贴管理模块 -->
<dependency>
<groupId>org.dromara</groupId>
<artifactId>ruoyi-jcbt</artifactId>
<version>${revision}</version>
</dependency>
<!-- 社团管理模块 -->
<!-- <dependency>
backend/ruoyi-admin/src/main/resources/application-dev.yml
+30
View File
@@ -341,3 +341,33 @@ system:
# - 对于频繁访问的小文件，可以增加 max-cache-size
# - 对于大文件较多的环境，可以调整 max-single-file-size
# - 对于访问频率较低的环境，可以适当减少 expire-time-ms
--- # SQL日志配置（用于调试班级名额查询问题）
logging:
level:
# 开启 MyBatis SQL 日志
org.dromara.jcbt.mapper: DEBUG
org.dromara.jcbt.service: DEBUG
# 开启 MyBatis-Plus SQL 日志
com.baomidou.mybatisplus.extension.plugins.MybatisPlusInterceptor: DEBUG
# 开启 HikariCP 连接池日志（可选）
com.zaxxer.hikari: DEBUG
# 开启 P6Spy SQL 日志（更详细的SQL执行日志）
p6spy: INFO
pattern:
# 控制台日志格式，增加线程名和方法名
console: "%clr(%d{yyyy-MM-dd HH:mm:ss.SSS}){faint} %clr(%5p) %clr(${PID:- }){magenta} %clr(---){faint} %clr([%15.15t]){faint} %clr(%-40.40logger{39}){cyan} %clr(:){faint} %m%n%wEx"
# MyBatis 配置
mybatis-plus:
configuration:
# 开启 SQL 日志打印
log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
# 开启驼峰命名转换
map-underscore-to-camel-case: true
# 开启缓存
cache-enabled: true
# 开启懒加载
lazy-loading-enabled: true
# 开启积极懒加载
aggressive-lazy-loading: false
backend/ruoyi-admin/src/main/resources/application-prod.yml
+9 -9
View File
@@ -5,7 +5,7 @@ spring.servlet.multipart.location: /ruoyi/server/temp
spring.boot.admin.client:
# 增加客户端开关
enabled: true
url: http://localhost:9090/admin
url: http://47.121.125.41:9090/admin
instance:
service-host-type: IP
metadata:
@@ -22,7 +22,7 @@ snail-job:
# SnailJob 接入验证令牌 详见 script/sql/ry_job.sql `sj_group_config`表
token: "SJ_cKqBTPzCsWA3VyuCfFoccmuIEGXjr5KT"
server:
host: 127.0.0.1
host: 47.121.125.41
port: 17888
# 命名空间UUID 详见 script/sql/ry_job.sql `sj_namespace`表`unique_id`字段
namespace: ${spring.profiles.active}
@@ -54,7 +54,7 @@ spring:
# rewriteBatchedStatements=true 批处理优化 大幅提升批量插入更新删除性能(对数据库有性能损耗 使用批量操作应考虑性能问题)
url: jdbc:mysql://47.99.164.66:3306/hzdyjs_xg?useUnicode=true&characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&useSSL=true&serverTimezone=GMT%2B8&autoReconnect=true&rewriteBatchedStatements=true&allowPublicKeyRetrieval=true&nullCatalogMeansCurrent=true
username: root
password: 'hn02le.34lkdLKD'
password: hn02le.34lkdLKD
# # 从库数据源
# slave:
# lazy: true
@@ -83,7 +83,7 @@ spring:
# password: root
hikari:
# 最大连接池数量
maxPoolSize: 20
maxPoolSize: 30
# 最小空闲线程数量
minIdle: 10
# 配置获取连接等待超时的时间
@@ -101,13 +101,13 @@ spring:
spring.data:
redis:
# 地址
host: localhost
host: 47.99.164.66
# 端口，默认为6379
port: 6379
port: 16379
# 数据库索引
database: 0
database: 3
# redis 密码必须配置
password: ruoyi123
password: Hzdyjs@123456
# 连接超时时间
timeout: 10s
# 是否开启ssl
@@ -312,4 +312,4 @@ system:
# - 对于内存充足的环境，可以适当增加 max-cache-size-bytes
# - 对于频繁访问的小文件，可以增加 max-cache-size
# - 对于大文件较多的环境，可以调整 max-single-file-size
# - 对于访问频率较低的环境，可以适当减少 expire-time-ms
# - 对于访问频率较低的环境，可以适当减少 expire-time-ms
backend/ruoyi-extend/ruoyi-monitor-admin/src/main/resources/application.yml
+1 -1
View File
@@ -38,7 +38,7 @@ spring.boot.admin.client:
# 增加客户端开关
enabled: true
# 设置 Spring Boot Admin Server 地址
url: http://localhost:9090/admin
url: http://127.0.0.1:9090/admin
instance:
service-host-type: IP
metadata:
backend/ruoyi-extend/ruoyi-snailjob-server/src/main/resources/application-prod.yml
+3 -3
View File
@@ -2,9 +2,9 @@ spring:
datasource:
type: com.zaxxer.hikari.HikariDataSource
driver-class-name: com.mysql.cj.jdbc.Driver
url: jdbc:mysql://localhost:3306/ry-vue?useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai&allowPublicKeyRetrieval=true
url: jdbc:mysql://47.99.164.66:3306/hzdyjs_xg?useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai&allowPublicKeyRetrieval=true
username: root
password: root
password: hn02le.34lkdLKD
hikari:
connection-timeout: 30000
validation-timeout: 5000
@@ -30,7 +30,7 @@ snail-job:
spring.boot.admin.client:
# 增加客户端开关
enabled: true
url: http://localhost:9090/admin
url: http://47.121.125.41:9090/admin
instance:
service-host-type: IP
metadata:
backend/ruoyi-modules/pom.xml
+2 -1
View File
@@ -15,13 +15,14 @@
<module>ruoyi-demo</module>
<module>ruoyi-workflow</module>
<module>ruoyi-xg</module>
<module>ruoyi-xg-xx</module>
<!-- <module>ruoyi-xg-xx</module> -->
<module>ruoyi-zsjy</module>
<module>ruoyi-hq</module>
<module>ruoyi-aqbw</module>
<module>ruoyi-cw</module>
<module>ruoyi-rs</module>
<module>ruoyi-xljk</module>
<module>ruoyi-jcbt</module>
<!-- <module>ruoyi-stgl</module> -->
</modules>
backend/ruoyi-modules/ruoyi-cw/src/main/java/org/dromara/cw/service/impl/CwApprovalRecordServiceImpl.java
+72 -27
View File
@@ -36,6 +36,8 @@ import org.dromara.system.domain.bo.SysDeptBo;
import java.util.*;
import java.util.stream.Collectors;
import org.dromara.common.core.utils.SpringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
/**
* 审批记录Service业务层处理
@@ -54,6 +56,9 @@ public class CwApprovalRecordServiceImpl implements ICwApprovalRecordService {
private final ISysUserService sysUserService;
private final ISysDeptService sysDeptService;
@Autowired
private JdbcTemplate jdbcTemplate;
/**
* 根据主键查询审批记录
*/
@@ -1119,51 +1124,91 @@ public class CwApprovalRecordServiceImpl implements ICwApprovalRecordService {
return checkApprovalPermission(applicationId, "dept_approve");
}
/**
/**
* 获取可选审批人列表（院领导）
* 修改为基于权限角色查找：查找具有cw:approval:leader权限的用户
*/
@Override
public List<Map<String, Object>> getAvailableApprovers(Long applicationId) {
log.info("开始查询院领导审批人列表，applicationId: {}", applicationId);
log.info("开始查询院领导审批人列表（基于权限角色），applicationId: {}", applicationId);
List<Map<String, Object>> approvers = new ArrayList<>();
try {
// 1. 查询部门名称包含"院领导"的部门
SysDeptBo deptBo = new SysDeptBo();
deptBo.setDeptName("院领导"); // 设置查询条件
List<SysDeptVo> leaderDepts = sysDeptService.selectDeptList(deptBo);
// 使用原生SQL查询具有cw:approval:leader权限的用户
String sql = """
SELECT DISTINCT
u.user_id,
u.user_name,
u.nick_name,
COALESCE(d.dept_name, '未分配部门') as dept_name,
COALESCE(d.dept_id, 0) as dept_id
FROM sys_user u
LEFT JOIN sys_dept d ON u.dept_id = d.dept_id
INNER JOIN sys_user_role ur ON u.user_id = ur.user_id
INNER JOIN sys_role r ON ur.role_id = r.role_id
INNER JOIN sys_role_menu rm ON r.role_id = rm.role_id
INNER JOIN sys_menu m ON rm.menu_id = m.menu_id
WHERE m.perms = 'cw:approval:leader'
AND u.status = '0'
AND u.del_flag = '0'
AND r.status = '0'
ORDER BY u.user_name
""";
log.info("找到院领导部门数量: {}", leaderDepts.size());
for (SysDeptVo dept : leaderDepts) {
log.info("院领导部门: ID={}, 名称={}", dept.getDeptId(), dept.getDeptName());
log.info("执行权限查询SQL查找具有cw:approval:leader权限的用户");
// 执行SQL查询
List<Map<String, Object>> results = jdbcTemplate.queryForList(sql);
log.info("SQL查询结果：找到 {} 个具有院领导审批权限的用户", results.size());
// 转换查询结果为返回格式
for (Map<String, Object> row : results) {
Map<String, Object> approver = new HashMap<>();
approver.put("userId", row.get("user_id"));
approver.put("userName", row.get("user_name"));
approver.put("nickName", row.get("nick_name"));
approver.put("deptName", row.get("dept_name"));
approver.put("deptId", row.get("dept_id"));
approvers.add(approver);
log.info("添加院领导审批人: userId={}, userName={}, nickName={}, deptName={}",
row.get("user_id"), row.get("user_name"), row.get("nick_name"), row.get("dept_name"));
}
// 2. 查询院领导部门下的所有用户
for (SysDeptVo dept : leaderDepts) {
List<SysUserVo> users = sysUserService.selectUserListByDept(dept.getDeptId());
// 如果基于权限查询没有找到用户，使用原有的部门查询作为备选方案
if (approvers.isEmpty()) {
log.warn("基于权限查询未找到院领导，尝试使用部门查询作为备选方案");
log.info("部门[{}]下的用户数量: {}", dept.getDeptName(), users.size());
SysDeptBo deptBo = new SysDeptBo();
deptBo.setDeptName("院领导");
List<SysDeptVo> leaderDepts = sysDeptService.selectDeptList(deptBo);
// 3. 将用户信息转换为Map格式
for (SysUserVo user : users) {
// 只返回状态正常的用户
if ("0".equals(user.getStatus())) {
Map<String, Object> approver = new HashMap<>();
approver.put("userId", user.getUserId());
approver.put("userName", user.getUserName());
approver.put("nickName", user.getNickName());
approver.put("deptName", dept.getDeptName());
approver.put("deptId", dept.getDeptId());
approvers.add(approver);
log.info("备选方案：找到院领导部门数量: {}", leaderDepts.size());
log.info("添加院领导审批人: userId={}, userName={}, nickName={}",
user.getUserId(), user.getUserName(), user.getNickName());
for (SysDeptVo dept : leaderDepts) {
List<SysUserVo> users = sysUserService.selectUserListByDept(dept.getDeptId());
log.info("备选方案：部门[{}]下的用户数量: {}", dept.getDeptName(), users.size());
for (SysUserVo user : users) {
if ("0".equals(user.getStatus())) {
Map<String, Object> approver = new HashMap<>();
approver.put("userId", user.getUserId());
approver.put("userName", user.getUserName());
approver.put("nickName", user.getNickName());
approver.put("deptName", dept.getDeptName());
approver.put("deptId", dept.getDeptId());
approvers.add(approver);
log.info("备选方案：添加院领导审批人: userId={}, userName={}, nickName={}",
user.getUserId(), user.getUserName(), user.getNickName());
}
}
}
}
log.info("查询院领导审批人完成，共找到 {} 个院领导", approvers.size());
log.info("查询院领导审批人完成，共找到 {} 个院领导（权限验证+部门备选）", approvers.size());
} catch (Exception e) {
log.error("查询院领导审批人失败：{}", e.getMessage(), e);
backend/ruoyi-modules/ruoyi-cw/src/main/java/org/dromara/cw/service/impl/CwProjectApplicationServiceImpl.java
+18 -2
View File
@@ -86,13 +86,29 @@ public class CwProjectApplicationServiceImpl implements ICwProjectApplicationSer
log.info("✅ [统计页面-项目清单] 查询完成");
log.info("📊 [统计页面-项目清单] 查询结果: 总数={}, 当前页记录数={}", result.getTotal(), result.getRecords().size());
// 🔧 为每个项目补充绩效指标数据（修复统计页面详情缺少绩效指标的问题）
if (!result.getRecords().isEmpty()) {
log.info("🔄 [统计页面-项目清单] 开始补充绩效指标数据...");
for (CwProjectApplicationVo record : result.getRecords()) {
try {
List<CwPerformanceIndicatorVo> performanceIndicators = performanceIndicatorService.queryByApplicationId(record.getId());
record.setPerformanceIndicators(performanceIndicators);
log.debug(" ✅ 项目ID: {} 绩效指标数量: {}", record.getId(), performanceIndicators.size());
} catch (Exception e) {
log.error(" ❌ 获取项目ID: {} 的绩效指标数据失败: {}", record.getId(), e.getMessage());
// 设置空列表，避免前端报错
record.setPerformanceIndicators(new ArrayList<>());
}
}
log.info("✅ [统计页面-项目清单] 绩效指标数据补充完成");
log.info("📝 [统计页面-项目清单] 前3条数据示例:");
for (int i = 0; i < Math.min(result.getRecords().size(), 3); i++) {
CwProjectApplicationVo record = result.getRecords().get(i);
log.info(" {}. ID: {}, 申报编号: {}, 项目名称: {}, 状态: {}, 申报人: {}, 部门: {}",
int indicatorCount = record.getPerformanceIndicators() != null ? record.getPerformanceIndicators().size() : 0;
log.info(" {}. ID: {}, 申报编号: {}, 项目名称: {}, 状态: {}, 申报人: {}, 部门: {}, 绩效指标数: {}",
i + 1, record.getId(), record.getApplicationNo(), record.getProjectName(),
record.getApprovalStatus(), record.getApplicantName(), record.getDepartmentName());
record.getApprovalStatus(), record.getApplicantName(), record.getDepartmentName(), indicatorCount);
}
} else {
log.warn("⚠️ [统计页面-项目清单] 查询结果为空！");
backend/ruoyi-modules/ruoyi-xg-xx/pom.xml → backend/ruoyi-modules/ruoyi-jcbt/pom.xml
+9 -4
View File
@@ -1,7 +1,6 @@
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
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">
<parent>
<artifactId>ruoyi-modules</artifactId>
<groupId>org.dromara</groupId>
@@ -9,9 +8,9 @@
</parent>
<modelVersion>4.0.0</modelVersion>
<artifactId>ruoyi-xg-xx</artifactId>
<artifactId>ruoyi-jcbt</artifactId>
<description>
学工管理信息系统模块
奖惩补贴管理模块
</description>
<dependencies>
@@ -105,6 +104,12 @@
<artifactId>ruoyi-workflow</artifactId>
</dependency>
<!-- 学工管理模块 -->
<dependency>
<groupId>org.dromara</groupId>
<artifactId>ruoyi-xg</artifactId>
</dependency>
</dependencies>
</project>
backend/ruoyi-modules/ruoyi-jcbt/src/main/java/org/dromara/jcbt/RuoyiJcbtApplication.java
+19
View File
@@ -0,0 +1,19 @@
package org.dromara.jcbt;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
/**
* 奖惩补贴管理模块启动程序
*
* @author ruoyi
*/
@SpringBootApplication
public class RuoyiJcbtApplication {
public static void main(String[] args) {
SpringApplication.run(RuoyiJcbtApplication.class, args);
System.out.println("(♥◠‿◠)ﾉﾞ 奖惩补贴管理模块启动成功 ლ(´ڡ`ლ)ﾞ");
}
}
backend/ruoyi-admin/table_structures.txt → backend/ruoyi-modules/ruoyi-jcbt/src/main/java/org/dromara/jcbt/controller/.gitkeep
View File
File renamed without changes.
backend/ruoyi-modules/ruoyi-jcbt/src/main/java/org/dromara/jcbt/controller/JcbtPovertyApplicationController.java
+335
View File
@@ -0,0 +1,335 @@
package org.dromara.jcbt.controller;
import cn.dev33.satoken.annotation.SaCheckPermission;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.Parameter;
import io.swagger.v3.oas.annotations.tags.Tag;
import jakarta.servlet.http.HttpServletResponse;
import jakarta.validation.constraints.NotEmpty;
import jakarta.validation.constraints.NotNull;
import lombok.extern.slf4j.Slf4j;
import org.dromara.common.core.domain.R;
import org.dromara.common.core.validate.AddGroup;
import org.dromara.common.core.validate.EditGroup;
import org.dromara.common.excel.utils.ExcelUtil;
import org.dromara.common.idempotent.annotation.RepeatSubmit;
import org.dromara.common.log.annotation.Log;
import org.dromara.common.log.enums.BusinessType;
import org.dromara.common.mybatis.core.page.PageQuery;
import org.dromara.common.mybatis.core.page.TableDataInfo;
import org.dromara.common.satoken.utils.LoginHelper;
import org.dromara.common.web.core.BaseController;
import org.dromara.jcbt.domain.bo.AuditRequestBo;
import org.dromara.jcbt.domain.bo.JcbtPovertyApplicationBo;
import org.dromara.jcbt.domain.vo.JcbtPovertyApplicationVo;
import org.dromara.jcbt.service.IJcbtPovertyApplicationService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
import java.util.List;
import java.util.Map;
import java.util.HashMap;
/**
* 贫困生认定申请管理
*
* @author ruoyi
* @date 2025-08-09
*/
@Slf4j
@Validated
@Tag(name = "贫困生认定申请管理", description = "贫困生认定申请管理Controller")
@RestController
@RequestMapping("/jcbt/povertyApplication")
public class JcbtPovertyApplicationController extends BaseController {
@Autowired
private IJcbtPovertyApplicationService povertyApplicationService;
// ========== 基础管理接口（6个） ==========
/**
* 查询贫困生认定申请列表
*/
@SaCheckPermission("jcbt:povertyApplication:list")
@GetMapping("/list")
@Operation(summary = "查询贫困生认定申请列表")
public TableDataInfo<JcbtPovertyApplicationVo> list(JcbtPovertyApplicationBo bo, PageQuery pageQuery) {
return povertyApplicationService.queryPageList(bo, pageQuery);
}
/**
* 获取贫困生认定申请详细信息
*/
@SaCheckPermission("jcbt:povertyApplication:query")
@GetMapping("/{id}")
@Operation(summary = "获取贫困生认定申请详细信息")
public R<JcbtPovertyApplicationVo> getInfo(@Parameter(description = "主键") @PathVariable Long id) {
return R.ok(povertyApplicationService.queryById(id));
}
/**
* 新增贫困生认定申请
*/
@SaCheckPermission("jcbt:povertyApplication:add")
@Log(title = "贫困生认定申请", businessType = BusinessType.INSERT)
@RepeatSubmit()
@PostMapping
@Operation(summary = "新增贫困生认定申请")
public R<Long> add(@Parameter(description = "贫困生认定申请") @Validated(AddGroup.class) @RequestBody JcbtPovertyApplicationBo bo) {
boolean success = povertyApplicationService.insertByBo(bo);
if (success) {
return R.ok(bo.getId()); // 返回新创建的申请ID
} else {
return R.fail("新增失败");
}
}
/**
* 修改贫困生认定申请
*/
@SaCheckPermission("jcbt:povertyApplication:edit")
@Log(title = "贫困生认定申请", businessType = BusinessType.UPDATE)
@RepeatSubmit()
@PutMapping
@Operation(summary = "修改贫困生认定申请")
public R<Void> edit(@Parameter(description = "贫困生认定申请") @Validated(EditGroup.class) @RequestBody JcbtPovertyApplicationBo bo) {
return toAjax(povertyApplicationService.updateByBo(bo));
}
/**
* 删除贫困生认定申请
*/
@SaCheckPermission("jcbt:povertyApplication:remove")
@Log(title = "删除贫困生认定申请", businessType = BusinessType.DELETE)
@DeleteMapping("/{ids}")
@Operation(summary = "删除贫困生认定申请")
public R<Void> remove(@Parameter(description = "主键集合") @NotEmpty(message = "主键不能为空") @PathVariable Long[] ids) {
return toAjax(povertyApplicationService.deleteWithValidByIds(List.of(ids), true));
}
/**
* 导出贫困生认定申请列表
*/
@SaCheckPermission("jcbt:povertyApplication:export")
@Log(title = "导出贫困生认定申请", businessType = BusinessType.EXPORT)
@PostMapping("/export")
@Operation(summary = "导出贫困生认定申请列表")
public void export(JcbtPovertyApplicationBo bo, HttpServletResponse response) {
List<JcbtPovertyApplicationVo> list = povertyApplicationService.queryList(bo);
ExcelUtil.exportExcel(list, "贫困生认定申请", JcbtPovertyApplicationVo.class, response);
}
/**
* 导出我的申请列表（班主任导出自己提交的申请）
*/
@SaCheckPermission("jcbt:povertyApplication:myList")
@Log(title = "导出我的贫困生认定申请", businessType = BusinessType.EXPORT)
@PostMapping("/myExport")
@Operation(summary = "导出我的申请列表")
public void myExport(JcbtPovertyApplicationBo bo, HttpServletResponse response) {
Long teacherId = LoginHelper.getUserId();
List<JcbtPovertyApplicationVo> list = povertyApplicationService.queryListByTeacher(teacherId, bo);
ExcelUtil.exportExcel(list, "我的贫困生认定申请", JcbtPovertyApplicationVo.class, response);
}
// ========== 业务功能接口（4个） ==========
/**
* 查询我的申请列表（班主任查看自己提交的申请）
*/
@SaCheckPermission("jcbt:povertyApplication:myList")
@GetMapping("/myList")
@Operation(summary = "查询我的申请列表")
public TableDataInfo<JcbtPovertyApplicationVo> myList(JcbtPovertyApplicationBo bo, PageQuery pageQuery) {
Long teacherId = LoginHelper.getUserId();
return povertyApplicationService.queryPageListByTeacher(teacherId, bo, pageQuery);
}
/**
* 查询待审核申请列表（审核人员使用）
*/
@SaCheckPermission("jcbt:povertyApplication:pendingList")
@GetMapping("/pendingList")
@Operation(summary = "查询待审核申请列表")
public TableDataInfo<JcbtPovertyApplicationVo> pendingList(JcbtPovertyApplicationBo bo, PageQuery pageQuery) {
return povertyApplicationService.queryPendingPageList(bo, pageQuery);
}
/**
* 提交申请
*/
@SaCheckPermission("jcbt:povertyApplication:submit")
@Log(title = "提交贫困生认定申请", businessType = BusinessType.UPDATE)
@RepeatSubmit()
@PutMapping("/submit/{id}")
@Operation(summary = "提交申请")
public R<Void> submit(@Parameter(description = "申请ID") @PathVariable Long id) {
return toAjax(povertyApplicationService.submitApplication(id));
}
/**
* 撤销申请
*/
@SaCheckPermission("jcbt:povertyApplication:cancel")
@Log(title = "撤销贫困生认定申请", businessType = BusinessType.UPDATE)
@RepeatSubmit()
@PutMapping("/cancel/{id}")
@Operation(summary = "撤销申请")
public R<Void> cancel(@Parameter(description = "申请ID") @PathVariable Long id) {
return toAjax(povertyApplicationService.cancelApplication(id));
}
// ========== 辅助功能接口（6个） ==========
/**
* 根据申请编号获取申请信息
*/
@SaCheckPermission("jcbt:povertyApplication:query")
@GetMapping("/byApplicationNo/{applicationNo}")
@Operation(summary = "根据申请编号获取申请信息")
public R<JcbtPovertyApplicationVo> getInfoByApplicationNo(@Parameter(description = "申请编号") @PathVariable String applicationNo) {
return R.ok(povertyApplicationService.queryByApplicationNo(applicationNo));
}
/**
* 保存草稿
*/
@SaCheckPermission("jcbt:povertyApplication:saveDraft")
@Log(title = "保存贫困生认定申请草稿", businessType = BusinessType.UPDATE)
@RepeatSubmit()
@PostMapping("/saveDraft")
@Operation(summary = "保存草稿")
public R<Void> saveDraft(@Parameter(description = "贫困生认定申请") @RequestBody JcbtPovertyApplicationBo bo) {
return toAjax(povertyApplicationService.saveDraft(bo));
}
/**
* 审核通过
*/
@SaCheckPermission("jcbt:povertyApplication:approve")
@Log(title = "审核通过贫困生认定申请", businessType = BusinessType.UPDATE)
@RepeatSubmit()
@PutMapping("/approve")
@Operation(summary = "审核通过")
public R<Void> approve(@Parameter(description = "审核请求") @Validated @RequestBody AuditRequestBo auditRequest) {
return toAjax(povertyApplicationService.approveApplication(auditRequest.getId(), auditRequest.getAuditOpinion()));
}
/**
* 审核驳回
*/
@SaCheckPermission("jcbt:povertyApplication:reject")
@Log(title = "审核驳回贫困生认定申请", businessType = BusinessType.UPDATE)
@RepeatSubmit()
@PutMapping("/reject")
@Operation(summary = "审核驳回")
public R<Void> reject(@Parameter(description = "审核请求") @Validated @RequestBody AuditRequestBo auditRequest) {
return toAjax(povertyApplicationService.rejectApplication(auditRequest.getId(), auditRequest.getAuditOpinion()));
}
/**
* 生成申请编号
*/
@SaCheckPermission("jcbt:povertyApplication:add")
@GetMapping("/generateApplicationNo")
@Operation(summary = "生成申请编号")
public R<String> generateApplicationNo() {
return R.ok(povertyApplicationService.generateApplicationNo());
}
/**
* 检查学生申请是否重复
*/
@SaCheckPermission("jcbt:povertyApplication:add")
@GetMapping("/checkDuplicate")
@Operation(summary = "检查学生申请是否重复")
public R<Boolean> checkDuplicate(@Parameter(description = "学生ID") @RequestParam Long studentId,
@Parameter(description = "学年") @RequestParam String academicYear,
@Parameter(description = "认定类型ID") @RequestParam Long recognitionTypeId,
@Parameter(description = "排除的申请ID") @RequestParam(required = false) Long excludeId) {
boolean exists = povertyApplicationService.checkStudentApplicationExists(studentId, academicYear, recognitionTypeId, excludeId);
return R.ok(exists);
}
// ========== 统计分析接口（2个） ==========
/**
* 获取申请统计信息
*/
@SaCheckPermission("jcbt:povertyApplication:statistics")
@GetMapping("/statistics")
@Operation(summary = "获取申请统计信息")
public R<Map<String, Object>> statistics(@Parameter(description = "班主任ID") @RequestParam(required = false) Long teacherId) {
List<JcbtPovertyApplicationVo> statisticsList = povertyApplicationService.getApplicationStatistics(teacherId);
// 转换为前端需要的格式
Map<String, Object> result = new HashMap<>();
Map<String, Integer> statusCount = new HashMap<>();
int totalCount = 0;
for (JcbtPovertyApplicationVo stat : statisticsList) {
String status = stat.getStatus();
Integer count = stat.getId().intValue(); // 统计查询中，id字段存储的是count值
statusCount.put(status, count);
totalCount += count;
}
result.put("statusCount", statusCount);
result.put("totalCount", totalCount);
return R.ok(result);
}
/**
* 获取我的申请统计信息（班主任使用）
*/
@SaCheckPermission("jcbt:povertyApplication:myList")
@GetMapping("/myStatistics")
@Operation(summary = "获取我的申请统计信息")
public R<Map<String, Object>> myStatistics() {
Long teacherId = LoginHelper.getUserId();
List<JcbtPovertyApplicationVo> statisticsList = povertyApplicationService.getApplicationStatistics(teacherId);
// 转换为前端需要的格式
Map<String, Object> result = new HashMap<>();
Map<String, Integer> statusCount = new HashMap<>();
int totalCount = 0;
for (JcbtPovertyApplicationVo stat : statisticsList) {
String status = stat.getStatus();
Integer count = stat.getId().intValue(); // 统计查询中，id字段存储的是count值
statusCount.put(status, count);
totalCount += count;
}
result.put("statusCount", statusCount);
result.put("totalCount", totalCount);
return R.ok(result);
}
/**
* 获取当前用户班级信息
*/
@Operation(summary = "获取当前用户班级信息")
@SaCheckPermission("jcbt:povertyApplication:list")
@GetMapping("/user/classes")
public R<List<Map<String, Object>>> getCurrentUserClasses() {
Long currentUserId = LoginHelper.getLoginUser().getUserId();
List<Map<String, Object>> classes = povertyApplicationService.getCurrentUserClasses(currentUserId);
return R.ok(classes);
}
/**
* 获取班级学生列表
*/
@Operation(summary = "获取班级学生列表")
@Parameter(name = "classId", description = "班级ID", required = true)
@SaCheckPermission("jcbt:povertyApplication:list")
@GetMapping("/class/{classId}/students")
public R<List<Map<String, Object>>> getClassStudents(@PathVariable Long classId) {
List<Map<String, Object>> students = povertyApplicationService.getClassStudents(classId);
return R.ok(students);
}
}
backend/ruoyi-modules/ruoyi-jcbt/src/main/java/org/dromara/jcbt/controller/JcbtPovertyApplicationReviewController.java
+263
View File
@@ -0,0 +1,263 @@
package org.dromara.jcbt.controller;
import cn.dev33.satoken.annotation.SaCheckPermission;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.Parameter;
import io.swagger.v3.oas.annotations.tags.Tag;
import jakarta.servlet.http.HttpServletResponse;
import jakarta.validation.constraints.NotNull;
import lombok.extern.slf4j.Slf4j;
import org.dromara.common.core.domain.R;
import org.dromara.common.core.utils.StringUtils;
import org.dromara.common.excel.utils.ExcelUtil;
import org.dromara.common.log.annotation.Log;
import org.dromara.common.log.enums.BusinessType;
import org.dromara.common.mybatis.core.page.PageQuery;
import org.dromara.common.mybatis.core.page.TableDataInfo;
import org.dromara.common.web.core.BaseController;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import org.dromara.jcbt.domain.bo.AuditRequestBo;
import org.dromara.jcbt.domain.bo.JcbtPovertyApplicationBo;
import org.dromara.jcbt.domain.vo.JcbtPovertyApplicationVo;
import org.dromara.jcbt.enums.ApplicationStatusEnum;
import org.dromara.jcbt.service.IJcbtPovertyApplicationService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.HashMap;
/**
* 贫困生认定申请审核管理
*
* @author ruoyi
* @date 2025-08-09
*/
@Slf4j
@Validated
@Tag(name = "贫困生认定申请审核管理", description = "专门为审核人员提供的审核功能")
@RestController
@RequestMapping("/jcbt/povertyApplicationReview")
public class JcbtPovertyApplicationReviewController extends BaseController {
@Autowired
private IJcbtPovertyApplicationService povertyApplicationService;
// ========== 审核管理接口 ==========
/**
* 查询待审核申请列表
*/
@SaCheckPermission("jcbt:povertyApplication:query")
@GetMapping("/pendingList")
@Operation(summary = "查询待审核申请列表")
public TableDataInfo<JcbtPovertyApplicationVo> pendingList(JcbtPovertyApplicationBo bo, PageQuery pageQuery) {
return povertyApplicationService.queryPendingPageList(bo, pageQuery);
}
/**
* 查询所有申请列表（支持多状态筛选）
*/
@SaCheckPermission("jcbt:povertyApplication:query")
@GetMapping("/list")
@Operation(summary = "查询所有申请列表")
public TableDataInfo<JcbtPovertyApplicationVo> list(JcbtPovertyApplicationBo bo, PageQuery pageQuery) {
// 审核模块不显示草稿状态的申请
if (StringUtils.isBlank(bo.getStatus())) {
// 如果没有指定状态，则查询除草稿外的所有状态
bo.setStatusList(Arrays.asList(
ApplicationStatusEnum.SUBMITTED.getCode(),
ApplicationStatusEnum.WAITING.getCode(),
ApplicationStatusEnum.COMPLETE.getCode(),
ApplicationStatusEnum.REJECTED.getCode(),
ApplicationStatusEnum.CANCELED.getCode()
));
} else if (ApplicationStatusEnum.DRAFT.getCode().equals(bo.getStatus())) {
// 如果明确查询草稿状态，审核模块不允许，返回空列表
return TableDataInfo.build(new Page<>());
}
return povertyApplicationService.queryPageList(bo, pageQuery);
}
/**
* 获取申请详情
*/
@SaCheckPermission("jcbt:povertyApplication:detail")
@GetMapping("/{id}")
@Operation(summary = "获取申请详情")
public R<JcbtPovertyApplicationVo> getInfo(@Parameter(description = "申请ID") @PathVariable Long id) {
return R.ok(povertyApplicationService.queryById(id));
}
/**
* 审核通过
*/
@SaCheckPermission("jcbt:povertyApplication:approve")
@Log(title = "审核通过贫困生认定申请", businessType = BusinessType.UPDATE)
@PutMapping("/approve")
@Operation(summary = "审核通过")
public R<Void> approve(@Parameter(description = "审核请求") @Validated @RequestBody AuditRequestBo auditRequest) {
return toAjax(povertyApplicationService.approveApplication(auditRequest.getId(), auditRequest.getAuditOpinion()));
}
/**
* 审核驳回
*/
@SaCheckPermission("jcbt:povertyApplication:reject")
@Log(title = "审核驳回贫困生认定申请", businessType = BusinessType.UPDATE)
@PutMapping("/reject")
@Operation(summary = "审核驳回")
public R<Void> reject(@Parameter(description = "审核请求") @Validated @RequestBody AuditRequestBo auditRequest) {
return toAjax(povertyApplicationService.rejectApplication(auditRequest.getId(), auditRequest.getAuditOpinion()));
}
/**
* 打回修改
*/
@SaCheckPermission("jcbt:povertyApplication:reject")
@Log(title = "打回修改贫困生认定申请", businessType = BusinessType.UPDATE)
@PutMapping("/returnToDraft")
@Operation(summary = "打回修改")
public R<Void> returnToDraft(@Parameter(description = "审核请求") @Validated @RequestBody AuditRequestBo auditRequest) {
return toAjax(povertyApplicationService.returnToDraft(auditRequest.getId(), auditRequest.getAuditOpinion()));
}
/**
* 批量审核通过
*/
@SaCheckPermission("jcbt:povertyApplication:approve")
@Log(title = "批量审核通过贫困生认定申请", businessType = BusinessType.UPDATE)
@PutMapping("/batchApprove")
@Operation(summary = "批量审核通过")
public R<Void> batchApprove(@Parameter(description = "申请ID列表") @RequestBody List<Long> ids,
@Parameter(description = "审核意见") @RequestParam(required = false) String auditOpinion) {
return toAjax(povertyApplicationService.batchApproveApplications(ids, auditOpinion));
}
/**
* 批量审核驳回
*/
@SaCheckPermission("jcbt:povertyApplication:reject")
@Log(title = "批量审核驳回贫困生认定申请", businessType = BusinessType.UPDATE)
@PutMapping("/batchReject")
@Operation(summary = "批量审核驳回")
public R<Void> batchReject(@Parameter(description = "申请ID列表") @RequestBody List<Long> ids,
@Parameter(description = "审核意见") @RequestParam String auditOpinion) {
return toAjax(povertyApplicationService.batchRejectApplications(ids, auditOpinion));
}
// ========== 统计分析接口 ==========
/**
* 获取审核统计信息
*/
@SaCheckPermission("jcbt:povertyApplication:statistics")
@GetMapping("/statistics")
@Operation(summary = "获取审核统计信息")
public R<Map<String, Object>> statistics(@Parameter(description = "学年") @RequestParam(required = false) String academicYear,
@Parameter(description = "学院ID") @RequestParam(required = false) Long collegeId) {
List<JcbtPovertyApplicationVo> statisticsList = povertyApplicationService.getReviewStatistics(academicYear, collegeId);
// 转换为前端需要的格式
Map<String, Object> result = new HashMap<>();
Map<String, Integer> statusCount = new HashMap<>();
int totalCount = 0;
for (JcbtPovertyApplicationVo stat : statisticsList) {
String status = stat.getStatus();
Integer count = stat.getId().intValue(); // 统计查询中，id字段存储的是count值
statusCount.put(status, count);
totalCount += count;
}
result.put("statusCount", statusCount);
result.put("totalCount", totalCount);
return R.ok(result);
}
/**
* 获取审核工作量统计
*/
@SaCheckPermission("jcbt:povertyApplication:statistics")
@GetMapping("/workloadStatistics")
@Operation(summary = "获取审核工作量统计")
public R<List<Map<String, Object>>> workloadStatistics(@Parameter(description = "开始时间") @RequestParam(required = false) String startTime,
@Parameter(description = "结束时间") @RequestParam(required = false) String endTime) {
List<Map<String, Object>> workloadStats = povertyApplicationService.getAuditorWorkloadStatistics(startTime, endTime);
return R.ok(workloadStats);
}
// ========== 导出功能 ==========
/**
* 导出申请数据
*/
@SaCheckPermission("jcbt:povertyApplication:export")
@Log(title = "导出贫困生认定申请数据", businessType = BusinessType.EXPORT)
@PostMapping("/export")
@Operation(summary = "导出申请数据")
public void export(JcbtPovertyApplicationBo bo, HttpServletResponse response) {
List<JcbtPovertyApplicationVo> list = povertyApplicationService.queryList(bo);
ExcelUtil.exportExcel(list, "贫困生认定申请数据", JcbtPovertyApplicationVo.class, response);
}
/**
* 导出待审核申请数据
*/
@SaCheckPermission("jcbt:povertyApplication:export")
@Log(title = "导出待审核贫困生认定申请数据", businessType = BusinessType.EXPORT)
@PostMapping("/exportPending")
@Operation(summary = "导出待审核申请数据")
public void exportPending(JcbtPovertyApplicationBo bo, HttpServletResponse response) {
// 设置为待审核状态
bo.setStatus("SUBMITTED");
List<JcbtPovertyApplicationVo> list = povertyApplicationService.queryList(bo);
ExcelUtil.exportExcel(list, "待审核贫困生认定申请数据", JcbtPovertyApplicationVo.class, response);
}
// ========== 辅助功能 ==========
/**
* 获取申请附件预览信息
*/
@SaCheckPermission("jcbt:povertyApplication:detail")
@GetMapping("/{id}/attachments")
@Operation(summary = "获取申请附件预览信息")
public R<Map<String, Object>> getAttachments(@Parameter(description = "申请ID") @PathVariable Long id) {
JcbtPovertyApplicationVo application = povertyApplicationService.queryById(id);
if (application == null) {
return R.fail("申请不存在");
}
Map<String, Object> attachments = new HashMap<>();
// 申请表附件信息
String applicationFormUrl = application.getAttachApplicationFormUrl();
boolean hasApplicationForm = StringUtils.isNotBlank(applicationFormUrl);
attachments.put("applicationFormUrl", hasApplicationForm ? applicationFormUrl : null);
attachments.put("hasApplicationForm", hasApplicationForm);
// 调查表附件信息
String surveyFormUrl = application.getAttachSurveyFormUrl();
boolean hasSurveyForm = StringUtils.isNotBlank(surveyFormUrl);
attachments.put("surveyFormUrl", hasSurveyForm ? surveyFormUrl : null);
attachments.put("hasSurveyForm", hasSurveyForm);
return R.ok(attachments);
}
/**
* 获取审核历史记录
*/
@SaCheckPermission("jcbt:povertyApplication:detail")
@GetMapping("/{id}/history")
@Operation(summary = "获取审核历史记录")
public R<List<Map<String, Object>>> getAuditHistory(@Parameter(description = "申请ID") @PathVariable Long id) {
List<Map<String, Object>> history = povertyApplicationService.getApplicationAuditHistory(id);
return R.ok(history);
}
}
backend/ruoyi-modules/ruoyi-jcbt/src/main/java/org/dromara/jcbt/controller/JcbtScholarshipApplicationController.java
+417
View File
@@ -0,0 +1,417 @@
package org.dromara.jcbt.controller;
import cn.dev33.satoken.annotation.SaCheckPermission;
import org.dromara.common.core.domain.R;
import org.dromara.common.core.validate.AddGroup;
import org.dromara.common.core.validate.EditGroup;
import org.dromara.common.excel.utils.ExcelUtil;
import org.dromara.common.idempotent.annotation.RepeatSubmit;
import org.dromara.common.log.annotation.Log;
import org.dromara.common.log.enums.BusinessType;
import org.dromara.common.mybatis.core.page.PageQuery;
import org.dromara.common.mybatis.core.page.TableDataInfo;
import org.dromara.common.web.core.BaseController;
import org.dromara.jcbt.domain.bo.JcbtScholarshipApplicationBo;
import org.dromara.jcbt.domain.vo.JcbtScholarshipApplicationVo;
import org.dromara.jcbt.service.IJcbtScholarshipApplicationService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.MediaType;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.Parameter;
import io.swagger.v3.oas.annotations.tags.Tag;
import jakarta.servlet.http.HttpServletResponse;
import jakarta.validation.constraints.NotEmpty;
import jakarta.validation.constraints.NotNull;
import lombok.extern.slf4j.Slf4j;
import java.util.List;
import java.util.Map;
import java.util.HashMap;
/**
* 奖学金申请记录管理
*
* @author ruoyi
* @date 2025-01-01
*/
@Slf4j
@Validated
@Tag(name = "奖学金申请记录管理", description = "奖学金申请记录管理Controller")
@RestController
@RequestMapping("/jcbt/scholarshipApplication")
public class JcbtScholarshipApplicationController extends BaseController {
@Autowired
private IJcbtScholarshipApplicationService applicationService;
// ========== 基础管理接口（6个） ==========
/**
* 查询奖学金申请记录列表
*/
@SaCheckPermission("jcbt:scholarshipApplication:list")
@GetMapping("/list")
@Operation(summary = "查询奖学金申请记录列表")
public TableDataInfo<JcbtScholarshipApplicationVo> list(JcbtScholarshipApplicationBo bo, PageQuery pageQuery) {
return applicationService.queryPageList(bo, pageQuery);
}
/**
* 获取奖学金申请记录详细信息
*/
@SaCheckPermission("jcbt:scholarshipApplication:query")
@GetMapping("/{id}")
@Operation(summary = "获取奖学金申请记录详细信息")
public R<JcbtScholarshipApplicationVo> getInfo(@Parameter(description = "主键") @PathVariable Long id) {
return R.ok(applicationService.queryById(id));
}
/**
* 新增奖学金申请记录
*/
@SaCheckPermission("jcbt:scholarshipApplication:add")
@Log(title = "奖学金申请记录", businessType = BusinessType.INSERT)
@RepeatSubmit()
@PostMapping
@Operation(summary = "新增奖学金申请记录")
public R<Void> add(@Parameter(description = "奖学金申请记录") @Validated(AddGroup.class) @RequestBody JcbtScholarshipApplicationBo bo) {
return toAjax(applicationService.insertByBo(bo));
}
/**
* 修改奖学金申请记录
*/
@SaCheckPermission("jcbt:scholarshipApplication:edit")
@Log(title = "奖学金申请记录", businessType = BusinessType.UPDATE)
@RepeatSubmit()
@PutMapping
@Operation(summary = "修改奖学金申请记录")
public R<Void> edit(@Parameter(description = "奖学金申请记录") @Validated(EditGroup.class) @RequestBody JcbtScholarshipApplicationBo bo) {
log.info("🔍 [DEBUG] Controller.edit 开始执行");
log.info("🔍 [DEBUG] 接收到的BO对象: {}", bo);
log.info("🔍 [DEBUG] 关键字段检查:");
log.info(" - id: {}", bo.getId());
log.info(" - studentNo: {}", bo.getStudentNo());
log.info(" - studentName: {}", bo.getStudentName());
log.info(" - status: {}", bo.getStatus());
log.info(" - currentStatus: {}", bo.getCurrentStatus());
log.info(" - reviewComment: {}", bo.getReviewComment());
try {
boolean result = applicationService.updateByBo(bo);
log.info("🔍 [DEBUG] Service.updateByBo 执行结果: {}", result);
return toAjax(result);
} catch (Exception e) {
log.error("❌ [ERROR] Controller.edit 执行异常", e);
log.error("❌ [ERROR] 异常类型: {}", e.getClass().getSimpleName());
log.error("❌ [ERROR] 异常消息: {}", e.getMessage());
throw e;
}
}
/**
* 删除奖学金申请记录
*/
@SaCheckPermission("jcbt:scholarshipApplication:remove")
@Log(title = "奖学金申请记录", businessType = BusinessType.DELETE)
@DeleteMapping("/{ids}")
@Operation(summary = "删除奖学金申请记录")
public R<Void> remove(@Parameter(description = "主键串") @PathVariable Long[] ids) {
return toAjax(applicationService.deleteWithValidByIds(List.of(ids), true));
}
/**
* 获取可申请的奖学金类型列表
*/
@SaCheckPermission("jcbt:scholarshipApplication:available")
@GetMapping("/available")
@Operation(summary = "获取可申请的奖学金类型列表")
public R<List<Map<String, Object>>> getAvailableScholarshipTypes(@Parameter(description = "班级ID") @RequestParam Long classId,
@Parameter(description = "批次ID") @RequestParam Long batchId) {
return R.ok(applicationService.queryAvailableScholarshipTypes(classId, batchId));
}
// ========== 业务功能接口（4个） ==========
/**
* 查询我的申请记录（班主任）
*/
@SaCheckPermission("jcbt:scholarshipApplication:my")
@GetMapping("/my")
@Operation(summary = "查询我的申请记录")
public R<List<JcbtScholarshipApplicationVo>> getMyApplications(@Parameter(description = "申请人ID") @RequestParam Long applicantId,
@Parameter(description = "批次ID") @RequestParam(required = false) Long batchId) {
return R.ok(applicationService.queryApplicationsByApplicant(applicantId, batchId));
}
/**
* 查询待审核申请
*/
@SaCheckPermission("jcbt:scholarshipApplication:pending")
@GetMapping("/pending")
@Operation(summary = "查询待审核申请")
public R<List<JcbtScholarshipApplicationVo>> getPendingApplications(@Parameter(description = "审核人ID") @RequestParam(required = false) Long reviewerId,
@Parameter(description = "申请状态") @RequestParam(required = false) String status) {
return R.ok(applicationService.queryPendingApplications(reviewerId, status));
}
/**
* 检查学生申请资格
*/
@SaCheckPermission("jcbt:scholarshipApplication:check")
@GetMapping("/check")
@Operation(summary = "检查学生申请资格")
public R<Map<String, Object>> checkStudentEligibility(@Parameter(description = "学生ID") @RequestParam Long studentId,
@Parameter(description = "批次ID") @RequestParam Long batchId,
@Parameter(description = "奖学金类型ID") @RequestParam Long scholarshipTypeId) {
return R.ok(applicationService.checkStudentEligibility(studentId, batchId, scholarshipTypeId));
}
/**
* 批量审核申请
*/
@SaCheckPermission("jcbt:scholarshipApplication:approve")
@Log(title = "批量审核奖学金申请", businessType = BusinessType.UPDATE)
@PostMapping("/approve")
@Operation(summary = "批量审核申请")
public R<Void> batchApprove(@Parameter(description = "申请ID列表") @RequestBody @NotEmpty List<Long> applicationIds,
@Parameter(description = "审核状态") @RequestParam String status,
@Parameter(description = "审核人ID") @RequestParam Long reviewerId,
@Parameter(description = "审核人姓名") @RequestParam String reviewerName,
@Parameter(description = "审核意见") @RequestParam(required = false) String reviewComment) {
return toAjax(applicationService.batchReviewApplications(applicationIds, status, reviewerId, reviewerName, reviewComment));
}
// ========== 辅助功能接口（6个） ==========
/**
* 导出奖学金申请记录列表
*/
@SaCheckPermission("jcbt:schotlarshipApplication:expor")
@Log(title = "奖学金申请记录", businessType = BusinessType.EXPORT)
@PostMapping("/export")
@Operation(summary = "导出奖学金申请记录列表")
public void export(JcbtScholarshipApplicationBo bo, HttpServletResponse response) {
List<JcbtScholarshipApplicationVo> list = applicationService.queryList(bo);
ExcelUtil.exportExcel(list, "奖学金申请记录", JcbtScholarshipApplicationVo.class, response);
}
/**
* 导入奖学金申请记录
*/
@SaCheckPermission("jcbt:scholarshipApplication:import")
@Log(title = "奖学金申请记录", businessType = BusinessType.IMPORT)
@PostMapping(value = "/import", consumes = MediaType.MULTIPART_FORM_DATA_VALUE)
@Operation(summary = "导入奖学金申请记录")
public R<Void> importData(@Parameter(description = "Excel文件") @RequestPart("file") MultipartFile file) throws Exception {
List<JcbtScholarshipApplicationVo> list = ExcelUtil.importExcel(file.getInputStream(), JcbtScholarshipApplicationVo.class);
// 导入逻辑处理
for (JcbtScholarshipApplicationVo vo : list) {
JcbtScholarshipApplicationBo bo = new JcbtScholarshipApplicationBo();
// 这里需要实现VO到BO的转换逻辑
// BeanUtils.copyProperties(vo, bo);
applicationService.insertByBo(bo);
}
return R.ok();
}
/**
* 获取申请统计数据
*/
@SaCheckPermission("jcbt:scholarshipApplication:statistics")
@GetMapping("/statistics")
@Operation(summary = "获取申请统计数据")
public R<Map<String, Object>> getStatistics(@Parameter(description = "批次ID") @RequestParam(required = false) Long batchId,
@Parameter(description = "学院ID") @RequestParam(required = false) Long deptId) {
return R.ok(applicationService.getApplicationStatistics(batchId, deptId));
}
/**
* 班主任批量申请提交
*/
@SaCheckPermission("jcbt:scholarshipApplication:batch")
@Log(title = "班主任批量申请提交", businessType = BusinessType.INSERT)
@PostMapping("/batch")
@Operation(summary = "班主任批量申请提交")
public R<Void> batchSubmitByTeacher(@Parameter(description = "批次ID") @RequestParam Long batchId,
@Parameter(description = "奖学金类型ID") @RequestParam Long scholarshipTypeId,
@Parameter(description = "班级ID") @RequestParam Long classId,
@Parameter(description = "学生申请列表") @RequestBody @NotEmpty List<JcbtScholarshipApplicationBo> studentApplications) {
return toAjax(applicationService.batchSubmitApplicationsByTeacher(batchId, scholarshipTypeId, classId, studentApplications));
}
/**
* 提交申请
*/
@SaCheckPermission("jcbt:scholarshipApplication:submit")
@Log(title = "提交奖学金申请", businessType = BusinessType.UPDATE)
@PostMapping("/{id}/submit")
@Operation(summary = "提交申请")
public R<Void> submitApplication(@Parameter(description = "申请ID") @PathVariable @NotNull Long id) {
return toAjax(applicationService.submitApplication(id));
}
/**
* 撤回申请
*/
@SaCheckPermission("jcbt:scholarshipApplication:withdraw")
@Log(title = "撤回奖学金申请", businessType = BusinessType.UPDATE)
@PostMapping("/{id}/withdraw")
@Operation(summary = "撤回申请")
public R<Void> withdrawApplication(@Parameter(description = "申请ID") @PathVariable @NotNull Long id,
@Parameter(description = "撤回原因") @RequestParam(required = false) String reason) {
return toAjax(applicationService.withdrawApplication(id, reason));
}
// ========== 班级名额相关接口 ==========
/**
* 获取班级名额使用情况
*/
@SaCheckPermission("jcbt:scholarshipApplication:quota")
@GetMapping("/quota")
@Operation(summary = "获取班级名额使用情况")
public R<Map<String, Object>> getClassQuotaUsage(@Parameter(description = "班级ID") @RequestParam Long classId,
@Parameter(description = "批次ID") @RequestParam Long batchId) {
return R.ok(applicationService.getClassQuotaUsage(classId, batchId));
}
// ========== 班主任申请专用接口 ==========
/**
* 获取班主任所带班级信息
*/
@SaCheckPermission("jcbt:scholarshipApplication:classInfo")
@GetMapping("/classInfo")
@Operation(summary = "获取班主任所带班级信息")
public R<Map<String, Object>> getClassInfoByTeacher(@Parameter(description = "班主任ID") @RequestParam Long teacherId) {
return R.ok(applicationService.getClassInfoByTeacher(teacherId));
}
/**
* 获取班级学生列表（用于勾选）
*/
@SaCheckPermission("jcbt:scholarshipApplication:students")
@GetMapping("/students")
@Operation(summary = "获取班级学生列表")
public R<List<Map<String, Object>>> getClassStudents(@Parameter(description = "班级ID") @RequestParam Long classId) {
return R.ok(applicationService.getClassStudents(classId));
}
/**
* 根据批次获取可申请的奖学金类型
*/
@SaCheckPermission("jcbt:scholarshipApplication:scholarshipTypes")
@GetMapping("/scholarshipTypes")
@Operation(summary = "根据批次获取可申请的奖学金类型")
public R<List<Map<String, Object>>> getScholarshipTypesByBatch(@Parameter(description = "批次ID") @RequestParam Long batchId) {
return R.ok(applicationService.getScholarshipTypesByBatch(batchId));
}
/**
* 根据批次和班级获取带名额信息的奖学金类型（班主任专用）
*/
@SaCheckPermission("jcbt:scholarshipApplication:scholarshipTypes")
@GetMapping("/scholarshipTypesWithQuota")
@Operation(summary = "根据批次和班级获取带名额信息的奖学金类型")
public R<List<Map<String, Object>>> getScholarshipTypesWithQuota(
@Parameter(description = "批次ID") @RequestParam Long batchId,
@Parameter(description = "班级ID") @RequestParam Long classId) {
return R.ok(applicationService.getScholarshipTypesWithQuota(batchId, classId));
}
/**
* 确认选择班级（多班级时用户选择后调用）
*/
@SaCheckPermission("jcbt:scholarshipApplication:classInfo")
@PostMapping("/confirmClass")
@Operation(summary = "确认选择班级")
public R<Map<String, Object>> confirmClassSelection(@Parameter(description = "班主任ID") @RequestParam Long teacherId,
@Parameter(description = "班级ID") @RequestParam Long classId) {
return R.ok(applicationService.confirmClassSelection(teacherId, classId));
}
/**
* 测试接口：获取奖学金类型数据结构
*/
@SaCheckPermission("jcbt:scholarshipApplication:scholarshipTypes")
@GetMapping("/test/scholarshipTypesStructure")
@Operation(summary = "测试接口：获取奖学金类型数据结构")
public R<Map<String, Object>> testScholarshipTypesStructure(@Parameter(description = "批次ID") @RequestParam Long batchId,
@Parameter(description = "班级ID") @RequestParam(required = false) Long classId) {
Map<String, Object> result = new HashMap<>();
try {
if (classId != null) {
result.put("withQuota", applicationService.getScholarshipTypesWithQuota(batchId, classId));
}
result.put("withoutQuota", applicationService.getScholarshipTypesByBatch(batchId));
result.put("batchId", batchId);
result.put("classId", classId);
result.put("timestamp", System.currentTimeMillis());
} catch (Exception e) {
result.put("error", e.getMessage());
}
return R.ok(result);
}
/**
* 调试接口：详细SQL日志输出测试
*/
@SaCheckPermission("jcbt:scholarshipApplication:scholarshipTypes")
@GetMapping("/debug/sqlLogs")
@Operation(summary = "调试接口：详细SQL日志输出测试")
public R<Map<String, Object>> debugSqlLogs(@Parameter(description = "批次ID") @RequestParam Long batchId,
@Parameter(description = "班级ID") @RequestParam Long classId,
@Parameter(description = "奖学金类型ID（可选，测试单个类型）") @RequestParam(required = false) Long scholarshipTypeId) {
Map<String, Object> result = new HashMap<>();
try {
log.info("🚀 === SQL调试接口开始 ===");
log.info("📥 接收参数: batchId={}, classId={}, scholarshipTypeId={}", batchId, classId, scholarshipTypeId);
result.put("requestParams", Map.of(
"batchId", batchId,
"classId", classId,
"scholarshipTypeId", scholarshipTypeId
));
// 如果指定了奖学金类型ID，则只测试该类型
if (scholarshipTypeId != null) {
log.info("🎯 单个奖学金类型测试模式");
// 测试班级名额查询
log.info("📊 开始测试班级名额查询");
var classQuota = applicationService.testClassQuotaQuery(classId, scholarshipTypeId, batchId);
result.put("classQuotaTest", classQuota);
// 测试全校名额查询
log.info("🏫 开始测试全校名额查询");
var schoolQuota = applicationService.testSchoolQuotaQuery(batchId, scholarshipTypeId);
result.put("schoolQuotaTest", schoolQuota);
} else {
log.info("📋 完整流程测试模式");
// 完整流程测试
var quotaResult = applicationService.getScholarshipTypesWithQuota(batchId, classId);
result.put("fullProcessTest", quotaResult);
}
result.put("status", "success");
result.put("timestamp", System.currentTimeMillis());
log.info("✅ === SQL调试接口完成 ===");
} catch (Exception e) {
log.error("❌ === SQL调试接口异常 ===", e);
result.put("status", "error");
result.put("error", e.getMessage());
result.put("stackTrace", e.getStackTrace());
}
return R.ok(result);
}
}
backend/ruoyi-modules/ruoyi-jcbt/src/main/java/org/dromara/jcbt/controller/JcbtScholarshipBatchController.java
+180
View File
@@ -0,0 +1,180 @@
package org.dromara.jcbt.controller;
import java.util.List;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import jakarta.servlet.http.HttpServletResponse;
import jakarta.validation.constraints.*;
import cn.dev33.satoken.annotation.SaCheckPermission;
import org.springframework.web.bind.annotation.*;
import org.springframework.validation.annotation.Validated;
import org.dromara.common.idempotent.annotation.RepeatSubmit;
import org.dromara.common.log.annotation.Log;
import org.dromara.common.web.core.BaseController;
import org.dromara.common.mybatis.core.page.PageQuery;
import org.dromara.common.core.domain.R;
import org.dromara.common.core.validate.AddGroup;
import org.dromara.common.core.validate.EditGroup;
import org.dromara.common.excel.utils.ExcelUtil;
import org.dromara.jcbt.domain.vo.JcbtScholarshipBatchVo;
import org.dromara.jcbt.domain.bo.JcbtScholarshipBatchBo;
import org.dromara.jcbt.service.IJcbtScholarshipBatchService;
import org.dromara.common.mybatis.core.page.TableDataInfo;
import org.dromara.common.log.enums.BusinessType;
/**
* 奖学金评定批次
*
* @author ruoyi
* @date 2025-01-27
*/
@Validated
@RequiredArgsConstructor
@RestController
@RequestMapping("/jcbt/scholarshipBatch")
@Slf4j
public class JcbtScholarshipBatchController extends BaseController {
private final IJcbtScholarshipBatchService scholarshipBatchService;
/**
* 查询奖学金评定批次列表
*/
@SaCheckPermission("jcbt:scholarshipBatch:list")
@GetMapping("/list")
public TableDataInfo<JcbtScholarshipBatchVo> list(JcbtScholarshipBatchBo bo, PageQuery pageQuery) {
return scholarshipBatchService.queryPageList(bo, pageQuery);
}
/**
* 导出奖学金评定批次列表
*/
@SaCheckPermission("jcbt:scholarshipBatch:export")
@Log(title = "奖学金评定批次", businessType = BusinessType.EXPORT)
@PostMapping("/export")
public void export(JcbtScholarshipBatchBo bo, HttpServletResponse response) {
List<JcbtScholarshipBatchVo> list = scholarshipBatchService.queryExportList(bo);
ExcelUtil.exportExcel(list, "奖学金评定批次", JcbtScholarshipBatchVo.class, response);
}
/**
* 获取奖学金评定批次详细信息
*/
@SaCheckPermission("jcbt:scholarshipBatch:query")
@GetMapping("/{id}")
public R<JcbtScholarshipBatchVo> getInfo(@NotNull(message = "主键不能为空")
@PathVariable Long id) {
return R.ok(scholarshipBatchService.queryById(id));
}
/**
* 新增奖学金评定批次
*/
@SaCheckPermission("jcbt:scholarshipBatch:add")
@Log(title = "奖学金评定批次", businessType = BusinessType.INSERT)
@RepeatSubmit()
@PostMapping()
public R<Void> add(@Validated(AddGroup.class) @RequestBody JcbtScholarshipBatchBo bo) {
return toAjax(scholarshipBatchService.insertByBo(bo));
}
/**
* 修改奖学金评定批次
*/
@SaCheckPermission("jcbt:scholarshipBatch:edit")
@Log(title = "奖学金评定批次", businessType = BusinessType.UPDATE)
@RepeatSubmit()
@PutMapping()
public R<Void> edit(@Validated(EditGroup.class) @RequestBody JcbtScholarshipBatchBo bo) {
return toAjax(scholarshipBatchService.updateByBo(bo));
}
/**
* 删除奖学金评定批次
*/
@SaCheckPermission("jcbt:scholarshipBatch:remove")
@Log(title = "奖学金评定批次", businessType = BusinessType.DELETE)
@DeleteMapping("/{ids}")
public R<Void> remove(@NotEmpty(message = "主键不能为空")
@PathVariable Long[] ids) {
return toAjax(scholarshipBatchService.deleteWithValidByIds(List.of(ids), true));
}
/**
* 根据批次编码查询批次信息
*/
@SaCheckPermission("jcbt:scholarshipBatch:query")
@GetMapping("/getByCode/{batchCode}")
public R<JcbtScholarshipBatchVo> getByBatchCode(@PathVariable String batchCode) {
return R.ok(scholarshipBatchService.queryByBatchCode(batchCode));
}
/**
* 根据学年和学期查询批次列表
*/
@SaCheckPermission("jcbt:scholarshipBatch:query")
@GetMapping("/getByAcademicYear")
public R<List<JcbtScholarshipBatchVo>> getByAcademicYearAndSemester(
@RequestParam String academicYear,
@RequestParam(required = false) Integer semester) {
return R.ok(scholarshipBatchService.queryByAcademicYearAndSemester(academicYear, semester));
}
/**
* 查询启用状态的批次列表
*/
@SaCheckPermission("jcbt:scholarshipBatch:query")
@GetMapping("/getActiveBatches")
public R<List<JcbtScholarshipBatchVo>> getActiveBatches() {
return R.ok(scholarshipBatchService.queryActiveBatches());
}
/**
* 检查批次编码是否唯一
*/
@SaCheckPermission("jcbt:scholarshipBatch:query")
@GetMapping("/checkBatchCodeUnique")
public R<Boolean> checkBatchCodeUnique(@RequestParam String batchCode,
@RequestParam(required = false) Long id) {
return R.ok(scholarshipBatchService.checkBatchCodeUnique(batchCode, id));
}
/**
* 更改批次状态
*/
@SaCheckPermission("jcbt:scholarshipBatch:edit")
@Log(title = "奖学金评定批次", businessType = BusinessType.UPDATE)
@PutMapping("/changeStatus")
public R<Void> changeStatus(@RequestParam Long id, @RequestParam String status) {
return toAjax(scholarshipBatchService.changeStatus(id, status));
}
/**
* 查询当前进行中的批次
*/
@SaCheckPermission("jcbt:scholarshipBatch:query")
@GetMapping("/getCurrentActiveBatches")
public R<List<JcbtScholarshipBatchVo>> getCurrentActiveBatches() {
return R.ok(scholarshipBatchService.queryCurrentActiveBatches());
}
/**
* 根据状态查询批次列表
*/
@SaCheckPermission("jcbt:scholarshipBatch:query")
@GetMapping("/getByStatus/{status}")
public R<List<JcbtScholarshipBatchVo>> getByStatus(@PathVariable String status) {
return R.ok(scholarshipBatchService.queryByStatus(status));
}
/**
* 检查批次时间是否有冲突
*/
@SaCheckPermission("jcbt:scholarshipBatch:query")
@PostMapping("/checkTimeConflict")
public R<Boolean> checkTimeConflict(@RequestBody JcbtScholarshipBatchBo bo) {
return R.ok(scholarshipBatchService.checkTimeConflict(bo));
}
}
backend/ruoyi-modules/ruoyi-jcbt/src/main/java/org/dromara/jcbt/controller/JcbtScholarshipQuotaController.java
+248
View File
@@ -0,0 +1,248 @@
package org.dromara.jcbt.controller;
import cn.dev33.satoken.annotation.SaCheckPermission;
import jakarta.servlet.http.HttpServletResponse;
import jakarta.validation.constraints.NotEmpty;
import jakarta.validation.constraints.NotNull;
import lombok.RequiredArgsConstructor;
import org.dromara.common.core.domain.R;
import org.dromara.common.core.validate.AddGroup;
import org.dromara.common.core.validate.EditGroup;
import org.dromara.common.excel.utils.ExcelUtil;
import org.dromara.common.idempotent.annotation.RepeatSubmit;
import org.dromara.common.log.annotation.Log;
import org.dromara.common.log.enums.BusinessType;
import org.dromara.common.mybatis.core.page.PageQuery;
import org.dromara.common.mybatis.core.page.TableDataInfo;
import org.dromara.common.web.core.BaseController;
import org.dromara.jcbt.domain.bo.JcbtScholarshipQuotaBo;
import org.dromara.jcbt.domain.vo.JcbtScholarshipQuotaVo;
import org.dromara.jcbt.service.IJcbtScholarshipQuotaService;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
import java.util.List;
import java.util.Map;
/**
* 奖学金名额分配
*
* @author ruoyi
* @date 2025-01-27
*/
@Validated
@RequiredArgsConstructor
@RestController
@RequestMapping("/jcbt/scholarshipQuota")
public class JcbtScholarshipQuotaController extends BaseController {
private final IJcbtScholarshipQuotaService scholarshipQuotaService;
/**
* 查询奖学金名额分配列表
*/
@SaCheckPermission("jcbt:scholarshipQuota:list")
@GetMapping("/list")
public TableDataInfo<JcbtScholarshipQuotaVo> list(JcbtScholarshipQuotaBo bo, PageQuery pageQuery) {
return scholarshipQuotaService.queryPageList(bo, pageQuery);
}
/**
* 查询指定批次的名额分配列表
*/
@SaCheckPermission("jcbt:scholarshipQuota:list")
@GetMapping("/listByBatch/{batchId}")
public R<List<JcbtScholarshipQuotaVo>> listByBatch(@PathVariable Long batchId) {
List<JcbtScholarshipQuotaVo> list = scholarshipQuotaService.queryListByBatchId(batchId);
return R.ok(list);
}
/**
* 查询指定批次和奖学金类型的名额分配
*/
@SaCheckPermission("jcbt:scholarshipQuota:list")
@GetMapping("/listByBatchAndType")
public R<List<JcbtScholarshipQuotaVo>> listByBatchAndType(@RequestParam Long batchId,
@RequestParam Long scholarshipTypeId) {
List<JcbtScholarshipQuotaVo> list = scholarshipQuotaService.queryListByBatchAndType(batchId, scholarshipTypeId);
return R.ok(list);
}
/**
* 查询名额分配树形结构
*/
@SaCheckPermission("jcbt:scholarshipQuota:list")
@GetMapping("/tree")
public R<List<JcbtScholarshipQuotaVo>> tree(@RequestParam Long batchId,
@RequestParam Long scholarshipTypeId) {
List<JcbtScholarshipQuotaVo> tree = scholarshipQuotaService.queryQuotaTree(batchId, scholarshipTypeId);
return R.ok(tree);
}
/**
* 查询名额使用统计
*/
@SaCheckPermission("jcbt:scholarshipQuota:list")
@GetMapping("/statistics/{batchId}")
public R<Map<String, Object>> statistics(@PathVariable Long batchId) {
Map<String, Object> statistics = scholarshipQuotaService.queryQuotaUsageStatistics(batchId);
return R.ok(statistics);
}
/**
* 导出奖学金名额分配列表
*/
@SaCheckPermission("jcbt:scholarshipQuota:export")
@Log(title = "导出奖学金名额分配", businessType = BusinessType.EXPORT)
@PostMapping("/export")
public void export(JcbtScholarshipQuotaBo bo, HttpServletResponse response) {
List<JcbtScholarshipQuotaVo> list = scholarshipQuotaService.queryList(bo);
ExcelUtil.exportExcel(list, "奖学金名额分配", JcbtScholarshipQuotaVo.class, response);
}
/**
* 获取奖学金名额分配详细信息
*/
@SaCheckPermission("jcbt:scholarshipQuota:query")
@GetMapping("/{id}")
public R<JcbtScholarshipQuotaVo> getInfo(@NotNull(message = "主键不能为空") @PathVariable Long id) {
return R.ok(scholarshipQuotaService.queryById(id));
}
/**
* 新增奖学金名额分配
*/
@SaCheckPermission("jcbt:scholarshipQuota:add")
@Log(title = "新增奖学金名额分配", businessType = BusinessType.INSERT)
@RepeatSubmit()
@PostMapping()
public R<Void> add(@Validated(AddGroup.class) @RequestBody JcbtScholarshipQuotaBo bo) {
return toAjax(scholarshipQuotaService.insertByBo(bo));
}
/**
* 修改奖学金名额分配
*/
@SaCheckPermission("jcbt:scholarshipQuota:edit")
@Log(title = "修改奖学金名额分配", businessType = BusinessType.UPDATE)
@RepeatSubmit()
@PutMapping()
public R<Void> edit(@Validated(EditGroup.class) @RequestBody JcbtScholarshipQuotaBo bo) {
return toAjax(scholarshipQuotaService.updateByBo(bo));
}
/**
* 删除奖学金名额分配
*/
@SaCheckPermission("jcbt:scholarshipQuota:remove")
@Log(title = "删除奖学金名额分配", businessType = BusinessType.DELETE)
@DeleteMapping("/{ids}")
public R<Void> remove(@NotEmpty(message = "主键不能为空") @PathVariable Long[] ids) {
return toAjax(scholarshipQuotaService.deleteWithValidByIds(List.of(ids), true));
}
/**
* 批量删除奖学金名额分配
*/
@SaCheckPermission("jcbt:scholarshipQuota:remove")
@Log(title = "批量删除奖学金名额分配", businessType = BusinessType.DELETE)
@DeleteMapping("/batch")
public R<Void> batchRemove(@RequestBody @NotEmpty(message = "主键不能为空") List<Long> ids) {
return toAjax(scholarshipQuotaService.deleteWithValidByIds(ids, true));
}
/**
* 清空指定批次和奖学金类型的名额分配
*/
@SaCheckPermission("jcbt:scholarshipQuota:remove")
@Log(title = "清空奖学金名额分配", businessType = BusinessType.DELETE)
@DeleteMapping("/clear")
public R<Void> clearQuotaByBatchAndType(@RequestParam Long batchId,
@RequestParam(required = false) Long scholarshipTypeId) {
return toAjax(scholarshipQuotaService.clearQuotaByBatchAndType(batchId, scholarshipTypeId));
}
/**
* 批量分配名额
*/
@SaCheckPermission("jcbt:scholarshipQuota:add")
@Log(title = "批量分配奖学金名额", businessType = BusinessType.INSERT)
@RepeatSubmit()
@PostMapping("/batchAllocate")
public R<Void> batchAllocate(@RequestParam Long batchId,
@RequestParam Long scholarshipTypeId,
@RequestBody List<JcbtScholarshipQuotaBo> quotaAllocations) {
return toAjax(scholarshipQuotaService.batchAllocateQuota(batchId, scholarshipTypeId, quotaAllocations));
}
/**
* 调整名额分配
*/
@SaCheckPermission("jcbt:scholarshipQuota:edit")
@Log(title = "调整奖学金名额分配", businessType = BusinessType.UPDATE)
@RepeatSubmit()
@PostMapping("/adjust")
public R<Void> adjustQuota(@RequestParam Long fromQuotaId,
@RequestParam Long toQuotaId,
@RequestParam Integer adjustAmount,
@RequestParam String reason) {
return toAjax(scholarshipQuotaService.adjustQuotaAllocation(fromQuotaId, toQuotaId, adjustAmount, reason));
}
/**
* 锁定/解锁名额分配
*/
@SaCheckPermission("jcbt:scholarshipQuota:edit")
@Log(title = "锁定/解锁奖学金名额分配", businessType = BusinessType.UPDATE)
@PutMapping("/lock/{id}")
public R<Void> lockQuota(@PathVariable Long id, @RequestParam Integer isLocked) {
return toAjax(scholarshipQuotaService.lockQuotaAllocation(id, isLocked));
}
/**
* 自动分配名额
*/
@SaCheckPermission("jcbt:scholarshipQuota:edit")
@Log(title = "自动分配奖学金名额", businessType = BusinessType.UPDATE)
@RepeatSubmit()
@PostMapping("/autoAllocate")
public R<Void> autoAllocate(@RequestParam Long batchId,
@RequestParam Long scholarshipTypeId,
@RequestParam String allocationRule) {
return toAjax(scholarshipQuotaService.autoAllocateQuota(batchId, scholarshipTypeId, allocationRule));
}
/**
* 复制名额分配
*/
@SaCheckPermission("jcbt:scholarshipQuota:add")
@Log(title = "复制奖学金名额分配", businessType = BusinessType.INSERT)
@RepeatSubmit()
@PostMapping("/copy")
public R<Void> copyQuota(@RequestParam Long sourceBatchId,
@RequestParam Long targetBatchId,
@RequestBody List<Long> scholarshipTypeIds) {
return toAjax(scholarshipQuotaService.copyQuotaFromBatch(sourceBatchId, targetBatchId, scholarshipTypeIds));
}
/**
* 更新名额使用情况
*/
@SaCheckPermission("jcbt:scholarshipQuota:edit")
@Log(title = "更新奖学金名额使用情况", businessType = BusinessType.UPDATE)
@PutMapping("/updateUsage/{id}")
public R<Void> updateUsage(@PathVariable Long id, @RequestParam Integer usedChange) {
return toAjax(scholarshipQuotaService.updateQuotaUsage(id, usedChange));
}
/**
* 验证名额分配
*/
@SaCheckPermission("jcbt:scholarshipQuota:query")
@PostMapping("/validate")
public R<String> validate(@RequestBody JcbtScholarshipQuotaBo bo) {
String validationMsg = scholarshipQuotaService.validateQuotaAllocation(bo);
return R.ok("验证结果", validationMsg);
}
}
backend/ruoyi-modules/ruoyi-jcbt/src/main/java/org/dromara/jcbt/controller/JcbtScholarshipReviewController.java
+263
View File
@@ -0,0 +1,263 @@
package org.dromara.jcbt.controller;
import cn.dev33.satoken.annotation.SaCheckPermission;
import jakarta.servlet.http.HttpServletResponse;
import jakarta.validation.constraints.NotEmpty;
import jakarta.validation.constraints.NotNull;
import lombok.RequiredArgsConstructor;
import org.dromara.common.core.domain.R;
import org.dromara.common.core.validate.AddGroup;
import org.dromara.common.core.validate.EditGroup;
import org.dromara.common.excel.utils.ExcelUtil;
import org.dromara.common.idempotent.annotation.RepeatSubmit;
import org.dromara.common.log.annotation.Log;
import org.dromara.common.log.enums.BusinessType;
import org.dromara.common.mybatis.core.page.PageQuery;
import org.dromara.common.mybatis.core.page.TableDataInfo;
import org.dromara.common.web.core.BaseController;
import org.dromara.jcbt.domain.bo.JcbtScholarshipReviewBo;
import org.dromara.jcbt.domain.vo.JcbtScholarshipReviewVo;
import org.dromara.jcbt.service.IJcbtScholarshipReviewService;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
import java.util.List;
import java.util.Map;
/**
* 奖学金审核记录
*
* @author ruoyi
* @date 2025-08-05
*/
@Validated
@RequiredArgsConstructor
@RestController
@RequestMapping("/jcbt/review")
public class JcbtScholarshipReviewController extends BaseController {
private final IJcbtScholarshipReviewService reviewService;
/**
* 查询奖学金审核记录列表
*/
@SaCheckPermission("jcbt:review:list")
@GetMapping("/list")
public TableDataInfo<JcbtScholarshipReviewVo> list(JcbtScholarshipReviewBo bo, PageQuery pageQuery) {
return reviewService.queryPageList(bo, pageQuery);
}
/**
* 导出奖学金审核记录列表
*/
@SaCheckPermission("jcbt:review:export")
@Log(title = "奖学金审核记录", businessType = BusinessType.EXPORT)
@PostMapping("/export")
public void export(JcbtScholarshipReviewBo bo, HttpServletResponse response) {
List<JcbtScholarshipReviewVo> list = reviewService.queryList(bo);
ExcelUtil.exportExcel(list, "奖学金审核记录", JcbtScholarshipReviewVo.class, response);
}
/**
* 获取奖学金审核记录详细信息
*/
@SaCheckPermission("jcbt:review:query")
@GetMapping("/{id}")
public R<JcbtScholarshipReviewVo> getInfo(@NotNull(message = "主键不能为空")
@PathVariable Long id) {
return R.ok(reviewService.queryById(id));
}
// 注意：审核记录不允许手动新增、修改、删除
// 审核记录应由系统在申请提交时自动创建
// 仅保留查询和审核操作功能
/**
* 根据申请ID查询审核记录
*/
@SaCheckPermission("jcbt:review:query")
@GetMapping("/application/{applicationId}")
public R<List<JcbtScholarshipReviewVo>> getReviewsByApplicationId(
@NotNull(message = "申请ID不能为空") @PathVariable Long applicationId) {
return R.ok(reviewService.queryReviewsByApplicationId(applicationId));
}
/**
* 查询当前用户待审核的记录
*/
@SaCheckPermission("jcbt:review:pending")
@GetMapping("/pending")
public TableDataInfo<JcbtScholarshipReviewVo> getPendingReviews(
@RequestParam(required = false) Long reviewerId,
@RequestParam(required = false) String reviewLevel,
@RequestParam(required = false) String applicationNo,
@RequestParam(required = false) String studentName,
PageQuery pageQuery) {
return reviewService.queryPendingReviews(reviewerId, reviewLevel, applicationNo, studentName, pageQuery);
}
/**
* 查询审核历史记录
*/
@SaCheckPermission("jcbt:review:history")
@GetMapping("/history")
public TableDataInfo<JcbtScholarshipReviewVo> getReviewHistory(
@RequestParam(required = false) Long reviewerId,
@RequestParam(required = false) String reviewResult,
@RequestParam(required = false) Long batchId,
@RequestParam(required = false) String startTime,
@RequestParam(required = false) String endTime,
PageQuery pageQuery) {
return reviewService.queryReviewHistory(reviewerId, reviewResult, batchId, startTime, endTime, pageQuery);
}
/**
* 提交审核结果
*/
@SaCheckPermission("jcbt:review:approve")
@Log(title = "提交审核结果", businessType = BusinessType.UPDATE)
@RepeatSubmit()
@PostMapping("/submit")
public R<Void> submitReview(
@NotNull(message = "审核记录ID不能为空") @RequestParam Long reviewId,
@NotEmpty(message = "审核结果不能为空") @RequestParam String reviewResult,
@RequestParam(required = false) String reviewOpinion,
@RequestParam(required = false) Double reviewScore,
@RequestParam(required = false) Long nextReviewerId) {
return toAjax(reviewService.submitReview(reviewId, reviewResult, reviewOpinion, reviewScore, nextReviewerId));
}
/**
* 批量审核
*/
@SaCheckPermission("jcbt:review:batchApprove")
@Log(title = "批量审核", businessType = BusinessType.UPDATE)
@RepeatSubmit()
@PostMapping("/batch")
public R<Void> batchReview(
@NotEmpty(message = "审核记录ID列表不能为空") @RequestParam List<Long> reviewIds,
@NotEmpty(message = "审核结果不能为空") @RequestParam String reviewResult,
@RequestParam(required = false) String reviewOpinion,
@NotNull(message = "审核人ID不能为空") @RequestParam Long reviewerId,
@NotEmpty(message = "审核人姓名不能为空") @RequestParam String reviewerName) {
return toAjax(reviewService.batchReview(reviewIds, reviewResult, reviewOpinion, reviewerId, reviewerName));
}
// 注意：审核任务创建通常在申请提交时自动触发
// 此接口保留作为补偿性操作，用于特殊情况下手动创建审核任务
/**
* 转移审核任务
*/
@SaCheckPermission("jcbt:review:transfer")
@Log(title = "转移审核任务", businessType = BusinessType.UPDATE)
@RepeatSubmit()
@PostMapping("/transfer")
public R<Void> transferReview(
@NotNull(message = "审核记录ID不能为空") @RequestParam Long reviewId,
@NotNull(message = "新审核人ID不能为空") @RequestParam Long newReviewerId,
@NotEmpty(message = "新审核人姓名不能为空") @RequestParam String newReviewerName,
@RequestParam(required = false) String reason) {
return toAjax(reviewService.transferReview(reviewId, newReviewerId, newReviewerName, reason));
}
/**
* 撤回审核结果
*/
@SaCheckPermission("jcbt:review:revoke")
@Log(title = "撤回审核结果", businessType = BusinessType.UPDATE)
@RepeatSubmit()
@PostMapping("/withdraw")
public R<Void> withdrawReview(
@NotNull(message = "审核记录ID不能为空") @RequestParam Long reviewId,
@RequestParam(required = false) String reason) {
return toAjax(reviewService.withdrawReview(reviewId, reason));
}
/**
* 查询某个申请的最新审核记录
*/
@SaCheckPermission("jcbt:review:query")
@GetMapping("/latest/{applicationId}")
public R<JcbtScholarshipReviewVo> getLatestReview(
@NotNull(message = "申请ID不能为空") @PathVariable Long applicationId) {
return R.ok(reviewService.queryLatestReviewByApplicationId(applicationId));
}
/**
* 查询某个申请的指定级别审核记录
*/
@SaCheckPermission("jcbt:review:query")
@GetMapping("/level/{applicationId}/{reviewLevel}")
public R<JcbtScholarshipReviewVo> getReviewByLevel(
@NotNull(message = "申请ID不能为空") @PathVariable Long applicationId,
@NotEmpty(message = "审核级别不能为空") @PathVariable String reviewLevel) {
return R.ok(reviewService.queryReviewByApplicationAndLevel(applicationId, reviewLevel));
}
/**
* 统计审核数量
*/
@SaCheckPermission("jcbt:review:statistics")
@GetMapping("/statistics/count")
public R<Map<String, Long>> getReviewCount(
@RequestParam(required = false) Long reviewerId,
@RequestParam(required = false) String reviewLevel,
@RequestParam(required = false) String reviewResult,
@RequestParam(required = false) Long batchId) {
return R.ok(reviewService.countReviewsByCondition(reviewerId, reviewLevel, reviewResult, batchId));
}
/**
* 获取下一级审核人员列表
*/
@SaCheckPermission("jcbt:review:query")
@GetMapping("/next-reviewers/{applicationId}/{currentLevel}")
public R<List<Long>> getNextReviewers(
@NotNull(message = "申请ID不能为空") @PathVariable Long applicationId,
@NotEmpty(message = "当前审核级别不能为空") @PathVariable String currentLevel) {
return R.ok(reviewService.getNextReviewers(applicationId, currentLevel));
}
/**
* 审核流程推进
*/
@SaCheckPermission("jcbt:review:approve")
@Log(title = "审核流程推进", businessType = BusinessType.UPDATE)
@RepeatSubmit()
@PostMapping("/advance")
public R<Void> advanceReviewProcess(
@NotNull(message = "申请ID不能为空") @RequestParam Long applicationId,
@NotEmpty(message = "当前审核级别不能为空") @RequestParam String currentLevel,
@NotEmpty(message = "审核结果不能为空") @RequestParam String reviewResult,
@RequestParam(required = false) String reviewOpinion,
@RequestParam(required = false) Double reviewScore) {
return toAjax(reviewService.advanceReviewProcess(applicationId, currentLevel, reviewResult, reviewOpinion, reviewScore));
}
/**
* 检查用户审核权限
*/
@SaCheckPermission("jcbt:review:query")
@GetMapping("/permission")
public R<Boolean> checkReviewPermission(
@NotNull(message = "审核人ID不能为空") @RequestParam Long reviewerId,
@NotEmpty(message = "审核级别不能为空") @RequestParam String reviewLevel,
@NotNull(message = "申请ID不能为空") @RequestParam Long applicationId) {
return R.ok(reviewService.checkReviewPermission(reviewerId, reviewLevel, applicationId));
}
/**
* 获取审核统计信息
*/
@SaCheckPermission("jcbt:review:statistics")
@GetMapping("/statistics")
public R<Map<String, Object>> getReviewStatistics(
@RequestParam(required = false) Long reviewerId,
@RequestParam(required = false) String reviewLevel,
@RequestParam(required = false) Long batchId) {
return R.ok(reviewService.getReviewStatistics(reviewerId, reviewLevel, batchId));
}
}
backend/ruoyi-modules/ruoyi-jcbt/src/main/java/org/dromara/jcbt/controller/JcbtScholarshipTypeController.java
+298
View File
@@ -0,0 +1,298 @@
package org.dromara.jcbt.controller;
import java.util.List;
import java.util.Map;
import java.util.HashMap;
import java.util.ArrayList;
import java.util.stream.Collectors;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import jakarta.servlet.http.HttpServletResponse;
import jakarta.validation.constraints.*;
import cn.dev33.satoken.annotation.SaCheckPermission;
import org.springframework.web.bind.annotation.*;
import org.springframework.validation.annotation.Validated;
import org.dromara.common.idempotent.annotation.RepeatSubmit;
import org.dromara.common.log.annotation.Log;
import org.dromara.common.web.core.BaseController;
import org.dromara.common.mybatis.core.page.PageQuery;
import org.dromara.common.core.domain.R;
import org.dromara.common.core.validate.AddGroup;
import org.dromara.common.core.validate.EditGroup;
import org.dromara.common.excel.utils.ExcelUtil;
import org.dromara.jcbt.domain.vo.JcbtScholarshipTypeVo;
import org.dromara.jcbt.domain.bo.JcbtScholarshipTypeBo;
import org.dromara.jcbt.service.IJcbtScholarshipTypeService;
import org.dromara.jcbt.service.IJcbtScholarshipCompatibilityService;
import org.dromara.common.mybatis.core.page.TableDataInfo;
import org.dromara.common.log.enums.BusinessType;
/**
* 奖学金类型
*
* @author ruoyi
* @date 2025-01-27
*/
@Validated
@RequiredArgsConstructor
@RestController
@RequestMapping("/jcbt/scholarshipType")
@Slf4j
public class JcbtScholarshipTypeController extends BaseController {
private final IJcbtScholarshipTypeService scholarshipTypeService;
private final IJcbtScholarshipCompatibilityService compatibilityService;
/**
* 查询奖学金类型列表
*/
@SaCheckPermission("jcbt:scholarshipType:list")
@GetMapping("/list")
public TableDataInfo<JcbtScholarshipTypeVo> list(JcbtScholarshipTypeBo bo, PageQuery pageQuery) {
return scholarshipTypeService.queryPageList(bo, pageQuery);
}
/**
* 导出奖学金类型列表
*/
@SaCheckPermission("jcbt:scholarshipType:export")
@Log(title = "奖学金类型", businessType = BusinessType.EXPORT)
@PostMapping("/export")
public void export(JcbtScholarshipTypeBo bo, HttpServletResponse response) {
List<JcbtScholarshipTypeVo> list = scholarshipTypeService.queryExportList(bo);
ExcelUtil.exportExcel(list, "奖学金类型", JcbtScholarshipTypeVo.class, response);
}
/**
* 获取奖学金类型详细信息
*/
@SaCheckPermission("jcbt:scholarshipType:query")
@GetMapping("/{id}")
public R<JcbtScholarshipTypeVo> getInfo(@NotNull(message = "主键不能为空")
@PathVariable Long id) {
return R.ok(scholarshipTypeService.queryById(id));
}
/**
* 新增奖学金类型
*/
@SaCheckPermission("jcbt:scholarshipType:add")
@Log(title = "奖学金类型", businessType = BusinessType.INSERT)
@RepeatSubmit()
@PostMapping()
public R<Void> add(@Validated(AddGroup.class) @RequestBody JcbtScholarshipTypeBo bo) {
return toAjax(scholarshipTypeService.insertByBo(bo));
}
/**
* 修改奖学金类型
*/
@SaCheckPermission("jcbt:scholarshipType:edit")
@Log(title = "奖学金类型", businessType = BusinessType.UPDATE)
@RepeatSubmit()
@PutMapping()
public R<Void> edit(@Validated(EditGroup.class) @RequestBody JcbtScholarshipTypeBo bo) {
return toAjax(scholarshipTypeService.updateByBo(bo));
}
/**
* 删除奖学金类型
*/
@SaCheckPermission("jcbt:scholarshipType:remove")
@Log(title = "奖学金类型", businessType = BusinessType.DELETE)
@DeleteMapping("/{ids}")
public R<Void> remove(@NotEmpty(message = "主键不能为空")
@PathVariable Long[] ids) {
return toAjax(scholarshipTypeService.deleteWithValidByIds(List.of(ids), true));
}
/**
* 根据类型名称查询奖学金类型
*/
@SaCheckPermission("jcbt:scholarshipType:query")
@GetMapping("/getByName/{typeName}")
public R<JcbtScholarshipTypeVo> getByTypeName(@PathVariable String typeName) {
return R.ok(scholarshipTypeService.queryByTypeName(typeName));
}
/**
* 根据类别查询奖学金类型列表
*/
@SaCheckPermission("jcbt:scholarshipType:query")
@GetMapping("/getByCategory/{typeCategory}")
public R<List<JcbtScholarshipTypeVo>> getByCategory(@PathVariable String typeCategory) {
return R.ok(scholarshipTypeService.queryByCategory(typeCategory));
}
/**
* 查询启用状态的奖学金类型列表
*/
@SaCheckPermission("jcbt:scholarshipType:query")
@GetMapping("/getActiveTypes")
public R<List<JcbtScholarshipTypeVo>> getActiveTypes() {
return R.ok(scholarshipTypeService.queryActiveTypes());
}
/**
* 检查奖学金名称是否重复
*/
@SaCheckPermission("jcbt:scholarshipType:query")
@GetMapping("/checkTypeNameUnique")
public R<Boolean> checkTypeNameUnique(@RequestParam String typeName,
@RequestParam(required = false) Long id) {
return R.ok(scholarshipTypeService.checkTypeNameUnique(typeName, id));
}
/**
* 批量更新排序号
*/
@SaCheckPermission("jcbt:scholarshipType:edit")
@Log(title = "奖学金类型", businessType = BusinessType.UPDATE)
@PutMapping("/batchUpdateSort")
public R<Void> batchUpdateSortOrder(@RequestBody List<JcbtScholarshipTypeBo> scholarshipTypes) {
return toAjax(scholarshipTypeService.batchUpdateSortOrder(scholarshipTypes));
}
/**
* 根据兼得类型查询相关奖学金类型
*/
@SaCheckPermission("jcbt:scholarshipType:query")
@GetMapping("/getByCompatibilityType/{compatibilityType}")
public R<List<JcbtScholarshipTypeVo>> getByCompatibilityType(@PathVariable String compatibilityType) {
return R.ok(scholarshipTypeService.queryByCompatibilityType(compatibilityType));
}
/**
* 启用/停用奖学金类型
*/
@SaCheckPermission("jcbt:scholarshipType:edit")
@Log(title = "奖学金类型", businessType = BusinessType.UPDATE)
@PutMapping("/changeStatus")
public R<Void> changeStatus(@RequestParam Long id, @RequestParam Integer status) {
return toAjax(scholarshipTypeService.changeStatus(id, status));
}
/**
* 获取奖学金类型选项列表
*/
@SaCheckPermission("jcbt:scholarshipType:query")
@GetMapping("/options")
public R<List<JcbtScholarshipTypeVo>> getOptions() {
return R.ok(scholarshipTypeService.queryOptions());
}
/**
* 获取奖学金类型的兼得关系配置
*/
@SaCheckPermission("jcbt:scholarshipType:compatibility")
@GetMapping("/{id}/compatibility")
public R<Map<String, Object>> getCompatibilityConfig(@NotNull(message = "主键不能为空") @PathVariable Long id) {
// 获取所有启用的奖学金类型（除了当前奖学金）
List<JcbtScholarshipTypeVo> allTypes = scholarshipTypeService.queryActiveTypes()
.stream()
.filter(type -> !type.getId().equals(id))
.toList();
// 获取当前奖学金的互斥关系ID列表
List<Long> exclusiveTypeIds = compatibilityService.getExclusiveTypeIds(id);
// 获取当前奖学金的兼容关系ID列表
List<Long> compatibleTypeIds = compatibilityService.getCompatibleTypeIds(id);
// 获取互斥奖学金的详细信息（包含名称）
List<JcbtScholarshipTypeVo> exclusiveTypes = allTypes.stream()
.filter(type -> exclusiveTypeIds.contains(type.getId()))
.toList();
// 获取兼容奖学金的详细信息（包含名称）
List<JcbtScholarshipTypeVo> compatibleTypes = allTypes.stream()
.filter(type -> compatibleTypeIds.contains(type.getId()))
.toList();
Map<String, Object> result = new HashMap<>();
result.put("allTypes", allTypes);
result.put("exclusiveTypeIds", exclusiveTypeIds);
result.put("compatibleTypeIds", compatibleTypeIds);
// 新增：返回详细的兼容性信息
result.put("exclusiveTypes", exclusiveTypes);
result.put("compatibleTypes", compatibleTypes);
return R.ok(result);
}
/**
* 保存奖学金类型的兼得关系配置
*/
@SaCheckPermission("jcbt:scholarshipType:compatibility")
@Log(title = "奖学金兼得关系配置", businessType = BusinessType.UPDATE)
@PostMapping("/{id}/compatibility")
public R<Void> saveCompatibilityConfig(@NotNull(message = "主键不能为空") @PathVariable Long id,
@RequestBody Map<String, Object> config) {
// 安全地转换互斥类型ID列表，支持前端传递的字符串或数字类型
@SuppressWarnings("unchecked")
List<Object> exclusiveTypeIdsObj = (List<Object>) config.get("exclusiveTypeIds");
List<Long> exclusiveTypeIds = exclusiveTypeIdsObj != null ?
exclusiveTypeIdsObj.stream()
.map(obj -> {
if (obj instanceof String) {
return Long.parseLong((String) obj);
} else if (obj instanceof Number) {
return ((Number) obj).longValue();
} else {
throw new IllegalArgumentException("Invalid exclusiveTypeId type: " + obj.getClass());
}
})
.collect(Collectors.toList()) :
null;
// 安全地转换兼容类型ID列表，支持前端传递的字符串或数字类型
@SuppressWarnings("unchecked")
List<Object> compatibleTypeIdsObj = (List<Object>) config.get("compatibleTypeIds");
List<Long> compatibleTypeIds = compatibleTypeIdsObj != null ?
compatibleTypeIdsObj.stream()
.map(obj -> {
if (obj instanceof String) {
return Long.parseLong((String) obj);
} else if (obj instanceof Number) {
return ((Number) obj).longValue();
} else {
throw new IllegalArgumentException("Invalid compatibleTypeId type: " + obj.getClass());
}
})
.collect(Collectors.toList()) :
null;
boolean result = compatibilityService.saveCompatibilityConfig(id, exclusiveTypeIds, compatibleTypeIds);
return toAjax(result);
}
/**
* 检查两个奖学金类型是否兼容
*/
@SaCheckPermission("jcbt:scholarshipType:query")
@GetMapping("/checkCompatibility")
public R<Boolean> checkCompatibility(@RequestParam Long typeId1, @RequestParam Long typeId2) {
return R.ok(compatibilityService.checkCompatibility(typeId1, typeId2));
}
/**
* 获取可与指定奖学金兼得的奖学金类型列表
*/
@SaCheckPermission("jcbt:scholarshipType:query")
@GetMapping("/{id}/compatibleTypes")
public R<List<JcbtScholarshipTypeVo>> getCompatibleTypes(@NotNull(message = "主键不能为空") @PathVariable Long id) {
List<Long> compatibleTypeIds = compatibilityService.getCompatibleTypeIds(id);
List<JcbtScholarshipTypeVo> compatibleTypes = new ArrayList<>();
for (Long typeId : compatibleTypeIds) {
JcbtScholarshipTypeVo type = scholarshipTypeService.queryById(typeId);
if (type != null && type.getStatus() == 1) { // 只返回启用状态的
compatibleTypes.add(type);
}
}
return R.ok(compatibleTypes);
}
}
backend/ruoyi-modules/ruoyi-jcbt/src/main/java/org/dromara/jcbt/controller/JcbtWorkStudyApplicationCollegeReviewController.java
+398
View File
@@ -0,0 +1,398 @@
package org.dromara.jcbt.controller;
import cn.dev33.satoken.annotation.SaCheckPermission;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.Parameter;
import io.swagger.v3.oas.annotations.tags.Tag;
import jakarta.validation.constraints.NotEmpty;
import jakarta.validation.constraints.NotNull;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.dromara.common.core.domain.R;
import org.dromara.common.core.validate.AddGroup;
import org.dromara.common.core.validate.EditGroup;
import org.dromara.common.log.annotation.Log;
import org.dromara.common.log.enums.BusinessType;
import org.dromara.common.mybatis.core.page.PageQuery;
import org.dromara.common.mybatis.core.page.TableDataInfo;
import org.dromara.common.satoken.utils.LoginHelper;
import org.dromara.common.web.core.BaseController;
import org.dromara.jcbt.domain.bo.JcbtWorkStudyApplicationBo;
import org.dromara.jcbt.domain.bo.WorkStudyApplicationReviewBo;
import org.dromara.jcbt.domain.vo.JcbtWorkStudyApplicationVo;
import org.dromara.jcbt.service.IJcbtWorkStudyApplicationService;
import org.dromara.xg.domain.vo.XgStudentMsgVo;
import org.dromara.xg.service.IXgStudentMsgService;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
import java.util.*;
/**
* 勤工俭学申请学院审核管理
* 专门为学院审核人员提供的审核功能
*
* @author ruoyi
* @date 2025-01-13
*/
@Slf4j
@Validated
@Tag(name = "勤工俭学申请学院审核管理", description = "专门为学院审核人员提供的审核功能，只能查看本学院学生的申请")
@RestController
@RequestMapping("/jcbt/workStudyApplicationCollegeReview")
@RequiredArgsConstructor
public class JcbtWorkStudyApplicationCollegeReviewController extends BaseController {
private final IJcbtWorkStudyApplicationService workStudyApplicationService;
private final IXgStudentMsgService xgStudentMsgService;
// ========== 学院审核查询接口 ==========
/**
* 查询本学院待审核申请列表
*/
@Operation(summary = "查询本学院待审核申请列表")
@SaCheckPermission("jcbt:workStudyApplication:collegeReview")
@GetMapping("/pendingList")
public TableDataInfo<JcbtWorkStudyApplicationVo> pendingList(JcbtWorkStudyApplicationBo bo, PageQuery pageQuery) {
// 获取当前用户的学院ID
Long currentUserCollegeId = getCurrentUserCollegeIdAsLong();
if (currentUserCollegeId == null) {
log.warn("当前用户没有关联的学院信息，无法查看审核列表");
return TableDataInfo.build();
}
// 设置学院过滤条件 - 只查看本学院学生的申请
bo.setCollegeId(currentUserCollegeId);
// 只查询已提交状态的申请（待学院审核）- 这样审核通过后就不会在待审核列表中显示
bo.setStatus("SUBMITTED");
return workStudyApplicationService.queryPendingCollegeReview(bo, pageQuery);
}
/**
* 查询本学院所有申请列表（支持多状态筛选）
*/
@Operation(summary = "查询本学院所有申请列表")
@SaCheckPermission("jcbt:workStudyApplication:collegeReview")
@GetMapping("/list")
public TableDataInfo<JcbtWorkStudyApplicationVo> list(JcbtWorkStudyApplicationBo bo, PageQuery pageQuery) {
// 获取当前用户的学院ID
Long currentUserCollegeId = getCurrentUserCollegeIdAsLong();
if (currentUserCollegeId == null) {
log.warn("当前用户没有关联的学院信息，无法查看申请列表");
return TableDataInfo.build();
}
// 设置学院过滤条件 - 只查看本学院学生的申请
bo.setCollegeId(currentUserCollegeId);
// 审核模块不显示草稿状态的申请
if (bo.getStatus() == null || bo.getStatus().isEmpty()) {
// 如果没有指定状态，则查询除草稿外的所有状态
bo.setStatusList(Arrays.asList(
"SUBMITTED",
"COLLEGE_APPROVED",
"COLLEGE_REJECTED",
"FINAL_APPROVED",
"FINAL_REJECTED",
"CANCELLED"
));
}
return workStudyApplicationService.queryPageList(bo, pageQuery);
}
/**
* 获取本学院申请详情
*/
@Operation(summary = "获取本学院申请详情")
@SaCheckPermission("jcbt:workStudyApplication:collegeReview")
@GetMapping("/{id}")
public R<JcbtWorkStudyApplicationVo> getInfo(@PathVariable Long id) {
// 获取申请信息
JcbtWorkStudyApplicationVo vo = workStudyApplicationService.queryById(id);
if (vo == null) {
return R.fail("申请不存在");
}
// 权限检查：只能查看本学院学生的申请
Long currentUserCollegeId = getCurrentUserCollegeIdAsLong();
// 添加详细日志用于调试
log.info("权限检查 - 申请ID: {}, 申请学院ID: {}({}), 当前用户学院ID: {}({})",
id, vo.getCollegeId(), vo.getCollegeId() != null ? vo.getCollegeId().getClass().getSimpleName() : "null",
currentUserCollegeId, currentUserCollegeId != null ? currentUserCollegeId.getClass().getSimpleName() : "null");
if (currentUserCollegeId == null) {
log.warn("权限检查失败 - 当前用户没有关联的学院信息，用户ID: {}, 部门ID: {}, 部门名称: {}",
LoginHelper.getUserId(), LoginHelper.getDeptId(), LoginHelper.getDeptName());
return R.fail("无权查看此申请：用户未关联学院信息");
}
if (!currentUserCollegeId.equals(vo.getCollegeId())) {
log.warn("权限检查失败 - 学院不匹配，申请学院ID: {}, 用户学院ID: {}", vo.getCollegeId(), currentUserCollegeId);
return R.fail("无权查看此申请：只能查看本学院学生的申请");
}
log.info("权限检查通过 - 申请ID: {}", id);
return R.ok(vo);
}
// ========== 学院审核操作接口 ==========
/**
* 学院审核
*/
@Operation(summary = "学院审核")
@SaCheckPermission("jcbt:workStudyApplication:collegeReview")
@Log(title = "勤工俭学申请学院审核", businessType = BusinessType.UPDATE)
@PostMapping("/review")
public R<Void> review(@Validated @RequestBody WorkStudyApplicationReviewBo reviewBo) {
// 权限检查：只能审核本学院学生的申请
JcbtWorkStudyApplicationVo application = workStudyApplicationService.queryById(reviewBo.getApplicationId());
if (application == null) {
return R.fail("申请不存在");
}
Long currentUserCollegeId = getCurrentUserCollegeIdAsLong();
if (currentUserCollegeId == null || !currentUserCollegeId.equals(application.getCollegeId())) {
return R.fail("无权审核此申请");
}
return toAjax(workStudyApplicationService.collegeReview(reviewBo));
}
/**
* 批量学院审核
*/
@Operation(summary = "批量学院审核")
@SaCheckPermission("jcbt:workStudyApplication:collegeReview")
@Log(title = "勤工俭学申请批量学院审核", businessType = BusinessType.UPDATE)
@PostMapping("/batchReview")
public R<Void> batchReview(
@Parameter(description = "申请ID列表") @RequestBody @NotEmpty(message = "申请ID不能为空") Collection<Long> ids,
@Parameter(description = "审核结果") @RequestParam @NotNull(message = "审核结果不能为空") String reviewResult,
@Parameter(description = "审核意见") @RequestParam String reviewComment) {
// 权限检查：批量审核前检查所有申请是否属于当前用户学院
Long currentUserCollegeId = getCurrentUserCollegeIdAsLong();
if (currentUserCollegeId == null) {
return R.fail("当前用户没有关联的学院信息");
}
for (Long id : ids) {
JcbtWorkStudyApplicationVo application = workStudyApplicationService.queryById(id);
if (application == null || !currentUserCollegeId.equals(application.getCollegeId())) {
return R.fail("存在无权审核的申请，批量审核失败");
}
}
return toAjax(workStudyApplicationService.batchCollegeReview(ids, reviewResult, reviewComment));
}
// ========== 统计分析接口 ==========
/**
* 获取本学院申请统计信息
*/
@Operation(summary = "获取本学院申请统计信息")
@SaCheckPermission("jcbt:workStudyApplication:collegeReview")
@GetMapping("/statistics")
public R<Map<String, Object>> getStatistics() {
Long currentUserCollegeId = getCurrentUserCollegeIdAsLong();
if (currentUserCollegeId == null) {
return R.fail("当前用户没有关联的学院信息");
}
// 构建查询条件
JcbtWorkStudyApplicationBo bo = new JcbtWorkStudyApplicationBo();
bo.setCollegeId(currentUserCollegeId);
// 获取各状态申请数量
Map<String, Object> statistics = new HashMap<>();
// 待审核数量（已提交状态）
bo.setStatus("SUBMITTED");
Long pendingCount = workStudyApplicationService.queryPageList(bo, new PageQuery(1, 1)).getTotal();
statistics.put("pendingCount", pendingCount);
// 学院审核通过数量
bo.setStatus("COLLEGE_APPROVED");
Long approvedCount = workStudyApplicationService.queryPageList(bo, new PageQuery(1, 1)).getTotal();
statistics.put("approvedCount", approvedCount);
// 学院审核拒绝数量
bo.setStatus("COLLEGE_REJECTED");
Long rejectedCount = workStudyApplicationService.queryPageList(bo, new PageQuery(1, 1)).getTotal();
statistics.put("rejectedCount", rejectedCount);
// 最终通过数量
bo.setStatus("FINAL_APPROVED");
Long finalApprovedCount = workStudyApplicationService.queryPageList(bo, new PageQuery(1, 1)).getTotal();
statistics.put("finalApprovedCount", finalApprovedCount);
// 总申请数量
bo.setStatus(null);
bo.setStatusList(Arrays.asList("SUBMITTED", "COLLEGE_APPROVED", "COLLEGE_REJECTED", "FINAL_APPROVED", "FINAL_REJECTED", "CANCELLED"));
Long totalCount = workStudyApplicationService.queryPageList(bo, new PageQuery(1, 1)).getTotal();
statistics.put("totalCount", totalCount);
return R.ok(statistics);
}
/**
* 获取可用选项
*/
@Operation(summary = "获取可用选项")
@SaCheckPermission("jcbt:workStudyApplication:collegeReview")
@GetMapping("/options")
public R<Map<String, Object>> getOptions() {
Map<String, Object> options = Map.of(
"statusOptions", List.of(
Map.of("label", "已提交", "value", "SUBMITTED"),
Map.of("label", "学院审核通过", "value", "COLLEGE_APPROVED"),
Map.of("label", "学院审核拒绝", "value", "COLLEGE_REJECTED"),
Map.of("label", "学生处审核通过", "value", "FINAL_APPROVED"),
Map.of("label", "学生处审核拒绝", "value", "FINAL_REJECTED"),
Map.of("label", "已取消", "value", "CANCELLED")
),
"reviewStatusOptions", List.of(
Map.of("label", "待审核", "value", "PENDING"),
Map.of("label", "审核通过", "value", "APPROVED"),
Map.of("label", "审核拒绝", "value", "REJECTED")
)
);
return R.ok(options);
}
// ========== 工具方法 ==========
/**
* 调试权限信息 - 查看当前用户的学院关联情况
*/
@Operation(summary = "调试权限信息")
@SaCheckPermission("jcbt:workStudyApplication:collegeReview")
@GetMapping("/debug/permission")
public R<Map<String, Object>> debugPermission() {
Map<String, Object> result = new HashMap<>();
try {
Long userId = LoginHelper.getUserId();
result.put("userId", userId);
result.put("username", LoginHelper.getUsername());
result.put("deptId", LoginHelper.getDeptId());
result.put("deptName", LoginHelper.getDeptName());
try {
result.put("deptCategory", LoginHelper.getDeptCategory());
} catch (Exception e) {
result.put("deptCategory", "获取失败: " + e.getMessage());
}
// 检查学生信息
try {
XgStudentMsgVo studentInfo = xgStudentMsgService.queryByUserId(userId);
if (studentInfo != null) {
result.put("isStudent", true);
result.put("studentCollegeId", studentInfo.getCollegeId());
result.put("studentCollegeName", studentInfo.getCollegeName());
} else {
result.put("isStudent", false);
}
} catch (Exception e) {
result.put("studentInfoError", e.getMessage());
}
// 获取最终的学院ID
String collegeId = getCurrentUserCollegeId();
result.put("finalCollegeId", collegeId);
result.put("hasCollegeAccess", collegeId != null);
} catch (Exception e) {
result.put("error", e.getMessage());
}
return R.ok(result);
}
/**
* 获取当前用户的学院ID
* 通过查询学生信息或用户部门信息获取
*/
private String getCurrentUserCollegeId() {
try {
// 获取当前登录用户ID
Long userId = LoginHelper.getUserId();
if (userId == null) {
log.warn("用户未登录");
return null;
}
// 首先尝试通过学生信息获取学院ID
try {
XgStudentMsgVo studentInfo = xgStudentMsgService.queryByUserId(userId);
if (studentInfo != null && studentInfo.getCollegeId() != null) {
log.debug("通过学生信息获取学院ID: {}", studentInfo.getCollegeId());
return studentInfo.getCollegeId();
}
} catch (Exception e) {
log.debug("通过学生信息获取学院ID失败，可能用户不是学生: {}", e.getMessage());
}
// 如果不是学生用户，通过用户部门信息获取学院ID
try {
Long deptId = LoginHelper.getDeptId();
if (deptId != null) {
log.debug("通过部门信息获取学院ID: {}", deptId);
return String.valueOf(deptId);
}
} catch (Exception e) {
log.debug("通过部门信息获取学院ID失败: {}", e.getMessage());
}
// 尝试通过部门类别获取学院信息
try {
String deptCategory = LoginHelper.getDeptCategory();
String deptName = LoginHelper.getDeptName();
log.debug("用户部门信息 - 部门名称: {}, 部门类别: {}", deptName, deptCategory);
// 如果部门类别是学院类型，则使用部门ID作为学院ID
if ("college".equals(deptCategory) || "学院".equals(deptCategory)) {
Long deptId = LoginHelper.getDeptId();
if (deptId != null) {
log.info("根据部门类别确认为学院用户，学院ID: {}", deptId);
return String.valueOf(deptId);
}
}
} catch (Exception e) {
log.debug("通过部门类别获取学院ID失败: {}", e.getMessage());
}
log.warn("无法获取用户 {} 的学院信息，用户ID: {}, 部门ID: {}, 部门名称: {}",
userId, userId, LoginHelper.getDeptId(), LoginHelper.getDeptName());
return null;
} catch (Exception e) {
log.error("获取当前用户学院ID失败", e);
return null;
}
}
/**
* 获取当前用户的学院ID，返回Long类型
*/
private Long getCurrentUserCollegeIdAsLong() {
String collegeIdStr = getCurrentUserCollegeId();
if (collegeIdStr == null) {
return null;
}
try {
return Long.parseLong(collegeIdStr);
} catch (NumberFormatException e) {
log.error("学院ID格式错误: {}", collegeIdStr, e);
return null;
}
}
}
backend/ruoyi-modules/ruoyi-jcbt/src/main/java/org/dromara/jcbt/controller/JcbtWorkStudyApplicationController.java
+350
View File
@@ -0,0 +1,350 @@
package org.dromara.jcbt.controller;
import cn.dev33.satoken.annotation.SaCheckPermission;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.Parameter;
import io.swagger.v3.oas.annotations.tags.Tag;
import jakarta.servlet.http.HttpServletResponse;
import jakarta.validation.constraints.NotEmpty;
import jakarta.validation.constraints.NotNull;
import lombok.extern.slf4j.Slf4j;
import org.dromara.common.core.domain.R;
import org.dromara.common.core.validate.AddGroup;
import org.dromara.common.core.validate.EditGroup;
import org.dromara.common.excel.utils.ExcelUtil;
import org.dromara.common.idempotent.annotation.RepeatSubmit;
import org.dromara.common.log.annotation.Log;
import org.dromara.common.log.enums.BusinessType;
import org.dromara.common.mybatis.core.page.PageQuery;
import org.dromara.common.mybatis.core.page.TableDataInfo;
import org.dromara.common.web.core.BaseController;
import org.dromara.common.satoken.utils.LoginHelper;
import org.dromara.jcbt.domain.bo.JcbtWorkStudyApplicationBo;
import org.dromara.jcbt.domain.bo.WorkStudyApplicationReviewBo;
import org.dromara.jcbt.domain.vo.JcbtWorkStudyApplicationVo;
import org.dromara.jcbt.service.IJcbtWorkStudyApplicationService;
import org.dromara.xg.service.IXgStudentMsgService;
import org.dromara.xg.domain.vo.XgStudentMsgVo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
import java.util.List;
import java.util.Map;
import java.util.HashMap;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import org.dromara.jcbt.domain.JcbtWorkStudyApplication;
import org.dromara.jcbt.mapper.JcbtWorkStudyApplicationMapper;
/**
* 勤工俭学申请信息管理
*
* @author ruoyi
* @date 2025-01-03
*/
@Slf4j
@Validated
@Tag(name = "勤工俭学申请信息管理", description = "勤工俭学申请信息管理Controller")
@RestController
@RequestMapping("/jcbt/workStudyApplication")
public class JcbtWorkStudyApplicationController extends BaseController {
@Autowired
private IJcbtWorkStudyApplicationService workStudyApplicationService;
@Autowired
private JcbtWorkStudyApplicationMapper baseMapper;
@Autowired
private IXgStudentMsgService xgStudentMsgService;
// ========== 基础管理接口（6个） ==========
// 注意：学生查看可申请岗位列表的功能已迁移到岗位管理模块
// 请使用：GET /jcbt/workStudyPosition/visibleList?excludeApplied=true
/**
* 获取勤工俭学申请信息详细信息
*/
@Operation(summary = "获取勤工俭学申请信息详细信息")
// @SaCheckPermission("jcbt:workStudyApplication:query") // 暂时注释权限检查，用于测试
@GetMapping("/detail/{id}")
public R<JcbtWorkStudyApplicationVo> getInfo(@NotNull(message = "主键不能为空") @PathVariable Long id) {
return R.ok(workStudyApplicationService.queryById(id));
}
/**
* 新增勤工俭学申请信息
*/
@Operation(summary = "新增勤工俭学申请信息")
// @SaCheckPermission("jcbt:workStudyApplication:add") // 暂时注释权限检查，用于测试
@Log(title = "勤工俭学申请信息", businessType = BusinessType.INSERT)
@RepeatSubmit()
@PostMapping()
public R<Void> add(@Validated(AddGroup.class) @RequestBody JcbtWorkStudyApplicationBo bo) {
return toAjax(workStudyApplicationService.insertByBo(bo));
}
/**
* 修改勤工俭学申请信息
*/
@Operation(summary = "修改勤工俭学申请信息")
@SaCheckPermission("jcbt:workStudyApplication:edit")
@Log(title = "勤工俭学申请信息", businessType = BusinessType.UPDATE)
@RepeatSubmit()
@PutMapping()
public R<Void> edit(@Validated(EditGroup.class) @RequestBody JcbtWorkStudyApplicationBo bo) {
return toAjax(workStudyApplicationService.updateByBo(bo));
}
/**
* 删除勤工俭学申请信息
*/
@Operation(summary = "删除勤工俭学申请信息")
@SaCheckPermission("jcbt:workStudyApplication:remove")
@Log(title = "勤工俭学申请信息", businessType = BusinessType.DELETE)
@DeleteMapping("/{ids}")
public R<Void> remove(@NotEmpty(message = "主键不能为空") @PathVariable Long[] ids) {
return toAjax(workStudyApplicationService.deleteWithValidByIds(List.of(ids), true));
}
/**
* 导出勤工俭学申请信息列表
*/
@Operation(summary = "导出勤工俭学申请信息列表")
@SaCheckPermission("jcbt:workStudyApplication:export")
@Log(title = "勤工俭学申请信息", businessType = BusinessType.EXPORT)
@PostMapping("/export")
public void export(JcbtWorkStudyApplicationBo bo, HttpServletResponse response) {
List<JcbtWorkStudyApplicationVo> list = workStudyApplicationService.queryList(bo);
ExcelUtil.exportExcel(list, "勤工俭学申请信息", JcbtWorkStudyApplicationVo.class, response);
}
/**
* 临时调试接口 - 直接查询数据库记录
*/
@GetMapping("/debug/{id}")
public R<Map<String, Object>> debugQuery(@PathVariable Long id) {
log.info("调试查询接口，ID: {}", id);
Map<String, Object> result = new HashMap<>();
try {
// 1. 查询实体类
JcbtWorkStudyApplication entity = baseMapper.selectById(id);
result.put("entity", entity);
result.put("entityExists", entity != null);
if (entity != null) {
result.put("entityDetails", "ID=" + entity.getId() + ", studentName=" + entity.getStudentName() + ", deleted=" + entity.getDeleted());
}
// 2. 查询VO类
JcbtWorkStudyApplicationVo vo = baseMapper.selectVoById(id);
result.put("vo", vo);
result.put("voExists", vo != null);
if (vo != null) {
result.put("voDetails", "ID=" + vo.getId() + ", studentName=" + vo.getStudentName());
}
// 3. 手动构建查询条件
LambdaQueryWrapper<JcbtWorkStudyApplication> wrapper = new LambdaQueryWrapper<>();
wrapper.eq(JcbtWorkStudyApplication::getId, id);
JcbtWorkStudyApplication manualEntity = baseMapper.selectOne(wrapper);
result.put("manualEntity", manualEntity);
result.put("manualEntityExists", manualEntity != null);
// 4. 查询数据库表中所有记录数量
Long totalCount = baseMapper.selectCount(new LambdaQueryWrapper<>());
result.put("totalRecords", totalCount);
} catch (Exception e) {
log.error("调试查询发生异常", e);
result.put("exception", e.getMessage());
}
return R.ok(result);
}
// ========== 业务功能接口（4个） ==========
/**
* 查询我的申请列表
*/
@Operation(summary = "查询我的申请列表")
@SaCheckPermission("jcbt:workStudyApplication:myList")
@GetMapping("/myList")
public TableDataInfo<JcbtWorkStudyApplicationVo> myList(JcbtWorkStudyApplicationBo bo, PageQuery pageQuery) {
return workStudyApplicationService.queryMyApplications(bo, pageQuery);
}
/**
* 查询待学院审核列表
*/
@Operation(summary = "查询待学院审核列表")
@SaCheckPermission("jcbt:workStudyApplication:collegeReview")
@GetMapping("/pendingCollegeReview")
public TableDataInfo<JcbtWorkStudyApplicationVo> pendingCollegeReview(JcbtWorkStudyApplicationBo bo, PageQuery pageQuery) {
return workStudyApplicationService.queryPendingCollegeReview(bo, pageQuery);
}
/**
* 查询待学生处审核列表
*/
@Operation(summary = "查询待学生处审核列表")
@SaCheckPermission("jcbt:workStudyApplication:finalReview")
@GetMapping("/pendingFinalReview")
public TableDataInfo<JcbtWorkStudyApplicationVo> pendingFinalReview(JcbtWorkStudyApplicationBo bo, PageQuery pageQuery) {
return workStudyApplicationService.queryPendingFinalReview(bo, pageQuery);
}
/**
* 获取岗位申请统计信息
*/
@Operation(summary = "获取岗位申请统计信息")
@SaCheckPermission("jcbt:workStudyApplication:statistics")
@GetMapping("/statistics/{positionId}")
public R<Map<String, Object>> getStatistics(@PathVariable Long positionId) {
return R.ok(workStudyApplicationService.getPositionApplicationStatistics(positionId));
}
// ========== 申请流程接口（6个） ==========
/**
* 提交申请
*/
@Operation(summary = "提交申请")
@SaCheckPermission("jcbt:workStudyApplication:submit")
@Log(title = "勤工俭学申请", businessType = BusinessType.UPDATE)
@PostMapping("/submit/{id}")
public R<Void> submitApplication(@PathVariable Long id) {
return toAjax(workStudyApplicationService.submitApplication(id));
}
/**
* 撤销申请
*/
@Operation(summary = "撤销申请")
@SaCheckPermission("jcbt:workStudyApplication:cancel")
@Log(title = "勤工俭学申请", businessType = BusinessType.UPDATE)
@PostMapping("/cancel/{id}")
public R<Void> cancelApplication(@PathVariable Long id) {
return toAjax(workStudyApplicationService.cancelApplication(id));
}
/**
* 学院审核
*/
@Operation(summary = "学院审核")
@SaCheckPermission("jcbt:workStudyApplication:collegeReview")
@Log(title = "勤工俭学申请学院审核", businessType = BusinessType.UPDATE)
@PostMapping("/collegeReview")
public R<Void> collegeReview(@Validated @RequestBody WorkStudyApplicationReviewBo reviewBo) {
return toAjax(workStudyApplicationService.collegeReview(reviewBo));
}
/**
* 学生处审核
*/
@Operation(summary = "学生处审核")
@SaCheckPermission("jcbt:workStudyApplication:finalReview")
@Log(title = "勤工俭学申请学生处审核", businessType = BusinessType.UPDATE)
@PostMapping("/finalReview")
public R<Void> finalReview(@Validated @RequestBody WorkStudyApplicationReviewBo reviewBo) {
return toAjax(workStudyApplicationService.finalReview(reviewBo));
}
/**
* 批量学院审核
*/
@Operation(summary = "批量学院审核")
@SaCheckPermission("jcbt:workStudyApplication:collegeReview")
@Log(title = "勤工俭学申请批量学院审核", businessType = BusinessType.UPDATE)
@PostMapping("/batchCollegeReview")
public R<Void> batchCollegeReview(
@RequestParam @NotEmpty(message = "申请ID不能为空") List<Long> ids,
@RequestParam @NotNull(message = "审核结果不能为空") String reviewResult,
@RequestParam(required = false) String reviewComment) {
return toAjax(workStudyApplicationService.batchCollegeReview(ids, reviewResult, reviewComment));
}
/**
* 批量学生处审核
*/
@Operation(summary = "批量学生处审核")
@SaCheckPermission("jcbt:workStudyApplication:finalReview")
@Log(title = "勤工俭学申请批量学生处审核", businessType = BusinessType.UPDATE)
@PostMapping("/batchFinalReview")
public R<Void> batchFinalReview(
@RequestParam @NotEmpty(message = "申请ID不能为空") List<Long> ids,
@RequestParam @NotNull(message = "审核结果不能为空") String reviewResult,
@RequestParam(required = false) String reviewComment) {
return toAjax(workStudyApplicationService.batchFinalReview(ids, reviewResult, reviewComment));
}
// ========== 辅助功能接口（3个） ==========
// 注意：学生信息相关功能已迁移到岗位管理模块或其他相应模块
/**
* 检查学生是否已申请该岗位
*/
@Operation(summary = "检查学生是否已申请该岗位")
@SaCheckPermission("jcbt:workStudyApplication:check")
@GetMapping("/hasApplied")
public R<Boolean> hasApplied(@RequestParam Long studentId, @RequestParam Long positionId) {
return R.ok(workStudyApplicationService.hasApplied(studentId, positionId));
}
/**
* 获取可用选项
*/
@Operation(summary = "获取可用选项")
@SaCheckPermission("jcbt:workStudyApplication:options")
@GetMapping("/options")
public R<Map<String, Object>> getOptions() {
Map<String, Object> options = Map.of(
"statusOptions", List.of(
Map.of("label", "已提交", "value", "SUBMITTED"),
Map.of("label", "学院审核通过", "value", "COLLEGE_APPROVED"),
Map.of("label", "学院审核拒绝", "value", "COLLEGE_REJECTED"),
Map.of("label", "学生处审核通过", "value", "FINAL_APPROVED"),
Map.of("label", "学生处审核拒绝", "value", "FINAL_REJECTED"),
Map.of("label", "已取消", "value", "CANCELLED")
),
"reviewStatusOptions", List.of(
Map.of("label", "待审核", "value", "PENDING"),
Map.of("label", "审核通过", "value", "APPROVED"),
Map.of("label", "审核拒绝", "value", "REJECTED")
)
);
return R.ok(options);
}
/**
* 获取当前用户学生信息
*/
@Operation(summary = "获取当前用户学生信息")
@SaCheckPermission("jcbt:workStudyApplication:query")
@GetMapping("/currentStudentInfo")
public R<XgStudentMsgVo> getCurrentStudentInfo() {
try {
// 获取当前登录用户ID
Long userId = LoginHelper.getUserId();
if (userId == null) {
return R.fail("用户未登录");
}
// 根据用户ID查询学生信息
XgStudentMsgVo studentInfo = xgStudentMsgService.queryByUserId(userId);
if (studentInfo == null) {
return R.fail("未找到当前用户的学生信息");
}
return R.ok(studentInfo);
} catch (Exception e) {
log.error("获取当前用户学生信息失败", e);
return R.fail("获取学生信息失败：" + e.getMessage());
}
}
}
backend/ruoyi-modules/ruoyi-jcbt/src/main/java/org/dromara/jcbt/controller/JcbtWorkStudyApplicationStudentAffairsReviewController.java
+294
View File
@@ -0,0 +1,294 @@
package org.dromara.jcbt.controller;
import cn.dev33.satoken.annotation.SaCheckPermission;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.Parameter;
import io.swagger.v3.oas.annotations.tags.Tag;
import jakarta.validation.constraints.NotEmpty;
import jakarta.validation.constraints.NotNull;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.dromara.common.core.domain.R;
import org.dromara.common.core.validate.AddGroup;
import org.dromara.common.core.validate.EditGroup;
import org.dromara.common.log.annotation.Log;
import org.dromara.common.log.enums.BusinessType;
import org.dromara.common.mybatis.core.page.PageQuery;
import org.dromara.common.mybatis.core.page.TableDataInfo;
import org.dromara.common.satoken.utils.LoginHelper;
import org.dromara.common.web.core.BaseController;
import org.dromara.jcbt.domain.bo.JcbtWorkStudyApplicationBo;
import org.dromara.jcbt.domain.bo.WorkStudyApplicationReviewBo;
import org.dromara.jcbt.domain.vo.JcbtWorkStudyApplicationVo;
import org.dromara.jcbt.service.IJcbtWorkStudyApplicationService;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
import java.util.*;
/**
* 勤工俭学申请学工处审核管理
* 专门为学工处审核人员提供的最终审批功能
*
* @author ruoyi
* @date 2025-01-13
*/
@Slf4j
@Validated
@Tag(name = "勤工俭学申请学工处审核管理", description = "专门为学工处审核人员提供的最终审批功能，可查看全校所有学院审核通过的申请")
@RestController
@RequestMapping("/jcbt/workStudyApplicationStudentAffairsReview")
@RequiredArgsConstructor
public class JcbtWorkStudyApplicationStudentAffairsReviewController extends BaseController {
private final IJcbtWorkStudyApplicationService workStudyApplicationService;
// ========== 学工处审批查询接口 ==========
/**
* 查询待学工处审核申请列表（学院审核通过的申请）
*/
@Operation(summary = "查询待学工处审核申请列表")
@SaCheckPermission("jcbt:workStudyApplication:studentAffairsReview")
@GetMapping("/pendingList")
public TableDataInfo<JcbtWorkStudyApplicationVo> pendingList(JcbtWorkStudyApplicationBo bo, PageQuery pageQuery) {
// 只查询学院审核通过状态的申请（待学工处审核）
bo.setStatus("COLLEGE_APPROVED");
return workStudyApplicationService.queryPendingFinalReview(bo, pageQuery);
}
/**
* 查询学工处审核历史列表（支持多状态筛选）
*/
@Operation(summary = "查询学工处审核历史列表")
@SaCheckPermission("jcbt:workStudyApplication:studentAffairsReview")
@GetMapping("/list")
public TableDataInfo<JcbtWorkStudyApplicationVo> list(JcbtWorkStudyApplicationBo bo, PageQuery pageQuery) {
// 学工处可查看所有相关状态的申请
if (bo.getStatus() == null || bo.getStatus().isEmpty()) {
// 如果没有指定状态，则查询学工处相关的所有状态
bo.setStatusList(Arrays.asList(
"COLLEGE_APPROVED", // 待学工处审核
"FINAL_APPROVED", // 学工处审核通过
"FINAL_REJECTED" // 学工处审核拒绝
));
}
return workStudyApplicationService.queryPageList(bo, pageQuery);
}
/**
* 获取勤工俭学申请详情
*/
@Operation(summary = "获取勤工俭学申请详情")
@SaCheckPermission("jcbt:workStudyApplication:studentAffairsReview")
@GetMapping("/{id}")
public R<JcbtWorkStudyApplicationVo> getInfo(@Parameter(description = "主键") @PathVariable Long id) {
JcbtWorkStudyApplicationVo vo = workStudyApplicationService.queryById(id);
if (vo == null) {
return R.fail("申请不存在");
}
// 检查申请状态是否适合学工处审核
if (!"COLLEGE_APPROVED".equals(vo.getStatus())
&& !"FINAL_APPROVED".equals(vo.getStatus())
&& !"FINAL_REJECTED".equals(vo.getStatus())) {
log.warn("申请ID {} 状态为 {}，不适合学工处查看", id, vo.getStatus());
}
return R.ok(vo);
}
// ========== 学工处审批操作接口 ==========
/**
* 学工处审核申请
*/
@Operation(summary = "学工处审核申请")
@SaCheckPermission("jcbt:workStudyApplication:studentAffairsReview")
@Log(title = "勤工俭学申请学工处审核", businessType = BusinessType.UPDATE)
@PutMapping("/review")
public R<Void> review(@Validated @RequestBody WorkStudyApplicationReviewBo reviewBo) {
// 验证申请是否存在
JcbtWorkStudyApplicationVo application = workStudyApplicationService.queryById(reviewBo.getApplicationId());
if (application == null) {
return R.fail("申请不存在");
}
// 验证申请状态是否可以进行学工处审核
if (!"COLLEGE_APPROVED".equals(application.getStatus())) {
return R.fail("申请状态不正确，只能审核学院审核通过的申请");
}
// 执行学工处审核
Boolean result = workStudyApplicationService.finalReview(reviewBo);
if (!result) {
return R.fail("审核失败");
}
log.info("学工处审核完成 - 申请ID: {}, 审核结果: {}, 审核人: {}",
reviewBo.getApplicationId(), reviewBo.getReviewResult(), LoginHelper.getUsername());
return R.ok();
}
/**
* 批量学工处审核
*/
@Operation(summary = "批量学工处审核")
@SaCheckPermission("jcbt:workStudyApplication:studentAffairsReview")
@Log(title = "勤工俭学申请批量学工处审核", businessType = BusinessType.UPDATE)
@PutMapping("/batchReview")
public R<Void> batchReview(
@Parameter(description = "申请ID集合") @RequestParam @NotEmpty List<Long> ids,
@Parameter(description = "审核结果") @RequestParam @NotNull String reviewResult,
@Parameter(description = "审核意见") @RequestParam String reviewComment) {
// 验证审核结果
if (!"APPROVED".equals(reviewResult) && !"REJECTED".equals(reviewResult)) {
return R.fail("审核结果只能是 APPROVED 或 REJECTED");
}
// 验证申请状态
for (Long id : ids) {
JcbtWorkStudyApplicationVo application = workStudyApplicationService.queryById(id);
if (application == null) {
return R.fail("申请ID " + id + " 不存在");
}
if (!"COLLEGE_APPROVED".equals(application.getStatus())) {
return R.fail("申请ID " + id + " 状态不正确，只能审核学院审核通过的申请");
}
}
// 执行批量审核
Boolean result = workStudyApplicationService.batchFinalReview(ids, reviewResult, reviewComment);
if (!result) {
return R.fail("批量审核失败");
}
log.info("批量学工处审核完成 - 申请数量: {}, 审核结果: {}, 审核人: {}",
ids.size(), reviewResult, LoginHelper.getUsername());
return R.ok();
}
// ========== 统计查询接口 ==========
/**
* 获取学工处审核统计信息
*/
@Operation(summary = "获取学工处审核统计信息")
@SaCheckPermission("jcbt:workStudyApplication:studentAffairsReview")
@GetMapping("/statistics")
public R<Map<String, Object>> getStatistics() {
// 构建查询条件
JcbtWorkStudyApplicationBo bo = new JcbtWorkStudyApplicationBo();
// 获取各状态申请数量
Map<String, Object> statistics = new HashMap<>();
// 待学工处审核数量（学院审核通过状态）
bo.setStatus("COLLEGE_APPROVED");
Long pendingCount = workStudyApplicationService.queryPageList(bo, new PageQuery(1, 1)).getTotal();
statistics.put("pendingCount", pendingCount);
// 学工处审核通过数量
bo.setStatus("FINAL_APPROVED");
Long approvedCount = workStudyApplicationService.queryPageList(bo, new PageQuery(1, 1)).getTotal();
statistics.put("approvedCount", approvedCount);
// 学工处审核拒绝数量
bo.setStatus("FINAL_REJECTED");
Long rejectedCount = workStudyApplicationService.queryPageList(bo, new PageQuery(1, 1)).getTotal();
statistics.put("rejectedCount", rejectedCount);
// 本月待审核数量
bo.setStatus("COLLEGE_APPROVED");
bo.setCreateTimeStart(getMonthStart());
bo.setCreateTimeEnd(getMonthEnd());
Long monthlyPendingCount = workStudyApplicationService.queryPageList(bo, new PageQuery(1, 1)).getTotal();
statistics.put("monthlyPendingCount", monthlyPendingCount);
// 总处理数量（学工处审核通过 + 学工处审核拒绝）
bo.setStatus(null);
bo.setCreateTimeStart(null);
bo.setCreateTimeEnd(null);
bo.setStatusList(Arrays.asList("FINAL_APPROVED", "FINAL_REJECTED"));
Long totalProcessedCount = workStudyApplicationService.queryPageList(bo, new PageQuery(1, 1)).getTotal();
statistics.put("totalProcessedCount", totalProcessedCount);
return R.ok(statistics);
}
/**
* 获取按学院分组的统计信息
*/
@Operation(summary = "获取按学院分组的统计信息")
@SaCheckPermission("jcbt:workStudyApplication:studentAffairsReview")
@GetMapping("/statisticsByCollege")
public R<Map<String, Object>> getStatisticsByCollege() {
// 构建查询条件
JcbtWorkStudyApplicationBo bo = new JcbtWorkStudyApplicationBo();
// 查询待审核的申请（按学院分组）
bo.setStatus("COLLEGE_APPROVED");
List<JcbtWorkStudyApplicationVo> pendingApplications = workStudyApplicationService.queryList(bo);
// 统计各学院待审核数量
Map<String, Long> collegeStatistics = new HashMap<>();
for (JcbtWorkStudyApplicationVo application : pendingApplications) {
String collegeName = application.getCollegeName();
if (collegeName != null) {
collegeStatistics.merge(collegeName, 1L, Long::sum);
}
}
Map<String, Object> result = new HashMap<>();
result.put("collegeStatistics", collegeStatistics);
result.put("totalColleges", collegeStatistics.size());
return R.ok(result);
}
/**
* 获取可用选项
*/
@Operation(summary = "获取可用选项")
@SaCheckPermission("jcbt:workStudyApplication:studentAffairsReview")
@GetMapping("/options")
public R<Map<String, Object>> getOptions() {
Map<String, Object> options = Map.of(
"statusOptions", List.of(
Map.of("label", "待学工处审核", "value", "COLLEGE_APPROVED"),
Map.of("label", "学工处审核通过", "value", "FINAL_APPROVED"),
Map.of("label", "学工处审核拒绝", "value", "FINAL_REJECTED")
),
"reviewStatusOptions", List.of(
Map.of("label", "审核通过", "value", "APPROVED"),
Map.of("label", "审核拒绝", "value", "REJECTED")
)
);
return R.ok(options);
}
// ========== 工具方法 ==========
/**
* 获取本月开始时间
*/
private String getMonthStart() {
java.time.LocalDateTime now = java.time.LocalDateTime.now();
java.time.LocalDateTime monthStart = now.withDayOfMonth(1).withHour(0).withMinute(0).withSecond(0).withNano(0);
return monthStart.format(java.time.format.DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
}
/**
* 获取本月结束时间
*/
private String getMonthEnd() {
java.time.LocalDateTime now = java.time.LocalDateTime.now();
java.time.LocalDateTime monthEnd = now.withDayOfMonth(now.toLocalDate().lengthOfMonth()).withHour(23).withMinute(59).withSecond(59).withNano(999999999);
return monthEnd.format(java.time.format.DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
}
}
backend/ruoyi-modules/ruoyi-jcbt/src/main/java/org/dromara/jcbt/controller/JcbtWorkStudyPositionController.java
+425
View File
@@ -0,0 +1,425 @@
package org.dromara.jcbt.controller;
import cn.dev33.satoken.annotation.SaCheckPermission;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.Parameter;
import io.swagger.v3.oas.annotations.tags.Tag;
import jakarta.servlet.http.HttpServletResponse;
import jakarta.validation.constraints.NotEmpty;
import jakarta.validation.constraints.NotNull;
import lombok.extern.slf4j.Slf4j;
import org.dromara.common.core.domain.R;
import org.dromara.common.core.validate.AddGroup;
import org.dromara.common.core.validate.EditGroup;
import org.dromara.common.excel.utils.ExcelUtil;
import org.dromara.common.idempotent.annotation.RepeatSubmit;
import org.dromara.common.log.annotation.Log;
import org.dromara.common.log.enums.BusinessType;
import org.dromara.common.mybatis.core.page.PageQuery;
import org.dromara.common.mybatis.core.page.TableDataInfo;
import org.dromara.common.satoken.utils.LoginHelper;
import org.dromara.common.web.core.BaseController;
import org.dromara.jcbt.domain.bo.JcbtWorkStudyPositionBo;
import org.dromara.jcbt.domain.vo.JcbtWorkStudyPositionVo;
import org.dromara.jcbt.enums.PositionStatusEnum;
import org.dromara.jcbt.enums.PositionScopeEnum;
import org.dromara.jcbt.service.IJcbtWorkStudyPositionService;
import org.dromara.xg.domain.vo.XgStudentMsgVo;
import org.dromara.xg.service.IXgStudentMsgService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
import java.util.List;
import java.util.Map;
/**
* 勤工俭学岗位信息管理
*
* @author ruoyi
* @date 2025-01-03
*/
@Slf4j
@Validated
@Tag(name = "勤工俭学岗位信息管理", description = "勤工俭学岗位信息管理Controller")
@RestController
@RequestMapping("/jcbt/workStudyPosition")
public class JcbtWorkStudyPositionController extends BaseController {
@Autowired
private IJcbtWorkStudyPositionService workStudyPositionService;
@Autowired
private IXgStudentMsgService xgStudentMsgService;
// ========== 基础管理接口（6个） ==========
/**
* 查询勤工俭学岗位信息列表
*/
@Operation(summary = "查询勤工俭学岗位信息列表")
@SaCheckPermission("jcbt:workStudyPosition:list")
@GetMapping("/list")
public TableDataInfo<JcbtWorkStudyPositionVo> list(JcbtWorkStudyPositionBo bo, PageQuery pageQuery) {
return workStudyPositionService.queryPageList(bo, pageQuery);
}
/**
* 获取勤工俭学岗位信息详细信息
*/
@Operation(summary = "获取勤工俭学岗位信息详细信息")
@SaCheckPermission("jcbt:workStudyPosition:query")
@GetMapping("/{id}")
public R<JcbtWorkStudyPositionVo> getInfo(@NotNull(message = "主键不能为空")
@Parameter(description = "岗位ID", required = true)
@PathVariable Long id) {
return R.ok(workStudyPositionService.queryById(id));
}
/**
* 获取岗位详情及当前用户申请状态
*/
@Operation(summary = "获取岗位详情及当前用户申请状态")
@SaCheckPermission("jcbt:workStudyPosition:query")
@GetMapping("/{id}/withApplicationStatus")
public R<Map<String, Object>> getPositionWithApplicationStatus(@NotNull(message = "主键不能为空")
@Parameter(description = "岗位ID", required = true)
@PathVariable Long id) {
// 获取岗位详情
JcbtWorkStudyPositionVo position = workStudyPositionService.queryById(id);
if (position == null) {
return R.fail("岗位不存在");
}
// 获取当前用户的申请状态
Long currentUserId = LoginHelper.getUserId();
Map<String, Object> applicationStatus = workStudyPositionService.getUserApplicationStatus(id, currentUserId);
// 组装返回数据
Map<String, Object> result = Map.of(
"position", position,
"applicationStatus", applicationStatus
);
return R.ok(result);
}
/**
* 新增勤工俭学岗位信息
*/
@Operation(summary = "新增勤工俭学岗位信息")
@SaCheckPermission("jcbt:workStudyPosition:add")
@Log(title = "勤工俭学岗位信息", businessType = BusinessType.INSERT)
@RepeatSubmit()
@PostMapping()
public R<Void> add(@Validated(AddGroup.class) @RequestBody JcbtWorkStudyPositionBo bo) {
return toAjax(workStudyPositionService.insertByBo(bo));
}
/**
* 修改勤工俭学岗位信息
*/
@Operation(summary = "修改勤工俭学岗位信息")
@SaCheckPermission("jcbt:workStudyPosition:edit")
@Log(title = "勤工俭学岗位信息", businessType = BusinessType.UPDATE)
@RepeatSubmit()
@PutMapping()
public R<Void> edit(@Validated(EditGroup.class) @RequestBody JcbtWorkStudyPositionBo bo) {
return toAjax(workStudyPositionService.updateByBo(bo));
}
/**
* 删除勤工俭学岗位信息
*/
@Operation(summary = "删除勤工俭学岗位信息")
@SaCheckPermission("jcbt:workStudyPosition:remove")
@Log(title = "勤工俭学岗位信息", businessType = BusinessType.DELETE)
@DeleteMapping("/{ids}")
public R<Void> remove(@NotEmpty(message = "主键不能为空")
@Parameter(description = "岗位ID列表", required = true)
@PathVariable Long[] ids) {
return toAjax(workStudyPositionService.deleteWithValidByIds(List.of(ids), true));
}
/**
* 导出勤工俭学岗位信息列表
*/
@Operation(summary = "导出勤工俭学岗位信息列表")
@SaCheckPermission("jcbt:workStudyPosition:export")
@Log(title = "勤工俭学岗位信息", businessType = BusinessType.EXPORT)
@PostMapping("/export")
public void export(JcbtWorkStudyPositionBo bo, HttpServletResponse response) {
List<JcbtWorkStudyPositionVo> list = workStudyPositionService.queryList(bo);
ExcelUtil.exportExcel(list, "勤工俭学岗位信息", JcbtWorkStudyPositionVo.class, response);
}
// ========== 业务功能接口（4个） ==========
/**
* 我的岗位 - 查询当前用户所在学院的岗位
*/
@Operation(summary = "我的岗位")
@SaCheckPermission("jcbt:workStudyPosition:myList")
@GetMapping("/myList")
public TableDataInfo<JcbtWorkStudyPositionVo> myList(PageQuery pageQuery) {
// TODO: 获取当前用户所在学院ID
Long collegeId = getCurrentUserCollegeId();
return workStudyPositionService.queryByCollegeId(collegeId, pageQuery);
}
/**
* 可见岗位 - 查询学院可见的岗位（本学院岗位 + 全校范围岗位）
*/
@Operation(summary = "可见岗位")
@SaCheckPermission("jcbt:workStudyPosition:visibleList")
@GetMapping("/visibleList")
public TableDataInfo<JcbtWorkStudyPositionVo> visibleList(
JcbtWorkStudyPositionBo bo,
PageQuery pageQuery,
@Parameter(description = "是否排除已申请岗位") @RequestParam(defaultValue = "false") Boolean excludeApplied) {
// 获取当前用户所在学院ID
Long collegeId = getCurrentUserCollegeId();
Long userId = null;
if (excludeApplied) {
// 排除当前用户已申请的岗位 - 用于学生申请页面
userId = LoginHelper.getUserId();
if (userId == null) {
return TableDataInfo.build();
}
// 查询学生信息获取学院ID（覆盖默认学院ID）
try {
XgStudentMsgVo studentInfo = xgStudentMsgService.queryByUserId(userId);
if (studentInfo != null && studentInfo.getCollegeId() != null) {
collegeId = Long.parseLong(studentInfo.getCollegeId());
}
} catch (Exception e) {
log.warn("获取学生学院ID失败: {}", e.getMessage());
}
}
// 统一调用重载的方法
return workStudyPositionService.queryVisiblePositions(bo, pageQuery, collegeId, excludeApplied, userId);
}
/**
* 岗位状态检查 - 检查岗位是否可以申请
*/
@Operation(summary = "岗位状态检查")
@SaCheckPermission("jcbt:workStudyPosition:checkAvailable")
@GetMapping("/checkAvailable/{id}")
public R<Boolean> checkAvailable(@NotNull(message = "主键不能为空")
@Parameter(description = "岗位ID", required = true)
@PathVariable Long id) {
return R.ok(workStudyPositionService.checkPositionAvailable(id));
}
/**
* 岗位统计 - 获取岗位统计信息
*/
@Operation(summary = "岗位统计")
@SaCheckPermission("jcbt:workStudyPosition:statistics")
@GetMapping("/statistics")
public R<Map<String, Object>> statistics(@Parameter(description = "学院ID") @RequestParam(required = false) Long collegeId) {
return R.ok(workStudyPositionService.getPositionStatistics(collegeId));
}
// ========== 辅助功能接口（6个） ==========
/**
* 发布岗位
*/
@Operation(summary = "发布岗位")
@SaCheckPermission("jcbt:workStudyPosition:publish")
@Log(title = "勤工俭学岗位信息", businessType = BusinessType.UPDATE)
@PutMapping("/publish/{id}")
public R<Void> publish(@NotNull(message = "主键不能为空")
@Parameter(description = "岗位ID", required = true)
@PathVariable Long id) {
return toAjax(workStudyPositionService.publishPosition(id));
}
/**
* 开启招录
*/
@Operation(summary = "开启招录")
@SaCheckPermission("jcbt:workStudyPosition:startRecruiting")
@Log(title = "勤工俭学岗位信息", businessType = BusinessType.UPDATE)
@PutMapping("/startRecruiting/{id}")
public R<Void> startRecruiting(@NotNull(message = "主键不能为空")
@Parameter(description = "岗位ID", required = true)
@PathVariable Long id) {
return toAjax(workStudyPositionService.startRecruiting(id));
}
/**
* 暂停招录
*/
@Operation(summary = "暂停招录")
@SaCheckPermission("jcbt:workStudyPosition:suspend")
@Log(title = "勤工俭学岗位信息", businessType = BusinessType.UPDATE)
@PutMapping("/suspend/{id}")
public R<Void> suspend(@NotNull(message = "主键不能为空")
@Parameter(description = "岗位ID", required = true)
@PathVariable Long id) {
return toAjax(workStudyPositionService.suspendPosition(id));
}
/**
* 取消岗位
*/
@Operation(summary = "取消岗位")
@SaCheckPermission("jcbt:workStudyPosition:cancel")
@Log(title = "勤工俭学岗位信息", businessType = BusinessType.UPDATE)
@PutMapping("/cancel/{id}")
public R<Void> cancel(@NotNull(message = "主键不能为空")
@Parameter(description = "岗位ID", required = true)
@PathVariable Long id) {
return toAjax(workStudyPositionService.cancelPosition(id));
}
/**
* 批量更新状态
*/
@Operation(summary = "批量更新状态")
@SaCheckPermission("jcbt:workStudyPosition:batchUpdateStatus")
@Log(title = "勤工俭学岗位信息", businessType = BusinessType.UPDATE)
@PutMapping("/batchUpdateStatus")
public R<Void> batchUpdateStatus(@RequestParam @NotEmpty(message = "岗位ID列表不能为空") List<Long> ids,
@RequestParam @NotNull(message = "状态不能为空") String status) {
return toAjax(workStudyPositionService.batchUpdateStatus(ids, status));
}
/**
* 按状态分组统计
*/
@Operation(summary = "按状态分组统计")
@SaCheckPermission("jcbt:workStudyPosition:countByStatus")
@GetMapping("/countByStatus")
public R<List<Map<String, Object>>> countByStatus(@Parameter(description = "学院ID") @RequestParam(required = false) Long collegeId) {
return R.ok(workStudyPositionService.countByStatus(collegeId));
}
// ========== 字典选项接口 ==========
/**
* 获取岗位状态选项
*/
@Operation(summary = "获取岗位状态选项")
@GetMapping("/statusOptions")
public R<Map<String, String>> statusOptions() {
Map<String, String> options = Map.of(
PositionStatusEnum.DRAFT.getCode(), PositionStatusEnum.DRAFT.getDescription(),
PositionStatusEnum.PUBLISHED.getCode(), PositionStatusEnum.PUBLISHED.getDescription(),
PositionStatusEnum.RECRUITING.getCode(), PositionStatusEnum.RECRUITING.getDescription(),
PositionStatusEnum.FULL.getCode(), PositionStatusEnum.FULL.getDescription(),
PositionStatusEnum.EXPIRED.getCode(), PositionStatusEnum.EXPIRED.getDescription(),
PositionStatusEnum.SUSPENDED.getCode(), PositionStatusEnum.SUSPENDED.getDescription(),
PositionStatusEnum.CANCELLED.getCode(), PositionStatusEnum.CANCELLED.getDescription()
);
return R.ok(options);
}
/**
* 获取岗位发布范围选项
*/
@Operation(summary = "获取岗位发布范围选项")
@GetMapping("/scopeOptions")
public R<Map<String, String>> scopeOptions() {
Map<String, String> options = Map.of(
PositionScopeEnum.COLLEGE.getCode(), PositionScopeEnum.COLLEGE.getDescription(),
PositionScopeEnum.UNIVERSITY.getCode(), PositionScopeEnum.UNIVERSITY.getDescription()
);
return R.ok(options);
}
// ========== 数据查询接口 ==========
/**
* 根据状态查询岗位
*/
@Operation(summary = "根据状态查询岗位")
@SaCheckPermission("jcbt:workStudyPosition:queryByStatus")
@GetMapping("/queryByStatus")
public TableDataInfo<JcbtWorkStudyPositionVo> queryByStatus(@RequestParam String status, PageQuery pageQuery) {
return workStudyPositionService.queryByStatus(status, pageQuery);
}
/**
* 根据发布范围查询岗位
*/
@Operation(summary = "根据发布范围查询岗位")
@SaCheckPermission("jcbt:workStudyPosition:queryByScope")
@GetMapping("/queryByScope")
public TableDataInfo<JcbtWorkStudyPositionVo> queryByScope(@RequestParam String positionScope, PageQuery pageQuery) {
return workStudyPositionService.queryByPositionScope(positionScope, pageQuery);
}
/**
* 即将过期的岗位
*/
@Operation(summary = "即将过期的岗位")
@SaCheckPermission("jcbt:workStudyPosition:expiringPositions")
@GetMapping("/expiringPositions")
public R<List<JcbtWorkStudyPositionVo>> expiringPositions(@RequestParam(defaultValue = "7") int days) {
return R.ok(workStudyPositionService.getExpiringPositions(days));
}
/**
* 热门岗位
*/
@Operation(summary = "热门岗位")
@SaCheckPermission("jcbt:workStudyPosition:popularPositions")
@GetMapping("/popularPositions")
public R<List<JcbtWorkStudyPositionVo>> popularPositions(@RequestParam(defaultValue = "10") int limit) {
return R.ok(workStudyPositionService.getPopularPositions(limit));
}
// ========== 定时任务接口 ==========
/**
* 更新过期岗位状态（定时任务调用）
*/
@Operation(summary = "更新过期岗位状态")
@SaCheckPermission("jcbt:workStudyPosition:updateExpired")
@PostMapping("/updateExpired")
public R<Integer> updateExpiredPositions() {
int count = workStudyPositionService.updateExpiredPositions();
return R.ok("更新了 " + count + " 个过期岗位", count);
}
/**
* 更新满员岗位状态（定时任务调用）
*/
@Operation(summary = "更新满员岗位状态")
@SaCheckPermission("jcbt:workStudyPosition:updateFull")
@PostMapping("/updateFull")
public R<Integer> updateFullPositions() {
int count = workStudyPositionService.updateFullPositions();
return R.ok("更新了 " + count + " 个满员岗位", count);
}
/**
* 学生查看可申请的岗位列表（公开接口，无需权限）
*/
@Operation(summary = "学生查看可申请的岗位列表")
@GetMapping("/student/available")
public TableDataInfo<JcbtWorkStudyPositionVo> getAvailablePositionsForStudent(JcbtWorkStudyPositionBo bo, PageQuery pageQuery) {
// 只查询已发布、招录中、已发布状态的岗位
bo.setStatus(null); // 清除状态过滤，在Service层处理
return workStudyPositionService.queryAvailablePositionsForStudent(bo, pageQuery);
}
// ========== 私有方法 ==========
/**
* 获取当前用户所在学院ID
* TODO: 实现获取当前用户学院ID的逻辑
*/
private Long getCurrentUserCollegeId() {
// 临时返回固定值，实际应该从用户信息中获取
return 1L;
}
}
backend/ruoyi-modules/ruoyi-jcbt/src/main/java/org/dromara/jcbt/domain/JcbtAssistanceType.java
+66
View File
@@ -0,0 +1,66 @@
package org.dromara.jcbt.domain;
import com.baomidou.mybatisplus.annotation.*;
import lombok.Data;
import lombok.EqualsAndHashCode;
import org.dromara.common.mybatis.core.domain.BaseEntity;
import java.io.Serial;
/**
* 申请自助类型对象 jcbt_assistance_type
*
* @author ruoyi
* @date 2025-08-09
*/
@Data
@EqualsAndHashCode(callSuper = true)
@TableName("jcbt_assistance_type")
public class JcbtAssistanceType extends BaseEntity {
@Serial
private static final long serialVersionUID = 1L;
/**
* 主键ID
*/
@TableId(value = "id")
private Long id;
/**
* 自助类型编码
*/
private String assistanceCode;
/**
* 自助类型名称
*/
private String assistanceName;
/**
* 自助类型描述
*/
private String assistanceDescription;
/**
* 是否支持多选（0单选 1多选）
*/
private Integer isMultiSelect;
/**
* 排序号
*/
private Integer sortOrder;
/**
* 状态（0正常 1停用）
*/
private String status;
/**
* 逻辑删除标记
*/
@TableLogic
private Long deleted;
}
backend/ruoyi-modules/ruoyi-jcbt/src/main/java/org/dromara/jcbt/domain/JcbtPovertyApplication.java
+211
View File
@@ -0,0 +1,211 @@
package org.dromara.jcbt.domain;
import com.baomidou.mybatisplus.annotation.*;
import lombok.Data;
import lombok.EqualsAndHashCode;
import org.dromara.common.mybatis.core.domain.BaseEntity;
import java.io.Serial;
/**
* 贫困生认定申请对象 jcbt_poverty_application
*
* @author ruoyi
* @date 2025-08-09
*/
@Data
@EqualsAndHashCode(callSuper = true)
@TableName("jcbt_poverty_application")
public class JcbtPovertyApplication extends BaseEntity {
@Serial
private static final long serialVersionUID = 1L;
/**
* 主键ID
*/
@TableId(value = "id")
private Long id;
/**
* 申请编号
*/
private String applicationNo;
/**
* 学年
*/
private String academicYear;
/**
* 学期
*/
private Integer term;
/**
* 学生ID
*/
private Long studentId;
/**
* 学号
*/
private String studentNo;
/**
* 学生姓名
*/
private String studentName;
/**
* 性别
*/
private String gender;
/**
* 学院ID
*/
private Long collegeId;
/**
* 学院名称
*/
private String collegeName;
/**
* 专业ID
*/
private Long majorId;
/**
* 专业名称
*/
private String majorName;
/**
* 班级ID
*/
private Long classId;
/**
* 班级名称
*/
private String className;
/**
* 班主任教师ID
*/
private Long teacherId;
/**
* 班主任教师姓名
*/
private String teacherName;
/**
* 认定群体（特殊群体/其他群体）
*/
private String recognitionGroup;
/**
* 认定类型ID
*/
private Long recognitionTypeId;
/**
* 认定类型编码
*/
private String recognitionTypeCode;
/**
* 认定类型名称
*/
private String recognitionTypeName;
/**
* 申请自助类型ID数组（多选）
*/
private String assistanceTypeIds;
/**
* 申请自助类型名称（多个用逗号分隔）
*/
private String assistanceTypeNames;
/**
* 家庭经济情况摘要
*/
private String familyEconomySummary;
/**
* 申请表附件URL
*/
private String attachApplicationFormUrl;
/**
* 申请表附件ID
*/
private Long attachApplicationFormId;
/**
* 调查表附件URL
*/
private String attachSurveyFormUrl;
/**
* 调查表附件ID
*/
private Long attachSurveyFormId;
/**
* 申请状态
*/
private String status;
/**
* 提交人ID
*/
private Long submitterId;
/**
* 提交人姓名
*/
private String submitterName;
/**
* 提交时间
*/
private java.util.Date submitTime;
/**
* 审核人ID
*/
private Long auditorId;
/**
* 审核人姓名
*/
private String auditorName;
/**
* 审核时间
*/
private java.util.Date auditTime;
/**
* 审核意见
*/
private String auditOpinion;
/**
* 备注
*/
private String remark;
/**
* 逻辑删除标记
*/
@TableLogic
private Long deleted;
}
backend/ruoyi-modules/ruoyi-jcbt/src/main/java/org/dromara/jcbt/domain/JcbtRecognitionType.java
+71
View File
@@ -0,0 +1,71 @@
package org.dromara.jcbt.domain;
import com.baomidou.mybatisplus.annotation.*;
import lombok.Data;
import lombok.EqualsAndHashCode;
import org.dromara.common.mybatis.core.domain.BaseEntity;
import java.io.Serial;
/**
* 认定类型对象 jcbt_recognition_type
*
* @author ruoyi
* @date 2025-08-09
*/
@Data
@EqualsAndHashCode(callSuper = true)
@TableName("jcbt_recognition_type")
public class JcbtRecognitionType extends BaseEntity {
@Serial
private static final long serialVersionUID = 1L;
/**
* 主键ID
*/
@TableId(value = "id")
private Long id;
/**
* 类型分组（special特殊群体/other其他群体）
*/
private String typeGroup;
/**
* 类型编码
*/
private String typeCode;
/**
* 类型名称
*/
private String typeName;
/**
* 类型描述
*/
private String typeDescription;
/**
* 证明材料要求
*/
private String certificateRequirement;
/**
* 排序号
*/
private Integer sortOrder;
/**
* 状态（0正常 1停用）
*/
private String status;
/**
* 逻辑删除标记
*/
@TableLogic
private Long deleted;
}
backend/ruoyi-modules/ruoyi-jcbt/src/main/java/org/dromara/jcbt/domain/JcbtScholarshipApplication.java
+159
View File
@@ -0,0 +1,159 @@
package org.dromara.jcbt.domain;
import com.baomidou.mybatisplus.annotation.*;
import com.fasterxml.jackson.annotation.JsonIgnore;
import lombok.Data;
import lombok.EqualsAndHashCode;
import org.dromara.common.mybatis.core.domain.BaseEntity;
import java.io.Serial;
import java.util.Date;
/**
* 奖学金申请记录对象 jcbt_scholarship_application
*
* @author ruoyi
* @date 2025-01-01
*/
@Data
@EqualsAndHashCode(callSuper = true)
@TableName("jcbt_scholarship_application")
public class JcbtScholarshipApplication extends BaseEntity {
/**
* 重写父类的createDept字段，排除此字段因为数据库表中不存在create_dept列
* 通过重新声明字段并标记为不存在来避免MyBatis-Plus自动处理
*/
@TableField(exist = false)
private Long createDept;
@Serial
private static final long serialVersionUID = 1L;
/**
* 主键ID
*/
@TableId(value = "id")
private Long id;
/**
* 申请编号
*/
@TableField("application_no")
private String applicationNo;
/**
* 批次ID
*/
private Long batchId;
/**
* 奖学金类型ID
*/
private Long scholarshipTypeId;
/**
* 学生学号
*/
@TableField("student_no")
private String studentNo;
/**
* 学生姓名
*/
private String studentName;
/**
* 学生ID
*/
private Long studentId;
/**
* 学院ID
*/
private Long deptId;
/**
* 专业ID
*/
private Long majorId;
/**
* 班级ID
*/
private Long classId;
/**
* 申请类型：RECOMMEND-教师推荐，AUTO-自动评定，DIRECT-直接指定
*/
@TableField("application_type")
private String applicationType;
/**
* 申请原因
*/
@TableField("apply_reason")
private String applyReason;
/**
* 自我评价
*/
@TableField("self_evaluation")
private String selfEvaluation;
/**
* 系统计算分数
*/
@TableField("calculated_score")
private Double calculatedScore;
/**
* 最终评定分数
*/
@TableField("final_score")
private Double finalScore;
/**
* 在院系的排名
*/
@TableField("ranking_in_dept")
private Integer rankingInDept;
/**
* 在专业的排名
*/
@TableField("ranking_in_major")
private Integer rankingInMajor;
/**
* 当前状态：DRAFT-草稿，SUBMITTED-已提交，REVIEWING-审核中，APPROVED-已通过，REJECTED-已拒绝，WITHDRAWN-已撤回
*/
@TableField("current_status")
private String currentStatus;
/**
* 提交时间
*/
private Date submitTime;
/**
* 租户ID
*/
private String tenantId;
/**
* 删除标志
*/
@TableLogic
private Integer deleted;
}
backend/ruoyi-modules/ruoyi-jcbt/src/main/java/org/dromara/jcbt/domain/JcbtScholarshipAttachment.java
+131
View File
@@ -0,0 +1,131 @@
package org.dromara.jcbt.domain;
import com.baomidou.mybatisplus.annotation.*;
import lombok.Data;
import lombok.EqualsAndHashCode;
import org.dromara.common.mybatis.core.domain.BaseEntity;
import java.io.Serial;
/**
* 奖学金申请材料对象 jcbt_scholarship_attachment
*
* @author ruoyi
* @date 2025-01-01
*/
@Data
@EqualsAndHashCode(callSuper = true)
@TableName("jcbt_scholarship_attachment")
public class JcbtScholarshipAttachment extends BaseEntity {
@Serial
private static final long serialVersionUID = 1L;
/**
* 主键ID
*/
@TableId(value = "id")
private Long id;
/**
* 申请记录ID
*/
private Long applicationId;
/**
* 批次ID
*/
private Long batchId;
/**
* 奖学金类型ID
*/
private Long scholarshipTypeId;
/**
* 材料类型：TRANSCRIPT-成绩单，CERTIFICATE-获奖证书，RECOMMENDATION-推荐信，FAMILY_PROOF-家庭经济证明，OTHER-其他材料
*/
private String materialType;
/**
* 材料名称
*/
private String materialName;
/**
* 材料描述
*/
private String materialDescription;
/**
* 文件名称
*/
private String fileName;
/**
* 文件路径
*/
private String filePath;
/**
* 文件大小（字节）
*/
private Long fileSize;
/**
* 文件类型
*/
private String fileType;
/**
* 上传者类型：STUDENT-学生，TEACHER-教师
*/
private String uploaderType;
/**
* 上传者ID
*/
private Long uploaderId;
/**
* 上传者姓名
*/
private String uploaderName;
/**
* 审核状态：PENDING-待审核，APPROVED-已通过，REJECTED-已拒绝
*/
private String auditStatus;
/**
* 审核意见
*/
private String auditComment;
/**
* 是否必须：0-否，1-是
*/
private Integer isRequired;
/**
* 排序号
*/
private Integer sortOrder;
/**
* 备注
*/
private String remark;
/**
* 租户ID
*/
private String tenantId;
/**
* 删除标志
*/
@TableLogic
private Integer deleted;
}
backend/ruoyi-modules/ruoyi-jcbt/src/main/java/org/dromara/jcbt/domain/JcbtScholarshipBatch.java
+118
View File
@@ -0,0 +1,118 @@
package org.dromara.jcbt.domain;
import com.baomidou.mybatisplus.annotation.*;
import lombok.Data;
import lombok.EqualsAndHashCode;
import org.dromara.common.mybatis.core.domain.BaseEntity;
import java.util.Date;
import java.util.List;
/**
* 奖学金评定批次对象 jcbt_scholarship_batch
*
* @author ruoyi
* @date 2025-01-27
*/
@Data
@EqualsAndHashCode(callSuper = true)
@TableName("jcbt_scholarship_batch")
public class JcbtScholarshipBatch extends BaseEntity {
private static final long serialVersionUID = 1L;
/**
* 主键ID
*/
@TableId(value = "id")
private Long id;
/**
* 批次编码
*/
private String batchCode;
/**
* 批次名称
*/
private String batchName;
/**
* 学年
*/
private String academicYear;
/**
* 学期：1-第一学期，2-第二学期，3-全年
*/
private Integer semester;
/**
* 批次类型：REGULAR-常规批次，SPECIAL-专项批次，SUPPLEMENTARY-补充批次
*/
private String batchType;
/**
* 开始时间
*/
private Date startTime;
/**
* 结束时间
*/
private Date endTime;
/**
* 申请开始时间
*/
private Date applyStartTime;
/**
* 申请结束时间
*/
private Date applyEndTime;
/**
* 审核开始时间
*/
private Date reviewStartTime;
/**
* 审核结束时间
*/
private Date reviewEndTime;
/**
* 状态：DRAFT-草稿，ACTIVE-进行中，COMPLETED-已完成，CANCELLED-已取消
*/
private String status;
/**
* 批次描述
*/
private String description;
/**
* 通知内容
*/
private String noticeContent;
/**
* 租户ID
*/
@TableField("tenant_id")
private Long tenantId;
/**
* 删除标记
*/
@TableLogic
private Integer deleted;
/**
* 关联的奖学金类型ID列表（非数据库字段）
*/
@TableField(exist = false)
private List<Long> scholarshipTypeIds;
}
backend/ruoyi-modules/ruoyi-jcbt/src/main/java/org/dromara/jcbt/domain/JcbtScholarshipBatchType.java
+58
View File
@@ -0,0 +1,58 @@
package org.dromara.jcbt.domain;
import com.baomidou.mybatisplus.annotation.*;
import lombok.Data;
import lombok.EqualsAndHashCode;
import org.dromara.common.mybatis.core.domain.BaseEntity;
/**
* 奖学金批次类型关联对象 jcbt_scholarship_batch_type
*
* @author ruoyi
* @date 2025-01-27
*/
@Data
@EqualsAndHashCode(callSuper = true)
@TableName("jcbt_scholarship_batch_type")
public class JcbtScholarshipBatchType extends BaseEntity {
private static final long serialVersionUID = 1L;
/**
* 主键ID
*/
@TableId(value = "id")
private Long id;
/**
* 批次ID
*/
private Long batchId;
/**
* 奖学金类型ID
*/
private Long scholarshipTypeId;
/**
* 是否启用：0-禁用，1-启用
*/
private Integer isActive;
/**
* 排序号
*/
private Integer sortOrder;
/**
* 租户ID
*/
private String tenantId;
/**
* 删除标志
*/
@TableLogic
private Integer deleted;
}
backend/ruoyi-modules/ruoyi-jcbt/src/main/java/org/dromara/jcbt/domain/JcbtScholarshipClassQuota.java
+111
View File
@@ -0,0 +1,111 @@
package org.dromara.jcbt.domain;
import com.baomidou.mybatisplus.annotation.*;
import lombok.Data;
import lombok.EqualsAndHashCode;
import org.dromara.common.mybatis.core.domain.BaseEntity;
import java.io.Serial;
/**
* 奖学金班级名额分配对象 jcbt_scholarship_class_quota
*
* @author ruoyi
* @date 2025-01-01
*/
@Data
@EqualsAndHashCode(callSuper = true)
@TableName("jcbt_scholarship_class_quota")
public class JcbtScholarshipClassQuota extends BaseEntity {
@Serial
private static final long serialVersionUID = 1L;
/**
* 主键ID
*/
@TableId(value = "id")
private Long id;
/**
* 批次ID
*/
private Long batchId;
/**
* 奖学金类型ID
*/
private Long scholarshipTypeId;
/**
* 学院ID
*/
private Long deptId;
/**
* 班级ID
*/
private Long classId;
/**
* 班级名称
*/
private String className;
/**
* 总名额
*/
private Integer totalQuota;
/**
* 已使用名额
*/
private Integer usedQuota;
/**
* 预留名额
*/
private Integer reservedQuota;
/**
* 可用名额
*/
private Integer availableQuota;
/**
* 分配方式：MANUAL-手动分配，AUTO-自动分配，PROPORTIONAL-按比例分配
*/
private String allocationMethod;
/**
* 分配依据说明
*/
private String allocationBasis;
/**
* 是否锁定：0-否，1-是
*/
private Integer isLocked;
/**
* 状态：ACTIVE-生效，INACTIVE-失效，SUSPENDED-暂停
*/
private String status;
/**
* 备注
*/
private String remark;
/**
* 租户ID
*/
private String tenantId;
/**
* 删除标志
*/
@TableLogic
private Integer deleted;
}
backend/ruoyi-modules/ruoyi-jcbt/src/main/java/org/dromara/jcbt/domain/JcbtScholarshipCompatibility.java
+68
View File
@@ -0,0 +1,68 @@
package org.dromara.jcbt.domain;
import com.baomidou.mybatisplus.annotation.*;
import lombok.Data;
import lombok.EqualsAndHashCode;
import org.dromara.common.mybatis.core.domain.BaseEntity;
/**
* 奖学金兼得关系对象 jcbt_scholarship_compatibility
*
* @author ruoyi
* @date 2025-01-27
*/
@Data
@EqualsAndHashCode(callSuper = true)
@TableName("jcbt_scholarship_compatibility")
public class JcbtScholarshipCompatibility extends BaseEntity {
private static final long serialVersionUID = 1L;
/**
* 主键ID
*/
@TableId(value = "id")
private Long id;
/**
* 奖学金类型1
*/
@TableField("type_id_1")
private Long typeId1;
/**
* 奖学金类型2
*/
@TableField("type_id_2")
private Long typeId2;
/**
* 关系类型：COMPATIBLE-兼容，EXCLUSIVE-互斥，PRIORITY-优先级关系
*/
@TableField("relation_type")
private String relationType;
/**
* 优先级（relation_type为PRIORITY时有效）
*/
@TableField("priority_level")
private Integer priorityLevel;
/**
* 关系描述
*/
private String description;
/**
* 租户ID
*/
@TableField("tenant_id")
private Long tenantId;
/**
* 删除标记
*/
@TableLogic
private Integer deleted;
}
backend/ruoyi-modules/ruoyi-jcbt/src/main/java/org/dromara/jcbt/domain/JcbtScholarshipQuota.java
+125
View File
@@ -0,0 +1,125 @@
package org.dromara.jcbt.domain;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableLogic;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;
import lombok.EqualsAndHashCode;
import org.dromara.common.mybatis.core.domain.BaseEntity;
import org.dromara.common.tenant.core.TenantEntity;
import java.io.Serial;
/**
* 奖学金名额分配对象 jcbt_scholarship_quota
*
* @author ruoyi
* @date 2025-01-27
*/
@Data
@EqualsAndHashCode(callSuper = true)
@TableName("jcbt_scholarship_quota")
public class JcbtScholarshipQuota extends BaseEntity {
@Serial
private static final long serialVersionUID = 1L;
/**
* 主键ID
*/
@TableId(value = "id")
private Long id;
/**
* 批次ID
*/
private Long batchId;
/**
* 奖学金类型ID
*/
private Long scholarshipTypeId;
/**
* 分配级别：UNIVERSITY-全校，COLLEGE-学院，MAJOR-专业，CLASS-班级
*/
private String allocationLevel;
/**
* 目标部门ID（学院/专业/班级）
*/
private Long targetDeptId;
/**
* 上级名额ID（层级分配）
*/
private Long parentQuotaId;
/**
* 总名额
*/
private Integer totalQuota;
/**
* 已使用名额
*/
private Integer usedQuota;
/**
* 预留名额
*/
private Integer reservedQuota;
/**
* 可用名额
*/
private Integer availableQuota;
/**
* 分配规则（JSON格式）
*/
private String allocationRule;
/**
* 分配依据说明
*/
private String allocationBasis;
/**
* 分配方式：MANUAL-手动分配，AUTO-自动分配，PROPORTIONAL-按比例分配
*/
private String allocationMethod;
/**
* 是否可调整：0-否，1-是
*/
private Integer isAdjustable;
/**
* 是否锁定：0-否，1-是
*/
private Integer isLocked;
/**
* 状态：ACTIVE-生效，INACTIVE-失效，PENDING-待审核
*/
private String status;
/**
* 备注
*/
private String remark;
/**
* 租户ID
*/
private Long tenantId;
/**
* 删除标记：0-正常，1-删除
*/
@TableLogic
private Integer deleted;
}
backend/ruoyi-modules/ruoyi-jcbt/src/main/java/org/dromara/jcbt/domain/JcbtScholarshipQuotaUsage.java
+107
View File
@@ -0,0 +1,107 @@
package org.dromara.jcbt.domain;
import com.baomidou.mybatisplus.annotation.*;
import lombok.Data;
import lombok.EqualsAndHashCode;
import org.dromara.common.mybatis.core.domain.BaseEntity;
import java.io.Serial;
import java.util.Date;
/**
* 奖学金名额使用记录对象 jcbt_scholarship_quota_usage
*
* @author ruoyi
* @date 2025-01-01
*/
@Data
@EqualsAndHashCode(callSuper = true)
@TableName("jcbt_scholarship_quota_usage")
public class JcbtScholarshipQuotaUsage extends BaseEntity {
@Serial
private static final long serialVersionUID = 1L;
/**
* 主键ID
*/
@TableId(value = "id")
private Long id;
/**
* 申请记录ID
*/
private Long applicationId;
/**
* 批次ID
*/
private Long batchId;
/**
* 奖学金类型ID
*/
private Long scholarshipTypeId;
/**
* 名额类型：CLASS-班级名额，DEPT-学院名额
*/
private String quotaType;
/**
* 名额来源ID（班级名额分配ID或学院名额分配ID）
*/
private Long quotaSourceId;
/**
* 目标部门ID（学院ID或班级ID）
*/
private Long targetDeptId;
/**
* 操作类型：USE-使用名额，RELEASE-释放名额
*/
private String operationType;
/**
* 名额数量（通常为1）
*/
private Integer quotaCount;
/**
* 操作时间
*/
private Date operationTime;
/**
* 操作人ID
*/
private Long operatorId;
/**
* 操作人姓名
*/
private String operatorName;
/**
* 操作原因
*/
private String operationReason;
/**
* 备注
*/
private String remark;
/**
* 租户ID
*/
private String tenantId;
/**
* 删除标志
*/
@TableLogic
private Integer deleted;
}
backend/ruoyi-modules/ruoyi-jcbt/src/main/java/org/dromara/jcbt/domain/JcbtScholarshipReview.java
+95
View File
@@ -0,0 +1,95 @@
package org.dromara.jcbt.domain;
import com.baomidou.mybatisplus.annotation.*;
import com.fasterxml.jackson.annotation.JsonFormat;
import lombok.Data;
import lombok.EqualsAndHashCode;
import org.dromara.common.mybatis.core.domain.BaseEntity;
import java.io.Serial;
import java.math.BigDecimal;
import java.util.Date;
/**
* 奖学金审核记录对象 jcbt_scholarship_review
*
* @author ruoyi
* @date 2025-08-05
*/
@Data
@EqualsAndHashCode(callSuper = true)
@TableName("jcbt_scholarship_review")
public class JcbtScholarshipReview extends BaseEntity {
@Serial
private static final long serialVersionUID = 1L;
/**
* 主键ID
*/
@TableId(value = "id")
private Long id;
/**
* 申请记录ID
*/
private Long applicationId;
/**
* 审核级别：DEPARTMENT-院系审核，SCHOOL-学校审核，FINANCE-财务审核，FINAL-终审
*/
private String reviewLevel;
/**
* 审核人ID
*/
private Long reviewerId;
/**
* 审核人姓名
*/
private String reviewerName;
/**
* 审核结果：PENDING-待审核，APPROVED-通过，REJECTED-拒绝，RETURNED-退回
*/
private String reviewResult;
/**
* 审核评分
*/
private BigDecimal reviewScore;
/**
* 审核意见
*/
private String reviewOpinion;
/**
* 审核时间
*/
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date reviewTime;
/**
* 下一审核人ID
*/
private Long nextReviewerId;
/**
* 是否最终审核：0-否，1-是
*/
private Integer isFinalReview;
/**
* 租户ID
*/
private String tenantId;
/**
* 删除标志
*/
@TableLogic
private Integer deleted;
}
backend/ruoyi-modules/ruoyi-jcbt/src/main/java/org/dromara/jcbt/domain/JcbtScholarshipType.java
+110
View File
@@ -0,0 +1,110 @@
package org.dromara.jcbt.domain;
import com.baomidou.mybatisplus.annotation.*;
import lombok.Data;
import lombok.EqualsAndHashCode;
import org.dromara.common.mybatis.core.domain.BaseEntity;
import java.math.BigDecimal;
/**
* 奖学金类型对象 jcbt_scholarship_type
*
* @author ruoyi
* @date 2025-01-27
*/
@Data
@EqualsAndHashCode(callSuper = true)
@TableName("jcbt_scholarship_type")
public class JcbtScholarshipType extends BaseEntity {
private static final long serialVersionUID = 1L;
/**
* 主键ID
*/
@TableId(value = "id")
private Long id;
/**
* 奖学金类型编码
*/
private String typeCode;
/**
* 奖学金名称
*/
private String typeName;
/**
* 奖学金类别
*/
private String typeCategory;
/**
* 奖学金等级
*/
private String levelType;
/**
* 奖金金额
*/
private BigDecimal awardAmount;
/**
* 奖学金描述
*/
private String description;
/**
* 申请指南
*/
private String applicationGuide;
/**
* 申请条件
*/
private String applicationConditions;
/**
* 评定标准
*/
private String evaluationCriteria;
/**
* 备注
*/
private String remark;
/**
* 排序号
*/
private Integer sortOrder;
/**
* 状态：0-禁用，1-启用
*/
private Integer status;
/**
* 是否系统内置：0-否，1-是
*/
private Integer isSystem;
/**
* 兼得类型：EXCLUSIVE-完全互斥，COMPATIBLE-完全兼容，CUSTOM-自定义配置
*/
private String compatibilityType;
/**
* 租户ID
*/
private String tenantId;
/**
* 删除标志
*/
@TableLogic
private Integer deleted;
}
backend/ruoyi-modules/ruoyi-jcbt/src/main/java/org/dromara/jcbt/domain/JcbtWorkStudyApplication.java
+213
View File
@@ -0,0 +1,213 @@
package org.dromara.jcbt.domain;
import com.baomidou.mybatisplus.annotation.*;
import lombok.Data;
import lombok.EqualsAndHashCode;
import org.dromara.common.mybatis.core.domain.BaseEntity;
import java.io.Serial;
import java.util.Date;
/**
* 勤工俭学申请信息对象 jcbt_work_study_application
*
* @author ruoyi
* @date 2025-01-03
*/
@Data
@EqualsAndHashCode(callSuper = true)
@TableName("jcbt_work_study_application")
public class JcbtWorkStudyApplication extends BaseEntity {
@Serial
private static final long serialVersionUID = 1L;
/**
* 主键ID
*/
@TableId(value = "id")
private Long id;
/**
* 岗位ID
*/
private Long positionId;
/**
* 岗位名称（冗余字段）
*/
private String positionName;
/**
* 岗位类型
*/
private String positionType;
/**
* 工作地点
*/
private String workLocation;
/**
* 计划工作时长（小时/周）
*/
private Integer plannedWorkHours;
/**
* 学生ID
*/
private Long studentId;
/**
* 学生姓名
*/
private String studentName;
/**
* 学号
*/
private String studentNumber;
/**
* 身份证号
*/
private String idCard;
/**
* 联系电话
*/
@TableField("phone")
private String contactPhone;
/**
* 学生所在学院ID
*/
private Long collegeId;
/**
* 学生所在学院名称
*/
private String collegeName;
/**
* 专业名称
*/
@TableField("major")
private String majorName;
/**
* 年级
*/
private String grade;
/**
* 班级
*/
private String className;
/**
* 家庭经济情况
*/
private String familyFinancialStatus;
/**
* 申请理由
*/
private String applicationReason;
/**
* 个人能力及经验
*/
private String personalAbility;
/**
* 时间安排
*/
private String timeArrangement;
/**
* 备注
*/
private String remark;
/**
* 申请状态（DRAFT-草稿，SUBMITTED-已提交，COLLEGE_APPROVED-学院审核通过，COLLEGE_REJECTED-学院审核拒绝，FINAL_APPROVED-学生处审核通过，FINAL_REJECTED-学生处审核拒绝，CANCELLED-已取消）
*/
private String status;
/**
* 申请提交时间
*/
private Date applicationDate;
/**
* 学院审核状态（PENDING-待审核，APPROVED-通过，REJECTED-拒绝）
*/
private String collegeReviewStatus;
/**
* 学院审核时间
*/
private Date collegeReviewTime;
/**
* 学院审核人ID
*/
private Long collegeReviewerId;
/**
* 学院审核人姓名
*/
private String collegeReviewerName;
/**
* 学院审核意见
*/
private String collegeReviewComment;
/**
* 学生处审核状态（PENDING-待审核，APPROVED-通过，REJECTED-拒绝）
*/
private String finalReviewStatus;
/**
* 学生处审核时间
*/
private Date finalReviewTime;
/**
* 学生处审核人ID
*/
private Long finalReviewerId;
/**
* 学生处审核人姓名
*/
private String finalReviewerName;
/**
* 学生处审核意见
*/
private String finalReviewComment;
/**
* 工作开始时间
*/
private Date workStartDate;
/**
* 工作结束时间
*/
private Date workEndDate;
/**
* 逻辑删除标记
*/
@TableLogic
private Integer deleted;
/**
* 租户ID
*/
private String tenantId;
}
backend/ruoyi-modules/ruoyi-jcbt/src/main/java/org/dromara/jcbt/domain/JcbtWorkStudyPosition.java
+117
View File
@@ -0,0 +1,117 @@
package org.dromara.jcbt.domain;
import com.baomidou.mybatisplus.annotation.*;
import lombok.Data;
import lombok.EqualsAndHashCode;
import org.dromara.common.mybatis.core.domain.BaseEntity;
import java.io.Serial;
import java.util.Date;
/**
* 勤工俭学岗位信息对象 jcbt_work_study_position
*
* @author ruoyi
* @date 2025-01-03
*/
@Data
@EqualsAndHashCode(callSuper = true)
@TableName("jcbt_work_study_position")
public class JcbtWorkStudyPosition extends BaseEntity {
@Serial
private static final long serialVersionUID = 1L;
/**
* 主键ID
*/
@TableId(value = "id")
private Long id;
/**
* 岗位名称
*/
private String positionName;
/**
* 岗位发布范围（COLLEGE-本学院，UNIVERSITY-全校）
*/
private String positionScope;
/**
* 需求人数
*/
private Integer requiredCount;
/**
* 工作时间
*/
private String workTime;
/**
* 工作地点
*/
@TableField(exist = false)
private String workLocation;
/**
* 岗位有效期开始
*/
private Date startDate;
/**
* 岗位有效期结束
*/
private Date endDate;
/**
* 岗位要求
*/
private String positionRequirements;
/**
* 薪资情况
*/
private String salaryInfo;
/**
* 联系老师
*/
private String contactTeacher;
/**
* 联系电话
*/
private String contactPhone;
/**
* 发布学院ID
*/
private Long collegeId;
/**
* 发布学院名称
*/
private String collegeName;
/**
* 岗位状态（DRAFT-草稿，PUBLISHED-已发布，RECRUITING-招录中，FULL-已满员，EXPIRED-已过期，SUSPENDED-已暂停，CANCELLED-已取消）
*/
private String status;
/**
* 当前申请通过人数
*/
private Integer currentCount;
/**
* 逻辑删除标记
*/
@TableLogic
private Integer deleted;
/**
* 租户ID
*/
private String tenantId;
}
backend/ruoyi-modules/ruoyi-jcbt/src/main/java/org/dromara/jcbt/domain/bo/.gitkeep
View File
Whitespace-only changes.
backend/ruoyi-modules/ruoyi-jcbt/src/main/java/org/dromara/jcbt/domain/bo/AuditRequestBo.java
+28
View File
@@ -0,0 +1,28 @@
package org.dromara.jcbt.domain.bo;
import jakarta.validation.constraints.NotBlank;
import jakarta.validation.constraints.NotNull;
import lombok.Data;
/**
* 审核请求业务对象
*
* @author ruoyi
* @date 2025-08-09
*/
@Data
public class AuditRequestBo {
/**
* 申请ID
*/
@NotNull(message = "申请ID不能为空")
private Long id;
/**
* 审核意见
*/
@NotBlank(message = "审核意见不能为空")
private String auditOpinion;
}
backend/ruoyi-modules/ruoyi-jcbt/src/main/java/org/dromara/jcbt/domain/bo/JcbtPovertyApplicationBo.java
+254
View File
@@ -0,0 +1,254 @@
package org.dromara.jcbt.domain.bo;
import io.github.linpeilie.annotations.AutoMapper;
import jakarta.validation.constraints.NotBlank;
import jakarta.validation.constraints.NotNull;
import lombok.Data;
import lombok.EqualsAndHashCode;
import org.dromara.common.core.validate.AddGroup;
import org.dromara.common.core.validate.EditGroup;
import org.dromara.common.mybatis.core.domain.BaseEntity;
import org.dromara.jcbt.domain.JcbtPovertyApplication;
import java.util.Date;
import java.util.List;
/**
* 贫困生认定申请业务对象 jcbt_poverty_application
*
* @author ruoyi
* @date 2025-08-09
*/
@Data
@EqualsAndHashCode(callSuper = true)
@AutoMapper(target = JcbtPovertyApplication.class, reverseConvertGenerate = false)
public class JcbtPovertyApplicationBo extends BaseEntity {
/**
* 主键ID
*/
@NotNull(message = "主键ID不能为空", groups = { EditGroup.class })
private Long id;
/**
* 申请编号
*/
private String applicationNo;
/**
* 学年
*/
@NotBlank(message = "学年不能为空", groups = { AddGroup.class, EditGroup.class })
private String academicYear;
/**
* 学期
*/
private Integer term;
/**
* 学生ID
*/
@NotNull(message = "学生ID不能为空", groups = { AddGroup.class, EditGroup.class })
private Long studentId;
/**
* 学号
*/
@NotBlank(message = "学号不能为空", groups = { AddGroup.class, EditGroup.class })
private String studentNo;
/**
* 学生姓名
*/
@NotBlank(message = "学生姓名不能为空", groups = { AddGroup.class, EditGroup.class })
private String studentName;
/**
* 性别
*/
private String gender;
/**
* 学院ID
*/
@NotNull(message = "学院ID不能为空", groups = { AddGroup.class, EditGroup.class })
private Long collegeId;
/**
* 学院名称
*/
@NotBlank(message = "学院名称不能为空", groups = { AddGroup.class, EditGroup.class })
private String collegeName;
/**
* 专业ID
*/
@NotNull(message = "专业ID不能为空", groups = { AddGroup.class, EditGroup.class })
private Long majorId;
/**
* 专业名称
*/
@NotBlank(message = "专业名称不能为空", groups = { AddGroup.class, EditGroup.class })
private String majorName;
/**
* 班级ID
*/
@NotNull(message = "班级ID不能为空", groups = { AddGroup.class, EditGroup.class })
private Long classId;
/**
* 班级名称
*/
@NotBlank(message = "班级名称不能为空", groups = { AddGroup.class, EditGroup.class })
private String className;
/**
* 班主任教师ID
*/
private Long teacherId;
/**
* 班主任教师姓名
*/
private String teacherName;
/**
* 认定群体（特殊群体/其他群体）
*/
@NotBlank(message = "认定群体不能为空", groups = { AddGroup.class, EditGroup.class })
private String recognitionGroup;
/**
* 认定类型ID
*/
@NotNull(message = "认定类型ID不能为空", groups = { AddGroup.class, EditGroup.class })
private Long recognitionTypeId;
/**
* 认定类型编码
*/
@NotBlank(message = "认定类型编码不能为空", groups = { AddGroup.class, EditGroup.class })
private String recognitionTypeCode;
/**
* 认定类型名称
*/
@NotBlank(message = "认定类型名称不能为空", groups = { AddGroup.class, EditGroup.class })
private String recognitionTypeName;
/**
* 申请自助类型ID数组（多选）
*/
@NotBlank(message = "申请自助类型不能为空", groups = { AddGroup.class, EditGroup.class })
private String assistanceTypeIds;
/**
* 申请自助类型名称（多个用逗号分隔）
*/
@NotBlank(message = "申请自助类型名称不能为空", groups = { AddGroup.class, EditGroup.class })
private String assistanceTypeNames;
/**
* 家庭经济情况摘要
*/
@NotBlank(message = "家庭经济情况摘要不能为空", groups = { AddGroup.class, EditGroup.class })
private String familyEconomySummary;
/**
* 申请表附件URL
*/
@NotBlank(message = "申请表附件不能为空", groups = { AddGroup.class, EditGroup.class })
private String attachApplicationFormUrl;
/**
* 申请表附件ID
*/
@NotNull(message = "申请表附件ID不能为空", groups = { AddGroup.class, EditGroup.class })
private Long attachApplicationFormId;
/**
* 调查表附件URL
*/
@NotBlank(message = "调查表附件不能为空", groups = { AddGroup.class, EditGroup.class })
private String attachSurveyFormUrl;
/**
* 调查表附件ID
*/
@NotNull(message = "调查表附件ID不能为空", groups = { AddGroup.class, EditGroup.class })
private Long attachSurveyFormId;
/**
* 申请状态
*/
private String status;
/**
* 申请状态列表（用于多状态查询）
*/
private List<String> statusList;
/**
* 提交人ID
*/
private Long submitterId;
/**
* 提交人姓名
*/
private String submitterName;
/**
* 提交时间
*/
private Date submitTime;
/**
* 审核人ID
*/
private Long auditorId;
/**
* 审核人姓名
*/
private String auditorName;
/**
* 审核时间
*/
private Date auditTime;
/**
* 审核意见
*/
private String auditOpinion;
/**
* 备注
*/
private String remark;
/**
* 创建者
*/
private Long createBy;
/**
* 创建时间
*/
private Date createTime;
/**
* 更新者
*/
private Long updateBy;
/**
* 更新时间
*/
private Date updateTime;
}
backend/ruoyi-modules/ruoyi-jcbt/src/main/java/org/dromara/jcbt/domain/bo/JcbtScholarshipApplicationBo.java
+232
View File
@@ -0,0 +1,232 @@
package org.dromara.jcbt.domain.bo;
import org.dromara.jcbt.domain.JcbtScholarshipApplication;
import org.dromara.common.mybatis.core.domain.BaseEntity;
import org.dromara.common.core.validate.AddGroup;
import org.dromara.common.core.validate.EditGroup;
import io.github.linpeilie.annotations.AutoMapper;
import lombok.Data;
import lombok.EqualsAndHashCode;
import jakarta.validation.constraints.*;
import java.util.Date;
/**
* 奖学金申请记录业务对象 jcbt_scholarship_application
*
* @author ruoyi
* @date 2025-01-01
*/
@Data
@EqualsAndHashCode(callSuper = true)
@AutoMapper(target = JcbtScholarshipApplication.class, reverseConvertGenerate = false)
public class JcbtScholarshipApplicationBo extends BaseEntity {
/**
* 主键ID
*/
@NotNull(message = "主键ID不能为空", groups = { EditGroup.class })
private Long id;
/**
* 批次ID
*/
@NotNull(message = "批次ID不能为空", groups = { AddGroup.class, EditGroup.class })
private Long batchId;
/**
* 奖学金类型ID
*/
@NotNull(message = "奖学金类型ID不能为空", groups = { AddGroup.class, EditGroup.class })
private Long scholarshipTypeId;
/**
* 学生学号
*/
@NotBlank(message = "学生学号不能为空", groups = { AddGroup.class, EditGroup.class })
@Size(max = 50, message = "学生学号长度不能超过50个字符")
private String studentNo;
/**
* 学生姓名
*/
@NotBlank(message = "学生姓名不能为空", groups = { AddGroup.class, EditGroup.class })
@Size(max = 100, message = "学生姓名长度不能超过100个字符")
private String studentName;
/**
* 学生ID
*/
private Long studentId;
/**
* 学院ID
*/
@NotNull(message = "学院ID不能为空", groups = { AddGroup.class, EditGroup.class })
private Long deptId;
/**
* 学院名称
*/
@Size(max = 100, message = "学院名称长度不能超过100个字符")
private String deptName;
/**
* 班级ID
*/
@NotNull(message = "班级ID不能为空", groups = { AddGroup.class, EditGroup.class })
private Long classId;
/**
* 班级名称
*/
@Size(max = 100, message = "班级名称长度不能超过100个字符")
private String className;
// 已删除 applicantType 和 applicantId 字段
/**
* 申请人姓名（班主任姓名）
*/
@Size(max = 100, message = "申请人姓名长度不能超过100个字符")
private String applicantName;
/**
* 申请类型：RECOMMEND-教师推荐，AUTO-自动评定，DIRECT-直接指定
*/
private String applicationType;
/**
* 申请原因
*/
@Size(max = 1000, message = "申请原因长度不能超过1000个字符")
private String applicationReason;
/**
* 申请说明
*/
@Size(max = 2000, message = "申请说明长度不能超过2000个字符")
private String applicationDescription;
/**
* 综合测评成绩
*/
@DecimalMin(value = "0", message = "综合测评成绩不能为负数")
@DecimalMax(value = "100", message = "综合测评成绩不能超过100分")
private Double comprehensiveScore;
/**
* 学习成绩
*/
@DecimalMin(value = "0", message = "学习成绩不能为负数")
@DecimalMax(value = "100", message = "学习成绩不能超过100分")
private Double academicScore;
/**
* 德育成绩
*/
@DecimalMin(value = "0", message = "德育成绩不能为负数")
@DecimalMax(value = "100", message = "德育成绩不能超过100分")
private Double moralScore;
/**
* 体育成绩
*/
@DecimalMin(value = "0", message = "体育成绩不能为负数")
@DecimalMax(value = "100", message = "体育成绩不能超过100分")
private Double physicalScore;
/**
* 美育成绩
*/
@DecimalMin(value = "0", message = "美育成绩不能为负数")
@DecimalMax(value = "100", message = "美育成绩不能超过100分")
private Double aestheticScore;
/**
* 劳动成绩
*/
@DecimalMin(value = "0", message = "劳动成绩不能为负数")
@DecimalMax(value = "100", message = "劳动成绩不能超过100分")
private Double laborScore;
/**
* 系统计算分数
*/
@DecimalMin(value = "0", message = "系统计算分数不能为负数")
@DecimalMax(value = "100", message = "系统计算分数不能超过100分")
private Double calculatedScore;
/**
* 最终评定分数
*/
@DecimalMin(value = "0", message = "最终评定分数不能为负数")
@DecimalMax(value = "100", message = "最终评定分数不能超过100分")
private Double finalScore;
/**
* 在院系的排名
*/
@Min(value = 1, message = "在院系的排名至少为1")
private Integer rankingInDept;
/**
* 在专业的排名
*/
@Min(value = 1, message = "在专业的排名至少为1")
private Integer rankingInMajor;
/**
* 当前状态
*/
private String currentStatus;
/**
* 状态字段（前端使用，映射到currentStatus）
*/
private String status;
/**
* 提交时间
*/
private Date submitTime;
/**
* 审核评语
*/
@Size(max = 1000, message = "审核评语长度不能超过1000个字符")
private String reviewComment;
// Getter和Setter方法，确保status和currentStatus保持同步
public String getStatus() {
return this.currentStatus;
}
public void setStatus(String status) {
this.status = status;
this.currentStatus = status;
}
public String getCurrentStatus() {
return this.currentStatus;
}
public void setCurrentStatus(String currentStatus) {
this.currentStatus = currentStatus;
this.status = currentStatus;
}
/**
* 获取申请状态（兼容旧版本，返回currentStatus）
*/
public String getApplicationStatus() {
return currentStatus;
}
/**
* 设置申请状态（兼容旧版本，设置currentStatus）
*/
public void setApplicationStatus(String applicationStatus) {
this.currentStatus = applicationStatus;
}
}
backend/ruoyi-modules/ruoyi-jcbt/src/main/java/org/dromara/jcbt/domain/bo/JcbtScholarshipBatchBo.java
+126
View File
@@ -0,0 +1,126 @@
package org.dromara.jcbt.domain.bo;
import org.dromara.jcbt.domain.JcbtScholarshipBatch;
import org.dromara.common.mybatis.core.domain.BaseEntity;
import org.dromara.common.core.validate.AddGroup;
import org.dromara.common.core.validate.EditGroup;
import io.github.linpeilie.annotations.AutoMapper;
import lombok.Data;
import lombok.EqualsAndHashCode;
import jakarta.validation.constraints.*;
import java.util.Date;
import java.util.List;
/**
* 奖学金评定批次业务对象 jcbt_scholarship_batch
*
* @author ruoyi
* @date 2025-01-27
*/
@Data
@EqualsAndHashCode(callSuper = true)
@AutoMapper(target = JcbtScholarshipBatch.class, reverseConvertGenerate = false)
public class JcbtScholarshipBatchBo extends BaseEntity {
/**
* 主键ID
*/
@NotNull(message = "主键ID不能为空", groups = { EditGroup.class })
private Long id;
/**
* 批次编码
*/
@NotBlank(message = "批次编码不能为空", groups = { AddGroup.class, EditGroup.class })
@Size(max = 50, message = "批次编码不能超过50个字符")
private String batchCode;
/**
* 批次名称
*/
@NotBlank(message = "批次名称不能为空", groups = { AddGroup.class, EditGroup.class })
@Size(max = 100, message = "批次名称不能超过100个字符")
private String batchName;
/**
* 学年
*/
@NotBlank(message = "学年不能为空", groups = { AddGroup.class, EditGroup.class })
@Size(max = 20, message = "学年不能超过20个字符")
private String academicYear;
/**
* 学期：1-第一学期，2-第二学期，3-全年
*/
@NotNull(message = "学期不能为空", groups = { AddGroup.class, EditGroup.class })
@Min(value = 1, message = "学期值必须在1-3之间")
@Max(value = 3, message = "学期值必须在1-3之间")
private Integer semester;
/**
* 批次类型：REGULAR-常规批次，SPECIAL-专项批次，SUPPLEMENTARY-补充批次
*/
@NotBlank(message = "批次类型不能为空", groups = { AddGroup.class, EditGroup.class })
private String batchType;
/**
* 开始时间
*/
@NotNull(message = "开始时间不能为空", groups = { AddGroup.class, EditGroup.class })
private Date startTime;
/**
* 结束时间
*/
@NotNull(message = "结束时间不能为空", groups = { AddGroup.class, EditGroup.class })
private Date endTime;
/**
* 申请开始时间
*/
private Date applyStartTime;
/**
* 申请结束时间
*/
private Date applyEndTime;
/**
* 审核开始时间
*/
private Date reviewStartTime;
/**
* 审核结束时间
*/
private Date reviewEndTime;
/**
* 状态：DRAFT-草稿，ACTIVE-进行中，COMPLETED-已完成，CANCELLED-已取消
*/
@NotBlank(message = "状态不能为空", groups = { AddGroup.class, EditGroup.class })
private String status;
/**
* 批次描述
*/
@Size(max = 1000, message = "批次描述不能超过1000个字符")
private String description;
/**
* 通知内容
*/
private String noticeContent;
/**
* 关联的奖学金类型ID列表
*/
private List<Long> scholarshipTypeIds;
/**
* 租户ID
*/
private Long tenantId;
}
backend/ruoyi-modules/ruoyi-jcbt/src/main/java/org/dromara/jcbt/domain/bo/JcbtScholarshipClassQuotaBo.java
+112
View File
@@ -0,0 +1,112 @@
package org.dromara.jcbt.domain.bo;
import org.dromara.jcbt.domain.JcbtScholarshipClassQuota;
import org.dromara.common.mybatis.core.domain.BaseEntity;
import org.dromara.common.core.validate.AddGroup;
import org.dromara.common.core.validate.EditGroup;
import io.github.linpeilie.annotations.AutoMapper;
import lombok.Data;
import lombok.EqualsAndHashCode;
import jakarta.validation.constraints.*;
/**
* 奖学金班级名额分配业务对象 jcbt_scholarship_class_quota
*
* @author ruoyi
* @date 2025-01-01
*/
@Data
@EqualsAndHashCode(callSuper = true)
@AutoMapper(target = JcbtScholarshipClassQuota.class, reverseConvertGenerate = false)
public class JcbtScholarshipClassQuotaBo extends BaseEntity {
/**
* 主键ID
*/
@NotNull(message = "主键ID不能为空", groups = { EditGroup.class })
private Long id;
/**
* 批次ID
*/
@NotNull(message = "批次ID不能为空", groups = { AddGroup.class, EditGroup.class })
private Long batchId;
/**
* 奖学金类型ID
*/
@NotNull(message = "奖学金类型ID不能为空", groups = { AddGroup.class, EditGroup.class })
private Long scholarshipTypeId;
/**
* 学院ID
*/
@NotNull(message = "学院ID不能为空", groups = { AddGroup.class, EditGroup.class })
private Long deptId;
/**
* 班级ID
*/
@NotNull(message = "班级ID不能为空", groups = { AddGroup.class, EditGroup.class })
private Long classId;
/**
* 班级名称
*/
@NotBlank(message = "班级名称不能为空", groups = { AddGroup.class, EditGroup.class })
@Size(max = 100, message = "班级名称长度不能超过100个字符")
private String className;
/**
* 总名额
*/
@NotNull(message = "总名额不能为空", groups = { AddGroup.class, EditGroup.class })
@Min(value = 0, message = "总名额不能小于0")
private Integer totalQuota;
/**
* 已使用名额
*/
@Min(value = 0, message = "已使用名额不能小于0")
private Integer usedQuota;
/**
* 预留名额
*/
@Min(value = 0, message = "预留名额不能小于0")
private Integer reservedQuota;
/**
* 可用名额
*/
@Min(value = 0, message = "可用名额不能小于0")
private Integer availableQuota;
/**
* 分配方式：MANUAL-手动分配，AUTO-自动分配，PROPORTIONAL-按比例分配
*/
private String allocationMethod;
/**
* 分配依据说明
*/
@Size(max = 500, message = "分配依据说明长度不能超过500个字符")
private String allocationBasis;
/**
* 是否锁定：0-否，1-是
*/
private Integer isLocked;
/**
* 状态：ACTIVE-生效，INACTIVE-失效，SUSPENDED-暂停
*/
private String status;
/**
* 备注
*/
@Size(max = 500, message = "备注长度不能超过500个字符")
private String remark;
}
backend/ruoyi-modules/ruoyi-jcbt/src/main/java/org/dromara/jcbt/domain/bo/JcbtScholarshipCompatibilityBo.java
+68
View File
@@ -0,0 +1,68 @@
package org.dromara.jcbt.domain.bo;
import org.dromara.jcbt.domain.JcbtScholarshipCompatibility;
import org.dromara.common.mybatis.core.domain.BaseEntity;
import org.dromara.common.core.validate.AddGroup;
import org.dromara.common.core.validate.EditGroup;
import com.baomidou.mybatisplus.annotation.TableField;
import io.github.linpeilie.annotations.AutoMapper;
import lombok.Data;
import lombok.EqualsAndHashCode;
import jakarta.validation.constraints.*;
/**
* 奖学金兼得关系业务对象 jcbt_scholarship_compatibility
*
* @author ruoyi
* @date 2025-01-27
*/
@Data
@EqualsAndHashCode(callSuper = true)
@AutoMapper(target = JcbtScholarshipCompatibility.class, reverseConvertGenerate = false)
public class JcbtScholarshipCompatibilityBo extends BaseEntity {
/**
* 主键ID
*/
@NotNull(message = "主键ID不能为空", groups = { EditGroup.class })
private Long id;
/**
* 奖学金类型1
*/
@NotNull(message = "奖学金类型1不能为空", groups = { AddGroup.class, EditGroup.class })
@TableField("type_id_1")
private Long typeId1;
/**
* 奖学金类型2
*/
@NotNull(message = "奖学金类型2不能为空", groups = { AddGroup.class, EditGroup.class })
@TableField("type_id_2")
private Long typeId2;
/**
* 关系类型：COMPATIBLE-兼容，EXCLUSIVE-互斥，PRIORITY-优先级关系
*/
@NotBlank(message = "关系类型不能为空", groups = { AddGroup.class, EditGroup.class })
@TableField("relation_type")
private String relationType;
/**
* 优先级（relation_type为PRIORITY时有效）
*/
@TableField("priority_level")
private Integer priorityLevel;
/**
* 关系描述
*/
@Size(max = 500, message = "关系描述长度不能超过500个字符")
private String description;
/**
* 租户ID
*/
private Long tenantId;
}
backend/ruoyi-modules/ruoyi-jcbt/src/main/java/org/dromara/jcbt/domain/bo/JcbtScholarshipQuotaBo.java
+123
View File
@@ -0,0 +1,123 @@
package org.dromara.jcbt.domain.bo;
import org.dromara.common.core.validate.AddGroup;
import org.dromara.common.core.validate.EditGroup;
import org.dromara.common.mybatis.core.domain.BaseEntity;
import org.dromara.jcbt.domain.JcbtScholarshipQuota;
import io.github.linpeilie.annotations.AutoMapper;
import lombok.Data;
import lombok.EqualsAndHashCode;
import jakarta.validation.constraints.*;
/**
* 奖学金名额分配业务对象 JcbtScholarshipQuotaBo
*
* @author ruoyi
* @date 2025-01-27
*/
@Data
@EqualsAndHashCode(callSuper = true)
@AutoMapper(target = JcbtScholarshipQuota.class, reverseConvertGenerate = false)
public class JcbtScholarshipQuotaBo extends BaseEntity {
/**
* 主键ID
*/
@NotNull(message = "主键ID不能为空", groups = { EditGroup.class })
private Long id;
/**
* 批次ID
*/
@NotNull(message = "批次ID不能为空", groups = { AddGroup.class, EditGroup.class })
private Long batchId;
/**
* 奖学金类型ID
*/
@NotNull(message = "奖学金类型ID不能为空", groups = { AddGroup.class, EditGroup.class })
private Long scholarshipTypeId;
/**
* 分配级别：UNIVERSITY-全校，COLLEGE-学院，MAJOR-专业，CLASS-班级
*/
@NotBlank(message = "分配级别不能为空", groups = { AddGroup.class, EditGroup.class })
private String allocationLevel;
/**
* 目标部门ID（学院/专业/班级）
*/
private Long targetDeptId;
/**
* 上级名额ID（层级分配）
*/
private Long parentQuotaId;
/**
* 总名额
*/
@NotNull(message = "总名额不能为空", groups = { AddGroup.class, EditGroup.class })
@Min(value = 0, message = "总名额不能小于0")
private Integer totalQuota;
/**
* 已使用名额
*/
@Min(value = 0, message = "已使用名额不能小于0")
private Integer usedQuota;
/**
* 预留名额
*/
@Min(value = 0, message = "预留名额不能小于0")
private Integer reservedQuota;
/**
* 可用名额
*/
@Min(value = 0, message = "可用名额不能小于0")
private Integer availableQuota;
/**
* 分配规则（JSON格式）
*/
private String allocationRule;
/**
* 分配依据说明
*/
private String allocationBasis;
/**
* 分配方式：MANUAL-手动分配，AUTO-自动分配，PROPORTIONAL-按比例分配
*/
private String allocationMethod;
/**
* 是否可调整：0-否，1-是
*/
private Integer isAdjustable;
/**
* 是否锁定：0-否，1-是
*/
private Integer isLocked;
/**
* 状态：ACTIVE-生效，INACTIVE-失效，PENDING-待审核
*/
private String status;
/**
* 备注
*/
private String remark;
/**
* 租户ID
*/
private Long tenantId;
}
backend/ruoyi-modules/ruoyi-jcbt/src/main/java/org/dromara/jcbt/domain/bo/JcbtScholarshipReviewBo.java
+101
View File
@@ -0,0 +1,101 @@
package org.dromara.jcbt.domain.bo;
import com.fasterxml.jackson.annotation.JsonFormat;
import io.github.linpeilie.annotations.AutoMapper;
import lombok.Data;
import lombok.EqualsAndHashCode;
import org.dromara.common.core.validate.AddGroup;
import org.dromara.common.core.validate.EditGroup;
import org.dromara.common.mybatis.core.domain.BaseEntity;
import org.dromara.jcbt.domain.JcbtScholarshipReview;
import jakarta.validation.constraints.*;
import java.math.BigDecimal;
import java.util.Date;
/**
* 奖学金审核记录业务对象 jcbt_scholarship_review
*
* @author ruoyi
* @date 2025-08-05
*/
@Data
@EqualsAndHashCode(callSuper = true)
@AutoMapper(target = JcbtScholarshipReview.class, reverseConvertGenerate = false)
public class JcbtScholarshipReviewBo extends BaseEntity {
/**
* 主键ID
*/
@NotNull(message = "主键ID不能为空", groups = { EditGroup.class })
private Long id;
/**
* 申请记录ID
*/
@NotNull(message = "申请记录ID不能为空", groups = { AddGroup.class, EditGroup.class })
private Long applicationId;
/**
* 审核级别：DEPARTMENT-院系审核，SCHOOL-学校审核，FINANCE-财务审核，FINAL-终审
*/
@NotBlank(message = "审核级别不能为空", groups = { AddGroup.class, EditGroup.class })
@Size(max = 20, message = "审核级别长度不能超过20个字符")
private String reviewLevel;
/**
* 审核人ID
*/
@NotNull(message = "审核人ID不能为空", groups = { AddGroup.class, EditGroup.class })
private Long reviewerId;
/**
* 审核人姓名
*/
@NotBlank(message = "审核人姓名不能为空", groups = { AddGroup.class, EditGroup.class })
@Size(max = 100, message = "审核人姓名长度不能超过100个字符")
private String reviewerName;
/**
* 审核结果：PENDING-待审核，APPROVED-通过，REJECTED-拒绝，RETURNED-退回
*/
@NotBlank(message = "审核结果不能为空", groups = { AddGroup.class, EditGroup.class })
@Size(max = 20, message = "审核结果长度不能超过20个字符")
private String reviewResult;
/**
* 审核评分
*/
@DecimalMin(value = "0.00", message = "审核评分不能小于0")
@DecimalMax(value = "999999.99", message = "审核评分不能大于999999.99")
private BigDecimal reviewScore;
/**
* 审核意见
*/
@Size(max = 1000, message = "审核意见长度不能超过1000个字符")
private String reviewOpinion;
/**
* 审核时间
*/
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
@NotNull(message = "审核时间不能为空", groups = { AddGroup.class, EditGroup.class })
private Date reviewTime;
/**
* 下一审核人ID
*/
private Long nextReviewerId;
/**
* 是否最终审核：0-否，1-是
*/
private Integer isFinalReview;
/**
* 租户ID
*/
private String tenantId;
}
backend/ruoyi-modules/ruoyi-jcbt/src/main/java/org/dromara/jcbt/domain/bo/JcbtScholarshipTypeBo.java
+113
View File
@@ -0,0 +1,113 @@
package org.dromara.jcbt.domain.bo;
import org.dromara.jcbt.domain.JcbtScholarshipType;
import org.dromara.common.mybatis.core.domain.BaseEntity;
import org.dromara.common.core.validate.AddGroup;
import org.dromara.common.core.validate.EditGroup;
import io.github.linpeilie.annotations.AutoMapper;
import lombok.Data;
import lombok.EqualsAndHashCode;
import jakarta.validation.constraints.*;
import java.math.BigDecimal;
/**
* 奖学金类型业务对象 jcbt_scholarship_type
*
* @author ruoyi
* @date 2025-01-27
*/
@Data
@EqualsAndHashCode(callSuper = true)
@AutoMapper(target = JcbtScholarshipType.class, reverseConvertGenerate = false)
public class JcbtScholarshipTypeBo extends BaseEntity {
/**
* 主键ID
*/
@NotNull(message = "主键ID不能为空", groups = { EditGroup.class })
private Long id;
/**
* 奖学金类型编码
*/
@NotBlank(message = "奖学金类型编码不能为空", groups = { AddGroup.class, EditGroup.class })
@Size(max = 50, message = "奖学金类型编码不能超过50个字符")
private String typeCode;
/**
* 奖学金名称
*/
@NotBlank(message = "奖学金名称不能为空", groups = { AddGroup.class, EditGroup.class })
@Size(max = 100, message = "奖学金名称不能超过100个字符")
private String typeName;
/**
* 奖学金类别
*/
@NotBlank(message = "奖学金类别不能为空", groups = { AddGroup.class, EditGroup.class })
private String typeCategory;
/**
* 奖学金等级
*/
private String levelType;
/**
* 奖金金额
*/
@DecimalMin(value = "0", message = "奖金金额不能为负数")
@Digits(integer = 8, fraction = 2, message = "奖金金额格式不正确")
private BigDecimal awardAmount;
/**
* 奖学金描述
*/
private String description;
/**
* 申请指南
*/
private String applicationGuide;
/**
* 申请条件
*/
@Size(max = 2000, message = "申请条件不能超过2000个字符")
private String applicationConditions;
/**
* 评定标准
*/
@Size(max = 2000, message = "评定标准不能超过2000个字符")
private String evaluationCriteria;
/**
* 备注
*/
@Size(max = 500, message = "备注不能超过500个字符")
private String remark;
/**
* 排序号
*/
@Min(value = 0, message = "排序号不能为负数")
private Integer sortOrder;
/**
* 状态：0-停用 1-启用
*/
@NotNull(message = "状态不能为空", groups = { AddGroup.class, EditGroup.class })
private Integer status;
/**
* 是否系统内置：0-否，1-是
*/
private Integer isSystem;
/**
* 兼得类型：EXCLUSIVE-完全互斥，COMPATIBLE-完全兼容，CUSTOM-自定义配置
*/
private String compatibilityType;
}
backend/ruoyi-modules/ruoyi-jcbt/src/main/java/org/dromara/jcbt/domain/bo/JcbtWorkStudyApplicationBo.java
+225
View File
@@ -0,0 +1,225 @@
package org.dromara.jcbt.domain.bo;
import io.github.linpeilie.annotations.AutoMapper;
import jakarta.validation.constraints.NotBlank;
import jakarta.validation.constraints.NotNull;
import lombok.Data;
import lombok.EqualsAndHashCode;
import org.dromara.common.core.validate.AddGroup;
import org.dromara.common.core.validate.EditGroup;
import org.dromara.common.mybatis.core.domain.BaseEntity;
import org.dromara.jcbt.domain.JcbtWorkStudyApplication;
import java.util.Date;
import java.util.List;
/**
* 勤工俭学申请信息业务对象 jcbt_work_study_application
*
* @author ruoyi
* @date 2025-01-03
*/
@Data
@EqualsAndHashCode(callSuper = true)
@AutoMapper(target = JcbtWorkStudyApplication.class, reverseConvertGenerate = false)
public class JcbtWorkStudyApplicationBo extends BaseEntity {
/**
* 主键ID
*/
@NotNull(message = "主键ID不能为空", groups = { EditGroup.class })
private Long id;
/**
* 岗位ID
*/
@NotNull(message = "岗位ID不能为空", groups = { AddGroup.class, EditGroup.class })
private Long positionId;
/**
* 岗位名称（冗余字段）
*/
private String positionName;
/**
* 岗位类型
*/
private String positionType;
/**
* 工作地点
*/
private String workLocation;
/**
* 计划工作时长（小时/周）
*/
private Integer plannedWorkHours;
/**
* 学生ID
*/
private Long studentId;
/**
* 学生姓名
*/
@NotBlank(message = "学生姓名不能为空", groups = { AddGroup.class, EditGroup.class })
private String studentName;
/**
* 学号
*/
@NotBlank(message = "学号不能为空", groups = { AddGroup.class, EditGroup.class })
private String studentNumber;
/**
* 身份证号
*/
private String idCard;
/**
* 联系电话
*/
@NotBlank(message = "联系电话不能为空", groups = { AddGroup.class, EditGroup.class })
private String contactPhone;
/**
* 学生所在学院ID
*/
private Long collegeId;
/**
* 学生所在学院名称
*/
@NotBlank(message = "学院名称不能为空", groups = { AddGroup.class, EditGroup.class })
private String collegeName;
/**
* 专业名称
*/
@NotBlank(message = "专业名称不能为空", groups = { AddGroup.class, EditGroup.class })
private String majorName;
/**
* 年级
*/
private String grade;
/**
* 班级
*/
private String className;
/**
* 家庭经济情况
*/
private String familyFinancialStatus;
/**
* 申请理由
*/
@NotBlank(message = "申请理由不能为空", groups = { AddGroup.class, EditGroup.class })
private String applicationReason;
/**
* 个人能力及经验
*/
private String personalAbility;
/**
* 时间安排
*/
private String timeArrangement;
/**
* 备注
*/
private String remark;
/**
* 申请状态
*/
private String status;
/**
* 申请提交时间
*/
private Date applicationDate;
/**
* 学院审核状态
*/
private String collegeReviewStatus;
/**
* 学院审核时间
*/
private Date collegeReviewTime;
/**
* 学院审核人ID
*/
private Long collegeReviewerId;
/**
* 学院审核人姓名
*/
private String collegeReviewerName;
/**
* 学院审核意见
*/
private String collegeReviewComment;
/**
* 学生处审核状态
*/
private String finalReviewStatus;
/**
* 学生处审核时间
*/
private Date finalReviewTime;
/**
* 学生处审核人ID
*/
private Long finalReviewerId;
/**
* 学生处审核人姓名
*/
private String finalReviewerName;
/**
* 学生处审核意见
*/
private String finalReviewComment;
/**
* 工作开始时间
*/
private Date workStartDate;
/**
* 工作结束时间
*/
private Date workEndDate;
/**
* 状态列表（用于多状态查询）
*/
private List<String> statusList;
/**
* 创建时间开始（用于时间范围查询）
*/
private String createTimeStart;
/**
* 创建时间结束（用于时间范围查询）
*/
private String createTimeEnd;
}
backend/ruoyi-modules/ruoyi-jcbt/src/main/java/org/dromara/jcbt/domain/bo/JcbtWorkStudyPositionBo.java
+130
View File
@@ -0,0 +1,130 @@
package org.dromara.jcbt.domain.bo;
import io.github.linpeilie.annotations.AutoMapper;
import jakarta.validation.constraints.*;
import lombok.Data;
import lombok.EqualsAndHashCode;
import org.dromara.common.core.validate.AddGroup;
import org.dromara.common.core.validate.EditGroup;
import org.dromara.common.mybatis.core.domain.BaseEntity;
import org.dromara.jcbt.domain.JcbtWorkStudyPosition;
import java.util.Date;
/**
* 勤工俭学岗位信息业务对象 jcbt_work_study_position
*
* @author ruoyi
* @date 2025-01-03
*/
@Data
@EqualsAndHashCode(callSuper = true)
@AutoMapper(target = JcbtWorkStudyPosition.class, reverseConvertGenerate = false)
public class JcbtWorkStudyPositionBo extends BaseEntity {
/**
* 主键ID
*/
@NotNull(message = "主键ID不能为空", groups = { EditGroup.class })
private Long id;
/**
* 岗位名称
*/
@NotBlank(message = "岗位名称不能为空", groups = { AddGroup.class, EditGroup.class })
@Size(max = 100, message = "岗位名称长度不能超过100个字符")
private String positionName;
/**
* 岗位发布范围（COLLEGE-本学院，UNIVERSITY-全校）
*/
@NotBlank(message = "岗位发布范围不能为空", groups = { AddGroup.class, EditGroup.class })
private String positionScope;
/**
* 需求人数
*/
@NotNull(message = "需求人数不能为空", groups = { AddGroup.class, EditGroup.class })
@Min(value = 1, message = "需求人数必须大于0")
@Max(value = 999, message = "需求人数不能超过999")
private Integer requiredCount;
/**
* 工作时间
*/
@NotBlank(message = "工作时间不能为空", groups = { AddGroup.class, EditGroup.class })
@Size(max = 200, message = "工作时间描述长度不能超过200个字符")
private String workTime;
/**
* 工作地点
*/
@NotBlank(message = "工作地点不能为空", groups = { AddGroup.class, EditGroup.class })
@Size(max = 200, message = "工作地点描述长度不能超过200个字符")
private String workLocation;
/**
* 岗位有效期开始
*/
@NotNull(message = "岗位有效期开始时间不能为空", groups = { AddGroup.class, EditGroup.class })
private Date startDate;
/**
* 岗位有效期结束
*/
@NotNull(message = "岗位有效期结束时间不能为空", groups = { AddGroup.class, EditGroup.class })
private Date endDate;
/**
* 岗位要求
*/
@NotBlank(message = "岗位要求不能为空", groups = { AddGroup.class, EditGroup.class })
private String positionRequirements;
/**
* 薪资情况
*/
@NotBlank(message = "薪资情况不能为空", groups = { AddGroup.class, EditGroup.class })
@Size(max = 200, message = "薪资情况描述长度不能超过200个字符")
private String salaryInfo;
/**
* 联系老师
*/
@NotBlank(message = "联系老师不能为空", groups = { AddGroup.class, EditGroup.class })
@Size(max = 50, message = "联系老师姓名长度不能超过50个字符")
private String contactTeacher;
/**
* 联系电话
*/
@NotBlank(message = "联系电话不能为空", groups = { AddGroup.class, EditGroup.class })
@Pattern(regexp = "^1[3-9]\\d{9}$", message = "联系电话格式不正确")
private String contactPhone;
/**
* 发布学院ID
*/
@NotNull(message = "发布学院不能为空", groups = { AddGroup.class, EditGroup.class })
private Long collegeId;
/**
* 发布学院名称
*/
private String collegeName;
/**
* 岗位状态
*/
private String status;
/**
* 当前申请通过人数
*/
private Integer currentCount;
/**
* 租户ID
*/
private String tenantId;
}
backend/ruoyi-modules/ruoyi-jcbt/src/main/java/org/dromara/jcbt/domain/bo/WorkStudyApplicationReviewBo.java
+41
View File
@@ -0,0 +1,41 @@
package org.dromara.jcbt.domain.bo;
import jakarta.validation.constraints.NotBlank;
import jakarta.validation.constraints.NotNull;
import lombok.Data;
import org.dromara.common.core.validate.AddGroup;
import org.dromara.common.core.validate.EditGroup;
/**
* 勤工俭学申请审核业务对象
*
* @author ruoyi
* @date 2025-01-03
*/
@Data
public class WorkStudyApplicationReviewBo {
/**
* 申请ID
*/
@NotNull(message = "申请ID不能为空", groups = { AddGroup.class, EditGroup.class })
private Long applicationId;
/**
* 审核结果（APPROVED-通过，REJECTED-拒绝）
*/
@NotBlank(message = "审核结果不能为空", groups = { AddGroup.class, EditGroup.class })
private String reviewResult;
/**
* 审核意见
*/
private String reviewComment;
/**
* 审核类型（COLLEGE-学院审核，FINAL-学生处审核）
*/
@NotBlank(message = "审核类型不能为空", groups = { AddGroup.class, EditGroup.class })
private String reviewType;
}
backend/ruoyi-modules/ruoyi-jcbt/src/main/java/org/dromara/jcbt/domain/entity/.gitkeep
View File
Whitespace-only changes.
backend/ruoyi-modules/ruoyi-jcbt/src/main/java/org/dromara/jcbt/domain/vo/.gitkeep
View File
Whitespace-only changes.
backend/ruoyi-modules/ruoyi-jcbt/src/main/java/org/dromara/jcbt/domain/vo/JcbtPovertyApplicationVo.java
+256
View File
@@ -0,0 +1,256 @@
package org.dromara.jcbt.domain.vo;
import cn.idev.excel.annotation.ExcelIgnoreUnannotated;
import cn.idev.excel.annotation.ExcelProperty;
import com.fasterxml.jackson.annotation.JsonFormat;
import io.github.linpeilie.annotations.AutoMapper;
import lombok.Data;
import org.dromara.jcbt.domain.JcbtPovertyApplication;
import java.io.Serial;
import java.io.Serializable;
import java.util.Date;
/**
* 贫困生认定申请视图对象 jcbt_poverty_application
*
* @author ruoyi
* @date 2025-08-09
*/
@Data
@ExcelIgnoreUnannotated
@AutoMapper(target = JcbtPovertyApplication.class)
public class JcbtPovertyApplicationVo implements Serializable {
@Serial
private static final long serialVersionUID = 1L;
/**
* 主键ID
*/
@ExcelProperty(value = "主键ID")
private Long id;
/**
* 申请编号
*/
@ExcelProperty(value = "申请编号")
private String applicationNo;
/**
* 学年
*/
@ExcelProperty(value = "学年")
private String academicYear;
/**
* 学期
*/
@ExcelProperty(value = "学期")
private Integer term;
/**
* 学生ID
*/
private Long studentId;
/**
* 学号
*/
@ExcelProperty(value = "学号")
private String studentNo;
/**
* 学生姓名
*/
@ExcelProperty(value = "学生姓名")
private String studentName;
/**
* 性别
*/
@ExcelProperty(value = "性别")
private String gender;
/**
* 学院ID
*/
private Long collegeId;
/**
* 学院名称
*/
@ExcelProperty(value = "学院名称")
private String collegeName;
/**
* 专业ID
*/
private Long majorId;
/**
* 专业名称
*/
@ExcelProperty(value = "专业名称")
private String majorName;
/**
* 班级ID
*/
private Long classId;
/**
* 班级名称
*/
@ExcelProperty(value = "班级名称")
private String className;
/**
* 班主任教师ID
*/
private Long teacherId;
/**
* 班主任教师姓名
*/
@ExcelProperty(value = "班主任")
private String teacherName;
/**
* 认定群体（特殊群体/其他群体）
*/
@ExcelProperty(value = "认定群体")
private String recognitionGroup;
/**
* 认定类型ID
*/
private Long recognitionTypeId;
/**
* 认定类型编码
*/
private String recognitionTypeCode;
/**
* 认定类型名称
*/
@ExcelProperty(value = "认定类型")
private String recognitionTypeName;
/**
* 申请自助类型ID数组（多选）
*/
private String assistanceTypeIds;
/**
* 申请自助类型名称（多个用逗号分隔）
*/
@ExcelProperty(value = "申请自助类型")
private String assistanceTypeNames;
/**
* 家庭经济情况摘要
*/
@ExcelProperty(value = "家庭经济情况")
private String familyEconomySummary;
/**
* 申请表附件URL
*/
private String attachApplicationFormUrl;
/**
* 申请表附件ID
*/
private Long attachApplicationFormId;
/**
* 调查表附件URL
*/
private String attachSurveyFormUrl;
/**
* 调查表附件ID
*/
private Long attachSurveyFormId;
/**
* 申请状态
*/
@ExcelProperty(value = "申请状态")
private String status;
/**
* 提交人ID
*/
private Long submitterId;
/**
* 提交人姓名
*/
@ExcelProperty(value = "提交人")
private String submitterName;
/**
* 提交时间
*/
@ExcelProperty(value = "提交时间")
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date submitTime;
/**
* 审核人ID
*/
private Long auditorId;
/**
* 审核人姓名
*/
@ExcelProperty(value = "审核人")
private String auditorName;
/**
* 审核时间
*/
@ExcelProperty(value = "审核时间")
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date auditTime;
/**
* 审核意见
*/
@ExcelProperty(value = "审核意见")
private String auditOpinion;
/**
* 备注
*/
@ExcelProperty(value = "备注")
private String remark;
/**
* 创建者
*/
private Long createBy;
/**
* 创建时间
*/
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date createTime;
/**
* 更新者
*/
private Long updateBy;
/**
* 更新时间
*/
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date updateTime;
}
backend/ruoyi-modules/ruoyi-jcbt/src/main/java/org/dromara/jcbt/domain/vo/JcbtScholarshipApplicationVo.java
+197
View File
@@ -0,0 +1,197 @@
package org.dromara.jcbt.domain.vo;
import com.fasterxml.jackson.annotation.JsonFormat;
import org.dromara.jcbt.domain.JcbtScholarshipApplication;
import io.github.linpeilie.annotations.AutoMapper;
import lombok.Data;
import java.io.Serial;
import java.io.Serializable;
import java.util.Date;
/**
* 奖学金申请记录视图对象 jcbt_scholarship_application
*
* @author ruoyi
* @date 2025-01-01
*/
@Data
@AutoMapper(target = JcbtScholarshipApplication.class)
public class JcbtScholarshipApplicationVo implements Serializable {
@Serial
private static final long serialVersionUID = 1L;
/**
* 主键ID
*/
private Long id;
/**
* 批次ID
*/
private Long batchId;
/**
* 批次名称
*/
private String batchName;
/**
* 奖学金类型ID
*/
private Long scholarshipTypeId;
/**
* 奖学金名称
*/
private String scholarshipTypeName;
/**
* 申请编号
*/
private String applicationNo;
/**
* 学生学号
*/
private String studentNo;
/**
* 学生姓名
*/
private String studentName;
/**
* 学生ID
*/
private Long studentId;
/**
* 学院ID
*/
private Long deptId;
/**
* 学院名称
*/
private String deptName;
/**
* 专业ID
*/
private Long majorId;
/**
* 专业名称
*/
private String majorName;
/**
* 班级ID
*/
private Long classId;
/**
* 班级名称
*/
private String className;
// 已删除 applicantType 和 applicantId 字段
/**
* 申请人姓名
*/
private String applicantName;
/**
* 申请类型
*/
private String applicationType;
/**
* 当前状态
*/
private String currentStatus;
/**
* 状态（前端兼容字段，与currentStatus保持一致）
*/
public String getStatus() {
return currentStatus;
}
public void setStatus(String status) {
this.currentStatus = status;
}
/**
* 申请原因
*/
private String applyReason;
/**
* 自我评价
*/
private String selfEvaluation;
/**
* 系统计算分数
*/
private Double calculatedScore;
/**
* 最终评定分数
*/
private Double finalScore;
/**
* 在院系的排名
*/
private Integer rankingInDept;
/**
* 在专业的排名
*/
private Integer rankingInMajor;
/**
* 提交时间
*/
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date submitTime;
/**
* 租户编号
*/
private String tenantId;
/**
* 备注
*/
private String remark;
/**
* 创建者
*/
private Long createBy;
/**
* 创建时间
*/
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date createTime;
/**
* 更新者
*/
private Long updateBy;
/**
* 更新时间
*/
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date updateTime;
}
backend/ruoyi-modules/ruoyi-jcbt/src/main/java/org/dromara/jcbt/domain/vo/JcbtScholarshipAttachmentVo.java
+123
View File
@@ -0,0 +1,123 @@
package org.dromara.jcbt.domain.vo;
import com.fasterxml.jackson.annotation.JsonFormat;
import org.dromara.jcbt.domain.JcbtScholarshipAttachment;
import io.github.linpeilie.annotations.AutoMapper;
import lombok.Data;
import java.io.Serial;
import java.io.Serializable;
import java.util.Date;
/**
* 奖学金申请材料视图对象 jcbt_scholarship_attachment
*
* @author ruoyi
* @date 2025-01-01
*/
@Data
@AutoMapper(target = JcbtScholarshipAttachment.class)
public class JcbtScholarshipAttachmentVo implements Serializable {
@Serial
private static final long serialVersionUID = 1L;
/**
* 主键ID
*/
private Long id;
/**
* 申请记录ID
*/
private Long applicationId;
/**
* 材料类型
*/
private String materialType;
/**
* 材料名称
*/
private String materialName;
/**
* 文件名称
*/
private String fileName;
/**
* 文件路径
*/
private String filePath;
/**
* 文件大小
*/
private Long fileSize;
/**
* 上传者类型
*/
private String uploaderType;
/**
* 上传者ID
*/
private Long uploaderId;
/**
* 上传者姓名
*/
private String uploaderName;
/**
* 上传时间
*/
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date uploadTime;
/**
* 审核状态
*/
private String auditStatus;
/**
* 审核意见
*/
private String auditComment;
/**
* 是否必需
*/
private Integer isRequired;
/**
* 备注
*/
private String remark;
/**
* 创建者
*/
private Long createBy;
/**
* 创建时间
*/
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date createTime;
/**
* 更新者
*/
private Long updateBy;
/**
* 更新时间
*/
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date updateTime;
}
backend/ruoyi-modules/ruoyi-jcbt/src/main/java/org/dromara/jcbt/domain/vo/JcbtScholarshipBatchVo.java
+162
View File
@@ -0,0 +1,162 @@
package org.dromara.jcbt.domain.vo;
import org.dromara.jcbt.domain.JcbtScholarshipBatch;
import cn.idev.excel.annotation.ExcelIgnoreUnannotated;
import cn.idev.excel.annotation.ExcelProperty;
import org.dromara.common.excel.annotation.ExcelDictFormat;
import org.dromara.common.excel.convert.ExcelDictConvert;
import io.github.linpeilie.annotations.AutoMapper;
import lombok.Data;
import com.fasterxml.jackson.annotation.JsonFormat;
import java.io.Serial;
import java.io.Serializable;
import java.util.Date;
import java.util.List;
/**
* 奖学金评定批次视图对象 jcbt_scholarship_batch
*
* @author ruoyi
* @date 2025-01-27
*/
@Data
@ExcelIgnoreUnannotated
@AutoMapper(target = JcbtScholarshipBatch.class)
public class JcbtScholarshipBatchVo implements Serializable {
@Serial
private static final long serialVersionUID = 1L;
/**
* 主键ID
*/
@ExcelProperty(value = "主键ID")
private Long id;
/**
* 批次编码
*/
@ExcelProperty(value = "批次编码")
private String batchCode;
/**
* 批次名称
*/
@ExcelProperty(value = "批次名称")
private String batchName;
/**
* 学年
*/
@ExcelProperty(value = "学年")
private String academicYear;
/**
* 学期：1-第一学期，2-第二学期，3-全年
*/
@ExcelProperty(value = "学期", converter = ExcelDictConvert.class)
@ExcelDictFormat(dictType = "jcbt_semester_type")
private Integer semester;
/**
* 批次类型：REGULAR-常规批次，SPECIAL-专项批次，SUPPLEMENTARY-补充批次
*/
@ExcelProperty(value = "批次类型", converter = ExcelDictConvert.class)
@ExcelDictFormat(dictType = "jcbt_batch_type")
private String batchType;
/**
* 开始时间
*/
@ExcelProperty(value = "开始时间")
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date startTime;
/**
* 结束时间
*/
@ExcelProperty(value = "结束时间")
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date endTime;
/**
* 申请开始时间
*/
@ExcelProperty(value = "申请开始时间")
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date applyStartTime;
/**
* 申请结束时间
*/
@ExcelProperty(value = "申请结束时间")
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date applyEndTime;
/**
* 审核开始时间
*/
@ExcelProperty(value = "审核开始时间")
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date reviewStartTime;
/**
* 审核结束时间
*/
@ExcelProperty(value = "审核结束时间")
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date reviewEndTime;
/**
* 状态：DRAFT-草稿，ACTIVE-进行中，COMPLETED-已完成，CANCELLED-已取消
*/
@ExcelProperty(value = "状态", converter = ExcelDictConvert.class)
@ExcelDictFormat(dictType = "jcbt_batch_status")
private String status;
/**
* 批次描述
*/
@ExcelProperty(value = "批次描述")
private String description;
/**
* 通知内容
*/
@ExcelProperty(value = "通知内容")
private String noticeContent;
/**
* 创建者
*/
private Long createBy;
/**
* 创建时间
*/
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date createTime;
/**
* 更新者
*/
private Long updateBy;
/**
* 更新时间
*/
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date updateTime;
/**
* 关联的奖学金类型ID列表
*/
private List<Long> scholarshipTypeIds;
/**
* 租户ID
*/
private Long tenantId;
}
backend/ruoyi-modules/ruoyi-jcbt/src/main/java/org/dromara/jcbt/domain/vo/JcbtScholarshipClassQuotaVo.java
+117
View File
@@ -0,0 +1,117 @@
package org.dromara.jcbt.domain.vo;
import com.fasterxml.jackson.annotation.JsonFormat;
import org.dromara.jcbt.domain.JcbtScholarshipClassQuota;
import io.github.linpeilie.annotations.AutoMapper;
import lombok.Data;
import java.io.Serial;
import java.io.Serializable;
import java.util.Date;
/**
* 班级奖学金名额分配视图对象 jcbt_scholarship_class_quota
*
* @author ruoyi
* @date 2025-01-01
*/
@Data
@AutoMapper(target = JcbtScholarshipClassQuota.class)
public class JcbtScholarshipClassQuotaVo implements Serializable {
@Serial
private static final long serialVersionUID = 1L;
/**
* 主键ID
*/
private Long id;
/**
* 批次ID
*/
private Long batchId;
/**
* 批次名称
*/
private String batchName;
/**
* 奖学金类型ID
*/
private Long scholarshipTypeId;
/**
* 奖学金类型名称
*/
private String scholarshipTypeName;
/**
* 班级ID
*/
private Long classId;
/**
* 班级名称
*/
private String className;
/**
* 总名额
*/
private Integer totalQuota;
/**
* 已使用名额
*/
private Integer usedQuota;
/**
* 可用名额
*/
private Integer availableQuota;
/**
* 分配方式
*/
private String allocationMethod;
/**
* 分配级别
*/
private String allocationLevel;
/**
* 名额状态
*/
private String status;
/**
* 备注
*/
private String remark;
/**
* 创建者
*/
private Long createBy;
/**
* 创建时间
*/
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date createTime;
/**
* 更新者
*/
private Long updateBy;
/**
* 更新时间
*/
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date updateTime;
}
backend/ruoyi-modules/ruoyi-jcbt/src/main/java/org/dromara/jcbt/domain/vo/JcbtScholarshipCompatibilityVo.java
+99
View File
@@ -0,0 +1,99 @@
package org.dromara.jcbt.domain.vo;
import org.dromara.jcbt.domain.JcbtScholarshipCompatibility;
import cn.idev.excel.annotation.ExcelIgnoreUnannotated;
import cn.idev.excel.annotation.ExcelProperty;
import com.baomidou.mybatisplus.annotation.TableField;
import org.dromara.common.excel.annotation.ExcelDictFormat;
import org.dromara.common.excel.convert.ExcelDictConvert;
import io.github.linpeilie.annotations.AutoMapper;
import lombok.Data;
import com.fasterxml.jackson.annotation.JsonFormat;
import java.io.Serial;
import java.io.Serializable;
import java.util.Date;
/**
* 奖学金兼得关系视图对象 jcbt_scholarship_compatibility
*
* @author ruoyi
* @date 2025-01-27
*/
@Data
@ExcelIgnoreUnannotated
@AutoMapper(target = JcbtScholarshipCompatibility.class)
public class JcbtScholarshipCompatibilityVo implements Serializable {
@Serial
private static final long serialVersionUID = 1L;
/**
* 主键ID
*/
@ExcelProperty(value = "主键ID")
private Long id;
/**
* 奖学金类型1
*/
@ExcelProperty(value = "奖学金类型1")
@TableField("type_id_1")
private Long typeId1;
/**
* 奖学金类型2
*/
@ExcelProperty(value = "奖学金类型2")
@TableField("type_id_2")
private Long typeId2;
/**
* 关系类型：COMPATIBLE-兼容，EXCLUSIVE-互斥，PRIORITY-优先级关系
*/
@ExcelProperty(value = "关系类型", converter = ExcelDictConvert.class)
@ExcelDictFormat(dictType = "jcbt_relation_type")
@TableField("relation_type")
private String relationType;
/**
* 优先级（relation_type为PRIORITY时有效）
*/
@ExcelProperty(value = "优先级")
@TableField("priority_level")
private Integer priorityLevel;
/**
* 关系描述
*/
@ExcelProperty(value = "关系描述")
private String description;
/**
* 创建者
*/
private Long createBy;
/**
* 创建时间
*/
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date createTime;
/**
* 更新者
*/
private Long updateBy;
/**
* 更新时间
*/
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date updateTime;
/**
* 租户ID
*/
private Long tenantId;
}
backend/ruoyi-modules/ruoyi-jcbt/src/main/java/org/dromara/jcbt/domain/vo/JcbtScholarshipQuotaVo.java
+224
View File
@@ -0,0 +1,224 @@
package org.dromara.jcbt.domain.vo;
import cn.idev.excel.annotation.ExcelIgnoreUnannotated;
import cn.idev.excel.annotation.ExcelProperty;
import com.fasterxml.jackson.annotation.JsonFormat;
import io.github.linpeilie.annotations.AutoMapper;
import lombok.Data;
import org.dromara.jcbt.domain.JcbtScholarshipQuota;
import java.io.Serial;
import java.io.Serializable;
import java.util.Date;
/**
* 奖学金名额分配视图对象 JcbtScholarshipQuotaVo
*
* @author ruoyi
* @date 2025-01-27
*/
@Data
@ExcelIgnoreUnannotated
@AutoMapper(target = JcbtScholarshipQuota.class)
public class JcbtScholarshipQuotaVo implements Serializable {
@Serial
private static final long serialVersionUID = 1L;
/**
* 主键ID
*/
@ExcelProperty(value = "主键ID")
private Long id;
/**
* 批次ID
*/
@ExcelProperty(value = "批次ID")
private Long batchId;
/**
* 批次名称
*/
@ExcelProperty(value = "批次名称")
private String batchName;
/**
* 批次编码
*/
@ExcelProperty(value = "批次编码")
private String batchCode;
/**
* 学年
*/
@ExcelProperty(value = "学年")
private String academicYear;
/**
* 学期
*/
@ExcelProperty(value = "学期")
private Integer semester;
/**
* 奖学金类型ID
*/
@ExcelProperty(value = "奖学金类型ID")
private Long scholarshipTypeId;
/**
* 奖学金类型名称
*/
@ExcelProperty(value = "奖学金类型名称")
private String scholarshipTypeName;
/**
* 奖学金等级
*/
@ExcelProperty(value = "奖学金等级")
private String scholarshipLevel;
/**
* 分配级别：UNIVERSITY-全校，COLLEGE-学院，MAJOR-专业，CLASS-班级
*/
@ExcelProperty(value = "分配级别")
private String allocationLevel;
/**
* 分配级别名称
*/
@ExcelProperty(value = "分配级别名称")
private String allocationLevelName;
/**
* 目标部门ID（学院/专业/班级）
*/
@ExcelProperty(value = "目标部门ID")
private Long targetDeptId;
/**
* 目标部门名称
*/
@ExcelProperty(value = "目标部门名称")
private String targetDeptName;
/**
* 上级名额ID（层级分配）
*/
@ExcelProperty(value = "上级名额ID")
private Long parentQuotaId;
/**
* 上级部门名称
*/
@ExcelProperty(value = "上级部门名称")
private String parentDeptName;
/**
* 总名额
*/
@ExcelProperty(value = "总名额")
private Integer totalQuota;
/**
* 已使用名额
*/
@ExcelProperty(value = "已使用名额")
private Integer usedQuota;
/**
* 预留名额
*/
@ExcelProperty(value = "预留名额")
private Integer reservedQuota;
/**
* 可用名额
*/
@ExcelProperty(value = "可用名额")
private Integer availableQuota;
/**
* 分配规则（JSON格式）
*/
@ExcelProperty(value = "分配规则")
private String allocationRule;
/**
* 分配依据说明
*/
@ExcelProperty(value = "分配依据说明")
private String allocationBasis;
/**
* 分配方式：MANUAL-手动分配，AUTO-自动分配，PROPORTIONAL-按比例分配
*/
@ExcelProperty(value = "分配方式")
private String allocationMethod;
/**
* 分配方式名称
*/
@ExcelProperty(value = "分配方式名称")
private String allocationMethodName;
/**
* 是否可调整：0-否，1-是
*/
@ExcelProperty(value = "是否可调整")
private Integer isAdjustable;
/**
* 是否锁定：0-否，1-是
*/
@ExcelProperty(value = "是否锁定")
private Integer isLocked;
/**
* 状态：ACTIVE-生效，INACTIVE-失效，PENDING-待审核
*/
@ExcelProperty(value = "状态")
private String status;
/**
* 状态名称
*/
@ExcelProperty(value = "状态名称")
private String statusName;
/**
* 备注
*/
@ExcelProperty(value = "备注")
private String remark;
/**
* 租户ID
*/
private Long tenantId;
/**
* 创建者
*/
private Long createBy;
/**
* 创建时间
*/
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
@ExcelProperty(value = "创建时间")
private Date createTime;
/**
* 更新者
*/
private Long updateBy;
/**
* 更新时间
*/
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date updateTime;
}
backend/ruoyi-modules/ruoyi-jcbt/src/main/java/org/dromara/jcbt/domain/vo/JcbtScholarshipReviewVo.java
+162
View File
@@ -0,0 +1,162 @@
package org.dromara.jcbt.domain.vo;
import cn.idev.excel.annotation.ExcelIgnoreUnannotated;
import cn.idev.excel.annotation.ExcelProperty;
import com.fasterxml.jackson.annotation.JsonFormat;
import io.github.linpeilie.annotations.AutoMapper;
import lombok.Data;
import org.dromara.jcbt.domain.JcbtScholarshipReview;
import java.io.Serial;
import java.io.Serializable;
import java.math.BigDecimal;
import java.util.Date;
/**
* 奖学金审核记录视图对象 jcbt_scholarship_review
*
* @author ruoyi
* @date 2025-08-05
*/
@Data
@ExcelIgnoreUnannotated
@AutoMapper(target = JcbtScholarshipReview.class)
public class JcbtScholarshipReviewVo implements Serializable {
@Serial
private static final long serialVersionUID = 1L;
/**
* 主键ID
*/
@ExcelProperty(value = "主键ID")
private Long id;
/**
* 申请记录ID
*/
@ExcelProperty(value = "申请记录ID")
private Long applicationId;
/**
* 审核级别：DEPARTMENT-院系审核，SCHOOL-学校审核，FINANCE-财务审核，FINAL-终审
*/
@ExcelProperty(value = "审核级别")
private String reviewLevel;
/**
* 审核人ID
*/
@ExcelProperty(value = "审核人ID")
private Long reviewerId;
/**
* 审核人姓名
*/
@ExcelProperty(value = "审核人姓名")
private String reviewerName;
/**
* 审核结果：PENDING-待审核，APPROVED-通过，REJECTED-拒绝，RETURNED-退回
*/
@ExcelProperty(value = "审核结果")
private String reviewResult;
/**
* 审核评分
*/
@ExcelProperty(value = "审核评分")
private BigDecimal reviewScore;
/**
* 审核意见
*/
@ExcelProperty(value = "审核意见")
private String reviewOpinion;
/**
* 审核时间
*/
@ExcelProperty(value = "审核时间")
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date reviewTime;
/**
* 下一审核人ID
*/
@ExcelProperty(value = "下一审核人ID")
private Long nextReviewerId;
/**
* 是否最终审核：0-否，1-是
*/
@ExcelProperty(value = "是否最终审核")
private Integer isFinalReview;
/**
* 租户ID
*/
@ExcelProperty(value = "租户ID")
private String tenantId;
/**
* 创建者（基础字段）
*/
private Long createBy;
/**
* 创建时间（基础字段）
*/
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date createTime;
/**
* 更新者（基础字段）
*/
private Long updateBy;
/**
* 更新时间（基础字段）
*/
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date updateTime;
// 扩展字段：申请信息
/**
* 申请编号
*/
@ExcelProperty(value = "申请编号")
private String applicationNo;
/**
* 学生学号
*/
@ExcelProperty(value = "学生学号")
private String studentNo;
/**
* 学生姓名
*/
@ExcelProperty(value = "学生姓名")
private String studentName;
/**
* 奖学金类型名称
*/
@ExcelProperty(value = "奖学金类型")
private String scholarshipTypeName;
/**
* 批次名称
*/
@ExcelProperty(value = "批次名称")
private String batchName;
/**
* 申请状态
*/
@ExcelProperty(value = "申请状态")
private String applicationStatus;
}
backend/ruoyi-modules/ruoyi-jcbt/src/main/java/org/dromara/jcbt/domain/vo/JcbtScholarshipTypeVo.java
+147
View File
@@ -0,0 +1,147 @@
package org.dromara.jcbt.domain.vo;
import org.dromara.jcbt.domain.JcbtScholarshipType;
import cn.idev.excel.annotation.ExcelIgnoreUnannotated;
import cn.idev.excel.annotation.ExcelProperty;
import org.dromara.common.excel.annotation.ExcelDictFormat;
import org.dromara.common.excel.convert.ExcelDictConvert;
import io.github.linpeilie.annotations.AutoMapper;
import lombok.Data;
import com.fasterxml.jackson.annotation.JsonFormat;
import java.io.Serial;
import java.io.Serializable;
import java.math.BigDecimal;
import java.util.Date;
/**
* 奖学金类型视图对象 jcbt_scholarship_type
*
* @author ruoyi
* @date 2025-01-27
*/
@Data
@ExcelIgnoreUnannotated
@AutoMapper(target = JcbtScholarshipType.class)
public class JcbtScholarshipTypeVo implements Serializable {
@Serial
private static final long serialVersionUID = 1L;
/**
* 主键ID
*/
@ExcelProperty(value = "主键ID")
private Long id;
/**
* 奖学金类型编码
*/
@ExcelProperty(value = "奖学金类型编码")
private String typeCode;
/**
* 奖学金名称
*/
@ExcelProperty(value = "奖学金名称")
private String typeName;
/**
* 奖学金类别
*/
@ExcelProperty(value = "奖学金类别", converter = ExcelDictConvert.class)
@ExcelDictFormat(dictType = "jcbt_scholarship_category")
private String typeCategory;
/**
* 奖学金等级
*/
@ExcelProperty(value = "奖学金等级", converter = ExcelDictConvert.class)
@ExcelDictFormat(dictType = "jcbt_scholarship_level")
private String levelType;
/**
* 奖金金额
*/
@ExcelProperty(value = "奖金金额")
private BigDecimal awardAmount;
/**
* 奖学金描述
*/
@ExcelProperty(value = "奖学金描述")
private String description;
/**
* 申请指南
*/
@ExcelProperty(value = "申请指南")
private String applicationGuide;
/**
* 申请条件
*/
@ExcelProperty(value = "申请条件")
private String applicationConditions;
/**
* 评定标准
*/
@ExcelProperty(value = "评定标准")
private String evaluationCriteria;
/**
* 备注
*/
@ExcelProperty(value = "备注")
private String remark;
/**
* 排序号
*/
@ExcelProperty(value = "排序号")
private Integer sortOrder;
/**
* 状态：0-停用 1-启用
*/
@ExcelProperty(value = "状态", converter = ExcelDictConvert.class)
@ExcelDictFormat(dictType = "sys_normal_disable")
private Integer status;
/**
* 是否系统内置：0-否，1-是
*/
@ExcelProperty(value = "是否系统内置", converter = ExcelDictConvert.class)
@ExcelDictFormat(dictType = "sys_yes_no")
private Integer isSystem;
/**
* 兼得类型：EXCLUSIVE-完全互斥，COMPATIBLE-完全兼容，CUSTOM-自定义配置
*/
@ExcelProperty(value = "兼得类型")
private String compatibilityType;
/**
* 创建者
*/
private Long createBy;
/**
* 创建时间
*/
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date createTime;
/**
* 更新者
*/
private Long updateBy;
/**
* 更新时间
*/
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date updateTime;
}
backend/ruoyi-modules/ruoyi-jcbt/src/main/java/org/dromara/jcbt/domain/vo/JcbtWorkStudyApplicationVo.java
+297
View File
@@ -0,0 +1,297 @@
package org.dromara.jcbt.domain.vo;
import cn.idev.excel.annotation.ExcelIgnoreUnannotated;
import cn.idev.excel.annotation.ExcelProperty;
import com.fasterxml.jackson.annotation.JsonFormat;
import io.github.linpeilie.annotations.AutoMapper;
import lombok.Data;
import org.dromara.jcbt.domain.JcbtWorkStudyApplication;
import java.io.Serial;
import java.io.Serializable;
import java.util.Date;
/**
* 勤工俭学申请信息视图对象 jcbt_work_study_application
*
* @author ruoyi
* @date 2025-01-03
*/
@Data
@ExcelIgnoreUnannotated
@AutoMapper(target = JcbtWorkStudyApplication.class)
public class JcbtWorkStudyApplicationVo implements Serializable {
@Serial
private static final long serialVersionUID = 1L;
/**
* 主键ID
*/
@ExcelProperty(value = "主键ID")
private Long id;
/**
* 岗位ID
*/
@ExcelProperty(value = "岗位ID")
private Long positionId;
/**
* 岗位名称
*/
@ExcelProperty(value = "岗位名称")
private String positionName;
/**
* 岗位类型
*/
@ExcelProperty(value = "岗位类型")
private String positionType;
/**
* 工作地点
*/
@ExcelProperty(value = "工作地点")
private String workLocation;
/**
* 计划工作时长（小时/周）
*/
@ExcelProperty(value = "计划工作时长")
private Integer plannedWorkHours;
/**
* 学生ID
*/
@ExcelProperty(value = "学生ID")
private Long studentId;
/**
* 学生姓名
*/
@ExcelProperty(value = "学生姓名")
private String studentName;
/**
* 学号
*/
@ExcelProperty(value = "学号")
private String studentNumber;
/**
* 身份证号
*/
@ExcelProperty(value = "身份证号")
private String idCard;
/**
* 联系电话
*/
@ExcelProperty(value = "联系电话")
private String contactPhone;
/**
* 学生所在学院ID
*/
@ExcelProperty(value = "学院ID")
private Long collegeId;
/**
* 学生所在学院名称
*/
@ExcelProperty(value = "学院名称")
private String collegeName;
/**
* 专业名称
*/
@ExcelProperty(value = "专业名称")
private String majorName;
/**
* 年级
*/
@ExcelProperty(value = "年级")
private String grade;
/**
* 班级
*/
@ExcelProperty(value = "班级")
private String className;
/**
* 家庭经济情况
*/
@ExcelProperty(value = "家庭经济情况")
private String familyFinancialStatus;
/**
* 申请理由
*/
@ExcelProperty(value = "申请理由")
private String applicationReason;
/**
* 个人能力及经验
*/
@ExcelProperty(value = "个人能力及经验")
private String personalAbility;
/**
* 时间安排
*/
@ExcelProperty(value = "时间安排")
private String timeArrangement;
/**
* 备注
*/
@ExcelProperty(value = "备注")
private String remark;
/**
* 申请状态
*/
@ExcelProperty(value = "申请状态")
private String status;
/**
* 申请提交时间
*/
@ExcelProperty(value = "申请提交时间")
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date applicationDate;
/**
* 学院审核状态
*/
@ExcelProperty(value = "学院审核状态")
private String collegeReviewStatus;
/**
* 学院审核时间
*/
@ExcelProperty(value = "学院审核时间")
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date collegeReviewTime;
/**
* 学院审核人ID
*/
@ExcelProperty(value = "学院审核人ID")
private Long collegeReviewerId;
/**
* 学院审核人姓名
*/
@ExcelProperty(value = "学院审核人姓名")
private String collegeReviewerName;
/**
* 学院审核意见
*/
@ExcelProperty(value = "学院审核意见")
private String collegeReviewComment;
/**
* 学生处审核状态
*/
@ExcelProperty(value = "学生处审核状态")
private String finalReviewStatus;
/**
* 学生处审核时间
*/
@ExcelProperty(value = "学生处审核时间")
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date finalReviewTime;
/**
* 学生处审核人ID
*/
@ExcelProperty(value = "学生处审核人ID")
private Long finalReviewerId;
/**
* 学生处审核人姓名
*/
@ExcelProperty(value = "学生处审核人姓名")
private String finalReviewerName;
/**
* 学生处审核意见
*/
@ExcelProperty(value = "学生处审核意见")
private String finalReviewComment;
/**
* 工作开始时间
*/
@ExcelProperty(value = "工作开始时间")
@JsonFormat(pattern = "yyyy-MM-dd")
private Date workStartDate;
/**
* 工作结束时间
*/
@ExcelProperty(value = "工作结束时间")
@JsonFormat(pattern = "yyyy-MM-dd")
private Date workEndDate;
/**
* 创建者
*/
private Long createBy;
/**
* 创建时间
*/
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date createTime;
/**
* 更新者
*/
private Long updateBy;
/**
* 更新时间
*/
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date updateTime;
// ===== 岗位详细信息字段 =====
/**
* 岗位描述
*/
@ExcelProperty(value = "岗位描述")
private String positionDescription;
/**
* 工作要求
*/
@ExcelProperty(value = "工作要求")
private String workRequirements;
/**
* 薪资待遇（元/小时）
*/
@ExcelProperty(value = "薪资待遇")
private String salary;
/**
* 招聘人数
*/
@ExcelProperty(value = "招聘人数")
private Integer recruitmentQuota;
/**
* 当前申请人数
*/
@ExcelProperty(value = "当前申请人数")
private Integer currentApplicants;
}
backend/ruoyi-modules/ruoyi-jcbt/src/main/java/org/dromara/jcbt/domain/vo/JcbtWorkStudyPositionVo.java
+166
View File
@@ -0,0 +1,166 @@
package org.dromara.jcbt.domain.vo;
import cn.idev.excel.annotation.ExcelIgnoreUnannotated;
import cn.idev.excel.annotation.ExcelProperty;
import com.fasterxml.jackson.annotation.JsonFormat;
import io.github.linpeilie.annotations.AutoMapper;
import lombok.Data;
import org.dromara.jcbt.domain.JcbtWorkStudyPosition;
import java.io.Serial;
import java.io.Serializable;
import java.util.Date;
/**
* 勤工俭学岗位信息视图对象 jcbt_work_study_position
*
* @author ruoyi
* @date 2025-01-03
*/
@Data
@ExcelIgnoreUnannotated
@AutoMapper(target = JcbtWorkStudyPosition.class)
public class JcbtWorkStudyPositionVo implements Serializable {
@Serial
private static final long serialVersionUID = 1L;
/**
* 主键ID
*/
@ExcelProperty(value = "主键ID")
private Long id;
/**
* 岗位名称
*/
@ExcelProperty(value = "岗位名称")
private String positionName;
/**
* 岗位发布范围
*/
@ExcelProperty(value = "岗位发布范围")
private String positionScope;
/**
* 发布范围名称
*/
private String positionScopeName;
/**
* 需求人数
*/
@ExcelProperty(value = "需求人数")
private Integer requiredCount;
/**
* 工作时间
*/
@ExcelProperty(value = "工作时间")
private String workTime;
/**
* 工作地点
*/
@ExcelProperty(value = "工作地点")
private String workLocation;
/**
* 岗位有效期开始
*/
@ExcelProperty(value = "岗位有效期开始")
@JsonFormat(pattern = "yyyy-MM-dd")
private Date startDate;
/**
* 岗位有效期结束
*/
@ExcelProperty(value = "岗位有效期结束")
@JsonFormat(pattern = "yyyy-MM-dd")
private Date endDate;
/**
* 岗位要求
*/
@ExcelProperty(value = "岗位要求")
private String positionRequirements;
/**
* 薪资情况
*/
@ExcelProperty(value = "薪资情况")
private String salaryInfo;
/**
* 联系老师
*/
@ExcelProperty(value = "联系老师")
private String contactTeacher;
/**
* 联系电话
*/
@ExcelProperty(value = "联系电话")
private String contactPhone;
/**
* 发布学院ID
*/
private Long collegeId;
/**
* 发布学院名称
*/
@ExcelProperty(value = "发布学院")
private String collegeName;
/**
* 岗位状态
*/
@ExcelProperty(value = "岗位状态")
private String status;
/**
* 岗位状态名称
*/
private String statusName;
/**
* 当前申请通过人数
*/
@ExcelProperty(value = "当前申请通过人数")
private Integer currentCount;
/**
* 租户ID
*/
private String tenantId;
/**
* 创建部门
*/
private Long createDept;
/**
* 创建者
*/
private Long createBy;
/**
* 创建时间
*/
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date createTime;
/**
* 更新者
*/
private Long updateBy;
/**
* 更新时间
*/
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date updateTime;
}
backend/ruoyi-modules/ruoyi-jcbt/src/main/java/org/dromara/jcbt/enums/ApplicationStatusEnum.java
+111
View File
@@ -0,0 +1,111 @@
package org.dromara.jcbt.enums;
import lombok.AllArgsConstructor;
import lombok.Getter;
/**
* 申请状态枚举
*
* @author ruoyi
* @date 2025-08-09
*/
@Getter
@AllArgsConstructor
public enum ApplicationStatusEnum {
/**
* 草稿
*/
DRAFT("DRAFT", "草稿"),
/**
* 已提交
*/
SUBMITTED("SUBMITTED", "已提交"),
/**
* 待审核
*/
WAITING("WAITING", "待审核"),
/**
* 已驳回
*/
REJECTED("REJECTED", "已驳回"),
/**
* 已通过
*/
COMPLETE("COMPLETE", "已通过"),
/**
* 已撤销
*/
CANCELED("CANCELED", "已撤销");
/**
* 状态编码
*/
private final String code;
/**
* 状态名称
*/
private final String name;
/**
* 根据编码获取枚举
*
* @param code 状态编码
* @return 枚举对象
*/
public static ApplicationStatusEnum getByCode(String code) {
for (ApplicationStatusEnum status : values()) {
if (status.getCode().equals(code)) {
return status;
}
}
return null;
}
/**
* 判断是否为有效状态
*
* @param code 状态编码
* @return 是否有效
*/
public static boolean isValidStatus(String code) {
return getByCode(code) != null;
}
/**
* 判断是否可以编辑
*
* @param code 状态编码
* @return 是否可以编辑
*/
public static boolean canEdit(String code) {
return DRAFT.getCode().equals(code) || REJECTED.getCode().equals(code);
}
/**
* 判断是否可以撤销
*
* @param code 状态编码
* @return 是否可以撤销
*/
public static boolean canCancel(String code) {
return WAITING.getCode().equals(code);
}
/**
* 判断是否可以审核
*
* @param code 状态编码
* @return 是否可以审核
*/
public static boolean canAudit(String code) {
return WAITING.getCode().equals(code) || SUBMITTED.getCode().equals(code);
}
}
backend/ruoyi-modules/ruoyi-jcbt/src/main/java/org/dromara/jcbt/enums/PositionScopeEnum.java
+88
View File
@@ -0,0 +1,88 @@
package org.dromara.jcbt.enums;
import lombok.AllArgsConstructor;
import lombok.Getter;
/**
* 勤工俭学岗位发布范围枚举
*
* @author ruoyi
* @date 2025-01-03
*/
@Getter
@AllArgsConstructor
public enum PositionScopeEnum {
/**
* 本学院
*/
COLLEGE("COLLEGE", "本学院"),
/**
* 全校
*/
UNIVERSITY("UNIVERSITY", "全校");
/**
* 范围编码
*/
private final String code;
/**
* 范围描述
*/
private final String description;
/**
* 根据编码获取枚举
*
* @param code 范围编码
* @return 枚举值
*/
public static PositionScopeEnum getByCode(String code) {
for (PositionScopeEnum scope : values()) {
if (scope.getCode().equals(code)) {
return scope;
}
}
return null;
}
/**
* 检查范围是否有效
*
* @param code 范围编码
* @return 是否有效
*/
public static boolean isValidCode(String code) {
return getByCode(code) != null;
}
/**
* 获取所有范围编码
*
* @return 范围编码数组
*/
public static String[] getAllCodes() {
PositionScopeEnum[] enums = values();
String[] codes = new String[enums.length];
for (int i = 0; i < enums.length; i++) {
codes[i] = enums[i].getCode();
}
return codes;
}
/**
* 获取所有范围描述
*
* @return 范围描述数组
*/
public static String[] getAllDescriptions() {
PositionScopeEnum[] enums = values();
String[] descriptions = new String[enums.length];
for (int i = 0; i < enums.length; i++) {
descriptions[i] = enums[i].getDescription();
}
return descriptions;
}
}
backend/ruoyi-modules/ruoyi-jcbt/src/main/java/org/dromara/jcbt/enums/PositionStatusEnum.java
+113
View File
@@ -0,0 +1,113 @@
package org.dromara.jcbt.enums;
import lombok.AllArgsConstructor;
import lombok.Getter;
/**
* 勤工俭学岗位状态枚举
*
* @author ruoyi
* @date 2025-01-03
*/
@Getter
@AllArgsConstructor
public enum PositionStatusEnum {
/**
* 草稿
*/
DRAFT("DRAFT", "草稿"),
/**
* 已发布
*/
PUBLISHED("PUBLISHED", "已发布"),
/**
* 招录中
*/
RECRUITING("RECRUITING", "招录中"),
/**
* 已满员
*/
FULL("FULL", "已满员"),
/**
* 已过期
*/
EXPIRED("EXPIRED", "已过期"),
/**
* 已暂停
*/
SUSPENDED("SUSPENDED", "已暂停"),
/**
* 已取消
*/
CANCELLED("CANCELLED", "已取消");
/**
* 状态编码
*/
private final String code;
/**
* 状态描述
*/
private final String description;
/**
* 根据编码获取枚举
*
* @param code 状态编码
* @return 枚举值
*/
public static PositionStatusEnum getByCode(String code) {
for (PositionStatusEnum status : values()) {
if (status.getCode().equals(code)) {
return status;
}
}
return null;
}
/**
* 检查状态是否有效
*
* @param code 状态编码
* @return 是否有效
*/
public static boolean isValidCode(String code) {
return getByCode(code) != null;
}
/**
* 获取所有状态编码
*
* @return 状态编码数组
*/
public static String[] getAllCodes() {
PositionStatusEnum[] enums = values();
String[] codes = new String[enums.length];
for (int i = 0; i < enums.length; i++) {
codes[i] = enums[i].getCode();
}
return codes;
}
/**
* 获取所有状态描述
*
* @return 状态描述数组
*/
public static String[] getAllDescriptions() {
PositionStatusEnum[] enums = values();
String[] descriptions = new String[enums.length];
for (int i = 0; i < enums.length; i++) {
descriptions[i] = enums[i].getDescription();
}
return descriptions;
}
}
backend/ruoyi-modules/ruoyi-jcbt/src/main/java/org/dromara/jcbt/enums/ReviewStatusEnum.java
+66
View File
@@ -0,0 +1,66 @@
package org.dromara.jcbt.enums;
import lombok.AllArgsConstructor;
import lombok.Getter;
/**
* 审核状态枚举
*
* @author ruoyi
* @date 2025-01-03
*/
@Getter
@AllArgsConstructor
public enum ReviewStatusEnum {
/**
* 待审核
*/
PENDING("PENDING", "待审核"),
/**
* 审核通过
*/
APPROVED("APPROVED", "审核通过"),
/**
* 审核拒绝
*/
REJECTED("REJECTED", "审核拒绝");
/**
* 状态码
*/
private final String code;
/**
* 状态描述
*/
private final String description;
/**
* 根据状态码获取枚举
*
* @param code 状态码
* @return 枚举
*/
public static ReviewStatusEnum getByCode(String code) {
for (ReviewStatusEnum status : values()) {
if (status.getCode().equals(code)) {
return status;
}
}
return null;
}
/**
* 判断是否为有效状态
*
* @param code 状态码
* @return 是否有效
*/
public static boolean isValidStatus(String code) {
return getByCode(code) != null;
}
}
backend/ruoyi-modules/ruoyi-jcbt/src/main/java/org/dromara/jcbt/enums/WorkStudyApplicationStatusEnum.java
+86
View File
@@ -0,0 +1,86 @@
package org.dromara.jcbt.enums;
import lombok.AllArgsConstructor;
import lombok.Getter;
/**
* 勤工俭学申请状态枚举
*
* @author ruoyi
* @date 2025-01-03
*/
@Getter
@AllArgsConstructor
public enum WorkStudyApplicationStatusEnum {
/**
* 草稿
*/
DRAFT("DRAFT", "草稿"),
/**
* 已提交
*/
SUBMITTED("SUBMITTED", "已提交"),
/**
* 学院审核通过
*/
COLLEGE_APPROVED("COLLEGE_APPROVED", "学院审核通过"),
/**
* 学院审核拒绝
*/
COLLEGE_REJECTED("COLLEGE_REJECTED", "学院审核拒绝"),
/**
* 学生处审核通过
*/
FINAL_APPROVED("FINAL_APPROVED", "学生处审核通过"),
/**
* 学生处审核拒绝
*/
FINAL_REJECTED("FINAL_REJECTED", "学生处审核拒绝"),
/**
* 已取消
*/
CANCELLED("CANCELLED", "已取消");
/**
* 状态码
*/
private final String code;
/**
* 状态描述
*/
private final String description;
/**
* 根据状态码获取枚举
*
* @param code 状态码
* @return 枚举
*/
public static WorkStudyApplicationStatusEnum getByCode(String code) {
for (WorkStudyApplicationStatusEnum status : values()) {
if (status.getCode().equals(code)) {
return status;
}
}
return null;
}
/**
* 判断是否为有效状态
*
* @param code 状态码
* @return 是否有效
*/
public static boolean isValidStatus(String code) {
return getByCode(code) != null;
}
}
backend/ruoyi-modules/ruoyi-jcbt/src/main/java/org/dromara/jcbt/event/.gitkeep
View File
Whitespace-only changes.
backend/ruoyi-modules/ruoyi-jcbt/src/main/java/org/dromara/jcbt/listener/.gitkeep
View File
Whitespace-only changes.
backend/ruoyi-modules/ruoyi-jcbt/src/main/java/org/dromara/jcbt/mapper/.gitkeep
View File
Whitespace-only changes.
backend/ruoyi-modules/ruoyi-jcbt/src/main/java/org/dromara/jcbt/mapper/JcbtPovertyApplicationMapper.java
+91
View File
@@ -0,0 +1,91 @@
package org.dromara.jcbt.mapper;
import org.dromara.common.mybatis.core.mapper.BaseMapperPlus;
import org.dromara.jcbt.domain.JcbtPovertyApplication;
import org.dromara.jcbt.domain.vo.JcbtPovertyApplicationVo;
import org.apache.ibatis.annotations.Param;
import java.util.List;
import java.util.Map;
/**
* 贫困生认定申请Mapper接口
*
* @author ruoyi
* @date 2025-08-09
*/
public interface JcbtPovertyApplicationMapper extends BaseMapperPlus<JcbtPovertyApplication, JcbtPovertyApplicationVo> {
/**
* 查询贫困生认定申请列表
*
* @param application 贫困生认定申请
* @return 贫困生认定申请集合
*/
List<JcbtPovertyApplicationVo> selectApplicationList(JcbtPovertyApplication application);
/**
* 根据申请编号查询申请信息
*
* @param applicationNo 申请编号
* @return 申请信息
*/
JcbtPovertyApplicationVo selectByApplicationNo(@Param("applicationNo") String applicationNo);
/**
* 检查学生在指定学年是否已有认定申请
*
* @param studentId 学生ID
* @param academicYear 学年
* @param recognitionTypeId 认定类型ID
* @param excludeId 排除的申请ID（用于修改时排除自己）
* @return 申请数量
*/
int checkStudentApplicationExists(@Param("studentId") Long studentId,
@Param("academicYear") String academicYear,
@Param("recognitionTypeId") Long recognitionTypeId,
@Param("excludeId") Long excludeId);
/**
* 根据班主任ID查询其负责班级的申请列表
*
* @param teacherId 班主任ID
* @param application 查询条件
* @return 申请列表
*/
List<JcbtPovertyApplicationVo> selectApplicationListByTeacher(@Param("teacherId") Long teacherId,
@Param("application") JcbtPovertyApplication application);
/**
* 查询待审核的申请列表
*
* @param application 查询条件
* @return 申请列表
*/
List<JcbtPovertyApplicationVo> selectPendingApplicationList(JcbtPovertyApplication application);
/**
* 统计各种状态的申请数量
*
* @param teacherId 班主任ID（可选，为空则统计全部）
* @return 统计结果
*/
List<JcbtPovertyApplicationVo> selectApplicationStatistics(@Param("teacherId") Long teacherId);
/**
* 获取当前用户班级信息
*
* @param userId 用户ID
* @return 班级信息列表
*/
List<Map<String, Object>> selectCurrentUserClasses(@Param("userId") Long userId);
/**
* 获取班级学生列表
*
* @param classId 班级ID
* @return 学生信息列表
*/
List<Map<String, Object>> selectClassStudents(@Param("classId") Long classId);
}
backend/ruoyi-modules/ruoyi-jcbt/src/main/java/org/dromara/jcbt/mapper/JcbtScholarshipApplicationMapper.java
+99
View File
@@ -0,0 +1,99 @@
package org.dromara.jcbt.mapper;
import org.dromara.jcbt.domain.JcbtScholarshipApplication;
import org.dromara.jcbt.domain.vo.JcbtScholarshipApplicationVo;
import org.dromara.common.mybatis.core.mapper.BaseMapperPlus;
import org.apache.ibatis.annotations.Param;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.core.conditions.Wrapper;
import java.util.List;
/**
* 奖学金申请记录Mapper接口
*
* @author ruoyi
* @date 2025-01-01
*/
public interface JcbtScholarshipApplicationMapper extends BaseMapperPlus<JcbtScholarshipApplication, JcbtScholarshipApplicationVo> {
/**
* 自定义分页查询（包含关联表信息）
*
* @param page 分页对象
* @param ew 查询条件包装器
* @return 分页结果
*/
Page<JcbtScholarshipApplicationVo> selectJcbtScholarshipApplicationPage(@Param("page") Page<JcbtScholarshipApplicationVo> page, @Param("ew") Wrapper<JcbtScholarshipApplication> ew);
/**
* 查询班主任负责班级的申请记录列表（已删除applicantId字段，需重新设计）
*
* @param applicantId 申请人ID（班主任ID）
* @param batchId 批次ID
* @return 申请记录列表
*/
// List<JcbtScholarshipApplicationVo> selectApplicationsByApplicant(@Param("applicantId") Long applicantId, @Param("batchId") Long batchId);
/**
* 查询班级的申请记录列表
*
* @param classId 班级ID
* @param batchId 批次ID
* @return 申请记录列表
*/
List<JcbtScholarshipApplicationVo> selectApplicationsByClass(@Param("classId") Long classId, @Param("batchId") Long batchId);
/**
* 查询待审核的申请记录列表
*
* @param reviewerId 审核人ID
* @param status 申请状态
* @return 申请记录列表
*/
List<JcbtScholarshipApplicationVo> selectPendingApplications(@Param("reviewerId") Long reviewerId, @Param("status") String status);
/**
* 根据ID查询申请记录详情（包含关联信息）
*
* @param id 主键ID
* @return 申请记录详情
*/
JcbtScholarshipApplicationVo selectByIdWithRelations(@Param("id") Long id);
/**
* 检查学生在指定批次中是否已有申请记录
*
* @param studentId 学生ID
* @param batchId 批次ID
* @param scholarshipTypeId 奖学金类型ID
* @return 申请记录数量
*/
int checkStudentApplication(@Param("studentId") Long studentId, @Param("batchId") Long batchId, @Param("scholarshipTypeId") Long scholarshipTypeId);
/**
* 获取申请统计数据
*
* @param batchId 批次ID
* @param deptId 学院ID
* @return 统计数据
*/
List<JcbtScholarshipApplicationVo> selectApplicationStatistics(@Param("batchId") Long batchId, @Param("deptId") Long deptId);
/**
* 批量更新申请状态
*
* @param applicationIds 申请记录ID列表
* @param status 新状态
* @param reviewerId 审核人ID
* @param reviewerName 审核人姓名
* @param reviewComment 审核意见
* @return 更新记录数
*/
int batchUpdateStatus(@Param("applicationIds") List<Long> applicationIds,
@Param("status") String status,
@Param("reviewerId") Long reviewerId,
@Param("reviewerName") String reviewerName,
@Param("reviewComment") String reviewComment);
}
backend/ruoyi-modules/ruoyi-jcbt/src/main/java/org/dromara/jcbt/mapper/JcbtScholarshipBatchMapper.java
+15
View File
@@ -0,0 +1,15 @@
package org.dromara.jcbt.mapper;
import org.dromara.jcbt.domain.JcbtScholarshipBatch;
import org.dromara.jcbt.domain.vo.JcbtScholarshipBatchVo;
import org.dromara.common.mybatis.core.mapper.BaseMapperPlus;
/**
* 奖学金评定批次Mapper接口
*
* @author ruoyi
* @date 2025-01-27
*/
public interface JcbtScholarshipBatchMapper extends BaseMapperPlus<JcbtScholarshipBatch, JcbtScholarshipBatchVo> {
}
backend/ruoyi-modules/ruoyi-jcbt/src/main/java/org/dromara/jcbt/mapper/JcbtScholarshipBatchTypeMapper.java
+14
View File
@@ -0,0 +1,14 @@
package org.dromara.jcbt.mapper;
import org.dromara.jcbt.domain.JcbtScholarshipBatchType;
import org.dromara.common.mybatis.core.mapper.BaseMapperPlus;
/**
* 奖学金批次类型关联Mapper接口
*
* @author ruoyi
* @date 2025-01-27
*/
public interface JcbtScholarshipBatchTypeMapper extends BaseMapperPlus<JcbtScholarshipBatchType, JcbtScholarshipBatchType> {
}
backend/ruoyi-modules/ruoyi-jcbt/src/main/java/org/dromara/jcbt/mapper/JcbtScholarshipClassQuotaMapper.java
+66
View File
@@ -0,0 +1,66 @@
package org.dromara.jcbt.mapper;
import org.dromara.jcbt.domain.JcbtScholarshipClassQuota;
import org.dromara.jcbt.domain.vo.JcbtScholarshipClassQuotaVo;
import org.dromara.common.mybatis.core.mapper.BaseMapperPlus;
import org.apache.ibatis.annotations.Param;
import java.util.List;
/**
* 奖学金班级名额分配Mapper接口
*
* @author ruoyi
* @date 2025-01-01
*/
public interface JcbtScholarshipClassQuotaMapper extends BaseMapperPlus<JcbtScholarshipClassQuota, JcbtScholarshipClassQuotaVo> {
/**
* 查询班级可用名额
*
* @param classId 班级ID
* @param scholarshipTypeId 奖学金类型ID
* @param batchId 批次ID
* @return 名额分配信息
*/
JcbtScholarshipClassQuotaVo selectAvailableQuota(@Param("classId") Long classId,
@Param("scholarshipTypeId") Long scholarshipTypeId,
@Param("batchId") Long batchId);
/**
* 查询学院下所有班级的名额分配
*
* @param deptId 学院ID
* @param batchId 批次ID
* @return 名额分配列表
*/
List<JcbtScholarshipClassQuotaVo> selectQuotasByDept(@Param("deptId") Long deptId, @Param("batchId") Long batchId);
/**
* 更新名额使用情况
*
* @param id 名额分配ID
* @param usedQuota 已使用名额
* @param availableQuota 可用名额
* @return 更新记录数
*/
int updateQuotaUsage(@Param("id") Long id, @Param("usedQuota") Integer usedQuota, @Param("availableQuota") Integer availableQuota);
/**
* 批量更新名额分配
*
* @param quotaList 名额分配列表
* @return 更新记录数
*/
int batchUpdateQuota(@Param("quotaList") List<JcbtScholarshipClassQuota> quotaList);
/**
* 查询名额统计信息
*
* @param batchId 批次ID
* @param scholarshipTypeId 奖学金类型ID
* @return 统计信息
*/
List<JcbtScholarshipClassQuotaVo> selectQuotaStatistics(@Param("batchId") Long batchId, @Param("scholarshipTypeId") Long scholarshipTypeId);
}
backend/ruoyi-modules/ruoyi-jcbt/src/main/java/org/dromara/jcbt/mapper/JcbtScholarshipCompatibilityMapper.java
+42
View File
@@ -0,0 +1,42 @@
package org.dromara.jcbt.mapper;
import org.dromara.jcbt.domain.JcbtScholarshipCompatibility;
import org.dromara.jcbt.domain.vo.JcbtScholarshipCompatibilityVo;
import org.dromara.common.mybatis.core.mapper.BaseMapperPlus;
import java.util.List;
/**
* 奖学金兼得关系Mapper接口
*
* @author ruoyi
* @date 2025-01-27
*/
public interface JcbtScholarshipCompatibilityMapper extends BaseMapperPlus<JcbtScholarshipCompatibility, JcbtScholarshipCompatibilityVo> {
/**
* 查询与指定奖学金类型的兼得关系
*
* @param scholarshipTypeId 奖学金类型ID
* @return 兼得关系列表
*/
List<JcbtScholarshipCompatibilityVo> selectCompatibilityByTypeId(Long scholarshipTypeId);
/**
* 检查两个奖学金类型的兼得关系
*
* @param typeId1 奖学金类型1
* @param typeId2 奖学金类型2
* @return 兼得关系记录
*/
JcbtScholarshipCompatibilityVo selectCompatibilityByTwoTypes(Long typeId1, Long typeId2);
/**
* 批量删除指定奖学金类型的兼得关系
*
* @param scholarshipTypeId 奖学金类型ID
* @return 删除记录数
*/
int deleteByScholarshipTypeId(Long scholarshipTypeId);
}
backend/ruoyi-modules/ruoyi-jcbt/src/main/java/org/dromara/jcbt/mapper/JcbtScholarshipQuotaMapper.java
+118
View File
@@ -0,0 +1,118 @@
package org.dromara.jcbt.mapper;
import org.dromara.jcbt.domain.JcbtScholarshipQuota;
import org.dromara.jcbt.domain.vo.JcbtScholarshipQuotaVo;
import org.dromara.jcbt.domain.bo.JcbtScholarshipQuotaBo;
import org.dromara.common.mybatis.core.mapper.BaseMapperPlus;
import org.apache.ibatis.annotations.Param;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import java.util.List;
/**
* 奖学金名额分配Mapper接口
*
* @author ruoyi
* @date 2025-01-27
*/
public interface JcbtScholarshipQuotaMapper extends BaseMapperPlus<JcbtScholarshipQuota, JcbtScholarshipQuotaVo> {
/**
* 分页查询奖学金名额分配列表（带关联查询）
*
* @param page 分页参数
* @param bo 查询条件
* @return 分页结果
*/
IPage<JcbtScholarshipQuotaVo> selectQuotaPageList(IPage<JcbtScholarshipQuotaVo> page, @Param("bo") JcbtScholarshipQuotaBo bo);
/**
* 查询奖学金名额分配列表（带关联查询）
*
* @param bo 查询条件
* @return 名额分配列表
*/
List<JcbtScholarshipQuotaVo> selectQuotaList(@Param("bo") JcbtScholarshipQuotaBo bo);
/**
* 查询指定批次的名额分配列表
*
* @param batchId 批次ID
* @return 名额分配列表
*/
List<JcbtScholarshipQuotaVo> selectQuotaListByBatchId(@Param("batchId") Long batchId);
/**
* 查询指定批次和奖学金类型的名额分配
*
* @param batchId 批次ID
* @param scholarshipTypeId 奖学金类型ID
* @return 名额分配列表
*/
List<JcbtScholarshipQuotaVo> selectQuotaListByBatchAndType(@Param("batchId") Long batchId,
@Param("scholarshipTypeId") Long scholarshipTypeId);
/**
* 查询指定部门的名额分配统计
*
* @param targetDeptId 目标部门ID
* @param batchId 批次ID
* @return 名额统计信息
*/
JcbtScholarshipQuotaVo selectQuotaSummaryByDept(@Param("targetDeptId") Long targetDeptId,
@Param("batchId") Long batchId);
/**
* 查询子级名额分配列表
*
* @param parentQuotaId 父级名额ID
* @return 子级名额分配列表
*/
List<JcbtScholarshipQuotaVo> selectQuotaListByParentId(@Param("parentQuotaId") Long parentQuotaId);
/**
* 批量更新名额使用情况
*
* @param quotaList 名额分配列表
* @return 更新数量
*/
int batchUpdateQuotaUsage(@Param("quotaList") List<JcbtScholarshipQuota> quotaList);
/**
* 检查名额分配是否存在冲突
*
* @param batchId 批次ID
* @param scholarshipTypeId 奖学金类型ID
* @param targetDeptId 目标部门ID
* @param excludeId 排除的ID（修改时使用）
* @return 冲突记录数
*/
int checkQuotaConflict(@Param("batchId") Long batchId,
@Param("scholarshipTypeId") Long scholarshipTypeId,
@Param("targetDeptId") Long targetDeptId,
@Param("excludeId") Long excludeId);
/**
* 查询名额分配树形结构
*
* @param batchId 批次ID
* @param scholarshipTypeId 奖学金类型ID
* @return 树形结构数据
*/
List<JcbtScholarshipQuotaVo> selectQuotaTreeByBatchAndType(@Param("batchId") Long batchId,
@Param("scholarshipTypeId") Long scholarshipTypeId);
/**
* 查询班级级别的名额分配
*
* @param classId 班级ID
* @param scholarshipTypeId 奖学金类型ID
* @param batchId 批次ID
* @return 班级名额分配信息
*/
JcbtScholarshipQuotaVo selectClassQuota(@Param("classId") Long classId,
@Param("scholarshipTypeId") Long scholarshipTypeId,
@Param("batchId") Long batchId);
}
backend/ruoyi-modules/ruoyi-jcbt/src/main/java/org/dromara/jcbt/mapper/JcbtScholarshipReviewMapper.java
+85
View File
@@ -0,0 +1,85 @@
package org.dromara.jcbt.mapper;
import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.toolkit.Constants;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import org.apache.ibatis.annotations.Param;
import org.dromara.common.mybatis.core.mapper.BaseMapperPlus;
import org.dromara.jcbt.domain.JcbtScholarshipReview;
import org.dromara.jcbt.domain.vo.JcbtScholarshipReviewVo;
import java.util.List;
/**
* 奖学金审核记录Mapper接口
*
* @author ruoyi
* @date 2025-08-05
*/
public interface JcbtScholarshipReviewMapper extends BaseMapperPlus<JcbtScholarshipReview, JcbtScholarshipReviewVo> {
/**
* 查询奖学金审核记录列表
*/
List<JcbtScholarshipReviewVo> selectVoList(@Param(Constants.WRAPPER) Wrapper<JcbtScholarshipReview> queryWrapper);
/**
* 根据申请ID查询审核记录
*/
List<JcbtScholarshipReviewVo> selectReviewsByApplicationId(@Param("applicationId") Long applicationId);
/**
* 查询当前用户待审核的记录
*/
Page<JcbtScholarshipReviewVo> selectPendingReviews(Page<JcbtScholarshipReviewVo> page,
@Param("reviewerId") Long reviewerId,
@Param("reviewLevel") String reviewLevel,
@Param("applicationNo") String applicationNo,
@Param("studentName") String studentName);
/**
* 查询审核历史记录
*/
Page<JcbtScholarshipReviewVo> selectReviewHistory(Page<JcbtScholarshipReviewVo> page,
@Param("reviewerId") Long reviewerId,
@Param("reviewResult") String reviewResult,
@Param("batchId") Long batchId,
@Param("startTime") String startTime,
@Param("endTime") String endTime);
/**
* 查询某个申请的最新审核记录
*/
JcbtScholarshipReviewVo selectLatestReviewByApplicationId(@Param("applicationId") Long applicationId);
/**
* 查询某个申请的指定级别审核记录
*/
JcbtScholarshipReviewVo selectReviewByApplicationAndLevel(@Param("applicationId") Long applicationId,
@Param("reviewLevel") String reviewLevel);
/**
* 批量更新审核结果
*/
int batchUpdateReviewResult(@Param("reviewIds") List<Long> reviewIds,
@Param("reviewResult") String reviewResult,
@Param("reviewOpinion") String reviewOpinion,
@Param("reviewerId") Long reviewerId,
@Param("reviewerName") String reviewerName);
/**
* 统计审核数量
*/
Long countReviewsByCondition(@Param("reviewerId") Long reviewerId,
@Param("reviewLevel") String reviewLevel,
@Param("reviewResult") String reviewResult,
@Param("batchId") Long batchId);
/**
* 查询下一级审核人员
*/
List<Long> selectNextReviewers(@Param("applicationId") Long applicationId,
@Param("currentLevel") String currentLevel);
}
backend/ruoyi-modules/ruoyi-jcbt/src/main/java/org/dromara/jcbt/mapper/JcbtScholarshipTypeMapper.java
+73
View File
@@ -0,0 +1,73 @@
package org.dromara.jcbt.mapper;
import org.dromara.jcbt.domain.JcbtScholarshipType;
import org.dromara.jcbt.domain.vo.JcbtScholarshipTypeVo;
import org.dromara.common.mybatis.core.mapper.BaseMapperPlus;
import org.apache.ibatis.annotations.Param;
import java.util.List;
/**
* 奖学金类型Mapper接口
*
* @author ruoyi
* @date 2025-01-27
*/
public interface JcbtScholarshipTypeMapper extends BaseMapperPlus<JcbtScholarshipType, JcbtScholarshipTypeVo> {
/**
* 查询奖学金类型列表
*
* @param scholarshipType 奖学金类型
* @return 奖学金类型集合
*/
List<JcbtScholarshipTypeVo> selectScholarshipTypeList(JcbtScholarshipType scholarshipType);
/**
* 根据类型名称查询奖学金类型
*
* @param typeName 类型名称
* @return 奖学金类型
*/
JcbtScholarshipTypeVo selectByTypeName(@Param("typeName") String typeName);
/**
* 根据类别查询奖学金类型列表
*
* @param typeCategory 奖学金类别
* @return 奖学金类型集合
*/
List<JcbtScholarshipTypeVo> selectByCategory(@Param("typeCategory") String typeCategory);
/**
* 查询启用状态的奖学金类型列表
*
* @return 奖学金类型集合
*/
List<JcbtScholarshipTypeVo> selectActiveTypes();
/**
* 检查是否存在重复的奖学金名称
*
* @param typeName 奖学金名称
* @param id 排除的ID
* @return 是否存在重复
*/
boolean checkTypeNameExists(@Param("typeName") String typeName, @Param("id") Long id);
/**
* 批量更新排序号
*
* @param scholarshipTypes 奖学金类型列表
*/
void batchUpdateSortOrder(@Param("list") List<JcbtScholarshipType> scholarshipTypes);
/**
* 根据兼得类型查询相关奖学金类型
*
* @param compatibilityType 兼得限制类型
* @return 奖学金类型集合
*/
List<JcbtScholarshipTypeVo> selectByCompatibilityType(@Param("compatibilityType") String compatibilityType);
}
backend/ruoyi-modules/ruoyi-jcbt/src/main/java/org/dromara/jcbt/mapper/JcbtWorkStudyApplicationMapper.java
+27
View File
@@ -0,0 +1,27 @@
package org.dromara.jcbt.mapper;
import org.apache.ibatis.annotations.Param;
import org.dromara.common.mybatis.core.mapper.BaseMapperPlus;
import org.dromara.jcbt.domain.JcbtWorkStudyApplication;
import org.dromara.jcbt.domain.vo.JcbtWorkStudyApplicationVo;
import java.util.Map;
/**
* 勤工俭学申请信息Mapper接口
*
* @author ruoyi
* @date 2025-01-03
*/
public interface JcbtWorkStudyApplicationMapper extends BaseMapperPlus<JcbtWorkStudyApplication, JcbtWorkStudyApplicationVo> {
/**
* 查询用户对指定岗位的申请状态
*
* @param positionId 岗位ID
* @param userId 用户ID
* @return 申请状态信息
*/
Map<String, Object> selectApplicationStatus(@Param("positionId") Long positionId, @Param("userId") Long userId);
}
backend/ruoyi-modules/ruoyi-jcbt/src/main/java/org/dromara/jcbt/mapper/JcbtWorkStudyPositionMapper.java
+103
View File
@@ -0,0 +1,103 @@
package org.dromara.jcbt.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import org.apache.ibatis.annotations.Param;
import org.dromara.common.mybatis.core.mapper.BaseMapperPlus;
import org.dromara.jcbt.domain.JcbtWorkStudyPosition;
import org.dromara.jcbt.domain.vo.JcbtWorkStudyPositionVo;
import java.util.List;
import java.util.Map;
/**
* 勤工俭学岗位信息Mapper接口
*
* @author ruoyi
* @date 2025-01-03
*/
public interface JcbtWorkStudyPositionMapper extends BaseMapperPlus<JcbtWorkStudyPosition, JcbtWorkStudyPositionVo> {
/**
* 查询勤工俭学岗位信息列表
*
* @param page 分页对象
* @param queryBo 查询条件
* @return 勤工俭学岗位信息列表
*/
Page<JcbtWorkStudyPositionVo> queryPageList(@Param("page") Page<JcbtWorkStudyPositionVo> page, @Param("ew") JcbtWorkStudyPositionVo queryBo);
/**
* 根据学院ID查询岗位列表
*
* @param collegeId 学院ID
* @return 岗位列表
*/
Page<JcbtWorkStudyPositionVo> selectByCollegeId(@Param("page") Page<JcbtWorkStudyPositionVo> page, @Param("collegeId") Long collegeId);
/**
* 根据发布范围查询岗位列表
*
* @param positionScope 发布范围
* @return 岗位列表
*/
Page<JcbtWorkStudyPositionVo> selectByPositionScope(@Param("page") Page<JcbtWorkStudyPositionVo> page, @Param("positionScope") String positionScope);
/**
* 根据岗位状态查询岗位列表
*
* @param status 岗位状态
* @return 岗位列表
*/
Page<JcbtWorkStudyPositionVo> selectByStatus(@Param("page") Page<JcbtWorkStudyPositionVo> page, @Param("status") String status);
/**
* 查询学院可见的岗位（本学院岗位 + 全校范围岗位）
*
* @param collegeId 学院ID
* @return 可见岗位列表
*/
Page<JcbtWorkStudyPositionVo> selectVisiblePositions(@Param("page") Page<JcbtWorkStudyPositionVo> page, @Param("collegeId") Long collegeId);
/**
* 统计岗位数量按状态分组
*
* @param collegeId 学院ID（为空时统计全部）
* @return 统计结果
*/
Page<JcbtWorkStudyPositionVo> countByStatus(@Param("collegeId") Long collegeId);
/**
* 批量更新岗位状态
*
* @param ids 岗位ID列表
* @param status 新状态
* @param updateBy 更新人
* @return 更新数量
*/
int batchUpdateStatus(@Param("ids") java.util.List<Long> ids, @Param("status") String status, @Param("updateBy") Long updateBy);
/**
* 根据条件查询岗位统计信息
*
* @param collegeId 学院ID（为空时统计全部）
* @return 统计信息
*/
Map<String, Object> selectPositionStatistics(@Param("collegeId") Long collegeId);
/**
* 获取即将过期的岗位
*
* @param days 天数
* @return 即将过期的岗位列表
*/
List<JcbtWorkStudyPositionVo> selectExpiringPositions(@Param("days") int days);
/**
* 获取热门岗位（申请人数多的岗位）
*
* @param limit 限制数量
* @return 热门岗位列表
*/
List<JcbtWorkStudyPositionVo> selectPopularPositions(@Param("limit") int limit);
}
backend/ruoyi-modules/ruoyi-jcbt/src/main/java/org/dromara/jcbt/service/.gitkeep
View File
Whitespace-only changes.
backend/ruoyi-modules/ruoyi-jcbt/src/main/java/org/dromara/jcbt/service/IJcbtPovertyApplicationService.java
+243
View File
@@ -0,0 +1,243 @@
package org.dromara.jcbt.service;
import org.dromara.common.mybatis.core.page.PageQuery;
import org.dromara.common.mybatis.core.page.TableDataInfo;
import org.dromara.jcbt.domain.bo.JcbtPovertyApplicationBo;
import org.dromara.jcbt.domain.vo.JcbtPovertyApplicationVo;
import java.util.Collection;
import java.util.List;
import java.util.Map;
/**
* 贫困生认定申请Service接口
*
* @author ruoyi
* @date 2025-08-09
*/
public interface IJcbtPovertyApplicationService {
/**
* 查询贫困生认定申请
*
* @param id 贫困生认定申请主键
* @return 贫困生认定申请
*/
JcbtPovertyApplicationVo queryById(Long id);
/**
* 根据申请编号查询申请信息
*
* @param applicationNo 申请编号
* @return 申请信息
*/
JcbtPovertyApplicationVo queryByApplicationNo(String applicationNo);
/**
* 查询贫困生认定申请列表
*
* @param bo 查询条件
* @param pageQuery 分页参数
* @return 贫困生认定申请分页列表
*/
TableDataInfo<JcbtPovertyApplicationVo> queryPageList(JcbtPovertyApplicationBo bo, PageQuery pageQuery);
/**
* 查询贫困生认定申请列表
*
* @param bo 查询条件
* @return 贫困生认定申请列表
*/
List<JcbtPovertyApplicationVo> queryList(JcbtPovertyApplicationBo bo);
/**
* 根据班主任ID查询申请列表（班主任查看自己班级的申请）
*
* @param teacherId 班主任ID
* @param bo 查询条件
* @param pageQuery 分页参数
* @return 申请分页列表
*/
TableDataInfo<JcbtPovertyApplicationVo> queryPageListByTeacher(Long teacherId, JcbtPovertyApplicationBo bo, PageQuery pageQuery);
/**
* 根据班主任ID查询申请列表（不分页，用于导出）
*
* @param teacherId 班主任ID
* @param bo 查询条件
* @return 申请列表
*/
List<JcbtPovertyApplicationVo> queryListByTeacher(Long teacherId, JcbtPovertyApplicationBo bo);
/**
* 查询待审核的申请列表（审核人员使用）
*
* @param bo 查询条件
* @param pageQuery 分页参数
* @return 申请分页列表
*/
TableDataInfo<JcbtPovertyApplicationVo> queryPendingPageList(JcbtPovertyApplicationBo bo, PageQuery pageQuery);
/**
* 新增贫困生认定申请
*
* @param bo 贫困生认定申请
* @return 结果
*/
Boolean insertByBo(JcbtPovertyApplicationBo bo);
/**
* 修改贫困生认定申请
*
* @param bo 贫困生认定申请
* @return 结果
*/
Boolean updateByBo(JcbtPovertyApplicationBo bo);
/**
* 保存草稿
*
* @param bo 贫困生认定申请
* @return 结果
*/
Boolean saveDraft(JcbtPovertyApplicationBo bo);
/**
* 提交申请
*
* @param id 申请ID
* @return 结果
*/
Boolean submitApplication(Long id);
/**
* 撤销申请
*
* @param id 申请ID
* @return 结果
*/
Boolean cancelApplication(Long id);
/**
* 审核通过
*
* @param id 申请ID
* @param auditOpinion 审核意见
* @return 结果
*/
Boolean approveApplication(Long id, String auditOpinion);
/**
* 审核驳回
*
* @param id 申请ID
* @param auditOpinion 审核意见
* @return 操作结果
*/
Boolean rejectApplication(Long id, String auditOpinion);
/**
* 打回修改（将申请打回到草稿状态）
*
* @param id 申请ID
* @param auditOpinion 审核意见
* @return 操作结果
*/
Boolean returnToDraft(Long id, String auditOpinion);
/**
* 校验删除数据
*
* @param ids 主键集合
* @param isValid 是否校验,true-删除前校验,false-不校验
* @return 结果
*/
Boolean deleteWithValidByIds(Collection<Long> ids, Boolean isValid);
/**
* 生成申请编号
*
* @return 申请编号
*/
String generateApplicationNo();
/**
* 检查学生是否已有相同类型的认定申请
*
* @param studentId 学生ID
* @param academicYear 学年
* @param recognitionTypeId 认定类型ID
* @param excludeId 排除的申请ID（修改时使用）
* @return 是否存在
*/
boolean checkStudentApplicationExists(Long studentId, String academicYear, Long recognitionTypeId, Long excludeId);
/**
* 统计申请数据
*
* @param teacherId 班主任ID（可选）
* @return 统计结果
*/
List<JcbtPovertyApplicationVo> getApplicationStatistics(Long teacherId);
/**
* 获取当前用户班级信息
*
* @param userId 用户ID
* @return 班级信息列表
*/
List<Map<String, Object>> getCurrentUserClasses(Long userId);
/**
* 获取班级学生列表
*
* @param classId 班级ID
* @return 学生信息列表
*/
List<Map<String, Object>> getClassStudents(Long classId);
/**
* 批量审核通过申请
*
* @param ids 申请ID列表
* @param auditOpinion 审核意见
* @return 结果
*/
Boolean batchApproveApplications(List<Long> ids, String auditOpinion);
/**
* 批量审核驳回申请
*
* @param ids 申请ID列表
* @param auditOpinion 审核意见
* @return 结果
*/
Boolean batchRejectApplications(List<Long> ids, String auditOpinion);
/**
* 获取审核统计信息
*
* @param academicYear 学年
* @param collegeId 学院ID
* @return 统计信息列表
*/
List<JcbtPovertyApplicationVo> getReviewStatistics(String academicYear, Long collegeId);
/**
* 获取审核人员工作量统计
*
* @param startTime 开始时间
* @param endTime 结束时间
* @return 工作量统计
*/
List<Map<String, Object>> getAuditorWorkloadStatistics(String startTime, String endTime);
/**
* 获取申请审核历史记录
*
* @param applicationId 申请ID
* @return 审核历史记录
*/
List<Map<String, Object>> getApplicationAuditHistory(Long applicationId);
}
backend/ruoyi-modules/ruoyi-jcbt/src/main/java/org/dromara/jcbt/service/IJcbtScholarshipApplicationService.java
+239
View File
@@ -0,0 +1,239 @@
package org.dromara.jcbt.service;
import org.dromara.jcbt.domain.bo.JcbtScholarshipApplicationBo;
import org.dromara.jcbt.domain.vo.JcbtScholarshipApplicationVo;
import org.dromara.common.mybatis.core.page.PageQuery;
import org.dromara.common.mybatis.core.page.TableDataInfo;
import java.util.Collection;
import java.util.List;
import java.util.Map;
/**
* 奖学金申请记录Service接口
*
* @author ruoyi
* @date 2025-01-01
*/
public interface IJcbtScholarshipApplicationService {
/**
* 查询奖学金申请记录详情
*
* @param id 主键
* @return 奖学金申请记录
*/
JcbtScholarshipApplicationVo queryById(Long id);
/**
* 查询奖学金申请记录列表
*
* @param bo 查询条件
* @param pageQuery 分页参数
* @return 奖学金申请记录分页列表
*/
TableDataInfo<JcbtScholarshipApplicationVo> queryPageList(JcbtScholarshipApplicationBo bo, PageQuery pageQuery);
/**
* 查询奖学金申请记录列表
*
* @param bo 查询条件
* @return 奖学金申请记录列表
*/
List<JcbtScholarshipApplicationVo> queryList(JcbtScholarshipApplicationBo bo);
/**
* 新增奖学金申请记录
*
* @param bo 奖学金申请记录
* @return 是否新增成功
*/
Boolean insertByBo(JcbtScholarshipApplicationBo bo);
/**
* 修改奖学金申请记录
*
* @param bo 奖学金申请记录
* @return 是否修改成功
*/
Boolean updateByBo(JcbtScholarshipApplicationBo bo);
/**
* 校验并批量删除奖学金申请记录信息
*
* @param ids 需要删除的奖学金申请记录主键集合
* @param isValid 是否校验,true-删除前校验,false-不校验
* @return 是否删除成功
*/
Boolean deleteWithValidByIds(Collection<Long> ids, Boolean isValid);
/**
* 班主任代申请功能 - 批量提交学生申请
*
* @param batchId 批次ID
* @param scholarshipTypeId 奖学金类型ID
* @param classId 班级ID
* @param studentApplications 学生申请信息列表
* @return 提交结果
*/
Boolean batchSubmitApplicationsByTeacher(Long batchId, Long scholarshipTypeId, Long classId,
List<JcbtScholarshipApplicationBo> studentApplications);
/**
* 查询班主任负责班级的申请记录
*
* @param applicantId 申请人ID（班主任ID）
* @param batchId 批次ID
* @return 申请记录列表
*/
List<JcbtScholarshipApplicationVo> queryApplicationsByApplicant(Long applicantId, Long batchId);
/**
* 查询班级的申请记录
*
* @param classId 班级ID
* @param batchId 批次ID
* @return 申请记录列表
*/
List<JcbtScholarshipApplicationVo> queryApplicationsByClass(Long classId, Long batchId);
/**
* 查询待审核的申请记录
*
* @param reviewerId 审核人ID
* @param status 申请状态
* @return 申请记录列表
*/
List<JcbtScholarshipApplicationVo> queryPendingApplications(Long reviewerId, String status);
/**
* 检查学生申请资格和限制
*
* @param studentId 学生ID
* @param batchId 批次ID
* @param scholarshipTypeId 奖学金类型ID
* @return 检查结果
*/
Map<String, Object> checkStudentEligibility(Long studentId, Long batchId, Long scholarshipTypeId);
/**
* 批量审核申请
*
* @param applicationIds 申请ID列表
* @param status 审核状态
* @param reviewerId 审核人ID
* @param reviewerName 审核人姓名
* @param reviewComment 审核意见
* @return 是否审核成功
*/
Boolean batchReviewApplications(List<Long> applicationIds, String status, Long reviewerId,
String reviewerName, String reviewComment);
/**
* 提交申请（草稿状态改为提交状态）
*
* @param id 申请ID
* @return 是否提交成功
*/
Boolean submitApplication(Long id);
/**
* 撤回申请
*
* @param id 申请ID
* @param reason 撤回原因
* @return 是否撤回成功
*/
Boolean withdrawApplication(Long id, String reason);
/**
* 获取申请统计数据
*
* @param batchId 批次ID
* @param deptId 学院ID
* @return 统计数据
*/
Map<String, Object> getApplicationStatistics(Long batchId, Long deptId);
/**
* 查询可申请的奖学金类型列表（根据班级名额）
*
* @param classId 班级ID
* @param batchId 批次ID
* @return 奖学金类型列表
*/
List<Map<String, Object>> queryAvailableScholarshipTypes(Long classId, Long batchId);
/**
* 获取班级名额使用情况
*
* @param classId 班级ID
* @param batchId 批次ID
* @return 名额使用情况
*/
Map<String, Object> getClassQuotaUsage(Long classId, Long batchId);
// ========== 班主任申请专用接口 ==========
/**
* 获取班主任所带班级信息
*
* @param teacherId 班主任ID
* @return 班级信息
*/
Map<String, Object> getClassInfoByTeacher(Long teacherId);
/**
* 获取班级学生列表（用于勾选）
*
* @param classId 班级ID
* @return 学生列表
*/
List<Map<String, Object>> getClassStudents(Long classId);
/**
* 根据批次获取可申请的奖学金类型
*
* @param batchId 批次ID
* @return 奖学金类型列表
*/
List<Map<String, Object>> getScholarshipTypesByBatch(Long batchId);
/**
* 根据批次和班级获取带名额信息的奖学金类型（班主任专用）
*
* @param batchId 批次ID
* @param classId 班级ID
* @return 奖学金类型列表（包含名额信息）
*/
List<Map<String, Object>> getScholarshipTypesWithQuota(Long batchId, Long classId);
/**
* 测试班级名额查询（用于SQL日志调试）
*
* @param classId 班级ID
* @param scholarshipTypeId 奖学金类型ID
* @param batchId 批次ID
* @return 班级名额信息
*/
Map<String, Object> testClassQuotaQuery(Long classId, Long scholarshipTypeId, Long batchId);
/**
* 测试全校名额查询（用于SQL日志调试）
*
* @param batchId 批次ID
* @param scholarshipTypeId 奖学金类型ID
* @return 全校名额信息
*/
Map<String, Object> testSchoolQuotaQuery(Long batchId, Long scholarshipTypeId);
/**
* 确认选择班级（当用户从多个班级中选择一个时调用）
*
* @param teacherId 班主任ID
* @param classId 班级ID
* @return 班级信息
*/
Map<String, Object> confirmClassSelection(Long teacherId, Long classId);
}
backend/ruoyi-modules/ruoyi-jcbt/src/main/java/org/dromara/jcbt/service/IJcbtScholarshipBatchService.java
+89
View File
@@ -0,0 +1,89 @@
package org.dromara.jcbt.service;
import org.dromara.jcbt.domain.bo.JcbtScholarshipBatchBo;
import org.dromara.jcbt.domain.vo.JcbtScholarshipBatchVo;
import org.dromara.common.mybatis.core.page.TableDataInfo;
import org.dromara.common.mybatis.core.page.PageQuery;
import java.util.Collection;
import java.util.List;
/**
* 奖学金评定批次Service接口
*
* @author ruoyi
* @date 2025-01-27
*/
public interface IJcbtScholarshipBatchService {
/**
* 查询奖学金评定批次分页列表
*/
TableDataInfo<JcbtScholarshipBatchVo> queryPageList(JcbtScholarshipBatchBo bo, PageQuery pageQuery);
/**
* 查询奖学金评定批次列表（用于导出）
*/
List<JcbtScholarshipBatchVo> queryExportList(JcbtScholarshipBatchBo bo);
/**
* 根据id查询奖学金评定批次
*/
JcbtScholarshipBatchVo queryById(Long id);
/**
* 新增奖学金评定批次
*/
Boolean insertByBo(JcbtScholarshipBatchBo bo);
/**
* 修改奖学金评定批次
*/
Boolean updateByBo(JcbtScholarshipBatchBo bo);
/**
* 校验并批量删除奖学金评定批次信息
*/
Boolean deleteWithValidByIds(Collection<Long> ids, Boolean isValid);
/**
* 根据批次编码查询批次信息
*/
JcbtScholarshipBatchVo queryByBatchCode(String batchCode);
/**
* 根据学年和学期查询批次列表
*/
List<JcbtScholarshipBatchVo> queryByAcademicYearAndSemester(String academicYear, Integer semester);
/**
* 查询启用状态的批次列表
*/
List<JcbtScholarshipBatchVo> queryActiveBatches();
/**
* 检查批次编码是否唯一
*/
Boolean checkBatchCodeUnique(String batchCode, Long id);
/**
* 更改批次状态
*/
Boolean changeStatus(Long id, String status);
/**
* 查询当前进行中的批次
*/
List<JcbtScholarshipBatchVo> queryCurrentActiveBatches();
/**
* 根据状态查询批次列表
*/
List<JcbtScholarshipBatchVo> queryByStatus(String status);
/**
* 检查批次时间是否有冲突
*/
Boolean checkTimeConflict(JcbtScholarshipBatchBo bo);
}
backend/ruoyi-modules/ruoyi-jcbt/src/main/java/org/dromara/jcbt/service/IJcbtScholarshipBatchTypeService.java
+41
View File
@@ -0,0 +1,41 @@
package org.dromara.jcbt.service;
import org.dromara.jcbt.domain.JcbtScholarshipBatchType;
import java.util.List;
/**
* 奖学金批次类型关联Service接口
*
* @author ruoyi
* @date 2025-01-27
*/
public interface IJcbtScholarshipBatchTypeService {
/**
* 根据批次ID获取关联的奖学金类型ID列表
*
* @param batchId 批次ID
* @return 奖学金类型ID列表
*/
List<Long> getScholarshipTypeIdsByBatchId(Long batchId);
/**
* 批量保存批次类型关联关系
*
* @param batchId 批次ID
* @param scholarshipTypeIds 奖学金类型ID列表
* @param tenantId 租户ID
* @return 保存结果
*/
Boolean saveBatchTypes(Long batchId, List<Long> scholarshipTypeIds, String tenantId);
/**
* 根据批次ID删除关联关系
*
* @param batchId 批次ID
* @return 删除结果
*/
Boolean deleteByBatchId(Long batchId);
}
backend/ruoyi-modules/ruoyi-jcbt/src/main/java/org/dromara/jcbt/service/IJcbtScholarshipClassQuotaService.java
+116
View File
@@ -0,0 +1,116 @@
package org.dromara.jcbt.service;
import org.dromara.jcbt.domain.bo.JcbtScholarshipClassQuotaBo;
import org.dromara.jcbt.domain.vo.JcbtScholarshipClassQuotaVo;
import org.dromara.common.mybatis.core.page.PageQuery;
import org.dromara.common.mybatis.core.page.TableDataInfo;
import java.util.Collection;
import java.util.List;
/**
* 奖学金班级名额分配Service接口
*
* @author ruoyi
* @date 2025-01-01
*/
public interface IJcbtScholarshipClassQuotaService {
/**
* 查询奖学金班级名额分配详情
*
* @param id 主键
* @return 奖学金班级名额分配
*/
JcbtScholarshipClassQuotaVo queryById(Long id);
/**
* 查询奖学金班级名额分配列表
*
* @param bo 查询条件
* @param pageQuery 分页参数
* @return 奖学金班级名额分配分页列表
*/
TableDataInfo<JcbtScholarshipClassQuotaVo> queryPageList(JcbtScholarshipClassQuotaBo bo, PageQuery pageQuery);
/**
* 查询奖学金班级名额分配列表
*
* @param bo 查询条件
* @return 奖学金班级名额分配列表
*/
List<JcbtScholarshipClassQuotaVo> queryList(JcbtScholarshipClassQuotaBo bo);
/**
* 新增奖学金班级名额分配
*
* @param bo 奖学金班级名额分配
* @return 是否新增成功
*/
Boolean insertByBo(JcbtScholarshipClassQuotaBo bo);
/**
* 修改奖学金班级名额分配
*
* @param bo 奖学金班级名额分配
* @return 是否修改成功
*/
Boolean updateByBo(JcbtScholarshipClassQuotaBo bo);
/**
* 校验并批量删除奖学金班级名额分配信息
*
* @param ids 需要删除的奖学金班级名额分配主键集合
* @param isValid 是否校验,true-删除前校验,false-不校验
* @return 是否删除成功
*/
Boolean deleteWithValidByIds(Collection<Long> ids, Boolean isValid);
/**
* 查询班级可用名额
*
* @param classId 班级ID
* @param scholarshipTypeId 奖学金类型ID
* @param batchId 批次ID
* @return 名额分配信息
*/
JcbtScholarshipClassQuotaVo queryAvailableQuota(Long classId, Long scholarshipTypeId, Long batchId);
/**
* 查询班级的所有名额分配
*
* @param classId 班级ID
* @param batchId 批次ID
* @return 名额分配列表
*/
List<JcbtScholarshipClassQuotaVo> queryQuotasByClass(Long classId, Long batchId);
/**
* 查询学院下所有班级的名额分配
*
* @param deptId 学院ID
* @param batchId 批次ID
* @return 名额分配列表
*/
List<JcbtScholarshipClassQuotaVo> queryQuotasByDept(Long deptId, Long batchId);
/**
* 更新名额使用情况
*
* @param id 名额分配ID
* @param usedQuota 已使用名额
* @param availableQuota 可用名额
* @return 是否更新成功
*/
Boolean updateQuotaUsage(Long id, Integer usedQuota, Integer availableQuota);
/**
* 查询名额统计信息
*
* @param batchId 批次ID
* @param scholarshipTypeId 奖学金类型ID
* @return 统计信息
*/
List<JcbtScholarshipClassQuotaVo> queryQuotaStatistics(Long batchId, Long scholarshipTypeId);
}
backend/ruoyi-modules/ruoyi-jcbt/src/main/java/org/dromara/jcbt/service/IJcbtScholarshipCompatibilityService.java
+100
View File
@@ -0,0 +1,100 @@
package org.dromara.jcbt.service;
import org.dromara.jcbt.domain.vo.JcbtScholarshipCompatibilityVo;
import org.dromara.jcbt.domain.bo.JcbtScholarshipCompatibilityBo;
import org.dromara.common.mybatis.core.page.TableDataInfo;
import org.dromara.common.mybatis.core.page.PageQuery;
import java.util.Collection;
import java.util.List;
/**
* 奖学金兼得关系Service接口
*
* @author ruoyi
* @date 2025-01-27
*/
public interface IJcbtScholarshipCompatibilityService {
/**
* 查询奖学金兼得关系
*/
JcbtScholarshipCompatibilityVo queryById(Long id);
/**
* 查询奖学金兼得关系列表
*/
TableDataInfo<JcbtScholarshipCompatibilityVo> queryPageList(JcbtScholarshipCompatibilityBo bo, PageQuery pageQuery);
/**
* 查询奖学金兼得关系列表
*/
List<JcbtScholarshipCompatibilityVo> queryList(JcbtScholarshipCompatibilityBo bo);
/**
* 新增奖学金兼得关系
*/
Boolean insertByBo(JcbtScholarshipCompatibilityBo bo);
/**
* 修改奖学金兼得关系
*/
Boolean updateByBo(JcbtScholarshipCompatibilityBo bo);
/**
* 校验并批量删除奖学金兼得关系信息
*/
Boolean deleteWithValidByIds(Collection<Long> ids, Boolean isValid);
/**
* 查询与指定奖学金类型的兼得关系
*
* @param scholarshipTypeId 奖学金类型ID
* @return 兼得关系列表
*/
List<JcbtScholarshipCompatibilityVo> queryByScholarshipTypeId(Long scholarshipTypeId);
/**
* 检查两个奖学金类型是否兼容
*
* @param typeId1 奖学金类型1
* @param typeId2 奖学金类型2
* @return true-兼容，false-不兼容
*/
Boolean checkCompatibility(Long typeId1, Long typeId2);
/**
* 保存奖学金类型的兼得关系配置
*
* @param scholarshipTypeId 奖学金类型ID
* @param exclusiveTypeIds 互斥的奖学金类型ID列表
* @param compatibleTypeIds 兼容的奖学金类型ID列表
* @return 保存结果
*/
Boolean saveCompatibilityConfig(Long scholarshipTypeId, List<Long> exclusiveTypeIds, List<Long> compatibleTypeIds);
/**
* 获取与指定奖学金类型互斥的奖学金类型ID列表
*
* @param scholarshipTypeId 奖学金类型ID
* @return 互斥的奖学金类型ID列表
*/
List<Long> getExclusiveTypeIds(Long scholarshipTypeId);
/**
* 获取与指定奖学金类型兼容的奖学金类型ID列表
*
* @param scholarshipTypeId 奖学金类型ID
* @return 兼容的奖学金类型ID列表
*/
List<Long> getCompatibleTypeIds(Long scholarshipTypeId);
/**
* 删除指定奖学金类型的所有兼得关系
*
* @param scholarshipTypeId 奖学金类型ID
* @return 删除结果
*/
Boolean deleteByScholarshipTypeId(Long scholarshipTypeId);
}
backend/ruoyi-modules/ruoyi-jcbt/src/main/java/org/dromara/jcbt/service/IJcbtScholarshipQuotaService.java
+190
View File
@@ -0,0 +1,190 @@
package org.dromara.jcbt.service;
import org.dromara.jcbt.domain.bo.JcbtScholarshipQuotaBo;
import org.dromara.jcbt.domain.vo.JcbtScholarshipQuotaVo;
import org.dromara.common.mybatis.core.page.PageQuery;
import org.dromara.common.mybatis.core.page.TableDataInfo;
import java.util.Collection;
import java.util.List;
import java.util.Map;
/**
* 奖学金名额分配Service接口
*
* @author ruoyi
* @date 2025-01-27
*/
public interface IJcbtScholarshipQuotaService {
/**
* 查询奖学金名额分配
*
* @param id 主键
* @return 奖学金名额分配
*/
JcbtScholarshipQuotaVo queryById(Long id);
/**
* 分页查询奖学金名额分配列表
*
* @param bo 查询条件
* @param pageQuery 分页参数
* @return 奖学金名额分配分页列表
*/
TableDataInfo<JcbtScholarshipQuotaVo> queryPageList(JcbtScholarshipQuotaBo bo, PageQuery pageQuery);
/**
* 查询符合条件的奖学金名额分配列表
*
* @param bo 查询条件
* @return 奖学金名额分配列表
*/
List<JcbtScholarshipQuotaVo> queryList(JcbtScholarshipQuotaBo bo);
/**
* 新增奖学金名额分配
*
* @param bo 奖学金名额分配
* @return 是否新增成功
*/
Boolean insertByBo(JcbtScholarshipQuotaBo bo);
/**
* 修改奖学金名额分配
*
* @param bo 奖学金名额分配
* @return 是否修改成功
*/
Boolean updateByBo(JcbtScholarshipQuotaBo bo);
/**
* 校验并批量删除奖学金名额分配信息
*
* @param ids 待删除的主键集合
* @param isValid 是否进行有效性校验
* @return 是否删除成功
*/
Boolean deleteWithValidByIds(Collection<Long> ids, Boolean isValid);
/**
* 清空指定批次和奖学金类型的名额分配
*
* @param batchId 批次ID
* @param scholarshipTypeId 奖学金类型ID（可选）
* @return 是否清空成功
*/
Boolean clearQuotaByBatchAndType(Long batchId, Long scholarshipTypeId);
/**
* 查询指定批次的名额分配列表
*
* @param batchId 批次ID
* @return 名额分配列表
*/
List<JcbtScholarshipQuotaVo> queryListByBatchId(Long batchId);
/**
* 查询指定批次和奖学金类型的名额分配
*
* @param batchId 批次ID
* @param scholarshipTypeId 奖学金类型ID
* @return 名额分配列表
*/
List<JcbtScholarshipQuotaVo> queryListByBatchAndType(Long batchId, Long scholarshipTypeId);
/**
* 批量分配名额
*
* @param batchId 批次ID
* @param scholarshipTypeId 奖学金类型ID
* @param quotaAllocations 分配配置列表
* @return 是否分配成功
*/
Boolean batchAllocateQuota(Long batchId, Long scholarshipTypeId, List<JcbtScholarshipQuotaBo> quotaAllocations);
/**
* 调整名额分配
*
* @param fromQuotaId 源名额ID
* @param toQuotaId 目标名额ID
* @param adjustAmount 调整数量
* @param reason 调整原因
* @return 是否调整成功
*/
Boolean adjustQuotaAllocation(Long fromQuotaId, Long toQuotaId, Integer adjustAmount, String reason);
/**
* 锁定/解锁名额分配
*
* @param id 名额分配ID
* @param isLocked 是否锁定
* @return 是否操作成功
*/
Boolean lockQuotaAllocation(Long id, Integer isLocked);
/**
* 查询名额分配树形结构
*
* @param batchId 批次ID
* @param scholarshipTypeId 奖学金类型ID
* @return 树形结构数据
*/
List<JcbtScholarshipQuotaVo> queryQuotaTree(Long batchId, Long scholarshipTypeId);
/**
* 查询名额使用统计
*
* @param batchId 批次ID
* @return 统计数据
*/
Map<String, Object> queryQuotaUsageStatistics(Long batchId);
/**
* 自动分配名额（按规则）
*
* @param batchId 批次ID
* @param scholarshipTypeId 奖学金类型ID
* @param allocationRule 分配规则
* @return 是否分配成功
*/
Boolean autoAllocateQuota(Long batchId, Long scholarshipTypeId, String allocationRule);
/**
* 复制名额分配（从其他批次）
*
* @param sourceBatchId 源批次ID
* @param targetBatchId 目标批次ID
* @param scholarshipTypeIds 奖学金类型ID列表
* @return 是否复制成功
*/
Boolean copyQuotaFromBatch(Long sourceBatchId, Long targetBatchId, List<Long> scholarshipTypeIds);
/**
* 更新名额使用情况
*
* @param quotaId 名额分配ID
* @param usedChange 使用数量变化（正数增加，负数减少）
* @return 是否更新成功
*/
Boolean updateQuotaUsage(Long quotaId, Integer usedChange);
/**
* 验证名额分配的有效性
*
* @param bo 名额分配数据
* @return 验证结果消息
*/
String validateQuotaAllocation(JcbtScholarshipQuotaBo bo);
/**
* 查询班级级别的名额分配
*
* @param classId 班级ID
* @param scholarshipTypeId 奖学金类型ID
* @param batchId 批次ID
* @return 班级名额分配信息
*/
JcbtScholarshipQuotaVo selectClassQuota(Long classId, Long scholarshipTypeId, Long batchId);
}
backend/ruoyi-modules/ruoyi-jcbt/src/main/java/org/dromara/jcbt/service/IJcbtScholarshipReviewService.java
+135
View File
@@ -0,0 +1,135 @@
package org.dromara.jcbt.service;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import org.dromara.common.mybatis.core.page.PageQuery;
import org.dromara.common.mybatis.core.page.TableDataInfo;
import org.dromara.jcbt.domain.bo.JcbtScholarshipReviewBo;
import org.dromara.jcbt.domain.vo.JcbtScholarshipReviewVo;
import java.util.Collection;
import java.util.List;
import java.util.Map;
/**
* 奖学金审核记录Service接口
*
* @author ruoyi
* @date 2025-08-05
*/
public interface IJcbtScholarshipReviewService {
/**
* 查询奖学金审核记录
*/
JcbtScholarshipReviewVo queryById(Long id);
/**
* 查询奖学金审核记录列表
*/
TableDataInfo<JcbtScholarshipReviewVo> queryPageList(JcbtScholarshipReviewBo bo, PageQuery pageQuery);
/**
* 查询奖学金审核记录列表
*/
List<JcbtScholarshipReviewVo> queryList(JcbtScholarshipReviewBo bo);
/**
* 新增奖学金审核记录
*/
Boolean insertByBo(JcbtScholarshipReviewBo bo);
/**
* 修改奖学金审核记录
*/
Boolean updateByBo(JcbtScholarshipReviewBo bo);
/**
* 校验并批量删除奖学金审核记录信息
*/
Boolean deleteWithValidByIds(Collection<Long> ids, Boolean isValid);
/**
* 根据申请ID查询审核记录
*/
List<JcbtScholarshipReviewVo> queryReviewsByApplicationId(Long applicationId);
/**
* 查询当前用户待审核的记录
*/
TableDataInfo<JcbtScholarshipReviewVo> queryPendingReviews(Long reviewerId, String reviewLevel,
String applicationNo, String studentName,
PageQuery pageQuery);
/**
* 查询审核历史记录
*/
TableDataInfo<JcbtScholarshipReviewVo> queryReviewHistory(Long reviewerId, String reviewResult,
Long batchId, String startTime, String endTime,
PageQuery pageQuery);
/**
* 提交审核结果
*/
Boolean submitReview(Long reviewId, String reviewResult, String reviewOpinion,
Double reviewScore, Long nextReviewerId);
/**
* 批量审核
*/
Boolean batchReview(List<Long> reviewIds, String reviewResult, String reviewOpinion,
Long reviewerId, String reviewerName);
/**
* 创建审核任务
*/
Boolean createReviewTask(Long applicationId, String reviewLevel, Long reviewerId,
String reviewerName, Long nextReviewerId);
/**
* 转移审核任务
*/
Boolean transferReview(Long reviewId, Long newReviewerId, String newReviewerName, String reason);
/**
* 撤回审核结果
*/
Boolean withdrawReview(Long reviewId, String reason);
/**
* 查询某个申请的最新审核记录
*/
JcbtScholarshipReviewVo queryLatestReviewByApplicationId(Long applicationId);
/**
* 查询某个申请的指定级别审核记录
*/
JcbtScholarshipReviewVo queryReviewByApplicationAndLevel(Long applicationId, String reviewLevel);
/**
* 统计审核数量
*/
Map<String, Long> countReviewsByCondition(Long reviewerId, String reviewLevel,
String reviewResult, Long batchId);
/**
* 获取下一级审核人员列表
*/
List<Long> getNextReviewers(Long applicationId, String currentLevel);
/**
* 审核流程推进
*/
Boolean advanceReviewProcess(Long applicationId, String currentLevel, String reviewResult,
String reviewOpinion, Double reviewScore);
/**
* 检查用户审核权限
*/
Boolean checkReviewPermission(Long reviewerId, String reviewLevel, Long applicationId);
/**
* 获取审核统计信息
*/
Map<String, Object> getReviewStatistics(Long reviewerId, String reviewLevel, Long batchId);
}
backend/ruoyi-modules/ruoyi-jcbt/src/main/java/org/dromara/jcbt/service/IJcbtScholarshipTypeService.java
+94
View File
@@ -0,0 +1,94 @@
package org.dromara.jcbt.service;
import org.dromara.jcbt.domain.vo.JcbtScholarshipTypeVo;
import org.dromara.jcbt.domain.bo.JcbtScholarshipTypeBo;
import org.dromara.common.mybatis.core.page.TableDataInfo;
import org.dromara.common.mybatis.core.page.PageQuery;
import java.util.Collection;
import java.util.List;
/**
* 奖学金类型Service接口
*
* @author ruoyi
* @date 2025-01-27
*/
public interface IJcbtScholarshipTypeService {
/**
* 查询奖学金类型
*/
JcbtScholarshipTypeVo queryById(Long id);
/**
* 查询奖学金类型列表
*/
TableDataInfo<JcbtScholarshipTypeVo> queryPageList(JcbtScholarshipTypeBo bo, PageQuery pageQuery);
/**
* 查询奖学金类型列表
*/
List<JcbtScholarshipTypeVo> queryList(JcbtScholarshipTypeBo bo);
/**
* 新增奖学金类型
*/
Boolean insertByBo(JcbtScholarshipTypeBo bo);
/**
* 修改奖学金类型
*/
Boolean updateByBo(JcbtScholarshipTypeBo bo);
/**
* 校验并批量删除奖学金类型信息
*/
Boolean deleteWithValidByIds(Collection<Long> ids, Boolean isValid);
/**
* 根据类型名称查询奖学金类型
*/
JcbtScholarshipTypeVo queryByTypeName(String typeName);
/**
* 根据类别查询奖学金类型列表
*/
List<JcbtScholarshipTypeVo> queryByCategory(String typeCategory);
/**
* 查询启用状态的奖学金类型列表
*/
List<JcbtScholarshipTypeVo> queryActiveTypes();
/**
* 检查奖学金名称是否重复
*/
boolean checkTypeNameUnique(String typeName, Long id);
/**
* 批量更新排序号
*/
Boolean batchUpdateSortOrder(List<JcbtScholarshipTypeBo> scholarshipTypes);
/**
* 根据兼得类型查询相关奖学金类型
*/
List<JcbtScholarshipTypeVo> queryByCompatibilityType(String compatibilityType);
/**
* 启用/停用奖学金类型
*/
Boolean changeStatus(Long id, Integer status);
/**
* 导出奖学金类型数据
*/
List<JcbtScholarshipTypeVo> queryExportList(JcbtScholarshipTypeBo bo);
/**
* 获取奖学金类型选项列表
*/
List<JcbtScholarshipTypeVo> queryOptions();
}
backend/ruoyi-modules/ruoyi-jcbt/src/main/java/org/dromara/jcbt/service/IJcbtWorkStudyApplicationService.java
+167
View File
@@ -0,0 +1,167 @@
package org.dromara.jcbt.service;
import org.dromara.common.mybatis.core.page.PageQuery;
import org.dromara.common.mybatis.core.page.TableDataInfo;
import org.dromara.jcbt.domain.bo.JcbtWorkStudyApplicationBo;
import org.dromara.jcbt.domain.bo.WorkStudyApplicationReviewBo;
import org.dromara.jcbt.domain.vo.JcbtWorkStudyApplicationVo;
import java.util.Collection;
import java.util.List;
import java.util.Map;
/**
* 勤工俭学申请信息Service接口
*
* @author ruoyi
* @date 2025-01-03
*/
public interface IJcbtWorkStudyApplicationService {
/**
* 查询勤工俭学申请信息
*
* @param id 勤工俭学申请信息主键
* @return 勤工俭学申请信息
*/
JcbtWorkStudyApplicationVo queryById(Long id);
/**
* 查询勤工俭学申请信息列表
*
* @param bo 勤工俭学申请信息
* @param pageQuery 分页查询条件
* @return 勤工俭学申请信息集合
*/
TableDataInfo<JcbtWorkStudyApplicationVo> queryPageList(JcbtWorkStudyApplicationBo bo, PageQuery pageQuery);
/**
* 查询勤工俭学申请信息列表
*
* @param bo 勤工俭学申请信息
* @return 勤工俭学申请信息集合
*/
List<JcbtWorkStudyApplicationVo> queryList(JcbtWorkStudyApplicationBo bo);
/**
* 根据新增业务对象插入勤工俭学申请信息
*
* @param bo 勤工俭学申请信息新增业务对象
* @return 新增结果
*/
Boolean insertByBo(JcbtWorkStudyApplicationBo bo);
/**
* 根据编辑业务对象修改勤工俭学申请信息
*
* @param bo 勤工俭学申请信息编辑业务对象
* @return 修改结果
*/
Boolean updateByBo(JcbtWorkStudyApplicationBo bo);
/**
* 校验并批量删除勤工俭学申请信息
*
* @param ids 需要删除的勤工俭学申请信息主键集合
* @param isValid 是否校验,true-删除前校验,false-不校验
* @return 删除结果
*/
Boolean deleteWithValidByIds(Collection<Long> ids, Boolean isValid);
/**
* 提交申请
*
* @param id 申请ID
* @return 提交结果
*/
Boolean submitApplication(Long id);
/**
* 撤销申请
*
* @param id 申请ID
* @return 撤销结果
*/
Boolean cancelApplication(Long id);
/**
* 学院审核
*
* @param reviewBo 审核信息
* @return 审核结果
*/
Boolean collegeReview(WorkStudyApplicationReviewBo reviewBo);
/**
* 学生处审核
*
* @param reviewBo 审核信息
* @return 审核结果
*/
Boolean finalReview(WorkStudyApplicationReviewBo reviewBo);
/**
* 批量学院审核
*
* @param ids 申请ID集合
* @param reviewResult 审核结果
* @param reviewComment 审核意见
* @return 审核结果
*/
Boolean batchCollegeReview(Collection<Long> ids, String reviewResult, String reviewComment);
/**
* 批量学生处审核
*
* @param ids 申请ID集合
* @param reviewResult 审核结果
* @param reviewComment 审核意见
* @return 审核结果
*/
Boolean batchFinalReview(Collection<Long> ids, String reviewResult, String reviewComment);
/**
* 查询我的申请列表
*
* @param bo 查询条件
* @param pageQuery 分页查询条件
* @return 申请列表
*/
TableDataInfo<JcbtWorkStudyApplicationVo> queryMyApplications(JcbtWorkStudyApplicationBo bo, PageQuery pageQuery);
/**
* 查询待审核列表（学院审核人员）
*
* @param bo 查询条件
* @param pageQuery 分页查询条件
* @return 待审核列表
*/
TableDataInfo<JcbtWorkStudyApplicationVo> queryPendingCollegeReview(JcbtWorkStudyApplicationBo bo, PageQuery pageQuery);
/**
* 查询待审核列表（学生处审核人员）
*
* @param bo 查询条件
* @param pageQuery 分页查询条件
* @return 待审核列表
*/
TableDataInfo<JcbtWorkStudyApplicationVo> queryPendingFinalReview(JcbtWorkStudyApplicationBo bo, PageQuery pageQuery);
/**
* 检查学生是否已申请该岗位
*
* @param studentId 学生ID
* @param positionId 岗位ID
* @return 是否已申请
*/
Boolean hasApplied(Long studentId, Long positionId);
/**
* 获取岗位的申请统计
*
* @param positionId 岗位ID
* @return 申请统计信息
*/
Map<String, Object> getPositionApplicationStatistics(Long positionId);
}
Loaded 100 of 1200 files, more files were not shown because too many files have changed in this diff. Show more