Ejemplo n.º 1
0
        private List <IConverter> CreateConverters(string key, SourceTargetMapping mapping)
        {
            var converters = new List <IConverter>();

            foreach (var targetConverter in mapping.TargetConverters)
            {
                if (targetConverter.LeftSideMap != null && targetConverter.LeftSideMap.ContainsKey(key))
                {
                    var config = new ConverterConfiguration()
                    {
                        Id = targetConverter.Id,
                        CombineInputOutput = targetConverter.CombineInputOutput,
                        NestOutput         = targetConverter.NestOutput,
                        LeftSideMap        = targetConverter.LeftSideMap,
                        Properties         = (targetConverter.Properties.Count > 0) ? targetConverter.Properties : mapping.Properties,
                        PipedConverters    = converters,
                        Mapping            = mapping
                    };
                    IConverter converter = CollectorFactory.CloneConverter(Converters[targetConverter.Id]);
                    if (converter != null)
                    {
                        converter.Configure(config);
                        converters.Add(converter);
                    }
                }
            }
            return(converters);
        }
Ejemplo n.º 2
0
        /// <summary>
        /// Convert an entire row of data.
        /// </summary>
        /// <param name="dataRow">The row to convert</param>
        /// <returns>The converted row.</returns>
        public Dictionary <string, object> ConvertDataRow(SourceTargetMapping mapping, IEntityCollection dataRow)
        {
            var mappedRow = new Dictionary <string, object>();

            // Convert the data points...
            foreach (var dataPoint in dataRow.Entities)
            {
                var convertedDataPoints = ConvertDataPoint(mapping, dataPoint, dataRow);
                if (convertedDataPoints != null)
                {
                    foreach (var convertedDataPoint in convertedDataPoints)
                    {
                        // Last conversion wins
                        if (mappedRow.ContainsKey(convertedDataPoint.Key))
                        {
                            mappedRow[convertedDataPoint.Key] = convertedDataPoint.Value;
                        }
                        else
                        {
                            mappedRow.Add(convertedDataPoint.Key, convertedDataPoint.Value);
                        }
                    }
                }
            }
            return(mappedRow);
        }
Ejemplo n.º 3
0
        /// <summary>
        /// Convert a single data point.
        /// </summary>
        /// <param name="dataPoint">The data point to convert</param>
        /// <param name="dataRow">The associated row data points</param>
        /// <returns>A dictionary of converted data.</returns>
        public Dictionary <string, object> ConvertDataPoint(SourceTargetMapping mapping, KeyValuePair <string, object> dataPoint, IEntityCollection dataRowIn)
        {
            Dictionary <string, object> result = null;

            if (mapping != null)
            {
                // create any converters that are targeting this data point.
                var converters = CreateConverters(dataPoint.Key, mapping);
                // make our local copy of the data row, we may need to manipulate it for nested conversions.
                var dataRow = new EntityCollection();
                foreach (var e in dataRowIn.Entities)
                {
                    dataRow.Entities.Add(e.Key, e.Value);
                }
                Dictionary <string, object> convertedDataPoints = null;
                foreach (var converter in converters)
                {
                    var config = GetConverterConfiguration(converter.Id, mapping.TargetConverters);
                    var convertedDataPointsOut = converter.Convert(dataPoint, dataRow);
                    convertedDataPoints = CombineData(config, convertedDataPoints, convertedDataPointsOut);
                    result = convertedDataPoints;
                    if (!config.Pipe)
                    {
                        break;
                    }
                }
            }
            return(result);
        }
Ejemplo n.º 4
0
 /// <summary>
 /// Configure the converter.
 /// </summary>
 /// <param name="config">The converter configuration.</param>
 public void Configure(ConverterConfiguration config)
 {
     _id = config.Id;
     _combineInputOutput = config.CombineInputOutput;
     _nestOutput         = config.NestOutput;
     _leftSideMap        = config.LeftSideMap;
     _properties         = config.Properties;
     _mapping            = config.Mapping;
     _pipedConverters    = config.PipedConverters;
 }
Ejemplo n.º 5
0
        public void PipedConverters_PipedArray_Success()
        {
            // Use Case: A data point contains an array of objects (software items).
            // The PipedArrayConverter uses reflection to get each field, convert the field based on
            // the configured converters for the associated source target mapping.
            // The converter returns a dictionary of dictionaries based on an id.
            // The id is determined in the SourceTargetConverter property "ArrayKey".
            // The property "PrefixId" means to prefix the id with the "ArrayKey", i.e. "Id_XXX"
            // where XXX is the Id field of the software.
            var items = CreateMockSoftwareArray();
            var row   = new EntityCollection();

            row.Entities.Add("Items", items);

            var properties = new Dictionary <string, string>();

            properties.Add("ArrayKey", "Id");
            properties.Add("PrefixId", "true");

            var targetConverters = new List <SourceTargetConverter>();
            var mapping          = new SourceTargetMapping()
            {
                //PipeData = true,
                Properties       = properties,
                PrimaryKey       = "Items",
                TargetConverters = targetConverters
            };
            var noOpConverter = new NoOpConverter();
            var leftSideMap   = new Dictionary <string, List <string> >();

            leftSideMap.Add("Id", new List <string>()
            {
                "Id"
            });
            leftSideMap.Add("Title", new List <string>()
            {
                "Title"
            });
            leftSideMap.Add("DateTime", new List <string>()
            {
                "DateTime"
            });
            var noOpConfig = new ConverterConfiguration()
            {
                Id          = "1",
                LeftSideMap = leftSideMap
            };

            noOpConverter.Configure(noOpConfig);

            var converters = new List <IConverter>();

            converters.Add(noOpConverter);

            var converter = new PipedArrayConverter();

            converters.Add(converter);

            var config = new ConverterConfiguration()
            {
                Id              = "2",
                Mapping         = mapping,
                PipedConverters = converters,
                Properties      = properties
            };

            converter.Configure(config);
            var convertedData = converter.Convert(new KeyValuePair <string, object>("Items", items), row);

            convertedData.Count.Should().Be(2);

            foreach (var id in convertedData.Keys)
            {
                if (id.Contains("_pkAttrName"))
                {
                    continue;
                }
                var software  = convertedData[id] as List <object>;
                var software0 = software[0] as Dictionary <string, object>;
                software0["Id"].Should().Be("1");
                software0["Title"].Should().Be("Some Software Title #1");
                software0["DateTime"].Should().NotBeNull();
                var software1 = software[1] as Dictionary <string, object>;
                software1["Id"].Should().Be("2");
                software1["Title"].Should().Be("Some Software Title #2");
                software1["DateTime"].Should().NotBeNull();
            }
        }