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

我的课程-接口拆分

parent 03bbec8e
package com.platform.business.model.dto;
import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
/**
* “我的课程”单日详情请求。
*
* <p>只接收业务必需的日期。旧客户端携带的 userId、teacherId、classIds 等字段会被
* 忽略,避免身份或数据范围由请求方控制。</p>
*/
@Data
@ApiModel("我的课程单日查询")
@JsonIgnoreProperties(ignoreUnknown = true)
public class CourseDateQueryDTO {
/** 严格的自然日文本,服务端拒绝自动进位日期和附加时间。 */
@ApiModelProperty(value = "查询日期,格式为yyyy-MM-dd", required = true)
private String date;
}
package com.platform.business.model.dto;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import java.util.Date;
/**
* “我的课程”日历和汇总使用的日期范围请求。
*
* <p>历史接口曾复用包含班级、学员等大量字段的 {@code ClassDTO},其中的 userId
* 可能被客户端伪造。新请求只声明日期字段,并通过 {@link JsonIgnoreProperties}
* 兼容旧客户端继续提交 userId、teacherId 等多余字段;真实用户身份始终由服务端
* 从 JWT 登录态取得。</p>
*/
@Data
@ApiModel("我的课程日期范围查询")
@JsonIgnoreProperties(ignoreUnknown = true)
public class CourseRangeQueryDTO {
/** 查询开始日期;与结束日期同时为空时默认当前自然月。 */
@ApiModelProperty("开始日期;格式为yyyy-MM-dd,为空时查询当前自然月")
@JsonFormat(pattern = "yyyy-MM-dd", timezone = "GMT+8")
private Date startDate;
/** 查询结束日期;服务端会扩展到该自然日的最后一毫秒。 */
@ApiModelProperty("结束日期;格式为yyyy-MM-dd,为空时查询当前自然月")
@JsonFormat(pattern = "yyyy-MM-dd", timezone = "GMT+8")
private Date endDate;
}
package com.platform.business.controller;
import com.platform.business.model.dto.CalendarDTO;
import com.platform.business.model.dto.ClassDTO;
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;
import com.platform.page.TableDataInfo;
import io.swagger.annotations.ApiModelProperty;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.springframework.web.bind.annotation.*;
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.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.List;
import java.util.Map;
/**
* 班级基础管理控制器。
*
* <p>学员和教师“我的课程”接口已经分别迁移到StudentCourseController和
* TeacherCourseController,本类只保留班级本身的查询、维护和成员操作。</p>
*/
@Api(tags = "班级管理")
@RestController
@RequestMapping("/class")
public class ClassController extends BaseController {
......@@ -28,105 +31,34 @@ public class ClassController extends BaseController {
@Resource
private ClassService classService;
@Resource
private AuthenticatedUserService authenticatedUserService;
@ApiOperation("班级分页")
@PostMapping("/page")
public TableDataInfo page(@RequestBody ClassDTO classDTO) {
startPage(classDTO.getPageNum(), classDTO.getPageSize());
return getDataTable(classService.queryList(classDTO));
}
@ApiOperation("新增或编辑班级")
@PostMapping("/saveOrUpdate")
public Result<Boolean> saveOrUpdate(@RequestBody ClassDTO classDTO) {
return Result.data(classService.saveClass(classDTO));
}
@ApiOperation("班级详情")
@GetMapping("/detail/{id}")
public Result detail(@PathVariable String id) {
public Result<?> detail(@PathVariable String id) {
return Result.data(classService.detail(id));
}
@ApiOperation("从班级移除学员")
@DeleteMapping("/deleteStu/{studentId}")
public Result deleteStu(@PathVariable String studentId) {
public Result<?> deleteStu(@PathVariable String studentId) {
return toAjax(classService.deleteStu(studentId));
}
@ApiOperation("学生端-学习中心-我的课程-日历")
@PostMapping("/schedule")
public Result<List<ClassVO>> schedule(@RequestBody ClassDTO classDTO) {
return Result.data(classService.schedule(classDTO));
}
@ApiOperation("学生端-学习中心-我的课程-日历-详情")
@PostMapping("/schedule/detail")
public Result<ClassSubjectVO> scheduleDetail(@RequestBody ClassSubjectDTO classSubjectDTO) {
return Result.data(classService.scheduleDetail(classSubjectDTO));
}
@ApiOperation("学生端-学习中心-我的课程-今日课程")
@GetMapping("/today/course/{userId}")
public Result<List<CalendarVO>> todayCourse(@PathVariable String userId) {
return Result.data(classService.todayCourse(userId));
}
@ApiOperation("教师端-教学管理-我的课程-日历")
@PostMapping("/schedule/teacher")
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,
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("班级列表")
@GetMapping("/list")
public Result list() {
public Result<?> list() {
return Result.data(classService.list());
}
@ApiOperation("今日课程-签到")
@PostMapping("/today/course/signIn")
public Result<Boolean> todayCourseSignIn(@RequestBody CalendarDTO calendarDTO) {
return Result.data(classService.todayCourseSignIn(calendarDTO));
}
@ApiOperation("学生端-学习中心-我的课程-汇总")
@PostMapping("/student/course/summary")
public Result<Map<String, Integer>> studentCourseSummary(@RequestBody ClassDTO classDTO) {
return Result.data(classService.studentCourseSummary(classDTO));
}
@ApiOperation("教师端-教学管理-我的课程-汇总")
@PostMapping("/teacher/course/summary")
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.controller;
import com.platform.business.model.dto.CalendarDTO;
import com.platform.business.model.dto.CourseDateQueryDTO;
import com.platform.business.model.dto.CourseRangeQueryDTO;
import com.platform.business.model.entity.UserEntity;
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.service.AuthenticatedUserService;
import com.platform.business.service.StudentCourseService;
import com.platform.model.resp.Result;
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.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.List;
import java.util.Map;
/**
* 学员端“我的课程”控制器。
*
* <p>为兼容已有前端,本控制器继续使用历史/class路径。路径或请求体中的userId仅作为
* 旧协议占位,所有接口都先解析JWT并校验学员角色,再将可信的当前用户ID传给业务层。</p>
*/
@Api(tags = "学员端-我的课程")
@RestController
@RequestMapping("/class")
public class StudentCourseController {
@Resource
private StudentCourseService studentCourseService;
@Resource
private AuthenticatedUserService authenticatedUserService;
@ApiOperation("学生端-学习中心-我的课程-日历")
@PostMapping("/schedule")
public Result<List<ClassVO>> schedule(@RequestBody(required = false) CourseRangeQueryDTO query,
HttpServletRequest request) {
return Result.data(studentCourseService.schedule(query, currentStudent(request).getId()));
}
@ApiOperation("学生端-学习中心-我的课程-日历-详情")
@PostMapping("/schedule/detail")
public Result<ClassSubjectVO> detail(@RequestBody CourseDateQueryDTO query,
HttpServletRequest request) {
return Result.data(studentCourseService.detail(query, currentStudent(request).getId()));
}
@ApiOperation(value = "学生端-学习中心-我的课程-今日课程",
notes = "路径userId为旧版兼容字段,服务端始终查询当前登录学员")
@GetMapping("/today/course/{userId}")
public Result<List<CalendarVO>> today(@PathVariable String userId, HttpServletRequest request) {
// 故意不使用userId:保留旧URL的同时封堵通过路径参数查询其他学员课程的越权入口。
return Result.data(studentCourseService.today(currentStudent(request).getId()));
}
@ApiOperation("学生端-学习中心-我的课程-汇总")
@PostMapping("/student/course/summary")
public Result<Map<String, Integer>> summary(
@RequestBody(required = false) CourseRangeQueryDTO query, HttpServletRequest request) {
return Result.data(studentCourseService.summary(query, currentStudent(request).getId()));
}
@ApiOperation(value = "今日课程-签到(已停用)",
notes = "请迁移至/attendance/student/check-in")
@PostMapping("/today/course/signIn")
public Result<Boolean> legacySignIn(@RequestBody CalendarDTO requestBody,
HttpServletRequest request) {
// 即使是停用入口也先校验身份,避免匿名请求借由错误信息探测内部接口结构。
currentStudent(request);
return Result.data(studentCourseService.rejectLegacySignIn(requestBody));
}
/** 统一完成JWT解析和学员角色校验,Controller不信任任何客户端用户标识。 */
private UserEntity currentStudent(HttpServletRequest request) {
UserEntity student = authenticatedUserService.current(request);
authenticatedUserService.requireStudent(student);
return student;
}
}
package com.platform.business.controller;
import com.platform.business.model.dto.CourseDateQueryDTO;
import com.platform.business.model.dto.CourseRangeQueryDTO;
import com.platform.business.model.entity.UserEntity;
import com.platform.business.model.vo.ClassSubjectVO;
import com.platform.business.model.vo.ClassVO;
import com.platform.business.service.AuthenticatedUserService;
import com.platform.business.service.TeacherCourseService;
import com.platform.model.resp.Result;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
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.List;
import java.util.Map;
/**
* 教师端“我的课程”控制器。
*
* <p>接口地址保持历史/class前缀不变,但教师课程不再和学员课程或班级管理方法放在
* 同一个Controller。所有查询都从JWT取得教师ID,请求中的同名身份字段会被忽略。</p>
*/
@Api(tags = "教师端-我的课程")
@RestController
@RequestMapping("/class")
public class TeacherCourseController {
@Resource
private TeacherCourseService teacherCourseService;
@Resource
private AuthenticatedUserService authenticatedUserService;
@ApiOperation("教师端-教学管理-我的课程-日历")
@PostMapping("/schedule/teacher")
public Result<List<ClassVO>> schedule(@RequestBody(required = false) CourseRangeQueryDTO query,
HttpServletRequest request) {
return Result.data(teacherCourseService.schedule(query, currentTeacher(request).getId()));
}
@ApiOperation("教师端-教学管理-我的课程-详情")
@PostMapping("/schedule/teacher/detail")
public Result<ClassSubjectVO> detail(@RequestBody CourseDateQueryDTO query,
HttpServletRequest request) {
return Result.data(teacherCourseService.detail(query, currentTeacher(request).getId()));
}
@ApiOperation("教师端-教学管理-我的课程-今日课程")
@GetMapping("/today/course/teacher")
public Result<List<ClassSubjectVO>> today(HttpServletRequest request) {
return Result.data(teacherCourseService.today(currentTeacher(request).getId()));
}
@ApiOperation("教师端-教学管理-我的课程-汇总")
@PostMapping("/teacher/course/summary")
public Result<Map<String, Integer>> summary(
@RequestBody(required = false) CourseRangeQueryDTO query, HttpServletRequest request) {
return Result.data(teacherCourseService.summary(query, currentTeacher(request).getId()));
}
/** 统一完成JWT解析和教师角色校验,教师ID绝不从请求体读取。 */
private UserEntity currentTeacher(HttpServletRequest request) {
UserEntity teacher = authenticatedUserService.current(request);
authenticatedUserService.requireTeacher(teacher);
return teacher;
}
}
package com.platform.business.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
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.vo.AttendanceRecordVO;
......@@ -11,14 +10,18 @@ import com.platform.business.model.vo.AttendanceSummaryVO;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import java.util.Date;
import java.util.List;
/** 出勤记录写入、加锁查询及多维统计的数据访问接口。 */
@Mapper
public interface ClassSubjectAttendanceMapper extends BaseMapper<ClassSubjectAttendanceEntity> {
/** 兼容原有按本人查询签到记录的接口。 */
List<ClassSubjectAttendanceEntity> queryOneself(ClassDTO classDTO);
/** 按可信学员ID和课程日期范围查询出勤,避免加载该学员全部历史记录。 */
List<ClassSubjectAttendanceEntity> queryByStudentAndRange(
@Param("studentId") String studentId,
@Param("startDate") Date startDate,
@Param("endDate") Date endDate);
/** 幂等插入签到记录;课程与学员重复时忽略,用于处理并发签到。 */
int insertIgnore(ClassSubjectAttendanceEntity record);
......
......@@ -29,7 +29,9 @@ public interface ClassSubjectMapper extends BaseMapper<ClassSubjectEntity> {
List<ClassSubjectVO> queryByTeacherId(String id);
List<CalendarVO> todayCourse(@Param("classIds") List<Integer> classIds);
/** 按服务端确定的自然日查询课程,避免数据库时区与应用时区不一致。 */
List<CalendarVO> todayCourse(@Param("classIds") List<Integer> classIds,
@Param("date") Date date);
List<ClassSubjectVO> queryListByUserIdAndDate(ClassSubjectDTO classSubjectDTO);
......
package com.platform.business.service;
import com.baomidou.mybatisplus.extension.service.IService;
import com.platform.business.model.dto.CalendarDTO;
import com.platform.business.model.dto.ClassDTO;
import com.platform.business.model.dto.ClassSubjectDTO;
import com.platform.business.model.entity.ClassEntity;
import com.platform.business.model.vo.CalendarVO;
import com.platform.business.model.vo.ClassSubjectVO;
import com.platform.business.model.vo.ClassVO;
import java.util.List;
import java.util.Map;
/** 班级基础管理服务;角色端“我的课程”逻辑由独立服务负责。 */
public interface ClassService extends IService<ClassEntity> {
List<ClassVO> queryList(ClassDTO classDTO);
ClassVO detail(String id);
......@@ -20,29 +17,4 @@ public interface ClassService extends IService<ClassEntity> {
boolean saveClass(ClassDTO classDTO);
boolean deleteStu(String studentId);
List<ClassVO> schedule(ClassDTO classDTO);
ClassSubjectVO scheduleDetail(ClassSubjectDTO classSubjectDTO);
/** 查询当前登录教师在日期范围内的课程日历。teacherId只能来自JWT。 */
List<ClassVO> scheduleTeacher(ClassDTO classDTO, String teacherId);
/** 查询当前登录教师某一天的课程详情。 */
ClassSubjectVO scheduleTeacherDetail(ClassSubjectDTO classSubjectDTO, String teacherId);
/** 查询当前登录教师今天的全部课程。 */
List<ClassSubjectVO> todayTeacherCourse(String teacherId);
List<CalendarVO> todayCourse(String userId);
Boolean todayCourseSignIn(CalendarDTO calendarDTO);
Map<String, Integer> studentCourseSummary(ClassDTO classDTO);
/** 计算当前登录教师所选月份的页面KPI。 */
Map<String, Integer> teacherCourseSummary(ClassDTO classDTO, String teacherId);
}
package com.platform.business.service;
import com.baomidou.mybatisplus.extension.service.IService;
import com.platform.business.model.dto.ClassDTO;
import com.platform.business.model.entity.ClassSubjectAttendanceEntity;
import java.util.Date;
import java.util.List;
/**
......@@ -14,5 +14,10 @@ import java.util.List;
*/
public interface ClassSubjectAttendanceService extends IService<ClassSubjectAttendanceEntity> {
List<ClassSubjectAttendanceEntity> queryOneself(ClassDTO classDTO);
/**
* 只查询指定学员在课程日期范围内的出勤记录。
* 该方法替代直接接收ClassDTO的历史入口,避免业务层意外信任请求中的userId。
*/
List<ClassSubjectAttendanceEntity> queryByStudentAndRange(
String studentId, Date startDate, Date endDate);
}
......@@ -31,7 +31,8 @@ public interface ClassSubjectService extends IService<ClassSubjectEntity> {
List<ClassSubjectVO> queryOneselfTeacher(String userId);
List<CalendarVO> todayCourse(List<Integer> classIds);
/** 查询指定班级集合在某个自然日的课程,日期由服务端生成而不是使用数据库当前时间。 */
List<CalendarVO> todayCourse(List<Integer> classIds, Date date);
List<ClassSubjectVO> queryListByUserIdAndDate(ClassSubjectDTO classSubjectDTO);
......
package com.platform.business.service;
import com.platform.business.model.dto.CalendarDTO;
import com.platform.business.model.dto.CourseDateQueryDTO;
import com.platform.business.model.dto.CourseRangeQueryDTO;
import com.platform.business.model.vo.CalendarVO;
import com.platform.business.model.vo.ClassSubjectVO;
import com.platform.business.model.vo.ClassVO;
import java.util.List;
import java.util.Map;
/** 学员端“学习中心-我的课程”专用业务接口,所有studentId参数只能由JWT登录态提供。 */
public interface StudentCourseService {
/** 查询当前学员的按天课程日历,响应结构兼容原/class/schedule接口。 */
List<ClassVO> schedule(CourseRangeQueryDTO query, String studentId);
/** 查询当前学员指定自然日的课程详情。 */
ClassSubjectVO detail(CourseDateQueryDTO query, String studentId);
/** 查询当前学员今天的课程和签到状态。 */
List<CalendarVO> today(String studentId);
/** 统计当前学员在指定范围内的课程及出勤情况。 */
Map<String, Integer> summary(CourseRangeQueryDTO query, String studentId);
/** 原签到入口只返回迁移提示,正式签到必须经过AttendanceService的IP和验证码校验。 */
Boolean rejectLegacySignIn(CalendarDTO request);
}
package com.platform.business.service;
import com.platform.business.model.dto.CourseDateQueryDTO;
import com.platform.business.model.dto.CourseRangeQueryDTO;
import com.platform.business.model.vo.ClassSubjectVO;
import com.platform.business.model.vo.ClassVO;
import java.util.List;
import java.util.Map;
/** 教师端“教学管理-我的课程”专用业务接口,teacherId只能由JWT登录态提供。 */
public interface TeacherCourseService {
/** 查询当前教师在日期范围内的按天课程日历。 */
List<ClassVO> schedule(CourseRangeQueryDTO query, String teacherId);
/** 查询当前教师指定自然日的课程详情。 */
ClassSubjectVO detail(CourseDateQueryDTO query, String teacherId);
/** 查询当前教师今天的全部课程。 */
List<ClassSubjectVO> today(String teacherId);
/** 计算当前教师指定日期范围的页面KPI。 */
Map<String, Integer> summary(CourseRangeQueryDTO query, String teacherId);
}
......@@ -2,11 +2,11 @@ package com.platform.business.service.impl;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.platform.business.mapper.ClassSubjectAttendanceMapper;
import com.platform.business.model.dto.ClassDTO;
import com.platform.business.model.entity.ClassSubjectAttendanceEntity;
import com.platform.business.service.ClassSubjectAttendanceService;
import org.springframework.stereotype.Service;
import java.util.Date;
import java.util.List;
/**
......@@ -18,7 +18,8 @@ import java.util.List;
@Service
public class ClassSubjectAttendanceServiceImpl extends ServiceImpl<ClassSubjectAttendanceMapper, ClassSubjectAttendanceEntity> implements ClassSubjectAttendanceService {
@Override
public List<ClassSubjectAttendanceEntity> queryOneself(ClassDTO classDTO) {
return baseMapper.queryOneself(classDTO);
public List<ClassSubjectAttendanceEntity> queryByStudentAndRange(
String studentId, Date startDate, Date endDate) {
return baseMapper.queryByStudentAndRange(studentId, startDate, endDate);
}
}
......@@ -268,8 +268,8 @@ public class ClassSubjectServiceImpl extends ServiceImpl<ClassSubjectMapper, Cla
}
@Override
public List<CalendarVO> todayCourse(List<Integer> classIds) {
return baseMapper.todayCourse(classIds);
public List<CalendarVO> todayCourse(List<Integer> classIds, Date date) {
return baseMapper.todayCourse(classIds, date);
}
@Override
......
package com.platform.business.service.impl;
import com.platform.business.constant.AttendanceConstants;
import com.platform.business.model.dto.CalendarDTO;
import com.platform.business.model.dto.ClassSubjectDTO;
import com.platform.business.model.dto.CourseDateQueryDTO;
import com.platform.business.model.dto.CourseRangeQueryDTO;
import com.platform.business.model.entity.ClassSubjectAttendanceEntity;
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.vo.ExamStudentVO;
import com.platform.business.service.ClassStudentService;
import com.platform.business.service.ClassSubjectAttendanceService;
import com.platform.business.service.ClassSubjectService;
import com.platform.business.service.ExamStudentService;
import com.platform.business.service.StudentCourseService;
import com.platform.business.util.ClassSubjectTimeUtils;
import com.platform.business.util.CourseDateRangeUtils;
import com.platform.business.util.CourseDateRangeUtils.DateRange;
import com.platform.exception.BusinessException;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Date;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
/**
* 学员端“我的课程”业务实现。
*
* <p>本类只接受Controller从JWT传入的studentId,不读取请求体中的身份字段。课程、考试
* 和出勤数据最终都以当前学员为边界,防止历史接口通过伪造userId越权查询。</p>
*/
@Service
public class StudentCourseServiceImpl implements StudentCourseService {
@Resource
private ClassStudentService classStudentService;
@Resource
private ClassSubjectService classSubjectService;
@Resource
private ClassSubjectAttendanceService classSubjectAttendanceService;
@Resource
private ExamStudentService examStudentService;
@Override
public List<ClassVO> schedule(CourseRangeQueryDTO query, String studentId) {
DateRange range = CourseDateRangeUtils.normalize(query);
List<Integer> classIds = safeClassIds(studentId);
List<ClassSubjectVO> courses = classIds.isEmpty()
? Collections.emptyList()
: classSubjectService.queryOneself(classIds, range.getStart(), range.getEnd());
List<ClassSubjectAttendanceEntity> attendance = classIds.isEmpty()
? Collections.emptyList()
: classSubjectAttendanceService.queryByStudentAndRange(
studentId, range.getStart(), range.getEnd());
enrichStudentCourses(courses, attendance, new Date());
// 旧版课程日历同时展示学员考试,因此保留该响应能力并在Java侧限制到请求范围。
List<ExamStudentVO> exams = examStudentService.queryOneself(studentId);
Map<String, List<ClassSubjectVO>> coursesByDay = groupCourses(courses);
Map<String, List<ExamStudentVO>> examsByDay = groupExams(exams, range);
List<ClassVO> result = new ArrayList<>();
for (Date day : CourseDateRangeUtils.days(range)) {
String key = CourseDateRangeUtils.formatDay(day);
ClassVO item = new ClassVO();
item.setDate(day);
item.setClassSubjectList(coursesByDay.getOrDefault(key, Collections.emptyList()));
item.setExamStudentList(examsByDay.getOrDefault(key, Collections.emptyList()));
result.add(item);
}
return result;
}
@Override
public ClassSubjectVO detail(CourseDateQueryDTO query, String studentId) {
if (query == null) {
throw new BusinessException("查询日期不能为空");
}
Date date = CourseDateRangeUtils.parseStrictDay(query.getDate());
List<Integer> classIds = safeClassIds(studentId);
List<ClassSubjectVO> courses;
List<ClassSubjectAttendanceEntity> attendance;
if (classIds.isEmpty()) {
// 空班级直接返回空详情,绝不把空集合传给MyBatis生成非法IN ()。
courses = Collections.emptyList();
attendance = Collections.emptyList();
} else {
ClassSubjectDTO safeQuery = new ClassSubjectDTO();
safeQuery.setDate(CourseDateRangeUtils.formatDay(date));
safeQuery.setClassIds(classIds);
courses = classSubjectService.queryListByUserIdAndDate(safeQuery);
attendance = classSubjectAttendanceService.queryByStudentAndRange(
studentId, CourseDateRangeUtils.startOfDay(date), CourseDateRangeUtils.endOfDay(date));
}
enrichStudentCourses(courses, attendance, new Date());
ClassSubjectVO result = new ClassSubjectVO();
result.setData(courses);
result.setSubjectNum(courses.size());
return result;
}
@Override
public List<CalendarVO> today(String studentId) {
Date today = CourseDateRangeUtils.startOfDay(new Date());
List<Integer> classIds = safeClassIds(studentId);
if (classIds.isEmpty()) {
return Collections.emptyList();
}
List<CalendarVO> courses = classSubjectService.todayCourse(classIds, today);
List<ClassSubjectAttendanceEntity> attendance =
classSubjectAttendanceService.queryByStudentAndRange(
studentId, today, CourseDateRangeUtils.endOfDay(today));
Map<Integer, ClassSubjectAttendanceEntity> attendanceBySubject = indexAttendance(attendance);
Date now = new Date();
for (CalendarVO course : courses) {
ClassSubjectAttendanceEntity record = attendanceBySubject.get(course.getSubjectId());
if (record != null) {
course.setSignInTime(record.getCheckInTime());
course.setAttendanceStatus(record.getStatus());
course.setCheckInMethod(record.getCheckInMethod());
course.setIsSignIn(AttendanceConstants.isPresent(record.getStatus()));
continue;
}
// CalendarVO沿用旧字段名,转换为排课对象后复用统一的课程时段解析规则。
ClassSubjectVO subject = new ClassSubjectVO();
subject.setDate(course.getSubjectTime());
subject.setTimeFrame(course.getSubjectTimePeriod());
ClassSubjectTimeUtils.TimeWindow window = ClassSubjectTimeUtils.resolve(subject);
course.setIsSignIn(false);
if (now.before(window.getStart())) {
course.setAttendanceStatus("UPCOMING");
} else if (now.before(window.getEnd())) {
course.setAttendanceStatus("PENDING");
} else {
course.setAttendanceStatus(AttendanceConstants.STATUS_ABSENT);
}
}
return courses;
}
@Override
public Map<String, Integer> summary(CourseRangeQueryDTO query, String studentId) {
DateRange range = CourseDateRangeUtils.normalize(query);
List<Integer> classIds = safeClassIds(studentId);
List<ClassSubjectVO> courses = classIds.isEmpty()
? Collections.emptyList()
: classSubjectService.queryOneself(classIds, range.getStart(), range.getEnd());
List<ClassSubjectAttendanceEntity> attendance = classIds.isEmpty()
? Collections.emptyList()
: classSubjectAttendanceService.queryByStudentAndRange(
studentId, range.getStart(), range.getEnd());
enrichStudentCourses(courses, attendance, new Date());
int normal = 0;
int late = 0;
int absent = 0;
int leave = 0;
int pending = 0;
for (ClassSubjectVO course : courses) {
if (AttendanceConstants.STATUS_NORMAL.equals(course.getStatus())) normal++;
else if (AttendanceConstants.STATUS_LATE.equals(course.getStatus())) late++;
else if (AttendanceConstants.STATUS_ABSENT.equals(course.getStatus())) absent++;
else if (AttendanceConstants.STATUS_LEAVE.equals(course.getStatus())) leave++;
else pending++;
}
int signed = normal + late;
int finished = signed + absent + leave;
Map<String, Integer> result = new LinkedHashMap<>();
result.put("本月课程", courses.size());
result.put("已签到", signed);
result.put("正常签到", normal);
result.put("迟到", late);
result.put("缺勤", absent);
result.put("请假", leave);
result.put("待签到", pending);
result.put("出勤率", finished == 0 ? 0 : (int) Math.round(signed * 100.0 / finished));
return result;
}
@Override
public Boolean rejectLegacySignIn(CalendarDTO request) {
throw new BusinessException("原签到接口已停用,请使用 /attendance/student/check-in 完成IP和验证码校验");
}
/** 将课程状态统一为英文枚举,避免日历、详情和汇总各自使用不同的中文状态。 */
private void enrichStudentCourses(List<ClassSubjectVO> courses,
List<ClassSubjectAttendanceEntity> attendance,
Date now) {
Map<Integer, ClassSubjectAttendanceEntity> attendanceBySubject = indexAttendance(attendance);
for (ClassSubjectVO course : courses) {
ClassSubjectAttendanceEntity record = attendanceBySubject.get(course.getId());
ClassSubjectTimeUtils.TimeWindow window = ClassSubjectTimeUtils.resolve(course);
if (now.before(window.getStart())) {
course.setStatus("UPCOMING");
} else if (record != null) {
course.setStatus(record.getStatus());
} else if (now.before(window.getEnd())) {
course.setStatus("PENDING");
} else {
course.setStatus(AttendanceConstants.STATUS_ABSENT);
}
}
}
private List<Integer> safeClassIds(String studentId) {
List<Integer> classIds = classStudentService.queryClassIdByUserId(studentId);
return classIds == null ? Collections.emptyList() : classIds;
}
private Map<Integer, ClassSubjectAttendanceEntity> indexAttendance(
List<ClassSubjectAttendanceEntity> attendance) {
Map<Integer, ClassSubjectAttendanceEntity> result = new HashMap<>();
for (ClassSubjectAttendanceEntity record : attendance) {
result.put(record.getSubjectId(), record);
}
return result;
}
private Map<String, List<ClassSubjectVO>> groupCourses(List<ClassSubjectVO> courses) {
Map<String, List<ClassSubjectVO>> result = new HashMap<>();
for (ClassSubjectVO course : courses) {
result.computeIfAbsent(CourseDateRangeUtils.formatDay(course.getDate()), ignored -> new ArrayList<>())
.add(course);
}
return result;
}
private Map<String, List<ExamStudentVO>> groupExams(List<ExamStudentVO> exams, DateRange range) {
Map<String, List<ExamStudentVO>> result = new HashMap<>();
if (exams == null) {
return result;
}
for (ExamStudentVO exam : exams) {
Date examTime = exam.getExamTime();
if (examTime == null || examTime.before(range.getStart()) || examTime.after(range.getEnd())) {
continue;
}
result.computeIfAbsent(CourseDateRangeUtils.formatDay(examTime), ignored -> new ArrayList<>())
.add(exam);
}
return result;
}
}
package com.platform.business.service.impl;
import com.platform.business.model.dto.ClassSubjectDTO;
import com.platform.business.model.dto.CourseDateQueryDTO;
import com.platform.business.model.dto.CourseRangeQueryDTO;
import com.platform.business.model.vo.ClassSubjectVO;
import com.platform.business.model.vo.ClassVO;
import com.platform.business.model.vo.TeacherCourseAttendanceVO;
import com.platform.business.service.AttendanceService;
import com.platform.business.service.ClassSubjectService;
import com.platform.business.service.TeacherCourseService;
import com.platform.business.util.ClassSubjectTimeUtils;
import com.platform.business.util.CourseDateRangeUtils;
import com.platform.business.util.CourseDateRangeUtils.DateRange;
import com.platform.exception.BusinessException;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Date;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
/** 教师端“我的课程”业务实现,集中处理教师课程状态、出勤聚合和页面KPI。 */
@Service
public class TeacherCourseServiceImpl implements TeacherCourseService {
@Resource
private ClassSubjectService classSubjectService;
@Resource
private AttendanceService attendanceService;
@Override
public List<ClassVO> schedule(CourseRangeQueryDTO query, String teacherId) {
DateRange range = CourseDateRangeUtils.normalize(query);
// 查询页面前幂等补齐已结束课程的缺勤记录,确保日历和KPI使用同一套最终数据。
attendanceService.finalizeEndedSubjects(range.getStart(), range.getEnd(), teacherId);
List<ClassSubjectVO> courses = classSubjectService.queryTeacherCourse(
teacherId, range.getStart(), range.getEnd());
enrichCourses(courses, new Date());
Map<String, List<ClassSubjectVO>> coursesByDay = new HashMap<>();
for (ClassSubjectVO course : courses) {
coursesByDay.computeIfAbsent(
CourseDateRangeUtils.formatDay(course.getDate()), ignored -> new ArrayList<>()).add(course);
}
// 保留旧版“每天一个ClassVO”的响应结构,即使当天无课也返回空课程列表。
List<ClassVO> result = new ArrayList<>();
for (Date date : CourseDateRangeUtils.days(range)) {
ClassVO day = new ClassVO();
day.setDate(date);
day.setClassSubjectList(coursesByDay.getOrDefault(
CourseDateRangeUtils.formatDay(date), Collections.emptyList()));
result.add(day);
}
return result;
}
@Override
public ClassSubjectVO detail(CourseDateQueryDTO query, String teacherId) {
if (query == null) {
throw new BusinessException("查询日期不能为空");
}
Date date = CourseDateRangeUtils.parseStrictDay(query.getDate());
ClassSubjectDTO safeQuery = new ClassSubjectDTO();
safeQuery.setDate(CourseDateRangeUtils.formatDay(date));
safeQuery.setTeacherId(teacherId);
// userId仅用于兼容既有Mapper字段;其值同样来自JWT,而不是客户端请求。
safeQuery.setUserId(teacherId);
attendanceService.finalizeEndedSubjects(
date, CourseDateRangeUtils.endOfDay(date), teacherId);
List<ClassSubjectVO> courses = classSubjectService.queryListByUserIdAndDateTeacher(safeQuery);
enrichCourses(courses, new Date());
ClassSubjectVO result = new ClassSubjectVO();
result.setData(courses);
result.setSubjectNum(courses.size());
return result;
}
@Override
public List<ClassSubjectVO> today(String teacherId) {
Date today = CourseDateRangeUtils.startOfDay(new Date());
attendanceService.finalizeEndedSubjects(
today, CourseDateRangeUtils.endOfDay(today), teacherId);
List<ClassSubjectVO> courses = classSubjectService.queryTeacherCourse(
teacherId, today, CourseDateRangeUtils.endOfDay(today));
enrichCourses(courses, new Date());
return courses;
}
@Override
public Map<String, Integer> summary(CourseRangeQueryDTO query, String teacherId) {
DateRange range = CourseDateRangeUtils.normalize(query);
attendanceService.finalizeEndedSubjects(range.getStart(), range.getEnd(), teacherId);
List<ClassSubjectVO> courses = classSubjectService.queryTeacherCourse(
teacherId, range.getStart(), range.getEnd());
enrichCourses(courses, new Date());
int completed = 0;
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("待完成课程", courses.size() - completed);
result.put("平均出勤率", rate);
return result;
}
/**
* 将Mapper返回的扁平聚合字段组装为页面需要的attendance对象和稳定状态。
* 必须先判断课程是否尚未开始,避免全班提前请假时被误判为已完成课程。
*/
private void enrichCourses(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 long safeLong(Long value) {
return value == null ? 0L : value;
}
}
package com.platform.business.util;
import com.platform.business.model.dto.CourseRangeQueryDTO;
import com.platform.exception.BusinessException;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.List;
/**
* 学员端和教师端“我的课程”共用的自然日范围工具。
*
* <p>课程表按自然日查询,而数据库和请求对象仍使用旧版 {@link Date} 类型。本工具
* 集中处理当天起止、默认月份和范围上限,避免两个角色的接口出现不同边界口径。</p>
*/
public final class CourseDateRangeUtils {
/** 最长允许跨越62个自然日,防止一次查询生成过大的日历和聚合结果。 */
private static final int MAX_RANGE_DAYS = 62;
private CourseDateRangeUtils() {
}
/**
* 规范化查询范围。任意一端缺失时都使用当前自然月,保持与原教师端行为一致。
* 返回值中的开始时间为00:00:00.000,结束时间为23:59:59.999。
*/
public static DateRange normalize(CourseRangeQueryDTO 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("开始日期不能晚于结束日期");
}
if (daysBetween(start, end) > MAX_RANGE_DAYS) {
throw new BusinessException("课程查询时间范围不能超过62天");
}
return new DateRange(start, end);
}
/** 严格解析yyyy-MM-dd,禁止诸如2026-02-30被自动转换为三月日期。 */
public static 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 exception) {
throw new BusinessException("查询日期不是有效日期");
}
}
/** 返回包含开始、结束日期的自然日列表,供兼容旧版按天分组的响应结构使用。 */
public static List<Date> days(DateRange range) {
List<Date> result = new ArrayList<>();
Calendar cursor = Calendar.getInstance();
cursor.setTime(startOfDay(range.getStart()));
Date lastDay = startOfDay(range.getEnd());
while (!cursor.getTime().after(lastDay)) {
result.add(cursor.getTime());
cursor.add(Calendar.DAY_OF_MONTH, 1);
}
return result;
}
/** 将日期转换为稳定的yyyy-MM-dd分组键。 */
public static String formatDay(Date date) {
return new SimpleDateFormat("yyyy-MM-dd").format(date);
}
/** 判断两个时间是否属于同一自然日。 */
public static boolean isSameDay(Date first, Date second) {
return first != null && second != null && formatDay(first).equals(formatDay(second));
}
public 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();
}
public static 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 static int daysBetween(Date start, Date end) {
Calendar cursor = Calendar.getInstance();
cursor.setTime(startOfDay(start));
Date lastDay = startOfDay(end);
int days = 0;
while (cursor.getTime().before(lastDay)) {
cursor.add(Calendar.DAY_OF_MONTH, 1);
days++;
if (days > MAX_RANGE_DAYS) {
return days;
}
}
return days;
}
/** 已完成规范化的不可变日期范围。 */
public static final class DateRange {
private final Date start;
private final Date end;
private DateRange(Date start, Date end) {
this.start = start;
this.end = end;
}
public Date getStart() {
return start;
}
public Date getEnd() {
return end;
}
}
}
......@@ -99,7 +99,8 @@
end
</insert>
<select id="queryOneself" resultType="com.platform.business.model.entity.ClassSubjectAttendanceEntity">
<!-- 学员课程页面只读取当前日期范围,避免每次打开月历扫描本人全部历史出勤。 -->
<select id="queryByStudentAndRange" resultType="com.platform.business.model.entity.ClassSubjectAttendanceEntity">
select
a.id,
a.subject_id,
......@@ -118,7 +119,7 @@
inner join
class_subject s on s.id = a.subject_id
where
a.user_id = #{userId}
a.user_id = #{studentId}
and
s.date between #{startDate} and #{endDate}
</select>
......
......@@ -90,6 +90,8 @@
</foreach>
and
cs.date between #{startDate} and #{endDate}
order by
cs.date asc, cs.time_frame asc, cs.id asc
</select>
<select id="queryOneselfTeacher" resultType="com.platform.business.model.vo.ClassSubjectVO">
select
......@@ -135,24 +137,41 @@
<foreach item="item" index="index" collection="classIds" open="(" separator="," close=")">
#{item}
</foreach>
and cs.date = #{date}
order by cs.time_frame asc, cs.id asc
</select>
<select id="queryListByUserIdAndDate" 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.type
cs.teacher_id,
cs.remark,
cs.location,
cs.type,
u.nick_name as teacherName,
c.name as className
from
class_subject cs
left join
user u
on
cs.teacher_id = u.id
where date = #{date}
left join
class c
on
cs.class_id = c.id
where cs.date = #{date}
and cs.class_id in
<foreach item="item" index="index" collection="classIds" open="(" separator="," close=")">
#{item}
</foreach>
order by cs.time_frame asc, cs.id asc
</select>
<select id="queryTeacherCourse" resultType="com.platform.business.model.vo.ClassSubjectVO">
select
......
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