Exemple #1
0
        public void SmokeTest()
        {
            var csvLine1 = "A;B;C";
            var csvLine2 = "a1;b1;c1";
            var csvLine3 = "a2;b2;c2";

            var csvLineReader = new CsvLineParser();

            var csvTableReader = new CsvLineTableReader(csvLineReader);

            Assert.NotNull(csvTableReader);

            csvTableReader.ReadHeaders(csvLine1);

            Assert.Equal(3, csvTableReader.Headers.Count);
            Assert.Equal("A", csvTableReader.Headers[0]);
            Assert.Equal("B", csvTableReader.Headers[1]);
            Assert.Equal("C", csvTableReader.Headers[2]);

            csvTableReader.Read(csvLine2);

            Assert.Equal(3, csvTableReader.Headers.Count);
            Assert.Equal("a1", csvTableReader[0]);
            Assert.Equal("b1", csvTableReader[1]);
            Assert.Equal("c1", csvTableReader[2]);

            csvTableReader.Read(csvLine3);

            Assert.Equal(3, csvTableReader.Headers.Count);
            Assert.Equal("a2", csvTableReader["A"]);
            Assert.Equal("b2", csvTableReader["B"]);
            Assert.Equal("c2", csvTableReader["C"]);
        }
Exemple #2
0
        public void TestJsonValues()
        {
            var csvLine2 = "42;\"{\"\"IntValue\"\":42,\"\"StrValue\"\":\"\"Forty-Two\"\"}\"";
            var csvLine3 = "5;\"{\"\"IntValue\"\":5,\"\"StrValue\"\":\"\"Five\"\"}\"";

            var csvLineReader = new CsvLineParser();

            var csvTableReader = new CsvLineTableReader(csvLineReader, "A", "B");

            Assert.NotNull(csvTableReader);

            csvTableReader.AddConverter <CustomType>(new CustomTypeConverter());

            Assert.Equal(2, csvTableReader.Headers.Count);
            Assert.Equal("A", csvTableReader.Headers[0]);
            Assert.Equal("B", csvTableReader.Headers[1]);

            csvTableReader.Read(csvLine2);

            Assert.Equal(42, csvTableReader.GetValue <int>("A"));
            var o1 = csvTableReader.GetValue <CustomType>("B");

            Assert.Equal(42, o1.IntValue);
            Assert.Equal("Forty-Two", o1.StrValue);

            csvTableReader.Read(csvLine3);

            Assert.Equal(5, csvTableReader.GetValue <int>("A"));
            var o2 = csvTableReader.GetValue <CustomType>("B");

            Assert.Equal(5, o2.IntValue);
            Assert.Equal("Five", o2.StrValue);
        }
        public void Ensures_GivenValidLine_ResultsInValidIShare()
        {
            var    lineParser = new CsvLineParser();
            IShare share      = lineParser.ParseLine("04.03.2013;7.654,67;7.708,88;7.637,32;7.691,68;2.148.781.568");

            Assert.That(share.Datum, Is.EqualTo(new DateTime(2013, 3, 4)));
        }
        public ExportStudent(Configuration config, XlsReader xlsReader)
        {
            xlsReader.TryGetValue(config.GetXlsColumnName("Vorname"), out FirstName);
            xlsReader.TryGetValue(config.GetXlsColumnName("Mittelname"), out MiddleName);
            xlsReader.TryGetValue(config.GetXlsColumnName("Nachname"), out LastName);
            xlsReader.TryGetValue(config.GetXlsColumnName("Geburtstag"), out BirthDate);
            xlsReader.TryGetValue(config.GetXlsColumnName("Rufname"), out NickName);
            xlsReader.TryGetValue(config.GetXlsColumnName("Geschlecht"), out Gender);
            xlsReader.TryGetValue(config.GetXlsColumnName("Anrede"), out Salutation);

            if (xlsReader.TryGetValue(config.GetXlsColumnName("Name"), out string name))
            {
                var csvLineParser = new CsvLineParser(' ');

                var parts = csvLineParser.Read(name);

                if (parts.Length == 2)
                {
                    FirstName = parts[0];
                    LastName  = parts[1];
                }
                else if (parts.Length == 3)
                {
                    FirstName  = parts[0];
                    MiddleName = parts[1];
                    LastName   = parts[2];
                }
            }

            if (!xlsReader.TryGetValue(config.GetXlsColumnName("Id"), out Id))
            {
                Id = GenerateId();
            }
        }
Exemple #5
0
        public void ParseLine_InvalidDateTimeFormat_Exception()
        {
            CsvLineParser lineParser  = new CsvLineParser(TestInitializationFactory.GenerateFakeColumnTypes());
            string        lineToParse = "2018ax01-03 12:00:00, 1,2,3,4,5";

            Assert.Catch(() => lineParser.ParseLine(lineToParse));
        }
        private async Task <int> ExportTeachers(CsvTableReader csvTableReader, EcfTableWriter ecfTableWriter, string[] ecfHeaders)
        {
            var ecfCache         = new HashSet <string>();
            var ecfRecordCounter = 0;

            await csvTableReader.ReadHeadersAsync();

            if (ecfHeaders != null && ecfHeaders.Length > 0)
            {
                await ecfTableWriter.WriteHeadersAsync(ecfHeaders);
            }
            else
            {
                await ecfTableWriter.WriteHeadersAsync(
                    EcfHeaders.Id,
                    EcfHeaders.Code);
            }

            while (await csvTableReader.ReadAsync() > 0)
            {
                if (csvTableReader.TryGetValue("Alle Lehrkräfte (Kürzel) mit Fach", out var value))
                {
                    var csvLineParser = new CsvLineParser(',');

                    var subValues = csvLineParser.Read(value);

                    csvLineParser.Configuration.Separator = ' ';

                    foreach (var subValue in subValues)
                    {
                        if (!string.IsNullOrEmpty(subValue))
                        {
                            var subValueParts = csvLineParser.Read(subValue.Trim());
                            if (subValueParts.Length == 2)
                            {
                                var teacherCode = subValueParts[0];

                                if (!string.IsNullOrEmpty(teacherCode) && !ecfCache.Contains(teacherCode))
                                {
                                    ecfTableWriter.TrySetValue(EcfHeaders.Id, teacherCode);
                                    ecfTableWriter.TrySetValue(EcfHeaders.Code, teacherCode);

                                    await ecfTableWriter.WriteAsync();

                                    ecfCache.Add(teacherCode);
                                    ecfRecordCounter++;
                                }
                            }
                        }
                    }
                }
            }

            return(ecfRecordCounter);
        }
        public void CreateSystem(XbimModel model, string classificationName)
        {
            //set model in which the systems are to be created
            _model = model;
            string data = null;

            //try to get data from resources

            //get list of classifications available
            var dir = Directory.EnumerateFiles("Classifications");
            string clasPath = null;
            foreach (var f in dir)
            {
                if (Path.GetFileNameWithoutExtension(f).ToLower() == classificationName.ToLower())
                {
                    clasPath = f;
                    break;
                }
            }
            if (clasPath == null)
                throw new ArgumentException("Specified classification doesn't exist");
            var clasName = Path.GetFileNameWithoutExtension(clasPath);

            //get data
            data = File.ReadAllText(clasPath);

            CsvLineParser parser = null;
            if (clasName.Contains("NRM"))
            {
                parser = new CsvLineParser(';');
            }
            else
                parser = new CsvLineParser();

            //create classification source
            var action = new Action<XbimModel>(m => {
                var source = model.Instances.New<IfcClassification>(c =>
                {
                    c.Source = clasName;
                    c.Edition = "Default edition";
                    c.Name = clasName;
                });
                ParseCSV(data, parser, source);
            });

            //process file
            if (_model.IsTransacting)
                action(_model);
            else
                using (var txn = model.BeginTransaction("Systems creation"))
                {
                    action(_model);
                    txn.Commit();
                }
        }
Exemple #8
0
        public async Task TestThat_GetCoffeeShopLocation_When_ValidationDoesNotFail_Returns_NotNullLocation()
        {
            // Arrange
            var csvLineParser = new CsvLineParser();

            // Act
            var location = await csvLineParser.GetCoffeeShopLocation(MockObjects.ValidCsvLine1);

            // Assert
            Assert.NotNull(location);
        }
Exemple #9
0
        public async Task TestThat_GetCoffeeShopLocation_When_ValidatorDoesNotFail_Returns_LocationWithExpectedValues()
        {
            var csvLineParser = new CsvLineParser();

            // Act
            var location = await csvLineParser.GetCoffeeShopLocation(MockObjects.ValidCsvLine99);

            // Assert
            Assert.Equal(MockObjects.ShopLocation99.X, location.X);
            Assert.Equal(MockObjects.ShopLocation99.Y, location.Y);
            Assert.Equal(MockObjects.ShopLocation99.Tag, location.Tag);
        }
Exemple #10
0
        public async Task TestThat_GetCoffeeShopLocation_When_CsvLineHasErrorOnPositionTwo_Throws_DataValidationExceptionWithExpectedMessage()
        {
            // Arrange
            var csvLineParser = new CsvLineParser();

            // Act
            async Task Act() => await csvLineParser.GetCoffeeShopLocation(MockObjects.Token2ErrorCsvLine);

            // Assert
            var exception = await Assert.ThrowsAsync <DataValidationException>(Act);

            Assert.Equal(MockValues.IncorrectValuePosition2CsvLineExceptionMessage, exception.Message);
        }
Exemple #11
0
        public async Task TestThat_GetCoffeeShopLocation_When_CsvLineHasMoreThanThreeTokens_Throws_DataValidationExceptionWithExpectedMessage()
        {
            // Arrange
            var csvLineParser = new CsvLineParser();

            // Act
            async Task Act() => await csvLineParser.GetCoffeeShopLocation(MockObjects.MoreThanThreeTokensCsvLine);

            // Assert
            var exception = await Assert.ThrowsAsync <DataValidationException>(Act);

            Assert.Equal(MockValues.IncorrectNumberOfTokensCsvLineExceptionMessage, exception.Message);
        }
Exemple #12
0
        public async Task TestThat_GetCoffeeShopLocation_When_CsvLineIsEmpty_Throws_DataValidationExceptionWithExpectedMessage()
        {
            // Arrange
            var csvLineParser = new CsvLineParser();

            // Act
            async Task Act() => await csvLineParser.GetCoffeeShopLocation(MockObjects.StringNullCsvLine);

            // Assert
            var exception = await Assert.ThrowsAsync <DataValidationException>(Act);

            Assert.Equal(MockValues.NullOrEmptyCsvLineExceptionMessage, exception.Message);
        }
Exemple #13
0
        public void ParseLine_ValidLineParse_Success()
        {
            CsvLineParser lineParser  = new CsvLineParser(TestInitializationFactory.GenerateFakeColumnTypes());
            string        lineToParse = "2018-01-03 12:00:00, 1,2,3,4,5";
            DataObject    result      = lineParser.ParseLine(lineToParse);

            Assert.AreEqual(result.Columns.Length, 6);
            Assert.AreEqual(result.Columns[0].GetType(), typeof(DateTime));
            for (int i = 1; i < 6; i++)
            {
                Assert.AreEqual(result.Columns[i].GetType(), typeof(int));
                Assert.AreEqual(result.Columns[i], i);
            }
        }
Exemple #14
0
        public void TestTypedValues()
        {
            var csvLine1 = "A;B;C;D";
            var csvLine2 = "22;Text;true;01.01.2010";
            var csvLine3 = "-31;A long text;false;20.01.2050";
            var csvLine4 = "55;\"A text with ;\";;31.07.1971";

            var csvLineReader = new CsvLineParser();

            var csvTableReader = new CsvLineTableReader(csvLineReader);

            Assert.NotNull(csvTableReader);

            csvTableReader.SetFormats <DateTime>("dd.MM.yyyy");

            csvTableReader.ReadHeaders(csvLine1);

            Assert.Equal(4, csvTableReader.Headers.Count);
            Assert.Equal("A", csvTableReader.Headers[0]);
            Assert.Equal("B", csvTableReader.Headers[1]);
            Assert.Equal("C", csvTableReader.Headers[2]);
            Assert.Equal("D", csvTableReader.Headers[3]);

            csvTableReader.Read(csvLine2);

            Assert.Equal(22, csvTableReader.GetValue <int>("A"));
            Assert.Equal("Text", csvTableReader.GetValue <string>("B"));
            Assert.True(csvTableReader.GetValue <bool>("C"));
            Assert.Equal(new DateTime(2010, 1, 1), csvTableReader.GetValue <DateTime>("D"));

            csvTableReader.Read(csvLine3);

            Assert.Equal(-31, csvTableReader.GetValue <int>("A"));
            Assert.Equal("A long text", csvTableReader.GetValue <string>("B"));
            Assert.False(csvTableReader.GetValue <bool>("C"));
            Assert.Equal(new DateTime(2050, 1, 20), csvTableReader.GetValue <DateTime>("D"));

            csvTableReader.Read(csvLine4);

            Assert.True(csvTableReader.TryGetValue <int>("A", out var a));
            Assert.Equal(55, a);
            Assert.True(csvTableReader.TryGetValue <string>("B", out var b));
            Assert.Equal("A text with ;", b);
            Assert.True(csvTableReader.TryGetValue <bool?>("C", out var c));
            Assert.Null(c);
            Assert.True(csvTableReader.TryGetValue <DateTime>("D", out var d));
            Assert.Equal(new DateTime(1971, 7, 31), d);
        }
        public void SupportConvertingEmptyLine()
        {
            var textLine = "";

            var csvParser = new CsvLineParser();
            {
                Assert.NotNull(csvParser);

                var fieldsArray = csvParser.Read(textLine);
                Assert.Single(fieldsArray);

                var fieldsList = new List <string>();
                csvParser.Read(textLine, fieldsList);
                Assert.Single(fieldsList);
            }
        }
        public void SupportConvertingToArray()
        {
            var textLine = "aaa1;bbb1;ccc1";

            var csvParser = new CsvLineParser();
            {
                Assert.NotNull(csvParser);

                var fields = csvParser.Read(textLine);

                Assert.Equal(3, fields.Count());
                Assert.Equal("aaa1", fields[0]);
                Assert.Equal("bbb1", fields[1]);
                Assert.Equal("ccc1", fields[2]);
            }
        }
        public void SupportConvertingToCollection()
        {
            var textLine = "aaa1;bbb1;ccc1";

            var csvParser = new CsvLineParser();
            {
                Assert.NotNull(csvParser);

                var fields = new List <string>();

                csvParser.Read(textLine, fields);

                Assert.Equal(3, fields.Count);
                Assert.Equal("aaa1", fields[0]);
                Assert.Equal("bbb1", fields[1]);
                Assert.Equal("ccc1", fields[2]);
            }
        }
Exemple #18
0
        public void TestTryGetValue()
        {
            var csvLine1 = "A;B;C";
            var csvLine2 = "a1;b1;c1";
            var csvLine3 = "a2;b2;c2";

            var csvLineReader = new CsvLineParser();

            var csvTableReader = new CsvLineTableReader(csvLineReader);

            Assert.NotNull(csvTableReader);

            csvTableReader.ReadHeaders(csvLine1);

            csvTableReader.Read(csvLine2);

            Assert.Equal(3, csvTableReader.Headers.Count);
            Assert.True(csvTableReader.TryGetValue(0, out string v1));
            Assert.Equal("a1", v1);
            Assert.True(csvTableReader.TryGetValue(1, out string v2));
            Assert.Equal("b1", v2);
            Assert.True(csvTableReader.TryGetValue(2, out string v3));
            Assert.Equal("c1", v3);
            Assert.False(csvTableReader.TryGetValue(3, out string v4));
            Assert.Null(v4);

            csvTableReader.Read(csvLine3);

            Assert.Equal(3, csvTableReader.Headers.Count);
            Assert.True(csvTableReader.TryGetValue("A", out string v5));
            Assert.Equal("a2", v5);
            Assert.True(csvTableReader.TryGetValue("B", out string v6));
            Assert.Equal("b2", v6);
            Assert.True(csvTableReader.TryGetValue("C", out string v7));
            Assert.Equal("c2", v7);
            Assert.False(csvTableReader.TryGetValue("D", out string v8));
            Assert.Null(v8);
        }
Exemple #19
0
        private void ParseCSV(string data, CsvLineParser parser, IfcClassification source)
        {
            TextReader csvReader = new StringReader(data);

            //header line
            string        line       = csvReader.ReadLine();
            CsvLineParser lineParser = parser;

            lineParser.ParseHeader(line);

            //get first line of data
            line = csvReader.ReadLine();

            while (line != null)
            {
                //parse line
                Line parsedLine = lineParser.ParseLine(line);

                //create IFC object
                IfcSystem system         = GetOrCreateSystem(parsedLine.Code, parsedLine.Description);
                var       classification = GetOrCreateClassificationReference(parsedLine.Code, parsedLine.Description, source);

                //set up hierarchy
                if (system == null)
                {
                    continue;
                }
                IfcSystem parentSystem = GetOrCreateSystem(parsedLine.ParentCode);
                if (parentSystem != null)
                {
                    parentSystem.AddObjectToGroup(system);
                }

                //read new line to be processed in the next step
                line = csvReader.ReadLine();
            }
        }
        private async Task <int> ExportStudentSubjects(CsvTableReader csvTableReader, EcfTableWriter ecfTableWriter, string[] ecfHeaders)
        {
            var ecfRecordCounter = 0;

            await csvTableReader.ReadHeadersAsync();

            if (ecfHeaders != null && ecfHeaders.Length > 0)
            {
                await ecfTableWriter.WriteHeadersAsync(ecfHeaders);
            }
            else
            {
                await ecfTableWriter.WriteHeadersAsync(
                    EcfHeaders.StudentId,
                    EcfHeaders.SchoolClassId,
                    EcfHeaders.SubjectId,
                    EcfHeaders.TeacherId);
            }

            while (await csvTableReader.ReadAsync() > 0)
            {
                var student     = new CsvExportStudent(csvTableReader);
                var schoolClass = new CsvExportSchoolClass(csvTableReader);

                if (csvTableReader.TryGetValue("Alle Lehrkräfte (Kürzel) mit Fach", out var value))
                {
                    var csvLineParser = new CsvLineParser(',');

                    var subValues = csvLineParser.Read(value);

                    csvLineParser.Configuration.Separator = ' ';

                    foreach (var subValue in subValues)
                    {
                        if (!string.IsNullOrEmpty(subValue))
                        {
                            var subValueParts = csvLineParser.Read(subValue.Trim());
                            if (subValueParts.Length == 2)
                            {
                                var teacherCode = subValueParts[0];
                                var subjectCode = subValueParts[1];

                                if (!string.IsNullOrEmpty(subjectCode))
                                {
                                    ecfTableWriter.TrySetValue(EcfHeaders.StudentId, student.Id);
                                    ecfTableWriter.TrySetValue(EcfHeaders.SchoolClassId, schoolClass.Id);
                                    ecfTableWriter.TrySetValue(EcfHeaders.SubjectId, subjectCode);
                                    ecfTableWriter.TrySetValue(EcfHeaders.TeacherId, teacherCode);

                                    await ecfTableWriter.WriteAsync();

                                    ecfRecordCounter++;
                                }
                            }
                        }
                    }
                }
            }

            return(ecfRecordCounter);
        }
Exemple #21
0
        public void CreateSystem(XbimModel model, string classificationName)
        {
            //set model in which the systems are to be created
            _model = model;
            string data = null;

            //try to get data from resources

            //get list of classifications available
            var    dir      = Directory.EnumerateFiles("Classifications");
            string clasPath = null;

            foreach (var f in dir)
            {
                if (Path.GetFileNameWithoutExtension(f).ToLower() == classificationName.ToLower())
                {
                    clasPath = f;
                    break;
                }
            }
            if (clasPath == null)
            {
                throw new ArgumentException("Specified classification doesn't exist");
            }
            var clasName = Path.GetFileNameWithoutExtension(clasPath);


            //get data
            data = File.ReadAllText(clasPath);


            CsvLineParser parser = null;

            if (clasName.Contains("NRM"))
            {
                parser = new CsvLineParser(';');
            }
            else
            {
                parser = new CsvLineParser();
            }


            //create classification source
            var action = new Action <XbimModel>(m => {
                var source = model.Instances.New <IfcClassification>(c =>
                {
                    c.Source  = clasName;
                    c.Edition = "Default edition";
                    c.Name    = clasName;
                });
                ParseCSV(data, parser, source);
            });


            //process file
            if (_model.IsTransacting)
            {
                action(_model);
            }
            else
            {
                using (var txn = model.BeginTransaction("Systems creation"))
                {
                    action(_model);
                    txn.Commit();
                }
            }
        }
        private void ParseCSV(string data, CsvLineParser parser, IfcClassification source)
        {
            TextReader csvReader = new StringReader(data);

            //header line
            string line = csvReader.ReadLine();
            CsvLineParser lineParser = parser;
            lineParser.ParseHeader(line);

            //get first line of data
            line = csvReader.ReadLine();

            while (line != null)
            {
                //parse line
                Line parsedLine = lineParser.ParseLine(line);

                //create IFC object
                IfcSystem system = GetOrCreateSystem(parsedLine.Code, parsedLine.Description);
                var classification = GetOrCreateClassificationReference(parsedLine.Code, parsedLine.Description, source);

                //set up hierarchy
                if (system == null) continue;
                IfcSystem parentSystem = GetOrCreateSystem(parsedLine.ParentCode);
                if (parentSystem != null) parentSystem.AddObjectToGroup(system);

                //read new line to be processed in the next step
                line = csvReader.ReadLine();
            }
        }
        public void Ensures_GivenNullValueToParse_ExepectArgumentNullException()
        {
            var lineParser = new CsvLineParser();

            Assert.Throws <ArgumentNullException>(() => lineParser.ParseLine(null));
        }