public static void WriteCSV <T>(IEnumerable <T> simulationResults, string fileName)
{
var csvFilePath = Path.Combine(Directory.GetCurrentDirectory(), fileName);
Console.WriteLine(csvFilePath);
using (var fileStream = new FileStream(csvFilePath, FileMode.Create))
{
using (var writer = new StreamWriter(fileStream, Encoding.UTF8))
{
using (var csvWriter = new CsvHelper.CsvWriter(writer))
{
csvWriter.WriteHeader <T>();
csvWriter.Flush();
writer.WriteLine();
writer.Flush();
foreach (var result in simulationResults)
{
csvWriter.WriteRecord(result);
csvWriter.Flush();
writer.WriteLine();
writer.Flush();
}
}
}
}
}
public void CsvHelperSync()
{
TextWriter tw = TextWriter.Null;
var items = TestData.GetTestObjects();
var csv = new CsvHelper.CsvWriter(tw, new CsvConfiguration(CultureInfo.InvariantCulture));
csv.WriteField("Id");
csv.WriteField("Name");
csv.WriteField("Date");
csv.WriteField("IsActive");
for (int i = 0; i < ValueCount; i++)
{
csv.WriteField("Value" + i);
}
csv.NextRecord();
foreach (var item in items)
{
csv.WriteField(item.Id);
csv.WriteField(item.Name);
csv.WriteField(item.Date);
csv.WriteField(item.IsActive);
for (int i = 0; i < ValueCount; i++)
{
csv.WriteField(item.DataSet[i]);
}
csv.NextRecord();
}
csv.Flush();
}
public async Task <IActionResult> OnPostExportEventsFromFilesStoreToCsv()
{
if ((_eventPersistence is FilesEventPersistence) == false)
{
throw new ApplicationException($"{nameof(FilesEventPersistence)} not configured");
}
var events = await _eventPersistence.LoadAllCommittedEvents(GlobalPosition.Start, 1000, CancellationToken.None);
var result = events.CommittedDomainEvents
.Cast <FilesEventPersistence.FileEventData>()
.Select(x => new { Source = x, Deserialized = _eventJsonSerializer.Deserialize(x) })
.Select(x => new EventFlow.SQLite.EventStores.SQLiteEventPersistence.EventDataModel()
{
GlobalSequenceNumber = x.Source.GlobalSequenceNumber,
BatchId = Guid.Parse(x.Deserialized.Metadata["batch_id"]),
AggregateId = x.Source.AggregateId,
AggregateName = x.Deserialized.Metadata["aggregate_name"],
Data = x.Source.Data,
Metadata = x.Source.Metadata,
AggregateSequenceNumber = x.Source.AggregateSequenceNumber
});
using (var stream = new System.IO.MemoryStream())
using (var writer = new System.IO.StreamWriter(stream))
using (var csv = new CsvHelper.CsvWriter(writer, new CsvHelper.Configuration.CsvConfiguration(System.Globalization.CultureInfo.CurrentUICulture)))
{
csv.WriteRecords(result);
csv.Flush();
writer.Flush();
return(File(stream.ToArray(), "text/csv", "events.csv"));
}
}
public async Task <IActionResult> OnPostExportToCsv(GetSubmissions.Query query)
{
query.PageNo = 1;
query.PageSize = int.MaxValue;
var submissions = await _engine.Query(query);
using (var stream = new System.IO.MemoryStream())
using (var writer = new System.IO.StreamWriter(stream))
using (var csv = new CsvHelper.CsvWriter(writer, new CsvHelper.Configuration.CsvConfiguration(System.Globalization.CultureInfo.CurrentUICulture)))
{
csv.WriteRecords(submissions.Select(x => new {
Timestamp = x.Timestamp.ToString(),
FirstName = x.FirstName,
LastName = x.LastName,
FullName = x.FullName,
EmailAddress = x.Email.ToString(),
PhoneNumber = x.PhoneNumber.ToString(),
Region = x.Region,
HasLecturerRights = x.HasLecturerRights,
HasResigned = x.HasResignedPermanently || x.HasResignedTemporarily
}));
csv.Flush();
writer.Flush();
return(File(stream.ToArray(), "text/csv", "enrollments.csv"));
}
}
void LogActivity(ActivityEvent act)
{
var f = Path.Combine(myPath, "activities.csv");
_log.Info("activity change detected");
bool isNew = File.Exists(f);
lock (this)
{
using (var writer = new StreamWriter(f, true))
using (var csv = new CsvHelper.CsvWriter(writer, new CsvHelper.Configuration.Configuration()
{
Encoding = Encoding.UTF8, HasHeaderRecord = !isNew, CultureInfo = System.Globalization.CultureInfo.CurrentCulture
}))
{
csv.Configuration.TypeConverterOptionsCache.GetOptions <DateTime>().Formats = new[] { "yyyy-MM-dd HH:mm:ss.fff" };
csv.WriteRecords(new List <ActivityEvent>()
{
act
});
csv.Flush();
}
}
//activity change
lastActivitiy = act;
}
private async void csvExport_Click(object sender, RoutedEventArgs e)
{
/*
* Task gVotes = Task.Run(() => getVotes(false, false));
* gVotes.Wait();
*
* Task gCandidates= Task.Run(() => getCandidates(false, false,false));
* gCandidates.Wait();
*/
getVotes(false, false);
candidatesList.Clear();
var firebase = new FirebaseClient("https://votingcalculator.firebaseio.com");
var candidates = await firebase.Child("candidates").OnceAsync <Candidate>();
foreach (var candidate in candidates)
{
Candidate newcandidate = new Candidate
{
name = candidate.Object.name,
party = candidate.Object.party,
votes = candidate.Object.votes
};
candidatesList.Add(newcandidate);
}
partyList = candidatesList.GroupBy(c => c.party).Select(cl => new Candidate
{
party = cl.First().party,
votes = cl.Sum(c => c.votes),
}).ToList();
//candidates database
using (var streamWriter = File.CreateText(desktopPath + "//vcCsvCandidates.csv"))
{
var csv = new CsvHelper.CsvWriter(streamWriter, true);
csv.WriteRecords(candidatesList);
csv.Flush();
}
//votes database
using (var streamWriter = File.CreateText(desktopPath + "//vcCsvVotes.csv"))
{
List <Votes> votesList = new List <Votes>();
votesList.Add(GetVotesObject);
var csv = new CsvHelper.CsvWriter(streamWriter, true);
csv.WriteRecords(votesList);
csv.Flush();
}
//parties database
using (var streamWriter = File.CreateText(desktopPath + "//vcCsvParties.csv"))
{
var csv = new CsvHelper.CsvWriter(streamWriter, true);
csv.WriteRecords(partyList);
csv.Flush();
}
System.Windows.MessageBox.Show("You can find .csv files on your desktop as 'vcCsvCandidates.csv', 'vcCsvParties.csv' and 'vcCsvVotes.csv'.");
}
private string processCsv(List <ExportInvoiceHolder> invoices)
{
using StringWriter writer = new StringWriter();
using var csvWriter = new CsvHelper.CsvWriter(writer, new CsvConfiguration(CultureInfo.InvariantCulture), true);
csvWriter.WriteHeader <ExportInvoiceHolder>();
csvWriter.NextRecord();
csvWriter.WriteRecords(invoices);
csvWriter.Flush();
return(writer.ToString());
}
private static string ProcessCsv(IEnumerable <ExportTransaction> invoices)
{
using StringWriter writer = new();
using var csvWriter = new CsvHelper.CsvWriter(writer, new CsvConfiguration(CultureInfo.InvariantCulture), true);
csvWriter.Configuration.RegisterClassMap <ExportTransactionMap>();
csvWriter.WriteHeader <ExportTransaction>();
csvWriter.NextRecord();
csvWriter.WriteRecords(invoices);
csvWriter.Flush();
return(writer.ToString());
}
private static void ReMakeRecords(int playerCount)
{
var csvFilePath = Path.Combine(Directory.GetCurrentDirectory(), $"all-in-versusFold-{playerCount}players.csv");
Console.WriteLine(csvFilePath);
using (var fileStream = new FileStream(csvFilePath, FileMode.Create))
{
using (var writer = new StreamWriter(fileStream, Encoding.UTF8))
{
using (var csvWriter = new CsvHelper.CsvWriter(writer))
{
csvWriter.WriteHeader <AllInSimulation.SimulationResult>();
csvWriter.Flush();
writer.WriteLine();
writer.Flush();
var simulation = new AllInVersusFoldBadCardsSimulation();
var simulationResults = simulation.Run(new AllInSimulation.SimulationOptions
{
ConfidenceLevel = ConfidenceLevel.L95,
WinLoseRatesDesiredRelativeError = 0.02,
BalanceDesiredAbsoluteError = 0.01,
PlayerCount = playerCount
});
var watch = Stopwatch.StartNew();
foreach (var result in simulationResults)
{
csvWriter.WriteRecord(result);
csvWriter.Flush();
writer.WriteLine();
writer.Flush();
Console.WriteLine($"Processed {result.Card1}, {result.Card2}. Elapsed totally {watch.Elapsed}, Time: {DateTime.Now}");
}
}
}
}
}
public FileStreamResult GetEquivalencies()
{
var equivalencies = EquivalenceUnitSetsReader.DumpEquivalencies(this._db);
var memory = new MemoryStream();
var writer = new StreamWriter(memory, Encoding.UTF8);
var csv = new CsvHelper.CsvWriter(writer);
csv.WriteHeader <EquivalenceUnitSetRow>();
csv.NextRecord();
csv.WriteRecords(equivalencies);
csv.Flush();
writer.Flush();
memory.Seek(0, SeekOrigin.Begin);
return(new FileStreamResult(memory, "text/csv"));
}
public void WriteCSVFile(string fileName, List <IInstruction> fileContents, StringCollection fileStrings)
{
fileName = Path.Combine(Path.GetDirectoryName(fileName), Path.GetFileNameWithoutExtension(fileName) + ".csv");
DirectoryGuard.CheckDirectory(fileName);
FileStream fs = new FileStream(fileName, FileMode.Create);
StreamWriter sw = new StreamWriter(fs);
var csv = new CsvHelper.CsvWriter(sw);
csv.Configuration.RegisterClassMap <CSVRecordMap>();
csv.WriteHeader <CSVRecord>();
csv.NextRecord();
string lastSpeaker = "";
foreach (var instruction in fileContents)
{
if (instruction is IHasStrings)
{
var temp = instruction as IHasStrings;
List <CSVRecord> csvRecords = temp.GetCSVRecords();
foreach (var record in csvRecords)
{
record.originalText = fileStrings.GetString(record.stringID);
if (record.speaker != lastSpeaker)
{
lastSpeaker = record.speaker;
}
else
{
record.speaker = ""; // blank out the name of the speaker if it is being repeated to make it easier to note when speaker changes and avoid massive walls of speakers text
}
csv.WriteRecord(record);
csv.NextRecord();
}
}
}
csv.Flush();
sw.Close();
fs.Close();
}
public static void WriteToTextCsvStream(this IEnumerable <Models.Order> x, Stream stream)
{
using (var memoryStream = new MemoryStream())
using (var streamWriter = new StreamWriter(memoryStream))
using (var csv = new CsvHelper.CsvWriter(streamWriter))
{
csv.Configuration.HasHeaderRecord = false;
csv.Configuration.RegisterClassMap <Models.OrderMapper>();
csv.WriteRecords(x);
csv.Flush();
streamWriter.Flush();
memoryStream.WriteTo(stream);
#if DEBUG
Debug.WriteLine(Encoding.UTF8.GetString(memoryStream.ToArray()));
#endif
}
stream.Seek(0, SeekOrigin.Begin);
}
public static void ToCsv(DataTable dataTable, string csvFilePath, char Escape = '"', char Quote = '"', string Delimiter = ";", bool BoolToIntConvert = false, CultureInfo cultureInfo = null)
{
CsvHelper.Configuration.CsvConfiguration csvConf = new CsvHelper.Configuration.CsvConfiguration(cultureInfo ?? CultureInfo.CurrentCulture)
{
TrimOptions = CsvHelper.Configuration.TrimOptions.InsideQuotes,
Escape = Escape,
Quote = Quote,
Delimiter = Delimiter,
TypeConverterCache = null
};
if (BoolToIntConvert)
{
csvConf.TypeConverterCache = new CsvHelper.TypeConversion.TypeConverterCache();
csvConf.TypeConverterCache.AddConverter <bool>(new CsvBooleanConverter());
}
using (System.IO.StreamWriter textWriter = System.IO.File.CreateText(csvFilePath))
{
using (CsvHelper.CsvWriter csv = new CsvHelper.CsvWriter(textWriter, csvConf))
{
foreach (DataColumn column in dataTable.Columns)
{
csv.WriteField(column.ColumnName);
}
csv.NextRecord();
foreach (DataRow row in dataTable.Rows)
{
for (int i = 0; i < dataTable.Columns.Count; i++)
{
csv.WriteField(row[i]);
}
csv.NextRecord();
}
csv.Flush();
}
textWriter.Close();
}
}
private void AssertCsvSerialization <T>(T value, string expected, ITypeConverter converter)
{
string actual;
using (var writer = new StringWriter())
{
var serializer = new CsvHelper.CsvWriter(writer, CultureInfo.InvariantCulture);
serializer.Context.TypeConverterCache.AddConverter <T>(converter);
serializer.WriteField(value);
serializer.Flush();
actual = writer.ToString();
Assert.Equal(expected, actual);
}
var reader = new CsvHelper.CsvReader(new StringReader(actual), CultureInfo.InvariantCulture);
reader.Context.TypeConverterCache.AddConverter <T>(converter);
reader.Read();
var deserializedValue = reader.GetField <T>(0);
Assert.Equal(value, deserializedValue);
}
private static void ProcessFile(string file)
{
if (File.Exists(file) == false)
{
_logger.Warn($"'{file}' does not exist! Skipping");
return;
}
_logger.Warn($"\r\nProcessing '{file}'...");
Stream fileS;
try
{
fileS = new FileStream(file, FileMode.Open, FileAccess.Read);
}
catch (Exception)
{
//file is in use
if (Helper.IsAdministrator() == false)
{
_logger.Fatal("\r\nAdministrator privileges not found! Exiting!!\r\n");
Environment.Exit(0);
}
_logger.Warn($"\r\n'{file}' is in use. Rerouting...");
var files = new List <string>();
files.Add(file);
var rawFiles = Helper.GetFiles(files);
fileS = rawFiles.First().FileStream;
}
try
{
var evt = new EventLog(fileS);
var seenRecords = 0;
foreach (var eventRecord in evt.GetEventRecords())
{
if (_includeIds.Count > 0)
{
if (_includeIds.Contains(eventRecord.EventId) == false)
{
//it is NOT in the list, so skip
continue;
}
}
else if (_excludeIds.Count > 0)
{
if (_excludeIds.Contains(eventRecord.EventId))
{
//it IS in the list, so skip
continue;
}
}
// If not between start and stop we do not print
if (_from.ToString() != "01/01/0001 00:00:00" && _to.ToString() != "01/01/0001 00:00:00")
{
if (eventRecord.TimeCreated.DateTime < _from || eventRecord.TimeCreated.DateTime > _to)
{
continue;
}
}
// If before start we do not print
if (_from.ToString() != "01/01/0001 00:00:00")
{
if (eventRecord.TimeCreated.DateTime < _from)
{
continue;
}
}
if (_to.ToString() != "01/01/0001 00:00:00")
{
if (eventRecord.TimeCreated.DateTime > _to)
{
continue;
}
}
eventRecord.SourceFile = file;
try
{
var xdo = new XmlDocument();
xdo.LoadXml(eventRecord.Payload);
var payOut = JsonConvert.SerializeXmlNode(xdo);
eventRecord.Payload = payOut.Replace("\"#text\":", "").Replace("\"@Name\":", "").Replace("\",\"", ": ").Replace("\"\"}", "}").Replace("{\"\"", "").Replace("\"},{\"", ", ").Replace("{\"EventData\":{\"Data\":[{\"", "").Replace("\"}]}}", "").Replace("\":\"", ": ").Replace("\"}}}", "").Replace("\":{\"", ": ").Replace("{\"", "");
_csvWriter?.WriteRecord(eventRecord);
_csvWriter?.NextRecord();
seenRecords += 1;
}
catch (Exception e)
{
_logger.Error($"Error processing record #{eventRecord.RecordNumber}: {e.Message}");
}
}
_csvWriter?.Flush();
_swCsv?.Flush();
if (evt.ErrorRecords.Count > 0)
{
_errorFiles.Add(file, evt.ErrorRecords.Count);
}
_fileCount += 1;
_logger.Info("");
_logger.Fatal("Event log details");
_logger.Info(evt);
_logger.Info($"Records processed: {seenRecords:N0} Errors: {evt.ErrorRecords.Count:N0}");
if (evt.ErrorRecords.Count > 0)
{
_logger.Warn("\r\nErrors");
foreach (var evtErrorRecord in evt.ErrorRecords)
{
_logger.Info($"Record #{evtErrorRecord.Key}: Error: {evtErrorRecord.Value}");
}
}
if (_fluentCommandLineParser.Object.Metrics && evt.EventIdMetrics.Count > 0)
{
_logger.Fatal("\r\nMetrics");
_logger.Warn("Event Id\tCount");
foreach (var esEventIdMetric in evt.EventIdMetrics.OrderBy(t => t.Key))
{
if (_includeIds.Count > 0)
{
if (_includeIds.Contains((int)esEventIdMetric.Key) == false)
{
//it is NOT in the list, so skip
continue;
}
}
else if (_excludeIds.Count > 0)
{
if (_excludeIds.Contains((int)esEventIdMetric.Key))
{
//it IS in the list, so skip
continue;
}
}
_logger.Info($"{esEventIdMetric.Key}\t\t{esEventIdMetric.Value:N0}");
}
}
}
catch (Exception e)
{
if (e.Message.Contains("Invalid signature! Expected 'ElfFile"))
{
_logger.Info($"'{file}' is not an evtx file! Message: {e.Message} Skipping...");
}
else
{
_logger.Error($"Error processing '{file}'! Message: {e.Message}");
}
}
fileS?.Close();
}
