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); }