public async Task <DeviceConfiguration> GetDeviceConfigurationAsync(string id, EntityHeader org, EntityHeader user) { var deviceConfiguration = await _deviceConfigRepo.GetDeviceConfigurationAsync(id); await AuthorizeAsync(deviceConfiguration, AuthorizeActions.Read, user, org); foreach (var prop in deviceConfiguration.Properties.OrderBy(prop => prop.Order)) { if (prop.FieldType.Value == DeviceAdmin.Models.ParameterTypes.State) { prop.StateSet.Value = await _deviceAdminManager.GetStateSetAsync(prop.StateSet.Id, org, user); } else if (prop.FieldType.Value == DeviceAdmin.Models.ParameterTypes.ValueWithUnit) { prop.UnitSet.Value = await _deviceAdminManager.GetAttributeUnitSetAsync(prop.UnitSet.Id, org, user); } } if (!EntityHeader.IsNullOrEmpty(deviceConfiguration.CustomStatusType)) { deviceConfiguration.CustomStatusType.Value = await _deviceAdminManager.GetStateSetAsync(deviceConfiguration.CustomStatusType.Id, org, user); } return(deviceConfiguration); }
public async Task <DetailResponse <UnitSet> > GetUnitSetAsync(String unitsetid) { var unitSet = await _deviceAdminManager.GetAttributeUnitSetAsync(unitsetid, OrgEntityHeader, UserEntityHeader); var response = DetailResponse <UnitSet> .Create(unitSet); return(response); }
public async Task <InvokeResult <DeviceMessageDefinition> > LoadFullDeviceMessageDefinitionAsync(string id, EntityHeader org, EntityHeader user) { DeviceMessageDefinition message = null; try { message = await _deviceMessageDefinitionRepo.GetDeviceMessageDefinitionAsync(id); } catch (RecordNotFoundException) { return(InvokeResult <DeviceMessageDefinition> .FromErrors(Resources.DeviceMessagingAdminErrorCodes.CouldNotLoadDeviceMessageDefinition.ToErrorMessage($"MessageId={id}"))); } var result = new InvokeResult <DeviceMessageDefinition>(); foreach (var field in message.Fields) { if (!EntityHeader.IsNullOrEmpty(field.UnitSet)) { try { field.UnitSet.Value = await _deviceAdminManager.GetAttributeUnitSetAsync(field.UnitSet.Id, org, user); } catch (RecordNotFoundException) { result.Errors.Add(DeviceMessagingAdminErrorCodes.CouldNotLoadUnitSet.ToErrorMessage($"MessageId={id},UnitSetId={field.UnitSet.Id}")); } } if (!EntityHeader.IsNullOrEmpty(field.StateSet)) { try { field.StateSet.Value = await _deviceAdminManager.GetStateSetAsync(field.StateSet.Id, org, user); } catch (RecordNotFoundException) { result.Errors.Add(DeviceMessagingAdminErrorCodes.CouldNotLoadStateSet.ToErrorMessage($"MessageId={id},StateSetId={field.StateSet.Id}")); } } } if (result.Successful) { return(InvokeResult <DeviceMessageDefinition> .Create(message)); } return(result); }
public async Task <VerificationResults> VerifyAsync(VerificationRequest <DeviceMessageDefinition> request, EntityHeader org, EntityHeader user) { var sw = new Stopwatch(); var verifier = request.Verifier as Verifier; var result = new VerificationResults(new EntityHeader() { Text = request.Configuration.Name, Id = request.Configuration.Id }, VerifierTypes.MessageParser); if (String.IsNullOrEmpty(verifier.Input) && String.IsNullOrEmpty(verifier.Topic) && String.IsNullOrEmpty(verifier.PathAndQueryString) && verifier.Headers.Count == 0) { result.ErrorMessages.Add(VerifierResources.Verifier_MissingInput); result.Success = false; await _resultRepo.AddResultAsync(result); return(result); } if (verifier.ExpectedOutputs == null || verifier.ExpectedOutputs.Count == 0) { result.ErrorMessages.Add(VerifierResources.Verifier_MissingInput); result.Success = false; await _resultRepo.AddResultAsync(result); return(result); } if (EntityHeader.IsNullOrEmpty(verifier.InputType)) { result.ErrorMessages.Add(VerifierResources.Verifier_MissingInputType); result.Success = false; await _resultRepo.AddResultAsync(result); return(result); } if (request.Iterations == 0) { result.ErrorMessages.Add(VerifierResources.Verifier_IterationCountZero); result.Success = false; await _resultRepo.AddResultAsync(result); return(result); } var start = DateTime.Now; result.DateStamp = start.ToJSONString(); result.Success = true; result.RequestedBy = user; /* TODO: Need to think this through we are using the same parser we are for instances, do we care about logging this? */ var logger = new VerifierLogger(null, null, null, null); foreach (var fld in request.Configuration.Fields) { if (fld.StorageType.Value == DeviceAdmin.Models.ParameterTypes.State) { fld.StateSet.Value = await _deviceAdminManager.GetStateSetAsync(fld.StateSet.Id, org, user); } else if (fld.StorageType.Value == DeviceAdmin.Models.ParameterTypes.ValueWithUnit) { fld.UnitSet.Value = await _deviceAdminManager.GetAttributeUnitSetAsync(fld.UnitSet.Id, org, user); } } var parser = _parserManager.GetMessageParser(request.Configuration, logger); sw.Start(); for (var idx = 0; idx < request.Iterations; ++idx) { var pem = new IoT.Runtime.Core.Models.PEM.PipelineExecutionMessage(); pem.PayloadType = verifier.InputType.Value == InputTypes.Text ? IoT.Runtime.Core.Models.PEM.MessagePayloadTypes.Text : IoT.Runtime.Core.Models.PEM.MessagePayloadTypes.Binary; if (pem.PayloadType == IoT.Runtime.Core.Models.PEM.MessagePayloadTypes.Binary) { pem.BinaryPayload = verifier.GetBinaryPayload(); if (pem.BinaryPayload == null || pem.BinaryPayload.Length == 0) { result.ErrorMessages.Add(VerifierResources.Verifier_MissingInput); result.Success = false; await _resultRepo.AddResultAsync(result); return(result); } } else { pem.TextPayload = verifier.Input; } foreach (var header in verifier.Headers) { pem.Envelope.Headers.Add(header.Name, header.Value); } pem.Envelope.Path = verifier.PathAndQueryString; pem.Envelope.Topic = verifier.Topic; var parseResult = parser.Parse(pem, request.Configuration); if (parseResult.Successful) { foreach (var item in verifier.ExpectedOutputs) { var expectedValue = item.Value; if (pem.Envelope.Values.ContainsKey(item.Key)) { var actualValue = pem.Envelope.Values[item.Key].Value; if (expectedValue == actualValue) { result.Results.Add(new VerificationResult() { Key = item.Key, Expected = item.Value, Actual = String.IsNullOrEmpty(actualValue) ? "-empty-" : actualValue, Success = true, }); } else { var verificationResult = new VerificationResult() { Key = item.Key, Expected = item.Value, Actual = String.IsNullOrEmpty(actualValue) ? "-empty-" : actualValue, Success = false, }; result.Results.Add(verificationResult); result.ErrorMessages.Add($"{VerifierResources.Verifier_Expected_NotMatch_Actual}. {VerifierResources.Verifier_Field}: {item.Key}, {VerifierResources.Verifier_Expected}={verificationResult.Expected}, {VerifierResources.Verifier_Actual}={verificationResult.Actual} "); result.Success = false; } } else { result.ErrorMessages.Add($"{VerifierResources.Verifier_ResultDoesNotContainKey}, {item.Key}"); result.Success = false; } } } else { result.Success = false; result.ErrorMessages.AddRange(parseResult.Errors.Select(err => err.Message + " " + err.Details)); } result.IterationsCompleted++; if (!result.Success) { idx = request.Iterations; result.ErrorMessages.Add($"{VerifierResources.Verifier_Aborted}; {VerifierResources.Verifier_IterationsCompleted} ({result.IterationsCompleted})"); } } sw.Stop(); result.ExecutionTimeMS = Math.Round(sw.Elapsed.TotalMilliseconds, 3); await _resultRepo.AddResultAsync(result); return(result); }