feat(MES): 添加MES接口相关实体和DTO JS扩展文件至JSX格式并更新配置

wanshenmean

4 天以前 ce1292c9cf37195b6abd2699dfc5d6cb3e143c9b

 Code/WCS/WIDESEAWCS_Server/WIDESEAWCS_Tasks/StackerCraneJob/StackerCraneCommandBuilder.cs

@@ -1,6 +1,9 @@
using Microsoft.Extensions.Logging;
using System;
using System.Diagnostics.CodeAnalysis;
using WIDESEAWCS_Common.Constants;
using WIDESEAWCS_Common.TaskEnum;
using WIDESEAWCS_Core.LogHelper;
using WIDESEAWCS_ITaskInfoService;
using WIDESEAWCS_Model.Models;
using WIDESEAWCS_QuartzJob.Models;
@@ -39,19 +42,27 @@
        private readonly StackerCraneCommandConfig _config;

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

        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="taskService">任务服务</param>
        /// <param name="routerService">路由服务</param>
        /// <param name="config">命令配置</param>
        /// <param name="logger">日志记录器</param>
        public StackerCraneCommandBuilder(
            ITaskService taskService,
            IRouterService routerService,
            StackerCraneCommandConfig config)
            StackerCraneCommandConfig config,
            ILogger logger)
        {
            _taskService = taskService;
            _routerService = routerService;
            _config = config;
            _logger = logger;
        }

        /// <summary>
@@ -64,15 +75,19 @@
        /// <returns>堆垛机命令对象，转换失败返回 null</returns>
        public object? ConvertToStackerCraneTaskCommand([NotNull] Dt_Task task)
        {
            return  BuildCommand(task, CreateStandardCommand(task));
            // 根据巷道获取命令类型
            string commandType = GetCommandType(task.Roadway);
            //string commandType = GetCommandType(task.Roadway);

            // 根据命令类型调用相应的构建方法
            return commandType switch
            {
                "Formation" => BuildCommand(task, CreateFormationCommand(task)),  // 成型命令
                _ => BuildCommand(task, CreateStandardCommand(task))              // 标准命令
            };
            //_logger.LogInformation("ConvertToStackerCraneTaskCommand：构建命令，任务号: {TaskNum}，巷道: {Roadway}，命令类型: {CommandType}", task.TaskNum, task.Roadway, commandType);
            //QuartzLogger.Info($"构建命令，任务号: {task.TaskNum}，巷道: {task.Roadway}，命令类型: {commandType}", task.Roadway);

            //// 根据命令类型调用相应的构建方法
            //return commandType switch
            //{
            //    "Formation" => BuildCommand(task, CreateFormationCommand(task)),  // 成型命令
            //    _ => BuildCommand(task, CreateStandardCommand(task))              // 标准命令
            //};
        }

        /// <summary>
@@ -90,10 +105,14 @@
            {
                if (roadway.Contains(mapping.Key))
                {
                    _logger.LogDebug("GetCommandType：匹配巷道 {Roadway}，命令类型: {CommandType}", roadway, mapping.Value);
                    QuartzLogger.Debug($"GetCommandType：匹配巷道 {roadway}，命令类型: {mapping.Value}", roadway);
                    return mapping.Value;
                }
            }

            _logger.LogDebug("GetCommandType：巷道 {Roadway} 未匹配，使用默认命令类型: {DefaultType}", roadway, _config.DefaultCommandType);
            QuartzLogger.Debug($"GetCommandType：巷道 {roadway} 未匹配，使用默认命令类型: {_config.DefaultCommandType}", roadway);
            return _config.DefaultCommandType;
        }

@@ -110,8 +129,8 @@
            return new StackerCraneTaskCommand
            {
                TaskNum = task.TaskNum,   // 任务号
                WorkType = 1,             // 作业类型
                WorkAction = 1            // 作业指令：开始执行
                WorkType = StackerCraneConst.WorkTypeInbound,  // 作业类型：入库
                //WorkAction = StackerCraneWorkActionEnum.StartTask  // 作业指令：开始执行
            };
        }

@@ -130,10 +149,10 @@
            {
                Barcode = task.PalletCode,   // 托盘条码
                TaskNum = task.TaskNum,      // 任务号
                WorkType = 1,               // 作业类型
                WorkAction = 1,             // 作业指令：开始执行
                FireAlarm = 0,              // 火警：正常
                HeartBeat = 0,              // 心跳
                WorkType = StackerCraneConst.WorkTypeInbound,  // 作业类型：入库
                WorkAction = (short)StackerCraneWorkActionEnum.StartTask,  // 作业指令：开始执行
                FireAlarm = StackerCraneConst.FireAlarmNormal,  // 火警：正常
                HeartBeat = StackerCraneConst.HeartBeatInitial,  // 心跳
                FieldName = string.Empty     // 保留字段
            };
        }
@@ -152,6 +171,9 @@
        {
            // 获取任务类型分组
            TaskTypeGroup taskTypeGroup = task.TaskType.GetTaskTypeGroup();

            _logger.LogDebug("BuildCommand：任务号: {TaskNum}，任务类型分组: {TaskTypeGroup}", task.TaskNum, taskTypeGroup);
            QuartzLogger.Debug($"BuildCommand：任务号: {task.TaskNum}，任务类型分组: {taskTypeGroup}", task.Roadway);

            // 根据任务类型分发构建
            return taskTypeGroup switch
@@ -178,11 +200,14 @@
        /// <returns>填充好的命令对象</returns>
        private T? BuildInboundCommand<T>(Dt_Task task, T command) where T : class
        {
            // 确定任务类型（空托盘用特殊类型 100）
            _logger.LogInformation("BuildInboundCommand：构建入库命令，任务号: {TaskNum}", task.TaskNum);
            QuartzLogger.Info($"BuildInboundCommand：构建入库命令，任务号: {task.TaskNum}", task.Roadway);

            // 确定任务类型（空托盘用特殊类型）
            int taskType = 0;
            if (task.TaskType == (int)TaskOutboundTypeEnum.OutEmpty)
            {
                taskType = 100;
                taskType = StackerCraneConst.EmptyPalletTaskType;
            }
            else
                taskType = task.TaskType;
@@ -192,6 +217,8 @@
            if (router == null)
            {
                // 未找到站台，更新异常信息
                _logger.LogError("BuildInboundCommand：未找到站台【{CurrentAddress}】信息，任务号: {TaskNum}", task.CurrentAddress, task.TaskNum);
                QuartzLogger.Error($"BuildInboundCommand：未找到站台【{task.CurrentAddress}】信息", task.Roadway);
                _taskService.UpdateTaskExceptionMessage(task.TaskNum, $"未找到站台【{task.CurrentAddress}】信息，无法获取对应的堆垛机取货站台信息");
                return null;
            }
@@ -204,6 +231,8 @@
            // 解析目标地址（库位地址）
            if (!TryParseAddress(task.NextAddress, out short endRow, out short endColumn, out short endLayer))
            {
                _logger.LogError("BuildInboundCommand：入库任务终点地址解析失败，终点: {NextAddress}，任务号: {TaskNum}", task.NextAddress, task.TaskNum);
                QuartzLogger.Error($"BuildInboundCommand：入库任务终点地址解析失败，终点: {task.NextAddress}", task.Roadway);
                _taskService.UpdateTaskExceptionMessage(task.TaskNum, $"入库任务终点错误，终点：【{task.NextAddress}】");
                return null;
            }
@@ -212,6 +241,10 @@
            SetCommandProperty(command, "EndRow", endRow);
            SetCommandProperty(command, "EndColumn", endColumn);
            SetCommandProperty(command, "EndLayer", endLayer);

            _logger.LogInformation("BuildInboundCommand：入库命令构建成功，起点: {StartRow}-{StartColumn}-{StartLayer}，终点: {EndRow}-{EndColumn}-{EndLayer}，任务号: {TaskNum}",
                router.SrmRow, router.SrmColumn, router.SrmLayer, endRow, endColumn, endLayer, task.TaskNum);
            QuartzLogger.Info($"BuildInboundCommand：入库命令构建成功，起点: {router.SrmRow}-{router.SrmColumn}-{router.SrmLayer}，终点: {endRow}-{endColumn}-{endLayer}", task.Roadway);

            return command;
        }
@@ -231,11 +264,14 @@
        /// <returns>填充好的命令对象</returns>
        private T? BuildOutboundCommand<T>(Dt_Task task, T command) where T : class
        {
            _logger.LogInformation("BuildOutboundCommand：构建出库命令，任务号: {TaskNum}", task.TaskNum);
            QuartzLogger.Info($"BuildOutboundCommand：构建出库命令，任务号: {task.TaskNum}", task.Roadway);

            // 确定任务类型
            int taskType = 0;
            if (task.TaskType == (int)TaskOutboundTypeEnum.OutEmpty)
            {
                taskType = 100;
                taskType = StackerCraneConst.EmptyPalletTaskType;
            }
            else
                taskType = task.TaskType;
@@ -244,6 +280,8 @@
            Dt_Router? router = _routerService.QueryNextRoute(task.Roadway, task.TargetAddress, taskType);
            if (router == null)
            {
                _logger.LogError("BuildOutboundCommand：未找到站台【{TargetAddress}】信息，任务号: {TaskNum}", task.TargetAddress, task.TaskNum);
                QuartzLogger.Error($"BuildOutboundCommand：未找到站台【{task.TargetAddress}】信息", task.Roadway);
                _taskService.UpdateTaskExceptionMessage(task.TaskNum, $"未找到站台【{task.TargetAddress}】信息，无法获取对应的堆垛机放货站台信息");
                return null;
            }
@@ -256,6 +294,8 @@
            // 解析起始地址（库位地址）
            if (!TryParseAddress(task.CurrentAddress, out short startRow, out short startColumn, out short startLayer))
            {
                _logger.LogError("BuildOutboundCommand：出库任务起点地址解析失败，起点: {CurrentAddress}，任务号: {TaskNum}", task.CurrentAddress, task.TaskNum);
                QuartzLogger.Error($"BuildOutboundCommand：出库任务起点地址解析失败，起点: {task.CurrentAddress}", task.Roadway);
                _taskService.UpdateTaskExceptionMessage(task.TaskNum, $"出库任务起点错误，起点：【{task.CurrentAddress}】");
                return null;
            }
@@ -264,6 +304,10 @@
            SetCommandProperty(command, "StartRow", startRow);
            SetCommandProperty(command, "StartColumn", startColumn);
            SetCommandProperty(command, "StartLayer", startLayer);

            _logger.LogInformation("BuildOutboundCommand：出库命令构建成功，起点: {StartRow}-{StartColumn}-{StartLayer}，终点: {EndRow}-{EndColumn}-{EndLayer}，任务号: {TaskNum}",
                startRow, startColumn, startLayer, router.SrmRow, router.SrmColumn, router.SrmLayer, task.TaskNum);
            QuartzLogger.Info($"BuildOutboundCommand：出库命令构建成功，起点: {startRow}-{startColumn}-{startLayer}，终点: {router.SrmRow}-{router.SrmColumn}-{router.SrmLayer}", task.Roadway);

            return command;
        }
@@ -283,9 +327,14 @@
        /// <returns>填充好的命令对象</returns>
        private T? BuildRelocationCommand<T>(Dt_Task task, T command) where T : class
        {
            _logger.LogInformation("BuildRelocationCommand：构建移库命令，任务号: {TaskNum}", task.TaskNum);
            QuartzLogger.Info($"BuildRelocationCommand：构建移库命令，任务号: {task.TaskNum}", task.Roadway);

            // 解析目标地址
            if (!TryParseAddress(task.NextAddress, out short endRow, out short endColumn, out short endLayer))
            {
                _logger.LogError("BuildRelocationCommand：移库任务终点地址解析失败，终点: {NextAddress}，任务号: {TaskNum}", task.NextAddress, task.TaskNum);
                QuartzLogger.Error($"BuildRelocationCommand：移库任务终点地址解析失败，终点: {task.NextAddress}", task.Roadway);
                _taskService.UpdateTaskExceptionMessage(task.TaskNum, $"移库任务终点错误，终点：【{task.NextAddress}】");
                return null;
            }
@@ -298,6 +347,8 @@
            // 解析起始地址
            if (!TryParseAddress(task.CurrentAddress, out short startRow, out short startColumn, out short startLayer))
            {
                _logger.LogError("BuildRelocationCommand：移库任务起点地址解析失败，起点: {CurrentAddress}，任务号: {TaskNum}", task.CurrentAddress, task.TaskNum);
                QuartzLogger.Error($"BuildRelocationCommand：移库任务起点地址解析失败，起点: {task.CurrentAddress}", task.Roadway);
                _taskService.UpdateTaskExceptionMessage(task.TaskNum, $"移库任务起点错误，起点：【{task.CurrentAddress}】");
                return null;
            }
@@ -307,6 +358,10 @@
            SetCommandProperty(command, "StartColumn", startColumn);
            SetCommandProperty(command, "StartLayer", startLayer);

            _logger.LogInformation("BuildRelocationCommand：移库命令构建成功，起点: {StartRow}-{StartColumn}-{StartLayer}，终点: {EndRow}-{EndColumn}-{EndLayer}，任务号: {TaskNum}",
                startRow, startColumn, startLayer, endRow, endColumn, endLayer, task.TaskNum);
            QuartzLogger.Info($"BuildRelocationCommand：移库命令构建成功，起点: {startRow}-{startColumn}-{startLayer}，终点: {endRow}-{endColumn}-{endLayer}", task.Roadway);

            return command;
        }