批量调整清楚学生考勤

mec-biz/src/main/java/com/ym/mec/biz/dal/dto/VipGroupCourseAdjustInfoDto.java

@@ -44,6 +44,9 @@ public class VipGroupCourseAdjustInfoDto {
     @ApiModelProperty(value = "教学点")
     private Integer schoolId;
 
+    @ApiModelProperty(value = "操作人编号")
+    private Integer operatorId;
+
     public GroupType getGroupType() {
         return groupType;
     }
@@ -123,4 +126,12 @@ public class VipGroupCourseAdjustInfoDto {
     public void setHoliday(boolean holiday) {
         isHoliday = holiday;
     }
+
+    public Integer getOperatorId() {
+        return operatorId;
+    }
+
+    public void setOperatorId(Integer operatorId) {
+        this.operatorId = operatorId;
+    }
 }

mec-biz/src/main/java/com/ym/mec/biz/service/CourseScheduleService.java

@@ -16,6 +16,7 @@ import com.ym.mec.biz.dal.page.VipGroupQueryInfo;
 import com.ym.mec.common.page.PageInfo;
 import com.ym.mec.common.page.QueryInfo;
 import com.ym.mec.common.service.BaseService;
+import org.springframework.web.bind.annotation.RequestBody;
 
 import java.util.Date;
 import java.util.List;
@@ -249,23 +250,49 @@ public interface CourseScheduleService extends BaseService<Long, CourseSchedule>
 	void courseSwapWithDay(Date day1, Date day2);
 
 	/**
-	 * @describe 检测数据库不存在的课程是否存在错误
+	 * @describe 课程时间调整
 	 * @author Joburgess
-	 * @date 2019/10/31
-	 * @param courseSchedules: 课程列表
+	 * @date 2020.09.09
+	 * @param courseSchedules:
+	 * @return
+	 */
+	void courseAdjustOnlyWithClassDate(@RequestBody List<CourseSchedule> courseSchedules, Integer operatorId);
+
+	/**
+	 * @describe 课程时间调整
+	 * @author Joburgess
+	 * @date 2020.09.0
 	 * @return void
 	 */
-	void checkNewCourseSchedules(List<CourseSchedule> courseSchedules,boolean checkExistCourseSchedule);
+	Map<String, List<CourseSchedule>> courseAdjustOnlyWithClassDateCheck(VipGroupCourseAdjustInfoDto courseAdjustInfo);
 
 	/**
-	 * @describe 检测并校正冲突课程
+	 * @describe 单节课程冲突检测及时间校正
 	 * @author Joburgess
 	 * @date 2020.09.09
-	 * @param courseSchedules:
-	 * @param checkExistCourseSchedule:
+	 * @param courseSchedule:
 	 * @return void
 	 */
-	void checkAllCourseSchedules(List<CourseSchedule> courseSchedules,boolean checkExistCourseSchedule);
+	boolean checkSingleCourseConflict(CourseSchedule courseSchedule, List<CourseSchedule> adjustCourses, Map<String, List<CourseSchedule>> result);
+
+	/**
+	 * @describe 课程时间校正，将冲突课程的时间校正到当天空闲时间段
+	 * @author Joburgess
+	 * @date 2020.09.09
+	 * @param courseSchedule:
+	 * @param sameDayCourses:
+	 * @return void
+	 */
+	boolean courseTimeRevise(CourseSchedule courseSchedule, List<CourseSchedule> sameDayCourses);
+
+	/**
+	 * @describe 检测数据库不存在的课程是否存在错误
+	 * @author Joburgess
+	 * @date 2019/10/31
+	 * @param courseSchedules: 课程列表
+	 * @return void
+	 */
+	void checkNewCourseSchedules(List<CourseSchedule> courseSchedules,boolean checkExistCourseSchedule);
 
 	void checkNewCourseSchedulesWithoutMusicGroup(List<CourseSchedule> courseSchedules,boolean checkExistCourseSchedule);
 

mec-biz/src/main/java/com/ym/mec/biz/service/impl/CourseScheduleServiceImpl.java

@@ -34,12 +34,14 @@ import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.beans.BeanUtils;
 import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Lazy;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Propagation;
 import org.springframework.transaction.annotation.Transactional;
 import org.springframework.util.CollectionUtils;
 
+import java.lang.reflect.InvocationTargetException;
 import java.math.BigDecimal;
 import java.text.SimpleDateFormat;
 import java.time.LocalDate;
@@ -1212,7 +1214,325 @@ public class CourseScheduleServiceImpl extends BaseServiceImpl<Long, CourseSched
 //        }
 //    }
 
-    @Override
+
+	@Override
+	public void courseAdjustOnlyWithClassDate(List<CourseSchedule> courseSchedules, Integer operatorId) {
+    	if(CollectionUtils.isEmpty(courseSchedules)){
+    		throw new BizException("请指定课程");
+		}
+		Map<Long, CourseSchedule> idCourseMap = courseSchedules.stream().collect(Collectors.toMap(CourseSchedule::getId, c -> c));
+		List<Long> courseIds = courseSchedules.stream().map(CourseSchedule::getId).collect(Collectors.toList());
+		List<CourseSchedule> existCourses = courseScheduleDao.findByCourseScheduleIds(courseIds);
+		List<CourseScheduleModifyLog> scheduleModifyLogs = new ArrayList<>();
+		Date now=new Date();
+		for (CourseSchedule existCours : existCourses) {
+			CourseSchedule ac = idCourseMap.get(existCours.getId());
+
+			if(now.compareTo(ac.getStartClassTime())>0){
+				throw new BizException("课程调整时间不得小于当前时间");
+			}
+
+			CourseScheduleModifyLog scheduleModifyLog = new CourseScheduleModifyLog();
+			scheduleModifyLog.setCourseScheduleId(existCours.getId());
+			scheduleModifyLog.setPreviousCourseSchedule(JSONObject.toJSONString(existCours));
+			scheduleModifyLog.setCreateTime(now);
+			scheduleModifyLog.setOperatorId(operatorId);
+
+			existCours.setClassDate(ac.getClassDate());
+			existCours.setStartClassTime(ac.getStartClassTime());
+			existCours.setEndClassTime(ac.getEndClassTime());
+
+			scheduleModifyLog.setCurrentCourseSchedule(JSONObject.toJSONString(existCours));
+			scheduleModifyLogs.add(scheduleModifyLog);
+		}
+		checkNewCourseSchedules(existCourses, false);
+		courseScheduleDao.batchUpdate(existCourses);
+		courseScheduleModifyLogDao.batchInsert(scheduleModifyLogs);
+	}
+
+	@Override
+	@Transactional(rollbackFor = Exception.class)
+	public Map<String, List<CourseSchedule>> courseAdjustOnlyWithClassDateCheck(VipGroupCourseAdjustInfoDto courseAdjustInfo) {
+		if(StringUtils.isBlank(courseAdjustInfo.getCourseScheduleIds())){
+			throw new BizException("请指定课程");
+		}
+		if(Objects.isNull(courseAdjustInfo.getCourseCreateStartTime())){
+			throw new BizException("请指定课程调整起始时间");
+		}
+		if(Objects.isNull(courseAdjustInfo.getCourseTimes())){
+			throw new BizException("请指定课程调整周期");
+		}
+		Date now=new Date();
+		//所有课程编号
+		List<Long> adjustCourseScheduleIds = Arrays.asList(courseAdjustInfo.getCourseScheduleIds().split(","))
+				.stream().map(Long::parseLong).collect(Collectors.toList());
+		//所有的课程
+		List<CourseSchedule> courseSchedules = courseScheduleDao.findByCourseScheduleIds(adjustCourseScheduleIds);
+		courseSchedules.sort(Comparator.comparing(CourseSchedule::getStartClassTime));
+		if(adjustCourseScheduleIds.size()!=courseSchedules.size()){
+			throw new BizException("部分课程不存在");
+		}
+
+		Map<Long, CourseSchedule> idCourseMap = courseSchedules.stream().collect(Collectors.toMap(CourseSchedule::getId, c -> {
+			try {
+				return (CourseSchedule)org.apache.commons.beanutils.BeanUtils.cloneBean(c);
+			} catch (IllegalAccessException e) {
+				e.printStackTrace();
+			} catch (InstantiationException e) {
+				e.printStackTrace();
+			} catch (InvocationTargetException e) {
+				e.printStackTrace();
+			} catch (NoSuchMethodException e) {
+				e.printStackTrace();
+			}
+			return null;
+		}));
+
+		Calendar calendar = Calendar.getInstance();
+		calendar.setTime(courseAdjustInfo.getCourseCreateStartTime());
+		List<Date> courseStartDates = new ArrayList<>();
+
+		Set<String> holidayDays = new HashSet<>();
+
+		if (courseAdjustInfo.isHoliday()) {
+			SysConfig holidaySetting = sysConfigService.findByParamName(SysConfigService.HOLIDAY_SETTING);
+			if(StringUtils.isNotBlank(holidaySetting.getParanValue())){
+				holidayDays = new HashSet<>(JSON.parseArray(holidaySetting.getParanValue(), String.class));
+			}
+		}
+
+		Map<String, List<CourseSchedule>> result = new HashMap<String, List<CourseSchedule>>(){{
+			put("normal", new ArrayList<>());
+			put("revise", new ArrayList<>());
+			put("failed", new ArrayList<>());
+		}};
+
+		while (true) {
+			if (courseAdjustInfo.isHoliday() && holidayDays.contains(DateUtil.format(calendar.getTime(), "yyyy-MM-dd"))) {
+				calendar.add(Calendar.DATE, 1);
+				continue;
+			}
+			int i = calendar.get(Calendar.DAY_OF_WEEK);
+			if (i == 1) {
+				i = 7;
+			} else {
+				i = i - 1;
+			}
+			for (CourseTimeDto courseTime : courseAdjustInfo.getCourseTimes()) {
+				if (Objects.isNull(courseTime.getDayOfWeek())||StringUtils.isBlank(courseTime.getStartClassTime())) {
+					throw new BizException("排课循环周期错误");
+				}
+				if (courseTime.getDayOfWeek() < 1 || courseTime.getDayOfWeek() > 7) {
+					throw new BizException("排课循环周期错误");
+				}
+				if (courseTime.getDayOfWeek() == i) {
+					String dateYmdStr = DateUtil.dateToString(calendar.getTime(), DateUtil.ISO_EXPANDED_DATE_FORMAT);
+					dateYmdStr = dateYmdStr + " " + courseTime.getStartClassTime();
+					Date courseStartTime = DateUtil.stringToDate(dateYmdStr, "yyyy-MM-dd HH:mm");
+
+					if(courseStartTime.compareTo(now)<=0){
+						throw new BizException("课程调整时间不得小于当前时间");
+					}
+
+					courseStartDates.add(DateUtil.stringToDate(dateYmdStr, DateUtil.EXPANDED_DATE_TIME_FORMAT));
+					CourseSchedule currentCourseSchedule = courseSchedules.get(courseStartDates.size() - 1);
+					int singleClassMinutes = DateUtil.minutesBetween(currentCourseSchedule.getStartClassTime(), currentCourseSchedule.getEndClassTime());
+					Date courseEndTime = DateUtil.addMinutes(courseStartTime, singleClassMinutes);
+					int settlementNum = courseScheduleTeacherSalaryDao.checkCourseIsSettlement(courseSchedules.get(courseStartDates.size() - 1).getId().intValue());
+					if (settlementNum > 0) {
+						throw new BizException("{}[{}]{}-{}课程已结算",
+								courseSchedules.get(courseStartDates.size() - 1).getName(),
+								courseSchedules.get(courseStartDates.size() - 1).getId(),
+								DateUtil.dateToString(courseSchedules.get(courseStartDates.size() - 1).getStartClassTime(),
+										DateUtil.ISO_EXPANDED_DATE_TIME_FORMAT),
+								DateUtil.dateToString(courseSchedules.get(courseStartDates.size() - 1).getEndClassTime(),
+										DateUtil.ISO_EXPANDED_DATE_TIME_FORMAT));
+					}
+					int num = studentAttendanceDao.countStudentAttendenceNum(courseSchedules.get(courseStartDates.size() - 1).getId().intValue());
+					if (num > 0) {
+						throw new BizException("{}[{}]{}-{}课程已点名",
+								courseSchedules.get(courseStartDates.size() - 1).getName(),
+								courseSchedules.get(courseStartDates.size() - 1).getId(),
+								DateUtil.dateToString(courseSchedules.get(courseStartDates.size() - 1).getStartClassTime(),
+										DateUtil.EXPANDED_DATE_TIME_FORMAT),
+								DateUtil.dateToString(courseSchedules.get(courseStartDates.size() - 1).getEndClassTime(),
+										DateUtil.EXPANDED_DATE_TIME_FORMAT));
+					}
+					courseSchedules.get(courseStartDates.size() - 1).setStatus(CourseStatusEnum.NOT_START);
+					courseSchedules.get(courseStartDates.size() - 1).setClassDate(courseStartTime);
+					courseSchedules.get(courseStartDates.size() - 1).setStartClassTime(courseStartTime);
+					courseSchedules.get(courseStartDates.size() - 1).setEndClassTime(courseEndTime);
+				}
+				if (courseStartDates.size() == adjustCourseScheduleIds.size()) {
+					break;
+				}
+			}
+			if (courseStartDates.size() == adjustCourseScheduleIds.size()) {
+				break;
+			}
+			calendar.add(Calendar.DATE, 1);
+		}
+		for (CourseSchedule courseSchedule : courseSchedules) {
+			boolean b = checkSingleCourseConflict(courseSchedule, courseSchedules, result);
+			if(!b){
+				courseSchedule = idCourseMap.get(courseSchedule.getId());
+			}
+		}
+		return result;
+	}
+
+	@Override
+	public boolean courseTimeRevise(CourseSchedule courseSchedule, List<CourseSchedule> sameDayCourses) {
+		int singleClassMinutes = DateUtil.minutesBetween(courseSchedule.getStartClassTime(), courseSchedule.getEndClassTime());
+		sameDayCourses.sort(Comparator.comparing(CourseSchedule::getStartClassTime));
+		Date lastEndClassTime = courseSchedule.getEndClassTime();
+
+		for (int i=0;i<sameDayCourses.size();i++){
+			CourseSchedule cs1 = sameDayCourses.get(i);
+			if(cs1.getEndClassTime().compareTo(lastEndClassTime)>=0){
+				lastEndClassTime = cs1.getEndClassTime();
+			}
+
+			if(i!=sameDayCourses.size()-1&&DateUtil.minutesBetween(lastEndClassTime, sameDayCourses.get(i + 1).getStartClassTime())>=singleClassMinutes){
+				break;
+			}
+		}
+
+		Date endClassTime = DateUtil.addMinutes(lastEndClassTime, singleClassMinutes);
+		if(!DateUtil.isSameDay(lastEndClassTime, endClassTime)){
+			return false;
+		}
+		courseSchedule.setStartClassTime(lastEndClassTime);
+		courseSchedule.setEndClassTime(endClassTime);
+		return true;
+	}
+
+	@Override
+	public boolean checkSingleCourseConflict(CourseSchedule courseSchedule, List<CourseSchedule> adjustCourses, Map<String, List<CourseSchedule>> result) {
+		if(!DateUtil.isSameDay(courseSchedule.getStartClassTime(), courseSchedule.getEndClassTime())){
+			throw new BizException("课程时间不允许跨天");
+		}
+		List<CourseSchedule> allCourseSchedules = courseScheduleDao.findByClassDate(Arrays.asList(DateUtil.dateToString(courseSchedule.getClassDate(), "yyyy-MM-dd")));
+
+		if(null == allCourseSchedules){
+			allCourseSchedules = new ArrayList<>();
+		}
+		Set<Long> adjustCourseIds = adjustCourses.stream().map(CourseSchedule::getId).collect(Collectors.toSet());
+		allCourseSchedules= (List<CourseSchedule>) org.apache.commons.collections.CollectionUtils.union(allCourseSchedules.stream()
+				.filter(c->!adjustCourseIds.contains(c.getId())&&DateUtil.isSameDay(c.getClassDate(), courseSchedule.getClassDate())).collect(Collectors.toList()),
+						adjustCourses);
+
+		Map<Long, CourseSchedule> idCourseMap = allCourseSchedules.stream().collect(Collectors.toMap(CourseSchedule::getId, c -> c));
+		Set<Long> courseScheduleIds = allCourseSchedules.stream().map(CourseSchedule::getId).collect(Collectors.toSet());
+		courseScheduleIds.add(courseSchedule.getId());
+		List<CourseScheduleStudentPayment> courseScheduleStudentPayments = courseScheduleStudentPaymentDao.findByCourseScheduleIds(new ArrayList<>(courseScheduleIds));
+		Map<Long, Set<Integer>> courseStudentIdsMap = courseScheduleStudentPayments.stream()
+				.collect(Collectors.groupingBy(CourseScheduleStudentPayment::getCourseScheduleId,
+						Collectors.mapping(CourseScheduleStudentPayment::getUserId, Collectors.toSet())));
+
+		List<CourseScheduleTeacherSalary> courseScheduleTeacherSalaries = courseScheduleTeacherSalaryDao.findByCourseSchedules(new ArrayList<>(courseScheduleIds));
+		Map<Long, Set<Integer>> courseTeacherIdsMap = courseScheduleTeacherSalaries.stream()
+				.collect(Collectors.groupingBy(CourseScheduleTeacherSalary::getCourseScheduleId,
+						Collectors.mapping(CourseScheduleTeacherSalary::getUserId, Collectors.toSet())));
+		Set<Integer> currentCourseTeacherIds = courseTeacherIdsMap.get(courseSchedule.getId());
+
+		List<StudentAttendance> studentAttendances = studentAttendanceDao.findByCourseIds(new ArrayList<>(courseScheduleIds));
+		Map<Long, Set<Integer>> courseLeaveStudentIdsMap = new HashMap<>();
+		for (StudentAttendance sa : studentAttendances) {
+			if(sa.getCourseScheduleId().equals(courseSchedule.getId())&&!StudentAttendanceStatusEnum.LEAVE.equals(sa.getStatus())){
+				result.get("failed").add(courseSchedule);
+				return false;
+			}
+			if(!courseLeaveStudentIdsMap.containsKey(sa.getCourseScheduleId())){
+				courseLeaveStudentIdsMap.put(sa.getCourseScheduleId(), Collections.EMPTY_SET);
+			}
+			CourseSchedule cs = idCourseMap.get(sa.getCourseScheduleId());
+			if(DateUtil.addHours(sa.getCreateTime(),4).compareTo(cs.getStartClassTime())<0){
+				courseLeaveStudentIdsMap.get(sa.getCourseScheduleId()).add(sa.getUserId());
+			}
+		}
+		Set<Integer> currentCourseLeaveStudentIds = courseLeaveStudentIdsMap.get(courseSchedule.getId());
+		Set<Integer> currentCourseStudentIds = courseStudentIdsMap.get(courseSchedule.getId())
+												.stream().filter(id->Objects.nonNull(currentCourseLeaveStudentIds)&&!currentCourseLeaveStudentIds.contains(id)).collect(Collectors.toSet());
+
+		boolean isRepeat = false;
+		List<CourseSchedule> repeatCourses = new ArrayList<>();
+
+		allCourseSchedules.sort(Comparator.comparing(CourseSchedule::getStartClassTime));
+		for (CourseSchedule cs : allCourseSchedules) {
+			if(cs.getId().equals(courseSchedule.getId())){
+				continue;
+			}
+
+			if(cs.getStartClassTime().compareTo(courseSchedule.getEndClassTime())>0){
+				break;
+			}
+
+			if(cs.getEndClassTime().compareTo(courseSchedule.getStartClassTime())<0){
+				continue;
+			}
+
+			//判断两节课程时间是否重叠
+			if (!cs.getStartClassTime().before(courseSchedule.getEndClassTime())
+					||!cs.getEndClassTime().after(courseSchedule.getStartClassTime())) {
+				continue;
+			}
+
+			Set<Integer> csLeaveStudentIds = courseLeaveStudentIdsMap.get(cs.getId());
+			Set<Integer> repeatStudentIds = new HashSet<>();
+			if(null!=csLeaveStudentIds){
+				Set<Integer> csStudentIds = courseStudentIdsMap.get(cs.getId()).stream()
+						.filter(id->Objects.nonNull(csLeaveStudentIds)&&!csLeaveStudentIds.contains(id)).collect(Collectors.toSet());
+				repeatStudentIds = csStudentIds.stream().filter(id -> currentCourseStudentIds.contains(id)).collect(Collectors.toSet());
+			}
+
+			Set<Integer> csTeacherIds = courseTeacherIdsMap.get(cs.getId());
+			Set<Integer> repeatTeacherIds = new HashSet<>();
+			if(null!=csTeacherIds){
+				repeatTeacherIds = csTeacherIds.stream().filter(id -> Objects.nonNull(currentCourseTeacherIds)&&currentCourseTeacherIds.contains(id)).collect(Collectors.toSet());
+			}
+
+			if(!CollectionUtils.isEmpty(repeatStudentIds)||!CollectionUtils.isEmpty(repeatTeacherIds)){
+				isRepeat = true;
+				break;
+			}
+		}
+		if(isRepeat){
+			for (CourseSchedule cs : allCourseSchedules) {
+				if(cs.getId().equals(courseSchedule.getId())){
+					continue;
+				}
+
+				Set<Integer> csLeaveStudentIds = courseLeaveStudentIdsMap.get(cs.getId());
+				Set<Integer> repeatStudentIds = new HashSet<>();
+				if(null!=csLeaveStudentIds){
+					Set<Integer> csStudentIds = courseStudentIdsMap.get(cs.getId()).stream()
+							.filter(id->Objects.nonNull(csLeaveStudentIds)&&!csLeaveStudentIds.contains(id)).collect(Collectors.toSet());
+					repeatStudentIds = csStudentIds.stream().filter(id -> currentCourseStudentIds.contains(id)).collect(Collectors.toSet());
+				}
+
+				Set<Integer> csTeacherIds = courseTeacherIdsMap.get(cs.getId());
+				Set<Integer> repeatTeacherIds = new HashSet<>();
+				if(null!=csTeacherIds){
+					repeatTeacherIds = csTeacherIds.stream().filter(id -> Objects.nonNull(currentCourseTeacherIds)&&currentCourseTeacherIds.contains(id)).collect(Collectors.toSet());
+				}
+				if(!CollectionUtils.isEmpty(repeatStudentIds)||!CollectionUtils.isEmpty(repeatTeacherIds)){
+					repeatCourses.add(cs);
+				}
+			}
+			boolean b = courseTimeRevise(courseSchedule, repeatCourses);
+			if(b){
+				result.get("revise").add(courseSchedule);
+			}else{
+				result.get("failed").add(courseSchedule);
+			}
+			return b;
+		}
+		result.get("normal").add(courseSchedule);
+		return true;
+	}
+
+	@Override
     public void checkNewCourseSchedules(List<CourseSchedule> courseSchedules, boolean checkExistCourseSchedule) {
         if (CollectionUtils.isEmpty(courseSchedules)) {
             return;
@@ -1404,200 +1724,6 @@ public class CourseScheduleServiceImpl extends BaseServiceImpl<Long, CourseSched
         }
     }
 
-
-
-	@Override
-	public void checkAllCourseSchedules(List<CourseSchedule> courseSchedules, boolean checkExistCourseSchedule) {
-		if (CollectionUtils.isEmpty(courseSchedules)) {
-			return;
-		}
-		List<String> classDates = courseSchedules.stream().map(courseSchedule -> DateUtil.dateToString(courseSchedule.getClassDate(), "yyyy-MM-dd"))
-				.collect(Collectors.toList());
-
-		List<CourseSchedule> existCourseSchedules = courseScheduleDao.findByClassDate(classDates);
-
-		//只需要调整课程信息的课程编号列表
-		List<Long> updateCourseScheduleIds = courseSchedules
-				.stream()
-				.filter(courseSchedule -> Objects.nonNull(courseSchedule.getId()))
-				.map(CourseSchedule::getId)
-				.collect(Collectors.toList());
-
-		//排除只需调整的课程
-		existCourseSchedules = existCourseSchedules.stream()
-				.filter(courseSchedule -> !updateCourseScheduleIds.contains(courseSchedule.getId()))
-				.collect(Collectors.toList());
-		//新课程对应的班级编号列表
-		List<Integer> newCourseScheduleClassGroupIds = courseSchedules
-				.stream()
-				.map(CourseSchedule::getClassGroupId)
-				.distinct()
-				.collect(Collectors.toList());
-
-		List<Long> existCourseScheduleIds = existCourseSchedules.stream()
-				.map(CourseSchedule::getId)
-				.collect(Collectors.toList());
-
-		HashSet<Long> courseScheduleIdsSet = new HashSet<>(existCourseScheduleIds);
-
-		//合并新课程和已存在的课程
-		List<CourseSchedule> allCourseSchedules;
-		if (!CollectionUtils.isEmpty(existCourseSchedules)) {
-			allCourseSchedules = ListUtils.sum(courseSchedules, existCourseSchedules);
-		} else {
-			allCourseSchedules = courseSchedules;
-		}
-
-		//所有课程编号
-		List<Long> allCourseScheduleIds = allCourseSchedules.stream().map(CourseSchedule::getId).collect(Collectors.toList());
-		//所有课程学员签到记录
-		List<StudentAttendance> studentAttendances = studentAttendanceDao.findByCourseIds(allCourseScheduleIds);
-		//课程请假学员字典
-		Map<Long, Set<Integer>> courseLeaveStudentMap = studentAttendances.stream()
-				.filter(e -> StudentAttendanceStatusEnum.LEAVE.equals(e.getStatus()))
-				.collect(Collectors.groupingBy(StudentAttendance::getCourseScheduleId, Collectors.mapping(StudentAttendance::getUserId, Collectors.toSet())));
-
-		//所有课程的班级编号
-		List<Integer> classGroupIds = allCourseSchedules
-				.stream()
-				.map(CourseSchedule::getClassGroupId)
-				.distinct()
-				.collect(Collectors.toList());
-		//班级与学生的关联记录
-		List<ClassGroupStudentMapper> classGroupStudentMappers = classGroupStudentMapperDao.findByClassGroups(classGroupIds);
-		Map<Integer, List<ClassGroupStudentMapper>> classGroupStudentsMap = classGroupStudentMappers
-				.stream()
-				.collect(Collectors.groupingBy(ClassGroupStudentMapper::getClassGroupId));
-
-		//根据课程获取助教id关联集合
-		List<IntegerAndIntegerListDto> courseScheduleTeachingTeacherIdList = new ArrayList<>();
-		if (!CollectionUtils.isEmpty(existCourseScheduleIds)) {
-			courseScheduleTeachingTeacherIdList = courseScheduleDao.findCourseScheduleIdAndUserIdsMap(existCourseScheduleIds, TeachTypeEnum.TEACHING.getCode());
-		}
-		Map<Integer, IntegerAndIntegerListDto> courseScheduleTeachingTeacherMap = courseScheduleTeachingTeacherIdList.stream()
-				.collect(Collectors.toMap(IntegerAndIntegerListDto::getId, integerAndIntegerListDto -> integerAndIntegerListDto));
-
-		//班级助教关联ID集合
-		List<IntegerAndIntegerListDto> classGroupAndUserIdsMap = courseScheduleDao.findClassGroupAndUserIdsMap(newCourseScheduleClassGroupIds, TeachTypeEnum.TEACHING.getCode());
-		Map<Integer, IntegerAndIntegerListDto> classGroupTeachingTeacherMap = classGroupAndUserIdsMap.stream()
-				.collect(Collectors.toMap(IntegerAndIntegerListDto::getId, integerAndIntegerListDto -> integerAndIntegerListDto));
-
-		Set<Long> existCourseScheduleIdsSet=new HashSet<>(existCourseScheduleIds);
-
-		Map<String, List<CourseSchedule>> existClassDateCoursesMap = allCourseSchedules.stream().collect(Collectors.groupingBy(c -> DateUtil.dateToString(c.getClassDate(), "yyyy-MM-dd")));
-		Map<String, List<CourseSchedule>> newClassDateCoursesMap = courseSchedules.stream().collect(Collectors.groupingBy(c -> DateUtil.dateToString(c.getClassDate(), "yyyy-MM-dd")));
-		if (allCourseSchedules.size() > 1) {
-			for (Map.Entry<String, List<CourseSchedule>> classDateCourseEntry : newClassDateCoursesMap.entrySet()) {
-				List<CourseSchedule> existClassDateCourses = existClassDateCoursesMap.get(classDateCourseEntry.getKey());
-				if(CollectionUtils.isEmpty(existClassDateCourses)){
-					continue;
-				}
-				List<CourseSchedule> newClassDateCourses=classDateCourseEntry.getValue();
-				existClassDateCourses.sort(Comparator.comparing(CourseSchedule::getStartClassTime));
-				newClassDateCourses.sort(Comparator.comparing(CourseSchedule::getStartClassTime));
-				for (CourseSchedule preCourseSchedule : newClassDateCourses) {
-					for (CourseSchedule backCourseSchedule : existClassDateCourses) {
-
-						//判断前后两节课是否存在冲突
-						if (!preCourseSchedule.getStartClassTime().before(backCourseSchedule.getEndClassTime())
-								||!preCourseSchedule.getEndClassTime().after(backCourseSchedule.getStartClassTime())) {
-							continue;
-						}
-						if (!checkExistCourseSchedule
-								&& !courseScheduleIdsSet.contains(backCourseSchedule.getId())) {
-							continue;
-						}
-
-						//如果存在时间重叠，则需要判断前后两节课的教师和学生是否存在冲突
-						//主教冲突检测
-						if (Objects.nonNull(preCourseSchedule.getActualTeacherId())
-								&& preCourseSchedule.getActualTeacherId().equals(backCourseSchedule.getActualTeacherId())) {
-
-							throw new BizException(courseCheckInfo(preCourseSchedule, backCourseSchedule, existCourseScheduleIds, 1));
-						}
-
-						if(Objects.isNull(preCourseSchedule.getId())){
-							continue;
-						}
-
-						//助教冲突检测
-						if (Objects.isNull(preCourseSchedule.getId())) {
-							IntegerAndIntegerListDto integerAndIntegerListDto = classGroupTeachingTeacherMap.get(preCourseSchedule.getClassGroupId());
-							if (Objects.nonNull(integerAndIntegerListDto)) {
-								preCourseSchedule.setTeachingTeacherIdList(integerAndIntegerListDto.getIds());
-							}
-						} else if (existCourseScheduleIdsSet.contains(preCourseSchedule.getId())) {
-							IntegerAndIntegerListDto integerAndIntegerListDto = courseScheduleTeachingTeacherMap.get(preCourseSchedule.getId());
-							if (Objects.nonNull(integerAndIntegerListDto)) {
-								preCourseSchedule.setTeachingTeacherIdList(integerAndIntegerListDto.getIds());
-							}
-						}
-						if (Objects.isNull(backCourseSchedule.getId())) {
-							IntegerAndIntegerListDto integerAndIntegerListDto = classGroupTeachingTeacherMap.get(backCourseSchedule.getClassGroupId());
-							if (Objects.nonNull(integerAndIntegerListDto)) {
-								backCourseSchedule.setTeachingTeacherIdList(integerAndIntegerListDto.getIds());
-							}
-						} else if (existCourseScheduleIdsSet.contains(backCourseSchedule.getId())) {
-							IntegerAndIntegerListDto integerAndIntegerListDto = courseScheduleTeachingTeacherMap.get(backCourseSchedule.getId());
-							if (Objects.nonNull(integerAndIntegerListDto)) {
-								backCourseSchedule.setTeachingTeacherIdList(integerAndIntegerListDto.getIds());
-							}
-						}
-						if (!CollectionUtils.isEmpty(preCourseSchedule.getTeachingTeacherIdList())
-								&& !CollectionUtils.isEmpty(backCourseSchedule.getTeachingTeacherIdList())) {
-							List<Integer> repeatIds = preCourseSchedule.getTeachingTeacherIdList()
-									.stream().filter(backCourseSchedule.getTeachingTeacherIdList()::contains)
-									.collect(Collectors.toList());
-							if (!CollectionUtils.isEmpty(repeatIds)) {
-								throw new BizException(courseCheckInfo(preCourseSchedule, backCourseSchedule, existCourseScheduleIds, 2));
-							}
-						}
-						//学生冲突检测
-						if (preCourseSchedule.getClassGroupId().equals(backCourseSchedule.getClassGroupId())) {
-							//如果班级相同，则学生肯定存在冲突
-							throw new BizException(courseCheckInfo(preCourseSchedule, backCourseSchedule, existCourseScheduleIds, 3));
-						}
-						//如果班级不同，则需要检测两个班级是否存在重复的学生
-						List<ClassGroupStudentMapper> preClassGroupStudents = classGroupStudentsMap.get(preCourseSchedule.getClassGroupId());
-						List<ClassGroupStudentMapper> backClassGroupStudents = classGroupStudentsMap.get(backCourseSchedule.getClassGroupId());
-						//如果有一个存在没有学生的班级则不存在冲突
-						if (CollectionUtils.isEmpty(preClassGroupStudents) || CollectionUtils.isEmpty(backClassGroupStudents)) {
-							continue;
-						}
-						//课程对应请假学员编号集合
-						Set<Integer> preLeaveStudentIds = courseLeaveStudentMap.get(preCourseSchedule.getId());
-						if(null == preLeaveStudentIds){
-							preLeaveStudentIds = Collections.EMPTY_SET;
-						}
-						Set<Integer> backLeaveStudentIds = courseLeaveStudentMap.get(backCourseSchedule.getId());
-						if(null == backLeaveStudentIds){
-							backLeaveStudentIds = Collections.EMPTY_SET;
-						}
-
-						//当前课程所在班级的学生编号列表
-						Set<Integer> finalPreLeaveStudentIds = preLeaveStudentIds;
-						List<Integer> preClassGroupStudentIds = preClassGroupStudents.stream()
-								.filter(e->!finalPreLeaveStudentIds.contains(e.getUserId()))
-								.map(ClassGroupStudentMapper::getUserId)
-								.collect(Collectors.toList());
-						//后面一节课程所在班级的学生编号列表
-						Set<Integer> finalBackLeaveStudentIds = backLeaveStudentIds;
-						Set<Integer> backClassGroupStudentIds = backClassGroupStudents.stream()
-								.filter(e->!finalBackLeaveStudentIds.contains(e.getUserId()))
-								.map(ClassGroupStudentMapper::getUserId)
-								.collect(Collectors.toSet());
-						List<Integer> repeatStudentIds = preClassGroupStudentIds.stream()
-								.filter(backClassGroupStudentIds::contains)
-								.collect(Collectors.toList());
-						if (!CollectionUtils.isEmpty(repeatStudentIds)) {
-							throw new BizException(courseCheckInfo(preCourseSchedule, backCourseSchedule, existCourseScheduleIds, 3));
-						}
-					}
-				}
-			}
-		}
-	}
-
     @Override
     public void checkNewCourseSchedulesWithoutMusicGroup(List<CourseSchedule> courseSchedules, boolean checkExistCourseSchedule) {
         if (CollectionUtils.isEmpty(courseSchedules)) {

mec-teacher/src/main/java/com/ym/mec/teacher/controller/TeacherCourseScheduleController.java

@@ -4,10 +4,7 @@ import com.ym.mec.auth.api.client.SysUserFeignService;
 import com.ym.mec.auth.api.entity.SysUser;
 import com.ym.mec.biz.dal.dao.ClassGroupStudentMapperDao;
 import com.ym.mec.biz.dal.dao.StudentAttendanceDao;
-import com.ym.mec.biz.dal.dto.BatchInsertCoursesDto;
-import com.ym.mec.biz.dal.dto.ClassDateAdjustDto;
-import com.ym.mec.biz.dal.dto.CourseScheduleDto;
-import com.ym.mec.biz.dal.dto.TeacherRemarkCommitDto;
+import com.ym.mec.biz.dal.dto.*;
 import com.ym.mec.biz.dal.entity.CourseSchedule;
 import com.ym.mec.biz.dal.entity.SysConfig;
 import com.ym.mec.biz.dal.enums.ClassGroupStudentStatusEnum;
@@ -21,6 +18,7 @@ import com.ym.mec.biz.service.CourseScheduleService;
 import com.ym.mec.biz.service.StudentAttendanceService;
 import com.ym.mec.biz.service.SysConfigService;
 import com.ym.mec.common.controller.BaseController;
+import com.ym.mec.common.entity.HttpResponseResult;
 import com.ym.mec.common.exception.BizException;
 import com.ym.mec.common.page.QueryInfo;
 import com.ym.mec.util.collection.MapUtil;
@@ -322,4 +320,21 @@ public class TeacherCourseScheduleController extends BaseController {
         return succeed(scheduleService.teacherCourseMinutes(queryInfo));
     }
 
+    @ApiOperation(value = "课程批量调整检测-仅时间")
+    @PostMapping("/courseAdjustOnlyWithClassDateCheck")
+    public HttpResponseResult courseAdjustOnlyWithClassDateCheck(@RequestBody VipGroupCourseAdjustInfoDto vipGroupCourseAdjustInfo){
+        return succeed(scheduleService.courseAdjustOnlyWithClassDateCheck(vipGroupCourseAdjustInfo));
+    }
+
+    @ApiOperation(value = "课程批量调整")
+    @PostMapping("/courseAdjustOnlyWithClassDate")
+    public HttpResponseResult courseAdjustOnlyWithClassDate(@RequestBody List<CourseSchedule> courseSchedules){
+        SysUser user = sysUserFeignService.queryUserInfo();
+        if(null==user){
+            return failed(HttpStatus.FORBIDDEN, "请登录");
+        }
+        scheduleService.courseAdjustOnlyWithClassDate(courseSchedules,user.getId());
+        return succeed();
+    }
+
 }