public static void AssertColumnDataInt(CsvDoc doc, string columnName, int startingRowIndex, int startingValue, int increment)
{
// Iterate over each cell in column.
doc.ForEach <int>(columnName, 0, (row, col, val) =>
{
Assert.AreEqual(startingValue, val);
startingValue += increment;
});
}
/// <summary>
/// Map the objects.
/// </summary>
/// <param name="source"></param>
/// <param name="errors"></param>
/// <returns></returns>
public IList <T> Map(object source, IErrors errors)
{
if (source == null || source.GetType() != typeof(CsvDoc))
{
return(new List <T>());
}
_doc = source as CsvDoc;
return(Map(errors));
}
public void CanParseCsvNoHeader(string filePath, string delimeter, string nonAlphaNumericTextExpected)
{
string text = ContentLoader.GetTextFileContent(filePath);
CsvDoc csv = Csv.LoadText(text, false, false, delimeter);
// Check the csv data.
CsvCheck.AssertColumnDataInt(csv, "0", 0, 1, 1);
CsvCheck.AssertColumnData(csv, "1", 0, nonAlphaNumericTextExpected);
CsvCheck.AssertColumnData(csv, "2", 0, @"C:\pictures\100_01.JPG");
CsvCheck.AssertColumnDataDate(csv, "3", 0, DateTime.Parse("4/10/2009"), 1);
}
public void CanParseCsv_WithNewLines()
{
string expected = "Testing" + Environment.NewLine + "new line";
string text = ContentLoader.GetTextFileContent("Csv.Csv_MultiLine.csv");
CsvDoc csv = Csv.LoadText(text, true);
// Check the csv data.
CsvCheck.AssertColumnDataInt(csv, "Id", 0, 1, 1);
CsvCheck.AssertColumnData(csv, "NonAlphaNumeric", 0, @"(`~!@#$%^&*()_+-=[]\{}|<>?./;:)");
CsvCheck.AssertColumnData(csv, "Description", 0, expected);
CsvCheck.AssertColumnDataDate(csv, "Date", 0, DateTime.Parse("4/10/2009"), 1);
}
public void CanParseFailed1()
{
string text = "Id,Name" + Environment.NewLine
+ "0,Art";
CsvDoc doc = Csv.LoadText(text, true);
Assert.IsTrue(doc.Columns.Contains("Id"));
Assert.IsTrue(doc.Columns.Contains("Name"));
Assert.AreEqual(doc.Get <string>(0, "Id"), "0");
Assert.AreEqual(doc.Get <string>(0, "Name"), "Art");
}
/// <summary>
/// Run the application.
/// </summary>
public override BoolMessageItem Execute()
{
//<doc:example>
// See CommonLibrary.UnitTests Source code for actual csv files.
string text = GetSampleCsv();
CsvDoc csv = Csv.LoadText(text, true);
// 1. Get cell at row 0, column 1
string cell0 = csv.Get <string>(0, 1);
// 2. Get cell at row 0, column called "FilePath"
string cell2 = csv.Get <string>(0, "FilePath");
// 3. Number of columns
var colCount = csv.Columns.Count;
// 4. Number of rows
var rowCount = csv.Data.Count;
// 5. Column name at index 2
var col2 = csv.Columns[1];
// 6. Get int id at row 2
var id = csv.Get <int>(2, 0);
// 7. Iterate over all the cells in column named "Date" starting at row 0.
csv.ForEach <DateTime>("Date", 0, (row, col, val) =>
{
Console.WriteLine(string.Format("Row[{0}]Col[{1}] : {2}", row, col, val.ToString()));
});
// 8. Get the csv data as a datatable.
DataTable table = csv.ToDataTable("My_Sample_Data");
// 9. Iterate over rows / columns
for (int row = 0; row < csv.Data.Count; row++)
{
for (int col = 0; col < csv.Columns.Count; col++)
{
string cellVal = csv.Data[row][col] as string;
}
}
//</doc:example>
return(BoolMessageItem.True);
}
public void CanParseCsvAndGetTypedVal()
{
string text = "'Id', 'Name', 'Desc'" + Environment.NewLine
+ "'0', 'Art', 'Art class'" + Environment.NewLine
+ "'1', 'Sports', 'all sports'";
CsvDoc doc = Csv.LoadText(text, true);
Assert.IsTrue(doc.Columns.Contains("Id"));
Assert.IsTrue(doc.Columns.Contains("Name"));
Assert.IsTrue(doc.Columns.Contains("Desc"));
Assert.AreEqual(doc.Get <string>(0, "Id"), "0");
Assert.AreEqual(doc.Get <string>(0, "Name"), "Art");
Assert.AreEqual(doc.Get <string>(0, "Desc"), "Art class");
Assert.AreEqual(doc.Get <string>(1, "Id"), "1");
Assert.AreEqual(doc.Get <string>(1, "Name"), "Sports");
Assert.AreEqual(doc.Get <string>(1, "Desc"), "all sports");
}
public void CanParseCsv()
{
string text = "'Id', 'Name', 'Desc'" + Environment.NewLine
+ "'0', 'Art', 'Art class'" + Environment.NewLine
+ "'1', 'Sports', 'all sports'";
CsvDoc doc = Csv.LoadText(text, true);
Assert.IsTrue(doc.Columns.Contains("Id"));
Assert.IsTrue(doc.Columns.Contains("Name"));
Assert.IsTrue(doc.Columns.Contains("Desc"));
Assert.IsTrue(string.Compare((string)doc.Data[0]["Id"], "0") == 0);
Assert.IsTrue(string.Compare((string)doc.Data[0]["Name"], "Art") == 0);
Assert.IsTrue(string.Compare((string)doc.Data[0]["Desc"], "Art class") == 0);
Assert.IsTrue(string.Compare((string)doc.Data[1]["Id"], "1") == 0);
Assert.IsTrue(string.Compare((string)doc.Data[1]["Name"], "Sports") == 0);
Assert.IsTrue(string.Compare((string)doc.Data[1]["Desc"], "all sports") == 0);
}
public void DoCsvLoad()
{
// This is a LEXICAL parser.
// So this can handle quoted and non-quoted values
// where the separator "," can be inside the quotes such as in 'Art, Classes'
string csv = "Id, Name, 'Desc'" + Environment.NewLine
+ "0, Art, 'Art classes'" + Environment.NewLine
+ "1, Painting, 'Any type of painting' " + Environment.NewLine
+ "2, Sports, 'Sports classes'" + Environment.NewLine
+ "3, Boxing, 'Boxing classes'";
CsvDoc doc = new CsvDoc(csv, false);
Logger.Info("====================================================");
Logger.Info("CSV FILES ");
Logger.Info("Columns : " + doc.Columns.ToString());
Logger.Info("Row 1 - Col 1 : " + doc.Data[0][0]);
Logger.Info("Row 2 - Col 2: " + doc.Data[1][1]);
Logger.Info("Row 3['Name'] : " + doc.Data[2]["name"].ToString());
Logger.Info(Environment.NewLine);
}
public void CanParseCsv(string filePath, char delimeter, string nonAlphaNumericTextExpected, bool expectEscapedQuote)
{
string text = ContentLoader.GetTextFileContent(filePath);
text = CultureInfoHelper.FixDates(text);
CsvDoc csv = Csv.LoadText(text, true, false, delimeter);
// Check the csv data.
CsvCheck.AssertColumnDataInt(csv, "Id", 0, 1, 1);
CsvCheck.AssertColumnData(csv, "NonAlphaNumeric", 0, nonAlphaNumericTextExpected);
if (!expectEscapedQuote)
{
CsvCheck.AssertColumnData(csv, "FilePath", 0, @"C:\pictures\100_01.JPG");
}
else
{
CsvCheck.AssertColumnData(csv, "FilePath", 0, @"C"":\pictures\100_01.JPG");
}
CsvCheck.AssertColumnDataDate(csv, "Date", 0, DateTime.Parse(CultureInfoHelper.FixDates("4/10/2009")), 1);
}
public void CanMapFromCsv()
{
var csv = LoadDataCsv();
var io = new ImportExportService <Conference>();
CsvDoc data = new CsvDoc(csv, false);
var boolresult = io.LoadText(csv, "csv");
var result = boolresult.Item;
Assert.AreEqual(result[0].Title, data.Get <string>(0, "Title"));
Assert.AreEqual(result[0].StartDate.Date, DateTime.Today.Date);
Assert.AreEqual(result[0].StartTime, new TimeSpan(21, 30, 0));
Assert.AreEqual(result[0].IsFree, true);
Assert.AreEqual(result[0].MaxSeats, data.Get <int>(0, "MaxSeats"));
Assert.AreEqual(result[0].Cost, 250);
Assert.AreEqual(result[0].Url, data.Get <string>(0, "Url"));
Assert.AreEqual(result[1].Title, data.Get <string>(1, "Title"));
Assert.AreEqual(result[1].StartDate.Date, DateTime.Today.AddDays(4).Date);
Assert.AreEqual(result[1].StartTime, new TimeSpan(11, 30, 0));
Assert.AreEqual(result[1].IsFree, false);
Assert.AreEqual(result[1].MaxSeats, data.Get <int>(1, "MaxSeats"));
Assert.AreEqual(result[1].Cost, 251);
Assert.AreEqual(result[1].Url, data.Get <string>(1, "Url"));
}
/// <summary>
/// Map items from the dictionary data to items of Type T.
/// Each key in the data corresponds to a nested IDictionary which contains key/value
/// pairs representing the properties/values of the type T.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="path"></param>
/// <returns></returns>
public static IList <T> MapCsvFile <T>(string path) where T : class, new()
{
var doc = new CsvDoc(path, true);
return(MapCsv <T>(doc));
}
/// <summary>
/// Map items from the dictionary data to items of Type T.
/// Each key in the data corresponds to a nested IDictionary which contains key/value
/// pairs representing the properties/values of the type T.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="data">The data.</param>
/// <returns></returns>
public static IList <T> MapCsv <T>(CsvDoc data) where T : class, new()
{
return(MapCsv <T>(data, null));
}
/// <summary>
/// Map items from the dictionary data to items of Type T.
/// Each key in the data corresponds to a nested IDictionary which contains key/value
/// pairs representing the properties/values of the type T.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="data">The data.</param>
/// <returns></returns>
public static IList <T> MapCsv <T>(string data) where T : class, new()
{
CsvDoc doc = new CsvDoc(data, false);
return(MapCsv <T>(doc, null));
}
/// <summary>
/// Initialize with csv doc.
/// </summary>
/// <param name="doc"></param>
public MapperCsv(CsvDoc doc)
{
_doc = doc;
}
