"src/git@gitlab.ruzhoukj.com:wujipeng/ops.git" did not exist on "bf9a50ed1db55a22d7e534d0305655d69289e728"
Commit cc90e7f5 authored by wujipeng's avatar wujipeng
Browse files

教师-教学管理-我的课程

parent 242c8fe0
package com.platform.business.model.dto;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
/** 教师批量点名时提交的单名学员结果。 */
@Data
public class AttendanceBatchRecordDTO {
@ApiModelProperty(value = "学员用户ID", required = true)
private String studentId;
/**
* 教师只允许提交正常、迟到或缺勤。
* 已审批请假由服务端从数据库识别,前端不提交也不能覆盖。
*/
@ApiModelProperty(value = "NORMAL/LATE/ABSENT", required = true)
private String status;
}
package com.platform.business.model.dto;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import java.util.List;
/** 教师课堂点名弹窗的整班提交请求。 */
@Data
public class AttendanceBatchSubmitDTO {
@ApiModelProperty(value = "除已审批请假外的全部学员点名结果", required = true)
private List<AttendanceBatchRecordDTO> records;
}
......@@ -5,6 +5,8 @@ import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
import com.fasterxml.jackson.annotation.JsonIgnore;
import java.math.BigDecimal;
import java.util.List;
@Data
......@@ -19,6 +21,40 @@ public class ClassSubjectVO extends ClassSubjectEntity {
private String status;
/**
* 当前课程班级的有效学员数。
*
* <p>历史字段 {@code classNum} 在不同旧接口中曾表示课程数,语义不稳定;新页面使用
* 独立字段避免前端误解,同时保留原字段保证旧调用能够继续反序列化。</p>
*/
@ApiModelProperty("课程所属班级的学员数")
private Integer studentCount;
@ApiModelProperty("单节课程出勤汇总")
private TeacherCourseAttendanceVO attendance;
/*
* 以下字段只用于接收 MyBatis 聚合查询结果。服务层会把它们组装进 attendance,
* 因此使用 JsonIgnore,避免响应中同时出现扁平字段和嵌套字段两套重复数据。
*/
@JsonIgnore
private Long attendanceRecordCount;
@JsonIgnore
private Long normalCount;
@JsonIgnore
private Long lateCount;
@JsonIgnore
private Long absentCount;
@JsonIgnore
private Long leaveCount;
@JsonIgnore
private BigDecimal attendanceRate;
private List<ClassSubjectVO> data;
@ApiModelProperty(value = "课程数")
......
package com.platform.business.model.vo;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import java.math.BigDecimal;
/**
* 教师“我的课程”页面使用的单节课程出勤汇总。
*
* <p>该对象只描述当前班级成员在一节排课中的最终状态分布。请假仍计入应到人数,
* 但不计入实际到课人数,因此出勤率统一按
* {@code (normalCount + lateCount) / requiredCount * 100} 计算。</p>
*/
@Data
public class TeacherCourseAttendanceVO {
@ApiModelProperty("应到人数;等于当前课程班级的有效学员数")
private long requiredCount;
@ApiModelProperty("正常到课人数")
private long normalCount;
@ApiModelProperty("迟到人数")
private long lateCount;
@ApiModelProperty("缺勤人数")
private long absentCount;
@ApiModelProperty("已审批请假人数")
private long leaveCount;
@ApiModelProperty("出勤率百分比,保留两位小数")
private BigDecimal attendanceRate;
}
......@@ -3,6 +3,7 @@ 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.AttendanceBatchSubmitDTO;
import com.platform.business.model.dto.AttendanceQueryDTO;
import com.platform.business.model.dto.AttendanceStatusUpdateDTO;
import com.platform.business.model.entity.UserEntity;
......@@ -54,21 +55,31 @@ public class AttendanceController extends BaseController {
@ApiOperation("教师端-开始上课并获取本课次唯一验证码")
@PostMapping("/teacher/course/{subjectId}/start")
public Result<AttendanceSessionVO> startClass(@PathVariable Integer subjectId, HttpServletRequest request) {
return Result.data(attendanceService.startClass(subjectId, currentUser(request).getId()));
return Result.data(attendanceService.startClass(subjectId, currentTeacher(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()));
return Result.data(attendanceService.teacherRoster(subjectId, currentTeacher(request).getId()));
}
@ApiOperation("教师端-事务化提交整班点名结果")
@PutMapping("/teacher/course/{subjectId}/roster")
public Result<List<AttendanceRecordVO>> submitTeacherRoster(
@PathVariable Integer subjectId,
@RequestBody AttendanceBatchSubmitDTO body,
HttpServletRequest request) {
return Result.data(attendanceService.submitTeacherRoster(
subjectId, body, currentTeacher(request).getId()));
}
@ApiOperation("教师端-手动调整学员为正常、迟到或缺勤")
@PutMapping("/teacher/status")
public Result<AttendanceRecordVO> updateStatus(@RequestBody AttendanceStatusUpdateDTO body,
HttpServletRequest request) {
return Result.data(attendanceService.updateStatus(body, currentUser(request).getId()));
return Result.data(attendanceService.updateStatus(body, currentTeacher(request).getId()));
}
@ApiOperation("学员端-签到")
......@@ -119,6 +130,18 @@ public class AttendanceController extends BaseController {
}
}
/** 教师端路由除课程归属校验外还必须具备教师角色,避免普通学员探测接口。 */
private UserEntity currentTeacher(HttpServletRequest request) {
UserEntity user = currentUser(request);
List<SysPhoneRoleEntity> roles = sysPhoneRoleService.queryByPhone(user.getPhoneNumber());
boolean teacher = roles != null && roles.stream()
.anyMatch(role -> "教师".equals(role.getRoleName()));
if (!teacher) {
throw new BusinessException("只有教师可以访问教师端接口");
}
return user;
}
/** 管理端未传日期时默认查询当月1日至当前时间。 */
private void applyDefaultDateRange(AttendanceQueryDTO query) {
if (query.getStartDate() != null || query.getEndDate() != null) {
......
......@@ -6,6 +6,8 @@ import com.platform.business.model.dto.ClassSubjectDTO;
import com.platform.business.model.vo.CalendarVO;
import com.platform.business.model.vo.ClassSubjectVO;
import com.platform.business.model.vo.ClassVO;
import com.platform.business.model.entity.UserEntity;
import com.platform.business.service.AuthenticatedUserService;
import com.platform.business.service.ClassService;
import com.platform.controller.BaseController;
import com.platform.model.resp.Result;
......@@ -15,6 +17,7 @@ import io.swagger.annotations.ApiOperation;
import org.springframework.web.bind.annotation.*;
import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import java.util.List;
import java.util.Map;
......@@ -25,6 +28,9 @@ public class ClassController extends BaseController {
@Resource
private ClassService classService;
@Resource
private AuthenticatedUserService authenticatedUserService;
@PostMapping("/page")
public TableDataInfo page(@RequestBody ClassDTO classDTO) {
startPage(classDTO.getPageNum(), classDTO.getPageSize());
......@@ -66,14 +72,24 @@ public class ClassController extends BaseController {
@ApiOperation("教师端-教学管理-我的课程-日历")
@PostMapping("/schedule/teacher")
public Result<List<ClassVO>> scheduleTeacher(@RequestBody ClassDTO classDTO) {
return Result.data(classService.scheduleTeacher(classDTO));
public Result<List<ClassVO>> scheduleTeacher(@RequestBody(required = false) ClassDTO classDTO,
HttpServletRequest request) {
ClassDTO safeQuery = classDTO == null ? new ClassDTO() : classDTO;
return Result.data(classService.scheduleTeacher(safeQuery, currentTeacher(request).getId()));
}
@ApiOperation("教师端-教学管理-我的课程-详情")
@PostMapping("/schedule/teacher/detail")
public Result<ClassSubjectVO> scheduleTeacherDetail(@RequestBody ClassSubjectDTO classSubjectDTO) {
return Result.data(classService.scheduleTeacherDetail(classSubjectDTO));
public Result<ClassSubjectVO> scheduleTeacherDetail(@RequestBody ClassSubjectDTO classSubjectDTO,
HttpServletRequest request) {
return Result.data(classService.scheduleTeacherDetail(
classSubjectDTO, currentTeacher(request).getId()));
}
@ApiOperation("教师端-教学管理-我的课程-今日课程")
@GetMapping("/today/course/teacher")
public Result<List<ClassSubjectVO>> todayTeacherCourse(HttpServletRequest request) {
return Result.data(classService.todayTeacherCourse(currentTeacher(request).getId()));
}
@ApiOperation("班级列表")
......@@ -96,7 +112,21 @@ public class ClassController extends BaseController {
@ApiOperation("教师端-教学管理-我的课程-汇总")
@PostMapping("/teacher/course/summary")
public Result<Map<String, Integer>> teacherCourseSummary(@RequestBody ClassDTO classDTO) {
return Result.data(classService.teacherCourseSummary(classDTO));
public Result<Map<String, Integer>> teacherCourseSummary(
@RequestBody(required = false) ClassDTO classDTO, HttpServletRequest request) {
ClassDTO safeQuery = classDTO == null ? new ClassDTO() : classDTO;
return Result.data(classService.teacherCourseSummary(
safeQuery, currentTeacher(request).getId()));
}
/**
* 统一解析并校验教师身份。
*
* <p>教师ID绝不从请求体读取,避免调用方伪造userId或teacherId查询其他教师数据。</p>
*/
private UserEntity currentTeacher(HttpServletRequest request) {
UserEntity teacher = authenticatedUserService.current(request);
authenticatedUserService.requireTeacher(teacher);
return teacher;
}
}
package com.platform.business.service;
import com.platform.business.model.dto.AttendanceCheckInDTO;
import com.platform.business.model.dto.AttendanceBatchSubmitDTO;
import com.platform.business.model.dto.AttendanceQueryDTO;
import com.platform.business.model.dto.AttendanceStatusUpdateDTO;
import com.platform.business.model.vo.AttendanceRecordVO;
......@@ -30,6 +31,14 @@ public interface AttendanceService {
/** 查询本人授课课程的完整学员点名册。 */
List<AttendanceRecordVO> teacherRoster(Integer subjectId, String teacherId);
/**
* 教师一次性提交整班点名结果。
* 已审批请假由服务端保留,提交列表只包含NORMAL、LATE或ABSENT。
*/
List<AttendanceRecordVO> submitTeacherRoster(Integer subjectId,
AttendanceBatchSubmitDTO request,
String teacherId);
/** 按条件查询出勤记录。 */
List<AttendanceRecordVO> queryRecords(AttendanceQueryDTO query);
......@@ -38,4 +47,7 @@ public interface AttendanceService {
/** 将日期范围内已经结束且尚无出勤记录的学员补记为缺勤。 */
void finalizeEndedSubjects(Date startDate, Date endDate);
/** 仅补齐指定教师在日期范围内已经结束的课程,供“我的课程”页面使用。 */
void finalizeEndedSubjects(Date startDate, Date endDate, String teacherId);
}
......@@ -25,9 +25,14 @@ public interface ClassService extends IService<ClassEntity> {
ClassSubjectVO scheduleDetail(ClassSubjectDTO classSubjectDTO);
List<ClassVO> scheduleTeacher(ClassDTO classDTO);
/** 查询当前登录教师在日期范围内的课程日历。teacherId只能来自JWT。 */
List<ClassVO> scheduleTeacher(ClassDTO classDTO, String teacherId);
ClassSubjectVO scheduleTeacherDetail(ClassSubjectDTO classSubjectDTO);
/** 查询当前登录教师某一天的课程详情。 */
ClassSubjectVO scheduleTeacherDetail(ClassSubjectDTO classSubjectDTO, String teacherId);
/** 查询当前登录教师今天的全部课程。 */
List<ClassSubjectVO> todayTeacherCourse(String teacherId);
List<CalendarVO> todayCourse(String userId);
......@@ -35,7 +40,8 @@ public interface ClassService extends IService<ClassEntity> {
Map<String, Integer> studentCourseSummary(ClassDTO classDTO);
Map<String, Integer> teacherCourseSummary(ClassDTO classDTO);
/** 计算当前登录教师所选月份的页面KPI。 */
Map<String, Integer> teacherCourseSummary(ClassDTO classDTO, String teacherId);
......
......@@ -7,6 +7,8 @@ import com.platform.business.constant.AttendanceConstants;
import com.platform.business.mapper.ClassSubjectAttendanceMapper;
import com.platform.business.mapper.ClassSubjectAttendanceSessionMapper;
import com.platform.business.model.dto.AttendanceCheckInDTO;
import com.platform.business.model.dto.AttendanceBatchRecordDTO;
import com.platform.business.model.dto.AttendanceBatchSubmitDTO;
import com.platform.business.model.dto.AttendanceQueryDTO;
import com.platform.business.model.dto.AttendanceStatusUpdateDTO;
import com.platform.business.model.entity.ClassEntity;
......@@ -41,8 +43,10 @@ import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.HashSet;
import java.util.HashMap;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Set;
/** 出勤管理核心实现,所有时间判断均以课程计划开始、结束时间为基准。 */
......@@ -257,6 +261,95 @@ public class AttendanceServiceImpl implements AttendanceService {
return attendanceMapper.queryTeacherRoster(subjectId);
}
@Override
@Transactional
public List<AttendanceRecordVO> submitTeacherRoster(Integer subjectId,
AttendanceBatchSubmitDTO request,
String teacherId) {
ClassSubjectEntity subject = requireSubject(subjectId);
requireTeacher(subject, teacherId);
ClassSubjectTimeUtils.TimeWindow window = ClassSubjectTimeUtils.resolve(subject);
Date now = new Date();
if (now.before(window.getStart())) {
throw new BusinessException("课程尚未开始,不能提交点名结果");
}
if (request == null || request.getRecords() == null) {
throw new BusinessException("点名结果不能为空");
}
List<ClassStudentEntity> students = classStudentService.list(
new LambdaQueryWrapper<ClassStudentEntity>()
.eq(ClassStudentEntity::getClassId, subject.getClassId()));
Set<String> classStudentIds = new HashSet<>();
for (ClassStudentEntity student : students) {
if (!isBlank(student.getUserId())) {
classStudentIds.add(student.getUserId());
}
}
// 已审批请假不要求前端提交,且后续SQL会再次用CASE保护并发产生的LEAVE记录。
List<ClassSubjectAttendanceEntity> existingRecords = attendanceRecordService.list(
new LambdaQueryWrapper<ClassSubjectAttendanceEntity>()
.eq(ClassSubjectAttendanceEntity::getSubjectId, subjectId));
Set<String> approvedLeaveIds = new HashSet<>();
for (ClassSubjectAttendanceEntity existing : existingRecords) {
if (AttendanceConstants.STATUS_LEAVE.equals(existing.getStatus())
&& classStudentIds.contains(existing.getUserId())) {
approvedLeaveIds.add(existing.getUserId());
}
}
Map<String, String> submittedStatuses = new HashMap<>();
for (AttendanceBatchRecordDTO item : request.getRecords()) {
if (item == null || isBlank(item.getStudentId())) {
throw new BusinessException("点名结果中的学员ID不能为空");
}
String studentId = item.getStudentId().trim();
if (!classStudentIds.contains(studentId)) {
throw new BusinessException("学员不属于当前课程班级:" + studentId);
}
if (approvedLeaveIds.contains(studentId)) {
throw new BusinessException("已审批请假学员无需提交点名状态:" + studentId);
}
String status = item.getStatus() == null
? null : item.getStatus().trim().toUpperCase(Locale.ROOT);
if (!AttendanceConstants.isTeacherAdjustableStatus(status)) {
throw new BusinessException("教师只能提交 NORMAL、LATE 或 ABSENT");
}
if (submittedStatuses.put(studentId, status) != null) {
throw new BusinessException("点名结果中存在重复学员:" + studentId);
}
}
Set<String> requiredIds = new HashSet<>(classStudentIds);
requiredIds.removeAll(approvedLeaveIds);
if (!submittedStatuses.keySet().equals(requiredIds)) {
Set<String> missing = new HashSet<>(requiredIds);
missing.removeAll(submittedStatuses.keySet());
throw new BusinessException("点名结果不完整,仍有" + missing.size() + "名学员未标记");
}
// 单个事务内逐条使用数据库UPSERT。任一校验或写入异常都会回滚整次点名,避免半班数据。
for (Map.Entry<String, String> entry : submittedStatuses.entrySet()) {
ClassSubjectAttendanceEntity record = new ClassSubjectAttendanceEntity();
record.setId(IdWorker.getIdStr());
record.setSubjectId(subjectId);
record.setUserId(entry.getKey());
record.setStatus(entry.getValue());
record.setCheckInMethod(AttendanceConstants.METHOD_TEACHER);
record.setTeacherConfirmed(true);
record.setConfirmedBy(teacherId);
record.setConfirmedAt(now);
record.setCreatedTime(now);
record.setUpdateTime(now);
if (!AttendanceConstants.STATUS_ABSENT.equals(entry.getValue())) {
record.setCheckInTime(now);
}
attendanceMapper.upsertTeacherStatus(record);
}
return attendanceMapper.queryTeacherRoster(subjectId);
}
@Override
public List<AttendanceRecordVO> queryRecords(AttendanceQueryDTO query) {
AttendanceQueryDTO safeQuery = prepareQuery(query);
......@@ -283,11 +376,30 @@ public class AttendanceServiceImpl implements AttendanceService {
@Override
@Transactional
public void finalizeEndedSubjects(Date startDate, Date endDate) {
finalizeEndedSubjectsInternal(startDate, endDate, null);
}
@Override
@Transactional
public void finalizeEndedSubjects(Date startDate, Date endDate, String teacherId) {
if (isBlank(teacherId)) {
throw new BusinessException("无法获取当前教师身份");
}
finalizeEndedSubjectsInternal(startDate, endDate, teacherId);
}
/**
* 统一执行课程结束归档。teacherId为空时用于管理端全量统计,有值时仅处理当前教师课程。
*/
private void finalizeEndedSubjectsInternal(Date startDate, Date endDate, String teacherId) {
Date[] range = normalizeRange(startDate, endDate);
List<ClassSubjectEntity> subjects = classSubjectService.list(
new LambdaQueryWrapper<ClassSubjectEntity>()
.ge(ClassSubjectEntity::getDate, range[0])
.le(ClassSubjectEntity::getDate, range[1]));
LambdaQueryWrapper<ClassSubjectEntity> wrapper = new LambdaQueryWrapper<ClassSubjectEntity>()
.ge(ClassSubjectEntity::getDate, range[0])
.le(ClassSubjectEntity::getDate, range[1]);
if (!isBlank(teacherId)) {
wrapper.eq(ClassSubjectEntity::getTeacherId, teacherId);
}
List<ClassSubjectEntity> subjects = classSubjectService.list(wrapper);
Date now = new Date();
for (ClassSubjectEntity subject : subjects) {
try {
......
......@@ -21,6 +21,8 @@ import org.springframework.stereotype.Service;
import org.springframework.util.ObjectUtils;
import javax.annotation.Resource;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;
......@@ -38,6 +40,8 @@ public class ClassServiceImpl extends ServiceImpl<ClassMapper, ClassEntity> impl
private ExamStudentService examStudentService;
@Resource
private ClassSubjectAttendanceService classSubjectAttendanceService;
@Resource
private AttendanceService attendanceService;
@Override
public List<ClassVO> queryList(ClassDTO classDTO) {
......@@ -226,54 +230,60 @@ public class ClassServiceImpl extends ServiceImpl<ClassMapper, ClassEntity> impl
}
@Override
public List<ClassVO> scheduleTeacher(ClassDTO classDTO) {
//查询考试信息
List<ExamStudentVO> examStudentList = examStudentService.queryOneselfTeacher(classDTO.getUserId());
//查询课程信息
List<ClassSubjectVO> classSubjectList = classSubjectService.queryOneselfTeacher(classDTO.getUserId());
List<ClassVO> result = Lists.newArrayList();
List<Date> dateList = getDatesBetweenTwoDate(classDTO.getStartDate(), classDTO.getEndDate());
for (Date date : dateList) {
ClassVO classVO = new ClassVO();
List<ClassSubjectVO> classSubjectChildList = Lists.newArrayList();
for (ClassSubjectVO classSubjectVO : classSubjectList) {
if (classSubjectVO.getDate().equals(date)) {
classSubjectChildList.add(classSubjectVO);
}
}
List<ExamStudentVO> examStudentChildList = Lists.newArrayList();
for (ExamStudentVO examStudentVO : examStudentList) {
if (isSameDayWithFormat(examStudentVO.getExamTime(), date)) {
examStudentChildList.add(examStudentVO);
}
}
classVO.setClassSubjectList(classSubjectChildList);
classVO.setExamStudentList(examStudentChildList);
classVO.setDate(date);
result.add(classVO);
public List<ClassVO> scheduleTeacher(ClassDTO classDTO, String teacherId) {
Date[] range = normalizeTeacherCourseRange(classDTO);
// 查询页面前先补齐已经结束课程的缺勤记录,确保日历状态和KPI使用同一套最终数据。
attendanceService.finalizeEndedSubjects(range[0], range[1], teacherId);
List<ClassSubjectVO> courses = classSubjectService.queryTeacherCourse(
teacherId, range[0], range[1]);
enrichTeacherCourses(courses, new Date());
// 日历接口保留旧版“每天一个ClassVO”的响应结构,即使当天无课也返回空列表。
Map<String, List<ClassSubjectVO>> coursesByDay = new HashMap<>();
for (ClassSubjectVO course : courses) {
String key = formatDay(course.getDate());
coursesByDay.computeIfAbsent(key, ignored -> new ArrayList<>()).add(course);
}
List<ClassVO> result = new ArrayList<>();
for (Date date : getDatesBetweenTwoDate(range[0], range[1])) {
ClassVO day = new ClassVO();
day.setDate(date);
day.setClassSubjectList(coursesByDay.getOrDefault(
formatDay(date), Collections.emptyList()));
result.add(day);
}
return result;
}
@Override
public ClassSubjectVO scheduleTeacherDetail(ClassSubjectDTO classSubjectDTO) {
Date now = new Date();
ClassSubjectVO result = new ClassSubjectVO();
List<ClassSubjectVO> data = classSubjectService.queryListByUserIdAndDateTeacher(classSubjectDTO);
for (ClassSubjectVO classSubjectVO : data) {
if(now.before(classSubjectVO.getDate())){
classSubjectVO.setStatus("未开始");
} else if (now.after(classSubjectVO.getDate())) {
classSubjectVO.setStatus("已结束");
} else {
classSubjectVO.setStatus("进行中");
}
public ClassSubjectVO scheduleTeacherDetail(ClassSubjectDTO classSubjectDTO, String teacherId) {
if (classSubjectDTO == null) {
throw new BusinessException("查询日期不能为空");
}
Date date = parseStrictDay(classSubjectDTO.getDate());
classSubjectDTO.setTeacherId(teacherId);
// userId同样属于不可信历史字段,显式覆盖可以防止后续维护时误用客户端值。
classSubjectDTO.setUserId(teacherId);
attendanceService.finalizeEndedSubjects(date, endOfDay(date), teacherId);
List<ClassSubjectVO> data = classSubjectService.queryListByUserIdAndDateTeacher(classSubjectDTO);
enrichTeacherCourses(data, new Date());
ClassSubjectVO result = new ClassSubjectVO();
result.setData(data);
result.setSubjectNum(data.size());
return result;
}
@Override
public List<ClassSubjectVO> todayTeacherCourse(String teacherId) {
Date today = startOfDay(new Date());
attendanceService.finalizeEndedSubjects(today, endOfDay(today), teacherId);
List<ClassSubjectVO> courses = classSubjectService.queryTeacherCourse(
teacherId, today, endOfDay(today));
enrichTeacherCourses(courses, new Date());
return courses;
}
@Override
public List<CalendarVO> todayCourse(String userId) {
//获取学生的班级id
......@@ -356,25 +366,146 @@ public class ClassServiceImpl extends ServiceImpl<ClassMapper, ClassEntity> impl
}
@Override
public Map<String, Integer> teacherCourseSummary(ClassDTO classDTO) {
HashMap<String, Integer> result = new HashMap<>();
Date date = new Date();
//查询课程信息
List<ClassSubjectVO> classSubjectList = classSubjectService.queryTeacherCourse(classDTO.getUserId(), classDTO.getStartDate(), classDTO.getEndDate());
//本月课时
result.put("本月课时", classSubjectList.size());
//已完成课程
public Map<String, Integer> teacherCourseSummary(ClassDTO classDTO, String teacherId) {
Date[] range = normalizeTeacherCourseRange(classDTO);
attendanceService.finalizeEndedSubjects(range[0], range[1], teacherId);
List<ClassSubjectVO> courses = classSubjectService.queryTeacherCourse(
teacherId, range[0], range[1]);
enrichTeacherCourses(courses, new Date());
int completed = 0;
for (ClassSubjectVO subject : classSubjectList) {
if (subject.getDate().before(date)) completed++;
long completedRequired = 0L;
long completedPresent = 0L;
for (ClassSubjectVO course : courses) {
if (!"DONE".equals(course.getStatus())) {
continue;
}
completed++;
TeacherCourseAttendanceVO attendance = course.getAttendance();
completedRequired += attendance.getRequiredCount();
completedPresent += attendance.getNormalCount() + attendance.getLateCount();
}
int rate = completedRequired == 0L ? 0
: (int) Math.round(completedPresent * 100.0 / completedRequired);
// 使用LinkedHashMap固定文档和JSON展示顺序;“本月课时”作为旧键继续返回。
Map<String, Integer> result = new LinkedHashMap<>();
result.put("本月课时", courses.size());
result.put("本月课程", courses.size());
result.put("已完成课程", completed);
//待完成课程
result.put("待完成课程", classSubjectList.size() - completed);
//平均出勤率
result.put("待完成课程", courses.size() - completed);
result.put("平均出勤率", rate);
return result;
}
/**
* 为Mapper返回的聚合字段补充稳定的页面状态和嵌套出勤对象。
* 状态判断必须先判断课程是否尚未开始,避免“全班提前请假”被误判为已完成课程。
*/
private void enrichTeacherCourses(List<ClassSubjectVO> courses, Date now) {
for (ClassSubjectVO course : courses) {
int studentCount = course.getStudentCount() == null ? 0 : course.getStudentCount();
long recordCount = safeLong(course.getAttendanceRecordCount());
long normal = safeLong(course.getNormalCount());
long late = safeLong(course.getLateCount());
long absent = safeLong(course.getAbsentCount());
long leave = safeLong(course.getLeaveCount());
TeacherCourseAttendanceVO attendance = new TeacherCourseAttendanceVO();
attendance.setRequiredCount(studentCount);
attendance.setNormalCount(normal);
attendance.setLateCount(late);
attendance.setAbsentCount(absent);
attendance.setLeaveCount(leave);
attendance.setAttendanceRate(studentCount == 0
? BigDecimal.ZERO
: BigDecimal.valueOf((normal + late) * 100.0 / studentCount)
.setScale(2, RoundingMode.HALF_UP));
course.setAttendance(attendance);
ClassSubjectTimeUtils.TimeWindow window = ClassSubjectTimeUtils.resolve(course);
if (now.before(window.getStart())) {
course.setStatus("UPCOMING");
} else if (studentCount > 0 && recordCount >= studentCount) {
course.setStatus("DONE");
} else {
course.setStatus("PENDING");
}
}
}
/** 教师课程范围为空时默认当前自然月,并拒绝反向或超长范围。 */
private Date[] normalizeTeacherCourseRange(ClassDTO query) {
Date start = query == null ? null : query.getStartDate();
Date end = query == null ? null : query.getEndDate();
if (start == null || end == null) {
Calendar calendar = Calendar.getInstance();
calendar.set(Calendar.DAY_OF_MONTH, 1);
start = startOfDay(calendar.getTime());
calendar.set(Calendar.DAY_OF_MONTH, calendar.getActualMaximum(Calendar.DAY_OF_MONTH));
end = endOfDay(calendar.getTime());
} else {
start = startOfDay(start);
end = endOfDay(end);
}
if (start.after(end)) {
throw new BusinessException("开始日期不能晚于结束日期");
}
long span = end.getTime() - start.getTime();
if (span > 62L * 24L * 60L * 60L * 1000L) {
throw new BusinessException("课程查询时间范围不能超过62天");
}
if (query != null) {
query.setStartDate(start);
query.setEndDate(end);
// 不在服务层使用客户端传入的userId,避免直接调用服务时出现越权入口。
query.setUserId(null);
}
return new Date[]{start, end};
}
/** 严格解析yyyy-MM-dd,拒绝自动进位日期和附加时间文本。 */
private Date parseStrictDay(String value) {
if (value == null || !value.matches("\\d{4}-\\d{2}-\\d{2}")) {
throw new BusinessException("查询日期格式必须为yyyy-MM-dd");
}
SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
format.setLenient(false);
try {
return format.parse(value);
} catch (ParseException e) {
throw new BusinessException("查询日期不是有效日期");
}
}
private Date startOfDay(Date date) {
Calendar calendar = Calendar.getInstance();
calendar.setTime(date);
calendar.set(Calendar.HOUR_OF_DAY, 0);
calendar.set(Calendar.MINUTE, 0);
calendar.set(Calendar.SECOND, 0);
calendar.set(Calendar.MILLISECOND, 0);
return calendar.getTime();
}
private Date endOfDay(Date date) {
Calendar calendar = Calendar.getInstance();
calendar.setTime(date);
calendar.set(Calendar.HOUR_OF_DAY, 23);
calendar.set(Calendar.MINUTE, 59);
calendar.set(Calendar.SECOND, 59);
calendar.set(Calendar.MILLISECOND, 999);
return calendar.getTime();
}
private String formatDay(Date date) {
return new SimpleDateFormat("yyyy-MM-dd").format(date);
}
private long safeLong(Long value) {
return value == null ? 0L : value;
}
private static String displayAttendanceStatus(String status) {
if (AttendanceConstants.STATUS_NORMAL.equals(status)) return "已签到";
if (AttendanceConstants.STATUS_LATE.equals(status)) return "迟到";
......
......@@ -37,10 +37,10 @@
on duplicate key update
check_in_time = case when class_subject_attendance.status = 'LEAVE'
then class_subject_attendance.check_in_time
else coalesce(class_subject_attendance.check_in_time, values(check_in_time)) end,
else values(check_in_time) end,
check_in_method = case when class_subject_attendance.status = 'LEAVE'
then class_subject_attendance.check_in_method
else coalesce(class_subject_attendance.check_in_method, values(check_in_method)) end,
else values(check_in_method) end,
teacher_confirmed = case when class_subject_attendance.status = 'LEAVE'
then class_subject_attendance.teacher_confirmed else values(teacher_confirmed) end,
confirmed_by = case when class_subject_attendance.status = 'LEAVE'
......
......@@ -168,13 +168,34 @@
cs.remark,
cs.location,
cs.type,
c.name as className
c.name as className,
count(distinct member.user_id) as studentCount,
count(attendance.id) as attendanceRecordCount,
sum(case when attendance.status = 'NORMAL' then 1 else 0 end) as normalCount,
sum(case when attendance.status = 'LATE' then 1 else 0 end) as lateCount,
sum(case when attendance.status = 'ABSENT' then 1 else 0 end) as absentCount,
sum(case when attendance.status = 'LEAVE' then 1 else 0 end) as leaveCount,
case when count(distinct member.user_id) = 0 then 0
else round(
sum(case when attendance.status in ('NORMAL', 'LATE') then 1 else 0 end)
* 100.0 / count(distinct member.user_id), 2)
end as attendanceRate
from
class_subject cs
left join
class c
on
cs.class_id = c.id
left join
class_student member
on
member.class_id = cs.class_id
left join
class_subject_attendance attendance
on
attendance.subject_id = cs.id
and
attendance.user_id = member.user_id
where
cs.teacher_id = #{userId}
and
......@@ -183,24 +204,65 @@
#{startDate}
and
#{endDate}
group by
cs.id, cs.class_id, cs.subject_times, cs.date, cs.week, cs.time_frame,
cs.subject_hour, cs.subject_name, cs.teacher_id, cs.remark, cs.location,
cs.type, c.name
order by
cs.date asc, cs.time_frame asc, cs.id asc
</select>
<select id="queryListByUserIdAndDateTeacher" resultType="com.platform.business.model.vo.ClassSubjectVO">
select
cs.id,
cs.class_id,
cs.subject_times,
cs.date,
cs.week,
cs.time_frame,
cs.subject_hour,
cs.subject_name,
u.nick_name,
cs.teacher_id,
cs.remark,
cs.location,
cs.type,
cs.date
c.name as className,
count(distinct member.user_id) as studentCount,
count(attendance.id) as attendanceRecordCount,
sum(case when attendance.status = 'NORMAL' then 1 else 0 end) as normalCount,
sum(case when attendance.status = 'LATE' then 1 else 0 end) as lateCount,
sum(case when attendance.status = 'ABSENT' then 1 else 0 end) as absentCount,
sum(case when attendance.status = 'LEAVE' then 1 else 0 end) as leaveCount,
case when count(distinct member.user_id) = 0 then 0
else round(
sum(case when attendance.status in ('NORMAL', 'LATE') then 1 else 0 end)
* 100.0 / count(distinct member.user_id), 2)
end as attendanceRate
from
class_subject c
class_subject cs
left join
user u
class c
on
cs.teacher_id = u.id
cs.class_id = c.id
left join
class_student member
on
member.class_id = cs.class_id
left join
class_subject_attendance attendance
on
attendance.subject_id = cs.id
and
attendance.user_id = member.user_id
where
date = #{date}
cs.date = #{date}
and
cs.teacher_id = #{teacherId}
group by
cs.id, cs.class_id, cs.subject_times, cs.date, cs.week, cs.time_frame,
cs.subject_hour, cs.subject_name, cs.teacher_id, cs.remark, cs.location,
cs.type, c.name
order by
cs.time_frame asc, cs.id asc
</select>
<!--
......
-- 教师端“教学管理-我的课程”增量数据库脚本(MySQL 5.7+/8.0)。
--
-- 本功能不新增业务表或字段,只补齐教师日历和并发点名依赖的索引。
-- 唯一索引创建前会检查历史重复数据;发现重复时主动终止,不会自动删除任何业务记录。
delimiter $$
drop procedure if exists migrate_teacher_course$$
create procedure migrate_teacher_course()
begin
if not exists (
select 1 from information_schema.tables
where table_schema = database() and table_name = 'class_subject_attendance'
) or not exists (
select 1 from information_schema.tables
where table_schema = database() and table_name = 'class_subject_attendance_session'
) then
signal sqlstate '45000'
set message_text = '缺少出勤表,请先执行项目基础出勤模块数据库脚本';
end if;
-- 教师日历固定按教师和日期范围查询,课程ID用于稳定排序和回表。
if not exists (
select 1 from information_schema.statistics
where table_schema = database()
and table_name = 'class_subject'
and index_name = 'idx_subject_teacher_date'
) then
alter table class_subject
add index idx_subject_teacher_date (teacher_id, date, id);
end if;
-- 点名UPSERT依赖“一门课、一个学员只能有一条最终记录”。
if exists (
select 1
from class_subject_attendance
group by subject_id, user_id
having count(*) > 1
limit 1
) then
signal sqlstate '45000'
set message_text = 'class_subject_attendance存在重复课程学员记录,请先人工核对处理';
end if;
if not exists (
select 1
from (
select index_name,
group_concat(column_name order by seq_in_index separator ',') as indexed_columns
from information_schema.statistics
where table_schema = database()
and table_name = 'class_subject_attendance'
and non_unique = 0
group by index_name
) unique_indexes
where unique_indexes.indexed_columns = 'subject_id,user_id'
) then
alter table class_subject_attendance
add unique index uk_attendance_subject_user (subject_id, user_id);
end if;
-- 同一排课只能有一个签到会话和一份验证码,重复点击通过唯一索引实现幂等。
if exists (
select 1
from class_subject_attendance_session
group by subject_id
having count(*) > 1
limit 1
) then
signal sqlstate '45000'
set message_text = 'class_subject_attendance_session存在重复课程会话,请先人工核对处理';
end if;
if not exists (
select 1
from (
select index_name,
group_concat(column_name order by seq_in_index separator ',') as indexed_columns
from information_schema.statistics
where table_schema = database()
and table_name = 'class_subject_attendance_session'
and non_unique = 0
group by index_name
) unique_indexes
where unique_indexes.indexed_columns = 'subject_id'
) then
alter table class_subject_attendance_session
add unique index uk_attendance_session_subject (subject_id);
end if;
end$$
call migrate_teacher_course()$$
drop procedure if exists migrate_teacher_course$$
delimiter ;
-- 如迁移因重复数据终止,可先用以下只读SQL定位记录,确认业务归属后再人工处理:
select subject_id, user_id, count(*) as duplicate_count
from class_subject_attendance
group by subject_id, user_id
having count(*) > 1;
select subject_id, count(*) as duplicate_count
from class_subject_attendance_session
group by subject_id
having count(*) > 1;
# 教师端“教学管理-我的课程”接口
所有接口都从 `Authorization` 解析当前用户并校验“教师”角色。请求中的历史字段
`userId`、`teacherId` 不参与数据权限判断,教师只能查询和点名本人负责的排课。
## 1. 月历与统计
### `POST /class/schedule/teacher`
请求体可为空;为空时默认当前自然月。自定义日期范围最多 62 天:
```json
{"startDate":"2026-08-01","endDate":"2026-08-31","userId":"该值会被忽略"}
```
响应继续使用旧版按天分组结构。`classSubjectList` 中每门课程增加:
- `studentCount`:班级当前学员数;
- `status`:`UPCOMING` 未开始、`PENDING` 待完成点名、`DONE` 已完成点名;
- `attendance`:应到、正常、迟到、缺勤、请假和出勤率。
课程结束后查询页面会幂等补写尚无记录的学员为 `ABSENT`,随后再计算状态。
### `POST /class/schedule/teacher/detail`
```json
{"date":"2026-08-19","teacherId":"该值会被忽略"}
```
返回当天课程数量 `subjectNum` 和课程数组 `data`。日期必须严格使用 `yyyy-MM-dd`。
### `GET /class/today/course/teacher`
返回当前教师今天的全部排课,字段和月历中的课程对象一致。
### `POST /class/teacher/course/summary`
日期规则与月历接口相同,响应示例:
```json
{
"本月课时": 12,
"本月课程": 12,
"已完成课程": 7,
"待完成课程": 5,
"平均出勤率": 94
}
```
“本月课时”是旧客户端兼容键,与“本月课程”数值相同。平均出勤率只汇总已完成点名的
课程,按 `(正常 + 迟到) / 应到人数` 加权计算;请假计入应到但不计入到课。
## 2. 课堂点名
1. `POST /attendance/teacher/course/{subjectId}/start`:到达计划开始时间后开始上课并取得验证码;
2. `GET /attendance/teacher/course/{subjectId}/roster`:读取完整名册和当前状态;
3. `PUT /attendance/teacher/status`:调整单名学员为 `NORMAL`、`LATE` 或 `ABSENT`;
4. `PUT /attendance/teacher/course/{subjectId}/roster`:事务化提交整班点名。
批量提交示例:
```json
{
"records": [
{"studentId":"190000000000000001","status":"NORMAL"},
{"studentId":"190000000000000002","status":"LATE"},
{"studentId":"190000000000000003","status":"ABSENT"}
]
}
```
请求必须包含班级内除已审批请假外的全部学员,不能重复、漏标或提交其他班级学员。
`LEAVE` 只能由请假审批模块产生,教师点名接口只读展示且数据库写入层会防止并发覆盖。
批量提交任一校验或写入失败时整次事务回滚。
## 3. 数据库脚本
部署前执行 `sql/teacher_course.sql`。脚本可重复执行,仅确保教师日期索引、课程学员出勤唯一索引
和课程签到会话唯一索引;如果历史数据重复会明确报错并附带只读排查 SQL,不会自动删除数据。
package com.platform.business.controller;
import com.platform.business.model.dto.ClassDTO;
import com.platform.business.model.entity.UserEntity;
import com.platform.business.service.AuthenticatedUserService;
import com.platform.business.service.ClassService;
import com.platform.exception.BusinessException;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import org.springframework.mock.web.MockHttpServletRequest;
import org.springframework.test.util.ReflectionTestUtils;
import java.util.Collections;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.mockito.Mockito.doThrow;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
/** 教师“我的课程”控制器鉴权和可信身份传递测试。 */
@ExtendWith(MockitoExtension.class)
class TeacherCourseControllerTest {
@Mock
private ClassService classService;
@Mock
private AuthenticatedUserService authenticatedUserService;
private ClassController controller;
private MockHttpServletRequest request;
private UserEntity teacher;
@BeforeEach
void setUp() {
controller = new ClassController();
ReflectionTestUtils.setField(controller, "classService", classService);
ReflectionTestUtils.setField(controller, "authenticatedUserService", authenticatedUserService);
request = new MockHttpServletRequest();
teacher = new UserEntity();
teacher.setId("teacher-from-jwt");
when(authenticatedUserService.current(request)).thenReturn(teacher);
}
@Test
void scheduleShouldUseJwtTeacherInsteadOfForgedBodyUserId() {
ClassDTO query = new ClassDTO();
query.setUserId("forged-teacher");
when(classService.scheduleTeacher(query, "teacher-from-jwt"))
.thenReturn(Collections.emptyList());
controller.scheduleTeacher(query, request);
verify(authenticatedUserService).requireTeacher(teacher);
verify(classService).scheduleTeacher(query, "teacher-from-jwt");
}
@Test
void summaryShouldStopBeforeServiceWhenUserIsNotTeacher() {
doThrow(new BusinessException("只有教师可以访问教师端接口"))
.when(authenticatedUserService).requireTeacher(teacher);
assertThrows(BusinessException.class,
() -> controller.teacherCourseSummary(new ClassDTO(), request));
}
@Test
void todayCourseShouldRequireValidLoginBeforeCallingService() {
when(authenticatedUserService.current(request))
.thenThrow(new BusinessException("登录凭证无效或已过期"));
assertThrows(BusinessException.class, () -> controller.todayTeacherCourse(request));
}
}
package com.platform.business.mapper;
import com.platform.business.model.dto.ClassSubjectDTO;
import org.apache.ibatis.builder.xml.XMLMapperBuilder;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.mapping.BoundSql;
import org.apache.ibatis.session.Configuration;
import org.junit.jupiter.api.Test;
import java.io.InputStream;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertTrue;
/** 教师课程聚合SQL和点名请假保护SQL的启动前解析测试。 */
class TeacherCourseMapperXmlTest {
@Test
void mapperXmlShouldParseAndTeacherDetailShouldUseCorrectAlias() throws Exception {
Configuration configuration = new Configuration();
parse(configuration, "com/platform/business/mapper/ClassSubjectMapper.xml");
parse(configuration, "com/platform/business/mapper/ClassSubjectAttendanceMapper.xml");
ClassSubjectDTO query = new ClassSubjectDTO();
query.setDate("2026-08-19");
query.setTeacherId("teacher-1");
BoundSql detail = configuration.getMappedStatement(
"com.platform.business.mapper.ClassSubjectMapper.queryListByUserIdAndDateTeacher")
.getBoundSql(query);
String detailSql = compact(detail.getSql());
assertTrue(detailSql.contains("from class_subject cs"));
assertTrue(detailSql.contains("cs.teacher_id = ?"));
assertTrue(detailSql.contains("count(distinct member.user_id) as studentCount"));
assertFalse(detailSql.contains("from class_subject c left join class c"));
BoundSql upsert = configuration.getMappedStatement(
"com.platform.business.mapper.ClassSubjectAttendanceMapper.upsertTeacherStatus")
.getBoundSql(new Object());
String upsertSql = compact(upsert.getSql());
assertTrue(upsertSql.contains("class_subject_attendance.status = 'LEAVE'"));
assertTrue(upsertSql.contains("else values(status) end"));
}
private static void parse(Configuration configuration, String resource) throws Exception {
try (InputStream input = Resources.getResourceAsStream(resource)) {
XMLMapperBuilder builder = new XMLMapperBuilder(
input, configuration, resource, configuration.getSqlFragments());
builder.parse();
}
}
private static String compact(String sql) {
return sql.replaceAll("\\s+", " ").trim();
}
}
package com.platform.business.service.impl;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.platform.business.mapper.ClassSubjectAttendanceMapper;
import com.platform.business.model.dto.AttendanceBatchRecordDTO;
import com.platform.business.model.dto.AttendanceBatchSubmitDTO;
import com.platform.business.model.entity.ClassStudentEntity;
import com.platform.business.model.entity.ClassSubjectAttendanceEntity;
import com.platform.business.model.entity.ClassSubjectEntity;
import com.platform.business.model.vo.AttendanceRecordVO;
import com.platform.business.service.ClassStudentService;
import com.platform.business.service.ClassSubjectAttendanceService;
import com.platform.business.service.ClassSubjectService;
import com.platform.exception.BusinessException;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.ArgumentCaptor;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import org.springframework.test.util.ReflectionTestUtils;
import org.springframework.transaction.annotation.Transactional;
import java.util.Arrays;
import java.util.Calendar;
import java.util.Collections;
import java.util.Date;
import java.util.List;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
/** 整班点名的完整性、归属和请假保护测试。 */
@ExtendWith(MockitoExtension.class)
class AttendanceBatchSubmitServiceImplTest {
@Mock
private ClassSubjectService classSubjectService;
@Mock
private ClassStudentService classStudentService;
@Mock
private ClassSubjectAttendanceService attendanceRecordService;
@Mock
private ClassSubjectAttendanceMapper attendanceMapper;
private AttendanceServiceImpl service;
@BeforeEach
void setUp() {
service = new AttendanceServiceImpl();
ReflectionTestUtils.setField(service, "classSubjectService", classSubjectService);
ReflectionTestUtils.setField(service, "classStudentService", classStudentService);
ReflectionTestUtils.setField(service, "attendanceRecordService", attendanceRecordService);
ReflectionTestUtils.setField(service, "attendanceMapper", attendanceMapper);
}
@Test
void batchSubmitShouldSaveAllNonLeaveStudentsAndReturnFinalRoster() {
mockStartedSubject("teacher-1");
when(classStudentService.list(any(LambdaQueryWrapper.class)))
.thenReturn(Arrays.asList(student("student-1"), student("student-2")));
ClassSubjectAttendanceEntity leave = attendance("student-2", "LEAVE");
when(attendanceRecordService.list(any(LambdaQueryWrapper.class)))
.thenReturn(Collections.singletonList(leave));
AttendanceRecordVO saved = new AttendanceRecordVO();
saved.setStudentId("student-1");
when(attendanceMapper.queryTeacherRoster(10))
.thenReturn(Collections.singletonList(saved));
List<AttendanceRecordVO> result = service.submitTeacherRoster(
10, request(item("student-1", "normal")), "teacher-1");
ArgumentCaptor<ClassSubjectAttendanceEntity> captor =
ArgumentCaptor.forClass(ClassSubjectAttendanceEntity.class);
verify(attendanceMapper).upsertTeacherStatus(captor.capture());
assertEquals("NORMAL", captor.getValue().getStatus());
assertEquals("TEACHER", captor.getValue().getCheckInMethod());
assertEquals("student-1", result.get(0).getStudentId());
}
@Test
void batchSubmitShouldRejectMissingStudent() {
mockStartedSubject("teacher-1");
when(classStudentService.list(any(LambdaQueryWrapper.class)))
.thenReturn(Arrays.asList(student("student-1"), student("student-2")));
when(attendanceRecordService.list(any(LambdaQueryWrapper.class)))
.thenReturn(Collections.emptyList());
assertThrows(BusinessException.class, () -> service.submitTeacherRoster(
10, request(item("student-1", "NORMAL")), "teacher-1"));
verify(attendanceMapper, never()).upsertTeacherStatus(any());
}
@Test
void batchSubmitShouldRejectDuplicateAndCrossClassStudents() {
mockStartedSubject("teacher-1");
when(classStudentService.list(any(LambdaQueryWrapper.class)))
.thenReturn(Collections.singletonList(student("student-1")));
when(attendanceRecordService.list(any(LambdaQueryWrapper.class)))
.thenReturn(Collections.emptyList());
assertThrows(BusinessException.class, () -> service.submitTeacherRoster(
10, request(item("student-1", "NORMAL"), item("student-1", "LATE")),
"teacher-1"));
assertThrows(BusinessException.class, () -> service.submitTeacherRoster(
10, request(item("other-class-student", "NORMAL")), "teacher-1"));
}
@Test
void batchSubmitShouldRejectWrongTeacherAndCourseBeforeStart() {
mockStartedSubject("teacher-1");
assertThrows(BusinessException.class, () -> service.submitTeacherRoster(
10, request(), "teacher-2"));
ClassSubjectEntity future = subject("teacher-1");
future.setDate(addDays(new Date(), 1));
when(classSubjectService.getById(11)).thenReturn(future);
assertThrows(BusinessException.class, () -> service.submitTeacherRoster(
11, request(), "teacher-1"));
}
@Test
void batchSubmitShouldReturnConcurrentLeaveWithoutOverwritingIt() {
mockStartedSubject("teacher-1");
when(classStudentService.list(any(LambdaQueryWrapper.class)))
.thenReturn(Collections.singletonList(student("student-1")));
when(attendanceRecordService.list(any(LambdaQueryWrapper.class)))
.thenReturn(Collections.emptyList());
AttendanceRecordVO concurrentLeave = new AttendanceRecordVO();
concurrentLeave.setStudentId("student-1");
concurrentLeave.setStatus("LEAVE");
when(attendanceMapper.queryTeacherRoster(10))
.thenReturn(Collections.singletonList(concurrentLeave));
List<AttendanceRecordVO> result = service.submitTeacherRoster(
10, request(item("student-1", "NORMAL")), "teacher-1");
assertEquals("LEAVE", result.get(0).getStatus());
}
@Test
void batchSubmitMustBeTransactional() throws Exception {
Transactional annotation = AttendanceServiceImpl.class
.getMethod("submitTeacherRoster", Integer.class,
AttendanceBatchSubmitDTO.class, String.class)
.getAnnotation(Transactional.class);
assertNotNull(annotation);
}
private void mockStartedSubject(String teacherId) {
when(classSubjectService.getById(10)).thenReturn(subject(teacherId));
}
private static ClassSubjectEntity subject(String teacherId) {
ClassSubjectEntity subject = new ClassSubjectEntity();
subject.setId(10);
subject.setClassId(5);
subject.setTeacherId(teacherId);
subject.setDate(new Date());
subject.setTimeFrame("00:00-23:59");
return subject;
}
private static ClassStudentEntity student(String id) {
ClassStudentEntity student = new ClassStudentEntity();
student.setClassId(5);
student.setUserId(id);
return student;
}
private static ClassSubjectAttendanceEntity attendance(String studentId, String status) {
ClassSubjectAttendanceEntity record = new ClassSubjectAttendanceEntity();
record.setSubjectId(10);
record.setUserId(studentId);
record.setStatus(status);
return record;
}
private static AttendanceBatchRecordDTO item(String studentId, String status) {
AttendanceBatchRecordDTO item = new AttendanceBatchRecordDTO();
item.setStudentId(studentId);
item.setStatus(status);
return item;
}
private static AttendanceBatchSubmitDTO request(AttendanceBatchRecordDTO... records) {
AttendanceBatchSubmitDTO request = new AttendanceBatchSubmitDTO();
request.setRecords(Arrays.asList(records));
return request;
}
private static Date addDays(Date date, int days) {
Calendar calendar = Calendar.getInstance();
calendar.setTime(date);
calendar.add(Calendar.DAY_OF_MONTH, days);
return calendar.getTime();
}
}
package com.platform.business.service.impl;
import com.platform.business.model.dto.ClassDTO;
import com.platform.business.model.dto.ClassSubjectDTO;
import com.platform.business.model.vo.ClassSubjectVO;
import com.platform.business.model.vo.ClassVO;
import com.platform.business.service.AttendanceService;
import com.platform.business.service.ClassSubjectService;
import com.platform.exception.BusinessException;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.ArgumentCaptor;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import org.springframework.test.util.ReflectionTestUtils;
import java.util.Arrays;
import java.util.Calendar;
import java.util.Collections;
import java.util.Date;
import java.util.List;
import java.util.Map;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
/** 教师课程范围、状态和KPI统计测试。 */
@ExtendWith(MockitoExtension.class)
class TeacherCourseServiceImplTest {
@Mock
private ClassSubjectService classSubjectService;
@Mock
private AttendanceService attendanceService;
private ClassServiceImpl service;
@BeforeEach
void setUp() {
service = new ClassServiceImpl();
ReflectionTestUtils.setField(service, "classSubjectService", classSubjectService);
ReflectionTestUtils.setField(service, "attendanceService", attendanceService);
}
@Test
void emptyRangeShouldDefaultToCurrentNaturalMonth() {
when(classSubjectService.queryTeacherCourse(eq("teacher-1"), any(Date.class), any(Date.class)))
.thenReturn(Collections.emptyList());
List<ClassVO> result = service.scheduleTeacher(new ClassDTO(), "teacher-1");
ArgumentCaptor<Date> start = ArgumentCaptor.forClass(Date.class);
ArgumentCaptor<Date> end = ArgumentCaptor.forClass(Date.class);
verify(classSubjectService).queryTeacherCourse(eq("teacher-1"), start.capture(), end.capture());
Calendar startCalendar = Calendar.getInstance();
startCalendar.setTime(start.getValue());
Calendar endCalendar = Calendar.getInstance();
endCalendar.setTime(end.getValue());
assertEquals(1, startCalendar.get(Calendar.DAY_OF_MONTH));
assertEquals(startCalendar.getActualMaximum(Calendar.DAY_OF_MONTH), result.size());
assertEquals(startCalendar.getActualMaximum(Calendar.DAY_OF_MONTH),
endCalendar.get(Calendar.DAY_OF_MONTH));
}
@Test
void scheduleShouldDistinguishPendingAndUpcomingCourses() {
Date today = startOfDay(new Date());
Date tomorrow = addDays(today, 1);
ClassDTO query = range(today, tomorrow);
ClassSubjectVO pending = course(today, "00:00-23:59", 2, 1, 1, 0);
ClassSubjectVO upcoming = course(tomorrow, "08:00-09:00", 2, 0, 0, 0);
when(classSubjectService.queryTeacherCourse(eq("teacher-1"), any(), any()))
.thenReturn(Arrays.asList(pending, upcoming));
List<ClassVO> days = service.scheduleTeacher(query, "teacher-1");
assertEquals("PENDING", days.get(0).getClassSubjectList().get(0).getStatus());
assertEquals("UPCOMING", days.get(1).getClassSubjectList().get(0).getStatus());
assertEquals(2, pending.getAttendance().getRequiredCount());
}
@Test
void summaryShouldUseCompletedCoursesAndWeightedAttendanceRate() {
Date today = startOfDay(new Date());
Date tomorrow = addDays(today, 1);
ClassSubjectVO completed = course(today, "00:00-00:01", 2, 2, 1, 0);
ClassSubjectVO upcoming = course(tomorrow, "08:00-09:00", 3, 0, 0, 0);
when(classSubjectService.queryTeacherCourse(eq("teacher-1"), any(), any()))
.thenReturn(Arrays.asList(completed, upcoming));
Map<String, Integer> summary = service.teacherCourseSummary(
range(today, tomorrow), "teacher-1");
assertEquals(2, summary.get("本月课程"));
assertEquals(2, summary.get("本月课时"));
assertEquals(1, summary.get("已完成课程"));
assertEquals(1, summary.get("待完成课程"));
assertEquals(50, summary.get("平均出勤率"));
}
@Test
void summaryShouldReturnZeroRateWhenThereAreNoCompletedStudents() {
when(classSubjectService.queryTeacherCourse(eq("teacher-1"), any(), any()))
.thenReturn(Collections.emptyList());
Map<String, Integer> summary = service.teacherCourseSummary(new ClassDTO(), "teacher-1");
assertEquals(0, summary.get("平均出勤率"));
}
@Test
void detailShouldRejectInvalidCalendarDateBeforeQueryingMapper() {
ClassSubjectDTO query = new ClassSubjectDTO();
query.setDate("2026-02-30");
assertThrows(BusinessException.class,
() -> service.scheduleTeacherDetail(query, "teacher-1"));
verify(classSubjectService, never()).queryListByUserIdAndDateTeacher(any());
}
@Test
void rangeLongerThanSixtyTwoDaysShouldBeRejected() {
Date start = startOfDay(new Date());
ClassDTO query = range(start, addDays(start, 63));
assertThrows(BusinessException.class,
() -> service.scheduleTeacher(query, "teacher-1"));
}
private static ClassSubjectVO course(Date date, String timeFrame, int students,
long records, long normal, long late) {
ClassSubjectVO course = new ClassSubjectVO();
course.setId(1);
course.setDate(date);
course.setTimeFrame(timeFrame);
course.setStudentCount(students);
course.setAttendanceRecordCount(records);
course.setNormalCount(normal);
course.setLateCount(late);
course.setAbsentCount(Math.max(0, records - normal - late));
course.setLeaveCount(0L);
return course;
}
private static ClassDTO range(Date start, Date end) {
ClassDTO query = new ClassDTO();
query.setStartDate(start);
query.setEndDate(end);
return query;
}
private static Date startOfDay(Date date) {
Calendar calendar = Calendar.getInstance();
calendar.setTime(date);
calendar.set(Calendar.HOUR_OF_DAY, 0);
calendar.set(Calendar.MINUTE, 0);
calendar.set(Calendar.SECOND, 0);
calendar.set(Calendar.MILLISECOND, 0);
return calendar.getTime();
}
private static Date addDays(Date date, int days) {
Calendar calendar = Calendar.getInstance();
calendar.setTime(date);
calendar.add(Calendar.DAY_OF_MONTH, days);
return calendar.getTime();
}
}
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