no message

youchain-system/src/main/java/com/youchain/appupdate/service/impl/BydAppServiceImpl.java

@@ -216,6 +216,9 @@ public class BydAppServiceImpl implements BydAppService {
         //刷新出库单状态
         pickService.refreshPickStatus(task.getPickDetail().getPick());
 
+        //生成叫料任务
+        taskService.callJlTask(pick);
+
         //成品原托盘返库；单品不回库
         if (BaseStatus.GD_TYPE_CT.equals(pick.getOrderType())) {
             this.returnFBAgvTask(task);

youchain-system/src/main/java/com/youchain/basicdata/repository/StockRepository.java

@@ -43,12 +43,6 @@ public interface StockRepository extends JpaRepository<Stock, Long>, JpaSpecific
     @Query(" from Stock s where s.point.code = :pointCode")
     Stock findByPointCode(String pointCode);
 
-    @Query(" from Stock s where s.point.area.name = :areaName " +
+    @Query(" from Stock s where s.point.area.name = :areaName and s.point.id > 0 and s.point.enabled=true and s.point.status = 'USED' and s.status = :status and s.enabled = true  ")
-            " and s.point.id > 0 " +
-            " and s.point.enabled=true" +
-            " and s.point.status = 'USED'" +
-            " and s.status = :status " +
-            " and s.enabled = true " +
-            " and s.code not in (select agv.stockCode from AgvTask agv where agv.status not in ('FINISH','CANCEL') ) ")
     List<Stock> findByFreeOrUsedStock(String areaName, String status);
 }

youchain-system/src/main/java/com/youchain/businessdata/domain/AgvTask.java

@@ -20,6 +20,7 @@ import lombok.Data;
 import cn.hutool.core.bean.BeanUtil;
 import io.swagger.annotations.ApiModelProperty;
 import cn.hutool.core.bean.copier.CopyOptions;
+
 import javax.persistence.*;
 import javax.validation.constraints.*;
 import java.sql.Timestamp;
@@ -27,9 +28,9 @@ import java.io.Serializable;
 import java.util.Date;
 
 /**
+ * @author baobinglin
  * @website https://eladmin.vip
  * @description /
-* @author baobinglin
  * @date 2023-08-18
  **/
 @Entity
@@ -43,17 +44,14 @@ public class AgvTask  extends BaseEntity implements Serializable {
     private Long id;
 
     @Column(name = "`stock_code`")
-    @NotBlank
     @ApiModelProperty(value = "容器号")
     private String stockCode;
 
     @Column(name = "`stock_type_code`")
-    @NotBlank
     @ApiModelProperty(value = "")
     private String stockTypeCode;
 
-    @Column(name = "`start_slot_code`",nullable = false)
+    @Column(name = "`start_slot_code`")
-    @NotBlank
     @ApiModelProperty(value = "起点位置")
     private String startSlotCode;
 
@@ -66,7 +64,6 @@ public class AgvTask  extends BaseEntity implements Serializable {
     private String slotCode;
 
     @Column(name = "`status`", nullable = false)
-    @NotBlank
     @ApiModelProperty(value = "任务状态")
     private String status;
 
@@ -79,7 +76,6 @@ public class AgvTask  extends BaseEntity implements Serializable {
     private String jobId;
 
     @Column(name = "`job_type`", nullable = false)
-    @NotBlank
     @ApiModelProperty(value = "工作类型")
     /**
      * 01：料箱
@@ -137,6 +133,7 @@ public class AgvTask  extends BaseEntity implements Serializable {
 
     /**
      * 添加搬运任务
+     *
      * @param type          任务类型-入库/出库
      * @param stockCode     料车号
      * @param startSlotCode 起始位置(取料箱点位;料箱当前放置的货位码;取料箱时之前是否需要
@@ -145,7 +142,6 @@ public class AgvTask  extends BaseEntity implements Serializable {
      *                      确认)中间用 ; 隔开 例如 14;1-001;false
      * @param status        任务状态，直接下发还是排队下发
      * @param jobType       任务类型-货 架 ( 托 盘 ) 移动:RACK_MOVE
-     *
      */
     public AgvTask(String type, String stockCode, String startSlotCode, String endSlotCode, String status, String jobType) {
         this.type = type;
@@ -155,6 +151,7 @@ public class AgvTask  extends BaseEntity implements Serializable {
         this.status = status;
         this.jobType = jobType;
     }
+
     public void copy(AgvTask source) {
         BeanUtil.copyProperties(source, this, CopyOptions.create().setIgnoreNullValue(true));
     }

youchain-system/src/main/java/com/youchain/businessdata/domain/Pick.java

@@ -100,7 +100,10 @@ public class Pick extends BaseEntity implements Serializable {
 
     @Column(name = "`source_id`")
     @ApiModelProperty(value = "回传状态")
-    private Long sourceId;/** 0失败；1.成功*/
+    private Long sourceId;
+    /**
+     * 0失败；1.成功
+     */
 
     @OneToOne
     @JoinColumn(name = "`dept_id`", nullable = false)
@@ -108,6 +111,10 @@ public class Pick extends BaseEntity implements Serializable {
     @ApiModelProperty(value = "仓库")
     private Dept dept;
 
+    @Column(name = "`priority`")
+    @ApiModelProperty(value = "优先级")
+    private int priority=0;
+
     public void copy(Pick source) {
         BeanUtil.copyProperties(source, this, CopyOptions.create().setIgnoreNullValue(true));
     }

youchain-system/src/main/java/com/youchain/businessdata/repository/AgvTaskRepository.java

@@ -40,9 +40,10 @@ public interface AgvTaskRepository extends JpaRepository<AgvTask, Long>, JpaSpec
 
     /**
      * 查询待执行的备料、叫料、叫料返库任务
+     * 'PICK','CALL_PICK','CALL_RETURN'
      */
-    @Query(value = " from AgvTask agv where agv.type in ('PICK','CALL_PICK','CALL_RETURN') and agv.status='OPEN' order by agv.createTime ")
+    @Query(value = " from AgvTask agv where agv.type=:type and agv.status='OPEN' order by agv.createTime ")
-    List<AgvTask> findOpenByAgvTask();
+    List<AgvTask> findOpenByAgvTask(String type);
 
     /**
      * 翻包返库时，查询起点是否有多条不同容器的任务(不包括当前任务)

youchain-system/src/main/java/com/youchain/businessdata/repository/TaskRepository.java

@@ -51,8 +51,8 @@ public interface TaskRepository extends JpaRepository<Task, Long>, JpaSpecificat
      *
      * @param pickId 出库单ID
      */
-    @Query("from Task t where t.pickDetail.pick.id =:pickId and t.planQty > t.moveQty and t.agvTask.id is null")
+    @Query("from Task t where t.planQty > t.moveQty and t.agvTask.id is null")
-    List<Task> findByPickNotAllTask(Long pickId);
+    List<Task> findByPickNotAllTask();
 
     /**
      * 根据出库单查询已完成的Task集合

youchain-system/src/main/java/com/youchain/businessdata/rest/MesController.java

@@ -51,10 +51,10 @@ public class MesController {
             String itemCode = zpjlZj.getItemCode();//物料代码
             String station = zpjlZj.getStation();//需求工位
             String pointCode = zpjlZj.getPointCode();//需求点位
-            mesService.itemCall(orderNo, itemCode, station, pointCode);
+            String result = mesService.itemCall(orderNo, itemCode, station, pointCode);
-            return successResponse("叫料成功!");
+            return successResponse(result);
         } catch (Exception e) {
-            return badResponse("叫料失败:" + e.getMessage());
+            return successResponse("叫料失败:" + e.getMessage());
         }
     }
 
@@ -68,10 +68,10 @@ public class MesController {
             String completeCode = zpjlCt.getCompleteCode();//成套代码
             String station = zpjlCt.getStation();//需求工位
             String pointCode = zpjlCt.getPointCode();//需求点位
-            mesService.bigItemCall(orderNo, completeCode, station, pointCode);
+            String result = mesService.bigItemCall(orderNo, completeCode, station, pointCode);
-            return successResponse("叫料成功!");
+            return successResponse(result);
         } catch (Exception e) {
-            return badResponse("叫料失败：" + e.getMessage());
+            return successResponse("叫料失败：" + e.getMessage());
         }
     }
 
@@ -90,10 +90,10 @@ public class MesController {
     @AnonymousAccess
     public ResponseEntity<Object> transTask(@Validated @RequestBody TransTask transTask) {
         try {
-            mesService.performTransportTask(transTask);
+            String result = mesService.performTransportTask(transTask);
-            return successResponse("下发成功!");
+            return successResponse(result);
         } catch (Exception e) {
-            return badResponse("下发失败!" + e.getMessage());
+            return successResponse("下发失败!" + e.getMessage());
         }
     }
 

youchain-system/src/main/java/com/youchain/businessdata/service/AgvTaskService.java

@@ -110,6 +110,15 @@ public interface AgvTaskService {
      */
     List<AgvTask> findRepeat(String stockCode, String srcPointCode, String endPointCode);
 
+    /**
+     * 根据起点查询是否有重复任务
+     *
+     * @param startSlotCode 点位
+     * @param type        任务类型
+     * @param jobType     作业类型
+     */
+    Boolean findByStartSlotCode(String startSlotCode, String type, String jobType);
+
     /**
      * 根据终点查询是否有重复任务
      *
@@ -121,6 +130,7 @@ public interface AgvTaskService {
 
     /**
      * 叉车任务一个一个下发
+     *
      * @param endSlotCode 终点
      * @param type        任务类型
      * @param jobType     作业类型
@@ -131,7 +141,7 @@ public interface AgvTaskService {
     /**
      * 查询打开的任务并轮询下发
      */
-    List<AgvTask> findOpenByAgvTask();
+    List<AgvTask> findOpenByAgvTask(String type);
 
     /**
      * 翻包返库时，查询起点是否有多条不同容器的任务(不包括当前任务)
@@ -143,6 +153,7 @@ public interface AgvTaskService {
 
     /**
      * 根据状态查询任务
+     *
      * @param status 状态
      * @return List<AgvTask>
      */

youchain-system/src/main/java/com/youchain/businessdata/service/MesService.java

@@ -21,7 +21,7 @@ public interface MesService {
      * @param station->需求工位
      * @param pointCode->需求点位
      */
-    void itemCall(String gdNo, String itemCode, String station, String pointCode);
+    String itemCall(String gdNo, String itemCode, String station, String pointCode);
 
     /**
      * 成品叫料-小件
@@ -31,13 +31,13 @@ public interface MesService {
      * @param station->需求工位
      * @param pointCode->需求点位
      */
-    void bigItemCall(String gdNo, String completeCode, String station, String pointCode);
+    String bigItemCall(String gdNo, String completeCode, String station, String pointCode);
 
     /**
      * 搬运任务
      *
      * @param transTask 搬运任务
      */
-    void performTransportTask(TransTask transTask);
+    String performTransportTask(TransTask transTask);
 
 }

youchain-system/src/main/java/com/youchain/businessdata/service/TaskService.java

@@ -128,9 +128,8 @@ public interface TaskService {
     /**
      * 根据出库单查询未完成的Task集合
      *
-     * @param pickId 出库单Id
      */
-    List<Task> findByPickNotAllTask(Long pickId);
+    List<Task> findByPickNotAllTask();
 
     /**
      * 根据出库单查询已完成的Task集合
@@ -174,9 +173,8 @@ public interface TaskService {
     /**
      * 定时任务轮询出库单备料
      *
-     * @param pick 出库单
      */
-    void materialPick(Pick pick);
+    void materialPick();
 
     /**
      * 定时任务轮询叫料反空车至备料缓存区

youchain-system/src/main/java/com/youchain/businessdata/service/impl/AgvTaskServiceImpl.java

@@ -142,6 +142,18 @@ public class AgvTaskServiceImpl implements AgvTaskService {
         return agvTaskRepository.findRepeat(stockCode, srcPointCode, endPointCode);
     }
 
+    @Override
+    public Boolean findByStartSlotCode(String startSlotCode, String type, String jobType) {
+        String hql = " from AgvTask agv " +
+                " where  agv.startSlotCode='" + startSlotCode + "' " +
+                " and agv.type='" + type + "' " +
+                " and agv.jobType='" + jobType + "' " +
+                " and agv.status in ('OPEN','ATCALL','UP_CONTAINER') ";
+        Query query = entityMapper.createQuery(hql);
+        List<AgvTask> agvTaskList = query.getResultList();
+        return agvTaskList.isEmpty();
+    }
+
     @Override
     public Boolean findByEndSlotCode(String endSlotCode, String type, String jobType) {
         String hql = " from AgvTask agv " +
@@ -167,8 +179,8 @@ public class AgvTaskServiceImpl implements AgvTaskService {
     }
 
     @Override
-    public List<AgvTask> findOpenByAgvTask() {
+    public List<AgvTask> findOpenByAgvTask(String type) {
-        return agvTaskRepository.findOpenByAgvTask();
+        return agvTaskRepository.findOpenByAgvTask(type);
     }
 
     @Override

youchain-system/src/main/java/com/youchain/businessdata/service/impl/MesServiceImpl.java

@@ -9,6 +9,7 @@ import com.youchain.basicdata.domain.Item;
 import com.youchain.basicdata.domain.Point;
 import com.youchain.basicdata.domain.Stock;
 import com.youchain.basicdata.repository.ItemRepository;
+import com.youchain.basicdata.repository.PointRepository;
 import com.youchain.basicdata.service.ItemService;
 import com.youchain.basicdata.service.PointService;
 import com.youchain.basicdata.service.StockService;
@@ -40,7 +41,7 @@ import java.util.stream.Collectors;
 @RequiredArgsConstructor
 @Slf4j
 public class MesServiceImpl implements MesService {
-
+    private final PointRepository pointRepository;
     private final PickRepository pickRepository;
     private final PickDetailRepository pickDetailRepository;
     private final ItemRepository itemRepository;
@@ -129,82 +130,55 @@ public class MesServiceImpl implements MesService {
 
     @Override
     @Transactional(rollbackFor = Exception.class)
-    public void itemCall(String gdNo, String itemCode, String station, String pointCode) {
+    public String itemCall(String gdNo, String itemCode, String station, String pointCode) {
         Pick pick = pickRepository.findByPick(gdNo, itemCode, station);
         if (pick == null) {
-            throw new BadRequestException(gdNo + ":" + itemCode + ":" + station + "工单不存在，叫料失败!");
+            return gdNo + ":" + itemCode + ":" + station + "工单WMS不存在，叫料失败!";
         }
-        if (BizStatus.OPEN.equals(pick.getStatus())) {
-            throw new BadRequestException(gdNo + "工单未备料完成，叫料失败!");
-        }
-
-        Point point = pointService.queryPoint(pointCode, null, null, null);
-        if (point == null) {
-            throw new BadRequestException(pointCode + "点位不存在或已失效!");
-        }
-
-        pick.setIsCall(true);
         if (pick.getCallPoint() == null || pick.getCallPoint().length() <= 0) {
             pick.setCallPoint(pointCode);
-        } else if (!pointCode.equals(pick.getCallPoint())) {
+        } else {
             pick.setCallPoint(pick.getCallPoint() + "," + pointCode);
         }
+        pick.setIsCall(true);
         pickRepository.save(pick);
-
+        return "叫料成功!";
-        taskService.callJlTask(pick);
     }
 
     @Override
     @Transactional(rollbackFor = Exception.class)
-    public void bigItemCall(String gdNo, String completeCode, String station, String pointCode) {
+    public String bigItemCall(String gdNo, String completeCode, String station, String pointCode) {
         Pick pick = pickRepository.findByPick(gdNo, completeCode, station);
         if (pick == null) {
-            throw new BadRequestException(gdNo + ":" + completeCode + ":" + station + "工单不存在，叫料失败!");
+            return gdNo + ":" + completeCode + ":" + station + "工单WMS不存在，叫料失败!";
         }
-
-        if (BizStatus.OPEN.equals(pick.getStatus())) {
-            throw new BadRequestException(gdNo + "工单未备料完成，叫料失败!");
-        }
-
-        Point point = pointService.queryPoint(pointCode, null, null, null);
-        if (point == null) {
-            throw new BadRequestException(pointCode + "点位不存在或已失效!");
-        }
-
-
-        pick.setIsCall(true);
         if (pick.getCallPoint() == null || pick.getCallPoint().length() <= 0) {
             pick.setCallPoint(pointCode);
-        } else if (!pointCode.equals(pick.getCallPoint())) {
+        } else {
             pick.setCallPoint(pick.getCallPoint() + "," + pointCode);
         }
-
+        pick.setIsCall(true);
         pickRepository.save(pick);
-
+        //taskService.callJlTask(pick);
-        taskService.callJlTask(pick);
+        return "叫料成功!";
     }
 
     @Override
     @Transactional(rollbackFor = Exception.class)
-    public void performTransportTask(TransTask transTask) {
+    public String performTransportTask(TransTask transTask) {
         switch (transTask.getTaskType()) {
             case BizStatus.Cp_Off_Up:
-                moveCpOffUp(transTask.getPointCode());//呼叫空货架
+                return moveCpOffUp(transTask.getPointCode());//呼叫空货架
-                break;
             case BizStatus.Cp_Off_Line:
-                moveCpOffLine(transTask);//送满货架
+                return moveCpOffLine(transTask);//送满货架
-                break;
             case BizStatus.Fx_Off_Line:
-                moveFxOffLine(transTask);//返修呼叫空托盘、返修下线
+                return moveFxOffLine(transTask);//返修呼叫空托盘、返修下线
-                break;
             case BizStatus.Fx_Back:
-                moveFxBack(transTask);//返修载具送回
+                return moveFxBack(transTask);//返修载具送回
-                break;
             case BizStatus.JL_Back:
-                moveJLBack(transTask);//叫料返空
+                return moveJLBack(transTask);//叫料返空
-                break;
             default:
-                throw new BadRequestException("任务类型错误!");
+                return "任务类型错误!";
         }
     }
 
@@ -271,90 +245,109 @@ public class MesServiceImpl implements MesService {
         return pickDetail;
     }
 
-    private void moveCpOffUp(String pointCode) {
+    private String moveCpOffUp(String pointCode) {
-        // 从成品入库缓存区查询空车；没有在从成品入库区查询空车；
+        //终点
+        Point endPoint = pointRepository.findByCode(pointCode);
+        // 查询空车
+        List<Stock> emptyStockList = getEmptyStockList();
+        if (emptyStockList.isEmpty()) {
+            // 没有空车的处理逻辑
+            if (!isEndPointAvailable(endPoint.getCode(), BizStatus.Cp_Off_Up, "RACK_MOVE")) {
+                return pointCode + "点位有任务，请稍后再试!";
+            }
+            // 生成agv任务进行等待
+            agvTaskService.createAgvTask(BizStatus.Cp_Off_Up, null, null, endPoint.getCode(), "RACK_MOVE");
+            pointService.usedPoint(endPoint);
+            return "成品入库区、成品入库缓存区都没有空车,请稍后再试!";
+        }
+
+        //选择空车
+        Stock emptyStock = emptyStockList.get(0);
+        Point srcPoint = emptyStock.getPoint();
+
+        // 验证终点是否有任务
+        if (!isEndPointAvailable(endPoint.getCode(), BizStatus.Cp_Off_Up, "RACK_MOVE")) {
+            return pointCode + "点位有任务，请稍后再试!";
+        }
+
+        //创建Agv任务
+        AgvTask agvTask = agvTaskService.createAgvTask(BizStatus.Cp_Off_Up, emptyStock, srcPoint.getCode(), endPoint.getCode(), "RACK_MOVE");
+
+        // 更新点位状态
+        pointService.usedPoint(endPoint);
+
+        return "呼叫成功";
+
+    }
+
+    /**
+     * 从成品入库缓存区或成品入库区查询空车
+     *
+     * @return 空车列表
+     */
+    private List<Stock> getEmptyStockList() {
         List<Stock> emptyStockList = stockService.findByFreeOrUsedStock(AreaNameDic.CPRKHCQ, BaseStatus.FREE);
         if (emptyStockList.isEmpty()) {
             emptyStockList = stockService.findByFreeOrUsedStock(AreaNameDic.CPRKQ, BaseStatus.FREE);
-            if (emptyStockList.isEmpty()) {
-                throw new BadRequestException("成品入库区、成品入库缓存区都没有空车,请稍后再试!");
         }
-        }
+        return emptyStockList;
-        //容器
-        Stock emptyStock = emptyStockList.get(0);
-        //起点
-        Point srcPoint = emptyStock.getPoint();
-        //终点
-        Point endPoint = pointService.validatePoint(pointCode);
-        //验证终点是否有任务
-        if (!agvTaskService.findByEndSlotCode(endPoint.getCode(), BizStatus.Cp_Off_Up, "RACK_MOVE")) {
-            // 直接在条件判断为false时抛出异常，表示该点位有任务
-            throw new BadRequestException(endPoint.getCode() + "点位有任务，请稍后再试!");
-        }
-        //创建Agv任务
-        AgvTask agvTask = agvTaskService.createAgvTask(BizStatus.Cp_Off_Up, emptyStock, srcPoint.getCode(), endPoint.getCode(), "RACK_MOVE");
-        // 更新点位状态
-        pointService.usedPoint(endPoint);
-        //下发任务
-        kmReService.sendAgvTask(agvTask, kmReService.sendAgvTaskHjJson(agvTask));
     }
 
-    private void moveCpOffLine(TransTask transTask) {
+    /**
-        //查询下线缓存区是否有满货架；
+     * 验证终点是否有任务
-        List<Stock> fullStockList = stockService.findByFreeOrUsedStock(AreaNameDic.CPXXHC, BaseStatus.USED);
+     *
-        if (!fullStockList.isEmpty()) {
+     * @param endPointCode 终点点位代码
-            List<Point> endPointList = pointService.queryPoints(null, BaseStatus.FREE, BaseStatus.BOX, AreaNameDic.CPRKQ);
+     * @return 终点是否可用
-            if (!endPointList.isEmpty()) {
+     */
-                //容器
+    private boolean isEndPointAvailable(String endPointCode, String type, String jobType) {
-                Stock fullStock = fullStockList.get(0);
+        return agvTaskService.findByEndSlotCode(endPointCode, type, jobType);
-                //起点
-                Point srcPoint = fullStock.getPoint();
-                //终点
-                Point endPoint = endPointList.get(0);
-                //验证终点是否有任务
-                if (agvTaskService.findByEndSlotCode(endPoint.getCode(), BizStatus.Cp_Off_Line, "RACK_MOVE")) {
-                    //创建Agv任务
-                    AgvTask agvTask = agvTaskService.createAgvTask(BizStatus.Cp_Off_Line, fullStock, srcPoint.getCode(), endPoint.getCode(), "RACK_MOVE");
-                    synchronized (endPoint) {
-                        // 更新点位状态
-                        pointService.usedPoint(endPoint);
-
-                        //占用容器
-                        stockService.usedStock(fullStock, srcPoint, BaseStatus.USED);
     }
 
-
+    /**
-                    //下发任务
+     * 验证起点是否有任务
-                    kmReService.sendAgvTask(agvTask, kmReService.sendAgvTaskHjJson(agvTask));
+     *
-                }
+     * @param startSlotCode 终点点位代码
-            }
+     * @return 终点是否可用
+     */
+    private boolean isSrcPointAvailable(String startSlotCode, String type, String jobType) {
+        return agvTaskService.findByStartSlotCode(startSlotCode, type, jobType);
+    }
+
+    private String moveCpOffLine(TransTask transTask) {
+        Point srcPoint = pointRepository.findByCode(transTask.getPointCode());
+        if (srcPoint == null) {
+            return transTask.getPointCode() + "点位不存在!";
+        }
+        // 处理下线缓存区有满货架的情况
+        String result = handleFullStockInCache(srcPoint);
+        if (result != null) {
+            return result;
         }
 
-        //下线缓存区没有满货架，直接下发当前任务
-        Point srcPoint = pointService.validatePoint(transTask.getPointCode());
         //容器
         Stock stock = stockService.findByPointCode(srcPoint.getCode());
-        if (stock == null) {
+
-            throw new BadRequestException(srcPoint.getCode() + "点位没有货架!");
+        // 查找可用的终点点位
+        Point endPoint = findAvailableEndPoint();
+        if (endPoint == null) {
+            // 没有可用终点点位的处理逻辑
+            if (!isSrcPointAvailable(srcPoint.getCode(), BizStatus.Cp_Off_Line, "RACK_MOVE")) {
+                return srcPoint.getCode() + "点位有任务，请稍后再试!";
             }
-        List<Point> endPointList = pointService.queryPoints(null, BaseStatus.FREE, BaseStatus.BOX, AreaNameDic.CPRKQ);
+            // 生成等待任务
-        if (endPointList.isEmpty()) {
+            agvTaskService.createAgvTask(BizStatus.Cp_Off_Line, stock, srcPoint.getCode(), null, "RACK_MOVE");
-            endPointList = pointService.queryPoints(null, BaseStatus.FREE, BaseStatus.BOX, AreaNameDic.CPXXHC);
+            return "成品入库区和成品下线缓存区都没有空闲点位,请稍后再试!";
-            if (endPointList.isEmpty()) {
-                throw new BadRequestException("成品入库区和成品下线缓存区都没有空闲点位!");
         }
-        }
+
-        //终点
-        Point endPoint = endPointList.get(0);
         // 验证终点是否有任务
-        if (!agvTaskService.findByEndSlotCode(endPoint.getCode(), BizStatus.Cp_Off_Line, "RACK_MOVE")) {
+        if (!isEndPointAvailable(endPoint.getCode(), BizStatus.Cp_Off_Line, "RACK_MOVE")) {
-            // 直接在条件判断为false时抛出异常，表示该点位有任务
+            return transTask.getPointCode() + "点位有任务，请稍后再试!";
-            throw new BadRequestException(endPoint.getCode() + "点位有任务，请稍后再试!");
         }
 
         // 创建Agv任务
         AgvTask agvTask = agvTaskService.createAgvTask(BizStatus.Cp_Off_Line, stock, srcPoint.getCode(), endPoint.getCode(), "RACK_MOVE");
 
+        // 同步更新终点点位状态和占用容器
         synchronized (endPoint) {
             // 更新点位状态
             pointService.usedPoint(endPoint);
@@ -362,11 +355,66 @@ public class MesServiceImpl implements MesService {
             stockService.usedStock(stock, srcPoint, BaseStatus.USED);
         }
 
-        //下发任务
+        return "呼叫成功";
-        kmReService.sendAgvTask(agvTask, kmReService.sendAgvTaskHjJson(agvTask));
+
     }
 
-    private void moveFxOffLine(TransTask transTask) {
+    /**
+     * 查找可用的终点点位，优先从成品入库区查找，若没有则从成品下线缓存区查找
+     *
+     * @return 可用的终点点位，如果没有则返回null
+     */
+    private Point findAvailableEndPoint() {
+        List<Point> endPointList = pointService.queryPoints(null, BaseStatus.FREE, BaseStatus.BOX, AreaNameDic.CPRKQ);
+        if (endPointList.isEmpty()) {
+            endPointList = pointService.queryPoints(null, BaseStatus.FREE, BaseStatus.BOX, AreaNameDic.CPXXHC);
+        }
+        return endPointList.isEmpty() ? null : endPointList.get(0);
+    }
+
+    /**
+     * 处理下线缓存区有满货架的情况
+     *
+     * @param srcPoint 源点位
+     * @return 处理结果信息，如果为空则表示继续后续流程
+     */
+    private String handleFullStockInCache(Point srcPoint) {
+        // 查询下线缓存区是否有满货架
+        List<Stock> fullStockList = stockService.findByFreeOrUsedStock(AreaNameDic.CPXXHC, BaseStatus.USED);
+        if (!fullStockList.isEmpty()) {
+            // 取第一个满货架容器
+            Stock fullStock = fullStockList.get(0);
+            // 查找成品入库区的可用终点点位
+            List<Point> endPointList = pointService.queryPoints(null, BaseStatus.FREE, BaseStatus.BOX, AreaNameDic.CPRKQ);
+            if (!endPointList.isEmpty()) {
+                // 取第一个可用终点点位
+                Point endPoint = endPointList.get(0);
+                // 验证终点是否有任务
+                if (agvTaskService.findByEndSlotCode(endPoint.getCode(), BizStatus.Cp_Off_Line, "RACK_MOVE")) {
+                    // 创建Agv任务
+                    AgvTask agvTask = agvTaskService.createAgvTask(BizStatus.Cp_Off_Line, fullStock, srcPoint.getCode(), endPoint.getCode(), "RACK_MOVE");
+                    // 同步更新终点点位状态和占用容器
+                    synchronized (endPoint) {
+                        // 更新点位状态
+                        pointService.usedPoint(endPoint);
+                        // 占用容器
+                        stockService.usedStock(fullStock, srcPoint, BaseStatus.USED);
+                    }
+                }
+            } else {
+                // 没有空车的处理逻辑
+                if (!isSrcPointAvailable(fullStock.getPoint().getCode(), BizStatus.Cp_Off_Line, "RACK_MOVE")) {
+                    return fullStock.getPoint().getCode() + "点位有任务，请稍后再试!";
+                }
+                // 生成agv任务进行等待
+                agvTaskService.createAgvTask(BizStatus.Cp_Off_Line, fullStock, fullStock.getCode(), null, "RACK_MOVE");
+                return "成品入库区和成品下线缓存区都没有空闲点位,请稍后再试!";
+            }
+        }
+        return null;
+    }
+
+    private String moveFxOffLine(TransTask transTask) {
         //返修上线起点
         String srcPointCode = transTask.getPointCode();
         //终点
@@ -381,63 +429,78 @@ public class MesServiceImpl implements MesService {
         } else if (gtLineMap.isOfflinePoint(srcPointCode)) {
             dstPointCode = gtLineMap.getValueByKey(srcPointCode);
         } else {
-            throw new BadRequestException(srcPointCode + "点位不存在,请核实");
+            return srcPointCode + "点位不存在,请核实!";
         }
 
-
         // 验证终点是否有任务
-        if (!agvTaskService.findByEndSlotCode(dstPointCode, BizStatus.Fx_Off_Line, "ROLLER_MOVE")) {
+        if (!isEndPointAvailable(dstPointCode, BizStatus.Fx_Off_Line, "ROLLER_MOVE")) {
-            throw new BadRequestException(dstPointCode + "点位有任务，请稍后再试!");
+            return dstPointCode + "点位有任务，请稍后再试!";
         }
 
         // 生成任务
         AgvTask agvTask = agvTaskService.createAgvTask(BizStatus.Fx_Off_Line, null, srcPointCode, dstPointCode, "ROLLER_MOVE");
 
-        // 下发任务
+        return "呼叫成功";
-        kmReService.sendAgvTask(agvTask, kmReService.sendAgvTaskGtJson(agvTask));
+
     }
 
-    private void moveFxBack(TransTask transTask) {
+    private String moveFxBack(TransTask transTask) {
         String srcPointCode = transTask.getPointCode();
         if (!"FX001".equals(srcPointCode)) {
-            throw new BadRequestException("返修点位不正确,请核实");
+            return "返修点位不正确,请核实";
         }
 
         //根据状态查询任务
         List<AgvTask> agvTaskList = agvTaskService.findByStatus(BizStatus.ARRIVED);
         if (agvTaskList.isEmpty()) {
-            throw new BadRequestException("任务还未达到FX001返修点，请稍后再试!");
+            return "AGV还未达到FX001返修点，请稍后再试!";
         }
         AgvTask agvTask = agvTaskList.get(0);
 
         //任务放行
         kmReService.sendAgvTaskToContainer(UrlApi.operationFeedback(), kmReService.operationFeedbackJson(agvTask));
+
+        return "放行成功";
     }
 
-    private void moveJLBack(TransTask transTask) {
+    private String moveJLBack(TransTask transTask) {
         //起点
-        Point srcPoint = pointService.validatePoint(transTask.getPointCode());
+        Point srcPoint = pointRepository.findByCode(transTask.getPointCode());
-        Stock stock = stockService.findByPointCode(srcPoint.getCode());
+        if (srcPoint == null) {
-        if (stock == null) {
+            return transTask.getPointCode() + "点位不存在!";
-            throw new BadRequestException(srcPoint.getCode() + "点位没有货架!");
         }
 
+        //容器
+        Stock stock = stockService.findByPointCode(srcPoint.getCode());
+
         String dstAreaCode = AreaNameDic.XJJLQ.equals(srcPoint.getArea().getName()) ? AreaNameDic.XJFBCQ : AreaNameDic.DJFBCQ;
         List<Point> endPointList = pointService.queryPoints(null, BaseStatus.FREE, BaseStatus.BOX, dstAreaCode);
         if (endPointList.isEmpty()) {
-            throw new BadRequestException(dstAreaCode.equals(AreaNameDic.XJFBCQ) ? "小件翻包存储区" : "大件翻包存储区" + "没有空闲点位!");
+            // 没有空车的处理逻辑
+            if (!isSrcPointAvailable(srcPoint.getCode(), BizStatus.CALL_RETURN, "RACK_MOVE")) {
+                return srcPoint.getCode() + "点位有任务，请稍后再试!";
+            }
+            //生成agv任务进行等待
+            agvTaskService.createAgvTask(BizStatus.CALL_RETURN, stock, srcPoint.getCode(), null, "RACK_MOVE");
+            return dstAreaCode.equals(AreaNameDic.XJFBCQ) ? "小件翻包存储区" : "大件翻包存储区" + "没有空闲点位!";
         }
 
         Point endPoint = endPointList.get(0);
 
-        // 验证终点是否有任务
+        if (!isEndPointAvailable(endPoint.getCode(), BizStatus.CALL_RETURN, "RACK_MOVE")) {
-        if (!agvTaskService.findByEndSlotCode(endPoint.getCode(), BizStatus.CALL_RETURN, "RACK_MOVE")) {
+            return endPoint.getCode() + "点位有任务，请稍后再试!";
-            throw new BadRequestException(endPoint.getCode() + "点位有任务，请稍后再试!");
         }
 
         // 生成任务
         AgvTask agvTask = agvTaskService.createAgvTask(BizStatus.CALL_RETURN, stock, srcPoint.getCode(), endPoint.getCode(), "RACK_MOVE");
+        synchronized (endPoint) {
+            // 更新点位状态
+            pointService.usedPoint(endPoint);
+            //占用容器
+            stockService.usedStock(stock, srcPoint, BaseStatus.USED);
+        }
 
+        return "呼叫成功";
 
     }
 }

youchain-system/src/main/java/com/youchain/businessdata/service/impl/TaskServiceImpl.java

@@ -141,8 +141,8 @@ public class TaskServiceImpl implements TaskService {
     }
 
     @Override
-    public List<Task> findByPickNotAllTask(Long pickId) {
+    public List<Task> findByPickNotAllTask() {
-        return taskRepository.findByPickNotAllTask(pickId);
+        return taskRepository.findByPickNotAllTask();
     }
 
     @Override
@@ -238,9 +238,9 @@ public class TaskServiceImpl implements TaskService {
 
     @Override
     @Transactional(rollbackFor = Exception.class)
-    public void materialPick(Pick pick) {
+    public void materialPick() {
         AgvTask agvTask = null;
-        List<Task> taskList = this.findByPickNotAllTask(pick.getId());
+        List<Task> taskList = this.findByPickNotAllTask();
         for (Task task : taskList) {
             /*生成搬运任务*/
             List<AgvTask> agvTaskList = agvTaskService.findRepeat(task.getSrcStockCode(), task.getSrcPointCode(), task.getDstPointCode());
@@ -257,11 +257,6 @@ public class TaskServiceImpl implements TaskService {
             task.setTaskStatus(agvTask.getStatus());
             taskRepository.save(task);
         }
-
-        /*更新出库单状态*//*
-        pick.setStatus(BizStatus.PICKUP);
-        pickService.update(pick);*/
-
     }
 
     @Override
@@ -301,47 +296,38 @@ public class TaskServiceImpl implements TaskService {
     @Override
     @Transactional(rollbackFor = Exception.class)
     public void callJlTask(Pick pick) {
-        if (pick.getStock() == null) {
+
-            throw new BadRequestException(pick.getGdCode() + "工单未翻包拣货!");
-        }
-        if (pick.getCallPoint() == null) {
-            throw new BadRequestException(pick.getGdCode() + "工单没有叫料请求!");
-        }
         //绑定任务
         List<Task> taskList = this.findByPickAllTask(pick.getId());
         if (taskList.isEmpty()) {
-            throw new BadRequestException(pick.getGdCode() + "没有翻包拣货任务!");
+           return;
         }
 
-        //起点
-        String[] stocks = pick.getStock().split(",");
-        String stockCode = stocks[stocks.length - 1];
-        Stock stock = stockService.validateStock(stockCode);
-        Point srcPoint = stock.getPoint();
 
         //终点
         String[] points = pick.getCallPoint().split(",");
         String endPointCode = points[points.length - 1];
         Point endPoint = pointService.queryPoint(endPointCode, null, null, null);
 
+
+     /*   AgvTask agvTask = agvTaskService.createAgvTask(BizStatus.CALL_PICK, stock, srcPoint.getCode(), endPoint.getCode(), "RACK_MOVE");
+        agvTask.setLineSlotCode(pick.getCode());
+        agvTaskService.update(agvTask);*/
+
+        AgvTask agvTask = null;
+        for (Task task : taskList) {
+            List<AgvTask> agvTasks = agvTaskService.findRepeat(task.getDstStockCode(), task.getDstPointCode(), endPoint.getCode());
+            if (agvTasks.isEmpty()) {
                 //创建任务
-        if (!agvTaskService.findByEndSlotCode(endPoint.getCode(), BizStatus.CALL_PICK, "RACK_MOVE")) {
+                agvTask = agvTaskService.createAgvTask(BizStatus.JL_Back, task.getDstStock(), task.getDstPointCode(), endPoint.getCode(), "RACK_MOVE");
-            throw new BadRequestException(endPoint.getCode() + "点位有任务，请稍后再试!");
-        }
-        AgvTask agvTask = agvTaskService.createAgvTask(BizStatus.CALL_PICK, stock, srcPoint.getCode(), endPoint.getCode(), "RACK_MOVE");
                 agvTask.setLineSlotCode(pick.getCode());
                 agvTaskService.update(agvTask);
-
+            } else {
-
+                agvTask = agvTasks.get(0);
-        for (Task task : taskList) {
+            }
             task.setCallAgvTaskId(agvTask.getId());
             taskRepository.save(task);
         }
-        //起点占用
-        pointService.usedPoint(srcPoint);
-
-        //终点占用
-        pointService.usedPoint(endPoint);
 
     }
 
@@ -619,16 +605,6 @@ public class TaskServiceImpl implements TaskService {
         pickDetail.setPickedQty(pickDetail.getPickedQty() + moveQty);
         pickDetailService.update(pickDetail);
 
-        Pick pick = pickDetail.getPick();
-
-        if (pick.getStock() == null || pick.getStock().length() <= 0) {
-            pick.setStock(dstStock.getCode());
-        } else if (!dstStock.getCode().equals(pick.getStock())) {
-            pick.setStock(pick.getStock() + "," + dstStock.getCode());
-        }
-        pickService.update(pick);
-
-
         //容器占用
         stockService.usedStock(dstStock, dstStock.getPoint(), BaseStatus.USED);
 

youchain-system/src/main/java/com/youchain/modules/quartz/task/blTask.java

@@ -0,0 +1,75 @@
+package com.youchain.modules.quartz.task;
+
+import com.youchain.basicdata.domain.Point;
+import com.youchain.basicdata.domain.Stock;
+import com.youchain.basicdata.service.StockService;
+import com.youchain.businessdata.domain.AgvTask;
+import com.youchain.businessdata.service.AgvTaskService;
+import com.youchain.businessdata.service.KMReService;
+import com.youchain.businessdata.service.PickService;
+import com.youchain.businessdata.service.TaskService;
+import com.youchain.exception.BadRequestException;
+import com.youchain.utils.BizStatus;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+import java.util.List;
+
+/**
+ * 备料任务
+ */
+@Slf4j
+@Service
+public class blTask {
+
+
+    @Autowired
+    public StockService stockService;
+
+    @Autowired
+    public PickService pickService;
+
+    @Autowired
+    public TaskService taskService;
+
+    @Autowired
+    public AgvTaskService agvTaskService;
+
+    @Autowired
+    public KMReService kmReService;
+
+    // 定义异常信息常量
+    private static final String NO_EMPTY_SHELVES_ERROR_MSG = "没有备料任务!";
+
+    // 定义一个对象作为锁
+    private final Object lock = new Object();
+
+    /**
+     * 轮询下发备料任务、叫料任务、
+     */
+    public void sendAgvBl() {
+        List<AgvTask> agvTaskList = agvTaskService.findOpenByAgvTask(BizStatus.PICK);
+        if (agvTaskList.isEmpty()) {
+            throw new BadRequestException(NO_EMPTY_SHELVES_ERROR_MSG);
+        }
+        synchronized (lock) {
+            for (AgvTask agvTask : agvTaskList) {
+                processAgvTask(agvTask);
+            }
+        }
+
+    }
+
+    private void processAgvTask(AgvTask agvTask) {
+        //目标点没有托盘继续下发下一个任务
+        String endSlotCode = agvTask.getEndSlotCode();
+        Stock stock = stockService.findByPointCode(endSlotCode);
+        if (stock == null) {
+            boolean isTaskFound = agvTaskService.findByCcEndSlotCode(endSlotCode, BizStatus.PICK, "FORKLIFT_MOVE");
+            if (isTaskFound) {
+                kmReService.sendAgvTask(agvTask, kmReService.sendAgvTaskCcJson(agvTask));
+            }
+        }
+    }
+}

youchain-system/src/main/java/com/youchain/modules/quartz/task/cpLineTask.java

@@ -0,0 +1,96 @@
+package com.youchain.modules.quartz.task;
+
+import com.youchain.basicdata.domain.Point;
+import com.youchain.basicdata.service.PointService;
+import com.youchain.basicdata.service.StockService;
+import com.youchain.businessdata.domain.AgvTask;
+import com.youchain.businessdata.service.AgvTaskService;
+import com.youchain.businessdata.service.KMReService;
+import com.youchain.exception.BadRequestException;
+import com.youchain.utils.AreaNameDic;
+import com.youchain.utils.BaseStatus;
+import com.youchain.utils.BizStatus;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+import java.util.List;
+
+/**
+ * 成品下线任务
+ */
+@Slf4j
+@Service
+public class cpLineTask {
+
+    @Autowired
+    public StockService stockService;
+
+    @Autowired
+    private PointService pointService;
+
+    @Autowired
+    public AgvTaskService agvTaskService;
+
+    @Autowired
+    public KMReService kmReService;
+
+    // 定义异常信息常量
+    private static final String NO_EMPTY_SHELVES_ERROR_MSG = "成品入库区和成品入库缓存区都没有空闲点位，请及时处理!";
+    // 定义一个对象作为锁
+    private final Object lock = new Object();
+
+    public void sendAgvCpOffLine() {
+        // 使用同步块确保线程安全
+        synchronized (lock) {
+            // 获取处于特定业务状态的AGV任务列表
+            List<AgvTask> agvTaskList = agvTaskService.findOpenByAgvTask(BizStatus.Cp_Off_Line);
+            // 如果任务列表为空，直接返回，避免不必要的处理
+            if (agvTaskList.isEmpty()) {
+                return;
+            }
+            // 遍历AGV任务列表
+            for (AgvTask agvTask : agvTaskList) {
+                processAgvTask(agvTask);
+            }
+        }
+    }
+
+    private void processAgvTask(AgvTask agvTask) {
+        if (agvTask.getEndSlotCode() != null) {
+            kmReService.sendAgvTask(agvTask, kmReService.sendAgvTaskHjJson(agvTask));
+        } else {
+            // 查找可用的结束点
+            Point endPoint = findAvailableEndPoint();
+            if (endPoint != null) {
+                updateAgvTaskWithEndPoint(agvTask, endPoint);
+                kmReService.sendAgvTask(agvTask, kmReService.sendAgvTaskHjJson(agvTask));
+            } else {
+                // 若未找到可用结束点，抛出异常
+                throw new BadRequestException(NO_EMPTY_SHELVES_ERROR_MSG);
+            }
+        }
+    }
+
+    private void updateAgvTaskWithEndPoint(AgvTask agvTask, Point endPoint) {
+        // 设置任务的结束插槽代码
+        agvTask.setEndSlotCode(endPoint.getCode());
+        // 更新AGV任务信息
+        agvTaskService.update(agvTask);
+    }
+
+    /**
+     * 查找可用的终点点位，优先从成品入库区查找，若没有则从成品下线缓存区查找
+     *
+     * @return 可用的终点点位，如果没有则返回null
+     */
+    private Point findAvailableEndPoint() {
+        List<Point> endPointList = pointService.queryPoints(null, BaseStatus.FREE, BaseStatus.BOX, AreaNameDic.CPRKQ);
+        if (endPointList.isEmpty()) {
+            endPointList = pointService.queryPoints(null, BaseStatus.FREE, BaseStatus.BOX, AreaNameDic.CPXXHC);
+        }
+        return endPointList.isEmpty() ? null : endPointList.get(0);
+    }
+
+
+}

youchain-system/src/main/java/com/youchain/modules/quartz/task/cpUpTask.java

@@ -0,0 +1,91 @@
+package com.youchain.modules.quartz.task;
+
+import com.youchain.basicdata.domain.Stock;
+import com.youchain.basicdata.service.StockService;
+import com.youchain.businessdata.domain.AgvTask;
+import com.youchain.businessdata.service.AgvTaskService;
+import com.youchain.businessdata.service.KMReService;
+import com.youchain.exception.BadRequestException;
+import com.youchain.utils.AreaNameDic;
+import com.youchain.utils.BaseStatus;
+import com.youchain.utils.BizStatus;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+import java.util.List;
+
+/**
+ * 成品上线任务
+ */
+@Slf4j
+@Service
+public class cpUpTask {
+
+    @Autowired
+    public StockService stockService;
+
+    @Autowired
+    public AgvTaskService agvTaskService;
+
+    @Autowired
+    public KMReService kmReService;
+
+    // 定义异常信息常量
+    private static final String NO_EMPTY_SHELVES_ERROR_MSG = "成品入库区和成品入库缓存区都没有空货架，请及时解绑容器!";
+
+    private final Object lock = new Object();
+
+    /**
+     * 轮询下发成品上线任务
+     */
+    public void sendAgvCpOffUp() {
+        synchronized (lock) {
+            List<AgvTask> agvTaskList = agvTaskService.findOpenByAgvTask(BizStatus.Cp_Off_Up);
+            if (agvTaskList.isEmpty()) {
+                return;
+            }
+            // 遍历AGV任务列表
+            for (AgvTask agvTask : agvTaskList) {
+                processAgvTask(agvTask);
+            }
+        }
+    }
+
+    private List<Stock> getEmptyStockList() {
+        List<Stock> emptyStockList = stockService.findByFreeOrUsedStock(AreaNameDic.CPRKHCQ, BaseStatus.FREE);
+        if (emptyStockList.isEmpty()) {
+            emptyStockList = stockService.findByFreeOrUsedStock(AreaNameDic.CPRKQ, BaseStatus.FREE);
+        }
+        return emptyStockList;
+    }
+
+    private void processAgvTask(AgvTask agvTask) {
+        if (agvTask.getStockCode() != null && agvTask.getStartSlotCode() != null) {
+            //直接下发
+            kmReService.sendAgvTask(agvTask, kmReService.sendAgvTaskHjJson(agvTask));
+        } else {
+            //排队任务 查询成品入库区是否有空车
+            List<Stock> stocks = getEmptyStockList();
+            if (!stocks.isEmpty()) {
+                // 获取第一个空库存
+                Stock stock = stocks.get(0);
+                // 更新AGV任务的库存代码和起始插槽代码
+                updateAgvTask(agvTask, stock);
+                kmReService.sendAgvTask(agvTask, kmReService.sendAgvTaskHjJson(agvTask));
+            } else {
+                // 若没有空货架，抛出异常
+                throw new BadRequestException(NO_EMPTY_SHELVES_ERROR_MSG);
+            }
+        }
+    }
+
+    private void updateAgvTask(AgvTask agvTask, Stock stock) {
+        // 设置AGV任务的库存代码
+        agvTask.setStockCode(stock.getCode());
+        // 设置AGV任务的起始插槽代码
+        agvTask.setStartSlotCode(stock.getPoint() == null ? null : stock.getPoint().getCode());
+        // 更新AGV任务
+        agvTaskService.update(agvTask);
+    }
+}

youchain-system/src/main/java/com/youchain/modules/quartz/task/jlBackTask.java

@@ -0,0 +1,103 @@
+package com.youchain.modules.quartz.task;
+
+import com.youchain.basicdata.domain.Point;
+import com.youchain.basicdata.domain.Stock;
+import com.youchain.basicdata.repository.PointRepository;
+import com.youchain.basicdata.service.PointService;
+import com.youchain.basicdata.service.StockService;
+import com.youchain.businessdata.domain.AgvTask;
+import com.youchain.businessdata.service.AgvTaskService;
+import com.youchain.businessdata.service.KMReService;
+import com.youchain.exception.BadRequestException;
+import com.youchain.utils.AreaNameDic;
+import com.youchain.utils.BaseStatus;
+import com.youchain.utils.BizStatus;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+import java.util.List;
+
+/**
+ * 叫料返空任务
+ */
+@Slf4j
+@Service
+public class jlBackTask {
+
+    @Autowired
+    public StockService stockService;
+
+    @Autowired
+    private PointService pointService;
+
+    @Autowired
+    public AgvTaskService agvTaskService;
+
+    @Autowired
+    public KMReService kmReService;
+
+    // 定义异常信息常量
+    private static final String NO_EMPTY_SHELVES_ERROR_MSG = "区没有空闲点位，请及时处理!";
+
+    // 定义一个对象作为锁
+    private final Object lock = new Object();
+
+    public void sendAgvJlBack() {
+        // 使用同步块确保线程安全
+        synchronized (lock) {
+            // 获取处于特定业务状态的AGV任务列表
+            List<AgvTask> agvTaskList = agvTaskService.findOpenByAgvTask(BizStatus.JL_Back);
+            // 如果任务列表为空，直接返回，避免不必要的处理
+            if (agvTaskList.isEmpty()) {
+                return;
+            }
+            // 遍历AGV任务列表
+            for (AgvTask agvTask : agvTaskList) {
+                processAgvTask(agvTask);
+            }
+        }
+    }
+
+    private void processAgvTask(AgvTask agvTask) {
+        if (agvTask.getEndSlotCode() != null) {
+            kmReService.sendAgvTask(agvTask, kmReService.sendAgvTaskHjJson(agvTask));
+        } else {
+            // 查找可用的结束点
+            String areaName = getAreaName(agvTask.getStartSlotCode());
+            Point endPoint = findAvailableEndPoint(areaName);
+            if (endPoint != null) {
+                updateAgvTaskWithEndPoint(agvTask, endPoint);
+            } else {
+                // 若未找到可用结束点，抛出异常
+                throw new BadRequestException(areaName+NO_EMPTY_SHELVES_ERROR_MSG);
+            }
+        }
+    }
+
+    private void updateAgvTaskWithEndPoint(AgvTask agvTask, Point endPoint) {
+        // 设置任务的结束插槽代码
+        agvTask.setEndSlotCode(endPoint.getCode());
+        // 更新AGV任务信息
+        agvTaskService.update(agvTask);
+    }
+
+    private String getAreaName(String pointCode) {
+        Point srcPoint = pointService.validatePoint(pointCode);
+        Stock stock = stockService.findByPointCode(srcPoint.getCode());
+        String areaName = AreaNameDic.XJJLQ.equals(srcPoint.getArea().getName()) ? AreaNameDic.XJFBCQ : AreaNameDic.DJFBCQ;
+        return areaName;
+    }
+
+    /**
+     * 查找可用的终点点位，优先从成品入库区查找，若没有则从成品下线缓存区查找
+     *
+     * @return 可用的终点点位，如果没有则返回null
+     */
+    private Point findAvailableEndPoint(String areaName) {
+        String dstAreaCode = AreaNameDic.XJJLQ.equals(areaName) ? AreaNameDic.XJFBCQ : AreaNameDic.DJFBCQ;
+        List<Point> endPointList = pointService.queryPoints(null, BaseStatus.FREE, BaseStatus.BOX, dstAreaCode);
+
+        return endPointList.isEmpty() ? null : endPointList.get(0);
+    }
+}

youchain-system/src/main/java/com/youchain/modules/quartz/task/jlTask.java

@@ -0,0 +1,67 @@
+package com.youchain.modules.quartz.task;
+
+import com.youchain.basicdata.domain.Point;
+import com.youchain.basicdata.domain.Stock;
+import com.youchain.basicdata.service.StockService;
+import com.youchain.businessdata.domain.AgvTask;
+import com.youchain.businessdata.service.AgvTaskService;
+import com.youchain.businessdata.service.KMReService;
+import com.youchain.businessdata.service.PickService;
+import com.youchain.businessdata.service.TaskService;
+import com.youchain.exception.BadRequestException;
+import com.youchain.utils.BizStatus;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+import java.util.List;
+
+/**
+ * 备料任务
+ */
+@Slf4j
+@Service
+public class jlTask {
+
+
+    @Autowired
+    public StockService stockService;
+
+    @Autowired
+    public PickService pickService;
+
+    @Autowired
+    public TaskService taskService;
+
+    @Autowired
+    public AgvTaskService agvTaskService;
+
+    @Autowired
+    public KMReService kmReService;
+
+    // 定义异常信息常量
+    private static final String NO_EMPTY_SHELVES_ERROR_MSG = "没有叫料任务!";
+
+    // 定义一个对象作为锁
+    private final Object lock = new Object();
+
+    /**
+     * 下发叫料任务
+     */
+    public void sendAgvJl() {
+        List<AgvTask> agvTaskList = agvTaskService.findOpenByAgvTask(BizStatus.CALL_PICK);
+        if (agvTaskList.isEmpty()) {
+            throw new BadRequestException(NO_EMPTY_SHELVES_ERROR_MSG);
+        }
+        synchronized (lock) {
+            for (AgvTask agvTask : agvTaskList) {
+                processAgvTask(agvTask);
+            }
+        }
+
+    }
+
+    private void processAgvTask(AgvTask agvTask) {
+        kmReService.sendAgvTask(agvTask, kmReService.sendAgvTaskHjJson(agvTask));
+    }
+}

youchain-system/src/main/java/com/youchain/modules/quartz/task/pickTask.java

@@ -48,7 +48,7 @@ public class pickTask {
      * 分配出库单
      */
     public void allocatePick() {
-        List<String> statuses = Arrays.asList(BizStatus.OPEN, BizStatus.ASSIGN);
+        List<String> statuses = Arrays.asList(BizStatus.OPEN, BizStatus.ASSIGN, BizStatus.PICKUP);
         List<Pick> pickList = pickService.findByPickStatus(statuses, null);
         if (pickList.isEmpty()) {
             throw new BadRequestException("无待分配的成品出库单,分配失败!");
@@ -59,31 +59,18 @@ public class pickTask {
             }
         }
 
+        //生成备料任务
+        taskService.materialPick();
+
     }
 
+
+
     /**
-     * 轮询已分配的出库单，生成备料任务
+     * 生成叫料任务
      */
-    public void pickAgvTask() {
+    public void createJlTask() {
-        /*查询分配完成的出库单*/
+     /*   *//*查询拣货完成完成的出库单*//*
-        List<String> statuses = Arrays.asList(BizStatus.ASSIGN, BizStatus.ALLOCATE);
-        List<Pick> pickList = pickService.findByPickStatus(statuses, null);
-        if (pickList.isEmpty()) {
-            throw new BadRequestException("无已分配的出库单,下发任务失败!");
-        }
-        for (Pick pick : pickList) {
-            synchronized (pick) {
-                taskService.materialPick(pick);
-            }
-
-        }
-    }
-
-    /**
-     * 生成叫料搬运任务
-     */
-    public void callJlTask() {
-        /*查询拣货完成完成的出库单*/
         List<String> statuses = Arrays.asList(BizStatus.PICKUP, BizStatus.PICK_ALL);
         List<Pick> pickList = pickService.findByPickStatus(statuses, true);
         if (pickList.isEmpty()) {
@@ -93,36 +80,7 @@ public class pickTask {
             synchronized (pick) {
                 taskService.callJlTask(pick);
             }
-
+        }*/
-        }
-    }
-
-    /**
-     * 轮询下发备料任务、叫料任务、叫料返库任务
-     */
-    public void sendTaskBlAndJl() {
-        List<AgvTask> agvTaskList = agvTaskService.findOpenByAgvTask();
-        if (agvTaskList.isEmpty()) {
-            throw new BadRequestException("无备料任务或无叫料任务!");
-        }
-        for (AgvTask agvTask : agvTaskList) {
-            synchronized (agvTask) {
-                if (BizStatus.PICK.equals(agvTask.getType())) {
-                    //目标点没有托盘继续下发下一个任务
-                    String endSlotCode = agvTask.getEndSlotCode();
-                    Stock stock = stockService.findByPointCode(endSlotCode);
-                    if (stock == null) {
-                        boolean isTaskFound = agvTaskService.findByCcEndSlotCode(endSlotCode, BizStatus.PICK, "FORKLIFT_MOVE");
-                        if (isTaskFound) {
-                            kmReService.sendAgvTask(agvTask, kmReService.sendAgvTaskCcJson(agvTask));
-                        }
-                    }
-                } else {
-                    kmReService.sendAgvTask(agvTask, kmReService.sendAgvTaskHjJson(agvTask));
-                }
-            }
-
-        }
     }
 
 }

youchain-system/src/main/java/com/youchain/utils/BizStatus.java

@@ -142,7 +142,7 @@ public interface BizStatus {
     String Fx_Back = "Fx_Back";
 
     /**
-     * 任务类型-返修载具送回
+     * 任务类型-叫料返空
      */
     String JL_Back = "JL_Back";