/// <summary> /// MethodCallAsync /// </summary> /// <param name="parameterValues"></param> /// <param name="nodeId"></param> /// <returns>Status</returns> public async Task <string> MethodCallAsync(MethodMetadataResponseApiModel parameters, string[] parameterValues, string endpointId, string nodeId, CredentialModel credential = null) { var argumentsList = new List <MethodCallArgumentApiModel>(); var model = new MethodCallRequestApiModel() { MethodId = nodeId, ObjectId = parameters.ObjectId }; model.Header = Elevate(new RequestHeaderApiModel(), credential); try { var count = 0; foreach (var item in parameters.InputArguments) { var argument = new MethodCallArgumentApiModel { Value = parameterValues[count] ?? string.Empty, DataType = item.Type.DataType }; argumentsList.Add(argument); count++; } model.Arguments = argumentsList; MethodCallResponse = await _twinService.NodeMethodCallAsync(endpointId, model); if (MethodCallResponse.ErrorInfo == null) { return(null); } else { if (MethodCallResponse.ErrorInfo.Diagnostics != null) { return(MethodCallResponse.ErrorInfo.Diagnostics.ToString()); } else { return(MethodCallResponse.ErrorInfo.ToString()); } } } catch (Exception e) { _logger.Error($"Can not get method parameter from 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); } }
/// <summary> /// Call /// </summary> /// <param name="request"></param> /// <returns></returns> public async Task <MethodCallResponseApiModel> MethodCallAsync( MethodCallRequestApiModel request) { if (request == null) { throw new ArgumentNullException(nameof(request)); } var result = await _nodes.NodeMethodCallAsync( _twin.Endpoint, request.ToServiceModel()); return(new MethodCallResponseApiModel(result)); }
public async Task <MethodCallResponseApiModel> CallMethodAsync( string endpointId, [FromBody][Required] MethodCallRequestApiModel request) { if (request == null) { throw new ArgumentNullException(nameof(request)); } // TODO: Permissions var callresult = await _nodes.NodeMethodCallAsync( endpointId, request.ToServiceModel()); return(callresult.ToApiModel()); }
/// <summary> /// MethodCallAsync /// </summary> /// <param name="parameterValues"></param> /// <param name="nodeId"></param> /// <returns>Status</returns> public async Task <string> MethodCallAsync(MethodMetadataResponseApiModel parameters, string[] parameterValues, string endpointId, string nodeId) { var argumentsList = new List <MethodCallArgumentApiModel>(); var model = new MethodCallRequestApiModel() { MethodId = nodeId, ObjectId = parameters.ObjectId }; try { var count = 0; foreach (var item in parameters.InputArguments) { var argument = new MethodCallArgumentApiModel { Value = parameterValues[count] ?? string.Empty, DataType = item.Type.DataType }; argumentsList.Add(argument); count++; } model.Arguments = argumentsList; MethodCallResponse = await _twinService.NodeMethodCallAsync(endpointId, model); if (MethodCallResponse.ErrorInfo == null) { return(null); } else { if (MethodCallResponse.ErrorInfo.Diagnostics != null) { return(MethodCallResponse.ErrorInfo.Diagnostics.ToString()); } else { return(MethodCallResponse.ErrorInfo.ToString()); } } } catch (Exception e) { Trace.TraceError("Can not get method parameter from node '{0}'", nodeId); var errorMessage = string.Concat(e.Message, e.InnerException?.Message ?? "--", e?.StackTrace ?? "--"); Trace.TraceError(errorMessage); return(errorMessage); } }
/// <summary> /// Convert back to service model /// </summary> /// <returns></returns> public static MethodCallRequestModel ToServiceModel( this MethodCallRequestApiModel model) { if (model == null) { return(null); } return(new MethodCallRequestModel { MethodId = model.MethodId, ObjectId = model.ObjectId, MethodBrowsePath = model.MethodBrowsePath, ObjectBrowsePath = model.ObjectBrowsePath, Arguments = model.Arguments? .Select(s => s.ToServiceModel()).ToList(), Header = model.Header.ToServiceModel() }); }
/// <inheritdoc/> public async Task <MethodCallResponseApiModel> NodeMethodCallAsync( string endpointId, MethodCallRequestApiModel 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/call/{endpointId}", _resourceId); request.SetContent(content); var response = await _httpClient.PostAsync(request, ct).ConfigureAwait(false); response.Validate(); return(response.GetContent <MethodCallResponseApiModel>()); }
/// <inheritdoc/> public async Task <MethodCallResponseApiModel> NodeMethodCallAsync( EndpointApiModel endpoint, MethodCallRequestApiModel 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, "MethodCall_V2", _serializer.SerializeToString(new { endpoint, request }), null, ct); return(_serializer.Deserialize <MethodCallResponseApiModel>(response)); }
public async Task <ActionResult> MethodCall(string jstreeNode, string parameterData, string parameterValues, Session session = null) { string[] delimiter = { "__$__" }; string[] jstreeNodeSplit = jstreeNode.Split(delimiter, 3, StringSplitOptions.None); string node; string parentNode = null; string endpointId = Session["EndpointId"].ToString(); if (jstreeNodeSplit.Length == 1) { node = jstreeNodeSplit[0]; parentNode = null; } else { node = jstreeNodeSplit[1]; parentNode = (jstreeNodeSplit[0].Replace(delimiter[0], "")).Replace("__", ""); } string actionResult = ""; List <MethodCallParameterData> originalData = JsonConvert.DeserializeObject <List <MethodCallParameterData> >(parameterData); List <Variant> values = JsonConvert.DeserializeObject <List <Variant> >(parameterValues); List <MethodCallArgumentApiModel> argumentsList = new List <MethodCallArgumentApiModel>(); try { MethodCallRequestApiModel model = new MethodCallRequestApiModel(); model.MethodId = node; model.ObjectId = originalData[0].ObjectId; if (originalData.Count > 1) { int count = 0; foreach (var item in originalData) { MethodCallArgumentApiModel argument = new MethodCallArgumentApiModel(); argument.Value = values[count].Value != null ? values[count].Value.ToString() : string.Empty; argument.DataType = item.Datatype; argumentsList.Add(argument); count++; } model.Arguments = argumentsList; } var data = await TwinService.NodeMethodCallAsync(endpointId, model); if (data.ErrorInfo != null) { actionResult = Strings.BrowserOpcMethodCallFailed + @"<br/><br/>" + Strings.BrowserOpcMethodStatusCode + ": " + data.ErrorInfo.StatusCode; if (data.ErrorInfo.Diagnostics != null) { actionResult += @"<br/><br/>" + Strings.BrowserOpcDataDiagnosticInfoLabel + ": " + data.ErrorInfo.Diagnostics; } } else { if (data.Results.Count == 0) { actionResult = Strings.BrowserOpcMethodCallSucceeded; } else { actionResult = Strings.BrowserOpcMethodCallSucceededWithResults + @"<br/><br/>"; for (int ii = 0; ii < data.Results.Count; ii++) { actionResult += data.Results[ii].Value + @"<br/>"; } } } return(Content(actionResult)); } catch (Exception exception) { return(Content(CreateOpcExceptionActionString(exception))); } }
/// <summary> /// Call a method /// </summary> /// <remarks> /// Invoke method node with specified input arguments. 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 method call request /// </param> /// <param name='cancellationToken'> /// The cancellation token. /// </param> public static async Task <MethodCallResponseApiModel> CallMethodAsync(this IAzureOpcTwinClient operations, string endpointId, MethodCallRequestApiModel body, CancellationToken cancellationToken = default(CancellationToken)) { using (var _result = await operations.CallMethodWithHttpMessagesAsync(endpointId, body, null, cancellationToken).ConfigureAwait(false)) { return(_result.Body); } }
/// <summary> /// Call a method /// </summary> /// <remarks> /// Invoke method node with specified input arguments. 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 method call request /// </param> public static MethodCallResponseApiModel CallMethod(this IAzureOpcTwinClient operations, string endpointId, MethodCallRequestApiModel body) { return(operations.CallMethodAsync(endpointId, body).GetAwaiter().GetResult()); }
/// <inheritdoc/> public Task <MethodCallResponseApiModel> NodeMethodCallAsync( string endpointId, MethodCallRequestApiModel content, CancellationToken ct) { return(Task.FromException <MethodCallResponseApiModel>(new NotImplementedException())); }
/// <summary> /// Call method on endpoint /// </summary> /// <param name="api"></param> /// <param name="endpointUrl"></param> /// <param name="request"></param> /// <param name="ct"></param> /// <returns></returns> public static Task <MethodCallResponseApiModel> NodeMethodCallAsync( this ITwinModuleApi api, string endpointUrl, MethodCallRequestApiModel request, CancellationToken ct = default) { return(api.NodeMethodCallAsync(NewEndpoint(endpointUrl), request, ct)); }
public MethodCallResponseApiModel NodeMethodCall(string endpoint, MethodCallRequestApiModel content) { Task <MethodCallResponseApiModel> t = Task.Run(() => _twinServiceHandler.NodeMethodCallAsync(endpoint, content)); return(t.Result); }
public async Task <MethodCallResponseApiModel> NodeMethodCallAsync(string endpoint, MethodCallRequestApiModel content) { var applications = await _twinServiceHandler.NodeMethodCallAsync(endpoint, content).ConfigureAwait(false); return(applications); }