root/stand_acs
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

agv状态回传改用策略模式

Browse Source
This commit is contained in:
miguannan
2026-05-06 10:45:09 +08:00
parent 16ed2580b1
commit 1aa2356340
11 changed files with 568 additions and 196 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
acs2/nladmin-system/nlsso-server/src/main/java/org/nl/extInterface/agvKit/controller/KitToAcsController.java
View File

@@ -44,7 +44,7 @@ public class KitToAcsController {
param = JSONObject.parseObject(o);
}
log.info("---kit上报请求---"+param.toString());
System.out.println("---kit上报请求---"+param.toString());
System.out.println("---kit上报请求---"+ param);
return new ResponseEntity<>(kitToAcsService.agvCallback(param), HttpStatus.OK);
}
}

26
acs2/nladmin-system/nlsso-server/src/main/java/org/nl/extInterface/agvKit/service/handler/KitMessageHandler.java Normal file
View File

@@ -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;
}

43
acs2/nladmin-system/nlsso-server/src/main/java/org/nl/extInterface/agvKit/service/handler/KitResponse.java Normal file
View File

@@ -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;
}
}

37
acs2/nladmin-system/nlsso-server/src/main/java/org/nl/extInterface/agvKit/service/handler/impl/AgvErrorReportHandler.java Normal file
View File

@@ -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("更新指令执行中成功");
}
}

57
acs2/nladmin-system/nlsso-server/src/main/java/org/nl/extInterface/agvKit/service/handler/impl/AgvIdReportHandler.java Normal file
View File

@@ -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("更新车号成功");
}
}

37
acs2/nladmin-system/nlsso-server/src/main/java/org/nl/extInterface/agvKit/service/handler/impl/AgvPowerReportHandler.java Normal file
View File

@@ -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("更新指令执行中成功");
}
}

54
acs2/nladmin-system/nlsso-server/src/main/java/org/nl/extInterface/agvKit/service/handler/impl/AgvStateReportHandler.java Normal file
View File

@@ -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("更新指令执行中成功");
}
}

55
acs2/nladmin-system/nlsso-server/src/main/java/org/nl/extInterface/agvKit/service/handler/impl/TaskIndexReportHandler.java Normal file
View File

@@ -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("更新指令执行中成功");
}
}

37
acs2/nladmin-system/nlsso-server/src/main/java/org/nl/extInterface/agvKit/service/handler/impl/TaskRunReportHandler.java Normal file
View File

@@ -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("更新车号成功");
}
}

179
acs2/nladmin-system/nlsso-server/src/main/java/org/nl/extInterface/agvKit/service/handler/impl/TaskStateReportHandler.java Normal file
View File

@@ -0,0 +1,179 @@
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)) {
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;
}
}

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

@@ -1,213 +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.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.enums.InstructionStatusEnum;
import org.nl.acs.task.instruction.service.InstructionService;
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.wms.service.AcsToWmsService;
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;
@Autowired
private AcsToWmsService acsToWmsService;
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{
// AGV 回调只负责推进 ACS 内部状态，后续是否继续执行由站点驱动结合 WMS 许可决定。
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);
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);
return resp;
}
instructionService.reload();
}
if (TaskStateEnum.CANCELED.getValue().equals(taskState)){
instructionService.cancel(instruction.getInstruction_id());
resp.put("code", "200");
resp.put("message", "取消任务成功");
log.info("---kit响应请求---{}", resp);
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);
return resp;
}
device = deviceAppService.findDeviceByCode(storageCellDto.getStorage_code());
if (ObjectUtil.isEmpty(device)) {
resp.put("code", "400");
resp.put("message", "请求失败，请求位置编码不存在");
log.info("---kit响应请求---{}", resp);
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());
}
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);
return resp;
}
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)){
resp.put("code", "200");
resp.put("message", "完成任务成功");
log.info("---kit响应请求---{}", resp);
}
break;
default:
resp.put("code", "400");
resp.put("message", "taskPhase值不存在");
log.info("---kit响应请求---{}", resp);
return resp;
}
resp.put("code", "200");
resp.put("message", taskPhaseEnum.getDescription()+"处理完毕");
log.info("---kit响应请求---{}", resp);
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);
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);
return resp;
} else if (MsgTypeEnum.TASK_RUN_RPT.getValue().equals(type)){
resp.put("code", "200");
resp.put("message", "更新车号成功");
log.info("---kit响应请求---{}", resp);
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);
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);
return resp;
} else if (MsgTypeEnum.AGV_POWER_RPT.getValue().equals(type)){
resp.put("code", "200");
resp.put("message", "更新指令执行中成功");
log.info("---kit响应请求---{}", resp);
return resp;
} else if (MsgTypeEnum.AGV_STATE_RPT.getValue().equals(type)){
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) {
resp.put("code", "400");
resp.put("message", "AGV状态上报参数异常");
log.info("---kit响应请求---{}", resp);
return resp;
}
boolean success = acsToWmsService.deviceStatusUpdate(deviceCode, status, statusDescription);
if (!success) {
resp.put("code", "400");
resp.put("message", "回馈WMS设备状态失败");
log.info("---kit响应请求---{}", resp);
return resp;
}
resp.put("code", "200");
resp.put("message", "更新指令执行中成功");
log.info("---kit响应请求---{}", resp);
return resp;
} else if (MsgTypeEnum.AGV_ERROR_RPT.getValue().equals(type)){
resp.put("code", "200");
resp.put("message", "更新指令执行中成功");
log.info("---kit响应请求---{}", resp);
return resp;
KitMessageHandler handler = handlerMap.get(type);
if (handler == null) {
JSONObject response = KitResponse.fail(type + "type类型未定义");
log.info("---kit响应请求---{}", response);
return response;
}
resp.put("code", "400");
resp.put("message", type+"type类型未定义");
log.info("---kit响应请求---{}", resp);
return resp;
JSONObject response = handler.handle(params);
log.info("---kit响应请求---{}", response);
return response;
}
}