private Task <List <SheetCellInfo> > CreateSheetCellInfos <TModel>(ResGroupModel <TModel> group, CancellationToken cancellationToken)
where TModel : IRowModel
{
return(Task.Run(() =>
{
int rowIndex = 0;
List <SheetCellInfo> resCells = new List <SheetCellInfo>();
foreach (var table in group.Tables)
{
resCells.Add(new SheetCellInfo(rowIndex, 0, table.TableTitle));
rowIndex += 2;
resCells.AddRange(table.Header.Columns.Select((header, colIndex) => new SheetCellInfo(rowIndex, colIndex, header.Title)));
rowIndex++;
foreach (var row in table.Rows)
{
resCells.AddRange(row.DataList.Select((dataCell, colIndex) => new SheetCellInfo(rowIndex, colIndex, dataCell.DataString)));
rowIndex++;
}
rowIndex++;
cancellationToken.ThrowIfCancellationRequested();
}
return resCells;
}, cancellationToken));
}
private IReadOnlyList <ResGroupModel <TModel> > ImportFromDocument <TModel>(string path) where TModel : IRowModel, new()
{
using (ExcelPackage package = new ExcelPackage(new FileInfo(path)))
{
var workbook = package.Workbook;
var dataList = new List <ResGroupModel <TModel> >();
foreach (ExcelWorksheet worksheetPart in workbook.Worksheets)
{
var tables = new List <ResTableModel <TModel> >();
var newGroup = new ResGroupModel <TModel> {
GroupTitle = worksheetPart.Name, Tables = tables
};
var cells = worksheetPart.Cells.Select(cell => new { cell.Start.Row, cell.Start.Column, Value = (string)cell.Value }).ToList();
int maxRow = cells.Max(c => c.Row);
string[][] cellsArray = new string[maxRow][];
foreach (var row in cells.GroupBy(c => c.Row))
{
cellsArray[row.Key - 1] = row.OrderBy(c => c.Column).Select(c => c.Value).ToArray();
}
for (int i = 0; i < cellsArray.Length; i++)
{
var table = new ResTableModel <TModel>();
table.TableTitle = cellsArray[i][0];
i += 2;
table.Header = new HeaderModel {
Columns = cellsArray[i].Select(c => new ColumnModel {
Title = c
}).ToList()
};
var rows = new List <RowModel <TModel> >();
string[] rowsArray;
while (++i < cellsArray.Length && (rowsArray = cellsArray[i]) != null)
{
rows.Add(new RowModel <TModel>
{
Model = new TModel
{
DataList = rowsArray.Select(a => new CellModel {
DataString = a
}).ToList()
}
});
}
table.Rows = rows;
}
dataList.Add(newGroup);
}
return(dataList);
}
}
private async Task PushCellsAsync <TModel>(WorksheetEntry worksheet, ResGroupModel <TModel> group, SemaphoreSlim semaphore, IAggregateProgress progress, CancellationToken cancellationToken)
where TModel : IRowModel
{
var progresses = progress.CreateParallelProgresses(0.2, 0.8);
var mappingProgress = progresses[0];
var updatingProgress = progresses[1];
var cellFeed = await Service.GetFeedAsync(worksheet.GetCellsQuery(), cancellationToken : cancellationToken);
string cellsFeedUrl = cellFeed.Self;
string batchUrl = cellFeed.Batch;
var resCells = await CreateSheetCellInfos(group, cancellationToken);
var cellGroups = Devide(resCells, MaxBatchSize);
var mappingTasks = (await MapFeedBatchesAsync(cellGroups, cellsFeedUrl, batchUrl, mappingProgress, cancellationToken))
.Select(async kvp =>
{
var mappingFeed = kvp.Key;
var p = kvp.Value;
await semaphore.WaitAsync(cancellationToken);
try
{
return(await Service.BatchFeedAsync(mappingFeed, TimeOutAttemptsCount, p, cancellationToken));
}
finally
{
semaphore.Release();
}
});
//Mapping cells.
List <CellFeed> mappingFeeds = new List <CellFeed>(cellGroups.Count);
foreach (var mappingTask in mappingTasks)
{
mappingFeeds.Add(await mappingTask);
}
//Updating cells.
var updatingTasks = (await UpdateFeedBatchesAsync(cellGroups, mappingFeeds, cellsFeedUrl, batchUrl, updatingProgress, cancellationToken))
.Select(async kvp =>
{
var updateFeed = kvp.Key;
var p = kvp.Value;
await semaphore.WaitAsync(cancellationToken);
try
{
return(await Service.BatchFeedAsync(updateFeed, TimeOutAttemptsCount, p, cancellationToken));
}
finally
{
semaphore.Release();
}
});
foreach (var updatingTask in updatingTasks)
{
await updatingTask;
}
}
private Task <ResGroupModel <TModel> > ProcessGroupAsync <TModel>(WorksheetEntry worksheet, IEnumerable <CellEntry> cells, CancellationToken cancellationToken) where TModel : IRowModel, new()
{
return(Task.Run(() =>
{
List <string>[] rows = new List <string> [(int)worksheet.Rows];
foreach (CellEntry cellEntry in cells)
{
var cellsList = rows[cellEntry.Row - 1];
if (cellsList == null)
{
cellsList = new List <string>();
rows[cellEntry.Row - 1] = cellsList;
}
InsertElementAt(cellsList, (int)cellEntry.Column - 1, SheetCellInfo.GetValue(cellEntry));
}
var rowsEnumerator = rows.AsEnumerable().GetEnumerator();
ResGroupModel <TModel> group = new ResGroupModel <TModel>
{
GroupTitle = worksheet.Title.Text,
};
List <ResTableModel <TModel> > tables = new List <ResTableModel <TModel> >();
int colsCount = (int)worksheet.Cols;
List <string> row;
while (rowsEnumerator.MoveNext())
{
//Title row.
row = rowsEnumerator.Current;
if (row == null)
{
break;
}
var newTable = new ResTableModel <TModel> {
TableTitle = row[0]
};
//Space row.
rowsEnumerator.MoveNext();
//Header
rowsEnumerator.MoveNext();
row = rowsEnumerator.Current;
newTable.Header = new HeaderModel {
Columns = row.Select(r => new ColumnModel {
Title = r
}).ToList()
};
var rowsList = new List <RowModel <TModel> >();
while (rowsEnumerator.MoveNext())
{
row = rowsEnumerator.Current;
if (row == null)
{
break;
}
if (row.Count != colsCount)
{
//Adding empty cells.
for (int i = colsCount - 1; i >= 0; i--)
{
var elem = row.ElementAtOrDefault(i);
if (elem == null)
{
InsertElementAt(row, i, string.Empty);
if (row.Count == colsCount)
{
break;
}
}
}
}
rowsList.Add(new RowModel <TModel> {
Model = new TModel {
DataList = row.Select(c => new CellModel {
Model = c
}).ToList()
}
});
}
newTable.Rows = rowsList;
tables.Add(newTable);
}
group.Tables = tables;
return group;
}, cancellationToken));
}
