/// <inheritdoc/>
public async Task <BrowseNextResponseApiModel> NodeBrowseNextAsync(EndpointApiModel endpoint,
BrowseNextRequestApiModel request, CancellationToken ct)
{
if (endpoint == null)
{
throw new ArgumentNullException(nameof(endpoint));
}
if (string.IsNullOrEmpty(endpoint.Url))
{
throw new ArgumentNullException(nameof(endpoint.Url));
}
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
if (request.ContinuationToken == null)
{
throw new ArgumentNullException(nameof(request.ContinuationToken));
}
var response = await _methodClient.CallMethodAsync(_deviceId, _moduleId,
"BrowseNext_V2", _serializer.SerializeToString(new {
endpoint,
request
}), null, ct);
return(_serializer.Deserialize <BrowseNextResponseApiModel>(response));
}
/// <inheritdoc/>
public async Task <WriteResponseApiModel> NodeWriteAsync(EndpointApiModel endpoint,
WriteRequestApiModel request, CancellationToken ct)
{
if (endpoint == null)
{
throw new ArgumentNullException(nameof(endpoint));
}
if (string.IsNullOrEmpty(endpoint.Url))
{
throw new ArgumentNullException(nameof(endpoint.Url));
}
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
if (request.Attributes == null || request.Attributes.Count == 0)
{
throw new ArgumentException(nameof(request.Attributes));
}
var response = await _methodClient.CallMethodAsync(_deviceId, _moduleId,
"NodeWrite_V2", _serializer.SerializeToString(new {
endpoint,
request
}), null, ct);
return(_serializer.Deserialize <WriteResponseApiModel>(response));
}
/// <inheritdoc/>
public async Task <HistoryUpdateResponseApiModel> HistoryUpdateRawAsync(
EndpointApiModel endpoint, HistoryUpdateRequestApiModel <VariantValue> request,
CancellationToken ct)
{
if (endpoint == null)
{
throw new ArgumentNullException(nameof(endpoint));
}
if (string.IsNullOrEmpty(endpoint.Url))
{
throw new ArgumentNullException(nameof(endpoint.Url));
}
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
if (request.Details == null)
{
throw new ArgumentNullException(nameof(request.Details));
}
var response = await _methodClient.CallMethodAsync(_deviceId, _moduleId,
"HistoryUpdate_V2", _serializer.SerializeToString(new {
endpoint,
request
}), null, ct);
return(_serializer.Deserialize <HistoryUpdateResponseApiModel>(response));
}
/// <inheritdoc/>
public async Task <HistoryReadNextResponseApiModel <JToken> > HistoryReadRawNextAsync(
EndpointApiModel endpoint, HistoryReadNextRequestApiModel request,
CancellationToken ct)
{
if (endpoint == null)
{
throw new ArgumentNullException(nameof(endpoint));
}
if (string.IsNullOrEmpty(endpoint.Url))
{
throw new ArgumentNullException(nameof(endpoint.Url));
}
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
if (string.IsNullOrEmpty(request.ContinuationToken))
{
throw new ArgumentNullException(nameof(request.ContinuationToken));
}
var response = await _methodClient.CallMethodAsync(_deviceId, _moduleId,
"HistoryReadNext_V2", JsonConvertEx.SerializeObject(new {
endpoint,
request
}), null, ct);
return(JsonConvertEx.DeserializeObject <HistoryReadNextResponseApiModel <JToken> >(response));
}
/// <inheritdoc/>
public async Task <BrowsePathResponseApiModel> NodeBrowsePathAsync(EndpointApiModel endpoint,
BrowsePathRequestApiModel request, CancellationToken ct)
{
if (endpoint == null)
{
throw new ArgumentNullException(nameof(endpoint));
}
if (string.IsNullOrEmpty(endpoint.Url))
{
throw new ArgumentNullException(nameof(endpoint.Url));
}
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
if (request.BrowsePaths == null || request.BrowsePaths.Count == 0 ||
request.BrowsePaths.Any(p => p == null || p.Length == 0))
{
throw new ArgumentNullException(nameof(request.BrowsePaths));
}
var response = await _methodClient.CallMethodAsync(_deviceId, _moduleId,
"BrowsePath_V2", _serializer.SerializeToString(new {
endpoint,
request
}), null, ct);
return(_serializer.Deserialize <BrowsePathResponseApiModel>(response));
}
/// <inheritdoc/>
public async Task <ValueWriteResponseApiModel> NodeValueWriteAsync(EndpointApiModel endpoint,
ValueWriteRequestApiModel request, CancellationToken ct)
{
if (endpoint == null)
{
throw new ArgumentNullException(nameof(endpoint));
}
if (string.IsNullOrEmpty(endpoint.Url))
{
throw new ArgumentNullException(nameof(endpoint.Url));
}
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
if (request.Value == null)
{
throw new ArgumentNullException(nameof(request.Value));
}
var response = await _methodClient.CallMethodAsync(_deviceId, _moduleId,
"ValueWrite_V2", JsonConvertEx.SerializeObject(new {
endpoint,
request
}), null, ct);
return(JsonConvertEx.DeserializeObject <ValueWriteResponseApiModel>(response));
}
/// <summary>
/// Get endpoint certificate
/// </summary>
/// <param name="endpoint"></param>
/// <returns></returns>
public async Task <byte[]> GetEndpointCertificateAsync(
EndpointApiModel endpoint)
{
if (endpoint == null)
{
throw new ArgumentNullException(nameof(endpoint));
}
var result = await _discovery.GetEndpointCertificateAsync(
endpoint.ToServiceModel());
return(result);
}
/// <summary>
/// Update history
/// </summary>
/// <param name="endpoint"></param>
/// <param name="request"></param>
/// <returns></returns>
public async Task <HistoryUpdateResponseApiModel> HistoryUpdateAsync(
EndpointApiModel endpoint, HistoryUpdateRequestApiModel <VariantValue> request)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
var result = await _historian.HistoryUpdateAsync(
endpoint.ToServiceModel(), request.ToServiceModel());
return(result.ToApiModel());
}
/// <summary>
/// Write attributes
/// </summary>
/// <param name="endpoint"></param>
/// <param name="request"></param>
/// <returns></returns>
public async Task <WriteResponseApiModel> NodeWriteAsync(
EndpointApiModel endpoint, WriteRequestApiModel request)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
var result = await _nodes.NodeWriteAsync(
endpoint.ToServiceModel(), request.ToServiceModel());
return(result.ToApiModel());
}
/// <summary>
/// Publish
/// </summary>
/// <param name="endpoint"></param>
/// <param name="request"></param>
/// <returns></returns>
public async Task <PublishStartResponseApiModel> PublishStartAsync(
EndpointApiModel endpoint, PublishStartRequestApiModel request)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
var result = await _publisher.NodePublishStartAsync(
endpoint.ToServiceModel(), request.ToServiceModel());
return(new PublishStartResponseApiModel(result));
}
/// <summary>
/// Read next history
/// </summary>
/// <param name="endpoint"></param>
/// <param name="request"></param>
/// <returns></returns>
public async Task <HistoryReadNextResponseApiModel> HistoryReadNextAsync(
EndpointApiModel endpoint, HistoryReadNextRequestApiModel request)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
var result = await _historian.HistoryReadNextAsync(
endpoint.ToServiceModel(), request.ToServiceModel());
return(new HistoryReadNextResponseApiModel(result));
}
/// <summary>
/// Convert back to service model
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public static EndpointModel ToServiceModel(
this EndpointApiModel model)
{
if (model == null)
{
return(null);
}
return(new EndpointModel {
Url = model.Url,
AlternativeUrls = model.AlternativeUrls,
SecurityMode = (IIoT.OpcUa.Core.Models.SecurityMode?)model.SecurityMode,
SecurityPolicy = model.SecurityPolicy,
Certificate = model.Certificate,
});
}
/// <summary>
/// Browse
/// </summary>
/// <param name="endpoint"></param>
/// <param name="request"></param>
/// <returns></returns>
public async Task <BrowseResponseApiModel> BrowseAsync(
EndpointApiModel endpoint, BrowseRequestInternalApiModel request)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
if (endpoint == null)
{
throw new ArgumentNullException(nameof(endpoint));
}
var result = await _browse.NodeBrowseFirstAsync(
endpoint.ToServiceModel(), request.ToServiceModel());
return(result.ToApiModel());
}
/// <summary>
/// Get method meta data
/// </summary>
/// <param name="endpoint"></param>
/// <param name="request"></param>
/// <returns></returns>
public async Task <MethodMetadataResponseApiModel> MethodMetadataAsync(
EndpointApiModel endpoint, MethodMetadataRequestApiModel request)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
if (endpoint == null)
{
throw new ArgumentNullException(nameof(endpoint));
}
var result = await _nodes.NodeMethodGetMetadataAsync(
endpoint.ToServiceModel(), request.ToServiceModel());
return(result.ToApiModel());
}
/// <summary>
/// Read value
/// </summary>
/// <param name="endpoint"></param>
/// <param name="request"></param>
/// <returns></returns>
public async Task <ValueReadResponseApiModel> ValueReadAsync(
EndpointApiModel endpoint, ValueReadRequestApiModel request)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
if (endpoint == null)
{
throw new ArgumentNullException(nameof(endpoint));
}
var result = await _nodes.NodeValueReadAsync(
endpoint.ToServiceModel(), request.ToServiceModel());
return(new ValueReadResponseApiModel(result));
}
/// <summary>
/// Browse all references if max references == null and user
/// wants all. If user has requested maximum to return uses
/// <see cref="ITwinModuleApi.NodeBrowseFirstAsync"/>
/// </summary>
/// <param name="service"></param>
/// <param name="endpoint"></param>
/// <param name="request"></param>
/// <param name="ct"></param>
/// <returns></returns>
public static async Task <BrowseResponseApiModel> NodeBrowseAsync(
this ITwinModuleApi service, EndpointApiModel endpoint,
BrowseRequestApiModel request, CancellationToken ct = default)
{
if (request.MaxReferencesToReturn != null)
{
return(await service.NodeBrowseFirstAsync(endpoint, request));
}
while (true)
{
var result = await service.NodeBrowseFirstAsync(endpoint, request, ct);
while (result.ContinuationToken != null)
{
try {
var next = await service.NodeBrowseNextAsync(endpoint,
new BrowseNextRequestApiModel {
ContinuationToken = result.ContinuationToken,
Header = request.Header,
ReadVariableValues = request.ReadVariableValues,
TargetNodesOnly = request.TargetNodesOnly
}, ct);
result.References.AddRange(next.References);
result.ContinuationToken = next.ContinuationToken;
}
catch (Exception) {
await Try.Async(() => service.NodeBrowseNextAsync(endpoint,
new BrowseNextRequestApiModel {
ContinuationToken = result.ContinuationToken,
Abort = true
}));
throw;
}
}
return(result);
}
}
