clunt
/
ghy-all
1
0
Fork 0
Code Issues Pull Requests 1 Packages Projects Releases Wiki Activity

增加定点巡查

This commit is contained in:
cb 2025-04-18 10:54:05 +08:00
parent 21bfff0400
commit f04fa50549
3 changed files with 577 additions and 161 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
ghy-quartz/src/main/java/com/ghy/quartz/service/OrderService.java
View File

@ -12,4 +12,6 @@ public interface OrderService {
void autoChangeDrawCashStatus();
void timeOutOrder();
void AfterSalesAndShelveOrder() ;
}

710
ghy-quartz/src/main/java/com/ghy/quartz/service/impl/OrderServiceImpl.java
View File

@ -1,44 +1,60 @@
package com.ghy.quartz.service.impl;
import cn.hutool.core.collection.CollectionUtil;
import com.ghy.common.core.domain.AjaxResult;
import com.ghy.common.enums.OrderStatus;
import com.ghy.common.enums.WxMsgEnum;
import com.ghy.common.utils.WechatMsgUtils;
import com.ghy.customer.domain.CustomerAddress;
import com.ghy.customer.service.CustomerAddressService;
import com.ghy.order.domain.AfterServiceRecord;
import com.ghy.order.domain.OrderCallRecord;
import com.ghy.order.domain.OrderDetail;
import com.ghy.order.domain.OrderMaster;
import com.ghy.order.service.IAfterServiceRecordService;
import com.ghy.order.service.IOrderCallRecordService;
import com.ghy.order.service.OrderDetailService;
import com.ghy.order.service.OrderMasterService;
import com.ghy.goods.domain.Goods;
import com.ghy.goods.domain.GoodsStandard;
import com.ghy.goods.service.GoodsService;
import com.ghy.goods.service.GoodsStandardService;
import com.ghy.order.domain.*;
import com.ghy.order.service.*;
import com.ghy.payment.domain.FinancialChangeRecord;
import com.ghy.payment.domain.FinancialDetail;
import com.ghy.payment.domain.FinancialMaster;
import com.ghy.payment.domain.OrderTimeoutRecord;
import com.ghy.payment.mapper.OrderFineRecordMapper;
import com.ghy.payment.service.FinancialChangeRecordService;
import com.ghy.payment.service.FinancialDetailService;
import com.ghy.payment.service.FinancialMasterService;
import com.ghy.quartz.service.OrderService;
import com.ghy.system.domain.SysArea;
import com.ghy.system.domain.SysDeptConfig;
import com.ghy.system.service.ISysAreaService;
import com.ghy.system.service.ISysDeptConfigService;
import com.ghy.system.service.IWxMsgService;
import com.ghy.web.controller.order.OrderController;
import com.ghy.web.pojo.vo.OrderListRequest;
import com.ghy.web.pojo.vo.OrderListResponse;
import com.ghy.web.pojo.vo.OrderStandard;
import com.ghy.worker.domain.Worker;
import com.ghy.worker.domain.WorkerCertification;
import com.ghy.worker.service.IWorkerCertificationService;
import com.ghy.worker.service.WorkerService;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.time.DateUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.Assert;
import org.springframework.util.CollectionUtils;
import org.springframework.web.bind.annotation.RequestBody;
import javax.annotation.Resource;
import java.math.BigDecimal;
import java.text.SimpleDateFormat;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.ZoneId;
import java.util.*;
import java.util.stream.Collectors;
@ -83,6 +99,20 @@ public class OrderServiceImpl implements OrderService {
private CustomerAddressService customerAddressService;
@Autowired
private IOrderCallRecordService orderCallRecordService;
@Resource
private OrderGoodsService orderGoodsService;
@Resource
private ISysAreaService sysAreaService;
@Resource
private CustomerAddressService addressService;
@Resource
private GoodsService goodsService;
@Resource
private GoodsStandardService goodsStandardService;
@Resource
private FinancialChangeRecordService financialChangeRecordService;
@Resource
private IWorkerCertificationService workerCertificationService;
@Override
public void overTimeOrder(String orderStatus) {
@ -191,9 +221,9 @@ public class OrderServiceImpl implements OrderService {
orderMasterService.updateTimeout(order.getId(), 1);
timeout = true;
//主单超时未约未排
log.info("主订单是否未约未排[{}]",order.getIsCall());
log.info("主订单是否未约未排[{}]", order.getIsCall());
if (order.getIsCall().equals("01")) {
log.info("主订单未约[{}]",order.getIsCall());
log.info("主订单未约[{}]", order.getIsCall());
try {
// 推送公众号通知数据。
// 消息组装。
@ -215,7 +245,7 @@ public class OrderServiceImpl implements OrderService {
}
//主订单未排
if (order.getIsCall().equals("02")) {
log.info("主订单未排[{}]",order.getIsCall());
log.info("主订单未排[{}]", order.getIsCall());
try {
// 推送公众号通知数据。
// 消息组装。
@ -263,11 +293,12 @@ public class OrderServiceImpl implements OrderService {
}
}
public boolean isInTimeRange(LocalTime now,int hour,int minute) {
LocalTime start = LocalTime.of(hour, minute-1, 59); // 17:29:59
public boolean isInTimeRange(LocalTime now, int hour, int minute) {
LocalTime start = LocalTime.of(hour, minute - 1, 59); // 17:29:59
LocalTime end = LocalTime.of(hour, minute, 59); // 17:30:59
return !now.isBefore(start) && !now.isAfter(end);
}
/**
* 判断是否超时
*
@ -287,10 +318,10 @@ public class OrderServiceImpl implements OrderService {
boolean afterTimeout = ONE.equals(order.getAfterTimeout());
List<AfterServiceRecord> afterServiceRecord = afterServiceRecordService.selectAfterServiceRecordList(afterParam);
if (CollectionUtil.isNotEmpty(afterServiceRecord) && (afterServiceRecord.get(0).getCustomerFinalCheck() == null || afterServiceRecord.get(0).getCustomerFinalCheck() != 1L)) {
log.info("售后订单更新时间{},售后订单是否超时{}",afterServiceRecord.get(0).getUpdateTime(),afterTimeout);
log.info("售后订单更新时间{},售后订单是否超时{}", afterServiceRecord.get(0).getUpdateTime(), afterTimeout);
// 查询一下售后单时间
Date afterTime = getOverTime(afterServiceRecord.get(0).getUpdateTime(), 30 * 60 * 1000);
if (afterTime.before(now)&&!afterTimeout) {
if (afterTime.before(now) && !afterTimeout) {
log.info("售后订单[{}]超时30分钟", order.getId());
orderDetailService.updateAfterTimeout(order.getId(), 1, 0);
// 售后超时通知
@ -323,13 +354,13 @@ public class OrderServiceImpl implements OrderService {
// 服务中状态要按预计上门时间计算4h超时
Date overTime = DateUtils.addMilliseconds(order.getExpectTimeStart(), 30 * 60 * 1000);
Date oneHourTime=DateUtils.addMilliseconds(order.getExpectTimeStart(), -60 * 60 * 1000);
Date oneHourTime = DateUtils.addMilliseconds(order.getExpectTimeStart(), -60 * 60 * 1000);
// 1. 定位到今日 00:00
Date todayStart = DateUtils.truncate(order.getExpectTimeStart(), Calendar.DATE);
// 2. 增加 1 天
Date tomorrowStart = DateUtils.addDays(todayStart, 1);
log.info("订单开始前一个小时 订单号：[{}]时间：{} 当前时间 {} 是否为同一时间小时{} 分钟{}", order.getId(),oneHourTime,now,oneHourTime.getHours(),oneHourTime.getMinutes());
log.info("订单开始前一个小时 订单号：[{}]时间：{} 当前时间 {} 是否为同一时间小时{} 分钟{}", order.getId(), oneHourTime, now, oneHourTime.getHours(), oneHourTime.getMinutes());
LocalTime currentTime = LocalTime.now(); // 当前系统时间
if (overTime.before(now)) {
log.info("订单[{}]待上门状态超时30分钟", order.getId());
@ -360,7 +391,7 @@ public class OrderServiceImpl implements OrderService {
log.error(e.getMessage(), e);
}
}
if (isInTimeRange(currentTime,oneHourTime.getHours(),oneHourTime.getMinutes())){
if (isInTimeRange(currentTime, oneHourTime.getHours(), oneHourTime.getMinutes())) {
log.info("订单[{}]约一小时上门服务", order.getId());
try {
// 推送公众号通知数据。
@ -382,76 +413,7 @@ public class OrderServiceImpl implements OrderService {
log.error(e.getMessage(), e);
}
}
//TODO: 需要定时
log.info("明日订单时间{} 是否小于明日时间{} 是否为17:50{}",tomorrowStart,now.before(tomorrowStart),isInTimeRange(currentTime,14,45));
if(isInTimeRange(currentTime,14,55)){
if(now.before(tomorrowStart)){
log.info("订单[{}]明日订单通知", order.getId());
try {
// 推送公众号通知数据。
Worker worker = workerService.selectById(order.getWorkerId());
OrderMaster orderMaster = orderMasterService.selectById(order.getOrderMasterId());
// 消息组装。
Map<String, Object> paramsNew = new HashMap<>();
// 订单编号
paramsNew.put("thing13", "您有1条订单明日待上门/待服务");
// 名称
paramsNew.put("thing7", "进入【我的订单--明日单】查看和准备");
CustomerAddress address = customerAddressService.selectByCustomerAddressId(orderMaster.getAddressId());
paramsNew.put("character_string23", "进入见详情");
// 预约时间
paramsNew.put("time4", com.ghy.common.utils.DateUtils.parseDateToStr("yyyy年MM月dd日 HH:mm", new Date()));
WechatMsgUtils.sendWeChatMsg(WechatMsgUtils.getToken(), worker.getWxOpenId(), WxMsgEnum.TOMORROW_ORDER, paramsNew);
} catch (Exception e) {
log.error(e.getMessage(), e);
}
}
//是否有搁置单
if (ONE.equals(order.getShelveStatus())){
try {
// 推送公众号通知数据。
Worker worker = workerService.selectById(order.getWorkerId());
OrderMaster orderMaster = orderMasterService.selectById(order.getOrderMasterId());
// 消息组装。
Map<String, Object> paramsNew = new HashMap<>();
// 订单编号
paramsNew.put("thing13", "您有《无法排单》需再次联系客户");
// 名称
paramsNew.put("thing7", "请进入【我的订单--搁置单】操作处理");
CustomerAddress address = customerAddressService.selectByCustomerAddressId(orderMaster.getAddressId());
paramsNew.put("character_string23", "进入见详情");
// 预约时间
paramsNew.put("time4", com.ghy.common.utils.DateUtils.parseDateToStr("yyyy年MM月dd日 HH:mm", new Date()));
WechatMsgUtils.sendWeChatMsg(WechatMsgUtils.getToken(), worker.getWxOpenId(), WxMsgEnum.DEFAULT_HANDLE_ORDER, paramsNew);
} catch (Exception e) {
log.error(e.getMessage(), e);
}
}
//售后单
if(CollectionUtil.isNotEmpty(afterServiceRecord)){
try {
// 推送公众号通知数据。
Worker worker = workerService.selectById(order.getWorkerId());
OrderMaster orderMaster = orderMasterService.selectById(order.getOrderMasterId());
// 消息组装。
Map<String, Object> paramsNew = new HashMap<>();
// 订单编号
paramsNew.put("thing13", "售后巡查，您或您下级售后单未完成");
// 名称
paramsNew.put("thing7", "请进入【我的订单--售后中】查看处理");
CustomerAddress address = customerAddressService.selectByCustomerAddressId(orderMaster.getAddressId());
paramsNew.put("character_string23", "进入见详情");
// 预约时间
paramsNew.put("time4", com.ghy.common.utils.DateUtils.parseDateToStr("yyyy年MM月dd日 HH:mm", new Date()));
WechatMsgUtils.sendWeChatMsg(WechatMsgUtils.getToken(), worker.getWxOpenId(), WxMsgEnum.DEFAULT_HANDLE_ORDER, paramsNew);
} catch (Exception e) {
log.error(e.getMessage(), e);
}
}
}
}
// 未超时的单
else if (order.getOrderStatus().equals(OrderStatus.SERVER.code())) {
@ -761,39 +723,18 @@ public class OrderServiceImpl implements OrderService {
@Override
public void timeOutOrder() {
List<OrderMaster> orderMasters = orderMasterService.selectByStatus(orderMasterTimeoutStatus);
log.info("超时巡查扫描到{}条未完成的主订单", orderMasters.size());
for (OrderMaster orderMaster : orderMasters) {
try {
timeOutOrder(orderMaster);
} catch (Exception e) {
log.error("主单超时定时任务执行:单号:{},错误原因:{}", orderMaster.getCode(), e.getMessage());
e.printStackTrace();
}
List<Worker> workList = workerService.getWorkList(null);
for (Worker worker : workList) {
OrderListRequest orderListRequest = new OrderListRequest();
}
// 查询符合超时的子单
List<OrderDetail> orders = orderDetailService.selectByStatus(timeoutOrderStatus);
log.info("超时巡查扫描到{}条未完成的子订单", orders.size());
for (OrderDetail order : orders) {
try {
timeOutOrder(order);
} catch (Exception e) {
log.error("子单超时定时任务执行:单号:{},错误原因:{}", order.getCode(), e.getMessage());
e.printStackTrace();
}
}
}
public void timeOutOrder(OrderMaster order) {
log.info("超时巡查超时开始:单号:{}, 内容:{}", order.getCode(), order);
Date now = new Date();
// 待接单状态的超时逻辑
if (ZERO.equals(order.getOrderStatus())) {
log.info("超时巡查单号:{},状态:{},创建时间:{},更新时间:{}", order.getCode(), order.getOrderStatus(), order.getCreateTime(), order.getUpdateTime());
// 是否已经超时
boolean timeout = ONE.equals(order.getTimeout());
if (timeout){
orderListRequest.setDeptId(worker.getDeptId());
orderListRequest.setTimeout(1);
orderListRequest.setWorkerId(worker.getWorkerId());
orderListRequest.setIsMonitoredOrder(true);
orderListRequest.setNeedImgs(false);
long num = this.appMixOrderCount(orderListRequest);
log.info("超时巡查超时数量{},超时师傅名称{}",num,worker.getName());
if (num > 0) {
try {
// 推送公众号通知数据。
// 消息组装。
@ -803,79 +744,542 @@ public class OrderServiceImpl implements OrderService {
// 名称
paramsNew.put("thing7", "超时巡查，您或您下级订单超时中");
paramsNew.put("character_string23", "进入见详情");
paramsNew.put("character_string23", num);
// 预约时间
paramsNew.put("time4", com.ghy.common.utils.DateUtils.parseDateToStr("yyyy年MM月dd日 HH:mm", new Date()));
Worker worker = workerService.selectById(order.getWorkerId());
WechatMsgUtils.sendWeChatMsg(WechatMsgUtils.getToken(), worker.getWxOpenId(), WxMsgEnum.DEFAULT_HANDLE_ORDER, paramsNew);
} catch (Exception e) {
log.error(e.getMessage(), e);
}
}
return;
}
// 未派单状态的超时逻辑
if (ONE.equals(order.getOrderStatus())) {
log.info("超时巡查单号:{},状态:{},创建时间:{},更新时间:{}", order.getCode(), order.getOrderStatus(), order.getCreateTime(), order.getUpdateTime());
boolean timeout = ONE.equals(order.getTimeout());
if (timeout) {
}
@Override
public void AfterSalesAndShelveOrder() {
List<Worker> workList = workerService.getWorkList(null);
for (Worker worker : workList) {
OrderListRequest orderListRequest = new OrderListRequest();
OrderDetail orderDetail1 = new OrderDetail();
orderDetail1.setDeptId(worker.getDeptId());
orderDetail1.setWorkerId(worker.getWorkerId());
orderDetail1.setShelveStatus(1);
long num =orderDetailService.countOrderDetailList(orderDetail1);
log.info("搁置单巡查超时数量{},超时师傅名称{}",num,worker.getName());
if (num > 0) {
try {
// 推送公众号通知数据。
// 消息组装。
Map<String, Object> paramsNew = new HashMap<>();
// 订单编号
paramsNew.put("thing13", "超时巡查，您或您下级订单超时中");
paramsNew.put("thing13", "您有《无法排单》需再次联系客户");
// 名称
paramsNew.put("thing7", "超时巡查，您或您下级订单超时中");
paramsNew.put("character_string23", "进入见详情");
paramsNew.put("thing7", "请进入【我的订单--搁置单】操作处理");
paramsNew.put("character_string23", num);
// 预约时间
paramsNew.put("time4", com.ghy.common.utils.DateUtils.parseDateToStr("yyyy年MM月dd日 HH:mm", new Date()));
Worker worker = workerService.selectById(order.getWorkerId());
WechatMsgUtils.sendWeChatMsg(WechatMsgUtils.getToken(), worker.getWxOpenId(), WxMsgEnum.DEFAULT_HANDLE_ORDER, paramsNew);
} catch (Exception e) {
log.error(e.getMessage(), e);
}
}
}
}
public void timeOutOrder(OrderDetail order) {
log.info("超时巡查子单超时开始:单号:{}, 内容:{}", order.getCode(), order);
Date now = new Date();
// 是否超时
boolean timeout = ONE.equals(order.getTimeout());
// 超时扣款次数
if (timeout) {
log.info("超时巡查单号:{},状态:{},创建时间:{},更新时间:{}", order.getCode(), order.getOrderStatus(), order.getCreateTime(), order.getUpdateTime());
// 待上门超时
if (timeoutOrderStatus.contains(order.getOrderStatus())) {
OrderDetail orderDetail = new OrderDetail();
orderDetail.setDeptId(worker.getDeptId());
orderDetail.setOrderStatus(OrderStatus.RECEIVE.code());
orderDetail.setWorkerId(worker.getWorkerId());
orderDetail.setShelveStatus(0);
LocalDateTime tomorrow = LocalDateTime.of(LocalDate.now().plusDays(1), LocalTime.MIN);
orderDetail.setOrderStatus(OrderStatus.GOING.code());
orderDetail.setExpectTimeStart(Date.from(tomorrow.atZone(ZoneId.systemDefault()).toInstant()));
tomorrow = LocalDateTime.of(LocalDate.now().plusDays(1), LocalTime.MAX);
orderDetail.setExpectTimeEnd(Date.from(tomorrow.atZone(ZoneId.systemDefault()).toInstant()));
long tomorrowNum =orderDetailService.countOrderDetailList(orderDetail);
log.info("明日单巡查超时数量{},超时师傅名称{}",num,worker.getName());
if (tomorrowNum>0){
log.info("订单[{}]明日订单通知", worker.getName());
try {
// 推送公众号通知数据。
// 消息组装。
Map<String, Object> paramsNew = new HashMap<>();
// 订单编号
paramsNew.put("thing13", "超时巡查，您或您下级订单超时中");
paramsNew.put("thing13", "您有1条订单明日待上门/待服务");
// 名称
paramsNew.put("thing7", "超时巡查，您或您下级订单超时中");
paramsNew.put("thing7", "进入【我的订单--明日单】查看和准备");
paramsNew.put("character_string23", "进入见详情");
paramsNew.put("character_string23", tomorrowNum);
// 预约时间
paramsNew.put("time4", com.ghy.common.utils.DateUtils.parseDateToStr("yyyy年MM月dd日 HH:mm", new Date()));
WechatMsgUtils.sendWeChatMsg(WechatMsgUtils.getToken(), worker.getWxOpenId(), WxMsgEnum.TOMORROW_ORDER, paramsNew);
} catch (Exception e) {
log.error(e.getMessage(), e);
}
}
orderListRequest = new OrderListRequest();
orderListRequest.setDeptId(worker.getDeptId());
orderListRequest.setWorkerId(worker.getWorkerId());
orderListRequest.setIsMonitoredOrder(true);
orderListRequest.setAllSelfAssigned(0);
orderListRequest.setNeedImgs(false);
AjaxResult afterListRes = this.appMixAfterList(orderListRequest);
List<AfterServiceRecord> afterList = (List<AfterServiceRecord>) afterListRes.get("data");
log.info("售后单巡查超时数量{},超时师傅名称{}",num,worker.getName());
if (afterList.size()>0){
log.info("订单[{}]售后巡查订单通知", worker.getName());
try {
// 推送公众号通知数据。
// 消息组装。
Map<String, Object> paramsNew = new HashMap<>();
// 订单编号
paramsNew.put("thing13", "售后巡查，您或您下级售后单未完成");
// 名称
paramsNew.put("thing7", "请进入【我的订单--售后中】查看处理");
paramsNew.put("character_string23", afterList.size());
// 预约时间
paramsNew.put("time4", com.ghy.common.utils.DateUtils.parseDateToStr("yyyy年MM月dd日 HH:mm", new Date()));
// Worker worker = workerService.selectById(order.getWorkerId());
OrderMaster orderMaster = orderMasterService.selectById(order.getOrderMasterId());
Worker worker = workerService.selectById(orderMaster.getWorkerId());
WechatMsgUtils.sendWeChatMsg(WechatMsgUtils.getToken(), worker.getWxOpenId(), WxMsgEnum.DEFAULT_HANDLE_ORDER, paramsNew);
} catch (Exception e) {
log.error(e.getMessage(), e);
}
}
return;
}
}
public long appMixOrderCount(OrderListRequest orderListRequest) {
long count = 0;
// 校验参数
Assert.notNull(orderListRequest.getWorkerId(), "师傅id不能为空");
// 查询子单
OrderDetail orderDetailReq = new OrderDetail();
BeanUtils.copyProperties(orderListRequest, orderDetailReq);
List<OrderDetail> list = orderDetailService.selectOrderDetailList(orderDetailReq);
count += list.size();
List<OrderMaster> allList = new ArrayList<>();
List<Long> masterIdSet = new ArrayList<Long>();
if (orderListRequest.getTimeout() != null && orderListRequest.getTimeout() == 1) {
// 增加主单下子单有超时的
OrderMaster param = new OrderMaster();
param.setWorkerId(orderListRequest.getWorkerId());
List<OrderMaster> allOrderMaster = orderMasterService.selectOrderMasterList(param);
if(org.apache.commons.collections.CollectionUtils.isNotEmpty(allOrderMaster)){
OrderDetail countParam = new OrderDetail();
countParam.setMasterIds(allOrderMaster.stream().map(OrderMaster::getId).collect(Collectors.toList()));
List<OrderDetail> orderDetails = orderDetailService.selectOrderDetailList(countParam);
List<OrderDetail> result = orderDetails.stream().filter(s -> s.getTimeout().equals(1)).collect(Collectors.toList());
if (org.apache.commons.collections.CollectionUtils.isNotEmpty(result)) {
masterIdSet = result.stream().map(OrderDetail::getOrderMasterId).collect(Collectors.toList());
}
}
if (org.apache.commons.collections.CollectionUtils.isNotEmpty(masterIdSet)) {
OrderMaster timeOutMaster = new OrderMaster();
timeOutMaster.setOrderMasterIdList(masterIdSet);
allList.addAll(orderMasterService.selectOrderMasterList(timeOutMaster));
}
}
// 查询主单
OrderMaster orderMasterReq = new OrderMaster();
BeanUtils.copyProperties(orderListRequest, orderMasterReq);
orderMasterReq.setExceptOrderMasterIds(masterIdSet);
List<OrderMaster> masterList = orderMasterService.selectOrderMasterList(orderMasterReq);
allList.addAll(masterList);
// 超时查询需要排除同个师傅的主单子单同时出现
if (orderListRequest.getTimeout() != null && orderListRequest.getTimeout() == 1) {
// 需要排除同个师傅的主单子单同时出现
List<OrderMaster> filteredMasterList = new ArrayList<OrderMaster>();
for (OrderMaster master : allList) {
boolean isKeep = false;
// 查询该主单下所有售后中的子单
OrderDetail detailAfterListOfMasterQry = new OrderDetail();
detailAfterListOfMasterQry.setOrderMasterCode(master.getCode());
List<OrderDetail> tmpDetailListOfMasters = orderDetailService.selectOrderDetailList(detailAfterListOfMasterQry);
List<OrderListResponse> detailListOfMasters = new ArrayList<>();
tmpDetailListOfMasters.forEach(model -> {
OrderListResponse response = new OrderListResponse();
BeanUtils.copyProperties(model, response);
detailListOfMasters.add(response);
});
for (OrderListResponse detailListOfMaster : detailListOfMasters) {
if (!detailListOfMaster.getWorkerId().equals(orderListRequest.getWorkerId())) {
isKeep = true;
break;
}
}
if (isKeep) {
filteredMasterList.add(master);
}
}
count += filteredMasterList.size();
} else {
count += masterList.size();
}
return count;
}
public AjaxResult appMixAfterList(@RequestBody OrderListRequest orderListRequest) {
List<OrderListResponse> orderListResponses = new ArrayList<>();
// 校验参数
Assert.notNull(orderListRequest.getWorkerId(), "师傅id不能为空");
// 查询子单
OrderDetail orderDetailReq = new OrderDetail();
BeanUtils.copyProperties(orderListRequest, orderDetailReq);
orderDetailReq.setNeedImgs(orderListRequest.getNeedImgs());
List<OrderListResponse> detailList = this.getDetailAfterList(orderDetailReq);
orderListResponses.addAll(detailList);
// 查询主单
OrderMaster orderMasterReq = new OrderMaster();
BeanUtils.copyProperties(orderListRequest, orderMasterReq);
List<OrderListResponse> masterList = this.getMasterAfterList(orderMasterReq);
// 需要排除同个师傅的主单子单同时出现
List<OrderListResponse> filteredMasterList = new ArrayList<OrderListResponse>();
for (OrderListResponse master : masterList) {
boolean isKeep = false;
// 查询该主单下所有售后中的子单
OrderDetail detailAfterListOfMasterQry = new OrderDetail();
detailAfterListOfMasterQry.setOrderMasterCode(master.getOrderMasterCode());
List<OrderListResponse> detailAfterListOfMasters = this.getDetailAfterList(detailAfterListOfMasterQry);
for (OrderListResponse detailAfterListOfMaster : detailAfterListOfMasters) {
if (!detailAfterListOfMaster.getWorkerId().equals(orderListRequest.getWorkerId())) {
isKeep = true;
break;
}
}
long count = detailAfterListOfMasters.stream().filter(x->(x.getAfterTimeout()!=null && x.getAfterTimeout() == 1)).count();
if (isKeep) {
if(count > 0){
master.setAfterTimeout(1);
}
filteredMasterList.add(master);
}
}
orderListResponses.addAll(filteredMasterList);
// 根据更新时间倒序排列
Collections.sort(orderListResponses, new Comparator<OrderListResponse>() {
@Override
public int compare(OrderListResponse o1, OrderListResponse o2) {
return o2.getUpdateTime().compareTo(o1.getUpdateTime());
}
});
return AjaxResult.success(orderListResponses);
}
public List<OrderListResponse> getMasterAfterList(OrderMaster orderMaster) {
// 查所有售后的单
AfterServiceRecord afterServiceRecord = new AfterServiceRecord();
afterServiceRecord.setExcludeAfterServiceFinished(Boolean.TRUE);
List<AfterServiceRecord> afterServiceRecordList = afterServiceRecordService.selectAfterServiceRecordList(afterServiceRecord);
// 踢重后的子单ids
List<Long> detailIds = afterServiceRecordList.stream().map(AfterServiceRecord::getOrderDetailId).distinct().collect(Collectors.toList());
StringBuilder orderDetailIds = new StringBuilder();
OrderDetail orderDetail = new OrderDetail();
orderDetail.setCustomerId(orderMaster.getCustomerId());
orderDetail.setDeptId(orderMaster.getDeptId());
detailIds.forEach(id -> {
orderDetailIds.append(id).append(",");
});
String ids = orderDetailIds.toString();
if (StringUtils.isNotEmpty(ids)) {
orderDetail.setOrderDetailIds(ids.substring(0, ids.length() - 1));
} else {
orderDetail.setOrderDetailIds("0");
}
// 所有售后的子单
List<OrderDetail> orderDetailList = orderDetailService.selectOrderDetailList(orderDetail);
StringBuilder orderMasterIds = new StringBuilder();
orderDetailList.stream().map(OrderDetail::getOrderMasterId).distinct()
.collect(Collectors.toList()).forEach(id -> {
orderMasterIds.append(id).append(",");
});
String orderIds = orderMasterIds.toString();
if (StringUtils.isNotEmpty(orderIds)) {
orderMaster.setOrderMasterIds(orderIds.substring(0, orderIds.length() - 1));
} else {
orderMaster.setOrderMasterIds("0");
}
List<OrderListResponse> orderListResponses = new ArrayList<>();
List<OrderMaster> list = orderMasterService.selectOrderMasterList(orderMaster);
list.forEach(master -> {
//子单
List<OrderDetail> detailList = orderDetailService.selectByOrderMasterId(master.getId());
// 初始化属性
OrderListResponse orderListResponse = new OrderListResponse();
List<OrderStandard> standardList = new ArrayList<>();
// 师傅信息
Worker worker = master.getWorkerId() != null ? workerService.selectById(master.getWorkerId()) : null;
// 消费者信息
// Customer customer = customerService.selectByCustomerId(master.getCustomerId());
// 商品规格及信息
List<OrderGoods> orderStandardList = orderGoodsService.selectByOrderMasterId(master.getId());
// 商品信息
GoodsStandard goodsStandard = goodsStandardService.selectById(orderStandardList.get(0).getGoodsStandardId());
Goods goods = goodsService.selectById(goodsStandard.getGoodsId());
// 财务信息
FinancialMaster financialMaster = financialMasterService.selectByOrderMasterId(master.getId());
BigDecimal totalPayMoney = financialMaster.getPayMoney();
// BigDecimal totalChangeMoney = new BigDecimal(0);
// for (OrderDetail detail: detailList) {
// // 查询子单加价记录
// FinancialChangeRecord changeRecordQry = new FinancialChangeRecord();
// changeRecordQry.setOrderDetailId(detail.getId());
// List<FinancialChangeRecord> financialChangeRecords = financialChangeRecordService.selectFinancialChangeRecordList(changeRecordQry);
// if (CollectionUtils.isNotEmpty(financialChangeRecords)) {
// totalChangeMoney = totalChangeMoney.add(financialChangeRecords.get(0).getChangeMoney());
// }
// }
// totalPayMoney = totalPayMoney.add(totalChangeMoney);
// 地址信息
CustomerAddress customerAddress = addressService.selectByCustomerAddressId(master.getAddressId());
SysArea sysArea;
if(customerAddress.getStreetId()!=null){
sysArea = sysAreaService.selectById(customerAddress.getStreetId());
}else {
sysArea = sysAreaService.selectById(customerAddress.getCountryId());
}
String completeAddress = sysArea.getMergerName().replaceAll(",", "") + customerAddress.getAddress();
// 查询售后记录
List<AfterServiceRecord> afterServiceRecords = new ArrayList<>();
List<OrderDetail> detailOrderList = orderDetailService.selectByOrderMasterId(master.getId());
detailOrderList.stream().forEach(detail -> {
AfterServiceRecord afterServiceRecordQry = new AfterServiceRecord();
afterServiceRecordQry.setOrderDetailId(detail.getId());
List<AfterServiceRecord> records = afterServiceRecordService.selectAfterServiceRecordList(afterServiceRecordQry);
afterServiceRecords.addAll(records);
});
for (OrderGoods orderGoods : orderStandardList) {
OrderStandard orderStandard = new OrderStandard();
orderStandard.setStandardName(orderGoods.getGoodsName());
orderStandard.setStandardNum(orderGoods.getGoodsNum());
standardList.add(orderStandard);
}
// 编辑返回属性
orderListResponse.setGoodsBrand(master.getGoodsBrand());
orderListResponse.setGoodsSpecification(master.getGoodsSpecification());
orderListResponse.setOrderMasterId(master.getId());
orderListResponse.setGoodsName(goods.getGoodsName());
orderListResponse.setGoodsLogoUrl(goods.getGoodsImgUrl());
orderListResponse.setDiscountMoney(financialMaster.getDiscountMoney());
orderListResponse.setTotalMoney(financialMaster.getTotalMoney());
orderListResponse.setPayMoney(totalPayMoney);
// orderListResponse.setChangeMoney(totalChangeMoney);
orderListResponse.setWorkerName(worker == null ? "" : worker.getName());
orderListResponse.setWorkerPhone(worker == null ? "" : worker.getPhone());
orderListResponse.setCustomerName(customerAddress.getName());
orderListResponse.setCustomerPhone(customerAddress.getPhone());
orderListResponse.setServerTime(master.getRevTime());
orderListResponse.setExpectTimeStart(master.getExpectTimeStart());
orderListResponse.setExpectTimeEnd(master.getExpectTimeEnd());
orderListResponse.setExpectTimeStartFront(master.getExpectTimeStart());
orderListResponse.setExpectTimeEndFront(master.getExpectTimeEnd());
orderListResponse.setOrderStatus(master.getOrderStatus());
orderListResponse.setPayStatus(master.getPayStatus());
orderListResponse.setPayType(master.getPayType());
orderListResponse.setOrderMasterCode(master.getCode());
orderListResponse.setStandardList(standardList);
orderListResponse.setAddress(completeAddress);
orderListResponse.setRemark(goods.getRemark());
orderListResponse.setCustomerRemark(master.getRemark());
orderListResponse.setTimeout(master.getTimeout());
orderListResponse.setTimeoutFineTimes(master.getTimeoutFineTimes());
orderListResponse.setAfterServiceRecordList(afterServiceRecords);
orderListResponse.setCreateTime(master.getCreateTime());
orderListResponse.setUpdateTime(master.getUpdateTime());
orderListResponses.add(orderListResponse);
});
return orderListResponses;
}
public List<OrderListResponse> getDetailAfterList(OrderDetail orderDetail) {
AfterServiceRecord afterServiceRecord = new AfterServiceRecord();
afterServiceRecord.setExcludeAfterServiceFinished(Boolean.TRUE);
afterServiceRecord.setNeedImgs(orderDetail.getNeedImgs());
List<AfterServiceRecord> afterServiceRecordList = afterServiceRecordService.selectAfterServiceRecordList(afterServiceRecord);
Map<Long, List<AfterServiceRecord>> detailRecordMap = afterServiceRecordList.stream().collect(Collectors.groupingBy(record -> record.getOrderDetailId()));
// 踢重后的子单ids
List<Long> detailIds = afterServiceRecordList.stream().map(AfterServiceRecord::getOrderDetailId).distinct().collect(Collectors.toList());
StringBuilder orderDetailIds = new StringBuilder();
detailIds.forEach(id -> {
orderDetailIds.append(id).append(",");
});
String ids = orderDetailIds.toString();
if (StringUtils.isNotEmpty(ids)) {
orderDetail.setOrderDetailIds(ids.substring(0, ids.length() - 1));
} else {
orderDetail.setOrderDetailIds("0");
}
List<OrderListResponse> orderListResponses = new ArrayList<>();
List<OrderDetail> list = orderDetailService.selectOrderDetailList(orderDetail);
list.forEach(detail -> {
// 主单信息
OrderMaster orderMaster = orderMasterService.selectById(detail.getOrderMasterId());
// 初始化属性
OrderListResponse orderListResponse = new OrderListResponse();
List<OrderStandard> standardList = new ArrayList<>();
// 师傅信息
Worker worker = workerService.selectById(detail.getWorkerId());
WorkerCertification workerRealInfo = null;
String workerName = "";
if (worker != null) {
// 师傅实名信息
workerRealInfo = workerCertificationService.selectByWorkerId(orderMaster.getWorkerId());
workerName = workerRealInfo == null ? worker.getName() : workerRealInfo.getSurname()+workerRealInfo.getName();
}
// 消费者信息
// Customer customer = customerService.selectByCustomerId(detail.getCustomerId());
// 商品规格及信息
List<OrderGoods> orderStandardList = orderGoodsService.selectByOrderDetailId(detail.getId());
// 商品信息
GoodsStandard goodsStandard = goodsStandardService.selectById(orderStandardList.get(0).getGoodsStandardId());
Goods goods = goodsService.selectById(goodsStandard.getGoodsId());
// 财务信息
FinancialDetail financialDetail = financialDetailService.selectByOrderDetailId(detail.getId());
BigDecimal detailPayMoney = financialDetail.getPayMoney();
// 查询子单加价记录
FinancialChangeRecord financialChangeRecord = financialChangeRecordService.selectNotPayRecordByDetailId(detail.getId());
BigDecimal changeMoney = financialChangeRecord == null ? BigDecimal.ZERO : financialChangeRecord.getChangeMoney();
// 地址信息
CustomerAddress customerAddress = addressService.selectByCustomerAddressId(orderMaster.getAddressId());
SysArea sysArea;
if(customerAddress.getStreetId()!=null){
sysArea = sysAreaService.selectById(customerAddress.getStreetId());
}else {
sysArea = sysAreaService.selectById(customerAddress.getCountryId());
}
String completeAddress = sysArea.getMergerName().replaceAll(",", "") + customerAddress.getAddress();
for (OrderGoods orderGoods : orderStandardList) {
OrderStandard orderStandard = new OrderStandard();
orderStandard.setStandardName(orderGoods.getGoodsName());
orderStandard.setStandardNum(orderGoods.getGoodsNum());
orderStandard.setServerNum(orderGoods.getServerGoodsNum());
orderStandard.setFinishTime(orderGoods.getFinishTime());
orderStandard.setWaitServerNum(orderGoods.getGoodsNum() - orderGoods.getServerGoodsNum());
standardList.add(orderStandard);
}
if (this.checkIsOnlyServer(orderMaster.getId(), detail.getWorkerId())) {
FinancialMaster financialMaster = financialMasterService.selectByOrderMasterId(detail.getOrderMasterId());
BigDecimal workerFee = financialMaster.getPayMoney();
List<FinancialDetail> financialDetailList = financialDetailService.selectByFinancialMasterId(financialMaster.getId());
for (FinancialDetail param : financialDetailList) {
if (!detail.getWorkerId().equals(param.getPayeeId())) {
workerFee = workerFee.subtract(param.getPayMoney());
}
}
orderListResponse.setPayMoney(workerFee);
orderListResponse.setIsOnlyServ(Boolean.TRUE);
} else {
orderListResponse.setPayMoney(detailPayMoney);
orderListResponse.setIsOnlyServ(Boolean.FALSE);
}
// 编辑返回属性
orderListResponse.setGoodsBrand(orderMaster.getGoodsBrand());
orderListResponse.setGoodsSpecification(orderMaster.getGoodsSpecification());
orderListResponse.setOrderDetailId(detail.getId());
orderListResponse.setOrderDetailCode(detail.getCode());
orderListResponse.setOrderMasterId(detail.getOrderMasterId());
orderListResponse.setOrderMasterCode(detail.getOrderMasterCode());
orderListResponse.setGoodsName(goods.getGoodsName());
orderListResponse.setGoodsLogoUrl(goods.getGoodsImgUrl());
orderListResponse.setDiscountMoney(financialDetail.getDiscountMoney());
orderListResponse.setTotalMoney(financialDetail.getTotalMoney());
orderListResponse.setWorkerId(detail.getWorkerId());
orderListResponse.setWorkerName(workerName);
orderListResponse.setWorkerPhone(worker == null ? "" : worker.getPhone());
orderListResponse.setCustomerName(customerAddress.getName());
orderListResponse.setCustomerPhone(customerAddress.getPhone());
orderListResponse.setOrderStatus(detail.getOrderStatus());
orderListResponse.setPayStatus(orderMaster.getPayStatus());
orderListResponse.setPayType(orderMaster.getPayType());
orderListResponse.setStandardList(standardList);
orderListResponse.setAddress(completeAddress);
orderListResponse.setServerTime(detail.getRevTime());
orderListResponse.setExpectTimeStart(detail.getExpectTimeStart());
orderListResponse.setExpectTimeEnd(detail.getExpectTimeEnd());
orderListResponse.setExpectTimeStartFront(detail.getExpectTimeStart());
orderListResponse.setExpectTimeEndFront(detail.getExpectTimeEnd());
orderListResponse.setWorkBeginTime(detail.getWorkBeginTime());
orderListResponse.setWorkFinishTime(detail.getWorkFinishTime());
orderListResponse.setRemark(goods.getRemark());
orderListResponse.setCustomerRemark(orderMaster.getRemark());
orderListResponse.setOrderType(detail.getOrderType());
orderListResponse.setTimeout(detail.getTimeout());
orderListResponse.setAfterTimeout(detail.getAfterTimeout());
orderListResponse.setAfterServiceRecordList(detailRecordMap.get(detail.getId()));
orderListResponse.setChangeMoney(changeMoney);
orderListResponse.setDrawCashStatus(detail.getDrawCashStatus());
orderListResponse.setDrawCashTime(detail.getDrawCashTime());
orderListResponse.setCreateTime(detail.getCreateTime());
orderListResponse.setUpdateTime(detail.getUpdateTime());
orderListResponses.add(orderListResponse);
});
return orderListResponses;
}
private boolean checkIsOnlyServer(Long orderMasterId, Long workId) {
// 找出原单的数量
List<OrderGoods> orderGoodsList = orderGoodsService.selectByOrderMasterId(orderMasterId);
// 找出原单关联的细单的商品数量
List<OrderDetail> orderDetailList = orderDetailService.selectByOrderMasterId(orderMasterId);
for (OrderDetail detail : orderDetailList) {
// 非一个师傅接单
if (!workId.equals(detail.getWorkerId())) {
return false;
}
// 子单数量
List<OrderGoods> orderDetailGoodsList = orderGoodsService.selectByOrderDetailId(detail.getId());
// 计算剩余未分配的商品数量
for (OrderGoods detailGoods : orderDetailGoodsList) {
for (OrderGoods masterGoods : orderGoodsList) {
if (Objects.equals(masterGoods.getGoodsStandardId(), detailGoods.getGoodsStandardId())) {
masterGoods.setGoodsNum(masterGoods.getGoodsNum() - detailGoods.getGoodsNum());
}
}
}
}
// 有单派完.
for (OrderGoods orderGoods : orderGoodsList) {
if (orderGoods.getGoodsNum() > 0) {
return false;
}
}
return true;
}
}

10
ghy-quartz/src/main/java/com/ghy/quartz/task/OrderTask.java
View File

@ -57,4 +57,14 @@ public class OrderTask {
}
}
/**
* 定点巡查
*/
public void AfterSalesAndShelveOrder() {
try {
orderService.timeOutOrder();
} catch (Exception e) {
log.error(e.getMessage(), e);
}
}
}