private static void TrimValues(CsvFileLine csvFileLine)
{
for (var i = 0; i < csvFileLine.Values.Length; i++)
{
csvFileLine.Values[i] = csvFileLine.Values[i].Trim();
}
}
public void WhenOneValue_ThenSetValuesAndLine()
{
var sut = new CsvFileLine(new [] { "John" });
Assert.That(sut.Values.Single(), Is.EqualTo("John"));
Assert.That(sut.Line, Is.EqualTo("John"));
}
private static IList <CsvFileLine> ReadCsvFile(string file, CsvFileReaderOptions options)
{
var fileLines = new List <CsvFileLine>();
using (var reader = new StreamReader(File.OpenRead(file)))
{
while (!reader.EndOfStream)
{
var line = reader.ReadLine();
if (line == null)
{
continue;
}
var csvFileLine = new CsvFileLine(line);
if (options.EnableTrimValues)
{
TrimValues(csvFileLine);
}
fileLines.Add(csvFileLine);
}
}
return(fileLines);
}
/// <summary>
/// Write a body to a file.
/// </summary>
/// <param name="file">Path to CSV file.</param>
/// <param name="body">CSV file body to write.</param>
/// <param name="existingHasHeader">True the existing CSV file has a header; otherwise does not have a header.</param>
/// <exception cref="T:System.ArgumentNullException"><paramref name="body" /> is null.</exception>
public void WriteBody(string file, CsvFileBody body, bool existingHasHeader = true)
{
if (body == null)
{
throw new ArgumentNullException(nameof(body));
}
if (!body.HasLines)
{
return;
}
CsvFileLine header = null;
if (existingHasHeader)
{
header = ReadHeader(file);
}
using (var writer = new StreamWriter(file))
{
if (header != null)
{
writer.WriteLine(header);
}
foreach (var line in body.Lines)
{
writer.WriteLine(line.Line);
}
}
}
public void WhenIsNotEmpty_ThenReturnFalse()
{
var sut = new CsvFileLine(Line);
var result = sut.IsEmpty;
Assert.That(result, Is.False);
}
public void WhenIsEmpty_ThenReturnTrue()
{
var sut = new CsvFileLine(string.Empty);
var result = sut.IsEmpty;
Assert.That(result, Is.True);
}
public void WhenEmpty_ThenReturnZero()
{
var sut = new CsvFileLine(string.Empty);
var result = sut.ValuesCount;
Assert.That(result, Is.EqualTo(0));
}
public void WhenLinesAreNotEqual_ThenReturnFalse()
{
var line = new CsvFileLine(Line + ",Blah");
var result = Act(line);
Assert.That(result, Is.False);
}
public void WhenValidValues_ThenSetLine()
{
var sut = new CsvFileLine(Values);
var result = sut.Line;
Assert.That(result, Is.EqualTo(Line));
}
public void WhenValuesIsEmpty_ThenLineReturnsEmpty()
{
var sut = new CsvFileLine(string.Empty);
var result = sut.Line;
Assert.That(result, Is.Empty);
}
public void WhenLinesAreEqual_ThenReturnTrue()
{
var line = new CsvFileLine(Line);
var result = Act(line);
Assert.That(result, Is.True);
}
public void WhenValueIsEscapedWithDoubleQuotes_ThenTreatAsSingleValue()
{
var sut = new CsvFileLine(new [] { "list, of, items", "222" });
Assert.That(sut.Values.First(), Is.EqualTo("list, of, items"));
Assert.That(sut.Values.Second(), Is.EqualTo("222"));
Assert.That(sut.Line, Is.EqualTo("\"list, of, items\",222"));
}
public void WhenValuesContainCommas_ThenTreatCommasAsEscaped()
{
var sut = new CsvFileLine(new[] { ",", ",,", ",,," });
Assert.That(sut.Values.First(), Is.EqualTo(","));
Assert.That(sut.Values.Second(), Is.EqualTo(",,"));
Assert.That(sut.Values.Third(), Is.EqualTo(",,,"));
Assert.That(sut.Line, Is.EqualTo("\",\",\",,\",\",,,\""));
}
public void WhenValidValues_ThenSetValues()
{
var sut = new CsvFileLine(Values);
var result = sut.Values;
Assert.That(result.First(), Is.EqualTo(Values.First()));
Assert.That(result.Second(), Is.EqualTo(Values.Second()));
Assert.That(result.Third(), Is.EqualTo(Values.Third()));
}
public void WhenValuesIsEmpty_ThenValuesReturnsEmpty()
{
string[] values = new string[0];
var sut = new CsvFileLine(values);
var result = sut.Values;
Assert.That(result.Length, Is.EqualTo(0));
}
public void WhenValueHasOpenEscapedQuoteOnly_ThenTreatNotAsSingleValue()
{
var sut = new CsvFileLine("\"list,of,items");
Assert.That(sut.Values.First(), Is.EqualTo("\"list"));
Assert.That(sut.Values.Second(), Is.EqualTo("of"));
Assert.That(sut.Values.Third(), Is.EqualTo("items"));
Assert.That(sut.Line, Is.EqualTo("\"list,of,items"));
}
/// <summary>
/// Write a line to a CSV file.
/// </summary>
/// <param name="file">Path to CSV file.</param>
/// <param name="line">CSV line to write.</param>
/// <exception cref="T:System.ArgumentNullException"><paramref name="line" /> is null.</exception>
public void AppendLine(string file, CsvFileLine line)
{
if (line == null)
{
throw new ArgumentNullException(nameof(line));
}
using (var writer = new StreamWriter(file, true))
{
writer.WriteLine(line);
}
}
/// <summary>
/// Writes a header to a file.
/// </summary>
/// <param name="file">Path to CSV file.</param>
/// <param name="header">CSV file header to write.</param>
/// <exception cref="T:System.ArgumentNullException"><paramref name="header" /> is null.</exception>
public void WriteHeader(string file, CsvFileLine header)
{
if (header == null)
{
throw new ArgumentNullException(nameof(header));
}
var body = ReadBody(file);
using (var writer = new StreamWriter(file))
{
writer.WriteLine(header);
foreach (var line in body)
{
writer.WriteLine(line.Line);
}
}
}
private void Act(CsvFileLine line)
{
_sut.AppendLine(_file, line);
}
private void Act(CsvFileLine header)
{
_sut.WriteHeader(_file, header);
}
static void Main(string[] args)
{
Console.WriteLine("Converting CSV to JSON");
CsvFileLine FileData = null;
using (var reader = new StreamReader(@"data\input.csv"))
{
while (!reader.EndOfStream)
{
var line = reader.ReadLine();
var splitValues = line?.Split(',');
for (var i = 0; i < splitValues?.Length; i++)
{
splitValues[i] = splitValues[i].Replace("\"", string.Empty);
}
if (splitValues == null || splitValues.Length < 1)
{
Console.WriteLine("Empty line discovered. Aborting.");
return;
}
switch (splitValues[Constants.RecordTypeOrdinal])
{
case Constants.FLine:
{
FileData = new CsvFileLine(splitValues[Constants.DateOrdinal], splitValues[Constants.FileTypeOrdinal]);
break;
}
case Constants.OLine:
{
FileData?.AddOrder(splitValues[Constants.DateOrdinal], splitValues[Constants.OrderCodeOrdinal], splitValues[Constants.OrderNumberOrdinal]);
break;
}
case Constants.BLine:
{
FileData?.MostRecentOrder?.SetBuyer(splitValues[Constants.BuyerNameOrdinal], splitValues[Constants.BuyerStreetOrdinal], splitValues[Constants.BuyerZipOrdinal]);
break;
}
case Constants.TLine:
{
FileData?.MostRecentOrder?.SetTimings(splitValues[Constants.TimingsStartOrdinal], splitValues[Constants.TimingsStopOrdinal], splitValues[Constants.TimingsGapOrdinal], splitValues[Constants.TimingsOffsetOrdinal], splitValues[Constants.TimingsPauseOrdinal]);
break;
}
case Constants.LLine:
{
FileData?.MostRecentOrder?.AddItemLine(splitValues[Constants.LineItemSkuOrdinal], splitValues[Constants.LineItemQuantityOrdinal]);
break;
}
case Constants.ELine:
{
FileData?.AddEnder(splitValues[Constants.EnderProcessOrdinal], splitValues[Constants.EnderPaidOrdinal], splitValues[Constants.EnderCreatedOrdinal]);
break;
}
default:
break;
}
}
// Ensure that the output directory exists.
if (!Directory.Exists("output"))
{
Directory.CreateDirectory("output");
}
var contractResolver = new DefaultContractResolver
{
NamingStrategy = new CamelCaseNamingStrategy()
};
File.WriteAllText(@"output\results.json", JsonConvert.SerializeObject(FileData, new JsonSerializerSettings
{
ContractResolver = contractResolver,
Formatting = Formatting.Indented
}));
}
}
public void WhenValuesIsNull_ThenThrowException()
{
Assert.Throws <ArgumentNullException>(() => { var l = new CsvFileLine(null as string[]); });
}
public void SetUp()
{
_sut = new CsvFileLine(Line);
}
private bool Act(CsvFileLine line)
{
return(_sut.Equals(line));
}
private bool Act(CsvFileLine line)
{
return(_sut.Contains(line));
}
