public void CsvFormatter_with_non_standard_charset_should_get_the_encoding_right()
{
var formatter = new CsvFormatter(';', '"', '\\', "\r\n", CsvQuotingStyle.Required, Encoding.Unicode);
var csv = formatter.ToCsv(new[] { "ett", "två", "อักษรไทย" });
csv.ShouldBeEquivalentTo(ByteString.FromString("ett;två;อักษรไทย\r\n", Encoding.Unicode));
}
static void Main(string[] args)
{
var cmdArgsValidator = new CmdArgsValidator();
cmdArgsValidator.AddRule(@"(-col)\s(\d+)\b");
cmdArgsValidator.AddRule(@"(-row)\s(\d+)\b");
cmdArgsValidator.AddRule(@"(-len)\s(\d+)\b");
cmdArgsValidator.AddRule(@"(-enc)\s[a-zA-Z0-9\-]+\b");
cmdArgsValidator.AddRule(@"(-out)\s[a-zA-Z\\\/:]+\.(csv)\b");
if (!cmdArgsValidator.IsValid(string.Join(" ", args)))
{
Console.WriteLine("Параметры коммандной строки заданы неверно.");
return;
}
var parser = new CmdArgsParser(args);
var cmdArgs = new CmdArgsValues(parser);
var csv = new CsvFormatter();
csv.FormatToFile(cmdArgs);
Console.WriteLine("Press any key...");
Console.ReadKey();
}
private void OnNeuesFahrrad(Window window)
{
try
{
var path = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);
var file = Path.Combine(path, "Szenariorechner_"
+ HilfsFunktionen.GetValidFileName(NeuesFahrrad)
+ ".csv");
var i = 1;
while (File.Exists(file))
{
file = Path.Combine(path, "Szenariorechner_"
+ HilfsFunktionen.GetValidFileName(NeuesFahrrad)
+ string.Format(" ({0}).csv", i++));
}
using (var sw = new StreamWriter(file, false, Encoding.Default))
{
sw.Write(CsvFormatter.GetFormattetAlternativen(VergleichsListe));
}
Process.Start(new ProcessStartInfo("explorer.exe")
{
Arguments = "/select, \"" + file + "\""
});
}
catch (IOException ex)
{
HilfsFunktionen.ShowMessageBox(window, "Szenariorechner", ex.Message, true);
}
NeuesFahrrad = "";
}
public void TestFormatTitle()
{
var formatter = new CsvFormatter();
var buffer = new StringBuilder();
buffer.Append(formatter.FormatTitle(typeof(Model)));
Assert.AreEqual("Field1,Property1", buffer.ToString());
}
public void CsvFormatterShouldThrowOnMissingFileName()
{
formatterElement csvFileConfiguration = new formatterElement();
csvFileConfiguration.output.fileName = null;
CsvFormatter formatter = new CsvFormatter(csvFileConfiguration);
formatter.WriteReport(null, LogLevel.Information);
}
public IActionResult GetCurrentDataCsv(string sinkName)
{
var networkId = _networkAuthenticationContext.GetContextNetwork(this.HttpContext);
var data = _reportingService.CurrentDataFlatReport(new SinkAndNetworkDto {
NetworkId = networkId, SinkName = sinkName
});
return(CsvFormatter.ToHttpResponseMessage(data));
}
public void EmptyDataTable_YieldsEmpty()
{
var dataTable = new DataTable();
var formatter = new CsvFormatter();
var result = formatter.Format(dataTable).ToList();
CollectionAssert.AreEqual(new string[] { "" }, result);
}
public void Does_Not_Read_Types()
{
var formatter = new CsvFormatter();
formatter.CanReadType(typeof(ReleaseNotes)).ShouldBe(false);
formatter.CanReadType(typeof(WorkItem)).ShouldBe(false);
formatter.CanReadType(typeof(Project)).ShouldBe(false);
formatter.CanReadType(typeof(Build)).ShouldBe(false);
formatter.CanReadType(typeof(Models.Environment)).ShouldBe(false);
}
public void Only_Writes_Release_Notes()
{
var formatter = new CsvFormatter();
formatter.CanWriteType(typeof(ReleaseNotes)).ShouldBe(true);
formatter.CanWriteType(typeof(WorkItem)).ShouldBe(false);
formatter.CanWriteType(typeof(Project)).ShouldBe(false);
formatter.CanWriteType(typeof(Build)).ShouldBe(false);
formatter.CanWriteType(typeof(Models.Environment)).ShouldBe(false);
}
public void SingleResult_YieldsThatResult()
{
var dataTable = new DataTable();
dataTable.Columns.Add("Result", typeof(string));
dataTable.Rows.Add("Some Value");
var formatter = new CsvFormatter();
var result = formatter.Format(dataTable).ToList();
Assert.AreEqual("Some Value", result.Single());
}
public IActionResult GetCurrentDataCsv(string sinkName)
{
var deviceId = _deviceAuthenticationContext.GetContextDevice(this.HttpContext);
var data = _reportingService.CurrentDataFlatReport(new SinkAndDeviceDto {
DeviceId = deviceId, SinkName = sinkName
});
return(CsvFormatter.ToHttpResponseMessage(data));
}
private static void WritePayslipsToCsv(List <Payslip> payslips, string filename)
{
var lines = new List <string>()
{
"name,pay period,gross income,income tax,net income,super"
};
lines.AddRange(payslips.Select(payslip => CsvFormatter.CreateCsvLineFromPayslip(payslip)));
CsvReaderWriter.WriteLines(filename, lines);
}
public void ThenTheResultStartsWithCsvHeaders(
List <CommitmentAgreement> agreements,
CsvFormatter sut)
{
var byteResult = sut.Format(TestHelper.Clone(agreements));
var stringResult = Default.GetString(byteResult);
stringResult.Should().StartWith(
$"{nameof(CommitmentAgreement.OrganisationName)},{nameof(CommitmentAgreement.CohortID)},{nameof(CommitmentAgreement.AgreementID)}");
}
public void Delegates_ToString_formatter_segment()
{
var node = new NodeFactory().CreateBlankNode();
var wrapper = new MockWrapperNode(node);
var formatter = new CsvFormatter();
var expected = node.ToString(formatter, TripleSegment.Subject);
var actual = wrapper.ToString(formatter, TripleSegment.Subject);
Assert.Equal(expected, actual);
}
public IActionResult GetTimeSeriesReportCsv(string sinkName, long timestamp)
{
var deviceId = _deviceAuthenticationContext.GetContextDevice(this.HttpContext);
var data = _reportingService.TimeSeriesFlatReport(
new SinkAndDeviceDto {
DeviceId = deviceId, SinkName = sinkName
},
DateTimeExtensions.FromUnixTime(timestamp));
return(CsvFormatter.ToHttpResponseMessage(data));
}
public void ThenTheResultContainsCsvAgreements(
List <CommitmentAgreement> agreements,
CsvFormatter sut)
{
var byteResult = sut.Format(TestHelper.Clone(agreements));
var stringResult = Default.GetString(byteResult);
stringResult.Should().Contain($"{agreements[0].OrganisationName},{agreements[0].CohortID},{agreements[0].AgreementID}");
stringResult.Should().Contain($"{agreements[1].OrganisationName},{agreements[1].CohortID},{agreements[1].AgreementID}");
stringResult.Should().Contain($"{agreements[2].OrganisationName},{agreements[2].CohortID},{agreements[2].AgreementID}");
}
public void Format_CreatesCsv()
{
var dataTable = new[]
{
new Person {Id = 1, FirstName = "John", LastName = "Doe"}
}.ToDataTable();
var formatter = new CsvFormatter();
var result = formatter.Format(dataTable).ToList();
CollectionAssert.AreEqual(new[] { "\"Id\";\"FirstName\";\"LastName\"", "\"1\";\"John\";\"Doe\"" }, result);
}
public void Acceptance()
{
const string CSVTEXT =
@"Name;Age;City
Peter;26;Hamburg
Paul;45;London
Mary;38;Copenhagen";
var sut = new CsvFormatter ();
var result = sut.Format (CSVTEXT);
Console.WriteLine (result);
}
public void FormattersShouldNotThrowOnFormatting()
{
BuildCopConfiguration config = new BuildCopConfiguration();
buildGroupElement buildGroup = new buildGroupElement();
buildGroup.name = "TestBuildGroup";
buildFilePathElement path = new buildFilePathElement();
path.rootPath = @"BuildFiles";
path.searchPattern = "DefaultConsoleApplication.csproj";
buildGroup.buildFiles.paths.Add(path);
ruleElement mockRule = new ruleElement();
mockRule.name = "Mock";
mockRule.type = typeof(MockRule).AssemblyQualifiedName;
buildGroup.rules.Add(mockRule);
config.buildGroups.Add(buildGroup);
BuildCopReport report = BuildCopEngine.Execute(config);
Assert.IsNotNull(report);
// Execute the known formatters.
BaseFormatter formatter;
formatter = new ConsoleFormatter(null);
formatter.WriteReport(report, LogLevel.Information);
formatterElement htmlFileConfiguration = new formatterElement();
htmlFileConfiguration.output.fileName = "TestFormatterOutput.html";
htmlFileConfiguration.output.launch = false;
htmlFileConfiguration.output.stylesheet = string.Empty;
formatter = new HtmlFormatter(htmlFileConfiguration);
formatter.WriteReport(report, LogLevel.Information);
formatterElement xmlFileConfiguration = new formatterElement();
xmlFileConfiguration.output.fileName = "TestFormatterOutput.xml";
xmlFileConfiguration.output.launch = false;
xmlFileConfiguration.output.stylesheet = string.Empty;
formatter = new XmlFormatter(xmlFileConfiguration);
formatter.WriteReport(report, LogLevel.Information);
formatterElement csvFileConfiguration = new formatterElement();
csvFileConfiguration.output.fileName = "TestFormatterOutput.csv";
csvFileConfiguration.output.launch = false;
formatter = new CsvFormatter(csvFileConfiguration);
formatter.WriteReport(report, LogLevel.Information);
}
public void SaveSubjectData()
{
string folder = Application.persistentDataPath;
folder = Path.Combine(folder, data.subjectId);
if (!Directory.Exists(folder))
{
Directory.CreateDirectory(folder);
}
string sessionsFile = Path.Combine(folder, "sessions.csv");
{
var serializer = new CsvFormatter <SessionData>(',');
FileStream stream = File.Create(sessionsFile);
serializer.Serialize(stream, data.sessions);
stream.Close();
}
}
public IEnumerable <ITypeFormatter> CreateTypeFormatters()
{
yield return(new HtmlFormatter <TabularDataResource>((value, context) =>
{
IReadOnlyList <IHtmlContent> headers =
value.Schema
.Fields
.Select(f => (IHtmlContent)td(span(f.Name)))
.ToArray();
IReadOnlyList <IHtmlContent> rows =
value.Data
.Select(d => (IHtmlContent)tr(d.Values.Select(v => td(v))))
.ToArray();
Html.Table(headers, rows).WriteTo(context);
}));
yield return(new JsonFormatter <TabularDataResource>((value, context) =>
{
var json = JsonSerializer.Serialize(value.Data, TabularDataResourceFormatter.JsonSerializerOptions);
context.Writer.Write(json);
}));
yield return(new TabularDataResourceFormatter <TabularDataResource>((value, context) =>
{
var json = JsonSerializer.Serialize(value, TabularDataResourceFormatter.JsonSerializerOptions);
context.Writer.Write(json);
}));
yield return(new CsvFormatter <TabularDataResource>((value, context) =>
{
var columns = value.Schema.Fields.Select(f => f.Name).ToArray();
return CsvFormatter <IReadOnlyList <IDictionary <string, object> > > .BuildTable(value.Data, _ => columns,
rows =>
{
return rows.Select(row => columns.Select(c => row[c]));
}, context);
}));
}
public void FormatCommaWithCSV()
{
var formatter = new CsvFormatter();
var response = new PlacesResponse()
{
results = new PlacesResult[] {
new PlacesResult()
{
name = "Name, with, commas", opening_hours = new OpeningHours {
open_now = false
}, rating = 4.8, vicinity = "near by"
},
}
};
string formattedResult = formatter.Format(response);
var lines = formattedResult.Split(Environment.NewLine);
Assert.Equal(2, lines[1].Count(x => x == ','));
}
public static List <Payslip> MakePayslip(string csvFileName)
{
var allPayslips = new List <Payslip>();
var lines = CsvReaderWriter.ReadLines(csvFileName);
for (var i = 1; i < lines.Length; i++)
{
var line = lines[i];
var employee = CsvFormatter.ExtractEmployee(line);
employee.Country = Config.Australia; // TODO: Remove this hardcoded value once we have config input
var payPeriod = CsvFormatter.ExtractPayPeriod(line);
var payslip = CreatePayslipObject(employee, payPeriod);
allPayslips.Add(payslip);
}
return(allPayslips);
}
private static string GenerateCSV(Device[] data)
{
var formatter = new CsvFormatter();
var buffer = new StringBuilder();
buffer.Append(formatter.FormatTitle(typeof(Device)));
buffer.Append("\n");
foreach (Device item in data)
{
try
{
buffer.Append(formatter.FormatItem(item) + '\n');
}
catch (Exception e)
{
Console.WriteLine($"Buffer Append Failed: {item} ({e.InnerException})");
}
}
return(buffer.ToString());
}
public void LoadSubjectData()
{
string folder = Application.persistentDataPath;
folder = Path.Combine(folder, data.subjectId);
if (!Directory.Exists(folder))
{
return;
}
string sessionsFile = Path.Combine(folder, "sessions.csv");
if (File.Exists(sessionsFile))
{
var serializer = new CsvFormatter <SessionData>(',');
FileStream stream = File.Open(sessionsFile, FileMode.Open);
data.sessions = (List <SessionData>)serializer.Deserialize(stream);
stream.Close();
}
Debug.Log(String.Format("Loaded {0} sessions for '{1}'", data.sessions.Count, data.subjectId), this.gameObject);
}
/// <summary>
/// Create a Flow for converting <see cref="IImmutableList{string}"/> to ByteString.
/// </summary>
/// <param name="delimiter">Value delimiter, defaults to comma</param>
/// <param name="quoteChar">Quote character, defaults to double quote</param>
/// <param name="escapeChar">Escape character, defaults to backslash</param>
/// <param name="endOfLine">Line ending (default CR, LF)</param>
/// <param name="quotingStyle">Quote all fields, or only fields requiring quotes (default)</param>
/// <param name="encoding">Character encoding, defaults to UTF-8</param>
/// <param name="byteOrderMark">Certain CSV readers (namely Microsoft Excel) require a Byte Order mark, defaults to None</param>
public static Flow <ImmutableList <string>, ByteString, NotUsed> Format(
char delimiter = Comma,
char quoteChar = DoubleQuote,
char escapeChar = Backslash,
string endOfLine = "\r\n",
CsvQuotingStyle quotingStyle = CsvQuotingStyle.Required,
Encoding encoding = null,
ByteString byteOrderMark = null)
{
var formatter = new CsvFormatter(delimiter, quoteChar, escapeChar, endOfLine, quotingStyle, encoding);
if (byteOrderMark == null)
{
return(Flow.FromFunction <ImmutableList <string>, ByteString>(list => formatter.ToCsv(list))
.Named("CsvFormatting"));
}
return(Flow.FromFunction <ImmutableList <string>, ByteString>(list => formatter.ToCsv(list))
.Named("CsvFormatting")
.Prepend(Source.Single(byteOrderMark)));
}
public void TestFormatValues()
{
var model = new Model()
{
field1 = 1,
field2 = "field2 value"
};
var formatter = new CsvFormatter();
var buffer = new StringBuilder();
buffer.Append(formatter.FormatItem(model));
Assert.AreEqual("1,field2 value", buffer.ToString());
// With a comma
buffer = new StringBuilder();
model = new Model()
{
field1 = 1,
field2 = "field2,value"
};
buffer.Append(formatter.FormatItem(model));
Assert.AreEqual("1,\"field2,value\"", buffer.ToString());
}
public async Task <FileContentResult> Get()
{
// get the film list
var filmList = await _starWarsService.GetFilms();
// get the characters for these films
Character[] characterArray = new Character[0];
foreach (Film film in filmList)
{
var result = await _starWarsService.GetCharactersByFilm(film.ObjectId);
// combine and sort characters, no duplicates
foreach (var character in result)
{
character.EpisodeId = film.EpisodeId;
}
characterArray = characterArray.Union(result).ToArray();
}
Array.Sort(characterArray, new StarWarsComparer());
// convert names into last name, first name format
foreach (var character in characterArray)
{
var names = character.Name.Split(" ");
if (names.Length > 1)
{
character.Name = $"{names[1]}-{names[0]}";
}
}
// convert into csv file and return it.
var characterList = new List <Character>(characterArray);
var formatter = new CsvFormatter();
var csv = formatter.Format(characterList);
byte[] fileBytes = System.Text.Encoding.UTF8.GetBytes(csv);
// return csv file
return(File(fileBytes, "text/csv", "StarWarsCharacters.csv"));
}
public void CsvFormatter_quoting_everything_should_format_strings_with_commas()
{
var formatter = new CsvFormatter(',', '"', '\\', "\r\n", CsvQuotingStyle.Always);
ExpectInOut(formatter, new[] { "ett", "t,vå", "tre" }, @"""ett"",""t,vå"",""tre""" + "\r\n");
}
public void CanCreate()
{
var formatter = new CsvFormatter();
formatter.Should().NotBeNull();
}
private void OnExport(Window window)
{
if (ExportformatCsv)
{
try
{
var path = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);
var file = Path.Combine(path, "Wunschliste.csv");
var i = 1;
while (File.Exists(file))
{
file = Path.Combine(path, string.Format("Wunschliste ({0}).csv", i++));
}
using (var sw = new StreamWriter(file, false, Encoding.Default))
{
sw.Write(CsvFormatter.GetFormattetWunschliste(Wunschliste));
}
Process.Start(new ProcessStartInfo("explorer.exe")
{
Arguments = "/select, \"" + file + "\""
});
}
catch (IOException ex)
{
HilfsFunktionen.ShowMessageBox(window, "Wunschliste", ex.Message, true);
}
}
else
{
var liste = new List <EinzelteilExportDto>();
foreach (var item in Wunschliste)
{
var wunschteil = new EinzelteilExportDto
{
Guid = item.Guid,
Komponente = item.Komponente,
Hersteller = item.Hersteller,
Beschreibung = item.Beschreibung,
Groesse = item.Groesse,
Jahr = item.Jahr,
DatenbankId = item.DatenbankId,
DatenbankLink = item.DatenbankLink,
Preis = item.Preis,
Gewicht = item.Gewicht,
DokumentenListe = new List <DateiDto>()
};
if (item.IsNeueKomponente)
{
var cachedItem = _dateiCache.FirstOrDefault(teil => teil.Item1 == wunschteil.Guid);
if (cachedItem != null)
{
wunschteil.DokumentenListe.AddRange(cachedItem.Item2);
}
}
else
{
var dateiListe = new List <DateiDto>();
PluginManager.DbManager.GetDateiInfos(item.Guid, ref dateiListe);
wunschteil.DokumentenListe.AddRange(dateiListe);
}
liste.Add(wunschteil);
}
PluginManager.ExportManager.ExportKomponenten(new WindowInteropHelper(window).Handle,
"Wunschliste",
CsvFormatter.GetFormattetWunschliste(Wunschliste),
liste);
}
}
public void CsvFormatter_with_comma_delimiter_should_format_strings_containing_quotes()
{
var formatter = new CsvFormatter(',', '"', '\\', "\r\n", CsvQuotingStyle.Required);
ExpectInOut(formatter, new[] { "ett", "t\"vå", "tre" }, "ett,\"t\"\"vå\",tre\r\n");
}
public void CsvFormatter_quoting_everything_should_format_strings_containing_quotes_twice()
{
var formatter = new CsvFormatter(',', '"', '\\', "\r\n", CsvQuotingStyle.Always);
ExpectInOut(formatter, new[] { "ett", "t\"v\"å", "tre" }, @"""ett"",""t""""v""""å"",""tre""" + "\r\n");
}
public void CsvFormatter_with_required_quoting_should_format_strings()
{
var formatter = new CsvFormatter(';', '"', '\\', "\r\n", CsvQuotingStyle.Required);
ExpectInOut(formatter, new[] { "ett", "två", "tre" }, "ett;två;tre\r\n");
}
public void CsvFormatter_with_required_quoting_should_quote_strings_with_just_a_quote()
{
var formatter = new CsvFormatter(';', '"', '\\', "\r\n", CsvQuotingStyle.Required);
ExpectInOut(formatter, new[] { "ett", "\"", "tre" }, "ett;\"\"\"\";tre\r\n");
}
