package com.stylefeng.guns.modular.code.controller;
|
|
import com.baomidou.mybatisplus.mapper.EntityWrapper;
|
import com.github.pagehelper.PageHelper;
|
import com.github.pagehelper.PageInfo;
|
import com.stylefeng.guns.modular.system.dto.CourseDTO;
|
import com.stylefeng.guns.modular.system.dto.CourseQuery;
|
import com.stylefeng.guns.modular.system.dto.OSQuery;
|
import com.stylefeng.guns.modular.system.dto.OrderQuery;
|
import com.stylefeng.guns.modular.system.model.*;
|
import com.stylefeng.guns.modular.system.model.Package;
|
import com.stylefeng.guns.modular.system.service.*;
|
import com.stylefeng.guns.modular.system.util.DateUtils;
|
import com.stylefeng.guns.modular.system.util.Page;
|
import com.stylefeng.guns.modular.system.util.ResultUtil;
|
import com.stylefeng.guns.modular.system.util.UUIDUtil;
|
import com.stylefeng.guns.modular.system.vo.*;
|
import io.swagger.annotations.ApiImplicitParam;
|
import io.swagger.annotations.ApiImplicitParams;
|
import io.swagger.annotations.ApiOperation;
|
import lombok.extern.slf4j.Slf4j;
|
import net.bytebuddy.asm.Advice;
|
import org.aspectj.weaver.ast.Or;
|
import org.aspectj.weaver.ast.Var;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.util.StringUtils;
|
import org.springframework.web.bind.annotation.PostMapping;
|
import org.springframework.web.bind.annotation.RequestMapping;
|
import org.springframework.web.bind.annotation.ResponseBody;
|
import org.springframework.web.bind.annotation.RestController;
|
|
import java.math.BigDecimal;
|
import java.text.ParseException;
|
import java.text.SimpleDateFormat;
|
import java.time.*;
|
import java.time.format.DateTimeFormatter;
|
import java.util.*;
|
import java.util.stream.Collectors;
|
|
/**
|
* @author 无关风月
|
* @Date 2024/2/6 18:25
|
*/
|
@Slf4j
|
@RestController
|
@RequestMapping("")
|
public class OrderController {
|
@Autowired
|
private IFitnessTypeService fitnessTypeService;
|
@Autowired
|
private IFitnessPositionService fitnessPositionService;
|
@Autowired
|
private IAppUserService appUserService;
|
@Autowired
|
private ICourseService courseService;
|
@Autowired
|
private ICourseVideoService courseVideoService;
|
@Autowired
|
private IOrderService orderService;
|
@Autowired
|
private IOrderCourseService orderCourseService;
|
@Autowired
|
private ICouponService couponService;
|
@Autowired
|
private ICouponReceiveService couponReceiveService;
|
@Autowired
|
private IPackageService packageService;
|
@Autowired
|
private IProtocolService protocolService;
|
@Autowired
|
private IFindService findService;
|
@Autowired
|
private IRechargeService rechargeService;
|
@Autowired
|
private IWithdrawalService withdrawalService;
|
@Autowired
|
private IInviteService inviteService;
|
@ResponseBody
|
@PostMapping("/base/system/os")
|
@ApiOperation(value = "运营数据", tags = {"运营统计"})
|
public ResultUtil<OperationalDataVO> courseList(OSQuery query) throws ParseException {
|
Date endTime = new Date();
|
Date startTime = new Date();
|
OperationalDataVO res = new OperationalDataVO();
|
// 先查询用户总数、课程总数、动态总数
|
int c1 = appUserService.selectList(new EntityWrapper<AppUser>()
|
.ne("state", 3)
|
.isNotNull("phone")).size();
|
res.setUserCount(c1);
|
int c2 = courseService.selectList(new EntityWrapper<Course>()
|
.ne("state", 3)).size();
|
res.setCourseCount(c2);
|
int c3 = findService.selectList(new EntityWrapper<Find>()
|
.eq("isDelete", 0)).size();
|
res.setFindCount(c3);
|
// 判断选择的是什么搜索类型
|
LocalDateTime endDate = LocalDateTime.now().with(LocalTime.MAX);
|
LocalDateTime startDate = LocalDateTime.now().with(LocalTime.MIN);
|
switch (query.getType()){
|
case 1:
|
startDate = endDate.minusDays(7).with(LocalTime.MIN);
|
break;
|
case 2:
|
startDate = endDate.minusDays(30).with(LocalTime.MIN);
|
break;
|
case 3:
|
startDate = endDate.minusMonths(6).with(LocalTime.MIN);
|
break;
|
case 4:
|
startDate = endDate.minusYears(1).with(LocalTime.MIN);
|
break;
|
}
|
endTime = DateUtils.toDate(endDate);
|
startTime = DateUtils.toDate(startDate);
|
if (query.getType()==6){
|
startTime = DateUtils.getDate_str4(query.getStartTime());
|
endTime = DateUtils.getDate_str4(query.getEndTime());
|
endTime.setHours(23);
|
endTime.setMinutes(59);
|
endTime.setSeconds(59);
|
}
|
// 查询提现金额
|
EntityWrapper<Withdrawal> wrapper4 = new EntityWrapper<>();
|
wrapper4.eq("payment",2);
|
// 查询用户注册
|
EntityWrapper<AppUser> wrapper5 = new EntityWrapper<>();
|
wrapper5.ne("state",3);
|
wrapper5.isNotNull("phone");
|
// 查询平台销售额（购买课程 购买套餐 充值余额）
|
EntityWrapper<Order> wrapper1 = new EntityWrapper<Order>();
|
EntityWrapper<Order> wrapper7 = new EntityWrapper<Order>();
|
EntityWrapper<OrderCourse> wrapper2 = new EntityWrapper<OrderCourse>();
|
EntityWrapper<OrderCourse> wrapper8 = new EntityWrapper<OrderCourse>();
|
wrapper1.ne("payType",3);
|
wrapper1.eq("state",2);
|
wrapper7.eq("state",2);
|
wrapper8.eq("state",2);
|
wrapper2.ne("payType",3);
|
wrapper2.eq("state",2);
|
EntityWrapper<Recharge> wrapper3 = new EntityWrapper<Recharge>();
|
EntityWrapper<Invite> wrapper6 = new EntityWrapper<Invite>();
|
wrapper3.eq("state",2);
|
if (query.getType() != 5) {
|
wrapper7.ge("insertTime",startTime);
|
wrapper8.ge("insertTime",startTime);
|
wrapper1.ge("insertTime",startTime);
|
wrapper2.ge("insertTime",startTime);
|
wrapper3.ge("insertTime",startTime);
|
wrapper4.ge("complete",startTime);
|
wrapper5.ge("insertTime",startTime);
|
wrapper6.ge("insertTime",startTime);
|
wrapper1.le("insertTime",endTime);
|
wrapper2.le("insertTime",endTime);
|
wrapper3.le("insertTime",endTime);
|
wrapper4.le("complete",endTime);
|
wrapper5.le("insertTime",endTime);
|
wrapper6.le("insertTime",endTime);
|
wrapper7.le("insertTime",endTime);
|
wrapper8.le("insertTime",endTime);
|
}
|
List<AppUser> users = appUserService.selectList(wrapper5);
|
BigDecimal bigDecimal = orderService.selectList(wrapper1)
|
.stream().map(Order::getRealMoney).reduce(BigDecimal::add).orElse(BigDecimal.ZERO);
|
BigDecimal bigDecimal1 = orderCourseService.selectList(wrapper2)
|
.stream().map(OrderCourse::getRealMoney).reduce(BigDecimal::add).orElse(BigDecimal.ZERO);
|
BigDecimal bigDecimal2 = rechargeService.selectList(wrapper3)
|
.stream().map(Recharge::getAmount).reduce(BigDecimal::add).orElse(BigDecimal.ZERO);
|
BigDecimal add = bigDecimal.add(bigDecimal1);
|
BigDecimal add1 = add.add(bigDecimal2);
|
// 销售额
|
res.setSaleCount(add1);
|
// 查询提现金额
|
BigDecimal payment = withdrawalService.selectList(wrapper4)
|
.stream().map(Withdrawal::getAmount).reduce(BigDecimal::add).orElse(BigDecimal.ZERO);
|
res.setWithdrawalCount(payment);
|
BigDecimal subtract = add1.subtract(payment);
|
res.setBalanceCount(subtract);
|
|
// 购课量
|
List<Integer> list1 = new ArrayList<>();
|
// 购课金额
|
List<BigDecimal> list2 = new ArrayList<>();
|
// 用户量
|
List<Integer> list3 = new ArrayList<>();
|
// 购课数统计 先查询购买课程的数量
|
List<OrderCourse> orderCourses = orderCourseService.selectList(wrapper8);
|
// 购买套餐的数量 这个套餐有几个课程就算几次
|
List<Order> orders = orderService.selectList(wrapper7);
|
LocalDate currentDate = LocalDate.now();
|
// 根据所选时间类型 设置y轴
|
switch (query.getType()){
|
case 1:
|
// 获取当前日期
|
Calendar calendar = Calendar.getInstance();
|
calendar.setTime(new Date());
|
// 初始化一个列表来存储最近七天的日期
|
List<Date> recentDates = new ArrayList<>();
|
// 循环生成最近七天的日期，并将其添加到列表中
|
for (int i = 0; i < 7; i++) {
|
recentDates.add(calendar.getTime());
|
calendar.add(Calendar.DAY_OF_YEAR, -1); // 减去一天
|
}
|
List<String> strings = new ArrayList<>();
|
SimpleDateFormat format1 = new SimpleDateFormat("dd");
|
for (Date recentDate : recentDates) {
|
String format = format1.format(recentDate);
|
|
strings.add(format+"号");
|
}
|
Collections.reverse(strings);
|
res.setTime(strings);
|
for (int i = 0; i < 7; i++) {
|
list1.add(0);
|
}
|
for (int i = 0; i < 7; i++) {
|
list2.add(BigDecimal.ZERO);
|
}
|
for (int i = 0; i < 7; i++) {
|
list3.add(0);
|
}
|
for (OrderCourse orderCourse : orderCourses) {
|
// 获取订单的插入时间
|
Date insertTime = orderCourse.getInsertTime();
|
// 计算 insertTime 距离当前日期的天数差
|
long millisecondsDifference = currentDate.toEpochDay() - insertTime.toInstant().toEpochMilli() / (1000 * 3600 * 24);
|
int index = (int) millisecondsDifference;
|
if (index<7){
|
Integer integer = list1.get(index);
|
integer+=1;
|
list1.set(index,integer);
|
// 累加购课金额
|
BigDecimal realMoney = orderCourse.getRealMoney();
|
BigDecimal bigDecimal3 = list2.get(index);
|
BigDecimal add2 = bigDecimal3.add(realMoney);
|
list2.set(index,add2);
|
}
|
|
}
|
for (Order order : orders) {
|
// 获取订单的插入时间
|
Date insertTime = order.getInsertTime();
|
// 计算 insertTime 距离当前日期的天数差
|
long millisecondsDifference = currentDate.toEpochDay() - insertTime.toInstant().toEpochMilli() / (1000 * 3600 * 24);
|
// 如果 insertTime 在7天内，则放入对应位置的列表中
|
int index = (int) millisecondsDifference;
|
if (index<7){
|
Integer integer = list1.get(index);
|
integer+=1;
|
list1.set(index,integer);
|
// 累加购课金额
|
BigDecimal realMoney = order.getRealMoney();
|
BigDecimal bigDecimal3 = list2.get(index);
|
BigDecimal add2 = bigDecimal3.add(realMoney);
|
list2.set(index,add2);
|
}
|
}
|
for (AppUser user : users) {
|
// 获取订单的插入时间
|
Date insertTime = user.getInsertTime();
|
// 计算 insertTime 距离当前日期的天数差
|
long millisecondsDifference = currentDate.toEpochDay() - insertTime.toInstant().toEpochMilli() / (1000 * 3600 * 24);
|
int index = (int) millisecondsDifference;
|
if (index<7){
|
Integer integer = list3.get(index);
|
integer+=1;
|
list3.set(index,integer);
|
}
|
}
|
break;
|
case 2:
|
// 获取当前日期
|
Calendar calendar1 = Calendar.getInstance();
|
calendar1.setTime(new Date());
|
// 初始化一个列表来存储最近七天的日期
|
List<Date> recentDates1 = new ArrayList<>();
|
// 循环生成最近七天的日期，并将其添加到列表中
|
for (int i = 0; i < 30; i++) {
|
recentDates1.add(calendar1.getTime());
|
calendar1.add(Calendar.DAY_OF_YEAR, -1); // 减去一天
|
}
|
List<String> strings1 = new ArrayList<>();
|
SimpleDateFormat format2 = new SimpleDateFormat("dd");
|
for (Date recentDate : recentDates1) {
|
String format = format2.format(recentDate);
|
strings1.add(format+"号");
|
}
|
Collections.reverse(strings1);
|
res.setTime(strings1);
|
for (int i = 0; i < 30; i++) {
|
list1.add(0);
|
}
|
for (int i = 0; i < 30; i++) {
|
list2.add(BigDecimal.ZERO);
|
}
|
for (int i = 0; i < 30; i++) {
|
list3.add(0);
|
}
|
for (OrderCourse orderCourse : orderCourses) {
|
// 获取订单的插入时间
|
Date insertTime = orderCourse.getInsertTime();
|
// 计算 insertTime 距离当前日期的天数差
|
long millisecondsDifference = currentDate.toEpochDay() - insertTime.toInstant().toEpochMilli() / (1000 * 3600 * 24);
|
// 如果 insertTime 在7天内，则放入对应位置的列表中
|
int index = (int) millisecondsDifference;
|
|
if (index<30){
|
Integer integer = list1.get(index);
|
integer+=1;
|
list1.set(index,integer);
|
// 累加购课金额
|
BigDecimal realMoney = orderCourse.getRealMoney();
|
BigDecimal bigDecimal3 = list2.get(index);
|
BigDecimal add2 = bigDecimal3.add(realMoney);
|
list2.set(index,add2);
|
}
|
}
|
for (Order order : orders) {
|
|
// 获取订单的插入时间
|
Date insertTime = order.getInsertTime();
|
// 计算 insertTime 距离当前日期的天数差
|
long millisecondsDifference = currentDate.toEpochDay() - insertTime.toInstant().toEpochMilli() / (1000 * 3600 * 24);
|
// 如果 insertTime 在7天内，则放入对应位置的列表中
|
int index = (int) millisecondsDifference;
|
if (index<30){
|
Integer integer = list1.get(index);
|
integer+=1;
|
list1.set(index,integer);
|
// 累加购课金额
|
BigDecimal realMoney = order.getRealMoney();
|
BigDecimal bigDecimal3 = list2.get(index);
|
BigDecimal add2 = bigDecimal3.add(realMoney);
|
list2.set(index,add2);
|
}
|
}
|
for (AppUser user : users) {
|
// 获取订单的插入时间
|
Date insertTime = user.getInsertTime();
|
// 计算 insertTime 距离当前日期的天数差
|
long millisecondsDifference = currentDate.toEpochDay() - insertTime.toInstant().toEpochMilli() / (1000 * 3600 * 24);
|
int index = (int) millisecondsDifference;
|
if (index<30){
|
Integer integer = list3.get(index);
|
integer+=1;
|
list3.set(index,integer);
|
}
|
}
|
break;
|
case 3:
|
// 获取当前日期
|
LocalDate currentDate1 = LocalDate.now();
|
// 初始化一个列表来存储最近半年的日期的字符串表示
|
List<String> recentDates2 = new ArrayList<>();
|
// 设置日期格式化器
|
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("MM");
|
// 循环生成最近半年的日期，并将其格式化为字符串，然后添加到列表中
|
for (int i = 0; i < 6; i++) {
|
LocalDate date = currentDate1.minusMonths(i);
|
String formattedDate = date.format(formatter);
|
recentDates2.add(formattedDate+"月");
|
}
|
Collections.reverse(recentDates2);
|
res.setTime(recentDates2);
|
for (int i = 0; i < 6; i++) {
|
list1.add(0);
|
}
|
for (int i = 0; i < 6; i++) {
|
list2.add(BigDecimal.ZERO);
|
}
|
for (int i = 0; i < 6; i++) {
|
list3.add(0);
|
}
|
for (OrderCourse orderCourse : orderCourses) {
|
// 获取订单课程的插入日期，并转换为 LocalDate 类型
|
Date insertDate = orderCourse.getInsertTime();
|
LocalDate localInsertDate = insertDate.toInstant().atZone(ZoneId.systemDefault()).toLocalDate();
|
// 计算月份差距
|
int monthDifference = getMonthDifference(currentDate, localInsertDate);
|
if (monthDifference<7){
|
Integer integer = list1.get(monthDifference);
|
integer+=1;
|
list1.set(monthDifference,integer);
|
|
// 累加购课金额
|
BigDecimal realMoney = orderCourse.getRealMoney();
|
BigDecimal bigDecimal3 = list2.get(monthDifference);
|
BigDecimal add2 = bigDecimal3.add(realMoney);
|
list2.set(monthDifference,add2);
|
}
|
|
}
|
for (Order order : orders) {
|
|
// 获取订单课程的插入日期，并转换为 LocalDate 类型
|
Date insertDate = order.getInsertTime();
|
LocalDate localInsertDate = insertDate.toInstant().atZone(ZoneId.systemDefault()).toLocalDate();
|
// 计算月份差距
|
int monthDifference = getMonthDifference(currentDate, localInsertDate);
|
if (monthDifference<7){
|
Integer integer = list1.get(monthDifference);
|
integer+=1;
|
list1.set(monthDifference,integer);
|
// 累加购课金额
|
BigDecimal realMoney = order.getRealMoney();
|
BigDecimal bigDecimal3 = list2.get(monthDifference);
|
BigDecimal add2 = bigDecimal3.add(realMoney);
|
list2.set(monthDifference,add2);
|
}
|
|
}
|
for (AppUser user : users) {
|
// 获取订单课程的插入日期，并转换为 LocalDate 类型
|
Date insertDate = user.getInsertTime();
|
LocalDate localInsertDate = insertDate.toInstant().atZone(ZoneId.systemDefault()).toLocalDate();
|
// 计算月份差距
|
int monthDifference = getMonthDifference(currentDate, localInsertDate);
|
if (monthDifference<7){
|
Integer integer = list3.get(monthDifference);
|
integer+=1;
|
list3.set(monthDifference,integer);
|
}
|
|
}
|
break;
|
case 4:
|
// 获取当前日期
|
LocalDate currentDate7 = LocalDate.now();
|
// 初始化一个列表来存储最近半年的日期的字符串表示
|
List<String> recentDates7 = new ArrayList<>();
|
// 设置日期格式化器
|
DateTimeFormatter formatter7 = DateTimeFormatter.ofPattern("MM");
|
// 循环生成最近半年的日期，并将其格式化为字符串，然后添加到列表中
|
for (int i = 0; i < 12; i++) {
|
LocalDate date = currentDate7.minusMonths(i);
|
String formattedDate = date.format(formatter7);
|
recentDates7.add(formattedDate+"月");
|
}
|
Collections.reverse(recentDates7);
|
res.setTime(recentDates7);
|
|
for (int i = 0; i < 12; i++) {
|
list1.add(0);
|
}
|
for (int i = 0; i < 12; i++) {
|
list2.add(BigDecimal.ZERO);
|
}
|
for (int i = 0; i < 12; i++) {
|
list3.add(0);
|
}
|
for (OrderCourse orderCourse : orderCourses) {
|
// 获取订单课程的插入日期，并转换为 LocalDate 类型
|
Date insertDate = orderCourse.getInsertTime();
|
LocalDate localInsertDate = insertDate.toInstant().atZone(ZoneId.systemDefault()).toLocalDate();
|
// 计算月份差距
|
int monthDifference = getMonthDifference(currentDate, localInsertDate);
|
if (monthDifference<12){
|
Integer integer = list1.get(monthDifference);
|
integer+=1;
|
list1.set(monthDifference,integer);
|
|
// 累加购课金额
|
BigDecimal realMoney = orderCourse.getRealMoney();
|
BigDecimal bigDecimal3 = list2.get(monthDifference);
|
BigDecimal add2 = bigDecimal3.add(realMoney);
|
list2.set(monthDifference,add2);
|
}
|
|
}
|
for (Order order : orders) {
|
|
// 获取订单课程的插入日期，并转换为 LocalDate 类型
|
Date insertDate = order.getInsertTime();
|
LocalDate localInsertDate = insertDate.toInstant().atZone(ZoneId.systemDefault()).toLocalDate();
|
// 计算月份差距
|
int monthDifference = getMonthDifference(currentDate, localInsertDate);
|
if (monthDifference<12){
|
Integer integer = list1.get(monthDifference);
|
integer+=1;
|
list1.set(monthDifference,integer);
|
// 累加购课金额
|
BigDecimal realMoney = order.getRealMoney();
|
BigDecimal bigDecimal3 = list2.get(monthDifference);
|
BigDecimal add2 = bigDecimal3.add(realMoney);
|
list2.set(monthDifference,add2);
|
}
|
|
}
|
for (AppUser user : users) {
|
// 获取订单课程的插入日期，并转换为 LocalDate 类型
|
Date insertDate = user.getInsertTime();
|
LocalDate localInsertDate = insertDate.toInstant().atZone(ZoneId.systemDefault()).toLocalDate();
|
// 计算月份差距
|
int monthDifference = getMonthDifference(currentDate, localInsertDate);
|
if (monthDifference<12){
|
Integer integer = list3.get(monthDifference);
|
integer+=1;
|
list3.set(monthDifference,integer);
|
}
|
}
|
break;
|
case 5:
|
int size = orderCourses.size();
|
list1.add(size+orders.size());
|
BigDecimal bigDecimal7 = orderService.selectList(new EntityWrapper<Order>()
|
.eq("state",2)).stream().map(Order::getRealMoney).reduce(BigDecimal::add).orElse(BigDecimal.ZERO);
|
BigDecimal bigDecimal8 = orderCourseService.selectList(
|
new EntityWrapper<OrderCourse>().eq("state",2))
|
.stream().map(OrderCourse::getRealMoney).reduce(BigDecimal::add).orElse(BigDecimal.ZERO);
|
BigDecimal add3 = bigDecimal7.add(bigDecimal8);
|
list2.add(add3);
|
List<AppUser> users1 = appUserService.selectList(new EntityWrapper<AppUser>()
|
.ne("state", 3)
|
.isNotNull("phone"));
|
list3.add(users1.size());
|
List<String> strings2 = new ArrayList<>();
|
strings2.add("全部");
|
res.setTime(strings2);
|
break;
|
case 6:
|
SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
|
Date parse = format.parse(query.getEndTime());
|
LocalDate localDate = parse.toInstant().atZone(ZoneId.systemDefault()).toLocalDate();
|
// 将字符串解析为 LocalDate 对象
|
DateTimeFormatter formatter1 = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
|
// 解析字符串为 LocalDateTime 对象
|
LocalDateTime localDateTime1 = LocalDateTime.parse(query.getStartTime(), formatter1);
|
LocalDateTime localDateTime2 = LocalDateTime.parse(query.getEndTime(), formatter1);
|
// 提取日期部分，并转换为 LocalDate 对象
|
LocalDate s1 = localDateTime1.toLocalDate();
|
LocalDate e1 = localDateTime2.toLocalDate();
|
|
// 计算日期范围内的天数差
|
long daysDifference = e1.toEpochDay() - s1.toEpochDay() + 1;
|
// 初始化一个列表来存储日期字符串
|
List<String> datesInRange = new ArrayList<>();
|
// 设置日期格式化器
|
DateTimeFormatter formatter8 = DateTimeFormatter.ofPattern("MM-dd");
|
SimpleDateFormat format3 = new SimpleDateFormat("MM月dd号");
|
|
// 循环生成日期范围内的日期，并将其格式化为字符串，然后添加到列表中
|
for (int i = 0; i < daysDifference; i++) {
|
LocalDate date = s1.plusDays(i);
|
Date date1 = DateUtils.toDate(date);
|
String formattedDate = format3.format(date1);
|
datesInRange.add(formattedDate);
|
}
|
res.setTime(datesInRange);
|
for (int i = 0; i < daysDifference; i++) {
|
list1.add(0);
|
}
|
for (int i = 0; i < daysDifference; i++) {
|
list2.add(BigDecimal.ZERO);
|
}
|
for (int i = 0; i < daysDifference; i++) {
|
list3.add(0);
|
}
|
for (OrderCourse orderCourse : orderCourses) {
|
// 获取订单的插入时间
|
Date insertTime = orderCourse.getInsertTime();
|
// 计算 insertTime 距离当前日期的天数差
|
long millisecondsDifference = localDate.toEpochDay() - insertTime.toInstant().toEpochMilli() / (1000 * 3600 * 24);
|
// 如果 insertTime 在7天内，则放入对应位置的列表中
|
int index = (int) millisecondsDifference;
|
if (index<daysDifference){
|
Integer integer = list1.get(index);
|
integer+=1;
|
list1.set(index,integer);
|
// 累加购课金额
|
BigDecimal realMoney = orderCourse.getRealMoney();
|
BigDecimal bigDecimal3 = list2.get(index);
|
BigDecimal add2 = bigDecimal3.add(realMoney);
|
list2.set(index,add2);
|
}
|
|
}
|
for (Order order : orders) {
|
|
// 获取订单的插入时间
|
Date insertTime = order.getInsertTime();
|
// 计算 insertTime 距离当前日期的天数差
|
long millisecondsDifference = localDate.toEpochDay() - insertTime.toInstant().toEpochMilli() / (1000 * 3600 * 24);
|
// 如果 insertTime 在7天内，则放入对应位置的列表中
|
int index = (int) millisecondsDifference;
|
if (index<daysDifference){
|
Integer integer = list1.get(index);
|
integer+=1;
|
list1.set(index,integer);
|
// 累加购课金额
|
BigDecimal realMoney = order.getRealMoney();
|
BigDecimal bigDecimal3 = list2.get(index);
|
BigDecimal add2 = bigDecimal3.add(realMoney);
|
list2.set(index,add2);
|
}
|
|
}
|
for (AppUser user : users) {
|
// 获取订单的插入时间
|
Date insertTime = user.getInsertTime();
|
// 计算 insertTime 距离当前日期的天数差
|
long millisecondsDifference = localDate.toEpochDay() - insertTime.toInstant().toEpochMilli() / (1000 * 3600 * 24);
|
// 如果 insertTime 在7天内，则放入对应位置的列表中
|
int index = (int) millisecondsDifference;
|
if (index<daysDifference){
|
Integer integer = list3.get(index);
|
integer+=1;
|
list3.set(index,integer);
|
}
|
|
}
|
break;
|
}
|
Collections.reverse(list1);
|
Collections.reverse(list2);
|
Collections.reverse(list3);
|
res.setBuyCourse(list1);
|
res.setBuyMoney(list2);
|
res.setUserList(list3);
|
|
|
if (query.getType() == 5){
|
startTime =null;
|
endTime =null;
|
}
|
// 查询用户提成统计
|
List<CSVO> invites = inviteService.list(startTime,endTime);
|
|
// PageHelper.startPage(query.getPageNum(),query.getPageSize());
|
PageInfo<CSVO> info=new PageInfo<>(invites);
|
res.setCommissionStatistics(info);
|
return ResultUtil.success(res);
|
}
|
public static int getMonthDifference(LocalDate currentDate, LocalDate insertDate) {
|
return Period.between(insertDate, currentDate).getMonths();
|
}
|
@ResponseBody
|
@PostMapping("/base/sysnotice/update")
|
@ApiOperation(value = "公告消息详情和编辑", tags = {"公告消息"})
|
public ResultUtil<Protocol> courseList(String content) {
|
Protocol type = protocolService.selectOne(new EntityWrapper<Protocol>()
|
.eq("type", 5));
|
type.setContent(content);
|
type.setInsertTime(new Date());
|
protocolService.updateById(type);
|
return ResultUtil.success(type);
|
}
|
@ResponseBody
|
@PostMapping("/base/sysnotice/getInfo")
|
@ApiOperation(value = "获取公告消息", tags = {"公告消息"})
|
public ResultUtil<Protocol> courseList() {
|
Protocol type = protocolService.selectOne(new EntityWrapper<Protocol>()
|
.eq("type", 5));
|
return ResultUtil.success(type);
|
}
|
@ResponseBody
|
@PostMapping("/base/order/orderList")
|
@ApiOperation(value = "列表查询", tags = {"订单管理"})
|
public ResultUtil<PageInfo<OrderListVO>> courseList(OrderQuery query) throws ParseException {
|
if (query.getEndTime()!=null){
|
query.getEndTime().setHours(23);
|
query.getEndTime().setMinutes(59);
|
query.getEndTime().setSeconds(59);
|
|
SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
|
String format1 = format.format(query.getStartTime());
|
String format2 = format.format(query.getEndTime());
|
query.setEndTime1(format2);
|
query.setStartTime1(format1);
|
Date parse = format.parse(format1);
|
Date parse1 = format.parse(format2);
|
query.setStartTime(parse);
|
query.setEndTime(parse1);
|
}
|
|
// 查询套餐
|
List<OrderListVO> temp1= orderService.selectOrder(query);
|
// 查询购课
|
List<OrderListVO> temp2= orderCourseService.selectOrderCourse(query);
|
temp1.addAll(temp2);
|
List<OrderListVO> sortedList = temp1.stream()
|
.sorted(Comparator.comparing(OrderListVO::getPayTime).reversed())
|
.collect(Collectors.toList());
|
// PageHelper.startPage(query.getPageNum(),query.getPageSize());
|
PageInfo<OrderListVO> info=new PageInfo<>(sortedList);
|
return ResultUtil.success(info);
|
}
|
|
@ResponseBody
|
@PostMapping("/base/order/orderDetail")
|
@ApiOperation(value = "查看详情", tags = {"订单管理"})
|
@ApiImplicitParams({
|
@ApiImplicitParam(value = "订单id", name = "id"),
|
@ApiImplicitParam(value = "订单类型(列表查询里的type字段的值)", name = "type"),
|
})
|
public ResultUtil<OrderDetailVO> courseList(Integer id, Integer type) {
|
OrderDetailVO orderDetailVO = new OrderDetailVO();
|
if (type==1){
|
// 购买课程
|
OrderCourse orderCourse = orderCourseService.selectById(id);
|
AppUser appUser = appUserService.selectById(orderCourse.getUserId());
|
orderDetailVO.setUserName(appUser.getName());
|
orderDetailVO.setPhone(appUser.getPhone());
|
orderDetailVO.setPayTime(orderCourse.getPayTime());
|
// 查询这笔订单有没有使用优惠券
|
if (orderCourse.getCouponId()!=null){
|
CouponReceive couponReceive = couponReceiveService.selectById(orderCourse.getCouponId());
|
Coupon coupon = couponService.selectById(couponReceive.getCouponId());
|
if (coupon!=null){
|
orderDetailVO.setCouponName(coupon.getCouponName());
|
}
|
// 原价
|
BigDecimal amount = orderCourse.getAmount();
|
// 实际支付价格
|
BigDecimal realMoney = orderCourse.getRealMoney();
|
orderDetailVO.setRealMoney(realMoney);
|
orderDetailVO.setAmount(amount);
|
BigDecimal subtract = amount.subtract(realMoney);
|
orderDetailVO.setPreferential(""+subtract);
|
// 计算优惠价格
|
}else{
|
orderDetailVO.setAmount(orderCourse.getAmount());
|
orderDetailVO.setRealMoney(orderCourse.getRealMoney());
|
// 没有使用优惠券
|
orderDetailVO.setCouponName("无");
|
orderDetailVO.setPreferential("无");
|
}
|
orderDetailVO.setPayType(orderCourse.getPayType());
|
orderDetailVO.setPackageName("无");
|
Integer courseId = orderCourse.getCourseId();
|
Course course = courseService.selectById(courseId);
|
Integer positionId = course.getPositionId();
|
FitnessPosition fitnessPosition = fitnessPositionService.selectById(positionId);
|
FitnessType fitnessType = fitnessTypeService.selectById(fitnessPosition.getTypeId());
|
orderDetailVO.setPosition(fitnessType.getName()+"|"+fitnessPosition.getName());
|
}else{
|
// 购买的套餐
|
Order order = orderService.selectById(id);
|
AppUser appUser = appUserService.selectById(order.getUserId());
|
orderDetailVO.setUserName(appUser.getName());
|
orderDetailVO.setPhone(appUser.getPhone());
|
orderDetailVO.setPayTime(order.getPayTime());
|
// 查询这笔订单有没有使用优惠券
|
if (order.getCouponId()!=null){
|
Coupon coupon = couponService.selectById(order.getCouponId());
|
if (coupon!=null){
|
orderDetailVO.setCouponName(coupon.getCouponName());
|
}
|
// 原价
|
BigDecimal amount = order.getAmount();
|
// 实际支付价格
|
BigDecimal realMoney = order.getRealMoney();
|
orderDetailVO.setRealMoney(realMoney);
|
orderDetailVO.setAmount(amount);
|
BigDecimal subtract = amount.subtract(realMoney);
|
orderDetailVO.setPreferential(""+subtract);
|
// 计算优惠价格
|
}else{
|
orderDetailVO.setAmount(order.getAmount());
|
orderDetailVO.setRealMoney(order.getRealMoney());
|
// 没有使用优惠券
|
orderDetailVO.setCouponName("无");
|
orderDetailVO.setPreferential("无");
|
}
|
orderDetailVO.setPayType(order.getPayType());
|
Integer packageId = order.getPackageId();
|
Package aPackage = packageService.selectById(packageId);
|
orderDetailVO.setPackageName(aPackage.getName());
|
// 查询套餐的购买部位
|
String positions = aPackage.getPositions();
|
// 套餐包含的部位名称
|
StringBuilder temp = new StringBuilder("");
|
// 套餐包含的部位ids
|
for (String s : positions.split(",")) {
|
Integer positionId = Integer.valueOf(s);
|
FitnessPosition fitnessPosition = fitnessPositionService.selectById(positionId);
|
FitnessType fitnessType = fitnessTypeService.selectById(fitnessPosition.getTypeId());
|
temp.append(fitnessType.getName()+"|"+fitnessPosition.getName()+"、");
|
}
|
String s = temp.toString();
|
String substring = s.substring(0, s.length() - 1);
|
orderDetailVO.setPosition(substring+"。");
|
}
|
return ResultUtil.success(orderDetailVO);
|
}
|
|
public static void main(String[] args) {
|
|
// 定义开始日期和结束日期的字符串
|
String startTimeStr = "2024-11-11";
|
String endTimeStr = "2024-11-30";
|
|
// 将字符串解析为 LocalDate 对象
|
LocalDate startTime = LocalDate.parse(startTimeStr);
|
LocalDate endTime = LocalDate.parse(endTimeStr);
|
|
// 计算日期范围内的天数差
|
long daysDifference = endTime.toEpochDay() - startTime.toEpochDay() + 1;
|
|
// 初始化一个列表来存储日期字符串
|
List<String> datesInRange = new ArrayList<>();
|
|
// 设置日期格式化器
|
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");
|
|
// 循环生成日期范围内的日期，并将其格式化为字符串，然后添加到列表中
|
for (int i = 0; i < daysDifference; i++) {
|
LocalDate date = startTime.plusDays(i);
|
String formattedDate = date.format(formatter);
|
datesInRange.add(formattedDate);
|
}
|
|
// 输出集合中的日期字符串
|
for (String date : datesInRange) {
|
System.out.println(date);
|
}
|
|
// 输出日期范围内的天数差
|
System.out.println("日期范围内的天数差：" + daysDifference);
|
}
|
|
}
|
