Commit 9e0dacc7 authored by wujipeng's avatar wujipeng
Browse files

Merge remote-tracking branch 'origin/dev-v1.0' into dev-v1.0

parents 4ff3e0e4 1ea1a030
package com.platform.business.constant;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Set;
public final class AttendanceConstants {
private AttendanceConstants() {
}
public static final String STATUS_NORMAL = "NORMAL";
public static final String STATUS_LATE = "LATE";
public static final String STATUS_ABSENT = "ABSENT";
public static final String STATUS_LEAVE = "LEAVE";
public static final String METHOD_IP_CODE = "IP_CODE";
public static final String METHOD_IP_ONLY = "IP_ONLY";
public static final String METHOD_TEACHER = "TEACHER";
public static final String METHOD_SYSTEM = "SYSTEM";
public static final String METHOD_LEGACY = "LEGACY";
public static final String METHOD_LEAVE = "LEAVE";
public static final String SESSION_ACTIVE = "ACTIVE";
public static final String SESSION_ENDED = "ENDED";
private static final Set<String> TEACHER_ADJUSTABLE_STATUSES = new HashSet<>(
Arrays.asList(STATUS_NORMAL, STATUS_LATE, STATUS_ABSENT));
public static boolean isTeacherAdjustableStatus(String status) {
return status != null && TEACHER_ADJUSTABLE_STATUSES.contains(status.toUpperCase());
}
public static boolean isPresent(String status) {
return STATUS_NORMAL.equals(status) || STATUS_LATE.equals(status);
}
}
package com.platform.business.constant;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Set;
public final class LeaveConstants {
private LeaveConstants() {
}
public static final String TYPE_SICK = "SICK";
public static final String TYPE_PERSONAL = "PERSONAL";
public static final String TYPE_OTHER = "OTHER";
public static final String STATUS_PENDING = "PENDING";
public static final String STATUS_APPROVED = "APPROVED";
public static final String STATUS_REJECTED = "REJECTED";
public static final String STATUS_WITHDRAWN = "WITHDRAWN";
public static final String ROLE_TEACHER = "TEACHER";
public static final String ROLE_ADMIN = "ADMIN";
private static final Set<String> TYPES = new HashSet<>(
Arrays.asList(TYPE_SICK, TYPE_PERSONAL, TYPE_OTHER));
public static boolean isSupportedType(String type) {
return type != null && TYPES.contains(type);
}
}
package com.platform.business.constant;
/** 实训室与预约状态常量。 */
public final class TrainingRoomConstants {
/** 实训室运行中,可供学员预约。 */
public static final String ROOM_RUNNING = "running";
/** 实训室已停用,不可预约。 */
public static final String ROOM_DISABLED = "disabled";
/** 已预约、尚未开始。 */
public static final String BOOKING_BOOKED = "booked";
/** 已到开始时间、正在使用。 */
public static final String BOOKING_USING = "using";
/** 已正常或提前结束。 */
public static final String BOOKING_DONE = "done";
/** 已在开始前取消。 */
public static final String BOOKING_CANCELED = "canceled";
/** 创建预约操作。 */
public static final String ACTION_CREATE = "create";
/** 系统自动开始预约操作。 */
public static final String ACTION_AUTO_START = "auto_start";
/** 系统自动结束预约操作。 */
public static final String ACTION_AUTO_FINISH = "auto_finish";
/** 学员取消预约操作。 */
public static final String ACTION_STUDENT_CANCEL = "student_cancel";
/** 管理员取消预约操作。 */
public static final String ACTION_ADMIN_CANCEL = "admin_cancel";
/** 学员提前签退操作。 */
public static final String ACTION_STUDENT_SIGN_OUT = "student_sign_out";
/** 管理员手动结束预约操作。 */
public static final String ACTION_ADMIN_END = "admin_end";
/** 工具类不允许实例化。 */
private TrainingRoomConstants() {
}
}
package com.platform.business.constant;
import com.platform.business.model.vo.TrainingRoomTimeSlotVO;
import com.platform.exception.BusinessException;
import java.time.LocalTime;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
/** 原型约定的五个固定预约时段。 */
public enum TrainingRoomTimeSlot {
/** 08:00至10:00。 */
SLOT_1(1, "上午第1时段", LocalTime.of(8, 0), LocalTime.of(10, 0)),
/** 10:00至12:00。 */
SLOT_2(2, "上午第2时段", LocalTime.of(10, 0), LocalTime.of(12, 0)),
/** 14:00至16:00。 */
SLOT_3(3, "下午第1时段", LocalTime.of(14, 0), LocalTime.of(16, 0)),
/** 16:00至18:00。 */
SLOT_4(4, "下午第2时段", LocalTime.of(16, 0), LocalTime.of(18, 0)),
/** 19:00至21:00。 */
SLOT_5(5, "晚间时段", LocalTime.of(19, 0), LocalTime.of(21, 0));
private final int code;
private final String label;
private final LocalTime startTime;
private final LocalTime endTime;
TrainingRoomTimeSlot(int code, String label, LocalTime startTime, LocalTime endTime) {
this.code = code;
this.label = label;
this.startTime = startTime;
this.endTime = endTime;
}
public int getCode() {
return code;
}
public String getLabel() {
return label;
}
public LocalTime getStartTime() {
return startTime;
}
public LocalTime getEndTime() {
return endTime;
}
public String getTimeRange() {
return startTime + " - " + endTime;
}
/**
* 根据前端提交的时段编码查找固定时段。
*
* @param code 时段编码
* @return 匹配的固定时段
*/
public static TrainingRoomTimeSlot fromCode(Integer code) {
if (code != null) {
for (TrainingRoomTimeSlot slot : values()) {
if (slot.code == code) {
return slot;
}
}
}
throw new BusinessException("预约时段不存在");
}
/** 将所有固定时段转换为前端下拉框所需的数据。 */
public static List<TrainingRoomTimeSlotVO> toVOList() {
return Arrays.stream(values())
.map(slot -> new TrainingRoomTimeSlotVO(slot.code, slot.label,
slot.startTime.toString(), slot.endTime.toString()))
.collect(Collectors.toList());
}
}
package com.platform.business.controller;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.platform.business.config.AttendanceProperties;
import com.platform.business.model.dto.AttendanceCheckInDTO;
import com.platform.business.model.dto.AttendanceQueryDTO;
import com.platform.business.model.dto.AttendanceStatusUpdateDTO;
import com.platform.business.model.entity.UserEntity;
import com.platform.business.model.entity.SysPhoneRoleEntity;
import com.platform.business.model.vo.AttendanceRecordVO;
import com.platform.business.model.vo.AttendanceSessionVO;
import com.platform.business.model.vo.AttendanceSummaryVO;
import com.platform.business.service.AttendanceService;
import com.platform.business.service.UserService;
import com.platform.business.service.SysPhoneRoleService;
import com.platform.business.utils.JwtTokenUtil;
import com.platform.controller.BaseController;
import com.platform.exception.BusinessException;
import com.platform.model.resp.Result;
import com.platform.page.TableDataInfo;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import java.util.Calendar;
import java.util.Date;
import java.util.List;
@Api(tags = "出勤管理")
@RestController
@RequestMapping("/attendance")
public class AttendanceController extends BaseController {
@Resource
private AttendanceService attendanceService;
@Resource
private AttendanceProperties attendanceProperties;
@Resource
private JwtTokenUtil jwtTokenUtil;
@Resource
private UserService userService;
@Resource
private SysPhoneRoleService sysPhoneRoleService;
@ApiOperation("教师端-开始上课并获取本课次唯一验证码")
@PostMapping("/teacher/course/{subjectId}/start")
public Result<AttendanceSessionVO> startClass(@PathVariable Integer subjectId, HttpServletRequest request) {
return Result.data(attendanceService.startClass(subjectId, currentUser(request).getId()));
}
@ApiOperation("教师端-查看课程学员出勤名册(手机号完整展示)")
@GetMapping("/teacher/course/{subjectId}/roster")
public Result<List<AttendanceRecordVO>> teacherRoster(@PathVariable Integer subjectId,
HttpServletRequest request) {
return Result.data(attendanceService.teacherRoster(subjectId, currentUser(request).getId()));
}
@ApiOperation("教师端-手动调整学员为正常、迟到或缺勤")
@PutMapping("/teacher/status")
public Result<AttendanceRecordVO> updateStatus(@RequestBody AttendanceStatusUpdateDTO body,
HttpServletRequest request) {
return Result.data(attendanceService.updateStatus(body, currentUser(request).getId()));
}
@ApiOperation("学员端-签到")
@PostMapping("/student/check-in")
public Result<AttendanceRecordVO> checkIn(@RequestBody AttendanceCheckInDTO body,
HttpServletRequest request) {
UserEntity student = currentUser(request);
return Result.data(attendanceService.checkIn(body, student.getId(), resolveClientIp(request)));
}
@ApiOperation("学员端-查询本人出勤记录")
@PostMapping("/student/records")
public Result<List<AttendanceRecordVO>> studentRecords(@RequestBody(required = false) AttendanceQueryDTO query,
HttpServletRequest request) {
AttendanceQueryDTO safeQuery = query == null ? new AttendanceQueryDTO() : query;
safeQuery.setUserId(currentUser(request).getId());
applyDefaultDateRange(safeQuery);
attendanceService.finalizeEndedSubjects(safeQuery.getStartDate(), safeQuery.getEndDate());
return Result.data(attendanceService.queryRecords(safeQuery));
}
@ApiOperation("管理端-分页查询出勤记录")
@PostMapping("/admin/records/page")
public TableDataInfo adminRecords(@RequestBody AttendanceQueryDTO query, HttpServletRequest request) {
requireAdmin(currentUser(request));
applyDefaultDateRange(query);
attendanceService.finalizeEndedSubjects(query.getStartDate(), query.getEndDate());
int pageNum = query.getPageNum() == null || query.getPageNum() < 1 ? 1 : query.getPageNum();
int pageSize = query.getPageSize() == null || query.getPageSize() < 1 ? 10 : query.getPageSize();
startPage(pageNum, pageSize);
return getDataTable(attendanceService.queryRecords(query));
}
@ApiOperation("管理端-出勤汇总统计")
@PostMapping("/admin/statistics")
public Result<AttendanceSummaryVO> adminStatistics(@RequestBody(required = false) AttendanceQueryDTO query,
HttpServletRequest request) {
requireAdmin(currentUser(request));
return Result.data(attendanceService.querySummary(query));
}
private void requireAdmin(UserEntity user) {
List<SysPhoneRoleEntity> roles = sysPhoneRoleService.queryByPhone(user.getPhoneNumber());
boolean admin = roles != null && roles.stream().anyMatch(role -> "管理员".equals(role.getRoleName()));
if (!admin) {
throw new BusinessException("只有管理员可以查看全量出勤统计");
}
}
private void applyDefaultDateRange(AttendanceQueryDTO query) {
if (query.getStartDate() != null || query.getEndDate() != null) {
return;
}
Calendar start = Calendar.getInstance();
start.set(Calendar.DAY_OF_MONTH, 1);
start.set(Calendar.HOUR_OF_DAY, 0);
start.set(Calendar.MINUTE, 0);
start.set(Calendar.SECOND, 0);
start.set(Calendar.MILLISECOND, 0);
query.setStartDate(start.getTime());
query.setEndDate(new Date());
}
private UserEntity currentUser(HttpServletRequest request) {
String token = request.getHeader("Authorization");
if (token == null || token.trim().isEmpty()) {
throw new BusinessException("未获取到登录凭证");
}
token = token.trim();
if (token.regionMatches(true, 0, "Bearer ", 0, 7)) {
token = token.substring(7).trim();
}
String phone;
try {
phone = jwtTokenUtil.getUsernameFromToken(token);
} catch (Exception e) {
throw new BusinessException("登录凭证无效或已过期");
}
UserEntity user = userService.getOne(new LambdaQueryWrapper<UserEntity>()
.eq(UserEntity::getPhoneNumber, phone), false);
if (user == null) {
throw new BusinessException("当前登录用户不存在");
}
return user;
}
private String resolveClientIp(HttpServletRequest request) {
String ip = null;
if (attendanceProperties.isTrustForwardedHeaders()) {
String forwarded = request.getHeader("X-Forwarded-For");
if (forwarded != null && !forwarded.trim().isEmpty()) {
ip = forwarded.split(",", 2)[0].trim();
}
if (ip == null || ip.isEmpty()) {
ip = request.getHeader("X-Real-IP");
}
}
if (ip == null || ip.trim().isEmpty()) {
ip = request.getRemoteAddr();
}
ip = ip == null ? null : ip.trim();
if (ip != null && ip.startsWith("::ffff:")) {
ip = ip.substring(7);
}
return ip;
}
}
package com.platform.business.controller;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.platform.business.constant.LeaveConstants;
import com.platform.business.model.dto.LeaveApplyDTO;
import com.platform.business.model.dto.LeaveQueryDTO;
import com.platform.business.model.dto.LeaveReviewDTO;
import com.platform.business.model.entity.BsFileEntity;
import com.platform.business.model.entity.SysPhoneRoleEntity;
import com.platform.business.model.entity.UserEntity;
import com.platform.business.model.vo.LeaveApplicationVO;
import com.platform.business.service.BsFileService;
import com.platform.business.service.LeaveManagementService;
import com.platform.business.service.SysPhoneRoleService;
import com.platform.business.service.UserService;
import com.platform.business.utils.JwtTokenUtil;
import com.platform.controller.BaseController;
import com.platform.exception.BusinessException;
import com.platform.model.resp.Result;
import com.platform.page.TableDataInfo;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.MultipartFile;
import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import java.util.List;
@Api(tags = "请假管理")
@RestController
@RequestMapping("/leave")
public class LeaveController extends BaseController {
@Resource
private LeaveManagementService leaveManagementService;
@Resource
private JwtTokenUtil jwtTokenUtil;
@Resource
private UserService userService;
@Resource
private SysPhoneRoleService sysPhoneRoleService;
@Resource
private BsFileService bsFileService;
@ApiOperation("学员端-上传请假证明材料")
@PostMapping("/student/attachment")
public Result<BsFileEntity> uploadAttachment(@RequestParam("file") MultipartFile file,
HttpServletRequest request) {
currentUser(request);
validateAttachment(file);
return Result.data(bsFileService.uploadFile(file));
}
@ApiOperation("学员端-提交请假申请并自动关联时间重叠课程")
@PostMapping("/student/apply")
public Result<LeaveApplicationVO> apply(@RequestBody LeaveApplyDTO body,
HttpServletRequest request) {
return Result.data(leaveManagementService.apply(body, currentUser(request).getId()));
}
@ApiOperation("学员端-修改待审批请假申请")
@PutMapping("/student/apply")
public Result<LeaveApplicationVO> update(@RequestBody LeaveApplyDTO body,
HttpServletRequest request) {
return Result.data(leaveManagementService.update(body, currentUser(request).getId()));
}
@ApiOperation("学员端-撤回待审批请假申请")
@PutMapping("/student/{leaveId}/withdraw")
public Result<Boolean> withdraw(@PathVariable String leaveId, HttpServletRequest request) {
return Result.data(leaveManagementService.withdraw(leaveId, currentUser(request).getId()));
}
@ApiOperation("学员端-分页查询本人请假申请")
@PostMapping("/student/page")
public TableDataInfo studentPage(@RequestBody(required = false) LeaveQueryDTO query,
HttpServletRequest request) {
LeaveQueryDTO safeQuery = query == null ? new LeaveQueryDTO() : query;
safeQuery.setStudentId(currentUser(request).getId());
startLeavePage(safeQuery);
return getDataTable(leaveManagementService.queryApplications(safeQuery));
}
@ApiOperation("学员端-查看本人请假详情")
@GetMapping("/student/{leaveId}")
public Result<LeaveApplicationVO> studentDetail(@PathVariable String leaveId,
HttpServletRequest request) {
return Result.data(leaveManagementService.studentDetail(leaveId, currentUser(request).getId()));
}
@ApiOperation("教师端-分页查询本人课程关联的请假申请(完整手机号)")
@PostMapping("/teacher/page")
public TableDataInfo teacherPage(@RequestBody(required = false) LeaveQueryDTO query,
HttpServletRequest request) {
LeaveQueryDTO safeQuery = query == null ? new LeaveQueryDTO() : query;
safeQuery.setTeacherId(currentUser(request).getId());
startLeavePage(safeQuery);
return getDataTable(leaveManagementService.queryApplications(safeQuery));
}
@ApiOperation("教师端-查看本人课程关联的请假详情")
@GetMapping("/teacher/{leaveId}")
public Result<LeaveApplicationVO> teacherDetail(@PathVariable String leaveId,
HttpServletRequest request) {
return Result.data(leaveManagementService.teacherDetail(leaveId, currentUser(request).getId()));
}
@ApiOperation("教师端-审批本人课程关联的请假申请")
@PutMapping("/teacher/{leaveId}/review")
public Result<LeaveApplicationVO> teacherReview(@PathVariable String leaveId,
@RequestBody LeaveReviewDTO body,
HttpServletRequest request) {
return Result.data(leaveManagementService.review(leaveId, body,
currentUser(request).getId(), LeaveConstants.ROLE_TEACHER));
}
@ApiOperation("管理端-分页查询全部请假申请(完整手机号)")
@PostMapping("/admin/page")
public TableDataInfo adminPage(@RequestBody(required = false) LeaveQueryDTO query,
HttpServletRequest request) {
requireAdmin(currentUser(request));
LeaveQueryDTO safeQuery = query == null ? new LeaveQueryDTO() : query;
startLeavePage(safeQuery);
return getDataTable(leaveManagementService.queryApplications(safeQuery));
}
@ApiOperation("管理端-查看请假详情")
@GetMapping("/admin/{leaveId}")
public Result<LeaveApplicationVO> adminDetail(@PathVariable String leaveId,
HttpServletRequest request) {
requireAdmin(currentUser(request));
return Result.data(leaveManagementService.adminDetail(leaveId));
}
@ApiOperation("管理端-审批请假申请")
@PutMapping("/admin/{leaveId}/review")
public Result<LeaveApplicationVO> adminReview(@PathVariable String leaveId,
@RequestBody LeaveReviewDTO body,
HttpServletRequest request) {
UserEntity admin = currentUser(request);
requireAdmin(admin);
return Result.data(leaveManagementService.review(leaveId, body,
admin.getId(), LeaveConstants.ROLE_ADMIN));
}
private void startLeavePage(LeaveQueryDTO query) {
int pageNum = query.getPageNum() == null || query.getPageNum() < 1 ? 1 : query.getPageNum();
int pageSize = query.getPageSize() == null || query.getPageSize() < 1 ? 10 : query.getPageSize();
startPage(pageNum, pageSize);
}
private void validateAttachment(MultipartFile file) {
if (file == null || file.isEmpty()) {
throw new BusinessException("证明材料不能为空");
}
if (file.getSize() > 10L * 1024 * 1024) {
throw new BusinessException("单个证明材料不能超过10MB");
}
String filename = file.getOriginalFilename();
int dotIndex = filename == null ? -1 : filename.lastIndexOf('.');
String extension = dotIndex < 0 ? "" : filename.substring(dotIndex + 1).toLowerCase();
if (!("jpg".equals(extension) || "jpeg".equals(extension)
|| "png".equals(extension) || "pdf".equals(extension))) {
throw new BusinessException("证明材料只支持 JPG、PNG 或 PDF");
}
}
private void requireAdmin(UserEntity user) {
List<SysPhoneRoleEntity> roles = sysPhoneRoleService.queryByPhone(user.getPhoneNumber());
boolean admin = roles != null && roles.stream().anyMatch(role -> "管理员".equals(role.getRoleName()));
if (!admin) {
throw new BusinessException("只有管理员可以访问管理端请假接口");
}
}
private UserEntity currentUser(HttpServletRequest request) {
String token = request.getHeader("Authorization");
if (token == null || token.trim().isEmpty()) {
throw new BusinessException("未获取到登录凭证");
}
token = token.trim();
if (token.regionMatches(true, 0, "Bearer ", 0, 7)) {
token = token.substring(7).trim();
}
String phone;
try {
phone = jwtTokenUtil.getUsernameFromToken(token);
} catch (Exception e) {
throw new BusinessException("登录凭证无效或已过期");
}
UserEntity user = userService.getOne(new LambdaQueryWrapper<UserEntity>()
.eq(UserEntity::getPhoneNumber, phone), false);
if (user == null) {
throw new BusinessException("当前登录用户不存在");
}
return user;
}
}
package com.platform.business.controller;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.platform.business.model.dto.TeachingResourceDTO;
import com.platform.business.model.entity.UserEntity;
import com.platform.business.model.vo.TeachingResourceStatisticsVO;
import com.platform.business.model.vo.TeachingResourceVO;
import com.platform.business.service.TeachingResourceService;
import com.platform.business.service.UserService;
import com.platform.business.utils.JwtTokenUtil;
import com.platform.controller.BaseController;
import com.platform.exception.BusinessException;
import com.platform.model.resp.Result;
import com.platform.page.TableDataInfo;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.springframework.util.StringUtils;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.MultipartFile;
import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
/**
* 教学资源接口。
* 管理员接口使用全量数据范围,学生接口始终根据登录令牌解析当前用户,
* 不接受前端传入的学生ID。
*/
@Api(tags = "教学资源")
@RestController
@RequestMapping("/teaching/resource")
public class TeachingResourceController extends BaseController {
@Resource
private TeachingResourceService teachingResourceService;
@Resource
private UserService userService;
@Resource
private JwtTokenUtil jwtTokenUtil;
@ApiOperation("管理员端-教学资源分页")
@PostMapping("/admin/page")
public TableDataInfo adminPage(@RequestBody TeachingResourceDTO query) {
// 沿用项目现有 BaseController + PageHelper 的分页响应格式。
normalizePage(query);
startPage(query.getPageNum(), query.getPageSize());
return getDataTable(teachingResourceService.adminList(query));
}
@ApiOperation("管理员端-教学资源统计")
@GetMapping("/admin/statistics")
public Result<TeachingResourceStatisticsVO> adminStatistics() {
return Result.data(teachingResourceService.adminStatistics());
}
@ApiOperation("管理员端-上传教学资源")
@PostMapping("/admin/upload")
public Result<TeachingResourceVO> upload(@RequestParam("file") MultipartFile file,
@RequestParam("resourceName") String resourceName,
@RequestParam("courseId") Integer courseId,
HttpServletRequest request) {
// 上传者信息只从服务端登录态获取,避免伪造上传人。
return Result.data(teachingResourceService.upload(file, resourceName, courseId, currentUser(request)));
}
@ApiOperation("管理员端-编辑教学资源名称和适用课程")
@PutMapping("/admin/update")
public Result<Boolean> update(@RequestBody TeachingResourceDTO resource) {
return Result.data(teachingResourceService.updateResource(resource));
}
@ApiOperation("管理员端-逻辑删除教学资源")
@DeleteMapping("/admin/{id}")
public Result<Boolean> delete(@PathVariable String id) {
return Result.data(teachingResourceService.deleteResource(id));
}
@ApiOperation("管理员端-下载教学资源")
@GetMapping("/admin/download/{id}")
public void adminDownload(@PathVariable String id) {
teachingResourceService.adminDownload(id);
}
@ApiOperation("学生端-本人班级课程资源分页")
@PostMapping("/student/page")
public TableDataInfo studentPage(@RequestBody TeachingResourceDTO query, HttpServletRequest request) {
normalizePage(query);
// 先由令牌确定学生,再由 Mapper 查询该学生所在班级及对应课程资源。
UserEntity student = currentUser(request);
startPage(query.getPageNum(), query.getPageSize());
return getDataTable(teachingResourceService.studentList(student.getId(), query));
}
@ApiOperation("学生端-本人班级课程资源统计")
@GetMapping("/student/statistics")
public Result<TeachingResourceStatisticsVO> studentStatistics(HttpServletRequest request) {
return Result.data(teachingResourceService.studentStatistics(currentUser(request).getId()));
}
@ApiOperation("学生端-下载本人班级课程资源")
@GetMapping("/student/download/{id}")
public void studentDownload(@PathVariable String id, HttpServletRequest request) {
teachingResourceService.studentDownload(id, currentUser(request).getId());
}
/**
* 从 Authorization 头解析手机号并查询当前有效用户。
* 同时兼容项目原有裸 token 和标准 Bearer token 两种传递方式。
*/
private UserEntity currentUser(HttpServletRequest request) {
String token = request.getHeader("Authorization");
if (!StringUtils.hasText(token)) {
throw new BusinessException("未获取到登录凭证");
}
if (token.startsWith("Bearer ")) {
token = token.substring(7);
}
String phoneNumber = jwtTokenUtil.getUsernameFromToken(token);
UserEntity user = userService.getOne(new LambdaQueryWrapper<UserEntity>()
.eq(UserEntity::getPhoneNumber, phoneNumber)
.eq(UserEntity::getDelFlag, false));
if (user == null) {
throw new BusinessException("当前登录用户不存在");
}
return user;
}
/**
* 补充分页默认值并限制单页最大100条,防止一次查询数据量过大。
*/
private void normalizePage(TeachingResourceDTO query) {
if (query == null) {
throw new BusinessException("分页参数不能为空");
}
if (query.getPageNum() <= 0) {
query.setPageNum(1);
}
if (query.getPageSize() <= 0) {
query.setPageSize(20);
}
if (query.getPageSize() > 100) {
query.setPageSize(100);
}
}
}
package com.platform.business.controller;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.platform.business.model.dto.TrainingRoomBookingCreateDTO;
import com.platform.business.model.dto.TrainingRoomBookingDTO;
import com.platform.business.model.dto.TrainingRoomDTO;
import com.platform.business.model.entity.UserEntity;
import com.platform.business.model.vo.TrainingRoomBookingDetailVO;
import com.platform.business.model.vo.TrainingRoomBookingStatisticsVO;
import com.platform.business.model.vo.TrainingRoomBookingVO;
import com.platform.business.model.vo.TrainingRoomSeatVO;
import com.platform.business.model.vo.TrainingRoomStatisticsVO;
import com.platform.business.model.vo.TrainingRoomTimeSlotVO;
import com.platform.business.model.vo.TrainingRoomVO;
import com.platform.business.service.TrainingRoomBookingService;
import com.platform.business.service.TrainingRoomService;
import com.platform.business.service.UserService;
import com.platform.business.utils.JwtTokenUtil;
import com.platform.controller.BaseController;
import com.platform.exception.BusinessException;
import com.platform.model.resp.Result;
import com.platform.page.TableDataInfo;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.springframework.util.StringUtils;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import java.util.Date;
import java.util.List;
/**
* 实训室管理员端与学员端接口。
* 学员身份只从登录令牌解析,接口不接受前端传入的studentId。
*/
@Api(tags = "实训室管理与预约")
@RestController
@RequestMapping("/training/room")
public class TrainingRoomController extends BaseController {
/** 实训室基础信息、机位数量和KPI业务服务。 */
@Resource
private TrainingRoomService trainingRoomService;
/** 预约查询、操作、机位可用性及状态同步业务服务。 */
@Resource
private TrainingRoomBookingService bookingService;
/** 用于根据登录标识获取当前有效用户。 */
@Resource
private UserService userService;
/** 用于从Authorization请求头解析当前登录账号。 */
@Resource
private JwtTokenUtil jwtTokenUtil;
// ==================== 管理员端实训室管理 ====================
@ApiOperation("管理员端-实训室分页")
@PostMapping("/admin/page")
public TableDataInfo adminPage(@RequestBody TrainingRoomDTO query) {
normalizePage(query);
bookingService.synchronizeBookingStatuses();
startPage(query.getPageNum(), query.getPageSize());
return getDataTable(trainingRoomService.adminList(query, new Date()));
}
@ApiOperation("管理员端-实训室KPI")
@GetMapping("/admin/statistics")
public Result<TrainingRoomStatisticsVO> adminStatistics() {
bookingService.synchronizeBookingStatuses();
return Result.data(trainingRoomService.adminStatistics(new Date()));
}
@ApiOperation("管理员端-实训室详情")
@GetMapping("/admin/{id}")
public Result<TrainingRoomVO> adminDetail(@PathVariable String id) {
bookingService.synchronizeBookingStatuses();
return Result.data(trainingRoomService.detail(id, new Date()));
}
@ApiOperation("管理员端-新建实训室")
@PostMapping("/admin")
public Result<TrainingRoomVO> createRoom(@RequestBody TrainingRoomDTO room) {
return Result.data(trainingRoomService.createRoom(room));
}
@ApiOperation("管理员端-编辑实训室")
@PutMapping("/admin")
public Result<Boolean> updateRoom(@RequestBody TrainingRoomDTO room) {
bookingService.synchronizeBookingStatuses();
return Result.data(trainingRoomService.updateRoom(room));
}
@ApiOperation("管理员端-启用或停用实训室")
@PutMapping("/admin/{id}/status/{status}")
public Result<Boolean> updateRoomStatus(@PathVariable String id, @PathVariable String status) {
bookingService.synchronizeBookingStatuses();
return Result.data(trainingRoomService.updateStatus(id, status));
}
// ==================== 管理员端预约管理 ====================
@ApiOperation("管理员端-预约分页")
@PostMapping("/admin/booking/page")
public TableDataInfo adminBookingPage(@RequestBody TrainingRoomBookingDTO query) {
normalizePage(query);
// 必须在启动PageHelper前完成状态补偿,避免补偿查询消耗分页上下文。
bookingService.synchronizeBookingStatuses();
startPage(query.getPageNum(), query.getPageSize());
return getDataTable(bookingService.adminList(query));
}
@ApiOperation("管理员端-单个实训室预约统计")
@GetMapping("/admin/booking/statistics/{roomId}")
public Result<TrainingRoomBookingStatisticsVO> adminBookingStatistics(@PathVariable String roomId) {
return Result.data(bookingService.adminStatistics(roomId));
}
@ApiOperation("管理员端-指定日期时段机位状态")
@GetMapping("/admin/{roomId}/seats")
public Result<List<TrainingRoomSeatVO>> adminAvailability(@PathVariable String roomId,
@RequestParam String bookingDate,
@RequestParam Integer slotCode) {
return Result.data(bookingService.adminAvailability(roomId, bookingDate, slotCode));
}
@ApiOperation("管理员端-预约详情及操作记录")
@GetMapping("/admin/booking/{id}")
public Result<TrainingRoomBookingDetailVO> adminBookingDetail(@PathVariable String id) {
return Result.data(bookingService.adminDetail(id));
}
@ApiOperation("管理员端-取消未开始预约")
@PutMapping("/admin/booking/{id}/cancel")
public Result<Boolean> adminCancel(@PathVariable String id, HttpServletRequest request) {
return Result.data(bookingService.adminCancel(id, currentUser(request)));
}
@ApiOperation("管理员端-结束使用中的预约")
@PutMapping("/admin/booking/{id}/end")
public Result<Boolean> adminEnd(@PathVariable String id, HttpServletRequest request) {
return Result.data(bookingService.adminEnd(id, currentUser(request)));
}
// ==================== 学员端实训室预约 ====================
@ApiOperation("学员端-运行中实训室分页")
@PostMapping("/student/page")
public TableDataInfo studentPage(@RequestBody TrainingRoomDTO query, HttpServletRequest request) {
currentUser(request);
normalizePage(query);
bookingService.synchronizeBookingStatuses();
startPage(query.getPageNum(), query.getPageSize());
return getDataTable(trainingRoomService.studentList(query, new Date()));
}
@ApiOperation("学员端-实训室KPI")
@GetMapping("/student/statistics")
public Result<TrainingRoomStatisticsVO> studentStatistics(HttpServletRequest request) {
currentUser(request);
bookingService.synchronizeBookingStatuses();
return Result.data(trainingRoomService.studentStatistics(new Date()));
}
@ApiOperation("学员端-固定预约时段")
@GetMapping("/student/time-slots")
public Result<List<TrainingRoomTimeSlotVO>> timeSlots(HttpServletRequest request) {
currentUser(request);
return Result.data(bookingService.timeSlots());
}
@ApiOperation("学员端-指定日期时段机位状态")
@GetMapping("/student/{roomId}/seats")
public Result<List<TrainingRoomSeatVO>> availability(@PathVariable String roomId,
@RequestParam String bookingDate,
@RequestParam Integer slotCode,
HttpServletRequest request) {
currentUser(request);
return Result.data(bookingService.availability(roomId, bookingDate, slotCode));
}
@ApiOperation("学员端-创建预约")
@PostMapping("/student/booking")
public Result<TrainingRoomBookingVO> createBooking(@RequestBody TrainingRoomBookingCreateDTO booking,
HttpServletRequest request) {
return Result.data(bookingService.createBooking(booking, currentUser(request)));
}
@ApiOperation("学员端-我的预约分页")
@PostMapping("/student/booking/page")
public TableDataInfo studentBookingPage(@RequestBody TrainingRoomBookingDTO query,
HttpServletRequest request) {
normalizePage(query);
UserEntity student = currentUser(request);
bookingService.synchronizeBookingStatuses();
startPage(query.getPageNum(), query.getPageSize());
return getDataTable(bookingService.studentList(student.getId(), query));
}
@ApiOperation("学员端-我的预约详情")
@GetMapping("/student/booking/{id}")
public Result<TrainingRoomBookingDetailVO> studentBookingDetail(@PathVariable String id,
HttpServletRequest request) {
return Result.data(bookingService.studentDetail(id, currentUser(request).getId()));
}
@ApiOperation("学员端-取消未开始预约")
@PutMapping("/student/booking/{id}/cancel")
public Result<Boolean> studentCancel(@PathVariable String id, HttpServletRequest request) {
return Result.data(bookingService.studentCancel(id, currentUser(request)));
}
@ApiOperation("学员端-提前签退")
@PutMapping("/student/booking/{id}/sign-out")
public Result<Boolean> studentSignOut(@PathVariable String id, HttpServletRequest request) {
return Result.data(bookingService.studentSignOut(id, currentUser(request)));
}
/** 从JWT手机号查询当前有效用户,兼容裸token和Bearer token。 */
private UserEntity currentUser(HttpServletRequest request) {
String token = request.getHeader("Authorization");
if (!StringUtils.hasText(token)) {
throw new BusinessException("未获取到登录凭证");
}
if (token.startsWith("Bearer ")) {
token = token.substring(7);
}
String phoneNumber = jwtTokenUtil.getUsernameFromToken(token);
UserEntity user = userService.getOne(new LambdaQueryWrapper<UserEntity>()
.eq(UserEntity::getPhoneNumber, phoneNumber)
.eq(UserEntity::getDelFlag, false));
if (user == null) {
throw new BusinessException("当前登录用户不存在");
}
return user;
}
/** 统一分页默认值:第1页、每页20条、最大100条。 */
private void normalizePage(Object query) {
if (query instanceof TrainingRoomDTO) {
TrainingRoomDTO room = (TrainingRoomDTO) query;
room.setPageNum(room.getPageNum() <= 0 ? 1 : room.getPageNum());
room.setPageSize(normalizePageSize(room.getPageSize()));
} else if (query instanceof TrainingRoomBookingDTO) {
TrainingRoomBookingDTO booking = (TrainingRoomBookingDTO) query;
booking.setPageNum(booking.getPageNum() <= 0 ? 1 : booking.getPageNum());
booking.setPageSize(normalizePageSize(booking.getPageSize()));
} else {
throw new BusinessException("分页参数不能为空");
}
}
private int normalizePageSize(int pageSize) {
if (pageSize <= 0) {
return 20;
}
return Math.min(pageSize, 100);
}
}
...@@ -2,8 +2,14 @@ package com.platform.business.mapper; ...@@ -2,8 +2,14 @@ package com.platform.business.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper; import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.platform.business.model.dto.ClassDTO; import com.platform.business.model.dto.ClassDTO;
import com.platform.business.model.dto.AttendanceQueryDTO;
import com.platform.business.model.entity.ClassSubjectAttendanceEntity; import com.platform.business.model.entity.ClassSubjectAttendanceEntity;
import com.platform.business.model.vo.AttendanceRecordVO;
import com.platform.business.model.vo.AttendanceCourseStatisticsVO;
import com.platform.business.model.vo.AttendanceStudentStatisticsVO;
import com.platform.business.model.vo.AttendanceSummaryVO;
import org.apache.ibatis.annotations.Mapper; import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import java.util.List; import java.util.List;
...@@ -17,4 +23,25 @@ import java.util.List; ...@@ -17,4 +23,25 @@ import java.util.List;
public interface ClassSubjectAttendanceMapper extends BaseMapper<ClassSubjectAttendanceEntity> { public interface ClassSubjectAttendanceMapper extends BaseMapper<ClassSubjectAttendanceEntity> {
List<ClassSubjectAttendanceEntity> queryOneself(ClassDTO classDTO); List<ClassSubjectAttendanceEntity> queryOneself(ClassDTO classDTO);
int insertIgnore(ClassSubjectAttendanceEntity record);
int insertAbsencesIgnore(@Param("records") List<ClassSubjectAttendanceEntity> records);
int upsertTeacherStatus(ClassSubjectAttendanceEntity record);
List<ClassSubjectAttendanceEntity> lockRecords(@Param("subjectIds") List<Integer> subjectIds,
@Param("userId") String userId);
int upsertLeaveStatuses(@Param("records") List<ClassSubjectAttendanceEntity> records);
List<AttendanceRecordVO> queryRecords(AttendanceQueryDTO query);
List<AttendanceRecordVO> queryTeacherRoster(@Param("subjectId") Integer subjectId);
AttendanceSummaryVO querySummary(AttendanceQueryDTO query);
List<AttendanceStudentStatisticsVO> queryStudentStatistics(AttendanceQueryDTO query);
List<AttendanceCourseStatisticsVO> queryCourseStatistics(AttendanceQueryDTO query);
} }
package com.platform.business.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.platform.business.model.entity.ClassSubjectAttendanceSessionEntity;
import org.apache.ibatis.annotations.Mapper;
@Mapper
public interface ClassSubjectAttendanceSessionMapper extends BaseMapper<ClassSubjectAttendanceSessionEntity> {
int insertIgnore(ClassSubjectAttendanceSessionEntity session);
}
package com.platform.business.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.platform.business.model.dto.LeaveQueryDTO;
import com.platform.business.model.entity.StudentLeaveApplicationEntity;
import com.platform.business.model.vo.LeaveApplicationVO;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import java.util.Date;
import java.util.List;
@Mapper
public interface StudentLeaveApplicationMapper extends BaseMapper<StudentLeaveApplicationEntity> {
List<LeaveApplicationVO> queryApplications(LeaveQueryDTO query);
StudentLeaveApplicationEntity selectByIdForUpdate(@Param("id") String id);
int reviewPending(@Param("id") String id,
@Param("status") String status,
@Param("approverId") String approverId,
@Param("approverRole") String approverRole,
@Param("approvalOpinion") String approvalOpinion,
@Param("reviewedAt") Date reviewedAt);
int countTeacherRelatedSubjects(@Param("leaveId") String leaveId,
@Param("teacherId") String teacherId);
}
package com.platform.business.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.platform.business.model.entity.StudentLeaveAttachmentEntity;
import com.platform.business.model.vo.LeaveAttachmentVO;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import java.util.List;
@Mapper
public interface StudentLeaveAttachmentMapper extends BaseMapper<StudentLeaveAttachmentEntity> {
List<LeaveAttachmentVO> queryAttachmentsByLeaveId(@Param("leaveId") String leaveId);
}
package com.platform.business.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.platform.business.model.entity.StudentLeaveSubjectEntity;
import com.platform.business.model.vo.LeaveSubjectVO;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import java.util.List;
@Mapper
public interface StudentLeaveSubjectMapper extends BaseMapper<StudentLeaveSubjectEntity> {
List<LeaveSubjectVO> querySubjectsByLeaveId(@Param("leaveId") String leaveId);
}
package com.platform.business.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.platform.business.model.dto.TeachingResourceDTO;
import com.platform.business.model.entity.TeachingResourceEntity;
import com.platform.business.model.vo.TeachingResourceStatisticsVO;
import com.platform.business.model.vo.TeachingResourceVO;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import java.util.List;
/**
* 教学资源数据访问接口。
* 列表和统计查询通过课程所属班级控制学生的数据范围。
*/
@Mapper
public interface TeachingResourceMapper extends BaseMapper<TeachingResourceEntity> {
/** 管理员端全量分页查询,分页由 Controller 中的 PageHelper 启动。 */
List<TeachingResourceVO> selectAdminList(@Param("query") TeachingResourceDTO query);
/** 学生端分页查询,只返回该学生所在班级对应课程的资源。 */
List<TeachingResourceVO> selectStudentList(@Param("userId") String userId,
@Param("query") TeachingResourceDTO query);
/** 查询单条未删除资源及其课程、班级展示信息。 */
TeachingResourceVO selectAdminById(@Param("id") String id);
/** 判断指定资源是否属于学生所在班级的课程,用于下载前二次鉴权。 */
int countStudentResource(@Param("id") String id, @Param("userId") String userId);
/** 管理员端全量资源统计。 */
TeachingResourceStatisticsVO selectAdminStatistics();
/** 学生端可见范围资源统计。 */
TeachingResourceStatisticsVO selectStudentStatistics(@Param("userId") String userId);
/** 原子递增下载次数,避免并发下载时计数丢失。 */
int incrementDownloadCount(@Param("id") String id);
}
package com.platform.business.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.platform.business.model.entity.TrainingRoomBookingLogEntity;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import java.util.List;
/** 预约操作时间线数据访问接口。 */
@Mapper
public interface TrainingRoomBookingLogMapper extends BaseMapper<TrainingRoomBookingLogEntity> {
/** 查询指定预约的完整操作时间线,并按操作时间升序返回。 */
List<TrainingRoomBookingLogEntity> selectByBookingId(@Param("bookingId") String bookingId);
}
package com.platform.business.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.platform.business.model.dto.TrainingRoomBookingDTO;
import com.platform.business.model.entity.TrainingRoomBookingEntity;
import com.platform.business.model.vo.TrainingRoomBookingStatisticsVO;
import com.platform.business.model.vo.TrainingRoomBookingVO;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import java.util.Date;
import java.util.List;
/** 预约查询、冲突校验和状态流转数据访问接口。 */
@Mapper
public interface TrainingRoomBookingMapper extends BaseMapper<TrainingRoomBookingEntity> {
/** 管理员按实训室、日期、状态和关键字查询预约列表。 */
List<TrainingRoomBookingVO> selectAdminList(@Param("query") TrainingRoomBookingDTO query);
/** 查询指定学员自己的预约列表。 */
List<TrainingRoomBookingVO> selectStudentList(@Param("studentId") String studentId,
@Param("query") TrainingRoomBookingDTO query);
/** 查询预约详情及关联的实训室信息。 */
TrainingRoomBookingVO selectDetail(@Param("id") String id);
/** 按状态统计指定实训室的预约数量。 */
TrainingRoomBookingStatisticsVO selectStatistics(@Param("roomId") String roomId);
/** 统计同一实训室、日期、时段和机位上的有效预约,用于冲突校验。 */
int countSeatConflict(@Param("roomId") String roomId,
@Param("bookingDate") String bookingDate,
@Param("slotCode") Integer slotCode,
@Param("seatNo") Integer seatNo);
/** 统计同一学员、日期和时段上的有效预约,用于冲突校验。 */
int countStudentConflict(@Param("studentId") String studentId,
@Param("bookingDate") String bookingDate,
@Param("slotCode") Integer slotCode);
/** 查询已经到达开始时间、但状态仍为booked的预约。 */
List<TrainingRoomBookingEntity> selectDueBooked(@Param("now") Date now);
/** 查询已经到达结束时间、但状态仍为using的预约。 */
List<TrainingRoomBookingEntity> selectDueUsing(@Param("now") Date now);
/** 以条件更新方式将预约从booked变更为using。 */
int startBooking(@Param("id") String id, @Param("actualStartTime") Date actualStartTime);
/** 以条件更新方式将预约从using变更为done并释放唯一约束。 */
int finishUsingBooking(@Param("id") String id, @Param("actualEndTime") Date actualEndTime);
/** 服务停机跨过完整预约时段时,将booked预约直接补偿为done。 */
int finishExpiredBooked(@Param("id") String id);
/** 仅在预约尚未开始时将其取消,并释放唯一约束。 */
int cancelBooked(@Param("id") String id,
@Param("cancelTime") Date cancelTime,
@Param("cancelBy") String cancelBy);
}
package com.platform.business.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.platform.business.model.dto.TrainingRoomDTO;
import com.platform.business.model.entity.TrainingRoomEntity;
import com.platform.business.model.vo.TrainingRoomStatisticsVO;
import com.platform.business.model.vo.TrainingRoomVO;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import java.util.Date;
import java.util.List;
/** 实训室列表、详情与KPI数据访问接口。 */
@Mapper
public interface TrainingRoomMapper extends BaseMapper<TrainingRoomEntity> {
/** 管理员查询全部有效实训室及当前使用情况。 */
List<TrainingRoomVO> selectAdminList(@Param("query") TrainingRoomDTO query,
@Param("now") Date now);
/** 学员查询运行中的实训室及当前使用情况。 */
List<TrainingRoomVO> selectStudentList(@Param("query") TrainingRoomDTO query,
@Param("now") Date now);
/** 查询单个实训室详情及动态统计数据。 */
TrainingRoomVO selectDetail(@Param("id") String id, @Param("now") Date now);
/** 查询管理员端实训室KPI。 */
TrainingRoomStatisticsVO selectAdminStatistics(@Param("now") Date now);
/** 查询学员端运行中实训室KPI。 */
TrainingRoomStatisticsVO selectStudentStatistics(@Param("now") Date now);
/** 检查有效实训室名称是否重复,编辑时排除当前ID。 */
int countSameName(@Param("name") String name, @Param("excludeId") String excludeId);
/** 统计指定实训室当前尚未结束的有效预约。 */
int countActiveBookingsAfter(@Param("roomId") String roomId, @Param("now") Date now);
}
package com.platform.business.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.platform.business.model.entity.TrainingRoomSeatEntity;
import com.platform.business.model.vo.TrainingRoomSeatVO;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import java.util.List;
/** 机位定义与指定时段可用状态查询。 */
@Mapper
public interface TrainingRoomSeatMapper extends BaseMapper<TrainingRoomSeatEntity> {
/** 查询实训室的全部机位定义,包括缩容后停用的机位。 */
List<TrainingRoomSeatEntity> selectAllByRoom(@Param("roomId") String roomId);
/** 校验指定编号是否为当前启用机位。 */
TrainingRoomSeatEntity selectEnabledSeat(@Param("roomId") String roomId,
@Param("seatNo") Integer seatNo);
/** 一次返回指定实训室、日期和时段下的全部启用机位及动态状态。 */
List<TrainingRoomSeatVO> selectAvailability(@Param("roomId") String roomId,
@Param("bookingDate") String bookingDate,
@Param("slotCode") Integer slotCode);
/** 扩容时重新启用编号不大于新机位总数的历史机位。 */
int enableSeatsUpTo(@Param("roomId") String roomId, @Param("seatCount") Integer seatCount);
/** 缩容时停用编号大于新机位总数的机位。 */
int disableSeatsAbove(@Param("roomId") String roomId, @Param("seatCount") Integer seatCount);
}
package com.platform.business.service;
import com.platform.business.model.dto.AttendanceCheckInDTO;
import com.platform.business.model.dto.AttendanceQueryDTO;
import com.platform.business.model.dto.AttendanceStatusUpdateDTO;
import com.platform.business.model.vo.AttendanceRecordVO;
import com.platform.business.model.vo.AttendanceSessionVO;
import com.platform.business.model.vo.AttendanceSummaryVO;
import java.util.Date;
import java.util.List;
public interface AttendanceService {
AttendanceSessionVO startClass(Integer subjectId, String teacherId);
AttendanceRecordVO checkIn(AttendanceCheckInDTO request, String studentId, String clientIp);
AttendanceRecordVO updateStatus(AttendanceStatusUpdateDTO request, String teacherId);
List<AttendanceRecordVO> teacherRoster(Integer subjectId, String teacherId);
List<AttendanceRecordVO> queryRecords(AttendanceQueryDTO query);
AttendanceSummaryVO querySummary(AttendanceQueryDTO query);
void finalizeEndedSubjects(Date startDate, Date endDate);
}
...@@ -7,7 +7,12 @@ import org.springframework.web.multipart.MultipartFile; ...@@ -7,7 +7,12 @@ import org.springframework.web.multipart.MultipartFile;
public interface BsFileService extends IService<BsFileEntity> { public interface BsFileService extends IService<BsFileEntity> {
/** 单文件最大500MB,业务层再次校验,避免仅依赖容器配置。 */
long MAX_FILE_SIZE = 500L * 1024 * 1024;
/** 将文件保存到磁盘并持久化文件元数据。 */
BsFileEntity uploadFile(MultipartFile file) ; BsFileEntity uploadFile(MultipartFile file) ;
/** 以附件方式流式输出文件。 */
void downloadFile(Integer id); void downloadFile(Integer id);
} }
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment