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(); }