wcs_core/Sln.Wcs.HikRoBotApi/Service/Impl/HikRoBotService.cs

using Sln.Wcs.HikRoBotApi.Domain.Dto.CancelTask;
using Sln.Wcs.HikRoBotApi.Domain.Dto.ContinueTask;
using Sln.Wcs.HikRoBotApi.Domain.Dto.GbCancelTask;
using Sln.Wcs.HikRoBotApi.Domain.Dto.GbContinueTask;
using Sln.Wcs.HikRoBotApi.Domain.Dto.GbTaskSubmit;
using Sln.Wcs.HikRoBotApi.Enum;
using Sln.Wcs.HikRoBotApi.Util;
using Sln.Wcs.HikRoBotSdk;
using GenAgvSchedulingTaskDto = Sln.Wcs.HikRoBotApi.Domain.Dto.GenAgvSchedulingTask.GenAgvSchedulingTaskDto;
using GenAgvSchedulingTaskResultDto = Sln.Wcs.HikRoBotApi.Domain.Dto.GenAgvSchedulingTask.GenAgvSchedulingTaskResultDto;
using TaskGroupResultDto = Sln.Wcs.HikRoBotApi.Domain.Dto.TaskGroup.TaskGroupResultDto;
using TaskPriorityResultDto = Sln.Wcs.HikRoBotApi.Domain.Dto.TaskPriority.TaskPriorityResultDto;
using ZonePauseResultDto = Sln.Wcs.HikRoBotApi.Domain.Dto.ZonePause.ZonePauseResultDto;
using ZoneHomingResultDto = Sln.Wcs.HikRoBotApi.Domain.Dto.ZoneHoming.ZoneHomingResultDto;
using ZoneBanishResultDto = Sln.Wcs.HikRoBotApi.Domain.Dto.ZoneBanish.ZoneBanishResultDto;
using ZoneBlockadeResultDto = Sln.Wcs.HikRoBotApi.Domain.Dto.ZoneBlockade.ZoneBlockadeResultDto;
using CarrierBindResultDto = Sln.Wcs.HikRoBotApi.Domain.Dto.CarrierBind.CarrierBindResultDto;
using CarrierUnbindResultDto = Sln.Wcs.HikRoBotApi.Domain.Dto.CarrierUnbind.CarrierUnbindResultDto;
using SiteBindResultDto = Sln.Wcs.HikRoBotApi.Domain.Dto.SiteBind.SiteBindResultDto;
using CarrierLockResultDto = Sln.Wcs.HikRoBotApi.Domain.Dto.CarrierLock.CarrierLockResultDto;
using SiteLockResultDto = Sln.Wcs.HikRoBotApi.Domain.Dto.SiteLock.SiteLockResultDto;
using PreTaskResultDto = Sln.Wcs.HikRoBotApi.Domain.Dto.PreTask.PreTaskResultDto;
using QueryTaskResultDto = Sln.Wcs.HikRoBotApi.Domain.Dto.QueryTask.QueryTaskResultDto;
using QueryRobotResultDto = Sln.Wcs.HikRoBotApi.Domain.Dto.QueryRobot.QueryRobotResultDto;
using QueryCarrierResultDto = Sln.Wcs.HikRoBotApi.Domain.Dto.QueryCarrier.QueryCarrierResultDto;
using MatLabelBindResultDto = Sln.Wcs.HikRoBotApi.Domain.Dto.MatLabelBind.MatLabelBindResultDto;
using MatLabelUnbindResultDto = Sln.Wcs.HikRoBotApi.Domain.Dto.MatLabelUnbind.MatLabelUnbindResultDto;
using EquipmentNotifyResultDto = Sln.Wcs.HikRoBotApi.Domain.Dto.EquipmentNotify.EquipmentNotifyResultDto;
using CancelTaskResultDto = Sln.Wcs.HikRoBotApi.Domain.Dto.CancelTask.CancelTaskResultDto;
using ContinueTaskResultDto = Sln.Wcs.HikRoBotApi.Domain.Dto.ContinueTask.ContinueTaskResultDto;

#region << 版 本 注 释 >>
/*--------------------------------------------------------------------
* 版权所有 (c) 2026 WenJY 保留所有权利。
* CLR版本：4.0.30319.42000
* 机器名称：T14-GEN3-7895
* 命名空间：Sln.Wcs.HikRoBotApi.Service.Impl
* 唯一标识：05713c1e-50f3-48cf-8ac8-0dfd1f768856
*
* 创建者：WenJY
* 电子邮箱：
* 创建时间：2026-02-25 15:15:34
* 版本：V1.0.0
* 描述：
*
*--------------------------------------------------------------------
* 修改人：
* 时间：
* 修改说明：
*
* 版本：V1.0.0
*--------------------------------------------------------------------*/
#endregion << 版 本 注 释 >>
namespace Sln.Wcs.HikRoBotApi.Service.Impl
{
    public class HikRoBotService : IHikRoBotService
    {
        private readonly IHIKRoBotSdk hikRoBotSdk;
        private readonly ApiResultCodeUtil codeUtil;

        public HikRoBotService(IHIKRoBotSdk hikRoBotSdk,ApiResultCodeUtil codeUtil)
        {
            this.hikRoBotSdk = hikRoBotSdk;
            this.codeUtil = codeUtil;
        }

        public GbContinueTaskResultDto GbContinueTask(GbContinueTaskDto gbContinueTask)
        {
            try
            {
                if (gbContinueTask == null)
                {
                    throw new ArgumentException("输入参数为空。");
                }

                var sdkDto = new HikRoBotSdk.Dto.GbContinueTask.GbContinueTaskDto()
                {
                    triggerType = gbContinueTask.TriggerType,
                    triggerCode = gbContinueTask.TriggerCode,
                    targetRoute = gbContinueTask.TargetRoute != null ? new HikRoBotSdk.Dto.Common.TargetRoute()
                    {
                        type = gbContinueTask.TargetRoute.Type,
                        code = gbContinueTask.TargetRoute.Code,
                        operation = gbContinueTask.TargetRoute.Operation,
                    } : null,
                    extra = gbContinueTask.Extra,
                };

                var resp = this.hikRoBotSdk.GbContinueTask(sdkDto);

                bool parseRes = this.codeUtil.parse(resp.code, resp.message, out HikRoBotStatusEnum hikRoBotStatus);

                return new GbContinueTaskResultDto()
                {
                    code = hikRoBotStatus,
                    msg = resp.message,
                    data = new Domain.Model.GbContinueTask.GbContinueTaskResultModel
                    {
                        RobotTaskCode = resp.data?.robotTaskCode,
                        NextSeq = resp.data?.nextSeq,
                        Extra = resp.data?.extra,
                    },
                };
            }
            catch (Exception ex)
            {
                return new GbContinueTaskResultDto()
                {
                    code = HikRoBotStatusEnum.SDK调用异常,
                    msg = ex.Message,
                };
            }
        }

        public GbCancelTaskResultDto GbCancelTask(GbCancelTaskDto gbCancelTask)
        {
            try
            {
                if (gbCancelTask == null)
                {
                    throw new ArgumentException("输入参数为空。");
                }

                var sdkDto = new HikRoBotSdk.Dto.GbCancelTask.GbCancelTaskDto()
                {
                    robotTaskCode = gbCancelTask.RobotTaskCode,
                    cancelType = gbCancelTask.CancelType,
                    carrierCode = gbCancelTask.CarrierCode,
                    robotCode = gbCancelTask.RobotCode,
                    reason = gbCancelTask.Reason,
                    returnTaskType = gbCancelTask.ReturnTaskType,
                    targetRoute = gbCancelTask.TargetRoute != null ? new HikRoBotSdk.Dto.Common.TargetRoute()
                    {
                        type = gbCancelTask.TargetRoute.Type,
                        code = gbCancelTask.TargetRoute.Code,
                    } : null,
                    extra = gbCancelTask.Extra,
                };

                var resp = this.hikRoBotSdk.GbCancelTask(sdkDto);

                bool parseRes = this.codeUtil.parse(resp.code, resp.message, out HikRoBotStatusEnum hikRoBotStatus);

                return new GbCancelTaskResultDto()
                {
                    code = hikRoBotStatus,
                    msg = resp.message,
                    data = new Domain.Model.GbCancelTask.GbCancelTaskResultModel
                    {
                        RobotTaskCode = resp.data?.robotTaskCode,
                        Extra = resp.data?.extra,
                    },
                };
            }
            catch (Exception ex)
            {
                return new GbCancelTaskResultDto()
                {
                    code = HikRoBotStatusEnum.SDK调用异常,
                    msg = ex.Message,
                };
            }
        }

        public GbTaskSubmitResultDto GbTaskSubmit(GbTaskSubmitDto gbTaskSubmit)
        {
            try
            {
                if (gbTaskSubmit == null)
                {
                    throw new ArgumentException("输入参数为空。");
                }

                var sdkDto = new HikRoBotSdk.Dto.GbTaskSubmit.GbTaskSubmitDto()
                {
                    taskType = gbTaskSubmit.TaskType,
                    initPriority = gbTaskSubmit.InitPriority,
                    deadline = gbTaskSubmit.Deadline,
                    expectedStartTime = gbTaskSubmit.ExpectedStartTime,
                    robotType = gbTaskSubmit.RobotType,
                    robotCode = gbTaskSubmit.RobotCode,
                    interrupt = gbTaskSubmit.Interrupt,
                    robotTaskCode = gbTaskSubmit.RobotTaskCode,
                    groupCode = gbTaskSubmit.GroupCode,
                    extra = gbTaskSubmit.Extra != null ? new HikRoBotSdk.Dto.Common.ExtraInfo() : null,
                    targetRoute = gbTaskSubmit.TargetRoute != null ? gbTaskSubmit.TargetRoute.ConvertAll(r => new HikRoBotSdk.Dto.Common.TargetRoute()
                    {
                        type = r.Type,
                        code = r.Code,
                        operation = r.Operation,
                        robotType = r.RobotType,
                        robotCode = r.RobotCode,
                    }) : null,
                };

                var resp = this.hikRoBotSdk.GbTaskSubmit(sdkDto);

                bool parseRes = this.codeUtil.parse(resp.code, resp.message, out HikRoBotStatusEnum hikRoBotStatus);

                return new GbTaskSubmitResultDto()
                {
                    code = hikRoBotStatus,
                    msg = resp.message,
                    data = new Domain.Model.GbTaskSubmit.GbTaskSubmitResultModel
                    {
                        code = resp.code,
                        message = resp.message,
                        data = new Domain.Model.GbTaskSubmit.GbTaskSubmitResultData()
                        {
                            robotTaskCode = resp.data?.robotTaskCode,
                            extra = resp.data?.extra?.ToString(),
                        }
                    },
                };
            }
            catch (Exception ex)
            {
                return new GbTaskSubmitResultDto()
                {
                    code = HikRoBotStatusEnum.SDK调用异常,
                    msg = ex.Message,
                };
            }
        }
        
        public TaskGroupResultDto TaskGroup(Domain.Dto.TaskGroup.TaskGroupDto taskGroup)
        {
            try
            {
                if (taskGroup == null)
                {
                    throw new ArgumentException("输入参数为空。");
                }

                var sdkDto = new Sln.Wcs.HikRoBotSdk.Dto.TaskGroup.TaskGroupDto()
                {
                    groupCode = taskGroup.GroupCode,
                    strategy = taskGroup.Strategy,
                    strategyValue = taskGroup.StrategyValue,
                    groupSeq = !string.IsNullOrEmpty(taskGroup.GroupSeq) ? int.Parse(taskGroup.GroupSeq) : (int?)null,
                    targetRoute = taskGroup.TargetRoute != null ? new Sln.Wcs.HikRoBotSdk.Dto.Common.TargetRoute()
                    {
                        type = taskGroup.TargetRoute.Type,
                        code = taskGroup.TargetRoute.Code,
                    } : null,
                };

                var resp = this.hikRoBotSdk.TaskGroup(sdkDto);

                bool parseRes = this.codeUtil.parse(resp.code, resp.message, out HikRoBotStatusEnum hikRoBotStatus);

                return new TaskGroupResultDto()
                {
                    code = hikRoBotStatus,
                    msg = resp.message,
                };
            }
            catch (Exception ex)
            {
                return new TaskGroupResultDto()
                {
                    code = HikRoBotStatusEnum.SDK调用异常,
                    msg = ex.Message,
                };
            }
        }

        public TaskPriorityResultDto SetTaskPriority(Domain.Dto.TaskPriority.TaskPriorityDto taskPriority)
        {
            try
            {
                if (taskPriority == null)
                {
                    throw new ArgumentException("输入参数为空。");
                }

                var sdkDto = new Sln.Wcs.HikRoBotSdk.Dto.TaskPriority.TaskPriorityDto()
                {
                    robotTaskCode = taskPriority.RobotTaskCode,
                    initPriority = taskPriority.InitPriority ?? 0,
                    deadline = taskPriority.Deadline,
                    extra = taskPriority.Extra,
                };

                var resp = this.hikRoBotSdk.SetTaskPriority(sdkDto);

                bool parseRes = this.codeUtil.parse(resp.code, resp.message, out HikRoBotStatusEnum hikRoBotStatus);

                return new TaskPriorityResultDto()
                {
                    code = hikRoBotStatus,
                    msg = resp.message,
                    data = new Domain.Model.TaskPriority.TaskPriorityResultModel
                    {
                        RobotTaskCode = resp.data?.robotTaskCode,
                        Extra = resp.data?.extra?.ToString(),
                    },
                };
            }
            catch (Exception ex)
            {
                return new TaskPriorityResultDto()
                {
                    code = HikRoBotStatusEnum.SDK调用异常,
                    msg = ex.Message,
                };
            }
        }

        public ZonePauseResultDto ZonePause(Domain.Dto.ZonePause.ZonePauseDto zonePause)
        {
            try
            {
                if (zonePause == null)
                {
                    throw new ArgumentException("输入参数为空。");
                }

                var sdkDto = new Sln.Wcs.HikRoBotSdk.Dto.ZonePause.ZonePauseDto()
                {
                    zoneCode = zonePause.ZoneCode,
                    mapCode = zonePause.MapCode,
                    invoke = zonePause.Invoke,
                };

                var resp = this.hikRoBotSdk.ZonePause(sdkDto);

                bool parseRes = this.codeUtil.parse(resp.code, resp.message, out HikRoBotStatusEnum hikRoBotStatus);

                return new ZonePauseResultDto()
                {
                    code = hikRoBotStatus,
                    msg = resp.message,
                    data = new Domain.Model.ZonePause.ZonePauseResultModel
                    {
                        Extra = resp.extra?.ToString(),
                    },
                };
            }
            catch (Exception ex)
            {
                return new ZonePauseResultDto()
                {
                    code = HikRoBotStatusEnum.SDK调用异常,
                    msg = ex.Message,
                };
            }
        }

        public ZoneHomingResultDto ZoneHoming(Domain.Dto.ZoneHoming.ZoneHomingDto zoneHoming)
        {
            try
            {
                if (zoneHoming == null)
                {
                    throw new ArgumentException("输入参数为空。");
                }

                var sdkDto = new Sln.Wcs.HikRoBotSdk.Dto.ZoneHoming.ZoneHomingDto()
                {
                    mapCode = zoneHoming.MapCode,
                    zoneCode = zoneHoming.ZoneCode,
                    zoneCodes = zoneHoming.ZoneCodes,
                    autoShutdown = zoneHoming.AutoShutdown.ToString().ToLower(),
                    bootTime = zoneHoming.BootTime,
                    expireTime = zoneHoming.ExpireTime,
                    extra = zoneHoming.Extra,
                };

                var resp = this.hikRoBotSdk.ZoneHoming(sdkDto);

                bool parseRes = this.codeUtil.parse(resp.code, resp.message, out HikRoBotStatusEnum hikRoBotStatus);

                return new ZoneHomingResultDto()
                {
                    code = hikRoBotStatus,
                    msg = resp.message,
                    data = new Domain.Model.ZoneHoming.ZoneHomingResultModel
                    {
                        HomingCode = resp.data?.homingCode,
                        RobotCount = resp.data?.robotCount ?? 0,
                        Extra = resp.data?.extra?.ToString(),
                    },
                };
            }
            catch (Exception ex)
            {
                return new ZoneHomingResultDto()
                {
                    code = HikRoBotStatusEnum.SDK调用异常,
                    msg = ex.Message,
                };
            }
        }

        public ZoneBanishResultDto ZoneBanish(Domain.Dto.ZoneBanish.ZoneBanishDto zoneBanish)
        {
            try
            {
                if (zoneBanish == null)
                {
                    throw new ArgumentException("输入参数为空。");
                }

                var sdkDto = new Sln.Wcs.HikRoBotSdk.Dto.ZoneBanish.ZoneBanishDto()
                {
                    zoneCode = zoneBanish.ZoneCode,
                    zoneCodes = zoneBanish.ZoneCodes,
                    targetZoneCode = zoneBanish.TargetZoneCode,
                    pause = zoneBanish.Pause.ToString().ToLower(),
                    report = zoneBanish.Report.ToString().ToLower(),
                    controlMode = zoneBanish.ControlMode,
                    expireTime = zoneBanish.ExpireTime,
                    invoke = zoneBanish.Invoke,
                    extra = zoneBanish.Extra,
                };

                var resp = this.hikRoBotSdk.ZoneBanish(sdkDto);

                bool parseRes = this.codeUtil.parse(resp.code, resp.message, out HikRoBotStatusEnum hikRoBotStatus);

                return new ZoneBanishResultDto()
                {
                    code = hikRoBotStatus,
                    msg = resp.message,
                    data = new Domain.Model.ZoneBanish.ZoneBanishResultModel
                    {
                        BanishCode = resp.data?.banishCode,
                        Extra = resp.data?.extra?.ToString(),
                    },
                };
            }
            catch (Exception ex)
            {
                return new ZoneBanishResultDto()
                {
                    code = HikRoBotStatusEnum.SDK调用异常,
                    msg = ex.Message,
                };
            }
        }

        public ZoneBlockadeResultDto ZoneBlockade(Domain.Dto.ZoneBlockade.ZoneBlockadeDto zoneBlockade)
        {
            try
            {
                if (zoneBlockade == null)
                {
                    throw new ArgumentException("输入参数为空。");
                }

                var sdkDto = new Sln.Wcs.HikRoBotSdk.Dto.ZoneBlockade.ZoneBlockadeDto()
                {
                    zoneCode = zoneBlockade.ZoneCode,
                    mapCode = zoneBlockade.MapCode,
                    invoke = zoneBlockade.Invoke,
                    pause = zoneBlockade.Pause.ToString().ToLower(),
                    report = zoneBlockade.Report.ToString().ToLower(),
                    disableSite = zoneBlockade.DisableSite,
                    enableSite = zoneBlockade.EnableSite,
                };

                var resp = this.hikRoBotSdk.ZoneBlockade(sdkDto);

                bool parseRes = this.codeUtil.parse(resp.code, resp.message, out HikRoBotStatusEnum hikRoBotStatus);

                return new ZoneBlockadeResultDto()
                {
                    code = hikRoBotStatus,
                    msg = resp.message,
                    data = new Domain.Model.ZoneBlockade.ZoneBlockadeResultModel
                    {
                        Extra = resp.extra?.ToString(),
                    },
                };
            }
            catch (Exception ex)
            {
                return new ZoneBlockadeResultDto()
                {
                    code = HikRoBotStatusEnum.SDK调用异常,
                    msg = ex.Message,
                };
            }
        }

        public CarrierBindResultDto CarrierBind(Domain.Dto.CarrierBind.CarrierBindDto carrierBind)
        {
            try
            {
                if (carrierBind == null)
                {
                    throw new ArgumentException("输入参数为空。");
                }

                var sdkDto = new Sln.Wcs.HikRoBotSdk.Dto.CarrierBind.CarrierBindDto()
                {
                    carrierCode = carrierBind.CarrierCode,
                    siteCode = carrierBind.SiteCode,
                    carrierDir = carrierBind.CarrierDir,
                    extra = carrierBind.Extra,
                };

                var resp = this.hikRoBotSdk.CarrierBind(sdkDto);

                bool parseRes = this.codeUtil.parse(resp.code, resp.message, out HikRoBotStatusEnum hikRoBotStatus);

                return new CarrierBindResultDto()
                {
                    code = hikRoBotStatus,
                    msg = resp.message,
                    data = new Domain.Model.CarrierBind.CarrierBindResultModel
                    {
                        Extra = resp.extra?.ToString(),
                    },
                };
            }
            catch (Exception ex)
            {
                return new CarrierBindResultDto()
                {
                    code = HikRoBotStatusEnum.SDK调用异常,
                    msg = ex.Message,
                };
            }
        }

        public CarrierUnbindResultDto CarrierUnbind(Domain.Dto.CarrierUnbind.CarrierUnbindDto carrierUnbind)
        {
            try
            {
                if (carrierUnbind == null)
                {
                    throw new ArgumentException("输入参数为空。");
                }

                var sdkDto = new Sln.Wcs.HikRoBotSdk.Dto.CarrierUnbind.CarrierUnbindDto()
                {
                    carrierCode = carrierUnbind.CarrierCode,
                    siteCode = carrierUnbind.SiteCode,
                    extra = carrierUnbind.Extra,
                };

                var resp = this.hikRoBotSdk.CarrierUnbind(sdkDto);

                bool parseRes = this.codeUtil.parse(resp.code, resp.message, out HikRoBotStatusEnum hikRoBotStatus);

                return new CarrierUnbindResultDto()
                {
                    code = hikRoBotStatus,
                    msg = resp.message,
                    data = new Domain.Model.CarrierUnbind.CarrierUnbindResultModel
                    {
                        Extra = resp.extra?.ToString(),
                    },
                };
            }
            catch (Exception ex)
            {
                return new CarrierUnbindResultDto()
                {
                    code = HikRoBotStatusEnum.SDK调用异常,
                    msg = ex.Message,
                };
            }
        }

        public SiteBindResultDto SiteBind(Domain.Dto.SiteBind.SiteBindDto siteBind)
        {
            try
            {
                if (siteBind == null)
                {
                    throw new ArgumentException("输入参数为空。");
                }

                var sdkDto = new Sln.Wcs.HikRoBotSdk.Dto.SiteBind.SiteBindDto()
                {
                    slotCategory = siteBind.SlotCategory,
                    slotCode = siteBind.SlotCode,
                    carrierCategory = siteBind.CarrierCategory,
                    carrierType = siteBind.CarrierType,
                    carrierCode = siteBind.CarrierCode,
                    carrierDir = siteBind.CarrierDir,
                    invoke = siteBind.Invoke,
                    stackLabel = siteBind.StackLabel,
                    colCount = siteBind.ColCount,
                    extra = siteBind.Extra,
                };

                var resp = this.hikRoBotSdk.SiteBind(sdkDto);

                bool parseRes = this.codeUtil.parse(resp.code, resp.message, out HikRoBotStatusEnum hikRoBotStatus);

                return new SiteBindResultDto()
                {
                    code = hikRoBotStatus,
                    msg = resp.message,
                    data = new Domain.Model.SiteBind.SiteBindResultModel
                    {
                        Extra = resp.extra?.ToString(),
                    },
                };
            }
            catch (Exception ex)
            {
                return new SiteBindResultDto()
                {
                    code = HikRoBotStatusEnum.SDK调用异常,
                    msg = ex.Message,
                };
            }
        }

        public CarrierLockResultDto CarrierLock(Domain.Dto.CarrierLock.CarrierLockDto carrierLock)
        {
            try
            {
                if (carrierLock == null)
                {
                    throw new ArgumentException("输入参数为空。");
                }

                var sdkDto = new Sln.Wcs.HikRoBotSdk.Dto.CarrierLock.CarrierLockDto()
                {
                    carrierCode = carrierLock.CarrierCode,
                    invoke = carrierLock.Invoke,
                };

                var resp = this.hikRoBotSdk.CarrierLock(sdkDto);

                bool parseRes = this.codeUtil.parse(resp.code, resp.message, out HikRoBotStatusEnum hikRoBotStatus);

                return new CarrierLockResultDto()
                {
                    code = hikRoBotStatus,
                    msg = resp.message,
                };
            }
            catch (Exception ex)
            {
                return new CarrierLockResultDto()
                {
                    code = HikRoBotStatusEnum.SDK调用异常,
                    msg = ex.Message,
                };
            }
        }

        public SiteLockResultDto SiteLock(Domain.Dto.SiteLock.SiteLockDto siteLock)
        {
            try
            {
                if (siteLock == null)
                {
                    throw new ArgumentException("输入参数为空。");
                }

                var sdkDto = new Sln.Wcs.HikRoBotSdk.Dto.SiteLock.SiteLockDto()
                {
                    siteCode = siteLock.SiteCode,
                    invoke = siteLock.Invoke,
                };

                var resp = this.hikRoBotSdk.SiteLock(sdkDto);

                bool parseRes = this.codeUtil.parse(resp.code, resp.message, out HikRoBotStatusEnum hikRoBotStatus);

                return new SiteLockResultDto()
                {
                    code = hikRoBotStatus,
                    msg = resp.message,
                };
            }
            catch (Exception ex)
            {
                return new SiteLockResultDto()
                {
                    code = HikRoBotStatusEnum.SDK调用异常,
                    msg = ex.Message,
                };
            }
        }

        public PreTaskResultDto PreTask(Domain.Dto.PreTask.PreTaskDto preTask)
        {
            try
            {
                if (preTask == null)
                {
                    throw new ArgumentException("输入参数为空。");
                }

                var sdkDto = new Sln.Wcs.HikRoBotSdk.Dto.PreTask.PreTaskDto()
                {
                    siteCode = preTask.SiteCode,
                    nextTaskTime = preTask.NextTaskTime,
                    robotType = preTask.RobotType,
                    priority = preTask.Priority,
                    taskCount = preTask.TaskCount,
                    capacityCount = preTask.CapacityCount,
                    amrDir = preTask.AmrDir,
                    extra = preTask.Extra,
                };

                var resp = this.hikRoBotSdk.PreTask(sdkDto);

                bool parseRes = this.codeUtil.parse(resp.code, resp.message, out HikRoBotStatusEnum hikRoBotStatus);

                return new PreTaskResultDto()
                {
                    code = hikRoBotStatus,
                    msg = resp.message,
                    data = new Domain.Model.PreTask.PreTaskResultModel
                    {
                        RobotTaskCode = resp.data?.robotTaskCode,
                        Extra = resp.data?.extra?.ToString(),
                    },
                };
            }
            catch (Exception ex)
            {
                return new PreTaskResultDto()
                {
                    code = HikRoBotStatusEnum.SDK调用异常,
                    msg = ex.Message,
                };
            }
        }

        public QueryTaskResultDto QueryTaskStatus(Domain.Dto.QueryTask.QueryTaskDto queryTask)
        {
            try
            {
                if (queryTask == null)
                {
                    throw new ArgumentException("输入参数为空。");
                }

                var sdkDto = new Sln.Wcs.HikRoBotSdk.Dto.QueryTask.QueryTaskDto()
                {
                    robotTaskCode = queryTask.RobotTaskCode,
                };

                var resp = this.hikRoBotSdk.QueryTaskStatus(sdkDto);

                bool parseRes = this.codeUtil.parse(resp.code, resp.message, out HikRoBotStatusEnum hikRoBotStatus);

                var model = new Domain.Model.QueryTask.QueryTaskResultModel
                {
                    RobotTaskCode = resp.data?.robotTaskCode,
                    TaskType = resp.data?.taskType,
                    TaskStatus = resp.data?.taskStatus,
                    InitPriority = resp.data?.initPriority,
                    Deadline = resp.data?.deadline,
                    SingleRobotCode = resp.data?.singleRobotCode,
                    CurrentSeq = resp.data?.currentSeq,
                    Extra = resp.data?.extra?.ToString(),
                };

                if (resp.data?.targetRoute != null)
                {
                    model.TargetRoute = resp.data.targetRoute.Select(r => new Domain.Model.QueryTask.TargetRoute
                    {
                        Type = r.type,
                        Code = r.code,
                    }).ToList();
                }

                if (resp.data?.waring != null)
                {
                    model.Waring = new Domain.Model.QueryTask.Waring
                    {
                        Code = resp.data.waring.taskWarnCode,
                        Desc = resp.data.waring.errorMsg,
                    };
                }

                return new QueryTaskResultDto()
                {
                    code = hikRoBotStatus,
                    msg = resp.message,
                    data = model,
                };
            }
            catch (Exception ex)
            {
                return new QueryTaskResultDto()
                {
                    code = HikRoBotStatusEnum.SDK调用异常,
                    msg = ex.Message,
                };
            }
        }

        public QueryRobotResultDto QueryRobotStatus(Domain.Dto.QueryRobot.QueryRobotDto queryRobot)
        {
            try
            {
                if (queryRobot == null)
                {
                    throw new ArgumentException("输入参数为空。");
                }

                var sdkDto = new Sln.Wcs.HikRoBotSdk.Dto.QueryRobot.QueryRobotDto()
                {
                    singleRobotCode = queryRobot.SingleRobotCode,
                };

                var resp = this.hikRoBotSdk.QueryRobotStatus(sdkDto);

                bool parseRes = this.codeUtil.parse(resp.code, resp.message, out HikRoBotStatusEnum hikRoBotStatus);

                var model = new Domain.Model.QueryRobot.QueryRobotResultModel
                {
                    SingleRobotCode = resp.data?.singleRobotCode,
                    RobotDir = resp.data?.robotDir ?? 0,
                    RobotIp = resp.data?.robotIp,
                    Battery = resp.data?.battery ?? 0,
                    Speed = resp.data?.speed ?? 0,
                    CarrierCode = resp.data?.carrierCode,
                    Extra = resp.data?.extra?.ToString(),
                };

                if (double.TryParse(resp.data?.x, out double xVal))
                {
                    model.X = xVal;
                }

                if (double.TryParse(resp.data?.y, out double yVal))
                {
                    model.Y = yVal;
                }

                if (resp.data?.robotStatus != null)
                {
                    model.RobotStatus = resp.data.robotStatus.taskable;
                }

                if (resp.data?.warnings != null)
                {
                    model.Warnings = resp.data.warnings.Select(w => new Domain.Model.QueryRobot.Waring
                    {
                        Code = w.taskWarnCode,
                        Desc = w.errorMsg,
                    }).ToList();
                }

                return new QueryRobotResultDto()
                {
                    code = hikRoBotStatus,
                    msg = resp.message,
                    data = model,
                };
            }
            catch (Exception ex)
            {
                return new QueryRobotResultDto()
                {
                    code = HikRoBotStatusEnum.SDK调用异常,
                    msg = ex.Message,
                };
            }
        }

        public QueryCarrierResultDto QueryCarrierStatus(Domain.Dto.QueryCarrier.QueryCarrierDto queryCarrier)
        {
            try
            {
                if (queryCarrier == null)
                {
                    throw new ArgumentException("输入参数为空。");
                }

                var sdkDto = new Sln.Wcs.HikRoBotSdk.Dto.QueryCarrier.QueryCarrierDto()
                {
                    carrierCode = queryCarrier.CarrierCode,
                };

                var resp = this.hikRoBotSdk.QueryCarrierStatus(sdkDto);

                bool parseRes = this.codeUtil.parse(resp.code, resp.message, out HikRoBotStatusEnum hikRoBotStatus);

                var model = new Domain.Model.QueryCarrier.QueryCarrierResultModel
                {
                    CarrierCode = resp.data?.carrierCode,
                    RobotTaskCode = resp.data?.robotTaskCode,
                    SiteCode = resp.data?.siteCode,
                    CarrierDir = resp.data?.carrierDir,
                    CarrierStatus = resp.data?.carrierStatus,
                    BinCode = resp.data?.binCode,
                    BinName = resp.data?.binName,
                    RobotCode = resp.data?.robotCode,
                    Extra = resp.data?.extra?.ToString(),
                };

                if (double.TryParse(resp.data?.x, out double xVal))
                {
                    model.X = xVal;
                }

                if (double.TryParse(resp.data?.y, out double yVal))
                {
                    model.Y = yVal;
                }

                return new QueryCarrierResultDto()
                {
                    code = hikRoBotStatus,
                    msg = resp.message,
                    data = model,
                };
            }
            catch (Exception ex)
            {
                return new QueryCarrierResultDto()
                {
                    code = HikRoBotStatusEnum.SDK调用异常,
                    msg = ex.Message,
                };
            }
        }

        public MatLabelBindResultDto MatLabelBind(Domain.Dto.MatLabelBind.MatLabelBindDto matLabelBind)
        {
            try
            {
                if (matLabelBind == null)
                {
                    throw new ArgumentException("输入参数为空。");
                }

                var sdkDto = new Sln.Wcs.HikRoBotSdk.Dto.MatLabelBind.MatLabelBindDto()
                {
                    carrierCode = matLabelBind.CarrierCode,
                    matLabel = matLabelBind.MatLabel,
                };

                var resp = this.hikRoBotSdk.MatLabelBind(sdkDto);

                bool parseRes = this.codeUtil.parse(resp.code, resp.message, out HikRoBotStatusEnum hikRoBotStatus);

                return new MatLabelBindResultDto()
                {
                    code = hikRoBotStatus,
                    msg = resp.message,
                    data = new Domain.Model.MatLabelBind.MatLabelBindResultModel
                    {
                        Extra = resp.extra?.ToString(),
                    },
                };
            }
            catch (Exception ex)
            {
                return new MatLabelBindResultDto()
                {
                    code = HikRoBotStatusEnum.SDK调用异常,
                    msg = ex.Message,
                };
            }
        }

        public MatLabelUnbindResultDto MatLabelUnbind(Domain.Dto.MatLabelUnbind.MatLabelUnbindDto matLabelUnbind)
        {
            try
            {
                if (matLabelUnbind == null)
                {
                    throw new ArgumentException("输入参数为空。");
                }

                var sdkDto = new Sln.Wcs.HikRoBotSdk.Dto.MatLabelUnbind.MatLabelUnbindDto()
                {
                    carrierCode = matLabelUnbind.CarrierCode,
                    matLabel = matLabelUnbind.MatLabel,
                };

                var resp = this.hikRoBotSdk.MatLabelUnbind(sdkDto);

                bool parseRes = this.codeUtil.parse(resp.code, resp.message, out HikRoBotStatusEnum hikRoBotStatus);

                return new MatLabelUnbindResultDto()
                {
                    code = hikRoBotStatus,
                    msg = resp.message,
                };
            }
            catch (Exception ex)
            {
                return new MatLabelUnbindResultDto()
                {
                    code = HikRoBotStatusEnum.SDK调用异常,
                    msg = ex.Message,
                };
            }
        }

        public EquipmentNotifyResultDto EquipmentNotify(Domain.Dto.EquipmentNotify.EquipmentNotifyDto equipmentNotify)
        {
            try
            {
                if (equipmentNotify == null)
                {
                    throw new ArgumentException("输入参数为空。");
                }

                var sdkDto = new Sln.Wcs.HikRoBotSdk.Dto.EquipmentNotify.EquipmentNotifyDto()
                {
                    eqptCode = equipmentNotify.EqptCode,
                    taskCode = equipmentNotify.TaskCode,
                    actionStatus = equipmentNotify.ActionStatus,
                    siteCode = equipmentNotify.SiteCode,
                    extra = equipmentNotify.Extra,
                };

                var resp = this.hikRoBotSdk.EquipmentNotify(sdkDto);

                bool parseRes = this.codeUtil.parse(resp.code, resp.message, out HikRoBotStatusEnum hikRoBotStatus);

                return new EquipmentNotifyResultDto()
                {
                    code = hikRoBotStatus,
                    msg = resp.message,
                    data = new Domain.Model.EquipmentNotify.EquipmentNotifyResultModel
                    {
                        RobotTaskCode = resp.data?.robotTaskCode,
                        NextSeq = resp.data?.nextSeq,
                        Extra = resp.data?.extra?.ToString(),
                    },
                };
            }
            catch (Exception ex)
            {
                return new EquipmentNotifyResultDto()
                {
                    code = HikRoBotStatusEnum.SDK调用异常,
                    msg = ex.Message,
                };
            }
        }

        public EquipmentNotifyResultDto EquipmentNotifyGbt(Domain.Dto.EquipmentNotify.EquipmentNotifyDto equipmentNotify)
        {
            try
            {
                if (equipmentNotify == null)
                {
                    throw new ArgumentException("输入参数为空。");
                }

                var sdkDto = new Sln.Wcs.HikRoBotSdk.Dto.EquipmentNotify.EquipmentNotifyDto()
                {
                    eqptCode = equipmentNotify.EqptCode,
                    taskCode = equipmentNotify.TaskCode,
                    actionStatus = equipmentNotify.ActionStatus,
                    siteCode = equipmentNotify.SiteCode,
                    extra = equipmentNotify.Extra,
                };

                var resp = this.hikRoBotSdk.EquipmentNotifyGbt(sdkDto);

                bool parseRes = this.codeUtil.parse(resp.code, resp.message, out HikRoBotStatusEnum hikRoBotStatus);

                return new EquipmentNotifyResultDto()
                {
                    code = hikRoBotStatus,
                    msg = resp.message,
                    data = new Domain.Model.EquipmentNotify.EquipmentNotifyResultModel
                    {
                        RobotTaskCode = resp.data?.robotTaskCode,
                        NextSeq = resp.data?.nextSeq,
                        Extra = resp.data?.extra?.ToString(),
                    },
                };
            }
            catch (Exception ex)
            {
                return new EquipmentNotifyResultDto()
                {
                    code = HikRoBotStatusEnum.SDK调用异常,
                    msg = ex.Message,
                };
            }
        }
    }
}