public async Task<List<InitialDeviceConfig>> GetDeviceListAsync()
{
return await Task.Run(() =>
{
_logger.LogInfo("********** READING DEVICES FROM APP.CONFIG ********** ");
if (_devices.Any())
return _devices;
StringCollection deviceList = Properties.Settings.Default.DeviceList;
foreach (string device in deviceList)
{
string[] deviceConfigElements = device.Split(',');
var deviceConfig = new InitialDeviceConfig();
if (deviceConfigElements.Length > 1)
{
deviceConfig.DeviceId = deviceConfigElements[0];
deviceConfig.HostName = _hostName;
deviceConfig.Key = deviceConfigElements[1];
_devices.Add(deviceConfig);
}
}
return _devices;
});
}
public IDevice CreateDevice(ILogger logger, ITransportFactory transportFactory,
ITelemetryFactory telemetryFactory, IConfigurationProvider configurationProvider, InitialDeviceConfig config)
{
var device = new DeviceBase(logger, transportFactory, telemetryFactory, configurationProvider);
device.Init(config);
return device;
}
protected virtual void InitDeviceInfo(InitialDeviceConfig config)
{
dynamic initialDevice = SampleDeviceFactory.GetSampleSimulatedDevice(config.DeviceId, config.Key);
DeviceProperties = DeviceSchemaHelper.GetDeviceProperties(initialDevice);
Commands = CommandSchemaHelper.GetSupportedCommands(initialDevice);
HostName = config.HostName;
PrimaryAuthKey = config.Key;
}
public void Init(InitialDeviceConfig config)
{
InitDeviceInfo(config);
Transport = TransportFactory.CreateTransport(this);
_telemetryController = TelemetryFactory.PopulateDeviceWithTelemetryEvents(this);
InitCommandProcessors();
}
protected virtual void InitDeviceInfo(InitialDeviceConfig config)
{
DeviceModel initialDevice = SampleDeviceFactory.GetSampleSimulatedDevice(config.DeviceId, config.Key);
DeviceProperties = initialDevice.DeviceProperties;
Commands = initialDevice.Commands ?? new List<Command>();
Telemetry = initialDevice.Telemetry ?? new List<Common.Models.Telemetry>();
HostName = config.HostName;
PrimaryAuthKey = config.Key;
}
public async Task AddOrUpdateDeviceAsync(InitialDeviceConfig deviceConfig)
{
var deviceEnity = new DeviceListEntity()
{
DeviceId = deviceConfig.DeviceId,
HostName = deviceConfig.HostName,
Key = deviceConfig.Key
};
var operation = TableOperation.InsertOrReplace(deviceEnity);
await _azureTableStorageClient.ExecuteAsync(operation);
}
public async Task AddOrUpdateDeviceAsync(InitialDeviceConfig deviceConfig)
{
var devicesTable = await AzureTableStorageHelper.GetTableAsync(_storageConnectionString, _deviceTableName);
var deviceEnity = new DeviceListEntity()
{
DeviceId = deviceConfig.DeviceId,
HostName = deviceConfig.HostName,
Key = deviceConfig.Key
};
var operation = TableOperation.InsertOrReplace(deviceEnity);
await devicesTable.ExecuteAsync(operation);
}
public void GetDeviceInfoTests()
{
var config = new InitialDeviceConfig();
config.HostName = "HostName";
config.DeviceId = "test";
config.Key = "key";
deviceBase.Init(config);
var device = deviceBase.GetDeviceInfo();
Assert.Equal(device.DeviceProperties.DeviceID, "test");
Assert.Null(device.SystemProperties);
}
public CoolerDeviceTests()
{
_fixture = new Fixture();
_initConfig = _fixture.Create<InitialDeviceConfig>();
var loggerMock = new Mock<ILogger>();
_transportMock = new Mock<ITransport>();
var transportFactoryMock = new Mock<ITransportFactory>();
transportFactoryMock.Setup(x => x.CreateTransport(It.IsNotNull<IDevice>())).Returns(_transportMock.Object);
var telemetryFactoryMock = new Mock<ITelemetryFactory>();
var configurationProviderMock = new Mock<IConfigurationProvider>();
var coolerDeviceFactory = new CoolerDeviceFactory();
_coolerDevice = coolerDeviceFactory.CreateDevice(loggerMock.Object, transportFactoryMock.Object,
telemetryFactoryMock.Object, configurationProviderMock.Object, _initConfig) as CoolerDevice;
loggerMock.Setup(x => x.LogInfo(It.IsAny<string>(), It.IsAny<object[]>()));
}
public void InitTests()
{
var config = new InitialDeviceConfig();
config.HostName = "HostName";
config.DeviceId = "test";
config.Key = "key";
deviceBase.Init(config);
Assert.Equal(deviceBase.DeviceID, "test");
Assert.Equal(deviceBase.HostName, "HostName");
Assert.Equal(deviceBase.PrimaryAuthKey, "key");
Assert.NotNull(deviceBase.DeviceProperties);
Assert.NotNull(deviceBase.Commands);
Assert.NotNull(deviceBase.Telemetry);
}
public async Task<List<InitialDeviceConfig>> GetDeviceListAsync()
{
List<InitialDeviceConfig> devices = new List<InitialDeviceConfig>();
var devicesTable = await AzureTableStorageHelper.GetTableAsync(_storageConnectionString, _deviceTableName);
TableQuery<DeviceListEntity> query = new TableQuery<DeviceListEntity>();
foreach (var device in devicesTable.ExecuteQuery(query))
{
var deviceConfig = new InitialDeviceConfig()
{
HostName = device.HostName,
DeviceId = device.DeviceId,
Key = device.Key
};
devices.Add(deviceConfig);
}
return devices;
}
public async Task<List<InitialDeviceConfig>> GetDeviceListAsync()
{
List<InitialDeviceConfig> devices = new List<InitialDeviceConfig>();
TableQuery<DeviceListEntity> query = new TableQuery<DeviceListEntity>();
var devicesResult = await _azureTableStorageClient.ExecuteQueryAsync(query);
foreach (var device in devicesResult)
{
var deviceConfig = new InitialDeviceConfig()
{
HostName = device.HostName,
DeviceId = device.DeviceId,
Key = device.Key
};
devices.Add(deviceConfig);
}
return devices;
}
public Task AddOrUpdateDeviceAsync(InitialDeviceConfig deviceConfig)
{
return Task.Run(() =>
{
if (!_devices.Any())
return;
var device = _devices.FirstOrDefault(x => x.DeviceId == deviceConfig.DeviceId);
if (device != null)
{
device.Key = deviceConfig.Key;
device.HostName = deviceConfig.HostName;
}
else
{
_devices.Add(deviceConfig);
}
});
}
public async void AddOrUpdateDeviceAsyncTest()
{
//add device
InitialDeviceConfig device = new InitialDeviceConfig()
{
DeviceId = this.testDeviceId,
HostName = this.testHostName,
Key = this.testKey
};
//should fail before GetDeviceListAsync initializes the known list of devices
await this.repo.AddOrUpdateDeviceAsync(device);
//get all devices
Assert.Null(await this.repo.GetDeviceAsync(device.DeviceId));
List<InitialDeviceConfig> devices = await this.repo.GetDeviceListAsync();
Assert.False(devices.Contains(device));
//repeat and it should be added
await this.repo.AddOrUpdateDeviceAsync(device);
var returnedDevice = await this.repo.GetDeviceAsync(device.DeviceId);
Assert.NotNull(returnedDevice);
Assert.Equal(returnedDevice.Key, this.testKey);
Assert.Equal(returnedDevice.HostName, this.testHostName);
//repeat and it should be updated
string changedKey = "changedKey";
device.Key = changedKey;
string changedHostName = "changedHostName";
device.HostName = changedHostName;
await this.repo.AddOrUpdateDeviceAsync(device);
var changedDevice = await this.repo.GetDeviceAsync(device.DeviceId);
Assert.NotNull(changedDevice);
Assert.Equal(changedDevice.Key, changedKey);
Assert.Equal(changedDevice.HostName, changedHostName);
}
public async void RemoveDeviceAsyncTest()
{
InitialDeviceConfig device = new InitialDeviceConfig()
{
DeviceId = this.testDeviceId,
HostName = this.testHostName,
Key = this.testKey
};
Assert.False(await this.repo.RemoveDeviceAsync(device.DeviceId));
await this.repo.GetDeviceListAsync();
await this.repo.AddOrUpdateDeviceAsync(device);
Assert.True(await this.repo.RemoveDeviceAsync(device.DeviceId));
Assert.False(await this.repo.RemoveDeviceAsync(device.DeviceId));
}
