/// <summary>
/// GetEndpointListAsync
/// </summary>
/// <param name="discovererId"></param>
/// <returns>EndpointInfoApiModel</returns>
public async Task <PagedResult <EndpointInfoApiModel> > GetEndpointListAsync(
string discovererId, string applicationId, string supervisorId)
{
var pageResult = new PagedResult <EndpointInfoApiModel>();
try {
var model = new EndpointRegistrationQueryApiModel();
model.DiscovererId = discovererId == PathAll ? null : discovererId;
model.ApplicationId = applicationId == PathAll ? null : applicationId;
model.SupervisorId = supervisorId == PathAll ? null : supervisorId;
var endpoints = await _registryService.QueryAllEndpointsAsync(model);
foreach (var endpoint in endpoints)
{
pageResult.Results.Add(endpoint);
}
}
catch (Exception e) {
_logger.Warning("Can not get endpoint list");
var errorMessage = string.Concat(e.Message, e.InnerException?.Message ?? "--", e?.StackTrace ?? "--");
_logger.Warning(errorMessage);
pageResult.Error = e.Message;
}
pageResult.PageSize = 10;
pageResult.RowCount = pageResult.Results.Count;
pageResult.PageCount = (int)Math.Ceiling((decimal)pageResult.RowCount / 10);
return(pageResult);
}
/// <summary>
/// GetEndpointListAsync
/// </summary>
/// <param name="discovererId"></param>
/// <param name="previousPage"></param>
/// <returns>EndpointInfoApiModel</returns>
public async Task <PagedResult <EndpointInfo> > GetEndpointListAsync(
string discovererId, string applicationId, string supervisorId, PagedResult <EndpointInfo> previousPage = null, bool getNextPage = false)
{
var pageResult = new PagedResult <EndpointInfo>();
try {
var endpoints = new EndpointInfoListApiModel();
var query = new EndpointRegistrationQueryApiModel {
DiscovererId = discovererId == PathAll ? null : discovererId,
ApplicationId = applicationId == PathAll ? null : applicationId,
SupervisorId = supervisorId == PathAll ? null : supervisorId,
IncludeNotSeenSince = true
};
if (getNextPage && string.IsNullOrEmpty(previousPage?.ContinuationToken))
{
endpoints = await _registryService.QueryEndpointsAsync(query, null, _commonHelper.PageLength);
}
else
{
endpoints = await _registryService.ListEndpointsAsync(previousPage.ContinuationToken, null, _commonHelper.PageLength);
}
foreach (var ep in endpoints.Items)
{
// Get non cached version of endpoint
var endpoint = await _registryService.GetEndpointAsync(ep.Registration.Id);
pageResult.Results.Add(new EndpointInfo {
EndpointModel = endpoint
});
}
if (previousPage != null)
{
previousPage.Results.AddRange(pageResult.Results);
pageResult.Results = previousPage.Results;
}
pageResult.ContinuationToken = endpoints.ContinuationToken;
}
catch (UnauthorizedAccessException) {
pageResult.Error = "Unauthorized access: Bad User Access Denied.";
}
catch (Exception e) {
var message = "Cannot get endpoint list";
_logger.Warning(e, message);
pageResult.Error = message;
}
return(pageResult);
}
/// <summary>
/// Find endpoints
/// </summary>
/// <param name="service"></param>
/// <param name="query"></param>
/// <param name="onlyServerState"></param>
/// <param name="ct"></param>
/// <returns></returns>
public static async Task <IEnumerable <EndpointInfoApiModel> > QueryAllEndpointsAsync(
this IRegistryServiceApi service, EndpointRegistrationQueryApiModel query,
bool?onlyServerState = null, CancellationToken ct = default)
{
var registrations = new List <EndpointInfoApiModel>();
var result = await service.QueryEndpointsAsync(query, onlyServerState, null, ct);
registrations.AddRange(result.Items);
while (result.ContinuationToken != null)
{
result = await service.ListEndpointsAsync(result.ContinuationToken,
onlyServerState, null, ct);
registrations.AddRange(result.Items);
}
return(registrations);
}
public async Task <EndpointInfoListApiModel> GetFilteredListOfEndpointsAsync(
[FromQuery][Required] EndpointRegistrationQueryApiModel query,
[FromQuery] bool?onlyServerState,
[FromQuery] int?pageSize)
{
if (query == null)
{
throw new ArgumentNullException(nameof(query));
}
if (Request.Headers.ContainsKey(HttpHeader.MaxItemCount))
{
pageSize = int.Parse(Request.Headers[HttpHeader.MaxItemCount]
.FirstOrDefault());
}
var result = await _endpoints.QueryEndpointsAsync(query.ToServiceModel(),
onlyServerState ?? false, pageSize);
return(result.ToApiModel());
}
/// <inheritdoc/>
public async Task <EndpointInfoListApiModel> QueryEndpointsAsync(EndpointRegistrationQueryApiModel query,
bool?onlyServerState, int?pageSize)
{
var uri = new UriBuilder($"{_serviceUri}/v2/endpoints/query");
if (onlyServerState ?? false)
{
uri.Query = "onlyServerState=true";
}
var request = _httpClient.NewRequest(uri.Uri, _resourceId);
if (pageSize != null)
{
request.AddHeader(kPageSizeHeaderKey, pageSize.ToString());
}
request.SetContent(query);
var response = await _httpClient.PostAsync(request).ConfigureAwait(false);
response.Validate();
return(response.GetContent <EndpointInfoListApiModel>());
}
/// <summary>
/// Convert back to service model
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public static EndpointRegistrationQueryModel ToServiceModel(
this EndpointRegistrationQueryApiModel model)
{
if (model == null)
{
return(null);
}
return(new EndpointRegistrationQueryModel {
Url = model.Url,
Connected = model.Connected,
Activated = model.Activated,
EndpointState = (IIoT.OpcUa.Registry.Models.EndpointConnectivityState?)model.EndpointState,
Certificate = model.Certificate,
SecurityPolicy = model.SecurityPolicy,
SecurityMode = (IIoT.OpcUa.Core.Models.SecurityMode?)model.SecurityMode,
ApplicationId = model.ApplicationId,
DiscovererId = model.DiscovererId,
SiteOrGatewayId = model.SiteOrGatewayId,
SupervisorId = model.SupervisorId,
IncludeNotSeenSince = model.IncludeNotSeenSince
});
}
/// <inheritdoc/>
public async Task <EndpointInfoListApiModel> QueryEndpointsAsync(
EndpointRegistrationQueryApiModel query, bool?onlyServerState, int?pageSize,
CancellationToken ct)
{
var uri = new UriBuilder($"{_serviceUri}/v2/endpoints/query");
if (onlyServerState ?? false)
{
uri.Query = "onlyServerState=true";
}
var request = _httpClient.NewRequest(uri.Uri, Resource.Platform);
if (pageSize != null)
{
request.AddHeader(HttpHeader.MaxItemCount, pageSize.ToString());
}
_serializer.SerializeToRequest(request, query);
var response = await _httpClient.PostAsync(request, ct).ConfigureAwait(false);
response.Validate();
return(_serializer.DeserializeResponse <EndpointInfoListApiModel>(response));
}
