private static void MergeCells(ITableBuilder tableBuilder, RenderingTemplate template)
{
foreach (var mergedCells in template.MergedCells)
{
tableBuilder.MergeCells(mergedCells);
}
}
public void Render(ITableBuilder tableBuilder, object model, RenderingTemplate template)
{
var lastRow = template.Content.Cells.LastOrDefault();
foreach (var row in template.Content.Cells)
{
foreach (var cell in row)
{
tableBuilder.PushState(new Style(cell));
if (TemplateDescriptionHelper.IsCorrectFormValueDescription(cell.StringValue))
{
RenderFormControl(tableBuilder, model, cell);
}
else
{
RenderCellularValue(tableBuilder, model, cell);
}
tableBuilder.PopState();
}
if (!row.Equals(lastRow))
{
tableBuilder.MoveToNextLayer();
}
}
MergeCells(tableBuilder, template);
ResizeColumns(tableBuilder, template);
}
public void Render(ITableBuilder tableBuilder, object model, RenderingTemplate template)
{
if (!TypeCheckingHelper.IsEnumerable(model.GetType()))
{
throw new ArgumentException("model is not IEnumerable");
}
var enumerableToRender = ((IEnumerable)model).Cast <object>().ToArray();
for (var i = 0; i < enumerableToRender.Length; ++i)
{
var element = enumerableToRender[i];
var normalizedElement = NormalizeElement(element);
tableBuilder.PushState();
var renderer = rendererCollection.GetRenderer(normalizedElement.GetType());
renderer.Render(tableBuilder, normalizedElement, template);
tableBuilder.PopState();
if (i != enumerableToRender.Length - 1)
{
tableBuilder.MoveToNextLayer();
}
}
}
public TModel Parse <TModel>([NotNull] ITableParser tableParser, [NotNull] RenderingTemplate template, Action <string, string> addFieldMapping)
where TModel : new()
{
var model = new TModel();
var enumerablesLengths = GetEnumerablesLengths <TModel>(tableParser, template);
foreach (var row in template.Content.Cells)
{
foreach (var cell in row)
{
tableParser.PushState(cell.CellPosition);
var expression = cell.StringValue;
if (TemplateDescriptionHelper.IsCorrectValueDescription(expression))
{
ParseCellularValue(tableParser, addFieldMapping, model, ExcelTemplatePath.FromRawExpression(expression), enumerablesLengths);
continue;
}
if (TemplateDescriptionHelper.IsCorrectFormValueDescription(expression))
{
ParseFormValue(tableParser, addFieldMapping, model, cell, ExcelTemplatePath.FromRawExpression(expression));
continue;
}
tableParser.PopState();
}
}
return(model);
}
private static void ResizeColumns(ITableBuilder tableBuilder, RenderingTemplate template)
{
foreach (var column in template.Columns)
{
tableBuilder.ExpandColumn(column.Index - template.Range.UpperLeft.ColumnIndex + 1,
column.Width);
}
}
public void Render(ITableBuilder tableBuilder, object model, RenderingTemplate template)
{
if (!(model is string stringToRender))
{
throw new ArgumentException("model is not string");
}
tableBuilder.RenderAtomicValue(stringToRender);
tableBuilder.SetCurrentStyle();
tableBuilder.MoveToNextColumn();
}
public void Render(ITableBuilder tableBuilder, object model, RenderingTemplate template)
{
if (!(model is double))
{
throw new ArgumentException("model is not double");
}
var doubleToRender = (double)model;
tableBuilder.RenderAtomicValue(doubleToRender);
tableBuilder.SetCurrentStyle();
tableBuilder.MoveToNextColumn();
}
private Dictionary <ExcelTemplatePath, int> GetEnumerablesLengths <TModel>([NotNull] ITableParser tableParser, [NotNull] RenderingTemplate template)
{
var enumerableCellsGroups = new Dictionary <ExcelTemplatePath, List <ICell> >();
foreach (var row in template.Content.Cells)
{
foreach (var cell in row)
{
var expression = cell.StringValue;
if (TemplateDescriptionHelper.IsCorrectValueDescription(expression) && ExcelTemplatePath.FromRawExpression(expression).HasArrayAccess)
{
var cleanPathToEnumerable = ExcelTemplatePath.FromRawExpression(expression)
.SplitForEnumerableExpansion()
.pathToEnumerable
.WithoutArrayAccess();
if (!enumerableCellsGroups.ContainsKey(cleanPathToEnumerable))
{
enumerableCellsGroups[cleanPathToEnumerable] = new List <ICell>();
}
enumerableCellsGroups[cleanPathToEnumerable].Add(cell);
}
}
}
var enumerablesLengths = new Dictionary <ExcelTemplatePath, int>();
foreach (var enumerableCells in enumerableCellsGroups)
{
var cleanPathToEnumerable = enumerableCells.Key;
var childEnumerableType = ObjectPropertiesExtractor.ExtractChildObjectTypeFromPath(typeof(TModel), cleanPathToEnumerable);
if (!TypeCheckingHelper.IsIList(childEnumerableType))
{
throw new InvalidOperationException($"Only ILists are supported as collections, but tried to use '{childEnumerableType}'. (path: {cleanPathToEnumerable.RawPath})");
}
var primaryParts = enumerableCells.Value.Where(x => ExcelTemplatePath.FromRawExpression(x.StringValue).HasPrimaryKeyArrayAccess).ToList();
if (primaryParts.Count == 0)
{
primaryParts = enumerableCells.Value.Take(1).ToList();
}
var measurer = parserCollection.GetEnumerableMeasurer();
enumerablesLengths[cleanPathToEnumerable] = measurer.GetLength(tableParser, typeof(TModel), primaryParts);
}
return(enumerablesLengths);
}
