|
|
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.Domain.Model.CarrierLock;
|
|
|
using Sln.Wcs.HikRoBotApi.Domain.Model.MatLabelUnbind;
|
|
|
using Sln.Wcs.HikRoBotApi.Domain.Model.SiteLock;
|
|
|
using Sln.Wcs.HikRoBotApi.Domain.Model.TaskGroup;
|
|
|
using Sln.Wcs.HikRoBotApi.Enum;
|
|
|
using Sln.Wcs.HikRoBotApi.Util;
|
|
|
using Sln.Wcs.HikRoBotSdk;
|
|
|
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;
|
|
|
|
|
|
#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;
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 通用执行方法：封装空值检查、SDK 调用、结果码解析、异常处理
|
|
|
/// </summary>
|
|
|
private TResult Execute<TResult>(
|
|
|
Func<object> sdkCall,
|
|
|
Func<dynamic, HikRoBotStatusEnum, TResult> mapSuccess,
|
|
|
Func<string, TResult> mapError)
|
|
|
{
|
|
|
try
|
|
|
{
|
|
|
dynamic resp = sdkCall();
|
|
|
codeUtil.parse((string)resp.code, (string)resp.message, out var status);
|
|
|
return mapSuccess(resp, status);
|
|
|
}
|
|
|
catch (Exception ex)
|
|
|
{
|
|
|
return mapError(ex.Message);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
private static TResult Error<TResult>(string msg) where TResult : new()
|
|
|
{
|
|
|
dynamic result = new TResult();
|
|
|
result.code = HikRoBotStatusEnum.SDK调用异常;
|
|
|
result.msg = msg;
|
|
|
result.errorCode = msg;
|
|
|
result.success = false;
|
|
|
return result;
|
|
|
}
|
|
|
|
|
|
public GbContinueTaskResultDto GbContinueTask(GbContinueTaskDto req)
|
|
|
{
|
|
|
return Execute(
|
|
|
() =>
|
|
|
{
|
|
|
if (req == null) throw new ArgumentException("输入参数为空。");
|
|
|
return hikRoBotSdk.GbContinueTask(new HikRoBotSdk.Dto.GbContinueTask.GbContinueTaskDto
|
|
|
{
|
|
|
triggerType = req.TriggerType,
|
|
|
triggerCode = req.TriggerCode,
|
|
|
targetRoute = req.TargetRoute != null ? new HikRoBotSdk.Dto.Common.TargetRoute
|
|
|
{
|
|
|
type = req.TargetRoute.Type,
|
|
|
code = req.TargetRoute.Code,
|
|
|
operation = req.TargetRoute.Operation,
|
|
|
} : null,
|
|
|
extra = req.Extra,
|
|
|
});
|
|
|
},
|
|
|
(resp, status) => new GbContinueTaskResultDto
|
|
|
{
|
|
|
code = status,
|
|
|
msg = resp.message,
|
|
|
data = new Domain.Model.GbContinueTask.GbContinueTaskResultModel
|
|
|
{
|
|
|
RobotTaskCode = resp.data?.robotTaskCode,
|
|
|
NextSeq = resp.data?.nextSeq,
|
|
|
Extra = resp.data?.extra,
|
|
|
errorCode = resp.errorCode,
|
|
|
success = resp.success,
|
|
|
},
|
|
|
},
|
|
|
Error<GbContinueTaskResultDto>
|
|
|
);
|
|
|
}
|
|
|
|
|
|
public GbCancelTaskResultDto GbCancelTask(GbCancelTaskDto req)
|
|
|
{
|
|
|
return Execute(
|
|
|
() =>
|
|
|
{
|
|
|
if (req == null) throw new ArgumentException("输入参数为空。");
|
|
|
return hikRoBotSdk.GbCancelTask(new HikRoBotSdk.Dto.GbCancelTask.GbCancelTaskDto
|
|
|
{
|
|
|
robotTaskCode = req.RobotTaskCode,
|
|
|
cancelType = req.CancelType,
|
|
|
carrierCode = req.CarrierCode,
|
|
|
robotCode = req.RobotCode,
|
|
|
reason = req.Reason,
|
|
|
returnTaskType = req.ReturnTaskType,
|
|
|
targetRoute = req.TargetRoute != null ? new HikRoBotSdk.Dto.Common.TargetRoute
|
|
|
{
|
|
|
type = req.TargetRoute.Type,
|
|
|
code = req.TargetRoute.Code,
|
|
|
} : null,
|
|
|
extra = req.Extra,
|
|
|
});
|
|
|
},
|
|
|
(resp, status) => new GbCancelTaskResultDto
|
|
|
{
|
|
|
code = status,
|
|
|
msg = resp.message,
|
|
|
data = new Domain.Model.GbCancelTask.GbCancelTaskResultModel
|
|
|
{
|
|
|
RobotTaskCode = resp.data?.robotTaskCode,
|
|
|
Extra = resp.data?.extra,
|
|
|
errorCode = resp.errorCode,
|
|
|
success = resp.success,
|
|
|
},
|
|
|
},
|
|
|
Error<GbCancelTaskResultDto>
|
|
|
);
|
|
|
}
|
|
|
|
|
|
public GbTaskSubmitResultDto GbTaskSubmit(GbTaskSubmitDto req)
|
|
|
{
|
|
|
return Execute(
|
|
|
() =>
|
|
|
{
|
|
|
if (req == null) throw new ArgumentException("输入参数为空。");
|
|
|
return hikRoBotSdk.GbTaskSubmit(new HikRoBotSdk.Dto.GbTaskSubmit.GbTaskSubmitDto
|
|
|
{
|
|
|
taskType = req.TaskType,
|
|
|
initPriority = req.InitPriority,
|
|
|
deadline = req.Deadline,
|
|
|
expectedStartTime = req.ExpectedStartTime,
|
|
|
robotType = req.RobotType,
|
|
|
robotCode = req.RobotCode,
|
|
|
interrupt = req.Interrupt,
|
|
|
robotTaskCode = req.RobotTaskCode,
|
|
|
groupCode = req.GroupCode,
|
|
|
extra = req.Extra != null ? new HikRoBotSdk.Dto.Common.ExtraInfo() : null,
|
|
|
targetRoute = req.TargetRoute != null ? req.TargetRoute.ConvertAll(r => new HikRoBotSdk.Dto.Common.TargetRoute
|
|
|
{
|
|
|
type = r.Type,
|
|
|
code = r.Code,
|
|
|
operation = r.Operation,
|
|
|
robotType = r.RobotType,
|
|
|
robotCode = r.RobotCode,
|
|
|
}) : null,
|
|
|
});
|
|
|
},
|
|
|
(resp, status) => new GbTaskSubmitResultDto
|
|
|
{
|
|
|
code = status,
|
|
|
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(),
|
|
|
},
|
|
|
errorCode = resp.errorCode,
|
|
|
success = resp.success,
|
|
|
},
|
|
|
},
|
|
|
Error<GbTaskSubmitResultDto>
|
|
|
);
|
|
|
}
|
|
|
|
|
|
public TaskGroupResultDto TaskGroup(Domain.Dto.TaskGroup.TaskGroupDto req)
|
|
|
{
|
|
|
return Execute(
|
|
|
() =>
|
|
|
{
|
|
|
if (req == null) throw new ArgumentException("输入参数为空。");
|
|
|
return hikRoBotSdk.TaskGroup(new HikRoBotSdk.Dto.TaskGroup.TaskGroupDto
|
|
|
{
|
|
|
groupCode = req.GroupCode,
|
|
|
strategy = req.Strategy,
|
|
|
strategyValue = req.StrategyValue,
|
|
|
groupSeq = !string.IsNullOrEmpty(req.GroupSeq) ? int.Parse(req.GroupSeq) : (int?)null,
|
|
|
targetRoute = req.TargetRoute != null ? new HikRoBotSdk.Dto.Common.TargetRoute
|
|
|
{
|
|
|
type = req.TargetRoute.Type,
|
|
|
code = req.TargetRoute.Code,
|
|
|
} : null,
|
|
|
});
|
|
|
},
|
|
|
(resp, status) => new TaskGroupResultDto { code = status, msg = resp.message,data = new TaskGroupResultModel()
|
|
|
{
|
|
|
success = resp.success,
|
|
|
errorCode = resp.errorCode,
|
|
|
}},
|
|
|
Error<TaskGroupResultDto>
|
|
|
);
|
|
|
}
|
|
|
|
|
|
public TaskPriorityResultDto SetTaskPriority(Domain.Dto.TaskPriority.TaskPriorityDto req)
|
|
|
{
|
|
|
return Execute(
|
|
|
() =>
|
|
|
{
|
|
|
if (req == null) throw new ArgumentException("输入参数为空。");
|
|
|
return hikRoBotSdk.SetTaskPriority(new HikRoBotSdk.Dto.TaskPriority.TaskPriorityDto
|
|
|
{
|
|
|
robotTaskCode = req.RobotTaskCode,
|
|
|
initPriority = req.InitPriority ?? 0,
|
|
|
deadline = req.Deadline,
|
|
|
extra = req.Extra,
|
|
|
});
|
|
|
},
|
|
|
(resp, status) => new TaskPriorityResultDto
|
|
|
{
|
|
|
code = status,
|
|
|
msg = resp.message,
|
|
|
data = new Domain.Model.TaskPriority.TaskPriorityResultModel
|
|
|
{
|
|
|
RobotTaskCode = resp.data?.robotTaskCode,
|
|
|
Extra = resp.data?.extra?.ToString(),
|
|
|
errorCode = resp.errorCode,
|
|
|
success = resp.success,
|
|
|
},
|
|
|
},
|
|
|
Error<TaskPriorityResultDto>
|
|
|
);
|
|
|
}
|
|
|
|
|
|
public ZonePauseResultDto ZonePause(Domain.Dto.ZonePause.ZonePauseDto req)
|
|
|
{
|
|
|
return Execute(
|
|
|
() =>
|
|
|
{
|
|
|
if (req == null) throw new ArgumentException("输入参数为空。");
|
|
|
return hikRoBotSdk.ZonePause(new HikRoBotSdk.Dto.ZonePause.ZonePauseDto
|
|
|
{
|
|
|
zoneCode = req.ZoneCode,
|
|
|
mapCode = req.MapCode,
|
|
|
invoke = req.Invoke,
|
|
|
});
|
|
|
},
|
|
|
(resp, status) => new ZonePauseResultDto
|
|
|
{
|
|
|
code = status,
|
|
|
msg = resp.message,
|
|
|
data = new Domain.Model.ZonePause.ZonePauseResultModel
|
|
|
{
|
|
|
Extra = resp.extra?.ToString(),
|
|
|
errorCode = resp.errorCode,
|
|
|
success = resp.success,
|
|
|
},
|
|
|
},
|
|
|
Error<ZonePauseResultDto>
|
|
|
);
|
|
|
}
|
|
|
|
|
|
public ZoneHomingResultDto ZoneHoming(Domain.Dto.ZoneHoming.ZoneHomingDto req)
|
|
|
{
|
|
|
return Execute(
|
|
|
() =>
|
|
|
{
|
|
|
if (req == null) throw new ArgumentException("输入参数为空。");
|
|
|
return hikRoBotSdk.ZoneHoming(new HikRoBotSdk.Dto.ZoneHoming.ZoneHomingDto
|
|
|
{
|
|
|
mapCode = req.MapCode,
|
|
|
zoneCode = req.ZoneCode,
|
|
|
zoneCodes = req.ZoneCodes,
|
|
|
autoShutdown = req.AutoShutdown.ToString().ToLower(),
|
|
|
bootTime = req.BootTime,
|
|
|
expireTime = req.ExpireTime,
|
|
|
extra = req.Extra,
|
|
|
});
|
|
|
},
|
|
|
(resp, status) => new ZoneHomingResultDto
|
|
|
{
|
|
|
code = status,
|
|
|
msg = resp.message,
|
|
|
data = new Domain.Model.ZoneHoming.ZoneHomingResultModel
|
|
|
{
|
|
|
HomingCode = resp.data?.homingCode,
|
|
|
RobotCount = resp.data?.robotCount ?? 0,
|
|
|
Extra = resp.data?.extra?.ToString(),
|
|
|
errorCode = resp.errorCode,
|
|
|
success = resp.success,
|
|
|
},
|
|
|
},
|
|
|
Error<ZoneHomingResultDto>
|
|
|
);
|
|
|
}
|
|
|
|
|
|
public ZoneBanishResultDto ZoneBanish(Domain.Dto.ZoneBanish.ZoneBanishDto req)
|
|
|
{
|
|
|
return Execute(
|
|
|
() =>
|
|
|
{
|
|
|
if (req == null) throw new ArgumentException("输入参数为空。");
|
|
|
return hikRoBotSdk.ZoneBanish(new HikRoBotSdk.Dto.ZoneBanish.ZoneBanishDto
|
|
|
{
|
|
|
zoneCode = req.ZoneCode,
|
|
|
zoneCodes = req.ZoneCodes,
|
|
|
targetZoneCode = req.TargetZoneCode,
|
|
|
pause = req.Pause.ToString().ToLower(),
|
|
|
report = req.Report.ToString().ToLower(),
|
|
|
controlMode = req.ControlMode,
|
|
|
expireTime = req.ExpireTime,
|
|
|
invoke = req.Invoke,
|
|
|
extra = req.Extra,
|
|
|
});
|
|
|
},
|
|
|
(resp, status) => new ZoneBanishResultDto
|
|
|
{
|
|
|
code = status,
|
|
|
msg = resp.message,
|
|
|
data = new Domain.Model.ZoneBanish.ZoneBanishResultModel
|
|
|
{
|
|
|
BanishCode = resp.data?.banishCode,
|
|
|
Extra = resp.data?.extra?.ToString(),
|
|
|
errorCode = resp.errorCode,
|
|
|
success = resp.success,
|
|
|
},
|
|
|
},
|
|
|
Error<ZoneBanishResultDto>
|
|
|
);
|
|
|
}
|
|
|
|
|
|
public ZoneBlockadeResultDto ZoneBlockade(Domain.Dto.ZoneBlockade.ZoneBlockadeDto req)
|
|
|
{
|
|
|
return Execute(
|
|
|
() =>
|
|
|
{
|
|
|
if (req == null) throw new ArgumentException("输入参数为空。");
|
|
|
return hikRoBotSdk.ZoneBlockade(new HikRoBotSdk.Dto.ZoneBlockade.ZoneBlockadeDto
|
|
|
{
|
|
|
zoneCode = req.ZoneCode,
|
|
|
mapCode = req.MapCode,
|
|
|
invoke = req.Invoke,
|
|
|
pause = req.Pause.ToString().ToLower(),
|
|
|
report = req.Report.ToString().ToLower(),
|
|
|
disableSite = req.DisableSite,
|
|
|
enableSite = req.EnableSite,
|
|
|
});
|
|
|
},
|
|
|
(resp, status) => new ZoneBlockadeResultDto
|
|
|
{
|
|
|
code = status,
|
|
|
msg = resp.message,
|
|
|
data = new Domain.Model.ZoneBlockade.ZoneBlockadeResultModel
|
|
|
{
|
|
|
Extra = resp.extra?.ToString(),
|
|
|
errorCode = resp.errorCode,
|
|
|
success = resp.success,
|
|
|
},
|
|
|
},
|
|
|
Error<ZoneBlockadeResultDto>
|
|
|
);
|
|
|
}
|
|
|
|
|
|
public CarrierBindResultDto CarrierBind(Domain.Dto.CarrierBind.CarrierBindDto req)
|
|
|
{
|
|
|
return Execute(
|
|
|
() =>
|
|
|
{
|
|
|
if (req == null) throw new ArgumentException("输入参数为空。");
|
|
|
return hikRoBotSdk.CarrierBind(new HikRoBotSdk.Dto.CarrierBind.CarrierBindDto
|
|
|
{
|
|
|
carrierCode = req.CarrierCode,
|
|
|
siteCode = req.SiteCode,
|
|
|
carrierDir = req.CarrierDir,
|
|
|
extra = req.Extra,
|
|
|
});
|
|
|
},
|
|
|
(resp, status) => new CarrierBindResultDto
|
|
|
{
|
|
|
code = status,
|
|
|
msg = resp.message,
|
|
|
data = new Domain.Model.CarrierBind.CarrierBindResultModel
|
|
|
{
|
|
|
Extra = resp.extra?.ToString(),
|
|
|
errorCode = resp.errorCode,
|
|
|
success = resp.success,
|
|
|
},
|
|
|
},
|
|
|
Error<CarrierBindResultDto>
|
|
|
);
|
|
|
}
|
|
|
|
|
|
public CarrierUnbindResultDto CarrierUnbind(Domain.Dto.CarrierUnbind.CarrierUnbindDto req)
|
|
|
{
|
|
|
return Execute(
|
|
|
() =>
|
|
|
{
|
|
|
if (req == null) throw new ArgumentException("输入参数为空。");
|
|
|
return hikRoBotSdk.CarrierUnbind(new HikRoBotSdk.Dto.CarrierUnbind.CarrierUnbindDto
|
|
|
{
|
|
|
carrierCode = req.CarrierCode,
|
|
|
siteCode = req.SiteCode,
|
|
|
extra = req.Extra,
|
|
|
});
|
|
|
},
|
|
|
(resp, status) => new CarrierUnbindResultDto
|
|
|
{
|
|
|
code = status,
|
|
|
msg = resp.message,
|
|
|
data = new Domain.Model.CarrierUnbind.CarrierUnbindResultModel
|
|
|
{
|
|
|
Extra = resp.extra?.ToString(),
|
|
|
errorCode = resp.errorCode,
|
|
|
success = resp.success,
|
|
|
},
|
|
|
},
|
|
|
Error<CarrierUnbindResultDto>
|
|
|
);
|
|
|
}
|
|
|
|
|
|
public SiteBindResultDto SiteBind(Domain.Dto.SiteBind.SiteBindDto req)
|
|
|
{
|
|
|
return Execute(
|
|
|
() =>
|
|
|
{
|
|
|
if (req == null) throw new ArgumentException("输入参数为空。");
|
|
|
return hikRoBotSdk.SiteBind(new HikRoBotSdk.Dto.SiteBind.SiteBindDto
|
|
|
{
|
|
|
slotCategory = req.SlotCategory,
|
|
|
slotCode = req.SlotCode,
|
|
|
carrierCategory = req.CarrierCategory,
|
|
|
carrierType = req.CarrierType,
|
|
|
carrierCode = req.CarrierCode,
|
|
|
carrierDir = req.CarrierDir,
|
|
|
invoke = req.Invoke,
|
|
|
stackLabel = req.StackLabel,
|
|
|
colCount = req.ColCount,
|
|
|
extra = req.Extra,
|
|
|
});
|
|
|
},
|
|
|
(resp, status) => new SiteBindResultDto
|
|
|
{
|
|
|
code = status,
|
|
|
msg = resp.message,
|
|
|
data = new Domain.Model.SiteBind.SiteBindResultModel
|
|
|
{
|
|
|
Extra = resp.extra?.ToString(),
|
|
|
errorCode = resp.errorCode,
|
|
|
success = resp.success,
|
|
|
},
|
|
|
},
|
|
|
Error<SiteBindResultDto>
|
|
|
);
|
|
|
}
|
|
|
|
|
|
public CarrierLockResultDto CarrierLock(Domain.Dto.CarrierLock.CarrierLockDto req)
|
|
|
{
|
|
|
return Execute(
|
|
|
() =>
|
|
|
{
|
|
|
if (req == null) throw new ArgumentException("输入参数为空。");
|
|
|
return hikRoBotSdk.CarrierLock(new HikRoBotSdk.Dto.CarrierLock.CarrierLockDto
|
|
|
{
|
|
|
carrierCode = req.CarrierCode,
|
|
|
invoke = req.Invoke,
|
|
|
});
|
|
|
},
|
|
|
(resp, status) => new CarrierLockResultDto { code = status, msg = resp.message, data = new CarrierLockResultModel()
|
|
|
{
|
|
|
success = resp.success,
|
|
|
errorCode = resp.errorCode,
|
|
|
}},
|
|
|
Error<CarrierLockResultDto>
|
|
|
);
|
|
|
}
|
|
|
|
|
|
public SiteLockResultDto SiteLock(Domain.Dto.SiteLock.SiteLockDto req)
|
|
|
{
|
|
|
return Execute(
|
|
|
() =>
|
|
|
{
|
|
|
if (req == null) throw new ArgumentException("输入参数为空。");
|
|
|
return hikRoBotSdk.SiteLock(new HikRoBotSdk.Dto.SiteLock.SiteLockDto
|
|
|
{
|
|
|
siteCode = req.SiteCode,
|
|
|
invoke = req.Invoke,
|
|
|
});
|
|
|
},
|
|
|
(resp, status) => new SiteLockResultDto { code = status, msg = resp.message,data = new SiteLockResultModel()
|
|
|
{
|
|
|
success = resp.success,
|
|
|
errorCode = resp.errorCode,
|
|
|
}},
|
|
|
Error<SiteLockResultDto>
|
|
|
);
|
|
|
}
|
|
|
|
|
|
public PreTaskResultDto PreTask(Domain.Dto.PreTask.PreTaskDto req)
|
|
|
{
|
|
|
return Execute(
|
|
|
() =>
|
|
|
{
|
|
|
if (req == null) throw new ArgumentException("输入参数为空。");
|
|
|
return hikRoBotSdk.PreTask(new HikRoBotSdk.Dto.PreTask.PreTaskDto
|
|
|
{
|
|
|
siteCode = req.SiteCode,
|
|
|
nextTaskTime = req.NextTaskTime,
|
|
|
robotType = req.RobotType,
|
|
|
priority = req.Priority,
|
|
|
taskCount = req.TaskCount,
|
|
|
capacityCount = req.CapacityCount,
|
|
|
amrDir = req.AmrDir,
|
|
|
extra = req.Extra,
|
|
|
});
|
|
|
},
|
|
|
(resp, status) => new PreTaskResultDto
|
|
|
{
|
|
|
code = status,
|
|
|
msg = resp.message,
|
|
|
data = new Domain.Model.PreTask.PreTaskResultModel
|
|
|
{
|
|
|
RobotTaskCode = resp.data?.robotTaskCode,
|
|
|
Extra = resp.data?.extra?.ToString(),
|
|
|
errorCode = resp.errorCode,
|
|
|
success = resp.success,
|
|
|
},
|
|
|
},
|
|
|
Error<PreTaskResultDto>
|
|
|
);
|
|
|
}
|
|
|
|
|
|
public QueryTaskResultDto QueryTaskStatus(Domain.Dto.QueryTask.QueryTaskDto req)
|
|
|
{
|
|
|
return Execute(
|
|
|
() =>
|
|
|
{
|
|
|
if (req == null) throw new ArgumentException("输入参数为空。");
|
|
|
return hikRoBotSdk.QueryTaskStatus(new HikRoBotSdk.Dto.QueryTask.QueryTaskDto
|
|
|
{
|
|
|
robotTaskCode = req.RobotTaskCode,
|
|
|
});
|
|
|
},
|
|
|
(resp, status) =>
|
|
|
{
|
|
|
var data = resp.data;
|
|
|
var model = new Domain.Model.QueryTask.QueryTaskResultModel
|
|
|
{
|
|
|
RobotTaskCode = data?.robotTaskCode,
|
|
|
TaskType = data?.taskType,
|
|
|
TaskStatus = data?.taskStatus,
|
|
|
InitPriority = data?.initPriority,
|
|
|
Deadline = data?.deadline,
|
|
|
SingleRobotCode = data?.singleRobotCode,
|
|
|
CurrentSeq = data?.currentSeq,
|
|
|
Extra = data?.extra?.ToString(),
|
|
|
success = resp.success,
|
|
|
errorCode = resp.errorCode,
|
|
|
};
|
|
|
|
|
|
if (data?.targetRoute != null)
|
|
|
{
|
|
|
model.TargetRoute = ((IEnumerable<dynamic>)data.targetRoute).Select(r => new Domain.Model.QueryTask.TargetRoute
|
|
|
{
|
|
|
Type = r.type,
|
|
|
Code = r.code,
|
|
|
}).ToList();
|
|
|
}
|
|
|
|
|
|
if (data?.waring != null)
|
|
|
{
|
|
|
model.Waring = new Domain.Model.QueryTask.Waring
|
|
|
{
|
|
|
Code = data.waring.taskWarnCode,
|
|
|
Desc = data.waring.errorMsg,
|
|
|
};
|
|
|
}
|
|
|
|
|
|
return new QueryTaskResultDto { code = status, msg = resp.message, data = model };
|
|
|
},
|
|
|
Error<QueryTaskResultDto>
|
|
|
);
|
|
|
}
|
|
|
|
|
|
public QueryRobotResultDto QueryRobotStatus(Domain.Dto.QueryRobot.QueryRobotDto req)
|
|
|
{
|
|
|
return Execute(
|
|
|
() =>
|
|
|
{
|
|
|
if (req == null) throw new ArgumentException("输入参数为空。");
|
|
|
return hikRoBotSdk.QueryRobotStatus(new HikRoBotSdk.Dto.QueryRobot.QueryRobotDto
|
|
|
{
|
|
|
singleRobotCode = req.SingleRobotCode,
|
|
|
});
|
|
|
},
|
|
|
(resp, status) =>
|
|
|
{
|
|
|
var data = resp.data;
|
|
|
var model = new Domain.Model.QueryRobot.QueryRobotResultModel
|
|
|
{
|
|
|
SingleRobotCode = data?.singleRobotCode,
|
|
|
RobotDir = data?.robotDir ?? 0,
|
|
|
RobotIp = data?.robotIp,
|
|
|
Battery = data?.battery ?? 0,
|
|
|
Speed = data?.speed ?? 0,
|
|
|
CarrierCode = data?.carrierCode,
|
|
|
Extra = data?.extra?.ToString(),
|
|
|
success = resp.success,
|
|
|
errorCode = resp.errorCode,
|
|
|
};
|
|
|
|
|
|
string xStr = data?.x;
|
|
|
if (double.TryParse(xStr, out double xVal)) model.X = xVal;
|
|
|
|
|
|
string yStr = data?.y;
|
|
|
if (double.TryParse(yStr, out double yVal)) model.Y = yVal;
|
|
|
|
|
|
if (data?.robotStatus != null)
|
|
|
model.RobotStatus = data.robotStatus.taskable;
|
|
|
|
|
|
if (data?.warnings != null)
|
|
|
{
|
|
|
model.Warnings = ((IEnumerable<dynamic>)data.warnings).Select(w => new Domain.Model.QueryRobot.Waring
|
|
|
{
|
|
|
Code = w.taskWarnCode,
|
|
|
Desc = w.errorMsg,
|
|
|
}).ToList();
|
|
|
}
|
|
|
|
|
|
return new QueryRobotResultDto { code = status, msg = resp.message, data = model};
|
|
|
},
|
|
|
Error<QueryRobotResultDto>
|
|
|
);
|
|
|
}
|
|
|
|
|
|
public QueryCarrierResultDto QueryCarrierStatus(Domain.Dto.QueryCarrier.QueryCarrierDto req)
|
|
|
{
|
|
|
return Execute(
|
|
|
() =>
|
|
|
{
|
|
|
if (req == null) throw new ArgumentException("输入参数为空。");
|
|
|
return hikRoBotSdk.QueryCarrierStatus(new HikRoBotSdk.Dto.QueryCarrier.QueryCarrierDto
|
|
|
{
|
|
|
carrierCode = req.CarrierCode,
|
|
|
});
|
|
|
},
|
|
|
(resp, status) =>
|
|
|
{
|
|
|
var data = resp.data;
|
|
|
var model = new Domain.Model.QueryCarrier.QueryCarrierResultModel
|
|
|
{
|
|
|
CarrierCode = data?.carrierCode,
|
|
|
RobotTaskCode = data?.robotTaskCode,
|
|
|
SiteCode = data?.siteCode,
|
|
|
CarrierDir = data?.carrierDir,
|
|
|
CarrierStatus = data?.carrierStatus,
|
|
|
BinCode = data?.binCode,
|
|
|
BinName = data?.binName,
|
|
|
RobotCode = data?.robotCode,
|
|
|
Extra = data?.extra?.ToString(),
|
|
|
success = resp.success,
|
|
|
errorCode = resp.errorCode,
|
|
|
};
|
|
|
|
|
|
string xStr = data?.x;
|
|
|
if (double.TryParse(xStr, out double xVal)) model.X = xVal;
|
|
|
|
|
|
string yStr = data?.y;
|
|
|
if (double.TryParse(yStr, out double yVal)) model.Y = yVal;
|
|
|
|
|
|
return new QueryCarrierResultDto { code = status, msg = resp.message, data = model };
|
|
|
},
|
|
|
Error<QueryCarrierResultDto>
|
|
|
);
|
|
|
}
|
|
|
|
|
|
public MatLabelBindResultDto MatLabelBind(Domain.Dto.MatLabelBind.MatLabelBindDto req)
|
|
|
{
|
|
|
return Execute(
|
|
|
() =>
|
|
|
{
|
|
|
if (req == null) throw new ArgumentException("输入参数为空。");
|
|
|
return hikRoBotSdk.MatLabelBind(new HikRoBotSdk.Dto.MatLabelBind.MatLabelBindDto
|
|
|
{
|
|
|
carrierCode = req.CarrierCode,
|
|
|
matLabel = req.MatLabel,
|
|
|
});
|
|
|
},
|
|
|
(resp, status) => new MatLabelBindResultDto
|
|
|
{
|
|
|
code = status,
|
|
|
msg = resp.message,
|
|
|
data = new Domain.Model.MatLabelBind.MatLabelBindResultModel
|
|
|
{
|
|
|
Extra = resp.extra?.ToString(),
|
|
|
errorCode = resp.errorCode,
|
|
|
success = resp.success,
|
|
|
},
|
|
|
},
|
|
|
Error<MatLabelBindResultDto>
|
|
|
);
|
|
|
}
|
|
|
|
|
|
public MatLabelUnbindResultDto MatLabelUnbind(Domain.Dto.MatLabelUnbind.MatLabelUnbindDto req)
|
|
|
{
|
|
|
return Execute(
|
|
|
() =>
|
|
|
{
|
|
|
if (req == null) throw new ArgumentException("输入参数为空。");
|
|
|
return hikRoBotSdk.MatLabelUnbind(new HikRoBotSdk.Dto.MatLabelUnbind.MatLabelUnbindDto
|
|
|
{
|
|
|
carrierCode = req.CarrierCode,
|
|
|
matLabel = req.MatLabel,
|
|
|
});
|
|
|
},
|
|
|
(resp, status) => new MatLabelUnbindResultDto { code = status, msg = resp.message,data = new MatLabelUnbindResultModel()
|
|
|
{
|
|
|
errorCode = resp.errorCode,
|
|
|
success = resp.success,
|
|
|
}},
|
|
|
Error<MatLabelUnbindResultDto>
|
|
|
);
|
|
|
}
|
|
|
|
|
|
public EquipmentNotifyResultDto EquipmentNotify(Domain.Dto.EquipmentNotify.EquipmentNotifyDto req)
|
|
|
{
|
|
|
return Execute(
|
|
|
() =>
|
|
|
{
|
|
|
if (req == null) throw new ArgumentException("输入参数为空。");
|
|
|
return hikRoBotSdk.EquipmentNotify(new HikRoBotSdk.Dto.EquipmentNotify.EquipmentNotifyDto
|
|
|
{
|
|
|
eqptCode = req.EqptCode,
|
|
|
taskCode = req.TaskCode,
|
|
|
actionStatus = req.ActionStatus,
|
|
|
siteCode = req.SiteCode,
|
|
|
extra = req.Extra,
|
|
|
});
|
|
|
},
|
|
|
(resp, status) => new EquipmentNotifyResultDto
|
|
|
{
|
|
|
code = status,
|
|
|
msg = resp.message,
|
|
|
data = new Domain.Model.EquipmentNotify.EquipmentNotifyResultModel
|
|
|
{
|
|
|
RobotTaskCode = resp.data?.robotTaskCode,
|
|
|
NextSeq = resp.data?.nextSeq,
|
|
|
Extra = resp.data?.extra?.ToString(),
|
|
|
errorCode = resp.errorCode,
|
|
|
success = resp.success,
|
|
|
},
|
|
|
},
|
|
|
Error<EquipmentNotifyResultDto>
|
|
|
);
|
|
|
}
|
|
|
|
|
|
public EquipmentNotifyResultDto EquipmentNotifyGbt(Domain.Dto.EquipmentNotify.EquipmentNotifyDto req)
|
|
|
{
|
|
|
return Execute(
|
|
|
() =>
|
|
|
{
|
|
|
if (req == null) throw new ArgumentException("输入参数为空。");
|
|
|
return hikRoBotSdk.EquipmentNotifyGbt(new HikRoBotSdk.Dto.EquipmentNotify.EquipmentNotifyDto
|
|
|
{
|
|
|
eqptCode = req.EqptCode,
|
|
|
taskCode = req.TaskCode,
|
|
|
actionStatus = req.ActionStatus,
|
|
|
siteCode = req.SiteCode,
|
|
|
extra = req.Extra,
|
|
|
});
|
|
|
},
|
|
|
(resp, status) => new EquipmentNotifyResultDto
|
|
|
{
|
|
|
code = status,
|
|
|
msg = resp.message,
|
|
|
data = new Domain.Model.EquipmentNotify.EquipmentNotifyResultModel
|
|
|
{
|
|
|
RobotTaskCode = resp.data?.robotTaskCode,
|
|
|
NextSeq = resp.data?.nextSeq,
|
|
|
Extra = resp.data?.extra?.ToString(),
|
|
|
errorCode = resp.errorCode,
|
|
|
success = resp.success,
|
|
|
},
|
|
|
},
|
|
|
Error<EquipmentNotifyResultDto>
|
|
|
);
|
|
|
}
|
|
|
}
|
|
|
}
|