public int GetLength(ITableParser tableParser, Type modelType, IEnumerable <ICell> primaryParts)
{
var parserState = new List <(IAtomicValueParser parser, ICell cell, Type itemType)>();
foreach (var primaryPart in primaryParts)
{
var childModelPath = ExcelTemplatePath.FromRawExpression(primaryPart.StringValue);
var childModelType = ObjectPropertiesExtractor.ExtractChildObjectTypeFromPath(modelType, childModelPath);
var parser = parserCollection.GetAtomicValueParser();
parserState.Add((parser, primaryPart, childModelType));
}
for (var i = 0; i <= ParsingParameters.MaxEnumerableLength; i++)
{
var parsed = false;
foreach (var(parser, cell, type) in parserState)
{
tableParser.PushState(cell.CellPosition.Add(new ObjectSize(0, i)));
if (parser.TryParse(tableParser, type, out var result) && result != null)
{
parsed = true;
}
tableParser.PopState();
}
if (!parsed)
{
return(i);
}
}
throw new EnumerableTooLongException(ParsingParameters.MaxEnumerableLength);
}
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);
}
public List <object> Parse([NotNull] ITableParser tableParser, [NotNull] Type modelType, int count, [NotNull] Action <string, string> addFieldMapping)
{
if (count < 0)
{
throw new InvalidOperationException($"Count should be positive ({count} found)");
}
if (count > ParsingParameters.MaxEnumerableLength)
{
throw new InvalidOperationException($"Lists longer than {ParsingParameters.MaxEnumerableLength} are not supported");
}
var parser = parserCollection.GetAtomicValueParser();
var result = new List <object>();
for (var i = 0; i < count; i++)
{
if (i != 0)
{
tableParser.MoveToNextLayer();
}
tableParser.PushState();
if (!parser.TryParse(tableParser, modelType, out var item) || item == null)
{
item = GetDefault(modelType);
}
addFieldMapping($"[{i}]", tableParser.CurrentState.Cursor.CellReference);
result.Add(item);
tableParser.PopState();
}
return(result);
}
public object ParseOrDefault(ITableParser tableParser, string name, Type modelType)
{
if (!TryParse(tableParser, name, modelType, out var result))
{
result = false;
}
return(result);
}
public bool TryParse(ITableParser tableParser, string name, Type modelType, out object result)
{
if (!tableParser.TryParseCheckBoxValue(name, out var parseResult))
{
result = null;
return(false);
}
result = parseResult;
return(true);
}
private void ParseSingleValue(ITableParser tableParser, Action <string, string> addFieldMapping, Action <object> leafSetter, ExcelTemplatePath childModelPath, Type childModelType)
{
var parser = parserCollection.GetAtomicValueParser();
addFieldMapping(childModelPath.RawPath, tableParser.CurrentState.Cursor.CellReference);
if (!parser.TryParse(tableParser, childModelType, out var parsedObject))
{
logger.Error($"Failed to parse value from '{tableParser.CurrentState.Cursor.CellReference}' with childModelType='{childModelType}' via AtomicValueParser");
return;
}
leafSetter(parsedObject);
}
private void ParseCellularValue(ITableParser tableParser, Action <string, string> addFieldMapping, object model, ExcelTemplatePath path, Dictionary <ExcelTemplatePath, int> enumerablesLengths)
{
var leafSetter = ObjectPropertySettersExtractor.ExtractChildObjectSetter(model, path);
var leafModelType = ObjectPropertiesExtractor.ExtractChildObjectTypeFromPath(model.GetType(), path);
if (path.HasArrayAccess)
{
ParseEnumerableValue(tableParser, addFieldMapping, model, path, leafSetter, leafModelType, enumerablesLengths);
}
else
{
ParseSingleValue(tableParser, addFieldMapping, leafSetter, path, leafModelType);
}
}
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);
}
private void ParseFormValue(ITableParser tableParser, Action <string, string> addFieldMapping, object model, ICell cell, ExcelTemplatePath path)
{
var childSetter = ObjectPropertySettersExtractor.ExtractChildObjectSetter(model, path);
var childModelType = ObjectPropertiesExtractor.ExtractChildObjectTypeFromPath(model.GetType(), path);
var(childFormControlType, childFormControlName) = GetFormControlDescription(cell);
if (path.HasArrayAccess)
{
throw new InvalidOperationException("Enumerables are not supported for form controls");
}
var parser = parserCollection.GetFormValueParser(childFormControlType, childModelType);
var parsedObject = parser.ParseOrDefault(tableParser, childFormControlName, childModelType);
childSetter(parsedObject);
addFieldMapping(path.RawPath, childFormControlName);
}
private void ParseEnumerableValue(ITableParser tableParser, Action <string, string> addFieldMapping, object model, ExcelTemplatePath path, Action <object> leafSetter, Type leafModelType, Dictionary <ExcelTemplatePath, int> enumerablesLengths)
{
var(rawPathToEnumerable, childPath) = path.SplitForEnumerableExpansion();
var cleanPathToEnumerable = rawPathToEnumerable.WithoutArrayAccess();
var enumerableType = ObjectPropertiesExtractor.ExtractChildObjectTypeFromPath(model.GetType(), cleanPathToEnumerable);
if (!typeof(IList).IsAssignableFrom(enumerableType))
{
throw new Exception($"Only ILists are supported as collections, but tried to use '{enumerableType}'. (path: {cleanPathToEnumerable.RawPath})");
}
var parser = parserCollection.GetEnumerableParser(enumerableType);
var count = enumerablesLengths[cleanPathToEnumerable];
var parsedList = parser.Parse(tableParser, leafModelType, count, (name, value) => addFieldMapping($"{cleanPathToEnumerable.RawPath}{name}.{childPath.RawPath}", value));
leafSetter(parsedList);
}
public bool TryParse([NotNull] ITableParser tableParser, [NotNull] Type itemType, out object result)
{
if (itemType == typeof(string))
{
return(Parse(() => (tableParser.TryParseAtomicValue(out string res), res), out result));
}
if (itemType == typeof(int))
{
return(Parse(() => (tableParser.TryParseAtomicValue(out int res), res), out result));
}
if (itemType == typeof(double))
{
return(Parse(() => (tableParser.TryParseAtomicValue(out double res), res), out result));
}
if (itemType == typeof(decimal))
{
return(Parse(() => (tableParser.TryParseAtomicValue(out decimal res), res), out result));
}
if (itemType == typeof(long))
{
return(Parse(() => (tableParser.TryParseAtomicValue(out long res), res), out result));
}
if (itemType == typeof(int?))
{
return(Parse(() => (tableParser.TryParseAtomicValue(out int?res), res), out result));
}
if (itemType == typeof(double?))
{
return(Parse(() => (tableParser.TryParseAtomicValue(out double?res), res), out result));
}
if (itemType == typeof(decimal?))
{
return(Parse(() => (tableParser.TryParseAtomicValue(out decimal? res), res), out result));
}
if (itemType == typeof(long?))
{
return(Parse(() => (tableParser.TryParseAtomicValue(out long?res), res), out result));
}
throw new InvalidOperationException($"Type {itemType} is not a supported atomic value");
}
public ConsoleReportParser(ITableParser tableParser)
{
_tableParser = tableParser;
}
public static ITableParser Creator(TableIdentification tableName)
{
ITableParser tableParser = null;
switch (tableName)
{
case TableIdentification.GeneralManufacturerIdentification:
tableParser = new GeneralManufacturerIdentificationTable();
break;
case TableIdentification.ModeAndStatusStandardTable:
break;
case TableIdentification.StatusManufacturerTable:
break;
case TableIdentification.Multipliers:
break;
case TableIdentification.PrimaryMeteringInformation:
tableParser = new PrimaryMeteringInformation();
break;
case TableIdentification.ElsterSourceDefinitionTable:
tableParser = new ElsterSourceDefinitionTable();
break;
case TableIdentification.ActualRegisterTable:
tableParser = new ActualRegisterTable();
break;
case TableIdentification.DataSelectionTable:
tableParser = new DataSelectionTable();
break;
case TableIdentification.CurrentRegisterDataTable:
tableParser = new CurrentRegisterDataTable();
break;
case TableIdentification.PreviousSeasonDataTable:
tableParser = new PreviousSeasonDataTable();
break;
case TableIdentification.PreviousDemandResetDataTable:
tableParser = new PreviousDemandResetDataTable();
break;
case TableIdentification.PresentRegisterDataTable:
tableParser = new PresentRegisterDataTable();
break;
case TableIdentification.ActualLoadProfileTable:
tableParser = new ActualLoadProfileTable();
break;
case TableIdentification.LoadProfileDataSet1Table:
tableParser = new LoadProfileDataSet1Table();
break;
case TableIdentification.EventLogDataTable:
tableParser = new EventLogDataTable();
break;
default:
break;
}
return(tableParser);
}
