java/PlayPai.git

			@@ -1,45 +1,63 @@
			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.dsh.course.entity.TCoursePackage;
			import com.dsh.course.entity.TCoursePackageDiscount;
			import com.dsh.course.entity.TCoursePackagePayment;
			import com.dsh.course.entity.TCoursePackageType;
			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;
			import com.dsh.course.feignclient.account.AppUserClient;
			import com.dsh.course.feignclient.account.StudentClient;
			import com.dsh.course.feignclient.account.model.AppUser;
			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.model.BaseVo;
			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.model.*;
			import com.dsh.course.model.dto.DiscountJsonDto;
			import com.dsh.course.model.vo.CourseDetailRequest;
			import com.dsh.course.model.vo.RegisterCourseVo;
			import com.dsh.course.model.vo.request.ClasspaymentRequest;
			import com.dsh.course.model.vo.request.CourseOfAfterRequest;
			import com.dsh.course.model.vo.request.CourseWithDetailsRequest;
			import com.dsh.course.model.vo.request.UpdateCourseVideoStatusRequest;
			import com.dsh.course.model.vo.response.AppUserVideoResponse;
			import com.dsh.course.model.vo.response.CourseDetailsResponse;
			import com.dsh.course.model.vo.response.CourseOfVideoResponse;
			import com.dsh.course.model.vo.request.*;
			import com.dsh.course.model.vo.response.*;
			import com.dsh.course.service.*;
			import com.dsh.course.util.DateUtil;
			import com.dsh.course.util.ResultUtil;
			import com.dsh.course.util.StrUtils;
			import com.dsh.course.util.TokenUtil;
			import com.dsh.course.util.*;
			import com.fasterxml.jackson.core.JsonProcessingException;
			import com.fasterxml.jackson.databind.ObjectMapper;
			import io.swagger.annotations.Api;
			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;

			import javax.annotation.Resource;
			import javax.servlet.http.HttpServletRequest;
			import javax.servlet.http.HttpServletResponse;
			import java.io.PrintWriter;
			import java.math.BigDecimal;
			import java.text.ParseException;
			import java.text.SimpleDateFormat;
			import java.util.ArrayList;
			import java.util.Date;
			import java.util.List;
			import java.time.*;
			import java.time.temporal.ChronoUnit;
			import java.util.*;
			import java.util.stream.Collectors;

			@Api
			@@ -60,14 +78,18 @@
			@Autowired
			private TCoursePackageDiscountService tcpdService;

			@Autowired
			private PostCourseVideoService pcvService;

			@Autowired
			private CoursePackageStudentService cpsService;
			private ICoursePackagePaymentConfigService icppcService;

			@Autowired
			private CancelledClassesService cacService;
			private UserVideoDetailsService uvdsService;

			@Autowired
			private TCourseService tcService;

			@Resource
			private StudentClient studentClient;

			@Autowired
			private TCoursePackageTypeService coursePackageTypeService;
			@@ -75,29 +97,424 @@
			@Autowired
			private TokenUtil tokenUtil;

			@Autowired
			private CancelledClassesService cancelledClassesService;

			@Resource
			private CoursePackageStudentService cspsService;


			@Autowired
			private PayMoneyUtil payMoneyUtil;
			@Resource
			private AppUserClient auClitn;

			@Resource
			private StoreClient sreClient;

			@Autowired
			private AppUserClient appUserClient;

			@Autowired
			private RestTemplate internalRestTemplate;
			@Autowired
			private CouponClient couponClient;
			@Autowired
			private StoreClient storeClient;
			@Autowired
			private TCoursePackageDiscountService discountService;

			@Resource
			private CoursePackageSchedulingMapper coursePackageSchedulingMapper;
			@Autowired
			private ICoursePackageSchedulingService coursePackageSchedulingService;
			@Autowired
			private CoursePackageStudentService coursePackageStudentService;
			@Autowired
			private TOrderService orderService;

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

			/**
			* 查询学员入学时间根据第一次购买课包的时间
			* @return
			*/
			@RequestMapping("/base/coursePackagePayment/getTime")
			public String getTime(@RequestBody Integer studentId){
			List<TCoursePackagePayment> list = packagePaymentService.list(new QueryWrapper<TCoursePackagePayment>()
			.eq("studentId", studentId)
			.orderByDesc("insertTime")
			.last("LIMIT 1"));
			if (list.size()>0){
			SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
			Date insertTime = list.get(0).getInsertTime();
			String format1 = format.format(list.get(0).getInsertTime());
			return format1;
			}
			return "";
			}
			/**
			* 添加购课记录-后台
			* @return
			*/
			@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());
			}
			packagePayment.setTotalClassHours(packagePayment.getClassHours());
			packagePayment.setLaveClassHours(packagePayment.getClassHours());
			packagePayment.setAbsencesNumber(one.getAbsencesNumber());
			}else{
			packagePayment.setTotalClassHours(packagePayment.getClassHours());
			packagePayment.setLaveClassHours(packagePayment.getClassHours());
			packagePayment.setAbsencesNumber(0);
			}
			// 生成排课数据
			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();

			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);
			}
			/**
			* 手动支付
			* @return
			*/
			@RequestMapping("/base/coursePackagePayment/changeState")
			public Object changeState(@RequestBody CoursePackagePayDTO dto){

			return packagePaymentService.changeState(dto);
			}
			@GetMapping("/coursePackagePayment/courseStore/{appUserId}/{coursePackageId}")
			public List<TCoursePackagePayment> getByUserIdAndCoursePackageId(@PathVariable("appUserId") Integer appUserId,@PathVariable("coursePackageId") Integer coursePackageId){
			List<TCoursePackagePayment> list = packagePaymentService.list(new QueryWrapper<TCoursePackagePayment>()
			.eq("appUserId", appUserId)
			.eq("coursePackageId", coursePackageId));
			return list;
			}
			/**
			* 获取购课记录
			*/
			@ResponseBody
			@RequestMapping("/coursePackagePayment/listAll")
			public List<CoursePackagePaymentVO> listAll(@RequestBody CoursePackagePaymentQuery query){
			List<CoursePackagePaymentVO> res = packagePaymentService.listAll(query);
			List<CoursePackagePaymentVO> result = new ArrayList<>();
			for (CoursePackagePaymentVO re : res) {
			if (re.getCashPayment()==null){
			if (re.getPlayPaiCoin()!=null){
			String value = String.valueOf(re.getPlayPaiCoin());
			re.setCashPayment(new BigDecimal(value));
			}
			}

			Store store = storeClient.queryStoreById(re.getStoreId());
			TAppUser appUser = appUserClient.queryAppUser1(re.getAppUserId());
			Student student = studentClient.queryStudentById(re.getStudentId());
			re.setPayStudent(student.getName());
			re.setPayUser(appUser.getName());
			re.setPhone(appUser.getPhone());
			re.setStoreName(store.getName());
			if (query.getPayUser()== null \|\| query.getPayUser().equals("") ){
			}else{
			List<AppUser> appUsers = appUserClient.queryAppUserListByName(query.getPayUser());
			for (AppUser user : appUsers) {
			if (appUser.getName().equals(user.getName())){
			if (query.getPayStudent()== null \|\| query.getPayStudent().equals("")){
			}else{
			List<Student> students = studentClient.queryStudentListByName(query.getPayStudent());
			for (Student student1 : students) {
			if (student.getName().equals(student1.getName())){
			result.add(re);
			}
			}
			}
			}
			}
			}

			if (re.getPayType()!=null){
			if (re.getPayType()==1){
			re.setBuyTypeName("微信支付");
			}else if(re.getPayType()==2){
			re.setBuyTypeName("支付宝支付");
			}else if(re.getPayType()==3){
			re.setBuyTypeName("玩湃币支付");
			}else if(re.getPayType()==4){
			re.setBuyTypeName("积分支付");
			}else if(re.getPayType()==5){
			re.setBuyTypeName("积分+微信支付");
			}else if(re.getPayType()==6){
			re.setBuyTypeName("积分+支付宝支付");
			}else if(re.getPayType()==7){
			re.setBuyTypeName("手动支付"+"-"+re.getBuyTypeName());
			}
			}

			// 如果支付用户类型为管理员则购买方式则为1线下购买
			if (re.getPayUserType()!=null){
			if (re.getPayUserType()== 2){
			re.setBuyType(1);
			}else{
			// 如果当前课包有折扣则为3折扣购买
			if (discountService.list(new QueryWrapper<TCoursePackageDiscount>()
			.eq("coursePackageId",re.getCoursePackageId()).eq("auditStatus",2)).size()>0){
			re.setBuyType(3);
			re.setDiscountAmount(re.getOriginalPrice().subtract(re.getPayMoney()));
			}else{
			re.setBuyType(2);
			}
			}
			}
			if(re.getCashPayment()==null){
			BigDecimal bigDecimal = new BigDecimal("0.00");
			re.setDiscountAmount(bigDecimal);
			continue;
			}
			BigDecimal subtract = re.getOriginalPrice().subtract(re.getCashPayment());
			re.setDiscountAmount(subtract);
			}
			if (query.getPayStudent()== null \|\| query.getPayStudent().equals("")){
			if (query.getPayUser()== null \|\| query.getPayUser().equals("")){
			return res;
			}else{
			return result;
			}
			}else{
			return result;
			}
			}

			/**
			* 获取报名订单记录列表
			*/
			@ResponseBody
			@RequestMapping("/registerOrder/listAllRegister")
			public List<RegisterOrderVO> listAllRegister(@RequestBody RegisterOrderQuery query){
			if (query.getStudentName()!=null){
			if (!query.getStudentName().equals("")){
			List<TStudent> students1 = studentClient.queryTStudentListByName(query.getStudentName());
			List<Integer> studentIds = students1.stream().map(TStudent::getId).collect(Collectors.toList());
			query.setStudentIds(studentIds);
			if (students1.size()==0){
			return new ArrayList<>();
			}
			}
			}
			List<RegisterOrderVO> res = packagePaymentService.listAllRegister(query);
			// 该运营商下没有门店
			if (query.getInsertType() == 2){
			if (query.getStoresIds()!=null){
			if (query.getStoresIds().size()==0){
			List<RegisterOrderVO> registerOrderVOS = new ArrayList<>();
			return registerOrderVOS;
			}
			}else{
			List<RegisterOrderVO> registerOrderVOS = new ArrayList<>();
			return registerOrderVOS;
			}
			}

			List<RegisterOrderVO> result = new ArrayList<>();
			Iterator<RegisterOrderVO> iterator = res.iterator();
			while (iterator.hasNext()) {
			RegisterOrderVO re = iterator.next();
			if (re.getSalesName() == null) {
			re.setSalesName("无");
			}
			if (re.getPayType() != null) {
			if (re.getPayType() == 3) {
			re.setPayMoneyAndType(re.getPlayPaiCoin() + "玩湃币");
			} else {
			re.setPayMoneyAndType("￥" + re.getMoney());
			}
			}
			if (re.getStoreId()!=null){
			Store store = storeClient.queryStoreById(re.getStoreId());
			if (store!=null){
			re.setStoreName(store.getName());
			}
			}
			TAppUser appUser = appUserClient.queryAppUser1(re.getAppUserId());
			Student student = studentClient.queryStudentById(re.getStudentId());
			re.setPayStudent(student.getName());
			re.setPayUser(appUser.getName());
			re.setPhone(appUser.getPhone());
			}
			return res;
			}

			/**
			* 获取没有学员信息的图片配置
			* @param stuId 学员id
			* @return 课包列表
			*/
			@ResponseBody
			@PostMapping("/base/coursePack/queryPayment")
			public List<StuCourseResp> getStuCoursePackagePayment(@RequestParam("stuId") Integer stuId,@RequestParam("appUserId") Integer appUserId){
			public List<StuCourseResp> getStuCoursePackagePayment(@RequestBody Integer stuId){
			List<StuCourseResp> resps = new ArrayList<>();
			List<TCoursePackagePayment> byUserId = packagePaymentService.queryAllCoursePackage(null,null,null,stuId,appUserId);
			Student student = studentClient.queryStudentById(stuId);
			List<TCoursePackagePayment> byUserId = packagePaymentService.list(new QueryWrapper<TCoursePackagePayment>()
			.eq("appUserId",student.getAppUserId())
			.eq("studentId",stuId).eq("payStatus",2));

			Date date = new Date();

			if (byUserId.size() > 0 ){
			for (TCoursePackagePayment tCoursePackagePayment : byUserId) {
			TCoursePackage tCoursePackage = tcpService.getById(tCoursePackagePayment.getCoursePackageId());

			if (tCoursePackagePayment.getUseTime()!=null) {
			if (tCoursePackagePayment.getUseTime().after(date)) {
			date = tCoursePackagePayment.getUseTime();
			}
			}
			if (tCoursePackage.getType()==3){
			continue;
			}
			StuCourseResp resp = new StuCourseResp();
			resp.setCourseId(tCoursePackage.getId());
			resp.setId(tCoursePackagePayment.getId());
			resp.setCourseName(tCoursePackage.getName());
			resp.setTotalCourseNums(tCoursePackagePayment.getTotalClassHours());
			resp.setResidueNums(tCoursePackagePayment.getLaveClassHours());
			resp.setDeductionNums(tCoursePackagePayment.getTotalClassHours()-tCoursePackagePayment.getLaveClassHours());
			resp.setCourseType(tCoursePackage.getType());
			if (tCoursePackage.getType()!=1\|\|tCoursePackage.getState()==2\|\|tCoursePackagePayment.getPayStatus()==1){
			resp.setIsAble(0);
			}else {
			resp.setIsAble(1);
			}

			if (tCoursePackagePayment.getUseTime()!=null){
			// String afterDayDate = DateUtil.getAfterDayDate2(tCoursePackage.getInsertTime(),tCoursePackage.getValidDays() + "");
			// resp.setPeriodOfValidity(afterDayDate);


			SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
			String str = sdf.format(tCoursePackagePayment.getUseTime());
			resp.setPeriodOfValidity(str);
			}



			resps.add(resp);
			}
			}
			SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
			String str = sdf.format(date);

			for (StuCourseResp resp : resps) {


			resp.setPeriodOfValidity(str);
			}


			return resps;
			}

			@@ -105,21 +522,66 @@
			*
			* 获取发布的课包列表
			*/
			@ResponseBody
			@PostMapping("/base/coursePack/storeOfCourse")
			public List<CourseOfStoreVo> getStuCourseWithStores(){
			List<CourseOfStoreVo> courseOfStoreVos = tcpService.queryStoreOfCourse();
			if (courseOfStoreVos.size() > 0){
			for (CourseOfStoreVo courseOfStoreVo : courseOfStoreVos) {
			String[] split = courseOfStoreVo.getClassWeeks().split(";");
			List<Integer> integers = new ArrayList<>();
			for (String s : split) {
			int num = Integer.parseInt(s);
			integers.add(num);
			public List<CourseOfStoreVo> getStuCourseWithStores(@RequestBody WeeksOfCourseRest courseRest){
			List<CourseOfStoreVo> course = new ArrayList<>();
			SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
			try {
			Date parse = simpleDateFormat.parse(courseRest.getTime());
			List<TCoursePackagePayment> list = packagePaymentService.list(new QueryWrapper<TCoursePackagePayment>()
			.eq("appUserId",courseRest.getAppUserId() )
			.eq("studentId",courseRest.getStuId())
			.eq("payStatus",2)
			.eq("status",1)
			.eq("state",1)
			.groupBy("coursePackageId"));
			if (list.size() > 0){
			for (TCoursePackagePayment tCoursePackagePayment : list) {
			List<CoursePackageStudent> packageStudent = cspsService.list(new LambdaQueryWrapper<CoursePackageStudent>()
			.eq(CoursePackageStudent::getAppUserId, courseRest.getAppUserId())
			.eq(CoursePackageStudent::getStudentId,courseRest.getStuId())
			.eq(CoursePackageStudent::getCoursePackagePaymentId,tCoursePackagePayment.getId())
			.eq(CoursePackageStudent::getCoursePackageId,tCoursePackagePayment.getCoursePackageId()));
			if (ToolUtil.isEmpty(packageStudent) \|\| (ToolUtil.isNotEmpty(packageStudent) && packageStudent.get(0).getReservationStatus() == 1)){
			// 没有预约过的/已经取消了的
			TCoursePackage tCoursePackage = tcpService.getById(tCoursePackagePayment.getCoursePackageId());
			CoursePackagePaymentConfig paymentConfig = icppcService.getOne(new QueryWrapper<CoursePackagePaymentConfig>()
			.eq("coursePackageId",tCoursePackage.getId() )
			.eq("classHours",tCoursePackagePayment.getClassHours()));
			// 获取课程有效结束时间，判断查询的日期parse 是否在有效期范围内
			Date expirationDate = DateTimeHelper.getExpirationDate(tCoursePackagePayment.getInsertTime(),tCoursePackage.getValidDays());
			System.out.println(expirationDate.after(parse));
			String classWeeks = tCoursePackage.getClassWeeks();
			System.out.println(StrUtils.dealStrToList(classWeeks).contains(DateTimeHelper.getDayOfWeek(parse)));
			if (expirationDate.after(parse) && StrUtils.dealStrToList(classWeeks).contains(DateTimeHelper.getDayOfWeek(parse))){
			CourseOfStoreVo storeVo = new CourseOfStoreVo();
			storeVo.setCourseId(tCoursePackagePayment.getId());
			storeVo.setCourseName(tCoursePackage.getName());
			storeVo.setClassStartTime(tCoursePackage.getClassStartTime());
			storeVo.setClassEndTime(tCoursePackage.getClassEndTime());
			storeVo.setStoreId(tCoursePackage.getStoreId());
			Store store = sreClient.queryStoreById(tCoursePackage.getStoreId());
			storeVo.setStoreAddress(store.getAddress());
			storeVo.setLat(store.getLat());
			storeVo.setLon(store.getLon());
			storeVo.setCoursePrice(ToolUtil.isEmpty(paymentConfig.getCashPayment()) ? (double) paymentConfig.getPlayPaiCoin():paymentConfig.getCashPayment());
			storeVo.setStatus(1);
			// 2.0
			storeVo.setAllNum(tCoursePackagePayment.getTotalClassHours());
			storeVo.setLastNum(tCoursePackagePayment.getLaveClassHours());
			storeVo.setUseNum(tCoursePackagePayment.getTotalClassHours()-tCoursePackagePayment.getLaveClassHours());

			course.add(storeVo);
			}
			}
			}
			courseOfStoreVo.setClassWeekList(integers);
			}
			System.out.println(course);
			return course;
			} catch (ParseException e) {
			return null;
			}
			return tcpService.queryStoreOfCourse();
			}


			@@ -130,27 +592,36 @@
			@PostMapping("/base/coursePack/sessionNames")
			public List<StuSessionDetailsVo> getStuSessionList(@RequestBody CourseDetailRequest request){
			List<StuSessionDetailsVo> detailsVos = new ArrayList<>();
			List<TCoursePackagePayment> byUserId = packagePaymentService.queryAllCoursePackage(request.getStartTime(),request.getEndTime(),null,request.getStuId(),request.getAppUserId());
			List<TCoursePackagePayment> byUserId = packagePaymentService.list(new QueryWrapper<TCoursePackagePayment>()
			.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<TCoursePackage> list = tcpService.list(new QueryWrapper<TCoursePackage>()
			.in("id", collect));
			list.forEach(vo -> {
			StuSessionDetailsVo detVo = new StuSessionDetailsVo();
			detVo.setSessionid(vo.getId());
			detVo.setSessionName(vo.getName());
			String afterDayDate = DateUtil.getAfterDayDate2(vo.getInsertTime(),vo.getValidDays() + "");
			detVo.setPeriodOfValidity(afterDayDate);
			detailsVos.add(detVo);
			if (vo.getType()!=2) {
			detVo.setSessionid(vo.getId());
			detVo.setSessionName(vo.getName());
			String afterDayDate = DateUtil.getAfterDayDate2(vo.getInsertTime(), vo.getValidDays() + "");
			detVo.setPeriodOfValidity(afterDayDate);
			detailsVos.add(detVo);
			}
			});
			}
			return detailsVos;
			}

			@PostMapping("/base/coursePack/paymentCourse")
			public List<PurchaseRecordVo> queryCourseDetails(@RequestParam("startTime") Date startTime, @RequestParam("endTime") Date endTime,@RequestParam("stuId") Integer stuId, @RequestParam("appUserId") Integer appUserId) {
			public List<PurchaseRecordVo> queryCourseDetails(@RequestBody GetStuSessionList sessionList) {
			List<PurchaseRecordVo> purchaseRecordVos = new ArrayList<>();
			List<TCoursePackagePayment> coursePackage = packagePaymentService.queryAllCoursePackage(startTime,endTime,null,stuId, appUserId);

			List<TCoursePackagePayment> coursePackage = packagePaymentService.list(new QueryWrapper<TCoursePackagePayment>()
			.between("insertTime", sessionList.getStartTime(),sessionList.getEndTime())
			.eq("appUserId",sessionList.getAppUserId())
			.eq("studentId",sessionList.getStuId()));
			if (coursePackage.size() > 0 ){
			coursePackage.forEach( cspackage -> {
			PurchaseRecordVo recordVo = new PurchaseRecordVo();
			@@ -164,6 +635,62 @@
			}


			@Autowired
			private CourseCounsumService courseCounsumService;

			@Autowired
			private TCoursePackagePaymentService coursePackagePaymentService;

			@PostMapping("/base/coursePack/getRecord")
			public List<PurchaseRecordVo> getRecord(@RequestBody RecordTimeRequest recordTimeRequest) {
			List<TCoursePackagePayment> 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"));
			}else {

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

			}
			List<Long> ids = new ArrayList<>();
			for (TCoursePackagePayment coursePackagePayment : list) {
			ids.add(coursePackagePayment.getId());
			}



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

			if (recordTimeRequest.getType()!=null){
			if (recordTimeRequest.getType()==2){
			recordTimeRequest.setType(0);
			}
			in.eq("changeType",recordTimeRequest.getType());
			}
			List<CourseCounsum> paymentId = courseCounsumService.list(in);
			List<PurchaseRecordVo> recordVos =new ArrayList<>();
			for (CourseCounsum courseCounsum : paymentId) {
			PurchaseRecordVo purchaseRecordVo = new PurchaseRecordVo();
			if (courseCounsum.getChangeType() == 0) {
			purchaseRecordVo.setPurchaseAmount("-" + courseCounsum.getNum());
			purchaseRecordVo.setPurchaseType(courseCounsum.getReason());
			SimpleDateFormat sdf = new SimpleDateFormat("MM-dd HH:mm");
			String formattedDate = sdf.format(courseCounsum.getInsertTime());
			purchaseRecordVo.setPurchaseTime(formattedDate);
			} else {
			purchaseRecordVo.setPurchaseAmount("+" + courseCounsum.getNum());
			purchaseRecordVo.setPurchaseType(courseCounsum.getReason());
			SimpleDateFormat sdf = new SimpleDateFormat("MM-dd HH:mm");
			String formattedDate = sdf.format(courseCounsum.getInsertTime());
			purchaseRecordVo.setPurchaseTime(formattedDate);
			}
			recordVos.add(purchaseRecordVo);
			}

			return recordVos;
			}



			@PostMapping("/base/coursePack/stuOfCourses")
			public StuWithCoursesListVo getStuOfCoursesDetails(@RequestBody GetStuOfCoursesDetails getStuOfCoursesDetails){
			@@ -171,7 +698,9 @@
			Integer totalNu = 0;
			Integer dedutNu = 0;
			Integer remainNu = 0;
			List<TCoursePackagePayment> byUserId = packagePaymentService.queryAllCoursePackage(null,null,null,getStuOfCoursesDetails.getStuId(),getStuOfCoursesDetails.getAppUserId());
			List<TCoursePackagePayment> byUserId = packagePaymentService.list(new QueryWrapper<TCoursePackagePayment>()
			.eq("appUserId",getStuOfCoursesDetails.getAppUserId())
			.eq("studentId",getStuOfCoursesDetails.getStuId()));
			if (byUserId.size() > 0 ){
			for (TCoursePackagePayment tCoursePackagePayment : byUserId) {
			totalNu = totalNu + tCoursePackagePayment.getTotalClassHours();
			@@ -190,7 +719,10 @@
			@PostMapping("/base/coursePack/continuingCourse")
			public StudentOfCourseVo getStudentCourse(@RequestBody GetStudentCourse getStudentCourse){
			StudentOfCourseVo courseVo = new StudentOfCourseVo();
			List<TCoursePackagePayment> tCoursePackagePayments = packagePaymentService.queryAllCoursePackage(null,null,getStudentCourse.getCourseId(),getStudentCourse.getStuId(),getStudentCourse.getAppUserId());
			List<TCoursePackagePayment> tCoursePackagePayments = packagePaymentService.list(new QueryWrapper<TCoursePackagePayment>()
			.eq("appUserId", getStudentCourse.getAppUserId())
			.eq("coursePackageId", getStudentCourse.getCourseId())
			.eq("studentId", getStudentCourse.getStuId()));
			if (tCoursePackagePayments.size() > 0 ){

			List<CourseHoursType> typeList = new ArrayList<>();
			@@ -213,33 +745,9 @@
			if (integers.size() > 0){
			StringBuilder courWeeks = new StringBuilder("每");
			for (Integer integer : integers) {
			switch (integer){
			case 1:
			courWeeks.append("周一、");
			break;
			case 2:
			courWeeks.append("周二、");
			break;
			case 3:
			courWeeks.append("周三、");
			break;
			case 4:
			courWeeks.append("周四、");
			break;
			case 5:
			courWeeks.append("周五、");
			break;
			case 6:
			courWeeks.append("周六、");
			break;
			case 7:
			courWeeks.append("周末、");
			break;
			default:
			break;
			}
			courWeeks.append(integer).append("、");
			}
			if (courWeeks.length() > 0 && courWeeks.charAt(courWeeks.length() - 1) == ','){
			if (courWeeks.length() > 0 && courWeeks.charAt(courWeeks.length() - 1) == '、'){
			courWeeks.deleteCharAt(courWeeks.length() - 1);
			}
			courseVo.setCourseWeek(courWeeks.toString());
			@@ -284,18 +792,63 @@
			@PostMapping("/base/coursePack/afterCourseTwos")
			public List<AfterVideoVo> getAfterCourseTwos(@RequestParam("appUserId") Integer appUserId){
			List<AfterVideoVo> videoVos = new ArrayList<>();
			List<TCoursePackagePayment> tCoursePackagePayments = packagePaymentService.queryAllCoursePackage(null,null,null,null,appUserId);
			List<Integer> coursePackageIds = tCoursePackagePayments.stream().map(TCoursePackagePayment::getCoursePackageId).collect(Collectors.toList());
			// List<PostCourseVideo> videoList = pcvService.queryAllVideoNoneShow(coursePackageIds);
			// TODO: 2023/7/6 两个课后视频
			List<UserVideoDetails> list = uvdsService.list(new QueryWrapper<UserVideoDetails>()
			.eq("appUserId",appUserId)
			.eq("state",1));
			if (list.size() > 0 ){
			List<Integer> courseIds = list.stream().map(UserVideoDetails::getCourseId).collect(Collectors.toList());
			List<TCourse> courseList = tcService.list(new QueryWrapper<TCourse>()
			.in("id",courseIds)
			.eq("type",1)
			.eq("state",1)
			.last("ORDER BY insertTime desc LIMIT 2"));
			for (TCourse tCourse : courseList) {
			AfterVideoVo videoVo = new AfterVideoVo();
			videoVo.setCourseId(tCourse.getId());
			videoVo.setCourseUrl(tCourse.getCourseVideo());
			videoVos.add(videoVo);
			}
			}
			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)
			.eq("payStatus", 2)
			.eq("state", 1));
			if (list.size() > 0 ){
			for (TCoursePackagePayment tCoursePackagePayment : list) {
			CouponPaymentVo couponPaymentVo = new CouponPaymentVo();
			couponPaymentVo.setTime(simpleDateFormat.format(tCoursePackagePayment.getInsertTime()));
			couponPaymentVo.setAmount( tCoursePackagePayment.getPlayPaiCoin());
			paymentVos.add(couponPaymentVo);
			}
			}
			return paymentVos;
			}


			@ResponseBody
			@PostMapping("/base/coursePack/allAmountPayRecordOfUser")
			public BillingRequestVo getAmountPayRecord(@RequestBody BillingDataRequestVo billingDataRequestVo){
			BillingRequestVo requestVo = new BillingRequestVo();
			List<BillingRequest> billingRequests = packagePaymentService.queryAmountDatas(billingDataRequestVo.getAppUserId(), billingDataRequestVo.getMonthStart(), billingDataRequestVo.getMonthEnd());
			if (billingRequests.size() >0){
			requestVo.setRequests(billingRequests);
			}
			return requestVo;
			}


			@ResponseBody
			@PostMapping("/api/course/queryArrangeCourseList")
			@ApiOperation(value = "获取布置课程列表", tags = {"APP-课程列表"})
			@ApiOperation(value = "课后练习-获取布置课程列表", tags = {"APP-开始上课"})
			@ApiImplicitParams({
			})
			public ResultUtil<List<BaseVo>> queryArrangePackageType(){
			@@ -304,7 +857,8 @@
			if(null == appUserId){
			return ResultUtil.tokenErr();
			}
			List<TCoursePackagePayment> tCoursePackagePayments = packagePaymentService.queryAllCoursePackage(null,null,null,null,appUserId);
			List<TCoursePackagePayment> tCoursePackagePayments = packagePaymentService.list(new QueryWrapper<TCoursePackagePayment>()
			.eq("appUserId",appUserId));
			List<BaseVo> list = new ArrayList<>();
			tCoursePackagePayments.forEach(c -> {
			BaseVo baseVo = new BaseVo();
			@@ -313,39 +867,81 @@
			baseVo.setName(coursePackage.getName());
			list.add(baseVo);
			});
			return ResultUtil.success();

			Set<BaseVo> set = new HashSet<>(list);
			List<BaseVo> back = new ArrayList<>(set);

			return ResultUtil.success(back);
			}catch (Exception e){
			e.printStackTrace();
			return ResultUtil.runErr();
			}
			}


			/**
			* 课后视频课表
			*/
			@ResponseBody
			@PostMapping("/api/startCource/afterSourceList")
			@ApiOperation(value = "课后视频课表", tags = {"APP-开始上课"})
			@ApiOperation(value = "课后练习-课后视频列表", tags = {"APP-开始上课"})
			@ApiImplicitParams({
			@ApiImplicitParam(name = "Authorization", value = "Bearer +token", required = true, dataType = "String", paramType = "header", defaultValue = "Bearer eyJhbGciOiJIUzUxMiJ9....."),
			})
			public ResultUtil<List<AppUserVideoResponse>> queryAfterSourceList(@RequestBody CourseOfAfterRequest search){
			try {
			public ResultUtil<List<AppUserVideoResponse>> queryAfterSourceList( CourseOfAfterRequest search) throws Exception {
			// try {
			Integer appUserId = tokenUtil.getUserIdFormRedis();

			if(null == appUserId){
			return ResultUtil.tokenErr();
			}
			List<Integer> courseIds = new ArrayList<>();
			List<TCoursePackagePayment> tCoursePackagePayments = packagePaymentService.queryAllCoursePackage(null,null,search.getCourseTypeId(),null,appUserId);
			if (tCoursePackagePayments.size() > 0 ){
			courseIds = tCoursePackagePayments.stream().map(TCoursePackagePayment::getCoursePackageId).collect(Collectors.toList());
			//
			// List<Integer> courseIds = new ArrayList<>();
			// QueryWrapper<TCoursePackagePayment> queryWrapper = new QueryWrapper<TCoursePackagePayment>().eq("appUserId", appUserId)
			// .groupBy("coursePackageId");
			// if (ToolUtil.isNotEmpty(search.getCourseTypeId())){
			// queryWrapper.eq("coursePackageId",search.getCourseTypeId());
			// }
			// List<TCoursePackagePayment> tCoursePackagePayments = packagePaymentService.list(queryWrapper);
			// if (tCoursePackagePayments.size() > 0 ){
			// courseIds = tCoursePackagePayments.stream().map(TCoursePackagePayment::getCoursePackageId).collect(Collectors.toList());
			// }


			QueryWrapper<CoursePackageStudent> queryWrapper1 = new QueryWrapper<CoursePackageStudent>().eq("studentId", search.getStuId());
			if (ToolUtil.isNotEmpty(search.getCourseTypeId())){
			queryWrapper1.eq("coursePackageId",search.getCourseTypeId());
			}
			return ResultUtil.success(packagePaymentService.queryAfterVideo(search,courseIds));
			}catch (Exception e){
			return ResultUtil.runErr();
			}

			List<CoursePackageStudent> list = coursePackageStudentService.list(queryWrapper1);
			List<Long> longs = new ArrayList<>();
			for (CoursePackageStudent coursePackageStudent : list) {
			longs.add(coursePackageStudent.getCoursePackageSchedulingId());
			}

			System.out.println("======longs========"+longs);
			// List<CoursePackageScheduling> coursePackageSchedulings = coursePackageSchedulingService.list(new QueryWrapper<CoursePackageScheduling>().in("id",longs).isNotNull("courseId"));
			List<AppUserVideoResponse> coursePackageSchedulings1 = coursePackageSchedulingService.queryAll(longs);

			if (search.getSearch()!=null) {
			List<AppUserVideoResponse> filteredList = new ArrayList<>();
			for (AppUserVideoResponse response : coursePackageSchedulings1) {
			if (response.getVideoName().contains(search.getSearch())) {
			filteredList.add(response);
			}
			}
			return ResultUtil.success(filteredList);

			}

			return ResultUtil.success(coursePackageSchedulings1);





			// }catch (Exception e){
			// return ResultUtil.runErr();
			// }
			}

			/**
			@@ -353,11 +949,11 @@
			*/
			@ResponseBody
			@PostMapping("/api/startCource/afterSourceDetail")
			@ApiOperation(value = "课后视频详情", tags = {"APP-开始上课"})
			@ApiOperation(value = "课后练习-课后视频详情", tags = {"APP-开始上课"})
			@ApiImplicitParams({
			@ApiImplicitParam(name = "Authorization", value = "Bearer +token", required = true, dataType = "String", paramType = "header", defaultValue = "Bearer eyJhbGciOiJIUzUxMiJ9....."),
			})
			public ResultUtil<CourseOfVideoResponse> queryAfterSourceDetails(@RequestBody CourseWithDetailsRequest detailsRequest){
			public ResultUtil<CourseOfVideoResponse> queryAfterSourceDetails( CourseWithDetailsRequest detailsRequest){
			try {
			Integer appUserId = tokenUtil.getUserIdFormRedis();
			if(null == appUserId){
			@@ -369,6 +965,63 @@
			}
			}

			@ResponseBody
			@PostMapping("/api/startCource/payCourseInfo")
			@ApiOperation(value = "课后练习-购课详情（用于购课）", tags = {"APP-开始上课"})
			@ApiImplicitParams({
			@ApiImplicitParam(name = "Authorization", value = "Bearer +token", required = true, dataType = "String", paramType = "header", defaultValue = "Bearer eyJhbGciOiJIUzUxMiJ9....."),
			})
			public ResultUtil<PayCourseInfoReq> payCourseInfo(Integer courseId){
			try {
			PayCourseInfoReq payCourseInfoReq = packagePaymentService.payCourseInfo(courseId);

			// Arrays.sort(payCourseInfoReq.getDay(), (a, b) -> a.compareTo(b));

			Collections.sort(payCourseInfoReq.getDay(), Comparator.comparing(String::toString));


			return ResultUtil.success(payCourseInfoReq);
			}catch (Exception e){
			return ResultUtil.runErr();
			}
			}

			@ResponseBody
			@PostMapping("/api/startCource/getMyCourseList")
			@ApiOperation(value = "课后练习-可支付课程列表（用于购课）", tags = {"APP-开始上课"})
			@ApiImplicitParams({
			@ApiImplicitParam(name = "Authorization", value = "Bearer +token", required = true, dataType = "String", paramType = "header", defaultValue = "Bearer eyJhbGciOiJIUzUxMiJ9....."),
			})
			public ResultUtil<List<PayCourseRes>> getMyCourseList(Integer storeId){
			try {
			Integer appUserId = tokenUtil.getUserIdFormRedis();
			if(null == appUserId){
			return ResultUtil.tokenErr();
			}
			return ResultUtil.success(packagePaymentService.getMyCourseList(storeId,appUserId));
			}catch (Exception e){
			return ResultUtil.runErr();
			}
			}

			// 2.0
			@ResponseBody
			@PostMapping("/api/startCource/payCourse")
			@ApiOperation(value = "课后练习-确认购课", tags = {"APP-开始上课"})
			@ApiImplicitParams({
			@ApiImplicitParam(name = "Authorization", value = "Bearer +token", required = true, dataType = "String", paramType = "header", defaultValue = "Bearer eyJhbGciOiJIUzUxMiJ9....."),
			})
			public ResultUtil<?> payCourse(PayCourseReq req){
			try {
			Integer appUserId = tokenUtil.getUserIdFormRedis();
			if(null == appUserId){
			return ResultUtil.tokenErr();
			}
			return packagePaymentService.payCourse(req,appUserId);
			}catch (Exception e){
			return ResultUtil.runErr();
			}
			}

			/**
			* 更新课后视频学习状态
			@@ -379,7 +1032,7 @@
			@ApiImplicitParams({
			@ApiImplicitParam(name = "Authorization", value = "Bearer +token", required = true, dataType = "String", paramType = "header", defaultValue = "Bearer eyJhbGciOiJIUzUxMiJ9....."),
			})
			public ResultUtil updateVideoStatus(@RequestBody UpdateCourseVideoStatusRequest detailsRequest){
			public ResultUtil updateVideoStatus( UpdateCourseVideoStatusRequest detailsRequest){
			try {
			Integer appUserId = tokenUtil.getUserIdFormRedis();
			if(null == appUserId){
			@@ -390,7 +1043,6 @@
			return ResultUtil.runErr();
			}
			}



			@ResponseBody
			@@ -424,7 +1076,7 @@
			@ApiImplicitParams({
			@ApiImplicitParam(name = "Authorization", value = "Bearer +token", required = true, dataType = "String", paramType = "header", defaultValue = "Bearer eyJhbGciOiJIUzUxMiJ9....."),
			})
			public ResultUtil<List<RegisterCourseVo>> queryRegisteredCoursesDetails(@RequestBody CourseOfAfterRequest courseTypeId){
			public ResultUtil<List<RegisterCourseVo>> queryRegisteredCoursesDetails( CourseOfAfterRequest courseTypeId){
			try {
			Integer appUserId = tokenUtil.getUserIdFormRedis();
			if(null == appUserId){
			@@ -434,7 +1086,6 @@
			}catch (Exception e){
			return ResultUtil.runErr();
			}

			}


			@@ -442,20 +1093,27 @@
			* 已报名课程详情
			*/
			@ResponseBody
			@PostMapping("/api/startCource/afterSourceDetail")
			@PostMapping("/api/startCource/RegisteredData")
			@ApiOperation(value = "已报名课程详情", tags = {"APP-开始上课"})
			@ApiImplicitParams({
			@ApiImplicitParam(name = "Authorization", value = "Bearer +token", required = true, dataType = "String", paramType = "header", defaultValue = "Bearer eyJhbGciOiJIUzUxMiJ9....."),
			@ApiImplicitParam(value = "经度", name = "lon", dataType = "string", required = false),
			@ApiImplicitParam(value = "纬度", name = "lat", dataType = "string", required = false),
			@ApiImplicitParam(name = "coursePayId" ,value = "课包记录id",dataType = "long"),
			@ApiImplicitParam(name = "orderId" ,value = "订单id",dataType = "int")

			})
			public ResultUtil<CourseDetailsResponse> getRegisteredData(@RequestBody Integer coursePackageId){
			public ResultUtil<CourseDetailsResponse> getRegisteredData(Long coursePayId, String lon, String lat,Integer orderId){
			try {
			Integer appUserId = tokenUtil.getUserIdFormRedis();
			if(null == appUserId){
			return ResultUtil.tokenErr();
			}
			return ResultUtil.success(packagePaymentService.queryRegisteredCourseDetails(coursePackageId,appUserId));
			return ResultUtil.success(packagePaymentService.queryRegisteredCourseDetails(coursePayId,appUserId));
			}catch (Exception e){
			return ResultUtil.runErr();
			e.printStackTrace();
			throw new RuntimeException(e.getMessage());
			// return ResultUtil.runErr();
			}
			}

			@@ -469,11 +1127,15 @@
			@ApiImplicitParams({
			@ApiImplicitParam(name = "Authorization", value = "Bearer +token", required = true, dataType = "String", paramType = "header", defaultValue = "Bearer eyJhbGciOiJIUzUxMiJ9....."),
			})
			public ResultUtil continuationOperation(@RequestBody ClasspaymentRequest request){
			public ResultUtil continuationOperation(ClasspaymentRequest request){
			try {
			Integer userIdFormRedis = tokenUtil.getUserIdFormRedis();
			if(null == userIdFormRedis){
			return ResultUtil.tokenErr();
			}
			Integer couponId = request.getConponId();
			if(couponId==null \|\| couponId==0){
			request.setConponId(null);
			}
			return packagePaymentService.ContinuationOrpaymentCourse(userIdFormRedis,request);
			}catch (Exception e){
			@@ -484,4 +1146,1680 @@



			/**
			* 课包续课支付宝支付回调接口
			*/
			@PostMapping("/base/coursePackage/alipayRegisteredCoursesCallback")
			public void alipayCallback(HttpServletRequest request, HttpServletResponse response){
			System.err.println("========支付宝支付回调========");
			try {
			Map<String, String> map = payMoneyUtil.alipayCallback(request);
			if(null != map){
			String out_trade_no = map.get("out_trade_no");
			String transaction_id = map.get("transaction_id");
			ResultUtil resultUtil = packagePaymentService.insertVipPaymentCallback(out_trade_no, transaction_id);
			if(resultUtil.getCode() == 200){
			PrintWriter out = response.getWriter();
			out.write("success");
			out.flush();
			out.close();
			}
			}
			}catch (Exception e){
			e.printStackTrace();
			}
			}


			/**
			* 课包续课微信支付回调接口
			*/
			@PostMapping("/base/coursePackage/wechatRegisteredCoursesCallback")
			public void weChatCallback(HttpServletRequest request, HttpServletResponse response){
			try {
			Map<String, String> map = payMoneyUtil.weixinpayCallback(request);
			if(null != map){
			String out_trade_no = map.get("out_trade_no");
			String transaction_id = map.get("transaction_id");
			String result = map.get("result");
			ResultUtil resultUtil = packagePaymentService.insertVipPaymentCallback(out_trade_no, transaction_id);
			if(resultUtil.getCode() == 200){
			PrintWriter out = response.getWriter();
			out.write(result);
			out.flush();
			out.close();
			}
			}
			}catch (Exception e){
			e.printStackTrace();
			}
			}




			/**
			* 获取学员剩余课时
			* @param id
			* @return
			*/
			@ResponseBody
			@PostMapping("/coursePackagePayment/queryResidueClassHour")
			public Integer queryResidueClassHour(@RequestBody Integer id){
			try {
			List<TCoursePackagePayment> list = packagePaymentService.list(new QueryWrapper<TCoursePackagePayment>().eq("studentId", id).eq("payStatus", 2)
			.eq("status", 1).eq("state", 1).gt("laveClassHours", 0));
			Integer total = 0;
			for (TCoursePackagePayment coursePackagePayment : list) {
			total += coursePackagePayment.getLaveClassHours();
			}
			return total;
			}catch (Exception e){
			e.printStackTrace();
			return 0;
			}
			}
			/**
			* 获取学员剩余课时
			* @param id
			* @return
			*/
			@ResponseBody
			@PostMapping("/coursePackagePayment/queryResidueClassHourById")
			public Integer queryResidueClassHourById(@RequestBody Long id){
			try {
			TCoursePackagePayment list = packagePaymentService.getById(id);
			return list.getLaveClassHours();
			}catch (Exception e){
			e.printStackTrace();
			return 0;
			}
			}


			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;
			}

			@Autowired
			private TCoursePackageService packageService;
			@Autowired
			CoursePackageStudentService studentService ;
			/**
			* 课程用于支付进行扣减
			* @param paymentDeductionClassHour
			*/
			@ResponseBody
			@PostMapping("/coursePackagePayment/paymentDeductionClassHour")
			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();
			// 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()));





			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();
			}
			// }


			}catch (Exception e){
			e.printStackTrace();
			}
			}

			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;
			}
			/**
			* 取消赛事回退支付课时
			* @param paymentDeductionClassHour
			*/
			@ResponseBody
			@PostMapping("/coursePackagePayment/rollbackPaymentDeductionClassHour")
			public void rollbackPaymentDeductionClassHour(@RequestBody PaymentDeductionClassHour paymentDeductionClassHour){
			try {
			List<CancelledClasses> voucher = cancelledClassesService.list(new QueryWrapper<CancelledClasses>().eq("voucher", paymentDeductionClassHour.getCode()));
			for (CancelledClasses cancelledClasses : voucher) {
			TCoursePackagePayment coursePackagePayment = packagePaymentService.getById(cancelledClasses.getCoursePackagePaymentId());
			coursePackagePayment.setLaveClassHours(coursePackagePayment.getLaveClassHours() + cancelledClasses.getCancelledClassesNumber());
			coursePackagePayment.setAppUserId(null);
			packagePaymentService.updateById(coursePackagePayment);

			cancelledClassesService.removeById(cancelledClasses.getId());
			}
			}catch (Exception e){
			e.printStackTrace();
			}
			}


			/**
			* 找出符合门店的课包
			* @param s
			* @return
			*/
			@ResponseBody
			@PostMapping("/coursePackagePayment/paymentCompetitionCourseList")
			public List<PayCourseRes> paymentCompetitionCourseList(@RequestBody String s){
			ArrayList<PayCourseRes> objects = new ArrayList<>();

			String[] split = s.split("_");
			// 用户id
			Integer integer = Integer.valueOf(split[0]);
			String s1 = split[1];
			// 门店id
			String[] split1 = s1.split(",");
			ArrayList<Integer> storeIds = new ArrayList<>();
			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){
			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);
			}
			}
			return objects;
			}

			@ResponseBody
			@PostMapping("/coursePackagePayment/isHave")
			public Integer isHave(@RequestBody String ids){
			String[] split = ids.split(",");
			return coursePackagePaymentService.count(new QueryWrapper<TCoursePackagePayment>().in("studentId",split));

			}


			/**
			* 课包续费玩湃币支付
			* @param
			*/
			@PostMapping("/coursePackagePayment/courseRenewPlayPaiPay")
			public int paymentWanpaiRenewCourse(@RequestBody PlayPaiGoldCoursePackage coursePackage){
			try {
			Integer userIdFormRedis = tokenUtil.getUserIdFormRedis();
			if (null == userIdFormRedis){
			return 2;
			}
			CoursePackagePaymentConfig paymentConfig = icppcService.getById(coursePackage.getCoursePayConfigId());
			AppUser appUser = auClitn.queryAppUser(userIdFormRedis);
			if (appUser.getPlayPaiCoins() < paymentConfig.getPlayPaiCoin()){
			return 3;
			}
			TCoursePackagePayment packagePayment = packagePaymentService.getOne(new QueryWrapper<TCoursePackagePayment>()
			.eq("code",coursePackage.getCode() ));
			packagePayment.setPayStatus(2);
			packagePayment.setPayUserId(userIdFormRedis);
			packagePayment.setClassHours(paymentConfig.getClassHours());
			packagePayment.setPlayPaiCoin(paymentConfig.getPlayPaiCoin());
			packagePayment.setTotalClassHours(paymentConfig.getClassHours());
			packagePayment.setLaveClassHours(paymentConfig.getClassHours());
			packagePaymentService.updateById(packagePayment);

			appUser.setPlayPaiCoins(appUser.getPlayPaiCoins()-paymentConfig.getPlayPaiCoin());
			auClitn.updateAppUser(appUser);

			// 2.0
			TCourseInfoRecord tCourseInfoRecord = new TCourseInfoRecord();
			tCourseInfoRecord.setUserId(userIdFormRedis);
			tCourseInfoRecord.setCourseId(coursePackage.getCoursePackageId());
			tCourseInfoRecord.setName("续课");
			tCourseInfoRecord.setTime(new Date());
			tCourseInfoRecord.setType(1);
			tCourseInfoRecord.setNum(paymentConfig.getClassHours());
			auClitn.addCourseInfoRecord(tCourseInfoRecord);

			CourseCounsum courseCounsum = new CourseCounsum();
			courseCounsum.setPaymentId(packagePayment.getId());
			courseCounsum.setChangeType(1);
			courseCounsum.setNum(packagePayment.getClassHours());
			courseCounsum.setInsertTime(new Date());
			courseCounsum.setReason("购买课包");
			courseCounsumService.save(courseCounsum);

			} catch (Exception e) {
			return 4;
			}
			return 1;
			}

			@PostMapping("/base/coursePack/getPaymentCoursePackage")
			public TCoursePackagePayment getCoursePackagePaymentByCode(@RequestBody String code){
			return packagePaymentService.getOne(new QueryWrapper<TCoursePackagePayment>()
			.eq("code",code));
			}


			@PostMapping("/base/coursePack/getCoursePackagePaymentById")
			public TCoursePackagePayment getCoursePackagePaymentById(@RequestBody Long id){
			TCoursePackagePayment byId = packagePaymentService.getById(id);
			System.out.println("======byId=========="+byId);
			return byId;
			}


			@PostMapping("/base/coursePack/delPaymentCoursePackage")
			public boolean delPaymentCoursePackage(@RequestBody Integer payId){
			return packagePaymentService.removeById(payId);
			}
			@PostMapping("/base/coursePack/updatePaymentCoursePackage")
			public boolean updatePaymentCoursePackage(@RequestBody TCoursePackagePayment packagePayment){
			boolean id = packagePaymentService.update(packagePayment, new QueryWrapper<TCoursePackagePayment>()
			.eq("id", packagePayment.getId()));
			if(id){
			// 2.0
			TCourseInfoRecord tCourseInfoRecord = new TCourseInfoRecord();
			tCourseInfoRecord.setNum(packagePayment.getTotalClassHours());
			tCourseInfoRecord.setName("续课");
			tCourseInfoRecord.setCourseId(packagePayment.getCoursePackageId());
			tCourseInfoRecord.setUserId(packagePayment.getAppUserId());
			tCourseInfoRecord.setType(1);
			tCourseInfoRecord.setTime(new Date());
			id = appUserClient.addCourseInfoRecord(tCourseInfoRecord);


			CourseCounsum courseCounsum = new CourseCounsum();
			courseCounsum.setPaymentId(packagePayment.getId());
			courseCounsum.setChangeType(1);
			courseCounsum.setNum(packagePayment.getClassHours());
			courseCounsum.setInsertTime(new Date());
			courseCounsum.setReason("续课");
			courseCounsumService.save(courseCounsum);

			}
			return id;
			}

			@PostMapping("/base/coursePack/savePaymentCoursePackage")
			public boolean savePaymentCoursePackage(@RequestBody TCoursePackagePayment packagePayment){

			return packagePaymentService.save(packagePayment);
			}


			@PostMapping("/base/coursePack/orderClass")
			public void orderClass(@RequestBody OrderDto orderDto) throws ParseException {
			SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMddHHmmssSSS");
			String code = sdf.format(new Date()) + UUIDUtil.getNumberRandom(5);
			String[] split = orderDto.getStuIds().split(",");
			for (String s : split) {
			TCoursePackagePayment coursePackagePaymentServiceOne = coursePackagePaymentService.getOne(new QueryWrapper<TCoursePackagePayment>().eq("studentId", s).eq("coursePackageId",orderDto.getClassId()));



			if (coursePackagePaymentServiceOne==null) {
			TCoursePackagePayment coursePackagePayment = new TCoursePackagePayment();
			coursePackagePayment.setCode(code);
			coursePackagePayment.setAppUserId(orderDto.getAppUserId());
			coursePackagePayment.setStudentId(Integer.valueOf(s));
			coursePackagePayment.setCoursePackageId(orderDto.getClassId());
			coursePackagePayment.setPayType(4);
			coursePackagePayment.setClassHours(orderDto.getClassHours());
			coursePackagePayment.setTotalClassHours(orderDto.getClassHours());
			coursePackagePayment.setLaveClassHours(orderDto.getClassHours());
			coursePackagePayment.setAbsencesNumber(0);
			coursePackagePayment.setPayUserType(1);
			coursePackagePayment.setPayStatus(2);
			coursePackagePayment.setPayUserId(orderDto.getAppUserId());
			coursePackagePayment.setStatus(1);
			coursePackagePayment.setState(1);
			coursePackagePayment.setInsertTime(new Date());
			coursePackagePaymentService.save(coursePackagePayment);
			Integer sId = null;
			Student student = studentClient.queryDefaultStudent(orderDto.getAppUserId());
			if (student != null) {
			sId = student.getId();
			}
			addPackageStudent(orderDto.getClassId(), orderDto.getAppUserId(), Integer.valueOf(s), coursePackagePayment.getId());


			CourseCounsum courseCounsum = new CourseCounsum();
			courseCounsum.setPaymentId(coursePackagePayment.getId());
			courseCounsum.setChangeType(1);
			courseCounsum.setNum(orderDto.getClassHours());
			courseCounsum.setInsertTime(new Date());
			courseCounsum.setReason("积分兑换");
			courseCounsumService.save(courseCounsum);

			}else {
			coursePackagePaymentServiceOne.setClassHours(coursePackagePaymentServiceOne.getClassHours()+orderDto.getClassHours());
			coursePackagePaymentServiceOne.setTotalClassHours(coursePackagePaymentServiceOne.getTotalClassHours()+orderDto.getClassHours());
			coursePackagePaymentServiceOne.setLaveClassHours(coursePackagePaymentServiceOne.getLaveClassHours()+orderDto.getClassHours());
			coursePackagePaymentServiceOne.setAppUserId(null);
			coursePackagePaymentService.updateById(coursePackagePaymentServiceOne);

			Integer sId = null;
			Student student = studentClient.queryDefaultStudent(orderDto.getAppUserId());
			if (student != null) {
			sId = student.getId();
			}
			addPackageStudent(orderDto.getClassId(), orderDto.getAppUserId(), Integer.valueOf(s), coursePackagePaymentServiceOne.getId());


			CourseCounsum courseCounsum = new CourseCounsum();
			courseCounsum.setPaymentId(coursePackagePaymentServiceOne.getId());
			courseCounsum.setChangeType(1);
			courseCounsum.setNum(orderDto.getClassHours());
			courseCounsum.setInsertTime(new Date());
			courseCounsum.setReason("积分兑换");
			courseCounsumService.save(courseCounsum);


			}

			}

			}


			public static Date[] generateDateArray1(Date startDate, Date endDate) {
			List<Date> dateList = new ArrayList<>();
			Calendar calendar = Calendar.getInstance();
			calendar.setTime(startDate);

			while (!calendar.getTime().after(endDate)) {
			Date currentDate = calendar.getTime();
			dateList.add(currentDate);
			calendar.add(Calendar.DAY_OF_MONTH, 1);
			}

			return dateList.toArray(new Date[0]);
			}

			@Autowired
			private TCoursePackageService coursePackageService;
			private void addPackageStudent(Integer courseId, Integer userId, Integer sId,Long paymentId) throws ParseException {
			// 课包
			TCoursePackage tCoursePackage = coursePackageService.getById(courseId);

			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");

			//查出当前用户当前学员当前课包最后一天的排课数据
			List<CoursePackageStudent> studentCourse = coursePackageStudentService.list(new QueryWrapper<CoursePackageStudent>().eq("studentId", sId).eq("coursePackageId", courseId));
			List<Long> collect = studentCourse.stream().map(CoursePackageStudent::getCoursePackageSchedulingId).collect(Collectors.toList());
			//拿到最后一天的排课记录
			if (collect.size() > 0) {
			coursePackageSchedulingService.remove(new QueryWrapper<CoursePackageScheduling>().in("id", collect));
			coursePackageStudentService.remove(new QueryWrapper<CoursePackageStudent>().eq("studentId", sId).eq("coursePackageId", courseId));
			}
			Date today = new Date();
			TCoursePackagePayment pay = coursePackagePaymentService.getById(paymentId);
			Integer laveClassHours = pay.getLaveClassHours();
			Integer codeTime = tCoursePackage.getCodeTime();
			Integer can = 0;
			int count = 0;
			// 本周周几
			Date[] dates = generateDateArray(14, today);
			if (tCoursePackage.getType() == 1) {
			can = laveClassHours / codeTime;
			}
			if (tCoursePackage.getType() == 2) {
			Date startDate = tCoursePackage.getStartTime();
			Date endDate = tCoursePackage.getEndTime();
			dates = generateDateArray1(startDate, endDate);
			can = 999;
			}
			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(userId);
			student1.setStudentId(sId);
			student1.setCoursePackageId(tCoursePackage.getId());
			student1.setCoursePackagePaymentId(paymentId);
			student1.setCoursePackageSchedulingId(coursePackageScheduling.getId());
			student1.setSignInOrNot(1);
			student1.setReservationStatus(1);
			student1.setInsertTime(new Date());
			coursePackageStudentService.save(student1);
			count++;
			}
			}
			}

			}else if (tCoursePackage.getType()==2){
			String classWeeks = tCoursePackage.getClassWeeks();
			List<Integer> week = week(classWeeks);

			Date today = new Date();

			Date startTime = tCoursePackage.getStartTime();
			Date endTime = tCoursePackage.getEndTime();
			LocalDate startDate = startTime.toInstant().atZone(ZoneId.systemDefault()).toLocalDate();
			LocalDate endDate = endTime.toInstant().atZone(ZoneId.systemDefault()).toLocalDate();
			Period period = Period.between(startDate, endDate);
			int days = period.getDays() + 1;
			Integer can =999;
			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");

			Calendar calendar = Calendar.getInstance();
			calendar.setTime(startTime);
			calendar.add(Calendar.DAY_OF_MONTH, -1);

			TCoursePackagePayment pay = coursePackagePaymentService.getById(paymentId);


			Date[] dates = generateDateArray(days,calendar.getTime());
			for (Date date : dates) {
			if (count==can){
			break;
			}
			int wei = cn.hutool.core.date.DateUtil.dayOfWeek(date)-1;
			if (wei == 0){
			wei =7;
			}
			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(userId);
			student1.setStudentId(sId);
			student1.setCoursePackageId(tCoursePackage.getId());
			student1.setCoursePackagePaymentId(pay.getId());
			student1.setCoursePackageSchedulingId(coursePackageScheduling.getId());
			student1.setSignInOrNot(1);
			student1.setReservationStatus(1);
			student1.setInsertTime(new Date());
			coursePackageStudentService.save(student1);
			count++;
			}
			}
			}
			}


			// 2.0
			TCourseInfoRecord tCourseInfoRecord = new TCourseInfoRecord();
			tCourseInfoRecord.setUserId(userId);
			tCourseInfoRecord.setCourseId(courseId);
			tCourseInfoRecord.setName("报名运动营");
			tCourseInfoRecord.setNum(tCoursePackage.getNeedNum());
			tCourseInfoRecord.setTime(new Date());
			tCourseInfoRecord.setType(2);
			appUserClient.addCourseInfoRecord(tCourseInfoRecord);


			}

			@ResponseBody
			@PostMapping("/base/coursePack/obtainStudentClassDetails")
			public List<RecordAppoint> obtainStudentClassDetailsData(@RequestBody WeeksOfCourseRest stuId){
			// try {
			return packagePaymentService.obtainStuClassDetails(stuId.getStuId(),stuId.getAppUserId(),stuId.getPageNum());
			// }catch (Exception e){
			// e.printStackTrace();
			// throw new RuntimeException();
			// }
			}


			@PostMapping("/base/coursePack/getCoursePackageConfig")
			public List<CoursePackagePaymentConfig> getCourseConfigList(@RequestBody Integer coursePackageId){
			return icppcService.list(new QueryWrapper<CoursePackagePaymentConfig>()
			.eq("coursePackageId",coursePackageId));
			}



			@PostMapping("/base/coursePack/getCoursePackagePaymentOfCode")
			public List<TCoursePackagePayment> getCoursePackagePaymentOfCode(@RequestBody String code){
			return packagePaymentService.list(new QueryWrapper<TCoursePackagePayment>()
			.eq("code",code));
			}


			// 2.0 送课时
			@PostMapping("/base/coursePack/sendHours")
			public Integer sendHours(@RequestBody String s) throws ParseException {
			String[] split2 = s.split("_");
			TCoursePackagePayment byId = packagePaymentService.getById(Long.valueOf(split2[0]));
			byId.setTotalClassHours(byId.getTotalClassHours()+Integer.valueOf(split2[2]));
			boolean b = packagePaymentService.updateHoursById(byId,Integer.valueOf(split2[2]));

			CourseCounsum courseCounsum = new CourseCounsum();
			courseCounsum.setPaymentId(byId.getId());
			courseCounsum.setChangeType(1);
			courseCounsum.setNum(Integer.valueOf(split2[2]));
			courseCounsum.setInsertTime(new Date());
			courseCounsum.setReason("介绍有礼");
			courseCounsumService.save(courseCounsum);


			List<CoursePackageStudent> studentCourse = coursePackageStudentService.list(new QueryWrapper<CoursePackageStudent>().eq("studentId", byId.getStudentId()).eq("coursePackageId", byId.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", byId.getStudentId()).eq("coursePackageId", byId.getCoursePackageId()));





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

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

			Date today = new Date();

			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++;
			}
			}
			}









			if(b){
			return 1;
			}else {

			return 0;
			}
			}


			/**
			* 查询课时
			* @param courseConfigId
			* @return
			*/
			@PostMapping("/base/coursePack/getClassHour")
			public Integer getClassHour(@RequestBody Integer courseConfigId){
			CoursePackagePaymentConfig byId = icppcService.getById(courseConfigId);
			return byId.getClassHours();
			}

			/**
			* 获取课包报名信息列表
			* @param queryRegistrationRecord
			* @return
			*/
			@ResponseBody
			@PostMapping("/coursePackagePayment/queryRegistrationRecord")
			public Page<Map<String, Object>> queryRegistrationRecord(@RequestBody QueryRegistrationRecord queryRegistrationRecord){
			Page<Map<String, Object>> page = new PageFactory<Map<String, Object>>().defaultPage(queryRegistrationRecord.getLimit(), queryRegistrationRecord.getOffset(), queryRegistrationRecord.getSort(), queryRegistrationRecord.getOrder());
			Page<Map<String, Object>> mapPage = page.setRecords(packagePaymentService.queryRegistrationRecord(page, queryRegistrationRecord));
			return mapPage;
			}


			/**
			* 获取未预约排课学员列表
			* @param queryWalkInStudentList
			* @return
			*/
			@ResponseBody
			@PostMapping("/coursePackagePayment/queryWalkInStudentList")
			public Page<Map<String, Object>> queryWalkInStudentList(@RequestBody QueryWalkInStudentList queryWalkInStudentList){
			Page<Map<String, Object>> page = new PageFactory<Map<String, Object>>().defaultPage(queryWalkInStudentList.getLimit(), queryWalkInStudentList.getOffset(), queryWalkInStudentList.getSort(), queryWalkInStudentList.getOrder());
			Page<Map<String, Object>> mapPage = page.setRecords(packagePaymentService.queryWalkInStudentList(page, queryWalkInStudentList));
			return mapPage;
			}


			/**
			* 根据id获取数据
			* @param id
			* @return
			*/
			@ResponseBody
			@PostMapping("/coursePackagePayment/queryCoursePackagePaymentById")
			public TCoursePackagePayment queryCoursePackagePaymentById(@RequestParam("id")Long id){
			return packagePaymentService.getById(id);
			}


			@ResponseBody
			@PostMapping("/coursePackagePayment/CountqueryByClassId")
			public Integer CountqueryByClassId(@RequestBody Integer id){
			int coursePackageId = packagePaymentService.count(new QueryWrapper<TCoursePackagePayment>().eq("coursePackageId", id));


			return coursePackageId;
			}


			/**
			* 修改数据
			* @param coursePackagePayment
			*/
			@ResponseBody
			@PostMapping("/coursePackagePayment/editCoursePackagePayment")
			public void editCoursePackagePayment(TCoursePackagePayment coursePackagePayment){
			coursePackagePayment.setAppUserId(null);
			packagePaymentService.updateById(coursePackagePayment);
			}



			/**
			* 修改数据
			* @param coursePackagePayment
			*/
			@ResponseBody
			@PostMapping("/coursePackagePayment/editCoursePackagePayment1")
			public void editCoursePackagePayment1(@RequestBody TCoursePackagePayment coursePackagePayment){
			System.out.println("editCoursePackagePayment1====coursePackagePayment"+coursePackagePayment);
			// coursePackagePayment.setCoursePackageId(null);
			packagePaymentService.updateBytime(coursePackagePayment);
			}


			/**
			* 上课主页-预约操作
			*/
			@ResponseBody
			@PostMapping("/api/startCource/reverse")
			@ApiOperation(value = "上课主页-预约操作--2.0改请假操作", tags = {"APP-开始上课"})
			@ApiImplicitParams({
			@ApiImplicitParam(name = "Authorization", value = "Bearer +token", required = true, dataType = "String", paramType = "header", defaultValue = "Bearer eyJhbGciOiJIUzUxMiJ9....."),
			@ApiImplicitParam(value = "课包id", name = "courseID", required = true, dataType = "String"),
			@ApiImplicitParam(value = "时间 yyyy-MM-dd", name = "time", required = true, dataType = "String"),
			@ApiImplicitParam(value = "学员id", name = "stuId", required = true, dataType = "int"),
			})
			public ResultUtil reverse(String courseID,String time,Integer stuId){
			SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
			try {
			Integer appUserId = tokenUtil.getUserIdFormRedis();
			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)
			);

			if (ToolUtil.isEmpty(packagePayment) \|\| packagePayment.size()==0){
			return ResultUtil.error("该用户未购买该课包");
			}
			List<CoursePackageScheduling> coursePackageSchedulings = coursePackageSchedulingMapper.selectList(new LambdaQueryWrapper<CoursePackageScheduling>()
			.eq(CoursePackageScheduling::getCoursePackageId, Integer.valueOf(courseID))
			.like(CoursePackageScheduling::getClassDate, time)
			);

			List<CoursePackageStudent> coursePackageStudent = cspsService.list(new LambdaQueryWrapper<CoursePackageStudent>()
			.in(CoursePackageStudent::getCoursePackagePaymentId,packagePayment.stream().map(TCoursePackagePayment::getId).collect(Collectors.toList()))
			.in(CoursePackageStudent::getCoursePackageSchedulingId,coursePackageSchedulings.stream().map(CoursePackageScheduling::getId).collect(Collectors.toList()))
			.eq(CoursePackageStudent::getCoursePackageId,courseID)
			.eq(CoursePackageStudent::getStudentId,stuId)
			.eq(CoursePackageStudent::getAppUserId,appUserId)
			);

			if (ToolUtil.isNotEmpty(coursePackageStudent)){
			for (CoursePackageStudent packageStudent : coursePackageStudent) {
			if(packageStudent.getReservationStatus()==1){
			packageStudent.setSignInOrNot(2);
			cspsService.updateSignInOrNotById(packageStudent.getId());
			}
			}

			}else {
			}
			return ResultUtil.success();
			}catch (Exception e){
			e.printStackTrace();
			return ResultUtil.runErr();
			}
			}



			@ResponseBody
			@PostMapping("/base/coursePack/getConsumes")
			List<CourseCounsum> getConsumes(@RequestBody BillingDataRequestVo requestVo) {
			Integer[] integers = {2,3};
			QueryWrapper<CourseCounsum> courseCounsumQueryWrapper = new QueryWrapper<CourseCounsum>().in("changeType",integers).eq("appUserId",requestVo.getAppUserId());
			if (requestVo.getMonthEnd()!=null){
			courseCounsumQueryWrapper.ge("insertTime",requestVo.getMonthStart());
			courseCounsumQueryWrapper.le("insertTime",requestVo.getMonthEnd());
			}
			return courseCounsumService.list(courseCounsumQueryWrapper);

			}

			@ResponseBody
			@PostMapping("/base/coursePack/weeksOfCourseDetailsList")
			HashMap<String, Object> weeksOfCourseDetailsList(@RequestBody CourseDetailReq courseDetailReq){
			HashMap<String, Object> map = new HashMap<>();
			ArrayList<DetailsListVo> objects = new ArrayList<>();
			// try {
			String time = courseDetailReq.getTime();
			Date parse = null;
			try {
			parse = new SimpleDateFormat("yyyy-MM-dd").parse(time);
			} catch (ParseException e) {
			throw new RuntimeException(e);
			}
			int i = cn.hutool.core.date.DateUtil.dayOfWeek(parse)-1;
			String week = week(i);
			Store store = sreClient.queryStoreById(courseDetailReq.getStoreId());
			String lat = store.getLat();
			String lon = store.getLon();

			Map<String, Double> distance = GeodesyUtil.getDistance(courseDetailReq.getLon() + "," + courseDetailReq.getLat(), lon + "," + lat);
			double wgs84 = distance.get("WGS84") / 1000;
			map.put("distance",wgs84);
			map.put("name",store.getName());
			map.put("lon",lon);
			map.put("lat",lat);

			String time1 = courseDetailReq.getTime();

			// 找出门店的所有课程排出体验
			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<TCoursePackagePayment> list1 = packagePaymentService.list(new LambdaQueryWrapper<TCoursePackagePayment>().eq(TCoursePackagePayment::getAppUserId, courseDetailReq.getAppUserId()).eq(TCoursePackagePayment::getStudentId, courseDetailReq.getStuId()).in(TCoursePackagePayment::getCoursePackageId, collect));
			List<Integer> collect1 = list1.stream().map(TCoursePackagePayment::getCoursePackageId).collect(Collectors.toList());
			List<Long> ids = list1.stream().map(TCoursePackagePayment::getId).collect(Collectors.toList());


			for (TCoursePackage tCoursePackage : list) {
			DetailsListVo detailsListVo = new DetailsListVo();
			detailsListVo.setId(tCoursePackage.getId());
			detailsListVo.setName(tCoursePackage.getName());
			detailsListVo.setCourseType(tCoursePackage.getType());
			String classStartTime = tCoursePackage.getClassStartTime();
			String[] split = classStartTime.split(",");
			String classEndTime = tCoursePackage.getClassEndTime();
			String[] split1 = classEndTime.split(",");
			ArrayList<String> strings = new ArrayList<>();
			if(ToolUtil.isNotEmpty(classStartTime)){
			for (int i1 = 0; i1 < split.length; i1++) {
			String s = split[i1].substring(0,5) + "-" + split1[i1].substring(0,5);
			strings.add(s);
			}
			}
			if (detailsListVo.getCourseType()==1) {
			detailsListVo.setTime(strings);
			}else {
			Date startTime = tCoursePackage.getStartTime();
			Date endTime = tCoursePackage.getEndTime();
			SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
			String formattedStartTime = sdf.format(startTime);
			String formattedEndTime = sdf.format(endTime);

			String result = formattedStartTime + "至" + formattedEndTime;
			List<String> stringLists = new ArrayList<>();
			stringLists.add(result);
			detailsListVo.setTime(stringLists);

			}
			//价格
			List<CoursePackagePaymentConfig> list2 = icppcService.list(new LambdaQueryWrapper<CoursePackagePaymentConfig>().eq(CoursePackagePaymentConfig::getCoursePackageId, tCoursePackage.getId()).orderByAsc(CoursePackagePaymentConfig::getCashPayment));
			if (list2.size() > 0) {
			Double cashPayment = list2.get(0).getCashPayment();
			detailsListVo.setMoney(cashPayment);
			}
			detailsListVo.setNum(tCoursePackage.getNeedNum());
			if (collect1.contains(tCoursePackage.getId())) {
			// 找出排课记录
			List<CoursePackageScheduling> list3 = coursePackageSchedulingMapper.selectList(new LambdaQueryWrapper<CoursePackageScheduling>()
			.eq(CoursePackageScheduling::getCoursePackageId, tCoursePackage.getId())
			.like(CoursePackageScheduling::getClassDate, courseDetailReq.getTime())
			);
			if(list3.size()==0){
			detailsListVo.setType(2);
			objects.add(detailsListVo);
			continue;
			}
			//排课的ids
			List<Long> collect2 = list3.stream().map(CoursePackageScheduling::getId).collect(Collectors.toList());
			if(collect2.size()==0){
			collect2.add(-1l);
			}


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

			List<CoursePackageStudent> list5 = cspsService.list(new QueryWrapper<CoursePackageStudent>().eq("studentId", courseDetailReq.getStuId()).eq("coursePackageId",tCoursePackage.getId()));

			if(list5.size()>0&&list4.size()>0){
			Integer signInOrNot = list4.get(0).getSignInOrNot();
			detailsListVo.setType(1);

			if(signInOrNot==2){
			detailsListVo.setType(3);
			}
			detailsListVo.setIsType(list4.get(0).getType());

			for (CoursePackageStudent coursePackageStudent : list4) {
			Integer signInOrNot1 = coursePackageStudent.getSignInOrNot();
			detailsListVo.setType(1);

			if(signInOrNot1==2){
			detailsListVo.setType(3);
			}
			detailsListVo.setIsType(coursePackageStudent.getType());
			CoursePackageScheduling coursePackageScheduling = coursePackageSchedulingMapper.selectById(coursePackageStudent.getCoursePackageSchedulingId());
			Date classDate = coursePackageScheduling.getClassDate();
			Date endDate = coursePackageScheduling.getEndDate();
			SimpleDateFormat sdf = new SimpleDateFormat("HH:mm");
			String formattedClassDate = sdf.format(classDate);
			String formattedEndDate = sdf.format(endDate);

			String result = formattedClassDate + "-" + formattedEndDate;
			List<String> strings1 =new ArrayList<>();
			strings1.add(result);
			detailsListVo.setTime(strings1);
			DetailsListVo detailsListVo1 = new DetailsListVo();

			// detailsListVo1.setId(coursePackageStudent.getId());
			BeanUtils.copyProperties(detailsListVo,detailsListVo1);
			objects.add(detailsListVo1);
			}





			}else {
			detailsListVo.setType(2);
			objects.add(detailsListVo);

			}

			} else {
			detailsListVo.setType(2);
			objects.add(detailsListVo);

			}
			// objects.add(detailsListVo);
			}
			map.put("data",objects);

			return map;
			// } catch (ParseException e) {
			// e.printStackTrace();
			// }
			// return map;
			}

			private String week(int i){
			String a = "";
			switch (i){
			case 1:
			a="周一";
			break;
			case 2:
			a="周二";
			break;
			case 3:
			a="周三";
			break;
			case 4:
			a="周四";
			break;
			case 5:
			a="周五";
			break;
			case 6:
			a="周六";
			break;
			case 7:
			a="周日";
			break;
			}
			return a;
			}


			@ResponseBody
			@PostMapping("/coursePackagePayment/queryCourseData")
			public List<Map<String,Object>> queryCourseData(@RequestBody List<Integer> ids){
			// 找出课程类型找出剩余的课时数
			List<TCoursePackageType> list = coursePackageTypeService.list();
			if(ids.size()==0){
			ids.add(-1);
			}
			List<TCoursePackagePayment> list1 = packagePaymentService.listOne(ids);
			List<Integer> collect = list1.stream().map(TCoursePackagePayment::getCoursePackageId).collect(Collectors.toList());
			if(collect.size()==0){
			collect.add(-1);
			}
			List<TCoursePackage> list2 = tcpService.list(new LambdaQueryWrapper<TCoursePackage>().in(TCoursePackage::getId, collect));
			for (TCoursePackagePayment tCoursePackagePayment : list1) {
			for (TCoursePackage tCoursePackage : list2) {
			if(tCoursePackagePayment.getCoursePackageId().equals(tCoursePackage.getId())){
			tCoursePackagePayment.setType(tCoursePackage.getCoursePackageTypeId());
			}
			}
			}


			List<Map<String,Object>> mapList = new ArrayList<>();
			for (TCoursePackageType tCoursePackageType : list) {
			HashMap<String, Object> map = new HashMap<>();
			map.put("name",tCoursePackageType.getName());
			int a =0;
			for (TCoursePackagePayment tCoursePackagePayment : list1) {
			if(tCoursePackagePayment.getType().equals(tCoursePackageType.getId())){
			a += tCoursePackagePayment.getLaveClassHours();
			}
			}
			map.put("value",a);
			mapList.add(map);
			}


			return mapList;
			}



			@ResponseBody
			@PostMapping("/coursePackagePayment/coursePt")
			HashMap<String, Object> coursePt(@RequestBody List<Integer> userPt){
			if(userPt.size()==0){
			userPt.add(-1);
			}
			HashMap<String, Object> map = new HashMap<>();
			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);

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


			// 年
			List<CoursePackageStudent> list = cspsService.list(new LambdaQueryWrapper<CoursePackageStudent>().in(CoursePackageStudent::getAppUserId, userPt));


			for (CoursePackageStudent coursePackageStudent : list) {
			for (TCoursePackage coursePackage : coursePackages) {
			if(coursePackageStudent.getCoursePackageId().equals(coursePackage.getId())){
			if(ToolUtil.isEmpty(coursePackage.getNeedNum())){
			coursePackageStudent.setNeedNum(0);
			}else {
			coursePackageStudent.setNeedNum(coursePackage.getNeedNum());
			}
			}
			}
			}

			ArrayList<Object> integers = new ArrayList<>();
			int year = cn.hutool.core.date.DateUtil.year(new Date());
			for (int i = 0; i < 10; i++) {
			integers.add(year-i);
			}
			List<Object> collect = integers.stream().sorted().collect(Collectors.toList());
			// 年
			ArrayList<Integer> years = new ArrayList<>();
			for (Object o : collect) {
			String s = o.toString();
			List<CoursePackageStudent> collect1 = list.stream().filter(e -> e.getInsertTime().toString().contains(s)).filter(student -> student.getNeedNum() != null).collect(Collectors.toList());
			int sum2 = collect1.stream().mapToInt(CoursePackageStudent::getNeedNum).sum();
			years.add(sum2);
			}

			map.put("yearData",years);



			ArrayList<Integer> months = new ArrayList<>();

			SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");


			// 月
			for (int i = 1; i <= 12; i++) {
			String m=i+"";
			if(i<10){
			m="0"+i;
			}
			String s = year + "-" + m;
			List<CoursePackageStudent> collect1 = list.stream().filter(e -> format.format(e.getInsertTime()).contains(s)).filter(student -> student.getNeedNum() != null).collect(Collectors.toList());
			int sum2 = collect1.stream().mapToInt(CoursePackageStudent::getNeedNum).sum();
			months.add(sum2);
			}
			map.put("monthData",months);

			// 周
			// 获取最近四周
			LocalDateTime minNow = LocalDateTime.now().with(LocalTime.MIN);
			LocalDateTime maxNow = LocalDateTime.now().with(LocalTime.MAX);
			// 周度数据
			LocalDateTime s1 = minNow.minusDays(6);
			LocalDateTime s2 = maxNow;

			LocalDateTime s3 = minNow.minusDays(13);
			LocalDateTime s4 = maxNow.minusDays(6);


			LocalDateTime s5 = minNow.minusDays(20);
			LocalDateTime s6 = maxNow.minusDays(13);

			LocalDateTime s7 = minNow.minusDays(27);
			LocalDateTime s8 = maxNow.minusDays(20);
			ArrayList<Object> weekData = new ArrayList<>();

			int count = 0;

			int count1 = 0;

			int count2 = 0;

			int count3 = 0;
			for (CoursePackageStudent coursePackageStudent : list) {
			if (coursePackageStudent.getNeedNum()==null){
			continue;
			}
			// 如果到课状态为否则不计算
			if (coursePackageStudent.getSignInOrNot() != 0) {
			Date insertTime = coursePackageStudent.getInsertTime();
			Instant instant = insertTime.toInstant();
			ZoneId zoneId = ZoneId.systemDefault();
			LocalDateTime dateTime = instant.atZone(zoneId).toLocalDateTime();
			if (dateTime.isAfter(s1) && dateTime.isBefore(s2)){

			count+=coursePackageStudent.getNeedNum();
			}else if(dateTime.isAfter(s3) && dateTime.isBefore(s4)){
			count1+=coursePackageStudent.getNeedNum();
			}else if(dateTime.isAfter(s5) && dateTime.isBefore(s6)){
			count2+=coursePackageStudent.getNeedNum();
			}else if(dateTime.isAfter(s7) && dateTime.isBefore(s8)){
			count3+=coursePackageStudent.getNeedNum();
			}

			}
			}
			weekData.add(count3);
			weekData.add(count2);
			weekData.add(count1);
			weekData.add(count);

			map.put("weekData",weekData);


			LocalDateTime currentDateTime = LocalDateTime.now();
			List<Integer> amountByDay = new ArrayList<>(Collections.nCopies(7,0));
			for (CoursePackageStudent coursePackageStudent : list) {
			Date insertTime = coursePackageStudent.getInsertTime();
			// 将 Date 转换为 LocalDateTime
			LocalDateTime insertDateTime = LocalDateTime.ofInstant(insertTime.toInstant(), ZoneId.systemDefault());
			// 计算日期与当前日期的差距
			long daysDifference = ChronoUnit.DAYS.between(insertDateTime.toLocalDate(), currentDateTime.toLocalDate());
			// 如果日期在七天内，累加金额
			if (daysDifference >= 0 && daysDifference < 7) {
			int index = (int) (6 - daysDifference); // 计算对应的索引位置
			Integer needNum = coursePackageStudent.getNeedNum();
			if (needNum!=null){
			int i = amountByDay.get(index) + needNum;
			amountByDay.set(index, i);
			}

			}
			}
			map.put("dayData", amountByDay);

			return map;

			}
			@ResponseBody
			@PostMapping("/coursePackagePayment/courseYys")
			HashMap<String, Object> courseYys(@RequestBody List<Integer> userPt){
			if(userPt.size()==0){
			userPt.add(-1);
			}
			HashMap<String, Object> map = new HashMap<>();
			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);

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


			// 年
			List<CoursePackageStudent> list = cspsService.list(new LambdaQueryWrapper<CoursePackageStudent>().in(CoursePackageStudent::getAppUserId, userPt));


			for (CoursePackageStudent coursePackageStudent : list) {
			for (TCoursePackage coursePackage : coursePackages) {
			if(coursePackageStudent.getCoursePackageId().equals(coursePackage.getId())){
			if(ToolUtil.isEmpty(coursePackage.getNeedNum())){
			coursePackageStudent.setNeedNum(0);
			}else {
			coursePackageStudent.setNeedNum(coursePackage.getNeedNum());
			}
			}
			}
			}

			ArrayList<Object> integers = new ArrayList<>();
			int year = cn.hutool.core.date.DateUtil.year(new Date());
			for (int i = 0; i < 10; i++) {
			integers.add(year-i);
			}
			List<Object> collect = integers.stream().sorted().collect(Collectors.toList());
			// 年
			ArrayList<Integer> years = new ArrayList<>();
			for (Object o : collect) {
			String s = o.toString();
			List<CoursePackageStudent> collect1 = list.stream().filter(e -> e.getInsertTime().toString().contains(s)).filter(student -> student.getNeedNum() != null).collect(Collectors.toList());
			int sum2 = collect1.stream().mapToInt(CoursePackageStudent::getNeedNum).sum();
			years.add(sum2);
			}

			map.put("yearData",years);



			ArrayList<Integer> months = new ArrayList<>();

			SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");


			// 月
			for (int i = 1; i <= 12; i++) {
			String m=i+"";
			if(i<10){
			m="0"+i;
			}
			String s = year + "-" + m;
			List<CoursePackageStudent> collect1 = list.stream().filter(e -> format.format(e.getInsertTime()).contains(s)).filter(student -> student.getNeedNum() != null).collect(Collectors.toList());
			int sum2 = collect1.stream().mapToInt(CoursePackageStudent::getNeedNum).sum();
			months.add(sum2);
			}
			map.put("monthData",months);

			// 周
			// 获取最近四周
			LocalDateTime minNow = LocalDateTime.now().with(LocalTime.MIN);
			LocalDateTime maxNow = LocalDateTime.now().with(LocalTime.MAX);
			// 周度数据
			LocalDateTime s1 = minNow.minusDays(6);
			LocalDateTime s2 = maxNow;

			LocalDateTime s3 = minNow.minusDays(13);
			LocalDateTime s4 = maxNow.minusDays(6);


			LocalDateTime s5 = minNow.minusDays(20);
			LocalDateTime s6 = maxNow.minusDays(13);

			LocalDateTime s7 = minNow.minusDays(27);
			LocalDateTime s8 = maxNow.minusDays(20);
			ArrayList<Object> weekData = new ArrayList<>();

			int count = 0;

			int count1 = 0;

			int count2 = 0;

			int count3 = 0;
			for (CoursePackageStudent coursePackageStudent : list) {
			if (coursePackageStudent.getNeedNum()==null){
			continue;
			}
			// 如果到课状态为否则不计算
			if (coursePackageStudent.getSignInOrNot() != 0) {
			Date insertTime = coursePackageStudent.getInsertTime();
			Instant instant = insertTime.toInstant();
			ZoneId zoneId = ZoneId.systemDefault();
			LocalDateTime dateTime = instant.atZone(zoneId).toLocalDateTime();
			if (dateTime.isAfter(s1) && dateTime.isBefore(s2)){

			count+=coursePackageStudent.getNeedNum();
			}else if(dateTime.isAfter(s3) && dateTime.isBefore(s4)){
			count1+=coursePackageStudent.getNeedNum();
			}else if(dateTime.isAfter(s5) && dateTime.isBefore(s6)){
			count2+=coursePackageStudent.getNeedNum();
			}else if(dateTime.isAfter(s7) && dateTime.isBefore(s8)){
			count3+=coursePackageStudent.getNeedNum();
			}

			}
			}
			weekData.add(count3);
			weekData.add(count2);
			weekData.add(count1);
			weekData.add(count);

			map.put("weekData",weekData);


			LocalDateTime currentDateTime = LocalDateTime.now();
			List<Integer> amountByDay = new ArrayList<>(Collections.nCopies(7,0));
			for (CoursePackageStudent coursePackageStudent : list) {
			Date insertTime = coursePackageStudent.getInsertTime();
			// 将 Date 转换为 LocalDateTime
			LocalDateTime insertDateTime = LocalDateTime.ofInstant(insertTime.toInstant(), ZoneId.systemDefault());
			// 计算日期与当前日期的差距
			long daysDifference = ChronoUnit.DAYS.between(insertDateTime.toLocalDate(), currentDateTime.toLocalDate());
			// 如果日期在七天内，累加金额
			if (daysDifference >= 0 && daysDifference < 7) {
			int index = (int) (6 - daysDifference); // 计算对应的索引位置
			Integer needNum = coursePackageStudent.getNeedNum();
			if (needNum!=null){
			int i = amountByDay.get(index) + needNum;
			amountByDay.set(index, i);
			}

			}
			}
			map.put("dayData", amountByDay);

			return map;

			}
			@ResponseBody
			@PostMapping("/coursePackagePayment/courseStore")
			HashMap<String, Object> courseStore(@RequestBody List<Integer> userPt){
			if(userPt.size()==0){
			userPt.add(-1);
			}
			HashMap<String, Object> map = new HashMap<>();
			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);

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


			// 年
			List<CoursePackageStudent> list = cspsService.list(new LambdaQueryWrapper<CoursePackageStudent>().in(CoursePackageStudent::getAppUserId, userPt));


			for (CoursePackageStudent coursePackageStudent : list) {
			for (TCoursePackage coursePackage : coursePackages) {
			if(coursePackageStudent.getCoursePackageId().equals(coursePackage.getId())){
			if(ToolUtil.isEmpty(coursePackage.getNeedNum())){
			coursePackageStudent.setNeedNum(0);
			}else {
			coursePackageStudent.setNeedNum(coursePackage.getNeedNum());
			}
			}
			}
			}

			ArrayList<Object> integers = new ArrayList<>();
			int year = cn.hutool.core.date.DateUtil.year(new Date());
			for (int i = 0; i < 10; i++) {
			integers.add(year-i);
			}
			List<Object> collect = integers.stream().sorted().collect(Collectors.toList());
			// 年
			ArrayList<Integer> years = new ArrayList<>();
			for (Object o : collect) {
			String s = o.toString();
			List<CoursePackageStudent> collect1 = list.stream().filter(e -> e.getInsertTime().toString().contains(s)).filter(student -> student.getNeedNum() != null).collect(Collectors.toList());
			int sum2 = collect1.stream().mapToInt(CoursePackageStudent::getNeedNum).sum();
			years.add(sum2);
			}

			map.put("yearData",years);



			ArrayList<Integer> months = new ArrayList<>();

			SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");


			// 月
			for (int i = 1; i <= 12; i++) {
			String m=i+"";
			if(i<10){
			m="0"+i;
			}
			String s = year + "-" + m;
			List<CoursePackageStudent> collect1 = list.stream().filter(e -> format.format(e.getInsertTime()).contains(s)).filter(student -> student.getNeedNum() != null).collect(Collectors.toList());
			int sum2 = collect1.stream().mapToInt(CoursePackageStudent::getNeedNum).sum();
			months.add(sum2);
			}
			map.put("monthData",months);

			// 周
			// 获取最近四周
			LocalDateTime minNow = LocalDateTime.now().with(LocalTime.MIN);
			LocalDateTime maxNow = LocalDateTime.now().with(LocalTime.MAX);
			// 周度数据
			LocalDateTime s1 = minNow.minusDays(6);
			LocalDateTime s2 = maxNow;

			LocalDateTime s3 = minNow.minusDays(13);
			LocalDateTime s4 = maxNow.minusDays(6);


			LocalDateTime s5 = minNow.minusDays(20);
			LocalDateTime s6 = maxNow.minusDays(13);

			LocalDateTime s7 = minNow.minusDays(27);
			LocalDateTime s8 = maxNow.minusDays(20);
			ArrayList<Object> weekData = new ArrayList<>();

			int count = 0;

			int count1 = 0;

			int count2 = 0;

			int count3 = 0;
			for (CoursePackageStudent coursePackageStudent : list) {
			if (coursePackageStudent.getNeedNum()==null){
			continue;
			}
			// 如果到课状态为否则不计算
			if (coursePackageStudent.getSignInOrNot() != 0) {
			Date insertTime = coursePackageStudent.getInsertTime();
			Instant instant = insertTime.toInstant();
			ZoneId zoneId = ZoneId.systemDefault();
			LocalDateTime dateTime = instant.atZone(zoneId).toLocalDateTime();
			if (dateTime.isAfter(s1) && dateTime.isBefore(s2)){

			count+=coursePackageStudent.getNeedNum();
			}else if(dateTime.isAfter(s3) && dateTime.isBefore(s4)){
			count1+=coursePackageStudent.getNeedNum();
			}else if(dateTime.isAfter(s5) && dateTime.isBefore(s6)){
			count2+=coursePackageStudent.getNeedNum();
			}else if(dateTime.isAfter(s7) && dateTime.isBefore(s8)){
			count3+=coursePackageStudent.getNeedNum();
			}

			}
			}
			weekData.add(count3);
			weekData.add(count2);
			weekData.add(count1);
			weekData.add(count);

			map.put("weekData",weekData);


			LocalDateTime currentDateTime = LocalDateTime.now();
			List<Integer> amountByDay = new ArrayList<>(Collections.nCopies(7,0));
			for (CoursePackageStudent coursePackageStudent : list) {
			Date insertTime = coursePackageStudent.getInsertTime();
			// 将 Date 转换为 LocalDateTime
			LocalDateTime insertDateTime = LocalDateTime.ofInstant(insertTime.toInstant(), ZoneId.systemDefault());
			// 计算日期与当前日期的差距
			long daysDifference = ChronoUnit.DAYS.between(insertDateTime.toLocalDate(), currentDateTime.toLocalDate());
			// 如果日期在七天内，累加金额
			if (daysDifference >= 0 && daysDifference < 7) {
			int index = (int) (6 - daysDifference); // 计算对应的索引位置
			Integer needNum = coursePackageStudent.getNeedNum();
			if (needNum!=null){
			int i = amountByDay.get(index) + needNum;
			amountByDay.set(index, i);
			}

			}
			}
			map.put("dayData", amountByDay);

			return map;

			}
			}