订单比对加上状态

2026-10-26 11:59:19 +08:00
parent 4bee108661
commit ab6216922a
12 changed files with 337 additions and 61 deletions
@@ -1,12 +1,11 @@
 package com.bms.price.task;

 import java.util.ArrayList;
-import java.util.HashSet;
+import java.util.HashMap;
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Locale;
 import java.util.Map;
-import java.util.Set;
 import java.util.concurrent.TimeUnit;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -23,7 +22,7 @@ import com.bms.price.search.IBillSearchStore;
 import com.bms.price.search.TabOrderSyncEsLog;

 /**
- * 订单比对异步任务：分页拉上游转单号，与本地 transfer_no 比对差异。
+ * 订单比对异步任务：分页拉上游转单号+状态，与本地 transfer_no / order_status 比对。
 */
@Component
 public class TabOrderCompareAsyncRunner
@@ -37,6 +36,8 @@ public class TabOrderCompareAsyncRunner
    public static final int SCAN_HARD_LIMIT = 50000;
    /** 进度/抽屉中保留的缺失转单号上限 */
    public static final int MISSING_SAMPLE_LIMIT = 5000;
+    /** 状态不一致样本上限 */
+    public static final int STATUS_MISMATCH_SAMPLE_LIMIT = 5000;

    @Autowired
    private TabOrderMonitorService tabOrderMonitorService;
@@ -62,11 +63,14 @@ public class TabOrderCompareAsyncRunner
                query.setOrgOrderId(null);
                query.setTransferOrderId(null);
            }
-            put(asyncTaskId, TabOrderCompareTask.STATUS_RUNNING, 0, "starting", 0, 0, 0, null, null);
+            put(asyncTaskId, TabOrderCompareTask.STATUS_RUNNING, 0, "starting",
+                0, 0, 0, 0, null, null, null);
            int scanned = 0;
            int matched = 0;
            int missing = 0;
+            int statusMismatch = 0;
            List<String> missingSample = new ArrayList<String>();
+            List<Map<String, Object>> statusMismatchSample = new ArrayList<Map<String, Object>>();
            int pageNum = 1;
            while (true)
            {
@@ -77,43 +81,72 @@ public class TabOrderCompareAsyncRunner
                }
                int remain = SCAN_HARD_LIMIT - scanned;
                int pageSize = Math.min(PAGE_SIZE, remain);
-                List<String> transferNos = tabOrderMonitorService.selectCompareTransferPage(query, pageNum, pageSize);
-                if (transferNos == null || transferNos.isEmpty())
+                List<Map<String, Object>> pageRows =
+                    tabOrderMonitorService.selectCompareKeyPage(query, pageNum, pageSize);
+                if (pageRows == null || pageRows.isEmpty())
                {
                    break;
                }
-                Set<String> existing = findExisting(transferNos, query == null ? null : query.getCustomerCodes());
-                for (String tn : transferNos)
+                List<String> transferNos = new ArrayList<String>(pageRows.size());
+                for (Map<String, Object> row : pageRows)
                {
-                    if (StringUtils.isEmpty(tn))
+                    Object tn = row == null ? null : row.get("transferNo");
+                    if (tn != null && StringUtils.isNotEmpty(String.valueOf(tn).trim()))
+                    {
+                        transferNos.add(String.valueOf(tn).trim());
+                    }
+                }
+                Map<String, Integer> localStatusByTn =
+                    findLocalStatuses(transferNos, query == null ? null : query.getCustomerCodes());
+                for (Map<String, Object> row : pageRows)
+                {
+                    if (row == null)
                    {
                        continue;
                    }
-                    scanned++;
-                    String key = tn.trim().toUpperCase(Locale.ROOT);
-                    if (existing.contains(key))
+                    Object tnObj = row.get("transferNo");
+                    if (tnObj == null || StringUtils.isEmpty(String.valueOf(tnObj).trim()))
                    {
-                        matched++;
+                        continue;
                    }
-                    else
+                    String tn = String.valueOf(tnObj).trim();
+                    scanned++;
+                    String key = tn.toUpperCase(Locale.ROOT);
+                    Integer upstreamStatus = toInteger(row.get("orderStatus"));
+                    if (!localStatusByTn.containsKey(key))
                    {
                        missing++;
                        if (missingSample.size() < MISSING_SAMPLE_LIMIT)
                        {
-                            missingSample.add(tn.trim());
+                            missingSample.add(tn);
+                        }
+                        continue;
+                    }
+                    matched++;
+                    Integer localStatus = localStatusByTn.get(key);
+                    if (!statusEquals(upstreamStatus, localStatus))
+                    {
+                        statusMismatch++;
+                        if (statusMismatchSample.size() < STATUS_MISMATCH_SAMPLE_LIMIT)
+                        {
+                            Map<String, Object> one = new LinkedHashMap<String, Object>();
+                            one.put("transferNo", tn);
+                            one.put("upstreamStatus", upstreamStatus);
+                            one.put("localStatus", localStatus);
+                            statusMismatchSample.add(one);
                        }
                    }
                }
                int percent = Math.min(99, (int) ((scanned * 100L) / Math.max(scanned + pageSize, 1)));
-                // 最后一页不满页时近乎完成；否则按已扫描量给一个缓慢增长的百分比
-                if (transferNos.size() < pageSize)
+                if (pageRows.size() < pageSize)
                {
                    percent = 99;
                }
                put(asyncTaskId, TabOrderCompareTask.STATUS_RUNNING, percent,
-                    "scanning page=" + pageNum + " scanned=" + scanned + " missing=" + missing,
-                    scanned, matched, missing, null, missingSample);
-                if (transferNos.size() < pageSize)
+                    "scanning page=" + pageNum + " scanned=" + scanned
+                        + " missing=" + missing + " statusMismatch=" + statusMismatch,
+                    scanned, matched, missing, statusMismatch, null, missingSample, statusMismatchSample);
+                if (pageRows.size() < pageSize)
                {
                    break;
                }
@@ -124,14 +157,19 @@ public class TabOrderCompareAsyncRunner
            resp.put("scanned", Integer.valueOf(scanned));
            resp.put("matched", Integer.valueOf(matched));
            resp.put("missing", Integer.valueOf(missing));
+            resp.put("statusMismatch", Integer.valueOf(statusMismatch));
            resp.put("missingTransferNos", missingSample);
+            resp.put("statusMismatchSamples", statusMismatchSample);
            resp.put("missingTruncated", Boolean.valueOf(missing > missingSample.size()));
+            resp.put("statusMismatchTruncated",
+                Boolean.valueOf(statusMismatch > statusMismatchSample.size()));
            put(asyncTaskId, TabOrderCompareTask.STATUS_SUCCESS, 100,
-                "done scanned=" + scanned + " missing=" + missing,
-                scanned, matched, missing, null, missingSample);
+                "done scanned=" + scanned + " missing=" + missing + " statusMismatch=" + statusMismatch,
+                scanned, matched, missing, statusMismatch, null, missingSample, statusMismatchSample);
            TabOrderSyncEsLog.save(billSearchStore, asyncTaskId, "COMPARE_DONE", query, resp, "SUCCESS", null);
-            log.info("orderSource compare done asyncTaskId={} scanned={} matched={} missing={}",
-                asyncTaskId, Integer.valueOf(scanned), Integer.valueOf(matched), Integer.valueOf(missing));
+            log.info("orderSource compare done asyncTaskId={} scanned={} matched={} missing={} statusMismatch={}",
+                asyncTaskId, Integer.valueOf(scanned), Integer.valueOf(matched),
+                Integer.valueOf(missing), Integer.valueOf(statusMismatch));
        }
        catch (Exception e)
        {
@@ -141,33 +179,101 @@ public class TabOrderCompareAsyncRunner
            {
                msg = e.getClass().getSimpleName();
            }
-            put(asyncTaskId, TabOrderCompareTask.STATUS_FAIL, 100, "failed", 0, 0, 0, msg, null);
+            put(asyncTaskId, TabOrderCompareTask.STATUS_FAIL, 100, "failed",
+                0, 0, 0, 0, msg, null, null);
            TabOrderSyncEsLog.save(billSearchStore, asyncTaskId, "COMPARE_DONE", query, null, "FAIL", msg);
        }
    }

-    private Set<String> findExisting(List<String> transferNos, List<String> customerCodes)
+    /** transferNo(upper) -> local order_status (null value means local row exists with null status). */
+    private Map<String, Integer> findLocalStatuses(List<String> transferNos, List<String> customerCodes)
    {
-        Set<String> found = new HashSet<String>();
+        Map<String, Integer> found = new HashMap<String, Integer>();
        if (transferNos == null || transferNos.isEmpty())
        {
            return found;
        }
-        List<String> hit = prcOrderBillMapper.selectExistingTransferNos(transferNos, cleanCodes(customerCodes));
-        if (hit == null)
+        List<Map<String, Object>> rows =
+            prcOrderBillMapper.selectTransferOrderStatuses(transferNos, cleanCodes(customerCodes));
+        if (rows == null)
        {
            return found;
        }
-        for (String s : hit)
+        for (Map<String, Object> row : rows)
        {
-            if (StringUtils.isNotEmpty(s))
+            if (row == null)
            {
-                found.add(s.trim().toUpperCase(Locale.ROOT));
+                continue;
+            }
+            Object tn = first(row, "transferNo", "TRANSFERNO", "transfer_no");
+            if (tn == null || StringUtils.isEmpty(String.valueOf(tn).trim()))
+            {
+                continue;
+            }
+            String key = String.valueOf(tn).trim().toUpperCase(Locale.ROOT);
+            Integer st = toInteger(first(row, "orderStatus", "ORDERSTATUS", "order_status"));
+            // Keep first hit; duplicate transfer_no rare.
+            if (!found.containsKey(key))
+            {
+                found.put(key, st);
            }
        }
        return found;
    }

+    private static Object first(Map<String, Object> row, String... keys)
+    {
+        if (row == null || keys == null)
+        {
+            return null;
+        }
+        for (String k : keys)
+        {
+            if (row.containsKey(k) && row.get(k) != null)
+            {
+                return row.get(k);
+            }
+        }
+        return null;
+    }
+
+    private static Integer toInteger(Object v)
+    {
+        if (v == null || "".equals(String.valueOf(v).trim()))
+        {
+            return null;
+        }
+        if (v instanceof Integer)
+        {
+            return (Integer) v;
+        }
+        if (v instanceof Number)
+        {
+            return Integer.valueOf(((Number) v).intValue());
+        }
+        try
+        {
+            return Integer.valueOf(String.valueOf(v).trim());
+        }
+        catch (Exception e)
+        {
+            return null;
+        }
+    }
+
+    private static boolean statusEquals(Integer a, Integer b)
+    {
+        if (a == null && b == null)
+        {
+            return true;
+        }
+        if (a == null || b == null)
+        {
+            return false;
+        }
+        return a.intValue() == b.intValue();
+    }
+
    private static List<String> cleanCodes(List<String> codes)
    {
        if (codes == null || codes.isEmpty())
@@ -186,7 +292,8 @@ public class TabOrderCompareAsyncRunner
    }

    public void put(String taskId, String status, int percent, String message,
-        int scanned, int matched, int missing, String error, List<String> missingSample)
+        int scanned, int matched, int missing, int statusMismatch, String error,
+        List<String> missingSample, List<Map<String, Object>> statusMismatchSample)
    {
        TabOrderCompareTask task = new TabOrderCompareTask();
        task.setTaskId(taskId);
@@ -196,11 +303,16 @@ public class TabOrderCompareAsyncRunner
        task.setScanned(scanned);
        task.setMatched(matched);
        task.setMissing(missing);
+        task.setStatusMismatch(statusMismatch);
        task.setError(error);
        if (missingSample != null)
        {
            task.setMissingTransferNos(new ArrayList<String>(missingSample));
        }
+        if (statusMismatchSample != null)
+        {
+            task.setStatusMismatchSamples(new ArrayList<Map<String, Object>>(statusMismatchSample));
+        }
        redisCache.setCacheObject(CACHE_KEY_PREFIX + taskId, task, TTL_MINUTES, TimeUnit.MINUTES);
    }