package com.ruoyi.admin.service.impl;
|
|
import com.alibaba.excel.EasyExcelFactory;
|
import com.alibaba.excel.ExcelWriter;
|
import com.alibaba.excel.write.builder.ExcelWriterBuilder;
|
import com.alibaba.excel.write.metadata.WriteSheet;
|
import com.baomidou.mybatisplus.core.metadata.IPage;
|
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
|
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
|
import com.ruoyi.admin.entity.*;
|
import com.ruoyi.admin.mapper.OrderMapper;
|
import com.ruoyi.admin.mapper.UserMapper;
|
import com.ruoyi.admin.request.OrderCountRequest;
|
import com.ruoyi.admin.request.OrderQueryRequest;
|
import com.ruoyi.admin.service.*;
|
import com.ruoyi.admin.vo.*;
|
import com.ruoyi.common.core.constant.Constants;
|
import com.ruoyi.common.core.constant.OrderConstants;
|
import com.ruoyi.common.core.domain.R;
|
import com.ruoyi.common.core.exception.GlobalException;
|
import org.apache.commons.codec.CharEncoding;
|
import org.springframework.stereotype.Service;
|
|
import javax.annotation.Resource;
|
import javax.servlet.http.HttpServletResponse;
|
import java.io.IOException;
|
import java.io.InputStream;
|
import java.io.UnsupportedEncodingException;
|
import java.math.BigDecimal;
|
import java.net.URLEncoder;
|
import java.util.ArrayList;
|
import java.util.Arrays;
|
import java.util.List;
|
import java.util.stream.Collectors;
|
|
/**
|
* <p>
|
* 订单管理 服务实现类
|
* </p>
|
*
|
* @author hjl
|
* @since 2024-05-29
|
*/
|
@Service
|
public class OrderServiceImpl extends ServiceImpl<OrderMapper, Order> implements OrderService {
|
|
@Resource
|
private UserMapper userMapper;
|
@Resource
|
private RecoveryServeService recoveryServeService;
|
@Resource
|
private RecoveryClassifyService recoveryClassifyService;
|
@Resource
|
private MasterWorkerService masterWorkerService;
|
@Resource
|
private ServeRecordService serveRecordService;
|
@Resource
|
private ServeCoordinateService serveCoordinateService;
|
@Resource
|
private EvaluateService evaluateService;
|
|
@Override
|
public OrderResultVO orderCountHome(OrderCountRequest orderCount) {
|
List<String> cityList = orderCount.getCityList();
|
Integer orderState = orderCount.getOrderState();
|
String countType = orderCount.getCountType();
|
String startTime = orderCount.getStartTime();
|
String endTime = orderCount.getEndTime();
|
List<OrderQueryVO> list;
|
// 根据查询类型查询订单信息
|
if (OrderConstants.YEAR.equals(countType)) {
|
list = baseMapper.orderCountByYear(cityList, orderState, startTime, endTime);
|
} else if (OrderConstants.MONTH.equals(countType)) {
|
list = baseMapper.orderCountByMonth(cityList, orderState, startTime, endTime);
|
} else if (OrderConstants.WEEK.equals(countType)) {
|
list = baseMapper.orderCountByWeek(cityList, orderState, startTime, endTime);
|
} else if (OrderConstants.TODAY.equals(countType)) {
|
list = baseMapper.orderCountByToday(cityList, orderState, startTime, endTime);
|
} else {
|
list = new ArrayList<>();
|
}
|
// 计算订单总额及总订单数量
|
BigDecimal totalMoney;
|
int orderNumber;
|
if (list.isEmpty()) {
|
totalMoney = BigDecimal.ZERO;
|
orderNumber = 0;
|
} else {
|
totalMoney = list.stream().map(OrderQueryVO::getTotalPrice).reduce(BigDecimal.ZERO, BigDecimal::add);
|
orderNumber = list.stream().map(OrderQueryVO::getNumber).collect(Collectors.toList()).stream().mapToInt(Integer::intValue).sum();
|
}
|
return new OrderResultVO(totalMoney, orderNumber, list);
|
}
|
|
@Override
|
public BigDecimal totalMoneyByQuarter(String startDateStr, String endDateStr, List<String> cityList) {
|
return baseMapper.totalMoneyByQuarter(startDateStr, endDateStr, cityList);
|
}
|
|
@Override
|
public BigDecimal totalMoneyByYear(List<String> cityList) {
|
return baseMapper.totalMoneyByYear(cityList);
|
}
|
|
@Override
|
public BigDecimal totalMoneyByMonth(List<String> cityList) {
|
return baseMapper.totalMoneyByMonth(cityList);
|
}
|
|
@Override
|
public R<String> excelExport(List<String> idList, HttpServletResponse response) {
|
try {
|
response.setCharacterEncoding(Constants.UTF8);
|
response.setContentType("application/vnd.openxmlformats-officedocument.spreadsheetml.sheet");
|
response.setHeader("Access-Control-Expose-Headers", "Content-disposition");
|
response.setHeader("Content-Disposition", "attachment;filename=" + URLEncoder.encode(Constants.EXCEL_ORDER_FILE_NAME, CharEncoding.UTF_8) + ".xlsx");
|
} catch (UnsupportedEncodingException e) {
|
return R.fail("excel导出失败！");
|
}
|
try {
|
List<Order> list = lambdaQuery().in(Order::getId, idList).eq(Order::getIsDelete, 0).list();
|
// excel模板封装
|
ExcelWriterBuilder excelWriterBuilder = EasyExcelFactory.write(response.getOutputStream());
|
InputStream stream = Thread.currentThread().getContextClassLoader().getResourceAsStream("template/" + Constants.EXCEL_ORDER_FILE_NAME + ".xlsx");
|
// 自动释放资源
|
try (ExcelWriter excelWriter = excelWriterBuilder.withTemplate(stream).build()) {
|
WriteSheet writeSheet = EasyExcelFactory.writerSheet().build();
|
excelWriter.fill(list, writeSheet);
|
excelWriter.finish();
|
} catch (Exception e) {
|
return R.fail("excel导出失败！");
|
}
|
} catch (IOException e) {
|
return R.fail("excel导出失败！");
|
}
|
return R.ok();
|
}
|
|
@Override
|
public IPage<Order> queryPage(OrderQueryRequest orderQueryRequest) {
|
Page<Order> page = Page.of(orderQueryRequest.getPageNum(), orderQueryRequest.getPageSize());
|
// 基础查询
|
return baseMapper.queryPage(orderQueryRequest, page);
|
}
|
|
@Override
|
public OrderDetailVO orderListDetail(String id) {
|
OrderDetailVO result = new OrderDetailVO();
|
Order order = this.getById(id);
|
orderInfo(result, order);
|
// 预约人信息
|
userInfo(result, order);
|
// 服务信息
|
serveInfo(result, order);
|
// 师傅信息
|
workerInfo(result, order);
|
// 服务记录
|
serveRecordInfo(result, order);
|
// 评价信息
|
evaluateInfo(result, order);
|
return result;
|
}
|
|
private void evaluateInfo(OrderDetailVO result, Order order) {
|
Evaluate evaluate = evaluateService.lambdaQuery().eq(Evaluate::getOrderId, order.getId())
|
.eq(Evaluate::getIsDelete, 0).one();
|
OrderByEvaluateVO orderByEvaluate = new OrderByEvaluateVO();
|
orderByEvaluate.setStarRating(evaluate.getStarRating());
|
orderByEvaluate.setEvaluateTime(evaluate.getCreateTime());
|
orderByEvaluate.setEvaluateContent(evaluate.getContent());
|
result.setEvaluateInfo(orderByEvaluate);
|
}
|
|
private void serveRecordInfo(OrderDetailVO result, Order order) {
|
ServeRecord serveRecord = serveRecordService.lambdaQuery().eq(ServeRecord::getOrderId, order.getId())
|
.eq(ServeRecord::getIsDelete, 0).one();
|
if (null == serveRecord) {
|
throw new GlobalException("服务记录信息异常，请重试");
|
}
|
// 师傅路线轨迹
|
List<ServeCoordinate> serveCoordinateList = serveCoordinateService.lambdaQuery().eq(ServeCoordinate::getWorkerId, order.getServerId())
|
.eq(ServeCoordinate::getIsDelete, 0).orderByDesc(ServeCoordinate::getCreateTime).list();
|
OrderByServeRecordVO orderByServeRecord = new OrderByServeRecordVO();
|
orderByServeRecord.setAcceptOrderTime(order.getAcceptTime());
|
orderByServeRecord.setReachTime(order.getTime());
|
orderByServeRecord.setCoordinate(serveCoordinateList.stream().map(ServeCoordinate::getCoordinate).collect(Collectors.toList()));
|
orderByServeRecord.setPhoto(Arrays.stream(serveRecord.getPhoto().split(",")).collect(Collectors.toList()));
|
result.setServeRecordInfo(orderByServeRecord);
|
}
|
|
private void workerInfo(OrderDetailVO result, Order order) {
|
MasterWorker worker = masterWorkerService.getById(order.getServerId());
|
if (null == worker) {
|
throw new GlobalException("服务人员信息异常，请重试");
|
}
|
OrderByWorkerVO orderByWorker = new OrderByWorkerVO();
|
orderByWorker.setProfilePicture(worker.getProfilePicture());
|
orderByWorker.setName(worker.getRealName());
|
orderByWorker.setPhone(worker.getPhone());
|
orderByWorker.setSex(worker.getSex());
|
result.setWorkerInfo(orderByWorker);
|
}
|
|
private void serveInfo(OrderDetailVO result, Order order) {
|
RecoveryServe recoveryServe = recoveryServeService.getById(order.getServeId());
|
if (null == recoveryServe) {
|
throw new GlobalException("回收服务信息异常，请重试");
|
}
|
RecoveryClassify recoveryClassify = recoveryClassifyService.getById(recoveryServe.getClassifyId());
|
if (null == recoveryClassify) {
|
throw new GlobalException("回收服务分类信息异常，请重试");
|
}
|
OrderByServeVO orderByServe = new OrderByServeVO();
|
orderByServe.setServeName(recoveryServe.getServeName());
|
orderByServe.setSupClassify(recoveryClassify.getSupClassify());
|
orderByServe.setSubClassify(recoveryClassify.getSubClassify());
|
orderByServe.setPrice(order.getServePrice());
|
result.setServeInfo(orderByServe);
|
}
|
|
private void orderInfo(OrderDetailVO result, Order order) {
|
if (null == order) {
|
throw new GlobalException("订单信息异常，请重试");
|
}
|
// 订单信息
|
OrderInfoVO orderInfo = new OrderInfoVO();
|
orderInfo.setOrderNumber(order.getOrderNumber());
|
orderInfo.setPlaceOrderTime(order.getTime());
|
orderInfo.setState(order.getState());
|
result.setOrderInfo(orderInfo);
|
}
|
|
private void userInfo(OrderDetailVO result, Order order) {
|
Integer userId = order.getUserId();
|
User user = userMapper.selectById(userId);
|
if (null == user) {
|
throw new GlobalException("预约人信息异常，请重试");
|
}
|
OrderByUserInfoVO orderByUserInfo = new OrderByUserInfoVO();
|
orderByUserInfo.setProfilePicture(user.getProfilePicture());
|
orderByUserInfo.setUserNumber(user.getUserNo());
|
orderByUserInfo.setReservationName(order.getReservationName());
|
orderByUserInfo.setReservationPhone(order.getReservationPhone());
|
orderByUserInfo.setReservationAddress(order.getReservationAddress());
|
orderByUserInfo.setTime(order.getTime());
|
result.setUserInfo(orderByUserInfo);
|
}
|
|
@Override
|
public IPage<OrderCountVO> orderCount(String name, String phone, Page<OrderCountVO> page) {
|
return baseMapper.orderCount(name, phone, page);
|
}
|
|
@Override
|
public OrderPageCountVO orderPageCount(OrderQueryRequest orderQueryRequest) {
|
List<Order> orderList = baseMapper.orderPageCount(orderQueryRequest);
|
int total = 0;
|
int toBeDispatched = 0;
|
int stayDoorstep = 0;
|
int toBeCompleted = 0;
|
int completed = 0;
|
int canceled = 0;
|
int reInvestment = 0;
|
for (Order order : orderList) {
|
total++;
|
Integer state = order.getState();
|
if (Constants.ZERO.equals(state)) {
|
toBeDispatched++;
|
} else if (Constants.ONE.equals(state)) {
|
stayDoorstep++;
|
} else if (Constants.TWO.equals(state)) {
|
toBeCompleted++;
|
} else if (Constants.THREE.equals(state)) {
|
completed++;
|
} else if (Constants.FOUR.equals(state)) {
|
canceled++;
|
} else if (Constants.FIVE.equals(state)) {
|
reInvestment++;
|
}
|
}
|
return new OrderPageCountVO(total, toBeDispatched, stayDoorstep,
|
toBeCompleted, completed, canceled, reInvestment);
|
}
|
}
|
