protected void Add(ImportDataChunk <T> importDataChunk)
{
var insert = new Insert(UserConnection).Into(ImportSessionChunkSchemaName);
AddValuesToInsertQuery(insert, importDataChunk);
insert.Execute();
}
private void AddValuesToInsertQuery(Insert insert, ImportDataChunk <T> importDataChunk)
{
insert.Set("Id", Column.Parameter(importDataChunk.ChunkId));
insert.Set("CreatedOn", Column.Parameter(DateTime.Now));
insert.Set("Type", Column.Parameter((int)importDataChunk.Type));
insert.Set("State", Column.Parameter((int)importDataChunk.State));
insert.Set("Data", Column.Parameter(GetSerialize(importDataChunk.Data)));
insert.Set("ImportParametersId", Column.Parameter(importDataChunk.ImportSessionId));
}
/// <inheritdoc />
public bool Update(ImportDataChunk <T> importData)
{
var update = new Update(UserConnection, "ImportSessionChunk").
Set("State", Column.Parameter((int)importData.State)).
Set("Data", Column.Parameter(GetSerialize(importData.Data))).
Where("ImportParametersId").IsEqual(Column.Parameter(importData.ImportSessionId)).
And("Id").IsEqual(Column.Parameter(importData.ChunkId)).
And("Type").IsEqual(Column.Parameter((int)importData.Type)) as Update;
return(update.Execute() > 0);
}
public ImportDataChunk <LookupChunkData> CreateChunk(ImportDataChunk <EntityChunkData> chunk)
{
var processor = new LookupValuesToProcess(_userConnection);
foreach (var entityMemento in chunk.Data.Entities)
{
var entity = ImportEntity.CreateFromMemento(entityMemento);
processor.Add(entity, _lookupColumns);
}
var newLookupChunk = CreateChunk(processor.SaveState());
return(newLookupChunk);
}
private void ProcessChunks(ImportParameters importParameters,
ImportDataChunk <EntityChunkData> entityChunk)
{
if (entityChunk.State == ImportChunkState.Processed)
{
return;
}
IFileImportEntitiesChunkProcessor chunkProcessor = CreateChunkProcessor();
SubscribeChunkProcessorEvents(chunkProcessor);
ProcessChunk(chunkProcessor, importParameters, entityChunk);
UnsubscribeChunkProcessorEvents(chunkProcessor);
}
private ImportParameters PrepareImportParameters(ImportParameters importParameters,
ImportDataChunk <EntityChunkData> chunk)
{
var processedRowIndexes = new HashSet <uint>();
if (chunk.State == ImportChunkState.InProcess)
{
var processedRowResult = _importEntitiesChunksDataProvider.GetProcessedRows(chunk.ChunkId);
chunk.Data.SuccessProcessedEntityCount = processedRowResult.Count(i => i.Success == true);
chunk.Data.ProcessedWithErrorEntityCount = processedRowResult.Count() - chunk.Data.SuccessProcessedEntityCount;
_successProcessedRowsCount += (uint)chunk.Data.SuccessProcessedEntityCount;
_processedWithErrorRowsCount += (uint)chunk.Data.ProcessedWithErrorEntityCount;
processedRowIndexes.AddRange(processedRowResult.Select(i => (uint)i.RowIndex));
}
var chunkEntities = chunk.Data.Entities
.Where(e => !processedRowIndexes.Contains(e.RowIndex))
.Select(RestoreImportEntity).ToList();
ImportParameters newImportParameters = importParameters.Clone();
newImportParameters.ChunkId = chunk.ChunkId;
newImportParameters.SetEntities(chunkEntities);
return(newImportParameters);
}
private void SaveProcessedChunk(ImportDataChunk <EntityChunkData> chunk, ImportChunkState chunkState)
{
chunk.State = chunkState;
ImportEntitiesChunksDataProvider.Update(chunk);
}
private void ProcessChunk(IFileImportEntitiesChunkProcessor chunkProcessor, ImportParameters importParameters, ImportDataChunk <EntityChunkData> chunk)
{
EventHandler <ImportEntitySavedEventArgs> successImportEntitySavedHadler = (o, arg) => {
chunk.Data.SuccessProcessedEntityCount++;
_importEntitiesChunksDataProvider.SaveProcessedRow(chunk.ChunkId, (int)arg.RowIndex);
};
chunkProcessor.ImportEntitySaved += successImportEntitySavedHadler;
EventHandler <ImportEntitySaveErrorEventArgs> importEntitySavedWithErrorHandler = (o, arg) => {
chunk.Data.ProcessedWithErrorEntityCount++;
_importEntitiesChunksDataProvider.SaveProcessedRow(chunk.ChunkId, (int)arg.ImportEntity.RowIndex, false);
};
chunkProcessor.ImportEntitySaveError += importEntitySavedWithErrorHandler;
ImportParameters newImportParameters = PrepareImportParameters(importParameters, chunk);
SaveProcessedChunk(chunk, ImportChunkState.InProcess);
chunkProcessor.ProcessChunk(newImportParameters);
SaveProcessedChunk(chunk, ImportChunkState.Processed);
_importEntitiesChunksDataProvider.RemoveProcessedRows(chunk.ChunkId);
chunkProcessor.ImportEntitySaved -= successImportEntitySavedHadler;
chunkProcessor.ImportEntitySaveError -= importEntitySavedWithErrorHandler;
}
private void PopulateProcessedChunks(ImportDataChunk <EntityChunkData> entityChunk)
{
_processedWithErrorRowsCount += (uint)entityChunk.Data.ProcessedWithErrorEntityCount;
_successProcessedRowsCount += (uint)entityChunk.Data.SuccessProcessedEntityCount;
}
