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

wanshenmean

14 小时以前 627371d0ffdf50239313f2c86d022a0c5c69550d

 Code/WCS/WIDESEAWCS_Server/WIDESEAWCS_Tasks/RobotJob/RobotTaskProcessor.cs

@@ -1,5 +1,5 @@
using Microsoft.Extensions.Logging;
using Newtonsoft.Json;
using Serilog;
using WIDESEA_Core;
using WIDESEAWCS_Common;
using WIDESEAWCS_Common.HttpEnum;
@@ -176,8 +176,7 @@
            if (result)
            {
                // 发送成功，记录 Info 日志
                _logger.LogInformation("下发取货指令成功，指令: {TaskString}，设备: {DeviceName}", taskString, state.RobotCrane?.DeviceName);
                QuartzLogger.Info($"下发取货指令成功，指令: {taskString}", state.RobotCrane?.DeviceName);
                QuartzLogHelper.LogInfo(_logger, $"下发取货指令成功，指令: {taskString}，设备: {state.RobotCrane?.DeviceName}", state.RobotCrane?.DeviceName);

                // 更新任务状态为"机器人执行中"
                task.RobotTaskState = TaskRobotStatusEnum.RobotExecuting.GetHashCode();
@@ -185,7 +184,7 @@
                // 将任务关联到状态对象
                state.CurrentTask = task;

                if(isScanNG)
                if (isScanNG)
                {
                    state.IsScanNG = true;
                }
@@ -200,8 +199,7 @@
            else
            {
                // 发送失败，记录 Error 日志
                _logger.LogError("下发取货指令失败，指令: {TaskString}，设备: {DeviceName}", taskString, state.RobotCrane?.DeviceName);
                QuartzLogger.Error($"下发取货指令失败，指令: {taskString}", state.RobotCrane?.DeviceName);
                QuartzLogHelper.LogError(_logger, $"下发取货指令失败，指令: {taskString}，设备: {state.RobotCrane?.DeviceName}", state.RobotCrane?.DeviceName);
            }
        }

@@ -224,7 +222,7 @@
        {
            if (positions == null || positions.Count == 0)
            {
                _logger.LogWarning("SendSocketRobotFakeBatteryPickAsync：平面点位列表为空，任务号: {TaskNum}", task.RobotTaskNum);
                QuartzLogHelper.LogWarn(_logger, $"SendSocketRobotFakeBatteryPickAsync：平面点位列表为空，任务号: {task.RobotTaskNum}", state.RobotCrane?.DeviceName ?? "Unknown");
                return;
            }

@@ -241,9 +239,7 @@

            if (result)
            {
                _logger.LogInformation("下发假电芯取货指令成功，指令: {TaskString}，点位: {Positions}，设备: {DeviceName}",
                    taskString, string.Join(",", positions), state.RobotCrane?.DeviceName);
                QuartzLogger.Info($"下发假电芯取货指令成功，指令: {taskString}", state.RobotCrane?.DeviceName);
                QuartzLogHelper.LogInfo(_logger, $"下发假电芯取货指令成功，指令: {taskString}，点位: {string.Join(",", positions)}，设备: {state.RobotCrane?.DeviceName}", state.RobotCrane?.DeviceName);

                // 更新任务状态为"机器人执行中"
                task.RobotTaskState = TaskRobotStatusEnum.RobotExecuting.GetHashCode();
@@ -258,8 +254,7 @@
            }
            else
            {
                _logger.LogError("下发假电芯取货指令失败，指令: {TaskString}，设备: {DeviceName}", taskString, state.RobotCrane?.DeviceName);
                QuartzLogger.Error($"下发假电芯取货指令失败，指令: {taskString}", state.RobotCrane?.DeviceName);
                QuartzLogHelper.LogError(_logger, $"下发假电芯取货指令失败，指令: {taskString}，设备: {state.RobotCrane?.DeviceName}", state.RobotCrane?.DeviceName);
            }
        }

@@ -324,9 +319,7 @@

            if (result)
            {
                _logger.LogInformation("下发批次取货指令成功，指令: {TaskString}，批次: {Range}，设备: {DeviceName}",
                    taskString, range, state.RobotCrane?.DeviceName);
                QuartzLogger.Info($"下发批次取货指令成功，指令: {taskString}，批次: {range}", state.RobotCrane?.DeviceName);
                QuartzLogHelper.LogInfo(_logger, $"下发批次取货指令成功，指令: {taskString}，批次: {range}，设备: {state.RobotCrane?.DeviceName}", state.RobotCrane?.DeviceName);

                task.RobotTaskState = TaskRobotStatusEnum.RobotExecuting.GetHashCode();
                state.CurrentTask = task;
@@ -338,8 +331,51 @@
            }
            else
            {
                _logger.LogError("下发批次取货指令失败，指令: {TaskString}，设备: {DeviceName}", taskString, state.RobotCrane?.DeviceName);
                QuartzLogger.Error($"下发批次取货指令失败，指令: {taskString}", state.RobotCrane?.DeviceName);
                QuartzLogHelper.LogError(_logger, $"下发批次取货指令失败，指令: {taskString}，设备: {state.RobotCrane?.DeviceName}", state.RobotCrane?.DeviceName);
            }
        }

        /// <summary>
        /// 下发假电芯取货指令（带批次格式和总数）
        /// </summary>
        /// <remarks>
        /// 发送顺序：
        /// 1. PickTotalNum,{N} -- 真实电芯总数
        /// 2. Pickbattery,5,{start}-{end} -- 批次取货指令（固定从5号位取）
        ///
        /// 下发成功后更新任务状态为"机器人执行中"。
        /// </remarks>
        /// <param name="task">要下发的任务对象</param>
        /// <param name="state">机器人当前状态</param>
        /// <param name="batchStart">批次起始编号</param>
        /// <param name="batchEnd">批次结束编号</param>
        public async Task SendFakeBatteryPickWithBatchAsync(Dt_RobotTask task, RobotSocketState state, int batchStart, int batchEnd)
        {
            // 先发送总数指令
            string totalNumCmd = $"PickTotalNum,{task.RobotTaskTotalNum}";
            await _socketClientGateway.SendToClientAsync(state.IPAddress, totalNumCmd);

            // 再发送批次取货指令（假电芯固定从5号位取）
            string range = batchEnd == 0 ? $"{batchStart}-0" : $"{batchStart}-{batchEnd}";
            string taskString = $"Pickbattery,5,{range}";

            bool result = await _socketClientGateway.SendToClientAsync(state.IPAddress, taskString);

            if (result)
            {
                QuartzLogHelper.LogInfo(_logger, $"下发假电芯批次取货指令成功，指令: {taskString}，批次: {range}，设备: {state.RobotCrane?.DeviceName}", state.RobotCrane?.DeviceName);

                task.RobotTaskState = TaskRobotStatusEnum.RobotExecuting.GetHashCode();
                state.CurrentTask = task;

                if (_stateManager.TryUpdateStateSafely(state.IPAddress, state))
                {
                    await _robotTaskService.UpdateRobotTaskAsync(task);
                }
            }
            else
            {
                QuartzLogHelper.LogError(_logger, $"下发假电芯批次取货指令失败，指令: {taskString}，设备: {state.RobotCrane?.DeviceName}", state.RobotCrane?.DeviceName);
            }
        }

@@ -372,9 +408,7 @@

            if (result)
            {
                _logger.LogInformation("下发放货指令成功，指令: {TaskString}，批次: {Range}，设备: {DeviceName}",
                    taskString, range, state.RobotCrane?.DeviceName);
                QuartzLogger.Info($"下发放货指令成功，指令: {taskString}，批次: {range}", state.RobotCrane?.DeviceName);
                QuartzLogHelper.LogInfo(_logger, $"下发放货指令成功，指令: {taskString}，批次: {range}，设备: {state.RobotCrane?.DeviceName}", state.RobotCrane?.DeviceName);

                task.RobotTaskState = TaskRobotStatusEnum.RobotExecuting.GetHashCode();
                state.CurrentTask = task;
@@ -386,9 +420,7 @@
            }
            else
            {
                _logger.LogError("下发放货指令失败，指令: {TaskString}，设备: {DeviceName}",
                    taskString, state.RobotCrane?.DeviceName);
                QuartzLogger.Error($"下发放货指令失败，指令: {taskString}", state.RobotCrane?.DeviceName);
                QuartzLogHelper.LogError(_logger, $"下发放货指令失败，指令: {taskString}，设备: {state.RobotCrane?.DeviceName}", state.RobotCrane?.DeviceName);
            }
        }

@@ -409,30 +441,28 @@
        /// <param name="state">机器人当前状态</param>
        /// <param name="useSourceAddress">是否使用源地址（true 表示拆盘/换盘场景，false 表示组盘/换盘场景）</param>
        /// <returns>处理是否成功</returns>
        public async Task<bool> HandleInboundTaskAsync(RobotSocketState state, bool useSourceAddress)
        public async Task<bool> HandleInboundTaskAsync(RobotSocketState state, bool useSourceAddress, string isRoadway = null)
        {
            // 获取当前关联的任务
            var currentTask = state.CurrentTask;
            if (currentTask == null)
            {
                _logger.LogDebug("HandleInboundTaskAsync：当前任务为空");
                QuartzLogger.Debug($"HandleInboundTaskAsync：当前任务为空", state.RobotCrane?.DeviceName ?? "Unknown");
                QuartzLogHelper.LogDebug(_logger, $"HandleInboundTaskAsync：当前任务为空", state.RobotCrane?.DeviceName ?? "Unknown");
                return false;
            }

            // 获取巷道代码
            string roadway = currentTask.RobotSourceAddressLineCode;
            string roadway = string.Empty;

            // 根据巷道名称判断仓库 ID
            // ZYRB1 -> 1, HPRB001 -> 2, 其他 -> 3
            int warehouseId = currentTask.RobotRoadway == "注液组盘机械手" ? 1 : currentTask.RobotRoadway == "HPRB001" ? 2 : 3;

            // 任务类型（0 表示未定义，稍后根据任务类型设置）
            int taskType = 0;
            int warehouseId = 0;

            // 源地址和目标地址（初始化）
            string SourceAddress = currentTask.RobotTargetAddressLineCode;
            string TargetAddress = currentTask.RobotSourceAddressLineCode;

            // 任务类型（0 表示未定义，稍后根据任务类型设置）
            int taskType = 0;

            // 托盘代码（初始化为空）
            string PalletCode = string.Empty;
@@ -447,16 +477,33 @@
                switch (robotTaskType)
                {
                    case RobotTaskTypeEnum.GroupPallet:
                        // 组盘任务不使用源地址，直接返回 false
                        _logger.LogDebug("HandleInboundTaskAsync：组盘任务不使用源地址");
                        QuartzLogger.Debug($"HandleInboundTaskAsync：组盘任务不使用源地址", state.RobotCrane?.DeviceName ?? "Unknown");
                        return false;
                        warehouseId = 1;
                        roadway = "GWSC1";
                        break;

                    case RobotTaskTypeEnum.ChangePallet:
                        // 换盘/拆盘场景：托盘需要入库
                        taskType = TaskTypeEnum.InEmpty.GetHashCode();  // 空托盘入库
                        PalletCode = currentTask.RobotSourceAddressPalletCode;  // 使用源地址的托盘码
                        if (isRoadway == "HWSC1")
                        {
                            warehouseId = 2;
                            roadway = "HWSC1";
                        }
                        else if (isRoadway == "GWSC1")
                        {
                            warehouseId = 1;
                            roadway = "GWSC1";
                        }

                        break;
                    case RobotTaskTypeEnum.SplitPallet:
                        // 换盘/拆盘场景：托盘需要入库
                        taskType = TaskTypeEnum.InEmpty.GetHashCode();  // 空托盘入库
                        PalletCode = currentTask.RobotSourceAddressPalletCode;  // 使用源地址的托盘码

                        warehouseId = 3;
                        roadway = "CWSC1";
                        break;
                }
            }
@@ -466,17 +513,34 @@
                switch (robotTaskType)
                {
                    case RobotTaskTypeEnum.ChangePallet:
                        // 换盘/组盘场景：货物需要入库
                        taskType = TaskTypeEnum.Inbound.GetHashCode();  // 成品入库
                        PalletCode = currentTask.RobotTargetAddressPalletCode;  // 使用目标地址的托盘码

                        if (isRoadway == "HWSC1")
                        {
                            warehouseId = 2;
                            roadway = "HWSC1";
                        }
                        else if (isRoadway == "GWSC1")
                        {
                            warehouseId = 1;
                            roadway = "GWSC1";
                        }

                        break;
                    case RobotTaskTypeEnum.GroupPallet:
                        // 换盘/组盘场景：货物需要入库
                        taskType = TaskTypeEnum.Inbound.GetHashCode();  // 成品入库
                        PalletCode = currentTask.RobotTargetAddressPalletCode;  // 使用目标地址的托盘码

                        warehouseId = 1;
                        roadway = "GWSC1";
                        break;

                    case RobotTaskTypeEnum.SplitPallet:
                        // 拆盘任务不使用目标地址
                        _logger.LogDebug("HandleInboundTaskAsync：拆盘任务不使用目标地址");
                        QuartzLogger.Debug($"HandleInboundTaskAsync：拆盘任务不使用目标地址", state.RobotCrane?.DeviceName ?? "Unknown");
                        return true;

                        break;
                }
            }

@@ -485,25 +549,35 @@
            {
                PalletCode = PalletCode,                    // 托盘条码
                SourceAddress = SourceAddress ?? string.Empty,  // 源地址
                TargetAddress = TargetAddress ?? string.Empty,  // 目标地址
                Roadway = roadway,                          // 巷道
                TargetAddress = roadway ?? string.Empty,  // 目标地址
                Roadway = roadway ?? string.Empty,             // 巷道
                WarehouseId = warehouseId,                   // 仓库 ID
                PalletType = 1,                             // 托盘类型（默认为1）
                TaskType = taskType                         // 任务类型（入库/空托盘入库）
            };

            // 记录日志：开始调用 WMS 创建入库任务
            _logger.LogInformation("HandleInboundTaskAsync：调用WMS创建入库任务，托盘码: {PalletCode}，任务类型: {TaskType}", PalletCode, taskType);
            QuartzLogger.Info($"调用WMS创建入库任务，托盘码: {PalletCode}，任务类型: {taskType}", state.RobotCrane?.DeviceName ?? "Unknown");
            QuartzLogHelper.LogInfo(_logger, $"HandleInboundTaskAsync：调用WMS创建入库任务，托盘码: {PalletCode}，任务类型: {taskType}", state.RobotCrane?.DeviceName ?? "Unknown");

            // 调用 WMS 接口创建入库任务
            var result = _httpClientHelper.Post<WebResponseContent>(nameof(ConfigKey.CreateTaskInboundAsync), taskDto.ToJson());
            string configKey = nameof(ConfigKey.CreateTaskInboundAsync);
            string requestParam = taskDto.ToJson();
            DateTime startTime = DateTime.Now;

            var result = _httpClientHelper.Post<WebResponseContent>(configKey, requestParam);

            if (!result.IsSuccess || !result.Data.Status)
            {
                QuartzLogHelper.LogError(_logger, $"调用WMS接口失败,接口:【{configKey}】,请求参数:【{requestParam}】,错误信息:【{result.Data?.Message}】", state.RobotCrane?.DeviceName ?? "Unknown");
                return false;
            }

            QuartzLogHelper.LogInfo(_logger, $"调用WMS接口成功,接口:【{configKey}】,响应数据:【{result.Data?.Data}】,耗时:{(DateTime.Now - startTime).TotalMilliseconds}ms", state.RobotCrane?.DeviceName ?? "Unknown");

            // 如果调用失败或返回错误状态
            if (!result.Data.Status && result.IsSuccess)
            {
                _logger.LogError("HandleInboundTaskAsync：WMS返回错误状态，Status: {Status}", result.Data.Status);
                QuartzLogger.Error($"HandleInboundTaskAsync：WMS返回错误状态", state.RobotCrane?.DeviceName ?? "Unknown");
                QuartzLogHelper.LogError(_logger, $"HandleInboundTaskAsync：WMS返回错误状态，Status: {result.Data.Status}", state.RobotCrane?.DeviceName ?? "Unknown");
                return false;
            }

@@ -514,8 +588,7 @@
            var content = _taskService.ReceiveWMSTask(new List<WMSTaskDTO> { taskDTO });
            if (!content.Status)
            {
                _logger.LogError("HandleInboundTaskAsync：接收WMS任务失败");
                QuartzLogger.Error($"HandleInboundTaskAsync：接收WMS任务失败", state.RobotCrane?.DeviceName ?? "Unknown");
                QuartzLogHelper.LogError(_logger, $"HandleInboundTaskAsync：接收WMS任务失败", state.RobotCrane?.DeviceName ?? "Unknown");
                return false;
            }

@@ -552,7 +625,7 @@
            //    }
            //}

            return false;
            return true;
        }

        /// <summary>
@@ -618,7 +691,18 @@
        /// <returns>HTTP 响应结果</returns>
        public HttpResponseResult<WebResponseContent> PostSplitPalletAsync(StockDTO stockDTO)
        {
            return _httpClientHelper.Post<WebResponseContent>(nameof(ConfigKey.SplitPalletAsync), stockDTO.ToJson());
            string configKey = nameof(ConfigKey.SplitPalletAsync);
            string requestParam = stockDTO.ToJson();
            DateTime startTime = DateTime.Now;

            var result = _httpClientHelper.Post<WebResponseContent>(configKey, requestParam);

            if (!result.IsSuccess || !result.Data.Status)
                QuartzLogHelper.LogError(_logger, $"调用WMS接口失败,接口:【{configKey}】,请求参数:【{requestParam}】,错误信息:【{result.Data?.Message}】", "RobotTaskProcessor");
            else
                QuartzLogHelper.LogInfo(_logger, $"调用WMS接口成功,接口:【{configKey}】,响应数据:【{result.Data?.Data}】,耗时:{(DateTime.Now - startTime).TotalMilliseconds}ms", "RobotTaskProcessor");

            return result;
        }

        /// <summary>
@@ -637,7 +721,17 @@
        /// <returns>HTTP 响应结果</returns>
        public HttpResponseResult<WebResponseContent> PostGroupPalletAsync(string configKey, StockDTO stockDTO)
        {
            return _httpClientHelper.Post<WebResponseContent>(configKey, stockDTO.ToJson());
            string requestParam = stockDTO.ToJson();
            DateTime startTime = DateTime.Now;

            var result = _httpClientHelper.Post<WebResponseContent>(configKey, requestParam);

            if (!result.IsSuccess || !result.Data.Status)
                QuartzLogHelper.LogError(_logger, $"调用WMS接口失败,接口:【{configKey}】,请求参数:【{requestParam}】,错误信息:【{result.Data?.Message}】", "RobotTaskProcessor");
            else
                QuartzLogHelper.LogInfo(_logger, $"调用WMS接口成功,接口:【{configKey}】,响应数据:【{result.Data?.Data}】,耗时:{(DateTime.Now - startTime).TotalMilliseconds}ms", "RobotTaskProcessor");

            return result;
        }

        /// <summary>
@@ -647,11 +741,23 @@
        /// 当拆盘任务全部取完时调用，一次性上传整个托盘的解绑数据到 MES。
        /// </remarks>
        /// <param name="palletCode">源托盘号</param>
        /// <param name="deviceName">设备名称，用于传递到 WMS</param>
        /// <returns>HTTP 响应结果</returns>
        public HttpResponseResult<WebResponseContent> PostSplitPalletConfirmAsync(string palletCode)
        public HttpResponseResult<WebResponseContent> PostSplitPalletConfirmAsync(string palletCode, string deviceName)
        {
            var request = new { PalletCode = palletCode };
            return _httpClientHelper.Post<WebResponseContent>(nameof(ConfigKey.SplitPalletConfirm), request.ToJson());
            string configKey = nameof(ConfigKey.SplitPalletConfirm);
            var request = new { PalletCode = palletCode, DeviceName = deviceName };
            string requestParam = request.ToJson();
            DateTime startTime = DateTime.Now;

            var result = _httpClientHelper.Post<WebResponseContent>(configKey, requestParam);

            if (!result.IsSuccess || !result.Data.Status)
                QuartzLogHelper.LogError(_logger, $"调用WMS接口失败,接口:【{configKey}】,请求参数:【{requestParam}】,错误信息:【{result.Data?.Message}】", "RobotTaskProcessor");
            else
                QuartzLogHelper.LogInfo(_logger, $"调用WMS接口成功,接口:【{configKey}】,响应数据:【{result.Data?.Data}】,耗时:{(DateTime.Now - startTime).TotalMilliseconds}ms", "RobotTaskProcessor");

            return result;
        }

        /// <summary>
@@ -661,11 +767,23 @@
        /// 当组盘任务全部放完时调用，一次性上传整个托盘的绑定数据到 MES。
        /// </remarks>
        /// <param name="palletCode">目标托盘号</param>
        /// <param name="deviceName">设备名称，用于传递到 WMS</param>
        /// <returns>HTTP 响应结果</returns>
        public HttpResponseResult<WebResponseContent> PostGroupPalletConfirmAsync(string palletCode)
        public HttpResponseResult<WebResponseContent> PostGroupPalletConfirmAsync(string palletCode, string deviceName)
        {
            var request = new { PalletCode = palletCode };
            return _httpClientHelper.Post<WebResponseContent>(nameof(ConfigKey.GroupPalletConfirm), request.ToJson());
            string configKey = nameof(ConfigKey.GroupPalletConfirm);
            var request = new { PalletCode = palletCode, DeviceName = deviceName };
            string requestParam = request.ToJson();
            DateTime startTime = DateTime.Now;

            var result = _httpClientHelper.Post<WebResponseContent>(configKey, requestParam);

            if (!result.IsSuccess || !result.Data.Status)
                QuartzLogHelper.LogError(_logger, $"调用WMS接口失败,接口:【{configKey}】,请求参数:【{requestParam}】,错误信息:【{result.Data?.Message}】", "RobotTaskProcessor");
            else
                QuartzLogHelper.LogInfo(_logger, $"调用WMS接口成功,接口:【{configKey}】,响应数据:【{result.Data?.Data}】,耗时:{(DateTime.Now - startTime).TotalMilliseconds}ms", "RobotTaskProcessor");

            return result;
        }
    }
}