Merge remote-tracking branch 'origin/master'

# Conflicts:
#	src/main/java/cn/van/business/util/JDUtils.java

src/main/java/cn/van/business/util/JDUtils.java

@@ -7,7 +7,6 @@ import cn.van.business.model.jd.OrderRow;
 import cn.van.business.repository.OrderRowRepository;
 import com.alibaba.fastjson2.JSON;
 import com.alibaba.fastjson2.util.DateUtils;
-
 import com.jd.open.api.sdk.DefaultJdClient;
 import com.jd.open.api.sdk.JdClient;
 import com.jd.open.api.sdk.domain.kplunion.OrderService.request.query.OrderRowReq;
@@ -68,215 +67,6 @@ public class JDUtils {
     @Autowired
     private WXUtil wxUtil;
 
-
-
-    /**
-     * 每分钟拉取最近10分钟的订单
-     */
-    @Scheduled(cron = "0 * * * * ?") // 每分钟执行一次
-    public void fetchLatestOrder() throws Exception {
-        LocalDateTime now = LocalDateTime.now();
-        LocalDateTime lastMinute = now.minusMinutes(10).withSecond(0).withNano(0);
-
-        UnionOpenOrderRowQueryResponse response = fetchOrdersForDateTime(lastMinute, true);  // 真实代表实时订单
-        if (response != null) {
-
-            int code = response.getQueryResult().getCode();
-            if (code == 200) {
-                if (response.getQueryResult().getCode() == 200) {
-                    OrderRowResp[] orderRowResps = response.getQueryResult().getData();
-                    if (orderRowResps == null) {
-                        return;
-                    }
-                    for (OrderRowResp orderRowResp : orderRowResps) {
-                        // 固化到数据库
-                        OrderRow orderRow = createOrderRow(orderRowResp);
-                        // 订单号不存在就保存，存在就更新订单状态
-                        orderRowRepository.save(orderRow);
-                    }
-                }
-            }
-        }
-
-    }
-
-    // 拉取历史订单 2880 次请求
-    @Scheduled(cron = "0 0 8,12,16,20,0 * * ?")
-    public void fetchHistoricalOrders() throws Exception {
-        // 从设定的开始日期到昨天的同一时间
-        System.out.println("开始拉取历史订单");
-        // 拉最近两个月的订单
-        // 获取当前时间，并调整为整点开始
-        LocalDateTime startDate = LocalDateTime.now().minusMonths(2).truncatedTo(ChronoUnit.HOURS);
-
-        LocalDateTime now = LocalDateTime.now();
-        LocalDateTime lastHour = now.minusHours(1).withMinute(0).withSecond(0).withNano(0);
-
-
-        while (!startDate.isEqual(lastHour)) {
-            UnionOpenOrderRowQueryResponse response = fetchOrdersForDateTime(startDate, false);  // 假的代表历史订单
-            startDate = startDate.plusHours(1);
-            if (response != null) {
-                int code = response.getQueryResult().getCode();
-                if (code == 200) {
-                    if (response.getQueryResult().getCode() == 200) {
-                        OrderRowResp[] orderRowResps = response.getQueryResult().getData();
-                        if (orderRowResps == null) {
-                            continue;
-                        }
-                        for (OrderRowResp orderRowResp : orderRowResps) {
-                            // 固化到数据库
-                            OrderRow orderRow = createOrderRow(orderRowResp);
-                            // 订单号不存在就保存，存在就更新订单状态
-                            orderRowRepository.save(orderRow);
-                        }
-                    }
-                }
-            }
-            sleep(1000);
-        }
-    }
-
-    @Scheduled(cron = "0 * * * * ?") // 每分钟执行一次
-    public void sendOrderToWx() {
-        int[] parm = {-1, 17};
-        List<OrderRow> orderRows = orderRowRepository.findByValidCodeNotInOrderByOrderTimeDesc(parm);
-        if (!orderRows.isEmpty()) {
-            for (OrderRow orderRow : orderRows) {
-                orderToWx(orderRow, true);
-            }
-        }
-
-    }
-    /**
-     * 指令
-     */
-    public void sendOrderToWxByOrder(String order) {
-        int[] parm = {-1};
-        List<OrderRow> orderRows = orderRowRepository.findByValidCodeNotInOrderByOrderTimeDesc(parm);
-        /**
-         * 菜单：
-         * 今日统计
-         * 昨天统计
-         * 最近七天统计
-         * 最近一个月统计
-         * 今天订单
-         * 昨天订单
-         * */
-        String content = null;
-        switch (order) {
-            case "菜单":
-                content = "菜单：京粉 +命令 \n 如： 京粉 今日统计\r";
-                content += "今日统计\r";
-                content += "昨天统计\r";
-                content += "最近七天统计\r";
-                content += "最近一个月统计\r";
-                content += "今天订单\r";
-                content += "昨天订单\r";
-                break;
-            case "今日统计": {
-                List<OrderRow> todayOrders = filterOrdersByDate(orderRows, 0);
-                // 订单总数，已付款，已取消，佣金总计
-                content = "今日统计：";
-                content += "订单总数：" + todayOrders.size() + "\r";
-                content += "已付款：" + todayOrders.stream().filter(orderRow -> orderRow.getValidCode() == 16).count() + "\r";
-                content += "已取消：" + todayOrders.stream().filter(orderRow -> orderRow.getValidCode() != 16).count() + "\r";
-
-                content += "佣金总计：" + todayOrders.stream().filter(orderRow -> orderRow.getValidCode() == 16).mapToDouble(OrderRow::getEstimateFee).sum();
-
-                break;
-            }
-            case "昨天统计": {
-                List<OrderRow> yesterdayOrders = filterOrdersByDate(orderRows, 1);
-                content = "昨天统计：";
-                content += "订单总数：" + yesterdayOrders.size() + "\r";
-                content += "已付款：" + yesterdayOrders.stream().filter(orderRow -> orderRow.getValidCode() == 16).count() + "\r";
-                content += "已取消：" + yesterdayOrders.stream().filter(orderRow -> orderRow.getValidCode() != 16).count() + "\r";
-                content += "佣金总计：" + yesterdayOrders.stream().filter(orderRow -> orderRow.getValidCode() == 16).mapToDouble(OrderRow::getEstimateFee).sum();
-
-                break;
-            }
-            case "最近七天统计":
-                List<OrderRow> last7DaysOrders = filterOrdersByDate(orderRows, 7);
-                content = "最近七天统计：";
-                content += "订单总数：" + last7DaysOrders.size() + "\r";
-                content += "已付款：" + last7DaysOrders.stream().filter(orderRow -> orderRow.getValidCode() == 16).count() + "\r";
-                content += "已取消：" + last7DaysOrders.stream().filter(orderRow -> orderRow.getValidCode() != 16).count() + "\r";
-                content += "佣金总计：" + last7DaysOrders.stream().filter(orderRow -> orderRow.getValidCode() == 16).mapToDouble(OrderRow::getEstimateFee).sum();
-
-                break;
-            case "最近一个月统计":
-                List<OrderRow> last30DaysOrders = filterOrdersByDate(orderRows, 30);
-                content = "最近一个月统计：";
-                content += "订单总数：" + last30DaysOrders.size() + "\r";
-                content += "已付款：" + last30DaysOrders.stream().filter(orderRow -> orderRow.getValidCode() == 16).count() + "\r";
-                content += "已取消：" + last30DaysOrders.stream().filter(orderRow -> orderRow.getValidCode() != 16).count() + "\r";
-                content += "佣金总计：" + last30DaysOrders.stream().filter(orderRow -> orderRow.getValidCode() == 16).mapToDouble(OrderRow::getEstimateFee).sum();
-
-                break;
-            case "今天订单": {
-                List<OrderRow> todayOrders = filterOrdersByDate(orderRows, 0);
-                // 订单总数，已付款，已取消，佣金总计
-                content = "今日统计：";
-                content += "订单总数：" + todayOrders.size() + "\r";
-                content += "已付款：" + todayOrders.stream().filter(orderRow -> orderRow.getValidCode() == 16).count() + "\r";
-                content += "已取消：" + todayOrders.stream().filter(orderRow -> orderRow.getValidCode() != 16).count() + "\r";
-
-                content += "佣金总计：" + todayOrders.stream().filter(orderRow -> orderRow.getValidCode() == 16).mapToDouble(OrderRow::getEstimateFee).sum();
-
-                for (OrderRow orderRow : todayOrders) {
-                    orderToWx(orderRow, false);
-                }
-
-                break;
-            }
-            case "昨天订单": {
-                List<OrderRow> yesterdayOrders = filterOrdersByDate(orderRows, 1);
-                content = "昨天统计：";
-                content += "订单总数：" + yesterdayOrders.size() + "\r";
-                content += "已付款：" + yesterdayOrders.stream().filter(orderRow -> orderRow.getValidCode() == 16).count() + "\r";
-                content += "已取消：" + yesterdayOrders.stream().filter(orderRow -> orderRow.getValidCode() != 16).count() + "\r";
-                content += "佣金总计：" + yesterdayOrders.stream().filter(orderRow -> orderRow.getValidCode() == 16).mapToDouble(OrderRow::getEstimateFee).sum();
-
-                for (OrderRow orderRow : yesterdayOrders) {
-                    orderToWx(orderRow, false);
-                }
-                break;
-            }
-        }
-        if (content != null) {
-            wxUtil.sendTextMessage(WXUtil.super_admin_wxid, content, 1, WXUtil.super_admin_wxid);
-        }
-
-    }
-
-    private void orderToWx(OrderRow orderRow, Boolean isAutoFlush) {
-        // 查询订单状态
-        Integer newValidCode = orderRow.getValidCode();
-        String oldValidCode = redisTemplate.opsForValue().get(ORDER_ROW_KEY + orderRow.getId());
-        Integer lastValidCode = 0;
-        // 更新 Redis 状态
-        redisTemplate.opsForValue().set(ORDER_ROW_KEY + orderRow.getId(), String.valueOf(orderRow.getValidCode()));
-
-        if (Util.isNotEmpty(oldValidCode)) {
-            lastValidCode = Integer.valueOf(oldValidCode);
-        }
-        // 如果订单状态没变化，就不发送
-        if (isAutoFlush && lastValidCode.equals(newValidCode)) {
-        } else {
-            String content;
-            content = getFormattedOrderInfo(orderRow);
-
-            // 推送
-            wxUtil.sendTextMessage(WXUtil.super_admin_wxid, content, 1, WXUtil.super_admin_wxid);
-            try {
-                sleep(200);
-            } catch (InterruptedException e) {
-                throw new RuntimeException(e);
-            }
-        }
-
-    }
     /**
      * 将 响应参数转化为 OrderRow，并返回
      */
@@ -367,6 +157,212 @@ public class JDUtils {
                 })
                 .collect(Collectors.toList());
     }
+
+    /**
+     * 拉取最新的订单 1440分钟
+     */
+    @Scheduled(cron = "0 * * * * ?") // 每分钟执行一次
+    public void fetchLatestOrder() throws Exception {
+        LocalDateTime now = LocalDateTime.now();
+        LocalDateTime lastMinute = now.minusMinutes(10).withSecond(0).withNano(0);
+
+        UnionOpenOrderRowQueryResponse response = fetchOrdersForDateTime(lastMinute, true);  // 真实代表实时订单
+        if (response != null) {
+
+            int code = response.getQueryResult().getCode();
+            if (code == 200) {
+                if (response.getQueryResult().getCode() == 200) {
+                    OrderRowResp[] orderRowResps = response.getQueryResult().getData();
+                    if (orderRowResps == null) {
+                        return;
+                    }
+                    for (OrderRowResp orderRowResp : orderRowResps) {
+                        // 固化到数据库
+                        OrderRow orderRow = createOrderRow(orderRowResp);
+                        // 订单号不存在就保存，存在就更新订单状态
+                        orderRowRepository.save(orderRow);
+                    }
+                }
+            }
+        }
+
+    }
+
+    @Scheduled(cron = "0 * * * * ?") // 每分钟执行一次
+    public void sendOrderToWx() {
+        int[] parm = {-1, 17};
+        List<OrderRow> orderRows = orderRowRepository.findByValidCodeNotInOrderByOrderTimeDesc(parm);
+        if (!orderRows.isEmpty()) {
+            for (OrderRow orderRow : orderRows) {
+                orderToWx(orderRow, true);
+            }
+        }
+
+    }
+
+    /**
+     * 指令
+     */
+    public void sendOrderToWxByOrder(String order) throws Exception {
+        int[] parm = {-1};
+        List<OrderRow> orderRows = orderRowRepository.findByValidCodeNotInOrderByOrderTimeDesc(parm);
+        /**
+         * 菜单：
+         * 今日统计
+         * 昨天统计
+         * 最近七天统计
+         * 最近一个月统计
+         * 今天订单
+         * 昨天订单
+         * */
+        String content = null;
+        switch (order) {
+            case "菜单":
+                content = "菜单：京粉 +命令 \n 如： 京粉 今日统计\r";
+                content += "今日统计\r";
+                content += "昨天统计\r";
+                content += "最近七天统计\r";
+                content += "最近一个月统计\r";
+                content += "今天订单\r";
+                content += "昨天订单\r";
+                content += "刷新三天\r";
+                break;
+            case "今日统计": {
+                List<OrderRow> todayOrders = filterOrdersByDate(orderRows, 0);
+                // 订单总数，已付款，已取消，佣金总计
+                content = "今日统计：";
+                content += "订单总数：" + todayOrders.size() + "\r";
+                content += "已付款：" + todayOrders.stream().filter(orderRow -> orderRow.getValidCode() == 16).count() + "\r";
+                content += "已取消：" + todayOrders.stream().filter(orderRow -> orderRow.getValidCode() != 16).count() + "\r";
+
+                content += "佣金总计：" + todayOrders.stream().filter(orderRow -> orderRow.getValidCode() == 16).mapToDouble(OrderRow::getEstimateFee).sum();
+
+                break;
+            }
+            case "昨天统计": {
+                List<OrderRow> yesterdayOrders = filterOrdersByDate(orderRows, 1);
+                content = "昨天统计：";
+                content += "订单总数：" + yesterdayOrders.size() + "\r";
+                content += "已付款：" + yesterdayOrders.stream().filter(orderRow -> orderRow.getValidCode() == 16).count() + "\r";
+                content += "已取消：" + yesterdayOrders.stream().filter(orderRow -> orderRow.getValidCode() != 16).count() + "\r";
+                content += "佣金总计：" + yesterdayOrders.stream().filter(orderRow -> orderRow.getValidCode() == 16).mapToDouble(OrderRow::getEstimateFee).sum();
+
+                break;
+            }
+            case "最近七天统计":
+                List<OrderRow> last7DaysOrders = filterOrdersByDate(orderRows, 7);
+                content = "最近七天统计：";
+                content += "订单总数：" + last7DaysOrders.size() + "\r";
+                content += "已付款：" + last7DaysOrders.stream().filter(orderRow -> orderRow.getValidCode() == 16).count() + "\r";
+                content += "已取消：" + last7DaysOrders.stream().filter(orderRow -> orderRow.getValidCode() != 16).count() + "\r";
+                content += "佣金总计：" + last7DaysOrders.stream().filter(orderRow -> orderRow.getValidCode() == 16).mapToDouble(OrderRow::getEstimateFee).sum();
+
+                break;
+            case "最近一个月统计":
+                List<OrderRow> last30DaysOrders = filterOrdersByDate(orderRows, 30);
+                content = "最近一个月统计：";
+                content += "订单总数：" + last30DaysOrders.size() + "\r";
+                content += "已付款：" + last30DaysOrders.stream().filter(orderRow -> orderRow.getValidCode() == 16).count() + "\r";
+                content += "已取消：" + last30DaysOrders.stream().filter(orderRow -> orderRow.getValidCode() != 16).count() + "\r";
+                content += "佣金总计：" + last30DaysOrders.stream().filter(orderRow -> orderRow.getValidCode() == 16).mapToDouble(OrderRow::getEstimateFee).sum();
+
+                break;
+            case "今天订单": {
+                List<OrderRow> todayOrders = filterOrdersByDate(orderRows, 0);
+                // 订单总数，已付款，已取消，佣金总计
+                content = "今日统计：";
+                content += "订单总数：" + todayOrders.size() + "\r";
+                content += "已付款：" + todayOrders.stream().filter(orderRow -> orderRow.getValidCode() == 16).count() + "\r";
+                content += "已取消：" + todayOrders.stream().filter(orderRow -> orderRow.getValidCode() != 16).count() + "\r";
+
+                content += "佣金总计：" + todayOrders.stream().filter(orderRow -> orderRow.getValidCode() == 16).mapToDouble(OrderRow::getEstimateFee).sum();
+
+                for (OrderRow orderRow : todayOrders) {
+                    orderToWx(orderRow, false);
+                }
+
+                break;
+            }
+            case "昨天订单": {
+                List<OrderRow> yesterdayOrders = filterOrdersByDate(orderRows, 1);
+                content = "昨天统计：";
+                content += "订单总数：" + yesterdayOrders.size() + "\r";
+                content += "已付款：" + yesterdayOrders.stream().filter(orderRow -> orderRow.getValidCode() == 16).count() + "\r";
+                content += "已取消：" + yesterdayOrders.stream().filter(orderRow -> orderRow.getValidCode() != 16).count() + "\r";
+                content += "佣金总计：" + yesterdayOrders.stream().filter(orderRow -> orderRow.getValidCode() == 16).mapToDouble(OrderRow::getEstimateFee).sum();
+
+                for (OrderRow orderRow : yesterdayOrders) {
+                    orderToWx(orderRow, false);
+                }
+                break;
+            }
+            case "刷新三天": {
+                long start = System.currentTimeMillis();
+                int count = 0;
+                LocalDateTime startDate = LocalDateTime.now().minusDays(3).withMinute(0).withSecond(0).withNano(0);
+                LocalDateTime lastHour = LocalDateTime.now().minusHours(1).withMinute(0).withSecond(0).withNano(0);
+                while (!startDate.isEqual(lastHour)) {
+                    startDate = startDate.plusHours(1);
+                    UnionOpenOrderRowQueryResponse response = fetchOrdersForDateTime(startDate, false);
+                    if (response != null) {
+
+                        int code = response.getQueryResult().getCode();
+                        if (code == 200) {
+                            if (response.getQueryResult().getCode() == 200) {
+                                OrderRowResp[] orderRowResps = response.getQueryResult().getData();
+                                if (orderRowResps == null) {
+                                    continue;
+                                }
+                                for (OrderRowResp orderRowResp : orderRowResps) {
+                                    // 固化到数据库
+                                    OrderRow orderRow = createOrderRow(orderRowResp);
+                                    // 订单号不存在就保存，存在就更新订单状态
+                                    orderRowRepository.save(orderRow);
+                                    count++;
+                                }
+                            }
+                        }
+                    }
+
+
+                }
+                content = "刷新三天成功,耗时" + (System.currentTimeMillis() - start) / 1000 + "秒\r" + "刷新订单数：" + count;
+            }
+        }
+        if (content != null) {
+            wxUtil.sendTextMessage(WXUtil.super_admin_wxid, content, 1, WXUtil.super_admin_wxid);
+        }
+
+    }
+
+    private void orderToWx(OrderRow orderRow, Boolean isAutoFlush) {
+        // 查询订单状态
+        Integer newValidCode = orderRow.getValidCode();
+        String oldValidCode = redisTemplate.opsForValue().get(ORDER_ROW_KEY + orderRow.getId());
+        Integer lastValidCode = 0;
+        // 更新 Redis 状态
+        redisTemplate.opsForValue().set(ORDER_ROW_KEY + orderRow.getId(), String.valueOf(orderRow.getValidCode()));
+
+        if (Util.isNotEmpty(oldValidCode)) {
+            lastValidCode = Integer.valueOf(oldValidCode);
+        }
+        // 如果订单状态没变化，就不发送
+        if (isAutoFlush && lastValidCode.equals(newValidCode)) {
+        } else {
+            String content;
+            content = getFormattedOrderInfo(orderRow);
+
+            // 推送
+            wxUtil.sendTextMessage(WXUtil.super_admin_wxid, content, 1, WXUtil.super_admin_wxid);
+            try {
+                sleep(200);
+            } catch (InterruptedException e) {
+                throw new RuntimeException(e);
+            }
+        }
+
+    }
+
     public String getFormattedOrderInfo(OrderRow orderRow) {
         SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
         ValidCodeConverter converter = new ValidCodeConverter();
@@ -392,9 +388,10 @@ public class JDUtils {
     /**
      * 根据指定的日期时间拉取订单
      */
-    public UnionOpenOrderRowQueryResponse fetchOrdersForDateTime(LocalDateTime dateTime, boolean isRealTime) throws Exception {
-        LocalDateTime endTime = isRealTime ? dateTime.plusMinutes(10) : dateTime.plusHours(1);
-        String key = dateTime.format(DATE_TIME_FORMATTER);
+    public UnionOpenOrderRowQueryResponse fetchOrdersForDateTime(LocalDateTime startTime, boolean isRealTime) throws Exception {
+
+        LocalDateTime endTime = isRealTime ? startTime.plusMinutes(10) : startTime.plusHours(1);
+        String key = startTime.format(DATE_TIME_FORMATTER);
         String hourRange = isRealTime ? "minute" : "hour";
 
         SetOperations<String, String> setOps = redisTemplate.opsForSet();
@@ -406,18 +403,21 @@ public class JDUtils {
         //}
 
         // 调用 API 以拉取订单
-        UnionOpenOrderRowQueryResponse unionOpenOrderRowQueryResponse = getUnionOpenOrderRowQueryResponse(dateTime, endTime);
+        UnionOpenOrderRowQueryResponse unionOpenOrderRowQueryResponse = getUnionOpenOrderRowQueryResponse(startTime, endTime);
 
         // 标记已拉取
         setOps.add(key, hourRange);
+        // 打印方法调用和开始结束时间
+
+        System.out.println("拉取订单：" + "开始时间：" + startTime.format(DATE_TIME_FORMATTER) + "结束时间：" + endTime.format(DATE_TIME_FORMATTER));
         return unionOpenOrderRowQueryResponse;
     }
 
     /**
      * 获取订单列表
      *
-     * @param start 开始时间
-     * @param end   结束时间
+     * @param startTime 开始时间
+     * @param endTime   结束时间
      * @return
      * @throws Exception
      */
@@ -486,5 +486,42 @@ public class JDUtils {
         return response.getGetResult().getData().getClickURL();
     }
 
+    // 拉取历史订单 2880 次请求
+    @Scheduled(cron = "0 0 8,12,20,0 * * ?")
+    public void fetchHistoricalOrders() throws Exception {
+        // 从设定的开始日期到昨天的同一时间
+        System.out.println("开始拉取历史订单");
+        // 拉最近两个月的订单
+        // 获取当前时间，并调整为整点开始
+        LocalDateTime startDate = LocalDateTime.now().minusMonths(2).truncatedTo(ChronoUnit.HOURS);
 
+        LocalDateTime now = LocalDateTime.now();
+        LocalDateTime lastHour = now.minusHours(1).withMinute(0).withSecond(0).withNano(0);
+
+
+        while (!startDate.isEqual(lastHour)) {
+            UnionOpenOrderRowQueryResponse response = fetchOrdersForDateTime(startDate, false);  // 假的代表历史订单
+
+            if (response != null) {
+                int code = response.getQueryResult().getCode();
+                if (code == 200) {
+                    if (response.getQueryResult().getCode() == 200) {
+                        OrderRowResp[] orderRowResps = response.getQueryResult().getData();
+                        if (orderRowResps == null) {
+                            continue;
+                        }
+                        for (OrderRowResp orderRowResp : orderRowResps) {
+                            // 固化到数据库
+                            OrderRow orderRow = createOrderRow(orderRowResp);
+                            // 订单号不存在就保存，存在就更新订单状态
+                            orderRowRepository.save(orderRow);
+                            sleep(1000);
+                        }
+                    }
+                }
+            }
+            startDate = startDate.plusHours(1);
+
+        }
+    }
 }