package com.dsh.course.controller;
|
|
|
import cn.hutool.core.date.DateUtil;
|
import com.baomidou.mybatisplus.core.conditions.Wrapper;
|
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
|
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
|
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
|
import com.dsh.course.entity.*;
|
import com.dsh.course.entity.dto.*;
|
import com.dsh.course.feignclient.account.AppUserClient;
|
import com.dsh.course.feignclient.account.StudentClient;
|
import com.dsh.course.feignclient.account.model.Student;
|
import com.dsh.course.mapper.CoursePackageSchedulingMapper;
|
import com.dsh.course.mapper.CoursePackageStudentMapper;
|
import com.dsh.course.model.dto.ToClassDto;
|
import com.dsh.course.service.*;
|
import com.dsh.course.util.ResultUtil;
|
import com.dsh.course.util.UUIDUtil;
|
import io.swagger.annotations.Api;
|
import org.apache.commons.lang.StringUtils;
|
import org.apache.commons.lang3.ArrayUtils;
|
import org.checkerframework.checker.units.qual.A;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.http.MediaType;
|
import org.springframework.web.bind.annotation.*;
|
|
import javax.annotation.Resource;
|
import javax.swing.text.html.parser.Entity;
|
import java.text.ParseException;
|
import java.text.SimpleDateFormat;
|
import java.time.LocalDate;
|
import java.time.Period;
|
import java.time.ZoneId;
|
import java.util.*;
|
import java.util.stream.Collectors;
|
|
@Api
|
@CrossOrigin
|
@RestController
|
@RequestMapping("/courdent")
|
public class CourseStudentController {
|
@Autowired
|
CoursePackageStudentService studentService;
|
@Autowired
|
TCoursePackagePaymentService paymentService;
|
@Autowired
|
private CourseCounsumService counsumService;
|
@Autowired
|
private TCoursePackageService coursePackageService;
|
@Resource
|
private CoursePackageStudentMapper cpsMapper;
|
|
//获取退费记录
|
@RequestMapping("/getRefund")
|
@ResponseBody
|
public List<MoneyBack> getRefund() {
|
// 查询已通过申请的退费记录
|
return counsumService.getRefund();
|
}
|
|
|
@Resource
|
private CoursePackageSchedulingMapper coursePackageSchedulingService;
|
|
|
@RequestMapping("/getStudentTotal")
|
@ResponseBody
|
public List<Map<String, Object>> get(@RequestBody StudentQeryDto studentQeryDto) {
|
System.out.println("-====studentQeryDto=========" + studentQeryDto);
|
List<Map<String, Object>> pays = paymentService.getStudentTotal(studentQeryDto);
|
System.out.println("=========pays======" + pays);
|
|
return pays;
|
|
}
|
|
|
@RequestMapping("/bypac")
|
@ResponseBody
|
public List<Map<String, Object>> bypac(@RequestBody PacQueryDto pacQueryDto) {
|
System.out.println("-====studentQeryDto=========" + pacQueryDto);
|
if (pacQueryDto.getStoreIds() != null && pacQueryDto.getStoreIds().size() != 0) {
|
// 根据门店id 查询课包ids
|
List<Integer> coursePackageIds = coursePackageService.list(new QueryWrapper<TCoursePackage>()
|
.in("storeId", pacQueryDto.getStoreIds())).stream()
|
.map(TCoursePackage::getId).collect(Collectors.toList());
|
pacQueryDto.setStoreIds(coursePackageIds);
|
}
|
List<Map<String, Object>> pays = paymentService.bypac(pacQueryDto);
|
|
System.out.println("=========pays======" + pays);
|
|
return pays;
|
|
}
|
|
@ResponseBody
|
@PostMapping("/queryIdsByStore")
|
public List<Integer> queryIdsByStore(@RequestBody Integer objectId) {
|
List<TCoursePackage> list = packageService.list(new LambdaQueryWrapper<TCoursePackage>().eq(TCoursePackage::getStoreId, objectId));
|
List<Integer> collect = list.stream().map(TCoursePackage::getId).collect(Collectors.toList());
|
if (collect.size() == 0) {
|
collect.add(-1);
|
}
|
return collect;
|
}
|
|
|
|
|
@ResponseBody
|
@PostMapping("/queryAble")
|
public Integer queryAble(@RequestBody Integer id) {
|
|
int coursePackageId = orderStudentService.count(new QueryWrapper<CoursePackageOrderStudent>().eq("coursePackageId", id));
|
if (coursePackageId>0){
|
return 1;
|
}else {
|
return 0;
|
}
|
|
}
|
|
//获取学员课时数信息
|
@RequestMapping("/getInfo")
|
@ResponseBody
|
public StudentClassInfo list(@RequestParam("tStudentId") Integer tStudentId){
|
|
// System.out.println("------------>"+tStudentId);
|
|
|
StudentClassInfo studentClassInfo = studentService.listAll(tStudentId);
|
|
// Date maxDate = studentService.getMaxDate(tStudentId);
|
Date minDate = studentService.getMinDate(tStudentId);
|
Integer totalHours = studentClassInfo.getTotalHours();
|
Integer hasHours = studentClassInfo.getRestHours();
|
Integer restHours = totalHours - hasHours;
|
studentClassInfo.setHasHours(restHours);
|
studentClassInfo.setInDate(minDate);
|
System.out.println("===========>" + studentClassInfo);
|
|
// appUserClient.queryGift(tStudentId);
|
|
return studentClassInfo;
|
}
|
|
//获取学员课程列表
|
@RequestMapping("/getClassList")
|
@ResponseBody
|
public List<ClassListDto> listClass(@RequestParam("tStudentId") Integer tStudentId) {
|
System.out.println("==========getClassList===tStudentId====" + tStudentId);
|
List<ClassListDto> listDtos = studentService.getClassList(tStudentId);
|
for (ClassListDto dto : listDtos) {
|
if (dto.getClassType()!=2) {
|
dto.setHasClassHours(dto.getTotalClassHours() - dto.getLaveClassHours());
|
}
|
}
|
System.out.println("======listDtos======" + listDtos);
|
return listDtos;
|
|
}
|
|
//获取学员有效期
|
@RequestMapping("/getUseTime")
|
@ResponseBody
|
public Date getUseTime(@RequestParam("tStudentId") Integer tStudentId) {
|
Date maxDate = studentService.getMaxDate(tStudentId);
|
|
return maxDate;
|
|
}
|
|
//批量修改有效期
|
@RequestMapping("/updateUseDate")
|
@ResponseBody
|
public void updateUseDate(@RequestBody updateTimeDto updateTimeDto) {
|
System.out.println("=========updateUseDate=====>=" + updateTimeDto);
|
List<TCoursePackagePayment> paymentList = paymentService.list(new QueryWrapper<TCoursePackagePayment>().eq("studentId", updateTimeDto.getTStudentId()));
|
|
System.out.println("=========paymentList=====>=" + paymentList);
|
|
for (TCoursePackagePayment payment : paymentList) {
|
// payment.setUseTime(updateTimeDto.getDate());
|
paymentService.updateUseTime(payment.getId(), updateTimeDto.getDate());
|
}
|
System.out.println("=======updateUseDate=======>" + paymentList);
|
|
|
}
|
|
@Resource
|
private AppUserClient appUserClient;
|
|
|
@Autowired
|
private ICoursePackageOrderStudentService orderStudentService;
|
//获取可转移学员
|
@RequestMapping("/getSelect")
|
@ResponseBody
|
public List<SelectDto> getSelect(@RequestParam("payId") Long payId) {
|
|
// TCoursePackagePayment byId = paymentService.getById(payId);
|
//
|
// List<Integer> studentIds = paymentService.getStudentIds(payId, byId.getCoursePackageId(), byId.getAppUserId());
|
// System.out.println("=========studentIds=================>" + studentIds);
|
|
CoursePackageOrderStudent coursePackageOrderStudent = orderStudentService.getById(payId);
|
|
|
List<CoursePackageOrderStudent> orderStudent = orderStudentService.list(new QueryWrapper<CoursePackageOrderStudent>().eq("appUserId", coursePackageOrderStudent.getAppUserId()).eq("coursePackageId", coursePackageOrderStudent.getCoursePackageId()).ne("id",payId));
|
|
List<Integer> studentIds = new ArrayList<>();
|
for (CoursePackageOrderStudent packageOrderStudent : orderStudent) {
|
studentIds.add(packageOrderStudent.getStudentId());
|
}
|
|
|
if (studentIds.size() > 0) {
|
List<SelectDto> selectDtos = appUserClient.getSelects(studentIds);
|
|
return selectDtos;
|
} else return null;
|
}
|
|
|
//根据payid获取对应门店的常规课程
|
|
@Autowired
|
private TCoursePackageService packageService;
|
|
@RequestMapping("/holiSelect")
|
@ResponseBody
|
public List<SelectDto> getHoliSelect(@RequestParam("courseId") Integer id) {
|
|
TCoursePackage byId = packageService.getById(id);
|
Integer storeId = byId.getStoreId();
|
List<TCoursePackage> list = packageService.list(new QueryWrapper<TCoursePackage>()
|
.select("id", "name")
|
.eq("storeId", storeId)
|
.eq("type", "2")
|
);
|
List<SelectDto> selectDtos = new ArrayList<>();
|
for (TCoursePackage t : list) {
|
SelectDto selectDto = new SelectDto();
|
selectDto.setId(t.getId());
|
selectDto.setValue(t.getName());
|
selectDtos.add(selectDto);
|
}
|
|
|
return selectDtos;
|
}
|
|
@RequestMapping("/transSelect")
|
@ResponseBody
|
public List<SelectDto> getTransSelect(@RequestParam("courseId") Integer id) {
|
|
TCoursePackage byId = packageService.getById(id);
|
Integer storeId = byId.getStoreId();
|
List<TCoursePackage> list = packageService.list(new QueryWrapper<TCoursePackage>()
|
.select("id", "name")
|
.eq("storeId", storeId)
|
.eq("type", "1").ne("id", id)
|
);
|
List<SelectDto> selectDtos = new ArrayList<>();
|
for (TCoursePackage t : list) {
|
SelectDto selectDto = new SelectDto();
|
selectDto.setId(t.getId());
|
selectDto.setValue(t.getName());
|
selectDtos.add(selectDto);
|
}
|
|
|
return selectDtos;
|
}
|
|
|
@RequestMapping("/queryCounsum")
|
@ResponseBody
|
public List<CourseCounsum> queryCounsum(@RequestBody ConsumeQuery consumeQuery) {
|
System.out.println("======queryCounsum===========" + consumeQuery);
|
|
QueryWrapper<CourseCounsum> queryWrapper = new QueryWrapper<>();
|
queryWrapper.eq("paymentId", consumeQuery.getPayId());
|
|
|
if (consumeQuery.getChangeType() != null) {
|
queryWrapper.eq("changeType", consumeQuery.getChangeType());
|
}
|
if (consumeQuery.getStart() != null) {
|
queryWrapper.between("insertTime", consumeQuery.getStart(), consumeQuery.getEnd());
|
}
|
if (consumeQuery.getReason() != null && consumeQuery.getReason() != "") {
|
queryWrapper.like("reason", consumeQuery.getReason());
|
|
}
|
List<CourseCounsum> list = counsumService.list(queryWrapper);
|
// List<CourseCounsum> list = counsumService.list(new QueryWrapper<CourseCounsum>().eq("paymentId", consumeQuery.getPayId()).eq("changeType", consumeQuery.getChangeType()).between("insertTime", consumeQuery.getStart(), consumeQuery.getEnd()).like("reason", consumeQuery.getReason()));
|
return list;
|
}
|
|
|
|
|
@RequestMapping("/insertBack")
|
@ResponseBody
|
public Integer insertBack(@RequestBody InsertBackDto insertBackDto) {
|
|
List<MoneyBack> ids = moneyBackService.list(new QueryWrapper<MoneyBack>().eq("ids", insertBackDto.getIds()));
|
|
if (!ids.isEmpty()){
|
return 1 ;
|
}
|
|
|
MoneyBack moneyBack = new MoneyBack();
|
moneyBack.setStudentId(insertBackDto.getId());
|
moneyBack.setStatus(0);
|
moneyBack.setInsertTime(new Date());
|
moneyBack.setIds(insertBackDto.getIds());
|
moneyBackService.save(moneyBack);
|
|
// List<TCoursePackagePayment> pays = paymentService.list(new QueryWrapper<TCoursePackagePayment>().in("id", insertBackDto.getIds()));
|
|
|
List<CoursePackageOrderStudent> pays = orderStudentService.list(new QueryWrapper<CoursePackageOrderStudent>().in("id", insertBackDto.getIds()));
|
for (CoursePackageOrderStudent o : pays) {
|
o.setStatus(4);
|
o.setAppUserId(null);
|
List<CoursePackageScheduling> coursePackageSchedulings = coursePackageSchedulingService.selectList(new QueryWrapper<CoursePackageScheduling>().eq("studentId", o.getStudentId()).eq("coursePackageId", o.getCoursePackageId()).ge("classDate", new Date()));
|
List<Long> scs = new ArrayList<>();
|
for (CoursePackageScheduling coursePackageScheduling : coursePackageSchedulings) {
|
scs.add(coursePackageScheduling.getId());
|
}
|
coursePackageStudentService.remove(new QueryWrapper<CoursePackageStudent>().in("coursePackageSchedulingId",scs));
|
coursePackageSchedulingService.deleteBatchIds(scs);
|
|
|
|
}
|
|
|
|
orderStudentService.updateBatchById(pays);
|
return 0;
|
}
|
|
|
@Autowired
|
private ICoursePackageOrderService coursePackageOrderService;
|
|
@Autowired
|
private ICoursePackageOrderStudentService coursePackageOrderStudentService;
|
@RequestMapping("/queryByIds")
|
@ResponseBody
|
public List<CoursePackageOrderStudent> queryByIds(@RequestParam("ids") String ids) {
|
List<CoursePackageOrderStudent> paymentList = coursePackageOrderStudentService.list(new QueryWrapper<CoursePackageOrderStudent>()
|
.in("id", Arrays.asList(ids.split(","))));
|
|
System.out.println("========client==>" + paymentList);
|
return paymentList;
|
}
|
|
@RequestMapping("/changeStatus")
|
@ResponseBody
|
public void changeStatus(@RequestParam("id") Integer id) {
|
MoneyBack byId = moneyBackService.getById(id);
|
byId.setStatus(1);
|
moneyBackService.updateById(byId);
|
|
}
|
|
|
|
@RequestMapping("/noStatus")
|
@ResponseBody
|
public void noStatus(@RequestParam("id") Integer id) {
|
MoneyBack byId = moneyBackService.getById(id);
|
byId.setStatus(2);
|
moneyBackService.updateById(byId);
|
|
List<CoursePackageOrderStudent> pays = orderStudentService.list(new QueryWrapper<CoursePackageOrderStudent>().in("id", byId.getIds()));
|
for (CoursePackageOrderStudent o : pays) {
|
o.setStatus(1);
|
o.setAppUserId(null);
|
schedulingService.addNewCoursePackageScheduling(o.getId(),o.getLaveClassHours());
|
}
|
orderStudentService.updateBatchById(pays);
|
|
}
|
|
@RequestMapping("/zeroClass")
|
@ResponseBody
|
public void zeroClass(@RequestParam("id") Integer id) {
|
MoneyBack byId = moneyBackService.getById(id);
|
String[] split2 = byId.getIds().split(",");
|
System.out.println("========split===>" + split2);
|
List<TCoursePackagePayment> id1 = paymentService.list(new QueryWrapper<TCoursePackagePayment>().in("id", split2));
|
for (TCoursePackagePayment o : id1) {
|
CourseCounsum courseCounsum = new CourseCounsum();
|
courseCounsum.setNum(o.getLaveClassHours());
|
courseCounsum.setChangeType(0);
|
courseCounsum.setReason("退费");
|
courseCounsum.setPaymentId(o.getId());
|
courseCounsum.setInsertTime(new Date());
|
counsumService.save(courseCounsum);
|
|
o.setTotalClassHours(0);
|
o.setLaveClassHours(0);
|
o.setStatus(2);
|
o.setAppUserId(null);
|
|
|
TCoursePackage tCoursePackage = packageService.getById(o.getCoursePackageId());
|
String classWeeks = tCoursePackage.getClassWeeks();
|
List<Integer> week = week(classWeeks);
|
|
String[] split = tCoursePackage.getClassStartTime().split(",");
|
String[] split1 = tCoursePackage.getClassEndTime().split(",");
|
SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
|
SimpleDateFormat format1 = new SimpleDateFormat("yyyy-MM-dd HH:mm");
|
// 本周周几
|
|
List<CoursePackageStudent> studentCourse = coursePackageStudentService.list(new QueryWrapper<CoursePackageStudent>().eq("studentId", o.getStudentId()).eq("coursePackageId", o.getCoursePackageId()));
|
List<Long> collect = studentCourse.stream().map(CoursePackageStudent::getCoursePackageSchedulingId).collect(Collectors.toList());
|
//拿到最后一天的排课记录
|
if (collect.size() > 0) {
|
coursePackageSchedulingService.delete(new QueryWrapper<CoursePackageScheduling>().in("id", collect));
|
coursePackageStudentService.remove(new QueryWrapper<CoursePackageStudent>().eq("studentId", o.getStudentId()).eq("coursePackageId", o.getCoursePackageId()));
|
}
|
|
|
}
|
paymentService.updateBatchById(id1);
|
}
|
|
|
|
@RequestMapping("/getOrder")
|
@ResponseBody
|
public List<CoursePackageOrder> getOrder(@RequestParam("id") Long id) {
|
|
CoursePackageOrderStudent coursePackageOrderStudent = coursePackageOrderStudentService.getById(id);
|
|
List<CoursePackageOrder> list = coursePackageOrderService.list(new QueryWrapper<CoursePackageOrder>().eq("coursePackageId", coursePackageOrderStudent.getCoursePackageId()).like("studentIds", coursePackageOrderStudent.getStudentId()));
|
return list;
|
}
|
|
|
@RequestMapping("/backStausClass")
|
@ResponseBody
|
public void backStausClass(@RequestParam("id") Integer id) {
|
// MoneyBack byId = moneyBackService.getById(id);
|
// String[] split = byId.getIds().split(",");
|
// System.out.println("========split===>" + split);
|
// List<CoursePackageOrderStudent> id1 = coursePackageOrderStudentService.list(new QueryWrapper<CoursePackageOrderStudent>().in("id", split));
|
// for (CoursePackageOrderStudent o : id1) {
|
// o.setStatus(1);
|
// o.setAppUserId(null);
|
// }
|
// coursePackageOrderStudentService.updateBatchById(id1);
|
}
|
|
@RequestMapping("/cancel")
|
@ResponseBody
|
public void cancel(@RequestParam("ids") String ids) {
|
String[] split = ids.split(",");
|
List<CoursePackageStudent> coursePackagePaymentId = studentService.list(new QueryWrapper<CoursePackageStudent>().in("coursePackagePaymentId", split));
|
for (CoursePackageStudent student : coursePackagePaymentId) {
|
student.setReservationStatus(3);
|
student.setAppUserId(null);
|
}
|
studentService.updateBatchById(coursePackagePaymentId);
|
|
|
}
|
|
@Autowired
|
private MoneyBackService moneyBackService;
|
|
@RequestMapping("/getMoneyBack")
|
@ResponseBody
|
public List<MoneyBack> getMoneyBack(@RequestParam("tStudentId") Integer tStudentId) {
|
|
List<MoneyBack> moneyBacksck = moneyBackService.list(new QueryWrapper<MoneyBack>().eq("studentId", tStudentId));
|
return moneyBacksck;
|
}
|
|
|
|
@Autowired
|
private ICoursePackageSchedulingService schedulingService;
|
|
//课程转移
|
@RequestMapping("/toClass")
|
@ResponseBody
|
public void toClass(@RequestBody ToClassDto toClassDto) throws ParseException {
|
CoursePackageOrderStudent orinPay = orderStudentService.getById(toClassDto.getId());
|
CoursePackageOrderStudent studentPay = orderStudentService.getOne(new QueryWrapper<CoursePackageOrderStudent>()
|
.eq("studentId", toClassDto.getToStudentId())
|
.eq("coursePackageId", orinPay.getCoursePackageId()));
|
TCoursePackage coursePackage = packageService.getById(orinPay.getCoursePackageId());
|
if (studentPay != null) {
|
//转移
|
Integer laveClassHours = orinPay.getLaveClassHours();
|
Integer totalClassHours = orinPay.getTotalClassHours();
|
|
CourseCounsum courseCounsum = new CourseCounsum();
|
courseCounsum.setInsertTime(new Date());
|
Integer appUserId = orinPay.getAppUserId();
|
Integer appUserId1 = studentPay.getAppUserId();
|
if (appUserId.compareTo(appUserId1) != 0) {
|
courseCounsum.setReason("赠课");
|
} else {
|
courseCounsum.setReason("课时转移");
|
}
|
|
orinPay.setLaveClassHours(0);
|
orinPay.setStatus(5);
|
orinPay.setAppUserId(null);
|
orderStudentService.updateById(orinPay);
|
|
courseCounsum.setNum(laveClassHours);
|
courseCounsum.setChangeType(0);
|
courseCounsum.setPaymentId(orinPay.getId());
|
counsumService.save(courseCounsum);
|
|
CourseCounsum courseCounsum1 = new CourseCounsum();
|
courseCounsum1.setInsertTime(new Date());
|
if (appUserId.compareTo(appUserId1) != 0) {
|
courseCounsum1.setReason("赠课");
|
} else {
|
courseCounsum1.setReason("课时转移");
|
}
|
courseCounsum1.setNum(laveClassHours);
|
courseCounsum1.setChangeType(1);
|
courseCounsum1.setPaymentId(studentPay.getId());
|
counsumService.save(courseCounsum1);
|
|
schedulingService.addNewCoursePackageScheduling(studentPay.getId(), laveClassHours);
|
//删除原排课数据
|
List<CoursePackageScheduling> coursePackageSchedulings = coursePackageSchedulingService.selectList(new QueryWrapper<CoursePackageScheduling>()
|
.eq("type", 1).eq("appUserId", appUserId)
|
.eq("studentId", orinPay.getStudentId()).eq("coursePackageId", orinPay.getCoursePackageId())
|
.orderByAsc("classDate"));
|
int num = totalClassHours - laveClassHours;
|
for (int i = num; i < coursePackageSchedulings.size(); i++) {
|
CoursePackageScheduling packageScheduling = coursePackageSchedulings.get(i);
|
coursePackageSchedulingService.deleteById(packageScheduling.getId());
|
coursePackageStudentService.remove(new QueryWrapper<CoursePackageStudent>().eq("coursePackageSchedulingId", packageScheduling.getId()));
|
}
|
} else {
|
|
Integer totalClassHours = orinPay.getTotalClassHours();
|
Integer laveClassHours = orinPay.getLaveClassHours();
|
Student student = studentClient.queryStudentById(toClassDto.getToStudentId());
|
CoursePackageOrderStudent to = new CoursePackageOrderStudent();
|
to.setStudentId(toClassDto.getToStudentId());
|
to.setTotalClassHours(laveClassHours);
|
to.setLaveClassHours(laveClassHours);
|
to.setCoursePackageId(orinPay.getCoursePackageId());
|
to.setState(1);
|
to.setAppUserId(student.getAppUserId());
|
to.setStatus(1);
|
to.setInsertTime(new Date());
|
|
Integer validDays = coursePackage.getValidDays();
|
Calendar calendar = Calendar.getInstance();
|
calendar.setTime(new Date());
|
calendar.set(Calendar.DAY_OF_YEAR, calendar.get(Calendar.DAY_OF_YEAR) + validDays);
|
to.setUseTime(calendar.getTime());
|
orderStudentService.save(to);
|
if(null == student.getValidity()){
|
student.setValidity(calendar.getTime());
|
}else if(student.getValidity().getTime() < calendar.getTime().getTime()){
|
student.setValidity(calendar.getTime());
|
}
|
studentClient.frozen(student);
|
|
|
Integer laveClassHours1 = orinPay.getLaveClassHours();
|
Integer appUserId = orinPay.getAppUserId();
|
orinPay.setLaveClassHours(0);
|
orinPay.setAppUserId(null);
|
orinPay.setStatus(6);
|
orderStudentService.updateById(orinPay);
|
|
|
CourseCounsum courseCounsum = new CourseCounsum();
|
courseCounsum.setInsertTime(new Date());
|
courseCounsum.setReason("赠课");
|
courseCounsum.setNum(laveClassHours1);
|
courseCounsum.setChangeType(0);
|
courseCounsum.setPaymentId(orinPay.getId());
|
counsumService.save(courseCounsum);
|
|
|
CourseCounsum courseCounsum1 = new CourseCounsum();
|
courseCounsum1.setInsertTime(new Date());
|
courseCounsum1.setReason("赠课");
|
courseCounsum1.setNum(laveClassHours1);
|
courseCounsum1.setChangeType(1);
|
courseCounsum1.setPaymentId(to.getId());
|
counsumService.save(courseCounsum1);
|
|
//开始排课
|
addPackageStudent(coursePackage, to.getAppUserId(), to.getStudentId(), to);
|
//删除原排课数据
|
List<CoursePackageScheduling> coursePackageSchedulings = coursePackageSchedulingService.selectList(new QueryWrapper<CoursePackageScheduling>()
|
.eq("type", 1).eq("appUserId", appUserId)
|
.eq("studentId", orinPay.getStudentId()).eq("coursePackageId", orinPay.getCoursePackageId())
|
.orderByAsc("classDate"));
|
int num = totalClassHours - laveClassHours;
|
for (int i = num; i < coursePackageSchedulings.size(); i++) {
|
CoursePackageScheduling packageScheduling = coursePackageSchedulings.get(i);
|
coursePackageSchedulingService.deleteById(packageScheduling.getId());
|
coursePackageStudentService.remove(new QueryWrapper<CoursePackageStudent>().eq("coursePackageSchedulingId", packageScheduling.getId()));
|
}
|
}
|
}
|
|
|
|
/**
|
* 新购买课程后的排课
|
*
|
* @param userId
|
* @param sId
|
* @throws ParseException
|
*/
|
private void addPackageStudent(TCoursePackage tCoursePackage, Integer userId, Integer sId, CoursePackageOrderStudent coursePackageOrderStudent) {
|
try {
|
//1常规 2假期 3体验
|
if (tCoursePackage.getType() == 1) {
|
//上课星期
|
String classWeeks = tCoursePackage.getClassWeeks();
|
List<Integer> week = week(classWeeks);
|
//上课时段
|
String[] split = tCoursePackage.getClassStartTime().split(",");
|
String[] split1 = tCoursePackage.getClassEndTime().split(",");
|
SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
|
SimpleDateFormat format1 = new SimpleDateFormat("yyyy-MM-dd HH:mm");
|
|
|
//剩余课时
|
Integer laveClassHours = coursePackageOrderStudent.getLaveClassHours();
|
//扣除课时数
|
Integer codeTime = tCoursePackage.getCodeTime();
|
//排课 本周+下周，课时不够扣则直接剩余不排课
|
Calendar calendar = Calendar.getInstance();
|
calendar.setTime(new Date());
|
calendar.set(Calendar.DAY_OF_YEAR, calendar.get(Calendar.DAY_OF_YEAR) + 1);
|
calendar.set(Calendar.HOUR_OF_DAY, 0);
|
calendar.set(Calendar.MINUTE, 0);
|
calendar.set(Calendar.SECOND, 0);
|
int day_week = calendar.get(Calendar.DAY_OF_WEEK);
|
day_week = day_week - 1 == 0 ? 7 : day_week - 1;
|
int num = 8 - day_week + 7;
|
|
Student student = studentClient.queryStudentById(coursePackageOrderStudent.getStudentId());
|
Date useTime = student.getValidity();
|
|
for (int i = 0; i < num; i++) {
|
Date time = calendar.getTime();
|
|
//判断当天是否在排课星期内
|
int day = calendar.get(Calendar.DAY_OF_WEEK);
|
day = day - 1 == 0 ? 7 : day - 1;
|
if (!week.contains(day)) {
|
calendar.set(Calendar.DAY_OF_YEAR, calendar.get(Calendar.DAY_OF_YEAR) + 1);
|
continue;
|
}
|
|
|
//大于有效期不进行排课
|
if (calendar.getTimeInMillis() >= useTime.getTime()) {
|
break;
|
}
|
for (int j = 0; j < split.length; j++) {
|
//剩余数量不足以排课
|
if (laveClassHours.compareTo(codeTime) < 0) {
|
break;
|
}
|
|
laveClassHours -= codeTime;
|
|
CoursePackageScheduling coursePackageScheduling = new CoursePackageScheduling();
|
coursePackageScheduling.setType(tCoursePackage.getType());
|
coursePackageScheduling.setAppUserId(userId);
|
coursePackageScheduling.setStudentId(sId);
|
coursePackageScheduling.setCoursePackageId(tCoursePackage.getId());
|
Date parse = format1.parse(format.format(time) + " " + split[j]);
|
Date parse1 = format1.parse(format.format(time) + " " + split1[j]);
|
coursePackageScheduling.setClassDate(parse);
|
coursePackageScheduling.setEndDate(parse1);
|
coursePackageScheduling.setStatus(1);
|
coursePackageSchedulingService.insert(coursePackageScheduling);
|
CoursePackageStudent student1 = new CoursePackageStudent();
|
student1.setAppUserId(userId);
|
student1.setStudentId(sId);
|
student1.setCoursePackageId(tCoursePackage.getId());
|
student1.setCoursePackagePaymentId(coursePackageOrderStudent.getId());
|
student1.setCoursePackageSchedulingId(coursePackageScheduling.getId());
|
student1.setSignInOrNot(1);
|
student1.setReservationStatus(1);
|
student1.setInsertTime(new Date());
|
cpsMapper.insert(student1);
|
}
|
//增加日期，用于判断
|
calendar.set(Calendar.DAY_OF_YEAR, calendar.get(Calendar.DAY_OF_YEAR) + 1);
|
}
|
}
|
|
if (tCoursePackage.getType() == 2) {
|
//上课星期
|
String classWeeks = tCoursePackage.getClassWeeks();
|
List<Integer> week = week(classWeeks);
|
//上课时段
|
String[] split = tCoursePackage.getClassStartTime().split(",");
|
String[] split1 = tCoursePackage.getClassEndTime().split(",");
|
SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
|
SimpleDateFormat format1 = new SimpleDateFormat("yyyy-MM-dd HH:mm");
|
|
Date startTime = tCoursePackage.getStartTime();
|
Date endTime = tCoursePackage.getEndTime();
|
//排课 本周+下周，课时不够扣则直接剩余不排课
|
Calendar calendar = Calendar.getInstance();
|
//假期开始使用当前时间为起始时间进行排课
|
calendar.setTime(startTime.getTime() > System.currentTimeMillis() ? startTime : new Date());
|
calendar.set(Calendar.DAY_OF_YEAR, calendar.get(Calendar.DAY_OF_YEAR) + 1);
|
while (true) {
|
Date time = calendar.getTime();
|
|
//判断当天是否在排课星期内
|
int day = calendar.get(Calendar.DAY_OF_WEEK);
|
day = day - 1 == 0 ? 7 : day - 1;
|
if (!week.contains(day)) {
|
calendar.set(Calendar.DAY_OF_YEAR, calendar.get(Calendar.DAY_OF_YEAR) + 1);
|
continue;
|
}
|
|
//大于有效期不进行排课
|
if (calendar.getTimeInMillis() > endTime.getTime()) {
|
break;
|
}
|
for (int j = 0; j < split.length; j++) {
|
CoursePackageScheduling coursePackageScheduling = new CoursePackageScheduling();
|
coursePackageScheduling.setType(tCoursePackage.getType());
|
coursePackageScheduling.setAppUserId(userId);
|
coursePackageScheduling.setStudentId(sId);
|
coursePackageScheduling.setCoursePackageId(tCoursePackage.getId());
|
Date parse = format1.parse(format.format(time) + " " + split[j]);
|
Date parse1 = format1.parse(format.format(time) + " " + split1[j]);
|
coursePackageScheduling.setClassDate(parse);
|
coursePackageScheduling.setEndDate(parse1);
|
coursePackageScheduling.setStatus(1);
|
coursePackageSchedulingService.insert(coursePackageScheduling);
|
CoursePackageStudent student1 = new CoursePackageStudent();
|
student1.setAppUserId(userId);
|
student1.setStudentId(sId);
|
student1.setCoursePackageId(tCoursePackage.getId());
|
student1.setCoursePackagePaymentId(null);
|
student1.setCoursePackageSchedulingId(coursePackageScheduling.getId());
|
student1.setSignInOrNot(1);
|
student1.setReservationStatus(1);
|
student1.setInsertTime(new Date());
|
cpsMapper.insert(student1);
|
}
|
//增加日期，用于判断
|
calendar.set(Calendar.DAY_OF_YEAR, calendar.get(Calendar.DAY_OF_YEAR) + 1);
|
}
|
}
|
} catch (Exception e) {
|
e.printStackTrace();
|
}
|
}
|
|
@Resource
|
private StudentClient studentClient;
|
@Autowired
|
private CourseCounsumService courseCounsumService;
|
|
@RequestMapping(value = "/toHoli", produces = MediaType.APPLICATION_JSON_UTF8_VALUE, consumes = "application/json;charset=UTF-8")
|
@ResponseBody
|
public String toHoli(@RequestBody ToHoliDto toHoliDto) throws ParseException {
|
String[] stuIds = toHoliDto.getIds();
|
//查询出学员ids对应的棵树，判断剩余课时数是否够
|
List<CoursePackageOrderStudent> list = orderStudentService.list(new QueryWrapper<CoursePackageOrderStudent>().eq("coursePackageId", toHoliDto.getClassId()).in("studentId", stuIds));
|
List<String> notStudent = new ArrayList<>();
|
for (CoursePackageOrderStudent coursePackageOrderStudent : list) {
|
if (coursePackageOrderStudent.getLaveClassHours() < toHoliDto.getClassNum()) {
|
notStudent.add(studentClient.queryStudentById(coursePackageOrderStudent.getStudentId()).getName());
|
}
|
}
|
if (!notStudent.isEmpty()) {
|
String notStudentStr = String.join(",", notStudent);
|
return notStudentStr+":课时数不足";
|
}
|
|
for (String stuId : stuIds) {
|
Student student = studentClient.queryStudentById(Integer.valueOf(stuId));
|
|
// 扣除 原来的课时数
|
// 添加购买课时 paytyoe为7
|
// 排课可期 判断课程时间段 添加排课表 添加上课记录表
|
// 找到原来的课包 扣课时
|
// CoursePackageOrderStudent coursePackageOrderStudent = orderStudentService.getById(toHoliDto.getId());
|
CoursePackageOrderStudent coursePackageOrderStudent = orderStudentService.getOne(new QueryWrapper<CoursePackageOrderStudent>().eq("coursePackageId",toHoliDto.getId()).eq("studentId",stuId));
|
|
TCoursePackage coursePackage = coursePackageService.getById(coursePackageOrderStudent.getCoursePackageId());
|
TCoursePackage coursePackage1 = coursePackageService.getById(toHoliDto.getClassId());
|
//判断剩余课时是否已经全部进行排课，如果排课需要删除已经排好的记录
|
List<CoursePackageScheduling> list1 = coursePackageSchedulingService.selectList(new QueryWrapper<CoursePackageScheduling>()
|
.eq("studentId", coursePackageOrderStudent.getStudentId()).eq("status", 1)
|
.eq("type", 1).orderByDesc("classDate"));
|
//已经排课但没有使用的课时数量
|
int number = list1.size() * coursePackage.getNeedNum();
|
Integer laveClassHours1 = coursePackageOrderStudent.getLaveClassHours();
|
laveClassHours1 -= number;
|
//需要购买使用的课时数
|
Integer num = toHoliDto.getClassNum();
|
//需要删除多余的排课记录
|
if(num.compareTo(laveClassHours1) > 0){
|
//课时数差额
|
int number1 = num - laveClassHours1;
|
double o = number1 % coursePackage.getNeedNum();
|
int l = 0;
|
if(0 != o){
|
l = 1;
|
}
|
int n = Double.valueOf(number1 / coursePackage.getNeedNum()).intValue() + l;
|
for (int i = 0; i < n; i++) {
|
CoursePackageScheduling coursePackageScheduling = list1.get(i);
|
coursePackageSchedulingService.deleteById(coursePackageScheduling.getId());
|
|
coursePackageStudentService.getBaseMapper().delete(new QueryWrapper<CoursePackageStudent>()
|
.eq("coursePackageSchedulingId", coursePackageScheduling.getId()));
|
}
|
}
|
coursePackageOrderStudent.setAppUserId(null);
|
coursePackageOrderStudent.setLaveClassHours(coursePackageOrderStudent.getLaveClassHours()-toHoliDto.getClassNum());
|
orderStudentService.updateById(coursePackageOrderStudent);
|
|
//上课星期
|
String classWeeks = coursePackage1.getClassWeeks();
|
List<Integer> week = week(classWeeks);
|
//上课时段
|
String[] split = coursePackage1.getClassStartTime().split(",");
|
String[] split1 = coursePackage1.getClassEndTime().split(",");
|
SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
|
SimpleDateFormat format1 = new SimpleDateFormat("yyyy-MM-dd HH:mm");
|
|
Date startTime = coursePackage1.getStartTime();
|
Date endTime = coursePackage1.getEndTime();
|
//排课 本周+下周，课时不够扣则直接剩余不排课
|
Calendar calendar = Calendar.getInstance();
|
//假期开始使用当前时间为起始时间进行排课
|
calendar.setTime(startTime.getTime() > System.currentTimeMillis() ? startTime : new Date());
|
calendar.set(Calendar.DAY_OF_YEAR, calendar.get(Calendar.DAY_OF_YEAR) + 1);
|
while (true) {
|
Date time = calendar.getTime();
|
|
//判断当天是否在排课星期内
|
int day = calendar.get(Calendar.DAY_OF_WEEK);
|
day = day - 1 == 0 ? 7 : day - 1;
|
if (!week.contains(day)) {
|
calendar.set(Calendar.DAY_OF_YEAR, calendar.get(Calendar.DAY_OF_YEAR) + 1);
|
continue;
|
}
|
|
//大于有效期不进行排课
|
if (calendar.getTimeInMillis() > endTime.getTime()) {
|
break;
|
}
|
for (int j = 0; j < split.length; j++) {
|
CoursePackageScheduling coursePackageScheduling = new CoursePackageScheduling();
|
coursePackageScheduling.setType(coursePackage1.getType());
|
coursePackageScheduling.setAppUserId(student.getAppUserId());
|
coursePackageScheduling.setStudentId(Integer.valueOf(stuId));
|
coursePackageScheduling.setCoursePackageId(coursePackage1.getId());
|
Date parse = format1.parse(format.format(time) + " " + split[j]);
|
Date parse1 = format1.parse(format.format(time) + " " + split1[j]);
|
coursePackageScheduling.setClassDate(parse);
|
coursePackageScheduling.setEndDate(parse1);
|
coursePackageScheduling.setStatus(1);
|
coursePackageSchedulingService.insert(coursePackageScheduling);
|
CoursePackageStudent student1 = new CoursePackageStudent();
|
student1.setAppUserId(student.getAppUserId());
|
student1.setStudentId(Integer.valueOf(stuId));
|
student1.setCoursePackageId(coursePackage1.getId());
|
student1.setCoursePackagePaymentId(null);
|
student1.setCoursePackageSchedulingId(coursePackageScheduling.getId());
|
student1.setSignInOrNot(1);
|
student1.setReservationStatus(1);
|
student1.setInsertTime(new Date());
|
cpsMapper.insert(student1);
|
}
|
//增加日期，用于判断
|
calendar.set(Calendar.DAY_OF_YEAR, calendar.get(Calendar.DAY_OF_YEAR) + 1);
|
}
|
|
|
|
|
CourseCounsum courseCounsum = new CourseCounsum();
|
courseCounsum.setPaymentId(coursePackageOrderStudent.getId());
|
courseCounsum.setChangeType(0);
|
courseCounsum.setNum(toHoliDto.getClassNum());
|
courseCounsum.setInsertTime(new Date());
|
courseCounsum.setReason("报名假期班");
|
// courseCounsum.setAppUserId(userId);
|
courseCounsumService.save(courseCounsum);
|
}
|
|
return "报名成功";
|
|
|
}
|
|
|
@Autowired
|
private TCoursePackagePaymentService coursePackagePaymentService;
|
|
public static Date[] generateDateArray(int numDays, Date date) {
|
// LocalDate tomorrow = LocalDate.now().plusDays(1);
|
LocalDate tomorrow = date.toInstant().atZone(ZoneId.systemDefault()).toLocalDate().plusDays(1);
|
|
Date[] dates = new Date[numDays];
|
|
for (int i = 0; i < numDays; i++) {
|
LocalDate currentDate = tomorrow.plusDays(i);
|
dates[i] = Date.from(currentDate.atStartOfDay(ZoneId.systemDefault()).toInstant());
|
}
|
|
return dates;
|
}
|
|
private List<Integer> week(String week) {
|
String[] split = week.split(";");
|
ArrayList<Integer> integers = new ArrayList<>();
|
for (String s : split) {
|
switch (s) {
|
case "周一":
|
integers.add(1);
|
break;
|
case "周二":
|
integers.add(2);
|
break;
|
case "周三":
|
integers.add(3);
|
break;
|
case "周四":
|
integers.add(4);
|
break;
|
case "周五":
|
integers.add(5);
|
break;
|
case "周六":
|
integers.add(6);
|
break;
|
case "周日":
|
integers.add(7);
|
break;
|
}
|
}
|
return integers;
|
}
|
|
|
@Autowired
|
private CoursePackageStudentService coursePackageStudentService;
|
|
@RequestMapping(value = "/toTrans", produces = MediaType.APPLICATION_JSON_UTF8_VALUE, consumes = "application/json;charset=UTF-8")
|
@ResponseBody
|
public String toTrans(@RequestBody ToHoliDto toHoliDto) throws ParseException {
|
String[] stuIds = toHoliDto.getIds();
|
// //查询出学员ids对应的棵树，判断剩余课时数是否够
|
// List<CoursePackageOrderStudent> list = orderStudentService.list(new QueryWrapper<CoursePackageOrderStudent>().eq("coursePackageId", toHoliDto.getClassId()).in("studentId", stuIds));
|
// List<String> notStudent = new ArrayList<>();
|
// for (CoursePackageOrderStudent coursePackageOrderStudent : list) {
|
// if (coursePackageOrderStudent.getLaveClassHours() < toHoliDto.getClassNum()) {
|
// notStudent.add(studentClient.queryStudentById(coursePackageOrderStudent.getStudentId()).getName());
|
// }
|
// }
|
// if (!notStudent.isEmpty()) {
|
// String notStudentStr = String.join(",", notStudent);
|
// return notStudentStr+":课时数不足";
|
// }
|
|
|
//转移课程
|
for (String stuId : stuIds) {
|
// CoursePackageOrderStudent orinPay = orderStudentService.getById(toHoliDto.getId());
|
CoursePackageOrderStudent orinPay = orderStudentService.getOne(new QueryWrapper<CoursePackageOrderStudent>()
|
.eq("studentId", stuId)
|
.eq("coursePackageId", toHoliDto.getId()));
|
CoursePackageOrderStudent studentPay = orderStudentService.getOne(new QueryWrapper<CoursePackageOrderStudent>()
|
.eq("studentId", stuId)
|
.eq("coursePackageId", toHoliDto.getClassId()));
|
TCoursePackage coursePackage = packageService.getById(toHoliDto.getClassId());
|
if (studentPay != null) {
|
//转移
|
Integer laveClassHours = orinPay.getLaveClassHours();
|
Integer totalClassHours = orinPay.getTotalClassHours();
|
|
CourseCounsum courseCounsum = new CourseCounsum();
|
courseCounsum.setInsertTime(new Date());
|
Integer appUserId = orinPay.getAppUserId();
|
Integer appUserId1 = studentPay.getAppUserId();
|
|
courseCounsum.setReason("换课");
|
|
|
orinPay.setLaveClassHours(0);
|
orinPay.setStatus(3);
|
orinPay.setAppUserId(null);
|
orderStudentService.updateById(orinPay);
|
|
courseCounsum.setNum(laveClassHours);
|
courseCounsum.setChangeType(0);
|
courseCounsum.setPaymentId(orinPay.getId());
|
counsumService.save(courseCounsum);
|
|
CourseCounsum courseCounsum1 = new CourseCounsum();
|
courseCounsum1.setInsertTime(new Date());
|
// if (appUserId.compareTo(appUserId1) != 0) {
|
// courseCounsum1.setReason("赠课");
|
// } else {
|
courseCounsum1.setReason("换课");
|
// }
|
courseCounsum1.setNum(laveClassHours);
|
courseCounsum1.setChangeType(1);
|
courseCounsum1.setPaymentId(studentPay.getId());
|
counsumService.save(courseCounsum1);
|
|
schedulingService.addNewCoursePackageScheduling(studentPay.getId(), laveClassHours);
|
//删除原排课数据
|
List<CoursePackageScheduling> coursePackageSchedulings = coursePackageSchedulingService.selectList(new QueryWrapper<CoursePackageScheduling>()
|
.eq("type", 1).eq("appUserId", appUserId)
|
.eq("studentId", orinPay.getStudentId()).eq("coursePackageId", orinPay.getCoursePackageId())
|
.orderByAsc("classDate"));
|
int num = totalClassHours - laveClassHours;
|
for (int i = num; i < coursePackageSchedulings.size(); i++) {
|
CoursePackageScheduling packageScheduling = coursePackageSchedulings.get(i);
|
coursePackageSchedulingService.deleteById(packageScheduling.getId());
|
coursePackageStudentService.remove(new QueryWrapper<CoursePackageStudent>().eq("coursePackageSchedulingId", packageScheduling.getId()));
|
}
|
} else {
|
|
Integer totalClassHours = orinPay.getTotalClassHours();
|
Integer laveClassHours = orinPay.getLaveClassHours();
|
Student student = studentClient.queryStudentById(Integer.valueOf(stuId));
|
CoursePackageOrderStudent to = new CoursePackageOrderStudent();
|
to.setStudentId(Integer.valueOf(stuId));
|
to.setTotalClassHours(laveClassHours);
|
to.setLaveClassHours(laveClassHours);
|
to.setCoursePackageId(toHoliDto.getClassId());
|
to.setState(1);
|
to.setAppUserId(student.getAppUserId());
|
to.setStatus(1);
|
to.setInsertTime(new Date());
|
|
Integer validDays = coursePackage.getValidDays();
|
Calendar calendar = Calendar.getInstance();
|
calendar.setTime(new Date());
|
calendar.set(Calendar.DAY_OF_YEAR, calendar.get(Calendar.DAY_OF_YEAR) + validDays);
|
to.setUseTime(calendar.getTime());
|
orderStudentService.save(to);
|
if (null == student.getValidity()) {
|
student.setValidity(calendar.getTime());
|
} else if (student.getValidity().getTime() < calendar.getTime().getTime()) {
|
student.setValidity(calendar.getTime());
|
}
|
studentClient.frozen(student);
|
|
|
Integer laveClassHours1 = orinPay.getLaveClassHours();
|
Integer appUserId = orinPay.getAppUserId();
|
orinPay.setLaveClassHours(0);
|
orinPay.setAppUserId(null);
|
orinPay.setStatus(3);
|
orderStudentService.updateById(orinPay);
|
|
|
CourseCounsum courseCounsum = new CourseCounsum();
|
courseCounsum.setInsertTime(new Date());
|
courseCounsum.setReason("换课");
|
courseCounsum.setNum(laveClassHours1);
|
courseCounsum.setChangeType(0);
|
courseCounsum.setPaymentId(orinPay.getId());
|
counsumService.save(courseCounsum);
|
|
|
CourseCounsum courseCounsum1 = new CourseCounsum();
|
courseCounsum1.setInsertTime(new Date());
|
courseCounsum1.setReason("换课");
|
courseCounsum1.setNum(laveClassHours1);
|
courseCounsum1.setChangeType(1);
|
courseCounsum1.setPaymentId(to.getId());
|
counsumService.save(courseCounsum1);
|
|
//开始排课
|
addPackageStudent(coursePackage, to.getAppUserId(), to.getStudentId(), to);
|
//删除原排课数据
|
List<CoursePackageScheduling> coursePackageSchedulings = coursePackageSchedulingService.selectList(new QueryWrapper<CoursePackageScheduling>()
|
.eq("type", 1).eq("appUserId", appUserId)
|
.eq("studentId", orinPay.getStudentId()).eq("coursePackageId", orinPay.getCoursePackageId())
|
.orderByAsc("classDate"));
|
int num = totalClassHours - laveClassHours;
|
for (int i = num; i < coursePackageSchedulings.size(); i++) {
|
CoursePackageScheduling packageScheduling = coursePackageSchedulings.get(i);
|
coursePackageSchedulingService.deleteById(packageScheduling.getId());
|
coursePackageStudentService.remove(new QueryWrapper<CoursePackageStudent>().eq("coursePackageSchedulingId", packageScheduling.getId()));
|
}
|
}
|
|
}
|
return "换课成功";
|
|
}
|
}
|
