#### 接口

```java
 @ApiOperation("批量处理挂起正向订单，进行补单")
    @PostMapping("/completeUnReportOrder")
    public ResultVO completeUnReportOrder(String startDate,String endDate){
        taskServiceApi.completeUnReportOrder(startDate,endDate);
        return ResultVO.success();
    }

    @ApiOperation("批量处理挂起反向订单，进行补单")
    @PostMapping("/completeUnReportReverseOrder")
    public ResultVO completeUnReportReverseOrder(){
        taskServiceApi.completeUnReportReverseOrder();
        return ResultVO.success();
    }
```



#### 正向补单

```java
@Scheduled(fixedDelay=SIX_HOUR)
    public void completeUnReportOrder() {
        try{
            log.info("批量处理挂起正向订单，进行补单");
//            handleOrderTarckService.completeUnReportOrder();
            handleOrderTarckService.completeUnReportOrderV2();
        }catch (Exception e){
            log.error("批量处理挂起订单，进行补单失败，原因：", e);
            e.printStackTrace();
        }
    }
```

```java
 /**
     * 新版本计算补单
     */
    public void completeUnReportOrderV2() {
        //处理前60天的挂起订单
        Date startDate = ToolDateTime.startDateByDay(new Date(), -60);
        Date endDate = ToolDateTime.startDateByDay(new Date(), 0);
//        Date endDate = ToolDateTime.endDateByDay(new Date());
        List<EquipmentChargeOrderDO> hangUpOrderList = equipmentChargeOrderDOMapper.queryHangUpOrder(startDate, endDate);//查询挂起订单
        Stream.iterate(0, i -> i + 1).limit(hangUpOrderList.size()).forEach(i -> {
            asyncTaskService.completeUnReportOrder(hangUpOrderList.get(i));
        });
    }
```





#### 反向补单

```java
 @Scheduled(cron = "0 0 3 * * ?")
    public void completeUnReportReverseOrder() {
        try{
            log.info("批量处理挂起反向订单，进行补单");
            handleOrderTarckService.completeUnReportReverseOrder();
        }catch (Exception e){
            log.error("批量处理挂起反向订单，进行补单失败，原因：", e);
            e.printStackTrace();
        }
    }
```

定时了定时任务每天$3$点进行挂起反向订单的补单操作。

```java
	/**
     * 批量处理挂起反向订单，进行补单
     */
    public void completeUnReportReverseOrder() {
        //处理指定 ~ 指定时间三天前 时间内的反向挂起的订单
        // #{code} = push_reverse_orders.duration
        // select value from t_biz_parameter  where state = 1  and code = #{code} order by id desc limit 1
        // select value from t_biz_parameter  where state = 1  and code = 'push_reverse_orders.duration' order by id desc limit 1
        // 返回值 ： 72 小时
        String time = equipmentChargeOrderDOMapper.getReverseFinishTime(Constant.REVERSE_ORDER_TIME);
        int hour = new BigDecimal(time).intValue();
        Date startDate = DateUtil.offset(new Date(), DateField.HOUR_OF_DAY, -(hour + 720));//33天之内的
        Date endDate = DateUtil.offset(new Date(), DateField.HOUR_OF_DAY, -hour);//72小时前，也就是3天前
        //查询这段时间内挂起的工单
        /**
         <select id="queryHangUpReverseOrder" resultMap="BaseResultMap">
         SELECT
         o.*
         FROM
         t_equipment_charge_order o left join t_station s on o.station_id = s.id
         WHERE o.state = 5 and s.is_hlht = 1
         <if test="startDate != null">
         AND o.create_time &gt;= #{startDate}
         </if>
         <if test="endDate != null">
         AND o.create_time &lt;= #{endDate}
         </if>
         ORDER BY o.id DESC
         </select>

         o.state = 5    订单状态 0  创建中 1准备充电中 2 充电中 3完成 4 取消 5挂起 6需要手动补单 7结算中
         is_hlht=1      是否是互联互通站点 1是 0不是 , 注意：这里只处理了互联互通的！因为is_hlht=1,也就是说不是互联互通的挂单，调用这个接口补单是无效的！！！
         */
        List<EquipmentChargeOrderDO> hangUpOrderList = equipmentChargeOrderDOMapper.queryHangUpReverseOrder(startDate, endDate);//查询挂起订单

        Stream.iterate(0, i -> i + 1).limit(hangUpOrderList.size()).forEach(i -> {
            CompletableFuture<Map<String, Object>> sendCoupon = CompletableFuture.supplyAsync(() -> {
                //处理挂起订单进行补单
                asyncTaskService.completeUnReportReverseOrder(hangUpOrderList.get(i));
                return null;
            }, handleReverseService);
        });
    }
```

从$JAVA$代码来看，依赖这个接口实现补单功能有两个问题：

- 它只能实现$72$小时的补单，为什么一定要强调$72$小时呢？为什么不是$24$小时或者$1$小时呢?
- 它只能实现互联互通的补单，对于直连桩的无效，因为它根本就没有查询直联桩的补单信息！

```java
/**
     * 处理反向互通挂起订单
     */
    public void completeUnReportReverseOrder(EquipmentChargeOrderDO orderDO) {
        try {
            //从mongo上获取最后一次推送的账单数据
            NotificationChargeOrderInfoReqMongoDO notificationChargeOrderInfoReqMongoDO = notificationChargeOrderInfoReqDao.findOne(orderDO.getOrderNo());
            if(notificationChargeOrderInfoReqMongoDO != null) {
                completeWithPushedOrder(orderDO, notificationChargeOrderInfoReqMongoDO);
                return;
            }

            //若是没有，则从mongo中获取最后一次充电中推送的数据 进行结算
            ReverseOrderInfo reverseOrderInfo = reverseOrderInfoDao.findOne(orderDO.getOrderNo());
            if(reverseOrderInfo != null) {
                completeWithLastPushedOrder(orderDO, reverseOrderInfo);
            }

        } catch (Exception e) {
            addOrderTrack(orderDO.getOrderNo(), orderDO.getUserId(), orderDO.getConnectorId().toString(), (byte) 3, (byte) 0, "补单失败，补单异常,异常信息");
            log.error("反向订单" + orderDO.getOrderNo() + "补单异常,异常信息:", e);
        }

    }
```