From 69933e8f35f573f3401f028f7573fce3b7a299ba Mon Sep 17 00:00:00 2001
From: chen.lin <1442464845@qq.com>
Date: 星期六, 07 二月 2026 10:39:47 +0800
Subject: [PATCH] 完结可以出库成功

---
 rsf-server/src/main/java/com/vincent/rsf/server/manager/service/impl/TaskServiceImpl.java |  221 +++++++++++++++++++++++++++++++++++++++++++++---------
 1 files changed, 182 insertions(+), 39 deletions(-)

diff --git a/rsf-server/src/main/java/com/vincent/rsf/server/manager/service/impl/TaskServiceImpl.java b/rsf-server/src/main/java/com/vincent/rsf/server/manager/service/impl/TaskServiceImpl.java
index 610b525..0da8de8 100644
--- a/rsf-server/src/main/java/com/vincent/rsf/server/manager/service/impl/TaskServiceImpl.java
+++ b/rsf-server/src/main/java/com/vincent/rsf/server/manager/service/impl/TaskServiceImpl.java
@@ -508,22 +508,74 @@
     @Override
     @Transactional(rollbackFor = Exception.class)
     public Task operateComplete(Long id, Long loginUserId) {
-        List<Integer> longs = Arrays.asList(TaskStsType.GENERATE_IN.id, TaskStsType.GENERATE_OUT.id);
+        // 鍏堟煡璇换鍔★紝涓嶉檺鍒剁姸鎬�
         Task task = taskService.getOne(new LambdaQueryWrapper<Task>()
-                .eq(Task::getId, id)
-                .in(Task::getTaskStatus, longs));
+                .eq(Task::getId, id));
 
         if (Objects.isNull(task)) {
-            throw new CoolException("鏁版嵁閿欒锛氬綋鍓嶄换鍔′笉鍙墽琛屽畬缁撴搷浣滐紒锛�");
+            throw new CoolException("浠诲姟涓嶅瓨鍦紒锛�");
+        }
+
+        // 鏍规嵁鍓嶇閫昏緫鍒ゆ柇鏄惁鍏佽瀹屾垚锛�
+        // 鍓嶇鏉′欢锛�((taskStatus < 98) || (taskType >= 101 && taskStatus < 198)) || (taskType == 11 && taskStatus == 101)
+        // 1. 浠讳綍浠诲姟鐘舵�� < 98 閮藉彲浠ュ畬鎴�
+        // 2. 鍑哄簱浠诲姟锛坱askType >= 101锛変笖鐘舵�� < 198 鍙互瀹屾垚
+        // 3. 搴撴牸绉昏浇锛坱askType == 11锛変笖鐘舵�� == 101 鍙互瀹屾垚
+        boolean canComplete = false;
+        if (task.getTaskStatus() < TaskStsType.COMPLETE_IN.id) {
+            // 浠讳綍浠诲姟鐘舵�� < 98 閮藉彲浠ュ畬鎴�
+            canComplete = true;
+        } else if (task.getTaskType() >= 101 && task.getTaskStatus() < TaskStsType.COMPLETE_OUT.id) {
+            // 鍑哄簱浠诲姟涓旂姸鎬� < 198
+            canComplete = true;
+        } else if (task.getTaskType().equals(TaskType.TASK_TYPE_LOC_MOVE.type) 
+                && task.getTaskStatus().equals(TaskStsType.GENERATE_OUT.id)) {
+            // 搴撴牸绉昏浇涓旂姸鎬� == 101
+            canComplete = true;
+        }
+
+        if (!canComplete) {
+            throw new CoolException("鏁版嵁閿欒锛氬綋鍓嶄换鍔′笉鍙墽琛屽畬缁撴搷浣滐紒锛佷换鍔$被鍨嬶細" + task.getTaskType() + "锛屼换鍔$姸鎬侊細" + task.getTaskStatus());
         }
 
         modiftyTaskSort(task, loginUserId);
-        //
-//        if (task.getTaskType().equals(TaskType.TASK_TYPE_LOC_MOVE.type)) {
-//            task.setTaskStatus(TaskStsType.COMPLETE_OUT.id);
-//        } else {
-        task.setTaskStatus(task.getTaskType() < 100 ? TaskStsType.COMPLETE_IN.id : TaskStsType.AWAIT.id);
-//        }
+        
+        // 濡傛灉浠诲姟鐘舵�佸凡缁忔槸AWAIT (196)锛屽啀娆$偣鍑诲畬缁撴椂锛岀洿鎺ュ畬鎴�
+        if (task.getTaskStatus().equals(TaskStsType.AWAIT.id)) {
+            // AWAIT鐘舵�佺殑浠诲姟鍐嶆瀹岀粨锛岀洿鎺ヨ缃负鍑哄簱瀹屾垚
+            task.setTaskStatus(TaskStsType.COMPLETE_OUT.id);
+            
+            // 鏇存柊鍑哄簱绔欑偣鐘舵�侊紙涓嶳CS閫氱煡瀹岀粨淇濇寔涓�鑷达級
+            if (task.getTaskType() >= TaskType.TASK_TYPE_OUT.type && StringUtils.isNotBlank(task.getTargSite())) {
+                BasStation station = basStationService.getOne(new LambdaQueryWrapper<BasStation>()
+                        .eq(BasStation::getStationName, task.getTargSite()));
+                if (Objects.nonNull(station) && station.getType().equals(StationTypeEnum.STATION_TYPE_NORMAL.type)) {
+                    station.setUseStatus(LocStsType.LOC_STS_TYPE_F.type);
+                    if (!basStationService.updateById(station)) {
+                        throw new CoolException("鍑哄簱绔欑偣鐘舵�佷慨鏀瑰け璐ワ紒锛�");
+                    }
+                }
+            }
+        } else {
+            // 鍏朵粬鎯呭喌鎸夊師鏈夐�昏緫澶勭悊
+            // 鍏ュ簱浠诲姟锛坱askType < 100锛夛細璁剧疆涓哄叆搴撳畬鎴�
+            // 鍑哄簱浠诲姟锛坱askType >= 100锛夛細璁剧疆涓虹瓑寰呯‘璁�
+            Integer newStatus = task.getTaskType() < 100 ? TaskStsType.COMPLETE_IN.id : TaskStsType.AWAIT.id;
+            task.setTaskStatus(newStatus);
+            
+            // 濡傛灉鏄叆搴撲换鍔″畬鎴愶紝鏇存柊鍏ュ簱绔欑偣鐘舵�侊紙涓嶳CS閫氱煡瀹岀粨淇濇寔涓�鑷达級
+            if (newStatus.equals(TaskStsType.COMPLETE_IN.id) && StringUtils.isNotBlank(task.getOrgSite())) {
+                BasStation station = basStationService.getOne(new LambdaQueryWrapper<BasStation>()
+                        .eq(BasStation::getStationName, task.getOrgSite()));
+                if (Objects.nonNull(station) && station.getType().equals(StationTypeEnum.STATION_TYPE_NORMAL.type)) {
+                    station.setUseStatus(LocStsType.LOC_STS_TYPE_O.type);
+                    if (!basStationService.updateById(station)) {
+                        throw new CoolException("鍏ュ簱绔欑偣鐘舵�佷慨鏀瑰け璐ワ紒锛�");
+                    }
+                }
+            }
+        }
+        
         if (!this.updateById(task)) {
             throw new CoolException("瀹屾垚浠诲姟澶辫触");
         }
@@ -1541,7 +1593,9 @@
             if (!task.getTaskType().equals(TaskType.TASK_TYPE_LOC_MOVE.type)) {
                 station = basStationService.getOne(new LambdaQueryWrapper<BasStation>().eq(BasStation::getStationName, task.getTargSite()));
                 if (Objects.isNull(station)) {
-                    throw new CoolException("绔欑偣涓嶅瓨鍦紒锛�");
+                    log.error("========== RCS浠诲姟涓嬪彂澶辫触 ==========");
+                    log.error("绔欑偣涓嶅瓨鍦紒锛佷换鍔$紪鐮侊細{}锛岀洰鏍囩珯鐐癸細{}", task.getTaskCode(), task.getTargSite());
+                    continue;
                 }
             }
 
@@ -1550,12 +1604,16 @@
                 if (task.getTaskType() <= TaskType.TASK_TYPE_CHECK_IN.type && !task.getTaskType().equals(TaskType.TASK_TYPE_LOC_MOVE.type)) {
                     station.setUseStatus(LocStsType.LOC_STS_TYPE_R.type);
                     if (!basStationService.updateById(station)) {
-                        throw new CoolException("绔欑偣鐘舵�佹洿鏂板け璐ワ紒锛�");
+                        log.error("========== RCS浠诲姟涓嬪彂澶辫触 ==========");
+                        log.error("绔欑偣鐘舵�佹洿鏂板け璐ワ紒锛佷换鍔$紪鐮侊細{}锛岀珯鐐癸細{}", task.getTaskCode(), station.getStationName());
+                        continue;
                     }
                 } else if (task.getTaskType() >= TaskType.TASK_TYPE_OUT.type) {
                     station.setUseStatus(LocStsType.LOC_STS_TYPE_S.type);
                     if (!basStationService.updateById(station)) {
-                        throw new CoolException("绔欑偣鐘舵�佹洿鏂板け璐ワ紒锛�");
+                        log.error("========== RCS浠诲姟涓嬪彂澶辫触 ==========");
+                        log.error("绔欑偣鐘舵�佹洿鏂板け璐ワ紒锛佷换鍔$紪鐮侊細{}锛岀珯鐐癸細{}", task.getTaskCode(), station.getStationName());
+                        continue;
                     }
                 }
             }
@@ -1578,34 +1636,92 @@
                     || task.getTaskType().equals(TaskType.TASK_TYPE_EMPITY_OUT.type)
                     || task.getTaskType().equals(TaskType.TASK_TYPE_CHECK_OUT.type)
                     || task.getTaskType().equals(TaskType.TASK_TYPE_MERGE_OUT.type)) {
-                /**鍑哄簱鍙傛暟*/
-                itemParam.setOriLoc(task.getOrgLoc())
-                        .setDestSta(task.getTargSite());
+                /**鍑哄簱鍙傛暟 - 闇�瑕佹牴鎹换鍔℃槑缁嗕腑鐨勫涓簱浣嶈繘琛岀粍瑁�*/
+                // 鏌ヨ浠诲姟鏄庣粏
+                List<TaskItem> taskItems = taskItemService.list(new LambdaQueryWrapper<TaskItem>().eq(TaskItem::getTaskId, task.getId()));
+                if (!taskItems.isEmpty()) {
+                    // 閫氳繃TaskItem鐨剆ource瀛楁鏌ヨLocItem锛岃幏鍙栧簱浣嶄俊鎭�
+                    Set<String> locCodes = new HashSet<>();
+                    Map<String, LocItem> locItemMap = new HashMap<>();
+                    
+                    for (TaskItem taskItem : taskItems) {
+                        if (taskItem.getSource() != null) {
+                            // source瀛楁瀵瑰簲LocItem鐨刬d
+                            LocItem locItem = locItemService.getById(taskItem.getSource());
+                            if (locItem != null && StringUtils.isNotBlank(locItem.getLocCode())) {
+                                locCodes.add(locItem.getLocCode());
+                                locItemMap.put(locItem.getLocCode(), locItem);
+                            }
+                        }
+                    }
+                    
+                    // 濡傛灉閫氳繃source娌℃湁鎵惧埌搴撲綅锛屼娇鐢═ask鐨刼rgLoc浣滀负榛樿鍊�
+                    if (locCodes.isEmpty() && StringUtils.isNotBlank(task.getOrgLoc())) {
+                        locCodes.add(task.getOrgLoc());
+                    }
+                    
+                    // 涓烘瘡涓笉鍚岀殑搴撲綅鍒涘缓涓�涓猅askItemParam
+                    for (String locCode : locCodes) {
+                        TaskItemParam outItemParam = new TaskItemParam();
+                        outItemParam.setTaskNo(task.getTaskCode());
+                        outItemParam.setPriority(1);
+                        outItemParam.setOriLoc(locCode);
+                        outItemParam.setDestSta(task.getTargSite());
+                        if (task.getBarcode() != null) {
+                            outItemParam.setZpallet(task.getBarcode());
+                        }
+                        items.add(outItemParam);
+                    }
+                    
+                    log.info("鍑哄簱浠诲姟鍖呭惈{}涓簱浣嶏細{}", locCodes.size(), locCodes);
+                } else {
+                    // 濡傛灉娌℃湁浠诲姟鏄庣粏锛屼娇鐢═ask鐨刼rgLoc
+                    itemParam.setOriLoc(task.getOrgLoc())
+                            .setDestSta(task.getTargSite());
+                    items.add(itemParam);
+                }
             } else {
                 /**绔欑偣闂寸Щ搴撳弬鏁�*/
                 itemParam.setOriSta(task.getOrgSite()).setDestSta(task.getTargSite());
 
                 BasStation curSta = basStationService.getOne(new LambdaQueryWrapper<BasStation>().eq(BasStation::getStationName, task.getOrgSite()));
                 if (Objects.isNull(curSta)) {
-                    throw new CoolException("绔欑偣涓嶅瓨鍦紒锛�");
+                    log.error("========== RCS浠诲姟涓嬪彂澶辫触 ==========");
+                    log.error("绔欑偣涓嶅瓨鍦紒锛佷换鍔$紪鐮侊細{}锛屾簮绔欑偣锛歿}", task.getTaskCode(), task.getOrgSite());
+                    continue;
                 }
                 if (curSta.getType().equals(StationTypeEnum.STATION_TYPE_NORMAL.type)) {
                     if (!curSta.getUseStatus().equals(LocStsType.LOC_STS_TYPE_F.type)) {
-                        throw new CoolException("褰撳墠绔欑偣涓嶆槸F.鍦ㄥ簱鐘舵�侊紒锛�");
+                        log.error("========== RCS浠诲姟涓嬪彂澶辫触 ==========");
+                        log.error("褰撳墠绔欑偣涓嶆槸F.鍦ㄥ簱鐘舵�侊紒锛佷换鍔$紪鐮侊細{}锛岀珯鐐癸細{}锛屽綋鍓嶇姸鎬侊細{}", task.getTaskCode(), curSta.getStationName(), curSta.getUseStatus());
+                        continue;
                     }
                 }
                 // 绔欑偣闂寸Щ搴撻渶瑕佽幏鍙栫洰鏍囩珯鐐�
                 BasStation targetStation = basStationService.getOne(new LambdaQueryWrapper<BasStation>().eq(BasStation::getStationName, task.getTargSite()));
                 if (Objects.isNull(targetStation)) {
-                    throw new CoolException("鐩爣绔欑偣涓嶅瓨鍦紒锛�");
+                    log.error("========== RCS浠诲姟涓嬪彂澶辫触 ==========");
+                    log.error("鐩爣绔欑偣涓嶅瓨鍦紒锛佷换鍔$紪鐮侊細{}锛岀洰鏍囩珯鐐癸細{}", task.getTaskCode(), task.getTargSite());
+                    continue;
                 }
                 if (targetStation.getType().equals(StationTypeEnum.STATION_TYPE_NORMAL.type)) {
                     if (!targetStation.getUseStatus().equals(LocStsType.LOC_STS_TYPE_O.type)) {
-                        throw new CoolException("鐩爣绔欑偣涓嶆槸O.绌洪棽鐘舵�侊紒锛�");
+                        log.error("========== RCS浠诲姟涓嬪彂澶辫触 ==========");
+                        log.error("鐩爣绔欑偣涓嶆槸O.绌洪棽鐘舵�侊紒锛佷换鍔$紪鐮侊細{}锛岀珯鐐癸細{}锛屽綋鍓嶇姸鎬侊細{}", task.getTaskCode(), targetStation.getStationName(), targetStation.getUseStatus());
+                        continue;
                     }
                 }
             }
-            items.add(itemParam);
+            
+            // 瀵逛簬闈炲嚭搴撲换鍔★紝娣诲姞鍗曚釜itemParam
+            if (!(task.getTaskType().equals(TaskType.TASK_TYPE_OUT.type)
+                    || task.getTaskType().equals(TaskType.TASK_TYPE_PICK_AGAIN_OUT.type)
+                    || task.getTaskType().equals(TaskType.TASK_TYPE_EMPITY_OUT.type)
+                    || task.getTaskType().equals(TaskType.TASK_TYPE_CHECK_OUT.type)
+                    || task.getTaskType().equals(TaskType.TASK_TYPE_MERGE_OUT.type))) {
+                items.add(itemParam);
+            }
+            
             taskParams.setTasks(items);
             
             // 璁板綍褰撳墠浠诲姟淇℃伅
@@ -1645,9 +1761,11 @@
                 if (cause instanceof java.net.SocketTimeoutException || 
                     (cause instanceof java.net.ConnectException && cause.getMessage() != null && cause.getMessage().contains("timed out")) ||
                     (errorMsg != null && (errorMsg.contains("Connection timed out") || errorMsg.contains("timed out") || errorMsg.contains("timeout")))) {
-                    throw new CoolException("RCS杩炴帴瓒呮椂锛屼换鍔′笅鍙戝け璐ワ紒浠诲姟缂栫爜锛�" + task.getTaskCode() + "锛岄敊璇俊鎭細" + errorMsg);
+                    log.error("RCS杩炴帴瓒呮椂锛屼换鍔′笅鍙戝け璐ワ紒浠诲姟缂栫爜锛歿}锛岄敊璇俊鎭細{}", task.getTaskCode(), errorMsg);
+                } else {
+                    log.error("RCS璧勬簮璁块棶寮傚父锛屼换鍔′笅鍙戝け璐ワ紒浠诲姟缂栫爜锛歿}锛岄敊璇俊鎭細{}", task.getTaskCode(), errorMsg);
                 }
-                throw new CoolException("RCS璧勬簮璁块棶寮傚父锛屼换鍔′笅鍙戝け璐ワ紒浠诲姟缂栫爜锛�" + task.getTaskCode() + "锛岄敊璇俊鎭細" + errorMsg);
+                continue;
             } catch (Exception e) {
                 long endTime = System.currentTimeMillis();
                 log.error("========== RCS浠诲姟涓嬪彂寮傚父 ==========");
@@ -1657,9 +1775,11 @@
                 String errorMsg = e.getMessage();
                 // 妫�鏌ユ槸鍚︽槸杩炴帴瓒呮椂鐩稿叧鐨勫紓甯�
                 if (errorMsg != null && (errorMsg.contains("Connection timed out") || errorMsg.contains("timed out") || errorMsg.contains("timeout"))) {
-                    throw new CoolException("RCS杩炴帴瓒呮椂锛屼换鍔′笅鍙戝け璐ワ紒浠诲姟缂栫爜锛�" + task.getTaskCode() + "锛岄敊璇俊鎭細" + errorMsg);
+                    log.error("RCS杩炴帴瓒呮椂锛屼换鍔′笅鍙戝け璐ワ紒浠诲姟缂栫爜锛歿}锛岄敊璇俊鎭細{}", task.getTaskCode(), errorMsg);
+                } else {
+                    log.error("RCS浠诲姟涓嬪彂寮傚父锛佷换鍔$紪鐮侊細{}锛岄敊璇俊鎭細{}", task.getTaskCode(), errorMsg);
                 }
-                throw new CoolException("RCS浠诲姟涓嬪彂寮傚父锛佷换鍔$紪鐮侊細" + task.getTaskCode() + "锛岄敊璇俊鎭細" + errorMsg);
+                continue;
             }
             
             if (Objects.isNull(exchange) || Objects.isNull(exchange.getBody())) {
@@ -1668,7 +1788,8 @@
                 log.error("璇锋眰RCS-鍦板潃锛歿}", pubTakUrl);
                 log.error("璇锋眰RCS-鍙傛暟锛歿}", JSONObject.toJSONString(taskParams));
                 log.error("璇锋眰RCS-澶辫触鐨勪换鍔$紪鐮侊細{}", task.getTaskCode());
-                throw new CoolException("浠诲姟涓嬪彂澶辫触锛孯CS鍝嶅簲浣撲负绌猴紒锛佷换鍔$紪鐮侊細" + task.getTaskCode());
+                log.error("浠诲姟涓嬪彂澶辫触锛孯CS鍝嶅簲浣撲负绌猴紒锛佷换鍔$紪鐮侊細{}", task.getTaskCode());
+                continue;
             } else {
                 try {
                     ObjectMapper objectMapper = new ObjectMapper();
@@ -1688,13 +1809,17 @@
 
                             BasStation curSta = basStationService.getOne(new LambdaQueryWrapper<BasStation>().eq(BasStation::getStationName, task.getOrgSite()));
                             if (Objects.isNull(curSta)) {
-                                throw new CoolException("绔欑偣涓嶅瓨鍦紒锛�");
+                                log.error("========== RCS浠诲姟涓嬪彂澶辫触 ==========");
+                                log.error("绔欑偣涓嶅瓨鍦紒锛佷换鍔$紪鐮侊細{}锛屾簮绔欑偣锛歿}", task.getTaskCode(), task.getOrgSite());
+                                continue;
                             }
 
                             log.info("鏇存柊鍏ュ簱浠诲姟鐘舵�� - 浠诲姟缂栫爜锛歿}锛屾柊鐘舵�侊細{}", task.getTaskCode(), TaskStsType.WCS_EXECUTE_IN.id);
                             if (!taskService.update(new LambdaUpdateWrapper<Task>().eq(Task::getTaskCode, task.getTaskCode())
                                     .set(Task::getTaskStatus, TaskStsType.WCS_EXECUTE_IN.id))) {
-                                throw new CoolException("浠诲姟鐘舵�佷慨鏀瑰け璐ワ紒锛�");
+                                log.error("========== RCS浠诲姟涓嬪彂澶辫触 ==========");
+                                log.error("浠诲姟鐘舵�佷慨鏀瑰け璐ワ紒锛佷换鍔$紪鐮侊細{}", task.getTaskCode());
+                                continue;
                             }
                             log.info("鍏ュ簱浠诲姟鐘舵�佹洿鏂版垚鍔� - 浠诲姟缂栫爜锛歿}", task.getTaskCode());
                             /**鎺掗櫎绉诲簱鍔熻兘*/
@@ -1703,7 +1828,9 @@
                                 if (curSta.getType().equals(StationTypeEnum.STATION_TYPE_NORMAL.type)) {
                                     curSta.setUseStatus(LocStsType.LOC_STS_TYPE_R.type);
                                     if (!basStationService.updateById(curSta)) {
-                                        throw new CoolException("绔欑偣棰勭害澶辫触锛侊紒");
+                                        log.error("========== RCS浠诲姟涓嬪彂澶辫触 ==========");
+                                        log.error("绔欑偣棰勭害澶辫触锛侊紒浠诲姟缂栫爜锛歿}锛岀珯鐐癸細{}", task.getTaskCode(), curSta.getStationName());
+                                        continue;
                                     }
                                 }
                             }
@@ -1714,20 +1841,26 @@
                                 || task.getTaskType().equals(TaskType.TASK_TYPE_PICK_AGAIN_OUT.type)) {
                             BasStation curSta = basStationService.getOne(new LambdaQueryWrapper<BasStation>().eq(BasStation::getStationName, task.getTargSite()));
                             if (Objects.isNull(curSta)) {
-                                throw new CoolException("绔欑偣涓嶅瓨鍦紒锛�");
+                                log.error("========== RCS浠诲姟涓嬪彂澶辫触 ==========");
+                                log.error("绔欑偣涓嶅瓨鍦紒锛佷换鍔$紪鐮侊細{}锛岀洰鏍囩珯鐐癸細{}", task.getTaskCode(), task.getTargSite());
+                                continue;
                             }
 
                             log.info("鏇存柊鍑哄簱浠诲姟鐘舵�� - 浠诲姟缂栫爜锛歿}锛屾柊鐘舵�侊細{}", task.getTaskCode(), TaskStsType.WCS_EXECUTE_OUT.id);
                             if (!taskService.update(new LambdaUpdateWrapper<Task>().eq(Task::getTaskCode, task.getTaskCode())
                                     .set(Task::getTaskStatus, TaskStsType.WCS_EXECUTE_OUT.id))) {
-                                throw new CoolException("浠诲姟鐘舵�佷慨鏀瑰け璐ワ紒锛�");
+                                log.error("========== RCS浠诲姟涓嬪彂澶辫触 ==========");
+                                log.error("浠诲姟鐘舵�佷慨鏀瑰け璐ワ紒锛佷换鍔$紪鐮侊細{}", task.getTaskCode());
+                                continue;
                             }
                             log.info("鍑哄簱浠诲姟鐘舵�佹洿鏂版垚鍔� - 浠诲姟缂栫爜锛歿}", task.getTaskCode());
                             /**濡傛灉鏄櫘閫氱珯鐐癸紝淇敼绔欑偣鐘舵�佷负鍏ュ簱棰勭害*/
                             if (curSta.getType().equals(StationTypeEnum.STATION_TYPE_NORMAL.type)) {
                                 curSta.setUseStatus(LocStsType.LOC_STS_TYPE_S.type);
                                 if (!basStationService.updateById(curSta)) {
-                                    throw new CoolException("绔欑偣棰勭害澶辫触锛侊紒");
+                                    log.error("========== RCS浠诲姟涓嬪彂澶辫触 ==========");
+                                    log.error("绔欑偣棰勭害澶辫触锛侊紒浠诲姟缂栫爜锛歿}锛岀珯鐐癸細{}", task.getTaskCode(), curSta.getStationName());
+                                    continue;
                                 }
                             }
                         }
@@ -1736,16 +1869,19 @@
                         log.error("RCS杩斿洖閿欒 - code锛歿}锛宮sg锛歿}锛宒ata锛歿}", 
                                 result.getCode(), result.getMsg(), result.getData());
                         log.error("澶辫触鐨勪换鍔$紪鐮侊細{}锛屼换鍔$被鍨嬶細{}", task.getTaskCode(), task.getTaskType());
-                        throw new CoolException("浠诲姟涓嬪彂澶辫触锛侊紒浠诲姟缂栫爜锛�" + task.getTaskCode());
+                        log.error("浠诲姟涓嬪彂澶辫触锛侊紒浠诲姟缂栫爜锛歿}", task.getTaskCode());
+                        continue;
                     }
                 } catch (JsonProcessingException e) {
                     log.error("========== RCS浠诲姟涓嬪彂寮傚父 ==========");
                     log.error("瑙f瀽RCS鍝嶅簲澶辫触锛屽搷搴斾綋锛歿}锛屼换鍔$紪鐮侊細{}", exchange.getBody(), task.getTaskCode(), e);
-                    throw new CoolException("瑙f瀽RCS鍝嶅簲澶辫触锛�" + e.getMessage() + "锛屼换鍔$紪鐮侊細" + task.getTaskCode());
+                    log.error("瑙f瀽RCS鍝嶅簲澶辫触锛歿}锛屼换鍔$紪鐮侊細{}", e.getMessage(), task.getTaskCode());
+                    continue;
                 } catch (Exception e) {
                     log.error("========== RCS浠诲姟涓嬪彂寮傚父 ==========");
                     log.error("浠诲姟涓嬪彂杩囩▼涓彂鐢熷紓甯革紝浠诲姟缂栫爜锛歿}", task.getTaskCode(), e);
-                    throw e;
+                    log.error("浠诲姟涓嬪彂寮傚父锛歿}锛屼换鍔$紪鐮侊細{}", e.getMessage(), task.getTaskCode());
+                    continue;
                 }
             }
         }
@@ -1805,8 +1941,10 @@
             List<TaskItem> items = orderMap.get(key);
             //淇濆瓨鍏ュ嚭搴撴槑缁�
             saveStockItems(items, task, pakinItem.getId(), pakinItem.getAsnCode(), pakinItem.getWkType(), pakinItem.getType(), loginUserId);
-            //绉诲嚭鏀惰揣鍖哄簱瀛橈紝 淇敼缁勬墭鐘舵��
-            removeReceiptStock(pakinItem, loginUserId);
+            //绉诲嚭鏀惰揣鍖哄簱瀛橈紝 淇敼缁勬墭鐘舵�侊紙鍙湁褰搒ource涓嶄负null鏃舵墠闇�瑕佺Щ闄ゆ敹璐у尯搴撳瓨锛�
+            if (Objects.nonNull(pakinItem.getSource())) {
+                removeReceiptStock(pakinItem, loginUserId);
+            }
         });
 
         Set<Long> pkinItemIds = taskItems.stream().map(TaskItem::getSource).collect(Collectors.toSet());
@@ -1842,6 +1980,10 @@
      */
     @Transactional(rollbackFor = Exception.class)
     public synchronized void removeReceiptStock(WaitPakinItem pakinItem, Long loginUserId) {
+        // 濡傛灉source涓簄ull锛岃鏄庣粍鎵樻槑缁嗕笉鍦ㄦ敹璐у尯锛屾棤闇�绉婚櫎鏀惰揣鍖哄簱瀛�
+        if (Objects.isNull(pakinItem.getSource())) {
+            return;
+        }
         WarehouseAreasItem itemServiceOne = warehouseAreasItemService.getOne(new LambdaQueryWrapper<WarehouseAreasItem>()
                 .eq(WarehouseAreasItem::getId, pakinItem.getSource()));
         if (Objects.isNull(itemServiceOne)) {
@@ -1889,7 +2031,8 @@
                     .eq(LocItem::getMatnrId, taskItem.getMatnrId())
                     .eq(LocItem::getLocId, loc.getId())
                     .eq(StringUtils.isNotBlank(taskItem.getBatch()), LocItem::getBatch, taskItem.getBatch())
-                    .eq(StringUtils.isNotBlank(taskItem.getFieldsIndex()), LocItem::getFieldsIndex, taskItem.getFieldsIndex()));
+                    .eq(StringUtils.isNotBlank(taskItem.getFieldsIndex()), LocItem::getFieldsIndex, taskItem.getFieldsIndex())
+            );
             if (Objects.isNull(locItem)) {
                 BeanUtils.copyProperties(taskItem, item);
                 item.setLocCode(loc.getCode())
@@ -1902,7 +2045,7 @@
                     throw new CoolException("搴撲綅鏄庣粏鏇存柊澶辫触锛侊紒");
                 }
             } else {
-                logger.error("褰撳墠绁ㄥ彿:"  + locItem.getFieldsIndex()  + " 宸插湪搴撳唴锛岃妫�鏌ュ悗鍐嶆搷浣滐紒锛�");
+//                logger.error("褰撳墠绁ㄥ彿:"  + locItem.getFieldsIndex()  + " 宸插湪搴撳唴锛岃妫�鏌ュ悗鍐嶆搷浣滐紒锛�");
 //                throw new CoolException("褰撳墠绁ㄥ彿宸插湪搴撳唴锛岃妫�鏌ュ悗鍐嶆搷浣滐紒锛�");
 //                locItem.setAnfme(Math.round((locItem.getAnfme() + taskItem.getAnfme()) * 1000000) / 1000000.0)
 //                        .setUpdateTime(new Date());

--
Gitblit v1.9.1