refactor(logging): 重构日志记录模块，统一使用Serilog和QuartzLogHelper

wanshenmean

14 小时以前 627371d0ffdf50239313f2c86d022a0c5c69550d

 Code/WCS/WIDESEAWCS_Server/WIDESEAWCS_Tasks/RobotJob/Workflow/RobotPrefixCommandHandler.cs

@@ -1,7 +1,9 @@
using System.Net.Sockets;
using Serilog;
using WIDESEAWCS_Common.HttpEnum;
using WIDESEAWCS_Common.TaskEnum;
using WIDESEAWCS_DTO.TaskInfo;
using WIDESEAWCS_Core.Helper;
using WIDESEAWCS_Core.LogHelper;
using WIDESEAWCS_ITaskInfoService;
using WIDESEAWCS_Model.Models;
using WIDESEAWCS_Tasks.Workflow.Abstractions;
@@ -66,6 +68,11 @@
        private readonly IFakeBatteryPositionService _fakeBatteryPositionService;

        /// <summary>
        /// 日志记录器
        /// </summary>
        private readonly ILogger _logger;

        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="robotTaskService">任务服务</param>
@@ -73,18 +80,21 @@
        /// <param name="stateManager">状态管理器</param>
        /// <param name="socketClientGateway">Socket 网关</param>
        /// <param name="fakeBatteryPositionService">假电芯位置服务</param>
        /// <param name="logger">日志记录器</param>
        public RobotPrefixCommandHandler(
            IRobotTaskService robotTaskService,
            RobotTaskProcessor taskProcessor,
            RobotStateManager stateManager,
            ISocketClientGateway socketClientGateway,
            IFakeBatteryPositionService fakeBatteryPositionService)
            IFakeBatteryPositionService fakeBatteryPositionService,
            ILogger logger)
        {
            _robotTaskService = robotTaskService;
            _taskProcessor = taskProcessor;
            _stateManager = stateManager;
            _socketClientGateway = socketClientGateway;
            _fakeBatteryPositionService = fakeBatteryPositionService;
            _logger = logger;
        }

        /// <summary>
@@ -126,7 +136,7 @@
                var parts = message.Split(',');

                // 检查消息格式是否有效：至少要有命令前缀，且状态中有当前任务
                if (parts.Length < 1 || state.CurrentTask == null)
                if (parts.Length < 1)
                {
                    return;
                }
@@ -143,27 +153,34 @@
                    .ToArray();

                // 从数据库重新查询当前任务（确保获取最新状态）
                var task = await _robotTaskService.Repository.QueryFirstAsync(x => x.RobotTaskId == state.CurrentTask.RobotTaskId);
                var task = await _robotTaskService.Repository.QueryFirstAsync(x => x.RobotTaskState == TaskRobotStatusEnum.RobotExecuting.GetHashCode() && x.RobotRoadway == state.RobotCrane.DeviceName);

                // 根据命令前缀分发处理
                if (cmd.StartsWith("pickfinished"))
                if (task != null)
                {
                    // 处理取货完成
                    await HandlePickFinishedAsync(state, positions, task);
                }
                else if (cmd.StartsWith("putfinished"))
                {
                    // 处理放货完成
                    await HandlePutFinishedAsync(state, positions, task);
                }
                    // 根据命令前缀分发处理
                    if (cmd.StartsWith("pickfinished"))
                    {
                        // 处理取货完成
                        await HandlePickFinishedAsync(state, positions, task);
                    }
                    else if (cmd.StartsWith("putfinished"))
                    {
                        // 处理放货完成
                        await HandlePutFinishedAsync(state, positions, task);
                    }

                // 回写原消息到客户端（保持原有行为）
                await _socketClientGateway.SendMessageAsync(client, message);
                    // 回写原消息到客户端（保持原有行为）
                    await _socketClientGateway.SendMessageAsync(client, message);
                }
                else
                {
                    QuartzLogHelper.LogWarn(_logger, $"RobotJob HandleAsync Warning: Current task not found for RobotTaskId {state.CurrentTask.RobotTaskId}", state.RobotCrane?.DeviceName ?? "Unknown");
                }
            }
            catch (Exception ex)
            {
                // 捕获并记录异常，防止异常向上传播导致消息处理中断
                Console.WriteLine($"RobotJob MessageReceived Error: {ex.Message}");
                QuartzLogHelper.LogError(_logger, ex, $"RobotJob MessageReceived Error: {ex.Message}", $"RobotJob MessageReceived Error: {ex.Message}", state.RobotCrane?.DeviceName ?? "Unknown");
            }
        }

@@ -263,28 +280,36 @@
                    // 换盘任务：根据阶段区分处理
                    if (state.ChangePalletPhase == 2)
                    {
                        if (isFlowA)
                        {
                            // 流向A Phase2：放假电芯到目标托盘，不调用 API，不递增计数
                            // 仅更新状态
                        }
                        else
                        {
                            // 流向B Phase2：放正常电芯，递增计数
                            state.RobotTaskTotalNum += positions.Length;
                            if (task != null)
                                task.RobotTaskTotalNum -= positions.Length;
                        // Phase 2：放正常电芯到目标托盘完成，递增计数
                        state.RobotTaskTotalNum += positions.Length;
                        if (task != null)
                            task.RobotTaskTotalNum -= positions.Length;

                            // 构建库存 DTO 并调用 ChangePalletAsync API
                            var stockDTO = RobotTaskProcessor.BuildStockDTO(state, positions);
                            var result = _taskProcessor.PostGroupPalletAsync(nameof(ConfigKey.ChangePalletAsync), stockDTO);
                            putSuccess = result.Data.Status && result.IsSuccess;
                        }
                        // 两流向均调用换盘 API
                        var stockDTO = RobotTaskProcessor.BuildStockDTO(state, positions);
                        var result = _taskProcessor.PostGroupPalletAsync(nameof(ConfigKey.ChangePalletAsync), stockDTO);
                        putSuccess = result.Data.Status && result.IsSuccess;

                        // 切回 Phase 1，继续取正常电芯
                        state.ChangePalletPhase = 1;
                    }
                    else if (state.ChangePalletPhase == 4)
                    {
                        // 流向B Phase4：放假电芯到5号位，不调用 API，不递增计数，释放点位
                        _fakeBatteryPositionService.MarkAsAvailable(positions.ToList());
                        if (isFlowA)
                        {
                            // 流向A：放假电芯到目标托盘，仅递增计数，不调用 API
                            state.RobotTaskTotalNum += positions.Length;
                            if (task != null)
                                task.RobotTaskTotalNum -= positions.Length;
                        }
                        else
                        {
                            // 流向B：放假电芯到5号位，释放点位
                            _fakeBatteryPositionService.MarkAsAvailable(positions.ToList());
                        }

                        // 切回 Phase 3，继续取假电芯
                        state.ChangePalletPhase = 3;
                    }
                    else
                    {
@@ -306,9 +331,12 @@
                    putSuccess = result.Data.Status && result.IsSuccess;

                    // 增加任务计数
                    state.RobotTaskTotalNum += positions.Length;
                    if (task != null)
                        task.RobotTaskTotalNum -= positions.Length;
                    if (!state.IsScanNG)
                    {
                        state.RobotTaskTotalNum += positions.Length;
                        if (task != null)
                            task.RobotTaskTotalNum -= positions.Length;
                    }
                }
            }

@@ -317,6 +345,7 @@
            {
                // 更新当前动作为"放货完成"
                state.CurrentAction = "PutFinished";
                state.IsScanNG = false;

                // 非组盘任务时增加计数（组盘任务已在上面递增）
                if (!state.IsGroupPallet)
@@ -325,20 +354,20 @@
                    if (task != null)
                        task.RobotTaskTotalNum -= positions.Length;
                }
            }

            // 如果任务存在
            if (task != null)
            {
                // 更新任务状态为"机器人放货完成"
                task.RobotTaskState = TaskRobotStatusEnum.RobotPutFinish.GetHashCode();

                // 安全更新状态到 Redis
                if (_stateManager.TryUpdateStateSafely(state.IPAddress, state))
                // 如果任务存在
                if (task != null)
                {
                    await _robotTaskService.Repository.UpdateDataAsync(task);
                    // 更新任务状态为"机器人放货完成"
                    task.RobotTaskState = TaskRobotStatusEnum.RobotPutFinish.GetHashCode();

                    // 安全更新状态到 Redis
                    if (_stateManager.TryUpdateStateSafely(state.IPAddress, state))
                    {
                        await _robotTaskService.Repository.UpdateDataAsync(task);
                    }
                }
            }
        }
    }
}
}