Commit 65288165 authored by 王蔡翾's avatar 王蔡翾
Browse files

出勤管理,请假管理,实验室管理

parent 903ab81c
package com.platform.business.model.vo;
import lombok.Data;
import java.math.BigDecimal;
@Data
public class AttendanceStudentStatisticsVO {
private String studentId;
private String studentName;
private String studentPhone;
private long requiredCount;
private long normalCount;
private long lateCount;
private long absentCount;
private long leaveCount;
private BigDecimal attendanceRate;
}
package com.platform.business.model.vo;
import lombok.Data;
import java.math.BigDecimal;
import java.util.List;
@Data
public class AttendanceSummaryVO {
private long requiredCount;
private long normalCount;
private long lateCount;
private long absentCount;
private long leaveCount;
private BigDecimal attendanceRate;
private List<AttendanceStudentStatisticsVO> studentStatistics;
private List<AttendanceCourseStatisticsVO> courseStatistics;
}
package com.platform.business.model.vo;
import com.fasterxml.jackson.annotation.JsonFormat;
import lombok.Data;
import java.util.Date;
import java.util.List;
@Data
public class LeaveApplicationVO {
private String id;
private String studentId;
private String studentName;
private String studentPhone;
private String leaveType;
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
private Date startTime;
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
private Date endTime;
private Long durationMinutes;
private String reason;
private String emergencyContactName;
private String emergencyContactPhone;
private String status;
private String approverId;
private String approverName;
private String approverPhone;
private String approverRole;
private String approvalOpinion;
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
private Date appliedAt;
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
private Date reviewedAt;
private List<LeaveSubjectVO> subjects;
private List<LeaveAttachmentVO> attachments;
}
package com.platform.business.model.vo;
import lombok.Data;
@Data
public class LeaveAttachmentVO {
private Integer fileId;
private String fileName;
}
package com.platform.business.model.vo;
import com.fasterxml.jackson.annotation.JsonFormat;
import lombok.Data;
import java.util.Date;
@Data
public class LeaveSubjectVO {
private Integer subjectId;
private String subjectName;
private Integer classId;
private String className;
private String teacherId;
private String teacherName;
private String teacherPhone;
@JsonFormat(pattern = "yyyy-MM-dd", timezone = "GMT+8")
private Date subjectDate;
private String timeFrame;
}
package com.platform.business.model.vo;
import com.platform.business.model.entity.TrainingRoomBookingLogEntity;
import lombok.Data;
import java.util.List;
/** 预约详情及操作时间线。 */
@Data
public class TrainingRoomBookingDetailVO {
/** 预约基本信息及关联实训室信息。 */
private TrainingRoomBookingVO booking;
/** 按操作时间升序排列的预约状态变更记录。 */
private List<TrainingRoomBookingLogEntity> operationLogs;
}
package com.platform.business.model.vo;
import lombok.Data;
/** 单个实训室的预约状态统计。 */
@Data
public class TrainingRoomBookingStatisticsVO {
/** 预约记录总数,包含已取消记录。 */
private Long totalCount;
/** 未开始的有效预约数。 */
private Long bookedCount;
/** 当前使用中的预约数。 */
private Long usingCount;
/** 已完成的预约数。 */
private Long doneCount;
/** 已取消的预约数。 */
private Long canceledCount;
}
package com.platform.business.model.vo;
import com.platform.business.model.entity.TrainingRoomBookingEntity;
import lombok.Data;
import lombok.EqualsAndHashCode;
/** 预约列表展示对象。 */
@Data
@EqualsAndHashCode(callSuper = true)
public class TrainingRoomBookingVO extends TrainingRoomBookingEntity {
/** 预约关联的实训室名称。 */
private String roomName;
/** 预约关联的实训室位置。 */
private String roomLocation;
/** 固定时段的可读文本,例如08:00 - 10:00。 */
private String slotLabel;
}
package com.platform.business.model.vo;
import lombok.Data;
/** 指定日期和时段下的机位可用情况。 */
@Data
public class TrainingRoomSeatVO {
/** 机位雪花ID。 */
private String id;
/** 实训室内的机位编号。 */
private Integer seatNo;
/** free、booked、using。 */
private String status;
/** 机位被占用时对应的有效预约ID,空闲时为空。 */
private String bookingId;
}
package com.platform.business.model.vo;
import lombok.Data;
/** 实训室KPI统计。 */
@Data
public class TrainingRoomStatisticsVO {
/** 实训室总数。 */
private Long totalRooms;
/** 运行中的实训室数量。 */
private Long runningRooms;
/** 已停用的实训室数量。 */
private Long disabledRooms;
/** 机位总数。 */
private Long totalSeats;
/** 当前时刻未被使用的机位数。 */
private Long freeSeats;
/** 当前存在使用中预约的实训室数量。 */
private Long usingRooms;
/** 当前所有机位均在使用的实训室数量。 */
private Long fullRooms;
/** 当前时刻之后的有效预约数。 */
private Long futureBookings;
}
package com.platform.business.model.vo;
import lombok.AllArgsConstructor;
import lombok.Data;
/** 固定预约时段返回对象。 */
@Data
@AllArgsConstructor
public class TrainingRoomTimeSlotVO {
/** 时段编码,取值范围为1至5。 */
private Integer code;
/** 时段名称。 */
private String label;
/** 时段开始时间,格式为HH:mm。 */
private String startTime;
/** 时段结束时间,格式为HH:mm。 */
private String endTime;
}
package com.platform.business.model.vo;
import com.platform.business.model.entity.TrainingRoomEntity;
import lombok.Data;
import lombok.EqualsAndHashCode;
/** 实训室卡片展示对象。 */
@Data
@EqualsAndHashCode(callSuper = true)
public class TrainingRoomVO extends TrainingRoomEntity {
/** 实训室管理员姓名。 */
private String managerName;
/** 实训室管理员手机号。 */
private String managerPhone;
/** 当前时刻正在使用的机位数。 */
private Integer currentUsingCount;
/** 未开始的有效预约数。 */
private Integer bookedCount;
/** 已完成的预约数。 */
private Integer doneCount;
/** 当前时刻的空闲机位数。 */
private Integer freeSeatCount;
/** 当前时刻之后的有效预约数。 */
private Integer futureBookingCount;
/** 当前时刻动态状态:free、busy、full。 */
private String availabilityStatus;
}
package com.platform.business.config;
import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;
import java.util.ArrayList;
import java.util.List;
@Data
@Component
@ConfigurationProperties(prefix = "attendance")
public class AttendanceProperties {
/** 计划开始后的验证码有效分钟数。 */
private int verificationCodeValidMinutes = 15;
/**
* 允许签到的IPv4网段,例如 192.168.10.0/24。为空时安全拒绝签到,等待部署时补充。
*/
private List<String> allowedIpCidrs = new ArrayList<>();
/** 只有网关已清洗转发头时才应开启。 */
private boolean trustForwardedHeaders = false;
}
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.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);
}
}
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