二次请求地址使用配置

acs2/nladmin-system/nlsso-server/src/main/java/org/nl/acs/device/deviceDriver/service/defination/opcDefination/standardInspectSite/StandardInspectSiteDeviceDriver.java

@@ -15,12 +15,12 @@ import org.nl.acs.device.device.service.DeviceAppService;
 import org.nl.acs.task.history.ErrorUtil;
 import org.nl.acs.task.instruction.domain.Instruction;
 import org.nl.acs.task.instruction.service.InstructionService;
-import org.nl.acs.task.task.service.TaskService;
-import org.nl.acs.task.task.service.dto.TaskDto;
 import org.nl.config.SpringContextHolder;
 import org.nl.config.language.LangProcess;
 import org.nl.config.lucene.service.LuceneExecuteLogService;
 import org.nl.extInterface.agvKit.service.AcsToKitService;
+import org.nl.extInterface.wms.service.AcsToWmsService;
+import org.nl.extInterface.wms.service.enums.WmsFeedbackStatusEnum;
 
 import java.util.Date;
 import java.util.HashMap;
@@ -38,9 +38,9 @@ public class StandardInspectSiteDeviceDriver extends AbstractOpcDeviceDriver {
 
     private final LuceneExecuteLogService luceneExecuteLogService = SpringContextHolder.getBean(LuceneExecuteLogService.class);
     private final InstructionService instructionService = SpringContextHolder.getBean(InstructionService.class);
-    private final TaskService taskService = SpringContextHolder.getBean(TaskService.class);
     private final AcsToKitService acsToKitService = SpringContextHolder.getBean(AcsToKitService.class);
     private final DeviceAppService deviceAppService = SpringContextHolder.getBean(DeviceAppService.class);
+    private final AcsToWmsService acsToWmsService = SpringContextHolder.getBean(AcsToWmsService.class);
 
     private volatile int agvphase = 0;
     /**
@@ -157,14 +157,13 @@ public class StandardInspectSiteDeviceDriver extends AbstractOpcDeviceDriver {
             Thread.sleep(2000);
             this.devicecode = this.getDevice().getDevice_code();
             if (this.reqTakeRequireSuccess && ObjectUtil.isNotEmpty(this.reqTakeInstCode)) {
+                // 驱动按周期执行，当前直接 return 就会停留在等待态，下一轮继续请求 WMS 许可。
                 Instruction instruction = instructionService.findByCodeFromCache(this.reqTakeInstCode);
                 //取货申请
                 log.info("点位上报状态,{},{}",instruction.getTask_code(),agvphase);
                 if (ObjectUtil.isNotEmpty(instruction) && StrUtil.equals(instruction.getStart_point_code(), this.devicecode)) {
                     if (agvphase == 1) {
-                        TaskService taskService = SpringContextHolder.getBean("taskServiceImpl");
-                        TaskDto task = taskService.findByCode(instruction.getTask_code());
-                        if ((StrUtil.startWith(task.getTask_code(), "-"))) {
+                        if ((StrUtil.startWith(instruction.getTask_code(), "-"))) {
                             log.info("定点任务下发agv允许取货信号");
                             StorageCellDto dto = StorageCellServiceImpl.Storage_Cache_Map.get(instruction.getStart_point_code());
                             if (dto == null) {
@@ -179,7 +178,8 @@ public class StandardInspectSiteDeviceDriver extends AbstractOpcDeviceDriver {
                             } else {
                                 resetInstTask(agvphase);
                             }
-                        } else {
+                        } else
+                        {
                             HttpResponse result1 = acsToKitService.genAgvSchedulingTask(instruction, 10);
                             if (ObjectUtils.isEmpty(result1) || result1.getStatus() != 200) {
                                 return;
@@ -189,10 +189,8 @@ public class StandardInspectSiteDeviceDriver extends AbstractOpcDeviceDriver {
                         }
                     }
                     if (agvphase == 2) {
-                        TaskService taskService = SpringContextHolder.getBean("taskServiceImpl");
-                        TaskDto task = taskService.findByCode(instruction.getTask_code());
-
-                        if ((StrUtil.startWith(task.getTask_code(), "-"))) {
+                        acsToWmsService.feedbackTask(instruction, WmsFeedbackStatusEnum.TAKE_FINISH.getValue());
+                        if ((StrUtil.startWith(instruction.getTask_code(), "-"))) {
                             log.info("定点任务下发agv允许取货信号");
                             StorageCellDto dto = StorageCellServiceImpl.Storage_Cache_Map.get(instruction.getStart_point_code());
                             if (dto == null) {
@@ -220,9 +218,7 @@ public class StandardInspectSiteDeviceDriver extends AbstractOpcDeviceDriver {
                 //放货申请
                 else if (ObjectUtil.isNotEmpty(instruction) && StrUtil.equals(instruction.getNext_point_code(), this.devicecode)) {
                     if (agvphase == 3) {
-                        TaskService taskService = SpringContextHolder.getBean("taskServiceImpl");
-                        TaskDto task = taskService.findByCode(instruction.getTask_code());
-                        if ((StrUtil.startWith(task.getTask_code(), "-"))) {
+                        if ((StrUtil.startWith(instruction.getTask_code(), "-"))) {
                             log.info("定点任务下发agv允许取货信号");
                             StorageCellDto dto = StorageCellServiceImpl.Storage_Cache_Map.get(instruction.getNext_point_code());
                             if (dto == null) {
@@ -247,9 +243,8 @@ public class StandardInspectSiteDeviceDriver extends AbstractOpcDeviceDriver {
                         }
                     }
                     if (agvphase == 4) {
-                        TaskService taskService = SpringContextHolder.getBean("taskServiceImpl");
-                        TaskDto task = taskService.findByCode(instruction.getTask_code());
-                        if ((StrUtil.startWith(task.getTask_code(), "-"))) {
+                        acsToWmsService.feedbackTask(instruction, WmsFeedbackStatusEnum.PUT_FINISH.getValue());
+                        if ((StrUtil.startWith(instruction.getTask_code(), "-"))) {
                             log.info("定点任务下发agv允许取货信号");
                             StorageCellDto dto = StorageCellServiceImpl.Storage_Cache_Map.get(instruction.getNext_point_code());
                             if (dto == null) {
@@ -387,7 +382,7 @@ public class StandardInspectSiteDeviceDriver extends AbstractOpcDeviceDriver {
                 return;
             }
             // 设置新任务
-//            this.agvPhase = Integer.valueOf(innerParamss.get("agvphase"));
+            this.agvphase = Integer.valueOf(innerParamss.get("agvphase"));
             this.reqTakeInstCode = taskId;
             this.reqTakeRequireSuccess = true;
         }
@@ -406,4 +401,18 @@ public class StandardInspectSiteDeviceDriver extends AbstractOpcDeviceDriver {
             this.agvphase = 0;
         }
     }
+
+    private boolean requestPermission(Instruction instruction, String permissionStatus, String progressStatus) {
+        boolean allowed = acsToWmsService.feedbackTask(instruction, permissionStatus);
+        if (allowed) {
+            // WMS 放行后，先把外部状态推进到执行中，再继续给 AGV 下发动作。
+            acsToWmsService.feedbackTask(instruction, progressStatus);
+        }
+        return allowed;
+    }
+
+    private String unusedResolveCard(Instruction instruction) {
+        // 优先取任务上已绑定的车号，没有时再回退到当前指令上的车号。
+        return instruction == null ? "" : StrUtil.blankToDefault(instruction.getCarno(), "");
+    }
 }

acs2/nladmin-system/nlsso-server/src/main/java/org/nl/acs/device/deviceDriver/service/defination/ordinaryDefination/standardOrdinarySite/StandardOrdinarySiteDeviceDriver.java

@@ -12,12 +12,14 @@ import org.nl.acs.device.deviceDriver.service.defination.ordinaryDefination.Abst
 import org.nl.acs.device.storageMgt.service.dto.StorageCellDto;
 import org.nl.acs.device.storageMgt.service.impl.StorageCellServiceImpl;
 import org.nl.acs.device.device.service.DeviceAppService;
+import org.nl.acs.task.TaskConfig;
 import org.nl.acs.task.instruction.domain.Instruction;
 import org.nl.acs.task.instruction.service.InstructionService;
-import org.nl.acs.task.task.service.TaskService;
-import org.nl.acs.task.task.service.dto.TaskDto;
 import org.nl.config.SpringContextHolder;
+import org.nl.system.service.param.ISysParamService;
 import org.nl.extInterface.agvKit.service.AcsToKitService;
+import org.nl.extInterface.wms.service.AcsToWmsService;
+import org.nl.extInterface.wms.service.enums.WmsFeedbackStatusEnum;
 
 import java.util.Map;
 
@@ -32,6 +34,8 @@ public class StandardOrdinarySiteDeviceDriver extends AbstractStandardDeviceDriv
     private final InstructionService instructionService = SpringContextHolder.getBean(InstructionService.class);
     private final DeviceAppService deviceAppService = SpringContextHolder.getBean(DeviceAppService.class);
     private final AcsToKitService acsToKitService = SpringContextHolder.getBean(AcsToKitService.class);
+    private final AcsToWmsService acsToWmsService = SpringContextHolder.getBean(AcsToWmsService.class);
+    private final ISysParamService paramService = SpringContextHolder.getBean(ISysParamService.class);
 
     private int flag;
 
@@ -73,21 +77,31 @@ public class StandardOrdinarySiteDeviceDriver extends AbstractStandardDeviceDriv
         try {
             Thread.sleep(2000);
             if (this.reqTakeRequireSuccess && ObjectUtil.isNotEmpty(this.reqTakeInstCode)) {
+                // 驱动按周期执行，当前直接 return 就会停留在等待态，下一轮继续请求 WMS 许可。
                 Instruction instruction = instructionService.findByCodeFromCache(this.reqTakeInstCode);
                 //取货申请F
                 log.info("点位上报状态,{},{}", instruction.getTask_code(), agvPhase);
 
                 if (ObjectUtil.isNotEmpty(instruction) && StrUtil.equals(instruction.getStart_point_code(), this.deviceCode)) {
                     if (agvPhase == 1) {
-//    device = deviceAppService.findDeviceByCode(this.deviceCode);
-                        StorageCellDto dto = StorageCellServiceImpl.Storage_Cache_Map.get(instruction.getStart_point_code());
+                        //取货申请
+                        if (!requestPermission(instruction, WmsFeedbackStatusEnum.APPLY_TAKE.getValue())) {
+                            return;
+                        }
+                        //二次请求判断
+                        Instruction currentInstruction = redirectIfNeeded(instruction);
+                        if (currentInstruction == null) {
+                            return;
+                        }
+                        StorageCellDto dto = StorageCellServiceImpl.Storage_Cache_Map.get(currentInstruction.getStart_point_code());
                         if (dto == null) {
                             log.error(instruction.getStart_point_code() + "Storage_Cache_Map数据不存在");
                             return;
                         }
-                        instruction.setOffSet(dto.getAddress());
-                        instruction.setOffSetName(instruction.getStart_point_code());
-                        HttpResponse result = acsToKitService.genAgvSchedulingTask(instruction, 10);
+                        currentInstruction.setOffSet(dto.getAddress());
+                        currentInstruction.setOffSetName(currentInstruction.getStart_point_code());
+                        //反馈取货申请
+                        HttpResponse result = acsToKitService.genAgvSchedulingTask(currentInstruction, 10);
                         if (ObjectUtils.isEmpty(result) || result.getStatus() != 200) {
                             return;
                         } else {
@@ -95,8 +109,7 @@ public class StandardOrdinarySiteDeviceDriver extends AbstractStandardDeviceDriv
                         }
                     }
                     if (agvPhase == 2) {
-                        TaskService taskService = SpringContextHolder.getBean("taskServiceImpl");
-                        TaskDto task = taskService.findByCode(instruction.getTask_code());
+                        acsToWmsService.feedbackTask(instruction, WmsFeedbackStatusEnum.TAKE_FINISH.getValue());
                         StorageCellDto dto = StorageCellServiceImpl.Storage_Cache_Map.get(instruction.getStart_point_code());
                         if (dto == null) {
                             log.error(instruction.getStart_point_code() + "Storage_Cache_Map数据不存在");
@@ -104,7 +117,7 @@ public class StandardOrdinarySiteDeviceDriver extends AbstractStandardDeviceDriv
                         }
                         instruction.setOffSet(dto.getAddress());
                         instruction.setOffSetName(instruction.getStart_point_code());
-                        if ((StrUtil.startWith(task.getTask_code(), "-"))) {
+                        if ((StrUtil.startWith(instruction.getTask_code(), "-"))) {
                             log.info("定点任务下发agv允许取货信号");
                             HttpResponse result = acsToKitService.genAgvSchedulingTask(instruction, 10);
                             if (ObjectUtils.isEmpty(result) || result.getStatus() != 200) {
@@ -125,6 +138,10 @@ public class StandardOrdinarySiteDeviceDriver extends AbstractStandardDeviceDriv
                 //放货申请
                 else if (ObjectUtil.isNotEmpty(instruction) && StrUtil.equals(instruction.getNext_point_code(), this.deviceCode)) {
                     if (agvPhase == 3) {
+                        //放货申请
+                        if (!requestPermission(instruction, WmsFeedbackStatusEnum.APPLY_PUT.getValue())) {
+                            return;
+                        }
                         StorageCellDto dto = StorageCellServiceImpl.Storage_Cache_Map.get(instruction.getNext_point_code());
                         if (dto == null) {
                             log.error(instruction.getStart_point_code() + "Storage_Cache_Map数据不存在");
@@ -140,8 +157,7 @@ public class StandardOrdinarySiteDeviceDriver extends AbstractStandardDeviceDriv
                         }
                     }
                     if (agvPhase == 4) {
-                        TaskService taskService = SpringContextHolder.getBean("taskServiceImpl");
-                        TaskDto task = taskService.findByCode(instruction.getTask_code());
+                        acsToWmsService.feedbackTask(instruction, WmsFeedbackStatusEnum.PUT_FINISH.getValue());
                         StorageCellDto dto = StorageCellServiceImpl.Storage_Cache_Map.get(instruction.getNext_point_code());
                         if (dto == null) {
                             log.error(instruction.getStart_point_code() + "Storage_Cache_Map数据不存在");
@@ -149,7 +165,7 @@ public class StandardOrdinarySiteDeviceDriver extends AbstractStandardDeviceDriv
                         }
                         instruction.setOffSet(dto.getAddress1());
                         instruction.setOffSetName(instruction.getNext_point_code());
-                        if ((StrUtil.startWith(task.getTask_code(), "-"))) {
+                        if ((StrUtil.startWith(instruction.getTask_code(), "-"))) {
                             log.info("定点任务下发agv允许取货信号");
                             HttpResponse result = acsToKitService.genAgvSchedulingTask(instruction, 10);
                             if (ObjectUtils.isEmpty(result) || result.getStatus() != 200) {
@@ -226,5 +242,30 @@ public class StandardOrdinarySiteDeviceDriver extends AbstractStandardDeviceDriv
             this.agvPhase = 0;
         }
     }
+
+    private boolean requestPermission(Instruction instruction, String permissionStatus) {
+        return acsToWmsService.feedbackTask(instruction, permissionStatus);
+    }
+
+    private Instruction redirectIfNeeded(Instruction instruction) {
+        String redirectionPoint = paramService.findByCode(TaskConfig.REDIRECTION_POINT).getValue();
+        if (!StrUtil.equals(instruction.getNext_point_code(), redirectionPoint)) {
+            return instruction;
+        }
+        JSONObject response = acsToWmsService.taskRedirection(instruction.getTask_code(), instruction.getNext_point_code());
+        if (response == null || !Integer.valueOf(0).equals(response.getInteger("responseCode"))) {
+            log.error("taskRedirection failed, taskCode:{}, currLocation:{}, response:{}",
+                    instruction.getTask_code(), instruction.getNext_point_code(), response);
+            return null;
+        }
+        String locationNew = response.getString("locationNew");
+        if (StrUtil.isBlank(locationNew)) {
+            log.error("taskRedirection locationNew is blank, taskCode:{}, response:{}",
+                    instruction.getTask_code(), response);
+            return null;
+        }
+        instruction.setStart_device_code(locationNew);
+        return instruction;
+    }
 }
 

acs2/nladmin-system/nlsso-server/src/main/java/org/nl/acs/task/TaskConfig.java

@@ -65,11 +65,16 @@ public class TaskConfig {
      * WMS系统接口地址
      */
     public static String WMSURL = "wmsurl";
+    public static String WMS_HOUSE_CODE = "wmsHouseCode";
+    public static String WMS_SYSTEM_CODE = "wmsSystemCode";
+    public static String WMS_FEEDBACK_RETRY_MS = "wmsFeedbackRetryMs";
     /**
      * WCS系统接口地址
      */
     public static String WCSURL = "wcsurl";
 
+    public static String KITAGVURL = "kitagvurl";
+
     public static String HASOTHERSYSTEM = "hasOtherSystem";
 
     public static String ERPURL = "erpurl";
@@ -149,6 +154,11 @@ public class TaskConfig {
      */
     public static String CHOOSE = "choose";
 
+    /**
+     * 需要重定向的目标点位编码（如 7E）
+     */
+    public static String REDIRECTION_POINT = "redirectionPoint";
+
     public static String ELECTRIC ="electric";
 
     public static String ELECTRIC2 ="electric2";

acs2/nladmin-system/nlsso-server/src/main/java/org/nl/acs/task/instruction/service/impl/InstructionServiceImpl.java

@@ -7,6 +7,7 @@ import cn.hutool.core.date.DateUtil;
 import cn.hutool.core.util.IdUtil;
 import cn.hutool.core.util.ObjectUtil;
 import cn.hutool.core.util.StrUtil;
+import cn.hutool.http.HttpResponse;
 import com.alibaba.fastjson.JSON;
 import com.alibaba.fastjson.JSONArray;
 import com.alibaba.fastjson.JSONObject;
@@ -56,6 +57,7 @@ import org.nl.config.language.LangProcess;
 import org.nl.config.lucene.enums.LogLevelEnum;
 import org.nl.config.lucene.service.LuceneExecuteLogService;
 import org.nl.config.lucene.service.dto.LuceneLogDto;
+import org.nl.extInterface.agvKit.service.AcsToKitService;
 import org.nl.system.service.param.ISysParamService;
 import org.nl.common.utils.CodeUtil;
 import org.nl.config.SpringContextHolder;
@@ -67,6 +69,7 @@ import org.springframework.data.domain.Pageable;
 
 import javax.servlet.http.HttpServletResponse;
 import java.io.IOException;
+import java.net.InetSocketAddress;
 import java.util.*;
 import java.util.concurrent.CopyOnWriteArrayList;
 import java.util.regex.Pattern;
@@ -94,6 +97,8 @@ public class InstructionServiceImpl extends CommonServiceImpl<InstructionMapper,
     private RouteLineService routeLineService;
     @Autowired
     private TaskService taskService;
+    @Autowired
+    private AcsToKitService acsToKitService;
 
     @Autowired
     private LuceneExecuteLogService luceneExecuteLogService;
@@ -431,7 +436,8 @@ public class InstructionServiceImpl extends CommonServiceImpl<InstructionMapper,
             if (StrUtil.equals(shortPathsList.get(0).getType(), CommonFinalParam.ONE)) {
                 throw new BadRequestException(dto.getStart_device_code() + "->" + dto.getNext_device_code() + "路由类型不是agv类型");
             }
-            if (shortPathsList.size() > 0 && StrUtil.equals(shortPathsList.get(0).getType(), CommonFinalParam.ONE) && dto.getAgv_system_type().equals(AgvSystemTypeEnum.Two_NDC_System_Type.getIndex())) {
+            if (shortPathsList.size() > 0 && StrUtil.equals(shortPathsList.get(0).getType(), CommonFinalParam.ONE) && dto.getAgv_system_type().equals(AgvSystemTypeEnum.Two_NDC_System_Type.getIndex()))
+            {
                 // 0为输送、立库任务  1 1楼叉车系统  2 2楼1区域AGV系统 3 2楼2区域AGV系统
                 if (!StrUtil.equals(task.getAgv_system_type(), "0")
                         && ObjectUtil.isNotEmpty(task.getAgv_system_type())) {
@@ -439,49 +445,20 @@ public class InstructionServiceImpl extends CommonServiceImpl<InstructionMapper,
                         String agv_system_type = task.getAgv_system_type();
                         String task_type = task.getTask_type();
                         if (!StrUtil.equals(agv_system_type, "1")) {
-                            // task_type
-                            //1、生箔； Itype=1:取空，取满，放空，放满；
-                            //2、分切  Itype=3取满、取空、放满、放空；
-                            //3、普通任务 Itype=2:取货、放货；
-                            //4、叉车任务
-                            //5、输送任务
-                            //6、行架
-                            //7、立库
-                            if (StrUtil.equals(task_type, "1")) {
-                                dto.setAgv_inst_type("1");
-                            } else if (StrUtil.equals(task_type, "3")) {
                                 dto.setAgv_inst_type("2");
-                            } else if (StrUtil.equals(task_type, "2")) {
-                                dto.setAgv_inst_type("3");
-                            } else if (StrUtil.equals(task_type, "8")) {
-                                dto.setAgv_inst_type("2");
-                            } else {
-                                log.info("未找到对应的AGV指令类型，任务号:" + task.getTask_code() + ",task_type:" + task.getTask_type());
-                            }
-                        } else {
-                            dto.setAgv_inst_type("4");
+
                         }
                         dto.setAgv_system_type(task.getAgv_system_type());
                     }
-                   // NDCAgvService ndcAgvService = SpringContextHolder.getBean(NDCAgvService.class);
-                    log.warn("下发AGV指令数据," + "指令号:" + dto.getInstruction_code() + ",AGV系统类型:" + dto.getAgv_system_type()
-                            + ",AGV指令类型:" + dto.getInstruction_type());
                     try {
                         if (StrUtil.isEmpty(dto.getAgv_inst_type()) || StrUtil.isEmpty(dto.getAgv_system_type())) {
                             log.info("sendAgvInstToNDC 指令校验:" + dto.getInstruction_code() + ",inst_type:" + dto.getInstruction_type()
                                     + ",inst_system_type:" + dto.getAgv_system_type());
                         }
-//                        log.info("2楼1区域AGV系统链接开始");
-//                        String ip = paramService.findByCode(AcsConfig.AGVURL).getValue();
-//                        int port = Integer.parseInt(paramService.findByCode(AcsConfig.AGVPORT).getValue());
-//                        InetSocketAddress socketAddress = new InetSocketAddress(ip, port);
-//                        Socket s = new Socket();
-//                        s.connect(socketAddress, 2 * 1000);
-//                        if (ObjectUtil.isNotEmpty(s)&&s.isConnected()==true) {
-                      //  ndcAgvService.sendAgvInstToNDC(task.getAgv_system_type(), dto);
-//                        } else {
-//                            log.error("agv连接出现异常:服务端被关闭");
-//                        }
+                        HttpResponse httpResponse = acsToKitService.genAgvSchedulingTask(dto, 3);
+                        log.warn("下发AGV指令数据," + "指令号:" + dto.getInstruction_code() + ",AGV系统类型:" + dto.getAgv_system_type()
+                                + ",AGV指令类型:" + dto.getInstruction_type());
+
                     } catch (Exception e) {
                         dto.setSend_status("2");
                         dto.setRemark(e.getMessage());

acs2/nladmin-system/nlsso-server/src/main/java/org/nl/acs/task/task/service/impl/TaskServiceImpl.java

@@ -27,6 +27,7 @@ import org.nl.acs.device.device.service.DeviceService;
 import org.nl.acs.device.device.service.impl.DeviceServiceImpl;
 import org.nl.acs.device.deviceDriver.service.defination.DeviceDriverDefination;
 import org.nl.extInterface.wms.service.AcsToWmsService;
+import org.nl.extInterface.wms.service.enums.WmsFeedbackStatusEnum;
 import org.nl.acs.task.instruction.domain.Instruction;
 import org.nl.acs.task.instruction.domain.InstructionMybatis;
 import org.nl.acs.task.instruction.enums.InstructionStatusEnum;
@@ -860,8 +861,7 @@ public class TaskServiceImpl extends CommonServiceImpl<TaskMapper, Task> impleme
         //向缓存添加任务信息
         this.addTaskToCache(dto);
         //反馈上位系统任务状态
-
-        this.feedWmsTaskStatus(entity);
+        this.feedWmsTaskStatus(dto);
 
     }
 
@@ -1763,29 +1763,19 @@ public class TaskServiceImpl extends CommonServiceImpl<TaskMapper, Task> impleme
      *
      * @param taskDto
      */
+    /**
+     * 这里只处理任务终态回传。
+     * 取货、放货等中间阶段由站点驱动结合 AGV 回调直接回传 WMS。
+     */
     private void feedWmsTaskStatus(TaskDto taskDto) {
-        // 判断是否为WMS下发的任务，如果是反馈任务状态给WMS
-        TaskDto entity = this.findById(taskDto.getTask_id());
-        String hasWms = paramService.findByCode(TaskConfig.HASWMS).getValue();
-        if (!StrUtil.startWith(taskDto.getTask_code(), CommonFinalParam.HYPHEN_) && StrUtil.equals(hasWms, CommonFinalParam.ONE)) {
-//            FeedBackTaskStatusRequest request = new FeedBackTaskStatusRequest();
-//            request.setTask_id(taskDto.getExt_task_id());
-//            request.setTask_code(taskDto.getTask_code());
-//            request.setTask_status(taskDto.getTask_status());
-//            request.setRequest_medthod_code(RequestMethodEnum.feedback_task_status.getCode());
-//            request.setRequest_medthod_name(RequestMethodEnum.feedback_task_status.getName());
-            JSONObject feed_jo = new JSONObject();
-            feed_jo.put("task_id", entity.getExt_task_id());
-            feed_jo.put("task_code", entity.getTask_code());
-            feed_jo.put("task_status", entity.getTask_status());
-            if (ObjectUtil.isNotEmpty(entity.getWeight())) {
-                feed_jo.put("weight", entity.getWeight());
-            }
-            if (ObjectUtil.isNotEmpty(entity.getCarno())) {
-                feed_jo.put("car_no", entity.getCarno());
-            }
-            JSONArray ja = new JSONArray();
-            ja.add(feed_jo);
+        if (!acstowmsService.isWmsTask(taskDto)) {
+            return;
+        }
+        if (StrUtil.equals(taskDto.getTask_status(), TaskStatusEnum.CANCEL.getIndex())) {
+            acstowmsService.deprecateTask(taskDto, taskDto.getRemark());
+        } else if (StrUtil.equals(taskDto.getTask_status(), TaskStatusEnum.ERROR.getIndex())
+                || StrUtil.equals(taskDto.getTask_status(), TaskStatusEnum.FORCED_COMPLETION.getIndex())) {
+            acstowmsService.feedbackTask(taskDto, taskDto.getCarno(), WmsFeedbackStatusEnum.ERROR_FINISH.getValue());
         }
     }
 }

acs2/nladmin-system/nlsso-server/src/main/java/org/nl/extInterface/agvKit/service/handler/KitMessageHandler.java

@@ -0,0 +1,26 @@
+package org.nl.extInterface.agvKit.service.handler;
+
+import com.alibaba.fastjson.JSONObject;
+
+/**
+ * KIT消息处理器接口，定义消息类型支持与处理策略。
+ *
+ * @author guannan
+ * @date 2026-05-06
+ */
+public interface KitMessageHandler {
+    /**
+     * 返回当前策略所处理的KIT消息类型。
+     *
+     * @return MsgTypeEnum定义的类型值
+     */
+    Integer supportType();
+
+    /**
+     * 处理KIT消息负载并生成协议响应。
+     *
+     * @param params KIT回调请求中的params节点
+     * @return KIT协议响应体
+     */
+    JSONObject handle(JSONObject params) throws Exception;
+}

acs2/nladmin-system/nlsso-server/src/main/java/org/nl/extInterface/agvKit/service/handler/KitResponse.java

@@ -0,0 +1,43 @@
+package org.nl.extInterface.agvKit.service.handler;
+
+import com.alibaba.fastjson.JSONObject;
+
+/**
+ * KIT响应构建工具类，提供成功和失败响应的静态构建方法。
+ *
+ * @author guannan
+ * @date 2026-05-06
+ */
+public final class KitResponse {
+    /**
+     * 防止实例化响应工具类。
+     */
+    private KitResponse() {
+    }
+
+    /**
+     * 构建成功的KIT响应。
+     *
+     * @param message 响应消息
+     * @return 状态码200的响应体
+     */
+    public static JSONObject success(String message) {
+        JSONObject response = new JSONObject();
+        response.put("code", "200");
+        response.put("message", message);
+        return response;
+    }
+
+    /**
+     * 构建失败的KIT响应。
+     *
+     * @param message 失败原因
+     * @return 状态码400的响应体
+     */
+    public static JSONObject fail(String message) {
+        JSONObject response = new JSONObject();
+        response.put("code", "400");
+        response.put("message", message);
+        return response;
+    }
+}

acs2/nladmin-system/nlsso-server/src/main/java/org/nl/extInterface/agvKit/service/handler/impl/AgvErrorReportHandler.java

@@ -0,0 +1,37 @@
+package org.nl.extInterface.agvKit.service.handler.impl;
+
+import com.alibaba.fastjson.JSONObject;
+import org.nl.extInterface.agvKit.service.enums.MsgTypeEnum;
+import org.nl.extInterface.agvKit.service.handler.KitMessageHandler;
+import org.nl.extInterface.agvKit.service.handler.KitResponse;
+import org.springframework.stereotype.Component;
+
+/**
+ * AGV故障上报处理器，确认收到KIT上报的AGV故障信息。
+ *
+ * @author guannan
+ * @date 2026-05-06
+ */
+@Component
+public class AgvErrorReportHandler implements KitMessageHandler {
+    /**
+     * 返回AGV故障上报消息类型。
+     *
+     * @return AGV_ERROR_RPT类型值
+     */
+    @Override
+    public Integer supportType() {
+        return MsgTypeEnum.AGV_ERROR_RPT.getValue();
+    }
+
+    /**
+     * 确认AGV故障上报。当前集成不持久化故障详情。
+     *
+     * @param params KIT回调请求中的params节点
+     * @return KIT协议响应体
+     */
+    @Override
+    public JSONObject handle(JSONObject params) {
+        return KitResponse.success("更新指令执行中成功");
+    }
+}

acs2/nladmin-system/nlsso-server/src/main/java/org/nl/extInterface/agvKit/service/handler/impl/AgvIdReportHandler.java

@@ -0,0 +1,57 @@
+package org.nl.extInterface.agvKit.service.handler.impl;
+
+import cn.hutool.core.date.DateUtil;
+import cn.hutool.core.util.ObjectUtil;
+import com.alibaba.fastjson.JSONObject;
+import org.nl.acs.task.instruction.domain.Instruction;
+import org.nl.acs.task.instruction.enums.InstructionStatusEnum;
+import org.nl.acs.task.instruction.service.InstructionService;
+import org.nl.extInterface.agvKit.service.enums.MsgTypeEnum;
+import org.nl.extInterface.agvKit.service.handler.KitMessageHandler;
+import org.nl.extInterface.agvKit.service.handler.KitResponse;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+/**
+ * AGV车号上报处理器，持久化KIT上报的AGV车号并将指令标记为忙碌。
+ *
+ * @author guannan
+ * @date 2026-05-06
+ */
+@Component
+public class AgvIdReportHandler implements KitMessageHandler {
+    @Autowired
+    private InstructionService instructionService;
+
+    /**
+     * 返回AGV分配上报消息类型。
+     *
+     * @return AGV_ID_RPT类型值
+     */
+    @Override
+    public Integer supportType() {
+        return MsgTypeEnum.AGV_ID_RPT.getValue();
+    }
+
+    /**
+     * 持久化KIT上报的AGV车号，并将指令标记为忙碌。
+     *
+     * @param params KIT回调请求中的params节点
+     * @return KIT协议响应体
+     */
+    @Override
+    public JSONObject handle(JSONObject params) {
+        String taskId = params.getString("taskId");
+        String agvId = params.getString("agvId");
+        Instruction instruction = instructionService.findByCodeFromCache(taskId);
+        if (ObjectUtil.isEmpty(instruction)) {
+            return KitResponse.fail("请求失败，任务信息不存在,指令号:" + taskId);
+        }
+
+        instruction.setCarno(agvId);
+        instruction.setInstruction_status(InstructionStatusEnum.BUSY.getCode());
+        instruction.setUpdate_time(DateUtil.now());
+        instructionService.update(instruction);
+        return KitResponse.success("更新车号成功");
+    }
+}

acs2/nladmin-system/nlsso-server/src/main/java/org/nl/extInterface/agvKit/service/handler/impl/AgvPowerReportHandler.java

@@ -0,0 +1,37 @@
+package org.nl.extInterface.agvKit.service.handler.impl;
+
+import com.alibaba.fastjson.JSONObject;
+import org.nl.extInterface.agvKit.service.enums.MsgTypeEnum;
+import org.nl.extInterface.agvKit.service.handler.KitMessageHandler;
+import org.nl.extInterface.agvKit.service.handler.KitResponse;
+import org.springframework.stereotype.Component;
+
+/**
+ * AGV电量上报处理器，确认收到KIT上报的AGV电量信息。
+ *
+ * @author guannan
+ * @date 2026-05-06
+ */
+@Component
+public class AgvPowerReportHandler implements KitMessageHandler {
+    /**
+     * 返回AGV电量上报消息类型。
+     *
+     * @return AGV_POWER_RPT类型值
+     */
+    @Override
+    public Integer supportType() {
+        return MsgTypeEnum.AGV_POWER_RPT.getValue();
+    }
+
+    /**
+     * 确认AGV电量上报。当前集成不持久化电量详情。
+     *
+     * @param params KIT回调请求中的params节点
+     * @return KIT协议响应体
+     */
+    @Override
+    public JSONObject handle(JSONObject params) {
+        return KitResponse.success("更新指令执行中成功");
+    }
+}

acs2/nladmin-system/nlsso-server/src/main/java/org/nl/extInterface/agvKit/service/handler/impl/AgvStateReportHandler.java

@@ -0,0 +1,54 @@
+package org.nl.extInterface.agvKit.service.handler.impl;
+
+import cn.hutool.core.util.StrUtil;
+import com.alibaba.fastjson.JSONObject;
+import org.nl.extInterface.agvKit.service.enums.MsgTypeEnum;
+import org.nl.extInterface.agvKit.service.handler.KitMessageHandler;
+import org.nl.extInterface.agvKit.service.handler.KitResponse;
+import org.nl.extInterface.wms.service.AcsToWmsService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+/**
+ * AGV状态上报处理器，将KIT上报的AGV状态转发至WMS作为设备状态更新。
+ *
+ * @author guannan
+ * @date 2026-05-06
+ */
+@Component
+public class AgvStateReportHandler implements KitMessageHandler {
+    @Autowired
+    private AcsToWmsService acsToWmsService;
+
+    /**
+     * 返回AGV状态上报消息类型。
+     *
+     * @return AGV_STATE_RPT类型值
+     */
+    @Override
+    public Integer supportType() {
+        return MsgTypeEnum.AGV_STATE_RPT.getValue();
+    }
+
+    /**
+     * 将KIT上报的AGV状态转发至WMS作为设备状态更新。
+     *
+     * @param params KIT回调请求中的params节点
+     * @return KIT协议响应体
+     */
+    @Override
+    public JSONObject handle(JSONObject params) {
+        String deviceCode = StrUtil.blankToDefault(params.getString("deviceCode"), params.getString("agvId"));
+        Integer status = params.getInteger("status");
+        String statusDescription = params.getString("statusDescription");
+        if (StrUtil.isEmpty(deviceCode) || status == null) {
+            return KitResponse.fail("AGV状态上报参数异常");
+        }
+
+        boolean success = acsToWmsService.deviceStatusUpdate(deviceCode, status, statusDescription);
+        if (!success) {
+            return KitResponse.fail("回馈WMS设备状态失败");
+        }
+        return KitResponse.success("更新指令执行中成功");
+    }
+}

acs2/nladmin-system/nlsso-server/src/main/java/org/nl/extInterface/agvKit/service/handler/impl/TaskIndexReportHandler.java

@@ -0,0 +1,55 @@
+package org.nl.extInterface.agvKit.service.handler.impl;
+
+import cn.hutool.core.date.DateUtil;
+import cn.hutool.core.util.ObjectUtil;
+import com.alibaba.fastjson.JSONObject;
+import org.nl.acs.task.instruction.domain.Instruction;
+import org.nl.acs.task.instruction.enums.InstructionStatusEnum;
+import org.nl.acs.task.instruction.service.InstructionService;
+import org.nl.extInterface.agvKit.service.enums.MsgTypeEnum;
+import org.nl.extInterface.agvKit.service.handler.KitMessageHandler;
+import org.nl.extInterface.agvKit.service.handler.KitResponse;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+/**
+ * 车辆任务生成上报处理器，KIT上报车辆任务生成后将ACS指令标记为忙碌。
+ *
+ * @author guannan
+ * @date 2026-05-06
+ */
+@Component
+public class TaskIndexReportHandler implements KitMessageHandler {
+    @Autowired
+    private InstructionService instructionService;
+
+    /**
+     * 返回车辆任务生成上报消息类型。
+     *
+     * @return TASK_INDEX_RPT类型值
+     */
+    @Override
+    public Integer supportType() {
+        return MsgTypeEnum.TASK_INDEX_RPT.getValue();
+    }
+
+    /**
+     * KIT上报车辆任务生成后，将ACS指令标记为忙碌。
+     *
+     * @param params KIT回调请求中的params节点
+     * @return KIT协议响应体
+     */
+    @Override
+    public JSONObject handle(JSONObject params) {
+        String taskId = params.getString("taskId");
+        Instruction instruction = instructionService.findByCodeFromCache(taskId);
+        if (ObjectUtil.isEmpty(instruction)) {
+            return KitResponse.fail("请求失败，任务信息不存在,指令号:" + taskId);
+        }
+
+        instruction.setInstruction_status(InstructionStatusEnum.BUSY.getCode());
+        instruction.setUpdate_time(DateUtil.now());
+        instructionService.update(instruction);
+        return KitResponse.success("更新指令执行中成功");
+    }
+}

acs2/nladmin-system/nlsso-server/src/main/java/org/nl/extInterface/agvKit/service/handler/impl/TaskRunReportHandler.java

@@ -0,0 +1,37 @@
+package org.nl.extInterface.agvKit.service.handler.impl;
+
+import com.alibaba.fastjson.JSONObject;
+import org.nl.extInterface.agvKit.service.enums.MsgTypeEnum;
+import org.nl.extInterface.agvKit.service.handler.KitMessageHandler;
+import org.nl.extInterface.agvKit.service.handler.KitResponse;
+import org.springframework.stereotype.Component;
+
+/**
+ * 任务运行上报处理器，确认收到KIT上报的任务运行状态。
+ *
+ * @author guannan
+ * @date 2026-05-06
+ */
+@Component
+public class TaskRunReportHandler implements KitMessageHandler {
+    /**
+     * 返回任务运行上报消息类型。
+     *
+     * @return TASK_RUN_RPT类型值
+     */
+    @Override
+    public Integer supportType() {
+        return MsgTypeEnum.TASK_RUN_RPT.getValue();
+    }
+
+    /**
+     * 确认任务运行上报。当前集成无额外状态更新。
+     *
+     * @param params KIT回调请求中的params节点
+     * @return KIT协议响应体
+     */
+    @Override
+    public JSONObject handle(JSONObject params) {
+        return KitResponse.success("更新车号成功");
+    }
+}

acs2/nladmin-system/nlsso-server/src/main/java/org/nl/extInterface/agvKit/service/handler/impl/TaskStateReportHandler.java

@@ -0,0 +1,180 @@
+package org.nl.extInterface.agvKit.service.handler.impl;
+
+import cn.hutool.core.util.ObjectUtil;
+import cn.hutool.core.util.StrUtil;
+import com.alibaba.fastjson.JSONObject;
+import org.nl.acs.device.device.service.DeviceAppService;
+import org.nl.acs.device.device.service.entity.Device;
+import org.nl.acs.device.deviceDriver.service.driver.DeviceDriver;
+import org.nl.acs.device.storageMgt.service.StorageCellService;
+import org.nl.acs.device.storageMgt.service.entity.StorageCell;
+import org.nl.acs.task.instruction.domain.Instruction;
+import org.nl.acs.task.instruction.service.InstructionService;
+import org.nl.config.MapOf;
+import org.nl.extInterface.agvKit.service.enums.MsgTypeEnum;
+import org.nl.extInterface.agvKit.service.enums.TaskPhaseEnum;
+import org.nl.extInterface.agvKit.service.enums.TaskStateEnum;
+import org.nl.extInterface.agvKit.service.handler.KitMessageHandler;
+import org.nl.extInterface.agvKit.service.handler.KitResponse;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+/**
+ * 任务状态上报处理器，根据KIT任务状态上报推进ACS指令阶段，并通知相关设备驱动。
+ *
+ * @author guannan
+ * @date 2026-05-06
+ */
+@Component
+public class TaskStateReportHandler implements KitMessageHandler {
+    @Autowired
+    private InstructionService instructionService;
+    @Autowired
+    private StorageCellService storageCellService;
+    @Autowired
+    private DeviceAppService deviceAppService;
+
+    /**
+     * 返回任务状态上报消息类型。
+     *
+     * @return TASK_STATE_RPT类型值
+     */
+    @Override
+    public Integer supportType() {
+        return MsgTypeEnum.TASK_STATE_RPT.getValue();
+    }
+
+    /**
+     * 根据KIT任务状态上报推进ACS指令阶段，并通知相关设备驱动。
+     *
+     * @param params KIT回调请求中的params节点
+     * @return KIT协议响应体
+     */
+    @Override
+    public JSONObject handle(JSONObject params) throws Exception {
+        String instTaskId = params.getString("taskId");
+        String taskPhase = params.getString("taskPhase");
+        String taskState = params.getString("taskState");
+        String taskPoint = params.getString("taskPoint");
+        if (StrUtil.isEmpty(taskPhase)) {
+            return KitResponse.fail("taskPhase参数异常");
+        }
+
+        Instruction instruction = findInstruction(instTaskId);
+        if (ObjectUtil.isEmpty(instruction)) {
+            return KitResponse.fail("请求失败，任务信息不存在,指令号:" + instTaskId);
+        }
+
+        if (TaskStateEnum.CANCELED.getValue().equals(taskState)) {
+            instructionService.cancel(instruction.getInstruction_id());
+            return KitResponse.success("取消任务成功");
+        }
+
+        TaskPhaseEnum taskPhaseEnum = TaskPhaseEnum.fromPhase(taskPhase);
+        switch (taskPhaseEnum) {
+            case ENTER_REQUEST_OR_ALLOWED:
+            case LEAVE_NOTICE_OR_ALLOWED:
+                return handleSitePhase(instTaskId, taskPhase, taskPoint, taskPhaseEnum);
+            case PICKUP_REQUEST_OR_RESPONSE:
+            case PICKUP_COMPLETE:
+            case RELEASE_REQUEST_OR_RESPONSE:
+            case RELEASE_COMPLETE:
+                return handleCargoPhase(instruction, instTaskId, taskPhase, taskState, taskPhaseEnum);
+            default:
+                return KitResponse.fail("taskPhase值不存在");
+        }
+    }
+
+    /**
+     * 先从缓存查找指令，缓存未命中则查数据库，数据库命中后重载缓存。
+     *
+     * @param instTaskId ACS指令编码
+     * @return 查找到的指令，未找到则返回null
+     */
+    private Instruction findInstruction(String instTaskId) {
+        Instruction instruction = instructionService.findByCodeFromCache(instTaskId);
+        if (ObjectUtil.isNotEmpty(instruction)) {
+            return instruction;
+        }
+
+        instruction = instructionService.findByCode(instTaskId);
+        if (ObjectUtil.isNotEmpty(instruction)) {
+            //TODO 并发情况下状态会有问题
+            instructionService.reload();
+        }
+        return instruction;
+    }
+
+    /**
+     * 处理进入/离开站点阶段，将AGV阶段数据推入站点设备驱动。
+     *
+     * @param instTaskId ACS指令编码
+     * @param taskPhase KIT上报的任务阶段
+     * @param taskPoint KIT上报的站点地址
+     * @param taskPhaseEnum 解析后的任务阶段枚举
+     * @return KIT协议响应体
+     */
+    private JSONObject handleSitePhase(String instTaskId, String taskPhase, String taskPoint,
+                                       TaskPhaseEnum taskPhaseEnum) {
+        StorageCell storageCellDto = storageCellService.findByAddress(taskPoint);
+        if (ObjectUtil.isEmpty(storageCellDto)) {
+            return KitResponse.fail("请求失败，点位信息不存在,点位站点号:" + taskPoint);
+        }
+
+        Device device = deviceAppService.findDeviceByCode(storageCellDto.getStorage_code());
+        if (ObjectUtil.isEmpty(device)) {
+            return KitResponse.fail("请求失败，请求位置编码不存在");
+        }
+
+        DeviceDriver deviceDriver = device.getDeviceDriver();
+        deviceDriver.setDeviceInnerParam(MapOf.of("taskId", instTaskId, "agvphase", taskPhase));
+        return KitResponse.success(taskPhaseEnum.getDescription() + "处理完毕");
+    }
+
+    /**
+     * 处理取货/放货阶段，更新站点驱动并持久化指令执行阶段。
+     *
+     * @param instruction 当前ACS指令
+     * @param instTaskId ACS指令编码
+     * @param taskPhase KIT上报的任务阶段
+     * @param taskState KIT上报的任务状态
+     * @param taskPhaseEnum 解析后的任务阶段枚举
+     * @return KIT协议响应体
+     */
+    private JSONObject handleCargoPhase(Instruction instruction, String instTaskId, String taskPhase,
+                                        String taskState, TaskPhaseEnum taskPhaseEnum) {
+        Device device = findCargoPhaseDevice(instruction, taskPhase);
+        if (device == null) {
+            return KitResponse.fail("点位驱动不存在");
+        }
+
+        device.getDeviceDriver().setDeviceInnerParam(MapOf.of("taskId", instTaskId, "agvphase", taskPhase));
+        if (!taskPhase.equals(instruction.getExecute_status())) {
+            instruction.setExecute_status(taskPhase);
+            instructionService.update(instruction);
+        }
+        if (TaskStateEnum.COMPLETED.getValue().equals(taskState)) {
+            return KitResponse.success("完成任务成功");
+        }
+        return KitResponse.success(taskPhaseEnum.getDescription() + "处理完毕");
+    }
+
+    /**
+     * 根据取货或放货阶段解析对应的设备。
+     *
+     * @param instruction 当前ACS指令
+     * @param taskPhase KIT上报的任务阶段
+     * @return 匹配的起点或终点设备，阶段不支持时返回null
+     */
+    private Device findCargoPhaseDevice(Instruction instruction, String taskPhase) {
+        if (TaskPhaseEnum.PICKUP_REQUEST_OR_RESPONSE.getValue().equals(taskPhase)
+                || TaskPhaseEnum.PICKUP_COMPLETE.getValue().equals(taskPhase)) {
+            return deviceAppService.findDeviceByCode(instruction.getStart_point_code());
+        }
+        if (TaskPhaseEnum.RELEASE_REQUEST_OR_RESPONSE.getValue().equals(taskPhase)
+                || TaskPhaseEnum.RELEASE_COMPLETE.getValue().equals(taskPhase)) {
+            return deviceAppService.findDeviceByCode(instruction.getNext_point_code());
+        }
+        return null;
+    }
+}

acs2/nladmin-system/nlsso-server/src/main/java/org/nl/extInterface/agvKit/service/impl/AcsToKitServiceImpl.java

@@ -82,7 +82,7 @@ public class AcsToKitServiceImpl implements AcsToKitService {
             ja.put("location_name", instruction.getOffSetName());
             jo.put("params", ja);
         }
-        String wmsurl = paramService.findByCode(TaskConfig.WCSURL).getValue();
+        String wmsurl = paramService.findByCode(TaskConfig.KITAGVURL).getValue();
         String url = wmsurl;
         log.info("任务号：{},指令号{},下发agv订单序列下发:{}", instruction.getTask_code(), instruction.getInstruction_code(), JSON.toJSONString(jo));
         LuceneLogDto logDto =

acs2/nladmin-system/nlsso-server/src/main/java/org/nl/extInterface/agvKit/service/impl/KitToAcsServiceImpl.java

@@ -1,215 +1,60 @@
 package org.nl.extInterface.agvKit.service.impl;
 
-import cn.hutool.core.date.DateUtil;
-import cn.hutool.core.util.ObjectUtil;
-import cn.hutool.core.util.StrUtil;
 import com.alibaba.fastjson.JSONObject;
-import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
-import org.nl.acs.device.device.service.entity.Device;
-import org.nl.acs.device.deviceDriver.service.driver.DeviceDriver;
-import org.nl.acs.device.storageMgt.service.entity.StorageCell;
-import org.nl.acs.task.instruction.domain.Instruction;
-import org.nl.acs.task.instruction.enums.InstructionStatusEnum;
-import org.nl.acs.task.instruction.service.InstructionService;
-import org.nl.acs.device.device.service.DeviceAppService;
-import org.nl.acs.device.storageMgt.service.StorageCellService;
-import org.nl.config.MapOf;
 import org.nl.extInterface.agvKit.service.KitToAcsService;
-import org.nl.extInterface.agvKit.service.enums.MsgTypeEnum;
-import org.nl.extInterface.agvKit.service.enums.TaskPhaseEnum;
-import org.nl.extInterface.agvKit.service.enums.TaskStateEnum;
+import org.nl.extInterface.agvKit.service.handler.KitMessageHandler;
+import org.nl.extInterface.agvKit.service.handler.KitResponse;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * KIT回调服务实现，构建类型-处理器注册表并路由回调请求。
+ *
+ * @author guannan
+ * @date 2026-05-06
+ */
 @Service
-@RequiredArgsConstructor
 @Slf4j
 public class KitToAcsServiceImpl implements KitToAcsService {
-    @Autowired
-    private InstructionService instructionService;
-    @Autowired
-    private StorageCellService storageCellService;
-    @Autowired
-    private DeviceAppService deviceAppService;
+    private final Map<Integer, KitMessageHandler> handlerMap;
 
+    /**
+     * 根据Spring管理的KIT处理器构建类型-处理器注册表。
+     *
+     * @param handlers Spring发现的所有KIT消息处理器
+     */
+    @Autowired
+    public KitToAcsServiceImpl(List<KitMessageHandler> handlers) {
+        this.handlerMap = new HashMap<>();
+        for (KitMessageHandler handler : handlers) {
+            this.handlerMap.put(handler.supportType(), handler);
+        }
+    }
+
+    /**
+     * 将KIT回调请求路由至支持其消息类型的处理器。
+     *
+     * @param requestParam KIT回调原始JSON，包含type和params
+     * @return KIT协议响应体
+     */
     @Override
-    public JSONObject agvCallback(JSONObject requestParam) throws Exception{
-        JSONObject resp = new JSONObject();
+    public JSONObject agvCallback(JSONObject requestParam) throws Exception {
         Integer type = requestParam.getInteger("type");
         JSONObject params = requestParam.getJSONObject("params");
-        //任务状态上报
-        if (MsgTypeEnum.TASK_STATE_RPT.getValue().equals(type)) {
-            String instTaskId = params.getString("taskId");
-            String taskPhase = params.getString("taskPhase");
-            String taskState = params.getString("taskState");
-            String taskPoint = params.getString("taskPoint");//请求进入/离开需要上报站点号
-            if (StrUtil.isEmpty(taskPhase)){
-                resp.put("code", "400");
-                resp.put("message", "taskPhase参数异常");
-                log.info("---响应kit请求---"+resp.toString());
-                return resp;
-            }
-            Instruction instruction = instructionService.findByCodeFromCache(instTaskId);
-            if (ObjectUtil.isEmpty(instruction)) {
-                instruction = instructionService.findByCode(instTaskId);
-                if (ObjectUtil.isEmpty(instruction)){
-                    resp.put("code", "400");
-                    resp.put("message", "请求失败，任务信息不存在,指令号:" + instTaskId);
-                    log.info("---响应kit请求---"+resp.toString());
-                    return resp;
-                }
-                instructionService.reload();
-            }
+        KitMessageHandler handler = handlerMap.get(type);
+        if (handler == null) {
+            JSONObject response = KitResponse.fail(type + "type类型未定义");
+            log.info("---kit响应请求---{}", response);
+            return response;
+        }
 
-            //taskPhase 任务取消
-            if (TaskStateEnum.CANCELED.getValue().equals(taskState)){
-                instructionService.cancel(instruction.getInstruction_id());
-                resp.put("code", "200");
-                resp.put("message", "取消任务成功");
-                log.info("---响应kit请求---"+resp.toString());
-                return resp;
-            }
-            Device device = null;
-            TaskPhaseEnum taskPhaseEnum = TaskPhaseEnum.fromPhase(taskPhase);
-            switch (taskPhaseEnum){
-                case ENTER_REQUEST_OR_ALLOWED:
-                case LEAVE_NOTICE_OR_ALLOWED:
-                    StorageCell storageCellDto = storageCellService.findByAddress(taskPoint);
-                    if (ObjectUtil.isEmpty(storageCellDto)) {
-                        resp.put("code", "400");
-                        resp.put("message", "请求失败，点位信息不存在,点位站点号:" + taskPoint);
-                        log.info("---响应kit请求---"+resp.toString());
-                        return resp;
-                    }
-                    device = deviceAppService.findDeviceByCode(storageCellDto.getStorage_code());
-                    if (ObjectUtil.isEmpty(device)) {
-                        resp.put("code", "400");
-                        resp.put("message", "请求失败，请求位置编号不存在！");
-                        log.info("---响应kit请求---"+resp.toString());
-                        return resp;
-                    }
-                    DeviceDriver deviceDriver = device.getDeviceDriver();
-                    deviceDriver.setDeviceInnerParam(MapOf.of("taskId",instTaskId,"agvphase",taskPhase));
-                    break;
-                case PICKUP_REQUEST_OR_RESPONSE:
-                case PICKUP_COMPLETE:
-                case RELEASE_REQUEST_OR_RESPONSE:
-                case RELEASE_COMPLETE:
-                    if (TaskPhaseEnum.PICKUP_REQUEST_OR_RESPONSE.getValue().equals(taskPhase) || TaskPhaseEnum.PICKUP_COMPLETE.getValue().equals(taskPhase)){
-                        device = deviceAppService.findDeviceByCode(instruction.getStart_point_code());
-                    }
-                    //taskPhase 请求放货上报,放货完成上报
-                    if (TaskPhaseEnum.RELEASE_REQUEST_OR_RESPONSE.getValue().equals(taskPhase)||TaskPhaseEnum.RELEASE_COMPLETE.getValue().equals(taskPhase)){
-                        device = deviceAppService.findDeviceByCode(instruction.getNext_point_code());
-                    }
-                    if (device == null){
-                        resp.put("code", "400");
-                        resp.put("message", "点位驱动不存在");
-                        log.info("---响应kit请求---"+resp.toString());
-                        return resp;
-                    }
-                    device.getDeviceDriver().setDeviceInnerParam(MapOf.of("taskId",instTaskId,"agvphase",taskPhase));
-                    if (!taskPhase.equals(instruction.getExecute_status())){
-                        instruction.setExecute_status(taskPhase);
-                        instructionService.update(instruction);
-                    }
-                    //taskPhase 任务完成
-                    if (TaskStateEnum.COMPLETED.getValue().equals(taskState)){
-                        resp.put("code", "200");
-                        resp.put("message", "完成任务成功");
-                        log.info("---响应kit请求---"+resp.toString());
-                    }
-                    break;
-                default:
-                    resp.put("code", "400");
-                    resp.put("message", "taskPhase值不存在");
-                    log.info("---响应kit请求---"+resp.toString());
-                    return resp;
-            }
-            resp.put("code", "200");
-            resp.put("message", taskPhaseEnum.getDescription()+"处理完毕");
-            log.info("---响应kit请求---"+resp.toString());
-            return resp;
-        }
-        //任务分配车辆上报
-        else if (MsgTypeEnum.AGV_ID_RPT.getValue().equals(type)){
-            String taskId = params.getString("taskId");
-            String agvId = params.getString("agvId");
-            Instruction instruction = instructionService.findByCodeFromCache(taskId);
-            if (ObjectUtil.isEmpty(instruction)) {
-                resp.put("code", "400");
-                resp.put("message", "请求失败，任务信息不存在,指令号:" + taskId);
-                log.info("---响应kit请求---"+resp.toString());
-                return resp;
-            }
-            //更新车号
-            instruction.setCarno(agvId);
-            instruction.setInstruction_status(InstructionStatusEnum.BUSY.getCode());
-            instruction.setUpdate_time(DateUtil.now());
-            instructionService.update(instruction);
-            resp.put("code", "200");
-            resp.put("message", "更新车号成功");
-            log.info("---响应kit请求---"+resp.toString());
-            return resp;
-        }
-        else if (MsgTypeEnum.TASK_RUN_RPT.getValue().equals(type)){
-            System.out.println("------");
-            resp.put("code", "200");
-            resp.put("message", "更新车号成功");
-            log.info("---响应kit请求---"+resp.toString());
-            return resp;
-        }
-        //车辆任务生成上报
-        else if (MsgTypeEnum.TASK_INDEX_RPT.getValue().equals(type)){
-            String taskId = params.getString("taskId");
-            Instruction instruction = instructionService.findByCodeFromCache(taskId);
-            if (ObjectUtil.isEmpty(instruction)) {
-                resp.put("code", "400");
-                resp.put("message", "请求失败，任务信息不存在,指令号:" + taskId);
-                log.info("---响应kit请求---"+resp.toString());
-                return resp;
-            }
-            //修改指令状态执行中
-            instruction.setInstruction_status(InstructionStatusEnum.BUSY.getCode());
-            instruction.setUpdate_time(DateUtil.now());
-            instructionService.update(instruction);
-            resp.put("code", "200");
-            resp.put("message", "更新指令执行中成功");
-            log.info("---响应kit请求---"+resp.toString());
-            return resp;
-        }
-        else if (MsgTypeEnum.AGV_POWER_RPT.getValue().equals(type)){
-            int agvId = params.getIntValue("agvId");
-            int stateValue = params.getIntValue("stateValue");
-            resp.put("code", "200");
-            resp.put("message", "更新指令执行中成功");
-            log.info("---响应kit请求---"+resp.toString());
-            return resp;
-        }
-        else if (MsgTypeEnum.AGV_STATE_RPT.getValue().equals(type)){
-            int agvId = params.getIntValue("agvId");
-            int stateValue = params.getIntValue("stateValue");
-            int xLocation = params.getIntValue("xLocation");
-            int yLocation = params.getIntValue("yLocation");
-            int angle = params.getIntValue("angle");
-            int speed = params.getIntValue("speed");
-            resp.put("code", "200");
-            resp.put("message", "更新指令执行中成功");
-            log.info("---响应kit请求---"+resp.toString());
-            return resp;
-        }
-        else if (MsgTypeEnum.AGV_ERROR_RPT.getValue().equals(type)){
-            int agvId = params.getIntValue("agvId");
-            int errorCode = params.getIntValue("errState");
-            resp.put("code", "200");
-            resp.put("message", "更新指令执行中成功");
-            log.info("---响应kit请求---"+resp.toString());
-            return resp;
-        }
-        resp.put("code", "400");
-        resp.put("message", type+"type类型未定义");
-        log.info("---响应kit请求---"+resp.toString());
-        return resp;
+        JSONObject response = handler.handle(params);
+        log.info("---kit响应请求---{}", response);
+        return response;
     }
 }

acs2/nladmin-system/nlsso-server/src/main/java/org/nl/extInterface/wms/controller/WmsToAcsController.java

@@ -1,8 +1,15 @@
-
 package org.nl.extInterface.wms.controller;
 
+import cn.dev33.satoken.annotation.SaIgnore;
+import io.swagger.annotations.Api;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
+import org.nl.extInterface.wms.service.WmsToAcsService;
+import org.nl.extInterface.wms.service.dto.CreateTaskRequest;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
 import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RestController;
 
@@ -12,7 +19,18 @@ import org.springframework.web.bind.annotation.RestController;
  **/
 @RestController
 @RequiredArgsConstructor
+@Api(tags = "wms->ACS")
 @RequestMapping("/api/wms")
 @Slf4j
 public class WmsToAcsController {
+    private final WmsToAcsService wmsToAcsService;
+
+    @SaIgnore
+    @PostMapping("/createTask")
+    public ResponseEntity<Object> createTask(@RequestBody CreateTaskRequest request) {
+        // 控制层只做协议接入，字段映射和业务处理统一下沉到 service。
+        return new ResponseEntity<>(wmsToAcsService.createTask(request), HttpStatus.OK);
+    }
+
+
 }

acs2/nladmin-system/nlsso-server/src/main/java/org/nl/extInterface/wms/service/AcsToWmsService.java

@@ -1,5 +1,27 @@
 package org.nl.extInterface.wms.service;
 
-public interface AcsToWmsService {
+import com.alibaba.fastjson.JSONObject;
+import org.nl.acs.task.instruction.domain.Instruction;
+import org.nl.acs.task.task.service.dto.TaskDto;
 
+public interface AcsToWmsService {
+    /**
+     * 复用 WMS 的 feedbackTask 接口，同时承担阶段反馈和取放货许可判断。
+     */
+    boolean feedbackTask(TaskDto taskDto, String card, String feedbackStatus);
+
+    boolean feedbackTask(Instruction instruction, String feedbackStatus);
+
+    boolean deprecateTask(TaskDto taskDto, String reason);
+
+    JSONObject taskRedirection(String taskCode, String currLocation);
+
+    boolean deviceStatusUpdate(String deviceCode, Integer status, String statusDescription);
+
+    /**
+     * 判断任务是否需要进入 WMS 回传链路，避免本地任务误回传。
+     */
+    boolean isWmsTask(TaskDto taskDto);
+
+    boolean isWmsInstruction(Instruction instruction);
 }

acs2/nladmin-system/nlsso-server/src/main/java/org/nl/extInterface/wms/service/WmsToAcsService.java

@@ -1,7 +1,13 @@
 package org.nl.extInterface.wms.service;
 
+import com.alibaba.fastjson.JSONObject;
+import org.nl.extInterface.wms.service.dto.CreateTaskRequest;
 
 public interface WmsToAcsService {
+    /**
+     * 接收 WMS 的 createTask 报文，并映射到现有 ACS 任务流程。
+     */
 
+    JSONObject createTask(CreateTaskRequest request);
 
 }

acs2/nladmin-system/nlsso-server/src/main/java/org/nl/extInterface/wms/service/enums/WmsFeedbackStatusEnum.java

@@ -0,0 +1,39 @@
+package org.nl.extInterface.wms.service.enums;
+
+
+/**
+ * WMS feedbackTask 接口使用的任务阶段状态枚举。
+ */
+public enum WmsFeedbackStatusEnum {
+    /** 取货执行中。 */
+    TAKING("taking"),
+    /** 请求 WMS 允许取货。 */
+    APPLY_TAKE("applyTake"),
+    /** 取货完成。 */
+    TAKE_FINISH("takeFinish"),
+    /** 放货执行中。 */
+    PUTTING("putting"),
+    /** 请求 WMS 允许放货。 */
+    APPLY_PUT("applyPut"),
+    /** 放货完成。 */
+    PUT_FINISH("putFinish"),
+    /** 无目标点放货完成。 */
+    NO_TARGET_PUT_FINISH("NoTargetPutFinish"),
+    /** 异常完成。 */
+    ERROR_FINISH("errorFinish"),
+    /** 运行异常。 */
+    EXCEPTION("exception"),
+    /** 任务作废。 */
+    DEPRECATE("deprecate");
+
+    /** 对外回传给 WMS 的状态值。 */
+    private final String value;
+
+    WmsFeedbackStatusEnum(String value) {
+        this.value = value;
+    }
+
+    public String getValue() {
+        return value;
+    }
+}

acs2/nladmin-system/nlsso-server/src/main/java/org/nl/extInterface/wms/service/impl/AcsToWmsServiceImpl.java

@@ -1,13 +1,153 @@
 package org.nl.extInterface.wms.service.impl;
 
+import cn.hutool.core.util.StrUtil;
+import cn.hutool.http.HttpRequest;
+import com.alibaba.fastjson.JSON;
+import com.alibaba.fastjson.JSONObject;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
+import org.nl.acs.task.TaskConfig;
+import org.nl.acs.task.instruction.domain.Instruction;
+import org.nl.acs.task.task.service.dto.TaskDto;
+import org.nl.common.db.CommonFinalParam;
 import org.nl.extInterface.wms.service.AcsToWmsService;
+import org.nl.system.service.param.ISysParamService;
+import org.nl.system.service.param.dao.Param;
 import org.springframework.stereotype.Service;
 
 @Service
 @RequiredArgsConstructor
 @Slf4j
 public class AcsToWmsServiceImpl implements AcsToWmsService {
+    private static final String FEEDBACK_TASK_PATH = "/restful/api/v3/system_car/feedbackTask";
+    private static final String DEPRECATE_TASK_PATH = "/restful/api/v3/system_car/deprecateTask";
+    private static final String TASK_REDIRECTION_PATH = "/restful/api/v3/system_car/taskRedirection";
+    private static final String DEVICE_STATUS_PATH = "/restful/api/v3/system_car/deviceStatusUpdate";
 
+    private final ISysParamService paramService;
+
+    @Override
+    public boolean feedbackTask(TaskDto taskDto, String card, String feedbackStatus) {
+        if (!isWmsTask(taskDto)) {
+            return true;
+        }
+        // 当前项目复用 feedbackTask 作为统一出口，既回传阶段，也做取放货许可判断。
+        JSONObject body = baseBody();
+        body.put("taskCode", getExternalTaskCode(taskDto));
+        body.put("card", StrUtil.blankToDefault(card, ""));
+        body.put("taskType", StrUtil.blankToDefault(taskDto.getTask_type(), ""));
+        body.put("feedbackStatus", feedbackStatus);
+        JSONObject response = postJson(buildUrl(FEEDBACK_TASK_PATH), body);
+        return isSuccess(response);
+    }
+
+    @Override
+    public boolean feedbackTask(Instruction instruction, String feedbackStatus) {
+        if (!isWmsInstruction(instruction)) {
+            return true;
+        }
+        JSONObject body = baseBody();
+        body.put("taskCode", instruction.getTask_code());
+        body.put("card", StrUtil.blankToDefault(instruction.getCarno(), ""));
+        body.put("taskType", StrUtil.blankToDefault(instruction.getInstruction_type(), ""));
+        body.put("feedbackStatus", feedbackStatus);
+        JSONObject response = postJson(buildUrl(FEEDBACK_TASK_PATH), body);
+        return isSuccess(response);
+    }
+
+    @Override
+    public boolean deprecateTask(TaskDto taskDto, String reason) {
+        if (!isWmsTask(taskDto)) {
+            return true;
+        }
+        JSONObject body = baseBody();
+        body.put("taskCode", getExternalTaskCode(taskDto));
+        body.put("reason", StrUtil.blankToDefault(reason, ""));
+        JSONObject response = postJson(buildUrl(DEPRECATE_TASK_PATH), body);
+        return isSuccess(response);
+    }
+
+    @Override
+    public JSONObject taskRedirection(String taskCode, String currLocation) {
+        JSONObject body = baseBody();
+        body.put("taskCode", taskCode);
+        body.put("currLocation", currLocation);
+        return postJson(buildUrl(TASK_REDIRECTION_PATH), body);
+    }
+
+    @Override
+    public boolean deviceStatusUpdate(String deviceCode, Integer status, String statusDescription) {
+        JSONObject body = baseBody();
+        body.put("deviceCode", deviceCode);
+        body.put("status", status);
+        body.put("statusDescription", statusDescription);
+        JSONObject response = postJson(buildUrl(DEVICE_STATUS_PATH), body);
+        return isSuccess(response);
+    }
+
+    @Override
+    public boolean isWmsTask(TaskDto taskDto) {
+        // 当前通过任务号规则和总开关共同判断，避免历史 ACS 本地任务进入 WMS 流程。
+        return taskDto != null
+                && StrUtil.isNotBlank(taskDto.getTask_code())
+                && !StrUtil.startWith(taskDto.getTask_code(), CommonFinalParam.HYPHEN_)
+                && StrUtil.equals("1", getParam(TaskConfig.HASWMS, "0"));
+    }
+
+    @Override
+    public boolean isWmsInstruction(Instruction instruction) {
+        return instruction != null
+                && StrUtil.isNotBlank(instruction.getTask_code())
+                && !StrUtil.startWith(instruction.getTask_code(), CommonFinalParam.HYPHEN_)
+                && StrUtil.equals("1", getParam(TaskConfig.HASWMS, "0"));
+    }
+
+    protected JSONObject postJson(String url, JSONObject body) {
+        try {
+            String result = HttpRequest.post(url)
+                    .header("Content-Type", "application/json")
+                    .body(body.toJSONString())
+                    .timeout(8000)
+                    .execute()
+                    .body();
+            return JSON.parseObject(result);
+        } catch (Exception ex) {
+            // 统一包装成失败响应，调用方可以按 WMS 拒绝的同一套逻辑处理。
+            log.error("postJson failed, url={}, body={}", url, body, ex);
+            JSONObject error = new JSONObject();
+            error.put("responseCode", 1);
+            error.put("responseMessage", ex.getMessage());
+            return error;
+        }
+    }
+
+    private JSONObject baseBody() {
+        JSONObject body = new JSONObject();
+        body.put("houseCode", getParam(TaskConfig.WMS_HOUSE_CODE, ""));
+        body.put("systemCode", getParam(TaskConfig.WMS_SYSTEM_CODE, ""));
+        // 协议预留了扩展参数对象，即使当前流程没有额外字段也保持结构一致。
+        body.put("parameters", new JSONObject());
+        return body;
+    }
+
+    private String buildUrl(String path) {
+        String baseUrl = getParam(TaskConfig.WMSURL, "");
+        if (StrUtil.endWith(baseUrl, "/")) {
+            baseUrl = StrUtil.removeSuffix(baseUrl, "/");
+        }
+        return baseUrl + path;
+    }
+
+    private String getExternalTaskCode(TaskDto taskDto) {
+        return StrUtil.isNotBlank(taskDto.getExt_task_id()) ? taskDto.getExt_task_id() : taskDto.getTask_code();
+    }
+
+    private boolean isSuccess(JSONObject response) {
+        return response != null && Integer.valueOf(0).equals(response.getInteger("responseCode"));
+    }
+
+    private String getParam(String code, String defaultValue) {
+        Param param = paramService.findByCode(code);
+        return param == null || StrUtil.isBlank(param.getValue()) ? defaultValue : param.getValue();
+    }
 }

acs2/nladmin-system/nlsso-server/src/main/java/org/nl/extInterface/wms/service/impl/WmsToAcsServiceImpl.java

@@ -1,13 +1,57 @@
 package org.nl.extInterface.wms.service.impl;
 
+import cn.hutool.core.util.StrUtil;
+import com.alibaba.fastjson.JSONObject;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
+import org.nl.acs.task.task.service.TaskService;
+import org.nl.acs.task.task.service.dto.TaskDto;
 import org.nl.extInterface.wms.service.WmsToAcsService;
+import org.nl.extInterface.wms.service.dto.CreateTaskRequest;
 import org.springframework.stereotype.Service;
 
 @Service
 @RequiredArgsConstructor
 @Slf4j
 public class WmsToAcsServiceImpl implements WmsToAcsService {
+    private final TaskService taskService;
 
+    @Override
+    public JSONObject createTask(CreateTaskRequest request) {
+        JSONObject response = new JSONObject();
+        try {
+            // 将 WMS 协议报文转换成现有 ACS 任务 DTO，复用已有建单和调度链路。
+            TaskDto dto = new TaskDto();
+            dto.setTask_code(request.getTaskCode());
+            dto.setExt_task_id(request.getTaskCode());
+            dto.setTask_type(StrUtil.blankToDefault(request.getTaskType(), "1"));
+            dto.setVehicle_code(request.getContainerCode());
+            dto.setVehicle_type(request.getContainerType());
+            dto.setStart_point_code(request.getLocationFrom());
+            dto.setStart_device_code(request.getLocationFrom());
+            dto.setNext_point_code(request.getLocationTo());
+            dto.setNext_device_code(request.getLocationTo());
+            dto.setPriority(request.getPriority() == null ? null : String.valueOf(request.getPriority()));
+            dto.setQuantity("1");
+            dto.setRoute_plan_code("normal");
+            dto.setCompound_task("0");
+            dto.setCreate_type("WMS");
+            dto.setFinish_type("WMS");
+            // 当前任务模型没有完整承载 WMS 扩展字段的结构化列，先放入 remark 保留。
+            JSONObject extInfo = new JSONObject();
+            extInfo.put("houseCode", request.getHouseCode());
+            extInfo.put("systemCode", request.getSystemCode());
+            extInfo.put("taskCreateDateTime", request.getTaskCreateDateTime());
+            extInfo.put("parameters", request.getParameters());
+            dto.setRemark(extInfo.toJSONString());
+            taskService.create(dto);
+            response.put("responseCode", 0);
+            response.put("responseMessage", "success");
+        } catch (Exception ex) {
+            log.error("createTask failed, taskCode={}", request.getTaskCode(), ex);
+            response.put("responseCode", 1);
+            response.put("responseMessage", ex.getMessage());
+        }
+        return response;
+    }
 }

acs2/nladmin-system/nlsso-server/src/test/java/org/nl/extInterface/wms/service/impl/AcsToWmsServiceImplTest.java

@@ -0,0 +1,95 @@
+package org.nl.extInterface.wms.service.impl;
+
+import com.alibaba.fastjson.JSONObject;
+import org.junit.Test;
+import org.nl.acs.task.TaskConfig;
+import org.nl.acs.task.task.service.dto.TaskDto;
+import org.nl.system.service.param.ISysParamService;
+import org.nl.system.service.param.dao.Param;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+public class AcsToWmsServiceImplTest {
+
+    @Test
+    public void feedbackTaskTreatsZeroResponseCodeAsAllowed() {
+        ISysParamService paramService = mock(ISysParamService.class);
+        when(paramService.findByCode(TaskConfig.WMSURL)).thenReturn(param(TaskConfig.WMSURL, "http://wms"));
+        when(paramService.findByCode(TaskConfig.HASWMS)).thenReturn(param(TaskConfig.HASWMS, "1"));
+        when(paramService.findByCode(TaskConfig.WMS_HOUSE_CODE)).thenReturn(param(TaskConfig.WMS_HOUSE_CODE, "H1"));
+        when(paramService.findByCode(TaskConfig.WMS_SYSTEM_CODE)).thenReturn(param(TaskConfig.WMS_SYSTEM_CODE, "WMS"));
+
+        TestableAcsToWmsServiceImpl service = new TestableAcsToWmsServiceImpl(paramService);
+        service.nextResponse = jsonResponse(0, "ok");
+
+        TaskDto task = new TaskDto();
+        task.setTask_code("TASK-1");
+        task.setTask_type("MOVE");
+
+        boolean allowed = service.feedbackTask(task, "AGV-01", "applyTake");
+
+        assertTrue(allowed);
+        assertEquals("http://wms/restful/api/v3/system_car/feedbackTask", service.lastUrl);
+        assertEquals("TASK-1", service.lastBody.getString("taskCode"));
+        assertEquals("AGV-01", service.lastBody.getString("card"));
+        assertEquals("MOVE", service.lastBody.getString("taskType"));
+        assertEquals("applyTake", service.lastBody.getString("feedbackStatus"));
+        assertEquals("H1", service.lastBody.getString("houseCode"));
+        assertEquals("WMS", service.lastBody.getString("systemCode"));
+    }
+
+    @Test
+    public void feedbackTaskTreatsNonZeroResponseCodeAsRejected() {
+        ISysParamService paramService = mock(ISysParamService.class);
+        when(paramService.findByCode(TaskConfig.WMSURL)).thenReturn(param(TaskConfig.WMSURL, "http://wms"));
+        when(paramService.findByCode(TaskConfig.HASWMS)).thenReturn(param(TaskConfig.HASWMS, "1"));
+        when(paramService.findByCode(TaskConfig.WMS_HOUSE_CODE)).thenReturn(param(TaskConfig.WMS_HOUSE_CODE, "H1"));
+        when(paramService.findByCode(TaskConfig.WMS_SYSTEM_CODE)).thenReturn(param(TaskConfig.WMS_SYSTEM_CODE, "WMS"));
+
+        TestableAcsToWmsServiceImpl service = new TestableAcsToWmsServiceImpl(paramService);
+        service.nextResponse = jsonResponse(2, "denied");
+
+        TaskDto task = new TaskDto();
+        task.setTask_code("TASK-2");
+        task.setTask_type("MOVE");
+
+        boolean allowed = service.feedbackTask(task, "AGV-02", "applyPut");
+
+        assertFalse(allowed);
+    }
+
+    private static Param param(String code, String value) {
+        Param param = new Param();
+        param.setCode(code);
+        param.setValue(value);
+        return param;
+    }
+
+    private static JSONObject jsonResponse(int code, String message) {
+        JSONObject json = new JSONObject();
+        json.put("responseCode", code);
+        json.put("responseMessage", message);
+        return json;
+    }
+
+    private static class TestableAcsToWmsServiceImpl extends AcsToWmsServiceImpl {
+        private JSONObject nextResponse;
+        private String lastUrl;
+        private JSONObject lastBody;
+
+        private TestableAcsToWmsServiceImpl(ISysParamService paramService) {
+            super(paramService);
+        }
+
+        @Override
+        protected JSONObject postJson(String url, JSONObject body) {
+            this.lastUrl = url;
+            this.lastBody = body;
+            return nextResponse;
+        }
+    }
+}

acs2/nladmin-system/nlsso-server/src/test/java/org/nl/extInterface/wms/service/impl/WmsToAcsServiceImplTest.java

@@ -0,0 +1,81 @@
+package org.nl.extInterface.wms.service.impl;
+
+import com.alibaba.fastjson.JSONObject;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.ArgumentCaptor;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnitRunner;
+import org.nl.acs.task.task.service.TaskService;
+import org.nl.acs.task.task.service.dto.TaskDto;
+import org.nl.extInterface.wms.service.dto.CreateTaskRequest;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.doThrow;
+import static org.mockito.Mockito.verify;
+
+@RunWith(MockitoJUnitRunner.class)
+public class WmsToAcsServiceImplTest {
+
+    @Mock
+    private TaskService taskService;
+
+    @InjectMocks
+    private WmsToAcsServiceImpl service;
+
+    @Test
+    public void createTaskMapsRequestToTaskDto() throws Exception {
+        CreateTaskRequest request = new CreateTaskRequest();
+        request.setTaskCode("TASK-001");
+        request.setTaskType("MOVE");
+        request.setContainerCode("PALLET-1");
+        request.setContainerType("PALLET");
+        request.setLocationFrom("A01");
+        request.setLocationTo("B01");
+        request.setPriority(5);
+        request.setHouseCode("H1");
+        request.setSystemCode("WMS");
+        JSONObject parameters = new JSONObject();
+        parameters.put("batch", "B1");
+        request.setParameters(parameters);
+
+        JSONObject response = service.createTask(request);
+
+        ArgumentCaptor<TaskDto> captor = ArgumentCaptor.forClass(TaskDto.class);
+        verify(taskService).create(captor.capture());
+        TaskDto dto = captor.getValue();
+        assertEquals("TASK-001", dto.getTask_code());
+        assertEquals("TASK-001", dto.getExt_task_id());
+        assertEquals("MOVE", dto.getTask_type());
+        assertEquals("PALLET-1", dto.getVehicle_code());
+        assertEquals("PALLET", dto.getVehicle_type());
+        assertEquals("A01", dto.getStart_point_code());
+        assertEquals("A01", dto.getStart_device_code());
+        assertEquals("B01", dto.getNext_point_code());
+        assertEquals("B01", dto.getNext_device_code());
+        assertEquals("5", dto.getPriority());
+        assertEquals("1", dto.getQuantity());
+        assertTrue(dto.getRemark().contains("\"houseCode\":\"H1\""));
+        assertTrue(dto.getRemark().contains("\"systemCode\":\"WMS\""));
+        assertEquals(Integer.valueOf(0), response.getInteger("responseCode"));
+    }
+
+    @Test
+    public void createTaskReturnsErrorWhenTaskCreationFails() throws Exception {
+        CreateTaskRequest request = new CreateTaskRequest();
+        request.setTaskCode("TASK-ERR");
+        request.setContainerCode("PALLET-ERR");
+        request.setLocationFrom("A01");
+        request.setLocationTo("B01");
+
+        doThrow(new IllegalStateException("duplicate task")).when(taskService).create(any(TaskDto.class));
+
+        JSONObject response = service.createTask(request);
+
+        assertEquals(Integer.valueOf(1), response.getInteger("responseCode"));
+        assertEquals("duplicate task", response.getString("responseMessage"));
+    }
+}