代码更新：

1. createWork实现
2. doWork实现
3. 方法向service层移动

src/main/java/com/wms/controller/JobComponent.java

@@ -11,6 +11,7 @@ import com.wms.entity.table.Stand;
 import com.wms.entity.table.Task;
 import com.wms.entity.table.WmsLog;
 import com.wms.service.*;
+import com.wms.service.business.IWorkService;
 import com.wms.utils.HttpUtils;
 import com.wms.utils.StringUtils;
 import com.wms.utils.WmsUtils;
@@ -59,6 +60,10 @@ public class JobComponent {
      * 站台服务
      */
     private final StandService standService;
+    /**
+     * 工作服务
+     */
+    private final IWorkService workService;
 
 
     /**
@@ -68,55 +73,36 @@ public class JobComponent {
 //    @Scheduled(fixedDelay = 2000)
     public void executeTasks() {
         // 发送正常任务
-        sendCommonTask();
+        sendCommonTasks();
+        // 发送拣选任务
+        sendPickTasks();
         // 针对重复入库的任务，发送新的目的地
         solveDuplicateTask();
     }
 
     /**
-     * 执行备料任务的轮询，处理站台任务
+     * 检测工作
      */
 //    @Scheduled(fixedDelay = 2000)
     @Transactional(isolation = Isolation.REPEATABLE_READ, propagation = Propagation.REQUIRED)
-    public void checkForOrders() {
+    public void detectWork() {
         try {
-
-        } catch (Exception e) {
-            // 回滚事务
-            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
-        }
             // 轮询工作站台，判断是否需要下发任务
             List<Stand> stands = standService.list(new LambdaQueryWrapper<Stand>()
                     .eq(Stand::getStandType, 2));
             for (Stand workStation : stands) {
-            // TODO 判断当前站台还有没有未完成的任务
-            // 1.有未完成的任务，继续做未完成的
-            doTask(workStation.getStandId());
-            // 2.没有任务，生成新的任务
-            createTask(workStation.getStandId());
+                // 创建工作
+                workService.createWork(workStation.getStandId());
+                // 执行工作
+                workService.doWork(workStation.getStandId());
+            }
+        } catch (Exception e) {
+            // 回滚事务
+            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
+            logger.error("检测工作时发生错误：{}", convertJsonString(e));
         }
     }
 
-    /**
-     * 做备料任务
-     */
-    private void doTask(String workStationId) {
-        // TODO 生成出库任务---针对未完成的任务
-        // 1. 判断堵塞阈值，超过则不生成任务
-        // 2. 已经出库的物料不再重复下发任务
-        // 3. 生成某个箱子的出库任务后，对应箱子的所有物料添加进出库列表
-    }
-
-    /**
-     * 做备料任务
-     */
-    private void createTask(String workStationId) {
-        // TODO 联表查询  要加一个一个order，确保序号靠前的工单先做
-        // 装载机机型 工站配置-工作站台+工位+机型+大工位+开工时间调整-----DBS-顺序-工单+开工时间-----工单-工单+工位+物料号+数量
-        // 平地机机型
-    }
-
-
 //    /**
 //     * 每天查询一次是否有过期的库存
 //     * 每天晚上8点执行一次
@@ -179,7 +165,82 @@ public class JobComponent {
     /**
      * 发送正常的任务
      */
-    private void sendCommonTask() {
+    private void sendCommonTasks() {
+        try {
+            // 检索任务表---新建未下发的任务
+            LambdaQueryWrapper<Task> waitForDistributeTaskQuery = new LambdaQueryWrapper<Task>()
+                    .eq(Task::getTaskStatus, WmsTaskStatus.NEW.getCode());
+            List<TaskDto> allTasks = BeanUtil.copyToList(taskService.list(waitForDistributeTaskQuery), TaskDto.class);
+            // 需要发送给wcs的任务列表
+            List<WcsTaskRequest> request = new ArrayList<>();
+            // 已经下发的任务组列表
+            List<String> taskGroupIds = new ArrayList<>();
+            if (!allTasks.isEmpty()) {
+                for (TaskDto task : allTasks) {
+                    if (StringUtils.isNotEmpty(task.getPreTask())) {// 当前任务具有前置任务
+                        // 查询一下前置的任务有没有存在，存在则不下发
+                        if (taskService.exists(new LambdaQueryWrapper<Task>().eq(Task::getTaskId, task.getPreTask()))) {
+                            continue;
+                        }
+                    }
+                    if (taskGroupIds.contains(task.getTaskGroup())) {
+                        // 已经发送过的任务组，直接设置状态
+                        task.setTaskStatus(WmsTaskStatus.WAIT.getCode());
+                    }
+                    // 创建发送的任务
+                    WcsTaskRequest tempTask = new WcsTaskRequest();
+                    tempTask.setTaskId(task.getTaskGroup());
+                    if (Objects.equals(task.getTaskType(), TaskType.INVENTORY.getCode())) {
+                        tempTask.setTaskType(TaskType.OUT.getCode());
+                    } else {
+                        tempTask.setTaskType(task.getTaskType());
+                    }
+                    tempTask.setOrigin(task.getOrigin());
+                    tempTask.setDestination(task.getDestination());
+                    tempTask.setVehicleNo(task.getVehicleId());
+                    tempTask.setVehicleSize(task.getVehicleSize());
+                    tempTask.setWeight(task.getWeight());
+                    tempTask.setPriority(task.getTaskPriority());
+                    request.add(tempTask);
+                    task.setTaskStatus(WmsTaskStatus.WAIT.getCode());
+                    // 已经发送过的任务组
+                    taskGroupIds.add(task.getTaskGroup());
+                }
+                if (request.size() == 0) {
+                    return;
+                }
+                // 发送任务
+                String url = configMap.get(ConfigMapKeyEnum.URL_WCS_TASK.getConfigKey());
+                if (url != null) {
+                    logger.info("向WCS发送任务，地址：{}，请求详情：{}", url, convertJsonString(request));
+                    ResponseEntity result = JSON.parseObject(HttpUtils.sendHttpPostWithoutToken(url, convertJsonString(request)), ResponseEntity.class);
+                    try {
+                        logService.save(new WmsLog(WmsUtils.generateId("LOG_"), "向WCS发送任务", "SetStackerTask", JSON.toJSONString(request), JSON.toJSONString(result), url, LocalDateTime.now(), "WMS"));
+                    } catch (Exception e) {
+                        logger.error("插入日志错误");
+                    }
+                    if (result != null && Objects.equals(ResponseCode.OK.getCode(), result.getCode())) {
+                        taskService.saveBatch(BeanUtil.copyToList(allTasks, Task.class));
+                    } else {
+                        if (result != null) {
+                            logger.error("存在错误：{}", result.getMessage());
+                        } else {
+                            logger.error("请求无返回");
+                        }
+                    }
+                } else {
+                    logger.error("WCS发送任务地址为空");
+                }
+            }
+        } catch (Exception exception) {
+            logger.error("向Wcs发送任务时发生异常：{}", convertJsonString(exception));
+        }
+    }
+
+    /**
+     * 发送拣选任务
+     */
+    private void sendPickTasks() {
         try {
             // 检索任务表---新建未下发的任务
             LambdaQueryWrapper<Task> waitForDistributeTaskQuery = new LambdaQueryWrapper<Task>()

src/main/java/com/wms/entity/table/GoodsToStation.java

@@ -12,6 +12,11 @@ import java.math.BigDecimal;
 @Data
 @TableName(value = "tbl_app_goods_to_station", autoResultMap = true)
 public class GoodsToStation {
+    /**
+     * 主键
+     */
+    @TableField("config_id")
+    private String configId;
     /**
      * 工作站台
      */

src/main/java/com/wms/entity/table/OutsideVehicles.java

@@ -1,6 +1,7 @@
 package com.wms.entity.table;
 
 import com.baomidou.mybatisplus.annotation.TableField;
+import com.baomidou.mybatisplus.annotation.TableId;
 import com.baomidou.mybatisplus.annotation.TableName;
 import lombok.Data;
 
@@ -10,8 +11,13 @@ import java.math.BigDecimal;
  * 当前出库中的载具和物料
  */
 @Data
-@TableName(value = "tbl_app_outside_vehicles")
+@TableName(value = "tbl_app_outside_vehicles", autoResultMap = true)
 public class OutsideVehicles {
+    /**
+     * id
+     */
+    @TableId("outside_id")
+    private String outsideId;
     /**
      * 载具号
      */

src/main/java/com/wms/service/business/IValidateService.java

@@ -0,0 +1,10 @@
+package com.wms.service.business;
+
+import com.wms.entity.app.request.TaskInRequest;
+
+/**
+ * 验证服务接口
+ */
+public interface IValidateService {
+    String validateTaskInRequest(TaskInRequest taskInRequest);
+}

src/main/java/com/wms/service/business/serviceImplements/ValidateServiceImplements.java

@@ -0,0 +1,100 @@
+package com.wms.service.business.serviceImplements;
+
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.wms.constants.enums.ConfigMapKeyEnum;
+import com.wms.constants.enums.TaskInValidationEnum;
+import com.wms.constants.enums.TaskType;
+import com.wms.constants.enums.VehicleStatus;
+import com.wms.entity.app.request.GoodsInRequest;
+import com.wms.entity.app.request.TaskInRequest;
+import com.wms.entity.table.Task;
+import com.wms.entity.table.Vehicle;
+import com.wms.service.GoodsService;
+import com.wms.service.StandService;
+import com.wms.service.TaskService;
+import com.wms.service.VehicleService;
+import com.wms.service.business.IValidateService;
+import com.wms.utils.StringUtils;
+import lombok.RequiredArgsConstructor;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+import java.math.BigDecimal;
+
+import static com.wms.config.InitLocalConfig.configMap;
+
+/**
+ * 验证服务接口的实现
+ */
+@Service
+@RequiredArgsConstructor(onConstructor = @__(@Autowired))
+public class ValidateServiceImplements implements IValidateService {
+    private final Logger logger = LoggerFactory.getLogger(this.getClass());// 日志
+    private final VehicleService vehicleService;
+    private final TaskService taskService;
+    private final StandService standService;
+    private final GoodsService goodsService;
+    @Override
+    public String validateTaskInRequest(TaskInRequest taskInRequest) {
+        if (taskInRequest == null) {
+            return TaskInValidationEnum.NO_REQUEST_BODY.getErrorMessage();
+        }
+        // 验证载具号
+        if (StringUtils.isEmpty(taskInRequest.getVehicleId())) {
+            return TaskInValidationEnum.NO_VEHICLE_ID.getErrorMessage();
+        }
+        // 验证载具号是否重复入库
+        if (vehicleService.exists(new LambdaQueryWrapper<Vehicle>().eq(Vehicle::getVehicleId, taskInRequest.getVehicleId())
+                .and(wrapper -> wrapper.eq(Vehicle::getVehicleStatus, VehicleStatus.ON.getCode())
+                        .or().eq(Vehicle::getVehicleStatus, VehicleStatus.MOVE.getCode())))) {
+            return TaskInValidationEnum.DUPLICATE_VEHICLE_ID.getErrorMessage();
+        }
+        // 验证当前载具是否已经有入库任务
+        if (taskService.exists(new LambdaQueryWrapper<Task>().eq(Task::getVehicleId, taskInRequest.getVehicleId())
+                .and(wrapper -> wrapper.eq(Task::getTaskType, TaskType.IN.getCode())))) {
+            return TaskInValidationEnum.DUPLICATE_VEHICLE_ID.getErrorMessage();
+        }
+        // 验证重量
+        if (taskInRequest.getTotalWeight() == null) {
+            return TaskInValidationEnum.NO_WEIGHT.getErrorMessage();
+        }
+        BigDecimal max_weight = BigDecimal.valueOf(10000000);
+        try {
+            max_weight = new BigDecimal(configMap.get(ConfigMapKeyEnum.MAX_WEIGHT.getConfigKey()));
+        } catch (Exception e) {
+            logger.error("转换配置项---最大承重，发生错误");
+        }
+        if (taskInRequest.getTotalWeight().compareTo(max_weight) > 0) {
+            // 超重
+            return TaskInValidationEnum.OVER_WEIGHT.getErrorMessage();
+        }
+        // 验证起点
+        if (StringUtils.isEmpty(taskInRequest.getOriginPoint())) {
+            return TaskInValidationEnum.NO_IN_POINT.getErrorMessage();
+        } else {
+            if (!standService.validateStand(taskInRequest.getOriginPoint(), TaskType.IN.getCode())) {
+                return TaskInValidationEnum.ERROR_IN_POINT.getErrorMessage();
+            }
+        }
+        // 验证物料信息
+        if (taskInRequest.getGoodsList() != null && !taskInRequest.getGoodsList().isEmpty()) {
+            for (GoodsInRequest goodsInRequest : taskInRequest.getGoodsList()) {
+                // 验证物料编号
+                if (StringUtils.isEmpty(goodsInRequest.getGoodsId())) {
+                    return TaskInValidationEnum.NO_GOODS_ID.getErrorMessage();
+                } else {
+                    if (!goodsService.validateGoodsId(goodsInRequest.getGoodsId())) {
+                        return TaskInValidationEnum.ERROR_GOODS_ID.getErrorMessage();
+                    }
+                }
+                // 验证数量
+                if (goodsInRequest.getGoodsNum() == null || goodsInRequest.getGoodsNum().compareTo(BigDecimal.ZERO) <= 0) {
+                    return TaskInValidationEnum.ERROR_GOODS_NUM.getErrorMessage();
+                }
+            }
+        }
+        return TaskInValidationEnum.OK.getErrorMessage();
+    }
+}

src/main/java/com/wms/service/business/serviceImplements/WorkServiceImplements.java

@@ -2,7 +2,12 @@ package com.wms.service.business.serviceImplements;
 
 import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
+import com.wms.constants.enums.StockStatus;
+import com.wms.constants.enums.TaskType;
+import com.wms.constants.enums.VehicleStatus;
+import com.wms.constants.enums.WmsTaskStatus;
 import com.wms.entity.app.dto.WorkCenterAndOrderDto;
+import com.wms.entity.app.dto.extend.StockDetailInfo;
 import com.wms.entity.table.*;
 import com.wms.service.*;
 import com.wms.service.business.IWorkService;
@@ -15,9 +20,9 @@ import org.springframework.stereotype.Service;
 import java.math.BigDecimal;
 import java.time.LocalDateTime;
 import java.util.*;
-import java.util.stream.Collectors;
 
 import static com.wms.config.InitLocalConfig.configMap;
+import static com.wms.utils.WmsUtils.generateId;
 
 /**
  * 工作服务接口的实现
@@ -33,6 +38,10 @@ public class WorkServiceImplements implements IWorkService {
     private final ELocationConfigService eLocationConfigService;// 电子标签配置服务
     private final GoodsToStationService goodsToStationService;// 站台要料服务
     private final OutsideVehiclesService outsideVehiclesService;// 流转中的箱子服务
+    private final StockService stockService;// 库存服务
+    private final TaskService taskService;// 任务服务
+    private final PickTaskService pickTaskService;// 拣选任务服务
+    private final VehicleService vehicleService;// 载具服务
     private final List<String> workCreatingStations = new ArrayList<>();// 当前正在创建任务的站台
     private final List<String> workDoingStations = new ArrayList<>();// 当前正在执行任务的站台
     @Override
@@ -176,16 +185,96 @@ public class WorkServiceImplements implements IWorkService {
                     .eq(GoodsToStation::getDistributeStatus, 0)
                     .or().eq(GoodsToStation::getDistributeStatus, 1));
             for (GoodsToStation goodsToStation : goodsToStationList) {
+                // 当前物料当前站台需求数量
+                BigDecimal needNum = goodsToStation.getTotalNum().subtract(goodsToStation.getDistributedNum());
                 // 判断当前物料是否在流转中
                 List<OutsideVehicles> outsideVehiclesList = outsideVehiclesService.list(new LambdaQueryWrapper<OutsideVehicles>()
                         .eq(OutsideVehicles::getGoodsId, goodsToStation.getGoodsId())
                         .gt(OutsideVehicles::getRemainNum, 0));
+                List<OutsideVehicles> usedOutsideVehiclesList = new ArrayList<>();
+                if (outsideVehiclesList != null && !outsideVehiclesList.isEmpty()) {
+                    // 存在流转中的料箱
+                    for (OutsideVehicles outsideVehicle : outsideVehiclesList) {
+                        if (needNum.compareTo(BigDecimal.ZERO) <= 0) {// 需求数量小于等于0
+                            break;
                         }
-            // 查流转中的箱子和物料表
-
-            // 判断是否需要生成出库任务
-            // 生成拣货任务
-            // 修改状态
+                        if (outsideVehicle.getRemainNum().compareTo(needNum) > 0) {
+                            // 当前箱子剩余物料数量多于需求数量
+                            needNum = BigDecimal.ZERO;
+                            outsideVehicle.setRemainNum(outsideVehicle.getRemainNum().subtract(needNum));
+                            usedOutsideVehiclesList.add(outsideVehicle);
+                            break;
+                        } else {
+                            // 当前箱子物料剩余数量少于需求数量
+                            needNum = needNum.subtract(outsideVehicle.getRemainNum());
+                            outsideVehicle.setRemainNum(BigDecimal.ZERO);
+                            usedOutsideVehiclesList.add(outsideVehicle);
+                        }
+                    }
+                    // 更新流转箱表
+                    outsideVehiclesService.updateBatchById(usedOutsideVehiclesList);
+                    // 生成拣选任务
+                    List<String> vehicleIds = usedOutsideVehiclesList.stream().map(OutsideVehicles::getVehicleId).toList();
+                    createPickTasks(vehicleIds, workStation);
+                }
+                // 判断此时需求数量是否为0
+                if (needNum.compareTo(BigDecimal.ZERO) <= 0) {
+                    // 分配完成
+                    goodsToStation.setDistributeStatus(2);
+                } else {
+                    // 查询库存，判断数量是否重组
+                    List<Stock> stockList = stockService.list(new LambdaQueryWrapper<Stock>()
+                            .eq(Stock::getStockStatus, StockStatus.OK.getCode())
+                            .apply("goods_related ->> '$.goodsId' = {0}", goodsToStation.getGoodsId()));
+                    if (stockList != null && !stockList.isEmpty()) {
+                        List<Stock> waitForOutStockList = new ArrayList<>();
+                        // 尝试生成出库任务
+                        for (Stock tempStock : stockList) {
+                            if (needNum.compareTo(BigDecimal.ZERO) <= 0) {// 需求数量小于等于0
+                                break;
+                            }
+                            if (tempStock.getGoodsRelated().getRemainNum().compareTo(needNum) > 0) {
+                                // 当前箱子剩余物料数量多于需求数量
+                                needNum = BigDecimal.ZERO;
+                                // 设置剩余数量
+                                StockDetailInfo goodsRelated = tempStock.getGoodsRelated();
+                                goodsRelated.setRemainNum(goodsRelated.getRemainNum().subtract(needNum));
+                                tempStock.setGoodsRelated(goodsRelated);
+                                waitForOutStockList.add(tempStock);
+                                break;
+                            } else {
+                                // 当前箱子物料剩余数量少于需求数量
+                                needNum = needNum.subtract(tempStock.getGoodsRelated().getRemainNum());
+                                // 设置剩余数量
+                                StockDetailInfo goodsRelated = tempStock.getGoodsRelated();
+                                goodsRelated.setRemainNum(BigDecimal.ZERO);
+                                tempStock.setGoodsRelated(goodsRelated);
+                                waitForOutStockList.add(tempStock);
+                            }
+                        }
+                        createVehicleOutTaskAndPickTask(waitForOutStockList, workStation);
+                    }
+                    if (needNum.compareTo(BigDecimal.ZERO) > 0) {
+                        // 分配完成但库存缺料
+                        goodsToStation.setDistributeStatus(3);
+                    }
+                }
+                // 更新已分配数量
+                goodsToStation.setDistributedNum(goodsToStation.getTotalNum().subtract(needNum));
+            }
+            goodsToStationService.updateBatchById(goodsToStationList);
+            // 更新工作流状态
+            List<String> workFlowIds = currentWorkFlowList.stream().map(WorkFlow::getWorkFlowId).toList();
+            List<String> orderIds = currentWorkFlowList.stream().map(WorkFlow::getOrderId).toList();
+            workFlowService.update(new LambdaUpdateWrapper<WorkFlow>()
+                    .set(WorkFlow::getWorkStatus, 1)
+                    .in(WorkFlow::getWorkFlowId, workFlowIds)
+                    .eq(WorkFlow::getWorkStatus, 0));
+            // 更新工单表状态
+            kateOrdersService.update(new LambdaUpdateWrapper<KateOrders>()
+                    .set(KateOrders::getOrderStatus, 2)
+                    .in(KateOrders::getOrderId, orderIds)
+                    .eq(KateOrders::getOrderStatus, 1));
         } catch (Exception e) {
             throw new Exception("执行站台：" + workStation + "工作发生异常!");
         } finally {
@@ -291,4 +380,101 @@ public class WorkServiceImplements implements IWorkService {
             }
         }
     }
+
+    /**
+     * 生成出库任务，同时生成拣选任务
+     * @param waitForOutStocks 待出库库存
+     */
+    private void createVehicleOutTaskAndPickTask(List<Stock> waitForOutStocks, String workStation) {
+        // 出库任务列表
+        List<Task> outTasks = new ArrayList<>();
+        // 流转载具列表
+        List<OutsideVehicles> outsideVehicles = new ArrayList<>();
+        // 载具列表
+        List<String> vehicleIds = new ArrayList<>();
+        for (Stock tempStock : waitForOutStocks) {
+            if (vehicleIds.contains(tempStock.getVehicleId())) {
+                continue;
+            }
+            // 创建出库任务
+            Task tempOutTask = new Task();
+            tempOutTask.setTaskId(generateId("CK_"));
+            tempOutTask.setTaskType(TaskType.OUT.getCode());
+            tempOutTask.setTaskGroup(generateId(""));
+            tempOutTask.setTaskStatus(WmsTaskStatus.NEW.getCode());
+            tempOutTask.setTaskPriority(1);
+            tempOutTask.setVehicleId(tempStock.getVehicleId());
+            tempOutTask.setUserName("WMS_AUTO");
+            tempOutTask.setOrigin(tempStock.getLocationId());
+            tempOutTask.setDestination("");
+            tempOutTask.setCreateTime(LocalDateTime.now());
+            outTasks.add(tempOutTask);
+            // 添加载具列表
+            vehicleIds.add(tempStock.getVehicleId());
+            // 添加流转箱数据
+            OutsideVehicles outsideVehicle = new OutsideVehicles();
+            outsideVehicle.setOutsideId(generateId("OUTSIDE_"));
+            outsideVehicle.setVehicleId(tempStock.getVehicleId());
+            outsideVehicle.setGoodsId(tempStock.getGoodsRelated().getGoodsId());
+            outsideVehicle.setRemainNum(tempStock.getGoodsRelated().getRemainNum());
+            outsideVehicles.add(outsideVehicle);
+        }
+        for (String vehicleId : vehicleIds) {
+            // 查询到对应的库存信息
+            List<Stock> vehicleStocks = stockService.list(new LambdaQueryWrapper<Stock>()
+                    .eq(Stock::getVehicleId, vehicleId)
+                    .eq(Stock::getStockStatus, 0));
+            for (Stock vehicleStock : vehicleStocks) {
+                if (outsideVehicles.stream().anyMatch(outsideVehicle -> outsideVehicle.getVehicleId().equals(vehicleStock.getVehicleId()) && outsideVehicle.getGoodsId().equals(vehicleStock.getGoodsRelated().getGoodsId()))) {
+                    // 已经生成过
+                    continue;
+                }
+                // 添加流转箱数据
+                OutsideVehicles outsideVehicle = new OutsideVehicles();
+                outsideVehicle.setOutsideId(generateId("OUTSIDE_"));
+                outsideVehicle.setVehicleId(vehicleStock.getVehicleId());
+                outsideVehicle.setGoodsId(vehicleStock.getGoodsRelated().getGoodsId());
+                outsideVehicle.setRemainNum(vehicleStock.getGoodsRelated().getRemainNum());
+                outsideVehicles.add(outsideVehicle);
+            }
+        }
+        // 保存出库任务至任务表
+        taskService.saveBatch(outTasks);
+        // 更新载具信息
+        vehicleService.update(new LambdaUpdateWrapper<Vehicle>()
+                .set(Vehicle::getVehicleStatus, VehicleStatus.OUT.getCode())
+                .in(Vehicle::getVehicleId, vehicleIds)
+                .eq(Vehicle::getVehicleStatus, VehicleStatus.ON.getCode()));
+        // 更新库存信息
+        stockService.update(new LambdaUpdateWrapper<Stock>()
+                .set(Stock::getStockStatus, StockStatus.OUT.getCode())
+                .in(Stock::getVehicleId, vehicleIds)
+                .eq(Stock::getStockStatus, StockStatus.OK.getCode()));
+        // 保存流转箱信息
+        outsideVehiclesService.saveBatch(outsideVehicles);
+        // 保存拣选任务至拣选任务表
+        createPickTasks(vehicleIds, workStation);
+    }
+
+    /**
+     * 生成拣选任务
+     * @param vehicleIds 载具列表
+     * @param workStation 工作站台
+     */
+    private void createPickTasks(List<String> vehicleIds, String workStation) {
+        // 拣选任务暂存列表
+        List<PickTask> pickTasks = new ArrayList<>();
+        vehicleIds.forEach(vehicleId -> {
+            // 暂存拣选任务
+            PickTask tempPickTask = new PickTask();
+            tempPickTask.setPickTaskId(generateId("PICK_"));
+            tempPickTask.setVehicleId(vehicleId);
+            tempPickTask.setStandId(workStation);
+            tempPickTask.setPickStatus(0);
+            tempPickTask.setLastUpdateTime(LocalDateTime.now());
+            pickTasks.add(tempPickTask);
+        });
+        // 添加数据库
+        pickTaskService.saveBatch(pickTasks);
+    }
 }