first commit

2026-09-02 16:31:50 +08:00
commit a461727193
911 changed files with 692450 additions and 0 deletions
@@ -0,0 +1,25 @@
+
+using JSMachine.WMS.RPC.RcsRPC.Dto.In;
+using JSMachine.WMS.RPC.RcsRPC.Dto;
+using JSMachine.WMS.RPC.ErpRPC.Dto.Out;
+using JSMachine.WMS.App.Dto;
+
+namespace JSMachine.WMS.Business.RcsCallBack.IService
+{
+    public interface IRcsCallBackService
+    {
+        /// <summary>
+        /// 给Rcs调用，获取AGV上报的任务状态
+        /// </summary>
+        /// <param name="callBackWmsParam"></param>
+        /// <returns></returns>
+        Task<RcsApiResult> DealwithExcutionStatus(AgvExcutionInfo agvExcutionInfo, AGVTaskDto agvTask);
+
+        /// <summary>
+        /// 处理PDA上报的ａｇｖ报警处理结果
+        /// </summary>
+        /// <param name="agvTaskId"></param>
+        /// <returns></returns>
+        Task<bool> DealWithAlarmHandleResult(Guid agvTaskId);
+    }
+}
@@ -0,0 +1,25 @@
+using JSMachine.WMS.App.Dto;
+using JSMachine.WMS.RPC.RcsRPC.Dto.In;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace JSMachine.WMS.Business.RcsCallBack.IService.StaePattern
+{
+    /// <summary>
+    /// agv任务状态处理器 状态设计模式
+    /// </summary>
+    public interface IAgvTaskStateHandler
+    {
+        /// <summary>
+        /// 处理一次 AGV 状态回调，并按状态推进任务或更新任务结果。
+        /// </summary>
+        /// <param name="agvExcutionInfo">RCS 返回的 AGV 执行信息。</param>
+        /// <param name="agvTask">系统中的 AGV 任务。</param>
+        /// <param name="destWarehouse">任务目标库位。</param>
+        /// <returns>状态处理是否成功。</returns>
+        Task<bool> HandleAsync(AgvExcutionInfo agvExcutionInfo, AGVTaskDto agvTask, StorageRackDto destWarehouse);
+    }
+}
@@ -0,0 +1,18 @@
+using JSMachine.WMS.App.Dto;
+using JSMachine.WMS.Domain.Entity;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace JSMachine.WMS.Business.RcsCallBack.IService.StrategyPattern
+{
+    /// <summary>
+    /// agv任务结束策略（放货完成即代表agv任务结束）
+    /// </summary>
+    public interface ITaskCompletionStrategy
+    {
+        Task<bool> CompleteTaskAsync(AGVTaskDto agvTask, StorageRackDto destWarehouse);
+    }
+}
@@ -0,0 +1,419 @@
+using JSMachine.WMS.App.Dto;
+using JSMachine.WMS.App.Dto.Enum;
+using JSMachine.WMS.App.IService;
+using JSMachine.WMS.Business.RcsCallBack.IService;
+using JSMachine.WMS.Business.RcsCallBack.IService.StaePattern;
+using JSMachine.WMS.Business.RcsCallBack.IService.StrategyPattern;
+using JSMachine.WMS.Business.RcsCallBack.ServiceImpl.StatePattern;
+using JSMachine.WMS.Business.RcsCallBack.ServiceImpl.StrategyPatternImpl;
+using JSMachine.WMS.Common.Dto.Business;
+using JSMachine.WMS.Infrastructure.Helper;
+using JSMachine.WMS.RPC.RcsRPC.Dto;
+using JSMachine.WMS.RPC.RcsRPC.Dto.In;
+
+namespace JSMachine.WMS.Business.RcsCallBack.ServiceImpl
+{
+    /// <summary>
+        /// RCS 回调业务，将外部 AGV 状态转换为本地任务、库存及报警状态。
+    /// </summary>
+    public class RcsCallBackService : IRcsCallBackService
+    {
+        private IAGVTaskService _agvTaskService;
+        private IElevatorPlcQueueService _elevatorPlcQueueService;
+        private IStorageRackService _storageRackService;
+        private IERPTaskService _erptaskService;
+        private IElevatorCountService _elevatorCountService;
+
+        public RcsCallBackService(
+            IAGVTaskService agvTaskService,
+            IElevatorPlcQueueService elevatorPlcQueueService,
+            IStorageRackService storageRackService,
+            IERPTaskService erpTaskService,
+            IElevatorCountService elevatorCountService)
+        {
+            _agvTaskService = agvTaskService;
+            _elevatorPlcQueueService = elevatorPlcQueueService;
+            _storageRackService = storageRackService;
+            _erptaskService = erpTaskService;
+            _elevatorCountService = elevatorCountService;
+        }
+
+        /// <summary>
+        /// 给Rcs调用，获取AGV上报的任务状态
+        /// </summary>
+        /// <param name="callBackWmsParam"></param>
+        /// <returns></returns>
+        public async Task<RcsApiResult> DealwithExcutionStatus(AgvExcutionInfo agvExcutionInfo, AGVTaskDto agvTask)
+        {
+            // 先处理失败和取消状态，再处理成功状态；各处理器根据回调状态自行决定是否生效。
+            //处理agv执行失败的回调,推送pda报警
+            await HandleFailed(agvExcutionInfo, agvTask);
+
+            await HandleCanceled(agvExcutionInfo, agvTask);
+            //处理agv执行成功的回调
+            RcsApiResult rcsApiResult = await HandleSuccess(agvExcutionInfo, agvTask);
+
+            return rcsApiResult;
+        }
+
+        public async Task<bool> DealWithAlarmHandleResult(Guid agvTaskId)
+        {
+            AGVTaskDto agvTask = await _agvTaskService.GetSingalByExpression(p => p.Id == agvTaskId);
+
+            if (agvTask == null)
+            {
+                LogHelper.Warn($"PDA上传的 {agvTaskId} 任务不存在，该任务告警可能已经处理？");
+                return true;
+            }
+
+            //模拟rcs回调，发送放货完成命令
+            await DealwithExcutionStatus(new AgvExcutionInfo
+            {
+                OrderId = agvTaskId.ToString(),
+                Status = 23
+            }, agvTask);
+
+            //处理完删除缓存中的报警信息
+            GlobalAgvTaskFailedAlarmInfo.RemoveAlarmInfo(agvTaskId);
+
+            return true;
+        }
+
+        #region  处理入库rcs回调信息
+
+        private async Task HandleCanceled(AgvExcutionInfo agvExcutionInfo, AGVTaskDto agvTask)
+        {
+            if (agvExcutionInfo.Status != 3)
+                return;
+
+            agvTask.TaskStatus = TaskStatusEnum.Cancelled;
+            await _agvTaskService.EditSingal(agvTask);
+
+            //搬运的任务没有对应的erptask
+            if (agvTask.TaskType != TaskTypeEnum.Carry)
+            {
+                ERPTaskDto erpTask = await _erptaskService.GetSingalByExpression(p => p.Id == agvTask.ErpTaskId);
+                erpTask.TaskStatus = TaskStatusEnum.Cancelled;
+                await _erptaskService.UpdateTaskStatus(erpTask);
+            }
+        }
+
+        private async Task HandleFailed(AgvExcutionInfo agvExcutionInfo, AGVTaskDto agvTask)
+        {
+            if (agvExcutionInfo.Status != 7)
+                return;
+
+            //1.一楼 起点在入库库位，终点在提升机，人工搬运托盘到提升机入口，手动提交放货完成信号
+            //2.二楼 起点在提升机出口，终点在存储区库位，人工搬运托盘到库位，手动提交放货完成信号
+            //3.二楼 起点在入库区库位，终点在提升机入口，人工搬运托盘到提升机入口，手动提交放货完成信号
+            //4.一楼 起点在提升机，终点在出货码头，人工搬运托盘到出货码头，无需其他处理
+
+            await HandleStocInFirstFloor(agvExcutionInfo, agvTask);
+            await HandleStocInSecondFloor(agvExcutionInfo, agvTask);
+            await HandleStocOutSecondFloor(agvExcutionInfo, agvTask);
+            await HandleStocOutFirstFloor(agvExcutionInfo, agvTask);
+        }
+
+        #region agv执行失败报警分任务处理
+        private async Task HandleStocInFirstFloor(AgvExcutionInfo agvExcutionInfo, AGVTaskDto agvTask)
+        {
+            if (!(agvTask.TaskType == TaskTypeEnum.PdaIn && agvTask.Floor == FloorEnum.FirstFloor))
+                return;
+
+            StorageRackDto destWarehouse = await _storageRackService.GetSingalByExpression(p => p.StorageRackNo == agvTask.EndPositionCode);
+
+            //终点在存储区，人工搬运获取到指定库位，完成后写放货完成
+            if (destWarehouse.Transport == TransportEnum.NormalArea)
+            {
+                string operatn = $"{agvExcutionInfo.DeviceNum}号小车报警，请将货物从车上取下搬运到 {destWarehouse.StorageRackName} " +
+                    $"库区的 {destWarehouse.StorageRackNo}库位上，完成后点击已处理按钮";
+
+                LogHelper.Warn(operatn);
+
+                GlobalAgvTaskFailedAlarmInfo.AddAlarmInfo(new AgvTaskFailedAlarmInfo
+                {
+                    AgvTaskId = agvTask.Id,
+                    Operation = operatn
+                });
+
+                await UpdateErpTaskStatus(agvTask, TaskStatusEnum.Failed);
+            }
+
+            //终点在提升机入口,人工搬运获取到提升机入口，完成后写放货完成
+            if (destWarehouse.Transport == TransportEnum.Elevator)
+            {
+                string operatn = $"{agvExcutionInfo.DeviceNum}号小车报警，请将货物从车上(或库位{agvTask.StartPositionCode})搬运到 {destWarehouse.StorageRackName} 上，" +
+                    $"完成后点击已处理按钮";
+
+                LogHelper.Warn($"任务 id {agvTask.Id} 操作信息：{operatn}");
+
+                GlobalAgvTaskFailedAlarmInfo.AddAlarmInfo(new AgvTaskFailedAlarmInfo
+                {
+                    AgvTaskId = agvTask.Id,
+                    Operation = operatn
+                });
+            }
+        }
+        private async Task HandleStocInSecondFloor(AgvExcutionInfo agvExcutionInfo, AGVTaskDto agvTask)
+        {
+            if (!(agvTask.TaskType == TaskTypeEnum.PdaIn && agvTask.Floor == FloorEnum.SecondFloor))
+                return;
+
+            StorageRackDto startWarehouse = await _storageRackService.GetByStorageRackNo(agvTask.StartPositionCode);
+            StorageRackDto destWarehouse = await _storageRackService.GetByStorageRackNo(agvTask.EndPositionCode);
+
+            //终点在存储区，人工搬运获取到指定库位，完成后写放货完成
+
+            string operatn = $"{agvExcutionInfo.DeviceNum}号小车报警，请将货物从 {startWarehouse.StorageRackName} 搬运到 " +
+                $"{destWarehouse.StorageRackNo}库位上，完成后点击已处理按钮";
+
+            LogHelper.Warn($"任务 id {agvTask.Id} 操作信息：{operatn}");
+
+            GlobalAgvTaskFailedAlarmInfo.AddAlarmInfo(new AgvTaskFailedAlarmInfo
+            {
+                AgvTaskId = agvTask.Id,
+                Operation = operatn
+            });
+
+            await UpdateErpTaskStatus(agvTask, TaskStatusEnum.Failed);
+        }
+        private async Task HandleStocOutSecondFloor(AgvExcutionInfo agvExcutionInfo, AGVTaskDto agvTask)
+        {
+            if (!(agvTask.TaskType == TaskTypeEnum.SaleOut && agvTask.Floor == FloorEnum.SecondFloor))
+                return;
+
+            StorageRackDto destWarehouse = await _storageRackService.GetByStorageRackNo(agvTask.EndPositionCode);
+
+            //终点在存储区，人工搬运获取到指定库位，完成后写放货完成
+
+            string operatn = $"{agvExcutionInfo.DeviceNum}号小车报警，请将货物从车上(或者{agvTask.StartPositionCode})放到 {destWarehouse.StorageRackNo} 上，完成后点击已处理按钮";
+
+            LogHelper.Warn($"任务 id {agvTask.Id} 操作信息：{operatn}");
+
+            GlobalAgvTaskFailedAlarmInfo.AddAlarmInfo(new AgvTaskFailedAlarmInfo
+            {
+                AgvTaskId = agvTask.Id,
+                Operation = operatn
+            });
+        }
+        private async Task HandleStocOutFirstFloor(AgvExcutionInfo agvExcutionInfo, AGVTaskDto agvTask)
+        {
+            if (!(agvTask.TaskType == TaskTypeEnum.SaleOut && agvTask.Floor == FloorEnum.SecondFloor))
+                return;
+
+            StorageRackDto startWarehouse = await _storageRackService.GetByStorageRackNo(agvTask.StartPositionCode);
+            StorageRackDto destWarehouse = await _storageRackService.GetByStorageRackNo(agvTask.EndPositionCode);
+
+            if (startWarehouse.Transport == TransportEnum.Elevator)
+            {
+                string operatn = $"{agvExcutionInfo.DeviceNum}号小车报警，请将货物从 {startWarehouse.StorageRackName} 搬运到 " +
+                    $"{(destWarehouse.Transport == TransportEnum.NorthArea ? "北出库码头" : "南出库码头")} " +
+                    $"的 {destWarehouse.StorageRackNo} 库位上，完成后点击已处理按钮";
+
+                LogHelper.Warn($"任务 id {agvTask.Id} 操作信息：{operatn}");
+
+                GlobalAgvTaskFailedAlarmInfo.AddAlarmInfo(new AgvTaskFailedAlarmInfo
+                {
+                    AgvTaskId = agvTask.Id,
+                    Operation = operatn
+                });
+            }
+
+            if (startWarehouse.Transport == TransportEnum.NorthArea)
+            {
+                string operatn = $"{agvExcutionInfo.DeviceNum}号小车报警，请将货物从  " +
+                    $"{startWarehouse} 库位上搬运到北出库码头的" +
+                    $"{destWarehouse.StorageRackNo} 库位上，完成后点击已处理按钮";
+
+                LogHelper.Warn($"任务 id {agvTask.Id} 操作信息：{operatn}");
+
+                GlobalAgvTaskFailedAlarmInfo.AddAlarmInfo(new AgvTaskFailedAlarmInfo
+                {
+                    AgvTaskId = agvTask.Id,
+                    Operation = operatn
+                });
+            }
+
+            if (startWarehouse.Transport == TransportEnum.SouthArea)
+            {
+                string operatn = $"{agvExcutionInfo.DeviceNum}号小车报警，请将货物从" +
+                    $"{startWarehouse} 库位搬运到南出库码头" +
+                    $"的 {destWarehouse.StorageRackNo} 库位上，完成后点击已处理按钮";
+
+                LogHelper.Warn($"任务 id {agvTask.Id} 操作信息：{operatn}");
+
+                GlobalAgvTaskFailedAlarmInfo.AddAlarmInfo(new AgvTaskFailedAlarmInfo
+                {
+                    AgvTaskId = agvTask.Id,
+                    Operation = operatn
+                });
+            }
+        }
+        #endregion
+
+        private async Task<RcsApiResult> HandleSuccess(AgvExcutionInfo agvExcutionInfo, AGVTaskDto agvTask)
+        {
+            if (!new int[] { 21, 23 }.Contains(agvExcutionInfo.Status))
+            {
+                LogHelper.Warn("rcs回调状态不是21,23，不处理");
+                return new RcsApiResult { code = 1000 };
+            }
+
+            StorageRackDto destWarehouse = await _storageRackService.GetSingalByExpression(p => p.StorageRackNo == agvTask.EndPositionCode);
+            if (destWarehouse == null)
+            {
+                LogHelper.Error($"AgvTask终点库位 {agvTask.EndPositionCode} 不存在");
+                return new RcsApiResult { code = 1000 }; ;
+            }
+
+            IAgvTaskStateHandler handler = new RcsCallbackHandlerFactory().CreateHandler(agvExcutionInfo.Status, destWarehouse);
+            if (handler == null)
+            {
+                LogHelper.Error("状态模式 没有匹配的模式可以处理");
+                return new RcsApiResult { code = 1000 }; 
+            }
+            await handler.HandleAsync(agvExcutionInfo, agvTask, destWarehouse);
+            return new RcsApiResult { code = 1000 };    
+        }
+
+       
+        private async Task UpdateErpTaskStatus(AGVTaskDto agvTask, TaskStatusEnum taskStatus)
+        {
+            ERPTaskDto erpTask = await _erptaskService.GetSingalByExpression(p => p.Id == agvTask.ErpTaskId);
+            erpTask.TaskStatus = taskStatus;
+            //更新erp任务状态为完成
+            bool bRet = await _erptaskService.EditSingal(erpTask);
+            LogHelper.Info($"更新erptask状态为 {taskStatus} ,数据库操作结果 {bRet}");
+        }
+        #endregion
+
+        #region 处理销售出库/生产退库，Rcs回调
+
+        
+        /// <summary>
+        /// 解锁中区库位并绑定合格证
+        /// </summary>
+        /// <returns></returns>
+        private async Task UnlockAndSetMiddleWarehouse(StorageRackDto storageRack)
+        {
+            if (storageRack.Transport != TransportEnum.MiddleOutArea)
+                return;
+
+            storageRack.IsLock = false;
+            await _storageRackService.EditSingalWithSpecificCols(storageRack, ["IsLock", "BarCode"]);
+        }
+
+        /// <summary>
+        /// 更新AgvTask任务状态
+        /// </summary>
+        /// <param name="agvTask">库位编号</param>
+        /// <returns></returns>
+        private async Task<bool> UpdateAgvTaskStatus(AGVTaskDto agvTask)
+        {
+            var updateResult = false;
+
+            if (agvTask != null)
+            {
+                updateResult = await _agvTaskService.EditSingal(agvTask);
+                if (!updateResult)
+                {
+                    LogHelper.Error($"销售出库：更新AgvTask {agvTask.Id} 的,完成状态失败");
+                }
+                else
+                {
+                    LogHelper.Info($"销售出库：更新AgvTask {agvTask.Id} 的,完成状态成功");
+                }
+            }
+            return updateResult;
+        }
+
+        /// <summary>
+        /// 清空起点库位上的物料信息
+        /// </summary>
+        /// <param name="agvTask"></param>
+        /// <returns></returns>
+        private async Task<bool> ClearMateriaInfo(AGVTaskDto agvTask)
+        {
+            var clearResult = false;
+            var typeMsg = "";
+            if (agvTask.TaskType == TaskTypeEnum.SaleOut)
+            {
+                typeMsg = "销售出库，";
+            }
+            else if (agvTask.TaskType == TaskTypeEnum.Carry)
+            {
+                typeMsg = "搬运物料，";
+            }
+
+            var clearWarehouse = await _storageRackService.GetSingalByExpression(p => p.StorageRackNo == agvTask.StartPositionCode);
+            if (clearWarehouse != null)
+            {
+                clearWarehouse.MateriaBatch = "";
+                clearWarehouse.MateriaNum = 0;
+
+                clearWarehouse.OrderNo = "";
+                clearWarehouse.MateriaName = "";
+                clearWarehouse.MateriaType = "";
+                clearWarehouse.MateriaCode = "";
+                clearWarehouse.BarCode = "";
+                clearWarehouse.IsLock = false;
+
+                clearResult = await _storageRackService.EditSingal(clearWarehouse);
+                if (!clearResult)
+                {
+                    LogHelper.Error($"{typeMsg}清空库位{clearWarehouse.StorageRackNo}上的物料信息{clearWarehouse.MateriaCode}失败");
+                }
+                else
+                {
+                    LogHelper.Info($"{typeMsg}清空库位{clearWarehouse.StorageRackNo}上的物料信息{clearWarehouse.MateriaCode}成功");
+                }
+            }
+            else
+            {
+                LogHelper.Error($"{typeMsg}清空库位时，未查询到库位{agvTask.StartPositionCode}上的物料信息");
+            }
+            return clearResult;
+        }
+
+        /// <summary>
+        /// 更新终点库位上的物料信息
+        /// </summary>
+        /// <param name="agvTask"></param>
+        /// <returns></returns>
+        private async Task<bool> UpdateMateriaInfo(AGVTaskDto agvTask)
+        {
+            var updateResult = false;
+
+            var updateWarehouse = await _storageRackService.GetSingalByExpression(p => p.StorageRackNo == agvTask.EndPositionCode);
+            if (updateWarehouse != null)
+            {
+                updateWarehouse.MateriaBatch = agvTask.MateriaBatch;
+                updateWarehouse.MateriaNum = agvTask.MateriaNum;
+
+                updateWarehouse.OrderNo = agvTask.OrderNo;
+                updateWarehouse.MateriaName = agvTask.MateriaName;
+                updateWarehouse.MateriaType = agvTask.MateriaType;
+                updateWarehouse.MateriaCode = agvTask.MateriaCode;
+                updateWarehouse.BarCode = agvTask.BarCode;
+                updateWarehouse.IsLock = false;
+
+                updateResult = await _storageRackService.EditSingal(updateWarehouse);
+                if (!updateResult)
+                {
+                    LogHelper.Error($"销售出库：更新库位{updateWarehouse.StorageRackNo}上的物料信息{updateWarehouse.MateriaCode}失败");
+                }
+                else
+                {
+                    LogHelper.Info($"销售出库：更新库位{updateWarehouse.StorageRackNo}上的物料信息{updateWarehouse.MateriaCode}成功");
+                }
+            }
+            else
+            {
+                LogHelper.Error($"销售出库：更新库位时，未查询到库位{agvTask.EndPositionCode}上的物料信息");
+            }
+            return updateResult;
+        }
+
+        #endregion  
+    }
+}
@@ -0,0 +1,39 @@
+using JSMachine.WMS.App.Dto;
+using JSMachine.WMS.App.Dto.Enum;
+using JSMachine.WMS.App.IService;
+using JSMachine.WMS.App.ServiceImpl;
+using JSMachine.WMS.Business.RcsCallBack.IService.StaePattern;
+using JSMachine.WMS.RPC.RcsRPC.Dto.In;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace JSMachine.WMS.Business.RcsCallBack.ServiceImpl.StatePattern
+{
+    /// <summary>
+    /// agv任务执行失败处理器
+    /// </summary>
+    public class FailedStateHandler : IAgvTaskStateHandler
+    {
+        private readonly IAGVTaskService _agvTaskService;
+        /// <summary>创建失败状态处理器。</summary>
+        /// <param name="agvTaskService">AGV 任务持久化服务。</param>
+        public FailedStateHandler(IAGVTaskService agvTaskService)
+        {
+            _agvTaskService=agvTaskService;
+        }
+
+        /// <summary>将当前 AGV 任务标记为失败并保存状态。</summary>
+        /// <param name="agvExcutionInfo">RCS 执行信息。</param>
+        /// <param name="agvTask">待更新的 AGV 任务。</param>
+        /// <param name="destWarehouse">目标库位。</param>
+        /// <returns>状态更新是否成功。</returns>
+        public async Task<bool> HandleAsync(AgvExcutionInfo agvExcutionInfo, AGVTaskDto agvTask, StorageRackDto destWarehouse)
+        {
+            agvTask.TaskStatus = TaskStatusEnum.Failed;
+            return await _agvTaskService.UpdateAgvTaskStatus(agvTask);
+        }
+    }
+}
@@ -0,0 +1,92 @@
+using JSMachine.WMS.App.Dto;
+using JSMachine.WMS.App.Dto.Enum;
+using JSMachine.WMS.App.IService;
+using JSMachine.WMS.Business.RcsCallBack.IService.StaePattern;
+using JSMachine.WMS.Business.SSE;
+using JSMachine.WMS.Infrastructure.Helper;
+using JSMachine.WMS.RPC.RcsRPC.Dto.In;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace JSMachine.WMS.Business.RcsCallBack.ServiceImpl.StatePattern
+{
+    /// <summary>
+    /// agv取货完成处理器
+    /// </summary>
+    public class PickupCompletedStateHandler : IAgvTaskStateHandler
+    {
+        private readonly IStorageRackService _storageRackService;
+        private readonly IAGVTaskService _agvTaskService;
+
+        public PickupCompletedStateHandler(IStorageRackService storageRackService, IAGVTaskService agvTaskService)
+        {
+            _storageRackService = storageRackService;
+            _agvTaskService = agvTaskService;
+        }
+
+        public async Task<bool> HandleAsync(AgvExcutionInfo agvExcutionInfo, AGVTaskDto agvTask, StorageRackDto destWarehouse)
+        {
+            // 清空出库库位上的物料、解锁库位
+            await ClearMateriaInfo(agvTask);
+
+            //更新AgvTask的状态为 取货完成
+            agvTask.TaskStatus = TaskStatusEnum.PickupCompleted;
+            return await _agvTaskService.UpdateAgvTaskStatus(agvTask);
+        }
+
+        /// <summary>
+        /// 清空起点库位上的物料信息
+        /// </summary>
+        /// <param name="agvTask"></param>
+        /// <returns></returns>
+        private async Task<bool> ClearMateriaInfo(AGVTaskDto agvTask)
+        {
+            var clearResult = false;
+            var typeMsg = "";
+            if (agvTask.TaskType == TaskTypeEnum.SaleOut)
+            {
+                typeMsg = "销售出库，";
+            }
+            else if (agvTask.TaskType == TaskTypeEnum.Carry)
+            {
+                typeMsg = "搬运物料，";
+            }
+
+            var clearWarehouse = await _storageRackService.GetSingalByExpression(p => p.StorageRackNo == agvTask.StartPositionCode);
+            if (clearWarehouse != null)
+            {
+                clearWarehouse.MateriaBatch = "";
+                clearWarehouse.MateriaNum = 0;
+
+                clearWarehouse.OrderNo = "";
+                clearWarehouse.MateriaName = "";
+                clearWarehouse.MateriaType = "";
+                clearWarehouse.MateriaCode = "";
+                clearWarehouse.BarCode = "";
+                clearWarehouse.IsLock = false;
+
+                clearResult = await _storageRackService.EditSingal(clearWarehouse);
+                if (!clearResult)
+                {
+                    LogHelper.Error($"{typeMsg}清空库位{clearWarehouse.StorageRackNo}上的物料信息{clearWarehouse.MateriaCode}失败");
+                }
+                else
+                {
+                    LogHelper.Info($"{typeMsg}清空库位{clearWarehouse.StorageRackNo}上的物料信息{clearWarehouse.MateriaCode}成功");
+                }
+            }
+            else
+            {
+                LogHelper.Error($"{typeMsg}清空库位时，未查询到库位{agvTask.StartPositionCode}上的物料信息");
+            }
+
+            //发送广播通知前端网站刷新页面
+            SseEngine.BrodCast(agvTask.Floor.ToString());
+
+            return clearResult;
+        }
+    }
+}
@@ -0,0 +1,104 @@
+using JSMachine.WMS.App.Dto;
+using JSMachine.WMS.App.Dto.Enum;
+using JSMachine.WMS.App.IService;
+using JSMachine.WMS.App.ServiceImpl;
+using JSMachine.WMS.Business.SSE;
+using JSMachine.WMS.Infrastructure;
+using JSMachine.WMS.Infrastructure.Helper;
+using JSMachine.WMS.PLC.ModbusImpl.Elevator.Model;
+using JSMachine.WMS.PLC.ModbusImpl.PaperFeedGroundRack.ModbusIO.Write;
+using JSMachine.WMS.RPC.RcsRPC.Dto.In;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace JSMachine.WMS.Business.RcsCallBack.ServiceImpl.StatePattern.PutdownCompleted
+{
+    /// <summary>
+    /// 提升机处理器
+    /// </summary>
+    public class ElevatorDeliveryHandler : PutdownCompletedStateHandler
+    {
+        public ElevatorDeliveryHandler
+            (IStorageRackService storageRackService,
+            IAGVTaskService agvTaskService,
+            IElevatorPlcQueueService elevatorPlcQueueService,
+            IElevatorCountService elevatorCountService,
+            IERPTaskService erpTaskService) :
+            base(storageRackService, agvTaskService, elevatorPlcQueueService, elevatorCountService, erpTaskService)
+        {
+        }
+
+        public async override Task<bool> HandleAsync(AgvExcutionInfo agvExcutionInfo, AGVTaskDto agvTask, StorageRackDto destWarehouse)
+        {
+            var elevatorPlcStatus = new ElevatorPlcStatus();
+
+            //2.1 写PLC放货完成
+            int elevatorNo = destWarehouse.StorageRackName.Contains("1号") ? 1 : 2;
+            elevatorPlcStatus.ElevatorNo = elevatorNo;
+
+            if (destWarehouse.ElevatorChannel == 1001)
+            {
+                elevatorPlcStatus.StockInPutdownChanelTwo = true;
+            }
+            if (destWarehouse.ElevatorChannel == 1011)
+            {
+                elevatorPlcStatus.StockInPutdownChanelOne = true;
+            }
+            if (destWarehouse.ElevatorChannel == 2001)
+            {
+                elevatorPlcStatus.StockOutPutdownChanelTwo = true;
+            }
+            if (destWarehouse.ElevatorChannel == 2011)
+            {
+                elevatorPlcStatus.StockOutPutdownChanelOne = true;
+            }
+            bool bRet = await ElevatorWrite.WriteElevator(elevatorPlcStatus);
+            if (!bRet)
+            {
+                LogHelper.Error($"{agvTask.TaskType.GetDescription()}: " +
+                    $"向 {elevatorPlcStatus.ElevatorNo} 号提升机 {destWarehouse.ElevatorChannel} 网带写放货完成信号失败");
+                return false;
+            }
+
+            if(agvTask.TaskType!=TaskTypeEnum.Carry)
+            {
+                //2.2 写PLC队列信息
+                ElevatorPlcQueueDto elevatorPlcQueue = new()
+                {
+                    ElevatorNo = elevatorNo,
+                    ElevatorChannel = destWarehouse.ElevatorChannel.Value,
+                    AgvTaskId = agvTask.Id,
+                    IsLock = false
+                };
+                bRet = await _elevatorPlcQueueService.Add(elevatorPlcQueue);
+                if (!bRet)
+                {
+                    LogHelper.Error($"{agvTask.TaskType.GetDescription()}：写PLC队列失败");
+                    return false;
+                }
+                else
+                {
+                    LogHelper.Info($"{agvTask.TaskType.GetDescription()}：" +
+                        $"写PLC队列成功，提升机编号 {elevatorPlcQueue.ElevatorNo} 通道号 {elevatorPlcQueue.ElevatorChannel}");
+                }
+
+                //提升机计数
+                await _elevatorCountService.IncrementCount(elevatorNo, elevatorPlcQueue.ElevatorChannel);
+            }
+
+            //2.3 更新agvtask的状态为完成
+            await base.CompleteTask(agvTask);
+
+            //2.4 解锁提升机库位
+            await _storageRackService.Unlock(destWarehouse);
+
+            //发送广播通知前端网站刷新页面
+            SseEngine.BrodCast(agvTask.Floor.ToString());
+
+            return true;
+        }
+    }
+}
@@ -0,0 +1,49 @@
+using JSMachine.WMS.App.Dto;
+using JSMachine.WMS.App.Dto.Enum;
+using JSMachine.WMS.App.IService;
+using JSMachine.WMS.App.ServiceImpl;
+using JSMachine.WMS.Business.RcsCallBack.IService.StaePattern;
+using JSMachine.WMS.RPC.RcsRPC.Dto.In;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace JSMachine.WMS.Business.RcsCallBack.ServiceImpl.StatePattern.PutdownCompleted
+{
+    /// <summary>
+    /// 放货完成处理器
+    /// </summary>
+    public abstract class PutdownCompletedStateHandler : IAgvTaskStateHandler
+    {
+        protected readonly IStorageRackService _storageRackService;
+        protected readonly IAGVTaskService _agvTaskService;
+        protected readonly IElevatorPlcQueueService _elevatorPlcQueueService;
+        protected readonly IElevatorCountService _elevatorCountService;
+        protected readonly IERPTaskService _erpTaskService;
+
+        public PutdownCompletedStateHandler(
+            IStorageRackService storageRackService, 
+            IAGVTaskService agvTaskService, 
+            IElevatorPlcQueueService elevatorPlcQueueService,
+            IElevatorCountService elevatorCountService,
+            IERPTaskService erpTaskService
+            )
+        {
+            _storageRackService = storageRackService;
+            _agvTaskService = agvTaskService;
+            _elevatorPlcQueueService = elevatorPlcQueueService;
+            _elevatorCountService= elevatorCountService;
+            _erpTaskService = erpTaskService;
+        }
+
+        public abstract Task<bool> HandleAsync(AgvExcutionInfo agvExcutionInfo, AGVTaskDto agvTask, StorageRackDto destWarehouse);
+
+        protected async Task CompleteTask(AGVTaskDto agvTask)
+        {
+            agvTask.TaskStatus = TaskStatusEnum.Completed;
+            await _agvTaskService.UpdateAgvTaskStatus(agvTask);
+        }
+    }
+}
@@ -0,0 +1,75 @@
+using JSMachine.WMS.App.Dto;
+using JSMachine.WMS.App.Dto.Enum;
+using JSMachine.WMS.App.IService;
+using JSMachine.WMS.App.ServiceImpl;
+using JSMachine.WMS.Business.Common.IService;
+using JSMachine.WMS.Business.RcsCallBack.IService.StaePattern;
+using JSMachine.WMS.Business.SSE;
+using JSMachine.WMS.RPC.RcsRPC.Dto.In;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using static JSMachine.WMS.App.Dto.StorageRackDto;
+
+namespace JSMachine.WMS.Business.RcsCallBack.ServiceImpl.StatePattern.PutdownCompleted
+{
+    /// <summary>
+    /// 存储区（包括中转区）放货完成处理器
+    /// </summary>
+    public class StockAreaHandler : PutdownCompletedStateHandler
+    {
+        public StockAreaHandler(
+            IStorageRackService storageRackService,
+            IAGVTaskService agvTaskService,
+            IElevatorPlcQueueService elevatorPlcQueueService,
+            IElevatorCountService elevatorCountService,
+            IERPTaskService erpTaskService) :
+            base(storageRackService, agvTaskService, elevatorPlcQueueService, elevatorCountService, erpTaskService)
+        {
+        }
+
+        public async override Task<bool> HandleAsync(AgvExcutionInfo agvExcutionInfo, AGVTaskDto agvTask, StorageRackDto destWarehouse)
+        {
+            //1.将物料绑定到目标库位
+            //2.解锁目标库位
+            //3.更改agv任务为完成
+
+            destWarehouse.BingdingMaterial(new MateriaInfo
+            {
+                BarCode = agvTask.BarCode,
+                MateriaBatch = agvTask.MateriaBatch,
+                MateriaCode = agvTask.MateriaCode,
+                MateriaName = agvTask.MateriaName,
+                MateriaNum = agvTask.MateriaNum.ToString(),
+                MateriaType = agvTask.MateriaType,
+                OrderNo = agvTask.OrderNo
+            });
+            destWarehouse.IsLock = false;
+
+            await _storageRackService.EditSingal(destWarehouse);
+
+            await CompleteTask(agvTask);
+
+            //更新erp任务为完成状态
+            if (agvTask.TaskType == TaskTypeEnum.PdaIn ||
+                agvTask.TaskType == TaskTypeEnum.TailIn ||
+                agvTask.TaskType == TaskTypeEnum.TransferStockIn)
+            {
+                ERPTaskDto erpTask = await _erpTaskService.GetSingalByExpression(p => p.Id == agvTask.ErpTaskId);
+                if (erpTask != null)
+                {
+                    erpTask.TaskStatus = TaskStatusEnum.Completed;
+                    erpTask.TaskMsg = "";
+                    await _erpTaskService.EditSingalWithSpecificCols(erpTask, ["TaskStatus", "TaskMsg"]);
+                }
+            }
+
+            //发送广播通知前端网站刷新页面
+            SseEngine.BrodCast(agvTask.Floor.ToString());
+
+            return true;
+        }
+    }
+}
@@ -0,0 +1,52 @@
+using JSMachine.WMS.App.Dto;
+using JSMachine.WMS.App.Dto.Enum;
+using JSMachine.WMS.App.IService;
+using JSMachine.WMS.RPC.RcsRPC.Dto.In;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace JSMachine.WMS.Business.RcsCallBack.ServiceImpl.StatePattern.PutdownCompleted
+{
+    /// <summary>
+    /// 出库码头处理器
+    /// </summary>
+    public class StockOutWharfHandler : PutdownCompletedStateHandler
+    {
+        public StockOutWharfHandler
+            (IStorageRackService storageRackService,
+            IAGVTaskService agvTaskService,
+            IElevatorPlcQueueService elevatorPlcQueueService,
+            IElevatorCountService elevatorCountService,
+            IERPTaskService erpTaskService) :
+            base(storageRackService, agvTaskService, elevatorPlcQueueService, elevatorCountService, erpTaskService)
+        {
+        }
+
+        public async override Task<bool> HandleAsync(AgvExcutionInfo agvExcutionInfo, AGVTaskDto agvTask, StorageRackDto destWarehouse)
+        {
+            destWarehouse.BarCode = agvTask.BarCode;
+
+            agvTask.TaskStatus = TaskStatusEnum.Completed;
+
+            await UnlockAndSetMiddleWarehouse(destWarehouse);
+
+            return await _agvTaskService.UpdateAgvTaskStatus(agvTask);
+        }
+
+        /// <summary>
+        /// 解锁中区库位并绑定合格证
+        /// </summary>
+        /// <returns></returns>
+        private async Task UnlockAndSetMiddleWarehouse(StorageRackDto storageRack)
+        {
+            if (storageRack.Transport != TransportEnum.MiddleOutArea)
+                return;
+
+            storageRack.IsLock = false;
+            await _storageRackService.EditSingalWithSpecificCols(storageRack, ["IsLock", "BarCode"]);
+        }
+    }
+}
@@ -0,0 +1,55 @@
+using JSMachine.WMS.App.Dto;
+using JSMachine.WMS.App.Dto.Enum;
+using JSMachine.WMS.App.IService;
+using JSMachine.WMS.Business.SSE;
+using JSMachine.WMS.RPC.RcsRPC.Dto.In;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using static JSMachine.WMS.App.Dto.StorageRackDto;
+
+namespace JSMachine.WMS.Business.RcsCallBack.ServiceImpl.StatePattern.PutdownCompleted
+{
+    public class TransitAreaHandler : PutdownCompletedStateHandler
+    {
+        public TransitAreaHandler(
+            IStorageRackService storageRackService,
+            IAGVTaskService agvTaskService,
+            IElevatorPlcQueueService elevatorPlcQueueService,
+            IElevatorCountService elevatorCountService,
+            IERPTaskService erpTaskService) :
+            base(storageRackService, agvTaskService, elevatorPlcQueueService, elevatorCountService, erpTaskService)
+        {
+        }
+
+        public async override Task<bool> HandleAsync(AgvExcutionInfo agvExcutionInfo, AGVTaskDto agvTask, StorageRackDto destWarehouse)
+        {
+            //1.将物料绑定到目标库位
+            //2.解锁目标库位
+            //3.更改agv任务为完成
+
+            destWarehouse.BingdingMaterial(new MateriaInfo
+            {
+                BarCode = agvTask.BarCode,
+                MateriaBatch = agvTask.MateriaBatch,
+                MateriaCode = agvTask.MateriaCode,
+                MateriaName = agvTask.MateriaName,
+                MateriaNum = agvTask.MateriaNum.ToString(),
+                MateriaType = agvTask.MateriaType,
+                OrderNo = agvTask.OrderNo
+            });
+            destWarehouse.IsLock = false;
+
+            await _storageRackService.EditSingal(destWarehouse);
+
+            await CompleteTask(agvTask);
+
+            //发送广播通知前端网站刷新页面
+            SseEngine.BrodCast(agvTask.Floor.ToString());
+
+            return true;
+        }
+    }
+}
@@ -0,0 +1,42 @@
+using JSMachine.WMS.App.Dto;
+using JSMachine.WMS.App.Dto.Enum;
+using JSMachine.WMS.Business.RcsCallBack.IService.StaePattern;
+using JSMachine.WMS.Business.RcsCallBack.ServiceImpl.StatePattern.PutdownCompleted;
+using JSMachine.WMS.Infrastructure;
+using Microsoft.Extensions.DependencyInjection;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace JSMachine.WMS.Business.RcsCallBack.ServiceImpl.StatePattern
+{
+    /// <summary>
+    /// rcs回调处理器工厂类
+    /// </summary>
+    public class RcsCallbackHandlerFactory
+    {
+        /// <summary>
+        /// 根据 RCS 返回状态和目标库位运输区域选择状态处理器。
+        /// </summary>
+        /// <param name="status">RCS 任务状态码。</param>
+        /// <param name="destWarehouse">任务目标库位。</param>
+        /// <returns>负责当前状态后续处理的处理器。</returns>
+        public IAgvTaskStateHandler CreateHandler(int status, StorageRackDto destWarehouse)
+        {
+            return status switch
+            {
+                21 => GlobalServericeProvidor.GetService<PickupCompletedStateHandler>(),
+                23 => destWarehouse.Transport switch
+                {
+                    TransportEnum.NorthArea or TransportEnum.SouthArea or TransportEnum.MiddleOutArea or TransportEnum.ReturnStockArea
+                        => GlobalServericeProvidor.GetService<StockOutWharfHandler>(),
+                    TransportEnum.NormalArea => GlobalServericeProvidor.GetService<StockAreaHandler>(),
+                    TransportEnum.TransitArea => GlobalServericeProvidor.GetService<TransitAreaHandler>(),
+                    TransportEnum.Elevator => GlobalServericeProvidor.GetService<ElevatorDeliveryHandler>(),
+                }
+            };
+        }
+    }
+}
@@ -0,0 +1,90 @@
+using JSMachine.WMS.App.Dto;
+using JSMachine.WMS.App.Dto.Enum;
+using JSMachine.WMS.App.IService;
+using JSMachine.WMS.App.ServiceImpl;
+using JSMachine.WMS.Business.RcsCallBack.IService.StrategyPattern;
+using JSMachine.WMS.Infrastructure.Helper;
+using JSMachine.WMS.PLC.ModbusImpl.Elevator.Model;
+using JSMachine.WMS.PLC.ModbusImpl.PaperFeedGroundRack.ModbusIO.Write;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace JSMachine.WMS.Business.RcsCallBack.ServiceImpl.StrategyPatternImpl
+{
+    public class ElevatorStrategy : ITaskCompletionStrategy
+    {
+        private readonly IElevatorPlcQueueService _elevatorPlcQueueService;
+        private readonly IStorageRackService _storageRackService;
+        private readonly IAGVTaskService _agvTaskService;
+        private readonly IElevatorCountService _elevatorCountService;
+
+        public ElevatorStrategy(
+            IElevatorPlcQueueService elevatorPlcQueueService,
+            IStorageRackService storageRackService,
+            IElevatorCountService elevatorCountService,
+            IAGVTaskService agvTaskService)
+        {
+            _elevatorPlcQueueService = elevatorPlcQueueService;
+            _storageRackService = storageRackService;
+            _elevatorCountService = elevatorCountService;
+            _agvTaskService = agvTaskService;
+        }
+
+        public async Task<bool> CompleteTaskAsync(AGVTaskDto agvTask, StorageRackDto destWarehouse)
+        {
+            ElevatorPlcStatus elevatorPlcStatus = new();
+
+            int elevatorNo = destWarehouse.StorageRackName.Contains("1号") ? 1 : 2;
+            elevatorPlcStatus.ElevatorNo = elevatorNo;
+
+            if (destWarehouse.ElevatorChannel == 1001)
+            {
+                elevatorPlcStatus.StockInPutdownChanelTwo = true;
+            }
+            if (destWarehouse.ElevatorChannel == 1011)
+            {
+                elevatorPlcStatus.StockInPutdownChanelOne = true;
+            }
+
+            bool bRet = await ElevatorWrite.WriteElevator(elevatorPlcStatus);
+
+            if (!bRet)
+            {
+                LogHelper.Error($"向 {elevatorPlcStatus.ElevatorNo} 号提升机 {destWarehouse.ElevatorChannel} 网带写放货完成信号失败");
+                return false;
+            }
+
+            ElevatorPlcQueueDto elevatorPlcQueue = new()
+            {
+                ElevatorNo = elevatorNo,
+                ElevatorChannel = destWarehouse.ElevatorChannel.Value,
+                AgvTaskId = agvTask.Id,
+                IsLock = false
+            };
+
+            bRet = await _elevatorPlcQueueService.Add(elevatorPlcQueue);
+            if (!bRet)
+            {
+                LogHelper.Error($"写PLC队列失败");
+                return false;
+            }
+            else
+            {
+                LogHelper.Info($"入库：写提升机队列成功 提升机编号 {elevatorPlcQueue.ElevatorNo} 通道号 {elevatorPlcQueue.ElevatorChannel}");
+            }
+
+            agvTask.TaskStatus = TaskStatusEnum.Completed;
+            await _agvTaskService.EditSingalWithSpecificCols(agvTask, ["TaskStatus"]);
+
+            //解锁提升机通道库位
+            await _storageRackService.Unlock(destWarehouse);
+            //提升机计数
+            await _elevatorCountService.IncrementCount(elevatorNo, elevatorPlcQueue.ElevatorChannel);
+
+            return true;
+        }
+    }
+}
@@ -0,0 +1,80 @@
+using JSMachine.WMS.App.Dto;
+using JSMachine.WMS.App.Dto.Enum;
+using JSMachine.WMS.App.IService;
+using JSMachine.WMS.App.ServiceImpl;
+using JSMachine.WMS.Business.RcsCallBack.IService.StrategyPattern;
+using JSMachine.WMS.Infrastructure.Helper;
+using Prism;
+using System;
+using System.Collections.Generic;
+using System.ComponentModel.Design;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using static JSMachine.WMS.App.Dto.StorageRackDto;
+
+namespace JSMachine.WMS.Business.RcsCallBack.ServiceImpl.StrategyPatternImpl
+{
+    /// <summary>
+    /// 存储区策略（普通库位，中转库位）
+    /// </summary>
+    public class StorageAreaStrategy : ITaskCompletionStrategy
+    {
+        private readonly IStorageRackService _storageRackService;
+        private readonly IAGVTaskService _agvTaskService;
+        private readonly IERPTaskService _erpTaskService;
+        public StorageAreaStrategy(
+            IStorageRackService storageRackService,
+            IAGVTaskService agvTaskService,
+            IERPTaskService erpTaskService)
+        {
+            _storageRackService = storageRackService;
+            _agvTaskService = agvTaskService;
+            _erpTaskService = erpTaskService;
+        }
+
+        public async Task<bool> CompleteTaskAsync(AGVTaskDto agvTask, StorageRackDto destWarehouse)
+        {
+            
+            
+
+            bool bRet = await _agvTaskService.EditSingalWithSpecificCols(agvTask, ["TaskStatus"]);
+            if (!bRet)
+            {
+                LogHelper.Error($"更新agvTask {agvTask.Id} 失败");
+                return false;
+            }
+
+            destWarehouse.BingdingMaterial(new MateriaInfo
+            {
+                BarCode = agvTask.BarCode,
+                MateriaBatch = agvTask.MateriaBatch,
+                MateriaCode = agvTask.MateriaCode,
+                MateriaName = agvTask.MateriaName,
+                MateriaNum = agvTask.MateriaNum.ToString(),
+                MateriaType = agvTask.MateriaType,
+                OrderNo = agvTask.OrderNo
+            });
+            //托盘放到位后解锁库位
+            destWarehouse.IsLock = false;
+            await _storageRackService.EditSingal(destWarehouse);
+
+            agvTask.TaskStatus = TaskStatusEnum.Completed;
+            await _agvTaskService.EditSingalWithSpecificCols(agvTask, ["TaskStatus"]);
+
+            //更新erp任务状态为完成
+            await UpdateErpTaskStatus(agvTask, TaskStatusEnum.Completed);
+
+            return true;
+        }
+        private async Task UpdateErpTaskStatus(AGVTaskDto agvTask, TaskStatusEnum taskStatus)
+        {
+            ERPTaskDto erpTask = await _erpTaskService.GetSingalByExpression(p => p.Id == agvTask.ErpTaskId);
+            erpTask.TaskStatus = taskStatus;
+            //更新erp任务状态为完成
+            bool bRet = await _erpTaskService.EditSingal(erpTask);
+            LogHelper.Info($"更新erptask状态为 {taskStatus} ,数据库操作结果 {bRet}");
+        }
+
+    }
+}
@@ -0,0 +1,46 @@
+using JSMachine.WMS.App.Dto;
+using JSMachine.WMS.App.Dto.Enum;
+using JSMachine.WMS.Business.RcsCallBack.IService.StrategyPattern;
+using JSMachine.WMS.Domain.Entity;
+using JSMachine.WMS.Infrastructure;
+using JSMachine.WMS.Infrastructure.Helper;
+using Microsoft.Extensions.DependencyInjection;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace JSMachine.WMS.Business.RcsCallBack.ServiceImpl.StrategyPatternImpl
+{
+    /// <summary>
+        /// 根据任务楼层、目标区域和提升机区域选择任务完成处理策略。
+    /// </summary>
+    public class TaskCompletionStrategyFactory
+    {
+        /// <summary>
+        /// 解析 AGV 任务完成后的后续处理策略。
+        /// </summary>
+        /// <param name="agvTask">已完成的 AGV 任务。</param>
+        /// <param name="destWarehouse">任务目标库位。</param>
+        /// <returns>匹配的策略实例；无法匹配时返回空值。</returns>
+        public ITaskCompletionStrategy GetStrategy(AGVTaskDto agvTask, StorageRackDto destWarehouse)
+        {
+            if (agvTask.Floor == FloorEnum.FirstFloor)
+            {
+                if (destWarehouse.Transport == TransportEnum.NormalArea)
+                    return GlobalServericeProvidor.GetService<StorageAreaStrategy>();
+                else if (destWarehouse.ReservoirAreaId == 1091 || destWarehouse.ReservoirAreaId == 1092)
+                    return GlobalServericeProvidor.GetService<ElevatorStrategy>();
+            }
+            else if (
+                agvTask.Floor == FloorEnum.SecondFloor &&
+                (destWarehouse.Transport == TransportEnum.NormalArea || destWarehouse.Transport == TransportEnum.TransitArea))
+            {
+                return GlobalServericeProvidor.GetService<StorageAreaStrategy>();
+            }
+
+            return null;
+        }
+    }
+}