/// <summary>
/// Browse all references
/// </summary>
private static async Task <BrowseResponseApiModel> NodeBrowseAsync(
ITwinServiceApi service, string endpoint, BrowseRequestApiModel request)
{
while (true)
{
var result = await service.NodeBrowseFirstAsync(endpoint, request);
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
});
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);
}
}
/// <summary>
/// Browse node on endpoint
/// </summary>
/// <param name="api"></param>
/// <param name="endpointUrl"></param>
/// <param name="request"></param>
/// <param name="ct"></param>
/// <returns></returns>
public static Task <BrowseResponseApiModel> NodeBrowseFirstAsync(
this ITwinModuleApi api, string endpointUrl, BrowseRequestApiModel request,
CancellationToken ct = default)
{
return(api.NodeBrowseFirstAsync(new EndpointApiModel {
Url = endpointUrl,
SecurityMode = SecurityMode.None
}, request, ct));
}
public async Task <BrowseResponseApiModel> BrowseAsync(string endpointId,
[FromBody][Required] BrowseRequestApiModel request)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
var browseresult = await _broser.NodeBrowseAsync(endpointId,
request.ToServiceModel());
return(new BrowseResponseApiModel(browseresult));
}
/// <summary>
/// Browse
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public async Task <BrowseResponseApiModel> BrowseAsync(
BrowseRequestApiModel request)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
var result = await _browse.NodeBrowseFirstAsync(
await _twin.GetEndpointAsync(), request.ToServiceModel());
return(new BrowseResponseApiModel(result));
}
/// <inheritdoc/>
public async Task <BrowseResponseApiModel> NodeBrowseFirstAsync(string endpointId,
BrowseRequestApiModel content, CancellationToken ct)
{
if (string.IsNullOrEmpty(endpointId))
{
throw new ArgumentNullException(nameof(endpointId));
}
var request = _httpClient.NewRequest($"{_serviceUri}/v2/browse/{endpointId}",
_resourceId);
request.SetContent(content);
var response = await _httpClient.PostAsync(request, ct).ConfigureAwait(false);
response.Validate();
return(response.GetContent <BrowseResponseApiModel>());
}
/// <inheritdoc/>
public async Task <BrowseResponseApiModel> NodeBrowseFirstAsync(string endpointId,
BrowseRequestApiModel content, CancellationToken ct)
{
if (string.IsNullOrEmpty(endpointId))
{
throw new ArgumentNullException(nameof(endpointId));
}
var path = new UriBuilder($"{_serviceUri}/v2/browse/{endpointId}");
if (!string.IsNullOrEmpty(content.NodeId))
{
path.Query = $"nodeId={content.NodeId.UrlEncode()}";
}
var request = _httpClient.NewRequest(path.ToString());
var response = await _httpClient.GetAsync(request, ct).ConfigureAwait(false);
response.Validate();
return(response.GetContent <BrowseResponseApiModel>());
}
/// <summary>
/// Convert back to service model
/// </summary>
/// <returns></returns>
public static BrowseRequestModel ToServiceModel(
this BrowseRequestApiModel model)
{
if (model == null)
{
return(null);
}
return(new BrowseRequestModel {
NodeId = model.NodeId,
MaxReferencesToReturn = model.MaxReferencesToReturn,
Direction = (IIoT.OpcUa.Core.Models.BrowseDirection?)model.Direction,
View = model.View.ToServiceModel(),
ReferenceTypeId = model.ReferenceTypeId,
TargetNodesOnly = model.TargetNodesOnly,
ReadVariableValues = model.ReadVariableValues,
NoSubtypes = model.NoSubtypes,
Header = model.Header.ToServiceModel()
});
}
/// <summary>
/// Browse
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public async Task <BrowseResponseApiModel> BrowseAsync(
BrowseRequestApiModel request)
{
// Limit returned references to fit into 128k response
const int kMaxReferences = 100;
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
if (!request.MaxReferencesToReturn.HasValue ||
request.MaxReferencesToReturn.Value > kMaxReferences)
{
request.MaxReferencesToReturn = kMaxReferences;
}
var result = await _browse.NodeBrowseFirstAsync(
_twin.Endpoint, request.ToServiceModel());
return(new BrowseResponseApiModel(result));
}
/// <summary>
/// Browse all references if max references is null and user
/// wants all. If user has requested maximum to return uses
/// <see cref="ITwinServiceApi.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 ITwinServiceApi service, string endpoint, BrowseRequestApiModel request,
CancellationToken ct = default)
{
if (request.MaxReferencesToReturn != null)
{
return(await service.NodeBrowseFirstAsync(endpoint, request, ct));
}
while (true)
{
// Limit size of batches to a reasonable default to avoid communication timeouts.
request.MaxReferencesToReturn = 500;
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);
}
}
public async Task <ActionResult> GetRootNode()
{
List <object> jsonTree = new List <object>();
string endpointId = Session["EndpointId"].ToString();
BrowseRequestApiModel model = new BrowseRequestApiModel();
model.NodeId = "";
model.TargetNodesOnly = true;
try
{
var browseData = await TwinService.NodeBrowseAsync(endpointId, model);
jsonTree.Add(new { id = browseData.Node.NodeId, text = browseData.Node.DisplayName, children = (browseData.References?.Count != 0) });
return(Json(jsonTree, JsonRequestBehavior.AllowGet));
}
catch (Exception exception)
{
Session["EndpointId"] = null;
return(Content(CreateOpcExceptionActionString(exception)));
}
}
/// <inheritdoc/>
public async Task <BrowseResponseApiModel> NodeBrowseFirstAsync(EndpointApiModel endpoint,
BrowseRequestApiModel 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));
}
var response = await _methodClient.CallMethodAsync(_deviceId, _moduleId,
"Browse_V2", _serializer.SerializeToString(new {
endpoint,
request
}), null, ct);
return(_serializer.Deserialize <BrowseResponseApiModel>(response));
}
public BrowseResponseApiModel NodeBrowse(string endpoint, BrowseRequestApiModel content)
{
Task <BrowseResponseApiModel> t = Task.Run(() => _twinServiceHandler.NodeBrowseAsync(endpoint, content));
return(t.Result);
}
/// <summary>
/// Get tree
/// </summary>
/// <param name="endpointId"></param>
/// <param name="id"></param>
/// <param name="parentId"></param>
/// <param name="discovererId"></param>
/// <param name="direction"></param>
/// <returns>ListNode</returns>
public async Task <PagedResult <ListNode> > GetTreeAsync(string endpointId,
string id, List <string> parentId, string discovererId, BrowseDirection direction)
{
var pageResult = new PagedResult <ListNode>();
var model = new BrowseRequestApiModel {
TargetNodesOnly = true
};
if (direction == BrowseDirection.Forward)
{
model.MaxReferencesToReturn = _MAX_REFERENCES;
model.NodeId = id;
if (id == string.Empty)
{
Path = string.Empty;
}
}
else
{
model.NodeId = parentId.ElementAt(parentId.Count - 2);
}
try {
var browseData = await _twinService.NodeBrowseAsync(endpointId, model);
var continuationToken = browseData.ContinuationToken;
var references = browseData.References;
var browseDataNext = new BrowseNextResponseApiModel();
if (direction == BrowseDirection.Forward)
{
parentId.Add(browseData.Node.NodeId);
Path += "/" + browseData.Node.DisplayName;
}
else
{
parentId.RemoveAt(parentId.Count - 1);
Path = Path.Substring(0, Path.LastIndexOf("/"));
}
do
{
if (references != null)
{
foreach (var nodeReference in references)
{
pageResult.Results.Add(new ListNode {
Id = nodeReference.Target.NodeId.ToString(),
NodeClass = nodeReference.Target.NodeClass ?? 0,
NodeName = nodeReference.Target.DisplayName.ToString(),
Children = (bool)nodeReference.Target.Children,
ParentIdList = parentId,
DiscovererId = discovererId,
AccessLevel = nodeReference.Target.AccessLevel ?? 0,
ParentName = browseData.Node.DisplayName,
DataType = nodeReference.Target.DataType,
Value = string.Empty,
Publishing = false,
PublishedItem = null
});
}
}
if (!string.IsNullOrEmpty(continuationToken))
{
var modelNext = new BrowseNextRequestApiModel {
ContinuationToken = continuationToken
};
browseDataNext = await _twinService.NodeBrowseNextAsync(endpointId, modelNext);
references = browseDataNext.References;
continuationToken = browseDataNext.ContinuationToken;
}
else
{
browseDataNext.References = null;
}
} while (!string.IsNullOrEmpty(continuationToken) || browseDataNext.References != null);
}
catch (Exception e) {
// skip this node
Trace.TraceError("Can not browse node '{0}'", id);
var errorMessage = string.Concat(e.Message, e.InnerException?.Message ?? "--", e?.StackTrace ?? "--");
Trace.TraceError(errorMessage);
pageResult.Results.Add(new ListNode {
NodeName = e.Message,
DiscovererId = discovererId,
ParentName = "Root"
});
}
pageResult.PageSize = 10;
pageResult.RowCount = pageResult.Results.Count;
pageResult.PageCount = (int)Math.Ceiling((decimal)pageResult.RowCount / 10);
return(pageResult);
}
/// <summary>
/// Get tree
/// </summary>
/// <param name="endpointId"></param>
/// <param name="id"></param>
/// <param name="parentId"></param>
/// <param name="discovererId"></param>
/// <param name="direction"></param>
/// <param name="index"></param>
/// <param name="credential"></param>
/// <returns>ListNode</returns>
public async Task <PagedResult <ListNode> > GetTreeAsync(string endpointId, string id,
List <string> parentId, string discovererId, BrowseDirection direction, int index,
CredentialModel credential = null)
{
var pageResult = new PagedResult <ListNode>();
var header = Elevate(new RequestHeaderApiModel(), credential);
var previousPage = new PagedResult <ListNode>();
var model = new BrowseRequestApiModel {
TargetNodesOnly = true,
ReadVariableValues = true,
MaxReferencesToReturn = _MAX_REFERENCES
};
if (direction == BrowseDirection.Forward)
{
model.NodeId = id;
if (id == string.Empty)
{
Path = new List <string>();
}
}
else
{
model.NodeId = parentId.ElementAt(index - 1);
}
model.Header = header;
try {
var browseData = await _twinService.NodeBrowseAsync(endpointId, model);
_displayName = browseData.Node.DisplayName;
if (direction == BrowseDirection.Forward)
{
parentId.Add(browseData.Node.NodeId);
Path.Add(browseData.Node.DisplayName);
}
else
{
parentId.RemoveAt(parentId.Count - 1);
Path.RemoveRange(index, Path.Count - index);
}
if (!string.IsNullOrEmpty(browseData.ContinuationToken))
{
pageResult.PageCount = 2;
}
if (browseData.References != null)
{
foreach (var nodeReference in browseData.References)
{
previousPage.Results.Add(new ListNode {
Id = nodeReference.Target.NodeId.ToString(),
NodeClass = nodeReference.Target.NodeClass ?? 0,
NodeName = nodeReference.Target.DisplayName.ToString(),
Children = (bool)nodeReference.Target.Children,
ParentIdList = parentId,
DiscovererId = discovererId,
AccessLevel = nodeReference.Target.AccessLevel ?? 0,
ParentName = _displayName,
DataType = nodeReference.Target.DataType,
Value = nodeReference.Target.Value?.ToJson()?.TrimQuotes(),
Publishing = false,
PublishedItem = null
});
}
}
pageResult.Results = previousPage.Results;
pageResult.ContinuationToken = browseData.ContinuationToken;
pageResult.PageSize = _commonHelper.PageLength;
pageResult.RowCount = pageResult.Results.Count;
}
catch (UnauthorizedAccessException) {
pageResult.Error = "Unauthorized access: Bad User Access Denied.";
}
catch (Exception e) {
// skip this node
_logger.Error(e, "Can not browse node '{id}'", id);
var errorMessage = string.Concat(e.Message, e.InnerException?.Message ?? "--", e?.StackTrace ?? "--");
pageResult.Error = errorMessage;
}
return(pageResult);
}
/// <summary>
/// Browse node on endpoint
/// </summary>
/// <param name="api"></param>
/// <param name="endpointUrl"></param>
/// <param name="request"></param>
/// <param name="ct"></param>
/// <returns></returns>
public static Task <BrowseResponseApiModel> NodeBrowseAsync(
this ITwinModuleApi api, string endpointUrl, BrowseRequestApiModel request,
CancellationToken ct = default)
{
return(api.NodeBrowseAsync(NewEndpoint(endpointUrl), request, ct));
}
/// <summary>
/// Browse nodes
/// </summary>
private async Task BrowseAsync(int index, string id, bool silent, bool recursive,
bool?readDuringBrowse, string node, bool?targetNodesOnly,
uint?maxReferencesToReturn, BrowseDirection?direction, CliOptions options,
List <string> variables = null)
{
var request = new BrowseRequestApiModel {
TargetNodesOnly = targetNodesOnly,
ReadVariableValues = readDuringBrowse,
MaxReferencesToReturn = maxReferencesToReturn,
Direction = direction
};
var nodes = new HashSet <string>(StringComparer.OrdinalIgnoreCase)
{
node
};
var visited = new HashSet <string>(StringComparer.OrdinalIgnoreCase);
var nodesRead = new HashSet <string>(StringComparer.OrdinalIgnoreCase);
var errors = 0;
var sw = Stopwatch.StartNew();
while (nodes.Count > 0)
{
request.NodeId = nodes.First();
nodes.Remove(request.NodeId);
try {
var result = await NodeBrowseAsync(_twin, id, request);
visited.Add(request.NodeId);
if (!silent)
{
PrintResult(options, result);
}
if (readDuringBrowse ?? false)
{
continue;
}
// Do recursive browse
if (recursive)
{
foreach (var r in result.References)
{
if (!visited.Contains(r.ReferenceTypeId))
{
nodes.Add(r.ReferenceTypeId);
}
if (!visited.Contains(r.Target.NodeId))
{
nodes.Add(r.Target.NodeId);
if (variables != null &&
r.Target.NodeClass == NodeClass.Variable)
{
variables.Add(r.Target.NodeId);
}
}
if (nodesRead.Contains(r.Target.NodeId))
{
continue; // We have read this one already
}
if (!r.Target.NodeClass.HasValue ||
r.Target.NodeClass.Value != NodeClass.Variable)
{
continue;
}
if (!silent)
{
Console.WriteLine($"Reading {r.Target.NodeId}");
}
try {
nodesRead.Add(r.Target.NodeId);
var read = await _twin.NodeValueReadAsync(id,
new ValueReadRequestApiModel {
NodeId = r.Target.NodeId
});
if (!silent)
{
PrintResult(options, read);
}
}
catch (Exception ex) {
Console.WriteLine($"Browse {index} - reading {r.Target.NodeId} resulted in {ex}");
errors++;
}
}
}
}
catch (Exception e) {
Console.WriteLine($"Browse {index} {request.NodeId} resulted in {e}");
errors++;
}
}
Console.WriteLine($"Browse {index} took {sw.Elapsed}. Visited " +
$"{visited.Count} nodes and read {nodesRead.Count} of them with {errors} errors.");
}
public async Task <ActionResult> GetChildren(string jstreeNode)
{
// This delimiter is used to allow the storing of the OPC UA parent node ID together with the OPC UA child node ID in jstree data structures and provide it as parameter to
// Ajax calls.
string[] delimiter = { "__$__" };
string[] jstreeNodeSplit = jstreeNode.Split(delimiter, 3, StringSplitOptions.None);
string node;
if (jstreeNodeSplit.Length == 1)
{
node = jstreeNodeSplit[0];
}
else
{
node = jstreeNodeSplit[1];
}
List <object> jsonTree = new List <object>();
string endpointId = Session["EndpointId"].ToString();
string endpointUrl = Session["EndpointUrl"].ToString();
string ProductUri = Session["ProductUri"].ToString();
// read the currently published nodes
PublishedItemListResponseApiModel publishedNodes = new PublishedItemListResponseApiModel();
try
{
PublishedItemListRequestApiModel publishModel = new PublishedItemListRequestApiModel();
publishedNodes = await TwinService.GetPublishedNodesAsync(endpointId, publishModel);
}
catch (Exception e)
{
// do nothing, since we still want to show the tree
Trace.TraceWarning("Can not read published nodes for endpoint '{0}'.", endpointUrl);
string errorMessage = string.Format(Strings.BrowserOpcException, e.Message,
e.InnerException?.Message ?? "--", e?.StackTrace ?? "--");
Trace.TraceWarning(errorMessage);
}
BrowseResponseApiModel browseData = new BrowseResponseApiModel();
try
{
Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();
try
{
BrowseRequestApiModel model = new BrowseRequestApiModel();
model.NodeId = node;
model.TargetNodesOnly = false;
browseData = TwinService.NodeBrowse(endpointId, model);
}
catch (Exception e)
{
// skip this node
Trace.TraceError("Can not browse node '{0}'", node);
string errorMessage = string.Format(Strings.BrowserOpcException, e.Message,
e.InnerException?.Message ?? "--", e?.StackTrace ?? "--");
Trace.TraceError(errorMessage);
}
Trace.TraceInformation("Browsing node '{0}' data took {0} ms", node.ToString(), stopwatch.ElapsedMilliseconds);
if (browseData.References != null)
{
var idList = new List <string>();
foreach (var nodeReference in browseData.References)
{
bool idFound = false;
foreach (var id in idList)
{
if (id == nodeReference.Target.NodeId.ToString())
{
idFound = true;
}
}
if (idFound == true)
{
continue;
}
Trace.TraceInformation("Browse '{0}' count: {1}", nodeReference.Target.NodeId, jsonTree.Count);
NodeApiModel currentNode = nodeReference.Target;
currentNode = nodeReference.Target;
byte currentNodeAccessLevel = 0;
byte currentNodeEventNotifier = 0;
bool currentNodeExecutable = false;
switch (currentNode.NodeClass)
{
case NodeClass.Variable:
currentNodeAccessLevel = (byte)currentNode.UserAccessLevel;
if (!PermsChecker.HasPermission(Permission.ControlOpcServer))
{
currentNodeAccessLevel = (byte)((uint)currentNodeAccessLevel & ~0x2);
}
break;
case NodeClass.Object:
currentNodeEventNotifier = (byte)currentNode.EventNotifier;
break;
case NodeClass.View:
currentNodeEventNotifier = (byte)currentNode.EventNotifier;
break;
case NodeClass.Method:
if (PermsChecker.HasPermission(Permission.ControlOpcServer))
{
currentNodeExecutable = (bool)currentNode.UserExecutable;
}
break;
default:
break;
}
var isPublished = false;
var isRelevant = false;
if (publishedNodes.Items != null)
{
foreach (var item in publishedNodes.Items)
{
if (item.NodeId == nodeReference.Target.NodeId.ToString())
{
isPublished = true;
ContosoOpcUaNode contosoOpcUaNode = Startup.Topology.GetOpcUaNode(ProductUri, item.NodeId);
if (contosoOpcUaNode?.Relevance != null)
{
isRelevant = true;
}
}
}
}
jsonTree.Add(new
{
id = ("__" + node + delimiter[0] + nodeReference.Target.NodeId.ToString()),
text = nodeReference.Target.DisplayName.ToString(),
nodeClass = nodeReference.Target.NodeClass.ToString(),
accessLevel = currentNodeAccessLevel.ToString(),
eventNotifier = currentNodeEventNotifier.ToString(),
executable = currentNodeExecutable.ToString(),
children = nodeReference.Target.HasChildren,
publishedNode = isPublished,
relevantNode = isRelevant
});
idList.Add(nodeReference.Target.NodeId.ToString());
}
}
stopwatch.Stop();
Trace.TraceInformation("Browing all childeren info of node '{0}' took {0} ms", node, stopwatch.ElapsedMilliseconds);
return(Json(jsonTree, JsonRequestBehavior.AllowGet));
}
catch (Exception exception)
{
return(Content(CreateOpcExceptionActionString(exception)));
}
}
/// <summary>
/// Browse node references
/// </summary>
/// <remarks>
/// Browse a node on the specified endpoint. The endpoint must be activated and
/// connected and the module client and server must trust each other.
/// </remarks>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='endpointId'>
/// The identifier of the activated endpoint.
/// </param>
/// <param name='body'>
/// The browse request
/// </param>
/// <param name='cancellationToken'>
/// The cancellation token.
/// </param>
public static async Task <BrowseResponseApiModel> BrowseAsync(this IAzureOpcTwinClient operations, string endpointId, BrowseRequestApiModel body, CancellationToken cancellationToken = default(CancellationToken))
{
using (var _result = await operations.BrowseWithHttpMessagesAsync(endpointId, body, null, cancellationToken).ConfigureAwait(false))
{
return(_result.Body);
}
}
public async Task <BrowseResponseApiModel> NodeBrowseAsync(string endpoint, BrowseRequestApiModel content)
{
var applications = await _twinServiceHandler.NodeBrowseAsync(endpoint, content).ConfigureAwait(false);
return(applications);
}
/// <summary>
/// Browse node references
/// </summary>
/// <remarks>
/// Browse a node on the specified endpoint. The endpoint must be activated and
/// connected and the module client and server must trust each other.
/// </remarks>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='endpointId'>
/// The identifier of the activated endpoint.
/// </param>
/// <param name='body'>
/// The browse request
/// </param>
public static BrowseResponseApiModel Browse(this IAzureOpcTwinClient operations, string endpointId, BrowseRequestApiModel body)
{
return(operations.BrowseAsync(endpointId, body).GetAwaiter().GetResult());
}
/// <summary>
/// Get tree
/// </summary>
/// <param name="endpointId"></param>
/// <param name="id"></param>
/// <param name="parentId"></param>
/// <param name="discovererId"></param>
/// <param name="direction"></param>
/// <returns>ListNode</returns>
public async Task <PagedResult <ListNode> > GetTreeAsync(string endpointId, string id,
List <string> parentId, string discovererId, BrowseDirection direction, int index,
CredentialModel credential = null)
{
var pageResult = new PagedResult <ListNode>();
var model = new BrowseRequestApiModel {
TargetNodesOnly = true,
ReadVariableValues = true
};
if (direction == BrowseDirection.Forward)
{
model.MaxReferencesToReturn = _MAX_REFERENCES;
model.NodeId = id;
if (id == string.Empty)
{
Path = new List <string>();
}
}
else
{
model.NodeId = parentId.ElementAt(index - 1);
}
model.Header = Elevate(new RequestHeaderApiModel(), credential);
try {
var browseData = await _twinService.NodeBrowseAsync(endpointId, model);
var continuationToken = browseData.ContinuationToken;
var references = browseData.References;
var browseDataNext = new BrowseNextResponseApiModel();
if (direction == BrowseDirection.Forward)
{
parentId.Add(browseData.Node.NodeId);
Path.Add(browseData.Node.DisplayName);
}
else
{
parentId.RemoveAt(parentId.Count - 1);
Path.RemoveRange(index, Path.Count - index);
}
do
{
if (references != null)
{
foreach (var nodeReference in references)
{
pageResult.Results.Add(new ListNode {
Id = nodeReference.Target.NodeId.ToString(),
NodeClass = nodeReference.Target.NodeClass ?? 0,
NodeName = nodeReference.Target.DisplayName.ToString(),
Children = (bool)nodeReference.Target.Children,
ParentIdList = parentId,
DiscovererId = discovererId,
AccessLevel = nodeReference.Target.AccessLevel ?? 0,
ParentName = browseData.Node.DisplayName,
DataType = nodeReference.Target.DataType,
Value = nodeReference.Target.Value?.ToString(),
Publishing = false,
PublishedItem = null
});
}
}
if (!string.IsNullOrEmpty(continuationToken))
{
bool?abort = null;
if (pageResult.Results.Count > 5)
{
// TODO: !!! Implement real paging - need to make ux responsive for large # tags !!!
abort = true;
}
var modelNext = new BrowseNextRequestApiModel {
ContinuationToken = continuationToken,
Abort = abort
};
browseDataNext = await _twinService.NodeBrowseNextAsync(endpointId, modelNext);
if (abort == true)
{
break;
}
references = browseDataNext.References;
continuationToken = browseDataNext.ContinuationToken;
}
else
{
browseDataNext.References = null;
}
} while (!string.IsNullOrEmpty(continuationToken) || browseDataNext.References != null);
}
catch (Exception e) {
// skip this node
_logger.Error($"Can not browse node '{id}'");
var errorMessage = string.Concat(e.Message, e.InnerException?.Message ?? "--", e?.StackTrace ?? "--");
_logger.Error(errorMessage);
string error = JToken.Parse(e.Message).ToString(Formatting.Indented);
if (error.Contains(StatusCodes.Status401Unauthorized.ToString()))
{
pageResult.Error = "Unauthorized access: Bad User Access Denied.";
}
else
{
pageResult.Error = error;
}
}
pageResult.PageSize = 10;
pageResult.RowCount = pageResult.Results.Count;
pageResult.PageCount = (int)Math.Ceiling((decimal)pageResult.RowCount / 10);
return(pageResult);
}
