/// <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 is null)
{
throw new ArgumentNullException(nameof(request.Value));
}
var response = await _methodClient.CallMethodAsync(_deviceId, _moduleId,
"ValueWrite_V2", _serializer.SerializeToString(new {
endpoint,
request
}), null, ct);
return(_serializer.Deserialize <ValueWriteResponseApiModel>(response));
}
/// <summary>
/// WriteValueAsync
/// </summary>
/// <param name="endpointId"></param>
/// <param name="nodeId"></param>
/// <param name="value"></param>
/// <returns>Status</returns>
public async Task <string> WriteValueAsync(string endpointId, string nodeId, string value)
{
var model = new ValueWriteRequestApiModel()
{
NodeId = nodeId,
Value = value
};
try {
var response = await _twinService.NodeValueWriteAsync(endpointId, model);
if (response.ErrorInfo == null)
{
return(string.Format("value successfully written to node '{0}'", nodeId));
}
else
{
if (response.ErrorInfo.Diagnostics != null)
{
return(response.ErrorInfo.Diagnostics.ToString());
}
else
{
return(response.ErrorInfo.ToString());
}
}
}
catch (Exception e) {
Trace.TraceError("Can not write value of node '{0}'", nodeId);
var errorMessage = string.Concat(e.Message, e.InnerException?.Message ?? "--", e?.StackTrace ?? "--");
Trace.TraceError(errorMessage);
return(errorMessage);
}
}
public async Task <ValueWriteResponseApiModel> WriteValueAsync(
string endpointId, [FromBody][Required] ValueWriteRequestApiModel request)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
var writeResult = await _nodes.NodeValueWriteAsync(
endpointId, request.ToServiceModel());
return(writeResult.ToApiModel());
}
/// <summary>
/// Write
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public async Task <ValueWriteResponseApiModel> ValueWriteAsync(
ValueWriteRequestApiModel request)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
var result = await _nodes.NodeValueWriteAsync(
_twin.Endpoint, request.ToServiceModel());
return(new ValueWriteResponseApiModel(result));
}
/// <summary>
/// Convert back to service model
/// </summary>
/// <returns></returns>
public static ValueWriteRequestModel ToServiceModel(
this ValueWriteRequestApiModel model)
{
if (model == null)
{
return(null);
}
return(new ValueWriteRequestModel {
NodeId = model.NodeId,
BrowsePath = model.BrowsePath,
DataType = model.DataType,
IndexRange = model.IndexRange,
Value = model.Value,
Header = model.Header.ToServiceModel()
});
}
/// <summary>
/// WriteValueAsync
/// </summary>
/// <param name="endpointId"></param>
/// <param name="nodeId"></param>
/// <param name="value"></param>
/// <returns>Status</returns>
public async Task <string> WriteValueAsync(string endpointId, string nodeId, string value, CredentialModel credential = null)
{
var model = new ValueWriteRequestApiModel()
{
NodeId = nodeId,
Value = value
};
model.Header = Elevate(new RequestHeaderApiModel(), credential);
try {
var response = await _twinService.NodeValueWriteAsync(endpointId, model);
if (response.ErrorInfo == null)
{
return(string.Format("value successfully written to node '{0}'", nodeId));
}
else
{
if (response.ErrorInfo.Diagnostics != null)
{
return(response.ErrorInfo.Diagnostics.ToString());
}
else
{
return(response.ErrorInfo.ToString());
}
}
}
catch (Exception e) {
_logger.Error($"Can not write 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 <ActionResult> VariableWriteUpdate(string jstreeNode, string newValue)
{
string[] delimiter = { "__$__" };
string[] jstreeNodeSplit = jstreeNode.Split(delimiter, 3, StringSplitOptions.None);
string node;
string endpointId = Session["EndpointId"].ToString();
if (jstreeNodeSplit.Length == 1)
{
node = jstreeNodeSplit[0];
}
else
{
node = jstreeNodeSplit[1];
}
try
{
ValueWriteRequestApiModel model = new ValueWriteRequestApiModel();
model.NodeId = node;
model.Value = newValue;
var data = await TwinService.WriteNodeValueAsync(endpointId, model);
if (data.ErrorInfo == null)
{
return(Content(Strings.WriteSuccesfully));
}
else
{
return(Content(data.ErrorInfo.ErrorMessage));
}
}
catch (Exception exception)
{
return(Content(CreateOpcExceptionActionString(exception)));
}
}
/// <inheritdoc/>
public async Task <ValueWriteResponseApiModel> NodeValueWriteAsync(string endpointId,
ValueWriteRequestApiModel content, CancellationToken ct)
{
if (string.IsNullOrEmpty(endpointId))
{
throw new ArgumentNullException(nameof(endpointId));
}
if (content == null)
{
throw new ArgumentNullException(nameof(content));
}
if (content.Value == null)
{
throw new ArgumentNullException(nameof(content.Value));
}
var request = _httpClient.NewRequest($"{_serviceUri}/v2/write/{endpointId}",
_resourceId);
request.SetContent(content);
var response = await _httpClient.PostAsync(request, ct).ConfigureAwait(false);
response.Validate();
return(response.GetContent <ValueWriteResponseApiModel>());
}
/// <summary>
/// Write variable value
/// </summary>
/// <remarks>
/// Write 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 write value request
/// </param>
/// <param name='cancellationToken'>
/// The cancellation token.
/// </param>
public static async Task <ValueWriteResponseApiModel> WriteValueAsync(this IAzureOpcTwinClient operations, string endpointId, ValueWriteRequestApiModel body, CancellationToken cancellationToken = default(CancellationToken))
{
using (var _result = await operations.WriteValueWithHttpMessagesAsync(endpointId, body, null, cancellationToken).ConfigureAwait(false))
{
return(_result.Body);
}
}
/// <summary>
/// Write variable value
/// </summary>
/// <remarks>
/// Write 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 write value request
/// </param>
public static ValueWriteResponseApiModel WriteValue(this IAzureOpcTwinClient operations, string endpointId, ValueWriteRequestApiModel body)
{
return(operations.WriteValueAsync(endpointId, body).GetAwaiter().GetResult());
}
/// <inheritdoc/>
public Task <ValueWriteResponseApiModel> NodeValueWriteAsync(string endpointId,
ValueWriteRequestApiModel content, CancellationToken ct)
{
return(Task.FromException <ValueWriteResponseApiModel>(new NotImplementedException()));
}
/// <summary>
/// Write 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 <ValueWriteResponseApiModel> NodeValueWriteAsync(
this ITwinModuleApi api, string endpointUrl, ValueWriteRequestApiModel request,
CancellationToken ct = default)
{
return(api.NodeValueWriteAsync(NewEndpoint(endpointUrl), request, ct));
}
public ValueWriteResponseApiModel WriteNodeValue(string endpoint, ValueWriteRequestApiModel content)
{
Task <ValueWriteResponseApiModel> t = Task.Run(() => _twinServiceHandler.NodeValueWriteAsync(endpoint, content));
return(t.Result);
}
public async Task <ValueWriteResponseApiModel> WriteNodeValueAsync(string endpoint, ValueWriteRequestApiModel content)
{
var applications = await _twinServiceHandler.NodeValueWriteAsync(endpoint, content).ConfigureAwait(false);
return(applications);
}
