package com.dsh.course.controller;
|
|
|
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
|
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
|
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.model.*;
|
import com.dsh.course.feignclient.other.StoreClient;
|
import com.dsh.course.feignclient.other.model.Store;
|
import com.dsh.course.mapper.CoursePackageSchedulingMapper;
|
import com.dsh.course.mapper.CoursePackageStudentMapper;
|
import com.dsh.course.mapper.TCoursePackageMapper;
|
import com.dsh.course.model.*;
|
import com.dsh.course.model.dto.DiscountJsonDto;
|
import com.dsh.course.model.vo.CourseDetailRequest;
|
import com.dsh.course.model.vo.RegisterCourseVo;
|
import com.dsh.course.model.vo.request.*;
|
import com.dsh.course.model.vo.response.*;
|
import com.dsh.course.service.*;
|
import com.dsh.course.util.*;
|
import com.fasterxml.jackson.core.JsonProcessingException;
|
import com.fasterxml.jackson.databind.ObjectMapper;
|
import com.obs.services.internal.ServiceException;
|
import io.swagger.annotations.Api;
|
import io.swagger.annotations.ApiImplicitParam;
|
import io.swagger.annotations.ApiImplicitParams;
|
import io.swagger.annotations.ApiOperation;
|
import net.sf.json.JSONObject;
|
import org.slf4j.Logger;
|
import org.slf4j.LoggerFactory;
|
import org.springframework.beans.BeanUtils;
|
import org.springframework.beans.factory.annotation.Autowired;
|
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.time.*;
|
import java.time.temporal.ChronoUnit;
|
import java.util.*;
|
import java.util.stream.Collectors;
|
|
@Api
|
@CrossOrigin
|
@RestController
|
@RequestMapping("")
|
public class CoursePackagePaymentController {
|
private Logger logger = LoggerFactory.getLogger("business-log");
|
|
@Autowired
|
private TCoursePackagePaymentService packagePaymentService;
|
|
@Resource
|
private CoursePackageStudentMapper cpsMapper;
|
@Autowired
|
private ICoursePackageOrderService coursePackageOrderService;
|
|
@Autowired
|
private TCoursePackageService tcpService;
|
|
@Autowired
|
private TCoursePackageDiscountService tcpdService;
|
|
|
@Autowired
|
private ICoursePackagePaymentConfigService icppcService;
|
|
@Autowired
|
private UserVideoDetailsService uvdsService;
|
|
@Autowired
|
private TCourseService tcService;
|
|
@Resource
|
private StudentClient studentClient;
|
|
@Autowired
|
private TCoursePackageTypeService coursePackageTypeService;
|
|
@Autowired
|
private TokenUtil tokenUtil;
|
|
@Autowired
|
private CancelledClassesService cancelledClassesService;
|
|
@Resource
|
private CoursePackageStudentService cspsService;
|
|
@Autowired
|
private PayMoneyUtil payMoneyUtil;
|
|
@Resource
|
private AppUserClient auClitn;
|
|
@Resource
|
private StoreClient sreClient;
|
|
@Resource
|
private AppUserClient appUserClient;
|
|
@Autowired
|
private RestTemplate internalRestTemplate;
|
|
@Resource
|
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");
|
|
|
|
@Autowired
|
private ICoursePackageOrderStudentService coursePackageOrderStudentService;
|
|
|
/**
|
* 查询学员入学时间 根据第一次购买课包的时间
|
*
|
* @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) {
|
//校验是否已经报满
|
Integer cpId = Integer.valueOf((int) packagePayment.getCoursePackageId());
|
Integer integer = coursePackagePaymentService.queryCountNumber(cpId);
|
TCoursePackage course = coursePackageService.getById(packagePayment.getCoursePackageId());
|
if (course.getType() != 3) {
|
if (integer + 1 > course.getMaxSubscribeNumber()) {
|
return 5001;
|
}
|
}
|
CoursePackageOrder coursePackageOrder = new CoursePackageOrder();
|
coursePackageOrder.setAppUserId(packagePayment.getAppUserId());
|
coursePackageOrder.setStudentIds(String.valueOf(packagePayment.getStudentId()));
|
coursePackageOrder.setCoursePackageId(packagePayment.getCoursePackageId());
|
coursePackageOrder.setClassHours(packagePayment.getClassHours());
|
coursePackageOrder.setOriginalPrice(packagePayment.getOriginalPrice());
|
coursePackageOrder.setCashPayment(packagePayment.getCashPayment());
|
coursePackageOrder.setPlayPaiCoin(packagePayment.getPlayPaiCoin());
|
coursePackageOrder.setCode(packagePayment.getCode());
|
coursePackageOrder.setPayStatus(1);
|
coursePackageOrder.setStatus(1);
|
coursePackageOrder.setState(1);
|
coursePackageOrder.setInsertTime(new Date());
|
coursePackageOrder.setSalesName(packagePayment.getSalesName());
|
coursePackageOrderService.save(coursePackageOrder);
|
// 生成排课数据
|
return 200;
|
|
}
|
|
/**
|
* 手动支付
|
*
|
* @return
|
*/
|
@RequestMapping("/base/coursePackagePayment/changeState")
|
public Object changeState(@RequestBody CoursePackagePayDTO dto) {
|
String ids = dto.getIds();
|
Long aLong = Long.valueOf(ids);
|
CoursePackageOrder byId1 = coursePackageOrderService.getById(aLong);
|
TCoursePackage byId = coursePackageService.getById(byId1.getCoursePackageId());
|
if (byId.getType()==1){
|
// 如果重复购买 累加课时
|
CoursePackageOrderStudent coursePackageOrderStudent = coursePackageOrderStudentService
|
.getOne(new QueryWrapper<CoursePackageOrderStudent>().eq("studentId", Integer.valueOf(byId1.getStudentIds()))
|
.eq("coursePackageId", byId1.getCoursePackageId()).eq("status", 1).eq("state", 1));
|
if (null == coursePackageOrderStudent) {
|
coursePackageOrderStudent = new CoursePackageOrderStudent();
|
coursePackageOrderStudent.setAppUserId(byId1.getAppUserId());
|
coursePackageOrderStudent.setStudentId(Integer.valueOf(byId1.getStudentIds()));
|
coursePackageOrderStudent.setCoursePackageId(byId1.getCoursePackageId());
|
coursePackageOrderStudent.setTotalClassHours(byId1.getClassHours());
|
coursePackageOrderStudent.setLaveClassHours(byId1.getClassHours());
|
coursePackageOrderStudent.setAbsencesNumber(0);
|
coursePackageOrderStudent.setStatus(1);
|
coursePackageOrderStudent.setState(1);
|
coursePackageOrderStudent.setInsertTime(new Date());
|
// 判断这个订单购买的是哪一个课时规格
|
CoursePackagePaymentConfig one1 = icppcService.getOne(new QueryWrapper<CoursePackagePaymentConfig>()
|
.eq("coursePackageId", byId.getId())
|
.eq("classHours", byId1.getClassHours()));
|
|
// 判断当前购买的课包有没有赠送课时
|
TCoursePackageDiscount one = tcpdService.getOne(new QueryWrapper<TCoursePackageDiscount>().eq("coursePackageId", byId.getId())
|
.eq("type", 4).eq("auditStatus", 2).eq("status", 1)
|
.eq("coursePackagePaymentConfigId",one1.getId()));
|
if (one!=null){
|
Integer giftClassHours = getGiftClassHours(one,null);
|
coursePackageOrderStudent.setGiftClassHours(giftClassHours);
|
coursePackageOrderStudent.setTotalClassHours(coursePackageOrderStudent.getTotalClassHours()+giftClassHours);
|
coursePackageOrderStudent.setLaveClassHours(coursePackageOrderStudent.getLaveClassHours()+giftClassHours);
|
}else{
|
coursePackageOrderStudent.setGiftClassHours(0);
|
}
|
Integer validDays = byId.getValidDays();
|
Calendar calendar = Calendar.getInstance();
|
calendar.setTime(new Date());
|
calendar.set(Calendar.DAY_OF_YEAR, calendar.get(Calendar.DAY_OF_YEAR) + validDays);
|
coursePackageOrderStudent.setUseTime(calendar.getTime());
|
coursePackageOrderStudent.setInsertTime(new Date());
|
coursePackageOrderStudentService.saveOrUpdate(coursePackageOrderStudent);
|
Integer studentId = Integer.valueOf(byId1.getStudentIds());
|
//开始排课
|
addPackageStudent1(byId, byId1.getAppUserId(), studentId, byId1, coursePackageOrderStudent);
|
} else {
|
Date useTime = coursePackageOrderStudent.getUseTime();
|
coursePackageOrderStudent.setTotalClassHours(coursePackageOrderStudent.getTotalClassHours() + byId1.getClassHours());
|
coursePackageOrderStudent.setLaveClassHours(coursePackageOrderStudent.getLaveClassHours() + byId1.getClassHours());
|
Integer validDays = byId.getValidDays();
|
Calendar calendar = Calendar.getInstance();
|
calendar.setTime(useTime.compareTo(new Date()) < 0 ? new Date() : useTime);
|
calendar.set(Calendar.DAY_OF_YEAR, calendar.get(Calendar.DAY_OF_YEAR) + validDays);
|
coursePackageOrderStudent.setUseTime(calendar.getTime());
|
// 判断这个订单购买的是哪一个课时规格
|
CoursePackagePaymentConfig one1 = icppcService.getOne(new QueryWrapper<CoursePackagePaymentConfig>()
|
.eq("coursePackageId", byId.getId())
|
.eq("classHours", byId1.getClassHours()));
|
// 判断当前购买的课包有没有赠送课时
|
TCoursePackageDiscount one = tcpdService.getOne(new QueryWrapper<TCoursePackageDiscount>().eq("coursePackageId", byId.getId())
|
.eq("type", 4).eq("auditStatus", 2).eq("status", 1)
|
.eq("coursePackagePaymentConfigId",one1.getId()));
|
if (one!=null){
|
Integer giftClassHours = getGiftClassHours(one,null);
|
coursePackageOrderStudent.setGiftClassHours(giftClassHours);
|
}else{
|
coursePackageOrderStudent.setGiftClassHours(0);
|
}
|
// 获取常规课的有效期 计算是哪一天
|
Calendar calendar9 = Calendar.getInstance();
|
calendar9.add(Calendar.DAY_OF_MONTH, byId.getValidDays());
|
Date time = calendar9.getTime();
|
coursePackageOrderStudent.setUseTime(time);
|
coursePackageOrderStudent.setInsertTime(new Date());
|
coursePackageOrderStudentService.saveOrUpdate(coursePackageOrderStudent);
|
Integer studentId = Integer.valueOf(byId1.getStudentIds());
|
//中间断课，没有连续续费的情况需要重新排课
|
if (useTime.compareTo(new Date()) < 0) {
|
addPackageStudent1(byId, byId1.getAppUserId(), studentId, byId1, coursePackageOrderStudent);
|
}
|
}
|
}
|
if(byId.getType() == 2){
|
addPackageStudent1(byId, byId1.getAppUserId(), Integer.valueOf(byId1.getStudentIds()), byId1, null);
|
}
|
return packagePaymentService.changeState(dto);
|
}
|
|
@GetMapping("/coursePackagePayment/courseStore/{appUserId}/{coursePackageId}")
|
public List<CoursePackageOrderStudent> getByUserIdAndCoursePackageId(@PathVariable("appUserId") Integer appUserId, @PathVariable("coursePackageId") Integer coursePackageId) {
|
List<CoursePackageOrderStudent> list = coursePackageOrderStudentService.list(new QueryWrapper<CoursePackageOrderStudent>()
|
.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) {
|
// 判断这条记录有没有赠送课时
|
Integer coursePackageId = re.getCoursePackageId();
|
Integer classHours = re.getClassHours();
|
CoursePackagePaymentConfig one = icppcService.getOne(new QueryWrapper<CoursePackagePaymentConfig>()
|
.eq("coursePackageId", coursePackageId)
|
.eq("classHours", classHours));
|
if (one!=null){
|
TCoursePackageDiscount one1 = discountService.getOne(new QueryWrapper<TCoursePackageDiscount>().eq("coursePackageId", coursePackageId)
|
.eq("coursePackagePaymentConfigId", one.getId())
|
.eq("auditStatus",2).eq("status",1).eq("type",4));
|
if (one1 == null){
|
re.setGiftClassHours(0);
|
}else{
|
Integer giftClassHours = getGiftClassHours(one1,re.getInsertTime());
|
re.setGiftClassHours(giftClassHours);
|
}
|
}else{
|
re.setGiftClassHours(0);
|
}
|
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());
|
String studentId = re.getStudentId();
|
String[] split = studentId.split(";");
|
StringBuilder stringBuilder = new StringBuilder("");
|
|
for (String s : split) {
|
Student student = studentClient.queryStudentById(Integer.valueOf(s));
|
stringBuilder.append(student.getName()+",");
|
}
|
String string = stringBuilder.toString();
|
if (string.length() > 0) {
|
String stringWithoutLastCharacter = string.substring(0, string.length() - 1);
|
re.setPayStudent(stringWithoutLastCharacter);
|
}
|
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 (string.contains(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.getCashPayment()));
|
} 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());
|
String[] split = re.getStudentIds().split(",");
|
Student student = studentClient.queryStudentById(Integer.valueOf(split[0]));
|
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(@RequestBody Integer stuId) {
|
List<StuCourseResp> resps = new ArrayList<>();
|
Student student = studentClient.queryStudentById(stuId);
|
List<CoursePackageOrderStudent> byUserId = coursePackageOrderStudentService.list(new QueryWrapper<CoursePackageOrderStudent>()
|
.eq("appUserId", student.getAppUserId())
|
.eq("studentId", stuId));
|
|
Date date = new Date();
|
|
if (byUserId.size() > 0) {
|
for (CoursePackageOrderStudent 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) {
|
resp.setIsAble(0);
|
} else {
|
resp.setIsAble(1);
|
}
|
|
if (tCoursePackagePayment.getUseTime() != null) {
|
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;
|
}
|
|
/**
|
* 获取发布的 课包列表
|
*/
|
@ResponseBody
|
@PostMapping("/base/coursePack/storeOfCourse")
|
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);
|
}
|
}
|
}
|
}
|
System.out.println(course);
|
return course;
|
} catch (ParseException e) {
|
return null;
|
}
|
}
|
|
@Autowired
|
private ICoursePackageOrderStudentService orderStudentService;
|
|
/**
|
* 课程名称列表
|
*/
|
@PostMapping("/base/coursePack/sessionNames")
|
public List<StuSessionDetailsVo> getStuSessionList(@RequestBody CourseDetailRequest request) {
|
List<StuSessionDetailsVo> detailsVos = new ArrayList<>();
|
List<CoursePackageOrderStudent> byUserId = orderStudentService.list(new QueryWrapper<CoursePackageOrderStudent>()
|
.between("insertTime", request.getStartTime(), request.getEndTime())
|
.eq("appUserId", request.getAppUserId())
|
.eq("studentId", request.getStuId()));
|
if (byUserId.size() > 0) {
|
List<Integer> collect = byUserId.stream().map(CoursePackageOrderStudent::getCoursePackageId).collect(Collectors.toList());
|
List<TCoursePackage> list = tcpService.list(new QueryWrapper<TCoursePackage>()
|
.in("id", collect));
|
|
byUserId.forEach(vo -> {
|
|
StuSessionDetailsVo detVo = new StuSessionDetailsVo();
|
detVo.setSessionid(vo.getCoursePackageId());
|
TCoursePackage byId = coursePackageService.getById(vo.getCoursePackageId());
|
detVo.setSessionName(byId.getName());
|
// String afterDayDate = DateUtil.getAfterDayDate2(vo.getInsertTime(), vo.getValidDays() + "");
|
|
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
|
String format1 = simpleDateFormat.format(vo.getUseTime());
|
detVo.setPeriodOfValidity(format1);
|
|
detVo.setTotalNums(vo.getTotalClassHours());
|
detVo.setDeductedNums(vo.getTotalClassHours() - vo.getLaveClassHours());
|
detVo.setRemainingNums(vo.getLaveClassHours());
|
|
detailsVos.add(detVo);
|
|
|
});
|
|
// list.forEach(vo -> {
|
// StuSessionDetailsVo detVo = new StuSessionDetailsVo();
|
// if (vo.getType()!=2) {
|
// detVo.setSessionid(vo.getId());
|
// detVo.setSessionName(vo.getName());
|
// String afterDayDate = DateUtil.getAfterDayDate2(vo.getInsertTime(), vo.getValidDays() + "");
|
// detVo.setPeriodOfValidity(afterDayDate);
|
//
|
// detVo.setTotalNums(ToolUtil.isEmpty(tCoursePackagePayment.getTotalCourseNums()) ? 0 : tCoursePackagePayment.getTotalCourseNums());
|
// detVo.setDeductedNums(ToolUtil.isEmpty(tCoursePackagePayment.getDeductionNums()) ? 0 : tCoursePackagePayment.getDeductionNums());
|
// detVo.setRemainingNums(ToolUtil.isEmpty(tCoursePackagePayment.getResidueNums())? 0 : tCoursePackagePayment.getResidueNums());
|
//
|
// detailsVos.add(detVo);
|
// }
|
// });
|
}
|
return detailsVos;
|
}
|
|
@PostMapping("/base/coursePack/paymentCourse")
|
public List<PurchaseRecordVo> queryCourseDetails(@RequestBody GetStuSessionList sessionList) {
|
List<PurchaseRecordVo> purchaseRecordVos = new ArrayList<>();
|
|
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();
|
recordVo.setPurchaseAmount("+" + cspackage.getClassHours());
|
recordVo.setPurchaseTime(format.format(cspackage.getInsertTime()));
|
recordVo.setPurchaseType("购买课包");
|
purchaseRecordVos.add(recordVo);
|
});
|
}
|
return purchaseRecordVos;
|
}
|
|
|
@Autowired
|
private CourseCounsumService courseCounsumService;
|
|
@Autowired
|
private TCoursePackagePaymentService coursePackagePaymentService;
|
|
@PostMapping("/base/coursePack/getRecord")
|
public List<PurchaseRecordVo> getRecord(@RequestBody RecordTimeRequest recordTimeRequest) {
|
// List<CoursePackageOrderStudent> list = new ArrayList<>();
|
Integer[] changes = {1, 0};
|
// if (recordTimeRequest.getType() == null) {
|
// list = coursePackageOrderStudentService.list(new QueryWrapper<CoursePackageOrderStudent>().eq("studentId", recordTimeRequest.getStuId()).eq("coursePackageId", recordTimeRequest.getLessionId()).orderByDesc("insertTime"));
|
// } else {
|
//
|
// list = coursePackageOrderStudentService.list(new QueryWrapper<CoursePackageOrderStudent>().eq("studentId", recordTimeRequest.getStuId()).eq("coursePackageId", recordTimeRequest.getLessionId()).orderByDesc("insertTime"));
|
// }
|
// List<Integer> appUserIds = list.stream().map(CoursePackageOrderStudent::getAppUserId).collect(Collectors.toList());
|
List<CoursePackageOrderStudent> list1 = coursePackageOrderStudentService.list(new QueryWrapper<CoursePackageOrderStudent>()
|
.eq("studentId", recordTimeRequest.getStuId())
|
.eq("coursePackageId", recordTimeRequest.getLessionId())
|
.eq("state", 1)
|
);
|
List<Long> collect = list1.stream().map(CoursePackageOrderStudent::getId).collect(Collectors.toList());
|
|
QueryWrapper<CourseCounsum> in = new QueryWrapper<CourseCounsum>().in("paymentId", collect).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) {
|
StuWithCoursesListVo lisco = new StuWithCoursesListVo();
|
Integer totalNu = 0;
|
Integer dedutNu = 0;
|
Integer remainNu = 0;
|
List<CoursePackageOrderStudent> byUserId = coursePackageOrderStudentService.list(new QueryWrapper<CoursePackageOrderStudent>()
|
.eq("appUserId", getStuOfCoursesDetails.getAppUserId())
|
.eq("studentId", getStuOfCoursesDetails.getStuId()));
|
if (byUserId.size() > 0) {
|
for (CoursePackageOrderStudent tCoursePackagePayment : byUserId) {
|
totalNu = totalNu + tCoursePackagePayment.getTotalClassHours();
|
dedutNu = dedutNu + tCoursePackagePayment.getLaveClassHours();
|
remainNu = remainNu + (tCoursePackagePayment.getTotalClassHours() - tCoursePackagePayment.getLaveClassHours());
|
}
|
lisco.setTotalNums(totalNu);
|
lisco.setDeductedNums(remainNu);
|
lisco.setRemainingNums(dedutNu);
|
}
|
return lisco;
|
}
|
|
@PostMapping("/base/coursePack/continuingCourse")
|
public StudentOfCourseVo getStudentCourse(@RequestBody GetStudentCourse getStudentCourse) {
|
StudentOfCourseVo courseVo = new StudentOfCourseVo();
|
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<>();
|
tCoursePackagePayments.forEach(cou -> {
|
CourseHoursType hoursType = new CourseHoursType();
|
hoursType.setCourseConfigId(cou.getId());
|
hoursType.setCourseHourNums(cou.getClassHours());
|
typeList.add(hoursType);
|
});
|
TCoursePackagePayment tCoursePackagePayment = tCoursePackagePayments.get(0);
|
courseVo.setCoursePackageId(tCoursePackagePayment.getCoursePackageId());
|
courseVo.setTypeList(typeList);
|
TCoursePackage coursePackage = tcpService.getById(tCoursePackagePayment.getCoursePackageId());
|
courseVo.setPackageImg(coursePackage.getCoverDrawing());
|
courseVo.setCourseName(coursePackage.getName());
|
courseVo.setCoachId(coursePackage.getCoachId());
|
String classWeeks = coursePackage.getClassWeeks();
|
List<Integer> integers = StrUtils.dealStrToList(classWeeks);
|
if (integers.size() > 0) {
|
StringBuilder courWeeks = new StringBuilder("每");
|
for (Integer integer : integers) {
|
courWeeks.append(integer).append("、");
|
}
|
if (courWeeks.length() > 0 && courWeeks.charAt(courWeeks.length() - 1) == '、') {
|
courWeeks.deleteCharAt(courWeeks.length() - 1);
|
}
|
courseVo.setCourseWeek(courWeeks.toString());
|
}
|
|
courseVo.setCourseTime(coursePackage.getClassStartTime() + "-" + coursePackage.getClassEndTime());
|
Integer payType = tCoursePackagePayment.getPayType();
|
BigDecimal cashPayment = tCoursePackagePayment.getCashPayment();
|
double cashPaymentValue = cashPayment.doubleValue();
|
Integer playPaiCoin = tCoursePackagePayment.getPlayPaiCoin();
|
TCoursePackageDiscount coursePackageDiscount = tcpdService.getOne(new QueryWrapper<TCoursePackageDiscount>()
|
.eq("coursePackageId", coursePackage.getId())
|
.eq("type", 1)
|
.eq("auditStatus", 2));
|
ObjectMapper objectMapper = new ObjectMapper();
|
String content = coursePackageDiscount.getContent();
|
double discountMember = 0.0;
|
DiscountJsonDto discountJsonDto = null;
|
try {
|
discountJsonDto = objectMapper.readValue(content, DiscountJsonDto.class);
|
discountMember = discountJsonDto.getDiscountMember();
|
} catch (JsonProcessingException e) {
|
throw new RuntimeException(e);
|
}
|
switch (payType) {
|
case 1:
|
case 2:
|
courseVo.setAmount(cashPaymentValue);
|
courseVo.setVipAmount(discountMember);
|
break;
|
case 3:
|
courseVo.setWpGold(playPaiCoin);
|
break;
|
}
|
courseVo.setStoreId(coursePackage.getStoreId());
|
}
|
|
return courseVo;
|
}
|
|
|
@PostMapping("/base/coursePack/afterCourseTwos")
|
public List<AfterVideoVo> getAfterCourseTwos(@RequestParam("appUserId") Integer appUserId) {
|
List<AfterVideoVo> videoVos = new ArrayList<>();
|
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));
|
|
|
List<CoursePackageOrder> list = coursePackageOrderService.list(new QueryWrapper<CoursePackageOrder>().eq("appUserId", appUserId).eq("payType", 3)
|
.eq("payStatus", 2)
|
.eq("state", 1));
|
|
|
if (list.size() > 0) {
|
for (CoursePackageOrder 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-开始上课"})
|
@ApiImplicitParams({
|
})
|
public ResultUtil<List<BaseVo>> queryArrangePackageType() {
|
try {
|
Integer appUserId = tokenUtil.getUserIdFormRedis();
|
if (null == appUserId) {
|
return ResultUtil.tokenErr();
|
}
|
List<TCoursePackagePayment> tCoursePackagePayments = packagePaymentService.list(new QueryWrapper<TCoursePackagePayment>()
|
.eq("appUserId", appUserId));
|
List<BaseVo> list = new ArrayList<>();
|
tCoursePackagePayments.forEach(c -> {
|
BaseVo baseVo = new BaseVo();
|
baseVo.setId(c.getCoursePackageId());
|
TCoursePackage coursePackage = tcpService.getById(c.getCoursePackageId());
|
baseVo.setName(coursePackage.getName());
|
list.add(baseVo);
|
});
|
|
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-开始上课"})
|
@ApiImplicitParams({
|
@ApiImplicitParam(name = "Authorization", value = "Bearer +token", required = true, dataType = "String", paramType = "header", defaultValue = "Bearer eyJhbGciOiJIUzUxMiJ9....."),
|
})
|
public ResultUtil<List<AppUserVideoResponse>> queryAfterSourceList(CourseOfAfterRequest search) throws Exception {
|
Integer appUserId = tokenUtil.getUserIdFormRedis();
|
|
if (null == appUserId) {
|
return ResultUtil.tokenErr();
|
}
|
QueryWrapper<CoursePackageStudent> queryWrapper1 = new QueryWrapper<CoursePackageStudent>().eq("studentId", search.getStuId());
|
if (ToolUtil.isNotEmpty(search.getCourseTypeId())) {
|
queryWrapper1.eq("coursePackageId", search.getCourseTypeId());
|
}
|
|
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<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);
|
}
|
|
/**
|
* 课后视频详情
|
*/
|
@ResponseBody
|
@PostMapping("/api/startCource/afterSourceDetail")
|
@ApiOperation(value = "课后练习-课后视频详情", tags = {"APP-开始上课"})
|
@ApiImplicitParams({
|
@ApiImplicitParam(name = "Authorization", value = "Bearer +token", required = true, dataType = "String", paramType = "header", defaultValue = "Bearer eyJhbGciOiJIUzUxMiJ9....."),
|
})
|
public ResultUtil<CourseOfVideoResponse> queryAfterSourceDetails(CourseWithDetailsRequest detailsRequest) {
|
try {
|
Integer appUserId = tokenUtil.getUserIdFormRedis();
|
if (null == appUserId) {
|
return ResultUtil.tokenErr();
|
}
|
return ResultUtil.success(packagePaymentService.queryVideoDetails(detailsRequest, appUserId));
|
} catch (Exception e) {
|
return ResultUtil.runErr();
|
}
|
}
|
|
@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();
|
}
|
}
|
|
/**
|
* 更新课后视频学习状态
|
*/
|
@ResponseBody
|
@PostMapping("/api/startCource/updateVideoStatus")
|
@ApiOperation(value = "更新课后视频学习状态", tags = {"APP-开始上课"})
|
@ApiImplicitParams({
|
@ApiImplicitParam(name = "Authorization", value = "Bearer +token", required = true, dataType = "String", paramType = "header", defaultValue = "Bearer eyJhbGciOiJIUzUxMiJ9....."),
|
})
|
public ResultUtil updateVideoStatus(UpdateCourseVideoStatusRequest detailsRequest) {
|
try {
|
Integer appUserId = tokenUtil.getUserIdFormRedis();
|
if (null == appUserId) {
|
return ResultUtil.tokenErr();
|
}
|
return ResultUtil.success(packagePaymentService.updateVideoStatus(detailsRequest, appUserId));
|
} catch (Exception e) {
|
return ResultUtil.runErr();
|
}
|
}
|
|
|
@ResponseBody
|
@PostMapping("/api/course/getCourseAppUserDetails")
|
@ApiOperation(value = "已报名课程-获取课程类型列表", tags = {"APP-课程列表"})
|
@ApiImplicitParams({
|
})
|
public ResultUtil<List<BaseVo>> queryCoursePackageType() {
|
try {
|
List<TCoursePackageType> coursePackageTypes = coursePackageTypeService.list(new QueryWrapper<TCoursePackageType>().eq("state", 1));
|
List<BaseVo> list = new ArrayList<>();
|
coursePackageTypes.forEach(c -> {
|
BaseVo baseVo = new BaseVo();
|
BeanUtils.copyProperties(c, baseVo);
|
list.add(baseVo);
|
});
|
return ResultUtil.success(list);
|
} catch (Exception e) {
|
e.printStackTrace();
|
return ResultUtil.runErr();
|
}
|
}
|
|
|
/**
|
* 已报名课程列表
|
*/
|
@ResponseBody
|
@PostMapping("/api/startCource/registeredCourses")
|
@ApiOperation(value = "已报名课程-课程列表", tags = {"APP-开始上课"})
|
@ApiImplicitParams({
|
@ApiImplicitParam(name = "Authorization", value = "Bearer +token", required = true, dataType = "String", paramType = "header", defaultValue = "Bearer eyJhbGciOiJIUzUxMiJ9....."),
|
})
|
public ResultUtil<List<RegisterCourseVo>> queryRegisteredCoursesDetails(CourseOfAfterRequest courseTypeId) {
|
try {
|
Integer appUserId = tokenUtil.getUserIdFormRedis();
|
if (null == appUserId) {
|
return ResultUtil.tokenErr();
|
}
|
return ResultUtil.success(coursePackageOrderService.queryRegisteredCourseList(courseTypeId, appUserId));
|
} catch (Exception e) {
|
return ResultUtil.runErr();
|
}
|
}
|
|
|
/**
|
* 已报名课程详情
|
*/
|
@ResponseBody
|
@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(Long coursePayId, String lon, String lat) {
|
try {
|
Integer appUserId = tokenUtil.getUserIdFormRedis();
|
if (null == appUserId) {
|
return ResultUtil.tokenErr();
|
}
|
CourseDetailsResponse courseDetailsResponse = packagePaymentService.queryRegisteredCourseDetails(coursePayId, appUserId, lon, lat);
|
|
//
|
// if (orderId != null) {
|
// TOrder byId = orderService.getById(orderId);
|
// courseDetailsResponse.setAmount(byId.getPrice());
|
// }
|
return ResultUtil.success(courseDetailsResponse);
|
} catch (Exception e) {
|
e.printStackTrace();
|
throw new RuntimeException(e.getMessage());
|
}
|
}
|
|
|
/**
|
* 已报名课程-支付
|
*/
|
@ResponseBody
|
@PostMapping("/api/startCource/payment")
|
@ApiOperation(value = "已报名课程-支付", tags = {"APP-开始上课"})
|
@ApiImplicitParams({
|
@ApiImplicitParam(name = "Authorization", value = "Bearer +token", required = true, dataType = "String", paramType = "header", defaultValue = "Bearer eyJhbGciOiJIUzUxMiJ9....."),
|
})
|
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) {
|
return ResultUtil.runErr();
|
}
|
|
}
|
|
|
/**
|
* 课包续课支付宝支付回调接口
|
*/
|
@PostMapping("/base/coursePackage/alipayRegisteredCoursesCallback")
|
public void alipayCallback(HttpServletRequest request, HttpServletResponse response) {
|
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 {
|
CoursePackageOrderStudent coursePackageOrderStudent = coursePackageOrderStudentService.getById(id);
|
return coursePackageOrderStudent.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) {
|
|
|
|
CoursePackageOrderStudent coursePackageOrderStudent = coursePackageOrderStudentService.getById(paymentDeductionClassHour.getCourseId());
|
// if (paymentDeductionClassHour.getClassHour() > coursePackageOrderStudent.getLaveClassHours()) {
|
// return ResultUtil.error("当前课包课时数不足");
|
// }
|
TCoursePackage coursePackage = coursePackageService.getById(coursePackageOrderStudent.getCoursePackageId());
|
coursePackageOrderStudent.setLaveClassHours(coursePackageOrderStudent.getLaveClassHours() - paymentDeductionClassHour.getClassHour());
|
coursePackageOrderStudentService.updateById(coursePackageOrderStudent);
|
//判断剩余课时是否已经全部进行排课，如果排课需要删除已经排好的记录
|
List<CoursePackageScheduling> list1 = coursePackageSchedulingService.list(new QueryWrapper<CoursePackageScheduling>()
|
.eq("studentId", coursePackageOrderStudent.getStudentId()).eq("status", 1)
|
.eq("type", 1).orderByDesc("classDate"));
|
//已经排课但没有使用的课时数量
|
int number = list1.size() * coursePackage.getNeedNum();
|
Integer laveClassHours1 = coursePackageOrderStudent.getLaveClassHours();
|
//需要删除多余的排课记录
|
if(number > laveClassHours1){
|
int n = number - laveClassHours1;
|
for (int i = 0; i < n; i++) {
|
CoursePackageScheduling coursePackageScheduling = list1.get(i);
|
coursePackageSchedulingService.getBaseMapper().deleteById(coursePackageScheduling.getId());
|
|
coursePackageStudentService.getBaseMapper().delete(new QueryWrapper<CoursePackageStudent>()
|
.eq("coursePackageSchedulingId", coursePackageScheduling.getId()));
|
}
|
}
|
|
|
|
|
|
|
// 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();
|
}
|
}
|
|
|
@Resource
|
private TCoursePackageMapper tcpmapper;
|
/**
|
* 找出符合门店的课包
|
*
|
* @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);
|
// }
|
// }
|
|
|
|
List<CoursePackageOrderStudent> tCoursePackagePayments = coursePackageOrderStudentService.list(new LambdaQueryWrapper<CoursePackageOrderStudent>().eq(CoursePackageOrderStudent::getAppUserId, integer));
|
// ArrayList<PayCourseRes> payCourseRes = new ArrayList<>();
|
for (CoursePackageOrderStudent tCoursePackagePayment : tCoursePackagePayments) {
|
TCoursePackage tCoursePackage = tcpmapper.selectById(tCoursePackagePayment.getCoursePackageId());
|
if (tCoursePackage.getType() != 1) {
|
continue;
|
}
|
if (storeIds.contains(tCoursePackage.getStoreId())) {
|
PayCourseRes payCourseRes = new PayCourseRes();
|
payCourseRes.setCourseNum(tCoursePackagePayment.getLaveClassHours());
|
payCourseRes.setId(tCoursePackagePayment.getId());
|
payCourseRes.setName(tCoursePackage.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, 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, coursePackagePaymentServiceOne.getId());
|
|
|
CourseCounsum courseCounsum = new CourseCounsum();
|
courseCounsum.setPaymentId(coursePackagePaymentServiceOne.getId());
|
courseCounsum.setChangeType(1);
|
courseCounsum.setNum(orderDto.getClassHours());
|
courseCounsum.setInsertTime(new Date());
|
courseCounsum.setReason("积分兑换");
|
courseCounsum.setInsertTime(new Date());
|
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]);
|
}
|
|
public Integer getGiftClassHours(TCoursePackageDiscount one,Date insertTime){
|
if (insertTime!=null){
|
// 判断购买时间 是否满足折扣规则
|
char c = one.getContent().charAt(0);
|
String value1 = String.valueOf(c);
|
JSONObject jsonObject ;
|
if (value1.equals("[")){
|
jsonObject = JSONObject.fromObject(one.getContent()
|
.substring(1,one.getContent().length() - 1));
|
}else{
|
jsonObject = JSONObject.fromObject(one.getContent());
|
}
|
// 赠送课时 判断当前课包有没有赠送课时
|
String weeks = jsonObject.getString("weeks");
|
Calendar calendar = Calendar.getInstance();
|
calendar.setTime(insertTime);
|
// 获取星期几，星期日是1，星期一是2，以此类推
|
int dayOfWeek = calendar.get(Calendar.DAY_OF_WEEK);
|
// 将星期日（Calendar定义为1）转换为7
|
if (dayOfWeek == Calendar.SUNDAY) {
|
dayOfWeek = 7;
|
} else {
|
// 其他星期减一即可得到1-6的数字表示
|
dayOfWeek -= 1;
|
}
|
if (weeks.contains(String.valueOf(dayOfWeek))){
|
// 限时折扣判断是否在有效期
|
try {
|
// 判断当日时间是否能享受到折扣
|
String startTime = jsonObject.getString("startTime");
|
String endTime = jsonObject.getString("endTime");
|
|
// 定义时间格式
|
SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss");
|
// 解析开始时间和结束时间为Date对象
|
Date startTime1 = sdf.parse(startTime);
|
Date endTime1 = sdf.parse(endTime);
|
Date date1 = new Date();
|
date1.setHours(startTime1.getHours());
|
date1.setMinutes(startTime1.getMinutes());
|
date1.setSeconds(startTime1.getSeconds());
|
Date date2 = new Date();
|
date2.setHours(endTime1.getHours());
|
date2.setMinutes(endTime1.getMinutes());
|
date2.setSeconds(endTime1.getSeconds());
|
// 检查当前时间是否在开始时间和结束时间之间
|
if (insertTime.after(date1) && insertTime.before(date2)) {
|
System.out.println("当前时间在开始时间和结束时间之间。");
|
String hour = jsonObject.getString("hour");
|
return Integer.valueOf(hour);
|
} else {
|
System.out.println("当前时间不在开始时间和结束时间之间。");
|
return 0;
|
}
|
} catch (ParseException e) {
|
e.printStackTrace();
|
}
|
}
|
}
|
// 判断购买时间 是否满足折扣规则
|
char c = one.getContent().charAt(0);
|
String value1 = String.valueOf(c);
|
JSONObject jsonObject ;
|
if (value1.equals("[")){
|
jsonObject = JSONObject.fromObject(one.getContent()
|
.substring(1,one.getContent().length() - 1));
|
}else{
|
jsonObject = JSONObject.fromObject(one.getContent());
|
}
|
// 赠送课时 判断当前课包有没有赠送课时
|
String weeks = jsonObject.getString("weeks");
|
// 判断当前周几 是否满足折扣规则
|
// 获取当前日期
|
LocalDate currentDate = LocalDate.now();
|
// 获取当前日期是星期几的数字表示
|
int dayOfWeekAsNumber = currentDate.getDayOfWeek().getValue();
|
if (weeks.contains(String.valueOf(dayOfWeekAsNumber))){
|
// 限时折扣判断是否在有效期
|
try {
|
// 判断当日时间是否能享受到折扣
|
String startTime = jsonObject.getString("startTime");
|
String endTime = jsonObject.getString("endTime");
|
// 获取当前时间
|
Date currentTime = new Date();
|
// 定义时间格式
|
SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss");
|
// 解析开始时间和结束时间为Date对象
|
Date startTime1 = sdf.parse(startTime);
|
Date endTime1 = sdf.parse(endTime);
|
Date date1 = new Date();
|
date1.setHours(startTime1.getHours());
|
date1.setMinutes(startTime1.getMinutes());
|
date1.setSeconds(startTime1.getSeconds());
|
Date date2 = new Date();
|
date2.setHours(endTime1.getHours());
|
date2.setMinutes(endTime1.getMinutes());
|
date2.setSeconds(endTime1.getSeconds());
|
// 检查当前时间是否在开始时间和结束时间之间
|
if (currentTime.after(date1) && currentTime.before(date2)) {
|
System.out.println("当前时间在开始时间和结束时间之间。");
|
String hour = jsonObject.getString("hour");
|
|
return Integer.valueOf(hour);
|
} else {
|
System.out.println("当前时间不在开始时间和结束时间之间。");
|
return 0;
|
}
|
} catch (ParseException e) {
|
e.printStackTrace();
|
}
|
}
|
return 0;
|
}
|
|
@Autowired
|
private TCoursePackageService coursePackageService;
|
|
private void addPackageStudent1(TCoursePackage tCoursePackage, Integer userId, Integer sId, CoursePackageOrder coursePackageOrder, CoursePackageOrderStudent coursePackageOrderStudent) {
|
try {
|
//1常规 2假期 3体验
|
if (tCoursePackage.getType() == 1) {
|
//上课星期
|
String classWeeks = tCoursePackage.getClassWeeks();
|
List<Integer> week = week(classWeeks);
|
//上课时段
|
String[] split = tCoursePackage.getClassStartTime().split(",");
|
String[] split1 = tCoursePackage.getClassEndTime().split(",");
|
SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
|
SimpleDateFormat format1 = new SimpleDateFormat("yyyy-MM-dd HH:mm");
|
//剩余课时
|
Integer laveClassHours = coursePackageOrderStudent.getLaveClassHours();
|
//扣除课时数
|
Integer codeTime = tCoursePackage.getCodeTime();
|
//排课 本周+下周，课时不够扣则直接剩余不排课
|
Calendar calendar = Calendar.getInstance();
|
calendar.setTime(new Date());
|
calendar.set(Calendar.DAY_OF_YEAR, calendar.get(Calendar.DAY_OF_YEAR) + 1);
|
calendar.set(Calendar.HOUR_OF_DAY, 0);
|
calendar.set(Calendar.MINUTE, 0);
|
calendar.set(Calendar.SECOND, 0);
|
int day_week = calendar.get(Calendar.DAY_OF_WEEK);
|
day_week = day_week - 1 == 0 ? 7 : day_week - 1;
|
int num = 8 - day_week + 7;
|
Date useTime = coursePackageOrderStudent.getUseTime();
|
|
for (int i = 0; i < num; i++) {
|
Date time = calendar.getTime();
|
|
//判断当天是否在排课星期内
|
int day = calendar.get(Calendar.DAY_OF_WEEK);
|
day = day - 1 == 0 ? 7 : day - 1;
|
if (!week.contains(day)) {
|
calendar.set(Calendar.DAY_OF_YEAR, calendar.get(Calendar.DAY_OF_YEAR) + 1);
|
continue;
|
}
|
|
|
//大于有效期不进行排课
|
if (calendar.getTimeInMillis() >= useTime.getTime()) {
|
break;
|
}
|
for (int j = 0; j < split.length; j++) {
|
//剩余数量不足以排课
|
if (laveClassHours.compareTo(codeTime) < 0) {
|
break;
|
}
|
|
laveClassHours -= codeTime;
|
|
CoursePackageScheduling coursePackageScheduling = new CoursePackageScheduling();
|
coursePackageScheduling.setType(tCoursePackage.getType());
|
coursePackageScheduling.setAppUserId(userId);
|
coursePackageScheduling.setStudentId(sId);
|
coursePackageScheduling.setCoursePackageId(tCoursePackage.getId());
|
Date parse = format1.parse(format.format(time) + " " + split[j]);
|
Date parse1 = format1.parse(format.format(time) + " " + split1[j]);
|
coursePackageScheduling.setClassDate(parse);
|
coursePackageScheduling.setEndDate(parse1);
|
coursePackageScheduling.setStatus(1);
|
coursePackageSchedulingService.save(coursePackageScheduling);
|
CoursePackageStudent student1 = new CoursePackageStudent();
|
student1.setAppUserId(userId);
|
student1.setStudentId(sId);
|
student1.setCoursePackageId(tCoursePackage.getId());
|
student1.setCoursePackagePaymentId(coursePackageOrderStudent.getId());
|
student1.setCoursePackageSchedulingId(coursePackageScheduling.getId());
|
student1.setSignInOrNot(1);
|
student1.setReservationStatus(1);
|
student1.setInsertTime(new Date());
|
cpsMapper.insert(student1);
|
}
|
//增加日期，用于判断
|
calendar.set(Calendar.DAY_OF_YEAR, calendar.get(Calendar.DAY_OF_YEAR) + 1);
|
}
|
}
|
|
if (tCoursePackage.getType() == 2) {
|
//上课星期
|
String classWeeks = tCoursePackage.getClassWeeks();
|
List<Integer> week = week(classWeeks);
|
//上课时段
|
String[] split = tCoursePackage.getClassStartTime().split(",");
|
String[] split1 = tCoursePackage.getClassEndTime().split(",");
|
SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
|
SimpleDateFormat format1 = new SimpleDateFormat("yyyy-MM-dd HH:mm");
|
|
Date startTime = tCoursePackage.getStartTime();
|
Date endTime = tCoursePackage.getEndTime();
|
//排课 本周+下周，课时不够扣则直接剩余不排课
|
Calendar calendar = Calendar.getInstance();
|
//假期开始使用当前时间为起始时间进行排课
|
calendar.setTime(startTime.getTime() > System.currentTimeMillis() ? startTime : new Date());
|
calendar.set(Calendar.DAY_OF_YEAR, calendar.get(Calendar.DAY_OF_YEAR) + 1);
|
while (true) {
|
Date time = calendar.getTime();
|
|
//判断当天是否在排课星期内
|
int day = calendar.get(Calendar.DAY_OF_WEEK);
|
day = day - 1 == 0 ? 7 : day - 1;
|
if (!week.contains(day)) {
|
calendar.set(Calendar.DAY_OF_YEAR, calendar.get(Calendar.DAY_OF_YEAR) + 1);
|
continue;
|
}
|
|
//大于有效期不进行排课
|
if (calendar.getTimeInMillis() > endTime.getTime()) {
|
break;
|
}
|
for (int j = 0; j < split.length; j++) {
|
CoursePackageScheduling coursePackageScheduling = new CoursePackageScheduling();
|
coursePackageScheduling.setType(tCoursePackage.getType());
|
coursePackageScheduling.setAppUserId(userId);
|
coursePackageScheduling.setStudentId(sId);
|
coursePackageScheduling.setCoursePackageId(tCoursePackage.getId());
|
Date parse = format1.parse(format.format(time) + " " + split[j]);
|
Date parse1 = format1.parse(format.format(time) + " " + split1[j]);
|
coursePackageScheduling.setClassDate(parse);
|
coursePackageScheduling.setEndDate(parse1);
|
coursePackageScheduling.setStatus(1);
|
coursePackageSchedulingService.save(coursePackageScheduling);
|
CoursePackageStudent student1 = new CoursePackageStudent();
|
student1.setAppUserId(userId);
|
student1.setStudentId(sId);
|
student1.setCoursePackageId(tCoursePackage.getId());
|
student1.setCoursePackagePaymentId(null);
|
student1.setCoursePackageSchedulingId(coursePackageScheduling.getId());
|
student1.setSignInOrNot(1);
|
student1.setReservationStatus(1);
|
student1.setInsertTime(new Date());
|
cpsMapper.insert(student1);
|
}
|
//增加日期，用于判断
|
calendar.set(Calendar.DAY_OF_YEAR, calendar.get(Calendar.DAY_OF_YEAR) + 1);
|
}
|
}
|
} catch (Exception e) {
|
e.printStackTrace();
|
}
|
}
|
private void addPackageStudent(Integer courseId, Integer userId, Integer sId, TCoursePackagePayment coursePackagePayment, 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 coursePackageOrderStudentService.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/queryCoursePackagePaymentById1")
|
public CoursePackageOrderStudent queryCoursePackagePaymentById1(@RequestParam("id") Long id) {
|
return coursePackageOrderStudentService.getById(id);
|
}
|
|
|
// @Autowired
|
// private ICoursePackageOrderStudentService orderStudentService;
|
|
|
@ResponseBody
|
@PostMapping("/coursePackagePayment/consumeCourse")
|
public Integer consumeCourse(@RequestBody Integer coursePackagePaymentId) {
|
CoursePackageOrderStudent coursePackageOrderStudent = orderStudentService.getById(coursePackagePaymentId);
|
|
TCoursePackage coursePackage = coursePackageService.getById(coursePackageOrderStudent.getCoursePackageId());
|
|
if (coursePackageOrderStudent.getLaveClassHours()<coursePackage.getNeedNum()){
|
return 1;
|
}
|
coursePackageOrderStudent.setLaveClassHours(coursePackageOrderStudent.getLaveClassHours()-coursePackage.getNeedNum());
|
orderStudentService.updateById(coursePackageOrderStudent);
|
CourseCounsum courseCounsum = new CourseCounsum();
|
courseCounsum.setPaymentId(coursePackageOrderStudent.getId());
|
courseCounsum.setChangeType(0);
|
courseCounsum.setNum(coursePackage.getNeedNum());
|
courseCounsum.setInsertTime(new Date());
|
courseCounsum.setReason("补课");
|
courseCounsumService.save(courseCounsum);
|
return 2;
|
}
|
|
|
@ResponseBody
|
@PostMapping("/coursePackagePayment/CountqueryByClassId")
|
public Integer CountqueryByClassId(@RequestBody Integer id) {
|
int coursePackageId = coursePackageOrderStudentService.count(new QueryWrapper<CoursePackageOrderStudent>().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("/coursePackagePayment/editCoursePackagePayment2")
|
public void editCoursePackagePayment2(@RequestBody CoursePackageOrderStudent coursePackageOrderStudent) {
|
System.out.println("editCoursePackagePayment1====coursePackagePayment" + coursePackageOrderStudent);
|
// coursePackagePayment.setCoursePackageId(null);
|
// packagePaymentService.updateBytime(coursePackagePayment);
|
|
coursePackageOrderStudentService.updateById(coursePackageOrderStudent);
|
}
|
|
|
/**
|
* 上课主页-预约操作
|
*/
|
@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<CoursePackageOrderStudent> packagePayment = coursePackageOrderStudentService.list(new QueryWrapper<CoursePackageOrderStudent>()
|
.eq("coursePackageId", courseID)
|
.eq("appUserId", appUserId)
|
.eq("studentId", 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(CoursePackageOrderStudent::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")
|
public HashMap<String, Object> weeksOfCourseDetailsList(@RequestBody CourseDetailReq courseDetailReq) {
|
HashMap<String, Object> map = new HashMap<>();
|
ArrayList<DetailsListVo> objects = new ArrayList<>();
|
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);
|
// 找出门店的所有课程 排出体验
|
List<TCoursePackage> list = tcpService.list(new LambdaQueryWrapper<TCoursePackage>()
|
.eq(TCoursePackage::getStoreId, courseDetailReq.getStoreId()).ne(TCoursePackage::getType, 3)
|
.eq(TCoursePackage::getState, 1).like(TCoursePackage::getClassWeeks, week));
|
List<Integer> collect = list.stream().map(TCoursePackage::getId).collect(Collectors.toList());
|
if (collect.size() == 0) {
|
collect.add(-1);
|
}
|
|
List<CoursePackageScheduling> list8 = coursePackageSchedulingMapper.selectList(new LambdaQueryWrapper<CoursePackageScheduling>()
|
.eq(CoursePackageScheduling::getAppUserId, courseDetailReq.getAppUserId())
|
.eq(CoursePackageScheduling::getStudentId, courseDetailReq.getStuId())
|
.in(CoursePackageScheduling::getCoursePackageId, collect)
|
);
|
List<Integer> collect1 = list8.stream().map(CoursePackageScheduling::getCoursePackageId).collect(Collectors.toList());
|
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.isEmpty()) {
|
detailsListVo.setType(2);
|
objects.add(detailsListVo);
|
continue;
|
}
|
//排课的ids
|
List<Long> collect2 = list3.stream().map(CoursePackageScheduling::getId).collect(Collectors.toList());
|
if (collect2.isEmpty()){
|
collect2.add(-1l);
|
}
|
|
|
List<CoursePackageStudent> list4 = cspsService.list(new LambdaQueryWrapper<CoursePackageStudent>()
|
.eq(CoursePackageStudent::getAppUserId, courseDetailReq.getAppUserId())
|
.eq(CoursePackageStudent::getStudentId, courseDetailReq.getStuId())
|
.eq(CoursePackageStudent::getCoursePackageId, tCoursePackage.getId())
|
.in(CoursePackageStudent::getCoursePackageSchedulingId, collect2)
|
);
|
|
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) {
|
CoursePackageScheduling coursePackageScheduling = coursePackageSchedulingMapper.selectById(coursePackageStudent.getCoursePackageSchedulingId());
|
if (coursePackageScheduling.getStatus()==4){
|
detailsListVo.setIsType(3);
|
}
|
|
Integer signInOrNot1 = coursePackageStudent.getSignInOrNot();
|
detailsListVo.setType(1);
|
|
if (signInOrNot1 == 2) {
|
detailsListVo.setType(3);
|
}
|
//体验购课去掉按钮
|
if(coursePackageScheduling.getType() == 3){
|
detailsListVo.setCourseType(3);
|
detailsListVo.setType(2);
|
}
|
|
|
detailsListVo.setIsType(coursePackageStudent.getType());
|
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);
|
|
}
|
}
|
map.put("data", objects);
|
|
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.getType());
|
// }
|
// }
|
// }
|
|
|
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 (null != tCoursePackagePayment.getType() && 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;
|
|
}
|
|
|
@ResponseBody
|
@PostMapping("/coursePackagePayment/queryPaymentCoursePackage")
|
public List<Integer> queryPaymentCoursePackage(@RequestBody List<Integer> storeIds){
|
if(storeIds.size() == 0){
|
return new ArrayList<>();
|
}
|
List<TCoursePackage> list = coursePackageService.list(new QueryWrapper<TCoursePackage>().eq("auditStatus", 2)
|
.ne("status", 4).eq("state", 1).in("storeId", storeIds));
|
List<Integer> collect = list.stream().map(TCoursePackage::getId).collect(Collectors.toList());
|
if(collect.size() == 0){
|
return new ArrayList<>();
|
}
|
List<CoursePackageOrder> list1 = coursePackageOrderService.list(new QueryWrapper<CoursePackageOrder>().in("coursePackageId", collect).eq("payStatus", 2).eq("status", 1));
|
return list1.stream().map(CoursePackageOrder::getAppUserId).collect(Collectors.toList());
|
}
|
}
|
