Пример #1
0
 public ParsingResult(ResultLevel level, string message, object value, IDataSourceLocation dataSourceLocation)
 {
     _level              = level;
     _message            = message;
     _value              = value;
     _dataSourceLocation = dataSourceLocation;
 }
        public IResult Parse(IDataToImport dataToImport, IDataSourceLocation dataSourceLocation, Type type)
        {
            if (!(dataSourceLocation is XMLDataSourceLocation))
            {
                return(new ParsingResult(ResultLevel.FATAL, dataSourceLocation.GetType().ToString() + " is not supported by XML Node Parser", null, dataSourceLocation));
            }

            if (!(dataToImport is XMLDataToImport))
            {
                return(new ParsingResult(ResultLevel.FATAL, dataToImport.GetType().ToString() + " is not supported by XML Node Parser", null, dataSourceLocation));
            }


            var castedDataToImport       = dataToImport as XMLDataToImport;
            var castedDataSourceLocation = dataSourceLocation as XMLDataSourceLocation;

            try
            {
                var rawData     = GetRawDataValue(castedDataSourceLocation, castedDataToImport);
                var parsedValue = ParseRawValue(type, rawData);

                return(new ParsingResult(ResultLevel.INFO, "Parsing value successfully", parsedValue, dataSourceLocation));
            }
            catch (Exception e)
            {
                return(new ParsingResult(ResultLevel.FATAL, "Exception caught: " + e, null, dataSourceLocation));
            }
        }
        public IResult Parse(IDataToImport dataToImport, IDataSourceLocation dataSourceLocation, Type type)
        {
            if (!(dataSourceLocation is XMLDataSourceLocation))
            {
                return new ParsingResult(ResultLevel.FATAL, dataSourceLocation.GetType().ToString() + " is not supported by XML Node Parser", null, dataSourceLocation);
            }

            if (!(dataToImport is XMLDataToImport))
            {
                return new ParsingResult(ResultLevel.FATAL, dataToImport.GetType().ToString() + " is not supported by XML Node Parser", null, dataSourceLocation);
            }


            var castedDataToImport = dataToImport as XMLDataToImport;
            var castedDataSourceLocation = dataSourceLocation as XMLDataSourceLocation;

            try
            {
                var rawData = GetRawDataValue(castedDataSourceLocation, castedDataToImport);
                var parsedValue = ParseRawValue(type, rawData);

                return new ParsingResult(ResultLevel.INFO, "Parsing value successfully", parsedValue, dataSourceLocation);
            }
            catch (Exception e)
            {
                return new ParsingResult(ResultLevel.FATAL, "Exception caught: " + e, null, dataSourceLocation);
            }
        }
        public IResult Parse(IDataToImport dataToImport, IDataSourceLocation dataSourceLocation, Type type)
        {
            var castedDataToImport = dataToImport as JSONDataToImport;
            var castedJObject = castedDataToImport.Data as JObject;

            var castedDataSourceLocation = dataSourceLocation as JSONDataSourceLocation;
            var locationPath = castedDataSourceLocation.Path;

            if (castedDataSourceLocation.IsArray)
            {
                var rawValues = castedJObject.SelectTokens(locationPath).Values<string>();
                var valueParser = _parserFactory.GetValueParser(type);

                var parsedValue = from value in rawValues
                                  select valueParser.Parse(value);


                return new ParsingResult(ResultLevel.INFO, "Parse value from " + dataToImport.ToString() + " successfully, the value is " + parsedValue.ToString(), parsedValue.ToList(), castedDataSourceLocation);

            }
            else
            {
                var rawValue = (castedJObject.SelectTokens(locationPath).ElementAt(castedDataSourceLocation.Index.Value) as JValue).Value;
                var valueParser = _parserFactory.GetValueParser(type);
                var parsedValue = valueParser.Parse(rawValue);

                return new ParsingResult(ResultLevel.INFO, "Parse value from " + dataToImport.ToString() + " successfully " + parsedValue, parsedValue, castedDataSourceLocation);
            }

        }
Пример #5
0
        public IExtractedDataset <T> Extract <T>(IDataToImport dataToImport) where T : new()
        {
            var extractedDataset            = new ExtractedDataset <T>(_thresholdLevel);
            var validatedDataToImportResult = ValidateDataToImport(dataToImport);

            extractedDataset.AddParsingResults(validatedDataToImportResult.Item2);

            if (!validatedDataToImportResult.Item1)
            {
                //format not valid, return
                return(extractedDataset);
            }
            var results = new List <IResult>();
            var model   = new T();
            IDataSourceLocation currentLocation = null;

            foreach (var configuration in _extractConfigurations)
            {
                if (configuration is SimpleXMLExtractConfiguration)
                {
                    currentLocation = new XMLDataSourceLocation(((SimpleXMLExtractConfiguration)configuration).ElementName, ((SimpleXMLExtractConfiguration)configuration).AttributeName);
                }

                results.AddRange(((SimpleXMLExtractConfiguration)configuration).ExtractData(model, dataToImport, currentLocation));
            }

            var parsingResult = new ParsingResult(ResultLevel.DEBUG, "Extract data from single row success", model, null);

            results.Add(parsingResult);

            extractedDataset.AddParsingResults(results);

            return(extractedDataset);
        }
        public IResult Parse(IDataToImport dataToImport, IDataSourceLocation dataSourceLocation, Type type)
        {
            if (!(dataSourceLocation is CSVDataSourceLocation))
            {
                return new ParsingResult(ResultLevel.FATAL, dataSourceLocation.GetType().ToString() + " is not supported by CSV Cell Parser", null, null);
            }

            if (!(dataToImport is CSVDataToImport))
            {
                return new ParsingResult(ResultLevel.FATAL, dataToImport.GetType().ToString() + " is not supported by CSV Cell Parser", null, null);
            }


            var castedDataToImport = dataToImport as CSVDataToImport;
            var castedDataSourceLocation = dataSourceLocation as CSVDataSourceLocation;

            try
            {
                var rawData = GetRawDataValue(castedDataSourceLocation, castedDataToImport);
                var parsedValue = ParseRawValue(type, rawData);

                return new ParsingResult(ResultLevel.INFO, "Parsing value successfully", parsedValue, castedDataSourceLocation);
            }
            catch (IndexOutOfRangeException)
            {
                return new ParsingResult(ResultLevel.FATAL, "Index is out of range", null, castedDataSourceLocation);
            }
        }
        public IResult Parse(IDataToImport dataToImport, IDataSourceLocation dataSourceLocation, Type type)
        {
            var castedDataToImport = dataToImport as JSONDataToImport;
            var castedJObject      = castedDataToImport.Data as JObject;

            var castedDataSourceLocation = dataSourceLocation as JSONDataSourceLocation;
            var locationPath             = castedDataSourceLocation.Path;

            if (castedDataSourceLocation.IsArray)
            {
                var rawValues   = castedJObject.SelectTokens(locationPath).Values <string>();
                var valueParser = _parserFactory.GetValueParser(type);

                var parsedValue = from value in rawValues
                                  select valueParser.Parse(value);


                return(new ParsingResult(ResultLevel.INFO, "Parse value from " + dataToImport.ToString() + " successfully, the value is " + parsedValue.ToString(), parsedValue.ToList(), castedDataSourceLocation));
            }
            else
            {
                var rawValue    = (castedJObject.SelectTokens(locationPath).ElementAt(castedDataSourceLocation.Index.Value) as JValue).Value;
                var valueParser = _parserFactory.GetValueParser(type);
                var parsedValue = valueParser.Parse(rawValue);

                return(new ParsingResult(ResultLevel.INFO, "Parse value from " + dataToImport.ToString() + " successfully " + parsedValue, parsedValue, castedDataSourceLocation));
            }
        }
Пример #8
0
        public IResult Parse(IDataToImport dataToImport, IDataSourceLocation dataSourceLocation, Type type)
        {
            if (!(dataSourceLocation is CSVDataSourceLocation))
            {
                return(new ParsingResult(ResultLevel.FATAL, dataSourceLocation.GetType().ToString() + " is not supported by CSV Cell Parser", null, null));
            }

            if (!(dataToImport is CSVDataToImport))
            {
                return(new ParsingResult(ResultLevel.FATAL, dataToImport.GetType().ToString() + " is not supported by CSV Cell Parser", null, null));
            }


            var castedDataToImport       = dataToImport as CSVDataToImport;
            var castedDataSourceLocation = dataSourceLocation as CSVDataSourceLocation;

            try
            {
                var rawData     = GetRawDataValue(castedDataSourceLocation, castedDataToImport);
                var parsedValue = ParseRawValue(type, rawData);

                return(new ParsingResult(ResultLevel.INFO, "Parsing value successfully", parsedValue, castedDataSourceLocation));
            }
            catch (IndexOutOfRangeException)
            {
                return(new ParsingResult(ResultLevel.FATAL, "Index is out of range", null, castedDataSourceLocation));
            }
        }
Пример #9
0
        public HelixAnalyzerService(XmlNode configNode, IDataSourceLocation dataSourceLocation,
                                    ICerberusVariablesReplacer variablesReplacer) : base(
                variablesReplacer)
        {
            _dataSourceLocation = dataSourceLocation;
            if (configNode == null)
            {
                return;
            }

            var analyzers = GetAnalyzers(configNode, out var provider);

            _logProvider = GetLogContainer(configNode);

            foreach (var node in analyzers)
            {
                var ruleProvider = RegisterRules(node);
                var type         = XmlActivator.GetType(node);
                if (type != null)
                {
                    provider.Register(type,
                                      () => XmlActivator.CreateInstance(type, node, new[] { provider, ruleProvider, _logProvider }),
                                      true);

                    if (provider.Resolve(type) is IHelixAnalyzer resolve)
                    {
                        Analyzers.Add(resolve);
                    }
                }
            }
        }
 public ParsingResult(ResultLevel level, string message, object value, IDataSourceLocation dataSourceLocation)
 {
     _level = level;
     _message = message;
     _value = value;
     _dataSourceLocation = dataSourceLocation;
 }
Пример #11
0
 public RainbowConfigurationService(string configPath, IHelixModuleProvider helixModuleProvider,
                                    IDataSourceLocation dataSourceLocation,
                                    ICerberusVariablesReplacer variablesReplacer) :
     base(configPath, helixModuleProvider, variablesReplacer)
 {
     _helixModuleProvider = helixModuleProvider;
     _dataSourceLocation  = dataSourceLocation;
 }
 public CellValueMatchCriteriaValidationRule(IDataSourceLocation location,
                                             ICSVParserFactory parserFactory, 
                                             Type cellValueType, 
                                             ICriteria criteria)
 {
     _location = location;
     _parserFactory = parserFactory;
     _cellValueType = cellValueType;
     _criteria = criteria;
 }
Пример #13
0
 public ElementValueMatchCriteriaValidationRule(IDataSourceLocation location,
                                                IXMLParserFactory parserFactory,
                                                Type elementValueType,
                                                ICriteria criteria)
 {
     _location         = location;
     _parserFactory    = parserFactory;
     _elementValueType = elementValueType;
     _criteria         = criteria;
 }
 public CellValueMatchCriteriaValidationRule(IDataSourceLocation location,
                                             ICSVParserFactory parserFactory,
                                             Type cellValueType,
                                             ICriteria criteria)
 {
     _location      = location;
     _parserFactory = parserFactory;
     _cellValueType = cellValueType;
     _criteria      = criteria;
 }
 public ElementValueMatchCriteriaValidationRule(IDataSourceLocation location,
                                             IXMLParserFactory parserFactory,
                                             Type elementValueType,
                                             ICriteria criteria)
 {
     _location = location;
     _parserFactory = parserFactory;
     _elementValueType = elementValueType;
     _criteria = criteria;
 }
Пример #16
0
        public HtmlLogger(string outputPath, IDataSourceLocation dataSourceLocation)
        {
            var path = Path.GetFullPath(outputPath.ToLower().Replace("$(configpath)", dataSourceLocation.Root));

            path = path.EndsWith(@"\") ? path : $@"{path}\";

            var reporter = new ExtentHtmlReporter(path);

            // create ExtentReports and attach reporter(s)
            _extent = new ExtentReports();
            _extent.AttachReporter(reporter);
        }
Пример #17
0
        protected IEnumerable <IResult> ExtractDataForSingleNode <T>(IList <IExtractConfiguration> extractConfigurations, IDataToImport dataToImport) where T : new()
        {
            var resultsForSingleNode = new List <IResult>();
            var model = new T();
            IDataSourceLocation currentLocation = null;

            foreach (var configuration in _extractConfigurations)
            {
                if (configuration is SimpleXMLExtractConfiguration)
                {
                    currentLocation = new XMLDataSourceLocation(((SimpleXMLExtractConfiguration)configuration).ElementName, ((SimpleXMLExtractConfiguration)configuration).AttributeName);
                }

                resultsForSingleNode.AddRange(((SimpleXMLExtractConfiguration)configuration).ExtractData(model, dataToImport, currentLocation));
            }
            var parsingResult = new ParsingResult(ResultLevel.DEBUG, "Extract data from single row success", model, new XMLDataSourceLocation("", ""));

            resultsForSingleNode.Add(parsingResult);

            return(resultsForSingleNode);
        }
Пример #18
0
        public LogDispatcher(XmlNode configNode, IDataSourceLocation dataSourceLocation) : base(
                new ContainerDefinitionVariablesReplacer())
        {
            var loggerConfigs = configNode.ChildNodes.OfType <XmlElement>().Where(node =>
                                                                                  node.NodeType == XmlNodeType.Element && node.Name.Equals("logger"));
            var provider = GetContainer(new ContainerDefinition(configNode as XmlElement));

            provider.Register(typeof(IDataSourceLocation), () => dataSourceLocation, true);

            _loggers = new List <ILogger>();
            foreach (var config in loggerConfigs)
            {
                var type = Type.GetType(config.Attributes["type"]?.Value ??
                                        throw new InvalidOperationException("Invalid Logger Configuration."));
                if (type != null)
                {
                    var allInterfaces   = type.GetInterfaces();
                    var directInterface = allInterfaces.Except(allInterfaces.SelectMany(t => t.GetInterfaces()));
                    _loggers.Add(provider.Resolve(directInterface.First()) as ILogger);
                }
            }
        }
Пример #19
0
        protected IEnumerable <IResult> ExtractDataForSingleRow <T>(IList <IExtractConfiguration> extractConfigurations, IDataToImport dataSource, int currentRow) where T : new()
        {
            var resultsForSingleRow = new List <IResult>();
            var model = new T();

            IDataSourceLocation currentLocation = null;

            foreach (var configuration in extractConfigurations.Where(x => x is ISimpleExtractConfiguration).Cast <ISimpleExtractConfiguration>())
            {
                if (configuration is SimpleCSVExtractConfiguration)
                {
                    currentLocation = new CSVDataSourceLocation(currentRow, ((SimpleCSVExtractConfiguration)configuration).ColumnIndex);
                }
                resultsForSingleRow.AddRange(configuration.ExtractData(model, dataSource, currentLocation));
            }

            var parsingResult = new ParsingResult(ResultLevel.DEBUG, "Extract data from single row success", model, new CSVDataSourceLocation(currentRow, 1));

            resultsForSingleRow.Add(parsingResult);

            return(resultsForSingleRow);
        }
        private IEnumerable <IResult> ExtractHeaderFile(object model, IList <IExtractConfiguration> extractConfiguration, IDataToImport xmlDataToImport)
        {
            var results = new List <IResult>();

            var validatedDataToImportResult = ValidateHeaderFileDataToImport(xmlDataToImport);

            results.AddRange(validatedDataToImportResult.Item2);

            IDataSourceLocation currentLocation = null;

            foreach (var configuration in extractConfiguration.Where(x => x is ISimpleExtractConfiguration))
            {
                if (configuration is SimpleXMLExtractConfiguration)
                {
                    currentLocation = new XMLDataSourceLocation(((SimpleXMLExtractConfiguration)configuration).ElementName, ((SimpleXMLExtractConfiguration)configuration).AttributeName);
                }

                results.AddRange(((SimpleXMLExtractConfiguration)configuration).ExtractData(model, xmlDataToImport, currentLocation));
            }

            return(results);
        }
        public override IEnumerable<IResult> ExtractData(object model, IDataToImport dataToImport, IDataSourceLocation currentLocation)
        {
            var results = new List<IResult>();            

            try
            {
                var parsingResult = _parser.Parse(dataToImport, currentLocation, _propertyType) as IParsingResult;

                _valueAssigner.AssignValue(model, _propertyPath, parsingResult.Value, _propertyType);

                results.Add(new BaseResult(ResultLevel.DEBUG, string.Format("Extract data from csv file and assign to model {0}", currentLocation.ToString())));
                return results;
            }
            catch(Exception ex)
            {
                results.Add(new BaseResult(ResultLevel.ERROR, string.Format("Extract data from csv file and assign to model fail. {0}", currentLocation.ToString())));
                
            }
            
            return results;
            
            
        }
        public override IEnumerable <IResult> ExtractData(object model, IDataToImport dataToImport, IDataSourceLocation currentLocation)
        {
            if (!(dataToImport is JSONDataToImport))
            {
                throw new ArgumentException("The SimpleJSONExtractConfiguration only accept JSONDataToImport to extract data");
            }

            if (!(currentLocation is JSONDataSourceLocation))
            {
                throw new ArgumentException("The SimpleJSONExtractConfiguration only accept JSONDataSourceLocation to extract data");
            }

            throw new NotImplementedException();
        }
 public abstract IEnumerable <IResult> ExtractData(object model, IDataToImport dataToImport,
                                                   IDataSourceLocation currentLocation);
Пример #24
0
 public HelixModuleProvider(IDataSourceLocation dataSourceLocation, string pattern)
 {
     _dataSourceLocation = dataSourceLocation;
     _pattern            = pattern;
 }
 public abstract IEnumerable<IResult> ExtractData(object model, IDataToImport dataToImport,
                                                  IDataSourceLocation currentLocation);
 public MappingResult(ResultLevel level, string message, IDataSourceLocation dataSourceLocation)
 {
     _level = level;
     _message = message;
     _dataSourceLocation = dataSourceLocation;
 }
Пример #27
0
        public IEnumerable <IResult> ExtractData(object model, IDataToImport dataToImport, IDataSourceLocation locationToParse)
        {
            var results = new List <IResult>();

            try
            {
                var parsingResult = _parser.Parse(dataToImport, locationToParse, _propertyType) as IParsingResult;

                _valueAssigner.AssignValue(model, _propertyPath, parsingResult.Value, _propertyType);

                results.Add(new BaseResult(ResultLevel.DEBUG, string.Format("Extract data from xml file and assign to model {0}", locationToParse.ToString())));
                return(results);
            }
            catch (Exception ex)
            {
                results.Add(new BaseResult(ResultLevel.ERROR, string.Format("Extract data from xml file and assign to model fail. {0}", locationToParse.ToString())));
            }

            return(results);
        }
Пример #28
0
 public MappingResult(ResultLevel level, string message, IDataSourceLocation dataSourceLocation)
 {
     _level              = level;
     _message            = message;
     _dataSourceLocation = dataSourceLocation;
 }