public async Task <DetailResponse <DeviceType> > GetDeviceType(String id)
{
var deviceType = await _deviceTypeManager.GetDeviceTypeAsync(id, OrgEntityHeader, UserEntityHeader);
return(DetailResponse <DeviceType> .Create(deviceType));
}
public async Task <InvokeResult> PopulateDeviceConfigToDeviceAsync(Device device, EntityHeader instanceEH, EntityHeader org, EntityHeader user)
{
var result = new InvokeResult();
device.DeviceType.Value = await _deviceTypeManager.GetDeviceTypeAsync(device.DeviceType.Id, org, user);
var deviceConfig = await GetDeviceConfigurationAsync(device.DeviceConfiguration.Id, org, user);
if (deviceConfig == null)
{
result.AddSystemError($"Could Not Load Device Configuration with Device Configuration {device.DeviceConfiguration.Text}, Id={device.DeviceConfiguration.Id}.");
return(result);
}
device.DeviceLabel = deviceConfig.DeviceLabel;
device.DeviceIdLabel = deviceConfig.DeviceIdLabel;
device.DeviceNameLabel = deviceConfig.DeviceNameLabel;
device.DeviceTypeLabel = deviceConfig.DeviceTypeLabel;
if (deviceConfig.Properties != null)
{
device.PropertiesMetaData = new List <DeviceAdmin.Models.CustomField>();
foreach (var prop in deviceConfig.Properties.OrderBy(prop => prop.Order))
{
device.PropertiesMetaData.Add(prop);
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(instanceEH))
{
result.AddSystemError($"Device does not have a valid device configuration Device Id={device.Id}");
return(result);
}
var instance = await _deploymentInstanceManager.GetInstanceAsync(instanceEH.Id, org, user);
if (instance != null && instance.Status.Value == DeploymentInstanceStates.Running)
{
if (instance.InputCommandSSL)
{
device.DeviceURI = $"https://{instance.DnsHostName}:{instance.InputCommandPort}/devices/{device.Id}";
}
else
{
device.DeviceURI = $"http://{instance.DnsHostName}:{instance.InputCommandPort}/devices/{device.Id}";
}
var workflowKeys = new List <string>();
var endpoints = new List <InputCommandEndPoint>();
foreach (var route in deviceConfig.Routes)
{
foreach (var module in route.PipelineModules)
{
if (module.ModuleType.Value == Pipeline.Admin.Models.PipelineModuleType.Workflow)
{
var wfLoadResult = await _deviceAdminManager.LoadFullDeviceWorkflowAsync(module.Module.Id, org, user);
if (wfLoadResult.Successful && !workflowKeys.Contains(wfLoadResult.Result.Key))
{
workflowKeys.Add(wfLoadResult.Result.Key);
if (wfLoadResult.Result.Attributes != null)
{
foreach (var attribute in wfLoadResult.Result.Attributes)
{
if (device.AttributeMetaData == null)
{
device.AttributeMetaData = new List <DeviceAdmin.Models.Attribute>();
}
if (!device.AttributeMetaData.Where(attr => attr.Key == attribute.Key).Any())
{
device.AttributeMetaData.Add(attribute);
}
}
}
if (wfLoadResult.Result.StateMachines != null)
{
if (device.StateMachineMetaData == null)
{
device.StateMachineMetaData = new List <StateMachine>();
}
foreach (var stateMachine in wfLoadResult.Result.StateMachines)
{
if (!device.StateMachineMetaData.Where(attr => attr.Key == stateMachine.Key).Any())
{
device.StateMachineMetaData.Add(stateMachine);
}
}
}
if (wfLoadResult.Result.InputCommands != null)
{
foreach (var inputCommand in wfLoadResult.Result.InputCommands)
{
var protocol = instance.InputCommandSSL ? "https://" : "http://";
var endPoint = new InputCommandEndPoint
{
EndPoint = $"{protocol}{instance.DnsHostName}:{instance.InputCommandPort}/{deviceConfig.Key}/{route.Key}/{wfLoadResult.Result.Key}/{inputCommand.Key}/{device.DeviceId}",
InputCommand = inputCommand
};
foreach (var param in inputCommand.Parameters)
{
if (param.ParameterType.Value == ParameterTypes.State)
{
param.StateSet.Value = await _deviceAdminManager.GetStateSetAsync(param.StateSet.Id, org, user);
}
else if (param.ParameterType.Value == ParameterTypes.ValueWithUnit)
{
param.UnitSet.Value = await _deviceAdminManager.GetAttributeUnitSetAsync(param.UnitSet.Id, org, user);
}
}
if (!endpoints.Where(end => end.EndPoint == endPoint.EndPoint).Any())
{
endpoints.Add(endPoint);
}
}
}
}
else
{
result.Concat(result);
}
}
}
}
device.InputCommandEndPoints = endpoints;
}
else
{
device.InputCommandEndPoints = new List <InputCommandEndPoint>();
device.AttributeMetaData = new List <DeviceAdmin.Models.Attribute>();
device.StateMachineMetaData = new List <StateMachine>();
}
return(result);
}
