public async Task Verifier_Message_SimpleTest_Invalid()
{
var msgDefinition = new DeviceMessageDefinition();
var verifier = new Verifier
{
ShouldSucceed = true,
VerifierType = EntityHeader <VerifierTypes> .Create(VerifierTypes.MessageFieldParser),
InputType = EntityHeader <InputTypes> .Create(InputTypes.Binary),
Input = "03 32 05"
};
verifier.ExpectedOutputs.Add(new ExpectedValue()
{
Key = "key1", Value = "8"
});
verifier.ExpectedOutputs.Add(new ExpectedValue()
{
Key = "key2", Value = "value1"
});
var parserMgr = GetParserManager(new KeyValuePair <string, string>("key1", "5"), new KeyValuePair <string, string>("key2", "value1"));
var verifiers = new MessageParserVerifierRuntime(parserMgr, _resultRepo.Object, _deviceAdminManager.Object);
var result = await verifiers.VerifyAsync(new IoT.Runtime.Core.Models.Verifiers.VerificationRequest <DeviceMessageDefinition>()
{
Verifier = verifier,
Configuration = msgDefinition
}, null, null);
WriteResults(result);
Assert.IsFalse(result.Success);
Assert.AreEqual(1, result.IterationsCompleted);
}
public async Task <InvokeResult> AddDeviceMessageDefinitionAsync(DeviceMessageDefinition deviceMessageConfiguration, EntityHeader org, EntityHeader user)
{
await AuthorizeAsync(deviceMessageConfiguration, AuthorizeActions.Create, user, org);
ValidationCheck(deviceMessageConfiguration, Actions.Create);
await _deviceMessageDefinitionRepo.AddDeviceMessageDefinitionAsync(deviceMessageConfiguration);
return(InvokeResult.Success);
}
public static void AddByte(this DeviceMessageDefinition msgDefinition, string key)
{
msgDefinition.Fields.Add(new DeviceMessageDefinitionField()
{
Key = "key1",
SearchLocation = EntityHeader <SearchLocations> .Create(SearchLocations.Body), BinaryOffset = 2,
ParsedBinaryFieldType = EntityHeader <ParseBinaryValueType> .Create(ParseBinaryValueType.Byte)
});
}
public DeviceMessageDefinition GetDeviceMessage(string name = "msg1", string key = "msg1")
{
var msg = new DeviceMessageDefinition();
msg.Name = name;
msg.Key = key;
msg.Fields.Add(GetDeviceMessageField(name, key));
return(msg);
}
public InvokeResult Parse(PipelineExecutionMessage pem, DeviceMessageDefinition definition)
{
foreach (var kvp in KVPs)
{
pem.Envelope.Values.Add(kvp.Key, new MessageValue()
{
Value = kvp.Value
});
}
return(InvokeResult.Success);
}
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 void Init()
{
_messageDefinition = GetDeviceMessage();
_deviceWorkflow = GetWorkflow();
_moduleConfig = new RouteModuleConfig
{
PrimaryOutput = new RouteConnection()
};
RefreshMapping();
_outputTranslatorConfig = new OutputTranslatorConfiguration()
{
Key = "key1"
};
}
public async Task <DeviceConfiguration> AddDeviceConfigAsync(string name, string key, SentinelConfiguration sentinal,
InputTranslatorConfiguration input, DeviceWorkflow workflow, OutputTranslatorConfiguration output,
DeviceMessageDefinition msg, EntityHeader org, EntityHeader user, DateTime createTimestamp)
{
if (sentinal == null)
{
throw new ArgumentNullException(nameof(sentinal));
}
if (input == null)
{
throw new ArgumentNullException(nameof(input));
}
if (workflow == null)
{
throw new ArgumentNullException(nameof(workflow));
}
if (output == null)
{
throw new ArgumentNullException(nameof(output));
}
if (msg == null)
{
throw new ArgumentNullException(nameof(msg));
}
await _storageUtils.DeleteIfExistsAsync <DeviceConfiguration>(key, org);
var deviceConfig = new DeviceConfiguration()
{
Id = Guid.NewGuid().ToId(),
Name = name,
Key = key,
};
AddOwnedProperties(deviceConfig, org);
AddAuditProperties(deviceConfig, createTimestamp, org, user);
var route = Route.Create();
route.Name = "Motion Message Handler";
route.Key = EXAMPLE_MOTION_KEY;
AddId(route);
AddAuditProperties(route, createTimestamp, org, user);
route.MessageDefinition = new EntityHeader <DeviceMessageDefinition>()
{
Id = msg.Id,
Text = msg.Name
};
var sentinalConfig = route.PipelineModules.Where(pm => pm.ModuleType.Value == PipelineModuleType.Sentinel).First();
sentinalConfig.Name = sentinal.Name;
sentinalConfig.Key = sentinal.Key;
sentinalConfig.Module = new EntityHeader <DeviceAdmin.Interfaces.IPipelineModuleConfiguration>()
{
Id = sentinal.Id,
Text = sentinal.Name
};
var inputTranslator = route.PipelineModules.Where(pm => pm.ModuleType.Value == PipelineModuleType.InputTranslator).First();
inputTranslator.Name = input.Name;
inputTranslator.Key = input.Key;
inputTranslator.Module = new EntityHeader <DeviceAdmin.Interfaces.IPipelineModuleConfiguration>()
{
Id = input.Id,
Text = input.Name
};
inputTranslator.PrimaryOutput.Mappings.Add(new KeyValuePair <string, object>("motion", "motionstatus"));
var wf = route.PipelineModules.Where(pm => pm.ModuleType.Value == PipelineModuleType.Workflow).First();
wf.Key = workflow.Key;
wf.Name = workflow.Name;
wf.Module = new EntityHeader <DeviceAdmin.Interfaces.IPipelineModuleConfiguration>()
{
Id = workflow.Id,
Text = workflow.Name
};
var outputTranslator = route.PipelineModules.Where(pm => pm.ModuleType.Value == PipelineModuleType.OutputTranslator).First();
outputTranslator.Name = output.Name;
outputTranslator.Key = output.Key;
outputTranslator.Module = new EntityHeader <DeviceAdmin.Interfaces.IPipelineModuleConfiguration>()
{
Id = output.Id,
Text = output.Name
};
deviceConfig.Routes.Add(route);
await _deviceCfgMgr.AddDeviceConfigurationAsync(deviceConfig, org, user);
return(deviceConfig);
}
public async Task <DeviceMessageDefinition> AddDefaultMessage(string name, string key, EntityHeader org, EntityHeader user, DateTime createTimeStamp)
{
await _storageUtils.DeleteIfExistsAsync <DeviceMessageDefinition>(key, org);
await _storageUtils.DeleteIfExistsAsync <Verifier>("exmplmotgparser", org);
var msgDefinition = new DeviceMessageDefinition()
{
Id = Guid.NewGuid().ToId(),
Name = name,
Key = key,
MessageId = "motion",
MessageDirection = EntityHeader <MessageDirections> .Create(MessageDirections.Incoming),
ContentType = EntityHeader <MessageContentTypes> .Create(MessageContentTypes.JSON)
};
msgDefinition.Fields.Add(new DeviceMessageDefinitionField()
{
ContentType = EntityHeader <MessageContentTypes> .Create(MessageContentTypes.JSON),
FieldIndex = 0,
Name = "Motion Status",
SearchLocation = EntityHeader <SearchLocations> .Create(SearchLocations.Body),
Id = Guid.NewGuid().ToId(),
JsonPath = "motion",
Key = "motion",
StorageType = EntityHeader <ParameterTypes> .Create(ParameterTypes.String),
ParsedStringFieldType = EntityHeader <ParseStringValueType> .Create(ParseStringValueType.String),
});
msgDefinition.SampleMessages.Add(new SampleMessage()
{
Id = Guid.NewGuid().ToId(),
Name = "Sample Motion Message",
Key = "smplmotionmsg",
Payload = "{'motion':'on'}",
PathAndQueryString = "/api/motion/dev001",
Description = "Sample message that would be sent by a motion detector.",
Topic = String.Empty,
});
AddOwnedProperties(msgDefinition, org);
AddAuditProperties(msgDefinition, createTimeStamp, org, user);
await _deviceMsgMgr.AddDeviceMessageDefinitionAsync(msgDefinition, org, user);
await _storageUtils.DeleteIfExistsAsync <Verifier>("examplemotionmsgparser", org);
var verifier = new Verifier()
{
Component = new EntityHeader()
{
Id = msgDefinition.Id,
Text = msgDefinition.Name
},
ExpectedOutputs = new System.Collections.ObjectModel.ObservableCollection <ExpectedValue>()
{
new ExpectedValue()
{
Key = "motion", Value = "on"
},
},
InputType = EntityHeader <InputTypes> .Create(InputTypes.Text),
Name = "Simple Message Verifier",
Key = "exmplmotgparser",
Description = "Validates that a Sample Motion Message has the proper field parsers",
Input = "{'motion':'on'}",
PathAndQueryString = "/smplmot001/device001",
ShouldSucceed = true,
VerifierType = EntityHeader <VerifierTypes> .Create(VerifierTypes.MessageParser)
};
AddId(verifier);
AddOwnedProperties(verifier, org);
AddAuditProperties(verifier, createTimeStamp, org, user);
await _verifierMgr.AddVerifierAsync(verifier, org, user);
return(msgDefinition);
}
public void InputTranslatorToWorkflowValidation(ValidationResult result, DeviceMessageDefinition message, DeviceWorkflow workflow)
{
if (PrimaryOutput != null)
{
if (PrimaryOutput.Mappings == null)
{
PrimaryOutput.Mappings = new List <KeyValuePair <string, object> >();
}
foreach (var mapping in PrimaryOutput.Mappings)
{
var mapResult = new ValidationResult();
var fieldKey = mapping.Key;
if (mapping.Value == null)
{
mapResult.AddUserError($"Missing Input Key for mapping on work flow {workflow.Name} for input mapping.");
}
else
{
var inputKey = mapping.Value.ToString();
if (String.IsNullOrEmpty(inputKey))
{
mapResult.AddUserError($"Missing Input Key for mapping on work flow {workflow.Name} for input mapping.");
}
if (String.IsNullOrEmpty(fieldKey))
{
mapResult.AddUserError($"Missing Message Field Key for mapping on work flow {workflow.Name} for input mapping.");
}
if (mapResult.Successful)
{
var input = workflow.Inputs.Where(inp => inp.Key == inputKey).FirstOrDefault();
var field = message.Fields.Where(fld => fld.Key == fieldKey).FirstOrDefault();
if (input == null)
{
mapResult.AddUserError($"Could not find input {inputKey} on workflow {workflow.Name}");
}
if (field == null)
{
mapResult.AddUserError($"Could not find field {fieldKey} on message {message.Name} on workflow {workflow.Name} for input mapping.");
}
if (field != null && input != null)
{
if (EntityHeader.IsNullOrEmpty(field.StorageType))
{
mapResult.AddUserError($"On field {field.Name} for message {message.Name} storage type is empty.");
}
else if (EntityHeader.IsNullOrEmpty(input.InputType))
{
mapResult.AddUserError($"On input {field.Name} for workflow {workflow.Name} storage type is empty.");
}
else
{
if (field.StorageType.Id != input.InputType.Id)
{
mapResult.AddUserError($"On Mapping for field {field.Name} for message {message.Name} and input {input.Name} type mismatch, {field.StorageType.Text} can not be mapped to {input.InputType.Text}.");
}
else if (field.StorageType.Value == ParameterTypes.State)
{
if (EntityHeader.IsNullOrEmpty(field.StateSet))
{
result.AddUserError($"State Set Not provided on Message {message.Name}, Field {field.Name}.");
}
else if (EntityHeader.IsNullOrEmpty(input.StateSet))
{
result.AddUserError($"State Set Not provided on Input {input.Name}, for work flow {workflow.Name}");
}
else if (field.StateSet.Id != input.StateSet.Id)
{
result.AddUserError($"State Set are different on mapping between Message Field {message.Name}/{field.Name} and input {input.Name} on workflow {workflow.Name} (Field={field.StateSet.Text}, Input={input.StateSet.Text}).");
}
}
else if (field.StorageType.Value == ParameterTypes.ValueWithUnit)
{
if (EntityHeader.IsNullOrEmpty(field.UnitSet))
{
result.AddUserError($"Unit Set Not provided on Message {message.Name}, Field {field.Name}.");
}
else if (EntityHeader.IsNullOrEmpty(input.UnitSet))
{
result.AddUserError($"Unit Set Not provided on Input {input.Name}, for work flow {workflow.Name}");
}
else if (field.UnitSet.Id != input.UnitSet.Id)
{
result.AddUserError($"Units Set are different on mapping between message {message.Name}/{field.Name} and input {input.Name} on workflow {workflow.Name} (Field={field.UnitSet.Text}, Input={input.UnitSet.Text}).");
}
}
}
}
}
result.Concat(mapResult);
}
}
}
}
public Task <InvokeResult> UpdateDeviceMessageConfigurationAsync([FromBody] DeviceMessageDefinition deviceMessageConfiguration)
{
SetUpdatedProperties(deviceMessageConfiguration);
return(_deviceConfigManager.UpdateDeviceMessageDefinitionAsync(deviceMessageConfiguration, OrgEntityHeader, UserEntityHeader));
}
public Task <InvokeResult> AddDeviceMessageConfigurationAsync([FromBody] DeviceMessageDefinition deviceMessageConfiguration)
{
return(_deviceConfigManager.AddDeviceMessageDefinitionAsync(deviceMessageConfiguration, OrgEntityHeader, UserEntityHeader));
}
protected DeviceMessageDefinition GetValidMessage(MessageContentTypes contenttype)
{
var msg = new DeviceMessageDefinition()
{
Name = "msg1234",
MessageId = "msg1234",
Key = "msg1234",
MessageDirection = EntityHeader <MessageDirections> .Create(MessageDirections.Incoming),
Id = Guid.NewGuid().ToId(),
CreationDate = DateTime.Now.ToJSONString(),
CreatedBy = new Core.Models.EntityHeader()
{
Id = Guid.NewGuid().ToId(), Text = "user name"
}
};
msg.LastUpdatedDate = msg.CreationDate;
msg.LastUpdatedBy = msg.CreatedBy;
switch (contenttype)
{
case MessageContentTypes.Binary:
msg.ContentType = new Core.Models.EntityHeader <MessageContentTypes>()
{
Id = DeviceMessageDefinition.ContentType_Binary, Text = "Binary"
};
msg.StringParsingStrategy = new Core.Models.EntityHeader <StringParsingStrategy>()
{
Id = DeviceMessageDefinition.StringParsingStrategy_NullTerminated, Text = "Null"
};
msg.Endian = new Core.Models.EntityHeader <EndianTypes>()
{
Id = DeviceMessageDefinition.Endian_BigEndian, Text = "Little Endian"
};
msg.BinaryParsingStrategy = new Core.Models.EntityHeader <BinaryParsingStrategy>()
{
Id = DeviceMessageDefinition.BinaryParsingStrategy_Absolute, Text = "AbsolutePosition"
};
msg.StringLengthByteCount = 2;
break;
/* case MessageContentTypes.Custom:
* msg.ContentType = new Core.Models.EntityHeader<MessageContentTypes>() { Id = DeviceMessageDefinition.ContentType_Custom, Text = "Custom" };
* msg.Script = "function() {do something, for now javascript validate}";
* break;*/;
case MessageContentTypes.Delimited:
msg.ContentType = new Core.Models.EntityHeader <MessageContentTypes>()
{
Id = DeviceMessageDefinition.ContentType_Delimited, Text = "Delimited"
};
msg.Delimiter = ",";
msg.QuotedText = false;
break;
case MessageContentTypes.JSON:
msg.ContentType = new Core.Models.EntityHeader <MessageContentTypes>()
{
Id = DeviceMessageDefinition.ContentType_Json,
Text = "JSON"
};
break;
case MessageContentTypes.StringRegEx:
msg.ContentType = new Core.Models.EntityHeader <MessageContentTypes>()
{
Id = DeviceMessageDefinition.ContentType_StringRegEx, Text = "StringRegEx"
};
msg.RegEx = "^parse_me_if_i_was_valid_reg_ex$";
break;
case MessageContentTypes.StringPosition:
msg.ContentType = new Core.Models.EntityHeader <MessageContentTypes>()
{
Id = DeviceMessageDefinition.ContentType_StringPosition, Text = "StringPosition"
};
break;
case MessageContentTypes.XML:
msg.ContentType = new Core.Models.EntityHeader <MessageContentTypes>()
{
Id = DeviceMessageDefinition.ContentType_Xml, Text = "XML"
};
break;
}
return(msg);
}
public void Init()
{
_messageDefinition = GetDeviceMessage();
_deviceWorkflow = GetWorkflow();
}
