public async Task ImportObservations(ImportObservationsMessage message, StatisticsDbContext context)
{
var import = await _dataImportService.GetImport(message.Id);
_logger.LogInformation($"Importing Observations for {import.File.Filename} batchNo {message.BatchNo}");
if (import.Status.IsFinished())
{
_logger.LogInformation($"Import for {import.File.Filename} already finished with state " +
$"{import.Status} - ignoring Observations in file {message.ObservationsFilePath}");
return;
}
if (import.Status == CANCELLING)
{
_logger.LogInformation($"Import for {import.File.Filename} is " +
$"{import.Status} - ignoring Observations in file {message.ObservationsFilePath} " +
"and marking import as CANCELLED");
await _dataImportService.UpdateStatus(message.Id, CANCELLED, 100);
return;
}
var subject = await context.Subject.FindAsync(import.SubjectId);
var datafileStream = await _blobStorageService.StreamBlob(PrivateReleaseFiles, message.ObservationsFilePath);
var dataFileTable = DataTableUtils.CreateFromStream(datafileStream);
var metaFileStream = await _blobStorageService.StreamBlob(PrivateReleaseFiles, import.MetaFile.Path());
var metaFileTable = DataTableUtils.CreateFromStream(metaFileStream);
await context.Database.CreateExecutionStrategy().Execute(async() =>
{
await using var transaction = await context.Database.BeginTransactionAsync();
await _importerService.ImportObservations(
import,
dataFileTable.Columns,
dataFileTable.Rows,
subject,
_importerService.GetMeta(metaFileTable, subject, context),
message.BatchNo,
context
);
await transaction.CommitAsync();
await context.Database.CloseConnectionAsync();
});
if (import.NumBatches > 1)
{
await _blobStorageService.DeleteBlob(PrivateReleaseFiles, message.ObservationsFilePath);
}
await CheckComplete(message, context);
}
public async Task ImportObservations(ImportObservationsMessage message, StatisticsDbContext context)
{
var releaseId = message.ReleaseId;
var status = await _importStatusService.GetImportStatus(releaseId, message.DataFileName);
if (status.IsFinished())
{
_logger.LogInformation($"Import for {message.DataFileName} already finished with state " +
$"{status.Status} - ignoring Observations in file {message.ObservationsFilePath}");
return;
}
if (status.Status == CANCELLING)
{
_logger.LogInformation($"Import for {message.DataFileName} is CANCELLING " +
$"{status.Status} - ignoring Observations in file {message.ObservationsFilePath} " +
$"and marking import as CANCELLED");
await _importStatusService.UpdateStatus(releaseId, message.DataFileName, CANCELLED, 100);
return;
}
var subjectData = await _fileStorageService.GetSubjectData(message.ReleaseId, message.ObservationsFilePath);
var releaseSubject = GetReleaseSubjectLink(message.ReleaseId, message.SubjectId, context);
await using var datafileStream = await _fileStorageService.StreamBlob(subjectData.DataBlob);
var dataFileTable = DataTableUtils.CreateFromStream(datafileStream);
await using var metaFileStream = await _fileStorageService.StreamBlob(subjectData.MetaBlob);
var metaFileTable = DataTableUtils.CreateFromStream(metaFileStream);
await context.Database.CreateExecutionStrategy().Execute(async() =>
{
await using var transaction = await context.Database.BeginTransactionAsync();
await _importerService.ImportObservations(
dataFileTable.Columns,
dataFileTable.Rows,
releaseSubject.Subject,
_importerService.GetMeta(metaFileTable, releaseSubject.Subject, context),
message.BatchNo,
message.RowsPerBatch,
context
);
await transaction.CommitAsync();
await context.Database.CloseConnectionAsync();
});
if (message.NumBatches > 1)
{
await _fileStorageService.DeleteBlobByPath(message.ObservationsFilePath);
}
await CheckComplete(releaseId, message, context);
}
