diff --git a/ruoyi-admin/src/main/java/com/ruoyi/api/controller/Wcs2WmsController.java b/ruoyi-admin/src/main/java/com/ruoyi/api/controller/Wcs2WmsController.java index 2cd981d..fbf00fd 100644 --- a/ruoyi-admin/src/main/java/com/ruoyi/api/controller/Wcs2WmsController.java +++ b/ruoyi-admin/src/main/java/com/ruoyi/api/controller/Wcs2WmsController.java @@ -21,29 +21,43 @@ public class Wcs2WmsController { @Autowired private IWcsPortService wcsPortService; + + /** * 接收wms出库任务 * - * @param stockoutReceive + * @param receiveJob * @return */ @PostMapping("/receiveOutMydoJob") - public AjaxResult receiveOutMydoJob(@RequestBody StockoutReceive stockoutReceive) { - return apiService.receiveOutMydoJob(stockoutReceive); + public AjaxResult receiveOutMydoJob(@RequestBody ReceiveJob receiveJob) { + return apiService.receiveOutMydoJob(receiveJob); } + /** * 接收入库任务 * - * @param receiveInJob + * @param receiveJob * @return */ @PostMapping("/receiveInMydoJob") - public AjaxResult receiveInMydoJob(@RequestBody ReceiveJob receiveInJob) { - return apiService.receiveInMydoJob(receiveInJob); + public AjaxResult receiveInMydoJob(@RequestBody ReceiveJob receiveJob) { + return apiService.receiveInMydoJob(receiveJob); } + /** + * 接收盘点任务 + * + * @param receiveJob + * @return + */ + @PostMapping("/receiveInventoryMydoJob") + public AjaxResult receiveInventoryMydoJob(@RequestBody ReceiveJob receiveJob) { + return apiService.receiveInventoryMydoJob(receiveJob); + } + /** * wms取消任务 @@ -52,7 +66,18 @@ public class Wcs2WmsController { */ @PostMapping("/cancelMydoJob") public AjaxResult cancelMydoJob(@RequestBody JobParam jobParam) { - return apiService.cancelMydoJob(jobParam); + return apiService.cancelTask(jobParam.getTaskNo()); + } + + + /** + * wms手动完成任务 + * @param jobParam + * @return + */ + @PostMapping("/manuallyCompeleteMydoJob") + public AjaxResult manuallyCompeleteMydoJob(@RequestBody JobParam jobParam) { + return apiService.manuallyCompeleteTask(jobParam.getTaskNo()); } @@ -66,6 +91,7 @@ public class Wcs2WmsController { return apiService.selectWcsPort(wcsPort); } + /** * 修改缓存点状态 * @param wcsPort diff --git a/ruoyi-admin/src/main/java/com/ruoyi/api/domain/wcs2wms/JobParam.java b/ruoyi-admin/src/main/java/com/ruoyi/api/domain/wcs2wms/JobParam.java index d93de24..88d943b 100644 --- a/ruoyi-admin/src/main/java/com/ruoyi/api/domain/wcs2wms/JobParam.java +++ b/ruoyi-admin/src/main/java/com/ruoyi/api/domain/wcs2wms/JobParam.java @@ -23,5 +23,10 @@ public class JobParam { */ private String taskNo; + /** + * 货位号 + */ + private String cargoSpaceId; + } diff --git a/ruoyi-admin/src/main/java/com/ruoyi/api/domain/wcs2wms/ReceiveJob.java b/ruoyi-admin/src/main/java/com/ruoyi/api/domain/wcs2wms/ReceiveJob.java index 92b8c66..65e7ad6 100644 --- a/ruoyi-admin/src/main/java/com/ruoyi/api/domain/wcs2wms/ReceiveJob.java +++ b/ruoyi-admin/src/main/java/com/ruoyi/api/domain/wcs2wms/ReceiveJob.java @@ -8,6 +8,12 @@ import lombok.NoArgsConstructor; @AllArgsConstructor @NoArgsConstructor public class ReceiveJob { + + /** + * 作业号 + */ + private String jobId; + /** * 任务号 */ @@ -18,6 +24,11 @@ public class ReceiveJob { */ private String cargoSpaceId; + /** + * 入口 + */ + private String entranceId; + /** * 出口 */ @@ -28,21 +39,11 @@ public class ReceiveJob { */ private String trayCode; - /** - * 入口 - */ - private String entranceId; - /** * 任务类型 */ private String inOrOut; - /** - * 作业号 - */ - private String jobId; - /** * 巷道号 */ @@ -52,4 +53,6 @@ public class ReceiveJob { * */ private String departmentId; + + } diff --git a/ruoyi-admin/src/main/java/com/ruoyi/api/service/IApiService.java b/ruoyi-admin/src/main/java/com/ruoyi/api/service/IApiService.java index 6a91c9f..d16b973 100644 --- a/ruoyi-admin/src/main/java/com/ruoyi/api/service/IApiService.java +++ b/ruoyi-admin/src/main/java/com/ruoyi/api/service/IApiService.java @@ -1,5 +1,11 @@ package com.ruoyi.api.service; +import cn.hutool.core.bean.BeanUtil; +import cn.hutool.core.convert.Convert; +import cn.hutool.core.date.DateUtil; +import cn.hutool.core.util.IdUtil; +import cn.hutool.json.JSONUtil; +import com.alibaba.fastjson2.JSON; import com.ruoyi.api.domain.RequestLog; import com.ruoyi.api.domain.agv.agvCallback.AgvCallbackRequest; import com.ruoyi.api.domain.agv.agvCallback.AgvCallbackResponse; @@ -9,6 +15,7 @@ import com.ruoyi.api.domain.agv.continueTask.ContinueTaskRequest; import com.ruoyi.api.domain.agv.continueTask.ContinueTaskResponse; import com.ruoyi.api.domain.agv.genAgvSchedulingTask.GenAgvSchedulingTaskRequest; import com.ruoyi.api.domain.agv.genAgvSchedulingTask.GenAgvSchedulingTaskResponse; +import com.ruoyi.api.domain.agv.genAgvSchedulingTask.PositionCodeData; import com.ruoyi.api.domain.wcs2wms.JobParam; import com.ruoyi.api.domain.wcs2wms.ReceiveJob; import com.ruoyi.api.domain.wcs2wms.exception.TaskExceptionRequest; @@ -19,11 +26,16 @@ import com.ruoyi.common.exception.job.TaskException; import com.ruoyi.job.domain.MydoJob; import com.ruoyi.queue.agv.domain.AgvQueue; import org.aspectj.weaver.loadtime.Aj; +import org.springframework.transaction.annotation.Transactional; +import java.util.ArrayList; import java.util.HashMap; import java.util.List; import java.util.Map; +import static com.ruoyi.common.Constant.*; +import static com.ruoyi.common.Constant.CANCEL_TASK_URL; + /** * 接口记录Service接口 * @@ -33,6 +45,77 @@ import java.util.Map; public interface IApiService { + + /** + * 任务到达拣选口 + * @param param + * @return + */ + RequestLog finishMydoJob(Map param); + + AjaxResult selectWcsPort(WcsPort wcsPort); + + AjaxResult updateWcsPort(WcsPort wcsPort); + + + + /** + * 放货有货，重新分配货位 + * @param jobParam + * @return + */ + AjaxResult reAssign(JobParam jobParam); + + + /** + * 取货无货，重新分配单据 + * @param jobParam + * @return + */ + AjaxResult reMaterial(JobParam jobParam); + + + + /** + * 入库请求生成作业 + */ + AjaxResult createInMydoJob(Map param); + + /** + * @@@ FT568 入库请求生成作业 处理了请求响应，适应wms的自定义响应格式 + */ + AjaxResult createMydoJobForStockin(Map param); + + /** + * 入库请求作业异常反馈（扫码失败、外形、称重等异常） + */ + AjaxResult createInMydoJobException(Map param); + + AjaxResult selectMydoJobByNoTrayCode(Map param); + + AjaxResult receiveOutMydoJob(ReceiveJob receiveJob); + + AjaxResult receiveInMydoJob(ReceiveJob receiveJob); + + AjaxResult receiveInventoryMydoJob(ReceiveJob receiveInventoryJob); + + AjaxResult selectMydoJobByTrayCodeAndEntranceId(HashMap paramMap); + + AjaxResult requestWmsSpace(MydoJob mydoJob); + + AjaxResult manuallyCompeleteTask(String taskNo); + + AjaxResult cancelTask(String taskNo); + + + + + + //=============================================AGV相关============================================= + //=============================================AGV相关============================================= + //=============================================AGV相关============================================= + + /** * 生成agv队列 * @param code1 起点 @@ -82,19 +165,7 @@ public interface IApiService */ AjaxResult receiveAgvMoveJob(Map param); - /** - * 任务到达拣选口 - * @param param - * @return - */ - RequestLog finishMydoJob(Map param); - - /** - * @@@ FT568 任务完成回传 适应wms的自定义响应格式 - * @param param - * @return - */ - RequestLog finishMydoJobForResponseResult(Map param); + AjaxResult deleteAgvTray(AgvQueue agvQueue); /** * 下发agv任务 @@ -103,7 +174,6 @@ public interface IApiService */ public GenAgvSchedulingTaskResponse requestAgvQueue(AgvQueue agvQueue); - /** * 取消ctu任务 * @param jobParam @@ -111,69 +181,5 @@ public interface IApiService */ AjaxResult cancelMydoJob(JobParam jobParam); - AjaxResult selectWcsPort(WcsPort wcsPort); - - AjaxResult updateWcsPort(WcsPort wcsPort); - - - - /** - * 放货有货，重新分配货位 - * @param jobParam - * @return - */ - AjaxResult reAssign(JobParam jobParam); - - /** - * 放货有货 （参数类型TaskExceptionRequest） - * @param taskExceptionRequest - * @return - */ - AjaxResult reAssign(TaskExceptionRequest taskExceptionRequest); - - /** - * 取货无货，重新分配单据 - * @param jobParam - * @return - */ - AjaxResult reMaterial(JobParam jobParam); - - /** - * 取货无货（参数类型TaskExceptionRequest） - * @param taskExceptionRequest - * @return - */ - AjaxResult reMaterial(TaskExceptionRequest taskExceptionRequest); - - /** - * 入库请求生成作业 - */ - AjaxResult createInMydoJob(Map param); - - /** - * @@@ FT568 入库请求生成作业 处理了请求响应，适应wms的自定义响应格式 - */ - AjaxResult createMydoJobForStockin(Map param); - - /** - * 入库请求作业异常反馈（扫码失败、外形、称重等异常） - */ - AjaxResult createInMydoJobException(Map param); - - AjaxResult selectMydoJobByNoTrayCode(Map param); - - AjaxResult receiveOutMydoJob(StockoutReceive stockoutReceive); - - AjaxResult receiveInMydoJob(ReceiveJob receiveInJob); - - AjaxResult selectMydoJobByTrayCodeAndEntranceId(HashMap paramMap); - - AjaxResult deleteAgvTray(AgvQueue agvQueue); - - AjaxResult requestWmsSpace(MydoJob mydoJob); - - - - } diff --git a/ruoyi-admin/src/main/java/com/ruoyi/api/service/impl/ApiServiceImpl.java b/ruoyi-admin/src/main/java/com/ruoyi/api/service/impl/ApiServiceImpl.java index 74e9127..b3e79f0 100644 --- a/ruoyi-admin/src/main/java/com/ruoyi/api/service/impl/ApiServiceImpl.java +++ b/ruoyi-admin/src/main/java/com/ruoyi/api/service/impl/ApiServiceImpl.java @@ -28,6 +28,7 @@ import com.ruoyi.bas.cargospace.service.IBasCargoSpaceService; import com.ruoyi.bas.port.domain.WcsPort; import com.ruoyi.bas.port.service.IWcsPortService; import com.ruoyi.common.GoodsType; +import com.ruoyi.common.TaskType; import com.ruoyi.common.core.domain.AjaxResult; import com.ruoyi.common.utils.DateUtils; import com.ruoyi.job.domain.MydoJob; @@ -39,15 +40,15 @@ import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Service; import org.springframework.transaction.annotation.Transactional; -import javax.annotation.PostConstruct; import java.util.ArrayList; import java.util.HashMap; import java.util.List; import java.util.Map; import static com.ruoyi.common.Constant.*; -import static com.ruoyi.common.ConvType.CONV_STOCKOUT; +import static com.ruoyi.common.ConvType.ROADWAY1_EXIT; import static com.ruoyi.common.TaskStatusCode.TASK_EP_CREATED; +import static com.ruoyi.common.TaskStatusCode.TASK_STATUS_CREATED; /** * 接口记录Service业务层处理 @@ -71,6 +72,451 @@ public class ApiServiceImpl implements IApiService { private IBasCargoSpaceService basCargoSpaceService; + /** + * 出库到达拣选口 + * + * @param param + * @return + */ + @Override + public RequestLog finishMydoJob(Map param) { + return requestLogService.getRequestLog(WMS_TASK_FINISH, "任务完成上报", JSONUtil.toJsonStr(param)); + } + + + /** + * 异常重分（参数类型JobParam） + * @param jobParam + * @return + */ + @Override + public AjaxResult reAssign(JobParam jobParam) { + RequestLog requestLog = requestLogService.getRequestLog(RE_ASSIGN_URL, "重新分配货位", JSONUtil.toJsonStr(jobParam)); + if ("1".equals(requestLog.getIsSuccessful())){ + InterfaceReceive bean = JSONUtil.toBean(requestLog.getResponseBody(), InterfaceReceive.class); + MydoJob wmsMydoJob = BeanUtil.toBean(bean.getData(), MydoJob.class); + MydoJob mydoJob = mydoJobService.selectMydoJobByJobId(wmsMydoJob.getJobId()); + mydoJob.setCargoSpaceId(wmsMydoJob.getCargoSpaceId()); + mydoJobService.updateMydoJob(mydoJob); + return AjaxResult.success(); + } + return AjaxResult.error(); + } + + + /** + * 出库异常作废（参数类型jobParam） + * @param jobParam + * @return + */ + @Override + public AjaxResult reMaterial(JobParam jobParam) { + RequestLog requestLog = requestLogService.getRequestLog(RE_MATERIAL_URL, "重新分配物料", JSONUtil.toJsonStr(jobParam)); + if ("1".equals(requestLog.getIsSuccessful())){ + return AjaxResult.success(); + } + return AjaxResult.error(); + } + + + /** + * 请求wms获取入库任务参数 + * @param param + * @return + */ + @Override + public AjaxResult createInMydoJob(Map param) { + RequestLog requestLog = requestLogService.getRequestLog(WMS_STOCKIN_MYDOJOB, "入库请求生成作业", JSONUtil.toJsonStr(param)); + if ("1".equals(requestLog.getIsSuccessful())) { + InterfaceReceive bean = JSONUtil.toBean(requestLog.getResponseBody(), InterfaceReceive.class); + return AjaxResult.success(bean.getData()); + } else { + return AjaxResult.error(); + } + } + + /** + * @@@ FT568 请求wms获取入库任务参数 - 适应wms的自定义请求响应格式 + * @param param + * @return + */ + @Override + public AjaxResult createMydoJobForStockin(Map param) { + RequestLog requestLog = requestLogService.getRequestLogForResponseResult(WMS_STOCKIN_MYDOJOB, "入库请求生成作业", JSONUtil.toJsonStr(param)); + if ("1".equals(requestLog.getIsSuccessful())) { + ResponseResult bean = JSONUtil.toBean(requestLog.getResponseBody(), ResponseResult.class); + return AjaxResult.success(bean.getResult()); + } else { + return AjaxResult.error(); + } + } + + /** + * @@@ FT568 入库请求作业异常反馈（扫码失败、外形、称重等异常） + * @param param + * @return + */ + @Override + public AjaxResult createInMydoJobException(Map param) { + RequestLog requestLog = requestLogService.getRequestLog(WMS_STOCKIN_MYDOJOB, "入库异常反馈", JSONUtil.toJsonStr(param)); + if ("1".equals(requestLog.getIsSuccessful())) { + InterfaceReceive bean = JSONUtil.toBean(requestLog.getResponseBody(), InterfaceReceive.class); + return AjaxResult.success(bean.getData()); + } else { + return AjaxResult.error(); + } + } + + + @Override + public AjaxResult receiveOutMydoJob(ReceiveJob stockoutReceive) { + + //生成接口记录 + RequestLog requestLog = requestLogService.getRequestLog(JSONUtil.toJsonStr(stockoutReceive), "推送出库作业"); + requestLog.setResponseBody(JSONUtil.toJsonStr(AjaxResult.success())); + requestLog.setResponseStatus("0"); + requestLog.setIsSuccessful("1"); + requestLogService.insertRequestLog(requestLog); + + // -------------------------检查推送的任务参数------------------------- + log.info( + "【wms推送出库】作业号:{}，wms任务号:{}，推送出库货位:{}，推送类型:出库【{}】",stockoutReceive.getJobId(), stockoutReceive.getTaskNo(), stockoutReceive.getCargoSpaceId(), stockoutReceive.getInOrOut() + ); + + BasCargoSpace cargoSpace = basCargoSpaceService.selectBasCargoSpaceByCargoSpaceId(stockoutReceive.getCargoSpaceId()); + + // 0.检查货位参数是否合法 + if(stockoutReceive.getCargoSpaceId() == null || stockoutReceive.getCargoSpaceId() == ""){ + log.info("【请求错误】wms推送出库任务失败，参数错误，推送作业号:{}，推送出库货位:{}", stockoutReceive.getJobId(), stockoutReceive.getCargoSpaceId()); + return AjaxResult.error("【请求错误】wms推送出库任务失败，参数错误，推送作业号:{}" + stockoutReceive.getJobId() + "，推送出库货位:" + stockoutReceive.getCargoSpaceId()); + }else{ + //排号检查 + if (cargoSpace.getThePlatoon() > 2 || cargoSpace.getThePlatoon() < 0){ + log.info("【请求错误】wms推送出库任务失败，参数错误，推送作业号:{}，推送排:{}", stockoutReceive.getJobId(), cargoSpace.getThePlatoon()); + return AjaxResult.error("【请求错误】wms推送出库任务失败，错误，推送任务号:" + stockoutReceive.getJobId() + "，推送出库排号:" + cargoSpace.getThePlatoon() + "，仓库中不存在该位置！"); + } + + //列号检查 + if (cargoSpace.getTheColumn() > 33 || cargoSpace.getTheColumn() < 0){ + log.info("【请求错误】wms推送出库任务失败，参数错误，推送作业号:{}，推送列:{}", stockoutReceive.getJobId(), cargoSpace.getTheColumn()); + return AjaxResult.error("【请求错误】wms推送出库任务失败，错误，推送任务号:" + stockoutReceive.getJobId() + "，推送出库列号:" + cargoSpace.getTheColumn() + "，仓库中不存在该位置！"); + } + + //层号检查 + if (cargoSpace.getTheFloor() > 6 || cargoSpace.getTheFloor() < 0){ + log.info("【请求错误】wms推送出库任务失败，参数错误，推送作业号:{}，推送层:{}", stockoutReceive.getJobId(), cargoSpace.getThePlatoon()); + return AjaxResult.error("【请求错误】wms推送出库任务失败，错误，推送任务号:" + stockoutReceive.getJobId() + "，推送出库层号:" + cargoSpace.getThePlatoon() + "，仓库中不存在该位置！"); + } + } + + // 1.wms推送的作业号是否重复 + MydoJob job = new MydoJob().builder().jobId(stockoutReceive.getJobId()).build(); + List tasks = mydoJobService.selectMydoJobList(job); + if (tasks.size() != 0) { + log.info("【请求错误】wms下发出库任务失败，该任务已存在，推送作业号号:{}，推送出库货位:{}", stockoutReceive.getJobId(), stockoutReceive.getCargoSpaceId()); + return AjaxResult.error("【请求错误】wms下发出库任务失败，该任务已存在，推送作业号:{}" + stockoutReceive.getJobId() + "，推送出库货位:" + stockoutReceive.getCargoSpaceId()); + } + + // 2.wms推送的出库货位是否已经有任务 + job = new MydoJob().builder().cargoSpaceId(stockoutReceive.getCargoSpaceId()).build(); + tasks = mydoJobService.selectMydoJobList(job); + if (tasks.size() != 0) { + log.info("【请求错误】wms下发出库任务失败，已经存在该货位的出库任务，推送任务号:{}，推送出库货位:{}", stockoutReceive.getJobId(), stockoutReceive.getCargoSpaceId()); + return AjaxResult.error("【请求错误】wms下发出库任务失败，已经存在该货位的出库任务，推送任务号:{}" + stockoutReceive.getJobId() + "，推送出库货位:" + stockoutReceive.getCargoSpaceId()); + } + + //生成出库作业 + MydoJob mydoJob = new MydoJob(); + mydoJob = BeanUtil.copyProperties(stockoutReceive, MydoJob.class); +// mydoJob.setJobId(stockoutReceive.getJobId()); +// mydoJob.setTaskNo(stockoutReceive.getTaskNo()); +//// mydoJob.setWmsTaskNo(stockoutReceive.getTaskCode()); +// mydoJob.setCargoSpaceId(stockoutReceive.getCargoSpaceId()); +// mydoJob.setInOrOut(stockoutReceive.getInOrOut()); +// + mydoJob.setTraySize(GoodsType.TYPE_DEFAULT);//默认 + mydoJob.setStatus(TASK_STATUS_CREATED); + mydoJob.setPriority(Long.valueOf(10)); + //todo 可能需要查本地库存信息获取条码？ +// mydoJob.setTrayCode(receiveOutJob.getTrayCode()); + mydoJob.setRoadwayId( + basCargoSpaceService.selectBasCargoSpaceByCargoSpaceId(stockoutReceive.getCargoSpaceId()).getRoadwayId() + ); + mydoJob.setExitId(ROADWAY1_EXIT);//todo 需要判断两个双向输送口是否空闲 + mydoJob.setCreateTime(DateUtils.getNowDate()); + mydoJob.setExecutionPhase(TASK_EP_CREATED); +// mydoJob.setTraySize(receiveOutJob.getDepartmentId()); + + if (mydoJobService.selectMydoJobByJobId(mydoJob.getJobId()) != null){ + log.info("【任务警告】生成作业失败，已存在的作业号:{}", mydoJob.getJobId() + "(此条可忽略)"); + return AjaxResult.error("【请求警告】生成作业失败，已存在的作业号:{}" + mydoJob.getJobId() + "(此条可忽略)"); + } + + int i = mydoJobService.insertMydoJob(mydoJob); +// boolean success = mydoJobService.saveOrUpdate(mydoJob); + if (i != 0) { + requestLog.setResponseStatus("1"); + requestLogService.updateRequestLog(requestLog); + return AjaxResult.success( + "【堆垛机出库】wms下发出库作业，下发作业号:" + stockoutReceive.getJobId() + "，出库货位:" + stockoutReceive.getCargoSpaceId()); + }else{ + return AjaxResult.error(); + } + + } + + @Override + public AjaxResult receiveInMydoJob(ReceiveJob receiveInJob) { + + RequestLog requestLog = requestLogService.getRequestLog(JSONUtil.toJsonStr(receiveInJob), "推送入库作业"); + requestLog.setResponseBody(JSONUtil.toJsonStr(AjaxResult.success())); + requestLog.setResponseStatus("0"); + requestLog.setIsSuccessful("1"); + requestLogService.insertRequestLog(requestLog); + + // -------------------------检查推送的任务参数------------------------- + log.info( + "【wms推送入库】作业号:{}，目标货位:{}，托盘号:{}",receiveInJob.getJobId(), receiveInJob.getCargoSpaceId(), receiveInJob.getTrayCode() + ); + + // 1.wms推送的作业号是否重复 + MydoJob job = new MydoJob().builder().jobId(receiveInJob.getJobId()).build(); + List tasks = mydoJobService.selectMydoJobList(job); + if (tasks.size() != 0) { + log.info("【请求错误】wms下发入库任务失败，该任务已存在，推送作业号:{}，目标货位:{}", receiveInJob.getJobId(), receiveInJob.getCargoSpaceId()); + return AjaxResult.error("【请求错误】wms下发入库任务失败，该任务已存在，推送作业号:{}" + receiveInJob.getJobId() + "，目标货位:" + receiveInJob.getCargoSpaceId()); + } + + // 2.wms推送的目标货位是否已经有任务 + job = new MydoJob().builder().cargoSpaceId(receiveInJob.getCargoSpaceId()).build(); + tasks = mydoJobService.selectMydoJobList(job); + if (tasks.size() != 0) { + log.info("【请求错误】wms下发入库任务失败，已经存在该货位的入库任务，推送作业号:{}，目标货位:{}", receiveInJob.getJobId(), receiveInJob.getCargoSpaceId()); + return AjaxResult.error("【请求错误】wms下发入库任务失败，已经存在目标货位的入库任务，目标货位:{}" + receiveInJob.getJobId() + "，目标货位:" + receiveInJob.getCargoSpaceId()); + } + + //生成入库作业 + MydoJob mydoJob = new MydoJob(); + mydoJob = BeanUtil.copyProperties(receiveInJob, MydoJob.class); +// mydoJob.setJobId(mydoJobService.getJobId("RK")); +// mydoJob.setTaskNo(mydoJobService.getTaskNo("3")); +// mydoJob.setWmsTaskNo(receiveInJob.getJobId()); +// mydoJob.setCargoSpaceId(receiveInJob.getTrayCode()); +// mydoJob.setTrayCode(receiveOutJob.getTrayCode()); + mydoJob.setRoadwayId( + basCargoSpaceService.selectBasCargoSpaceByCargoSpaceId(receiveInJob.getCargoSpaceId()).getRoadwayId() + ); +// mydoJob.setTraySize(GoodsType.TYPE_DEFAULT); + mydoJob.setInOrOut("1"); + mydoJob.setStatus(TASK_STATUS_CREATED); + mydoJob.setPriority(Long.valueOf(10)); + //todo 可能需要查本地库存信息获取条码？ + + mydoJob.setCreateTime(DateUtils.getNowDate()); + mydoJob.setExecutionPhase(TASK_EP_CREATED); +// mydoJob.setTraySize(receiveOutJob.getDepartmentId()); + + if (mydoJobService.selectMydoJobByJobId(mydoJob.getJobId()) != null){ + log.info("【警告】生成作业失败，已存在的作业号:{}", mydoJob.getJobId() + "(仅提示)"); + return AjaxResult.error("【警告】生成作业失败，已存在的作业号:{}" + mydoJob.getJobId() + "(仅提示)"); + } + + int i = mydoJobService.insertMydoJob(mydoJob); +// boolean success = mydoJobService.saveOrUpdate(mydoJob); + if (i != 0) { + requestLog.setResponseStatus("1"); + requestLogService.updateRequestLog(requestLog); + return AjaxResult.success( + "【推送入库】wms下发入库作业，下发作业号:" + receiveInJob.getJobId() + "，目标货位:" + receiveInJob.getCargoSpaceId()); + }else{ + return AjaxResult.error(); + } + + } + + @Override + public AjaxResult receiveInventoryMydoJob(ReceiveJob receiveInventoryJob) { + + RequestLog requestLog = requestLogService.getRequestLog(JSONUtil.toJsonStr(receiveInventoryJob), "推送盘点作业"); + requestLog.setResponseBody(JSONUtil.toJsonStr(AjaxResult.success())); + requestLog.setResponseStatus("0"); + requestLog.setIsSuccessful("1"); + requestLogService.insertRequestLog(requestLog); + + // -------------------------检查推送的任务参数------------------------- + log.info( + "【wms推送盘点】作业号:{}，目标货位:{}，托盘号:{}",receiveInventoryJob.getJobId(), receiveInventoryJob.getCargoSpaceId(), receiveInventoryJob.getTrayCode() + ); + + // 1.wms推送的作业号是否重复 + MydoJob job = new MydoJob().builder().jobId(receiveInventoryJob.getJobId()).build(); + List tasks = mydoJobService.selectMydoJobList(job); + if (tasks.size() != 0) { + log.info("【请求错误】wms下发盘点任务失败，该任务已存在，推送作业号:{}，目标货位:{}", receiveInventoryJob.getJobId(), receiveInventoryJob.getCargoSpaceId()); + return AjaxResult.error("【请求错误】wms下发盘点任务失败，该任务已存在，推送作业号:{}" + receiveInventoryJob.getJobId() + "，目标货位:" + receiveInventoryJob.getCargoSpaceId()); + } + + // 2.wms推送的目标货位是否已经有任务 + job = new MydoJob().builder().cargoSpaceId(receiveInventoryJob.getCargoSpaceId()).build(); + tasks = mydoJobService.selectMydoJobList(job); + if (tasks.size() != 0) { + log.info("【请求错误】wms下发盘点任务失败，已经存在该货位的入库任务，推送作业号:{}，目标货位:{}", receiveInventoryJob.getJobId(), receiveInventoryJob.getCargoSpaceId()); + return AjaxResult.error("【请求错误】wms下发盘点任务失败，已经存在目标货位的盘点任务，目标货位:{}" + receiveInventoryJob.getJobId() + "，目标货位:" + receiveInventoryJob.getCargoSpaceId()); + } + + //生成入库作业 + MydoJob mydoJob = new MydoJob(); + mydoJob = BeanUtil.copyProperties(receiveInventoryJob, MydoJob.class); +// mydoJob.setJobId(mydoJobService.getJobId("RK")); +// mydoJob.setTaskNo(mydoJobService.getTaskNo("3")); +// mydoJob.setWmsTaskNo(receiveInJob.getJobId()); +// mydoJob.setCargoSpaceId(receiveInJob.getTrayCode()); +// mydoJob.setTrayCode(receiveOutJob.getTrayCode()); + mydoJob.setRoadwayId( + basCargoSpaceService.selectBasCargoSpaceByCargoSpaceId(receiveInventoryJob.getCargoSpaceId()).getRoadwayId() + ); +// mydoJob.setTraySize(GoodsType.TYPE_DEFAULT); + mydoJob.setInOrOut("3"); + mydoJob.setStatus(TASK_STATUS_CREATED); + mydoJob.setPriority(Long.valueOf(10)); + //todo 可能需要查本地库存信息获取条码？ + + mydoJob.setCreateTime(DateUtils.getNowDate()); + mydoJob.setExecutionPhase(TASK_EP_CREATED); +// mydoJob.setTraySize(receiveOutJob.getDepartmentId()); + + if (mydoJobService.selectMydoJobByJobId(mydoJob.getJobId()) != null){ + log.info("【警告】生成作业失败，已存在的作业号:{}", mydoJob.getJobId() + "(仅提示)"); + return AjaxResult.error("【警告】生成作业失败，已存在的作业号:{}" + mydoJob.getJobId() + "(仅提示)"); + } + + int i = mydoJobService.insertMydoJob(mydoJob); +// boolean success = mydoJobService.saveOrUpdate(mydoJob); + if (i != 0) { + requestLog.setResponseStatus("1"); + requestLogService.updateRequestLog(requestLog); + return AjaxResult.success( + "【推送盘点】wms下发盘点作业，下发作业号:" + receiveInventoryJob.getJobId() + "，目标货位:" + receiveInventoryJob.getCargoSpaceId()); + }else{ + return AjaxResult.error(); + } + + } + + @Override + public AjaxResult selectMydoJobByTrayCodeAndEntranceId(HashMap paramMap) { + RequestLog requestLog = requestLogService.getRequestLog(REQUEST_ENTER_URL, "请求获取入库作业", JSONUtil.toJsonStr(paramMap)); + if ("1".equals(requestLog.getIsSuccessful())) { + InterfaceReceive bean = JSONUtil.toBean(requestLog.getResponseBody(), InterfaceReceive.class); + return AjaxResult.success(bean.getData()); + } else { + return AjaxResult.error(); + } + } + + + + + /** + * FT517 - 请求wms货位改在AGV放货到输送线后，在巷道口位置执行 + * @param mydoJob + * @return + */ + @Override + public AjaxResult requestWmsSpace(MydoJob mydoJob) { + RequestLog requestLog = requestLogService.getRequestLog(REQUEST_IN_SPACE_URL, "入库请求分货位", JSONUtil.toJsonStr(mydoJob)); + if ("1".equals(requestLog.getIsSuccessful())) { + InterfaceReceive bean = JSONUtil.toBean(requestLog.getResponseBody(), InterfaceReceive.class); + return AjaxResult.success(bean.getData()); + } else { + return AjaxResult.error(); + } + } + + + @Override + public AjaxResult selectMydoJobByNoTrayCode(Map param) { + RequestLog requestLog = requestLogService.getRequestLog(REQUEST_MYDO_JOB_URL, "入库请求补码作业", JSONUtil.toJsonStr(param)); + if ("1".equals(requestLog.getIsSuccessful())) { + InterfaceReceive bean = JSONUtil.toBean(requestLog.getResponseBody(), InterfaceReceive.class); + return AjaxResult.success(bean.getData()); + } else { + return AjaxResult.error(); + } + } + + @Override + public AjaxResult selectWcsPort(WcsPort wcsPort) { + List wcsPorts = wcsPortService.selectWcsPortList(wcsPort); + return AjaxResult.success(wcsPorts); + } + + @Override + public AjaxResult updateWcsPort(WcsPort wcsPort) { + int i = wcsPortService.updateWcsPort(wcsPort); + if(i > 0){ + return AjaxResult.success(); + }else{ + return AjaxResult.error(); + } + } + + + + public AjaxResult manuallyCompeleteTask(String taskNo) { + return mydoJobService.manuallyCompeleteTask(taskNo); + } + + + public AjaxResult cancelTask(String taskNo) { + return mydoJobService.cancelTask(taskNo); + } + + + + + + + + //=============================================AGV相关============================================= + //=============================================AGV相关============================================= + //=============================================AGV相关============================================= + + /** + * AGV站点映射 + * @param agvQueue + * @return + */ + @Override + public AjaxResult deleteAgvTray(AgvQueue agvQueue) { + Map paramMap = new HashMap<>(); + paramMap.put("reqCode", IdUtil.fastSimpleUUID()); + paramMap.put("ctnrTyp", agvQueue.getCtnrType()); + paramMap.put("ctnrCode", agvQueue.getCtnrCode()); + + if("L1001".equals(agvQueue.getPositionCode2())){ + paramMap.put("stgBinCode", "JT000307001013"); + } + if("L1003".equals(agvQueue.getPositionCode2())){ + paramMap.put("stgBinCode", "JT000206001013"); + } + if("L1001-1".equals(agvQueue.getPositionCode2())){ + paramMap.put("stgBinCode", "JT000407001013"); + } +// paramMap.put("binName", agvQueue.getPositionCode2()); + paramMap.put("indBind", "0"); + + RequestLog requestLog = requestLogService.getRequestLog2(DELETE_BIN_URL, "AGV解绑容器", JSONUtil.toJsonStr(paramMap)); + if ("1".equals(requestLog.getIsSuccessful())) { + log.info("站点："+agvQueue.getPositionCode2()+"{}AGV容器解绑成功！"); + return AjaxResult.success(); + } else { + log.info("站点："+agvQueue.getPositionCode2()+"{}AGV容器解绑失败！"); + return AjaxResult.error(); + } + } + + /** * 下发agv编码 * @@ -124,6 +570,7 @@ public class ApiServiceImpl implements IApiService { } } + /** * agv搬运作业 * @@ -148,24 +595,112 @@ public class ApiServiceImpl implements IApiService { } + /** - * 出库到达拣选口 + * 继续agv任务 * - * @param param + * @param agvQueue * @return */ @Override - public RequestLog finishMydoJob(Map param) { - return requestLogService.getRequestLog(WMS_TASK_FINISH, "任务完成上报", JSONUtil.toJsonStr(param)); + public AjaxResult continueTask(AgvQueue agvQueue) { + ContinueTaskRequest continueTaskRequest = new ContinueTaskRequest(); + continueTaskRequest.setReqCode(IdUtil.fastSimpleUUID()); + continueTaskRequest.setReqTime(DateUtil.formatDateTime(DateUtil.date())); + continueTaskRequest.setTaskCode(agvQueue.getTaskCode()); + RequestLog requestLog = requestLogService.getRequestLog2(CONTINUE_TASK_URL, "继续执行任务", JSONUtil.toJsonStr(continueTaskRequest)); + if ("1".equals(requestLog.getIsSuccessful())) { + return AjaxResult.success(); + } else { + return AjaxResult.error(); + } + } + /** - * @@@ FT568 任务完成回传 适应wms的自定义响应格式 - * @param param + * 请求海康生成agv任务,并修改wms任务状态 + * + * @param agvQueue + */ + @Override + public GenAgvSchedulingTaskResponse requestAgvQueue(AgvQueue agvQueue) { + + GenAgvSchedulingTaskRequest genAgvSchedulingTaskRequest = new GenAgvSchedulingTaskRequest(); + genAgvSchedulingTaskRequest.setReqCode(agvQueue.getReqCode()); + genAgvSchedulingTaskRequest.setPriority("10"); + genAgvSchedulingTaskRequest.setTaskTyp(agvQueue.getTaskType()); + genAgvSchedulingTaskRequest.setCtnrTyp(agvQueue.getCtnrType()); + genAgvSchedulingTaskRequest.setCtnrCode(agvQueue.getCtnrCode()); + genAgvSchedulingTaskRequest.setTaskCode(agvQueue.getTaskCode()); + List positionCodePath = new ArrayList<>(); + positionCodePath.add(new PositionCodeData(agvQueue.getPositionCode1(), "05")); + positionCodePath.add(new PositionCodeData(agvQueue.getPositionCode2(), "05")); + genAgvSchedulingTaskRequest.setPositionCodePath(positionCodePath); + return genAgvSchedulingTask(genAgvSchedulingTaskRequest); + } + + + /** + * 生成agv队列----临时修改起终点 + * + * @param code1 起点 + * @param code2 终点 + * @param wmsTrayCode 容器码 托盘料箱码/容器码 + * @param wmsTaskNo mydojob 任务 + * @param wmsTaskType 1-入库 2-出库 3-agv搬运 * @return */ - public RequestLog finishMydoJobForResponseResult(Map param) { - return requestLogService.getRequestLogForResponseResult(WMS_TASK_FINISH, "任务完成上报", JSONUtil.toJsonStr(param)); + @Override + public AgvQueue createAgvQueue(String code1, String code2, String wmsTrayCode, String taskCode, String wmsTaskType, String traySize, String wmsTaskNo) { + //生成ctu执行队列 + AgvQueue agvQueue = new AgvQueue(); + String reqCode = IdUtil.fastSimpleUUID(); + agvQueue.setReqCode(reqCode); + agvQueue.setReqTime(DateUtil.formatDateTime(DateUtil.date())); + agvQueue.setAgvType("AGV"); + agvQueue.setPositionCode1(code1); + if("4".equals(traySize) && "L1001".equals(code2)){ + agvQueue.setPositionCode2("L1001-1"); + }else{ + agvQueue.setPositionCode2(code2); + } + + agvQueue.setTaskType("A22"); + agvQueue.setCtnrType("1"); + //rcslite开启托盘自动调整位置后 - 测试一巷道放货区分托盘类型 + if (traySize == "2" || traySize == "3") { + agvQueue.setCtnrType("3"); + }else{ + agvQueue.setCtnrType("1"); + } + + agvQueue.setCtnrCode(traySize); + agvQueue.setCtnrNum("0"); + agvQueue.setTaskMode("0"); + agvQueue.setPriority("10"); + agvQueue.setRequest("0"); + agvQueue.setWmsTraycode(wmsTrayCode); + agvQueue.setWmsTaskNo(wmsTaskNo); + agvQueue.setStatus("0"); + agvQueue.setTaskCode(taskCode); + agvQueue.setWmsTaskType(wmsTaskType); + agvQueueService.insertAgvQueue(agvQueue); + return agvQueue; + } + + + /** + * 取消AGV任务 + * + * @param cancelTaskRequest + * @return + */ + @Override + public CancelTaskResponse cancelTask(CancelTaskRequest cancelTaskRequest) { + RequestLog requestLog = requestLogService.getRequestLog(CANCEL_TASK_URL, "取消任务", JSONUtil.toJsonStr(cancelTaskRequest)); + return BeanUtil.toBean(requestLog.getResponseBody(), CancelTaskResponse.class); + } @@ -251,427 +786,4 @@ public class ApiServiceImpl implements IApiService { } - - - /** - * 异常重分（参数类型JobParam） - * @param jobParam - * @return - */ - @Override - public AjaxResult reAssign(JobParam jobParam) { - RequestLog requestLog = requestLogService.getRequestLog(RE_ASSIGN_URL, "重新分配货位", JSONUtil.toJsonStr(jobParam)); - if ("1".equals(requestLog.getIsSuccessful())){ - InterfaceReceive bean = JSONUtil.toBean(requestLog.getResponseBody(), InterfaceReceive.class); - MydoJob wmsMydoJob = BeanUtil.toBean(bean.getData(), MydoJob.class); - MydoJob mydoJob = mydoJobService.selectMydoJobByJobId(wmsMydoJob.getJobId()); - mydoJob.setCargoSpaceId(wmsMydoJob.getCargoSpaceId()); - mydoJobService.updateMydoJob(mydoJob); - return AjaxResult.success(); - } - return AjaxResult.error(); - } - - /** - * 异常重分（参数类型TaskExceptionRequest） - * @param taskExceptionRequest - * @return - */ - @Override - public AjaxResult reAssign(TaskExceptionRequest taskExceptionRequest) { - RequestLog requestLog = requestLogService.getRequestLogForResponseResult(WMS_TASK_EXCEPTION, "入库异常-重新分配货位", JSONUtil.toJsonStr(taskExceptionRequest)); - if ("1".equals(requestLog.getIsSuccessful())){ - //请求获取新分配的货位 - ResponseResult bean = JSONUtil.toBean(requestLog.getResponseBody(), ResponseResult.class); - TaskExceptionReceive taskExceptionReceive = BeanUtil.toBean(bean.getResult(), TaskExceptionReceive.class); - - //更新任务信息 - MydoJob mydoJob = mydoJobService.selectMydoJobByWmsTaskNo(taskExceptionReceive.getTaskCode()); - mydoJob.setCargoSpaceId(taskExceptionReceive.getSiteCode()); - mydoJobService.updateMydoJob(mydoJob); - return AjaxResult.success(taskExceptionReceive); - } - return AjaxResult.error(); - } - - /** - * 出库异常作废（参数类型jobParam） - * @param jobParam - * @return - */ - @Override - public AjaxResult reMaterial(JobParam jobParam) { - RequestLog requestLog = requestLogService.getRequestLog(RE_MATERIAL_URL, "重新分配物料", JSONUtil.toJsonStr(jobParam)); - if ("1".equals(requestLog.getIsSuccessful())){ - return AjaxResult.success(); - } - return AjaxResult.error(); - } - - /** - * 出库异常作废（参数类型TaskExceptionRequest） - * @param taskExceptionRequest - * @return - */ - @Override - public AjaxResult reMaterial(TaskExceptionRequest taskExceptionRequest) { - RequestLog requestLog = requestLogService.getRequestLogForResponseResult(WMS_TASK_EXCEPTION, "出库无货异常-任务作废", JSONUtil.toJsonStr(taskExceptionRequest)); - if ("1".equals(requestLog.getIsSuccessful())){ - return AjaxResult.success(); - } - return AjaxResult.error(); - } - - - - - /** - * 生成agv队列----临时修改起终点 - * - * @param code1 起点 - * @param code2 终点 - * @param wmsTrayCode 容器码 托盘料箱码/容器码 - * @param wmsTaskNo mydojob 任务 - * @param wmsTaskType 1-入库 2-出库 3-agv搬运 - * @return - */ - @Override - public AgvQueue createAgvQueue(String code1, String code2, String wmsTrayCode, String taskCode, String wmsTaskType, String traySize, String wmsTaskNo) { - //生成ctu执行队列 - AgvQueue agvQueue = new AgvQueue(); - String reqCode = IdUtil.fastSimpleUUID(); - agvQueue.setReqCode(reqCode); - agvQueue.setReqTime(DateUtil.formatDateTime(DateUtil.date())); - agvQueue.setAgvType("AGV"); - agvQueue.setPositionCode1(code1); - if("4".equals(traySize) && "L1001".equals(code2)){ - agvQueue.setPositionCode2("L1001-1"); - }else{ - agvQueue.setPositionCode2(code2); - } - - agvQueue.setTaskType("A22"); - agvQueue.setCtnrType("1"); - //rcslite开启托盘自动调整位置后 - 测试一巷道放货区分托盘类型 - if (traySize == "2" || traySize == "3") { - agvQueue.setCtnrType("3"); - }else{ - agvQueue.setCtnrType("1"); - } - - agvQueue.setCtnrCode(traySize); - agvQueue.setCtnrNum("0"); - agvQueue.setTaskMode("0"); - agvQueue.setPriority("10"); - agvQueue.setRequest("0"); - agvQueue.setWmsTraycode(wmsTrayCode); - agvQueue.setWmsTaskNo(wmsTaskNo); - agvQueue.setStatus("0"); - agvQueue.setTaskCode(taskCode); - agvQueue.setWmsTaskType(wmsTaskType); - agvQueueService.insertAgvQueue(agvQueue); - return agvQueue; - } - - - /** - * 取消AGV任务 - * - * @param cancelTaskRequest - * @return - */ - @Override - public CancelTaskResponse cancelTask(CancelTaskRequest cancelTaskRequest) { - RequestLog requestLog = requestLogService.getRequestLog(CANCEL_TASK_URL, "取消任务", JSONUtil.toJsonStr(cancelTaskRequest)); - return BeanUtil.toBean(requestLog.getResponseBody(), CancelTaskResponse.class); - - } - - - /** - * 继续agv任务 - * - * @param agvQueue - * @return - */ - @Override - public AjaxResult continueTask(AgvQueue agvQueue) { - ContinueTaskRequest continueTaskRequest = new ContinueTaskRequest(); - continueTaskRequest.setReqCode(IdUtil.fastSimpleUUID()); - continueTaskRequest.setReqTime(DateUtil.formatDateTime(DateUtil.date())); - continueTaskRequest.setTaskCode(agvQueue.getTaskCode()); - RequestLog requestLog = requestLogService.getRequestLog2(CONTINUE_TASK_URL, "继续执行任务", JSONUtil.toJsonStr(continueTaskRequest)); - if ("1".equals(requestLog.getIsSuccessful())) { - return AjaxResult.success(); - } else { - return AjaxResult.error(); - } - - } - - - /** - * 请求海康生成agv任务,并修改wms任务状态 - * - * @param agvQueue - */ - @Override - public GenAgvSchedulingTaskResponse requestAgvQueue(AgvQueue agvQueue) { - - GenAgvSchedulingTaskRequest genAgvSchedulingTaskRequest = new GenAgvSchedulingTaskRequest(); - genAgvSchedulingTaskRequest.setReqCode(agvQueue.getReqCode()); - genAgvSchedulingTaskRequest.setPriority("10"); - genAgvSchedulingTaskRequest.setTaskTyp(agvQueue.getTaskType()); - genAgvSchedulingTaskRequest.setCtnrTyp(agvQueue.getCtnrType()); - genAgvSchedulingTaskRequest.setCtnrCode(agvQueue.getCtnrCode()); - genAgvSchedulingTaskRequest.setTaskCode(agvQueue.getTaskCode()); - List positionCodePath = new ArrayList<>(); - positionCodePath.add(new PositionCodeData(agvQueue.getPositionCode1(), "05")); - positionCodePath.add(new PositionCodeData(agvQueue.getPositionCode2(), "05")); - genAgvSchedulingTaskRequest.setPositionCodePath(positionCodePath); - return genAgvSchedulingTask(genAgvSchedulingTaskRequest); - } - - - /** - * 请求wms获取入库任务参数 - * @param param - * @return - */ - @Override - public AjaxResult createInMydoJob(Map param) { - RequestLog requestLog = requestLogService.getRequestLog(WMS_STOCKIN_MYDOJOB, "入库请求生成作业", JSONUtil.toJsonStr(param)); - if ("1".equals(requestLog.getIsSuccessful())) { - InterfaceReceive bean = JSONUtil.toBean(requestLog.getResponseBody(), InterfaceReceive.class); - return AjaxResult.success(bean.getData()); - } else { - return AjaxResult.error(); - } - } - - - /** - * @@@ FT568 请求wms获取入库任务参数 - 适应wms的自定义请求响应格式 - * @param param - * @return - */ - @Override - public AjaxResult createMydoJobForStockin(Map param) { - RequestLog requestLog = requestLogService.getRequestLogForResponseResult(WMS_STOCKIN_MYDOJOB, "入库请求生成作业", JSONUtil.toJsonStr(param)); - if ("1".equals(requestLog.getIsSuccessful())) { - ResponseResult bean = JSONUtil.toBean(requestLog.getResponseBody(), ResponseResult.class); - return AjaxResult.success(bean.getResult()); - } else { - return AjaxResult.error(); - } - } - - /** - * @@@ FT568 入库请求作业异常反馈（扫码失败、外形、称重等异常） - * @param param - * @return - */ - @Override - public AjaxResult createInMydoJobException(Map param) { - RequestLog requestLog = requestLogService.getRequestLog(WMS_STOCKIN_MYDOJOB, "入库异常反馈", JSONUtil.toJsonStr(param)); - if ("1".equals(requestLog.getIsSuccessful())) { - InterfaceReceive bean = JSONUtil.toBean(requestLog.getResponseBody(), InterfaceReceive.class); - return AjaxResult.success(bean.getData()); - } else { - return AjaxResult.error(); - } - } - - - @Override - public AjaxResult receiveOutMydoJob(StockoutReceive stockoutReceive) { - - //生成接口记录 - RequestLog requestLog = requestLogService.getRequestLog(JSONUtil.toJsonStr(stockoutReceive), "推送出库作业"); - requestLog.setResponseBody(JSONUtil.toJsonStr(AjaxResult.success())); - requestLog.setResponseStatus("0"); - requestLog.setIsSuccessful("1"); - requestLogService.insertRequestLog(requestLog); - - // -------------------------检查推送的任务参数------------------------- - log.info( - "【wms推送出库】请求码:{}，wms任务号:{}，推送出库货位:{}，推送类型:{}",stockoutReceive.getReqCode(), stockoutReceive.getTaskCode(), stockoutReceive.getSiteCode(), stockoutReceive.getTaskTypeCode() - ); - - BasCargoSpace cargoSpace = basCargoSpaceService.selectBasCargoSpaceByCargoSpaceId(stockoutReceive.getSiteCode()); - - // 0.检查货位参数是否合法 - if(stockoutReceive.getSiteCode() == null || stockoutReceive.getSiteCode() == ""){ - log.info("【请求错误】wms推送出库任务失败，参数错误，推送任务号:{}，推送出库货位:{}", stockoutReceive.getTaskCode(), stockoutReceive.getSiteCode()); - return AjaxResult.error("【请求错误】wms推送出库任务失败，参数错误，推送任务号:{}" + stockoutReceive.getTaskCode() + "，推送出库货位:" + stockoutReceive.getSiteCode()); - }else{ - //排号检查 - if (cargoSpace.getThePlatoon() > 2 || cargoSpace.getThePlatoon() < 0){ - log.info("【请求错误】wms推送出库任务失败，参数错误，推送任务号:{}，推送排:{}", stockoutReceive.getTaskCode(), cargoSpace.getThePlatoon()); - return AjaxResult.error("【请求错误】wms推送出库任务失败，错误，推送任务号:" + stockoutReceive.getTaskCode() + "，推送出库排号:" + cargoSpace.getThePlatoon() + "，仓库中不存在该位置！"); - } - - //列号检查 - if (cargoSpace.getTheColumn() > 33 || cargoSpace.getTheColumn() < 0){ - log.info("【请求错误】wms推送出库任务失败，参数错误，推送任务号:{}，推送列:{}", stockoutReceive.getTaskCode(), cargoSpace.getTheColumn()); - return AjaxResult.error("【请求错误】wms推送出库任务失败，错误，推送任务号:" + stockoutReceive.getTaskCode() + "，推送出库列号:" + cargoSpace.getTheColumn() + "，仓库中不存在该位置！"); - } - - //层号检查 - if (cargoSpace.getTheFloor() > 6 || cargoSpace.getTheFloor() < 0){ - log.info("【请求错误】wms推送出库任务失败，参数错误，推送任务号:{}，推送层:{}", stockoutReceive.getTaskCode(), cargoSpace.getThePlatoon()); - return AjaxResult.error("【请求错误】wms推送出库任务失败，错误，推送任务号:" + stockoutReceive.getTaskCode() + "，推送出库层号:" + cargoSpace.getThePlatoon() + "，仓库中不存在该位置！"); - } - } - - // 1.wms推送的任务号是否重复 - MydoJob job = new MydoJob().builder().wmsTaskNo(stockoutReceive.getTaskCode()).build(); - List tasks = mydoJobService.selectMydoJobList(job); - if (tasks.size() != 0) { - log.info("【请求错误】wms下发出库任务失败，该任务已存在，推送任务号:{}，推送出库货位:{}", stockoutReceive.getTaskCode(), stockoutReceive.getSiteCode()); - return AjaxResult.error("【请求错误】wms下发出库任务失败，该任务已存在，推送任务号:{}" + stockoutReceive.getTaskCode() + "，推送出库货位:" + stockoutReceive.getSiteCode()); - } - - // 2.wms推送的出库货位是否已经有任务 - job = new MydoJob().builder().cargoSpaceId(stockoutReceive.getSiteCode()).build(); - tasks = mydoJobService.selectMydoJobList(job); - if (tasks.size() != 0) { - log.info("【请求错误】wms下发出库任务失败，已经存在该货位的出库任务，推送任务号:{}，推送出库货位:{}", stockoutReceive.getTaskCode(), stockoutReceive.getSiteCode()); - return AjaxResult.error("【请求错误】wms下发出库任务失败，已经存在该货位的出库任务，推送任务号:{}" + stockoutReceive.getTaskCode() + "，推送出库货位:" + stockoutReceive.getSiteCode()); - } - - //生成出库作业 - MydoJob mydoJob = new MydoJob(); - mydoJob.setJobId(mydoJobService.getJobId("CK")); - mydoJob.setTaskNo(mydoJobService.getTaskNo("3")); - mydoJob.setWmsTaskNo(stockoutReceive.getTaskCode()); - mydoJob.setCargoSpaceId(stockoutReceive.getSiteCode()); - mydoJob.setRoadwayId( - basCargoSpaceService.selectBasCargoSpaceByCargoSpaceId(stockoutReceive.getSiteCode()).getRoadwayId() - ); - mydoJob.setTraySize(GoodsType.TYPE_DEFAULT);//默认 - mydoJob.setExitId(CONV_STOCKOUT); - mydoJob.setInOrOut("2"); - mydoJob.setStatus("1"); - mydoJob.setPriority(Long.valueOf(10)); - //todo 可能需要查本地库存信息获取条码？ -// mydoJob.setTrayCode(receiveOutJob.getTrayCode()); - mydoJob.setCreateTime(DateUtils.getNowDate()); - mydoJob.setExecutionPhase(TASK_EP_CREATED); -// mydoJob.setTraySize(receiveOutJob.getDepartmentId()); - - if (mydoJobService.selectMydoJobByJobId(mydoJob.getJobId()) != null){ - log.info("【任务警告】生成作业失败，已存在的作业号:{}", mydoJob.getJobId() + "(此条可忽略)"); - return AjaxResult.error("【请求警告】生成作业失败，已存在的作业号:{}" + mydoJob.getJobId() + "(此条可忽略)"); - } - - int i = mydoJobService.insertMydoJob(mydoJob); -// boolean success = mydoJobService.saveOrUpdate(mydoJob); - if (i != 0) { - requestLog.setResponseStatus("1"); - requestLogService.updateRequestLog(requestLog); - return AjaxResult.success( - "【堆垛机出库】wms下发出库作业，下发任务号:" + stockoutReceive.getTaskCode() + "，出库货位:" + stockoutReceive.getSiteCode()); - }else{ - return AjaxResult.error(); - } - - } - - @Override - public AjaxResult receiveInMydoJob(ReceiveJob receiveInJob) { - return null; - } - - @Override - public AjaxResult selectMydoJobByTrayCodeAndEntranceId(HashMap paramMap) { - RequestLog requestLog = requestLogService.getRequestLog(REQUEST_ENTER_URL, "请求获取入库作业", JSONUtil.toJsonStr(paramMap)); - if ("1".equals(requestLog.getIsSuccessful())) { - InterfaceReceive bean = JSONUtil.toBean(requestLog.getResponseBody(), InterfaceReceive.class); - return AjaxResult.success(bean.getData()); - } else { - return AjaxResult.error(); - } - } -//todo 新增agv站点 - - /** - * AGV站点映射 - * @param agvQueue - * @return - */ - @Override - public AjaxResult deleteAgvTray(AgvQueue agvQueue) { - Map paramMap = new HashMap<>(); - paramMap.put("reqCode", IdUtil.fastSimpleUUID()); - paramMap.put("ctnrTyp", agvQueue.getCtnrType()); - paramMap.put("ctnrCode", agvQueue.getCtnrCode()); - - if("L1001".equals(agvQueue.getPositionCode2())){ - paramMap.put("stgBinCode", "JT000307001013"); - } - if("L1003".equals(agvQueue.getPositionCode2())){ - paramMap.put("stgBinCode", "JT000206001013"); - } - if("L1001-1".equals(agvQueue.getPositionCode2())){ - paramMap.put("stgBinCode", "JT000407001013"); - } -// paramMap.put("binName", agvQueue.getPositionCode2()); - paramMap.put("indBind", "0"); - - RequestLog requestLog = requestLogService.getRequestLog2(DELETE_BIN_URL, "AGV解绑容器", JSONUtil.toJsonStr(paramMap)); - if ("1".equals(requestLog.getIsSuccessful())) { - log.info("站点："+agvQueue.getPositionCode2()+"{}AGV容器解绑成功！"); - return AjaxResult.success(); - } else { - log.info("站点："+agvQueue.getPositionCode2()+"{}AGV容器解绑失败！"); - return AjaxResult.error(); - } - } - - @Override - public AjaxResult requestWmsSpace(MydoJob mydoJob) { - RequestLog requestLog = requestLogService.getRequestLog(REQUEST_IN_SPACE_URL, "入库请求分货位", JSONUtil.toJsonStr(mydoJob)); - if ("1".equals(requestLog.getIsSuccessful())) { - InterfaceReceive bean = JSONUtil.toBean(requestLog.getResponseBody(), InterfaceReceive.class); - return AjaxResult.success(bean.getData()); - } else { - return AjaxResult.error(); - } - } - - - @Override - public AjaxResult selectMydoJobByNoTrayCode(Map param) { - RequestLog requestLog = requestLogService.getRequestLog(REQUEST_MYDO_JOB_URL, "入库请求补码作业", JSONUtil.toJsonStr(param)); - if ("1".equals(requestLog.getIsSuccessful())) { - InterfaceReceive bean = JSONUtil.toBean(requestLog.getResponseBody(), InterfaceReceive.class); - return AjaxResult.success(bean.getData()); - } else { - return AjaxResult.error(); - } - } - - @Override - public AjaxResult selectWcsPort(WcsPort wcsPort) { - List wcsPorts = wcsPortService.selectWcsPortList(wcsPort); - return AjaxResult.success(wcsPorts); - } - - @Override - public AjaxResult updateWcsPort(WcsPort wcsPort) { - int i = wcsPortService.updateWcsPort(wcsPort); - if(i > 0){ - return AjaxResult.success(); - }else{ - return AjaxResult.error(); - } - } - -// @PostConstruct - void test() { - - } - - } diff --git a/ruoyi-admin/src/main/java/com/ruoyi/common/ConvType.java b/ruoyi-admin/src/main/java/com/ruoyi/common/ConvType.java index 782f95e..8548e86 100644 --- a/ruoyi-admin/src/main/java/com/ruoyi/common/ConvType.java +++ b/ruoyi-admin/src/main/java/com/ruoyi/common/ConvType.java @@ -3,17 +3,32 @@ package com.ruoyi.common; public class ConvType { /** - * 出库输送机（到位位置） + * 1#巷道出库输送机（出口到位位置） */ - public static final String CONV_STOCKOUT = "TD1001"; + public static final String ROADWAY1_EXIT = "L1008"; /** - * 入库输送机（到位位置） + * 1#巷道入库输送机（入口源位置） */ - public static final String CONV_STOCKIN = "G1004"; + public static final String ROADWAY1_ENTRANCE = "L1009"; /** - * 1#巷道口输送机（到位位置） + * 2#巷道输送口-2（双向输送机到位位置） */ - public static final String CONV_ROAD_1 = "L1001"; + public static final String ROADWAY2_PORTCONV_2 = "L1006"; + + /** + * 2#巷道输送口-1（双向输送机到位位置） + */ + public static final String ROADWAY2_PORTCONV_1 = "L1004"; + + /** + * 3#巷道出库输送机（出口到位位置） + */ + public static final String ROADWAY3_EXIT = "L1001"; + + /** + * 3#巷道入库输送机（入口源位置） + */ + public static final String ROADWAY3_ENTRANCE = "L1002"; } diff --git a/ruoyi-admin/src/main/java/com/ruoyi/common/GoodsType.java b/ruoyi-admin/src/main/java/com/ruoyi/common/GoodsType.java index afb47c4..e037370 100644 --- a/ruoyi-admin/src/main/java/com/ruoyi/common/GoodsType.java +++ b/ruoyi-admin/src/main/java/com/ruoyi/common/GoodsType.java @@ -18,5 +18,5 @@ public class GoodsType { /** * 高度2 */ - public static final String TYPE_HEIGHT_2 = "0"; + public static final String TYPE_HEIGHT_2 = "2"; } diff --git a/ruoyi-admin/src/main/java/com/ruoyi/common/TaskStatusCode.java b/ruoyi-admin/src/main/java/com/ruoyi/common/TaskStatusCode.java index 2170a75..6bc467c 100644 --- a/ruoyi-admin/src/main/java/com/ruoyi/common/TaskStatusCode.java +++ b/ruoyi-admin/src/main/java/com/ruoyi/common/TaskStatusCode.java @@ -30,12 +30,12 @@ public class TaskStatusCode { /** * 任务状态-手动完成 */ - public static final String TASK_STATUS_FINISH_MANUAL = "5"; + public static final String TASK_STATUS_FINISH_MANUAL = "4"; /** * 任务状态-作废 */ - public static final String TASK_STATUS_INVALID = "6"; + public static final String TASK_STATUS_INVALID = "5"; //>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 【执行阶段】 <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< @@ -57,7 +57,7 @@ public class TaskStatusCode { public static final String TASK_EP_AGV = "2"; /** - * 任务执行阶段 入口输送机 + * 任务执行阶段 入口输送机到位 */ public static final String TASK_EP_SSJ = "3"; @@ -72,24 +72,38 @@ public class TaskStatusCode { public static final String TASK_EP_DDJ = "5"; /** - * 任务执行阶段 堆垛机放货完成 + * 任务执行阶段 堆垛机入库放货完成 */ public static final String TASK_EP_DDJ_FINISH = "6"; /** - * 任务执行阶段 输送机出库到位-出库完成 + * 任务执行阶段 输送机出库输送机到位-出库完成 */ public static final String TASK_EP_SSJ_STOCKOUT_FINISH = "6"; /** - * 任务执行阶段 任务自动完成 + * 任务执行阶段 任务自动完成 （如果不想区分出入库完成可以直接统一使用【自动完成】） */ public static final String TASK_EP_FINISH = "6"; + /** + * 任务执行阶段 输送机出库到位-盘点出库阶段完成 + */ + public static final String TASK_EP_SSJ_INVENTORY_STOCKOUT_FINISH = "7"; + + /** + * 任务执行阶段 堆垛机入库放货完成-盘点回库阶段完成 + */ + public static final String TASK_EP_SSJ_INVENTORY_STOCKIN_FINISH = "8"; + + + + + /** * 任务执行阶段 任务超时-自动结束当前任务 */ - public static final String TASK_EP_DDJ_FINISH_TIMEOUT = "6_TIMEOUT_FINISH"; + public static final String TASK_EP_DDJ_FINISH_TIMEOUT = "TIMEOUT_FINISH"; /** * 入库异常 - 放货有货 @@ -106,10 +120,7 @@ public class TaskStatusCode { */ public static final String TASK_EXCEPTION_PUT_REASSIGN = "STOCKIN_FAULT_REASSIGN"; - /** - * 任务执行阶段 回传wms完成 - */ - public static final String TASK_EP_WMS_FINISH = "9"; + } diff --git a/ruoyi-admin/src/main/java/com/ruoyi/common/TaskType.java b/ruoyi-admin/src/main/java/com/ruoyi/common/TaskType.java index 84f0d71..77a6576 100644 --- a/ruoyi-admin/src/main/java/com/ruoyi/common/TaskType.java +++ b/ruoyi-admin/src/main/java/com/ruoyi/common/TaskType.java @@ -8,7 +8,28 @@ public class TaskType { /** * 默认类型 */ - public static final int STACKER_TYPE_DEFAULT = 0; + public static final int TASKTYPE_DEFAULT = 0; + public static final String TASKTYPE_DEFAULT_STR = "0"; + + /** + * 常规入库 + */ + public static final int TASKTYPE_STOCKIN = 1; + public static final String TASKTYPE_STOCKIN_STR = "1"; + + /** + * 常规出库 + */ + public static final int TASKTYPE_STOCKOUT = 2; + public static final String TASKTYPE_STOCKOUT_STR = "2"; + + /** + * 盘点出库 + */ + public static final int TASKTYPE_INVENTORY = 3; + public static final String TASKTYPE_INVENTORY_STR = "3"; + + /** * 1-二楼入出 diff --git a/ruoyi-admin/src/main/java/com/ruoyi/job/controller/MydoJobController.java b/ruoyi-admin/src/main/java/com/ruoyi/job/controller/MydoJobController.java index 660505f..2d10f8b 100644 --- a/ruoyi-admin/src/main/java/com/ruoyi/job/controller/MydoJobController.java +++ b/ruoyi-admin/src/main/java/com/ruoyi/job/controller/MydoJobController.java @@ -114,12 +114,23 @@ public class MydoJobController extends BaseController @PreAuthorize("@ss.hasAnyPermi('job:mydoJob:outhandFinish')") @Log(title = "出库手动完成", businessType = BusinessType.OTHER) - @RequestMapping("/outhandFinish") - public AjaxResult manualCompleted(@RequestParam("jobIds")String[] jobIds) + @RequestMapping("/manualCompleted") + public AjaxResult manualCompleted(@RequestParam String[] jobIds) { return mydoJobService.outhandFinish(jobIds); } + /** + * 取消作业 + */ + @PreAuthorize("@ss.hasPermi('job:mydoJob:remove')") + @Log(title = "手动取消作业", businessType = BusinessType.DELETE) + @DeleteMapping("/cancelMydoJob") + public AjaxResult cancelMydoJob(@RequestParam String[] jobIds) + { + return mydoJobService.cancelTask(jobIds); + } + @PreAuthorize("@ss.hasAnyPermi('job:mydoJob:resendTaskToEntrance')") @Log(title = "入口输送机重新下发", businessType = BusinessType.OTHER) @PutMapping("/resendTaskToEntrance") diff --git a/ruoyi-admin/src/main/java/com/ruoyi/job/domain/MydoJob.java b/ruoyi-admin/src/main/java/com/ruoyi/job/domain/MydoJob.java index ca18d28..f056780 100644 --- a/ruoyi-admin/src/main/java/com/ruoyi/job/domain/MydoJob.java +++ b/ruoyi-admin/src/main/java/com/ruoyi/job/domain/MydoJob.java @@ -1,5 +1,6 @@ package com.ruoyi.job.domain; +import com.baomidou.mybatisplus.annotation.TableField; import com.baomidou.mybatisplus.annotation.TableId; import com.baomidou.mybatisplus.annotation.TableName; import lombok.*; @@ -21,13 +22,14 @@ import java.util.List; @NoArgsConstructor @ToString @Builder -//@TableName("mydo_job_wcs") +@TableName("mydo_job_wcs") public class MydoJob extends BaseEntity { + @TableField(exist = false) private static final long serialVersionUID = 1L; /** 任务ID */ -// @TableId + @TableId private String jobId; /** 任务状态 */ diff --git a/ruoyi-admin/src/main/java/com/ruoyi/job/service/IMydoJobService.java b/ruoyi-admin/src/main/java/com/ruoyi/job/service/IMydoJobService.java index eaea0e5..d016a3d 100644 --- a/ruoyi-admin/src/main/java/com/ruoyi/job/service/IMydoJobService.java +++ b/ruoyi-admin/src/main/java/com/ruoyi/job/service/IMydoJobService.java @@ -90,7 +90,15 @@ public interface IMydoJobService AjaxResult outhandFinish(String[] jobIds); - AjaxResult ManuelTaskFinish(String taskNo); + AjaxResult manuallyCompeleteTask(String taskNo); + + AjaxResult manuallyCompeleteTask(String[] jobIds); + + AjaxResult cancelTask(String taskNo); + + AjaxResult cancelTask(String[] JobIds); + + AjaxResult compeleteTimeoutTask(String taskNo); List getInJobByEntranceId(String exitId); diff --git a/ruoyi-admin/src/main/java/com/ruoyi/job/service/impl/MydoJobServiceImpl.java b/ruoyi-admin/src/main/java/com/ruoyi/job/service/impl/MydoJobServiceImpl.java index a37f4d6..3c9f42e 100644 --- a/ruoyi-admin/src/main/java/com/ruoyi/job/service/impl/MydoJobServiceImpl.java +++ b/ruoyi-admin/src/main/java/com/ruoyi/job/service/impl/MydoJobServiceImpl.java @@ -24,6 +24,7 @@ import com.ruoyi.job.domain.MydoJob; import com.ruoyi.job.service.IMydoJobService; import static com.ruoyi.common.TaskStatusCode.TASK_STATUS_FINISH_MANUAL; +import static com.ruoyi.common.TaskStatusCode.TASK_STATUS_INVALID; import static com.ruoyi.common.WmsTaskTypeCode.*; /** @@ -105,16 +106,13 @@ public class MydoJobServiceImpl implements IMydoJobService @Override public int deleteMydoJobByJobIds(String[] jobIds) { + MydoJob mydojob; + for (String jobId : jobIds) { + mydojob = selectMydoJobByJobId(jobId); mydoJobMapper.insertHistory(jobId); - //当执行任务的【删除】操作时（特殊场景需要手动处理异常导致不需要入库时，此时不需要向回传异常） - // 此处顺便处理对应任务号生成的堆垛机执行队列，省去sql直接表中删记录的操作 - if (selectMydoJobByJobId(jobId) != null){ - String taskNo = selectMydoJobByJobId(jobId).getTaskNo(); - if (ddjDeviceExecutionQueueService.selectDdjDeviceExecutionQueueByTaskNo(taskNo) != null) { - ddjDeviceExecutionQueueService.deleteDdjDeviceExecutionQueueByTaskNo(taskNo); - } - } + mydojob.setStatus(TASK_STATUS_INVALID); + updateMydoJob(mydojob); } return mydoJobMapper.deleteMydoJobByJobIds(jobIds); @@ -150,14 +148,30 @@ public class MydoJobServiceImpl implements IMydoJobService throw new RuntimeException(map.get("v_result").toString()); } } - + + /** + * 任务自动完成 + * @param rwh + * @return + */ @Override public boolean taskFinish(Long rwh) { - MydoJob task = selectMydoJobByTaskNo(rwh); - insertHistory(task.getJobId()); - deleteMydoJobByJobId(task.getJobId()); - ddjDeviceExecutionQueueService.deleteDdjDeviceExecutionQueueByTaskNo(task.getTaskNo()); + MydoJob task = selectMydoJobByTaskNo(rwh); + + //插入历史表 + insertHistory(task.getJobId()); + + //删除执行中的作业 + deleteMydoJobByJobId(task.getJobId()); + + //移除“可能存在”的堆垛机队列 + DdjDeviceExecutionQueue queue = ddjDeviceExecutionQueueService.selectDdjDeviceExecutionQueueByTaskNo(task.getTaskNo()); + if (queue != null){ + ddjDeviceExecutionQueueService.deleteDdjDeviceExecutionQueueByTaskNo(task.getTaskNo()); + } + + //插入回传表 JobCallBack jobCallBack = new JobCallBack(); jobCallBack.setType(Integer.valueOf(task.getInOrOut()) < 20 ? "1" : "2"); jobCallBack.setMydoJobId(task.getJobId()); @@ -168,9 +182,13 @@ public class MydoJobServiceImpl implements IMydoJobService jobCallBack.setReqCode(UUID.randomUUID().toString().replace("-", "")); jobCallBack.setTaskCode(task.getWmsTaskNo()); jobCallBackService.insertJobCallBack(jobCallBack); + + log.info("【任务自动完成】生成历史记录，插入回传列表，作业号:{},wcs任务号:{}", task.getJobId(), rwh); + return true; } + @Override public boolean InvalidMydoJob(Long rwh, Integer id) { HashMap map = new HashMap<>(); @@ -187,21 +205,25 @@ public class MydoJobServiceImpl implements IMydoJobService } } + @Override public MydoJob selectMydoJobByExitList(List exitList ) { return mydoJobMapper.selectMydoJobByExitList(exitList); } + @Override public MydoJob selectMydoJobByExitList1(String exitId ,String roadwayId) { return mydoJobMapper.selectMydoJobByExitList1(exitId,roadwayId); } + @Override public void insertHistory(String jobId) { mydoJobMapper.insertHistory(jobId); } + @Override public List selectInOrOutMydoJobList(MydoJob mydoJob) { return mydoJobMapper.selectInOrOutMydoJobList(mydoJob); @@ -232,61 +254,43 @@ public class MydoJobServiceImpl implements IMydoJobService mydoJob.setStatus(TASK_STATUS_FINISH_MANUAL); updateMydoJob(mydoJob); - //插入历史表 - mydoJobMapper.insertHistory(jobId); - - JobCallBack jobCallBack = new JobCallBack(); - jobCallBack.setType(mydoJob.getInOrOut()); - jobCallBack.setTaskTypeCode(WMS_TASK_TYPE_FINISH);// wms自定义的任务类型 - jobCallBack.setMydoJobId(mydoJob.getJobId()); - jobCallBack.setStatus("0"); - jobCallBack.setTaskNo(Convert.toLong(mydoJob.getTaskNo())); - jobCallBack.setCreateTime(new Date()); - jobCallBack.setTaskCode(mydoJob.getWmsTaskNo()); - jobCallBack.setRetry(0); - - jobCallBack.setReqCode(UUID.randomUUID().toString()); - jobCallBackService.insertJobCallBack(jobCallBack); - - //移除实时任务 - - mydoJobMapper.deleteMydoJobByJobId(jobId); - - log.info("【人工操作】手动完成wcs任务，wcs任务号:{}，wms任务号:{}", mydoJob.getTaskNo(), mydoJob.getWmsTaskNo()); - - DdjDeviceExecutionQueue queue = ddjDeviceExecutionQueueService.selectDdjDeviceExecutionQueueByTaskNo(mydoJob.getTaskNo()); - - try { - if (queue != null) - { - DdjDeviceExecutionQueueFinish queueFinish = BeanUtil.copyProperties(queue, DdjDeviceExecutionQueueFinish.class); - - ddjDeviceExecutionQueueServiceFinishService.insertDdjDeviceExecutionQueueFinish(queueFinish); - - ddjDeviceExecutionQueueService.deleteDdjDeviceExecutionQueueByTaskNo(mydoJob.getTaskNo()); - - log.info("【人工操作】移除堆垛机队列，wcs任务号:{}", mydoJob.getTaskNo()); - } - } catch (Exception e) { - - } - } return AjaxResult.success("操作成功"); } + /** - * 手动处理指定【任务号】的作业 + * 手动完成指定【任务号】的作业 * @param taskNo * @return */ @Override - public AjaxResult ManuelTaskFinish(String taskNo) { + public AjaxResult manuallyCompeleteTask(String taskNo) { //获取所有符合【任务号】的作业 MydoJob mydoJob = mydoJobMapper.selectMydoJobByTaskNo(taskNo); - mydoJobMapper.insertHistory(mydoJob.getInOrOut()); + + if (mydoJob == null){ + return AjaxResult.error("无该任务号的执行作业,请确认该任务是否已经处理和进行其他操作"); + } + + //标记状态为【手动完成】插入历史表 + mydoJob.setStatus(TASK_STATUS_FINISH_MANUAL); + updateMydoJob(mydoJob); + mydoJobMapper.insertHistory(mydoJob.getJobId()); + + try { + //处理堆垛机执行队列和历史记录 + DdjDeviceExecutionQueue queue = ddjDeviceExecutionQueueService.selectDdjDeviceExecutionQueueByTaskNo(mydoJob.getTaskNo()); + if (queue != null){ + DdjDeviceExecutionQueueFinish queueFinish = BeanUtil.copyProperties(queue, DdjDeviceExecutionQueueFinish.class); + ddjDeviceExecutionQueueServiceFinishService.insertDdjDeviceExecutionQueueFinish(queueFinish); + } + } catch (Exception e) { + log.warn("【人工操作】手动完成操作失败:{}", e.getMessage()); + } + JobCallBack jobCallBack = new JobCallBack(); jobCallBack.setType(mydoJob.getInOrOut()); jobCallBack.setTaskTypeCode(WMS_TASK_TYPE_FINISH);// wms下发的任务类型 @@ -301,10 +305,179 @@ public class MydoJobServiceImpl implements IMydoJobService mydoJobMapper.deleteMydoJobByTaskNo(taskNo); + log.info("【任务手动完成】生成历史记录，插入回传列表，作业号:{},wcs任务号:{}", mydoJob.getJobId(), taskNo); return AjaxResult.success("操作成功"); } + /** + * 手动完成指定【任务号】的作业（数组类型参数） + * @param jobIds + * @return + */ + @Override + public AjaxResult manuallyCompeleteTask(String[] jobIds) { + + for (String jobId : jobIds) { + //获取所有符合【任务号】的作业 + MydoJob mydoJob = mydoJobMapper.selectMydoJobByJobId(jobId); + + if (mydoJob == null){ + return AjaxResult.error("无该任务号的执行作业,请确认该任务是否已经处理和进行其他操作"); + } + + //标记状态为【手动完成】插入历史表 + mydoJob.setStatus(TASK_STATUS_FINISH_MANUAL); + updateMydoJob(mydoJob); + mydoJobMapper.insertHistory(jobId); + + try { + //处理堆垛机执行队列和历史记录 + DdjDeviceExecutionQueue queue = ddjDeviceExecutionQueueService.selectDdjDeviceExecutionQueueByTaskNo(mydoJob.getTaskNo()); + if (queue != null){ + DdjDeviceExecutionQueueFinish queueFinish = BeanUtil.copyProperties(queue, DdjDeviceExecutionQueueFinish.class); + ddjDeviceExecutionQueueServiceFinishService.insertDdjDeviceExecutionQueueFinish(queueFinish); + } + } catch (Exception e) { + log.warn("【人工操作】手动完成操作失败:{}", e.getMessage()); + } + + JobCallBack jobCallBack = new JobCallBack(); + jobCallBack.setType(mydoJob.getInOrOut()); + jobCallBack.setTaskTypeCode(WMS_TASK_TYPE_FINISH);// wms下发的任务类型 + jobCallBack.setMydoJobId(jobId); + jobCallBack.setStatus("0"); + jobCallBack.setTaskNo(Convert.toLong(mydoJob.getTaskNo())); + jobCallBack.setCreateTime(new Date()); + jobCallBack.setTaskCode(mydoJob.getWmsTaskNo()); + jobCallBack.setRetry(0); + jobCallBack.setReqCode(UUID.randomUUID().toString()); + jobCallBackService.insertJobCallBack(jobCallBack); + + mydoJobMapper.deleteMydoJobByJobId(jobId); + + log.info("【任务手动完成】生成历史记录，插入回传列表，作业号:{},wcs任务号:{}", jobId, mydoJob.getTaskNo()); + } + + return AjaxResult.success("操作成功"); + } + + + /** + * 手动作废指定【任务号】的作业 + * @param taskNo + * @return + */ + @Override + public AjaxResult cancelTask(String taskNo) { + + //获取所有符合【任务号】的作业 + MydoJob mydoJob = mydoJobMapper.selectMydoJobByTaskNo(taskNo); + + if (mydoJob == null){ + return AjaxResult.error("无该任务号的执行作业,请确认该任务是否已经处理和进行其他操作"); + } + + //标记状态为【手动作废】插入历史表 + mydoJob.setStatus(TASK_STATUS_INVALID); + updateMydoJob(mydoJob); + mydoJobMapper.insertHistory(mydoJob.getJobId()); + + try { + //处理堆垛机执行队列和历史记录 + DdjDeviceExecutionQueue queue = ddjDeviceExecutionQueueService.selectDdjDeviceExecutionQueueByTaskNo(mydoJob.getTaskNo()); + if (queue != null){ + DdjDeviceExecutionQueueFinish queueFinish = BeanUtil.copyProperties(queue, DdjDeviceExecutionQueueFinish.class); + ddjDeviceExecutionQueueServiceFinishService.insertDdjDeviceExecutionQueueFinish(queueFinish); + } + } catch (Exception e) { + log.warn("【人工操作】手动作废操作失败:{}", e.getMessage()); + } + + JobCallBack jobCallBack = new JobCallBack(); + jobCallBack.setType(mydoJob.getInOrOut()); + jobCallBack.setTaskTypeCode(WMS_TASK_TYPE_FINISH);// wms下发的任务类型 + jobCallBack.setMydoJobId(mydoJob.getJobId()); + jobCallBack.setStatus("0"); + jobCallBack.setTaskNo(Convert.toLong(mydoJob.getTaskNo())); + jobCallBack.setCreateTime(new Date()); + jobCallBack.setTaskCode(mydoJob.getWmsTaskNo()); + jobCallBack.setRetry(0); + jobCallBack.setReqCode(UUID.randomUUID().toString()); + jobCallBackService.insertJobCallBack(jobCallBack); + + mydoJobMapper.deleteMydoJobByTaskNo(taskNo); + + log.info("【任务手动取消】生成历史记录，插入回传列表，作业号:{},wcs任务号:{}", mydoJob.getJobId(), taskNo); + + return AjaxResult.success("操作成功"); + } + + /** + * 手动作废指定【任务号】的作业（数组类型参数） + * @param JobIds + * @return + */ + @Override + public AjaxResult cancelTask(String[] JobIds) { + + for (String jobId : JobIds) { + //获取所有符合【任务号】的作业 + MydoJob mydoJob = mydoJobMapper.selectMydoJobByJobId(jobId); + + if (mydoJob == null){ + return AjaxResult.error("无该任务号的执行作业,请确认该任务是否已经处理和进行其他操作"); + } + + //标记状态为【手动作废】插入历史表 + mydoJob.setStatus(TASK_STATUS_INVALID); + updateMydoJob(mydoJob); + mydoJobMapper.insertHistory(jobId); + + try { + //处理堆垛机执行队列和历史记录 + DdjDeviceExecutionQueue queue = ddjDeviceExecutionQueueService.selectDdjDeviceExecutionQueueByTaskNo(mydoJob.getTaskNo()); + if (queue != null){ + DdjDeviceExecutionQueueFinish queueFinish = BeanUtil.copyProperties(queue, DdjDeviceExecutionQueueFinish.class); + ddjDeviceExecutionQueueServiceFinishService.insertDdjDeviceExecutionQueueFinish(queueFinish); + } + } catch (Exception e) { + log.warn("【人工操作】手动作废操作失败:{}", e.getMessage()); + } + + JobCallBack jobCallBack = new JobCallBack(); + jobCallBack.setType(mydoJob.getInOrOut()); + jobCallBack.setTaskTypeCode(WMS_TASK_TYPE_FINISH);// wms下发的任务类型 + jobCallBack.setMydoJobId(jobId); + jobCallBack.setStatus("0"); + jobCallBack.setTaskNo(Convert.toLong(mydoJob.getTaskNo())); + jobCallBack.setCreateTime(new Date()); + jobCallBack.setTaskCode(mydoJob.getWmsTaskNo()); + jobCallBack.setRetry(0); + jobCallBack.setReqCode(UUID.randomUUID().toString()); + jobCallBackService.insertJobCallBack(jobCallBack); + + mydoJobMapper.deleteMydoJobByJobId(jobId); + + log.info("【任务手动取消】生成历史记录，插入回传列表，作业号:{},wcs任务号:{}", jobId, mydoJob.getTaskNo()); + } + + return AjaxResult.success("操作成功"); + } + + + /** + * 遗留任务超时自动完成 + * @param taskNo + * @return + */ + @Override + public AjaxResult compeleteTimeoutTask(String taskNo) { + + //todo + return null; + } + @Override public List getInJobByEntranceId(String exitId) { @@ -341,6 +514,10 @@ public class MydoJobServiceImpl implements IMydoJobService return mydoJobMapper.selectJobByTaskNo(taskNo); } + + + + /** * 获取本地生成作业号 * @param type RK-入库 CK-出库 diff --git a/ruoyi-admin/src/main/java/com/ruoyi/queue/ddj/service/impl/DdjDeviceExecutionQueueFinishServiceImpl.java b/ruoyi-admin/src/main/java/com/ruoyi/queue/ddj/service/impl/DdjDeviceExecutionQueueFinishServiceImpl.java index e938964..80d515a 100644 --- a/ruoyi-admin/src/main/java/com/ruoyi/queue/ddj/service/impl/DdjDeviceExecutionQueueFinishServiceImpl.java +++ b/ruoyi-admin/src/main/java/com/ruoyi/queue/ddj/service/impl/DdjDeviceExecutionQueueFinishServiceImpl.java @@ -1,6 +1,9 @@ package com.ruoyi.queue.ddj.service.impl; import java.util.List; + +import com.ruoyi.queue.ddj.domain.DdjDeviceExecutionQueue; +import com.ruoyi.queue.ddj.service.IDdjDeviceExecutionQueueService; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Service; import com.ruoyi.queue.ddj.mapper.DdjDeviceExecutionQueueFinishMapper; @@ -19,6 +22,9 @@ public class DdjDeviceExecutionQueueFinishServiceImpl implements IDdjDeviceExecu @Autowired private DdjDeviceExecutionQueueFinishMapper ddjDeviceExecutionQueueFinishMapper; + @Autowired + private IDdjDeviceExecutionQueueService ddjDeviceExecutionQueueService; + /** * 查询堆垛机完成队列 * diff --git a/ruoyi-admin/src/main/java/com/ruoyi/schedule/ScheduleThread.java b/ruoyi-admin/src/main/java/com/ruoyi/schedule/ScheduleThread.java index 36ffb59..a6f525b 100644 --- a/ruoyi-admin/src/main/java/com/ruoyi/schedule/ScheduleThread.java +++ b/ruoyi-admin/src/main/java/com/ruoyi/schedule/ScheduleThread.java @@ -7,7 +7,6 @@ import com.ruoyi.device.ssj.domain.DeviceSsj; import com.ruoyi.device.ssj.service.IDeviceSsjService; import com.ruoyi.common.domain.PlcConnectInfo; import com.ruoyi.schedule.plcRead.ddj.PlcDdj1Read; -import com.ruoyi.schedule.plcRead.ddj.PlcDdj2Read; import com.ruoyi.schedule.plcRead.ssj.PlcSsjRead; import com.ruoyi.common.domain.CustomThread; import com.ruoyi.schedule.scheduleTask.ddj.DdjThread; diff --git a/ruoyi-admin/src/main/java/com/ruoyi/schedule/scheduleTask/TaskHandler.java b/ruoyi-admin/src/main/java/com/ruoyi/schedule/scheduleTask/TaskHandler.java index 12a0b48..6b4191f 100644 --- a/ruoyi-admin/src/main/java/com/ruoyi/schedule/scheduleTask/TaskHandler.java +++ b/ruoyi-admin/src/main/java/com/ruoyi/schedule/scheduleTask/TaskHandler.java @@ -2,6 +2,7 @@ package com.ruoyi.schedule.scheduleTask; import cn.hutool.core.bean.BeanUtil; import cn.hutool.core.lang.UUID; +import com.ruoyi.api.domain.wcs2wms.JobParam; import com.ruoyi.api.domain.wcs2wms.exception.TaskExceptionReceive; import com.ruoyi.api.domain.wcs2wms.exception.TaskExceptionRequest; import com.ruoyi.api.service.IApiService; @@ -44,14 +45,17 @@ public class TaskHandler { private IDdjDeviceExecutionQueueService ddjDeviceExecutionQueueService; - private static final int DEFAULTTIMEINTERVAL = 2000; + private static final int TIMEINTERVAL_DEFAULT = 2000; + private static final int TIMEINTERVAL_3000 = 3000; + private static final int TIMEINTERVAL_5000 = 5000; + private static final int TIMEINTERVAL_10000 = 10000; /** - * 处理未正常移除的【堆垛机执行完成】或【出库到位】的遗留任务 + * 【自动完成】 - 处理标记为自动完成的任务 */ -// @Scheduled(fixedDelay = 3000) - public void mydoJobHandler() { + @Scheduled(fixedDelay = TIMEINTERVAL_3000) + public void mydoJobAutoFinish() { //查询所有标记为【已完成】的任务 List jobs = mydoJobService.selectMydoJobList( new MydoJob().builder().executionPhase(TASK_EP_FINISH).build() @@ -64,10 +68,27 @@ public class TaskHandler { } + /** + * 【手动完成】 - 查询并处理标记为已经手动完成的任务 + */ + @Scheduled(fixedDelay = TIMEINTERVAL_3000) + public void manualFinishmydoJob() { + //查询所有标记为【已完成】的任务 + List jobs = mydoJobService.selectMydoJobList( + new MydoJob().builder().status(TASK_STATUS_FINISH_MANUAL).build() + ); + if (!jobs.isEmpty()) { + for (MydoJob job : jobs) { + mydoJobService.manuallyCompeleteTask(job.getTaskNo()); + } + } + } + + /** * 【手动作废】 - 查询并处理标记为已经作废的任务 */ - //@Scheduled(fixedDelay = 3000) + @Scheduled(fixedDelay = TIMEINTERVAL_3000) public void cancelMydoJob(){ List jobs = mydoJobService.selectMydoJobList( new MydoJob().builder().status(TASK_STATUS_INVALID).build() @@ -75,24 +96,24 @@ public class TaskHandler { if (!jobs.isEmpty()) { for (MydoJob job : jobs) { - mydoJobService.ManuelTaskFinish(job.getTaskNo()); + mydoJobService.cancelTask(job.getTaskNo()); } } } /** - * 【手动完成】 - 查询并处理标记为已经手动完成的任务 + * 【超时自动完成】 - 处理未正常移除的【堆垛机执行完成】或【出库到位】的遗留任务 */ - //@Scheduled(fixedDelay = 3000) - public void finishMydoJob(){ + @Scheduled(fixedDelay = TIMEINTERVAL_10000) + public void finishMydoJobTimeout(){ List jobs = mydoJobService.selectMydoJobList( - new MydoJob().builder().status(TASK_STATUS_FINISH_MANUAL).build() + new MydoJob().builder().status(TASK_EP_DDJ_FINISH_TIMEOUT).build() ); if (!jobs.isEmpty()) { for (MydoJob job : jobs) { - mydoJobService.ManuelTaskFinish(job.getTaskNo()); + mydoJobService.compeleteTimeoutTask(job.getTaskNo()); } } } @@ -101,16 +122,61 @@ public class TaskHandler { /** * 定时扫描未回传或回传异常的任务记录 */ - @Scheduled(fixedDelay = 3000) + @Scheduled(fixedDelay = TIMEINTERVAL_3000) public void jobCallBack() { jobCallBackService.jobCallBack(); } + /** + * 【出库异常】 - 【取货无货】处理方法 + */ + @Scheduled(fixedDelay = TIMEINTERVAL_DEFAULT) + public void stockoutExceptionHandler() { + List jobs = mydoJobService.selectMydoJobList( + new MydoJob().builder().executionPhase(TASK_EXCEPTION_PICK).build() + ); + + if (!jobs.isEmpty()) { + for (MydoJob job : jobs) { + //向wms返回异常信息 +// TaskExceptionRequest taskExceptionRequest = new TaskExceptionRequest(); +// taskExceptionRequest.setTaskClass(job.getInOrOut().substring(0, 1)); +// taskExceptionRequest.setType(String.valueOf(TASK_EXCEPTION_STOCKIN_OCCUPIED)); +// taskExceptionRequest.setTaskCode(String.valueOf(job.getWmsTaskNo())); +// taskExceptionRequest.setTaskTypeCode(WMS_TASK_TYPE_EXCEPTION);//todo 不知道填什么 +// taskExceptionRequest.setReqCode(UUID.randomUUID().toString().replace("-", "")); +// taskExceptionRequest.setAdverseCauses("取货位置空，盘点后作废该任务"); + + JobParam param = new JobParam(); + param.setJobId(job.getJobId()); + param.setTaskNo(job.getTaskNo()); + param.setTrayCode(job.getTrayCode()); + param.setCargoSpaceId(job.getCargoSpaceId()); + + AjaxResult ajaxResult = apiService.reMaterial(param); + + if (ajaxResult.isSuccess()){ + mydoJobService.InvalidMydoJob(Long.valueOf(job.getTaskNo()), Integer.valueOf(job.getRoadwayId())); + //清空/重置【取货无货】的出库异常货位库存信息 + basCargoSpaceService.resetCargoSpaceByStockoutException(job.getCargoSpaceId()); + + log.info("【出库异常】堆垛机取货时目标位置无货，当前任务已作废，异常货位:{}，任务号:{}", job.getCargoSpaceId(), job.getRoadwayId()); + }else{ + log.info("【出库异常】堆垛机取货时目标位置无货，异常上报请求失败，请咨询操作管理员，异常货位:{}，任务号:{}", job.getCargoSpaceId(), job.getRoadwayId()); + } + + } + } + + + } + + /** * 【入库异常-请求重分】 - 【放货有货】处理方法 */ - @Scheduled(fixedDelay = DEFAULTTIMEINTERVAL) + @Scheduled(fixedDelay = TIMEINTERVAL_DEFAULT) public void stockinExceptionHandler() { List jobs = mydoJobService.selectMydoJobList( new MydoJob().builder().executionPhase(TASK_EXCEPTION_PUT).build() @@ -120,15 +186,21 @@ public class TaskHandler { for (MydoJob job : jobs) { String oldCargo = job.getCargoSpaceId(); //上报异常 - 向wms请求重分接口 - TaskExceptionRequest taskExceptionRequest = new TaskExceptionRequest(); - taskExceptionRequest.setTaskClass(job.getInOrOut().substring(0, 1)); - taskExceptionRequest.setType(String.valueOf(TASK_EXCEPTION_STOCKIN_OCCUPIED)); - taskExceptionRequest.setTaskCode(job.getWmsTaskNo()); - taskExceptionRequest.setTaskTypeCode(WMS_TASK_TYPE_EXCEPTION);//wms自定义文本 - taskExceptionRequest.setReqCode(UUID.randomUUID().toString().replace("-", "")); - taskExceptionRequest.setAdverseCauses("当前位置已有货物，盘点后重新分配货位"); +// TaskExceptionRequest taskExceptionRequest = new TaskExceptionRequest(); +// taskExceptionRequest.setTaskClass(job.getInOrOut().substring(0, 1)); +// taskExceptionRequest.setType(String.valueOf(TASK_EXCEPTION_STOCKIN_OCCUPIED)); +// taskExceptionRequest.setTaskCode(job.getWmsTaskNo()); +// taskExceptionRequest.setTaskTypeCode(WMS_TASK_TYPE_EXCEPTION);//wms自定义文本 +// taskExceptionRequest.setReqCode(UUID.randomUUID().toString().replace("-", "")); +// taskExceptionRequest.setAdverseCauses("当前位置已有货物，盘点后重新分配货位"); - AjaxResult ajaxResult = apiService.reAssign(taskExceptionRequest); + JobParam param = new JobParam(); + param.setJobId(job.getJobId()); + param.setTaskNo(job.getTaskNo()); + param.setTrayCode(job.getTrayCode()); + param.setCargoSpaceId(job.getCargoSpaceId()); + + AjaxResult ajaxResult = apiService.reAssign(param); if (ajaxResult.isSuccess()){ //获取返回的任务号和新分配的货位 TaskExceptionReceive mydoJobReAssign = BeanUtil.toBean(ajaxResult.get("data"), TaskExceptionReceive.class); @@ -158,49 +230,10 @@ public class TaskHandler { } - /** - * 【出库异常】 - 【取货无货】处理方法 - */ - @Scheduled(fixedDelay = DEFAULTTIMEINTERVAL) - public void stockoutExceptionHandler() { - List jobs = mydoJobService.selectMydoJobList( - new MydoJob().builder().executionPhase(TASK_EXCEPTION_PICK).build() - ); - - if (!jobs.isEmpty()) { - for (MydoJob job : jobs) { - //向wms返回异常信息 - TaskExceptionRequest taskExceptionRequest = new TaskExceptionRequest(); - taskExceptionRequest.setTaskClass(job.getInOrOut().substring(0, 1)); - taskExceptionRequest.setType(String.valueOf(TASK_EXCEPTION_STOCKIN_OCCUPIED)); - taskExceptionRequest.setTaskCode(String.valueOf(job.getWmsTaskNo())); - taskExceptionRequest.setTaskTypeCode(WMS_TASK_TYPE_EXCEPTION);//todo 不知道填什么 - taskExceptionRequest.setReqCode(UUID.randomUUID().toString().replace("-", "")); - taskExceptionRequest.setAdverseCauses("取货位置空，盘点后作废该任务"); - - AjaxResult ajaxResult = apiService.reMaterial(taskExceptionRequest); - - if (ajaxResult.isSuccess()){ - mydoJobService.InvalidMydoJob(Long.valueOf(job.getTaskNo()), Integer.valueOf(job.getRoadwayId())); - //清空/重置【取货无货】的出库异常货位库存信息 - basCargoSpaceService.resetCargoSpaceByStockoutException(job.getCargoSpaceId()); - - log.info("【出库异常】堆垛机取货时目标位置无货，当前任务已作废，异常货位:{}，任务号:{}", job.getCargoSpaceId(), job.getRoadwayId()); - }else{ - log.info("【出库异常】堆垛机取货时目标位置无货，异常上报请求失败，请咨询操作管理员，异常货位:{}，任务号:{}", job.getCargoSpaceId(), job.getRoadwayId()); - } - - } - } - - - } - - /** * 【入库异常-重分完成】 - 堆垛机重新下发 */ - @Scheduled(fixedDelay = DEFAULTTIMEINTERVAL) + @Scheduled(fixedDelay = TIMEINTERVAL_DEFAULT) public void sendTaskForStacker(){ List jobs = mydoJobService.selectMydoJobList( new MydoJob().builder().executionPhase(TASK_EXCEPTION_PUT_REASSIGN).build() diff --git a/ruoyi-admin/src/main/java/com/ruoyi/schedule/scheduleTask/ddj/DdjThread.java b/ruoyi-admin/src/main/java/com/ruoyi/schedule/scheduleTask/ddj/DdjThread.java index ce7c49d..75f34fd 100644 --- a/ruoyi-admin/src/main/java/com/ruoyi/schedule/scheduleTask/ddj/DdjThread.java +++ b/ruoyi-admin/src/main/java/com/ruoyi/schedule/scheduleTask/ddj/DdjThread.java @@ -76,7 +76,7 @@ public class DdjThread implements Runnable { for (String ddjCode : ddjCodeList.get(type)) { try { if ("ddj1".equals(ddjCode)) { - ddjTask(PlcDdj1Read.deviceDdjMap.get(ddjCode)); +// ddjTask(PlcDdj1Read.deviceDdjMap.get(ddjCode)); } //PlcDdj2Read.deviceDdjMap.containsKey(ddjCode) // if ("ddj2".equals(ddjCode)) { diff --git a/ruoyi-admin/src/main/java/com/ruoyi/schedule/scheduleTask/ddj/DdjThread_1.java b/ruoyi-admin/src/main/java/com/ruoyi/schedule/scheduleTask/ddj/DdjThread_1.java new file mode 100644 index 0000000..41d500b --- /dev/null +++ b/ruoyi-admin/src/main/java/com/ruoyi/schedule/scheduleTask/ddj/DdjThread_1.java @@ -0,0 +1,335 @@ +package com.ruoyi.schedule.scheduleTask.ddj; + +import cn.hutool.core.collection.CollUtil; +import cn.hutool.core.convert.Convert; +import cn.hutool.core.date.DateUtil; +import cn.hutool.core.util.ObjUtil; +import com.ruoyi.api.service.IApiService; +import com.ruoyi.bas.cargospace.service.IBasCargoSpaceService; +import com.ruoyi.common.utils.spring.SpringUtils; +import com.ruoyi.device.ddj.domain.MsgDdj; +import com.ruoyi.job.domain.MydoJob; +import com.ruoyi.job.service.IMydoJobService; +import com.ruoyi.queue.ddj.domain.DdjDeviceExecutionQueue; +import com.ruoyi.queue.ddj.service.IDdjDeviceExecutionQueueFinishService; +import com.ruoyi.queue.ddj.service.IDdjDeviceExecutionQueueService; +import com.ruoyi.schedule.plcRead.ddj.PlcDdj1Read; +import com.ruoyi.schedule.plcRead.ddj.PlcDdj2Read; +import com.ruoyi.schedule.plcRead.util.Tools; +import lombok.extern.slf4j.Slf4j; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; + +import static com.ruoyi.common.TaskStatusCode.*; + + +@Slf4j +public class DdjThread_1 implements Runnable { + + public HashMap> ddjCodeList; + + private IApiService apiService; + private IDdjDeviceExecutionQueueService ddjDeviceExecutionQueueService; + private IDdjDeviceExecutionQueueFinishService ddjDeviceExecutionQueueFinishService; + private IMydoJobService mydoJobService; + private IBasCargoSpaceService basCargoSpaceService; + + + public boolean isRun = true; + + + public void init() { + //todo 获取设备编码列表 + ddjCodeList = new HashMap<>(); + ArrayList ddjCodes = new ArrayList<>(); + ddjCodes.add("ddj1"); +// ddjCodes.add("ddj2"); + ddjCodeList.put("ddj", ddjCodes); + + apiService = SpringUtils.getBean(IApiService.class); + ddjDeviceExecutionQueueService = SpringUtils.getBean(IDdjDeviceExecutionQueueService.class); + ddjDeviceExecutionQueueFinishService = SpringUtils.getBean(IDdjDeviceExecutionQueueFinishService.class); + basCargoSpaceService = SpringUtils.getBean(IBasCargoSpaceService.class); + mydoJobService = SpringUtils.getBean(IMydoJobService.class); + log.info("初始化服务 {}，{},{},{}", apiService, ddjDeviceExecutionQueueService, ddjDeviceExecutionQueueFinishService,mydoJobService); + } + + @Override + public void run() { + init(); + while (isRun) { + for (String type : ddjCodeList.keySet()) { + + if ("ddj".equals(type)) { + for (String ddjCode : ddjCodeList.get(type)) { + try { + if ("ddj1".equals(ddjCode)) { + ddjTask(PlcDdj1Read.deviceDdjMap.get(ddjCode)); + } + } catch (RuntimeException e) { + log.error(e.getMessage(), e); + } + + } + } + } + try { + Thread.sleep(3000); + } catch (InterruptedException e) { + throw new RuntimeException(e); + } + } + + } + + private void ddjTask(MsgDdj ddj) { + /* --------------------------------------【1 处理已经完成的作业】-------------------------------------- + 堆垛机线程进来后第一件事先进行堆垛机正执行任务的账务处理 + 以防存在漏处理，没处理的情况发生 + */ + + //非【联机自动】状态 + if (ddj.getCzfs() != 5) return; + + // 检查当前堆垛机参数 - 是否有执行中的作业 + // 1.联机自动【5】 2.设备状态【0】 3.执行阶段【0】【5】（无执行中的任务） + if (ddj.getSbzt() == 0 && (ddj.getJdbz() == 5 || ddj.getJdbz() == 0)) { + Long rwh = ddj.getRwh(); + + //完成作业 + MydoJob mydoJob = mydoJobService.selectMydoJobByTaskNo(rwh); + DdjDeviceExecutionQueue ddjDeviceExecutionQueue = ddjDeviceExecutionQueueService.selectDdjDeviceExecutionQueueByRwh(rwh,ddj.getId()); + + //满足上述条件(【有实时任务】且【存在堆垛机执行队列】)，表示该任务已完成-标记为已完成状态 + if (mydoJob != null && ddjDeviceExecutionQueue != null) { + + //标记为堆垛机执行完成 + mydoJob.setExecutionPhase(TASK_EP_DDJ_FINISH); + mydoJobService.updateMydoJob(mydoJob); + + //执行wms回传 - 方法在存储过程【proc_mydojob_finish】中 +// ddjTaskFinish(rwh, ddj.getId()); + log.info("【堆垛机执行】设备编号：" + ddj.getId() + " 执行完成，任务结束，任务号："+ddj.getRwh()); + } + } + + //-------------------------------------- 【2 更新执行阶段】 -------------------------------------- + + // 1.联机自动【5】 2.设备状态 - 运行中【1】 3.执行阶段【2】 + if (ddj.getSbzt() == 1 && ddj.getJdbz() == 2) { + + //根据堆垛机上任务号，修改任务执行阶段 + Long rwh = ddj.getRwh(); + DdjDeviceExecutionQueue ddjDeviceExecutionQueue = ddjDeviceExecutionQueueService.selectDdjDeviceExecutionQueueByRwh(rwh, ddj.getId()); + + if (ddjDeviceExecutionQueue != null && !"1".equals(ddjDeviceExecutionQueue.getSpare1())) { + //修改队列执行阶段 + ddjDeviceExecutionQueue.setRwzt(ddj.getJdbz()); + ddjDeviceExecutionQueue.setSpare1("1"); + ddjDeviceExecutionQueueService.updateDdjDeviceExecutionQueue(ddjDeviceExecutionQueue); + } + } + + /* -------------------------------------- 【3 放货有货，重新分配货位】-------------------------------------- */ +// ddj.setCzfs(5); +// ddj.setSbzt(1052); +// ddj.setYxxf(1); +// ddj.setJdbz(4); +// ddj.setRwh(85015L); + // 1.联机自动【5】 2.设备状态-放货有货【1052】 3.执行阶段【0】【5】（无执行中的任务） + if (ddj.getSbzt() == 1052 && ddj.getJdbz() < 5 && ddj.getYxxf() == 1) { + + // 判断堆垛机上任务是否已重分，若未重分，则调用接口，请求重分货位 + Long rwh = ddj.getRwh(); + + //查询正在执行中的【任务号】获取堆垛机队列 + MydoJob mydoJob = mydoJobService.selectMydoJobByTaskNo(rwh); + + if (mydoJob != null && mydoJob.getExecutionPhase() != TASK_EXCEPTION_PUT) { + DdjDeviceExecutionQueue ddjDeviceExecutionQueue = ddjDeviceExecutionQueueService.selectDdjDeviceExecutionQueueByRwh(rwh, ddj.getId()); + //更新异常类型【FaultFlag】-1 + if ("0".equals(mydoJob.getFaultFlag()) && "1".equals(ddjDeviceExecutionQueue.getSpare1())) { + mydoJob.setStatus("1"); + //把执行阶段标记为【入库放货有货】的异常 + mydoJob.setExecutionPhase(TASK_EXCEPTION_PUT); + mydoJobService.updateMydoJob(mydoJob); + log.info("【入库异常】堆垛机放货时目标位置有货，异常货位:{}，任务号:{}", mydoJob.getCargoSpaceId(), rwh); + } + + + } + } + + +// -------------------------------------- 4 取货无货，作废当前任务，重新分配单据 -------------------------------------- + + //测试数据 +// ddj.setCzfs(5); +// ddj.setSbzt(1053); +// ddj.setYxxf(1); +// ddj.setJdbz(3); +// ddj.setRwh(20021L); +// ddj.setId(1); + // 1.联机自动【5】 2.设备状态-取货无货【1053】 3.执行阶段【<5】（任务执行中） + if (ddj.getSbzt() == 1053 && ddj.getJdbz() < 5) { + Long rwh = ddj.getRwh(); + MydoJob mydoJob = mydoJobService.selectMydoJobByTaskNo(rwh); + + if (mydoJob != null && mydoJob.getExecutionPhase() != TASK_EXCEPTION_PICK) { + //把执行阶段标记为【出库取货无货】的异常 + mydoJob.setExecutionPhase(TASK_EXCEPTION_PICK); + mydoJobService.updateMydoJob(mydoJob); + log.info("【出库异常】堆垛机取货时目标位置无货，异常货位:{}，任务号:{}", mydoJob.getCargoSpaceId(), rwh); + } + + +// //无货异常处理 +// DdjDeviceExecutionQueue ddjDeviceExecutionQueue = ddjDeviceExecutionQueueService.selectDdjDeviceExecutionQueueByRwh(rwh,ddj.getId()); +// +// //找到对应任务 调用api接口 取货无货，重新分配单据 +// if (ObjUtil.isNotNull(ddjDeviceExecutionQueue)) { +// +// //向wms返回异常信息 +// TaskExceptionRequest taskExceptionRequest = new TaskExceptionRequest(); +// taskExceptionRequest.setTaskClass(mydoJob.getInOrOut().substring(0, 1)); +// taskExceptionRequest.setType(String.valueOf(TASK_EXCEPTION_STOCKIN_OCCUPIED)); +// taskExceptionRequest.setTaskCode(String.valueOf(mydoJob)); +// taskExceptionRequest.setTaskTypeCode(WMS_TASK_TYPE_EXCEPTION);//todo 不知道填什么 +// taskExceptionRequest.setReqCode(UUID.randomUUID().toString().replace("-", "")); +// taskExceptionRequest.setAdverseCauses("取货位置空，盘点后作废该任务"); +// +// AjaxResult ajaxResult = apiService.reMaterial(taskExceptionRequest); +// if (ajaxResult.isSuccess()) { +// //作废作业 +// InvalidMydoJob(rwh, ddj.getId()); +// +// //清空/重置【取货无货】的出库异常货位库存信息 +// basCargoSpaceService.resetCargoSpaceByStockoutException(mydoJob.getCargoSpaceId()); +// } +// } + } + +// -------------------------------------- 5 下发堆垛机任务 -------------------------------------- + + //重分货位后重下 + if (ddj.getYxxf() == 1 && ddj.getSbzt() == 1052) { + Long rwh = ddj.getRwh(); + + //查询执行中的作业 + MydoJob mydoJob = mydoJobService.selectMydoJobByTaskNo(rwh); + + //该任务存在且【FaultFlag】为 2-已重分完成 + if (ObjUtil.isNotNull(mydoJob) && "2".equals(mydoJob.getFaultFlag())) { + + //判断任务是否重分完成 + DdjDeviceExecutionQueue ddjDeviceExecutionQueue = ddjDeviceExecutionQueueService.selectDdjDeviceExecutionQueueByRwh(rwh,ddj.getId()); + if (ObjUtil.isNotNull(ddjDeviceExecutionQueue) && "0".equals(ddjDeviceExecutionQueue.getDdjxf())) { + + //重新下发堆垛机任务 + int i = issuedDDJTask(ddj.getId(), ddjDeviceExecutionQueue); + if (i == 1) { + //更新开始时间，修改ddjxf为已下发1 + ddjDeviceExecutionQueue.setXfsj(DateUtil.formatDateTime(DateUtil.date())); + ddjDeviceExecutionQueue.setDdjxf("1"); + ddjDeviceExecutionQueueService.updateDdjDeviceExecutionQueue(ddjDeviceExecutionQueue); + mydoJob.setFaultFlag("0"); + mydoJobService.updateMydoJob(mydoJob); + log.info("【入库异常】重分货位下发堆垛机任务成功，当前任务号:{}", rwh); + } else { + log.error("【入库异常】重分货位 - 下发堆垛机任务失败！！！！！！！"); + } + } + } + } + + //正常下发 + if (ddj.getYxxf() == 1 && ddj.getSbzt() == 0 ) { + //检查是否有正在执行的堆垛机队列 + Long rwh = ddj.getRwh(); + DdjDeviceExecutionQueue ddjDeviceExecutionQueueRunningParam = new DdjDeviceExecutionQueue(); + ddjDeviceExecutionQueueRunningParam.setDdjxf("1"); + //ddjDeviceExecutionQueueRunningParam.setSpare1("1"); + ddjDeviceExecutionQueueRunningParam.setDevId(ddj.getId()); + List ddjDeviceExecutionRunningQueues = ddjDeviceExecutionQueueService.selectDdjDeviceExecutionQueueList(ddjDeviceExecutionQueueRunningParam); + if (CollUtil.isNotEmpty(ddjDeviceExecutionRunningQueues)) { + log.error("【提示】堆垛机有正在执行的队列，任务号: {}，请检查该任务号的wcs作业是否已经手动处理" , ddjDeviceExecutionRunningQueues.get(0).getRwh()); + return; + } + + //对堆垛机执行队列中无已下发队列 + DdjDeviceExecutionQueue ddjDeviceExecutionQueueParam = new DdjDeviceExecutionQueue(); + ddjDeviceExecutionQueueParam.setDdjxf("0"); + ddjDeviceExecutionQueueParam.setDevId(ddj.getId()); + List ddjDeviceExecutionQueues = ddjDeviceExecutionQueueService.selectDdjDeviceExecutionQueueList(ddjDeviceExecutionQueueParam); + + //取堆垛机队列中，生成时间最早的执行队列下发 + if (CollUtil.isNotEmpty(ddjDeviceExecutionQueues)) { + DdjDeviceExecutionQueue ddjDeviceExecutionQueue = ddjDeviceExecutionQueues.get(0); + int i = issuedDDJTask(ddj.getId(), ddjDeviceExecutionQueue); + if (i == 1) { + //更新开始时间，修改ddjxf为已下发1 + ddjDeviceExecutionQueue.setXfsj(DateUtil.formatDateTime(DateUtil.date())); + ddjDeviceExecutionQueue.setDdjxf("1"); + ddjDeviceExecutionQueueService.updateDdjDeviceExecutionQueue(ddjDeviceExecutionQueue); + log.info("【堆垛机入库】下发任务成功，任务执行中, 任务号:{}", ddjDeviceExecutionQueue.getRwh()); + } else { + log.error("【堆垛机入库】执行异常, 堆垛机下发任务失败！"); + } + } + } + + } + + /** + * 作废作业 + * + * @param rwh 作业单号 + * @param id 作业单id + */ + private void InvalidMydoJob(Long rwh, Integer id) { + mydoJobService.InvalidMydoJob(rwh, id); + } + + /** + * 堆垛机任务完成 + * + * @param rwh 作业单号 + * @param id 作业单id + */ + private void ddjTaskFinish(Long rwh, Integer id) { + mydoJobService.ddjTaskFinish(rwh, id); + } + + + /** + * 给堆垛机下发任务 + * + * @param queue 堆垛机执行的队列 + */ + private int issuedDDJTask(Integer devId, DdjDeviceExecutionQueue queue) { + int taskNo = Convert.toInt(queue.getRwh()); + int yph = Convert.toInt(queue.getYph()); + int ylh = Convert.toInt(queue.getYlh()); + int ych = Convert.toInt(queue.getYch()); + int mbph = Convert.toInt(queue.getMbph()); + int mblh = Convert.toInt(queue.getMblh()); + int mbch = Convert.toInt(queue.getMbch()); + int mlfs = 5; + int xfwc = 1; + int hwlx = Convert.toInt(queue.getSpare1()); +// int hwlx = 0;//默认值 + int jym = Tools.getJYM(taskNo, yph, ylh, ych, mbph, mblh, mbch, mlfs, hwlx); + byte[] sendData = Tools.sendDataToDevice(taskNo, null, yph, ylh, ych, mbph, mblh, mbch, mlfs, hwlx, xfwc, jym); + if (devId==1){ + return PlcDdj1Read.WriteToDDJ("DB61.0", sendData); + }else { + return PlcDdj2Read.WriteToDDJ("DB61.0", sendData); + } + } + + + + +} diff --git a/ruoyi-admin/src/main/java/com/ruoyi/schedule/scheduleTask/ddj/DdjThread_2.java b/ruoyi-admin/src/main/java/com/ruoyi/schedule/scheduleTask/ddj/DdjThread_2.java new file mode 100644 index 0000000..1a4789c --- /dev/null +++ b/ruoyi-admin/src/main/java/com/ruoyi/schedule/scheduleTask/ddj/DdjThread_2.java @@ -0,0 +1,333 @@ +package com.ruoyi.schedule.scheduleTask.ddj; + +import cn.hutool.core.collection.CollUtil; +import cn.hutool.core.convert.Convert; +import cn.hutool.core.date.DateUtil; +import cn.hutool.core.util.ObjUtil; +import com.ruoyi.api.service.IApiService; +import com.ruoyi.bas.cargospace.service.IBasCargoSpaceService; +import com.ruoyi.common.utils.spring.SpringUtils; +import com.ruoyi.device.ddj.domain.MsgDdj; +import com.ruoyi.job.domain.MydoJob; +import com.ruoyi.job.service.IMydoJobService; +import com.ruoyi.queue.ddj.domain.DdjDeviceExecutionQueue; +import com.ruoyi.queue.ddj.service.IDdjDeviceExecutionQueueFinishService; +import com.ruoyi.queue.ddj.service.IDdjDeviceExecutionQueueService; +import com.ruoyi.schedule.plcRead.ddj.PlcDdj1Read; +import com.ruoyi.schedule.plcRead.ddj.PlcDdj2Read; +import com.ruoyi.schedule.plcRead.util.Tools; +import lombok.extern.slf4j.Slf4j; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; + +import static com.ruoyi.common.TaskStatusCode.*; + + +@Slf4j +public class DdjThread_2 implements Runnable { + + public HashMap> ddjCodeList; + + private IApiService apiService; + private IDdjDeviceExecutionQueueService ddjDeviceExecutionQueueService; + private IDdjDeviceExecutionQueueFinishService ddjDeviceExecutionQueueFinishService; + private IMydoJobService mydoJobService; + private IBasCargoSpaceService basCargoSpaceService; + + + public boolean isRun = true; + + + public void init() { + //todo 获取设备编码列表 + ddjCodeList = new HashMap<>(); + ArrayList ddjCodes = new ArrayList<>(); + ddjCodes.add("ddj2"); +// ddjCodes.add("ddj2"); + ddjCodeList.put("ddj", ddjCodes); + + apiService = SpringUtils.getBean(IApiService.class); + ddjDeviceExecutionQueueService = SpringUtils.getBean(IDdjDeviceExecutionQueueService.class); + ddjDeviceExecutionQueueFinishService = SpringUtils.getBean(IDdjDeviceExecutionQueueFinishService.class); + basCargoSpaceService = SpringUtils.getBean(IBasCargoSpaceService.class); + mydoJobService = SpringUtils.getBean(IMydoJobService.class); + log.info("初始化服务 {}，{},{},{}", apiService, ddjDeviceExecutionQueueService, ddjDeviceExecutionQueueFinishService,mydoJobService); + } + + @Override + public void run() { + init(); + while (isRun) { + for (String type : ddjCodeList.keySet()) { + + if ("ddj".equals(type)) { + for (String ddjCode : ddjCodeList.get(type)) { + try { + if ("ddj2".equals(ddjCode)) { + ddjTask(PlcDdj1Read.deviceDdjMap.get(ddjCode)); + } + } catch (RuntimeException e) { + log.error(e.getMessage(), e); + } + + } + } + } + try { + Thread.sleep(3000); + } catch (InterruptedException e) { + throw new RuntimeException(e); + } + } + + } + + private void ddjTask(MsgDdj ddj) { + /* --------------------------------------【1 处理已经完成的作业】-------------------------------------- + 堆垛机线程进来后第一件事先进行堆垛机正执行任务的账务处理 + 以防存在漏处理，没处理的情况发生 + */ + + //非【联机自动】状态 + if (ddj.getCzfs() != 5) return; + + // 检查当前堆垛机参数 - 是否有执行中的作业 + // 1.联机自动【5】 2.设备状态【0】 3.执行阶段【0】【5】（无执行中的任务） + if (ddj.getSbzt() == 0 && (ddj.getJdbz() == 5 || ddj.getJdbz() == 0)) { + Long rwh = ddj.getRwh(); + + //完成作业 + MydoJob mydoJob = mydoJobService.selectMydoJobByTaskNo(rwh); + DdjDeviceExecutionQueue ddjDeviceExecutionQueue = ddjDeviceExecutionQueueService.selectDdjDeviceExecutionQueueByRwh(rwh,ddj.getId()); + + //满足上述条件(【有实时任务】且【存在堆垛机执行队列】)，表示该任务已完成-执行任务回传 + if (mydoJob != null && ddjDeviceExecutionQueue != null) { + //标记为堆垛机执行完成 + mydoJob.setExecutionPhase(TASK_EP_DDJ_FINISH); + mydoJobService.updateMydoJob(mydoJob); + //回传完成信号 - 方法在存储过程【proc_mydojob_finish】中 +// ddjTaskFinish(rwh, ddj.getId()); + log.info("【堆垛机入库】堆垛机编号：" + ddj.getId() + " 执行完成，任务结束，任务号："+ddj.getRwh()); + } + } + + //-------------------------------------- 【2 更新执行阶段】 -------------------------------------- + + // 1.联机自动【5】 2.设备状态 - 运行中【1】 3.执行阶段【2】 + if (ddj.getSbzt() == 1 && ddj.getJdbz() == 2) { + + //根据堆垛机上任务号，修改任务执行阶段 + Long rwh = ddj.getRwh(); + DdjDeviceExecutionQueue ddjDeviceExecutionQueue = ddjDeviceExecutionQueueService.selectDdjDeviceExecutionQueueByRwh(rwh, ddj.getId()); + + if (ddjDeviceExecutionQueue != null && !"1".equals(ddjDeviceExecutionQueue.getSpare1())) { + //修改队列执行阶段 + ddjDeviceExecutionQueue.setRwzt(ddj.getJdbz()); + ddjDeviceExecutionQueue.setSpare1("1"); + ddjDeviceExecutionQueueService.updateDdjDeviceExecutionQueue(ddjDeviceExecutionQueue); + } + } + + /* -------------------------------------- 【3 放货有货，重新分配货位】-------------------------------------- */ +// ddj.setCzfs(5); +// ddj.setSbzt(1052); +// ddj.setYxxf(1); +// ddj.setJdbz(4); +// ddj.setRwh(85015L); + // 1.联机自动【5】 2.设备状态-放货有货【1052】 3.执行阶段【0】【5】（无执行中的任务） + if (ddj.getSbzt() == 1052 && ddj.getJdbz() < 5 && ddj.getYxxf() == 1) { + + // 判断堆垛机上任务是否已重分，若未重分，则调用接口，请求重分货位 + Long rwh = ddj.getRwh(); + + //查询正在执行中的【任务号】获取堆垛机队列 + MydoJob mydoJob = mydoJobService.selectMydoJobByTaskNo(rwh); + + if (mydoJob != null && mydoJob.getExecutionPhase() != TASK_EXCEPTION_PUT) { + DdjDeviceExecutionQueue ddjDeviceExecutionQueue = ddjDeviceExecutionQueueService.selectDdjDeviceExecutionQueueByRwh(rwh, ddj.getId()); + //更新异常类型【FaultFlag】-1 + if ("0".equals(mydoJob.getFaultFlag()) && "1".equals(ddjDeviceExecutionQueue.getSpare1())) { + mydoJob.setStatus("1"); + //把执行阶段标记为【入库放货有货】的异常 + mydoJob.setExecutionPhase(TASK_EXCEPTION_PUT); + mydoJobService.updateMydoJob(mydoJob); + log.info("【入库异常】堆垛机放货时目标位置有货，异常货位:{}，任务号:{}", mydoJob.getCargoSpaceId(), rwh); + } + + + } + } + + +// -------------------------------------- 4 取货无货，作废当前任务，重新分配单据 -------------------------------------- + + //测试数据 +// ddj.setCzfs(5); +// ddj.setSbzt(1053); +// ddj.setYxxf(1); +// ddj.setJdbz(3); +// ddj.setRwh(20021L); +// ddj.setId(1); + // 1.联机自动【5】 2.设备状态-取货无货【1053】 3.执行阶段【<5】（任务执行中） + if (ddj.getSbzt() == 1053 && ddj.getJdbz() < 5) { + Long rwh = ddj.getRwh(); + MydoJob mydoJob = mydoJobService.selectMydoJobByTaskNo(rwh); + + if (mydoJob != null && mydoJob.getExecutionPhase() != TASK_EXCEPTION_PICK) { + //把执行阶段标记为【出库取货无货】的异常 + mydoJob.setExecutionPhase(TASK_EXCEPTION_PICK); + mydoJobService.updateMydoJob(mydoJob); + log.info("【出库异常】堆垛机取货时目标位置无货，异常货位:{}，任务号:{}", mydoJob.getCargoSpaceId(), rwh); + } + + +// //无货异常处理 +// DdjDeviceExecutionQueue ddjDeviceExecutionQueue = ddjDeviceExecutionQueueService.selectDdjDeviceExecutionQueueByRwh(rwh,ddj.getId()); +// +// //找到对应任务 调用api接口 取货无货，重新分配单据 +// if (ObjUtil.isNotNull(ddjDeviceExecutionQueue)) { +// +// //向wms返回异常信息 +// TaskExceptionRequest taskExceptionRequest = new TaskExceptionRequest(); +// taskExceptionRequest.setTaskClass(mydoJob.getInOrOut().substring(0, 1)); +// taskExceptionRequest.setType(String.valueOf(TASK_EXCEPTION_STOCKIN_OCCUPIED)); +// taskExceptionRequest.setTaskCode(String.valueOf(mydoJob)); +// taskExceptionRequest.setTaskTypeCode(WMS_TASK_TYPE_EXCEPTION);//todo 不知道填什么 +// taskExceptionRequest.setReqCode(UUID.randomUUID().toString().replace("-", "")); +// taskExceptionRequest.setAdverseCauses("取货位置空，盘点后作废该任务"); +// +// AjaxResult ajaxResult = apiService.reMaterial(taskExceptionRequest); +// if (ajaxResult.isSuccess()) { +// //作废作业 +// InvalidMydoJob(rwh, ddj.getId()); +// +// //清空/重置【取货无货】的出库异常货位库存信息 +// basCargoSpaceService.resetCargoSpaceByStockoutException(mydoJob.getCargoSpaceId()); +// } +// } + } + +// -------------------------------------- 5 下发堆垛机任务 -------------------------------------- + + //重分货位后重下 + if (ddj.getYxxf() == 1 && ddj.getSbzt() == 1052) { + Long rwh = ddj.getRwh(); + + //查询执行中的作业 + MydoJob mydoJob = mydoJobService.selectMydoJobByTaskNo(rwh); + + //该任务存在且【FaultFlag】为 2-已重分完成 + if (ObjUtil.isNotNull(mydoJob) && "2".equals(mydoJob.getFaultFlag())) { + + //判断任务是否重分完成 + DdjDeviceExecutionQueue ddjDeviceExecutionQueue = ddjDeviceExecutionQueueService.selectDdjDeviceExecutionQueueByRwh(rwh,ddj.getId()); + if (ObjUtil.isNotNull(ddjDeviceExecutionQueue) && "0".equals(ddjDeviceExecutionQueue.getDdjxf())) { + + //重新下发堆垛机任务 + int i = issuedDDJTask(ddj.getId(), ddjDeviceExecutionQueue); + if (i == 1) { + //更新开始时间，修改ddjxf为已下发1 + ddjDeviceExecutionQueue.setXfsj(DateUtil.formatDateTime(DateUtil.date())); + ddjDeviceExecutionQueue.setDdjxf("1"); + ddjDeviceExecutionQueueService.updateDdjDeviceExecutionQueue(ddjDeviceExecutionQueue); + mydoJob.setFaultFlag("0"); + mydoJobService.updateMydoJob(mydoJob); + log.info("【入库异常】重分货位下发堆垛机任务成功，当前任务号:{}", rwh); + } else { + log.error("【入库异常】重分货位 - 下发堆垛机任务失败！！！！！！！"); + } + } + } + } + + //正常下发 + if (ddj.getYxxf() == 1 && ddj.getSbzt() == 0 ) { + //检查是否有正在执行的堆垛机队列 + Long rwh = ddj.getRwh(); + DdjDeviceExecutionQueue ddjDeviceExecutionQueueRunningParam = new DdjDeviceExecutionQueue(); + ddjDeviceExecutionQueueRunningParam.setDdjxf("1"); + //ddjDeviceExecutionQueueRunningParam.setSpare1("1"); + ddjDeviceExecutionQueueRunningParam.setDevId(ddj.getId()); + List ddjDeviceExecutionRunningQueues = ddjDeviceExecutionQueueService.selectDdjDeviceExecutionQueueList(ddjDeviceExecutionQueueRunningParam); + if (CollUtil.isNotEmpty(ddjDeviceExecutionRunningQueues)) { + log.error("【提示】堆垛机有正在执行的队列，任务号: {}，请检查该任务号的wcs作业是否已经手动处理" , ddjDeviceExecutionRunningQueues.get(0).getRwh()); + return; + } + + //对堆垛机执行队列中无已下发队列 + DdjDeviceExecutionQueue ddjDeviceExecutionQueueParam = new DdjDeviceExecutionQueue(); + ddjDeviceExecutionQueueParam.setDdjxf("0"); + ddjDeviceExecutionQueueParam.setDevId(ddj.getId()); + List ddjDeviceExecutionQueues = ddjDeviceExecutionQueueService.selectDdjDeviceExecutionQueueList(ddjDeviceExecutionQueueParam); + + //取堆垛机队列中，生成时间最早的执行队列下发 + if (CollUtil.isNotEmpty(ddjDeviceExecutionQueues)) { + DdjDeviceExecutionQueue ddjDeviceExecutionQueue = ddjDeviceExecutionQueues.get(0); + int i = issuedDDJTask(ddj.getId(), ddjDeviceExecutionQueue); + if (i == 1) { + //更新开始时间，修改ddjxf为已下发1 + ddjDeviceExecutionQueue.setXfsj(DateUtil.formatDateTime(DateUtil.date())); + ddjDeviceExecutionQueue.setDdjxf("1"); + ddjDeviceExecutionQueueService.updateDdjDeviceExecutionQueue(ddjDeviceExecutionQueue); + log.info("【堆垛机入库】下发任务成功，任务执行中, 任务号:{}", ddjDeviceExecutionQueue.getRwh()); + } else { + log.error("【堆垛机入库】执行异常, 堆垛机下发任务失败！"); + } + } + } + + } + + /** + * 作废作业 + * + * @param rwh 作业单号 + * @param id 作业单id + */ + private void InvalidMydoJob(Long rwh, Integer id) { + mydoJobService.InvalidMydoJob(rwh, id); + } + + /** + * 堆垛机任务完成 + * + * @param rwh 作业单号 + * @param id 作业单id + */ + private void ddjTaskFinish(Long rwh, Integer id) { + mydoJobService.ddjTaskFinish(rwh, id); + } + + + /** + * 给堆垛机下发任务 + * + * @param queue 堆垛机执行的队列 + */ + private int issuedDDJTask(Integer devId, DdjDeviceExecutionQueue queue) { + int taskNo = Convert.toInt(queue.getRwh()); + int yph = Convert.toInt(queue.getYph()); + int ylh = Convert.toInt(queue.getYlh()); + int ych = Convert.toInt(queue.getYch()); + int mbph = Convert.toInt(queue.getMbph()); + int mblh = Convert.toInt(queue.getMblh()); + int mbch = Convert.toInt(queue.getMbch()); + int mlfs = 5; + int xfwc = 1; + int hwlx = Convert.toInt(queue.getSpare1()); +// int hwlx = 0;//默认值 + int jym = Tools.getJYM(taskNo, yph, ylh, ych, mbph, mblh, mbch, mlfs, hwlx); + byte[] sendData = Tools.sendDataToDevice(taskNo, null, yph, ylh, ych, mbph, mblh, mbch, mlfs, hwlx, xfwc, jym); + if (devId==1){ + return PlcDdj1Read.WriteToDDJ("DB61.0", sendData); + }else { + return PlcDdj2Read.WriteToDDJ("DB61.0", sendData); + } + } + + + + +} diff --git a/ruoyi-admin/src/main/java/com/ruoyi/schedule/scheduleTask/ssj/PortConvThread.java b/ruoyi-admin/src/main/java/com/ruoyi/schedule/scheduleTask/ssj/PortConvThread.java index 849a4f1..9f7a597 100644 --- a/ruoyi-admin/src/main/java/com/ruoyi/schedule/scheduleTask/ssj/PortConvThread.java +++ b/ruoyi-admin/src/main/java/com/ruoyi/schedule/scheduleTask/ssj/PortConvThread.java @@ -32,6 +32,7 @@ import java.util.regex.Matcher; import java.util.regex.Pattern; import static com.ruoyi.common.TaskStatusCode.*; +import static com.ruoyi.common.TaskType.*; import static com.ruoyi.common.WmsTaskTypeCode.WMS_TASK_TYPE_STOCKIN; import static com.ruoyi.schedule.plcRead.ssj.PlcSsjRead.writeToSsj; @@ -58,8 +59,8 @@ public class PortConvThread implements Runnable { public void init() { ssjCodeList = new HashMap<>(); ArrayList ssjCodes = new ArrayList<>(); - ssjCodes.add("G1004"); - ssjCodes.add("TD1001"); + ssjCodes.add("L1008"); + ssjCodes.add("L1009"); ssjCodeList.put("portConv", ssjCodes); apiService = SpringUtils.getBean(IApiService.class); // agvQueueService = SpringUtils.getBean(IAgvQueueService.class); @@ -81,13 +82,7 @@ public class PortConvThread implements Runnable { for (String ssjCode : ssjCodeList.get(type)) { try { if (PlcSsjRead.deviceSsjMap.containsKey(ssjCode)) { - if (ssjCode == "G1004"){ - inDispatch(PlcSsjRead.deviceSsjMap.get(ssjCode)); - } - if (ssjCode == "TD1001"){ - outDispatch(PlcSsjRead.deviceSsjMap.get(ssjCode)); - } - + Schedule(PlcSsjRead.deviceSsjMap.get(ssjCode)); } else { log.error("设备不存在 ssjCode:{}", ssjCode); } @@ -100,7 +95,7 @@ public class PortConvThread implements Runnable { } } try { - Thread.sleep(3000); + Thread.sleep(1500); } catch (InterruptedException e) { throw new RuntimeException(e); } @@ -108,9 +103,14 @@ public class PortConvThread implements Runnable { } + public void Schedule(DeviceSsj deviceSsj){ - public void inDispatch(DeviceSsj inSsjDevice) { - // 测试数据 + switch (deviceSsj.getDeviceCode()){ + //1#巷道入库（单向） + case "L1009": + //3#巷道入库（单向） + case "L1002": + // 测试数据 // inSsjDevice.setInOrOut(1); // inSsjDevice.setTrayCode("T000004503"); // inSsjDevice.setTaskNo(777778); @@ -121,22 +121,53 @@ public class PortConvThread implements Runnable { // inSsjDevice.setException(0); // inSsjDevice.setRkqq(1); - //输送机状态 - if (!convChecked(inSsjDevice)) return; - //更新入库任务阶段 - updateMydoJob(inSsjDevice); - //请求wms获取入库任务 - requestMydoJob(inSsjDevice); + //到位校验 + if (!portConvChecked(deviceSsj)) return; + //更新入库任务阶段 + updateMydoJob(deviceSsj); + + //请求wms获取入库任务 + //requestMydoJob(deviceSsj); + break; + + //1#巷道出库口（单向） + case "L1008": + //3#巷道出库口（单向） + case "L1001": + //出库完成 + finishStockoutMydoJob(deviceSsj); + //盘点出库 + finishInventoryStockoutMydoJob(deviceSsj); + break; + + //2#巷道出库口（双向） + case "L1004": + //2#巷道出库口（双向） + case "L1006": + + //更新入库任务阶段 + updateMydoJob(deviceSsj); + + //出库完成 + finishStockoutMydoJob(deviceSsj); + + //盘点出库 + finishInventoryStockoutMydoJob(deviceSsj); + break; + + + } } + /** * 输送机到位判断校验 * @param inSsjDevice * @return */ - private boolean convChecked(DeviceSsj inSsjDevice){ + private boolean portConvChecked(DeviceSsj inSsjDevice){ boolean flag = false; //---------------------------入口取输送机（叉车取放货位置）--------------------------- @@ -165,19 +196,9 @@ public class PortConvThread implements Runnable { ).size(); if (count > 0) { - //如果查到输送机有已经该条码的入库作业 - 把该作业更新为初始状态（未向入库输送机下发任务号的阶段） - // 省去入库输送机口的手动作废操作，自动更新任务至初始阶段 -// mydoJobService.updateMydoJob( -// new MydoJob().builder() -// .status("1") -// .executionPhase("0") -// .build() -// ); return; } - - String errorMessage = ""; AjaxResult ajaxResult; @@ -257,22 +278,27 @@ public class PortConvThread implements Runnable { } } + /** * 更新入库任务阶段 * @param inSsjDevice */ private void updateMydoJob(DeviceSsj inSsjDevice){ + //-------------------------------------------常规入库------------------------------------------- //检查是否有已经创建成功的任务(请求成功的入库任务) - 更新到下一个执行阶段 MydoJob mydoJobStockin = new MydoJob().builder() .trayCode(inSsjDevice.getTrayCode()) .status(TASK_STATUS_CREATED) .executionPhase(TASK_EP_CREATED) + .entranceId(inSsjDevice.getDeviceCode()) .build(); if(!mydoJobService.selectMydoJobList(mydoJobStockin).isEmpty()){ - mydoJobStockin = mydoJobService.selectMydoJobList(mydoJobStockin).get(0); + //如果已经生成入库任务 - 向输送机下发任务号 - //输送去向值【1】 + mydoJobStockin = mydoJobService.selectMydoJobList(mydoJobStockin).get(0); + + //输送机去向值【1】 int i = writeToSsj(inSsjDevice.getPlcDbWriteAddress(), mydoJobStockin.getTaskNo(), 1, 1); // int i = 1; if (i == 1) { @@ -281,10 +307,36 @@ public class PortConvThread implements Runnable { mydoJobStockin.setExecutionPhase(TASK_EP_SSJ); mydoJobStockin.setStartTime(DateUtil.formatDateTime(DateUtil.date())); mydoJobService.updateMydoJob(mydoJobStockin); - log.info("【更新状态】G1004入口输送机下发成功,任务号:{},入库执行中", mydoJobStockin.getTaskNo()); + log.info("【更新状态】G1009入口输送机下发成功,任务号:{},入库执行中", mydoJobStockin.getTaskNo()); } } + + //-------------------------------------------盘点回库------------------------------------------- + //检查是否有已经创建成功的任务(请求成功的入库任务) - 更新到下一个执行阶段 + mydoJobStockin = new MydoJob().builder() + .trayCode(inSsjDevice.getTrayCode()) + .status(TASK_STATUS_RUNNING) + .executionPhase(TASK_EP_SSJ_INVENTORY_STOCKOUT_FINISH) + .build(); + if(!mydoJobService.selectMydoJobList(mydoJobStockin).isEmpty()){ + + //如果已经生成入库任务 - 向输送机下发任务号 + mydoJobStockin = mydoJobService.selectMydoJobList(mydoJobStockin).get(0); + + //输送机去向值【1】 + int i = writeToSsj(inSsjDevice.getPlcDbWriteAddress(), mydoJobStockin.getTaskNo(), 1, 1); +// int i = 1; + if (i == 1) { + //写入成功则更新执行阶段 + mydoJobStockin.setExecutionPhase(TASK_EP_SSJ); + mydoJobStockin.setStartTime(DateUtil.formatDateTime(DateUtil.date())); + mydoJobService.updateMydoJob(mydoJobStockin); + log.info("【更新状态】入口输送机{}下发成功,任务号:{},盘点回库执行中", inSsjDevice.getDeviceCode(), mydoJobStockin.getTaskNo()); + } + } + + } @@ -298,16 +350,49 @@ public class PortConvThread implements Runnable { if (outSsjDevice.getDw() == 1 && outSsjDevice.getTaskNo() > 0) { //查询该出库任务 MydoJob mydoJob = mydoJobService.selectMydoJobByTaskNo(Convert.toLong(outSsjDevice.getTaskNo())); - if (mydoJob != null && Integer.parseInt(mydoJob.getInOrOut()) > 20) { - log.info("【出库完成】去向:{}，出库货位:{}，任务号:{}，出库到位", "任务结束", outSsjDevice.getDeviceCode(),mydoJob.getCargoSpaceId() , mydoJob.getTaskNo()); + if (mydoJob != null && Integer.parseInt(mydoJob.getInOrOut()) == TASKTYPE_STOCKOUT) { + log.info("【出库完成】去向:{}，出库货位:{}，任务号:{}，出库到位, 任务结束", outSsjDevice.getDeviceCode(),mydoJob.getCargoSpaceId() , mydoJob.getTaskNo()); mydoJob.setExecutionPhase(TASK_EP_SSJ_STOCKOUT_FINISH); mydoJobService.updateMydoJob(mydoJob); mydoJobService.taskFinish(Long.valueOf(mydoJob.getTaskNo())); } + + //盘点任务出库到位不结束任务 + if (mydoJob != null && Integer.parseInt(mydoJob.getInOrOut()) == TASKTYPE_STOCKOUT) { + log.info("【盘点出库完成】去向:{}，出库货位:{}，任务号:{}，盘点出库到位, 等待盘点回库", outSsjDevice.getDeviceCode(),mydoJob.getCargoSpaceId() , mydoJob.getTaskNo()); + mydoJob.setExecutionPhase(TASK_EP_SSJ_INVENTORY_STOCKOUT_FINISH); + mydoJobService.updateMydoJob(mydoJob); + } + } } + /** + * 输送机出库到位 - 盘点任务出库阶段完成 + * 出库完成在升降位置，即【TD1001】判断完成 + * @param outSsjDevice + */ + private void finishInventoryStockoutMydoJob(DeviceSsj outSsjDevice){ + //出库到位 + if (outSsjDevice.getDw() == 1 && outSsjDevice.getTaskNo() > 0) { + //查询该出库任务 + MydoJob mydoJob = mydoJobService.selectMydoJobByTaskNo(Convert.toLong(outSsjDevice.getTaskNo())); + if (mydoJob != null && Integer.parseInt(mydoJob.getInOrOut()) == TASKTYPE_INVENTORY) { + log.info("【盘点出库完成】去向:{}，出库货位:{}，任务号:{}，出库到位", "盘点出库完成，等待执行回库", outSsjDevice.getDeviceCode(),mydoJob.getCargoSpaceId() , mydoJob.getTaskNo()); + mydoJob.setExecutionPhase(TASK_EP_SSJ_INVENTORY_STOCKOUT_FINISH); + mydoJobService.updateMydoJob(mydoJob); +// mydoJobService.taskFinish(Long.valueOf(mydoJob.getTaskNo())); + } + } + } + + + + + + + // ====== 【请按实际修改】====== private static final String MOXA_IP = "192.168.1.200"; // NPort 5110 的 IP private static final int MOXA_PORT = 4001; // NPort 配置的 Local Port @@ -376,10 +461,6 @@ public class PortConvThread implements Runnable { - - - - public void inDispatch1(DeviceSsj ssjDevice) { //有入库请求就肯定是电气的任务号的作业 @@ -450,16 +531,6 @@ public class PortConvThread implements Runnable { } - public void outDispatch(DeviceSsj ssjDevice) { - - //出库完成 - finishStockoutMydoJob(ssjDevice); - - } - - - - diff --git a/ruoyi-admin/src/main/java/com/ruoyi/schedule/scheduleTask/ssj/RoadConvThread.java b/ruoyi-admin/src/main/java/com/ruoyi/schedule/scheduleTask/ssj/RoadConvThread.java index ed4281c..a0d5848 100644 --- a/ruoyi-admin/src/main/java/com/ruoyi/schedule/scheduleTask/ssj/RoadConvThread.java +++ b/ruoyi-admin/src/main/java/com/ruoyi/schedule/scheduleTask/ssj/RoadConvThread.java @@ -1,6 +1,5 @@ package com.ruoyi.schedule.scheduleTask.ssj; -import cn.hutool.core.bean.BeanUtil; import cn.hutool.core.collection.CollUtil; import cn.hutool.core.convert.Convert; import cn.hutool.core.date.DateUtil; @@ -9,7 +8,6 @@ import cn.hutool.core.util.ObjUtil; import com.ruoyi.api.service.IApiService; import com.ruoyi.bas.cargospace.domain.BasCargoSpace; import com.ruoyi.bas.cargospace.service.IBasCargoSpaceService; -import com.ruoyi.common.core.domain.AjaxResult; import com.ruoyi.common.utils.spring.SpringUtils; import com.ruoyi.device.ssj.domain.DeviceSsj; import com.ruoyi.job.domain.MydoJob; @@ -22,8 +20,7 @@ import lombok.extern.slf4j.Slf4j; import java.util.*; -import static com.ruoyi.common.ConvType.CONV_ROAD_1; -import static com.ruoyi.common.ConvType.CONV_STOCKOUT; +import static com.ruoyi.common.ConvType.ROADWAY1_EXIT; import static com.ruoyi.common.TaskStatusCode.*; import static com.ruoyi.common.TaskType.*; @@ -47,7 +44,7 @@ public class RoadConvThread implements Runnable { ssjCodeList = new HashMap<>(); ArrayList ssjCodes = new ArrayList<>(); // ssjCodes.add("L1002"); - ssjCodes.add("L1001"); + ssjCodes.add("L1010"); ssjCodeList.put("roadConv", ssjCodes); apiService = SpringUtils.getBean(IApiService.class); agvQueueService = SpringUtils.getBean(IAgvQueueService.class); @@ -56,7 +53,7 @@ public class RoadConvThread implements Runnable { ddjDeviceExecutionQueueService = SpringUtils.getBean(IDdjDeviceExecutionQueueService.class); //初始化巷道口 排 列 层 //todo 核对堆垛机取放位置的货位编码 - roadwayMap.put("L1001", Arrays.asList(2, 1, 1)); + roadwayMap.put("L1010", Arrays.asList(1, 1, 1)); // roadwayMap.put("L1004", Arrays.asList(4, 0, 1)); log.info("初始化服务 {}，{}", apiService, agvQueueService); } @@ -72,7 +69,7 @@ public class RoadConvThread implements Runnable { for (String ssjCode : ssjCodeList.get(type)) { try { if (PlcSsjRead.deviceSsjMap.containsKey(ssjCode)) { - inDispatch(PlcSsjRead.deviceSsjMap.get(ssjCode)); + schedule(PlcSsjRead.deviceSsjMap.get(ssjCode)); } else { log.error("设备不存在 ssjCode{}", ssjCode); } @@ -93,15 +90,55 @@ public class RoadConvThread implements Runnable { } - public void inDispatch(DeviceSsj roadSsjDevice) { + public void schedule(DeviceSsj roadSsjDevice) { - sendStackerIn(roadSsjDevice); + switch (roadSsjDevice.getDeviceCode()){ + //1#巷道入库（单向） + case "L1010": + //3#巷道入库（单向） + case "L1003": + + //到位校验 + if (!roadConvChecked(roadSsjDevice)) return; + + //更新入库任务阶段 + sendStackerIn(roadSsjDevice); + + //请求wms获取入库任务 + //requestMydoJob(deviceSsj); + break; + + //1#巷道出库口（单向） -- FT577项目巷道1和巷道3出库位置为单输送机，故此处【出库完成】的方法移至端口输送机线程【PortConvThread】中执行 + case "L1008": + //3#巷道出库口（单向） + case "L1001": + //出库完成 +// finishStockoutMydoJob(deviceSsj); + sendStackerOut(roadSsjDevice); + break; + } - sendStackerOut(roadSsjDevice); } + /** + * 输送机到位判断校验 + * @param inSsjDevice + * @return + */ + private boolean roadConvChecked(DeviceSsj inSsjDevice){ + + boolean flag = false; + //---------------------------巷道口取放货输送机--------------------------- + //输送机【任务号】和【到位】校验 + if (inSsjDevice.getTaskNo() == 0 || inSsjDevice.getDw() == 0) return flag; + + return true; + } + + + /** * 向堆垛机发送【入库】任务 * @param roadSsjDevice @@ -129,8 +166,11 @@ public class RoadConvThread implements Runnable { // 检查任务属性：【任务已存在】、执行阶段-【巷道口输送机到位】、任务类型-【入库】 → 下发堆垛机执行队列 if (mydoJob.getExecutionPhase().equals(TASK_EP_ROADWAY_SSJ) && Convert.toInt(mydoJob.getInOrOut()) < 20) { + //弯轨堆垛机设备编号使用货位区域编号对应 + int devId = Convert.toInt(basCargoSpaceService.selectBasCargoSpaceByCargoSpaceId(mydoJob.getCargoSpaceId()).getCargoAreaId()); + //检查堆垛机是否在正在执行中/已经有执行队列 - List ddjDeviceExecutionQueues = ddjDeviceExecutionQueueService.selectDdjDeviceExecutionQueueListByRwlx(DDJ_RWLX_3, Convert.toInt(mydoJob.getRoadwayId())); + List ddjDeviceExecutionQueues = ddjDeviceExecutionQueueService.selectDdjDeviceExecutionQueueListByRwlx(DDJ_RWLX_3, devId); BasCargoSpace basCargoSpace = basCargoSpaceService.selectBasCargoSpaceByWmsCargoSpaceId(mydoJob.getCargoSpaceId()); List pclList = roadwayMap.get(roadSsjDevice.getDeviceCode()); @@ -140,7 +180,7 @@ public class RoadConvThread implements Runnable { ddjDeviceExecutionQueue.setUuid(IdUtil.simpleUUID()); ddjDeviceExecutionQueue.setRwh(Convert.toLong(mydoJob.getTaskNo())); ddjDeviceExecutionQueue.setDevName(mydoJob.getRoadwayId()); - ddjDeviceExecutionQueue.setDevId(Convert.toInt(mydoJob.getRoadwayId())); + ddjDeviceExecutionQueue.setDevId(devId); ddjDeviceExecutionQueue.setRwzt(0); ddjDeviceExecutionQueue.setYph(pclList.get(0)); ddjDeviceExecutionQueue.setYlh(pclList.get(1)); @@ -176,11 +216,11 @@ public class RoadConvThread implements Runnable { //检查巷道口输送机是否空闲 if(roadSsjDevice.getKx()==1 && roadSsjDevice.getTaskNo() == 0){ - //检查是否有入口是【G1004】的入库任务 - String exitId = CONV_STOCKOUT; - List inList = mydoJobService.getInJobByEntranceId(exitId); + //检查是否有入口是1#巷道的出库任务 + String exitId = ROADWAY1_EXIT; + MydoJob job = mydoJobService.selectMydoJobByExitId(exitId); - if(inList.size() == 0){ + if(job == null){ //检查是否有出库任务 MydoJob mydoJob = mydoJobService.selectMydoJobByExitId(exitId); diff --git a/ruoyi-admin/src/main/resources/application.yml b/ruoyi-admin/src/main/resources/application.yml index 22b4d14..c87e930 100644 --- a/ruoyi-admin/src/main/resources/application.yml +++ b/ruoyi-admin/src/main/resources/application.yml @@ -113,6 +113,7 @@ mybatis: # mapper-locations: classpath*:mapper/**/*Mapper.xml # # 实体类别名包（让 XML 中能用 User 而非全限定名） # type-aliases-package: com.ruoyi.**.domain +# config-location: classpath:mybatis/mybatis-config.xml # configuration: # map-underscore-to-camel-case: true # cache-enabled: false diff --git a/ruoyi-admin/src/main/resources/logback.xml b/ruoyi-admin/src/main/resources/logback.xml index 9282fe2..a360583 100644 --- a/ruoyi-admin/src/main/resources/logback.xml +++ b/ruoyi-admin/src/main/resources/logback.xml @@ -5,9 +5,6 @@ - - - @@ -27,7 +24,6 @@ ${log.pattern} - ${log.charset} @@ -50,7 +46,6 @@ ${log.pattern} - ${log.charset}