public static void Import(string csv)
        {
            var csvMapper = new CsvMapper();
            //var csv = File.ReadAllText(@"D:\Dev\git\FatDividends\_documentation\D&E\earning_cba.csv");
            var mappings = new Dictionary<string, int>
                {
                    {"StockCode", 0},
                    {"Year", 1},
                    {"Period", 2},
                    {"ReportedDate", 3},
                    {"NPAT", 4},
                    {"Margin", 5},
                    {"CashFlow", 6},
                    {"EPS", 7},
                    {"DPS", 8},
                    {"ROE", 9}
                };

            var earnings = csvMapper.MapCsvTo<StockEarning>(mappings, csv, true);

            using (var service = new EarningService())
            {
                service.Add(earnings);
            }
        }
Esempio n. 2
0
        public void MapByFilePathCustomMappings()
        {
            // arrange
            var mapper = new CsvMapper<CurryOrder>();

            // make sure calling GetHeaders does not affect the result
            mapper.GetHeaders(this.CurryOrderFilePath);
            mapper.GetHeaders(this.CurryOrderFilePath);
            mapper.GetHeaders(this.CurryOrderFilePath);

            // act
            mapper.OnItemDataBound += this.CurryOrder_OnItemDataBound;
            var result = mapper.Map(this.CurryOrderFilePath);

            // assert
            Assert.IsNotNull(result);
            Assert.IsTrue(result.Count > 0);
            Assert.AreEqual(3, result.Count);
            var lastRow = result.LastOrDefault();
            Assert.IsNotNull(lastRow);
            Assert.AreEqual("Korma", lastRow.Curry);
            Assert.AreEqual(2, lastRow.Quantity);
            Assert.AreEqual(12.5M, lastRow.Price);
            Assert.AreEqual(25M, lastRow.Total);
        }
Esempio n. 3
0
        public void MapByFilePathParseValues()
        {
            // arrange
            var mapper   = new CsvMapper <CurryOrder>();
            var mappings = new NameValueCollection();

            mappings.Add("Curry", "0");
            mappings.Add("Quantity", "1");
            mappings.Add("Price", "2");
            mappings.Add("Total", "3");

            // make sure calling GetHeaders does not affect the result
            mapper.GetHeaders(this.CurryOrderFilePath);
            mapper.GetHeaders(this.CurryOrderFilePath);
            mapper.GetHeaders(this.CurryOrderFilePath);

            // act
            var result = mapper.Map(this.CurryOrderFilePath, mappings);

            // assert
            Assert.IsNotNull(result);
            Assert.IsTrue(result.Count > 0);
            Assert.AreEqual(3, result.Count);
            var lastRow = result.LastOrDefault();

            Assert.IsNotNull(lastRow);
            Assert.AreEqual("Korma", lastRow.Curry);
            Assert.AreEqual(2, lastRow.Quantity);
            Assert.AreEqual(12.5M, lastRow.Price);
            Assert.AreEqual(25M, lastRow.Total);
        }
Esempio n. 4
0
 public string[] GetHeaders(string filePath, char delimiter)
 {
     using (var csvProcessor = new CsvMapper <TranslationLabel>(filePath, delimiter))
     {
         return(csvProcessor.GetHeaders());
     }
 }
Esempio n. 5
0
        public void MapByFilePathCustomMappings()
        {
            // arrange
            var mapper = new CsvMapper <CurryOrder>();

            // make sure calling GetHeaders does not affect the result
            mapper.GetHeaders(this.CurryOrderFilePath);
            mapper.GetHeaders(this.CurryOrderFilePath);
            mapper.GetHeaders(this.CurryOrderFilePath);

            // act
            mapper.OnItemDataBound += this.CurryOrder_OnItemDataBound;
            var result = mapper.Map(this.CurryOrderFilePath);

            // assert
            Assert.IsNotNull(result);
            Assert.IsTrue(result.Count > 0);
            Assert.AreEqual(3, result.Count);
            var lastRow = result.LastOrDefault();

            Assert.IsNotNull(lastRow);
            Assert.AreEqual("Korma", lastRow.Curry);
            Assert.AreEqual(2, lastRow.Quantity);
            Assert.AreEqual(12.5M, lastRow.Price);
            Assert.AreEqual(25M, lastRow.Total);
        }
Esempio n. 6
0
        private void ButtonLoadData_Click(object sender, RoutedEventArgs e)
        {
            if (!UpDownLineSkip.Value.HasValue || !UpDownClassCount.Value.HasValue)
            {
                return;
            }

            Mapper = new CsvMapper
            {
                Normalized       = true,
                Separator        = TextBoxColumnSeparator.Text[0],
                DecimalSeparator =
                    CheckBoxDecimalSeparator.IsChecked != null && CheckBoxDecimalSeparator.IsChecked.Value ? '.' : ',',
                SkipRows = (int)UpDownLineSkip.Value.Value
            };

            var openFileDialog = new OpenFileDialog
            {
                Filter      = "csv file (*.csv)|*.csv",
                Multiselect = false
            };

            if (openFileDialog.ShowDialog() != true)
            {
                return;
            }

            var filename = openFileDialog.FileName;

            Data = Mapper.ReadDataFromFile(filename, Convert.ToInt32(UpDownClassCount.Value.Value));

            DataGridHelper.SetTableData(DataGridSet, new TableData(Data));

            ButtonStart.IsEnabled = true;
        }
Esempio n. 7
0
 public CsvReader(Stream stream, bool isHeaderIncluded, char delimeter, CsvMapper mapper)
 {
     this.Mapper    = mapper;
     LineEnumerator = RowReader(stream, delimeter).GetEnumerator();
     if (isHeaderIncluded)
     {
         LineEnumerator.MoveNext();
         mapper.ColumnNames = LineEnumerator.Current;
     }
 }
Esempio n. 8
0
        public void Load_NullConfig_Throws()
        {
            // arrange
            var parser = new CsvParser("Foo,Bar,Baz");
            var mapper = new CsvMapper(parser, _outStream);

            // act

            // assert
            Assert.Throws <ArgumentNullException>(() => mapper.Load((IDictionary <string, IncomingFormat>)null));
        }
Esempio n. 9
0
        public void GetHeadersByFilePath()
        {
            // arrange
            var mapper = new CsvMapper<TranslationLabel>();

            // act
            var result = mapper.GetHeaders(this.TranslationLabelFilePath);

            // assert
            Assert.IsNotNull(result);
            Assert.AreEqual(6, result.Length);
            Assert.AreEqual("Italian", result[4]);
        }
Esempio n. 10
0
        public void GetHeadersByFilePath()
        {
            // arrange
            var mapper = new CsvMapper <TranslationLabel>();

            // act
            var result = mapper.GetHeaders(this.TranslationLabelFilePath);

            // assert
            Assert.IsNotNull(result);
            Assert.AreEqual(6, result.Length);
            Assert.AreEqual("Italian", result[4]);
        }
        public void MappingWithRowLimit2()
        {
            var mapper = new CsvMapper <TestClass>(new MappingOptions
            {
                RowsLimit = 100,
                HasHeader = true
            });
            var items = mapper.Map(TestCsvPath);

            Assert.IsNotNull(items, "Result is null");
            Assert.IsTrue(items.Any(), "Items empty");

            items.SimpleMappingTrace(TestCsvPath);
        }
        public void SimpleMappingByPath()
        {
            var mapper = new CsvMapper <TestClass>(new MappingOptions
            {
                MappingMode = MappingMode.ByNumber,
                HasHeader   = false
            });
            var items = mapper.Map(TestCsvPath);

            Assert.IsNotNull(items, "Result is null");
            Assert.IsTrue(items.Any(), "Items empty");

            items.SimpleMappingTrace(TestCsvPath);
        }
Esempio n. 13
0
        public void map_should_throw_missing_mapping_exception_for_not_mapings()
        {
            //Given
            var csvMapper = new CsvMapper <Employee>();
            var csvLines  = new List <string> {
                "john",
                "mary,[email protected]"
            };

            //When
            Action action = () => csvMapper.Map(csvLines);

            //Then
            action.Should().Throw <MissingMappingException>();
        }
Esempio n. 14
0
        public async Task Remap_Writes_Stream()
        {
            // arrange
            var config = GetTestConfig();
            var parser = GetTestParser().UseHeaders();
            var mapper = new CsvMapper(parser, _outStream);

            mapper.Load(config);

            // act
            await mapper.RemapAsync(',');

            // assert
            Assert.NotEqual(0, _outStream.Length);
        }
        public void SimpleMappingByStream()
        {
            var mapper = new CsvMapper <TestClass>(new MappingOptions {
            });

            using (var fs = new FileStream(TestCsvPath, FileMode.Open))
            {
                var items = mapper.Map(fs);

                Assert.IsNotNull(items, "Result is null");
                Assert.IsTrue(items.Any(), "Result empty");

                items.SimpleMappingTrace(TestCsvPath);
            }
        }
Esempio n. 16
0
        public void create_map_should_add_mapping()
        {
            //Given
            var csvMapper = new CsvMapper <Employee>();

            //when
            csvMapper.CreateMap(0, e => e.Name);

            //then
            csvMapper.IndexPropertyMappings.Should().NotBeNullOrEmpty();
            var mappedProperty = csvMapper.IndexPropertyMappings.First();

            mappedProperty.Index.Should().Be(0);
            mappedProperty.AttributeName.Should().Be("Name");
        }
 public void MappingWithRowLimit()
 {
     try
     {
         var mapper = new CsvMapper <TestClass>(new MappingOptions {
             RowsLimit = 99
         });
         var items = mapper.Map(TestCsvPath);
     }
     catch (TableMappingException ex)
     {
         Trace.WriteLine($"{ex.Message}; Row {ex.Row}");
         return;
     }
     Assert.Fail($"{nameof(TableMappingException)} has not been thrown");
 }
        public void SimpleMappingByPath()
        {
            var mapper = new CsvMapper <TestClass>(
                new MappingOptions
            {
                MappingMode = MappingMode.ByNumber,
                SuppressConvertTypeErrors = false,
                EnableValidation          = true,
                HasHeader = true
            });
            var items = mapper.Map(TestCsvPath);

            Assert.IsNotNull(items, "Result is null");
            Assert.IsTrue(items.Any(), "Items empty");

            items.SimpleMappingTrace(TestCsvPath);
        }
Esempio n. 19
0
        public MappingResponse Map(string filePath, char delimiter, NameValueCollection mappings)
        {
            using (var mapper = new CsvMapper <TranslationLabel>(filePath, delimiter))
            {
                this.mappings           = mappings;
                mapper.OnItemDataBound += CsvProcessor_OnItemDataBound;
                var translationLabels = mapper.MapToClass().Skip(1).ToList();

                var response = new MappingResponse
                {
                    Results     = ReflectionUtility.GetDataTableByReflection <TranslationLabel>(translationLabels),
                    Log         = mapper.Log,
                    SqlFilePath = this.CreateSql(translationLabels)
                };

                return(response);
            }
        }
Esempio n. 20
0
        public void map_should_throw_exception_for_invalid_data()
        {
            //Given
            var csvMapper = new CsvMapper <Employee>();

            csvMapper.CreateMap(0, e => e.Name);
            csvMapper.CreateMap(1, e => e.Email);
            var csvLines = new List <string> {
                "john",
                "mary,[email protected]"
            };

            //When
            Action action = () => csvMapper.Map(csvLines);

            //then
            action.Should().Throw <Exception>();
        }
        public void MappingWithValidation()
        {
            var mapper = new CsvMapper <ValidationTestClass>(new MappingOptions {
                EnableValidation = true
            });

            try
            {
                var items = mapper.Map(ValidationTestCsvPath);
            }
            catch (TableMappingException ex)
            {
                Trace.WriteLine($"{ex.Message}; Row {ex.Row}");
                return;
            }

            Assert.Fail($"{nameof(TableMappingException)} has not been thrown");
        }
        private void cSVImportierenToolStripMenuItem_Click(object sender, EventArgs e)
        {
            // Datei öffnen
            OpenFileDialog ofd = new OpenFileDialog();
            if (ofd.ShowDialog() != DialogResult.OK) return;

            IList<Judoka> jlst = Judoka.List();

            CsvMapper<Judoka> jcsv = new CsvMapper<Judoka>(ofd.FileName);
            jcsv.IgnoreErrors = true;
            List<Judoka> jclst = jcsv.List();

            foreach (Judoka perJ in jlst)
            {
                String perJHash = perJ.GetNameHash(Judoka.HashType.None);

                foreach (Judoka csvJ in jclst)
                {
                    if (perJHash == csvJ.GetNameHash(Judoka.HashType.None))
                    {
                        Console.WriteLine("Persistiert: " + perJ.ToString() + " [" + perJ.Id + "]");
                        csvJ.Id = perJ.Id;
                    }
                }
            }

            foreach (Judoka csvJ in jclst)
            {
                if (csvJ.Id == 0)
                {
                    Console.WriteLine("Nicht Persistent: " + csvJ.ToString());

                    if (csvJ.Geschlecht == null || csvJ.Verein == null || csvJ.Gürtel == null)
                    {
                        MessageBox.Show("Judoka hat Geschlecht, Verein oder Gürtel NULL");
                        continue;
                    }
                    else
                    {
                        csvJ.Save();
                    }
                }
            }
        }
Esempio n. 23
0
        public async Task Remap_IgnoresUnmapped()
        {
            // arrange
            var config = GetTestConfig();
            var parser = GetTestParser().UseHeaders();
            var mapper = new CsvMapper(parser, _outStream);

            mapper.Load(config);
            var outStream = new MemoryStream();

            // act
            await mapper.RemapAsync(',');

            outStream.Seek(0, SeekOrigin.Begin);
            var asText = Encoding.UTF8.GetString(outStream.ToArray());

            // assert
            Assert.DoesNotContain("bat", asText);
        }
        public void MappingWithSuppressConvertTypeErrors()
        {
            try
            {
                var mapper = new CsvMapper <TestClass>(new MappingOptions {
                    SuppressConvertTypeErrors = false
                });
                var items = mapper.Map(SuppressConvertTypeErrorsTestCsvPath);
                Assert.IsNotNull(items, "Result is null");
                Assert.IsTrue(items.Any(), "Items empty");

                items.SimpleMappingTrace(TestCsvPath);
            }
            catch (TableMappingException ex)
            {
                Trace.WriteLine($"{ex.Message}; Row {ex.Row}");
                return;
            }
            Assert.Fail($"{nameof(TableMappingException)} has not been thrown");
        }
Esempio n. 25
0
    public IEnumerable <T> Parse <T>(string fileName) where T : class, new()
    {
        var           lines  = File.ReadLines(fileName);
        CsvMapper <T> mapper = null;

        if (typeof(T) == typeof(Employee))
        {
            mapper = new EmployeeMapper() as CsvMapper <T>;
        }
        if (typeof(T) == typeof(Department))
        {
            mapper = new DepartmentMapper() as CsvMapper <T>;
        }

        if (mapper == null)
        {
            throw new MissingMappingException();
        }

        return(mapper.Map(lines));
    }
Esempio n. 26
0
        public void map_should_map_csv_data()
        {
            //Given
            var csvMapper = new CsvMapper <Employee>();

            csvMapper.CreateMap(0, e => e.Name);
            csvMapper.CreateMap(1, e => e.Email);
            var csvLines = new List <string> {
                "john,[email protected]",
                "mary,[email protected]"
            };

            //When
            var output = csvMapper.Map(csvLines);

            //Then
            output.Should().NotBeNullOrEmpty();
            output.Count().Should().Be(2);
            output.First().Name.Should().Be("john");
            output.First().Email.Should().Be("*****@*****.**");
        }
Esempio n. 27
0
        private void ValidateFile(string file, InputData input)
        {
            var header = System.IO.File.ReadLines(file).First();
            //Validate file is good by validating header record.
            var listOfRequiredWords = new List <string>()
            {
                CsvMapper.GetByDefaultName(CsvMapper.Year),
                CsvMapper.GetByDefaultName(CsvMapper.Month),
            };

            listOfRequiredWords.AddRange(input.DisplayNameToCsvHeader.Values);
            listOfRequiredWords.AddRange(input.DisplayNameOfCapeMeasureToHeader.Values);

            foreach (var item in listOfRequiredWords)
            {
                if (!header.Contains(item))
                {
                    throw new InvalidDataException($"Header of CSV (the first line of the file) does not contain '{item}'.  Header: '{header}'");
                }
            }
        }
        public static void Import(string csv)
        {
            var csvMapper = new CsvMapper();
            var mappings = new Dictionary<string, int>
                {
                    {"StockCode", 0},
                    {"ExDate", 1},
                    {"Amount", 2},
                    {"Franked", 3},
                    {"FrankingCredit", 4},
                    {"PayableDate", 5}
                };

            var stockDividends = csvMapper.MapCsvTo<StockDividend>(mappings, csv, true).ToList();

            UpdateClosingPrices(stockDividends);

            using (var service = new DividendService())
            {
                service.Add(stockDividends);
            }
        }
Esempio n. 29
0
        public virtual MappingResponse Map(List <string> filePaths, NameValueCollection mappings)
        {
            var rows = new List <T>();
            var log  = new List <LogEntry>();

            foreach (var filePath in filePaths)
            {
                var mapper = new CsvMapper <T>();
                rows.AddRange(mapper.Map(filePath, mappings).ToList());
                log.AddRange(mapper.Log);
            }

            this.Rows = rows;

            var response = new MappingResponse
            {
                ResultsAsTable = ReflectionUtility.GetDataTableByReflection <T>(rows),
                Log            = log
            };

            return(response);
        }
Esempio n. 30
0
        public async Task Remap_MutatorWasRun()
        {
            // arrange
            var config = GetTestConfig();
            var parser = GetTestParser().UseHeaders();
            var mapper = new CsvMapper(parser, _outStream);

            mapper.Load(config);

            // act
            await mapper.RemapAsync(',');


            // assert
            _outStream.Seek(0, SeekOrigin.Begin);
            var asText      = Encoding.UTF8.GetString(_outStream.ToArray());
            var lines       = asText.Split(Environment.NewLine);
            var firstRecord = lines[1];
            var fields      = firstRecord.Split(',');

            Assert.Equal("unknown", fields[0]);
        }
Esempio n. 31
0
        public void MapByFilePath()
        {
            // arrange
            var mapper = new CsvMapper<TranslationLabel>();
            var mappings = this.GetTranslationLabelMappings();

            // make sure calling GetHeaders does not affect the result
            mapper.GetHeaders(this.TranslationLabelFilePath);
            mapper.GetHeaders(this.TranslationLabelFilePath);
            mapper.GetHeaders(this.TranslationLabelFilePath);

            // act
            var result = mapper.Map(this.TranslationLabelFilePath, mappings);

            // assert
            Assert.IsNotNull(result);
            Assert.IsTrue(result.Count > 0);
            Assert.AreEqual(22, result.Count);
            var firstRow = result.FirstOrDefault();
            Assert.IsNotNull(firstRow);
            Assert.AreEqual("InfinitiMonthlyPayment", firstRow.LabelName);
        }
Esempio n. 32
0
        public IEnumerable <ReturnData> GetData(InputData input)
        {
            var file = input.FilePath;

            ValidateFile(file, input);

            using (var reader = new StreamReader(file))
                using (var csv = new CsvReader(reader))
                {
                    var records = new List <ReturnData>();
                    csv.Read();
                    csv.ReadHeader();
                    int row = 0;
                    while (csv.Read())
                    {
                        var record = new ReturnData
                        {
                            Year  = csv.Get <int?>(CsvMapper.GetByDefaultName(CsvMapper.Year)),
                            Month = csv.Get <int?>(CsvMapper.GetByDefaultName(CsvMapper.Month)),
                            Row   = row++,
                            NameToPercentageReturn = new Dictionary <string, decimal?>(),
                        };

                        foreach (var item in input.DisplayNameToCsvHeader)
                        {
                            record.NameToPercentageReturn.Add(item.Key, csv.Get(item.Value).ToNumber());
                        }

                        foreach (var item in input.DisplayNameOfCapeMeasureToHeader)
                        {
                            record.NameToCape.Add(item.Key, csv.Get(item.Value).ToNumber());
                        }

                        records.Add(record);
                    }

                    return(records);
                }
        }
Esempio n. 33
0
        public async Task Remap_Writes_TransformedFields()
        {
            // arrange
            var config = GetTestConfig();
            var parser = GetTestParser().UseHeaders();
            var mapper = new CsvMapper(parser, _outStream);

            mapper.Load(config);

            // act
            await mapper.RemapAsync(',');

            // assert
            _outStream.Seek(0, SeekOrigin.Begin);
            var asText    = Encoding.UTF8.GetString(_outStream.ToArray());
            var firstLine = asText.Split(Environment.NewLine, StringSplitOptions.RemoveEmptyEntries)[0];
            var fields    = firstLine.Split(',');

            Assert.Equal("foo-1", fields[0]);
            Assert.Equal("bar-1", fields[1]);
            Assert.Equal("baz-1", fields[2]);
        }
Esempio n. 34
0
        public void MapByFilePath()
        {
            // arrange
            var mapper   = new CsvMapper <TranslationLabel>();
            var mappings = this.GetTranslationLabelMappings();

            // make sure calling GetHeaders does not affect the result
            mapper.GetHeaders(this.TranslationLabelFilePath);
            mapper.GetHeaders(this.TranslationLabelFilePath);
            mapper.GetHeaders(this.TranslationLabelFilePath);

            // act
            var result = mapper.Map(this.TranslationLabelFilePath, mappings);

            // assert
            Assert.IsNotNull(result);
            Assert.IsTrue(result.Count > 0);
            Assert.AreEqual(22, result.Count);
            var firstRow = result.FirstOrDefault();

            Assert.IsNotNull(firstRow);
            Assert.AreEqual("InfinitiMonthlyPayment", firstRow.LabelName);
        }
Esempio n. 35
0
        public void Test2([Values(500)] int iterations, [Values(100)] int columns)
        {
            var testDir  = Path.GetDirectoryName(Path.GetDirectoryName(TestContext.CurrentContext.TestDirectory));
            var dataPath = Path.Combine(testDir ?? throw new NullReferenceException(), "..", "Data", "data.csv");

            var mapper = new CsvMapper();

            var data        = mapper.ReadDataFromFile(dataPath, 1);
            var correlation = Correlation.GetCorrelation(data);

            data = data.RemoveLeastRelevantColumn(correlation, columns);

            var dataSet      = data.SplitData(1, 2, 0);
            var trainingData = dataSet[DataType.Training];
            var testingData  = dataSet[DataType.Testing];

            var neuralNetwork = new NeuralNetwork.NeuralNetwork {
                MinWeight = -5, MaxWeight = 5
            };
            var activationFunction = new SigmoidFunction(-1);

            neuralNetwork.ActivationFunction = activationFunction;
            neuralNetwork.AddLayer(new Layer(10, columns));
            neuralNetwork.AddLayer(new Layer(1, 10));

            var genetic = new GeneticAlgorithm.GeneticAlgorithm(100, neuralNetwork.GetConnectionCount())
            {
                Selection = new TournamentSelection(100, 10),
                Crossover = new TwoPointCrossover(0.65, 100),
                Mutation  = new FlipBitMutation(0.05)
            };

            var keepLooping = true;

            for (var it = 0; it < iterations && keepLooping; it++)
            {
                foreach (var chromosome in genetic.Population)
                {
                    neuralNetwork.SetWeights(chromosome.Genome);

                    Parallel.For(0, trainingData.Attributes.Count, i =>
                    {
                        var res = neuralNetwork.GetResult(trainingData.Attributes[i]);
                        lock (chromosome)
                        {
                            chromosome.Fitness += Math.Abs(res[0] - trainingData.ObjectClass[i]);
                        }
                    });
                }

                keepLooping = !genetic.Population.Any(chromosome => chromosome.Fitness < 5.0);

                Console.WriteLine($@"iteration: {it} | " +
                                  $@"best: {genetic.Population.MinBy(chromosome => chromosome.Fitness).First().Fitness}");

                if (keepLooping && it < iterations - 1)
                {
                    genetic.NextGeneration();
                }
            }

            var best = genetic.Population.MinBy(chromosome => chromosome.Fitness).First();

            neuralNetwork.SetWeights(best.Genome);

            var correct = testingData.Attributes
                          .AsParallel()
                          .Where((t, i) => Math.Abs(neuralNetwork.GetResult(t)[0] - testingData.ObjectClass[i]) < 0.3)
                          .Count();

            Console.WriteLine(
                $@"Population: {100}, iterations: {iterations} - fitness: {best.Fitness:0.0} " +
                $@"| correctly recognized: {correct}/{testingData.Attributes.Count}");
        }
Esempio n. 36
0
        public void MapByFilePathParseValues()
        {
            // arrange
            var mapper = new CsvMapper<CurryOrder>();
            var mappings = new NameValueCollection();
            mappings.Add("Curry", "0");
            mappings.Add("Quantity", "1");
            mappings.Add("Price", "2");
            mappings.Add("Total", "3");

            // make sure calling GetHeaders does not affect the result
            mapper.GetHeaders(this.CurryOrderFilePath);
            mapper.GetHeaders(this.CurryOrderFilePath);
            mapper.GetHeaders(this.CurryOrderFilePath);

            // act
            var result = mapper.Map(this.CurryOrderFilePath, mappings);

            // assert
            Assert.IsNotNull(result);
            Assert.IsTrue(result.Count > 0);
            Assert.AreEqual(3, result.Count);
            var lastRow = result.LastOrDefault();
            Assert.IsNotNull(lastRow);
            Assert.AreEqual("Korma", lastRow.Curry);
            Assert.AreEqual(2, lastRow.Quantity);
            Assert.AreEqual(12.5M, lastRow.Price);
            Assert.AreEqual(25M, lastRow.Total);
        }
Esempio n. 37
0
        public string[] GetHeaders(string filePath)
        {
            var csvProcessor = new CsvMapper <T>();

            return(csvProcessor.GetHeaders(filePath));
        }