static void Main(string[] args)
{
var cmiXmlPath = args[0]; // @"Z:\MSaravi\MIMS-Sample\CMI\CMIxml20170100\CMIxml";
var outputPath = args[1]; //@"Z:\MSaravi\MIMS-Sample\CMI\output.csv"
var xmiXmlExtension = @System.Configuration.ConfigurationManager.AppSettings["fileType"]; // "*.xml";
var separator = @System.Configuration.ConfigurationManager.AppSettings["separator"]; // "*.xml";
var enclose = @System.Configuration.ConfigurationManager.AppSettings["enclose"]; // "*.xml";
var newLine = @System.Configuration.ConfigurationManager.AppSettings["newLine"]; // "*.xml";
var schema = GetSchema();
var _CsvGenerator = new CsvGenerator(outputPath, schema, separator, enclose, newLine);
var fileNames = System.IO.Directory.EnumerateFiles(cmiXmlPath, xmiXmlExtension).ToList();
var progress = 0.0;
var total = (double)fileNames.Count;
_CsvGenerator.AddHeader();
foreach (string fileName in fileNames)
{
string xmlFileContents = File.ReadAllText(fileName);
var cmiCode = GetCmiCodeFromFileName(fileName);
var escapedXmlFileContents = System.Security.SecurityElement.Escape(xmlFileContents);
_CsvGenerator.AddRecord(new string[] { cmiCode, xmlFileContents, escapedXmlFileContents });
Console.WriteLine(cmiCode + " finished, %" + Math.Round(progress * 100 / total, 1).ToString());
progress++;
}
_CsvGenerator.End();
}
public void OptimizationStoresLessItems_BiggerAmounts(int items_number, int orders_number)
{
CsvGenerator csv_generator = new CsvGenerator(items_number, orders_number);
ObjectGenerator obj_generator = new ObjectGenerator();
optimizer = new Optimizer();
CancellationTokenSource cts = new CancellationTokenSource();
csv_generator.GenerateOrdersFile();
var orders = obj_generator.CreateOrders();
csv_generator.GenerateShipmentFile(orders);
var shipment = obj_generator.CreateShipment();
Random rnd = new Random();
int test_num = 10;
for (int i = 1; i <= test_num; i++)
{
var optimized_orders = optimizer.GetMonteCarlo(orders, shipment, cts.Token);
var nonOpt_package = optimizer.GetNonOpt(orders, shipment);
var opt_num = optimized_orders.Sum(x => x.TotalItems);
var nonOpt_num = nonOpt_package.Sum(x => x.TotalItems);
Assert.That(opt_num > nonOpt_num);
}
}
public async Task <IActionResult> GenerateReportForDate(DateTime date, [FromBody] ReportGenBindingModel bm)
{
var formattedDateString = date.Date.ToString("yyyy-MM-dd");
var attendance = await _attendanceRepo.GetAttendance(date);
var attendanceCsv = await CsvGenerator.ForAttendees(attendance);
var emailMessage = new EmailMessage
{
Subject = $"Attendance Reports For {formattedDateString}",
Content = "<p>See attached for the generated report</p>",
Attachments = new List <EmailAttachment>
{
new()
{
Content = attendanceCsv,
MimeType = "text/csv",
Name = $"{formattedDateString}.csv"
}
}
};
await _emailService.SendAsync(bm?.EmailAddress, emailMessage);
return(NoContent());
}
private void exportEanCsvDocument(object sender, RunWorkerCompletedEventArgs e)
{
if (this.InvokeRequired)
{
object[] args = new object[2];
args[0] = sender;
args[1] = e;
exportEanCsvDocumentDelegate deleg = new exportEanCsvDocumentDelegate(exportEanCsvDocument);
this.Invoke(deleg, args);
}
else
{
if (e.Error != null)
{
LogUtils.error(e.Error);
MessageBox.Show("Une erreur est survenue : " + e.Error.Message);
return;
}
DialogResult dr = saveCsvFile.ShowDialog();
if (dr == DialogResult.Cancel)
{
return;
}
// Saving the file name for later
Aide_Dilicom3.Properties.Settings.Default.ExportEanCsvFile = saveCsvFile.FileName;
Aide_Dilicom3.Properties.Settings.Default.Save();
List <Article> results = (List <Article>)e.Result;
CsvGenerator.GenerateCsv(saveCsvFile.FileName, results.ToArray());
}
}
public void CanGenerateACsvDefinitionWhereCommasAreEscaped(string headers, string rows)
{
var definition = CsvDefinitionProvider.Get(headers.Split(','),
rows.Split('|').Select(row => SplitWithEscape(row, ',', '"')).ToArray());
var testInput = definition.GenerateString();
var result = CsvGenerator.FromString(testInput);
Assert.Equal(definition.Headers.Count, result.Headers.Count);
Assert.Equal(definition.Rows.Count, result.Rows.Count);
foreach (var header in definition.Headers)
{
Assert.Contains(header, result.Headers);
}
for (var i = 0; i < definition.Rows.Count; i++)
{
var definitionRow = definition.Rows[i];
var resultRow = result.Rows[i];
for (var ci = 0; ci < definitionRow.Count; ci++)
{
Assert.Equal(definitionRow[ci].ToString(), resultRow[ci].ToString());
}
}
}
public void GetStringReport_WhenCalled_ReturningEmptyLines(string splitter)
{
List <dynamic> data = new List <dynamic>
{
new Dictionary <string, object>()
{
["user"] = "******",
["age"] = 30,
["sex"] = null
},
new Dictionary <string, object>
{
["user"] = null,
["age"] = null,
["sex"] = "male"
},
new Dictionary <string, object>
{
["user"] = "******",
["age"] = 10000,
["sex"] = "male"
}
};
var expected = $"user{splitter}age{splitter}sex{Environment.NewLine}" +
$"james{splitter}30{splitter}{splitter}{Environment.NewLine}" +
$"{splitter}{splitter}male{splitter}{Environment.NewLine}" +
$"mr.popo{splitter}10000{splitter}male{splitter}";
var result = CsvGenerator.GetStringReport(data, splitter);
result.Should().Be(expected);
}
public static ClaimAdvice StoreClaimAdvice(ClaimAdvice claimAdvice, List <string> filePaths, string databaseRecoveryPath)
{
try
{
int isSaved;
using (var context = new PickeringsContext())
{
context.ClaimAdvices.Add(claimAdvice);
isSaved = context.SaveChanges();
claimAdvice.ReferenceNumber = "PCAF" + claimAdvice.id;
context.SaveChanges();
}
if (isSaved == 0)
{
WriteCustomErrorLog.WriteLog("An error occured while saving claim advice - Email-" + claimAdvice.ContactEmail.ToString());
CsvGenerator.SaveAsCsV(claimAdvice, @databaseRecoveryPath, filePaths, true);
}
}
catch (Exception ex)
{
WriteCustomErrorLog.WriteLog("An error occured while saving claim advice - Email-" + claimAdvice.ContactEmail.ToString());
CsvGenerator.SaveAsCsV(claimAdvice, @databaseRecoveryPath, filePaths, true);
if (filePaths.Count > 0)
{
string serverPath = Path.GetDirectoryName(filePaths[0]);
new FileHandler().DeleteFiles(serverPath);
}
throw new Exception(ex.Message);
}
return(claimAdvice);
}
public void SendMail(List <string> attachmentFilesPath, ClaimAdvice claimAdvice, IDictionary <string, string> Configurations)
{
string[] emailBodys = HtmlTableGenerator.CreateHtmlMail(claimAdvice);
bool mailSentStatus = EmailSender.SendMail(Configurations, emailBodys[0], "Pickerings Claim Submission – Reference Number " + claimAdvice.ReferenceNumber, attachmentFilesPath);
if (!mailSentStatus)
{
WriteCustomErrorLog.WriteLog("Email failed to AJG - Ref # : " + claimAdvice.ReferenceNumber.ToString());
CsvGenerator.SaveAsCsV(claimAdvice, @Configurations["EmailToAJGrecoveryPath"], attachmentFilesPath);
}
Configurations["ToAddress"] = claimAdvice.ContactEmail;
mailSentStatus = EmailSender.SendMail(Configurations, emailBodys[1], "Pickerings Claim Submission – Reference Number " + claimAdvice.ReferenceNumber);
if (!mailSentStatus)
{
WriteCustomErrorLog.WriteLog("Email failed to initiator - Ref # : " + claimAdvice.ReferenceNumber.ToString());
CsvGenerator.SaveAsCsV(claimAdvice, @Configurations["EmailToInitiatorRecoveryPath"], attachmentFilesPath);
}
if (attachmentFilesPath.Count > 0)
{
string serverPath = Path.GetDirectoryName(attachmentFilesPath[0]);
new FileHandler().DeleteFiles(serverPath);
}
}
public async Task <FileResult> ExportCSV(ReportConfigureViewModel viewModel)
{
var receiptsResults = await dbReceipt.GetAll();
string fileName = ($"Report {viewModel.CarData} {viewModel.StartDate.ToString("yyyyMMdd")} {viewModel.EndDate.ToString("yyyyMMdd")}.csv").Replace(' ', '_');
byte[] fileBody = CsvGenerator.CreateCsvBody(viewModel, receiptsResults);
return(File(fileBody, "text/csv", fileName));
}
public void WhenGenerateObjects_OrdersNumberCorrect(int items_number, int orders_number)
{
CsvGenerator csv_generator = new CsvGenerator(items_number, orders_number);
ObjectGenerator obj_generator = new ObjectGenerator();
csv_generator.GenerateOrdersFile();
var orders = obj_generator.CreateOrders();
var orderId_num = orders.SelectMany(x => x.OrderItems).GroupBy(y => y.OrderId).Count();
Assert.That(orderId_num == orders_number);
}
public ActionResult Generate(HttpPostedFileBase excelFile = null, string nodeName = null)
{
if (excelFile == null || excelFile.ContentLength <= 0 || string.IsNullOrWhiteSpace(nodeName))
{
return(RedirectToAction("Index"));
}
var path = Path.GetTempFileName();
ViewBag.ErrorMessage = path + Environment.NewLine;
try
{
excelFile.SaveAs(path);
var posList = new ExcelPositionList(path);
if (!posList.LoadAiSheet())
{
ViewBag.ErrorMessage += "Ошибка загрузки страницы AI из Excel\n" + Environment.NewLine;
}
if (!posList.LoadAoSheet())
{
ViewBag.ErrorMessage += "Ошибка загрузки страницы AO из Excel\n" + Environment.NewLine;
}
if (!posList.LoadDioSheet())
{
ViewBag.ErrorMessage += "Ошибка загрузки страницы DIO из Excel\n" + Environment.NewLine;
}
var binDirectoryPath = Server.MapPath("~/bin");
var p = AppDomain.CurrentDomain.BaseDirectory;
var shemaFilePath = Path.Combine(binDirectoryPath, @"RSView\ImportExport\POSITIONLIST.xml");
var shema = XElement.Load(shemaFilePath);
var converter = new RSViewPositionListConverter(posList, shema, nodeName);
var csvGenerator = new CsvGenerator(converter.ConvertAllPositionsToRsViewTags(), nodeName);
var fileData = csvGenerator.GetZipStream().ToArray();
var fileName = csvGenerator.ZipFileName;
//Response.AppendHeader("Content-Disposition", );
return(File(fileData, MediaTypeNames.Application.Zip, fileName));
}
catch (Exception ex)
{
System.IO.File.Delete(path);
ViewBag.ErrorMessage += ex.ToString();
return(View());
}
finally
{
System.IO.File.Delete(path);
}
}
public async Task <IActionResult> ExportTestSuite(long id)
{
var testSuite = await _repository.GetSuite(id, true);
if (testSuite == null)
{
return(NotFound());
}
CsvGenerator csvGenerator = new CsvGenerator();
return(Ok(csvGenerator.GenerateFromSuite(testSuite)));
}
private void Generate_csv_button_Click(object sender, RoutedEventArgs e)
{
int items_number = (int)items_slider.Value;
int orders_number = (int)orders_slider.Value;
CsvGenerator csv_generator = new CsvGenerator(items_number, orders_number);
csv_generator.GenerateOrdersFile();
shop.Orders = obj_generator.CreateOrders(); // 1.Input Csv
csv_generator.GenerateShipmentFile(shop.Orders); //Send Sum to Factory
shop.Shipment = obj_generator.CreateShipment(); // 2.Input Csv
all_label.Content = shop.Orders.Sum(x => x.TotalItems);
}
private static void GenerateCsv(CsvOutputConfiguration config, Dictionary <string, int> words, string baseName)
{
if (!config.IsEnabled)
{
return;
}
Console.Write("Writing word list to csv...");
var csvGenerator = new CsvGenerator();
var csvData = csvGenerator.Generate(words);
csvData.Save(baseName);
Console.WriteLine("[Done]");
}
public void ShouldBeEmptyWhenWordsAreEmpty()
{
// Arrange
var sut = new CsvGenerator();
var input = new Dictionary <string, int>();
// Act
var actual = sut.Generate(input);
// Assert
var expected = "Word;Count" + Environment.NewLine;
Assert.Equal(expected, actual.ToString());
}
public void WhenGenerateObjects_NoRepeatedItemInOrder(int items_number, int orders_number)
{
CsvGenerator csv_generator = new CsvGenerator(items_number, orders_number);
ObjectGenerator obj_generator = new ObjectGenerator();
csv_generator.GenerateOrdersFile();
var orders = obj_generator.CreateOrders();
var order_by_id = orders.GroupBy(y => y.OrderId);
foreach (var order in order_by_id)
{
var num = order.SelectMany(x => x.OrderItems).GroupBy(y => y.ItemName).Count();
Assert.That(num <= items_number);
}
}
/// <summary>
/// Converts the given list of objects into CSV format.
/// </summary>
/// <typeparam name="T">The object type.</typeparam>
/// <param name="data">The data.</param>
/// <returns>The CSV representation of the given objects.</returns>
public string ToCsv <T>(IList <T> data)
{
var properties = GetCleanObjectProperties(data.First());
var generator = new CsvGenerator().AddHeaders(properties);
foreach (var item in data)
{
var values = properties.Select(
property => item.GetType().GetProperty(property)?.GetValue(item).ToString())
.ToList();
generator.CreateRow(values, false);
}
return(generator.ToString());
}
public void HeaderDeterminationIsCaseInsensitive(string headers, string rows)
{
var headersArray = headers.Split(',');
var definition = CsvDefinitionProvider.Get(headersArray,
rows.Split('|').Select(row => row.Split(',')).ToArray());
var testInput = definition.GenerateString();
var result = CsvGenerator.FromString(testInput);
var testRow = result.Rows.First();
foreach (var header in headersArray)
{
var cell = testRow.Cell(header);
Assert.True(cell != null, "The header was not found at all.");
cell = testRow.Cell(header.ToLower());
Assert.True(cell != null, "The header does not match when lower cased.");
cell = testRow.Cell(header.ToUpper());
Assert.True(cell != null, "The header does not match when upper cased.");
}
}
public void ShouldContainWordsInCorrectOrder()
{
// Arrange
var sut = new CsvGenerator();
var input = new Dictionary <string, int>
{
{ "two", 2 },
{ "three", 3 },
{ "one", 1 }
};
// Act
var actual = sut.Generate(input);
// Assert
var expected = "Word;Count" + Environment.NewLine +
"three;3" + Environment.NewLine +
"two;2" + Environment.NewLine +
"one;1" + Environment.NewLine;
Assert.Equal(expected, actual.ToString());
}
static void Main(string[] args)
{
PostgresDbCreator postgresDbCreator = new PostgresDbCreator();
PostgresDbSeeder postgresDbSeeder = new PostgresDbSeeder();
SQLiteDbCreator sqLiteDbCreator = new SQLiteDbCreator();
SQLiteDbSeeder sqLiteDbSeeder = new SQLiteDbSeeder();
PostgresDbExtractor postgresDbExtractor = new PostgresDbExtractor();
SQLiteDbExtractor sqLiteDbExtractor = new SQLiteDbExtractor();
CsvGenerator csvGenerator = new CsvGenerator();
HtmlGenerator htmlGenerator = new HtmlGenerator();
XmlGenerator xmlGenerator = new XmlGenerator();
CsGenerator csGenerator = new CsGenerator();
try
{
using (DbConnection connection = new SQLiteConnection(Configuration.SQLiteConnectionString))
{
connection.Open();
var path = "D:\\sqLite_output";
if (Directory.Exists(path))
{
Directory.Delete(path, true);
}
Directory.CreateDirectory(path);
var sqLiteTables = sqLiteDbExtractor.GetTables(connection);
foreach (var sqLiteTable in sqLiteTables.Where(x => x != "sqlite_sequence"))
{
csvGenerator.Generate(sqLiteDbExtractor, connection, sqLiteTable, path);
htmlGenerator.Generate(sqLiteDbExtractor, connection, sqLiteTable, path);
xmlGenerator.Generate(sqLiteDbExtractor, connection, sqLiteTable, path);
csGenerator.Generate(sqLiteDbExtractor, connection, sqLiteTable, path);
}
}
using (DbConnection connection = new NpgsqlConnection(Configuration.NpgsqlConnectionString))
{
connection.Open();
var path = "D:\\pgsql_output";
if (Directory.Exists(path))
{
Directory.Delete(path, true);
}
Directory.CreateDirectory(path);
var pgsqlTables = postgresDbExtractor.GetTables(connection);
foreach (var pgsqlTable in pgsqlTables)
{
csvGenerator.Generate(postgresDbExtractor, connection, pgsqlTable, path);
htmlGenerator.Generate(postgresDbExtractor, connection, pgsqlTable, path);
xmlGenerator.Generate(postgresDbExtractor, connection, pgsqlTable, path);
csGenerator.Generate(postgresDbExtractor, connection, pgsqlTable, path);
}
}
}
catch (Exception e)
{
Console.WriteLine(e.Message);
throw;
}
}
public void WhenCallingGenerateFileDirectlyTheDefinitionParameterIsRequired()
=> Assert.Throws <ArgumentNullException>("definition", () => CsvGenerator.GenerateFile(null, "C:\\myfile.csv"));
public void WhenCallingGenerateBytesDirectlyTheDefinitionParameterIsRequired()
=> Assert.Throws <ArgumentNullException>("definition", () => CsvGenerator.GenerateBytes(null));
static void ToCSV(Dictionary <string, string> streetsNumbers)
{
IFileGenerator csvGenerator = new CsvGenerator(Directory.GetCurrentDirectory(), "dachs");
csvGenerator.Generate(streetsNumbers);
}
public byte[] GenerateShipmentRequestDocument(IEnumerable <IPurchaseOrder> orders)
{
var orderList = orders.ToList();
m_log.Info($"Zacinam vytvareni dokumentu pro Zasilkovnu, zdroj = {orderList.Count} objednavek");
using (var stream = new MemoryStream())
using (var streamWriter = new StreamWriter(stream, Encoding.UTF8))
{
var generator = new CsvGenerator(streamWriter, ZasilkovnaColIndex);
foreach (var order in orderList)
{
try
{
var shipmentTitle = order.ShippingMethodName;
var dobirkovaCastka = StringUtil.FormatDecimal(order.PriceWithVat);
if (!string.IsNullOrWhiteSpace(dobirkovaCastka) && order.Currency.Symbol == "CZK")
{
dobirkovaCastka = ((int)double.Parse(dobirkovaCastka)).ToString();
}
if (!order.IsPayOnDelivery)
{
dobirkovaCastka = string.Empty;
}
var pobockaId = GetPobockaId(order);
if (string.IsNullOrWhiteSpace(order.CustomerEmail) &&
string.IsNullOrWhiteSpace(order.DeliveryAddress?.Phone) &&
string.IsNullOrWhiteSpace(order.InvoiceAddress?.Phone))
{
throw new Exception("Musi byt telefon nebo e-mail");
}
var externalDeliveryProvider = false;
if (string.IsNullOrWhiteSpace(pobockaId))
{
externalDeliveryProvider = true;
pobockaId = GetBranches().GetPobockaId(shipmentTitle, GetShipmentMethodsMapping());
}
if (order.ErpId == null)
{
throw new InvalidOperationException("Unexpected order without Erp");
}
var erpClient = m_erpClientFactory.GetErpClient(order.ErpId.Value);
var trackingNumber = erpClient.GetPackingReferenceNumber(order);
decimal?weight = null;
try
{
weight = m_orderWeightCalculator.GetWeight(order);
}
catch (Exception e)
{
m_log.Error($"Weight calc failed", e);
}
// not sure about Version 4 used by Elsa, but ver. 6 is documented here: https://docs.packetery.com/03-creating-packets/01-csv-import.html
generator.CellOpt(null) //1 Vyhrazeno
.CellMan(trackingNumber) //2 Číslo objednávky
.CellMan(order.DeliveryAddress?.FirstName, order.InvoiceAddress?.FirstName) //3 Jméno
.CellMan(order.DeliveryAddress?.LastName, order.InvoiceAddress?.LastName) //4 Příjmení
.CellOpt(
externalDeliveryProvider
? (string.IsNullOrWhiteSpace(order.DeliveryAddress?.CompanyName)
? order.InvoiceAddress?.CompanyName
: order.DeliveryAddress?.CompanyName)
: string.Empty) //5 Firma
.CellOpt(order.CustomerEmail) //6 E-mail
.CellOpt(order.DeliveryAddress?.Phone, order.InvoiceAddress?.Phone) //7 Mobil
.CellOpt(dobirkovaCastka) //8 Dobírková částka
.CellMan(order.Currency.Symbol) //9 Měna
.CellMan(StringUtil.FormatDecimal(order.PriceWithVat)) //10 Hodnota zásilky
.CellOpt(StringUtil.FormatDecimal(weight)) //11 Hmotnost zásilky
.CellMan(pobockaId) //12 Cílová pobočka
.CellMan(/*"biorythme.cz"*/ m_config.ClientName) //13 Odesilatel
.CellMan(0) //14 Obsah 18+
.CellOpt(null) //15 Zpožděný výdej
;
if (externalDeliveryProvider)
{
generator.CellMan(order.DeliveryAddress?.Street, order.InvoiceAddress?.Street) //16
.CellMan(
GetFormattedHouseNumber(order.DeliveryAddress),
GetFormattedHouseNumber(order.InvoiceAddress)) //17
.CellMan(order.DeliveryAddress?.City, order.InvoiceAddress?.City) //18
.CellMan(order.DeliveryAddress?.Zip, order.InvoiceAddress?.Zip) //19
;
}
generator.CommitRow();
}
catch (Exception ex)
{
generator.RollbackRow();
throw new InvalidOperationException(
"Chyba objednavky " + order.OrderNumber + ":" + ex.Message,
ex);
}
}
streamWriter.Flush();
return(stream.ToArray());
}
}
