private async void BtnExport_OnClick(object sender, RoutedEventArgs e)
{
// Get input field values
var deckIndex = ComboBoxDeckPicker.SelectedIndex;
var deck = deckIndex <= 0 ? (Guid?)null : decks.ElementAt(deckIndex - 1).DeckId;
var region = (StatsRegion)ComboBoxRegion.SelectedItem;
var time = (TimeFrame)ComboBoxTime.SelectedItem;
var mode = (GameMode)ComboBoxMode.SelectedItem;
// create exporting objects
var filter = new StatsFilter(deck, region, mode, time);
// TODO: needs to be selectable with further export types
var exporter = new CSVExporter();
// set up and open save dialog
SaveFileDialog dlg = new SaveFileDialog();
dlg.FileName = GetDefaultFileName();
dlg.DefaultExt = "." + exporter.FileExtension;
dlg.InitialDirectory = Settings.Default.DefaultExportPath;
dlg.Filter = exporter.Name + " Files | *." + exporter.FileExtension;
Nullable<bool> result = dlg.ShowDialog();
// close export dialog
await Hearthstone_Deck_Tracker.API.Core.MainWindow.HideMetroDialogAsync(this);
// Process save file dialog box results
if (result == true)
{
// Save document
string filename = dlg.FileName;
await Converter.Export(exporter, filter, filename);
}
}
public async Task ExportToFile(BandEventBase eventBase, string filePath)
{
await Task.Run(() =>
{
var dataDump = new List <Dictionary <string, object> >();
foreach (var info in eventBase.InfoSegments)
{
dataDump.Add(new Dictionary <string, object>()
{
{ "Time of Day", info.TimeOfDay },
{ "Day Classification", info.DayClassification },
{ "Activity Level", info.ActivityLevel },
{ "Steps Taken", info.StepsTaken },
{ "Calories Burned", info.CaloriesBurned },
{ "UV Exposure", info.UvExposure },
{ "Location", info.Location },
{ "Peak Heart Rate", info.HeartRate.Peak },
{ "Average Heart Rate", info.HeartRate.Average },
{ "Lowest Heart Rate", info.HeartRate.Lowest },
{ "Total Distance", info.TotalDistance },
{ "It Cal", info.ItCal }
});
}
CSVExporter.ExportToFile(dataDump, filePath);
});
}
public bool GenerateCsv <T>(string csvFilePath, CSVExporter <T> exporter, IEnumerable <T> modelData, string filterCriteria = "", bool skipHeader = false)
{
var csvStringBuilder = new StringBuilder();
var sanitizer = new CSVSanitizer();
if (!string.IsNullOrEmpty(filterCriteria))
{
csvStringBuilder.Append(sanitizer.EscapeString(filterCriteria) + Environment.NewLine + Environment.NewLine);
}
if (!skipHeader)
{
csvStringBuilder.Append(exporter.Header + Environment.NewLine);
}
foreach (string line in exporter.ExportObjects(modelData))
{
csvStringBuilder.Append(line + Environment.NewLine);
}
var request = new GenericReportRequest {
Model = csvStringBuilder.ToString(), CsvFilePath = csvFilePath
};
var isGenerated = _baseReportService.GetResponse(request, skipHeader);
return(isGenerated);
}
public void Setup()
{
_csvExporter = new CSVExporter <TestType>(
new CSVColumn <TestType>("Name", t => t.Name),
new CSVColumn <TestType>("Age", t => t.Age.ToString())
);
}
private string WriteCsv <T>(string fileName, CSVExporter <T> exporter, IEnumerable <T> modelData, string queue, string channel)
{
var csvFilePath = _tempMediaLocation.PhysicalPath + fileName;
//using (var streamWriter = new StreamWriter(csvFilePath, false))
//{
var csvStringBuilder = new StringBuilder();
csvStringBuilder.Append(exporter.Header + Environment.NewLine);
foreach (string line in exporter.ExportObjects(modelData))
{
csvStringBuilder.Append(line + Environment.NewLine);
}
// streamWriter.Close();
//}
var request = new GenericReportRequest {
Model = csvStringBuilder.ToString(), CsvFilePath = csvFilePath
};
var isGenerated = GetResponse(request, queue, channel);
if (!isGenerated)
{
return("CSV File Export failed!");
}
DownloadZipFile(_tempMediaLocation, fileName);
return("CSV File Export was succesful!");
}
protected void Export()
{
string fileName = UIHelper.GetSaveFile("Excel files (*.xls)|*.xls|CSV files (*.csv)|*.csv");
if (string.IsNullOrEmpty(fileName))
{
return;
}
string ext = FileHelper.GetFileExtension(fileName);
switch (ext)
{
case ".xls":
ExcelExporter.Generate(fListView, fileName);
break;
case ".csv":
CSVExporter.Generate(fListView, fileName);
break;
default:
return;
}
AppHost.LoadExtFile(fileName);
}
public async Task ExportToFile(BandEventBase eventBase, string filePath)
{
if (!(eventBase is UserDailyActivity))
{
throw new ArgumentException("eventBase must be of type UserDailyActivity to use the UserDailyActivityToCSVExporter");
}
await Task.Run(() =>
{
var dataDump = new List <Dictionary <string, object> >();
foreach (UserDailyActivity info in ((UserDailyActivity)eventBase).Segments)
{
dataDump.Add(new Dictionary <string, object>()
{
{ "Start Time", info.StartTime },
{ "Day Classification", info.DayClassification },
{ "Activity Level", info.ActivityLevel },
{ "Steps Taken", info.StepsTaken },
{ "Calories Burned", info.CaloriesBurned },
{ "UV Exposure", info.UvExposure },
{ "Peak Heart Rate", info.HeartRate.Peak },
{ "Average Heart Rate", info.HeartRate.Average },
{ "Lowest Heart Rate", info.HeartRate.Lowest },
{ "Total Distance", info.TotalDistance },
{ "It Cal", info.ItCal }
});
}
CSVExporter.ExportToFile(dataDump, filePath);
});
}
private void toolStripMenuItemCSVExport_Click(object sender, EventArgs e)
{
if (this.FileControl.SelectedTab is FileTabPage tabPageSelected)
{
var itemsSelected = tabPageSelected.SequencesSelected;
CSVExporter exporter = new CSVExporter(ObjectWriter.HEADERS);
foreach (Sequence sequenceAktuell in itemsSelected)
{
foreach (ObjectInSequence obj in sequenceAktuell.ObjectsInSequence)
{
exporter.AddLine(ObjectWriter.GetStringData(obj));
}
}
using (DialogCSVExport dialogExport = new DialogCSVExport())
{
dialogExport.Exporter = exporter;
dialogExport.ShowDialog(this.FindForm());
}
// exporter.WriteCSV(@"d:\temp\test.csv");
}
else
{
// Nothing selected...every TabPage should be a FileTabPage
MessageBox.Show("Please select a Page to export.", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
public async Task ExportToFile(BandEventBase eventBase, string filePath)
{
if (!(eventBase is SleepEvent))
{
throw new ArgumentException("eventBase must be of type SleepEvent to use the SleepToCSVExporter");
}
var sleepEvent = eventBase as SleepEvent;
await Task.Run(() =>
{
var dataDump = new List <Dictionary <string, object> >();
foreach (var sequence in sleepEvent.Sequences)
{
var sleepSequence = sequence as SleepEventSequenceItem;
var sequenceData = new Dictionary <string, object>(BaseSequenceDumper.Dump(sequence));
sequenceData.Add("Sequence Type", sleepSequence.SequenceType);
sequenceData.Add("Sleep Time", sleepSequence.SleepTime);
sequenceData.Add("Day Id", sleepSequence.DayId);
sequenceData.Add("Sleep Type", sleepSequence.SleepType);
dataDump.Add(sequenceData);
}
// TODO: pass through convertDateTimeToLocal
CSVExporter.ExportToFile(dataDump, filePath);
});
}
public EmptyResult Report()
{
var logfilePath = HttpContext.Server.MapPath("~/App_Data/access.log");
var iisLog = W3CEnumerable.FromFile(logfilePath);
List <ReportModel> report = new List <ReportModel>();
foreach (var line in iisLog.Where(x => !string.IsNullOrEmpty(x.c_ip) && !x.c_ip.StartsWith("207.114") && x.s_port == "80" && x.cs_method == "GET")
.GroupBy(x => x.c_ip)
.Select(group => new {
Counter = group.Count(),
IP = group.Key
})
.OrderByDescending(x => x.Counter)
.ThenByDescending(x => Version.Parse(x.IP.ToString())))
{
ReportModel reportItem = new ReportModel();
reportItem.Count = line.Counter;
reportItem.IP = IPAddress.Parse(line.IP);
report.Add(reportItem);
}
CSVExporter.WriteToCSV(report);
return(new EmptyResult());
}
public async Task ExportToFile(BandEventBase eventBase, string filePath)
{
if (!(eventBase is RunEvent))
{
throw new ArgumentException("eventBase must be of type SleepEvent to use the RunToCSVExporter");
}
var runEvent = eventBase as RunEvent;
await Task.Run(() =>
{
var dataDump = new List <Dictionary <string, object> >();
foreach (var sequence in runEvent.Sequences)
{
var runSequence = sequence as RunEventSequenceItem;
var sequenceData = new Dictionary <string, object>(BaseSequenceDumper.Dump(sequence))
{
{ "Total Distance", runSequence.TotalDistance },
{ "Split Distance", runSequence.SplitDistance },
{ "Split Pace", runSequence.SplitPace },
{ "Overall Pace", runSequence.OverallPace },
{ "Actual Distance", runSequence.ActualDistance },
{ "Paused Time", runSequence.PausedTime },
};
dataDump.Add(sequenceData);
}
// TODO: pass through convertDateTimeToLocal
CSVExporter.ExportToFile(dataDump, filePath);
});
}
static void Main(string[] args)
{
Document document = new Document();
Exporter exporter = new CSVExporter();
ExportController exportController = new ExportController(exporter);
exportController.RunExport(document);
}
public void TestCsvHelper()
{
var exporter = new CSVExporter();
var filter = new StatsFilter();
var file = "sample-export.csv";
exporter.To(file, filter.Apply(stats));
var count = TestHelper.CountLines(file);
Assert.AreEqual(10, count);
}
public Task <ExportResult> Handle(ExportTagsDataCommand request, CancellationToken cancellationToken)
{
var tagExp = new CSVExporter <TagEntity>(_tagRepository, "moonglade-tags", ExportManager.DataDir);
return(tagExp.ExportData(p => new
{
p.Id,
p.NormalizedName,
p.DisplayName
}, cancellationToken));
}
private void WriteCsv <T>(string fileName, CSVExporter <T> exporter, IEnumerable <T> modelData)
{
var csvStringBuilder = new StringBuilder();
csvStringBuilder.Append(exporter.Header + Environment.NewLine);
foreach (string line in exporter.ExportObjects(modelData))
{
csvStringBuilder.Append(line + Environment.NewLine);
}
System.IO.File.AppendAllText(fileName, csvStringBuilder.ToString());
}
// Start is called before the first frame update
void Start()
{
logger = this.gameObject.GetComponent <CSVExporter>();
logger.LogLine("d1,d2,d3,label"); //write header
float[] data = new float[3] {
1, 2, 3
}; //data
string label = "apple"; //label
logger.LogDataLabel(data, label); //log data and the label
//logger.LogData(data); //this is also an option
}
public Task <ExportResult> Handle(ExportCategoryDataCommand request, CancellationToken cancellationToken)
{
var catExp = new CSVExporter <CategoryEntity>(_catRepository, "moonglade-categories", ExportManager.DataDir);
return(catExp.ExportData(p => new
{
p.Id,
p.DisplayName,
p.RouteName,
p.Note
}, cancellationToken));
}
// GET Report/ExportAudit
public FileContentResult ExportAudit()
{
string displayName;
var csvExport = new CSVExporter();
foreach (var auditRecord in AuditRecordProvider.GetAll())
{
csvExport.AddRow();
foreach (var prop in auditRecord.GetType().GetProperties())
{
switch (prop.Name)
{
case "EntityName":
displayName = "Entity";
break;
case "PrimaryKeyValue":
displayName = "ID";
break;
case "PropertyName":
displayName = "Property";
break;
case "OldValue":
displayName = "Old Value";
break;
case "NewValue":
displayName = "New Value";
break;
case "DateChanged":
displayName = "Date Changed";
break;
case "UserName":
displayName = "Changed By";
break;
default:
displayName = prop.Name;
break;
}
csvExport[displayName] = prop.GetValue(auditRecord, null);
}
}
return(File(new UTF8Encoding().GetBytes(csvExport.Export()), "text/csv", "AuditRecords.csv"));
}
public string WriteCsv <T>(string fileName, CSVExporter <T> exporter, IEnumerable <T> modelData, long userId, string filterCriteria = "")
{
var csvFilePath = ExportableMediaLocation.PhysicalPath + fileName;
var isGenerated = GenerateCsv(csvFilePath, exporter, modelData, filterCriteria);
if (!isGenerated)
{
return(string.Empty);
}
return(_baseReportService.DownloadZipFile(ExportableMediaLocation, fileName, userId, Logger));
}
private void ExportList()
{
try
{
CSVExporter exporter = new CSVExporter();
exporter.List = QuickSearch.DisplayList.ToList <dynamic>();
exporter.Export();
}
catch (Exception E)
{
ExepionLogger.Logger.LogException(E);
ExepionLogger.Logger.Show(E);
}
}
public static void ExportPlatformMetamodel(string dbEngine, OSDiagToolConf.ConfModel.strConfModel configurations, OSDiagToolForm.OsDiagFormConfModel.strFormConfigurationsModel FormConfigurations,
DBConnector.SQLConnStringModel sqlConnString = null, DBConnector.OracleConnStringModel oracleConnString = null)
{
FileLogger.TraceLog("Exporting Platform Metamodel...");
Directory.CreateDirectory(_osMetamodelTablesDest);
if (dbEngine.Equals("sqlserver"))
{
var connector = new DBConnector.SLQDBConnector();
SqlConnection connection = connector.SQLOpenConnection(sqlConnString);
using (connection) {
bool isLifeTimeEnvironment = Platform.PlatformUtils.IsLifeTimeEnvironment(dbEngine, configurations.queryTimeout, connection);
FileLogger.TraceLog("Starting exporting tables: ");
foreach (string table in FormConfigurations.metamodelTables)
{
if ((isLifeTimeEnvironment && table.ToLower().StartsWith("osltm") || table.ToLower().StartsWith("ossys")))
{
FileLogger.TraceLog(table + ", ", writeDateTime: false);
string selectAllQuery = "SELECT * FROM " + table;
CSVExporter.SQLToCSVExport(dbEngine, table, _osMetamodelTablesDest, configurations.queryTimeout, selectAllQuery, connection, null);
}
}
}
}
else if (dbEngine.Equals("oracle"))
{
var connector = new DBConnector.OracleDBConnector();
OracleConnection connection = connector.OracleOpenConnection(oracleConnString);
string platformDBAdminUser = Platform.PlatformUtils.GetPlatformDBAdminUser();
using (connection) {
bool isLifeTimeEnvironment = Platform.PlatformUtils.IsLifeTimeEnvironment(dbEngine, configurations.queryTimeout, null, connection, platformDBAdminUser);
FileLogger.TraceLog("Starting exporting tables: ");
foreach (string table in FormConfigurations.metamodelTables)
{
if ((isLifeTimeEnvironment && table.ToLower().StartsWith("osltm") || table.ToLower().StartsWith("ossys")))
{
FileLogger.TraceLog(table + ", ", writeDateTime: false);
string selectAllQuery = "SELECT * FROM " + platformDBAdminUser + "." + table;
CSVExporter.ORCLToCsvExport(connection, table, _osMetamodelTablesDest, configurations.queryTimeout, platformDBAdminUser, selectAllQuery);
}
}
}
}
}
public MainViewModel(Dispatcher dispatcher)
{
// handle settings
this.settingsFile = this.DetermineSettingsFile();
this.MonlistSettings = ReadSettings(this.settingsFile);
dispatcher.BeginInvoke(DispatcherPriority.Loaded, new Action(UpdateVisibility));
this.Settings = this.MonlistSettings;
this.CustomWindowPlacementSettings = new CustomWindowPlacementSettings(this.Settings);
WorkDayParser.Instance = new WorkDayParser(this.Settings.ParserSettings);
// pnsearch
this.PNSearch = new PNSearchViewModel(this.Settings.MainSettings.ProjectNumberFilePath, this.Settings.MainSettings.MonlistGBNumber);
// posnumsearch
this.PositionSearch = new PositionSearchViewModel(this.Settings.MainSettings.PositionNumberFilePath);
// read persistencedata
string dataDirectory = Utils.PatchFilePath(this.MonlistSettings.MainSettings.DataDirectory);
this.persistenceLayer = new TextFilePersistenceLayer(dataDirectory);
this.csvExporter = new CSVExporter(dataDirectory);
this.jsonExporter = new JSONExporter(dataDirectory);
//this.persistentResult = this.persistenceLayer.ReadData();
this.SelectToday(); // sets data from persistencelayer
if (dispatcher != null)
{
this.throttleSaveAndCalc = new DispatcherTimer(DispatcherPriority.DataBind, dispatcher);
this.throttleSaveAndCalc.Tick += this.throttleSaveAndCalc_Tick;
}
// updateinfo
Version currentVersion = Assembly.GetExecutingAssembly().GetName().Version;
this.UpdateInfoViewModel = new UpdateInfoViewModel(this.Settings.MainSettings.UpdateInfoURL, currentVersion, this.persistenceLayer.EntryCount, this.persistenceLayer.FirstEntryDate);
// load help
dispatcher.BeginInvoke(DispatcherPriority.Loaded, new Action(async() =>
{
var readme = await this.ReadHelpAsync();
this.Help = readme;
}));
this.SelectWorkItemTextComplete += DoSelectWorkItemTextComplete;
this.SelectWorkItemTextWithOutTime += DoSelectWorkItemTextWithOutTime;
this.GoToDay = DoGoToDay;
}
private void TryExportToCSV()
{
string newCSVExportPath = EditorUtility.SaveFilePanel("Save CSV", EditorWindowTools.GetDirectoryName(csvExportPath), csvExportPath, "csv");
if (!string.IsNullOrEmpty(newCSVExportPath))
{
csvExportPath = newCSVExportPath;
if (Application.platform == RuntimePlatform.WindowsEditor)
{
csvExportPath = csvExportPath.Replace("/", "\\");
}
CSVExporter.Export(database, csvExportPath, exportActors, exportItems, exportLocations, exportVariables, exportConversations, exportConversationsAfterEntries, entrytagFormat);
EditorUtility.DisplayDialog("Export Complete", "The dialogue database was exported to CSV (comma-separated values) format. ", "OK");
}
}
private void Export(bool optionCustomersWithOrders, bool optionNewsletterSubscribers)
{
List <object> exportList = new List <object>();
if (optionNewsletterSubscribers)
{
List <NewsLetter> newsletterMailingList = NewsLetter.NewsLetterMailingList(optionCustomersWithOrders);
exportList = newsletterMailingList.ConvertAll <object>(delegate(NewsLetter g) { return((object)g); });
}
else
{
List <GridCustomer> customerList = new List <GridCustomer>();
if (optionCustomersWithOrders) // filter to customers only with orders
{
var allCustomers = GridCustomer.GetCustomers();
foreach (var c in allCustomers)
{
Customer customer = new Customer(c.CustomerID);
if (customer.HasOrders())
{
customerList.Add(c);
}
}
}
else // return all customers
{
customerList = GridCustomer.GetCustomers();
}
exportList = customerList.ConvertAll <object>(delegate(GridCustomer g) { return((object)g); });
}
StringBuilder strMailingList = new StringBuilder();
Response.Clear();
Response.ClearHeaders();
Response.ClearContent();
Response.AddHeader("content-disposition", "attachment; filename=MailingList.csv");
Response.ContentType = "text/csv";
Response.AddHeader("Pragma", "public");
strMailingList.Append(CSVExporter.ExportListToCSV(exportList));
Response.Write(strMailingList.ToString());
Response.End();
}
public void OnExportClicked()
{
StringBuilder sb = new StringBuilder();
sb.AppendLine($"Type,Name,Action Summary,Notes");
foreach (ReturnedEntity item in ReportEntities)
{
sb.AppendLine(
$"{item.Type},{item.FullName},{item.Action.actionType} completed by {item.Action.completedBy} on {item.Action.date.Value.ToShortDateString()},\"{item.Action.DecodedNotes}\"");
}
ReportExporter exporter = new CSVExporter()
{
Data = sb.ToString()
};
exporter.Export();
}
public void OnExportClicked()
{
StringBuilder sb = new StringBuilder();
sb.AppendLine($"Type,SunshineID,Name,Address,Last Action");
foreach (ReturnedEntity item in ReportEntities)
{
sb.AppendLine(
$"{item.Type},{item.SunshineId},{item.FullName},{item.FullAddress},{item.LastAction}");
}
ReportExporter exporter = new CSVExporter()
{
Data = sb.ToString()
};
exporter.Export();
}
// GET Report/ExportMatrix
public FileContentResult ExportMatrix()
{
string displayName;
var csvExport = new CSVExporter();
foreach (var reportMatrix in ReportProvider.GetMatrix())
{
csvExport.AddRow();
foreach (var prop in reportMatrix.GetType().GetProperties())
{
switch (prop.Name)
{
case "Reporting Period":
displayName = "Reporting Period";
break;
case "RecordStatus":
displayName = "Record Status";
break;
case "NewVehicles":
displayName = "New Vehicles";
break;
case "ExpansionVehicles":
displayName = "Expansion Vehicles";
break;
case "ReplacementVehicles":
displayName = "Replacement Vehicles";
break;
default:
displayName = prop.Name;
break;
}
csvExport[displayName] = prop.GetValue(reportMatrix, null);
}
}
return(File(new UTF8Encoding().GetBytes(csvExport.Export()), "text/csv", "ReportMatrix.csv"));
}
public void CounterTest()
{
string fileName = "CounterTest.csv";
CSVExporter exporter = new CSVExporter(fileName);
exporter.Initialize();
DateTime start = DateTime.Now;
for (int i = 0; i < 10; i++)
{
exporter.CounterPayloadReceived(new GaugePayload("myProvider", "counterOne", "Counter One", "", "", i, start + TimeSpan.FromSeconds(i)), false);
}
exporter.Stop();
Assert.True(File.Exists(fileName));
try
{
List <string> lines = File.ReadLines(fileName).ToList();
Assert.Equal(11, lines.Count); // should be 11 including the headers
string[] headerTokens = lines[0].Split(',');
Assert.Equal("Provider", headerTokens[1]);
Assert.Equal("Counter Name", headerTokens[2]);
Assert.Equal("Counter Type", headerTokens[3]);
Assert.Equal("Mean/Increment", headerTokens[4]);
for (int i = 1; i < lines.Count; i++)
{
string[] tokens = lines[i].Split(',');
Assert.Equal("myProvider", tokens[1]);
Assert.Equal("Counter One", tokens[2]);
Assert.Equal("Metric", tokens[3]);
Assert.Equal((i - 1).ToString(), tokens[4]);
}
}
finally
{
File.Delete(fileName);
}
}
public void ParsingComplete(IEnumerable <DeviceData> deviceDatas)
{
// Check if any files were parsed
if (deviceDatas.Count() == 0)
{
MessageBox.Show("There where no files that parsed or parsed correctly. No export file was created.", "Parsing Failed");
LoadingSpinner.StopText();
return;
}
// Export to CSV file on desktop
string filePath = Path.Combine(directoryOfFiles, Path.ChangeExtension(DeviceFileParser.FileName, ".csv"));
CSVExporter.ExportFiles(deviceDatas, filePath);
MessageBox.Show("Parseing complete. An excel spreadsheet and zipped folder with files used can be found in the same directory with the name of the device.", "Parsing Complete");
LoadingSpinner.StopText();
}
/// <summary>
/// Raises the activated event when the Export menu item is invoked.
/// </summary>
/// <param name='sender'>
/// The Gtk.MenuItem.
/// </param>
/// <param name='args'>
/// Arguments.
/// </param>
///
void OnExportActivated(object sender, EventArgs args)
{
var fc = new Gtk.FileChooserDialog("Save", null, Gtk.FileChooserAction.Save, "Cancel",
Gtk.ResponseType.Cancel, "Export", Gtk.ResponseType.Accept);
try {
Directory.CreateDirectory("/media/LocalD/SolidProject/Tools/DataMorphose/plugins/ImportExport/test/DemoDB/Text/ExportedFiles");
fc.SetCurrentFolder("/media/LocalD/SolidProject/Tools/DataMorphose/plugins/ImportExport/test/DemoDB/Text/ExportedFiles/");
if (fc.Run() == (int)Gtk.ResponseType.Accept)
{
CSVExporter exporter = new CSVExporter();
exporter.ExportDatabase(morphose.GetModel().DB, fc.Filename);
morphose.GetModel();
}
} finally {
fc.Destroy();
}
}
public void TagsTest()
{
string fileName = "tagsTest.csv";
CSVExporter exporter = new CSVExporter(fileName);
exporter.Initialize();
DateTime start = DateTime.Now;
for (int i = 0; i < 100; i++)
{
exporter.CounterPayloadReceived(new RatePayload("myProvider", "allocRateGen", "Allocation Rate Gen", "MB", "foo=bar,baz=7", i, 60, start + TimeSpan.FromSeconds(i)), false);
}
exporter.Stop();
Assert.True(File.Exists(fileName));
try
{
List <string> lines = File.ReadLines(fileName).ToList();
Assert.Equal(101, lines.Count); // should be 101 including the headers
string[] headerTokens = lines[0].Split(',');
Assert.Equal("Provider", headerTokens[1]);
Assert.Equal("Counter Name", headerTokens[2]);
Assert.Equal("Counter Type", headerTokens[3]);
Assert.Equal("Mean/Increment", headerTokens[4]);
for (int i = 1; i < lines.Count; i++)
{
string[] tokens = lines[i].Split(',');
Assert.Equal("myProvider", tokens[1]);
Assert.Equal($"Allocation Rate Gen (MB / 60 sec)[foo=bar;baz=7]", tokens[2]);
Assert.Equal("Rate", tokens[3]);
Assert.Equal((i - 1).ToString(), tokens[4]);
}
}
finally
{
File.Delete(fileName);
}
}
private void ExportShipment()
{
string importMethod = "export";
string filepath = CommonLogic.SafeMapPath("../images") + "\\";
string filename = importMethod + Localization.ToThreadCultureShortDateString(System.DateTime.Now).Replace(" ", "").Replace("/", "").Replace(":", "").Replace(".", "");
string fileextension = String.Empty;
string xml = ExportXML();
string extname = "csv";
string[] oldfiles = Directory.GetFiles(filepath, "export*." + extname);
foreach (string oldfile in oldfiles)
{
try
{
File.Delete(oldfile);
}
catch { }
}
List <object> newList = ExportList();
String csvList = CSVExporter.ExportListToCSV(newList);
using (StreamWriter sw = new StreamWriter(filepath + filename + ".csv"))
{
sw.Write(csvList);
sw.Close();
sw.Dispose();
}
Response.Clear();
Response.ClearHeaders();
Response.ClearContent();
Response.AddHeader("content-disposition", "attachment; filename=Export_ADNSF.csv");
Response.ContentType = "text/csv";
Response.AddHeader("Pragma", "public");
Response.Write(csvList);
Response.End();
}
