public void CanBuildACsvDefinitionByAddingHeadersDirectly()
{
var objUt = new CsvDefinition();
objUt.AddHeaders("Column 1", "Column 2", "TOTAL");
Assert.NotEmpty(objUt.Headers);
Assert.Equal(3, objUt.Headers.Count);
}
public void AddHeadersAndAddRowReturnsTheCsvDefinitionToEnableChaining()
{
var objUt = new CsvDefinition()
.AddHeaders("Column 1", "Column 2", "TOTAL")
.AddRow(10, 20, 30)
.AddRow(11, 21, 31);
Assert.NotEmpty(objUt.Rows);
Assert.Equal(2, objUt.Rows.Count);
}
/// <summary>
/// Gets the object for the provided data.
/// </summary>
public static CsvDefinition Get(string[] headers, params object[][] rows)
{
var definition = new CsvDefinition()
.AddHeaders(headers);
foreach (var row in rows)
{
definition.AddRow(row);
}
return(definition);
}
private void AddHeader <T>(IXLWorksheet worksheet, CsvDefinition <T> definition, T[] rows, int rowid)
{
var headers = definition.Columns.SelectMany(column => GetHeaderNames <T>(definition, column, rows)).ToArray();
var row = worksheet.Row(rowid);
var colid = 1;
foreach (var header in headers)
{
row.Cell(colid).Value = header;
colid++;
}
}
public void Build_WithoutHeaderNames_NamesAreReflected()
{
var definition = new CsvDefinition <TestRow>(
new TextCsvColumn <TestRow>(e => e.Name))
{
FirstRowContainsHeaders = true,
WriteBitOrderMarker = false
};
var result = CsvWriter.CreateStream <TestRow>(definition, oneRow).GetString();
Assert.AreEqual("\"Name\"\r\n\"OK_NAME\"\r\n", result);
}
public void Build_NoHeaderNamesInFirstRow_HeaderRowIsSkipped()
{
var definition = new CsvDefinition <TestRow>(
new TextCsvColumn <TestRow>(e => e.Name))
{
FirstRowContainsHeaders = false,
WriteBitOrderMarker = false
};
var result = CsvWriter.CreateStream <TestRow>(definition, oneRow).GetString();
Assert.AreEqual("\"OK_NAME\"\r\n", result);
}
public void Composition_NotInCollection_ThrowsException()
{
var rows = this.GetCompositeRows();
var definition =
new CsvDefinition <CompositeTestModel>(
new TextCsvColumn <CompositeTestModel>(e => e.Name),
new ObjectCsvColumn <CompositeTestModel>(e => e.TestColor),
new CompositeCsvColumn <CompositeTestModel, string>(e => e.GetTestColors(), Header1, "NotInCollection"))
{
FirstRowContainsHeaders = true
};
var result = CsvWriter.CreateStream(definition, rows).GetString();
}
public void Reading_WithStringBasedProperty_ReturnsResult()
{
var def = new CsvDefinition <TestModel>(new TextCsvColumn <TestModel>("Name"))
{
FirstRowContainsHeaders = true,
ElementDelimiter = ";",
HasFieldsEnclosedInQuotes = true,
Encoding = Encoding.UTF8
};
var data = "\"Name\";\"TestColors\"\r\n\"OK_NAME\";\"Red\"";
var mapper = new TableDataMapper <TestModel>(def);
var result = mapper.FromStream(new MemoryStream(Encoding.UTF8.GetBytes(data)));
Assert.AreEqual("OK_NAME", result[0].Name);
}
public void Composition_FromPropertyWithAllHeaderNames_ResolvesAllHeaderName()
{
var rows = new[] {
new DynamicTestModel
{
Name = "Main name",
Columns = new[] { new TestColumn {
Name = "Test One", Type = 1, Value = "One"
}, new TestColumn {
Name = "Test Two", Type = 2, Value = "Two"
} }
}
};
var definition =
new CsvDefinition <DynamicTestModel>(
new TextCsvColumn <DynamicTestModel>(e => e.Name),
new DynamicCsvColumn <DynamicTestModel, TestColumn>(e => e.Columns, column =>
{
if (column.Type == 1)
{
return(new TextCsvColumn <TestColumn>(sf => sf.Value)
{
HeaderName = column.Name
});
}
else if (column.Type == 2)
{
return(new TextCsvColumn <TestColumn>(sf => sf.Value)
{
HeaderName = column.Name, Format = (v, c) => v.ToString()
});
}
throw new InvalidOperationException();
}))
{
FirstRowContainsHeaders = true,
WriteBitOrderMarker = false
};
var result = CsvWriter.CreateStream(definition, rows).GetString();
Assert.AreEqual("\"Name\";\"Test One\";\"Test Two\"\r\n\"Main name\";\"One\";\"Two\"\r\n", result);
}
public void CanBuildACsvDefinitionByAddingARowDirectly()
{
var objUt = new CsvDefinition();
objUt.AddHeaders("Column 1", "Column 2", "TOTAL");
objUt.AddRow(10, 20, 30);
objUt.AddRow(11, 21, 31);
Assert.NotEmpty(objUt.Rows);
Assert.Equal(2, objUt.Rows.Count);
Assert.Equal(objUt.Headers[0], objUt.Rows[0][0].Header);
Assert.Equal(objUt.Headers[1], objUt.Rows[0][1].Header);
Assert.Equal(objUt.Headers[2], objUt.Rows[0][2].Header);
Assert.Equal(objUt.Headers[0], objUt.Rows[1][0].Header);
Assert.Equal(objUt.Headers[1], objUt.Rows[1][1].Header);
Assert.Equal(objUt.Headers[2], objUt.Rows[1][2].Header);
}
public void CompositeProperty_WithoutHeadernames_ShouldGenerateHeadernames()
{
var rows = this.GetCompositeRows();
var definition =
new CsvDefinition <CompositeTestModel>(
new TextCsvColumn <CompositeTestModel>(e => e.Name),
new ObjectCsvColumn <CompositeTestModel>(e => e.TestColor),
new CompositeCsvColumn <CompositeTestModel, string>(e => e.GetTestColors())) //// Purple is not in the source
{
FirstRowContainsHeaders = true,
WriteBitOrderMarker = false
};
var result = CsvWriter.CreateStream(definition, rows).GetString();
Assert.AreEqual("\"Name\";\"TestColor\";\"Header1\";\"Header2\";\"Header3\"\r\n"
+ "\"OK_NAME\";0;\"ValueOne\";\"ValueTwo\";\"ValueThree\"\r\n", result);
}
public void Composition_FromPropertyWithAllHeaderNames_ResolvesAllHeaderName()
{
var rows = this.GetCompositeRows();
var definition =
new CsvDefinition <CompositeTestModel>(
new TextCsvColumn <CompositeTestModel>(e => e.Name),
new ObjectCsvColumn <CompositeTestModel>(e => e.TestColor),
new CompositeCsvColumn <CompositeTestModel, string>(e => e.TestColors, Header1, Header2, Header3))
{
FirstRowContainsHeaders = true,
WriteBitOrderMarker = false
};
var result = CsvWriter.CreateStream(definition, rows).GetString();
Assert.AreEqual("\"Name\";\"TestColor\";\"Header1\";\"Header2\";\"Header3\"\r\n"
+ "\"OK_NAME\";0;\"ValueOne\";\"ValueTwo\";\"ValueThree\"\r\n", result);
}
private static void InMemoryFileWithNoHeader()
{
Console.WriteLine("Test In Memory File With No Header");
var csvDefinition = new CsvDefinition
{
Header = "ClientId|FirstName|LastName|Occupation|City",
FieldSeparator = '|'
};
var csvWithNoHeader = new CsvFileReader<Client>(
new StringReader("1|Pascal|Ganaye|CodeMonkey|Macon\r" +
"2|Mick|Jagger|Singer|Dartford"), csvDefinition
);
foreach (var c in csvWithNoHeader)
Console.WriteLine(string.Format("Client #{0}: {1} ({2} in {3})",
c.ClientId,
c.FirstName + (string.IsNullOrEmpty(c.MiddleName) ? " " : " " + c.MiddleName + " ") + c.LastName,
c.Occupation,
c.City));
}
public void Render_ForceExcelTextCell_AddsSingleQuote()
{
var rows = this.GetModelRows();
var definition =
new CsvDefinition <ColorArrayModel>(
new TextCsvColumn <ColorArrayModel>(e => e.Name)
{
ForceNumberToTextFormatting = true
})
{
FirstRowContainsHeaders = true,
WriteBitOrderMarker = false
};
var result = CsvWriter.CreateStream(definition, rows).GetString();
Assert.AreEqual("\"Name\"\r\n"
+ "=\"OK_NAME\"\r\n", result);
}
public void ACsvDefinitionWithACellForANonExistentHeaderIsInvalid()
{
var objUt = new CsvDefinition();
objUt.Headers.AddItems("Column 1", "Column 2", "TOTAL");
objUt.Rows.AddItems(
new CsvRow
{
new CsvCell("Column 1", 10),
new CsvCell("Column 2", 20),
new CsvCell("TOTAL", 30)
},
new CsvRow
{
new CsvCell("Column 1", 11),
new CsvCell("Column 2", 21),
new CsvCell("Column 3", 31)
});
Assert.False(objUt.Validate());
}
public void CanValidateACsvDefinition()
{
var objUt = new CsvDefinition();
objUt.Headers.AddItems("Column 1", "Column 2", "TOTAL");
objUt.Rows.AddItems(
new CsvRow
{
new CsvCell("Column 1", 10),
new CsvCell("Column 2", 20),
new CsvCell("TOTAL", 30)
},
new CsvRow
{
new CsvCell("Column 1", 11),
new CsvCell("Column 2", 21),
new CsvCell("TOTAL", 31)
});
Assert.True(objUt.Validate());
}
/// <summary>
/// Writes the array according to the specified definition.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="rows">The rows.</param>
/// <param name="definition">The definition.</param>
public void Write <T>(Stream stream, T[] rows, CsvDefinition <T> definition)
{
var writer = new StreamWriter(stream, definition.Encoding);
WriteBitOrderMarker <T>(stream, definition);
if (definition.FirstRowContainsHeaders)
{
this.AddHeader <T>(writer, definition, rows);
}
foreach (var row in rows)
{
this.AddLine <T>(writer, definition, row);
}
writer.Flush();
stream.Flush();
}
public static void ImportHeaderHistory(object sender, DoWorkEventArgs e)
{
string filename = e.Argument as string;
BackgroundWorker worker = sender as BackgroundWorker;
Dictionary<string, Dictionary<DateTime, string>> HeaderRoutes = new Dictionary<string,Dictionary<DateTime,string>>();
CsvDefinition def = new CsvDefinition() { FieldSeparator = ',' };
CsvFileReader<HeaderHistory> reader = new CsvFileReader<HeaderHistory>(filename, def);
string traincode = "";
int count = 0;
foreach(HeaderHistory hh in reader)
{
if(hh.trainDate < new DateTime(2010,1,1)){count++; continue;}
if (hh.trainCode != traincode)
{
worker.ReportProgress(0, "Processing... HeaderCode : " + hh.trainCode + " Lines Processed : " + count.ToString());
HeaderRoutes.Add(hh.trainCode, new Dictionary<DateTime, string>());
traincode = hh.trainCode;
}
HeaderRoutes[traincode].Add(hh.trainDate, hh.trainRoute);
}
DataContainer.NeuralNetwork.HeaderRoutes = HeaderRoutes;
}
protected MetadataCsvAbstract(string filename)
{
Filename = filename;
Definition = CsvDefinition.SemiColumnDoubleQuote();
}
private static HeaderCollection GetHeaderNames <T>(CsvDefinition <T> definition, ICsvColumn <T> column, T[] rows)
{
return(column.GetWritingHeaderNames(rows));
}
public static void ImportDelayCombinations(object sender, DoWorkEventArgs e)
{
string filename = e.Argument as string;
BackgroundWorker worker = sender as BackgroundWorker;
DataContainer.NeuralNetwork.DelayCombinations = new Data.DelayCombinationCollection();
CsvDefinition def = new CsvDefinition() { FieldSeparator = ',' };
CsvFileReader<Record> reader = new CsvFileReader<Record>(filename, def);
DateTime date = new DateTime();
DelayDay day = new DelayDay();
int count = 0;
foreach (Record record in reader)
{
if (record.trainDate != date)
{
if (DataContainer.NeuralNetwork.DelayCombinations.dict.ContainsKey(date))
{
DataContainer.NeuralNetwork.DelayCombinations.dict[date].AddRange(day.FormCombinations());
}
else
{
DataContainer.NeuralNetwork.DelayCombinations.dict.Add(date, day.FormCombinations());
}
date = record.trainDate;
day = new DelayDay();
worker.ReportProgress(0, new string[] { record.trainDate.ToString(), count.ToString() });
}
//if (record.delayCode != string.Empty)// || record.difference > 120)
//{
Delay delay = new Delay();
delay.traincode = record.trainCode;
delay.WLCheader = record.WLCTrainCode;
delay.date = record.trainDate;
delay.delaycode = record.delayCode;
if (record.locationType == "D") { delay.destinationdelay = record.difference; }
else { delay.origindelay = record.difference; }
if (day.delays.ContainsKey(delay.traincode)) { ((Delay)day.delays[delay.traincode]).destinationdelay = delay.destinationdelay; }
else { day.delays.Add(delay.traincode, delay); }
//}
count++;
}
}
public void WhenAddingHeadersTheHeadersAreRequired()
{
var objUt = new CsvDefinition();
Assert.Throws <ArgumentException>("headers", () => objUt.AddHeaders());
}
public ResultSetCsvWriter(string persistancePath, CsvDefinition definition)
: base(persistancePath)
{
Definition = definition;
}
public ResultSetCsvReader(CsvDefinition definition)
{
Definition = definition;
}
public ResultSetCsvReader(CsvDefinition definition)
{
Definition = definition;
}
public ResultSetCsvWriter(string persistancePath) : base(persistancePath)
{
Definition = CsvDefinition.SemiColumnDoubleQuote();
}
public ResultSetCsvReader() : this(CsvDefinition.SemiColumnDoubleQuote())
{
}
public ResultSetCsvWriter(string persistancePath, CsvDefinition definition) : base(persistancePath)
{
Definition = definition;
}
public static void TimetableFromCsv(object sender, DoWorkEventArgs e)
{
DateTime ThresholdDate = new DateTime(2010, 1, 1);
if (DataContainer.model == null)
{
DataContainer.model = new railml();
}
DataContainer.model.timetable = new timetable();
Dictionary <string, int> categories = new Dictionary <string, int>();
string filename = e.Argument as string;
BackgroundWorker worker = sender as BackgroundWorker;
CsvDefinition def = new CsvDefinition()
{
FieldSeparator = ','
};
CsvFileReader <TimetableEntry> reader = new CsvFileReader <TimetableEntry>(filename, def);
int count = 0;
RuntimeRep rep = new RuntimeRep();
List <StopDelay> stopdelays = new List <StopDelay>();
string traincode = "";
foreach (TimetableEntry entry in reader)
{
if (entry.TrainDate < ThresholdDate)
{
count++; continue;
}
string category = entry.TrainOrigin + "to" + entry.TrainDestination;
if (categories.ContainsKey(category))
{
categories[category] = (int)categories[category] + 1;
}
else
{
categories.Add(category, 1);
//eCategory cat = new eCategory();
//cat.id = category;
//cat.name = category;
//DataContainer.model.timetable.categories.Add(cat);
//eRostering roster = new eRostering();
//DataContainer.IDGenerator(roster);
//roster.name = category;
//DataContainer.model.timetable.rosterings.Add(roster);
}
if (entry.TrainDate != date || entry.TrainCode != traincode)
{
AddStopDelays(stopdelays, traincode, date);
stopdelays = new List <StopDelay>();
if (rep.traincode != null)
{
trainvariations.AddRep(rep, date);
}
if (entry.TrainCode != traincode)
{
if (trainvariations != null)
{
string cat = categories.FirstOrDefault(x => x.Value == categories.Values.Max()).Key;
trainvariations.category = cat;
categories = new Dictionary <string, int>();
if (!DataContainer.model.timetable.rosterings.Any(x => x.name == cat))
{
eRostering roster = new eRostering()
{
name = cat,
scope = "scheduled"
};
DataContainer.IDGenerator(roster);
DataContainer.model.timetable.rosterings.Add(roster);
}
ProcessTimetableVariations(trainvariations);
}
trainvariations = new TrainVariations();
trainvariations.traincode = entry.TrainCode;
worker.ReportProgress(0, new string[] { traincode, count.ToString() });
traincode = entry.TrainCode;
}
rep = new RuntimeRep();
date = entry.TrainDate;
rep.traincode = entry.TrainCode;
rep.destination = entry.TrainDestination;
rep.origin = entry.TrainOrigin;
}
if (entry.LocationType == "O")
{
rep.departuretime = default(DateTime).Add(entry.ScheduledDeparture.TimeOfDay);
}
else if (entry.LocationType == "D")
{
rep.arrivaltime = default(DateTime).Add(entry.ScheduledArrival.TimeOfDay);
}
else if (entry.LocationType == "S")
{
Stop stop = new Stop()
{
location = entry.LocationCode, arrival = entry.ScheduledArrival, departure = entry.ScheduledDeparture
};
rep.stops.Add(stop);
if (entry.Arrival != default(DateTime) && entry.Departure != default(DateTime))
{
StopDelay delay = new StopDelay()
{
location = entry.LocationCode, departuredelay = (entry.Departure - entry.ScheduledDeparture).TotalSeconds, arrivaldelay = (entry.Arrival - entry.ExpectedArrival).TotalSeconds
};
stopdelays.Add(delay);
}
}
//if (count > 300000) { break; }
count++;
}
// Append the last trainvariation to the totalvariations list
if (trainvariations != null)
{
string cat = categories.FirstOrDefault(x => x.Value == categories.Values.Max()).Key;
trainvariations.category = cat;
categories = new Dictionary <string, int>();
ProcessTimetableVariations(trainvariations);
if (!DataContainer.model.timetable.rosterings.Any(x => x.name == cat))
{
eRostering roster = new eRostering()
{
name = cat,
scope = "scheduled"
};
DataContainer.IDGenerator(roster);
DataContainer.model.timetable.rosterings.Add(roster);
}
}
e.Result = unhandled;
}
private IEnumerable <string> GetHeaderNames <T>(CsvDefinition <T> definition, ICsvColumn <T> column, T[] rows)
{
return(column.GetWritingHeaderNames(rows).Select(header => GetColumnHeaderWithoutEnters(header)));
}
private void AddHeader <T>(StreamWriter writer, CsvDefinition <T> definition, T[] rows)
{
var headers = definition.Columns.SelectMany(column => GetHeaderNames <T>(definition, column, rows)).ToArray();
writer.WriteLine(string.Join(definition.ElementDelimiter, headers));
}
void cellStrings_should_escapeSpecialChars(string input, string expected)
{
var result = CsvDefinition <DemoModel> .Escape(input, escapeChars);
Assert.Equal(expected, result);
}
public static void ImportDelayCombinations(object sender, DoWorkEventArgs e)
{
string filename = e.Argument as string;
BackgroundWorker worker = sender as BackgroundWorker;
DataContainer.NeuralNetwork.DelayCombinations = new Data.DelayCombinationCollection();
CsvDefinition def = new CsvDefinition()
{
FieldSeparator = ','
};
CsvFileReader <Record> reader = new CsvFileReader <Record>(filename, def);
DateTime date = new DateTime();
DelayDay day = new DelayDay();
int count = 0;
foreach (Record record in reader)
{
if (record.trainDate != date)
{
if (DataContainer.NeuralNetwork.DelayCombinations.dict.ContainsKey(date))
{
DataContainer.NeuralNetwork.DelayCombinations.dict[date].AddRange(day.FormCombinations());
}
else
{
DataContainer.NeuralNetwork.DelayCombinations.dict.Add(date, day.FormCombinations());
}
date = record.trainDate;
day = new DelayDay();
worker.ReportProgress(0, new string[] { record.trainDate.ToString(), count.ToString() });
}
//if (record.delayCode != string.Empty)// || record.difference > 120)
//{
Delay delay = new Delay();
delay.traincode = record.trainCode;
delay.WLCheader = record.WLCTrainCode;
delay.date = record.trainDate;
delay.delaycode = record.delayCode;
if (record.locationType == "D")
{
delay.destinationdelay = record.difference;
}
else
{
delay.origindelay = record.difference;
}
if (day.delays.ContainsKey(delay.traincode))
{
((Delay)day.delays[delay.traincode]).destinationdelay = delay.destinationdelay;
}
else
{
day.delays.Add(delay.traincode, delay);
}
//}
count++;
}
}
private void AddLine <T>(StreamWriter writer, CsvDefinition <T> definition, T item)
{
var values = definition.Columns.SelectMany(e => e.Render(definition, item, definition.FormattingCulture, formatter)).ToArray();
writer.WriteLine(string.Join(definition.ElementDelimiter, values));
}
