package com.dsh.course.controller;
|
|
|
import cn.mb.cloud.common.data.controller.BaseController;
|
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.dto.SelectDto;
|
import com.dsh.course.feignclient.model.ExerciseVideo;
|
import com.dsh.course.model.*;
|
import com.dsh.course.model.dto.CourseChangeStateDTO;
|
import com.dsh.course.model.dto.TQueryBenefitsVideosDTO;
|
import com.dsh.course.model.vo.TQueryBenefitsVideosVO;
|
import com.dsh.course.service.*;
|
import com.dsh.course.util.*;
|
import io.swagger.annotations.Api;
|
import io.swagger.annotations.ApiImplicitParam;
|
import io.swagger.annotations.ApiImplicitParams;
|
import io.swagger.annotations.ApiOperation;
|
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 javax.servlet.http.HttpServletRequest;
|
import javax.servlet.http.HttpServletResponse;
|
import java.io.PrintWriter;
|
import java.math.BigDecimal;
|
import java.util.*;
|
import java.util.stream.Collectors;
|
|
@Api
|
@CrossOrigin
|
@RestController
|
@RequestMapping("")
|
public class CourseController extends BaseController {
|
|
private Logger logger = LoggerFactory.getLogger("business-log");
|
|
@Autowired
|
private TCourseService courseService;
|
|
@Autowired
|
private TCoursePackageService coursePackageService;
|
|
@Autowired
|
private TokenUtil tokenUtil;
|
|
@Autowired
|
private TCoursePackageTypeService coursePackageTypeService;
|
|
@Autowired
|
private PayMoneyUtil payMoneyUtil;
|
|
@Autowired
|
private TCoursePackagePaymentService coursePackagePaymentService;
|
|
@Autowired
|
private TCoursePackageDiscountService discountService;
|
@Autowired
|
private ICoursePackagePaymentConfigService coursePackagePaymentConfigService;
|
|
@Autowired
|
private ICoursePackageOrderService coursePackageOrderService;
|
|
/**
|
* 上/下架 1为上架 2为下架 3为删除
|
*
|
* @return
|
*/
|
@RequestMapping("/base/course/changeState")
|
@ResponseBody
|
public Object changeState(@RequestBody CourseChangeStateDTO dto) {
|
return courseService.changeState(dto);
|
}
|
|
/**
|
* 通过课程ids获取课程
|
*
|
* @return
|
*/
|
@RequestMapping("/base/course/getCourseByCourseIds")
|
public List<TQueryBenefitsVideosVO> getCourseByCourseIds(@RequestBody TQueryBenefitsVideosDTO query) {
|
|
return courseService.getCourseByCourseIds(query);
|
}
|
|
@PostMapping("/base/course/queryList")
|
public List<ExerciseVideo> queryStuCourseAfterVideos(@RequestBody List<Integer> courseIds) {
|
List<ExerciseVideo> videos = new ArrayList<>();
|
List<TCourse> list = courseService.list(new QueryWrapper<TCourse>()
|
.in("id", courseIds)
|
.eq("state", 1));
|
if (list.size() > 0) {
|
list.forEach(vs -> {
|
ExerciseVideo video = new ExerciseVideo();
|
video.setVideoUrl(vs.getCourseVideo());
|
video.setVideoName(vs.getName());
|
video.setVideoCoverImgUrl(vs.getCoverDrawing());
|
videos.add(video);
|
});
|
}
|
return videos;
|
}
|
|
|
@ResponseBody
|
@PostMapping("/api/course/queryCoursePackageType")
|
@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/course/queryCourseList")
|
@ApiOperation(value = "获取课程列表", tags = {"APP-课程列表"})
|
@ApiImplicitParams({
|
@ApiImplicitParam(name = "Authorization", value = "用户token（Bearer +token）", required = true, dataType = "String", paramType = "header", defaultValue = "Bearer eyJhbGciOiJIUzUxMiJ9.....")
|
})
|
public ResultUtil<List<CoursePackageListVo>> queryCourseList(CoursePackageList coursePackageList) {
|
try {
|
Integer uid = tokenUtil.getUserIdFormRedis();
|
if (null == uid) {
|
return ResultUtil.tokenErr();
|
}
|
List<CoursePackageListVo> coursePackageListVos = coursePackageService.queryCourseList(uid, coursePackageList);
|
return ResultUtil.success(coursePackageListVos);
|
} catch (Exception e) {
|
e.printStackTrace();
|
return ResultUtil.runErr();
|
}
|
}
|
|
|
@ResponseBody
|
@PostMapping("/base/course/queryCourseListOne")
|
@ApiOperation(value = "获取课程列表", tags = {"APP-课程列表"})
|
@ApiImplicitParams({
|
@ApiImplicitParam(name = "Authorization", value = "用户token（Bearer +token）", required = true, dataType = "String", paramType = "header", defaultValue = "Bearer eyJhbGciOiJIUzUxMiJ9.....")
|
})
|
public ResultUtil<List<CoursePackageListVo>> queryCourseListOne(CoursePackageList coursePackageList) {
|
try {
|
List<CoursePackageListVo> coursePackageListVos = coursePackageService.queryCourseListOne(coursePackageList);
|
return ResultUtil.success(coursePackageListVos);
|
} catch (Exception e) {
|
e.printStackTrace();
|
return ResultUtil.runErr();
|
}
|
}
|
|
|
@ResponseBody
|
@PostMapping("/api/course/queryCourseInfo")
|
@ApiOperation(value = "获取课程详情", tags = {"APP-课程列表"})
|
@ApiImplicitParams({
|
@ApiImplicitParam(value = "课包id", name = "id", dataType = "int", required = true),
|
@ApiImplicitParam(value = "经度", name = "lon", dataType = "string", required = false),
|
@ApiImplicitParam(value = "纬度", name = "lat", dataType = "string", required = false),
|
@ApiImplicitParam(value = "学员id", name = "stuId", dataType = "int", required = false),
|
@ApiImplicitParam(name = "Authorization", value = "用户token（Bearer +token）", required = true, dataType = "String", paramType = "header", defaultValue = "Bearer eyJhbGciOiJIUzUxMiJ9.....")
|
})
|
public ResultUtil<CoursePackageInfo> queryCourseInfo(Integer id, String lon, String lat, Integer stuId) {
|
try {
|
Integer uid = tokenUtil.getUserIdFormRedis();
|
if (null == uid) {
|
return ResultUtil.tokenErr();
|
}
|
CoursePackageInfo coursePackageInfo = coursePackageService.queryCourseInfo(uid, id, lon, lat, stuId);
|
return ResultUtil.success(coursePackageInfo);
|
} catch (Exception e) {
|
e.printStackTrace();
|
return ResultUtil.runErr();
|
}
|
}
|
|
|
@ResponseBody
|
@PostMapping("/api/course/paymentCourse")
|
@ApiOperation(value = "支付课程", tags = {"APP-课程列表"})
|
@ApiImplicitParams({
|
@ApiImplicitParam(name = "Authorization", value = "用户token（Bearer +token）", required = true, dataType = "String", paramType = "header", defaultValue = "Bearer eyJhbGciOiJIUzUxMiJ9.....")
|
})
|
public synchronized ResultUtil paymentCourse(PaymentCourseVo paymentCourseVo) {
|
try {
|
Integer uid = tokenUtil.getUserIdFormRedis();
|
if (null == uid) {
|
return ResultUtil.tokenErr();
|
}
|
Long couponId = paymentCourseVo.getCouponId();
|
if (couponId == null || couponId == 0) {
|
paymentCourseVo.setCouponId(null);
|
}
|
return coursePackageService.paymentCourse(uid, paymentCourseVo);
|
} catch (Exception e) {
|
e.printStackTrace();
|
return ResultUtil.runErr();
|
}
|
}
|
|
// 2.0
|
@ResponseBody
|
@PostMapping("/api/course/paymentCourseCouponList")
|
@ApiOperation(value = "支付课程--完成后优惠券列表", tags = {"APP-课程列表"})
|
@ApiImplicitParams({
|
@ApiImplicitParam(name = "Authorization", value = "用户token（Bearer +token）", required = true, dataType = "String", paramType = "header", defaultValue = "Bearer eyJhbGciOiJIUzUxMiJ9.....")
|
})
|
public ResultUtil paymentCourseCouponList(Integer coursePackagePaymentConfigId) {
|
try {
|
Integer uid = tokenUtil.getUserIdFormRedis();
|
if (null == uid) {
|
return ResultUtil.tokenErr();
|
}
|
return coursePackageService.paymentCourseCouponList(uid, coursePackagePaymentConfigId);
|
} catch (Exception e) {
|
e.printStackTrace();
|
return ResultUtil.runErr();
|
}
|
}
|
|
/**
|
* 购买课程微信支付回调
|
*
|
* @param request
|
* @param response
|
*/
|
@ResponseBody
|
@PostMapping("/base/course/weChatPaymentCourseCallback")
|
public void weChatPaymentCourseCallback(HttpServletRequest request, HttpServletResponse response) {
|
try {
|
Map<String, String> map = payMoneyUtil.weixinpayCallback(request);
|
if (null != map) {
|
String code = map.get("out_trade_no");
|
String transaction_id = map.get("transaction_id");
|
String attach = map.get("attach");
|
String result = map.get("result");
|
|
ResultUtil resultUtil = coursePackageService.paymentCourseCallback(code, transaction_id, attach);
|
if (resultUtil.getCode() == 200) {
|
PrintWriter out = response.getWriter();
|
out.write(result);
|
out.flush();
|
out.close();
|
}
|
}
|
} catch (Exception e) {
|
e.printStackTrace();
|
}
|
}
|
|
|
/**
|
* 购买课程支付宝回调
|
*
|
* @param request
|
* @param response
|
*/
|
@ResponseBody
|
@PostMapping("/base/course/aliPaymentCourseCallback")
|
public void aliPaymentCourseCallback(HttpServletRequest request, HttpServletResponse response) {
|
try {
|
Map<String, String> map = payMoneyUtil.alipayCallback(request);
|
if (null != map) {
|
String code = map.get("out_trade_no");
|
String trade_no = map.get("trade_no");
|
String passback_params = map.get("passback_params");
|
ResultUtil resultUtil = coursePackageService.paymentCourseCallback(code, trade_no, passback_params);
|
if (resultUtil.getCode() == 200) {
|
PrintWriter out = response.getWriter();
|
out.write("success");
|
out.flush();
|
out.close();
|
}
|
}
|
} catch (Exception e) {
|
e.printStackTrace();
|
}
|
}
|
|
/**
|
* 根据id获取课程数据
|
*
|
* @param id
|
* @return
|
*/
|
@ResponseBody
|
@PostMapping("/course/queryCourseById")
|
public TCourse queryCourseById(@RequestBody Integer id) {
|
try {
|
return courseService.getById(id);
|
} catch (Exception e) {
|
e.printStackTrace();
|
return null;
|
}
|
}
|
|
|
/**
|
* 根据名称获取数据
|
*
|
* @param name
|
* @return
|
*/
|
@ResponseBody
|
@PostMapping("/course/queryCourseByName")
|
public List<TCourse> queryCourseByName(@RequestBody String name) {
|
try {
|
return courseService.list(new QueryWrapper<TCourse>().like("name", name).eq("state", 1));
|
} catch (Exception e) {
|
e.printStackTrace();
|
return null;
|
}
|
}
|
|
|
@PostMapping("/course/getPageageType")
|
public List<Map<String, Object>> getPageageType() {
|
List<TCoursePackageType> list = coursePackageTypeService.list(new LambdaQueryWrapper<TCoursePackageType>().eq(TCoursePackageType::getState, 1));
|
ArrayList<Map<String, Object>> objects = new ArrayList<>();
|
for (TCoursePackageType tCoursePackageType : list) {
|
HashMap<String, Object> map = new HashMap<>();
|
map.put("id", tCoursePackageType.getId());
|
map.put("name", tCoursePackageType.getName());
|
objects.add(map);
|
}
|
return objects;
|
}
|
|
|
/**
|
* 获取课程管理列表数据
|
*
|
* @param queryCourseList
|
* @return
|
*/
|
@ResponseBody
|
@PostMapping("/course/queryCourseLists")
|
public Page<Map<String, Object>> queryCourseLists(@RequestBody QueryCourseList queryCourseList) {
|
Page<Map<String, Object>> page = new PageFactory<Map<String, Object>>().defaultPage(queryCourseList.getLimit(), queryCourseList.getOffset(), queryCourseList.getSort(), queryCourseList.getOrder());
|
Page<Map<String, Object>> mapPage = page.setRecords(courseService.queryCourseList(page, queryCourseList));
|
return mapPage;
|
}
|
|
|
/**
|
* 添加课程
|
*
|
* @param course
|
*/
|
@ResponseBody
|
@PostMapping("/course/addCourse")
|
public void addCourse(@RequestBody TCourse course) {
|
course.setState(1);
|
course.setInsertTime(new Date());
|
courseService.save(course);
|
}
|
|
|
/**
|
* 编辑数据
|
*
|
* @param course
|
*/
|
@ResponseBody
|
@PostMapping("/course/editCourse")
|
public void editCourse(@RequestBody TCourse course) {
|
courseService.updateById(course);
|
}
|
|
|
/**
|
* 删除数据
|
*
|
* @param id
|
*/
|
@ResponseBody
|
@PostMapping("/course/delCourseById")
|
public void delCourseById(@RequestBody Integer id) {
|
TCourse course = courseService.getById(id);
|
if (null != course) {
|
course.setState(3);
|
courseService.updateById(course);
|
}
|
}
|
|
|
/**
|
* 编辑数据状态
|
*
|
* @param editCourseState
|
*/
|
@ResponseBody
|
@PostMapping("/course/editCourseState")
|
public void editCourseState(@RequestBody EditCourseState editCourseState) {
|
TCourse course = courseService.getById(editCourseState.getId());
|
if (null != course) {
|
course.setState(editCourseState.getState());
|
courseService.updateById(course);
|
}
|
}
|
|
|
/**
|
* 根据类型获取数据
|
*
|
* @param type
|
* @return
|
*/
|
@ResponseBody
|
@PostMapping("/course/queryCourseByType")
|
public List<TCourse> queryCourseByType(@RequestBody Integer type) {
|
return courseService.list(new QueryWrapper<TCourse>().eq("type", type).eq("state", 1));
|
}
|
|
|
@PostMapping("/course/queryPackageById")
|
public List<String> queryPackageById(@RequestBody Integer coursePackageId) {
|
ArrayList<String> strings = new ArrayList<>();
|
TCoursePackage byId = coursePackageService.getById(coursePackageId);
|
Integer coursePackageTypeId = byId.getCoursePackageTypeId();
|
strings.add(coursePackageTypeService.getById(coursePackageTypeId).getName());
|
strings.add(byId.getName());
|
|
return strings;
|
|
}
|
|
// 获取课包商品的价格配置
|
@PostMapping("/course/getHoursByPackageId")
|
@ResponseBody
|
public List<CoursePackagePaymentConfig> getHoursByPackageId(@RequestBody Integer coursePackageId1) {
|
List<CoursePackagePaymentConfig> coursePackageId = coursePackagePaymentConfigService.list(new QueryWrapper<CoursePackagePaymentConfig>()
|
.eq("coursePackageId", coursePackageId1));
|
return coursePackageId;
|
}
|
|
@PostMapping("/course/getHours")
|
public List<Integer> getHours(@RequestBody Integer coursePackageId1) {
|
return coursePackageService.getHours(coursePackageId1);
|
}
|
|
@PostMapping("/course/queryByDiscountId")
|
public TCoursePackage queryByDiscountId(@RequestBody Integer id) {
|
TCoursePackageDiscount byId = discountService.getById(id);
|
TCoursePackage byId1 = coursePackageService.getById(byId.getCoursePackageId());
|
return byId1;
|
}
|
|
@ResponseBody
|
@PostMapping("/course/queryByDiscountId1")
|
public TCoursePackage queryByDiscountId1(@RequestBody Integer id) {
|
TCoursePackageDiscount byId = discountService.getById(id);
|
TCoursePackage byId1 = coursePackageService.getById(byId.getCoursePackageId());
|
return byId1;
|
}
|
|
|
@PostMapping("/course/queryDiscountById")
|
public Integer queryDiscountById(@RequestBody Integer id) {
|
TCoursePackageDiscount byId = discountService.getById(id);
|
return byId.getAuditStatus();
|
}
|
|
@PostMapping("/course/queryDiscountList")
|
public List<DiscountList> queryDiscountList(@RequestBody QueryDiscountList queryDiscountList) {
|
return discountService.queryDiscountList(queryDiscountList);
|
}
|
|
@PostMapping("/course/queryDiscountListAudit")
|
public List<DiscountList> queryDiscountListAudit(@RequestBody QueryDiscountList queryDiscountList) {
|
return discountService.queryDiscountListAudit(queryDiscountList);
|
}
|
|
|
@PostMapping("/course/updateState")
|
public Boolean updateState(@RequestBody DiscountUpdateState discountUpdateState) {
|
TCoursePackageDiscount byId = discountService.getById(discountUpdateState.getId());
|
List<TCoursePackageDiscount> list = discountService.list(new LambdaQueryWrapper<TCoursePackageDiscount>().eq(TCoursePackageDiscount::getCoursePackageId, byId.getCoursePackageId()));
|
list.forEach(e -> e.setStatus(discountUpdateState.getStatus()));
|
return discountService.updateBatchById(list);
|
}
|
|
|
@PostMapping("/course/auditDiscount")
|
public Boolean auditDiscount(@RequestBody AuditDiscount auditDiscount) {
|
List<TCoursePackageDiscount> list = discountService.list(new LambdaQueryWrapper<TCoursePackageDiscount>()
|
.eq(TCoursePackageDiscount::getCoursePackageId, auditDiscount.getId()));
|
for (TCoursePackageDiscount tCoursePackageDiscount : list) {
|
tCoursePackageDiscount.setAuditStatus(auditDiscount.getType());
|
tCoursePackageDiscount.setAuditRemark(auditDiscount.getText());
|
}
|
return discountService.updateBatchById(list);
|
}
|
|
@Autowired
|
private ICoursePackagePaymentConfigService packagePaymentConfigService;
|
|
@PostMapping("/course/times")
|
public List<SelectDto> times(@RequestBody Integer oneId) {
|
List<CoursePackagePaymentConfig> list = packagePaymentConfigService.list(new QueryWrapper<CoursePackagePaymentConfig>().eq("coursePackageId", oneId));
|
List<SelectDto> integerList = new ArrayList<>();
|
for (CoursePackagePaymentConfig coursePackagePaymentConfig : list) {
|
// integerList.add(coursePackagePaymentConfig.getClassHours());
|
SelectDto selectDto = new SelectDto();
|
selectDto.setId(coursePackagePaymentConfig.getId());
|
selectDto.setValue(String.valueOf(coursePackagePaymentConfig.getClassHours()));
|
integerList.add(selectDto);
|
}
|
return integerList;
|
}
|
|
@PostMapping("/course/queryFee")
|
public HashMap<String, Object> queryFee(@RequestBody QueryDataFee queryDataFee) {
|
HashMap<String, Object> map = new HashMap<>();
|
String data = queryDataFee.getData();
|
List<Integer> ids = queryDataFee.getIds();
|
if (ids.size() == 0) {
|
ids.add(-1);
|
}else{
|
List<TCoursePackage> list = coursePackageService.list(new QueryWrapper<TCoursePackage>().in("storeId", ids)
|
.ne("status", 4).eq("auditStatus", 2).eq("state", 1));
|
ids = list.stream().map(TCoursePackage::getId).collect(Collectors.toList());
|
if(ids.size() == 0){
|
ids.add(-1);
|
}
|
}
|
|
LambdaQueryWrapper<CoursePackageOrder> wrapper = new LambdaQueryWrapper<>();
|
if (ToolUtil.isNotEmpty(data)) {
|
String stime = data.split(" - ")[0] + " 00:00:00";
|
String etime = data.split(" - ")[1] + " 23:59:59";
|
wrapper.between(CoursePackageOrder::getInsertTime, stime, etime);
|
}
|
wrapper.in(CoursePackageOrder::getCoursePackageId, ids);
|
wrapper.eq(CoursePackageOrder::getPayStatus, 2);
|
ArrayList<Integer> objects = new ArrayList<>();
|
objects.add(1);
|
objects.add(2);
|
objects.add(5);
|
objects.add(6);
|
wrapper.in(CoursePackageOrder::getPayType, objects);
|
List<CoursePackageOrder> list = coursePackageOrderService.list(wrapper);
|
double v = list.stream().map(CoursePackageOrder::getCashPayment).reduce(BigDecimal.ZERO, BigDecimal::add).doubleValue();
|
List<Integer> collect = list.stream().map(CoursePackageOrder::getCoursePackageId).collect(Collectors.toList());
|
if (collect.size() == 0) {
|
collect.add(-1);
|
}
|
//
|
List<TCoursePackage> list2 = coursePackageService.list(new LambdaQueryWrapper<TCoursePackage>().in(TCoursePackage::getId, collect));
|
// 课类型
|
List<TCoursePackageType> list1 = coursePackageTypeService.list();
|
|
for (CoursePackageOrder tCoursePackagePayment : list) {
|
for (TCoursePackage tCoursePackage : list2) {
|
if (tCoursePackagePayment.getCoursePackageId().equals(tCoursePackage.getId())) {
|
tCoursePackagePayment.setType(tCoursePackage.getCoursePackageTypeId());
|
}
|
}
|
}
|
|
ArrayList<HashMap<String, Object>> hashMaps = new ArrayList<>();
|
|
for (TCoursePackageType tCoursePackageType : list1) {
|
HashMap<String, Object> objectObjectHashMap = new HashMap<>();
|
objectObjectHashMap.put("name", tCoursePackageType.getName());
|
double a = 0;
|
for (CoursePackageOrder tCoursePackagePayment : list) {
|
if (tCoursePackagePayment.getType().equals(tCoursePackageType.getId())) {
|
a += tCoursePackagePayment.getCashPayment().doubleValue();
|
}
|
}
|
objectObjectHashMap.put("value", a);
|
hashMaps.add(objectObjectHashMap);
|
}
|
|
HashMap<String, Object> map1 = new HashMap<>();
|
map1.put("fee", v);
|
map1.put("data", hashMaps);
|
|
return map1;
|
}
|
}
|
