示例#1
0
        static void Main()
        {
            //string mtdPath = @"C:\Users\BOX\Desktop\Global_Yearly_1415\CANADA_P&G_MALE GROOMING_ToplineData_Additional_Dec_2014_RE_CS.mtd";
            // @"C:\Users\BOX\Desktop\Global_Yearly_1415\Global_Yearly_1415.mtd";

            OpenFileDialog fileSelectPopUp = new OpenFileDialog();

            fileSelectPopUp.Title = "MTD Select";
            //fileSelectPopUp.InitialDirectory = @"c:\";
            fileSelectPopUp.Filter           = "All MTD FILES (*.mtd*)|*.mtd";
            fileSelectPopUp.FilterIndex      = 2;
            fileSelectPopUp.RestoreDirectory = true;
            if (fileSelectPopUp.ShowDialog() == DialogResult.OK)
            {
                string mtdPath = fileSelectPopUp.FileName;
                var    reader  = new XMLParser();
                var    builder = new CsvBuilder(mtdPath + ".csv");

                reader.LoadMTD(mtdPath);

                reader.MoveToNextTable();
                while (reader.IsInTables)
                {
                    builder.BuildTable(reader.Table);
                    reader.MoveToNextTable();
                }

                reader.Close();
            }
        }
        public void Composition_NotInCollection_ResolvesHeaderName()
        {
            var models = new[]
            {
                new Model
                {
                    Name       = "OK_NAME",
                    TestColors = new[] { new KeyValuePair <string, string>("Green", "One"),
                                         new KeyValuePair <string, string>("Black", "Two"),
                                         new KeyValuePair <string, string>("Red", "Three") }
                }
            };

            var definition =
                new CsvDefinition <Model>(
                    new TextCsvColumn <Model>(e => e.Name),
                    new ObjectCsvColumn <Model>(e => e.TestColor),
                    new CompositeCsvColumn <Model>(e => e.GetTestColors(), "Green", "Purple"))
            {
                FirstRowContainsHeaders = true
            };

            var result = CsvBuilder.Build(definition, models).GetString();

            Assert.AreEqual("\"Name\";\"TestColor\";\"Green\";\"Purple\"\r\n"
                            + "=\"OK_NAME\";0;\"One\";\"\"\r\n", result);
        }
示例#3
0
        public void Adding_data_to_builder_produces_comma_separated_lines()
        {
            // Arrange
            var lines = new List <string>();

            var mockWriter = new Mock <ICsvWriter>();

            mockWriter.Setup(writer => writer.Write(It.IsAny <List <string> >()))
            .Callback <List <string> >(rows => lines = rows);

            var builder = new CsvBuilder();

            // Act
            builder.AppendRow()
            .AppendCell("Id")
            .AppendCell("Title")
            .AppendCell("Year");

            builder.AppendRow()
            .AppendCell("1")
            .AppendCell("Dr. No")
            .AppendCell("1963");

            builder.WriteTo(mockWriter.Object);

            // Assert
            Assert.Equal(expected: 2, actual: lines.Count);
            Assert.Equal(expected: "Id,Title,Year", actual: lines[0]);
            Assert.Equal(expected: "1,Dr. No,1963", actual: lines[1]);
        }
示例#4
0
        public void Serialize(Stream output, object value, bool leaveStreamOpen = true)
        {
            if (output == null)
            {
                throw new ArgumentNullException("output");
            }

            if (value == null)
            {
                throw new ArgumentNullException("value");
            }


            var columnList = GetColumnList(value);

            using (var csv = new CsvBuilder(Settings, output, leaveStreamOpen))
            {
                // Setup Columns
                csv.AddColumns(columnList);

                // Write out row data
                foreach (object rowObject in EnumerateRows(value))
                {
                    var row = csv.AddRow();
                    PopulateRowData(row, rowObject);
                }
            }
        }
        public async Task Execute()
        {
            this.Status = "CSV 変換中...";

            try
            {
                await Task.Run(() =>
                {
                    var context = new CsvBuildingContext
                    {
                        ConvertFrom = this.SrcKind,
                        ConvertTo   = this.DestKind,
                        SrcPath     = this.SrcPath,
                        DestPath    = this.DestPath
                    };

                    var builder = new CsvBuilder(context);
                    builder.Build();
                });
            }
            catch (CsvException ex)
            {
                this.Status = ex.Message;
                return;
            }
            catch
            {
                this.Status = "不明なエラー";
                return;
            }

            this.Status = "出力終了";
        }
示例#6
0
        private void OnSaveAsCSV(object sender, EventArgs e)
        {
            DialogResult result = m_saveFileDialog.ShowDialog();

            if (DialogResult.OK != result)
            {
                return;
            }
            try
            {
                string path = m_saveFileDialog.FileName;

                List <double> volumes = new List <double>();
                foreach (var element in m_settings.Lines)
                {
                    volumes.Add(element.Volume);
                }

                Quotes quotes = m_currentState.Quotes;

                string text = CsvBuilder.Format(m_parameters.LotSize, m_parameters.RoundingStepOfPrice, volumes, quotes);
                using (StreamWriter stream = new StreamWriter(path))
                {
                    stream.Write(text);
                }
            }
            catch (System.Exception ex)
            {
                MessageBox.Show(ex.Message, this.Text, MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
        }
示例#7
0
 public MainForm()
 {
     _formatProvider = CultureInfo.CurrentCulture;
     _fileLog        = new FileLog();
     _csvLog         = new CsvLog(CsvBuilder.BuildHeader(_formatProvider));
     _context        = SynchronizationContext.Current;
     InitializeComponent();
 }
示例#8
0
        public static void IsEqual(CsvBuilder uut,
                                   string[] lines,
                                   CsvBuilder.SortFields sortFields = CsvBuilder.SortFields.ByInsertionOrder)
        {
            var actual = uut.Build(sortFields);

            IsEqual(actual, lines);
        }
示例#9
0
        private void OnThinkGearDataReceived(object sender, EventArgs thinkGearChangedEventArgs)
        {
            try
            {
                if (_controllerBase.IntegrationType == IntegrationType.Arduino)
                {
                    #region Via Arduino

                    var bytesToRead = ((SerialPort)sender).BytesToRead;
                    var elements    = new byte[bytesToRead];
                    ((SerialPort)sender).Read(elements, 0, bytesToRead);
                    var generated = Encoding.ASCII.GetString(elements);
                    _csvLog.RegisterLog(generated);

                    #endregion
                }
                else
                {
                    #region Direct via Neurosky

                    _fileLog.RegisterLog($"Informações Recebidas: {((ThinkGearChangedEventArgs)thinkGearChangedEventArgs).ThinkGearState}");

                    _context.Post(state =>
                    {
                        var data = state as ThinkGearState;
                        if (data == null)
                        {
                            return;
                        }
                        _csvLog.RegisterLog(CsvBuilder.BuildInformation(_formatProvider, data));
                        thinkGearVersionValueLabel.Text = data.Version.ToString(_formatProvider);
                        batteryValueLabel.Text          = data.Battery.ToString(_formatProvider);
                        signalValueLabel.Text           = data.PoorSignal.ToString(_formatProvider);
                        attentionValueLabel.Text        = data.Attention.ToString(_formatProvider);
                        meditationValueLabel.Text       = data.Meditation.ToString(_formatProvider);
                        blinkValueLabel.Text            = "0";
                        blinkValueLabel.Text            = data.BlinkStrength.ToString(_formatProvider);

                        alphaUpperValueLabel.Text = data.Alpha1.ToString(_formatProvider);
                        alphaLowerValueLabel.Text = data.Alpha2.ToString(_formatProvider);
                        betaUpperValueLabel.Text  = data.Beta1.ToString(_formatProvider);
                        betaLowerValueLabel.Text  = data.Beta2.ToString(_formatProvider);
                        gammaUpperValueLabel.Text = data.Gamma1.ToString(_formatProvider);
                        gammaLowerValueLabel.Text = data.Gamma2.ToString(_formatProvider);
                        deltaValueLabel.Text      = data.Delta.ToString(_formatProvider);
                        thetaValueLabel.Text      = data.Theta.ToString(_formatProvider);
                    }, ((ThinkGearChangedEventArgs)thinkGearChangedEventArgs).ThinkGearState);
                    Thread.Sleep(100);

                    #endregion
                }
            }
            catch (Exception exception)
            {
                _fileLog.RegisterLog(Log.RegisterException(exception).ToString());
            }
        }
示例#10
0
 public void Given()
 {
     customers = new List<Customer>
     {
         new Customer { Id = 1, FirstName = "Mike", LastName = "McCarthy" },
         new Customer { Id = 2, FirstName = "Joe", LastName = "Schmoe" }
     };
     var sut = new CsvBuilder<Customer>();
     result = sut.BuildCsvFromListOf(customers, true);
 }
示例#11
0
        public void TestZeroHeadersAndRows()
        {
            var builder = new CsvBuilder();

            byte[] actualBytes        = builder.GetBytes();
            int    expectedByteLength = 0;

            // ensure the two arrays are the same length
            Assert.AreEqual(expectedByteLength, actualBytes.Length,
                            String.Format("Total byte count does not match Expected: '{0}', Actual: '{1}' | {2}", expectedByteLength, (actualBytes.Length), BitConverter.ToString(actualBytes))
                            );
        }
        public string EventsPerDeveloperStatisticAsCsv()
        {
            var csvBuilder = new CsvBuilder();

            foreach (var stat in Statistic)
            {
                csvBuilder.StartRow();
                csvBuilder["Developer"] = stat.Key.Id;
                csvBuilder["Events"]    = stat.Value.Sum(day => day.NumberOfEvents);
            }
            return(csvBuilder.Build());
        }
示例#13
0
        public void mostPopulusStateFromIndiaAndUs()
        {
            string     pathOfUsCencus              = @"D:\trimbak\state analys\USCensusData.csv";
            int        columNumberforUSScensus     = 6;
            string     pathofStateScensus          = @"D:\trimbak\state analys\StateCensusData.csv";
            int        columNumberforIndianScensus = 3;
            int        StringIsCharOrInt           = 1;
            CsvBuilder build  = new CsvBuilder();
            var        outPut = build.SortigOnTwoFile(pathOfUsCencus, columNumberforUSScensus, pathofStateScensus, columNumberforIndianScensus, StringIsCharOrInt);

            Assert.AreEqual("District of Columbia", outPut);
        }
        public string EventsPerDeveloperDayStatisticAsCsv()
        {
            var csvBuilder = new CsvBuilder();

            foreach (var stat in Statistic)
            {
                foreach (var developerDay in stat.Value)
                {
                    csvBuilder.StartRow();
                    csvBuilder["DevDay"] = developerDay.Day.ToString("yyyy-MM-dd") + "_" + stat.Key.Id;
                    csvBuilder["Events"] = developerDay.NumberOfEvents;
                }
            }
            return(csvBuilder.Build());
        }
示例#15
0
        public string StatisticAsCsv()
        {
            var csvBuilder = new CsvBuilder();
            var statistic  = Statistic.OrderByDescending(keyValuePair => keyValuePair.Value.Item1);

            foreach (var stat in statistic)
            {
                csvBuilder.StartRow();

                csvBuilder["Event"]       = stat.Key;
                csvBuilder["AverageTime"] = stat.Value.Item1.ToString("g");
                csvBuilder["Occurences"]  = stat.Value.Item2;
            }

            return(csvBuilder.Build());
        }
        public string StatisticAsCsv()
        {
            RemoveInfrequentMappingsFromStatistic();

            var csvBuilder = new CsvBuilder();
            var statistic  = Statistic.OrderByDescending(keyValuePair => keyValuePair.Value);

            foreach (var stat in statistic)
            {
                csvBuilder.StartRow();

                csvBuilder["FirstCommand"]  = stat.Key.Item1;
                csvBuilder["SecondCommand"] = stat.Key.Item2;
                csvBuilder["Count"]         = stat.Value;
            }
            return(csvBuilder.Build());
        }
示例#17
0
        public void TestBasicHeadersAndRows()
        {
            var builder = new CsvBuilder();

            var headers = new CsvRow();

            headers.AddCell("Header 1");
            headers.AddCell("Header 2");
            headers.AddCell("Header 3");
            headers.AddCell("Header 4");
            headers.AddCell(" Header 5");
            headers.AddCell("Header 6 ");
            headers.AddCell("Header 7");
            builder.AddHeaders(headers);

            var row = new CsvRow();

            row.AddCell("Cell 1 \"with quotes\"");
            row.AddCell("Cell 2 with line break 1\r\nline break 2");
            row.AddCell("Cell 3");
            row.AddCell("Cell, with, commas");
            row.AddCell(" leading space");
            row.AddCell("trailing space ");
            row.AddCell(null);
            builder.AddRow(row);

            byte[] actualBytes   = builder.GetBytes();
            byte[] expectedBytes = System.IO.File.ReadAllBytes("TestBasicHeadersAndRows_Expected.csv");

            // ensure the two arrays are the same length
            Assert.AreEqual(expectedBytes.Length, actualBytes.Length,
                            String.Format("Total byte count does not match Expected: '{0}', Actual: '{1}' | {2}", expectedBytes.Length, (actualBytes.Length), BitConverter.ToString(actualBytes))
                            );

            // ensure the bytes are identical
            for (int i = 0; i < expectedBytes.Length; i++)
            {
                byte expected = expectedBytes[i];
                byte actual   = actualBytes[i];

                Assert.IsTrue(expected == actual,
                              String.Format("Expected: '{0}', Actual: '{1}' at offset {2} | {3}", BitConverter.ToString(new byte[] { (byte)expected }), BitConverter.ToString(new byte[] { (byte)actual }), i, BitConverter.ToString(actualBytes))
                              );
            }
        }
        public string ActivityStreamsToCsv(TimeSpan shortInactivityLimit, TimeSpan longInactivityThreshold)
        {
            var builder = new CsvBuilder();

            foreach (var developerWithStreams in ActivityStreams)
            {
                builder.StartRow();
                builder["Developer"]  = developerWithStreams.Key.Id.ToString();
                builder["ActiveDays"] = developerWithStreams.Value.Count;
                var numberOfInactivities   = 0;
                var inactivityTime         = TimeSpan.Zero;
                var numberOfActivitySprees = 0;
                foreach (var dayWithStream in developerWithStreams.Value)
                {
                    var statistics = dayWithStream.Value.Evaluate(shortInactivityLimit, longInactivityThreshold);
                    foreach (var activityWithDuration in statistics)
                    {
                        builder[dayWithStream.Key.ToString("yyyy-MM-dd") + " " + activityWithDuration.Key] =
                            activityWithDuration.Value.TotalSeconds;
                    }
                    numberOfInactivities += statistics.NumberOfInactivityPeriods;
                    if (statistics.NumberOfInactivityPeriods > 0)
                    {
                        inactivityTime += statistics[Activity.Inactive];
                    }
                    numberOfActivitySprees += statistics.NumberOfInactivityPeriods +
                                              statistics.NumberOfLongInactivityPeriods + 1;
                }
                builder["# of Inactivities"]    = numberOfInactivities;
                builder["inactivity duration"]  = inactivityTime.TotalSeconds;
                builder["# of activity sprees"] = numberOfActivitySprees;
            }
            builder.StartRow();
            foreach (var field in builder.Fields.Skip(2))
            {
                builder[field] = field.Split(' ')[0];
            }
            builder.StartRow();
            foreach (var field in builder.Fields.Skip(2))
            {
                builder[field] = field.Split(' ')[1];
            }
            return(builder.Build(CsvBuilder.SortFields.ByNameLeaveFirst));
        }
示例#19
0
        public string StatisticAsCsv()
        {
            var csvBuilder = new CsvBuilder();
            var statistic  = Statistic.OrderByDescending(keyValuePair => keyValuePair.Value);

            foreach (var stat in statistic)
            {
                csvBuilder.StartRow();

                var eventList = stat.Key.ToList();
                for (var i = 0; i < eventList.Count; i++)
                {
                    csvBuilder["Event" + i] = eventList[i];
                }
                csvBuilder["Count"] = stat.Value;
            }

            return(csvBuilder.Build());
        }
        public string BreakAndSpreeStatisticAsCsv()
        {
            var csvBuilder = new CsvBuilder();

            foreach (var stat in Statistic)
            {
                csvBuilder.StartRow();
                csvBuilder["Developer"] = stat.Key.Id;

                if (stat.Value.Count > 0)
                {
                    var avgBreakTime = stat.Value.Average(day => day.AverageBreakTime.TotalSeconds);
                    var avgSpreeTime = stat.Value.Average(day => day.AverageSpreeTime.TotalSeconds);

                    csvBuilder["break"] = avgBreakTime;
                    csvBuilder["spree"] = avgSpreeTime;
                }
            }
            return(csvBuilder.Build(CsvBuilder.SortFields.ByNameLeaveFirst));
        }
        public string InactivityStatisticToCsv(TimeSpan shortInactivityLimit, params TimeSpan[] longInactivityThresholds)
        {
            var builder = new CsvBuilder();

            foreach (var longInactivityThreshold in longInactivityThresholds)
            {
                var inactivity = TimeSpan.Zero;
                var numberOfInactivityPeriods     = 0;
                var longInactivity                = TimeSpan.Zero;
                var numberOfLongInactivityPeriods = 0;
                var days = 0;
                foreach (var developerWithStreams in ActivityStreams)
                {
                    foreach (var dayWithStream in developerWithStreams.Value)
                    {
                        days++;
                        var statistic = dayWithStream.Value.Evaluate(shortInactivityLimit, longInactivityThreshold);
                        numberOfInactivityPeriods += statistic.NumberOfInactivityPeriods;
                        if (statistic.NumberOfInactivityPeriods > 0)
                        {
                            inactivity += statistic[Activity.Inactive];
                        }
                        numberOfLongInactivityPeriods += statistic.NumberOfLongInactivityPeriods;
                        if (statistic.NumberOfLongInactivityPeriods > 0)
                        {
                            longInactivity += statistic[Activity.InactiveLong];
                        }
                    }
                }
                builder.StartRow();
                builder["Threshold (ms)"]         = longInactivityThreshold.TotalSeconds;
                builder["Inactivity (ms)"]        = inactivity.TotalSeconds;
                builder["# of Inactivities"]      = numberOfInactivityPeriods;
                builder["Long Inactivity (ms)"]   = longInactivity.TotalSeconds;
                builder["# of Long Inactivities"] = numberOfLongInactivityPeriods;
                builder["Days"] = days;
            }
            return(builder.Build());
        }
        public string DeveloperDayStatisticToCsv(TimeSpan shortInactivityLimit, TimeSpan longInactivityThreshold)
        {
            var builder = new CsvBuilder();

            foreach (var developerWithStreams in ActivityStreams)
            {
                foreach (var dayWithStream in developerWithStreams.Value)
                {
                    builder.StartRow();
                    var statistic = dayWithStream.Value.Evaluate(shortInactivityLimit, longInactivityThreshold);
                    builder["DevDay"] = dayWithStream.Key.ToString("yyyy-MM-dd") + "_" + developerWithStreams.Key.Id;
                    foreach (var activityWithDuration in statistic)
                    {
                        builder[activityWithDuration.Key.ToString()] = activityWithDuration.Value.TotalSeconds;
                    }
                    builder["Inactivities"]     = statistic.NumberOfInactivityPeriods;
                    builder["LongInactivities"] = statistic.NumberOfLongInactivityPeriods;
                }
            }

            return(builder.Build());
        }
        public string StatisticAsCsv()
        {
            var csvBuilder = new CsvBuilder();

            foreach (var stat in Statistic)
            {
                csvBuilder.StartRow();
                csvBuilder["Developer"] = stat.Key.Id;
                foreach (var day in stat.Value)
                {
                    var dayString = day.Day.ToString("yyyy-MM-dd");
                    csvBuilder[dayString + " 1 Start"]       = day.FirstActivityAt.TimeOfDay;
                    csvBuilder[dayString + " 2 End"]         = day.LastActivityAt.TimeOfDay;
                    csvBuilder[dayString + " 3 Events"]      = day.NumberOfEvents;
                    csvBuilder[dayString + " 4 Breaks"]      = day.NumberOfBreaks;
                    csvBuilder[dayString + " 5 Total Break"] = (int)day.TotalBreakTime.TotalSeconds;
                }
                csvBuilder["#Days"]       = stat.Value.Count;
                csvBuilder["Total Break"] = stat.Value.Select(day => (int)day.TotalBreakTime.TotalSeconds).Sum();
            }
            return(csvBuilder.Build(CsvBuilder.SortFields.ByNameLeaveFirst));
        }
        public void Convert_builder_to_table()
        {
            // Arrange
            var builder = new CsvBuilder();

            builder.AppendRow()
            .AppendCell("Id")
            .AppendCell("Title")
            .AppendCell("Year");

            builder.AppendRow()
            .AppendCell("1")
            .AppendCell("Dr. No")
            .AppendCell("1963");

            // Act
            var table = builder.ToTable();

            // Assert
            Assert.Equal(expected: 1, actual: table.Rows.Count());
            Assert.Equal(expected: "Dr. No", actual: table.Rows[0].Cells[1].Value);
        }
示例#25
0
        public static CsvBuilder ToBuilder(this CsvTable table)
        {
            var builder = new CsvBuilder();

            var builderHeader = builder.AppendRow();

            foreach (var cell in table.Header.Cells)
            {
                builderHeader.AppendCell(cell.Value);
            }

            foreach (var row in table.Rows)
            {
                var builderRow = builder.AppendRow();
                foreach (var cell in row.Cells)
                {
                    builderRow.AppendCell(cell.Value);
                }
            }

            return(builder);
        }
示例#26
0
 public async Task<MemoryStream> Handle(ExportFileQuery request, CancellationToken cancellationToken)
 {
     return CsvBuilder.ExportHelper(_repository.GetTransactionsByParameters, request.Status, request.Type);
 }
示例#27
0
 public void CreateBuilder()
 {
     _uut = new CsvBuilder();
 }
示例#28
0
 public async Task <Unit> Handle(ImportFileCommand request, CancellationToken cancellationToken)
 {
     CsvBuilder.ImportHelper(_repository.AddOrUpdateTransactions, request.File);
     return(Unit.Value);
 }
示例#29
0
 public void Given()
 {
     var sut = new CsvBuilder<AClass>();
     var classes = new List<AClass>
     {
         new AClass
         {
             AClassProperty = "AClassProperty",
             NestedClass = new NestedClass
             {
                 NestedClassProperty = "NestedClassProperty",
                 NestedNestedClass = new NestedNestedClass
                 {
                     NestedNestedClassProperty = "NestedNestedClassProperty"
                 }
             }
         }
     };
     result = sut.BuildCsvFromListOf(classes, true);
 }
示例#30
0
 public static CsvTable ToTable(this CsvBuilder builder)
 => CsvTable.ReadFrom(() => builder.ToLines());
示例#31
0
            public void Given()
            {
                var list = new List<AClassWithAllValueTypesAsProperties>
                {
                    new AClassWithAllValueTypesAsProperties
                    {
                        Object = anObject,
                        Bool = true,
                        BookStruct = new BookStruct { Author = "BookStruct author", Price = 100, Title = "BookStruct title" },
                        Byte = new byte(),
                        Char = new char(),
                        DateTime = dateTimeNow,
                        Decimal = 1,
                        Double = 2d,
                        BookType = BookType.Fiction,
                        Float = 3,
                        Guid = guid,
                        Int = 4,
                        Long = 5,
                        Sbyte = new sbyte(),
                        Short = 6,
                        UInt = 7,
                        Ulong = 8,
                        Ushort = 9,
                        String = "string",
                        NestedNestedClass = new NestedNestedClass { NestedNestedClassProperty = "PropertyValueForNestedNestedClassProperty" }
                    }
                };

                var sut = new CsvBuilder<AClassWithAllValueTypesAsProperties>();
                result = sut.BuildCsvFromListOf(list, true);
            }