新增教育管理模块后端核心功能

- 新增学期管理功能:EduSemesterController、EduSemesterService、EduSemester实体类
- 新增课程班级管理功能:EduCourseClassController、EduCourseClassService、EduCourseClass实体类
- 新增课程安排管理功能:EduCourseScheduleController、EduCourseScheduleService、EduCourseSchedule实体类
- 新增对应的MyBatis映射文件和数据访问接口
- 实现完整的CRUD操作和业务逻辑处理
This commit is contained in:
Leo 2025-09-28 21:48:58 +08:00
parent 05c9143f64
commit 233bce0b25
18 changed files with 4348 additions and 0 deletions

View File

@ -0,0 +1,340 @@
package com.ruoyi.web.controller.education;
import java.util.List;
import javax.servlet.http.HttpServletResponse;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.ruoyi.common.annotation.Log;
import com.ruoyi.common.core.controller.BaseController;
import com.ruoyi.common.core.domain.AjaxResult;
import com.ruoyi.common.enums.BusinessType;
import com.ruoyi.education.domain.EduCourseClass;
import com.ruoyi.education.service.IEduCourseClassService;
import com.ruoyi.common.utils.poi.ExcelUtil;
import com.ruoyi.common.core.page.TableDataInfo;
import com.ruoyi.common.utils.StringUtils;
/**
* 开课计划Controller
*
* @author ruoyi
* @date 2024-09-26
*/
@RestController
@RequestMapping("/education/courseClass")
public class EduCourseClassController extends BaseController
{
@Autowired
private IEduCourseClassService eduCourseClassService;
/**
* 查询开课计划列表
*/
@PreAuthorize("@ss.hasPermi('education:courseClass:list')")
@GetMapping("/list")
public TableDataInfo list(EduCourseClass eduCourseClass)
{
startPage();
List<EduCourseClass> list = eduCourseClassService.selectEduCourseClassList(eduCourseClass);
return getDataTable(list);
}
/**
* 导出开课计划列表
*/
@PreAuthorize("@ss.hasPermi('education:courseClass:export')")
@Log(title = "开课计划", businessType = BusinessType.EXPORT)
@PostMapping("/export")
public void export(HttpServletResponse response, EduCourseClass eduCourseClass)
{
List<EduCourseClass> list = eduCourseClassService.selectEduCourseClassList(eduCourseClass);
ExcelUtil<EduCourseClass> util = new ExcelUtil<EduCourseClass>(EduCourseClass.class);
util.exportExcel(response, list, "开课计划数据");
}
/**
* 获取开课计划详细信息
*/
@PreAuthorize("@ss.hasPermi('education:courseClass:query')")
@GetMapping(value = "/{classId}")
public AjaxResult getInfo(@PathVariable("classId") Long classId)
{
return success(eduCourseClassService.selectEduCourseClassByClassId(classId));
}
/**
* 新增开课计划
*/
@PreAuthorize("@ss.hasPermi('education:courseClass:add')")
@Log(title = "开课计划", businessType = BusinessType.INSERT)
@PostMapping
public AjaxResult add(@RequestBody EduCourseClass eduCourseClass)
{
if ("NOT_UNIQUE".equals(eduCourseClassService.checkClassCodeUnique(eduCourseClass)))
{
return error("新增开课计划失败,班级编号已存在");
}
String capacityResult = eduCourseClassService.checkCapacityValid(eduCourseClass);
if (!"VALID".equals(capacityResult))
{
return getCapacityErrorMessage(capacityResult);
}
String classroomConflictResult = eduCourseClassService.checkClassroomConflict(eduCourseClass);
if ("CONFLICT".equals(classroomConflictResult))
{
return error("新增开课计划失败,教室时间冲突");
}
String teacherConflictResult = eduCourseClassService.checkTeacherConflict(eduCourseClass);
if ("CONFLICT".equals(teacherConflictResult))
{
return error("新增开课计划失败,教师时间冲突");
}
eduCourseClass.setCreateBy(getUsername());
return toAjax(eduCourseClassService.insertEduCourseClass(eduCourseClass));
}
/**
* 修改开课计划
*/
@PreAuthorize("@ss.hasPermi('education:courseClass:edit')")
@Log(title = "开课计划", businessType = BusinessType.UPDATE)
@PutMapping
public AjaxResult edit(@RequestBody EduCourseClass eduCourseClass)
{
if ("NOT_UNIQUE".equals(eduCourseClassService.checkClassCodeUnique(eduCourseClass)))
{
return error("修改开课计划失败,班级编号已存在");
}
String capacityResult = eduCourseClassService.checkCapacityValid(eduCourseClass);
if (!"VALID".equals(capacityResult))
{
return getCapacityErrorMessage(capacityResult);
}
String classroomConflictResult = eduCourseClassService.checkClassroomConflict(eduCourseClass);
if ("CONFLICT".equals(classroomConflictResult))
{
return error("修改开课计划失败,教室时间冲突");
}
String teacherConflictResult = eduCourseClassService.checkTeacherConflict(eduCourseClass);
if ("CONFLICT".equals(teacherConflictResult))
{
return error("修改开课计划失败,教师时间冲突");
}
eduCourseClass.setUpdateBy(getUsername());
return toAjax(eduCourseClassService.updateEduCourseClass(eduCourseClass));
}
/**
* 删除开课计划
*/
@PreAuthorize("@ss.hasPermi('education:courseClass:remove')")
@Log(title = "开课计划", businessType = BusinessType.DELETE)
@DeleteMapping("/{classIds}")
public AjaxResult remove(@PathVariable Long[] classIds)
{
return toAjax(eduCourseClassService.deleteEduCourseClassByClassIds(classIds));
}
/**
* 发布开课计划
*/
@PreAuthorize("@ss.hasPermi('education:courseClass:publish')")
@Log(title = "发布开课计划", businessType = BusinessType.UPDATE)
@PutMapping("/publish/{classId}")
public AjaxResult publishCourseClass(@PathVariable Long classId)
{
EduCourseClass courseClass = eduCourseClassService.selectEduCourseClassByClassId(classId);
if (StringUtils.isNull(courseClass))
{
return error("开课计划不存在");
}
if (!"0".equals(courseClass.getStatus()))
{
return error("只有待发布状态的开课计划才能发布");
}
return toAjax(eduCourseClassService.publishCourseClass(classId));
}
/**
* 批量发布开课计划
*/
@PreAuthorize("@ss.hasPermi('education:courseClass:publish')")
@Log(title = "批量发布开课计划", businessType = BusinessType.UPDATE)
@PutMapping("/batchPublish")
public AjaxResult batchPublishCourseClass(@RequestBody Long[] classIds)
{
return toAjax(eduCourseClassService.batchPublishCourseClass(classIds));
}
/**
* 停止选课
*/
@PreAuthorize("@ss.hasPermi('education:courseClass:edit')")
@Log(title = "停止选课", businessType = BusinessType.UPDATE)
@PutMapping("/stopEnrollment/{classId}")
public AjaxResult stopEnrollment(@PathVariable Long classId)
{
EduCourseClass courseClass = eduCourseClassService.selectEduCourseClassByClassId(classId);
if (StringUtils.isNull(courseClass))
{
return error("开课计划不存在");
}
if (!"1".equals(courseClass.getStatus()))
{
return error("只有可选课状态的开课计划才能停止选课");
}
return toAjax(eduCourseClassService.stopEnrollment(classId));
}
/**
* 结课
*/
@PreAuthorize("@ss.hasPermi('education:courseClass:edit')")
@Log(title = "结课", businessType = BusinessType.UPDATE)
@PutMapping("/finish/{classId}")
public AjaxResult finishCourse(@PathVariable Long classId)
{
EduCourseClass courseClass = eduCourseClassService.selectEduCourseClassByClassId(classId);
if (StringUtils.isNull(courseClass))
{
return error("开课计划不存在");
}
if (!"1".equals(courseClass.getStatus()) && !"2".equals(courseClass.getStatus()))
{
return error("只有可选课或已满额状态的开课计划才能结课");
}
return toAjax(eduCourseClassService.finishCourse(classId));
}
/**
* 调整容量
*/
@PreAuthorize("@ss.hasPermi('education:courseClass:capacity')")
@Log(title = "调整容量", businessType = BusinessType.UPDATE)
@PutMapping("/adjustCapacity/{classId}/{newCapacity}")
public AjaxResult adjustCapacity(@PathVariable Long classId, @PathVariable Integer newCapacity)
{
if (newCapacity == null || newCapacity <= 0)
{
return error("容量必须大于0");
}
int result = eduCourseClassService.adjustCapacity(classId, newCapacity);
if (result == -1)
{
return error("新容量不能小于已选课人数");
}
return toAjax(result);
}
/**
* 获取指定学期的开课计划
*/
@PreAuthorize("@ss.hasPermi('education:courseClass:query')")
@GetMapping("/semester/{semesterId}")
public AjaxResult getBySemester(@PathVariable Long semesterId)
{
return success(eduCourseClassService.selectCourseClassBySemester(semesterId));
}
/**
* 获取指定教师的开课计划
*/
@PreAuthorize("@ss.hasPermi('education:courseClass:query')")
@GetMapping("/teacher/{teacherId}")
public AjaxResult getByTeacher(@PathVariable Long teacherId)
{
return success(eduCourseClassService.selectCourseClassByTeacher(teacherId));
}
/**
* 获取可选课的开课计划
*/
@PreAuthorize("@ss.hasPermi('education:courseClass:query')")
@GetMapping("/enrollable")
public AjaxResult getEnrollableCourseClasses()
{
return success(eduCourseClassService.selectEnrollableCourseClasses());
}
/**
* 获取开课计划统计信息
*/
@PreAuthorize("@ss.hasPermi('education:courseClass:query')")
@GetMapping("/statistics/{semesterId}")
public AjaxResult getStatistics(@PathVariable Long semesterId)
{
return success(eduCourseClassService.getCourseClassStatistics(semesterId));
}
/**
* 获取课程列表用于下拉选择
*/
@PreAuthorize("@ss.hasPermi('education:courseClass:query')")
@GetMapping("/courseOptions")
public AjaxResult getCourseOptions()
{
return success(eduCourseClassService.getCourseOptions());
}
/**
* 获取教师列表用于下拉选择
*/
@PreAuthorize("@ss.hasPermi('education:courseClass:query')")
@GetMapping("/teacherOptions")
public AjaxResult getTeacherOptions()
{
return success(eduCourseClassService.getTeacherOptions());
}
/**
* 获取教室列表用于下拉选择
*/
@PreAuthorize("@ss.hasPermi('education:courseClass:query')")
@GetMapping("/classroomOptions")
public AjaxResult getClassroomOptions()
{
return success(eduCourseClassService.getClassroomOptions());
}
/**
* 获取容量校验错误信息
*/
private AjaxResult getCapacityErrorMessage(String capacityResult)
{
switch (capacityResult)
{
case "INVALID_CAPACITY":
return error("容量必须大于0");
case "ENROLL_LIMIT_EXCEED_CAPACITY":
return error("选课人数上限不能超过容量");
case "ENROLLED_EXCEED_LIMIT":
return error("已选课人数超过了容量限制");
default:
return error("容量设置无效");
}
}
}

View File

@ -0,0 +1,404 @@
package com.ruoyi.web.controller.education;
import java.util.List;
import javax.servlet.http.HttpServletResponse;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.ruoyi.common.annotation.Log;
import com.ruoyi.common.core.controller.BaseController;
import com.ruoyi.common.core.domain.AjaxResult;
import com.ruoyi.common.enums.BusinessType;
import com.ruoyi.education.domain.EduCourseSchedule;
import com.ruoyi.education.service.IEduCourseScheduleService;
import com.ruoyi.common.utils.poi.ExcelUtil;
import com.ruoyi.common.core.page.TableDataInfo;
import com.ruoyi.common.utils.StringUtils;
/**
* 开课节次安排Controller
*
* @author ruoyi
* @date 2024-09-26
*/
@RestController
@RequestMapping("/education/schedule")
public class EduCourseScheduleController extends BaseController
{
@Autowired
private IEduCourseScheduleService eduCourseScheduleService;
/**
* 查询开课节次安排列表
*/
@PreAuthorize("@ss.hasPermi('education:schedule:list')")
@GetMapping("/list")
public TableDataInfo list(EduCourseSchedule eduCourseSchedule)
{
startPage();
List<EduCourseSchedule> list = eduCourseScheduleService.selectEduCourseScheduleList(eduCourseSchedule);
return getDataTable(list);
}
/**
* 导出开课节次安排列表
*/
@PreAuthorize("@ss.hasPermi('education:schedule:export')")
@Log(title = "开课节次安排", businessType = BusinessType.EXPORT)
@PostMapping("/export")
public void export(HttpServletResponse response, EduCourseSchedule eduCourseSchedule)
{
List<EduCourseSchedule> list = eduCourseScheduleService.selectEduCourseScheduleList(eduCourseSchedule);
ExcelUtil<EduCourseSchedule> util = new ExcelUtil<EduCourseSchedule>(EduCourseSchedule.class);
util.exportExcel(response, list, "开课节次安排数据");
}
/**
* 获取开课节次安排详细信息
*/
@PreAuthorize("@ss.hasPermi('education:schedule:query')")
@GetMapping(value = "/{scheduleId}")
public AjaxResult getInfo(@PathVariable("scheduleId") Long scheduleId)
{
return success(eduCourseScheduleService.selectEduCourseScheduleByScheduleId(scheduleId));
}
/**
* 新增开课节次安排
*/
@PreAuthorize("@ss.hasPermi('education:schedule:add')")
@Log(title = "开课节次安排", businessType = BusinessType.INSERT)
@PostMapping
public AjaxResult add(@RequestBody EduCourseSchedule eduCourseSchedule)
{
String periodResult = eduCourseScheduleService.checkPeriodValid(eduCourseSchedule);
if (!"VALID".equals(periodResult))
{
return getPeriodErrorMessage(periodResult);
}
String weeksResult = eduCourseScheduleService.checkWeeksValid(eduCourseSchedule.getWeeks());
if (!"VALID".equals(weeksResult))
{
return getWeeksErrorMessage(weeksResult);
}
String conflictResult = eduCourseScheduleService.checkTimeConflict(eduCourseSchedule);
if (!"NO_CONFLICT".equals(conflictResult))
{
return getConflictErrorMessage(conflictResult);
}
eduCourseSchedule.setCreateBy(getUsername());
return toAjax(eduCourseScheduleService.insertEduCourseSchedule(eduCourseSchedule));
}
/**
* 修改开课节次安排
*/
@PreAuthorize("@ss.hasPermi('education:schedule:edit')")
@Log(title = "开课节次安排", businessType = BusinessType.UPDATE)
@PutMapping
public AjaxResult edit(@RequestBody EduCourseSchedule eduCourseSchedule)
{
String periodResult = eduCourseScheduleService.checkPeriodValid(eduCourseSchedule);
if (!"VALID".equals(periodResult))
{
return getPeriodErrorMessage(periodResult);
}
String weeksResult = eduCourseScheduleService.checkWeeksValid(eduCourseSchedule.getWeeks());
if (!"VALID".equals(weeksResult))
{
return getWeeksErrorMessage(weeksResult);
}
String conflictResult = eduCourseScheduleService.checkTimeConflict(eduCourseSchedule);
if (!"NO_CONFLICT".equals(conflictResult))
{
return getConflictErrorMessage(conflictResult);
}
eduCourseSchedule.setUpdateBy(getUsername());
return toAjax(eduCourseScheduleService.updateEduCourseSchedule(eduCourseSchedule));
}
/**
* 删除开课节次安排
*/
@PreAuthorize("@ss.hasPermi('education:schedule:remove')")
@Log(title = "开课节次安排", businessType = BusinessType.DELETE)
@DeleteMapping("/{scheduleIds}")
public AjaxResult remove(@PathVariable Long[] scheduleIds)
{
return toAjax(eduCourseScheduleService.deleteEduCourseScheduleByScheduleIds(scheduleIds));
}
/**
* 根据开课ID查询节次安排
*/
@PreAuthorize("@ss.hasPermi('education:schedule:query')")
@GetMapping("/class/{classId}")
public AjaxResult getByClassId(@PathVariable Long classId)
{
return success(eduCourseScheduleService.selectScheduleByClassId(classId));
}
/**
* 根据开课ID删除节次安排
*/
@PreAuthorize("@ss.hasPermi('education:schedule:remove')")
@Log(title = "删除开课节次安排", businessType = BusinessType.DELETE)
@DeleteMapping("/class/{classId}")
public AjaxResult removeByClassId(@PathVariable Long classId)
{
return toAjax(eduCourseScheduleService.deleteScheduleByClassId(classId));
}
/**
* 查询指定教室的课程安排
*/
@PreAuthorize("@ss.hasPermi('education:schedule:query')")
@GetMapping("/classroom/{classroomId}/{semesterId}")
public AjaxResult getByClassroom(@PathVariable Long classroomId, @PathVariable Long semesterId)
{
return success(eduCourseScheduleService.selectScheduleByClassroom(classroomId, semesterId));
}
/**
* 查询指定教师的课程安排
*/
@PreAuthorize("@ss.hasPermi('education:schedule:query')")
@GetMapping("/teacher/{teacherId}/{semesterId}")
public AjaxResult getByTeacher(@PathVariable Long teacherId, @PathVariable Long semesterId)
{
return success(eduCourseScheduleService.selectScheduleByTeacher(teacherId, semesterId));
}
/**
* 查询指定学期的所有课程安排
*/
@PreAuthorize("@ss.hasPermi('education:schedule:query')")
@GetMapping("/semester/{semesterId}")
public AjaxResult getBySemester(@PathVariable Long semesterId)
{
return success(eduCourseScheduleService.selectScheduleBySemester(semesterId));
}
/**
* 生成教室课表
*/
@PreAuthorize("@ss.hasPermi('education:schedule:query')")
@GetMapping("/timetable/classroom/{classroomId}/{semesterId}")
public AjaxResult generateClassroomTimetable(@PathVariable Long classroomId, @PathVariable Long semesterId)
{
return success(eduCourseScheduleService.generateClassroomTimetable(classroomId, semesterId));
}
/**
* 生成教师课表
*/
@PreAuthorize("@ss.hasPermi('education:schedule:query')")
@GetMapping("/timetable/teacher/{teacherId}/{semesterId}")
public AjaxResult generateTeacherTimetable(@PathVariable Long teacherId, @PathVariable Long semesterId)
{
return success(eduCourseScheduleService.generateTeacherTimetable(teacherId, semesterId));
}
/**
* 批量添加节次安排
*/
@PreAuthorize("@ss.hasPermi('education:schedule:add')")
@Log(title = "批量添加节次安排", businessType = BusinessType.INSERT)
@PostMapping("/batch/{classId}")
public AjaxResult batchAdd(@PathVariable Long classId, @RequestBody List<EduCourseSchedule> scheduleList)
{
if (scheduleList == null || scheduleList.isEmpty())
{
return error("节次安排列表不能为空");
}
for (EduCourseSchedule schedule : scheduleList)
{
String periodResult = eduCourseScheduleService.checkPeriodValid(schedule);
if (!"VALID".equals(periodResult))
{
return error("" + scheduleList.indexOf(schedule) + "项:" + getPeriodErrorText(periodResult));
}
String weeksResult = eduCourseScheduleService.checkWeeksValid(schedule.getWeeks());
if (!"VALID".equals(weeksResult))
{
return error("" + scheduleList.indexOf(schedule) + "项:" + getWeeksErrorText(weeksResult));
}
String conflictResult = eduCourseScheduleService.checkTimeConflict(schedule);
if (!"NO_CONFLICT".equals(conflictResult))
{
return error("" + scheduleList.indexOf(schedule) + "项:" + getConflictErrorText(conflictResult));
}
}
return toAjax(eduCourseScheduleService.batchAddSchedule(classId, scheduleList));
}
/**
* 复制节次安排
*/
@PreAuthorize("@ss.hasPermi('education:schedule:add')")
@Log(title = "复制节次安排", businessType = BusinessType.INSERT)
@PostMapping("/copy/{sourceClassId}/{targetClassId}")
public AjaxResult copySchedule(@PathVariable Long sourceClassId, @PathVariable Long targetClassId)
{
return toAjax(eduCourseScheduleService.copySchedule(sourceClassId, targetClassId));
}
/**
* 自动排课
*/
@PreAuthorize("@ss.hasPermi('education:schedule:add')")
@Log(title = "自动排课", businessType = BusinessType.INSERT)
@PostMapping("/auto/{classId}/{semesterId}/{courseHours}")
public AjaxResult autoSchedule(@PathVariable Long classId, @PathVariable Long semesterId, @PathVariable Integer courseHours)
{
String result = eduCourseScheduleService.autoSchedule(classId, semesterId, courseHours);
if ("AUTO_SCHEDULE_NOT_IMPLEMENTED".equals(result))
{
return error("自动排课功能暂未实现");
}
return success("自动排课完成");
}
/**
* 获取时间段统计信息
*/
@PreAuthorize("@ss.hasPermi('education:schedule:query')")
@GetMapping("/statistics/{semesterId}")
public AjaxResult getStatistics(@PathVariable Long semesterId)
{
return success(eduCourseScheduleService.getTimeSlotStatistics(semesterId));
}
/**
* 获取节次校验错误信息
*/
private AjaxResult getPeriodErrorMessage(String periodResult)
{
switch (periodResult)
{
case "INVALID_WEEKDAY":
return error("星期几必须在1-7之间");
case "INVALID_PERIOD_START":
return error("开始节次必须在1-12之间");
case "INVALID_PERIOD_END":
return error("结束节次必须在1-12之间");
case "PERIOD_START_AFTER_END":
return error("开始节次不能大于结束节次");
case "PERIOD_TOO_LONG":
return error("单次课程最多不能超过4节课");
default:
return error("节次设置无效");
}
}
/**
* 获取周次校验错误信息
*/
private AjaxResult getWeeksErrorMessage(String weeksResult)
{
switch (weeksResult)
{
case "INVALID_FORMAT":
return error("周次格式不正确,应为数字、逗号、减号的组合");
case "INVALID_RANGE":
return error("周次范围格式不正确");
case "INVALID_WEEK_NUMBER":
return error("周次必须在1-25之间");
case "INVALID_NUMBER":
return error("周次必须为数字");
default:
return error("周次设置无效");
}
}
/**
* 获取冲突校验错误信息
*/
private AjaxResult getConflictErrorMessage(String conflictResult)
{
switch (conflictResult)
{
case "CLASSROOM_CONFLICT":
return error("教室时间冲突");
case "TEACHER_CONFLICT":
return error("教师时间冲突");
default:
return error("时间冲突");
}
}
/**
* 获取节次校验错误文本
*/
private String getPeriodErrorText(String periodResult)
{
switch (periodResult)
{
case "INVALID_WEEKDAY":
return "星期几必须在1-7之间";
case "INVALID_PERIOD_START":
return "开始节次必须在1-12之间";
case "INVALID_PERIOD_END":
return "结束节次必须在1-12之间";
case "PERIOD_START_AFTER_END":
return "开始节次不能大于结束节次";
case "PERIOD_TOO_LONG":
return "单次课程最多不能超过4节课";
default:
return "节次设置无效";
}
}
/**
* 获取周次校验错误文本
*/
private String getWeeksErrorText(String weeksResult)
{
switch (weeksResult)
{
case "INVALID_FORMAT":
return "周次格式不正确";
case "INVALID_RANGE":
return "周次范围格式不正确";
case "INVALID_WEEK_NUMBER":
return "周次必须在1-25之间";
case "INVALID_NUMBER":
return "周次必须为数字";
default:
return "周次设置无效";
}
}
/**
* 获取冲突校验错误文本
*/
private String getConflictErrorText(String conflictResult)
{
switch (conflictResult)
{
case "CLASSROOM_CONFLICT":
return "教室时间冲突";
case "TEACHER_CONFLICT":
return "教师时间冲突";
default:
return "时间冲突";
}
}
}

View File

@ -0,0 +1,201 @@
package com.ruoyi.web.controller.education;
import java.util.List;
import javax.servlet.http.HttpServletResponse;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.ruoyi.common.annotation.Log;
import com.ruoyi.common.core.controller.BaseController;
import com.ruoyi.common.core.domain.AjaxResult;
import com.ruoyi.common.enums.BusinessType;
import com.ruoyi.education.domain.EduSemester;
import com.ruoyi.education.service.IEduSemesterService;
import com.ruoyi.common.utils.poi.ExcelUtil;
import com.ruoyi.common.core.page.TableDataInfo;
import com.ruoyi.common.utils.StringUtils;
/**
* 学期信息Controller
*
* @author ruoyi
* @date 2024-09-26
*/
@RestController
@RequestMapping("/education/semester")
public class EduSemesterController extends BaseController
{
@Autowired
private IEduSemesterService eduSemesterService;
/**
* 查询学期信息列表
*/
@PreAuthorize("@ss.hasPermi('education:semester:list')")
@GetMapping("/list")
public TableDataInfo list(EduSemester eduSemester)
{
startPage();
List<EduSemester> list = eduSemesterService.selectEduSemesterList(eduSemester);
return getDataTable(list);
}
/**
* 导出学期信息列表
*/
@PreAuthorize("@ss.hasPermi('education:semester:export')")
@Log(title = "学期信息", businessType = BusinessType.EXPORT)
@PostMapping("/export")
public void export(HttpServletResponse response, EduSemester eduSemester)
{
List<EduSemester> list = eduSemesterService.selectEduSemesterList(eduSemester);
ExcelUtil<EduSemester> util = new ExcelUtil<EduSemester>(EduSemester.class);
util.exportExcel(response, list, "学期信息数据");
}
/**
* 获取学期信息详细信息
*/
@PreAuthorize("@ss.hasPermi('education:semester:query')")
@GetMapping(value = "/{semesterId}")
public AjaxResult getInfo(@PathVariable("semesterId") Long semesterId)
{
return success(eduSemesterService.selectEduSemesterBySemesterId(semesterId));
}
/**
* 新增学期信息
*/
@PreAuthorize("@ss.hasPermi('education:semester:add')")
@Log(title = "学期信息", businessType = BusinessType.INSERT)
@PostMapping
public AjaxResult add(@RequestBody EduSemester eduSemester)
{
if ("NOT_UNIQUE".equals(eduSemesterService.checkSemesterCodeUnique(eduSemester)))
{
return error("新增学期'" + eduSemester.getSemesterName() + "'失败,学期编码已存在");
}
String timeConflictResult = eduSemesterService.checkSemesterTimeConflict(eduSemester);
if ("CONFLICT".equals(timeConflictResult))
{
return error("新增学期'" + eduSemester.getSemesterName() + "'失败,教学时间与其他学期冲突");
}
else if ("ENROLL_CONFLICT".equals(timeConflictResult))
{
return error("新增学期'" + eduSemester.getSemesterName() + "'失败,选课时间与其他学期冲突");
}
eduSemester.setCreateBy(getUsername());
return toAjax(eduSemesterService.insertEduSemester(eduSemester));
}
/**
* 修改学期信息
*/
@PreAuthorize("@ss.hasPermi('education:semester:edit')")
@Log(title = "学期信息", businessType = BusinessType.UPDATE)
@PutMapping
public AjaxResult edit(@RequestBody EduSemester eduSemester)
{
if ("NOT_UNIQUE".equals(eduSemesterService.checkSemesterCodeUnique(eduSemester)))
{
return error("修改学期'" + eduSemester.getSemesterName() + "'失败,学期编码已存在");
}
String timeConflictResult = eduSemesterService.checkSemesterTimeConflict(eduSemester);
if ("CONFLICT".equals(timeConflictResult))
{
return error("修改学期'" + eduSemester.getSemesterName() + "'失败,教学时间与其他学期冲突");
}
else if ("ENROLL_CONFLICT".equals(timeConflictResult))
{
return error("修改学期'" + eduSemester.getSemesterName() + "'失败,选课时间与其他学期冲突");
}
eduSemester.setUpdateBy(getUsername());
return toAjax(eduSemesterService.updateEduSemester(eduSemester));
}
/**
* 删除学期信息
*/
@PreAuthorize("@ss.hasPermi('education:semester:remove')")
@Log(title = "学期信息", businessType = BusinessType.DELETE)
@DeleteMapping("/{semesterIds}")
public AjaxResult remove(@PathVariable Long[] semesterIds)
{
return toAjax(eduSemesterService.deleteEduSemesterBySemesterIds(semesterIds));
}
/**
* 发布学期
*/
@PreAuthorize("@ss.hasPermi('education:semester:publish')")
@Log(title = "发布学期", businessType = BusinessType.UPDATE)
@PutMapping("/publish/{semesterId}")
public AjaxResult publishSemester(@PathVariable Long semesterId)
{
EduSemester semester = eduSemesterService.selectEduSemesterBySemesterId(semesterId);
if (StringUtils.isNull(semester))
{
return error("学期信息不存在");
}
if (!"0".equals(semester.getStatus()))
{
return error("只有草稿状态的学期才能发布");
}
return toAjax(eduSemesterService.publishSemester(semesterId));
}
/**
* 归档学期
*/
@PreAuthorize("@ss.hasPermi('education:semester:archive')")
@Log(title = "归档学期", businessType = BusinessType.UPDATE)
@PutMapping("/archive/{semesterId}")
public AjaxResult archiveSemester(@PathVariable Long semesterId)
{
EduSemester semester = eduSemesterService.selectEduSemesterBySemesterId(semesterId);
if (StringUtils.isNull(semester))
{
return error("学期信息不存在");
}
if (!"1".equals(semester.getStatus()))
{
return error("只有进行中状态的学期才能归档");
}
return toAjax(eduSemesterService.archiveSemester(semesterId));
}
/**
* 获取当前学期
*/
@PreAuthorize("@ss.hasPermi('education:semester:query')")
@GetMapping("/current")
public AjaxResult getCurrentSemester()
{
return success(eduSemesterService.selectCurrentSemester());
}
/**
* 获取可选课学期列表
*/
@PreAuthorize("@ss.hasPermi('education:semester:query')")
@GetMapping("/enrollable")
public AjaxResult getEnrollableSemesters()
{
return success(eduSemesterService.selectEnrollableSemesters());
}
}

View File

@ -0,0 +1,328 @@
package com.ruoyi.education.domain;
import java.util.Date;
import com.fasterxml.jackson.annotation.JsonFormat;
import org.apache.commons.lang3.builder.ToStringBuilder;
import org.apache.commons.lang3.builder.ToStringStyle;
import com.ruoyi.common.annotation.Excel;
import com.ruoyi.common.core.domain.BaseEntity;
/**
* 开课计划对象 edu_course_class
*
* @author ruoyi
* @date 2024-09-26
*/
public class EduCourseClass extends BaseEntity
{
private static final long serialVersionUID = 1L;
/** 开课ID */
private Long classId;
/** 课程ID */
@Excel(name = "课程ID")
private Long courseId;
/** 学期ID */
@Excel(name = "学期ID")
private Long semesterId;
/** 授课教师ID */
@Excel(name = "授课教师ID")
private Long teacherId;
/** 班级编号 */
@Excel(name = "班级编号")
private String classCode;
/** 容量上限 */
@Excel(name = "容量上限")
private Integer capacity;
/** 选课人数上限0表示同容量 */
@Excel(name = "选课人数上限")
private Integer enrollLimit;
/** 已选人数 */
@Excel(name = "已选人数")
private Integer enrolledCount;
/** 授课教室 */
@Excel(name = "授课教室")
private Long classroomId;
/** 选课开始时间 */
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
@Excel(name = "选课开始时间", width = 30, dateFormat = "yyyy-MM-dd HH:mm:ss")
private Date enrollStartTime;
/** 选课结束时间 */
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
@Excel(name = "选课结束时间", width = 30, dateFormat = "yyyy-MM-dd HH:mm:ss")
private Date enrollEndTime;
/** 开课日期 */
@JsonFormat(pattern = "yyyy-MM-dd")
@Excel(name = "开课日期", width = 30, dateFormat = "yyyy-MM-dd")
private Date teachStartDate;
/** 结课日期 */
@JsonFormat(pattern = "yyyy-MM-dd")
@Excel(name = "结课日期", width = 30, dateFormat = "yyyy-MM-dd")
private Date teachEndDate;
/** 上课星期描述,例如 周一 */
@Excel(name = "上课星期")
private String weekday;
/** 上课节次描述,例如 第1-2节 */
@Excel(name = "上课节次")
private String timeSlot;
/** 状态0待发布 1可选课 2已满额 3已结课 */
@Excel(name = "状态", readConverterExp = "0=待发布,1=可选课,2=已满额,3=已结课")
private String status;
/** 课程名称 - 关联查询字段 */
@Excel(name = "课程名称")
private String courseName;
/** 课程编码 - 关联查询字段 */
@Excel(name = "课程编码")
private String courseCode;
/** 教师姓名 - 关联查询字段 */
@Excel(name = "教师姓名")
private String teacherName;
/** 学期名称 - 关联查询字段 */
@Excel(name = "学期名称")
private String semesterName;
/** 教室名称 - 关联查询字段 */
@Excel(name = "教室名称")
private String classroomName;
public void setClassId(Long classId)
{
this.classId = classId;
}
public Long getClassId()
{
return classId;
}
public void setCourseId(Long courseId)
{
this.courseId = courseId;
}
public Long getCourseId()
{
return courseId;
}
public void setSemesterId(Long semesterId)
{
this.semesterId = semesterId;
}
public Long getSemesterId()
{
return semesterId;
}
public void setTeacherId(Long teacherId)
{
this.teacherId = teacherId;
}
public Long getTeacherId()
{
return teacherId;
}
public void setClassCode(String classCode)
{
this.classCode = classCode;
}
public String getClassCode()
{
return classCode;
}
public void setCapacity(Integer capacity)
{
this.capacity = capacity;
}
public Integer getCapacity()
{
return capacity;
}
public void setEnrollLimit(Integer enrollLimit)
{
this.enrollLimit = enrollLimit;
}
public Integer getEnrollLimit()
{
return enrollLimit;
}
public void setEnrolledCount(Integer enrolledCount)
{
this.enrolledCount = enrolledCount;
}
public Integer getEnrolledCount()
{
return enrolledCount;
}
public void setClassroomId(Long classroomId)
{
this.classroomId = classroomId;
}
public Long getClassroomId()
{
return classroomId;
}
public void setEnrollStartTime(Date enrollStartTime)
{
this.enrollStartTime = enrollStartTime;
}
public Date getEnrollStartTime()
{
return enrollStartTime;
}
public void setEnrollEndTime(Date enrollEndTime)
{
this.enrollEndTime = enrollEndTime;
}
public Date getEnrollEndTime()
{
return enrollEndTime;
}
public void setTeachStartDate(Date teachStartDate)
{
this.teachStartDate = teachStartDate;
}
public Date getTeachStartDate()
{
return teachStartDate;
}
public void setTeachEndDate(Date teachEndDate)
{
this.teachEndDate = teachEndDate;
}
public Date getTeachEndDate()
{
return teachEndDate;
}
public void setWeekday(String weekday)
{
this.weekday = weekday;
}
public String getWeekday()
{
return weekday;
}
public void setTimeSlot(String timeSlot)
{
this.timeSlot = timeSlot;
}
public String getTimeSlot()
{
return timeSlot;
}
public void setStatus(String status)
{
this.status = status;
}
public String getStatus()
{
return status;
}
public String getCourseName()
{
return courseName;
}
public void setCourseName(String courseName)
{
this.courseName = courseName;
}
public String getCourseCode()
{
return courseCode;
}
public void setCourseCode(String courseCode)
{
this.courseCode = courseCode;
}
public String getTeacherName()
{
return teacherName;
}
public void setTeacherName(String teacherName)
{
this.teacherName = teacherName;
}
public String getSemesterName()
{
return semesterName;
}
public void setSemesterName(String semesterName)
{
this.semesterName = semesterName;
}
public String getClassroomName()
{
return classroomName;
}
public void setClassroomName(String classroomName)
{
this.classroomName = classroomName;
}
@Override
public String toString() {
return new ToStringBuilder(this,ToStringStyle.MULTI_LINE_STYLE)
.append("classId", getClassId())
.append("courseId", getCourseId())
.append("semesterId", getSemesterId())
.append("teacherId", getTeacherId())
.append("classCode", getClassCode())
.append("capacity", getCapacity())
.append("enrollLimit", getEnrollLimit())
.append("enrolledCount", getEnrolledCount())
.append("classroomId", getClassroomId())
.append("enrollStartTime", getEnrollStartTime())
.append("enrollEndTime", getEnrollEndTime())
.append("teachStartDate", getTeachStartDate())
.append("teachEndDate", getTeachEndDate())
.append("weekday", getWeekday())
.append("timeSlot", getTimeSlot())
.append("status", getStatus())
.append("remark", getRemark())
.append("createBy", getCreateBy())
.append("createTime", getCreateTime())
.append("updateBy", getUpdateBy())
.append("updateTime", getUpdateTime())
.toString();
}
}

View File

@ -0,0 +1,238 @@
package com.ruoyi.education.domain;
import org.apache.commons.lang3.builder.ToStringBuilder;
import org.apache.commons.lang3.builder.ToStringStyle;
import com.ruoyi.common.annotation.Excel;
import com.ruoyi.common.core.domain.BaseEntity;
/**
* 开课节次安排对象 edu_course_schedule
*
* @author ruoyi
* @date 2024-09-26
*/
public class EduCourseSchedule extends BaseEntity
{
private static final long serialVersionUID = 1L;
/** 节次ID */
private Long scheduleId;
/** 开课ID */
@Excel(name = "开课ID")
private Long classId;
/** 周几1-7 */
@Excel(name = "周几", readConverterExp = "1=周一,2=周二,3=周三,4=周四,5=周五,6=周六,7=周日")
private Integer weekday;
/** 开始节次 */
@Excel(name = "开始节次")
private Integer periodStart;
/** 结束节次 */
@Excel(name = "结束节次")
private Integer periodEnd;
/** 上课周次,例如 1-16 */
@Excel(name = "上课周次")
private String weeks;
/** 教室ID */
@Excel(name = "教室ID")
private Long classroomId;
/** 班级编号 - 关联查询字段 */
@Excel(name = "班级编号")
private String classCode;
/** 课程名称 - 关联查询字段 */
@Excel(name = "课程名称")
private String courseName;
/** 课程编码 - 关联查询字段 */
@Excel(name = "课程编码")
private String courseCode;
/** 教师姓名 - 关联查询字段 */
@Excel(name = "教师姓名")
private String teacherName;
/** 学期名称 - 关联查询字段 */
@Excel(name = "学期名称")
private String semesterName;
/** 教室名称 - 关联查询字段 */
@Excel(name = "教室名称")
private String classroomName;
/** 星期描述 - 关联查询字段 */
@Excel(name = "星期")
private String weekdayName;
/** 节次描述 - 关联查询字段 */
@Excel(name = "节次")
private String periodName;
public void setScheduleId(Long scheduleId)
{
this.scheduleId = scheduleId;
}
public Long getScheduleId()
{
return scheduleId;
}
public void setClassId(Long classId)
{
this.classId = classId;
}
public Long getClassId()
{
return classId;
}
public void setWeekday(Integer weekday)
{
this.weekday = weekday;
}
public Integer getWeekday()
{
return weekday;
}
public void setPeriodStart(Integer periodStart)
{
this.periodStart = periodStart;
}
public Integer getPeriodStart()
{
return periodStart;
}
public void setPeriodEnd(Integer periodEnd)
{
this.periodEnd = periodEnd;
}
public Integer getPeriodEnd()
{
return periodEnd;
}
public void setWeeks(String weeks)
{
this.weeks = weeks;
}
public String getWeeks()
{
return weeks;
}
public void setClassroomId(Long classroomId)
{
this.classroomId = classroomId;
}
public Long getClassroomId()
{
return classroomId;
}
public String getClassCode()
{
return classCode;
}
public void setClassCode(String classCode)
{
this.classCode = classCode;
}
public String getCourseName()
{
return courseName;
}
public void setCourseName(String courseName)
{
this.courseName = courseName;
}
public String getCourseCode()
{
return courseCode;
}
public void setCourseCode(String courseCode)
{
this.courseCode = courseCode;
}
public String getTeacherName()
{
return teacherName;
}
public void setTeacherName(String teacherName)
{
this.teacherName = teacherName;
}
public String getSemesterName()
{
return semesterName;
}
public void setSemesterName(String semesterName)
{
this.semesterName = semesterName;
}
public String getClassroomName()
{
return classroomName;
}
public void setClassroomName(String classroomName)
{
this.classroomName = classroomName;
}
public String getWeekdayName()
{
return weekdayName;
}
public void setWeekdayName(String weekdayName)
{
this.weekdayName = weekdayName;
}
public String getPeriodName()
{
return periodName;
}
public void setPeriodName(String periodName)
{
this.periodName = periodName;
}
@Override
public String toString() {
return new ToStringBuilder(this,ToStringStyle.MULTI_LINE_STYLE)
.append("scheduleId", getScheduleId())
.append("classId", getClassId())
.append("weekday", getWeekday())
.append("periodStart", getPeriodStart())
.append("periodEnd", getPeriodEnd())
.append("weeks", getWeeks())
.append("classroomId", getClassroomId())
.append("remark", getRemark())
.append("createBy", getCreateBy())
.append("createTime", getCreateTime())
.append("updateBy", getUpdateBy())
.append("updateTime", getUpdateTime())
.toString();
}
}

View File

@ -0,0 +1,146 @@
package com.ruoyi.education.domain;
import java.util.Date;
import com.fasterxml.jackson.annotation.JsonFormat;
import org.apache.commons.lang3.builder.ToStringBuilder;
import org.apache.commons.lang3.builder.ToStringStyle;
import com.ruoyi.common.annotation.Excel;
import com.ruoyi.common.core.domain.BaseEntity;
/**
* 学期信息对象 edu_semester
*
* @author ruoyi
* @date 2024-09-26
*/
public class EduSemester extends BaseEntity
{
private static final long serialVersionUID = 1L;
/** 学期ID */
private Long semesterId;
/** 学期编码,例如 2024-2025-1 */
@Excel(name = "学期编码")
private String semesterCode;
/** 学期名称 */
@Excel(name = "学期名称")
private String semesterName;
/** 教学开始日期 */
@JsonFormat(pattern = "yyyy-MM-dd")
@Excel(name = "教学开始日期", width = 30, dateFormat = "yyyy-MM-dd")
private Date startDate;
/** 教学结束日期 */
@JsonFormat(pattern = "yyyy-MM-dd")
@Excel(name = "教学结束日期", width = 30, dateFormat = "yyyy-MM-dd")
private Date endDate;
/** 统一选课开始时间 */
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
@Excel(name = "选课开始时间", width = 30, dateFormat = "yyyy-MM-dd HH:mm:ss")
private Date enrollStartTime;
/** 统一选课结束时间 */
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
@Excel(name = "选课结束时间", width = 30, dateFormat = "yyyy-MM-dd HH:mm:ss")
private Date enrollEndTime;
/** 状态0草稿 1进行中 2已归档 */
@Excel(name = "状态", readConverterExp = "0=草稿,1=进行中,2=已归档")
private String status;
public void setSemesterId(Long semesterId)
{
this.semesterId = semesterId;
}
public Long getSemesterId()
{
return semesterId;
}
public void setSemesterCode(String semesterCode)
{
this.semesterCode = semesterCode;
}
public String getSemesterCode()
{
return semesterCode;
}
public void setSemesterName(String semesterName)
{
this.semesterName = semesterName;
}
public String getSemesterName()
{
return semesterName;
}
public void setStartDate(Date startDate)
{
this.startDate = startDate;
}
public Date getStartDate()
{
return startDate;
}
public void setEndDate(Date endDate)
{
this.endDate = endDate;
}
public Date getEndDate()
{
return endDate;
}
public void setEnrollStartTime(Date enrollStartTime)
{
this.enrollStartTime = enrollStartTime;
}
public Date getEnrollStartTime()
{
return enrollStartTime;
}
public void setEnrollEndTime(Date enrollEndTime)
{
this.enrollEndTime = enrollEndTime;
}
public Date getEnrollEndTime()
{
return enrollEndTime;
}
public void setStatus(String status)
{
this.status = status;
}
public String getStatus()
{
return status;
}
@Override
public String toString() {
return new ToStringBuilder(this,ToStringStyle.MULTI_LINE_STYLE)
.append("semesterId", getSemesterId())
.append("semesterCode", getSemesterCode())
.append("semesterName", getSemesterName())
.append("startDate", getStartDate())
.append("endDate", getEndDate())
.append("enrollStartTime", getEnrollStartTime())
.append("enrollEndTime", getEnrollEndTime())
.append("status", getStatus())
.append("remark", getRemark())
.append("createBy", getCreateBy())
.append("createTime", getCreateTime())
.append("updateBy", getUpdateBy())
.append("updateTime", getUpdateTime())
.toString();
}
}

View File

@ -0,0 +1,155 @@
package com.ruoyi.education.mapper;
import java.util.List;
import com.ruoyi.education.domain.EduCourseClass;
/**
* 开课计划Mapper接口
*
* @author ruoyi
* @date 2024-09-26
*/
public interface EduCourseClassMapper
{
/**
* 查询开课计划
*
* @param classId 开课计划主键
* @return 开课计划
*/
public EduCourseClass selectEduCourseClassByClassId(Long classId);
/**
* 查询开课计划列表
*
* @param eduCourseClass 开课计划
* @return 开课计划集合
*/
public List<EduCourseClass> selectEduCourseClassList(EduCourseClass eduCourseClass);
/**
* 新增开课计划
*
* @param eduCourseClass 开课计划
* @return 结果
*/
public int insertEduCourseClass(EduCourseClass eduCourseClass);
/**
* 修改开课计划
*
* @param eduCourseClass 开课计划
* @return 结果
*/
public int updateEduCourseClass(EduCourseClass eduCourseClass);
/**
* 删除开课计划
*
* @param classId 开课计划主键
* @return 结果
*/
public int deleteEduCourseClassByClassId(Long classId);
/**
* 批量删除开课计划
*
* @param classIds 需要删除的数据主键集合
* @return 结果
*/
public int deleteEduCourseClassByClassIds(Long[] classIds);
/**
* 根据班级编号查询开课计划
*
* @param classCode 班级编号
* @return 开课计划
*/
public EduCourseClass selectEduCourseClassByClassCode(String classCode);
/**
* 查询指定学期的开课计划
*
* @param semesterId 学期ID
* @return 开课计划集合
*/
public List<EduCourseClass> selectCourseClassBySemester(Long semesterId);
/**
* 查询指定教师的开课计划
*
* @param teacherId 教师ID
* @return 开课计划集合
*/
public List<EduCourseClass> selectCourseClassByTeacher(Long teacherId);
/**
* 查询可选课的开课计划
*
* @return 开课计划集合
*/
public List<EduCourseClass> selectEnrollableCourseClasses();
/**
* 查询教室在指定时间的课程安排冲突
*
* @param classroomId 教室ID
* @param weekday 星期几
* @param timeSlot 时间段
* @param semesterId 学期ID
* @param excludeClassId 排除的课程班级ID
* @return 冲突的课程数量
*/
public int checkClassroomConflict(Long classroomId, String weekday, String timeSlot, Long semesterId, Long excludeClassId);
/**
* 查询教师在指定时间的课程安排冲突
*
* @param teacherId 教师ID
* @param weekday 星期几
* @param timeSlot 时间段
* @param semesterId 学期ID
* @param excludeClassId 排除的课程班级ID
* @return 冲突的课程数量
*/
public int checkTeacherConflict(Long teacherId, String weekday, String timeSlot, Long semesterId, Long excludeClassId);
/**
* 更新已选课人数
*
* @param classId 班级ID
* @param enrolledCount 已选人数
* @return 结果
*/
public int updateEnrolledCount(Long classId, Integer enrolledCount);
/**
* 批量更新开课计划状态
*
* @param classIds 班级ID数组
* @param status 状态
* @return 结果
*/
public int batchUpdateStatus(Long[] classIds, String status);
/**
* 获取课程列表用于下拉选择
*
* @return 课程选项集合
*/
public List<Object> getCourseOptions();
/**
* 获取教师列表用于下拉选择
*
* @return 教师选项集合
*/
public List<Object> getTeacherOptions();
/**
* 获取教室列表用于下拉选择
*
* @return 教室选项集合
*/
public List<Object> getClassroomOptions();
}

View File

@ -0,0 +1,155 @@
package com.ruoyi.education.mapper;
import java.util.List;
import com.ruoyi.education.domain.EduCourseSchedule;
/**
* 开课节次安排Mapper接口
*
* @author ruoyi
* @date 2024-09-26
*/
public interface EduCourseScheduleMapper
{
/**
* 查询开课节次安排
*
* @param scheduleId 开课节次安排主键
* @return 开课节次安排
*/
public EduCourseSchedule selectEduCourseScheduleByScheduleId(Long scheduleId);
/**
* 查询开课节次安排列表
*
* @param eduCourseSchedule 开课节次安排
* @return 开课节次安排集合
*/
public List<EduCourseSchedule> selectEduCourseScheduleList(EduCourseSchedule eduCourseSchedule);
/**
* 新增开课节次安排
*
* @param eduCourseSchedule 开课节次安排
* @return 结果
*/
public int insertEduCourseSchedule(EduCourseSchedule eduCourseSchedule);
/**
* 修改开课节次安排
*
* @param eduCourseSchedule 开课节次安排
* @return 结果
*/
public int updateEduCourseSchedule(EduCourseSchedule eduCourseSchedule);
/**
* 删除开课节次安排
*
* @param scheduleId 开课节次安排主键
* @return 结果
*/
public int deleteEduCourseScheduleByScheduleId(Long scheduleId);
/**
* 批量删除开课节次安排
*
* @param scheduleIds 需要删除的数据主键集合
* @return 结果
*/
public int deleteEduCourseScheduleByScheduleIds(Long[] scheduleIds);
/**
* 根据开课ID查询节次安排
*
* @param classId 开课ID
* @return 节次安排集合
*/
public List<EduCourseSchedule> selectScheduleByClassId(Long classId);
/**
* 根据开课ID删除节次安排
*
* @param classId 开课ID
* @return 结果
*/
public int deleteScheduleByClassId(Long classId);
/**
* 查询指定教室的课程安排
*
* @param classroomId 教室ID
* @param semesterId 学期ID
* @return 课程安排集合
*/
public List<EduCourseSchedule> selectScheduleByClassroom(Long classroomId, Long semesterId);
/**
* 查询指定教师的课程安排
*
* @param teacherId 教师ID
* @param semesterId 学期ID
* @return 课程安排集合
*/
public List<EduCourseSchedule> selectScheduleByTeacher(Long teacherId, Long semesterId);
/**
* 查询指定学期的所有课程安排
*
* @param semesterId 学期ID
* @return 课程安排集合
*/
public List<EduCourseSchedule> selectScheduleBySemester(Long semesterId);
/**
* 检查时间冲突 - 教室维度
*
* @param classroomId 教室ID
* @param weekday 星期几
* @param periodStart 开始节次
* @param periodEnd 结束节次
* @param weeks 上课周次
* @param excludeScheduleId 排除的节次安排ID
* @return 冲突的安排数量
*/
public int checkClassroomTimeConflict(Long classroomId, Integer weekday, Integer periodStart, Integer periodEnd, String weeks, Long excludeScheduleId);
/**
* 检查时间冲突 - 教师维度
*
* @param teacherId 教师ID
* @param weekday 星期几
* @param periodStart 开始节次
* @param periodEnd 结束节次
* @param weeks 上课周次
* @param excludeScheduleId 排除的节次安排ID
* @return 冲突的安排数量
*/
public int checkTeacherTimeConflict(Long teacherId, Integer weekday, Integer periodStart, Integer periodEnd, String weeks, Long excludeScheduleId);
/**
* 生成课表数据 - 按教室
*
* @param classroomId 教室ID
* @param semesterId 学期ID
* @return 课表数据
*/
public List<EduCourseSchedule> generateClassroomTimetable(Long classroomId, Long semesterId);
/**
* 生成课表数据 - 按教师
*
* @param teacherId 教师ID
* @param semesterId 学期ID
* @return 课表数据
*/
public List<EduCourseSchedule> generateTeacherTimetable(Long teacherId, Long semesterId);
/**
* 批量插入节次安排
*
* @param scheduleList 节次安排列表
* @return 结果
*/
public int batchInsertSchedule(List<EduCourseSchedule> scheduleList);
}

View File

@ -0,0 +1,83 @@
package com.ruoyi.education.mapper;
import java.util.List;
import com.ruoyi.education.domain.EduSemester;
/**
* 学期信息Mapper接口
*
* @author ruoyi
* @date 2024-09-26
*/
public interface EduSemesterMapper
{
/**
* 查询学期信息
*
* @param semesterId 学期信息主键
* @return 学期信息
*/
public EduSemester selectEduSemesterBySemesterId(Long semesterId);
/**
* 查询学期信息列表
*
* @param eduSemester 学期信息
* @return 学期信息集合
*/
public List<EduSemester> selectEduSemesterList(EduSemester eduSemester);
/**
* 新增学期信息
*
* @param eduSemester 学期信息
* @return 结果
*/
public int insertEduSemester(EduSemester eduSemester);
/**
* 修改学期信息
*
* @param eduSemester 学期信息
* @return 结果
*/
public int updateEduSemester(EduSemester eduSemester);
/**
* 删除学期信息
*
* @param semesterId 学期信息主键
* @return 结果
*/
public int deleteEduSemesterBySemesterId(Long semesterId);
/**
* 批量删除学期信息
*
* @param semesterIds 需要删除的数据主键集合
* @return 结果
*/
public int deleteEduSemesterBySemesterIds(Long[] semesterIds);
/**
* 根据学期编码查询学期信息
*
* @param semesterCode 学期编码
* @return 学期信息
*/
public EduSemester selectEduSemesterBySemesterCode(String semesterCode);
/**
* 查询当前进行中的学期
*
* @return 当前学期信息
*/
public EduSemester selectCurrentSemester();
/**
* 查询可选课的学期列表
*
* @return 学期信息集合
*/
public List<EduSemester> selectEnrollableSemesters();
}

View File

@ -0,0 +1,203 @@
package com.ruoyi.education.service;
import java.util.List;
import com.ruoyi.education.domain.EduCourseClass;
/**
* 开课计划Service接口
*
* @author ruoyi
* @date 2024-09-26
*/
public interface IEduCourseClassService
{
/**
* 查询开课计划
*
* @param classId 开课计划主键
* @return 开课计划
*/
public EduCourseClass selectEduCourseClassByClassId(Long classId);
/**
* 查询开课计划列表
*
* @param eduCourseClass 开课计划
* @return 开课计划集合
*/
public List<EduCourseClass> selectEduCourseClassList(EduCourseClass eduCourseClass);
/**
* 新增开课计划
*
* @param eduCourseClass 开课计划
* @return 结果
*/
public int insertEduCourseClass(EduCourseClass eduCourseClass);
/**
* 修改开课计划
*
* @param eduCourseClass 开课计划
* @return 结果
*/
public int updateEduCourseClass(EduCourseClass eduCourseClass);
/**
* 批量删除开课计划
*
* @param classIds 需要删除的开课计划主键集合
* @return 结果
*/
public int deleteEduCourseClassByClassIds(Long[] classIds);
/**
* 删除开课计划信息
*
* @param classId 开课计划主键
* @return 结果
*/
public int deleteEduCourseClassByClassId(Long classId);
/**
* 根据班级编号查询开课计划
*
* @param classCode 班级编号
* @return 开课计划
*/
public EduCourseClass selectEduCourseClassByClassCode(String classCode);
/**
* 查询指定学期的开课计划
*
* @param semesterId 学期ID
* @return 开课计划集合
*/
public List<EduCourseClass> selectCourseClassBySemester(Long semesterId);
/**
* 查询指定教师的开课计划
*
* @param teacherId 教师ID
* @return 开课计划集合
*/
public List<EduCourseClass> selectCourseClassByTeacher(Long teacherId);
/**
* 查询可选课的开课计划
*
* @return 开课计划集合
*/
public List<EduCourseClass> selectEnrollableCourseClasses();
/**
* 发布开课计划将状态改为可选课
*
* @param classId 开课计划ID
* @return 结果
*/
public int publishCourseClass(Long classId);
/**
* 批量发布开课计划
*
* @param classIds 开课计划ID数组
* @return 结果
*/
public int batchPublishCourseClass(Long[] classIds);
/**
* 停止选课将状态改为已满额
*
* @param classId 开课计划ID
* @return 结果
*/
public int stopEnrollment(Long classId);
/**
* 结课将状态改为已结课
*
* @param classId 开课计划ID
* @return 结果
*/
public int finishCourse(Long classId);
/**
* 校验班级编号是否唯一
*
* @param eduCourseClass 开课计划
* @return 结果
*/
public String checkClassCodeUnique(EduCourseClass eduCourseClass);
/**
* 校验容量设置是否合理
*
* @param eduCourseClass 开课计划
* @return 结果
*/
public String checkCapacityValid(EduCourseClass eduCourseClass);
/**
* 校验教室时间冲突
*
* @param eduCourseClass 开课计划
* @return 结果
*/
public String checkClassroomConflict(EduCourseClass eduCourseClass);
/**
* 校验教师时间冲突
*
* @param eduCourseClass 开课计划
* @return 结果
*/
public String checkTeacherConflict(EduCourseClass eduCourseClass);
/**
* 更新已选课人数
*
* @param classId 班级ID
* @param enrolledCount 已选人数
* @return 结果
*/
public int updateEnrolledCount(Long classId, Integer enrolledCount);
/**
* 调整容量
*
* @param classId 班级ID
* @param newCapacity 新容量
* @return 结果
*/
public int adjustCapacity(Long classId, Integer newCapacity);
/**
* 获取开课计划统计信息
*
* @param semesterId 学期ID
* @return 统计结果
*/
public Object getCourseClassStatistics(Long semesterId);
/**
* 获取课程列表用于下拉选择
*
* @return 课程选项集合
*/
public List<Object> getCourseOptions();
/**
* 获取教师列表用于下拉选择
*
* @return 教师选项集合
*/
public List<Object> getTeacherOptions();
/**
* 获取教室列表用于下拉选择
*
* @return 教室选项集合
*/
public List<Object> getClassroomOptions();
}

View File

@ -0,0 +1,197 @@
package com.ruoyi.education.service;
import java.util.List;
import com.ruoyi.education.domain.EduCourseSchedule;
/**
* 开课节次安排Service接口
*
* @author ruoyi
* @date 2024-09-26
*/
public interface IEduCourseScheduleService
{
/**
* 查询开课节次安排
*
* @param scheduleId 开课节次安排主键
* @return 开课节次安排
*/
public EduCourseSchedule selectEduCourseScheduleByScheduleId(Long scheduleId);
/**
* 查询开课节次安排列表
*
* @param eduCourseSchedule 开课节次安排
* @return 开课节次安排集合
*/
public List<EduCourseSchedule> selectEduCourseScheduleList(EduCourseSchedule eduCourseSchedule);
/**
* 新增开课节次安排
*
* @param eduCourseSchedule 开课节次安排
* @return 结果
*/
public int insertEduCourseSchedule(EduCourseSchedule eduCourseSchedule);
/**
* 修改开课节次安排
*
* @param eduCourseSchedule 开课节次安排
* @return 结果
*/
public int updateEduCourseSchedule(EduCourseSchedule eduCourseSchedule);
/**
* 批量删除开课节次安排
*
* @param scheduleIds 需要删除的开课节次安排主键集合
* @return 结果
*/
public int deleteEduCourseScheduleByScheduleIds(Long[] scheduleIds);
/**
* 删除开课节次安排信息
*
* @param scheduleId 开课节次安排主键
* @return 结果
*/
public int deleteEduCourseScheduleByScheduleId(Long scheduleId);
/**
* 根据开课ID查询节次安排
*
* @param classId 开课ID
* @return 节次安排集合
*/
public List<EduCourseSchedule> selectScheduleByClassId(Long classId);
/**
* 根据开课ID删除节次安排
*
* @param classId 开课ID
* @return 结果
*/
public int deleteScheduleByClassId(Long classId);
/**
* 查询指定教室的课程安排
*
* @param classroomId 教室ID
* @param semesterId 学期ID
* @return 课程安排集合
*/
public List<EduCourseSchedule> selectScheduleByClassroom(Long classroomId, Long semesterId);
/**
* 查询指定教师的课程安排
*
* @param teacherId 教师ID
* @param semesterId 学期ID
* @return 课程安排集合
*/
public List<EduCourseSchedule> selectScheduleByTeacher(Long teacherId, Long semesterId);
/**
* 查询指定学期的所有课程安排
*
* @param semesterId 学期ID
* @return 课程安排集合
*/
public List<EduCourseSchedule> selectScheduleBySemester(Long semesterId);
/**
* 检查时间冲突
*
* @param eduCourseSchedule 节次安排
* @return 结果
*/
public String checkTimeConflict(EduCourseSchedule eduCourseSchedule);
/**
* 检查教室时间冲突
*
* @param eduCourseSchedule 节次安排
* @return 结果
*/
public String checkClassroomTimeConflict(EduCourseSchedule eduCourseSchedule);
/**
* 检查教师时间冲突
*
* @param eduCourseSchedule 节次安排
* @return 结果
*/
public String checkTeacherTimeConflict(EduCourseSchedule eduCourseSchedule);
/**
* 校验节次设置是否合理
*
* @param eduCourseSchedule 节次安排
* @return 结果
*/
public String checkPeriodValid(EduCourseSchedule eduCourseSchedule);
/**
* 生成课表数据 - 按教室
*
* @param classroomId 教室ID
* @param semesterId 学期ID
* @return 课表数据
*/
public List<EduCourseSchedule> generateClassroomTimetable(Long classroomId, Long semesterId);
/**
* 生成课表数据 - 按教师
*
* @param teacherId 教师ID
* @param semesterId 学期ID
* @return 课表数据
*/
public List<EduCourseSchedule> generateTeacherTimetable(Long teacherId, Long semesterId);
/**
* 批量添加节次安排
*
* @param classId 开课ID
* @param scheduleList 节次安排列表
* @return 结果
*/
public int batchAddSchedule(Long classId, List<EduCourseSchedule> scheduleList);
/**
* 复制节次安排
*
* @param sourceClassId 源开课ID
* @param targetClassId 目标开课ID
* @return 结果
*/
public int copySchedule(Long sourceClassId, Long targetClassId);
/**
* 自动排课
*
* @param classId 开课ID
* @param semesterId 学期ID
* @param courseHours 课程总学时
* @return 结果
*/
public String autoSchedule(Long classId, Long semesterId, Integer courseHours);
/**
* 获取时间段统计信息
*
* @param semesterId 学期ID
* @return 统计结果
*/
public Object getTimeSlotStatistics(Long semesterId);
/**
* 检查周次范围是否合理
*
* @param weeks 周次字符串
* @return 结果
*/
public String checkWeeksValid(String weeks);
}

View File

@ -0,0 +1,115 @@
package com.ruoyi.education.service;
import java.util.List;
import com.ruoyi.education.domain.EduSemester;
/**
* 学期信息Service接口
*
* @author ruoyi
* @date 2024-09-26
*/
public interface IEduSemesterService
{
/**
* 查询学期信息
*
* @param semesterId 学期信息主键
* @return 学期信息
*/
public EduSemester selectEduSemesterBySemesterId(Long semesterId);
/**
* 查询学期信息列表
*
* @param eduSemester 学期信息
* @return 学期信息集合
*/
public List<EduSemester> selectEduSemesterList(EduSemester eduSemester);
/**
* 新增学期信息
*
* @param eduSemester 学期信息
* @return 结果
*/
public int insertEduSemester(EduSemester eduSemester);
/**
* 修改学期信息
*
* @param eduSemester 学期信息
* @return 结果
*/
public int updateEduSemester(EduSemester eduSemester);
/**
* 批量删除学期信息
*
* @param semesterIds 需要删除的学期信息主键集合
* @return 结果
*/
public int deleteEduSemesterBySemesterIds(Long[] semesterIds);
/**
* 删除学期信息信息
*
* @param semesterId 学期信息主键
* @return 结果
*/
public int deleteEduSemesterBySemesterId(Long semesterId);
/**
* 根据学期编码查询学期信息
*
* @param semesterCode 学期编码
* @return 学期信息
*/
public EduSemester selectEduSemesterBySemesterCode(String semesterCode);
/**
* 查询当前进行中的学期
*
* @return 当前学期信息
*/
public EduSemester selectCurrentSemester();
/**
* 查询可选课的学期列表
*
* @return 学期信息集合
*/
public List<EduSemester> selectEnrollableSemesters();
/**
* 发布学期将状态改为进行中
*
* @param semesterId 学期ID
* @return 结果
*/
public int publishSemester(Long semesterId);
/**
* 归档学期将状态改为已归档
*
* @param semesterId 学期ID
* @return 结果
*/
public int archiveSemester(Long semesterId);
/**
* 校验学期编码是否唯一
*
* @param eduSemester 学期信息
* @return 结果
*/
public String checkSemesterCodeUnique(EduSemester eduSemester);
/**
* 校验学期时间是否冲突
*
* @param eduSemester 学期信息
* @return 结果
*/
public String checkSemesterTimeConflict(EduSemester eduSemester);
}

View File

@ -0,0 +1,450 @@
package com.ruoyi.education.service.impl;
import java.util.List;
import java.util.HashMap;
import java.util.Map;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.ruoyi.common.utils.DateUtils;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.common.utils.SecurityUtils;
import com.ruoyi.education.mapper.EduCourseClassMapper;
import com.ruoyi.education.domain.EduCourseClass;
import com.ruoyi.education.service.IEduCourseClassService;
/**
* 开课计划Service业务层处理
*
* @author ruoyi
* @date 2024-09-26
*/
@Service
public class EduCourseClassServiceImpl implements IEduCourseClassService
{
@Autowired
private EduCourseClassMapper eduCourseClassMapper;
/**
* 查询开课计划
*
* @param classId 开课计划主键
* @return 开课计划
*/
@Override
public EduCourseClass selectEduCourseClassByClassId(Long classId)
{
return eduCourseClassMapper.selectEduCourseClassByClassId(classId);
}
/**
* 查询开课计划列表
*
* @param eduCourseClass 开课计划
* @return 开课计划
*/
@Override
public List<EduCourseClass> selectEduCourseClassList(EduCourseClass eduCourseClass)
{
return eduCourseClassMapper.selectEduCourseClassList(eduCourseClass);
}
/**
* 新增开课计划
*
* @param eduCourseClass 开课计划
* @return 结果
*/
@Override
public int insertEduCourseClass(EduCourseClass eduCourseClass)
{
if (eduCourseClass.getEnrolledCount() == null)
{
eduCourseClass.setEnrolledCount(0);
}
if (eduCourseClass.getStatus() == null)
{
eduCourseClass.setStatus("0");
}
eduCourseClass.setCreateTime(DateUtils.getNowDate());
return eduCourseClassMapper.insertEduCourseClass(eduCourseClass);
}
/**
* 修改开课计划
*
* @param eduCourseClass 开课计划
* @return 结果
*/
@Override
public int updateEduCourseClass(EduCourseClass eduCourseClass)
{
eduCourseClass.setUpdateTime(DateUtils.getNowDate());
return eduCourseClassMapper.updateEduCourseClass(eduCourseClass);
}
/**
* 批量删除开课计划
*
* @param classIds 需要删除的开课计划主键
* @return 结果
*/
@Override
public int deleteEduCourseClassByClassIds(Long[] classIds)
{
return eduCourseClassMapper.deleteEduCourseClassByClassIds(classIds);
}
/**
* 删除开课计划信息
*
* @param classId 开课计划主键
* @return 结果
*/
@Override
public int deleteEduCourseClassByClassId(Long classId)
{
return eduCourseClassMapper.deleteEduCourseClassByClassId(classId);
}
/**
* 根据班级编号查询开课计划
*
* @param classCode 班级编号
* @return 开课计划
*/
@Override
public EduCourseClass selectEduCourseClassByClassCode(String classCode)
{
return eduCourseClassMapper.selectEduCourseClassByClassCode(classCode);
}
/**
* 查询指定学期的开课计划
*
* @param semesterId 学期ID
* @return 开课计划集合
*/
@Override
public List<EduCourseClass> selectCourseClassBySemester(Long semesterId)
{
return eduCourseClassMapper.selectCourseClassBySemester(semesterId);
}
/**
* 查询指定教师的开课计划
*
* @param teacherId 教师ID
* @return 开课计划集合
*/
@Override
public List<EduCourseClass> selectCourseClassByTeacher(Long teacherId)
{
return eduCourseClassMapper.selectCourseClassByTeacher(teacherId);
}
/**
* 查询可选课的开课计划
*
* @return 开课计划集合
*/
@Override
public List<EduCourseClass> selectEnrollableCourseClasses()
{
return eduCourseClassMapper.selectEnrollableCourseClasses();
}
/**
* 发布开课计划将状态改为可选课
*
* @param classId 开课计划ID
* @return 结果
*/
@Override
public int publishCourseClass(Long classId)
{
EduCourseClass courseClass = new EduCourseClass();
courseClass.setClassId(classId);
courseClass.setStatus("1");
courseClass.setUpdateBy(SecurityUtils.getUsername());
courseClass.setUpdateTime(DateUtils.getNowDate());
return eduCourseClassMapper.updateEduCourseClass(courseClass);
}
/**
* 批量发布开课计划
*
* @param classIds 开课计划ID数组
* @return 结果
*/
@Override
public int batchPublishCourseClass(Long[] classIds)
{
return eduCourseClassMapper.batchUpdateStatus(classIds, "1");
}
/**
* 停止选课将状态改为已满额
*
* @param classId 开课计划ID
* @return 结果
*/
@Override
public int stopEnrollment(Long classId)
{
EduCourseClass courseClass = new EduCourseClass();
courseClass.setClassId(classId);
courseClass.setStatus("2");
courseClass.setUpdateBy(SecurityUtils.getUsername());
courseClass.setUpdateTime(DateUtils.getNowDate());
return eduCourseClassMapper.updateEduCourseClass(courseClass);
}
/**
* 结课将状态改为已结课
*
* @param classId 开课计划ID
* @return 结果
*/
@Override
public int finishCourse(Long classId)
{
EduCourseClass courseClass = new EduCourseClass();
courseClass.setClassId(classId);
courseClass.setStatus("3");
courseClass.setUpdateBy(SecurityUtils.getUsername());
courseClass.setUpdateTime(DateUtils.getNowDate());
return eduCourseClassMapper.updateEduCourseClass(courseClass);
}
/**
* 校验班级编号是否唯一
*
* @param eduCourseClass 开课计划
* @return 结果
*/
@Override
public String checkClassCodeUnique(EduCourseClass eduCourseClass)
{
Long classId = StringUtils.isNull(eduCourseClass.getClassId()) ? -1L : eduCourseClass.getClassId();
EduCourseClass info = eduCourseClassMapper.selectEduCourseClassByClassCode(eduCourseClass.getClassCode());
if (StringUtils.isNotNull(info) && info.getClassId().longValue() != classId.longValue())
{
return "NOT_UNIQUE";
}
return "UNIQUE";
}
/**
* 校验容量设置是否合理
*
* @param eduCourseClass 开课计划
* @return 结果
*/
@Override
public String checkCapacityValid(EduCourseClass eduCourseClass)
{
if (eduCourseClass.getCapacity() == null || eduCourseClass.getCapacity() <= 0)
{
return "INVALID_CAPACITY";
}
if (eduCourseClass.getEnrollLimit() != null && eduCourseClass.getEnrollLimit() > 0)
{
if (eduCourseClass.getEnrollLimit() > eduCourseClass.getCapacity())
{
return "ENROLL_LIMIT_EXCEED_CAPACITY";
}
}
if (eduCourseClass.getEnrolledCount() != null && eduCourseClass.getEnrolledCount() > 0)
{
Integer limit = eduCourseClass.getEnrollLimit() != null && eduCourseClass.getEnrollLimit() > 0
? eduCourseClass.getEnrollLimit() : eduCourseClass.getCapacity();
if (eduCourseClass.getEnrolledCount() > limit)
{
return "ENROLLED_EXCEED_LIMIT";
}
}
return "VALID";
}
/**
* 校验教室时间冲突
*
* @param eduCourseClass 开课计划
* @return 结果
*/
@Override
public String checkClassroomConflict(EduCourseClass eduCourseClass)
{
if (eduCourseClass.getClassroomId() == null || StringUtils.isEmpty(eduCourseClass.getWeekday())
|| StringUtils.isEmpty(eduCourseClass.getTimeSlot()) || eduCourseClass.getSemesterId() == null)
{
return "NO_CONFLICT";
}
int conflictCount = eduCourseClassMapper.checkClassroomConflict(
eduCourseClass.getClassroomId(),
eduCourseClass.getWeekday(),
eduCourseClass.getTimeSlot(),
eduCourseClass.getSemesterId(),
eduCourseClass.getClassId()
);
return conflictCount > 0 ? "CONFLICT" : "NO_CONFLICT";
}
/**
* 校验教师时间冲突
*
* @param eduCourseClass 开课计划
* @return 结果
*/
@Override
public String checkTeacherConflict(EduCourseClass eduCourseClass)
{
if (eduCourseClass.getTeacherId() == null || StringUtils.isEmpty(eduCourseClass.getWeekday())
|| StringUtils.isEmpty(eduCourseClass.getTimeSlot()) || eduCourseClass.getSemesterId() == null)
{
return "NO_CONFLICT";
}
int conflictCount = eduCourseClassMapper.checkTeacherConflict(
eduCourseClass.getTeacherId(),
eduCourseClass.getWeekday(),
eduCourseClass.getTimeSlot(),
eduCourseClass.getSemesterId(),
eduCourseClass.getClassId()
);
return conflictCount > 0 ? "CONFLICT" : "NO_CONFLICT";
}
/**
* 更新已选课人数
*
* @param classId 班级ID
* @param enrolledCount 已选人数
* @return 结果
*/
@Override
public int updateEnrolledCount(Long classId, Integer enrolledCount)
{
return eduCourseClassMapper.updateEnrolledCount(classId, enrolledCount);
}
/**
* 调整容量
*
* @param classId 班级ID
* @param newCapacity 新容量
* @return 结果
*/
@Override
public int adjustCapacity(Long classId, Integer newCapacity)
{
EduCourseClass courseClass = eduCourseClassMapper.selectEduCourseClassByClassId(classId);
if (StringUtils.isNull(courseClass))
{
return 0;
}
if (newCapacity < courseClass.getEnrolledCount())
{
return -1;
}
EduCourseClass updateClass = new EduCourseClass();
updateClass.setClassId(classId);
updateClass.setCapacity(newCapacity);
updateClass.setUpdateBy(SecurityUtils.getUsername());
updateClass.setUpdateTime(DateUtils.getNowDate());
return eduCourseClassMapper.updateEduCourseClass(updateClass);
}
/**
* 获取开课计划统计信息
*
* @param semesterId 学期ID
* @return 统计结果
*/
@Override
public Object getCourseClassStatistics(Long semesterId)
{
EduCourseClass queryParam = new EduCourseClass();
queryParam.setSemesterId(semesterId);
List<EduCourseClass> classList = eduCourseClassMapper.selectEduCourseClassList(queryParam);
Map<String, Object> statistics = new HashMap<>();
int totalClasses = classList.size();
int publishedClasses = 0;
int fullClasses = 0;
int finishedClasses = 0;
int totalCapacity = 0;
int totalEnrolled = 0;
for (EduCourseClass courseClass : classList)
{
if ("1".equals(courseClass.getStatus()) || "2".equals(courseClass.getStatus()))
{
publishedClasses++;
}
if ("2".equals(courseClass.getStatus()))
{
fullClasses++;
}
if ("3".equals(courseClass.getStatus()))
{
finishedClasses++;
}
totalCapacity += courseClass.getCapacity() != null ? courseClass.getCapacity() : 0;
totalEnrolled += courseClass.getEnrolledCount() != null ? courseClass.getEnrolledCount() : 0;
}
statistics.put("totalClasses", totalClasses);
statistics.put("publishedClasses", publishedClasses);
statistics.put("fullClasses", fullClasses);
statistics.put("finishedClasses", finishedClasses);
statistics.put("totalCapacity", totalCapacity);
statistics.put("totalEnrolled", totalEnrolled);
statistics.put("enrollmentRate", totalCapacity > 0 ? (double)totalEnrolled / totalCapacity * 100 : 0);
return statistics;
}
/**
* 获取课程列表用于下拉选择
*
* @return 课程选项集合
*/
@Override
public List<Object> getCourseOptions()
{
return eduCourseClassMapper.getCourseOptions();
}
/**
* 获取教师列表用于下拉选择
*
* @return 教师选项集合
*/
@Override
public List<Object> getTeacherOptions()
{
return eduCourseClassMapper.getTeacherOptions();
}
/**
* 获取教室列表用于下拉选择
*
* @return 教室选项集合
*/
@Override
public List<Object> getClassroomOptions()
{
return eduCourseClassMapper.getClassroomOptions();
}
}

View File

@ -0,0 +1,495 @@
package com.ruoyi.education.service.impl;
import java.util.List;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import java.util.regex.Pattern;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import com.ruoyi.common.utils.DateUtils;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.common.utils.SecurityUtils;
import com.ruoyi.education.mapper.EduCourseScheduleMapper;
import com.ruoyi.education.mapper.EduCourseClassMapper;
import com.ruoyi.education.domain.EduCourseSchedule;
import com.ruoyi.education.domain.EduCourseClass;
import com.ruoyi.education.service.IEduCourseScheduleService;
/**
* 开课节次安排Service业务层处理
*
* @author ruoyi
* @date 2024-09-26
*/
@Service
public class EduCourseScheduleServiceImpl implements IEduCourseScheduleService
{
@Autowired
private EduCourseScheduleMapper eduCourseScheduleMapper;
@Autowired
private EduCourseClassMapper eduCourseClassMapper;
/**
* 查询开课节次安排
*
* @param scheduleId 开课节次安排主键
* @return 开课节次安排
*/
@Override
public EduCourseSchedule selectEduCourseScheduleByScheduleId(Long scheduleId)
{
return eduCourseScheduleMapper.selectEduCourseScheduleByScheduleId(scheduleId);
}
/**
* 查询开课节次安排列表
*
* @param eduCourseSchedule 开课节次安排
* @return 开课节次安排
*/
@Override
public List<EduCourseSchedule> selectEduCourseScheduleList(EduCourseSchedule eduCourseSchedule)
{
return eduCourseScheduleMapper.selectEduCourseScheduleList(eduCourseSchedule);
}
/**
* 新增开课节次安排
*
* @param eduCourseSchedule 开课节次安排
* @return 结果
*/
@Override
public int insertEduCourseSchedule(EduCourseSchedule eduCourseSchedule)
{
eduCourseSchedule.setCreateTime(DateUtils.getNowDate());
return eduCourseScheduleMapper.insertEduCourseSchedule(eduCourseSchedule);
}
/**
* 修改开课节次安排
*
* @param eduCourseSchedule 开课节次安排
* @return 结果
*/
@Override
public int updateEduCourseSchedule(EduCourseSchedule eduCourseSchedule)
{
eduCourseSchedule.setUpdateTime(DateUtils.getNowDate());
return eduCourseScheduleMapper.updateEduCourseSchedule(eduCourseSchedule);
}
/**
* 批量删除开课节次安排
*
* @param scheduleIds 需要删除的开课节次安排主键
* @return 结果
*/
@Override
public int deleteEduCourseScheduleByScheduleIds(Long[] scheduleIds)
{
return eduCourseScheduleMapper.deleteEduCourseScheduleByScheduleIds(scheduleIds);
}
/**
* 删除开课节次安排信息
*
* @param scheduleId 开课节次安排主键
* @return 结果
*/
@Override
public int deleteEduCourseScheduleByScheduleId(Long scheduleId)
{
return eduCourseScheduleMapper.deleteEduCourseScheduleByScheduleId(scheduleId);
}
/**
* 根据开课ID查询节次安排
*
* @param classId 开课ID
* @return 节次安排集合
*/
@Override
public List<EduCourseSchedule> selectScheduleByClassId(Long classId)
{
return eduCourseScheduleMapper.selectScheduleByClassId(classId);
}
/**
* 根据开课ID删除节次安排
*
* @param classId 开课ID
* @return 结果
*/
@Override
public int deleteScheduleByClassId(Long classId)
{
return eduCourseScheduleMapper.deleteScheduleByClassId(classId);
}
/**
* 查询指定教室的课程安排
*
* @param classroomId 教室ID
* @param semesterId 学期ID
* @return 课程安排集合
*/
@Override
public List<EduCourseSchedule> selectScheduleByClassroom(Long classroomId, Long semesterId)
{
return eduCourseScheduleMapper.selectScheduleByClassroom(classroomId, semesterId);
}
/**
* 查询指定教师的课程安排
*
* @param teacherId 教师ID
* @param semesterId 学期ID
* @return 课程安排集合
*/
@Override
public List<EduCourseSchedule> selectScheduleByTeacher(Long teacherId, Long semesterId)
{
return eduCourseScheduleMapper.selectScheduleByTeacher(teacherId, semesterId);
}
/**
* 查询指定学期的所有课程安排
*
* @param semesterId 学期ID
* @return 课程安排集合
*/
@Override
public List<EduCourseSchedule> selectScheduleBySemester(Long semesterId)
{
return eduCourseScheduleMapper.selectScheduleBySemester(semesterId);
}
/**
* 检查时间冲突
*
* @param eduCourseSchedule 节次安排
* @return 结果
*/
@Override
public String checkTimeConflict(EduCourseSchedule eduCourseSchedule)
{
String classroomResult = checkClassroomTimeConflict(eduCourseSchedule);
if (!"NO_CONFLICT".equals(classroomResult))
{
return classroomResult;
}
String teacherResult = checkTeacherTimeConflict(eduCourseSchedule);
if (!"NO_CONFLICT".equals(teacherResult))
{
return teacherResult;
}
return "NO_CONFLICT";
}
/**
* 检查教室时间冲突
*
* @param eduCourseSchedule 节次安排
* @return 结果
*/
@Override
public String checkClassroomTimeConflict(EduCourseSchedule eduCourseSchedule)
{
if (eduCourseSchedule.getClassroomId() == null || eduCourseSchedule.getWeekday() == null ||
eduCourseSchedule.getPeriodStart() == null || eduCourseSchedule.getPeriodEnd() == null)
{
return "NO_CONFLICT";
}
EduCourseClass courseClass = eduCourseClassMapper.selectEduCourseClassByClassId(eduCourseSchedule.getClassId());
if (courseClass == null)
{
return "NO_CONFLICT";
}
int conflictCount = eduCourseScheduleMapper.checkClassroomTimeConflict(
eduCourseSchedule.getClassroomId(),
eduCourseSchedule.getWeekday(),
eduCourseSchedule.getPeriodStart(),
eduCourseSchedule.getPeriodEnd(),
eduCourseSchedule.getWeeks(),
eduCourseSchedule.getScheduleId()
);
return conflictCount > 0 ? "CLASSROOM_CONFLICT" : "NO_CONFLICT";
}
/**
* 检查教师时间冲突
*
* @param eduCourseSchedule 节次安排
* @return 结果
*/
@Override
public String checkTeacherTimeConflict(EduCourseSchedule eduCourseSchedule)
{
if (eduCourseSchedule.getClassId() == null || eduCourseSchedule.getWeekday() == null ||
eduCourseSchedule.getPeriodStart() == null || eduCourseSchedule.getPeriodEnd() == null)
{
return "NO_CONFLICT";
}
EduCourseClass courseClass = eduCourseClassMapper.selectEduCourseClassByClassId(eduCourseSchedule.getClassId());
if (courseClass == null || courseClass.getTeacherId() == null)
{
return "NO_CONFLICT";
}
int conflictCount = eduCourseScheduleMapper.checkTeacherTimeConflict(
courseClass.getTeacherId(),
eduCourseSchedule.getWeekday(),
eduCourseSchedule.getPeriodStart(),
eduCourseSchedule.getPeriodEnd(),
eduCourseSchedule.getWeeks(),
eduCourseSchedule.getScheduleId()
);
return conflictCount > 0 ? "TEACHER_CONFLICT" : "NO_CONFLICT";
}
/**
* 校验节次设置是否合理
*
* @param eduCourseSchedule 节次安排
* @return 结果
*/
@Override
public String checkPeriodValid(EduCourseSchedule eduCourseSchedule)
{
if (eduCourseSchedule.getWeekday() == null || eduCourseSchedule.getWeekday() < 1 || eduCourseSchedule.getWeekday() > 7)
{
return "INVALID_WEEKDAY";
}
if (eduCourseSchedule.getPeriodStart() == null || eduCourseSchedule.getPeriodStart() < 1 || eduCourseSchedule.getPeriodStart() > 12)
{
return "INVALID_PERIOD_START";
}
if (eduCourseSchedule.getPeriodEnd() == null || eduCourseSchedule.getPeriodEnd() < 1 || eduCourseSchedule.getPeriodEnd() > 12)
{
return "INVALID_PERIOD_END";
}
if (eduCourseSchedule.getPeriodStart() > eduCourseSchedule.getPeriodEnd())
{
return "PERIOD_START_AFTER_END";
}
if (eduCourseSchedule.getPeriodEnd() - eduCourseSchedule.getPeriodStart() > 3)
{
return "PERIOD_TOO_LONG";
}
return "VALID";
}
/**
* 生成课表数据 - 按教室
*
* @param classroomId 教室ID
* @param semesterId 学期ID
* @return 课表数据
*/
@Override
public List<EduCourseSchedule> generateClassroomTimetable(Long classroomId, Long semesterId)
{
return eduCourseScheduleMapper.generateClassroomTimetable(classroomId, semesterId);
}
/**
* 生成课表数据 - 按教师
*
* @param teacherId 教师ID
* @param semesterId 学期ID
* @return 课表数据
*/
@Override
public List<EduCourseSchedule> generateTeacherTimetable(Long teacherId, Long semesterId)
{
return eduCourseScheduleMapper.generateTeacherTimetable(teacherId, semesterId);
}
/**
* 批量添加节次安排
*
* @param classId 开课ID
* @param scheduleList 节次安排列表
* @return 结果
*/
@Override
@Transactional
public int batchAddSchedule(Long classId, List<EduCourseSchedule> scheduleList)
{
if (scheduleList == null || scheduleList.isEmpty())
{
return 0;
}
for (EduCourseSchedule schedule : scheduleList)
{
schedule.setClassId(classId);
schedule.setCreateBy(SecurityUtils.getUsername());
}
return eduCourseScheduleMapper.batchInsertSchedule(scheduleList);
}
/**
* 复制节次安排
*
* @param sourceClassId 源开课ID
* @param targetClassId 目标开课ID
* @return 结果
*/
@Override
@Transactional
public int copySchedule(Long sourceClassId, Long targetClassId)
{
List<EduCourseSchedule> sourceSchedules = eduCourseScheduleMapper.selectScheduleByClassId(sourceClassId);
if (sourceSchedules.isEmpty())
{
return 0;
}
List<EduCourseSchedule> targetSchedules = new ArrayList<>();
for (EduCourseSchedule sourceSchedule : sourceSchedules)
{
EduCourseSchedule targetSchedule = new EduCourseSchedule();
targetSchedule.setClassId(targetClassId);
targetSchedule.setWeekday(sourceSchedule.getWeekday());
targetSchedule.setPeriodStart(sourceSchedule.getPeriodStart());
targetSchedule.setPeriodEnd(sourceSchedule.getPeriodEnd());
targetSchedule.setWeeks(sourceSchedule.getWeeks());
targetSchedule.setClassroomId(sourceSchedule.getClassroomId());
targetSchedule.setRemark(sourceSchedule.getRemark());
targetSchedule.setCreateBy(SecurityUtils.getUsername());
targetSchedules.add(targetSchedule);
}
return eduCourseScheduleMapper.batchInsertSchedule(targetSchedules);
}
/**
* 自动排课
*
* @param classId 开课ID
* @param semesterId 学期ID
* @param courseHours 课程总学时
* @return 结果
*/
@Override
public String autoSchedule(Long classId, Long semesterId, Integer courseHours)
{
return "AUTO_SCHEDULE_NOT_IMPLEMENTED";
}
/**
* 获取时间段统计信息
*
* @param semesterId 学期ID
* @return 统计结果
*/
@Override
public Object getTimeSlotStatistics(Long semesterId)
{
List<EduCourseSchedule> scheduleList = eduCourseScheduleMapper.selectScheduleBySemester(semesterId);
Map<String, Object> statistics = new HashMap<>();
Map<String, Integer> weekdayCount = new HashMap<>();
Map<String, Integer> periodCount = new HashMap<>();
for (EduCourseSchedule schedule : scheduleList)
{
String weekdayKey = "weekday_" + schedule.getWeekday();
weekdayCount.put(weekdayKey, weekdayCount.getOrDefault(weekdayKey, 0) + 1);
for (int period = schedule.getPeriodStart(); period <= schedule.getPeriodEnd(); period++)
{
String periodKey = "period_" + period;
periodCount.put(periodKey, periodCount.getOrDefault(periodKey, 0) + 1);
}
}
statistics.put("totalSchedules", scheduleList.size());
statistics.put("weekdayDistribution", weekdayCount);
statistics.put("periodDistribution", periodCount);
return statistics;
}
/**
* 检查周次范围是否合理
*
* @param weeks 周次字符串
* @return 结果
*/
@Override
public String checkWeeksValid(String weeks)
{
if (StringUtils.isEmpty(weeks))
{
return "VALID";
}
Pattern pattern = Pattern.compile("^[0-9,-]+$");
if (!pattern.matcher(weeks).matches())
{
return "INVALID_FORMAT";
}
String[] ranges = weeks.split(",");
for (String range : ranges)
{
if (range.contains("-"))
{
String[] parts = range.split("-");
if (parts.length != 2)
{
return "INVALID_RANGE";
}
try
{
int start = Integer.parseInt(parts[0].trim());
int end = Integer.parseInt(parts[1].trim());
if (start <= 0 || end <= 0 || start > end || end > 25)
{
return "INVALID_WEEK_NUMBER";
}
}
catch (NumberFormatException e)
{
return "INVALID_NUMBER";
}
}
else
{
try
{
int week = Integer.parseInt(range.trim());
if (week <= 0 || week > 25)
{
return "INVALID_WEEK_NUMBER";
}
}
catch (NumberFormatException e)
{
return "INVALID_NUMBER";
}
}
}
return "VALID";
}
}

View File

@ -0,0 +1,239 @@
package com.ruoyi.education.service.impl;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.ruoyi.common.utils.DateUtils;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.common.core.domain.entity.SysUser;
import com.ruoyi.common.utils.SecurityUtils;
import com.ruoyi.education.mapper.EduSemesterMapper;
import com.ruoyi.education.domain.EduSemester;
import com.ruoyi.education.service.IEduSemesterService;
/**
* 学期信息Service业务层处理
*
* @author ruoyi
* @date 2024-09-26
*/
@Service
public class EduSemesterServiceImpl implements IEduSemesterService
{
@Autowired
private EduSemesterMapper eduSemesterMapper;
/**
* 查询学期信息
*
* @param semesterId 学期信息主键
* @return 学期信息
*/
@Override
public EduSemester selectEduSemesterBySemesterId(Long semesterId)
{
return eduSemesterMapper.selectEduSemesterBySemesterId(semesterId);
}
/**
* 查询学期信息列表
*
* @param eduSemester 学期信息
* @return 学期信息
*/
@Override
public List<EduSemester> selectEduSemesterList(EduSemester eduSemester)
{
return eduSemesterMapper.selectEduSemesterList(eduSemester);
}
/**
* 新增学期信息
*
* @param eduSemester 学期信息
* @return 结果
*/
@Override
public int insertEduSemester(EduSemester eduSemester)
{
eduSemester.setCreateTime(DateUtils.getNowDate());
return eduSemesterMapper.insertEduSemester(eduSemester);
}
/**
* 修改学期信息
*
* @param eduSemester 学期信息
* @return 结果
*/
@Override
public int updateEduSemester(EduSemester eduSemester)
{
eduSemester.setUpdateTime(DateUtils.getNowDate());
return eduSemesterMapper.updateEduSemester(eduSemester);
}
/**
* 批量删除学期信息
*
* @param semesterIds 需要删除的学期信息主键
* @return 结果
*/
@Override
public int deleteEduSemesterBySemesterIds(Long[] semesterIds)
{
return eduSemesterMapper.deleteEduSemesterBySemesterIds(semesterIds);
}
/**
* 删除学期信息信息
*
* @param semesterId 学期信息主键
* @return 结果
*/
@Override
public int deleteEduSemesterBySemesterId(Long semesterId)
{
return eduSemesterMapper.deleteEduSemesterBySemesterId(semesterId);
}
/**
* 根据学期编码查询学期信息
*
* @param semesterCode 学期编码
* @return 学期信息
*/
@Override
public EduSemester selectEduSemesterBySemesterCode(String semesterCode)
{
return eduSemesterMapper.selectEduSemesterBySemesterCode(semesterCode);
}
/**
* 查询当前进行中的学期
*
* @return 当前学期信息
*/
@Override
public EduSemester selectCurrentSemester()
{
return eduSemesterMapper.selectCurrentSemester();
}
/**
* 查询可选课的学期列表
*
* @return 学期信息集合
*/
@Override
public List<EduSemester> selectEnrollableSemesters()
{
return eduSemesterMapper.selectEnrollableSemesters();
}
/**
* 发布学期将状态改为进行中
*
* @param semesterId 学期ID
* @return 结果
*/
@Override
public int publishSemester(Long semesterId)
{
EduSemester semester = new EduSemester();
semester.setSemesterId(semesterId);
semester.setStatus("1");
semester.setUpdateBy(SecurityUtils.getUsername());
semester.setUpdateTime(DateUtils.getNowDate());
return eduSemesterMapper.updateEduSemester(semester);
}
/**
* 归档学期将状态改为已归档
*
* @param semesterId 学期ID
* @return 结果
*/
@Override
public int archiveSemester(Long semesterId)
{
EduSemester semester = new EduSemester();
semester.setSemesterId(semesterId);
semester.setStatus("2");
semester.setUpdateBy(SecurityUtils.getUsername());
semester.setUpdateTime(DateUtils.getNowDate());
return eduSemesterMapper.updateEduSemester(semester);
}
/**
* 校验学期编码是否唯一
*
* @param eduSemester 学期信息
* @return 结果
*/
@Override
public String checkSemesterCodeUnique(EduSemester eduSemester)
{
Long semesterId = StringUtils.isNull(eduSemester.getSemesterId()) ? -1L : eduSemester.getSemesterId();
EduSemester info = eduSemesterMapper.selectEduSemesterBySemesterCode(eduSemester.getSemesterCode());
if (StringUtils.isNotNull(info) && info.getSemesterId().longValue() != semesterId.longValue())
{
return "NOT_UNIQUE";
}
return "UNIQUE";
}
/**
* 校验学期时间是否冲突
*
* @param eduSemester 学期信息
* @return 结果
*/
@Override
public String checkSemesterTimeConflict(EduSemester eduSemester)
{
Long semesterId = StringUtils.isNull(eduSemester.getSemesterId()) ? -1L : eduSemester.getSemesterId();
EduSemester queryParam = new EduSemester();
List<EduSemester> semesterList = eduSemesterMapper.selectEduSemesterList(queryParam);
for (EduSemester semester : semesterList)
{
if (semester.getSemesterId().longValue() != semesterId.longValue())
{
if (isTimeOverlap(eduSemester.getStartDate(), eduSemester.getEndDate(),
semester.getStartDate(), semester.getEndDate()))
{
return "CONFLICT";
}
if (isTimeOverlap(eduSemester.getEnrollStartTime(), eduSemester.getEnrollEndTime(),
semester.getEnrollStartTime(), semester.getEnrollEndTime()))
{
return "ENROLL_CONFLICT";
}
}
}
return "NO_CONFLICT";
}
/**
* 判断两个时间段是否重叠
*
* @param start1 开始时间1
* @param end1 结束时间1
* @param start2 开始时间2
* @param end2 结束时间2
* @return 是否重叠
*/
private boolean isTimeOverlap(java.util.Date start1, java.util.Date end1,
java.util.Date start2, java.util.Date end2)
{
if (start1 == null || end1 == null || start2 == null || end2 == null)
{
return false;
}
return start1.before(end2) && end1.after(start2);
}
}

View File

@ -0,0 +1,260 @@
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.ruoyi.education.mapper.EduCourseClassMapper">
<resultMap type="EduCourseClass" id="EduCourseClassResult">
<result property="classId" column="class_id" />
<result property="courseId" column="course_id" />
<result property="semesterId" column="semester_id" />
<result property="teacherId" column="teacher_id" />
<result property="classCode" column="class_code" />
<result property="capacity" column="capacity" />
<result property="enrollLimit" column="enroll_limit" />
<result property="enrolledCount" column="enrolled_count" />
<result property="classroomId" column="classroom_id" />
<result property="enrollStartTime" column="enroll_start_time" />
<result property="enrollEndTime" column="enroll_end_time" />
<result property="teachStartDate" column="teach_start_date" />
<result property="teachEndDate" column="teach_end_date" />
<result property="weekday" column="weekday" />
<result property="timeSlot" column="time_slot" />
<result property="status" column="status" />
<result property="remark" column="remark" />
<result property="createBy" column="create_by" />
<result property="createTime" column="create_time" />
<result property="updateBy" column="update_by" />
<result property="updateTime" column="update_time" />
<result property="courseName" column="course_name" />
<result property="courseCode" column="course_code" />
<result property="teacherName" column="teacher_name" />
<result property="semesterName" column="semester_name" />
<result property="classroomName" column="classroom_name" />
</resultMap>
<sql id="selectEduCourseClassVo">
select c.class_id, c.course_id, c.semester_id, c.teacher_id, c.class_code, c.capacity,
c.enroll_limit, c.enrolled_count, c.classroom_id, c.enroll_start_time, c.enroll_end_time,
c.teach_start_date, c.teach_end_date, c.weekday, c.time_slot, c.status, c.remark,
c.create_by, c.create_time, c.update_by, c.update_time,
co.course_name, co.course_code,
t.real_name as teacher_name,
s.semester_name,
CONCAT(cr.building, cr.room_no) as classroom_name
from edu_course_class c
left join edu_course co on c.course_id = co.course_id
left join edu_teacher t on c.teacher_id = t.teacher_id
left join edu_semester s on c.semester_id = s.semester_id
left join edu_classroom cr on c.classroom_id = cr.classroom_id
</sql>
<select id="selectEduCourseClassList" parameterType="EduCourseClass" resultMap="EduCourseClassResult">
<include refid="selectEduCourseClassVo"/>
<where>
<if test="courseId != null "> and c.course_id = #{courseId}</if>
<if test="semesterId != null "> and c.semester_id = #{semesterId}</if>
<if test="teacherId != null "> and c.teacher_id = #{teacherId}</if>
<if test="classCode != null and classCode != ''"> and c.class_code like concat('%', #{classCode}, '%')</if>
<if test="capacity != null "> and c.capacity = #{capacity}</if>
<if test="enrollLimit != null "> and c.enroll_limit = #{enrollLimit}</if>
<if test="enrolledCount != null "> and c.enrolled_count = #{enrolledCount}</if>
<if test="classroomId != null "> and c.classroom_id = #{classroomId}</if>
<if test="enrollStartTime != null "> and c.enroll_start_time = #{enrollStartTime}</if>
<if test="enrollEndTime != null "> and c.enroll_end_time = #{enrollEndTime}</if>
<if test="teachStartDate != null "> and c.teach_start_date = #{teachStartDate}</if>
<if test="teachEndDate != null "> and c.teach_end_date = #{teachEndDate}</if>
<if test="weekday != null and weekday != ''"> and c.weekday = #{weekday}</if>
<if test="timeSlot != null and timeSlot != ''"> and c.time_slot = #{timeSlot}</if>
<if test="status != null and status != ''"> and c.status = #{status}</if>
<if test="courseName != null and courseName != ''"> and co.course_name like concat('%', #{courseName}, '%')</if>
<if test="courseCode != null and courseCode != ''"> and co.course_code like concat('%', #{courseCode}, '%')</if>
<if test="teacherName != null and teacherName != ''"> and t.real_name like concat('%', #{teacherName}, '%')</if>
<if test="semesterName != null and semesterName != ''"> and s.semester_name like concat('%', #{semesterName}, '%')</if>
</where>
order by c.create_time desc
</select>
<select id="selectEduCourseClassByClassId" parameterType="Long" resultMap="EduCourseClassResult">
<include refid="selectEduCourseClassVo"/>
where c.class_id = #{classId}
</select>
<select id="selectEduCourseClassByClassCode" parameterType="String" resultMap="EduCourseClassResult">
<include refid="selectEduCourseClassVo"/>
where c.class_code = #{classCode}
</select>
<select id="selectCourseClassBySemester" parameterType="Long" resultMap="EduCourseClassResult">
<include refid="selectEduCourseClassVo"/>
where c.semester_id = #{semesterId}
order by c.create_time desc
</select>
<select id="selectCourseClassByTeacher" parameterType="Long" resultMap="EduCourseClassResult">
<include refid="selectEduCourseClassVo"/>
where c.teacher_id = #{teacherId}
order by c.create_time desc
</select>
<select id="selectEnrollableCourseClasses" resultMap="EduCourseClassResult">
<include refid="selectEduCourseClassVo"/>
where c.status = '1'
and NOW() BETWEEN c.enroll_start_time AND c.enroll_end_time
and c.enrolled_count &lt; IFNULL(NULLIF(c.enroll_limit, 0), c.capacity)
order by c.create_time desc
</select>
<select id="checkClassroomConflict" resultType="int">
select count(*)
from edu_course_class
where classroom_id = #{classroomId}
and semester_id = #{semesterId}
and weekday = #{weekday}
and time_slot = #{timeSlot}
and status in ('1', '2')
<if test="excludeClassId != null">
and class_id != #{excludeClassId}
</if>
</select>
<select id="checkTeacherConflict" resultType="int">
select count(*)
from edu_course_class
where teacher_id = #{teacherId}
and semester_id = #{semesterId}
and weekday = #{weekday}
and time_slot = #{timeSlot}
and status in ('1', '2')
<if test="excludeClassId != null">
and class_id != #{excludeClassId}
</if>
</select>
<insert id="insertEduCourseClass" parameterType="EduCourseClass" useGeneratedKeys="true" keyProperty="classId">
insert into edu_course_class
<trim prefix="(" suffix=")" suffixOverrides=",">
<if test="courseId != null">course_id,</if>
<if test="semesterId != null">semester_id,</if>
<if test="teacherId != null">teacher_id,</if>
<if test="classCode != null and classCode != ''">class_code,</if>
<if test="capacity != null">capacity,</if>
<if test="enrollLimit != null">enroll_limit,</if>
<if test="enrolledCount != null">enrolled_count,</if>
<if test="classroomId != null">classroom_id,</if>
<if test="enrollStartTime != null">enroll_start_time,</if>
<if test="enrollEndTime != null">enroll_end_time,</if>
<if test="teachStartDate != null">teach_start_date,</if>
<if test="teachEndDate != null">teach_end_date,</if>
<if test="weekday != null">weekday,</if>
<if test="timeSlot != null">time_slot,</if>
<if test="status != null">status,</if>
<if test="remark != null">remark,</if>
<if test="createBy != null">create_by,</if>
create_time
</trim>
<trim prefix="values (" suffix=")" suffixOverrides=",">
<if test="courseId != null">#{courseId},</if>
<if test="semesterId != null">#{semesterId},</if>
<if test="teacherId != null">#{teacherId},</if>
<if test="classCode != null and classCode != ''">#{classCode},</if>
<if test="capacity != null">#{capacity},</if>
<if test="enrollLimit != null">#{enrollLimit},</if>
<if test="enrolledCount != null">#{enrolledCount},</if>
<if test="classroomId != null">#{classroomId},</if>
<if test="enrollStartTime != null">#{enrollStartTime},</if>
<if test="enrollEndTime != null">#{enrollEndTime},</if>
<if test="teachStartDate != null">#{teachStartDate},</if>
<if test="teachEndDate != null">#{teachEndDate},</if>
<if test="weekday != null">#{weekday},</if>
<if test="timeSlot != null">#{timeSlot},</if>
<if test="status != null">#{status},</if>
<if test="remark != null">#{remark},</if>
<if test="createBy != null">#{createBy},</if>
sysdate()
</trim>
</insert>
<update id="updateEduCourseClass" parameterType="EduCourseClass">
update edu_course_class
<trim prefix="SET" suffixOverrides=",">
<if test="courseId != null">course_id = #{courseId},</if>
<if test="semesterId != null">semester_id = #{semesterId},</if>
<if test="teacherId != null">teacher_id = #{teacherId},</if>
<if test="classCode != null and classCode != ''">class_code = #{classCode},</if>
<if test="capacity != null">capacity = #{capacity},</if>
<if test="enrollLimit != null">enroll_limit = #{enrollLimit},</if>
<if test="enrolledCount != null">enrolled_count = #{enrolledCount},</if>
<if test="classroomId != null">classroom_id = #{classroomId},</if>
<if test="enrollStartTime != null">enroll_start_time = #{enrollStartTime},</if>
<if test="enrollEndTime != null">enroll_end_time = #{enrollEndTime},</if>
<if test="teachStartDate != null">teach_start_date = #{teachStartDate},</if>
<if test="teachEndDate != null">teach_end_date = #{teachEndDate},</if>
<if test="weekday != null">weekday = #{weekday},</if>
<if test="timeSlot != null">time_slot = #{timeSlot},</if>
<if test="status != null">status = #{status},</if>
<if test="remark != null">remark = #{remark},</if>
<if test="updateBy != null">update_by = #{updateBy},</if>
update_time = sysdate()
</trim>
where class_id = #{classId}
</update>
<update id="updateEnrolledCount">
update edu_course_class
set enrolled_count = #{enrolledCount},
status = case
when #{enrolledCount} >= IFNULL(NULLIF(enroll_limit, 0), capacity) then '2'
when #{enrolledCount} > 0 then '1'
else status
end
where class_id = #{classId}
</update>
<update id="batchUpdateStatus">
update edu_course_class set status = #{status}
where class_id in
<foreach item="classId" collection="array" open="(" separator="," close=")">
#{classId}
</foreach>
</update>
<delete id="deleteEduCourseClassByClassId" parameterType="Long">
delete from edu_course_class where class_id = #{classId}
</delete>
<delete id="deleteEduCourseClassByClassIds" parameterType="String">
delete from edu_course_class where class_id in
<foreach item="classId" collection="array" open="(" separator="," close=")">
#{classId}
</foreach>
</delete>
<!-- 获取课程选项 -->
<select id="getCourseOptions" resultType="java.util.HashMap">
select course_id as courseId, course_code as courseCode, course_name as courseName,
course_type as courseType, credit, total_hours as totalHours
from edu_course
where status = '0'
order by course_code
</select>
<!-- 获取教师选项 -->
<select id="getTeacherOptions" resultType="java.util.HashMap">
select teacher_id as teacherId, teacher_no as teacherNo, real_name as realName,
title, dept_id as deptId
from edu_teacher
where status = '0'
order by teacher_no
</select>
<!-- 获取教室选项 -->
<select id="getClassroomOptions" resultType="java.util.HashMap">
select classroom_id as classroomId, building, room_no as roomNo,
capacity, room_type as roomType,
CONCAT(building, room_no) as classroomName
from edu_classroom
where status = '0'
order by building, room_no
</select>
</mapper>

View File

@ -0,0 +1,220 @@
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.ruoyi.education.mapper.EduCourseScheduleMapper">
<resultMap type="EduCourseSchedule" id="EduCourseScheduleResult">
<result property="scheduleId" column="schedule_id" />
<result property="classId" column="class_id" />
<result property="weekday" column="weekday" />
<result property="periodStart" column="period_start" />
<result property="periodEnd" column="period_end" />
<result property="weeks" column="weeks" />
<result property="classroomId" column="classroom_id" />
<result property="remark" column="remark" />
<result property="createBy" column="create_by" />
<result property="createTime" column="create_time" />
<result property="updateBy" column="update_by" />
<result property="updateTime" column="update_time" />
<result property="classCode" column="class_code" />
<result property="courseName" column="course_name" />
<result property="courseCode" column="course_code" />
<result property="teacherName" column="teacher_name" />
<result property="semesterName" column="semester_name" />
<result property="classroomName" column="classroom_name" />
<result property="weekdayName" column="weekday_name" />
<result property="periodName" column="period_name" />
</resultMap>
<sql id="selectEduCourseScheduleVo">
select s.schedule_id, s.class_id, s.weekday, s.period_start, s.period_end, s.weeks,
s.classroom_id, s.remark, s.create_by, s.create_time, s.update_by, s.update_time,
cc.class_code,
c.course_name, c.course_code,
t.real_name as teacher_name,
sem.semester_name,
CONCAT(cr.building, cr.room_no) as classroom_name,
CASE s.weekday
WHEN 1 THEN '周一'
WHEN 2 THEN '周二'
WHEN 3 THEN '周三'
WHEN 4 THEN '周四'
WHEN 5 THEN '周五'
WHEN 6 THEN '周六'
WHEN 7 THEN '周日'
END as weekday_name,
CONCAT('第', s.period_start, '-', s.period_end, '节') as period_name
from edu_course_schedule s
left join edu_course_class cc on s.class_id = cc.class_id
left join edu_course c on cc.course_id = c.course_id
left join edu_teacher t on cc.teacher_id = t.teacher_id
left join edu_semester sem on cc.semester_id = sem.semester_id
left join edu_classroom cr on s.classroom_id = cr.classroom_id
</sql>
<select id="selectEduCourseScheduleList" parameterType="EduCourseSchedule" resultMap="EduCourseScheduleResult">
<include refid="selectEduCourseScheduleVo"/>
<where>
<if test="classId != null "> and s.class_id = #{classId}</if>
<if test="weekday != null "> and s.weekday = #{weekday}</if>
<if test="periodStart != null "> and s.period_start = #{periodStart}</if>
<if test="periodEnd != null "> and s.period_end = #{periodEnd}</if>
<if test="weeks != null and weeks != ''"> and s.weeks like concat('%', #{weeks}, '%')</if>
<if test="classroomId != null "> and s.classroom_id = #{classroomId}</if>
<if test="classCode != null and classCode != ''"> and cc.class_code like concat('%', #{classCode}, '%')</if>
<if test="courseName != null and courseName != ''"> and c.course_name like concat('%', #{courseName}, '%')</if>
<if test="courseCode != null and courseCode != ''"> and c.course_code like concat('%', #{courseCode}, '%')</if>
<if test="teacherName != null and teacherName != ''"> and t.real_name like concat('%', #{teacherName}, '%')</if>
</where>
order by s.weekday, s.period_start, s.create_time
</select>
<select id="selectEduCourseScheduleByScheduleId" parameterType="Long" resultMap="EduCourseScheduleResult">
<include refid="selectEduCourseScheduleVo"/>
where s.schedule_id = #{scheduleId}
</select>
<select id="selectScheduleByClassId" parameterType="Long" resultMap="EduCourseScheduleResult">
<include refid="selectEduCourseScheduleVo"/>
where s.class_id = #{classId}
order by s.weekday, s.period_start
</select>
<select id="selectScheduleByClassroom" resultMap="EduCourseScheduleResult">
<include refid="selectEduCourseScheduleVo"/>
where s.classroom_id = #{classroomId}
and cc.semester_id = #{semesterId}
and cc.status in ('1', '2')
order by s.weekday, s.period_start
</select>
<select id="selectScheduleByTeacher" resultMap="EduCourseScheduleResult">
<include refid="selectEduCourseScheduleVo"/>
where cc.teacher_id = #{teacherId}
and cc.semester_id = #{semesterId}
and cc.status in ('1', '2')
order by s.weekday, s.period_start
</select>
<select id="selectScheduleBySemester" parameterType="Long" resultMap="EduCourseScheduleResult">
<include refid="selectEduCourseScheduleVo"/>
where cc.semester_id = #{semesterId}
order by s.weekday, s.period_start, c.course_name
</select>
<select id="checkClassroomTimeConflict" resultType="int">
select count(*)
from edu_course_schedule s
inner join edu_course_class cc on s.class_id = cc.class_id
where s.classroom_id = #{classroomId}
and s.weekday = #{weekday}
and s.period_start &lt;= #{periodEnd}
and s.period_end &gt;= #{periodStart}
and cc.status in ('1', '2')
<if test="weeks != null and weeks != ''">
and s.weeks is not null and s.weeks != ''
</if>
<if test="excludeScheduleId != null">
and s.schedule_id != #{excludeScheduleId}
</if>
</select>
<select id="checkTeacherTimeConflict" resultType="int">
select count(*)
from edu_course_schedule s
inner join edu_course_class cc on s.class_id = cc.class_id
where cc.teacher_id = #{teacherId}
and s.weekday = #{weekday}
and s.period_start &lt;= #{periodEnd}
and s.period_end &gt;= #{periodStart}
and cc.status in ('1', '2')
<if test="weeks != null and weeks != ''">
and s.weeks is not null and s.weeks != ''
</if>
<if test="excludeScheduleId != null">
and s.schedule_id != #{excludeScheduleId}
</if>
</select>
<select id="generateClassroomTimetable" resultMap="EduCourseScheduleResult">
<include refid="selectEduCourseScheduleVo"/>
where s.classroom_id = #{classroomId}
and cc.semester_id = #{semesterId}
and cc.status in ('1', '2')
order by s.weekday, s.period_start
</select>
<select id="generateTeacherTimetable" resultMap="EduCourseScheduleResult">
<include refid="selectEduCourseScheduleVo"/>
where cc.teacher_id = #{teacherId}
and cc.semester_id = #{semesterId}
and cc.status in ('1', '2')
order by s.weekday, s.period_start
</select>
<insert id="insertEduCourseSchedule" parameterType="EduCourseSchedule" useGeneratedKeys="true" keyProperty="scheduleId">
insert into edu_course_schedule
<trim prefix="(" suffix=")" suffixOverrides=",">
<if test="classId != null">class_id,</if>
<if test="weekday != null">weekday,</if>
<if test="periodStart != null">period_start,</if>
<if test="periodEnd != null">period_end,</if>
<if test="weeks != null">weeks,</if>
<if test="classroomId != null">classroom_id,</if>
<if test="remark != null">remark,</if>
<if test="createBy != null">create_by,</if>
create_time
</trim>
<trim prefix="values (" suffix=")" suffixOverrides=",">
<if test="classId != null">#{classId},</if>
<if test="weekday != null">#{weekday},</if>
<if test="periodStart != null">#{periodStart},</if>
<if test="periodEnd != null">#{periodEnd},</if>
<if test="weeks != null">#{weeks},</if>
<if test="classroomId != null">#{classroomId},</if>
<if test="remark != null">#{remark},</if>
<if test="createBy != null">#{createBy},</if>
sysdate()
</trim>
</insert>
<insert id="batchInsertSchedule" parameterType="java.util.List">
insert into edu_course_schedule (class_id, weekday, period_start, period_end, weeks, classroom_id, remark, create_by, create_time)
values
<foreach collection="list" item="item" separator=",">
(#{item.classId}, #{item.weekday}, #{item.periodStart}, #{item.periodEnd}, #{item.weeks}, #{item.classroomId}, #{item.remark}, #{item.createBy}, sysdate())
</foreach>
</insert>
<update id="updateEduCourseSchedule" parameterType="EduCourseSchedule">
update edu_course_schedule
<trim prefix="SET" suffixOverrides=",">
<if test="classId != null">class_id = #{classId},</if>
<if test="weekday != null">weekday = #{weekday},</if>
<if test="periodStart != null">period_start = #{periodStart},</if>
<if test="periodEnd != null">period_end = #{periodEnd},</if>
<if test="weeks != null">weeks = #{weeks},</if>
<if test="classroomId != null">classroom_id = #{classroomId},</if>
<if test="remark != null">remark = #{remark},</if>
<if test="updateBy != null">update_by = #{updateBy},</if>
update_time = sysdate()
</trim>
where schedule_id = #{scheduleId}
</update>
<delete id="deleteEduCourseScheduleByScheduleId" parameterType="Long">
delete from edu_course_schedule where schedule_id = #{scheduleId}
</delete>
<delete id="deleteEduCourseScheduleByScheduleIds" parameterType="String">
delete from edu_course_schedule where schedule_id in
<foreach item="scheduleId" collection="array" open="(" separator="," close=")">
#{scheduleId}
</foreach>
</delete>
<delete id="deleteScheduleByClassId" parameterType="Long">
delete from edu_course_schedule where class_id = #{classId}
</delete>
</mapper>

View File

@ -0,0 +1,119 @@
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.ruoyi.education.mapper.EduSemesterMapper">
<resultMap type="EduSemester" id="EduSemesterResult">
<result property="semesterId" column="semester_id" />
<result property="semesterCode" column="semester_code" />
<result property="semesterName" column="semester_name" />
<result property="startDate" column="start_date" />
<result property="endDate" column="end_date" />
<result property="enrollStartTime" column="enroll_start_time" />
<result property="enrollEndTime" column="enroll_end_time" />
<result property="status" column="status" />
<result property="remark" column="remark" />
<result property="createBy" column="create_by" />
<result property="createTime" column="create_time" />
<result property="updateBy" column="update_by" />
<result property="updateTime" column="update_time" />
</resultMap>
<sql id="selectEduSemesterVo">
select semester_id, semester_code, semester_name, start_date, end_date, enroll_start_time, enroll_end_time, status, remark, create_by, create_time, update_by, update_time from edu_semester
</sql>
<select id="selectEduSemesterList" parameterType="EduSemester" resultMap="EduSemesterResult">
<include refid="selectEduSemesterVo"/>
<where>
<if test="semesterCode != null and semesterCode != ''"> and semester_code like concat('%', #{semesterCode}, '%')</if>
<if test="semesterName != null and semesterName != ''"> and semester_name like concat('%', #{semesterName}, '%')</if>
<if test="startDate != null "> and start_date = #{startDate}</if>
<if test="endDate != null "> and end_date = #{endDate}</if>
<if test="enrollStartTime != null "> and enroll_start_time = #{enrollStartTime}</if>
<if test="enrollEndTime != null "> and enroll_end_time = #{enrollEndTime}</if>
<if test="status != null and status != ''"> and status = #{status}</if>
</where>
order by create_time desc
</select>
<select id="selectEduSemesterBySemesterId" parameterType="Long" resultMap="EduSemesterResult">
<include refid="selectEduSemesterVo"/>
where semester_id = #{semesterId}
</select>
<select id="selectEduSemesterBySemesterCode" parameterType="String" resultMap="EduSemesterResult">
<include refid="selectEduSemesterVo"/>
where semester_code = #{semesterCode}
</select>
<select id="selectCurrentSemester" resultMap="EduSemesterResult">
<include refid="selectEduSemesterVo"/>
where status = '1'
limit 1
</select>
<select id="selectEnrollableSemesters" resultMap="EduSemesterResult">
<include refid="selectEduSemesterVo"/>
where status = '1'
and NOW() BETWEEN enroll_start_time AND enroll_end_time
order by create_time desc
</select>
<insert id="insertEduSemester" parameterType="EduSemester" useGeneratedKeys="true" keyProperty="semesterId">
insert into edu_semester
<trim prefix="(" suffix=")" suffixOverrides=",">
<if test="semesterCode != null and semesterCode != ''">semester_code,</if>
<if test="semesterName != null and semesterName != ''">semester_name,</if>
<if test="startDate != null">start_date,</if>
<if test="endDate != null">end_date,</if>
<if test="enrollStartTime != null">enroll_start_time,</if>
<if test="enrollEndTime != null">enroll_end_time,</if>
<if test="status != null">status,</if>
<if test="remark != null">remark,</if>
<if test="createBy != null">create_by,</if>
create_time
</trim>
<trim prefix="values (" suffix=")" suffixOverrides=",">
<if test="semesterCode != null and semesterCode != ''">#{semesterCode},</if>
<if test="semesterName != null and semesterName != ''">#{semesterName},</if>
<if test="startDate != null">#{startDate},</if>
<if test="endDate != null">#{endDate},</if>
<if test="enrollStartTime != null">#{enrollStartTime},</if>
<if test="enrollEndTime != null">#{enrollEndTime},</if>
<if test="status != null">#{status},</if>
<if test="remark != null">#{remark},</if>
<if test="createBy != null">#{createBy},</if>
sysdate()
</trim>
</insert>
<update id="updateEduSemester" parameterType="EduSemester">
update edu_semester
<trim prefix="SET" suffixOverrides=",">
<if test="semesterCode != null and semesterCode != ''">semester_code = #{semesterCode},</if>
<if test="semesterName != null and semesterName != ''">semester_name = #{semesterName},</if>
<if test="startDate != null">start_date = #{startDate},</if>
<if test="endDate != null">end_date = #{endDate},</if>
<if test="enrollStartTime != null">enroll_start_time = #{enrollStartTime},</if>
<if test="enrollEndTime != null">enroll_end_time = #{enrollEndTime},</if>
<if test="status != null">status = #{status},</if>
<if test="remark != null">remark = #{remark},</if>
<if test="updateBy != null">update_by = #{updateBy},</if>
update_time = sysdate()
</trim>
where semester_id = #{semesterId}
</update>
<delete id="deleteEduSemesterBySemesterId" parameterType="Long">
delete from edu_semester where semester_id = #{semesterId}
</delete>
<delete id="deleteEduSemesterBySemesterIds" parameterType="String">
delete from edu_semester where semester_id in
<foreach item="semesterId" collection="array" open="(" separator="," close=")">
#{semesterId}
</foreach>
</delete>
</mapper>