public async Task InsertAsync(AggregatedSensorData aggregatedSensorData)
{
var table = _client.GetTableClient(_tableName);
await table.CreateIfNotExistsAsync();
await table.UpsertEntityAsync(SensorDataMapper.Map(aggregatedSensorData));
}
public static TableEntity Map(AggregatedSensorData sensorData)
{
return(new TableEntity(sensorData.SensorBoxId, Guid.NewGuid().ToString())
{
[nameof(AggregatedSensorData.SensorType)] = sensorData.SensorType.ToString("G"),
[nameof(AggregatedSensorData.AggregationType)] = sensorData.AggregationType.ToString("G"),
Timestamp = sensorData.CreatedAt,
[nameof(AggregatedSensorData.Value)] = sensorData.Value
});
}
public async Task Run(
[QueueTrigger("aggregated-sensor-data")] AggregatedSensorData aggregatedSensorData,
[Queue("validated-sensor-data")] IAsyncCollector <AggregatedSensorData> output,
CancellationToken cancellationToken)
{
await _validationService.ValidateSensorDataAsync(aggregatedSensorData);
await output.AddAsync(aggregatedSensorData, cancellationToken);
await output.FlushAsync(cancellationToken);
}
private async Task ValidateAggregatedData(AggregatedSensorData aggregatedSensorData, Sensor sensor)
{
if (!AggregationTypesToValidate.Contains(aggregatedSensorData.AggregationType))
{
return;
}
if (aggregatedSensorData.Value < sensor.Min || aggregatedSensorData.Value > sensor.Max)
{
await CreateSensorAlarm(sensor, AlarmStatus.InvalidData);
}
}
public async Task ValidateSensorDataAsync(AggregatedSensorData aggregatedSensorData)
{
_logger.LogDebug($"Incoming aggregated sensor data: sensor id {aggregatedSensorData.SensorBoxId}");
var sensor = await _sensorRepository.GetByBoxIdAndTypeAsync(aggregatedSensorData.SensorBoxId, aggregatedSensorData.SensorType);
if (sensor == null)
{
_logger.LogError($"No sensor found for id {aggregatedSensorData.SensorBoxId}");
return;
}
await CheckSensorAndUpdateLastSeen(sensor);
await ValidateAggregatedData(aggregatedSensorData, sensor);
}
public async Task InsertAsyncTest()
{
var sensorDataRepository = A.Fake <ISensorDataRepository>();
var service = new SensorDataService(sensorDataRepository);
var aggregatedSensorData = new AggregatedSensorData
{
SensorBoxId = "test",
SensorType = SensorType.Temperature,
AggregationType = AggregationType.Mean,
CreatedAt = DateTimeOffset.UtcNow,
Value = 1
};
await service.InsertAsync(aggregatedSensorData);
A.CallTo(() => sensorDataRepository.InsertAsync(aggregatedSensorData)).MustHaveHappened();
}
public async Task WritesAggregatedData()
{
var writeService = A.Fake <ISensorDataService>();
var function = new SensorDataWriteFunction(writeService, A.Fake <ILogger <SensorDataWriteFunction> >());
var aggregatedSensorData = new AggregatedSensorData
{
SensorBoxId = "test",
SensorType = SensorType.Temperature,
AggregationType = AggregationType.Mean,
CreatedAt = DateTimeOffset.UtcNow,
Value = 1
};
await function.Run(aggregatedSensorData);
A.CallTo(() => writeService.InsertAsync(aggregatedSensorData)).MustHaveHappened();
}
public async Task Run([QueueTrigger("validated-sensor-data")] AggregatedSensorData aggregatedSensorData)
{
await _sensorDataService.InsertAsync(aggregatedSensorData);
}
public Task InsertAsync(AggregatedSensorData aggregatedSensorData)
{
return(_sensorDataRepository.InsertAsync(aggregatedSensorData));
}
