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; 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.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.business.service.ClassService;
import com.platform.controller.BaseController; import com.platform.controller.BaseController;
import com.platform.model.resp.Result; import com.platform.model.resp.Result;
import com.platform.page.TableDataInfo; import com.platform.page.TableDataInfo;
import io.swagger.annotations.ApiModelProperty; import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation; 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.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import java.util.List;
import java.util.Map;
/**
* 班级基础管理控制器。
*
* <p>学员和教师“我的课程”接口已经分别迁移到StudentCourseController和
* TeacherCourseController,本类只保留班级本身的查询、维护和成员操作。</p>
*/
@Api(tags = "班级管理")
@RestController @RestController
@RequestMapping("/class") @RequestMapping("/class")
public class ClassController extends BaseController { public class ClassController extends BaseController {
...@@ -28,105 +31,34 @@ public class ClassController extends BaseController { ...@@ -28,105 +31,34 @@ public class ClassController extends BaseController {
@Resource @Resource
private ClassService classService; private ClassService classService;
@Resource @ApiOperation("班级分页")
private AuthenticatedUserService authenticatedUserService;
@PostMapping("/page") @PostMapping("/page")
public TableDataInfo page(@RequestBody ClassDTO classDTO) { public TableDataInfo page(@RequestBody ClassDTO classDTO) {
startPage(classDTO.getPageNum(), classDTO.getPageSize()); startPage(classDTO.getPageNum(), classDTO.getPageSize());
return getDataTable(classService.queryList(classDTO)); return getDataTable(classService.queryList(classDTO));
} }
@ApiOperation("新增或编辑班级")
@PostMapping("/saveOrUpdate") @PostMapping("/saveOrUpdate")
public Result<Boolean> saveOrUpdate(@RequestBody ClassDTO classDTO) { public Result<Boolean> saveOrUpdate(@RequestBody ClassDTO classDTO) {
return Result.data(classService.saveClass(classDTO)); return Result.data(classService.saveClass(classDTO));
} }
@ApiOperation("班级详情")
@GetMapping("/detail/{id}") @GetMapping("/detail/{id}")
public Result detail(@PathVariable String id) { public Result<?> detail(@PathVariable String id) {
return Result.data(classService.detail(id)); return Result.data(classService.detail(id));
} }
@ApiOperation("从班级移除学员")
@DeleteMapping("/deleteStu/{studentId}") @DeleteMapping("/deleteStu/{studentId}")
public Result deleteStu(@PathVariable String studentId) { public Result<?> deleteStu(@PathVariable String studentId) {
return toAjax(classService.deleteStu(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("班级列表") @ApiOperation("班级列表")
@GetMapping("/list") @GetMapping("/list")
public Result list() { public Result<?> list() {
return Result.data(classService.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; package com.platform.business.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper; import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.platform.business.model.dto.ClassDTO;
import com.platform.business.model.dto.AttendanceQueryDTO; import com.platform.business.model.dto.AttendanceQueryDTO;
import com.platform.business.model.entity.ClassSubjectAttendanceEntity; import com.platform.business.model.entity.ClassSubjectAttendanceEntity;
import com.platform.business.model.vo.AttendanceRecordVO; import com.platform.business.model.vo.AttendanceRecordVO;
...@@ -11,14 +10,18 @@ import com.platform.business.model.vo.AttendanceSummaryVO; ...@@ -11,14 +10,18 @@ import com.platform.business.model.vo.AttendanceSummaryVO;
import org.apache.ibatis.annotations.Mapper; import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param; import org.apache.ibatis.annotations.Param;
import java.util.Date;
import java.util.List; import java.util.List;
/** 出勤记录写入、加锁查询及多维统计的数据访问接口。 */ /** 出勤记录写入、加锁查询及多维统计的数据访问接口。 */
@Mapper @Mapper
public interface ClassSubjectAttendanceMapper extends BaseMapper<ClassSubjectAttendanceEntity> { public interface ClassSubjectAttendanceMapper extends BaseMapper<ClassSubjectAttendanceEntity> {
/** 兼容原有按本人查询签到记录的接口。 */ /** 按可信学员ID和课程日期范围查询出勤,避免加载该学员全部历史记录。 */
List<ClassSubjectAttendanceEntity> queryOneself(ClassDTO classDTO); List<ClassSubjectAttendanceEntity> queryByStudentAndRange(
@Param("studentId") String studentId,
@Param("startDate") Date startDate,
@Param("endDate") Date endDate);
/** 幂等插入签到记录;课程与学员重复时忽略,用于处理并发签到。 */ /** 幂等插入签到记录;课程与学员重复时忽略,用于处理并发签到。 */
int insertIgnore(ClassSubjectAttendanceEntity record); int insertIgnore(ClassSubjectAttendanceEntity record);
......
...@@ -29,7 +29,9 @@ public interface ClassSubjectMapper extends BaseMapper<ClassSubjectEntity> { ...@@ -29,7 +29,9 @@ public interface ClassSubjectMapper extends BaseMapper<ClassSubjectEntity> {
List<ClassSubjectVO> queryByTeacherId(String id); 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); List<ClassSubjectVO> queryListByUserIdAndDate(ClassSubjectDTO classSubjectDTO);
......
package com.platform.business.service; package com.platform.business.service;
import com.baomidou.mybatisplus.extension.service.IService; 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.ClassDTO;
import com.platform.business.model.dto.ClassSubjectDTO;
import com.platform.business.model.entity.ClassEntity; 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 com.platform.business.model.vo.ClassVO;
import java.util.List; import java.util.List;
import java.util.Map;
/** 班级基础管理服务;角色端“我的课程”逻辑由独立服务负责。 */
public interface ClassService extends IService<ClassEntity> { public interface ClassService extends IService<ClassEntity> {
List<ClassVO> queryList(ClassDTO classDTO); List<ClassVO> queryList(ClassDTO classDTO);
ClassVO detail(String id); ClassVO detail(String id);
...@@ -20,29 +17,4 @@ public interface ClassService extends IService<ClassEntity> { ...@@ -20,29 +17,4 @@ public interface ClassService extends IService<ClassEntity> {
boolean saveClass(ClassDTO classDTO); boolean saveClass(ClassDTO classDTO);
boolean deleteStu(String studentId); 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; package com.platform.business.service;
import com.baomidou.mybatisplus.extension.service.IService; import com.baomidou.mybatisplus.extension.service.IService;
import com.platform.business.model.dto.ClassDTO;
import com.platform.business.model.entity.ClassSubjectAttendanceEntity; import com.platform.business.model.entity.ClassSubjectAttendanceEntity;
import java.util.Date;
import java.util.List; import java.util.List;
/** /**
...@@ -14,5 +14,10 @@ import java.util.List; ...@@ -14,5 +14,10 @@ import java.util.List;
*/ */
public interface ClassSubjectAttendanceService extends IService<ClassSubjectAttendanceEntity> { 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> { ...@@ -31,7 +31,8 @@ public interface ClassSubjectService extends IService<ClassSubjectEntity> {
List<ClassSubjectVO> queryOneselfTeacher(String userId); List<ClassSubjectVO> queryOneselfTeacher(String userId);
List<CalendarVO> todayCourse(List<Integer> classIds); /** 查询指定班级集合在某个自然日的课程,日期由服务端生成而不是使用数据库当前时间。 */
List<CalendarVO> todayCourse(List<Integer> classIds, Date date);
List<ClassSubjectVO> queryListByUserIdAndDate(ClassSubjectDTO classSubjectDTO); 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);
}
package com.platform.business.service.impl; package com.platform.business.service.impl;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl; import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.google.common.collect.Lists;
import com.platform.business.mapper.ClassMapper; import com.platform.business.mapper.ClassMapper;
import com.platform.business.constant.AttendanceConstants;
import com.platform.business.model.dto.CalendarDTO;
import com.platform.business.model.dto.ClassDTO; 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.entity.ClassEntity;
import com.platform.business.model.entity.ClassStudentEntity; import com.platform.business.model.entity.ClassStudentEntity;
import com.platform.business.model.entity.ClassSubjectAttendanceEntity;
import com.platform.business.model.entity.SysLevelEntity; import com.platform.business.model.entity.SysLevelEntity;
import com.platform.business.model.vo.*; import com.platform.business.model.vo.ClassStudentVO;
import com.platform.business.service.*; import com.platform.business.model.vo.ClassVO;
import com.platform.business.util.ClassSubjectTimeUtils; import com.platform.business.service.ClassService;
import com.platform.business.service.ClassStudentService;
import com.platform.business.service.SysLevelService;
import com.platform.exception.BusinessException; import com.platform.exception.BusinessException;
import com.platform.utils.DozerUtils; import com.platform.utils.DozerUtils;
import org.springframework.stereotype.Service; import org.springframework.stereotype.Service;
import org.springframework.util.ObjectUtils; import org.springframework.util.ObjectUtils;
import javax.annotation.Resource; import javax.annotation.Resource;
import java.math.BigDecimal; import java.util.Date;
import java.math.RoundingMode; import java.util.List;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;
/** 班级基础管理实现,不再承载学员端或教师端课程页面逻辑。 */
@Service @Service
public class ClassServiceImpl extends ServiceImpl<ClassMapper, ClassEntity> implements ClassService { public class ClassServiceImpl extends ServiceImpl<ClassMapper, ClassEntity> implements ClassService {
@Resource @Resource
private ClassStudentService classStudentService; private ClassStudentService classStudentService;
@Resource
private ClassSubjectService classSubjectService;
@Resource @Resource
private SysLevelService sysLevelService; private SysLevelService sysLevelService;
@Resource
private ExamStudentService examStudentService;
@Resource
private ClassSubjectAttendanceService classSubjectAttendanceService;
@Resource
private AttendanceService attendanceService;
@Override @Override
public List<ClassVO> queryList(ClassDTO classDTO) { public List<ClassVO> queryList(ClassDTO classDTO) {
...@@ -59,497 +46,30 @@ public class ClassServiceImpl extends ServiceImpl<ClassMapper, ClassEntity> impl ...@@ -59,497 +46,30 @@ public class ClassServiceImpl extends ServiceImpl<ClassMapper, ClassEntity> impl
classEntity.setLevel(sysLevel.getName()); classEntity.setLevel(sysLevel.getName());
} }
ClassVO classVO = DozerUtils.convertBean(classEntity, ClassVO.class); ClassVO classVO = DozerUtils.convertBean(classEntity, ClassVO.class);
//查看班级学生 // 班级详情保留原有学员清单,课程页面数据由两个角色专用服务提供。
List<ClassStudentVO> classStudentVOList = classStudentService.queryList(id); List<ClassStudentVO> students = classStudentService.queryList(id);
classVO.setClassStudentList(classStudentVOList); classVO.setClassStudentList(students);
return classVO; return classVO;
} }
@Override @Override
public boolean saveClass(ClassDTO classDTO) { public boolean saveClass(ClassDTO classDTO) {
//保存班级
ClassEntity classEntity = DozerUtils.convertBean(classDTO, ClassEntity.class); ClassEntity classEntity = DozerUtils.convertBean(classDTO, ClassEntity.class);
List<ClassStudentEntity> classStudentEntities = classDTO.getStudentList(); List<ClassStudentEntity> students = classDTO.getStudentList();
if (classEntity.getId() == null) { if (classEntity.getId() == null) {
classEntity.setCreateTime(new Date()); classEntity.setCreateTime(new Date());
save(classEntity); save(classEntity);
} else { } else {
updateById(classEntity); updateById(classEntity);
//先删除班级关联的学生 // 编辑时先重建班级成员关系,保持原接口的全量提交语义。
classStudentService.deleteByClassId(classEntity.getId()); classStudentService.deleteByClassId(classEntity.getId());
} }
//保存班级学生关联 students.forEach(student -> student.setClassId(classEntity.getId()));
classStudentEntities.forEach(classStudentEntity -> classStudentEntity.setClassId(classEntity.getId())); return classStudentService.saveBatch(students);
return classStudentService.saveBatch(classStudentEntities);
} }
@Override @Override
public boolean deleteStu(String studentId) { public boolean deleteStu(String studentId) {
return classStudentService.removeById(studentId); return classStudentService.removeById(studentId);
} }
@Override
public List<ClassVO> schedule(ClassDTO classDTO) {
Date now = new Date();
//查询考试信息
List<ExamStudentVO> examStudentList = examStudentService.queryOneself(classDTO.getUserId());
//获取班级id
List<Integer> classIds = classStudentService.queryClassIdByUserId(classDTO.getUserId());
//查询课程信息
List<ClassSubjectVO> classSubjectList = classSubjectService.queryOneself(classIds, classDTO.getStartDate(), classDTO.getEndDate());
//查询签到数据
List<ClassSubjectAttendanceEntity> classSubjectAttendanceList = classSubjectAttendanceService.queryOneself(classDTO);
HashMap<Integer, ClassSubjectAttendanceEntity> classSubjectAttendanceMap = new HashMap<>();
classSubjectAttendanceList.forEach(classSubjectAttendanceEntity -> classSubjectAttendanceMap.put(classSubjectAttendanceEntity.getSubjectId(), classSubjectAttendanceEntity));
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)) {
//判断状态
ClassSubjectTimeUtils.TimeWindow window = ClassSubjectTimeUtils.resolve(classSubjectVO);
if (now.before(window.getStart())) {
classSubjectVO.setStatus(classSubjectVO.getType());
} else if (classSubjectAttendanceMap.containsKey(classSubjectVO.getId())) {
classSubjectVO.setStatus(displayAttendanceStatus(classSubjectAttendanceMap.get(classSubjectVO.getId()).getStatus()));
} else if (now.before(window.getEnd())) {
classSubjectVO.setStatus("待签到");
} else {
classSubjectVO.setStatus("缺勤");
}
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);
}
return result;
}
@Override
public ClassSubjectVO scheduleDetail(ClassSubjectDTO classSubjectDTO) {
Date now = new Date();
ClassSubjectVO result = new ClassSubjectVO();
List<Integer> classIds = classStudentService.queryClassIdByUserId(classSubjectDTO.getUserId());
classSubjectDTO.setClassIds(classIds);
List<ClassSubjectVO> data = classSubjectService.queryListByUserIdAndDate(classSubjectDTO);
//查询签到数据
List<ClassSubjectAttendanceEntity> classSubjectAttendanceList = classSubjectAttendanceService.list(new LambdaQueryWrapper<>(ClassSubjectAttendanceEntity.class)
.eq(ClassSubjectAttendanceEntity::getUserId, classSubjectDTO.getUserId()));
HashMap<Integer, ClassSubjectAttendanceEntity> classSubjectAttendanceMap = new HashMap<>();
classSubjectAttendanceList.forEach(classSubjectAttendanceEntity -> classSubjectAttendanceMap.put(classSubjectAttendanceEntity.getSubjectId(), classSubjectAttendanceEntity));
//设置状态
for (ClassSubjectVO classSubjectVO : data) {
//判断状态
ClassSubjectTimeUtils.TimeWindow window = ClassSubjectTimeUtils.resolve(classSubjectVO);
if (now.before(window.getStart())) {
classSubjectVO.setStatus(classSubjectVO.getType());
} else if (classSubjectAttendanceMap.containsKey(classSubjectVO.getId())) {
classSubjectVO.setStatus(displayAttendanceStatus(classSubjectAttendanceMap.get(classSubjectVO.getId()).getStatus()));
} else if (now.before(window.getEnd())) {
classSubjectVO.setStatus("待签到");
} else {
classSubjectVO.setStatus("缺勤");
}
}
result.setData(data);
result.setSubjectNum(data.size());
return result;
}
/**
* 判断指定日期是否在时间段中最小的开始时间之前
*
* @param date 要判断的日期时间
* @param baseDate 基准日期(用于组合时间段中的时分秒)
* @param timeFrame 时间段字符串,格式如 "05:00-09:00,10:20-11:20"
* @return true表示date在最小开始时间之前,false表示之后或等于
*/
public static boolean isBeforeMinTime(Date date, Date baseDate, String timeFrame) {
// 用于解析时间格式
SimpleDateFormat sdf = new SimpleDateFormat("HH:mm");
List<Date> startTimes = new ArrayList<>();
// 按逗号拆分时间段
String[] timeFrames = timeFrame.split(",");
for (String tf : timeFrames) {
// 按横杠拆分开始和结束时间
String[] times = tf.split("-");
if (times.length == 2) {
try {
// 解析开始时间的时分
Date timePart = sdf.parse(times[0]);
// 使用Calendar将时分与基准日期组合
Calendar cal = Calendar.getInstance();
cal.setTime(baseDate);
Calendar timeCal = Calendar.getInstance();
timeCal.setTime(timePart);
// 设置时分秒
cal.set(Calendar.HOUR_OF_DAY, timeCal.get(Calendar.HOUR_OF_DAY));
cal.set(Calendar.MINUTE, timeCal.get(Calendar.MINUTE));
cal.set(Calendar.SECOND, 0);
cal.set(Calendar.MILLISECOND, 0);
startTimes.add(cal.getTime());
} catch (ParseException e) {
e.printStackTrace();
// 如果解析失败,跳过这个时间段
continue;
}
}
}
// 如果没有有效的时间段,返回false
if (startTimes.isEmpty()) {
return false;
}
// 找到最小的开始时间
Date minStartTime = startTimes.get(0);
for (Date st : startTimes) {
if (st.before(minStartTime)) {
minStartTime = st;
}
}
// 判断传入的date是否在最小开始时间之前
return date.before(minStartTime);
}
@Override
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, 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
List<Integer> classIds = classStudentService.queryClassIdByUserId(userId);
//获取今日课程数据
List<CalendarVO> result = classSubjectService.todayCourse(classIds);
//获取签到数据
List<ClassSubjectAttendanceEntity> classSubjectAttendanceList = classSubjectAttendanceService.list(
new LambdaQueryWrapper<ClassSubjectAttendanceEntity>().eq(ClassSubjectAttendanceEntity::getUserId, userId)
);
HashMap<Integer, ClassSubjectAttendanceEntity> classSubjectAttendanceMap = new HashMap<>();
for (ClassSubjectAttendanceEntity classSubjectAttendanceEntity : classSubjectAttendanceList) {
classSubjectAttendanceMap.put(classSubjectAttendanceEntity.getSubjectId(), classSubjectAttendanceEntity);
}
for (CalendarVO calendarVO : result) {
if (classSubjectAttendanceMap.containsKey(calendarVO.getSubjectId())) {
ClassSubjectAttendanceEntity attendance = classSubjectAttendanceMap.get(calendarVO.getSubjectId());
calendarVO.setSignInTime(attendance.getCheckInTime());
calendarVO.setAttendanceStatus(attendance.getStatus());
calendarVO.setCheckInMethod(attendance.getCheckInMethod());
calendarVO.setIsSignIn(AttendanceConstants.isPresent(attendance.getStatus()));
} else {
calendarVO.setIsSignIn(false);
calendarVO.setAttendanceStatus("PENDING");
}
}
return result;
}
@Override
public Boolean todayCourseSignIn(CalendarDTO calendarDTO) {
throw new BusinessException("原签到接口已停用,请使用 /attendance/student/check-in 完成IP和验证码校验");
}
@Override
public Map<String, Integer> studentCourseSummary(ClassDTO classDTO) {
//获取班级id
List<Integer> classIds = classStudentService.queryClassIdByUserId(classDTO.getUserId());
//查询课程信息
List<ClassSubjectVO> classSubjectList = classSubjectService.queryOneself(classIds, classDTO.getStartDate(), classDTO.getEndDate());
//查询签到信息
List<ClassSubjectAttendanceEntity> classSubjectAttendanceList = classSubjectAttendanceService.queryOneself(classDTO);
//查询课程数据
HashMap<String, Integer> result = new HashMap<>();
//本月课程
result.put("本月课程", classSubjectList.size());
Map<Integer, ClassSubjectAttendanceEntity> attendanceMap = new HashMap<>();
for (ClassSubjectAttendanceEntity attendance : classSubjectAttendanceList) {
attendanceMap.put(attendance.getSubjectId(), attendance);
}
int normal = 0;
int late = 0;
int absent = 0;
int leave = 0;
int pending = 0;
Date now = new Date();
for (ClassSubjectVO subject : classSubjectList) {
ClassSubjectAttendanceEntity attendance = attendanceMap.get(subject.getId());
if (attendance != null) {
if (AttendanceConstants.STATUS_NORMAL.equals(attendance.getStatus())) normal++;
else if (AttendanceConstants.STATUS_LATE.equals(attendance.getStatus())) late++;
else if (AttendanceConstants.STATUS_ABSENT.equals(attendance.getStatus())) absent++;
else if (AttendanceConstants.STATUS_LEAVE.equals(attendance.getStatus())) leave++;
} else if (now.before(ClassSubjectTimeUtils.resolve(subject).getEnd())) {
pending++;
} else {
absent++;
}
}
int signed = normal + late;
int finished = signed + absent + leave;
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 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;
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返回的聚合字段补充稳定的页面状态和嵌套出勤对象。
* 状态判断必须先判断课程是否尚未开始,避免“全班提前请假”被误判为已完成课程。
*/
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 "迟到";
if (AttendanceConstants.STATUS_ABSENT.equals(status)) return "缺勤";
if (AttendanceConstants.STATUS_LEAVE.equals(status)) return "请假";
return "已签到";
}
/**
* 方法2: 使用SimpleDateFormat格式化比较
* 将日期格式化为"yyyyMMdd"后比较字符串
*
* @param date1 第一个Date对象
* @param date2 第二个Date对象
* @return 是否为同一天
*/
public static boolean isSameDayWithFormat(Date date1, Date date2) {
SimpleDateFormat dayFormat = new SimpleDateFormat("yyyyMMdd");
return dayFormat.format(date1).equals(dayFormat.format(date2));
}
/**
* 获取两个日期之间的所有日期集合 (包含开始和结束日期)
*
* @param beginDate 开始日期
* @param endDate 结束日期
* @return 包含所有日期的List集合
*/
public static List<Date> getDatesBetweenTwoDate(Date beginDate, Date endDate) {
List<Date> dateList = new ArrayList<>();
// 将开始日期加入集合
dateList.add(beginDate);
Calendar cal = Calendar.getInstance();
cal.setTime(beginDate);
// 循环添加日期,直到超过结束日期
while (endDate.after(cal.getTime())) {
cal.add(Calendar.DAY_OF_MONTH, 1); // 增加一天
if (!endDate.before(cal.getTime())) {
dateList.add(cal.getTime());
}
}
return dateList;
}
} }
...@@ -2,11 +2,11 @@ package com.platform.business.service.impl; ...@@ -2,11 +2,11 @@ package com.platform.business.service.impl;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl; import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.platform.business.mapper.ClassSubjectAttendanceMapper; import com.platform.business.mapper.ClassSubjectAttendanceMapper;
import com.platform.business.model.dto.ClassDTO;
import com.platform.business.model.entity.ClassSubjectAttendanceEntity; import com.platform.business.model.entity.ClassSubjectAttendanceEntity;
import com.platform.business.service.ClassSubjectAttendanceService; import com.platform.business.service.ClassSubjectAttendanceService;
import org.springframework.stereotype.Service; import org.springframework.stereotype.Service;
import java.util.Date;
import java.util.List; import java.util.List;
/** /**
...@@ -18,7 +18,8 @@ import java.util.List; ...@@ -18,7 +18,8 @@ import java.util.List;
@Service @Service
public class ClassSubjectAttendanceServiceImpl extends ServiceImpl<ClassSubjectAttendanceMapper, ClassSubjectAttendanceEntity> implements ClassSubjectAttendanceService { public class ClassSubjectAttendanceServiceImpl extends ServiceImpl<ClassSubjectAttendanceMapper, ClassSubjectAttendanceEntity> implements ClassSubjectAttendanceService {
@Override @Override
public List<ClassSubjectAttendanceEntity> queryOneself(ClassDTO classDTO) { public List<ClassSubjectAttendanceEntity> queryByStudentAndRange(
return baseMapper.queryOneself(classDTO); String studentId, Date startDate, Date endDate) {
return baseMapper.queryByStudentAndRange(studentId, startDate, endDate);
} }
} }
...@@ -268,8 +268,8 @@ public class ClassSubjectServiceImpl extends ServiceImpl<ClassSubjectMapper, Cla ...@@ -268,8 +268,8 @@ public class ClassSubjectServiceImpl extends ServiceImpl<ClassSubjectMapper, Cla
} }
@Override @Override
public List<CalendarVO> todayCourse(List<Integer> classIds) { public List<CalendarVO> todayCourse(List<Integer> classIds, Date date) {
return baseMapper.todayCourse(classIds); return baseMapper.todayCourse(classIds, date);
} }
@Override @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 @@ ...@@ -99,7 +99,8 @@
end end
</insert> </insert>
<select id="queryOneself" resultType="com.platform.business.model.entity.ClassSubjectAttendanceEntity"> <!-- 学员课程页面只读取当前日期范围,避免每次打开月历扫描本人全部历史出勤。 -->
<select id="queryByStudentAndRange" resultType="com.platform.business.model.entity.ClassSubjectAttendanceEntity">
select select
a.id, a.id,
a.subject_id, a.subject_id,
...@@ -118,7 +119,7 @@ ...@@ -118,7 +119,7 @@
inner join inner join
class_subject s on s.id = a.subject_id class_subject s on s.id = a.subject_id
where where
a.user_id = #{userId} a.user_id = #{studentId}
and and
s.date between #{startDate} and #{endDate} s.date between #{startDate} and #{endDate}
</select> </select>
......
...@@ -90,6 +90,8 @@ ...@@ -90,6 +90,8 @@
</foreach> </foreach>
and and
cs.date between #{startDate} and #{endDate} cs.date between #{startDate} and #{endDate}
order by
cs.date asc, cs.time_frame asc, cs.id asc
</select> </select>
<select id="queryOneselfTeacher" resultType="com.platform.business.model.vo.ClassSubjectVO"> <select id="queryOneselfTeacher" resultType="com.platform.business.model.vo.ClassSubjectVO">
select select
...@@ -135,24 +137,41 @@ ...@@ -135,24 +137,41 @@
<foreach item="item" index="index" collection="classIds" open="(" separator="," close=")"> <foreach item="item" index="index" collection="classIds" open="(" separator="," close=")">
#{item} #{item}
</foreach> </foreach>
and cs.date = #{date}
order by cs.time_frame asc, cs.id asc
</select> </select>
<select id="queryListByUserIdAndDate" resultType="com.platform.business.model.vo.ClassSubjectVO"> <select id="queryListByUserIdAndDate" resultType="com.platform.business.model.vo.ClassSubjectVO">
select select
cs.id,
cs.class_id,
cs.subject_times,
cs.date,
cs.week,
cs.time_frame, cs.time_frame,
cs.subject_hour,
cs.subject_name, cs.subject_name,
u.nick_name, cs.teacher_id,
cs.type cs.remark,
cs.location,
cs.type,
u.nick_name as teacherName,
c.name as className
from from
class_subject cs class_subject cs
left join left join
user u user u
on on
cs.teacher_id = u.id 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 and cs.class_id in
<foreach item="item" index="index" collection="classIds" open="(" separator="," close=")"> <foreach item="item" index="index" collection="classIds" open="(" separator="," close=")">
#{item} #{item}
</foreach> </foreach>
order by cs.time_frame asc, cs.id asc
</select> </select>
<select id="queryTeacherCourse" resultType="com.platform.business.model.vo.ClassSubjectVO"> <select id="queryTeacherCourse" resultType="com.platform.business.model.vo.ClassSubjectVO">
select 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