/// <inheritdoc/>
public async Task <ValueReadResponseApiModel> NodeValueReadAsync(string endpointId,
ValueReadRequestApiModel content, CancellationToken ct)
{
if (string.IsNullOrEmpty(endpointId))
{
throw new ArgumentNullException(nameof(endpointId));
}
if (content == null)
{
throw new ArgumentNullException(nameof(content));
}
if (string.IsNullOrEmpty(content.NodeId))
{
throw new ArgumentNullException(nameof(content.NodeId));
}
var path = new UriBuilder($"{_serviceUri}/v2/read/{endpointId}")
{
Query = $"nodeId={content.NodeId.UrlEncode()}"
};
var request = _httpClient.NewRequest(path.ToString());
_serializer.SetAcceptHeaders(request);
var response = await _httpClient.GetAsync(request, ct).ConfigureAwait(false);
response.Validate();
return(_serializer.DeserializeResponse <ValueReadResponseApiModel>(response));
}
/// <summary>
/// ReadValueAsync
/// </summary>
/// <param name="endpointId"></param>
/// <param name="nodeId"></param>
/// <returns>Read value</returns>
public async Task <string> ReadValueAsync(string endpointId, string nodeId)
{
var model = new ValueReadRequestApiModel()
{
NodeId = nodeId
};
try {
var value = await _twinService.NodeValueReadAsync(endpointId, model);
if (value.ErrorInfo == null)
{
return(value.Value?.ToString());
}
else
{
return(value.ErrorInfo.ToString());
}
}
catch (Exception e) {
Trace.TraceError("Can not read value of node '{0}'", nodeId);
var errorMessage = string.Concat(e.Message, e.InnerException?.Message ?? "--", e?.StackTrace ?? "--");
Trace.TraceError(errorMessage);
return(errorMessage);
}
}
/// <summary>
/// ReadValueAsync
/// </summary>
/// <param name="endpointId"></param>
/// <param name="nodeId"></param>
/// <returns>Read value</returns>
public async Task <string> ReadValueAsync(string endpointId, string nodeId, CredentialModel credential = null)
{
var model = new ValueReadRequestApiModel()
{
NodeId = nodeId
};
model.Header = Elevate(new RequestHeaderApiModel(), credential);
try {
var value = await _twinService.NodeValueReadAsync(endpointId, model);
if (value.ErrorInfo == null)
{
return(value.Value?.ToJson()?.TrimQuotes());
}
else
{
return(value.ErrorInfo.ToString());
}
}
catch (UnauthorizedAccessException) {
return("Unauthorized access: Bad User Access Denied.");
}
catch (Exception e) {
_logger.Error(e, "Can not read value of node '{nodeId}'", nodeId);
var errorMessage = string.Concat(e.Message, e.InnerException?.Message ?? "--", e?.StackTrace ?? "--");
return(errorMessage);
}
}
public async Task <ValueReadResponseApiModel> ReadValueAsync(
string endpointId, [FromBody][Required] ValueReadRequestApiModel request)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
var readresult = await _nodes.NodeValueReadAsync(
endpointId, request.ToServiceModel());
return(new ValueReadResponseApiModel(readresult));
}
/// <summary>
/// Read
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public async Task <ValueReadResponseApiModel> ValueReadAsync(
ValueReadRequestApiModel request)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
var result = await _nodes.NodeValueReadAsync(
_twin.Endpoint, request.ToServiceModel());
return(new ValueReadResponseApiModel(result));
}
/// <summary>
/// Convert back to service model
/// </summary>
/// <returns></returns>
public static ValueReadRequestModel ToServiceModel(
this ValueReadRequestApiModel model)
{
if (model == null)
{
return(null);
}
return(new ValueReadRequestModel {
NodeId = model.NodeId,
BrowsePath = model.BrowsePath,
IndexRange = model.IndexRange,
Header = model.Header.ToServiceModel()
});
}
public async Task <ActionResult> VariableRead(string jstreeNode)
{
string[] delimiter = { "__$__" };
string[] jstreeNodeSplit = jstreeNode.Split(delimiter, 3, StringSplitOptions.None);
string node;
string actionResult = string.Empty;
string endpointId = Session["EndpointId"].ToString();
if (jstreeNodeSplit.Length == 1)
{
node = jstreeNodeSplit[0];
}
else
{
node = jstreeNodeSplit[1];
}
try
{
ValueReadRequestApiModel model = new ValueReadRequestApiModel();
model.NodeId = node;
var data = await TwinService.ReadNodeValueAsync(endpointId, model);
string value = "";
if (data.Value != null)
{
if (data.Value.ToString().Length > 40)
{
value = data.Value.ToString().Substring(0, 40);
value += "...";
}
else
{
value = data.Value.ToString();
}
}
// We return the HTML formatted content, which is shown in the context panel.
actionResult = Strings.BrowserOpcDataValueLabel + ": " + value + @"<br/>" +
(data.ErrorInfo == null ? "" : (Strings.BrowserOpcDataStatusLabel + ": " + data.ErrorInfo.StatusCode + @"<br/>")) +
Strings.BrowserOpcDataSourceTimestampLabel + ": " + data.SourceTimestamp + @"<br/>" +
Strings.BrowserOpcDataServerTimestampLabel + ": " + data.ServerTimestamp;
return(Content(actionResult));
}
catch (Exception exception)
{
return(Content(CreateOpcExceptionActionString(exception)));
}
}
public async Task <ValueReadResponseApiModel> GetValueAsync(
string endpointId, [FromQuery][Required] string nodeId)
{
if (string.IsNullOrEmpty(nodeId))
{
throw new ArgumentNullException(nameof(nodeId));
}
var request = new ValueReadRequestApiModel {
NodeId = nodeId
};
var readresult = await _nodes.NodeValueReadAsync(
endpointId, request.ToServiceModel());
return(new ValueReadResponseApiModel(readresult));
}
/// <summary>
/// Read
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public async Task <ValueReadResponseApiModel> ValueReadAsync(
ValueReadRequestApiModel request)
{
kValueReadAsync.Inc();
ValueReadResponseApiModel model;
using (kValueReadHistAsync.NewTimer()) {
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
var result = await _nodes.NodeValueReadAsync(
await _twin.GetEndpointAsync(), request.ToServiceModel());
model = result.ToApiModel();
}
return(model);
}
/// <summary>
/// PublishedAsync
/// </summary>
/// <param name="endpointId"></param>
/// <returns>PublishedNode</returns>
public async Task <PagedResult <ListNode> > PublishedAsync(string endpointId, bool readValues, CredentialModel credential = null)
{
var pageResult = new PagedResult <ListNode>();
var model = new ValueReadRequestApiModel();
try {
var continuationToken = string.Empty;
do
{
var result = await _publisherService.NodePublishListAsync(endpointId, continuationToken);
continuationToken = result.ContinuationToken;
if (result.Items != null)
{
foreach (var item in result.Items)
{
model.NodeId = item.NodeId;
model.Header = Elevate(new RequestHeaderApiModel(), credential);
var readResponse = readValues ? await _twinService.NodeValueReadAsync(endpointId, model) : null;
pageResult.Results.Add(new ListNode {
PublishedItem = item,
Value = readResponse?.Value?.ToJson()?.TrimQuotes(),
DataType = readResponse?.DataType
});
}
}
} while (!string.IsNullOrEmpty(continuationToken));
}
catch (UnauthorizedAccessException) {
pageResult.Error = "Unauthorized access: Bad User Access Denied.";
}
catch (Exception e) {
var message = $"Cannot get published nodes for endpointId'{endpointId}'";
_logger.Error(e, message);
pageResult.Error = message;
}
pageResult.PageSize = _commonHelper.PageLength;
pageResult.RowCount = pageResult.Results.Count;
pageResult.PageCount = (int)Math.Ceiling((decimal)pageResult.RowCount / pageResult.PageSize);
return(pageResult);
}
public async Task <ActionResult> VariableWriteFetch(string jstreeNode)
{
string[] delimiter = { "__$__" };
string[] jstreeNodeSplit = jstreeNode.Split(delimiter, 3, StringSplitOptions.None);
string node;
string actionResult = string.Empty;
string endpointId = Session["EndpointId"].ToString();
if (jstreeNodeSplit.Length == 1)
{
node = jstreeNodeSplit[0];
}
else
{
node = jstreeNodeSplit[1];
}
try
{
ValueReadRequestApiModel model = new ValueReadRequestApiModel();
model.NodeId = node;
var data = await TwinService.ReadNodeValueAsync(endpointId, model);
if (data.Value != null)
{
if (data.Value.ToString().Length > 30)
{
actionResult = data.Value.ToString().Substring(0, 30);
actionResult += "...";
}
else
{
actionResult = data.Value.ToString();
}
}
return(Content(actionResult));
}
catch (Exception exception)
{
return(Content(CreateOpcExceptionActionString(exception)));
}
}
/// <inheritdoc/>
public async Task <ValueReadResponseApiModel> NodeValueReadAsync(string endpointId,
ValueReadRequestApiModel content, CancellationToken ct)
{
if (string.IsNullOrEmpty(endpointId))
{
throw new ArgumentNullException(nameof(endpointId));
}
if (content == null)
{
throw new ArgumentNullException(nameof(content));
}
var request = _httpClient.NewRequest($"{_serviceUri}/v2/read/{endpointId}",
_resourceId);
request.SetContent(content);
var response = await _httpClient.PostAsync(request, ct).ConfigureAwait(false);
response.Validate();
return(response.GetContent <ValueReadResponseApiModel>());
}
/// <inheritdoc/>
public async Task <ValueReadResponseApiModel> NodeValueReadAsync(EndpointApiModel endpoint,
ValueReadRequestApiModel 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,
"ValueRead_V2", _serializer.SerializeToString(new {
endpoint,
request
}), null, ct);
return(_serializer.Deserialize <ValueReadResponseApiModel>(response));
}
/// <summary>
/// ReadValueAsync
/// </summary>
/// <param name="endpointId"></param>
/// <param name="nodeId"></param>
/// <returns>Read value</returns>
public async Task <string> ReadValueAsync(string endpointId, string nodeId, CredentialModel credential = null)
{
var model = new ValueReadRequestApiModel()
{
NodeId = nodeId
};
model.Header = Elevate(new RequestHeaderApiModel(), credential);
try {
var value = await _twinService.NodeValueReadAsync(endpointId, model);
if (value.ErrorInfo == null)
{
return(value.Value?.ToString());
}
else
{
return(value.ErrorInfo.ToString());
}
}
catch (Exception e) {
_logger.Error($"Can not read value of node '{nodeId}'");
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()))
{
errorMessage = "Unauthorized access: Bad User Access Denied.";
}
else
{
errorMessage = error;
}
return(errorMessage);
}
}
public async Task <ValueReadResponseApiModel> ReadNodeValueAsync(string endpoint, ValueReadRequestApiModel content)
{
var applications = await _twinServiceHandler.NodeValueReadAsync(endpoint, content).ConfigureAwait(false);
return(applications);
}
public ValueReadResponseApiModel ReadNodeValue(string endpoint, ValueReadRequestApiModel content)
{
Task <ValueReadResponseApiModel> t = Task.Run(() => _twinServiceHandler.NodeValueReadAsync(endpoint, content));
return(t.Result);
}
/// <summary>
/// Read node value on endpoint
/// </summary>
/// <param name="api"></param>
/// <param name="endpointUrl"></param>
/// <param name="request"></param>
/// <param name="ct"></param>
/// <returns></returns>
public static Task <ValueReadResponseApiModel> NodeValueReadAsync(
this ITwinModuleApi api, string endpointUrl, ValueReadRequestApiModel request,
CancellationToken ct = default)
{
return(api.NodeValueReadAsync(NewEndpoint(endpointUrl), request, ct));
}
/// <summary>
/// Read variable value
/// </summary>
/// <remarks>
/// Read a variable node's value. 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 read value request
/// </param>
public static ValueReadResponseApiModel ReadValue(this IAzureOpcTwinClient operations, string endpointId, ValueReadRequestApiModel body)
{
return(operations.ReadValueAsync(endpointId, body).GetAwaiter().GetResult());
}
/// <summary>
/// Read variable value
/// </summary>
/// <remarks>
/// Read a variable node's value. 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 read value request
/// </param>
/// <param name='cancellationToken'>
/// The cancellation token.
/// </param>
public static async Task <ValueReadResponseApiModel> ReadValueAsync(this IAzureOpcTwinClient operations, string endpointId, ValueReadRequestApiModel body, CancellationToken cancellationToken = default(CancellationToken))
{
using (var _result = await operations.ReadValueWithHttpMessagesAsync(endpointId, body, null, cancellationToken).ConfigureAwait(false))
{
return(_result.Body);
}
}
