提交全量运单监控功能

performance-web/src/main/java/com/clx/performance/dao/OrderChildDao.java

@@ -64,4 +64,6 @@ public interface OrderChildDao extends BaseDao<OrderChildMapper, OrderChild, Int
     List<OrderChild> listOrderChild(List<Integer> status);
 
     List<OrderChild> getOrderChildByOrderNo(String orderNo);
+
+    boolean updateArriveSendAddress(OrderChild orderChild);
 }

performance-web/src/main/java/com/clx/performance/dao/impl/OrderChildDaoImpl.java

@@ -216,6 +216,17 @@ public class OrderChildDaoImpl extends BaseDaoImpl<OrderChildMapper, OrderChild,
 
     }
 
+    @Override
+    public boolean updateArriveSendAddress(OrderChild item) {
+        return update(lUdWrapper()
+                .eq(OrderChild::getId, item.getId())
+                .set(OrderChild::getStatus, item.getStatus())
+                .set(OrderChild :: getArriveSendTime,item.getArriveSendTime())
+        );
+
+
+    }
+
     @Override
     public List<OrderChild> getOrderChildByOrderNo(String orderNo) {
         LambdaQueryWrapper<OrderChild> query = new LambdaQueryWrapper();

performance-web/src/main/java/com/clx/performance/dto/OrderChildExpectDTO.java

@@ -22,5 +22,7 @@ public class OrderChildExpectDTO implements Serializable {
     private LocalDateTime expectReceiveTime;//预计到达目的地时间
     private Integer expectReceiveTimeSecond;//预计到达目的地时间
     private Integer expectTransportTimeSecond;//预计运输时间
+    private String expectTransportTime;//预计运输时间(转化秒 为几小时几分钟)
+
 
 }

performance-web/src/main/java/com/clx/performance/model/OrderChild.java

@@ -72,6 +72,7 @@ public class OrderChild implements HasKey<Integer> {
     private Integer status;                         //状态
 
     private LocalDateTime payTime;                         //支付时间(抢单时间)
+    private LocalDateTime arriveSendTime;                  //到达货源地时间
     private LocalDateTime loadTime;                        //装车时间
     private LocalDateTime unloadTime;                      //卸车时间
     private LocalDateTime settleTime;                      //结算时间

performance-web/src/main/java/com/clx/performance/service/impl/OrderChildServiceImpl.java

 package com.clx.performance.service.impl;
 
 import com.baomidou.mybatisplus.core.metadata.IPage;
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
 import com.clx.order.enums.OrderEnum;
 import com.clx.order.feign.OrderFeign;
 import com.clx.order.vo.feign.FeignAddressVO;
@@ -251,6 +252,10 @@ public class OrderChildServiceImpl implements OrderChildService {
         orderChild.setStatus(OrderChildEnum.Status.CREATED.getCode());
         orderChild.setCreateTime(now);
 
+        //计算预计时间
+        LocalDateTime[] times = calcExpectTime(truckNo,orderGoods);
+        orderChild.setExpectSendTime(times[0]);
+        orderChild.setExpectReceiveTime(times[1]);
         // 更新货单数据
         updateOrderGoodsAmount(orderGoods, truckLoad);
 
@@ -272,6 +277,43 @@ public class OrderChildServiceImpl implements OrderChildService {
         return result;
     }
 
+    /**
+     * @Author kavin
+     * @Description 计算接单时，车辆距离发货地和收货地的用时时间
+     * @Param [truckNo, orderGoods]
+     * @return [预计到达发货地时间，预计到达收货地时间]
+     **/
+    public LocalDateTime[] calcExpectTime(String truckNo,OrderGoods orderGoods){
+
+        LocalDateTime now = LocalDateTime.now();
+        Map<String, TruckTraceDTO> truckTraceMap = redisTemplate.opsForHash().entries(
+                RedisConstants.ZJXL_TRUCK_TRACE_LIST);
+
+        BigDecimal truckLongitudeX = null;
+        BigDecimal truckLatitudeY = null;
+        TruckTraceDTO truckTraceDTO = truckTraceMap.get(truckNo);
+        if (Objects.nonNull(truckTraceDTO)) {
+            truckLongitudeX = truckTraceDTO.getLocation()[0];
+            truckLatitudeY = truckTraceDTO.getLocation()[1];
+        }else{
+            //TODO 如果新增的车辆，缓存中没有中交兴路的位置信息，需要实时获取，否则这里无法获得预计时间了。
+        }
+
+        List<GdRouteDTO> sendGdRouteDTOS = getRoute(truckNo, truckLongitudeX, truckLatitudeY, orderGoods.getSendLongitude(),orderGoods.getSendLatitude());
+        Integer sendPlusTime = 0;
+        if (CollectionUtils.isNotEmpty(sendGdRouteDTOS)) {
+            sendPlusTime = sendGdRouteDTOS.get(0).getDuration();
+        }
+
+        List<GdRouteDTO> receiveGdRouteDTOS = getRoute(truckNo, truckLongitudeX, truckLatitudeY, orderGoods.getSendLongitude(),orderGoods.getSendLatitude());
+        Integer receivePlusTime = 0;
+        if (CollectionUtils.isNotEmpty(receiveGdRouteDTOS)) {
+            receivePlusTime = receiveGdRouteDTOS.get(0).getDuration();
+        }
+        return new LocalDateTime[]{now.plusSeconds(sendPlusTime),now.plusSeconds(receivePlusTime)};
+    }
+
+
     @Override
     public void updateReject(OrderChildRejectParam param) {
         UserSessionData loginUserInfo = TokenUtil.getLoginUserInfo();
@@ -374,8 +416,8 @@ public class OrderChildServiceImpl implements OrderChildService {
         }
 
         orderChild.setStatus(OrderChildEnum.Status.ARRIVE_SEND.getCode());
-        orderChildDao.updateStatus(orderChild);
-
+        orderChild.setArriveSendTime(LocalDateTime.now());
+        orderChildDao.updateArriveSendAddress(orderChild);
         // 日志
         orderChildLogService.saveDriverOrderChildLog(childNo, OrderChildLogEnum.Type.ARRIVE_SEND.getCode(),
                 OrderChildLogEnum.Type.ARRIVE_SEND.getMsg(), loginUserInfo.getUserNo(), loginUserInfo.getUserName());
@@ -1413,167 +1455,102 @@ public class OrderChildServiceImpl implements OrderChildService {
 
     @Override
     public IPage<OutputMonitorOrderChildVO> getMonitorOrerChildListsByParam(PageMonitorOrderChildQCParam param) {
-
-
-/*        Integer loadWarningTime = 40 ;
+        Integer loadWarningTime = 40 ;
         Integer arriveWarningTime = 10 ;
         Integer receiveWarningTime = 60 ;
         LocalDateTime now = LocalDateTime.now();
-
         Page<OrderChild> page = orderChildDao.pageOrderChild(param);
         List<OrderChild> records = page.getRecords();
-
-        List<OrderChildPCVO> list = orderChildStruct.convertList(page.getRecords());
-
-
-
-
-
-
-
-        Result<List<OutputMonitorOrderChildDTO>> result = new Result<>();
-
-        PageHelper.startPage(qc.getPage(), qc.getPageSize(), qc.getPage() == 1);
-
-        PageInfo<OrderChild> pageInfo = new PageInfo<>(orderChildList);
-        result.setPageNum(pageInfo.getPages());
-        result.setTotal(pageInfo.getTotal());
-        if(CollectionUtils.isEmpty(orderChildList)){
-            result.setData(null);
-            return result;
-        }
-
-        //聚合合同 获取热值
-        List<String> contractNos = orderChildList.stream().map(it -> it.getContractNo()).collect(Collectors.toList());
-        List<OrderContractQualityIndicator> orderContractQualityIndicators = orderContractQualityIndicatorDao
-        .getListOfCalorificValueByContractNoList(contractNos, "calorificValue");
-        Map<String, OrderContractQualityIndicator> contractQualityIndicatorMap = orderContractQualityIndicators
-        .stream().collect(Collectors.toMap(OrderContractQualityIndicator::getContractNo, o -> o, (v1, v2) -> v2));
-
-        //聚合运单 获取运单预估时间
-        List<String> childNoList = orderChildList.stream().map(OrderChild::getChildNo).collect(Collectors.toList());
-        List<OrderChildExpect> orderChildExpect = orderChildExpectDao.getOrderChildExpectByChildNos(childNoList,0);
-        Map<String, OrderChildExpect> orderChildExpectMap = orderChildExpect.stream().collect(Collectors.toMap
-        (OrderChildExpect::getChildNo, o -> o, (v1, v2) -> v2));
-
         List<OutputMonitorOrderChildVO> monitorOrderChildList = records.stream().map(child -> {
             OutputMonitorOrderChildVO monitorOrderChild = new OutputMonitorOrderChildVO();
-
             monitorOrderChild.setChildNo(child.getChildNo());
             monitorOrderChild.setDriverMobile(child.getDriverMobile());
             monitorOrderChild.setDriverName(child.getDriverName());
             monitorOrderChild.setLoadTime(DateUtils.formatDateTime(child.getLoadTime()).get());
-            monitorOrderChild.setPayTime(DateUtils.formatDateTime(child.getPayTime()).get());
+            monitorOrderChild.setPayTime(DateUtils.formatDateTime(child.getCreateTime()).get());
             monitorOrderChild.setTruckNo(child.getTruckNo());
             monitorOrderChild.setSendAddress(child.getSendAddress());
             monitorOrderChild.setSendAddressId(child.getSendAddressId());
             monitorOrderChild.setStatus(child.getStatus());
-
+            monitorOrderChild.setExpectArriveTime(DateUtils.formatDateTime(child.getExpectSendTime()).get());
+            monitorOrderChild.setExpectReceiveTime(DateUtils.formatDateTime(child.getExpectReceiveTime()).get());
             BigDecimal poundTonnage = child.getLoadNet();
             if(BigDecimal.ZERO.compareTo(child.getLoadNet()) <= 0){
                 poundTonnage = child.getUnloadNet();
             }
             monitorOrderChild.setLoadNet(poundTonnage);
 
+            //获取缓存实时计算的位置信息
+            List<OrderChildExpectDTO> orderChildExpect = getOrderChildExpect(child.getChildNo());
+
+            if(CollectionUtils.isNotEmpty(orderChildExpect)){
+                OrderChildExpectDTO oneExpect = orderChildExpect.get(0);
 
-            if(null != orderChildExpectMap.get(child.getChildNo())){
-                OrderChildExpect expect = orderChildExpectMap.get(child.getChildNo());
 
-                if(StringUtil.isNotEmpty(expect.getExpectArriveTime())){
-                    monitorOrderChild.setExpectArriveTime(expect.getExpectArriveTime());
-                    LocalDateTime expectArriveTime = LocalDateTimeUtils.parseTime(expect.getExpectArriveTime());
-                    LocalDateTime expectArriveWarringTime = LocalDateTimeUtils.plus(expectArriveTime,
-                    arriveWarningTime, ChronoUnit.MINUTES);
-                    if(expectArriveWarringTime.isBefore(now)
-                            && child.getStatus() < OrderChildStatusEnum.ARRIVE_SEND.getValue()){
+                //预计到货源地趋势
+                if(orderChildExpect.size() >= 2){
+                    OrderChildExpectDTO twoExpect = orderChildExpect.get(1);
+                    if(oneExpect.getExpectArriveTimeSecond() < twoExpect.getExpectArriveTimeSecond()){
+                        monitorOrderChild.setArriveTrend(0);
+                    }else{
+                        monitorOrderChild.setArriveTrend(1);
+                    }
+
+                    if(oneExpect.getExpectReceiveTimeSecond() < twoExpect.getExpectReceiveTimeSecond()){
+                        monitorOrderChild.setReceiveTrend(0);
+                    }else{
+                        monitorOrderChild.setReceiveTrend(1);
+                    }
+                }
+
+                if(Objects.nonNull(oneExpect.getExpectArriveTime())){
+                    monitorOrderChild.setExpectArriveTimeRealTime(DateUtils.formatDateTime(oneExpect.getExpectArriveTime()).get());
+                }
+                if(Objects.nonNull(oneExpect.getExpectReceiveTime())){
+                    monitorOrderChild.setExpectReceiveTimeRealTime(DateUtils.formatDateTime(oneExpect.getExpectReceiveTime()).get());
+                }
+                monitorOrderChild.setExpectTransportTime(oneExpect.getExpectTransportTime());
+
+
+
+
+                LocalDateTime expectArriveTime = oneExpect.getExpectArriveTime();
+                LocalDateTime expectArriveWarringTime = expectArriveTime.plusMinutes(arriveWarningTime);
+                if(expectArriveWarringTime.isBefore(now) && child.getStatus() < OrderChildEnum.Status.ARRIVE_SEND.getCode()){
                     monitorOrderChild.setArriveWarning(1);
                 }else{
                     monitorOrderChild.setArriveWarning(0);
                 }
-                }
 
-                if(StringUtil.isNotEmpty(expect.getExpectReceiveTime())){
-                    monitorOrderChild.setExpectReceiveTime(expect.getExpectReceiveTime());
-                    LocalDateTime expectReceiveTime = LocalDateTimeUtils.parseTime(expect.getExpectReceiveTime());
-                    LocalDateTime expectReceiveWarringTime = LocalDateTimeUtils.plus(expectReceiveTime,
-                    receiveWarningTime, ChronoUnit.MINUTES);
+                LocalDateTime expectReceiveTime = oneExpect.getExpectReceiveTime();
+                LocalDateTime expectReceiveWarringTime = expectReceiveTime.plusMinutes(receiveWarningTime);
                 if(expectReceiveWarringTime.isBefore(now)
-                            && child.getStatus() >= OrderChildStatusEnum.OWNER_LOAD.getValue()
-                            && child.getStatus() < OrderChildStatusEnum.ARRIVE_RECEIVE.getValue()){
+                        && child.getStatus() >= OrderChildEnum.Status.ARRIVE_SEND.getCode()
+                        && child.getStatus() < OrderChildEnum.Status.ARRIVE_RECEIVE.getCode()){
                     monitorOrderChild.setReceiveWarning(1);
                 }else{
                     monitorOrderChild.setReceiveWarning(0);
                 }
             }
-                monitorOrderChild.setExpectTransportTime(expect.getExpectTransportTime());
-            }
-            if(StringUtil.isNotEmpty(child.getArriveTime())
-                    && child.getStatus() >= OrderChildStatusEnum.ARRIVE_SEND.getValue()
-                    && child.getStatus() < OrderChildStatusEnum.OWNER_LOAD.getValue()){
-                LocalDateTime arriveTime = LocalDateTimeUtils.parseTime(child.getArriveTime());
-                LocalDateTime arriveWarringTime = LocalDateTimeUtils.plus(arriveTime, loadWarningTime, ChronoUnit
-                .MINUTES);
+
+
+            if(Objects.nonNull(child.getArriveSendTime())
+                    && child.getStatus() >= OrderChildEnum.Status.ARRIVE_SEND.getCode()
+                    && child.getStatus() < OrderChildEnum.Status.LOAD.getCode()){
+                LocalDateTime arriveTime = child.getArriveSendTime();
+                LocalDateTime arriveWarringTime = arriveTime.plusMinutes(loadWarningTime);
                 if(arriveWarringTime.isBefore(now)){
                     monitorOrderChild.setLoadWarning(1);
                 }else{
                     monitorOrderChild.setLoadWarning(0);
                 }
             }
-
-            List<OrderChildExpect> orderChildExpects = orderChildExpectDao.getOrderChildExpectByChildNo(child
-            .getChildNo(),1);
-            boolean expectFlag = true ;
-            if(CollectionUtils.isNotEmpty(orderChildExpects)){
-                String exceptTime = orderChildExpects.get(0).getCreateTime();
-                LocalDateTime beginTime = LocalDateTimeUtils.plus(now,-5, ChronoUnit.MINUTES);
-                if(beginTime.isBefore(LocalDateTimeUtils.parseTime(exceptTime))){
-                    expectFlag = false;
-                }
-            }
-            if(expectFlag){
-                orderChildExpectService.orderChildExpect(child.getChildNo(),child.getTruckNo(),child.getStatus(),
-                child.getOrderNo(),1);
-                orderChildExpects = orderChildExpectDao.getOrderChildExpectByChildNo(child.getChildNo(),1);
-            }
-            if(CollectionUtils.isNotEmpty(orderChildExpects) && orderChildExpects.size() > 1){
-                OrderChildExpect oneExpect = orderChildExpects.get(0);
-                if(StringUtil.isNotEmpty(oneExpect.getExpectArriveTime())){
-                    monitorOrderChild.setExpectArriveTimeRealTime(oneExpect.getExpectArriveTime());
-                }
-                if(StringUtil.isNotEmpty(oneExpect.getExpectReceiveTime())){
-                    monitorOrderChild.setExpectReceiveTimeRealTime(oneExpect.getExpectReceiveTime());
-                }
-                OrderChildExpect twoExpect = orderChildExpects.get(1);
-                if(Objects.nonNull(oneExpect.getExpectArriveTimeSecond()) && Objects.nonNull(twoExpect
-                .getExpectArriveTimeSecond())){
-                    if(twoExpect.getExpectArriveTimeSecond() < oneExpect.getExpectArriveTimeSecond()){
-                        monitorOrderChild.setArriveTrend(0);
-                    }else{
-                        monitorOrderChild.setArriveTrend(1);
-                    }
-                }
-                if(Objects.nonNull(oneExpect.getExpectReceiveTimeSecond()) && Objects.nonNull(twoExpect
-                .getExpectReceiveTimeSecond())) {
-                    if(oneExpect.getExpectReceiveTimeSecond() < twoExpect.getExpectReceiveTimeSecond()){
-                        monitorOrderChild.setReceiveTrend(0);
-                    }else{
-                        monitorOrderChild.setReceiveTrend(1);
-                    }
-                }
-            }
-
-            try {
-                Thread.sleep(100);
-            } catch (InterruptedException e) {
-                throw new RuntimeException(e);
-            }
-
             return monitorOrderChild;
         }).collect(Collectors.toList());
-        result.setData(monitorOrderChildList);
 
-        return result;*/
-        return null;
+        IPage<OutputMonitorOrderChildVO> newPage = new Page<>();
+        newPage.setRecords(monitorOrderChildList).setTotal(page.getTotal()).setPages(page.getPages());
+        return newPage;
     }
 
     /**
@@ -1635,6 +1612,7 @@ public class OrderChildServiceImpl implements OrderChildService {
                     plusTime = gdRouteDTOS.get(0).getDuration();
                 }
                 expect.setExpectTransportTimeSecond(plusTime);
+                expect.setExpectTransportTime(formatTimeStr(plusTime));
                 LocalDateTime expectTime = now.plusSeconds(plusTime);
 
                 if (childStatus < OrderChildEnum.Status.ARRIVE_SEND.getCode()) {
@@ -1677,6 +1655,30 @@ public class OrderChildServiceImpl implements OrderChildService {
             redisTemplate.opsForHash().put(RedisConstants.ORDER_CHILD_EXPECT_TIME_DATA_KEY_MAP,orderChildNo,keyList);
         }
     }
+
+    /**
+     * @Author kavin
+     * @Description 获取运单监控实时位置到达时间计算集合
+     * @Param [orderChildNo]
+     * @return
+     **/
+    public List<OrderChildExpectDTO> getOrderChildExpect(String orderChildNo){
+        List<String> keyList = (List<String>) redisTemplate.opsForHash().get(
+                RedisConstants.ORDER_CHILD_EXPECT_TIME_DATA_KEY_MAP, orderChildNo);
+        List<OrderChildExpectDTO> list = new ArrayList<>();
+        if(CollectionUtils.isNotEmpty(keyList)){
+            keyList.forEach(item->{
+                OrderChildExpectDTO dto = (OrderChildExpectDTO)redisTemplate.opsForValue().get(item);
+                if(Objects.nonNull(dto)){
+                    list.add(dto);
+                }
+            });
+        }
+        return list;
+    }
+
+
+
     /**
      * @Author kavin
      * @Description 获取运单实时监控位置计算时间的数据key
@@ -1703,4 +1705,26 @@ public class OrderChildServiceImpl implements OrderChildService {
         }
         return gdRouteDTOS;
     }
+
+
+    private static String formatTimeStr(Integer n) {
+        if (n > Long.MAX_VALUE) {
+            return "--";
+        }
+        if (n <= 60) {            // 一分钟以下
+            return  "1分钟";
+        } else if (n > 60 && n < 3600) {//一小时以下
+            int minute = n / 60;
+            return minute + "分钟";
+        } else if (n >= 3600) {// 一小时及以上
+            int hour = n / 3600;
+            int minute = (n - 3600 * hour) / 60;
+            if(minute == 0){
+                return hour + "小时";
+            }else{
+                return hour + "小时" + minute + "分钟" ;
+            }
+        }
+        return "--";
+    }
 }