Merge branch 'master' of http://120.76.84.145:10101/gitblit/r/java/PlayPai

44323

2023-11-27 e9085eb620dcae1ceae24bc8b70e1a6bca228b15

 cloud-server-course/src/main/java/com/dsh/course/controller/CoursePackagePaymentController.java

@@ -1,11 +1,8 @@
package com.dsh.course.controller;


import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.activerecord.Model;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.dsh.course.entity.*;
import com.dsh.course.entity.TAppUser;
@@ -15,12 +12,11 @@
import com.dsh.course.feignclient.account.model.Student;
import com.dsh.course.feignclient.account.model.TCourseInfoRecord;
import com.dsh.course.feignclient.account.model.TStudent;
import com.dsh.course.feignclient.activity.CouponClient;
import com.dsh.course.feignclient.activity.model.Coupon;
import com.dsh.course.feignclient.model.*;
import com.dsh.course.feignclient.other.StoreClient;
import com.dsh.course.feignclient.other.model.Store;
import com.dsh.course.mapper.CoursePackageSchedulingMapper;
import com.dsh.course.mapper.TCoursePackageMapper;
import com.dsh.course.model.*;
import com.dsh.course.model.dto.DiscountJsonDto;
import com.dsh.course.model.vo.CourseDetailRequest;
@@ -35,16 +31,10 @@
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiImplicitParams;
import io.swagger.annotations.ApiOperation;
import net.bytebuddy.asm.Advice;
import org.aspectj.weaver.ast.Var;
import io.swagger.models.auth.In;
import org.checkerframework.checker.units.qual.C;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpHeaders;
import org.springframework.http.MediaType;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.client.RestTemplate;

@@ -133,11 +123,12 @@

    @Autowired
    private CoursePackageStudentService coursePackageStudentService;
    @Autowired
    private TOrderService orderService;

    private final SimpleDateFormat format = new SimpleDateFormat("MM-dd HH:mm");

    @Autowired
    private TOrderService orderService;


    @Autowired
    private ICoursePackageOrderStudentService coursePackageOrderStudentService;
@@ -170,124 +161,54 @@
     */
    @RequestMapping("/base/coursePackagePayment/add")
    public Object addCoursePackagePayment(@RequestBody TCoursePackagePayment packagePayment) {
        packagePayment.setInsertTime(new Date());
        packagePayment.setInsertTime(new Date());
        Integer studentId = packagePayment.getStudentId();
        // 添加学员上课记录
        CoursePackageStudent coursePackageStudent = new CoursePackageStudent();
        TCoursePackagePayment one = packagePaymentService.getOne(new QueryWrapper<TCoursePackagePayment>().eq("studentId", packagePayment.getStudentId())
                .orderByDesc("insertTime")
                .last("LIMIT 1"));

        if (one != null) {
            Integer totalClassHours = one.getTotalClassHours();
            Integer absencesNumber = one.getAbsencesNumber();
            // 没有过期
            if (one.getUseTime().after(new Date())) {
                if (one.getLaveClassHours() - packagePayment.getClassHours() < 0) {
                    return 5002;
                }
                packagePayment.setTotalClassHours(one.getTotalClassHours());
                packagePayment.setLaveClassHours(one.getLaveClassHours() - packagePayment.getClassHours());
                packagePayment.setAbsencesNumber(one.getAbsencesNumber());
        //校验是否已经报满
        Integer cpId = Integer.valueOf((int) packagePayment.getCoursePackageId());
        Integer integer = coursePackagePaymentService.queryCountNumber(cpId);
        TCoursePackage course = coursePackageService.getById(packagePayment.getId());
        if (course.getType() != 3) {
            if (integer + 1 > course.getMaxSubscribeNumber()) {
                return 5001;
            }
            packagePayment.setTotalClassHours(packagePayment.getClassHours());
            packagePayment.setLaveClassHours(packagePayment.getClassHours());
            packagePayment.setAbsencesNumber(one.getAbsencesNumber());
        } else {
            packagePayment.setTotalClassHours(packagePayment.getClassHours());
            packagePayment.setLaveClassHours(packagePayment.getClassHours());
            packagePayment.setAbsencesNumber(0);
        }
        // 如果重复购买 累加课时
        CoursePackageOrder coursePackageOrder = new CoursePackageOrder();
        coursePackageOrder.setAppUserId(packagePayment.getAppUserId());
        coursePackageOrder.setStudentIds(String.valueOf(packagePayment.getStudentId()));
        coursePackageOrder.setCoursePackageId(packagePayment.getCoursePackageId());
        coursePackageOrder.setClassHours(packagePayment.getClassHours());
        coursePackageOrder.setOriginalPrice(packagePayment.getOriginalPrice());
        coursePackageOrder.setCashPayment(packagePayment.getCashPayment());
        coursePackageOrder.setPlayPaiCoin(packagePayment.getPlayPaiCoin());
        coursePackageOrder.setPayStatus(1);
        coursePackageOrder.setState(1);
        coursePackageOrder.setInsertTime(new Date());
        coursePackageOrder.setSalesName(packagePayment.getSalesName());
        coursePackageOrderService.save(coursePackageOrder);
        TCoursePackage byId = coursePackageService.getById(packagePayment.getCoursePackageId());
        if (byId.getType()==1){
            CoursePackageOrderStudent coursePackageOrderStudent = new CoursePackageOrderStudent();
            coursePackageOrderStudent.setAppUserId(packagePayment.getAppUserId());
            coursePackageOrderStudent.setStudentId(packagePayment.getStudentId());
            coursePackageOrderStudent.setCoursePackageId(packagePayment.getCoursePackageId());
            coursePackageOrderStudent.setTotalClassHours(packagePayment.getClassHours());
            coursePackageOrderStudent.setLaveClassHours(packagePayment.getClassHours());
            coursePackageOrderStudent.setAbsencesNumber(0);
            coursePackageOrderStudent.setDropoutsNumber(0);
            coursePackageOrderStudent.setStatus(1);
            coursePackageOrderStudent.setState(1);
            coursePackageOrderStudent.setInsertTime(new Date());
            coursePackageOrderStudent.setGiftClassHours(packagePayment.getGiftClassHours());
            // 获取常规课的有效期 计算是哪一天
            Calendar calendar = Calendar.getInstance();
            calendar.add(Calendar.DAY_OF_MONTH, byId.getValidDays());
            Date time = calendar.getTime();
            coursePackageOrderStudent.setUseTime(time);
            return coursePackageOrderStudentService.save(coursePackageOrderStudent);
        }
        // 生成排课数据
        TCoursePackage coursePackage = tcpService.getById(packagePayment.getCoursePackageId());
        //生成排课数据
        try {
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
            SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            Date date = sdf1.parse(sdf.format(new Date()) + " 00:00:00");
            List<String> list = Arrays.asList(coursePackage.getClassWeeks().split(";"));
            String value = coursePackage.getClassStartTime();
            String value1 = coursePackage.getClassEndTime();
        return null;

            String[] star = value.split(",");
            String[] end = value1.split(",");
            for (int i = 0; i < star.length; i++) {
                //                int index = star[i].indexOf(",");
                //                String result = value.substring(0, index).trim();
                String classStartTime = star[i];
                String[] split = classStartTime.split(":");
                //            String value1 = en;
                int index1 = value1.indexOf(",");
                //                String result1 = value.substring(0, index1).trim();
                String classEndTime = end[i];
                String[] split1 = classEndTime.split(":");
                Calendar s = Calendar.getInstance();
                s.setTime(date);
                s.set(Calendar.DAY_OF_YEAR, s.get(Calendar.DAY_OF_YEAR) + 1);
                s.set(Calendar.HOUR_OF_DAY, Integer.valueOf(split[0]));
                s.set(Calendar.MINUTE, Integer.valueOf(split[1]));
                s.set(Calendar.SECOND, 0);

                Calendar e = Calendar.getInstance();
                e.setTime(date);
                e.set(Calendar.DAY_OF_YEAR, s.get(Calendar.DAY_OF_YEAR) + 14);
                long timeInMillis = e.getTimeInMillis();

                while (true) {
                    int w = s.get(Calendar.DAY_OF_WEEK);
                    WeekEnum weekEnum = WeekEnum.getWeekEnum(w);
                    if (list.contains(weekEnum.getChineseName())) {
                        Calendar classDate = Calendar.getInstance();
                        classDate.setTime(s.getTime());
                        classDate.set(Calendar.HOUR_OF_DAY, Integer.valueOf(split[0]));
                        classDate.set(Calendar.MINUTE, Integer.valueOf(split[1]));
                        classDate.set(Calendar.SECOND, 0);

                        Calendar endDate = Calendar.getInstance();
                        endDate.setTime(s.getTime());
                        endDate.set(Calendar.HOUR_OF_DAY, Integer.valueOf(split1[0]));
                        endDate.set(Calendar.MINUTE, Integer.valueOf(split1[1]));
                        endDate.set(Calendar.SECOND, 0);

                        CoursePackageScheduling coursePackageScheduling = new CoursePackageScheduling();
                        coursePackageScheduling.setCoursePackageId(coursePackage.getId());
                        coursePackageScheduling.setClassDate(classDate.getTime());
                        coursePackageScheduling.setEndDate(endDate.getTime());
                        coursePackageScheduling.setStatus(1);
                        coursePackageSchedulingService.save(coursePackageScheduling);
                        coursePackageStudent.setCoursePackageSchedulingId(coursePackageScheduling.getId());

                        List<CoursePackageScheduling> list1 = coursePackageSchedulingService.list(new QueryWrapper<CoursePackageScheduling>()
                                .eq("coursePackageId", coursePackage.getId())
                                .eq("classDate", classDate.getTime())
                                .eq("endDate", endDate.getTime()));
                        if (list1.size() + 1 > coursePackage.getMaxSubscribeNumber()) {
                            // 当前课包预约人数已满
                            return 5001;
                        }
                    }
                    s.set(Calendar.DAY_OF_YEAR, s.get(Calendar.DAY_OF_YEAR) + 1);
                    if (s.getTimeInMillis() > timeInMillis) {
                        break;
                    }
                }
            }
        } catch (ParseException e) {
            e.printStackTrace();
        }

        coursePackageStudent.setStudentId(packagePayment.getStudentId());
        coursePackageStudent.setCoursePackageId(packagePayment.getCoursePackageId());


        coursePackageStudent.setSignInOrNot(0);
        coursePackageStudent.setReservationStatus(1);
        coursePackageStudent.setInsertTime(new Date());
        coursePackageStudent.setAppUserId(packagePayment.getAppUserId());
        packagePaymentService.save(packagePayment);
        coursePackageStudent.setCoursePackagePaymentId(packagePayment.getId());
        return coursePackageStudentService.save(coursePackageStudent);
    }

    /**
@@ -585,6 +506,8 @@
        }
    }

    @Autowired
    private ICoursePackageOrderStudentService orderStudentService;

    /**
     * 课程名称列表
@@ -592,12 +515,12 @@
    @PostMapping("/base/coursePack/sessionNames")
    public List<StuSessionDetailsVo> getStuSessionList(@RequestBody CourseDetailRequest request) {
        List<StuSessionDetailsVo> detailsVos = new ArrayList<>();
        List<TCoursePackagePayment> byUserId = packagePaymentService.list(new QueryWrapper<TCoursePackagePayment>()
        List<CoursePackageOrderStudent> byUserId = orderStudentService.list(new QueryWrapper<CoursePackageOrderStudent>()
                .between("insertTime", request.getStartTime(), request.getEndTime())
                .eq("appUserId", request.getAppUserId())
                .eq("studentId", request.getStuId()));
        if (byUserId.size() > 0) {
            List<Integer> collect = byUserId.stream().map(TCoursePackagePayment::getCoursePackageId).collect(Collectors.toList());
            List<Integer> collect = byUserId.stream().map(CoursePackageOrderStudent::getCoursePackageId).collect(Collectors.toList());
            List<TCoursePackage> list = tcpService.list(new QueryWrapper<TCoursePackage>()
                    .in("id", collect));

@@ -670,22 +593,23 @@

    @PostMapping("/base/coursePack/getRecord")
    public List<PurchaseRecordVo> getRecord(@RequestBody RecordTimeRequest recordTimeRequest) {
        List<TCoursePackagePayment> list = new ArrayList<>();
        List<CoursePackageOrderStudent> list = new ArrayList<>();
        Integer[] changes = {1, 0};
        if (recordTimeRequest.getType() == null) {
            list = coursePackagePaymentService.list(new QueryWrapper<TCoursePackagePayment>().eq("studentId", recordTimeRequest.getStuId()).eq("coursePackageId", recordTimeRequest.getLessionId()).orderByDesc("insertTime"));
            list = coursePackageOrderStudentService.list(new QueryWrapper<CoursePackageOrderStudent>().eq("studentId", recordTimeRequest.getStuId()).eq("coursePackageId", recordTimeRequest.getLessionId()).orderByDesc("insertTime"));
        } else {

            list = coursePackagePaymentService.list(new QueryWrapper<TCoursePackagePayment>().eq("studentId", recordTimeRequest.getStuId()).eq("coursePackageId", recordTimeRequest.getLessionId()).orderByDesc("insertTime"));

            list = coursePackageOrderStudentService.list(new QueryWrapper<CoursePackageOrderStudent>().eq("studentId", recordTimeRequest.getStuId()).eq("coursePackageId", recordTimeRequest.getLessionId()).orderByDesc("insertTime"));
        }
        List<Long> ids = new ArrayList<>();
        for (TCoursePackagePayment coursePackagePayment : list) {
            ids.add(coursePackagePayment.getId());
        }
        List<Integer> appUserIds = list.stream().map(CoursePackageOrderStudent::getAppUserId).collect(Collectors.toList());
        List<CoursePackageOrderStudent> list1 = coursePackageOrderStudentService.list(new QueryWrapper<CoursePackageOrderStudent>()
                .in("appUserId", appUserIds)
                .eq("coursePackageId", recordTimeRequest.getLessionId())
                .eq("state", 1)
        );
        List<Long> collect = list1.stream().map(CoursePackageOrderStudent::getId).collect(Collectors.toList());


        QueryWrapper<CourseCounsum> in = new QueryWrapper<CourseCounsum>().in("paymentId", ids).in("changeType", changes);
        QueryWrapper<CourseCounsum> in = new QueryWrapper<CourseCounsum>().in("paymentId", collect).in("changeType", changes);

        if (recordTimeRequest.getType() != null) {
            if (recordTimeRequest.getType() == 2) {
@@ -723,11 +647,11 @@
        Integer totalNu = 0;
        Integer dedutNu = 0;
        Integer remainNu = 0;
        List<TCoursePackagePayment> byUserId = packagePaymentService.list(new QueryWrapper<TCoursePackagePayment>()
        List<CoursePackageOrderStudent> byUserId = coursePackageOrderStudentService.list(new QueryWrapper<CoursePackageOrderStudent>()
                .eq("appUserId", getStuOfCoursesDetails.getAppUserId())
                .eq("studentId", getStuOfCoursesDetails.getStuId()));
        if (byUserId.size() > 0) {
            for (TCoursePackagePayment tCoursePackagePayment : byUserId) {
            for (CoursePackageOrderStudent tCoursePackagePayment : byUserId) {
                totalNu = totalNu + tCoursePackagePayment.getTotalClassHours();
                dedutNu = dedutNu + tCoursePackagePayment.getLaveClassHours();
                remainNu = remainNu + (tCoursePackagePayment.getTotalClassHours() - tCoursePackagePayment.getLaveClassHours());
@@ -836,18 +760,28 @@
        return videoVos;
    }




    @PostMapping("/base/coursePack/allPaymentCourseList")
    @ResponseBody
    public List<CouponPaymentVo> getAppuserCourseList(@RequestBody Integer appUserId) {
        List<CouponPaymentVo> paymentVos = new ArrayList<>();
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm");
        List<TCoursePackagePayment> list = packagePaymentService.list(new QueryWrapper<TCoursePackagePayment>()
                .eq("appUserId", appUserId)
                .eq("payType", 3)
//        List<TCoursePackagePayment> list = packagePaymentService.list(new QueryWrapper<TCoursePackagePayment>()
//                .eq("appUserId", appUserId)
//                .eq("payType", 3)
//                .eq("payStatus", 2)
//                .eq("state", 1));


        List<CoursePackageOrder> list = coursePackageOrderService.list(new QueryWrapper<CoursePackageOrder>().eq("appUserId", appUserId).eq("payType", 3)
                .eq("payStatus", 2)
                .eq("state", 1));


        if (list.size() > 0) {
            for (TCoursePackagePayment tCoursePackagePayment : list) {
            for (CoursePackageOrder tCoursePackagePayment : list) {
                CouponPaymentVo couponPaymentVo = new CouponPaymentVo();
                couponPaymentVo.setTime(simpleDateFormat.format(tCoursePackagePayment.getInsertTime()));
                couponPaymentVo.setAmount(tCoursePackagePayment.getPlayPaiCoin());
@@ -1110,6 +1044,7 @@
    }



    /**
     * 已报名课程详情
     */
@@ -1133,10 +1068,12 @@
            CourseDetailsResponse courseDetailsResponse = packagePaymentService.queryRegisteredCourseDetails(coursePayId, appUserId, lon, lat);


            if (orderId != null) {
                TOrder byId = orderService.getById(orderId);
                courseDetailsResponse.setAmount(byId.getPrice());
            }


//            if (orderId != null) {
//                TOrder byId = orderService.getById(orderId);
//                courseDetailsResponse.setAmount(byId.getPrice());
//            }
            return ResultUtil.success(courseDetailsResponse);
        } catch (Exception e) {
            e.printStackTrace();
@@ -1255,8 +1192,8 @@
    @PostMapping("/coursePackagePayment/queryResidueClassHourById")
    public Integer queryResidueClassHourById(@RequestBody Long id) {
        try {
            TCoursePackagePayment list = packagePaymentService.getById(id);
            return list.getLaveClassHours();
            CoursePackageOrderStudent coursePackageOrderStudent = coursePackageOrderStudentService.getById(id);
            return coursePackageOrderStudent.getLaveClassHours();
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
@@ -1293,128 +1230,162 @@
    public void paymentDeductionClassHour(@RequestBody PaymentDeductionClassHour paymentDeductionClassHour) {
        try {
            // 2.0 用id进行查询
            TCoursePackagePayment coursePackagePayment = packagePaymentService.getOne(new QueryWrapper<TCoursePackagePayment>().eq("id", paymentDeductionClassHour.getCourseId()).eq("payStatus", 2)
                    .eq("status", 1).eq("state", 1).gt("laveClassHours", 0));
            Integer classHour = paymentDeductionClassHour.getClassHour();
//            TCoursePackagePayment coursePackagePayment = packagePaymentService.getOne(new QueryWrapper<TCoursePackagePayment>().eq("id", paymentDeductionClassHour.getCourseId()).eq("payStatus", 2)
//                    .eq("status", 1).eq("state", 1).gt("laveClassHours", 0));
//            Integer classHour = paymentDeductionClassHour.getClassHour();
//            for (TCoursePackagePayment coursePackagePayment : list) {
            if (coursePackagePayment.getLaveClassHours().compareTo(classHour) >= 0) {
                coursePackagePayment.setLaveClassHours(coursePackagePayment.getLaveClassHours() - classHour);
                coursePackagePayment.setAppUserId(null);
                packagePaymentService.updateById(coursePackagePayment);

                CourseCounsum courseCounsum = new CourseCounsum();
                courseCounsum.setPaymentId(coursePackagePayment.getId());
                courseCounsum.setChangeType(0);
                courseCounsum.setNum(classHour);
                courseCounsum.setInsertTime(new Date());
                courseCounsum.setReason("报名赛事");
                courseCounsumService.save(courseCounsum);


                List<CoursePackageStudent> studentCourse = coursePackageStudentService.list(new QueryWrapper<CoursePackageStudent>().eq("studentId", coursePackagePayment.getStudentId()).eq("coursePackageId", coursePackagePayment.getCoursePackageId()));
                List<Long> collect = studentCourse.stream().map(CoursePackageStudent::getCoursePackageSchedulingId).collect(Collectors.toList());
                coursePackageSchedulingService.remove(new QueryWrapper<CoursePackageScheduling>().in("id", collect));
                coursePackageStudentService.remove(new QueryWrapper<CoursePackageStudent>().eq("studentId", paymentDeductionClassHour.getId()).eq("coursePackageId", coursePackagePayment.getCoursePackageId()));

            CoursePackageOrderStudent coursePackageOrderStudent = coursePackageOrderStudentService.getById(paymentDeductionClassHour.getCourseId());
//            if (paymentDeductionClassHour.getClassHour() > coursePackageOrderStudent.getLaveClassHours()) {
//                return ResultUtil.error("当前课包课时数不足");
//            }
            TCoursePackage coursePackage = coursePackageService.getById(coursePackageOrderStudent.getCoursePackageId());
            coursePackageOrderStudent.setLaveClassHours(coursePackageOrderStudent.getLaveClassHours() - paymentDeductionClassHour.getClassHour());
            coursePackageOrderStudentService.updateById(coursePackageOrderStudent);
            //判断剩余课时是否已经全部进行排课，如果排课需要删除已经排好的记录
            List<CoursePackageScheduling> list1 = coursePackageSchedulingService.list(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();
            //需要删除多余的排课记录
            if(number > laveClassHours1){
                int n = number - laveClassHours1;
                for (int i = 0; i < n; i++) {
                    CoursePackageScheduling coursePackageScheduling = list1.get(i);
                    coursePackageSchedulingService.getBaseMapper().deleteById(coursePackageScheduling.getId());

                TCoursePackage tCoursePackage = packageService.getById(coursePackagePayment.getCoursePackageId());
                String classWeeks = tCoursePackage.getClassWeeks();
                List<Integer> week = week(classWeeks);

                TCoursePackagePayment pay = packagePaymentService.getOne(new QueryWrapper<TCoursePackagePayment>().eq("coursePackageId", coursePackagePayment.getCoursePackageId()).eq("studentId", coursePackagePayment.getStudentId()));

                Date today = new Date();
                Calendar calendar = Calendar.getInstance();
                calendar.add(Calendar.DATE, -1);
                today = calendar.getTime();


                Integer laveClassHours = pay.getLaveClassHours();
                Integer codeTime = tCoursePackage.getCodeTime();
                Integer can = laveClassHours / codeTime;

                int count = 0;
                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[] dates = generateDateArray(14, today);
                for (Date date : dates) {
                    if (count == can) {
                        break;
                    }
                    int wei = cn.hutool.core.date.DateUtil.dayOfWeek(date);
                    if (week.contains(wei)) {
                        for (int i1 = 0; i1 < split.length; i1++) {
                            if (count == can) {
                                break;
                            }
                            CoursePackageScheduling coursePackageScheduling = new CoursePackageScheduling();
                            coursePackageScheduling.setCoursePackageId(tCoursePackage.getId());
                            Date parse = format1.parse(format.format(date) + " " + split[i1]);
                            Date parse1 = format1.parse(format.format(date) + " " + split1[i1]);
                            coursePackageScheduling.setClassDate(parse);
                            coursePackageScheduling.setEndDate(parse1);
                            coursePackageScheduling.setStatus(1);
                            coursePackageSchedulingService.save(coursePackageScheduling);
                            CoursePackageStudent student1 = new CoursePackageStudent();
                            student1.setAppUserId(pay.getAppUserId());
                            student1.setStudentId(pay.getStudentId());
                            student1.setCoursePackageId(pay.getCoursePackageId());
                            student1.setCoursePackagePaymentId(pay.getId());
                            student1.setCoursePackageSchedulingId(coursePackageScheduling.getId());
                            student1.setSignInOrNot(1);
                            student1.setReservationStatus(1);
                            student1.setInsertTime(new Date());
                            studentService.save(student1);
                            count++;
                        }
                    }
                    coursePackageStudentService.getBaseMapper().delete(new QueryWrapper<CoursePackageStudent>()
                            .eq("coursePackageSchedulingId", coursePackageScheduling.getId()));
                }


                // 2.0 少于3课时 推送
                if (coursePackagePayment.getLaveClassHours() <= 3) {
                    Integer appUserId = coursePackagePayment.getAppUserId();

                    //调用推送
                    HttpHeaders headers = new HttpHeaders();
                    // 以表单的方式提交
                    headers.setContentType(MediaType.APPLICATION_FORM_URLENCODED);
                    String s1 = appUserId + "_" + "Three";
                    //定时修改排课状态
                    String s = internalRestTemplate.getForObject("http://mb-cloud-gateway/netty/sendMsgToClient?id=" + s1, String.class);
                    JSONObject jsonObject1 = JSON.parseObject(s, JSONObject.class);
                    if (jsonObject1.getIntValue("code") != 200) {
                        System.err.println(jsonObject1.getString("msg"));
                    }
                }

                CancelledClasses cancelledClasses = new CancelledClasses();
                cancelledClasses.setType(2);
                cancelledClasses.setVoucher(paymentDeductionClassHour.getCode());
                cancelledClasses.setCoursePackageId(coursePackagePayment.getCoursePackageId());
                cancelledClasses.setCoursePackagePaymentId(coursePackagePayment.getId());
                cancelledClasses.setCancelledClassesNumber(classHour);
                cancelledClasses.setInsertTime(new Date());
                cancelledClassesService.save(cancelledClasses);

            } else {
                CancelledClasses cancelledClasses = new CancelledClasses();
                cancelledClasses.setType(2);
                cancelledClasses.setVoucher(paymentDeductionClassHour.getCode());
                cancelledClasses.setCoursePackageId(coursePackagePayment.getCoursePackageId());
                cancelledClasses.setCoursePackagePaymentId(coursePackagePayment.getId());
                cancelledClasses.setCancelledClassesNumber(coursePackagePayment.getLaveClassHours());
                cancelledClasses.setInsertTime(new Date());
                cancelledClassesService.save(cancelledClasses);

                coursePackagePayment.setLaveClassHours(0);
                packagePaymentService.updateById(coursePackagePayment);

                classHour -= cancelledClasses.getCancelledClassesNumber();
            }






//            if (coursePackagePayment.getLaveClassHours().compareTo(classHour) >= 0) {
//                coursePackagePayment.setLaveClassHours(coursePackagePayment.getLaveClassHours() - classHour);
//                coursePackagePayment.setAppUserId(null);
//                packagePaymentService.updateById(coursePackagePayment);
//
//                CourseCounsum courseCounsum = new CourseCounsum();
//                courseCounsum.setPaymentId(coursePackagePayment.getId());
//                courseCounsum.setChangeType(0);
//                courseCounsum.setNum(classHour);
//                courseCounsum.setInsertTime(new Date());
//                courseCounsum.setReason("报名赛事");
//                courseCounsumService.save(courseCounsum);
//
//
//                List<CoursePackageStudent> studentCourse = coursePackageStudentService.list(new QueryWrapper<CoursePackageStudent>().eq("studentId", coursePackagePayment.getStudentId()).eq("coursePackageId", coursePackagePayment.getCoursePackageId()));
//                List<Long> collect = studentCourse.stream().map(CoursePackageStudent::getCoursePackageSchedulingId).collect(Collectors.toList());
//                coursePackageSchedulingService.remove(new QueryWrapper<CoursePackageScheduling>().in("id", collect));
//                coursePackageStudentService.remove(new QueryWrapper<CoursePackageStudent>().eq("studentId", paymentDeductionClassHour.getId()).eq("coursePackageId", coursePackagePayment.getCoursePackageId()));
//
//
//                TCoursePackage tCoursePackage = packageService.getById(coursePackagePayment.getCoursePackageId());
//                String classWeeks = tCoursePackage.getClassWeeks();
//                List<Integer> week = week(classWeeks);
//
//                TCoursePackagePayment pay = packagePaymentService.getOne(new QueryWrapper<TCoursePackagePayment>().eq("coursePackageId", coursePackagePayment.getCoursePackageId()).eq("studentId", coursePackagePayment.getStudentId()));
//
//                Date today = new Date();
//                Calendar calendar = Calendar.getInstance();
//                calendar.add(Calendar.DATE, -1);
//                today = calendar.getTime();
//
//
//                Integer laveClassHours = pay.getLaveClassHours();
//                Integer codeTime = tCoursePackage.getCodeTime();
//                Integer can = laveClassHours / codeTime;
//
//                int count = 0;
//                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[] dates = generateDateArray(14, today);
//                for (Date date : dates) {
//                    if (count == can) {
//                        break;
//                    }
//                    int wei = cn.hutool.core.date.DateUtil.dayOfWeek(date);
//                    if (week.contains(wei)) {
//                        for (int i1 = 0; i1 < split.length; i1++) {
//                            if (count == can) {
//                                break;
//                            }
//                            CoursePackageScheduling coursePackageScheduling = new CoursePackageScheduling();
//                            coursePackageScheduling.setCoursePackageId(tCoursePackage.getId());
//                            Date parse = format1.parse(format.format(date) + " " + split[i1]);
//                            Date parse1 = format1.parse(format.format(date) + " " + split1[i1]);
//                            coursePackageScheduling.setClassDate(parse);
//                            coursePackageScheduling.setEndDate(parse1);
//                            coursePackageScheduling.setStatus(1);
//                            coursePackageSchedulingService.save(coursePackageScheduling);
//                            CoursePackageStudent student1 = new CoursePackageStudent();
//                            student1.setAppUserId(pay.getAppUserId());
//                            student1.setStudentId(pay.getStudentId());
//                            student1.setCoursePackageId(pay.getCoursePackageId());
//                            student1.setCoursePackagePaymentId(pay.getId());
//                            student1.setCoursePackageSchedulingId(coursePackageScheduling.getId());
//                            student1.setSignInOrNot(1);
//                            student1.setReservationStatus(1);
//                            student1.setInsertTime(new Date());
//                            studentService.save(student1);
//                            count++;
//                        }
//                    }
//                }
//
//
//                // 2.0 少于3课时 推送
//                if (coursePackagePayment.getLaveClassHours() <= 3) {
//                    Integer appUserId = coursePackagePayment.getAppUserId();
//
//                    //调用推送
//                    HttpHeaders headers = new HttpHeaders();
//                    // 以表单的方式提交
//                    headers.setContentType(MediaType.APPLICATION_FORM_URLENCODED);
//                    String s1 = appUserId + "_" + "Three";
//                    //定时修改排课状态
//                    String s = internalRestTemplate.getForObject("http://mb-cloud-gateway/netty/sendMsgToClient?id=" + s1, String.class);
//                    JSONObject jsonObject1 = JSON.parseObject(s, JSONObject.class);
//                    if (jsonObject1.getIntValue("code") != 200) {
//                        System.err.println(jsonObject1.getString("msg"));
//                    }
//                }
//
//                CancelledClasses cancelledClasses = new CancelledClasses();
//                cancelledClasses.setType(2);
//                cancelledClasses.setVoucher(paymentDeductionClassHour.getCode());
//                cancelledClasses.setCoursePackageId(coursePackagePayment.getCoursePackageId());
//                cancelledClasses.setCoursePackagePaymentId(coursePackagePayment.getId());
//                cancelledClasses.setCancelledClassesNumber(classHour);
//                cancelledClasses.setInsertTime(new Date());
//                cancelledClassesService.save(cancelledClasses);
//
//            } else {
//                CancelledClasses cancelledClasses = new CancelledClasses();
//                cancelledClasses.setType(2);
//                cancelledClasses.setVoucher(paymentDeductionClassHour.getCode());
//                cancelledClasses.setCoursePackageId(coursePackagePayment.getCoursePackageId());
//                cancelledClasses.setCoursePackagePaymentId(coursePackagePayment.getId());
//                cancelledClasses.setCancelledClassesNumber(coursePackagePayment.getLaveClassHours());
//                cancelledClasses.setInsertTime(new Date());
//                cancelledClassesService.save(cancelledClasses);
//
//                coursePackagePayment.setLaveClassHours(0);
//                packagePaymentService.updateById(coursePackagePayment);
//
//                classHour -= cancelledClasses.getCancelledClassesNumber();
//            }
//                }


@@ -1478,6 +1449,8 @@
    }


    @Resource
    private TCoursePackageMapper tcpmapper;
    /**
     * 找出符合门店的课包
     *
@@ -1499,21 +1472,42 @@
        for (String s2 : split1) {
            storeIds.add(Integer.valueOf(s2));
        }
        List<TCoursePackagePayment> list = packagePaymentService.list(new LambdaQueryWrapper<TCoursePackagePayment>().eq(TCoursePackagePayment::getAppUserId, integer).ge(TCoursePackagePayment::getLaveClassHours, 0).eq(TCoursePackagePayment::getStatus, 1).eq(TCoursePackagePayment::getState, 1));
        for (TCoursePackagePayment tCoursePackagePayment : list) {
            Integer coursePackageId = tCoursePackagePayment.getCoursePackageId();
            TCoursePackage byId = tcpService.getById(coursePackageId);
            if (byId.getType() == 3) {
//        List<TCoursePackagePayment> list = packagePaymentService.list(new LambdaQueryWrapper<TCoursePackagePayment>().eq(TCoursePackagePayment::getAppUserId, integer).ge(TCoursePackagePayment::getLaveClassHours, 0).eq(TCoursePackagePayment::getStatus, 1).eq(TCoursePackagePayment::getState, 1));
//        for (TCoursePackagePayment tCoursePackagePayment : list) {
//            Integer coursePackageId = tCoursePackagePayment.getCoursePackageId();
//            TCoursePackage byId = tcpService.getById(coursePackageId);
//            if (byId.getType() == 3) {
//                continue;
//            }
//            if (storeIds.contains(byId.getStoreId())) {
//                PayCourseRes payCourseRes = new PayCourseRes();
//                payCourseRes.setCourseNum(tCoursePackagePayment.getLaveClassHours());
//                payCourseRes.setId(tCoursePackagePayment.getId());
//                payCourseRes.setName(byId.getName());
//                objects.add(payCourseRes);
//            }
//        }



        List<CoursePackageOrderStudent> tCoursePackagePayments = coursePackageOrderStudentService.list(new LambdaQueryWrapper<CoursePackageOrderStudent>().eq(CoursePackageOrderStudent::getAppUserId, integer));
//        ArrayList<PayCourseRes> payCourseRes = new ArrayList<>();
        for (CoursePackageOrderStudent tCoursePackagePayment : tCoursePackagePayments) {
            TCoursePackage tCoursePackage = tcpmapper.selectById(tCoursePackagePayment.getCoursePackageId());
            if (tCoursePackage.getType() != 1) {
                continue;
            }
            if (storeIds.contains(byId.getStoreId())) {
            if (storeIds.contains(tCoursePackage.getStoreId())) {
                PayCourseRes payCourseRes = new PayCourseRes();
                payCourseRes.setCourseNum(tCoursePackagePayment.getLaveClassHours());
                payCourseRes.setId(tCoursePackagePayment.getId());
                payCourseRes.setName(byId.getName());
                payCourseRes.setName(tCoursePackage.getName());
                objects.add(payCourseRes);

            }
        }


        return objects;
    }

@@ -1880,7 +1874,7 @@
    @PostMapping("/base/coursePack/obtainStudentClassDetails")
    public List<RecordAppoint> obtainStudentClassDetailsData(@RequestBody WeeksOfCourseRest stuId) {
//        try {
        return packagePaymentService.obtainStuClassDetails(stuId.getStuId(), stuId.getAppUserId(), stuId.getPageNum());
        return coursePackageOrderStudentService.obtainStuClassDetails(stuId.getStuId(), stuId.getAppUserId(), stuId.getPageNum());
//        }catch (Exception e){
//            e.printStackTrace();
//            throw new RuntimeException();
@@ -2042,6 +2036,33 @@
    }


//    @Autowired
//    private ICoursePackageOrderStudentService orderStudentService;


    @ResponseBody
    @PostMapping("/coursePackagePayment/consumeCourse")
    public ResultUtil consumeCourse(@RequestBody Integer coursePackagePaymentId) {
        CoursePackageOrderStudent coursePackageOrderStudent = orderStudentService.getById(coursePackagePaymentId);

        TCoursePackage coursePackage = coursePackageService.getById(coursePackageOrderStudent.getCoursePackageId());

        if (coursePackageOrderStudent.getLaveClassHours()<coursePackage.getNeedNum()){
            return ResultUtil.error("当前学员课时数不足");
        }
        coursePackageOrderStudent.setLaveClassHours(coursePackageOrderStudent.getLaveClassHours()-coursePackage.getNeedNum());
        orderStudentService.updateById(coursePackageOrderStudent);
        CourseCounsum courseCounsum = new CourseCounsum();
        courseCounsum.setPaymentId(coursePackageOrderStudent.getId());
        courseCounsum.setChangeType(0);
        courseCounsum.setNum(coursePackage.getNeedNum());
        courseCounsum.setInsertTime(new Date());
        courseCounsum.setReason("补课");
        courseCounsumService.save(courseCounsum);
        return ResultUtil.success("补课成功");
    }


    @ResponseBody
    @PostMapping("/coursePackagePayment/CountqueryByClassId")
    public Integer CountqueryByClassId(@RequestBody Integer id) {
@@ -2098,10 +2119,10 @@
            if (null == appUserId) {
                return ResultUtil.tokenErr();
            }
            List<TCoursePackagePayment> packagePayment = packagePaymentService.list(new LambdaQueryWrapper<TCoursePackagePayment>()
                    .eq(TCoursePackagePayment::getCoursePackageId, courseID)
                    .eq(TCoursePackagePayment::getAppUserId, appUserId)
                    .eq(TCoursePackagePayment::getStudentId, stuId)
            List<CoursePackageOrderStudent> packagePayment = coursePackageOrderStudentService.list(new QueryWrapper<CoursePackageOrderStudent>()
                    .eq("coursePackageId", courseID)
                    .eq("appUserId", appUserId)
                    .eq("studentId", stuId)
            );

            if (ToolUtil.isEmpty(packagePayment) || packagePayment.size() == 0) {
@@ -2113,7 +2134,7 @@
            );

            List<CoursePackageStudent> coursePackageStudent = cspsService.list(new LambdaQueryWrapper<CoursePackageStudent>()
                    .in(CoursePackageStudent::getCoursePackagePaymentId, packagePayment.stream().map(TCoursePackagePayment::getId).collect(Collectors.toList()))
                    .in(CoursePackageStudent::getCoursePackagePaymentId, packagePayment.stream().map(CoursePackageOrderStudent::getId).collect(Collectors.toList()))
                    .in(CoursePackageStudent::getCoursePackageSchedulingId, coursePackageSchedulings.stream().map(CoursePackageScheduling::getId).collect(Collectors.toList()))
                    .eq(CoursePackageStudent::getCoursePackageId, courseID)
                    .eq(CoursePackageStudent::getStudentId, stuId)
@@ -2176,25 +2197,32 @@
        map.put("name", store.getName());
        map.put("lon", lon);
        map.put("lat", lat);


        // 找出门店的所有课程 排出体验
        List<TCoursePackage> list = tcpService.list(new LambdaQueryWrapper<TCoursePackage>().eq(TCoursePackage::getStoreId, courseDetailReq.getStoreId()).ne(TCoursePackage::getType, 3).eq(TCoursePackage::getState, 1).like(TCoursePackage::getClassWeeks, week));
        List<Integer> collect = list.stream().map(TCoursePackage::getId).collect(Collectors.toList());
        if (collect.size() == 0) {
            collect.add(-1);
        }

        List<CoursePackageScheduling> list8 = coursePackageSchedulingMapper.selectList(new LambdaQueryWrapper<CoursePackageScheduling>()
                .eq(CoursePackageScheduling::getAppUserId, courseDetailReq.getAppUserId())
                .eq(CoursePackageScheduling::getStudentId, courseDetailReq.getStuId())
                .in(CoursePackageScheduling::getCoursePackageId, collect)
        );
        List<Integer> collect1 = list8.stream().map(CoursePackageScheduling::getCoursePackageId).collect(Collectors.toList());
        // 找出购买的课包
        List<CoursePackageOrderStudent> list1 = coursePackageOrderStudentService.list(new QueryWrapper<CoursePackageOrderStudent>()
                .eq("appUserId", courseDetailReq.getAppUserId())
                .eq("studentId", courseDetailReq.getStuId())
                .in("coursePackageId", collect)
                .in("coursePackageId", collect1)
                .eq("status", 1)
                .eq("state", 1)
        );

        List<Integer> collect1 = list1.stream().map(CoursePackageOrderStudent::getCoursePackageId).collect(Collectors.toList());
        List<Long> ids = list1.stream().map(CoursePackageOrderStudent::getId).collect(Collectors.toList());


//        List<Integer> collect1 = list1.stream().map(CoursePackageOrderStudent::getCoursePackageId).collect(Collectors.toList());
//        List<Long> ids = list1.stream().map(CoursePackageOrderStudent::getId).collect(Collectors.toList());


        for (TCoursePackage tCoursePackage : list) {
@@ -2235,6 +2263,9 @@
                detailsListVo.setMoney(cashPayment);
            }
            detailsListVo.setNum(tCoursePackage.getNeedNum());



            if (collect1.contains(tCoursePackage.getId())) {
                // 找出排课记录
                List<CoursePackageScheduling> list3 = coursePackageSchedulingMapper.selectList(new LambdaQueryWrapper<CoursePackageScheduling>()
@@ -2248,16 +2279,16 @@
                }
                //排课的ids
                List<Long> collect2 = list3.stream().map(CoursePackageScheduling::getId).collect(Collectors.toList());
                if (collect2.isEmpty()) {
                if (collect2.isEmpty()){
                    collect2.add(-1l);
                }


                List<CoursePackageStudent> list4 = cspsService.list(new LambdaQueryWrapper<CoursePackageStudent>()
                        .eq(CoursePackageStudent::getAppUserId, courseDetailReq.getAppUserId())
                        .eq(CoursePackageStudent::getStudentId, courseDetailReq.getStuId())
                        .eq(CoursePackageStudent::getCoursePackageId, tCoursePackage.getId())
                        .in(CoursePackageStudent::getCoursePackageSchedulingId, collect2).
                                in(CoursePackageStudent::getCoursePackagePaymentId, ids)
                        .in(CoursePackageStudent::getCoursePackageSchedulingId, collect2)
                );

                List<CoursePackageStudent> list5 = cspsService.list(new QueryWrapper<CoursePackageStudent>().eq("studentId", courseDetailReq.getStuId()).eq("coursePackageId", tCoursePackage.getId()));
@@ -2396,7 +2427,8 @@
        List<TCoursePackagePayment> tCoursePackagePayments = packagePaymentService.listOne(userPt);
        int sum = tCoursePackagePayments.stream().mapToInt(TCoursePackagePayment::getTotalClassHours).sum();
        int sum1 = tCoursePackagePayments.stream().mapToInt(TCoursePackagePayment::getLaveClassHours).sum();
        map.put("allCourse", sum - sum1);
        // 查询介绍有礼课时数量
        map.put("allCourse",sum-sum1);

        //所有课包
        List<TCoursePackage> coursePackages = tcpService.list();