public static bool SaveWithFiles(List <string> inFiles, string inZipFileName)
{
try
{
bool result = false;
using (ZipFile zip = new ZipFile())
{
foreach (string filename in inFiles)
{
if (!filename.EndsWith(@".zip"))
{
zip.AddFile(filename, @"");
}
}
if (zip.Count > 0)
{
zip.Save(inZipFileName);
result = true;
}
}
return(result);
}
catch (Exception e)
{
SummaException se = new SummaException("Problem creating Summa ZIP file. " + inZipFileName, e);
throw e;
}
}
public static bool SaveWithFolder(string inFolder, string inZipFileName)
{
try
{
// note: this does not recurse directories!
string[] filenames = System.IO.Directory.GetFiles(inFolder);
List <string> fileList = new List <string>();
foreach (string filename in filenames)
{
//fileList.Add(System.IO.Path.GetFileName(filename));
fileList.Add(filename);
}
if (fileList.Count > 0)
{
return(SaveWithFiles(fileList, inZipFileName));
}
else
{
DebugLog.Log(String.Format("No files found in folder {0}", inFolder));
return(false);
}
}
catch (Exception e)
{
SummaException se = new SummaException("Problem creating Summa ZIP file. Source folder not found ...", e);
throw se;
}
}
public override void SetupData(XmlDocument doc)
{
FULLFILEPATH += SummaFileName.GetName(SummaFileName.SummaFileType.ListPatronsTypes, SummaCommon.GetStoreId(doc));
XmlNodeList patrons = null;
try
{
patrons = doc.DocumentElement.SelectNodes("/ListPatronTypes/PatronType");
int c = 0;
foreach (XmlNode patronNode in patrons)
{
csvData.Add(new List <string>());
csvData[c].Add(GetPatronId(patronNode));
csvData[c].Add(GetPatronName(patronNode));
csvData[c].Add(GetStoreId(doc));
c++;
csvLineData.Add(new StringBuilder());
}
}
catch (Exception e) {
SummaException se = new SummaException("Problem processing patron types", e);
se.Data = doc.OuterXml;
throw se;
}
}
public override void SetupData(XmlDocument doc)
{
XmlNodeList groups = null;
try
{
// In case GetStoreId fails
Summa.ErrorLevelFile = FileLogger.LogErrorLevelFile.ListMemberGroupsXMLFile;
Summa.ErrorStrDetail = doc.DocumentElement.Attributes["id"].Name;
FULLFILEPATH += SummaFileName.GetName(SummaFileName.SummaFileType.CustomerRanking, NewSummaGroupsCommon.GetStoreId(doc));
groups = doc.DocumentElement.SelectNodes("/ListMemberGroups/Group");
int counter = 0;
foreach (XmlNode groupNode in groups)
{
csvData.Add(new List <string>());
csvData[counter].Add(NewSummaGroupsCommon.GetGroupId(groupNode));
csvData[counter].Add(NewSummaGroupsCommon.GetGroupName(groupNode));
csvData[counter].Add(NewSummaGroupsCommon.GetStatus(groupNode));
csvData[counter].Add(NewSummaGroupsCommon.GetStoreId(doc));
counter++;
csvLineData.Add(new StringBuilder());
}
}
catch (Exception e)
{
SummaException se = new SummaException("Problem processing groups", e);
se.Data = doc.OuterXml;
throw se;
}
}
public override void SetupData(XmlDocument doc)
{
XmlNodeList patronTotals = null;
try
{
FULLFILEPATH += SummaFileName.GetName(SummaFileName.SummaFileType.PatronCountsTotals, SummaCommon.GetStoreId(doc));
patronTotals = doc.DocumentElement.SelectNodes("/TotalsPatron/PatronType");
int c = 0;
foreach (XmlNode patronTotalNode in patronTotals)
{
csvData.Add(new List <string>());
csvData[c].Add(GetPatronId(patronTotalNode));
csvData[c].Add(GetPatronCount(patronTotalNode));
csvData[c].Add(GetTimestamp(patronTotalNode));
csvData[c].Add(GetTillId(doc));
csvData[c].Add(doc.DocumentElement.Attributes["SiteID"].Value);
c++;
csvLineData.Add(new StringBuilder());
}
}
catch (Exception e) {
SummaException se = new SummaException("Problem processing patron totals", e);
se.Data = doc.OuterXml;
throw se;
}
}
/// <summary>
/// Setup internal data values for each product.
/// </summary>
/// <param name="doc"></param>
public override void SetupData(XmlDocument doc)
{
XmlNodeList products = null;
try
{
// In case GetStoreId fails
Summa.ErrorLevelFile = FileLogger.LogErrorLevelFile.TransactionXMLFile;
Summa.ErrorStrDetail = doc.DocumentElement.Attributes["id"].Name;
FULLFILEPATH += SummaFileName.GetName(SummaFileName.SummaFileType.TransactionDetails, SummaTransactionCommon.GetStoreId(doc));
products = doc.DocumentElement.SelectNodes("/Transaction/Receipt/Product");
int counter = 0;
foreach (XmlNode productNode in products)
{
csvData.Add(new List <string>());
#region Specs v1.2
csvData[counter].Add(GetTransactionDetailID(doc, productNode));
#endregion
csvData[counter].Add(SummaTransactionCommon.GetTransactionID(doc));
csvData[counter].Add(SummaTransactionProductCommon.GetProductId(productNode));
csvData[counter].Add(GetQty(doc, productNode));
#region Old Specs
//csvData[counter].Add(SummaTransactionProductCommon.GetUnitPrice(productNode));
//csvData[counter].Add(SummaTransactionProductCommon.GetDiscount(productNode));
#endregion
#region Specs v1.2
// GST = Tax, in this context
csvData[counter].Add(GetUnitPriceXGST(productNode));
csvData[counter].Add(GetGSTAmount(productNode));
csvData[counter].Add(SummaTransactionProductCommon.GetDiscountXGST(productNode));
csvData[counter].Add(SummaTransactionProductCommon.GetDiscountGSTAmount(productNode));
#endregion
csvData[counter].Add(SummaTransactionProductCommon.GetPromotionId(productNode));
csvData[counter].Add(SummaTransactionProductCommon.GetBarcode(productNode));
csvData[counter].Add(SummaTransactionCommon.GetStoreId(doc));
counter++;
csvLineData.Add(new StringBuilder());
}
}
catch (Exception e) {
SummaException se = new SummaException("Problem processing transaction detail", e);
se.Data = doc.OuterXml;
throw se;
}
}
public override void SetupData(XmlDocument doc)
{
XmlNodeList productTotals = null;
try
{
FULLFILEPATH += SummaFileName.GetName(SummaFileName.SummaFileType.ProductTotals, SummaCommon.GetStoreId(doc));
productTotals = doc.DocumentElement.SelectNodes("/TotalsProducts/Product");
int counter = 0;
foreach (XmlNode productTotalNode in productTotals)
{
csvData.Add(new List <string>());
csvData[counter].Add(SummaProductTotalsCommon.GetProductId(productTotalNode));
csvData[counter].Add(SummaProductTotalsCommon.GetQty(productTotalNode));
#region Old Specs
// csvData[counter].Add(SummaProductTotalsCommon.GetTotalSales(productTotalNode));
#endregion
#region Specs v1.2
csvData[counter].Add(SummaProductTotalsCommon.GetTotalSalesXTax(productTotalNode));
csvData[counter].Add(SummaProductTotalsCommon.GetTotalTaxAmount(productTotalNode));
#endregion
csvData[counter].Add(SummaProductTotalsCommon.GetTimestamp(productTotalNode));
csvData[counter].Add(SummaCommon.GetStoreId(doc));
csvData[counter].Add(SummaCommon.GetTillId(doc));
counter++;
csvLineData.Add(new StringBuilder());
/*
* if ((counter == 1) || (counter > productTotals.Count))
* {
* csvLineData.Add(new StringBuilder());
* }
* else
* {
* csvLineData.Add(new StringBuilder(","));
* }
*/
}
}
catch (Exception e) {
SummaException se = new SummaException("Problem processing product totals", e);
se.Data = doc.OuterXml;
throw se;
}
}
public override void SetupData(XmlDocument doc)
{
FULLFILEPATH += SummaFileName.GetName(SummaFileName.SummaFileType.HourlyTotals, SummaCommon.GetStoreId(doc));
XmlNodeList hourTotals = null;
try
{
hourTotals = doc.DocumentElement.SelectNodes("/TotalsHourlySales/Hour");
int counter = 0;
foreach (XmlNode hourTotalNode in hourTotals)
{
csvData.Add(new List <string>());
csvData[counter].Add(SummaHourlyTotalsCommon.GetHourId(hourTotalNode));
csvData[counter].Add(SummaHourlyTotalsCommon.GetTransQty(hourTotalNode));
#region Old Specs
//csvData[counter].Add(SummaHourlyTotalsCommon.GetHourlyTotal(hourTotalNode));
#endregion
#region Specs v1.2
csvData[counter].Add(SummaHourlyTotalsCommon.GetHourlySalesXTax(hourTotalNode));
csvData[counter].Add(SummaHourlyTotalsCommon.GetTotalTaxAmount(hourTotalNode));
#endregion
csvData[counter].Add(SummaHourlyTotalsCommon.GetDateTime(hourTotalNode));
csvData[counter].Add(SummaCommon.GetStoreId(doc));
csvData[counter].Add(SummaCommon.GetTillId(doc));
counter++;
csvLineData.Add(new StringBuilder());
/*
* if ((counter == 1) || (counter > hourTotals.Count))
* {
* csvLineData.Add(new StringBuilder());
* }
* else
* {
* csvLineData.Add(new StringBuilder(","));
* }
*/
}
}
catch (Exception e) {
SummaException se = new SummaException("Problem processing hourly sales", e);
se.Data = doc.OuterXml;
throw se;
}
}
public override void SetupData(XmlDocument doc)
{
try
{
// In case GetStoreId fails
Summa.ErrorLevelFile = FileLogger.LogErrorLevelFile.TransactionXMLFile;
Summa.ErrorStrDetail = doc.DocumentElement.Attributes["id"].Name;
// build unique filename
FULLFILEPATH = GenerateCGFileName(doc);
XmlNodeList products = null;
XmlNodeList cards = null;
products = doc.DocumentElement.SelectNodes("/Transaction/Receipt/Product");
cards = doc.DocumentElement.SelectNodes("/Transaction/Receipt/Member/MagCards/MagCard");
int counter = 0;
foreach (XmlNode productNode in products)
{
foreach (XmlNode cardNode in cards)
{
csvData.Add(new List <string>());
csvData[counter].Add(SummaTransactionCommon.GetTransactionID(doc)); // txn id
csvData[counter].Add(SummaTransactionCommon.GetCustomerId(doc)); // customer id
csvData[counter].Add(GetTag(cardNode)); // card tag
csvData[counter].Add(GetMemberNumber(doc)); // member number
csvData[counter].Add(SummaTransactionProductCommon.GetProductId(productNode)); // product id
//csvData[counter].Add(GetProxCard(doc)); // proc card
csvData[counter].Add(GetProductName(productNode)); // product name
csvData[counter].Add(SummaTransactionCommon.GetDateStamp(doc)); // Date Stamp
//csvData[counter].Add(GetProxCard(doc)); // prox card
counter++;
csvLineData.Add(new StringBuilder());
}
}
}
catch (Exception e)
{
SummaException se = new SummaException("Problem processing transaction detail", e);
se.Data = doc.OuterXml;
throw se;
}
}
/// <summary>
/// Deconstruct xml document and populate internal data fields
/// </summary>
/// <param name="doc"></param>
public override void SetupData(XmlDocument doc)
{
try
{
// In case GetStoreId fails
Summa.ErrorLevelFile = FileLogger.LogErrorLevelFile.TransactionXMLFile;
Summa.ErrorStrDetail = doc.DocumentElement.Attributes["id"].Name;
FULLFILEPATH += SummaFileName.GetName(SummaFileName.SummaFileType.Transactions, SummaTransactionCommon.GetStoreId(doc));
csvData.Add(new List <string>());
csvLineData.Add(new StringBuilder());
csvData[0].Add(SummaTransactionCommon.GetTransactionID(doc));
csvData[0].Add(SummaTransactionCommon.GetTransactionType(doc));
csvData[0].Add(SummaTransactionCommon.GetTerminalID(doc));
csvData[0].Add(SummaTransactionCommon.GetCustomerId(doc));
//string id = SummaTransactionCommon.GetCustomerId(doc);
//CheckCustomerID.Check(id);
//csvData[0].Add(id);
#region Old Specs
//csvData[0].Add(SummaTransactionCommon.GetSalesTotal(doc));
#endregion
#region Specs v1.2
csvData[0].Add(GetSalesTotalXTax(doc)); // Sales Total Excluding Tax
csvData[0].Add(GetSalesTotalTaxAmount(doc)); // Sales Total Tax Amount
csvData[0].Add(GetDiscountXTax(doc)); // Discount Excluding Tax
csvData[0].Add(GetDiscountTaxAmount(doc)); // Discount Tax Amount
#endregion
csvData[0].Add(SummaTransactionCommon.GetDateStamp(doc));
csvData[0].Add(SummaTransactionCommon.GetPromotionId(doc));
csvData[0].Add(SummaTransactionCommon.GetOperatorId(doc));
csvData[0].Add(SummaTransactionCommon.GetExtra1(doc));
csvData[0].Add(SummaTransactionCommon.GetExtra2(doc));
csvData[0].Add(SummaTransactionCommon.GetExtra3(doc));
csvData[0].Add(SummaTransactionCommon.GetStoreId(doc));
}
catch (Exception e)
{
SummaException se = new SummaException("Problem processing transaction", e);
se.Data = doc.OuterXml;
throw se;
}
}
public override void SetupData(XmlDocument doc)
{
XmlNodeList departmentTotals = null;
try
{
FULLFILEPATH += SummaFileName.GetName(SummaFileName.SummaFileType.CategoriesTotals, SummaCommon.GetStoreId(doc));
// In case GetStoreId fails
//Summa.ErrorLevelFile = FileLogger.LogErrorLevelFile.UpdateMemberXMLFile;
//Summa.ErrorStrDetail = doc.DocumentElement.Attributes["id"].Name;
departmentTotals = doc.DocumentElement.SelectNodes("/TotalsCategories/Category");
int counter = 0;
foreach (XmlNode departmentTotalNode in departmentTotals)
{
csvData.Add(new List <string>());
csvData[counter].Add(SummaDepartmentTotals.GetDepartmentId(departmentTotalNode));
csvData[counter].Add(SummaDepartmentTotals.GetQtySold(departmentTotalNode));
csvData[counter].Add(SummaDepartmentTotals.GetTotalSales(departmentTotalNode));
csvData[counter].Add(SummaDepartmentTotals.GetTimestamp(departmentTotalNode));
csvData[counter].Add(SummaCommon.GetStoreId(doc));
csvData[counter].Add(SummaCommon.GetTillId(doc));
counter++;
csvLineData.Add(new StringBuilder());
/*
* if ((counter == 1) || (counter > departmentTotals.Count))
* {
* csvLineData.Add(new StringBuilder());
* }
* else
* {
* csvLineData.Add(new StringBuilder(","));
* }
*/
}
}
catch (Exception e) {
SummaException se = new SummaException("Problem processing department totals", e);
se.Data = doc.OuterXml;
throw se;
}
}
public override void SetupData(System.Xml.XmlDocument doc)
{
XmlNodeList inAndOuts = null;
try
{
// In case GetStoreId fails
Summa.ErrorLevelFile = FileLogger.LogErrorLevelFile.ListRosterXMLFile;
Summa.ErrorStrDetail = doc.DocumentElement.Attributes["id"].Name;
inAndOuts = doc.DocumentElement.SelectNodes("/ListRoster/TimeClock");
int counter = 0;
foreach (XmlNode inAndOutNode in inAndOuts)
{
csvData.Add(new List <string>());
csvData[counter].Add(GetEmployeeId(inAndOutNode));
csvData[counter].Add(GetStartHour1(inAndOutNode));
csvData[counter].Add(GetEndHour1(inAndOutNode));
csvData[counter].Add(GetStartHour2(inAndOutNode));
csvData[counter].Add(GetEndHour2(inAndOutNode));
csvData[counter].Add(GetBreak(inAndOutNode));
csvData[counter].Add(GetRosterDate(inAndOutNode));
csvData[counter].Add(GetStoreId(doc));
counter++;
csvLineData.Add(new StringBuilder());
/*
* if ((counter == 1) || (counter > inAndOuts.Count))
* {
* csvLineData.Add(new StringBuilder());
* }
* else
* {
* csvLineData.Add(new StringBuilder(","));
* }
*/
}
}
catch (Exception e) {
SummaException se = new SummaException("Problem processing roster", e);
se.Data = doc.OuterXml;
throw se;
}
}
public override void SetupData(System.Xml.XmlDocument doc)
{
try
{
// In case GetStoreId fails
Summa.ErrorLevelFile = FileLogger.LogErrorLevelFile.TotalsDiscountsXMLFile;
Summa.ErrorStrDetail = doc.DocumentElement.Attributes["id"].Name;
FULLFILEPATH += SummaFileName.GetName(SummaFileName.SummaFileType.FreeListTotals, SummaCommon.GetStoreId(doc));
XmlNodeList freeListTotals = null;
freeListTotals = doc.DocumentElement.SelectNodes("/TotalsDiscounts/Discount");
int counter = 0;
foreach (XmlNode freeListTotalNode in freeListTotals)
{
csvData.Add(new List <string>());
csvData[counter].Add(SummaFreeListTotals.GetId(freeListTotalNode));
csvData[counter].Add(SummaFreeListTotals.GetCount(freeListTotalNode));
csvData[counter].Add(SummaFreeListTotals.GetTotalSales(freeListTotalNode));
csvData[counter].Add(SummaFreeListTotals.GetTimestamp(freeListTotalNode));
csvData[counter].Add(SummaCommon.GetStoreId(doc));
csvData[counter].Add(SummaCommon.GetTillId(doc));
counter++;
csvLineData.Add(new StringBuilder());
/*
* if ((counter == 1) || (counter > freeListTotals.Count))
* {
* csvLineData.Add(new StringBuilder());
* }
* else
* {
* csvLineData.Add(new StringBuilder(","));
* }
*/
}
}
catch (Exception e) {
SummaException se = new SummaException("Problem processing free list totals", e);
se.Data = doc.OuterXml;
throw se;
}
}
public override void SetupData(System.Xml.XmlDocument doc)
{
XmlNodeList departments = null;
try
{
// In case GetStoreId fails
Summa.ErrorLevelFile = FileLogger.LogErrorLevelFile.ListCategoriesXMLFile;
Summa.ErrorStrDetail = doc.DocumentElement.Attributes["id"].Name;
FULLFILEPATH += SummaFileName.GetName(SummaFileName.SummaFileType.SubCategories, SummaCommon.GetStoreId(doc));
departments = doc.DocumentElement.SelectNodes("/ListCategories/Category");
int counter = 0;
foreach (XmlNode categoryNode in departments)
{
csvData.Add(new List <string>());
csvData[counter].Add(SummaDepartmentsCommon.GetDepartmentId(categoryNode));
csvData[counter].Add(SummaDepartmentsCommon.GetDepartmentName(categoryNode));
csvData[counter].Add(SummaDepartmentsCommon.GetDepartmentGroupId(categoryNode));
csvData[counter].Add(SummaDepartmentsCommon.GetStoreId(doc));
counter++;
csvLineData.Add(new StringBuilder());
/*
* if ((counter == 1) || (counter > departments.Count))
* {
* csvLineData.Add(new StringBuilder());
* }
* else
* {
* csvLineData.Add(new StringBuilder(","));
* }
*/
}
}
catch (Exception e) {
SummaException se = new SummaException("Problem processing departments", e);
se.Data = doc.OuterXml;
throw se;
}
}
public override void SetupData(System.Xml.XmlDocument doc)
{
XmlNodeList operators = null;
try
{
// In case GetStoreId fails
Summa.ErrorLevelFile = FileLogger.LogErrorLevelFile.ListStaffXMLFile;
Summa.ErrorStrDetail = doc.DocumentElement.Attributes["id"].Name;
FULLFILEPATH += SummaFileName.GetName(SummaFileName.SummaFileType.Operators, SummaCommon.GetStoreId(doc));
operators = doc.DocumentElement.SelectNodes("/ListStaff/Staff");
int counter = 0;
foreach (XmlNode operatorNode in operators)
{
csvData.Add(new List <string>());
csvData[counter].Add(SummaOperatorsCommon.GetOperatorId(operatorNode));
csvData[counter].Add(SummaOperatorsCommon.GetOperatorName(operatorNode));
csvData[counter].Add(SummaOperatorsCommon.GetStoreId(doc));
counter++;
csvLineData.Add(new StringBuilder());
/*
* if ((counter == 1) || (counter > operators.Count))
* {
* csvLineData.Add(new StringBuilder());
* }
* else
* {
* csvLineData.Add(new StringBuilder(","));
* }
*/
}
}
catch (Exception e) {
SummaException se = new SummaException("Problem processing operators", e);
se.Data = doc.OuterXml;
throw se;
}
}
public override void SetupData(System.Xml.XmlDocument doc)
{
try
{
XmlNodeList payments = null;
// In case GetStoreId fails
Summa.ErrorLevelFile = FileLogger.LogErrorLevelFile.ListPaymentTypesXMLFile;
Summa.ErrorStrDetail = doc.DocumentElement.Attributes["id"].Name;
FULLFILEPATH += SummaFileName.GetName(SummaFileName.SummaFileType.PaymentMethodTypes, SummaCommon.GetStoreId(doc));
payments = doc.DocumentElement.SelectNodes("/ListPaymentTypes/Payment");
int counter = 0;
foreach (XmlNode paymentTypeNode in payments)
{
csvData.Add(new List <string>());
csvData[counter].Add(SummaPaymentTypeCommon.GetPaymentTypeId(paymentTypeNode));
csvData[counter].Add(SummaPaymentTypeCommon.GetPaymentTypeName(paymentTypeNode));
csvData[counter].Add(SummaPaymentTypeCommon.GetStoreId(doc));
counter++;
csvLineData.Add(new StringBuilder());
/*
* if ((counter == 1 ) || (counter > payments.Count))
* {
* csvLineData.Add(new StringBuilder());
* }
* else
* {
* csvLineData.Add(new StringBuilder(","));
* }
*/
}
}
catch (Exception e) {
SummaException se = new SummaException("Problem processing payment method types", e);
se.Data = doc.OuterXml;
throw se;
}
}
public override void SetupData(XmlDocument doc)
{
XmlNodeList methods = null;
try
{
// In case GetStoreId fails
Summa.ErrorLevelFile = FileLogger.LogErrorLevelFile.TransactionXMLFile;
Summa.ErrorStrDetail = doc.DocumentElement.Attributes["id"].Name;
FULLFILEPATH += SummaFileName.GetName(SummaFileName.SummaFileType.TransactionPaymentMethods, SummaTransactionCommon.GetStoreId(doc));
methods = doc.DocumentElement.SelectNodes("/Transaction/Receipt/Payment");
if (methods.Count == 0)
{
Summa.SingletonLoggerStatic.Log(string.Format(string.Format("No payment methods for txn # {0}",
SummaTransactionCommon.GetTransactionID(doc))));
//Summa.LOGGER.Log(LogLevel.Warn, string.Format("No payment methods for txn # {0}",
// SummaTransactionCommon.GetTransactionID(doc)));
}
int counter = 0;
foreach (XmlNode paymentNode in methods)
{
csvData.Add(new List <string>());
csvData[counter].Add(SummaTransactionCommon.GetTransactionPaymentID(paymentNode));
csvData[counter].Add(SummaTransactionCommon.GetTransactionID(doc));
csvData[counter].Add(SummaPaymentMethodsCommon.GetPaymentId(paymentNode));
csvData[counter].Add(SummaPaymentMethodsCommon.GetCardNumber(paymentNode));
csvData[counter].Add(SummaPaymentMethodsCommon.GetSalesValue(paymentNode));
csvData[counter].Add(SummaTransactionCommon.GetStoreId(doc));
counter++;
csvLineData.Add(new StringBuilder());
}
}
catch (Exception e) {
SummaException se = new SummaException("Problem processing transaction payment methods", e);
se.Data = doc.OuterXml;
throw se;
}
}
public override void SetupData(System.Xml.XmlDocument doc)
{
XmlNodeList groupTotals = null;
try
{
FULLFILEPATH += SummaFileName.GetName(SummaFileName.SummaFileType.GroupTotals, SummaCommon.GetStoreId(doc));
groupTotals = doc.DocumentElement.SelectNodes("/TotalsGroups/Group");
int counter = 0;
foreach (XmlNode groupTotalNode in groupTotals)
{
csvData.Add(new List <string>());
csvData[counter].Add(SummaGroupTotals.GetGroupId(groupTotalNode));
csvData[counter].Add(SummaGroupTotals.GetQtySold(groupTotalNode));
csvData[counter].Add(SummaGroupTotals.GetTotalSales(groupTotalNode));
csvData[counter].Add(SummaGroupTotals.GetTimestamp(groupTotalNode));
csvData[counter].Add(SummaCommon.GetStoreId(doc));
csvData[counter].Add(SummaCommon.GetTillId(doc));
counter++;
csvLineData.Add(new StringBuilder());
/*
* if ((counter == 1) || (counter > groupTotals.Count))
* {
* csvLineData.Add(new StringBuilder());
* }
* else
* {
* csvLineData.Add(new StringBuilder(","));
* }
*/
}
}
catch (Exception e) {
SummaException se = new SummaException("Problem processing group totals", e);
se.Data = doc.OuterXml;
throw se;
}
}
public override void SetupData(XmlDocument doc)
{
FULLFILEPATH += SummaFileName.GetName(SummaFileName.SummaFileType.PaymentTotals, SummaCommon.GetStoreId(doc));
XmlNodeList paymentMethodTotals = null;
try {
paymentMethodTotals = doc.DocumentElement.SelectNodes("/TotalsPayments/TotalPayment");
int counter = 0;
foreach (XmlNode paymentTotalNode in paymentMethodTotals)
{
csvData.Add(new List <string>());
csvData[counter].Add(SummaPaymentMethodTotalsCommon.GetPaymentId(paymentTotalNode));
csvData[counter].Add(SummaPaymentMethodTotalsCommon.GetTransactionCount(paymentTotalNode));
csvData[counter].Add(SummaPaymentMethodTotalsCommon.GetTotal(paymentTotalNode));
csvData[counter].Add(SummaPaymentMethodTotalsCommon.GetTimestamp(paymentTotalNode));
csvData[counter].Add(SummaCommon.GetStoreId(doc));
csvData[counter].Add(SummaCommon.GetTillId(doc));
counter++;
csvLineData.Add(new StringBuilder());
/*
* if ((counter == 1) || (counter > paymentMethodTotals.Count))
* {
* csvLineData.Add(new StringBuilder());
* }
* else
* {
* csvLineData.Add(new StringBuilder(","));
* }
*/
}
}
catch (Exception e) {
SummaException se = new SummaException("Problem processing payment method totals", e);
se.Data = doc.OuterXml;
throw se;
}
}
/// <summary>
/// Deconstruct xml document and populate internal data fields
/// </summary>
/// <param name="doc"></param>
public override void SetupData(XmlDocument doc)
{
FULLFILEPATH += SummaFileName.GetName(SummaFileName.SummaFileType.TransactionCheck, SummaTransactionCommon.GetStoreId(doc));
try
{
csvData.Add(new List <string>());
csvLineData.Add(new StringBuilder());
csvData[0].Add(SummaTransactionCommon.GetTransactionID(doc));
csvData[0].Add(SummaTransactionCommon.GetSalesTotalXTax(doc)); // Sales Total Excluding Tax
//XmlNode productNode = doc.DocumentElement.SelectSingleNode("/Transaction/Receipt/Product");
XmlNodeList products = doc.DocumentElement.SelectNodes("/Transaction/Receipt/Product");
decimal summaNetXTax = 0;
decimal quantity = 0;
decimal unitPrice = 0;
foreach (XmlNode productNode in products)
{
summaNetXTax += Convert.ToDecimal(SummaTransactionProductCommon.GetSummaNetXTax(productNode));
quantity += Convert.ToDecimal(SummaTransactionProductCommon.GetQuantity(productNode));
unitPrice += Convert.ToDecimal(SummaTransactionProductCommon.GetUnitPriceXGST(productNode));
}
csvData[0].Add(string.Format("{0:#.00}", Math.Abs(summaNetXTax)));
csvData[0].Add(string.Format("{0:#.00}", Math.Abs(quantity)));
csvData[0].Add(string.Format("{0:#.00}", Math.Abs(unitPrice)));
}
catch (Exception e)
{
SummaException se = new SummaException("Problem processing transaction", e);
se.Data = doc.OuterXml;
throw se;
}
}
/// <summary>
/// Deconstruct xml document and populate internal data fields
/// </summary>
/// <param name="doc"></param>
public override void SetupData(XmlDocument doc)
{
try
{
// In case GetStoreId fails
Summa.ErrorLevelFile = FileLogger.LogErrorLevelFile.VersionXMLFile;
Summa.ErrorStrDetail = doc.DocumentElement.Attributes["id"].Name;
FULLFILEPATH += SummaFileName.GetName(SummaFileName.SummaFileType.Version, SummaCommon.GetStoreId(doc));
csvData.Add(new List <string>());
csvLineData.Add(new StringBuilder());
csvData[0].Add(SummaCommon.GetPOSVersion(doc));
csvData[0].Add(SummaCommon.GetInterfaceVersion(doc));
}
catch (Exception e)
{
SummaException se = new SummaException("Problem processing version", e);
se.Data = doc.OuterXml;
throw se;
}
}
public static bool SaveAndClean(string inFolder, string inZipFileName)
{
string tmp = @"";
try
{
bool result = SaveWithFolder(inFolder, inZipFileName);
//:::::::::::::::::::::::::::::::::::::
if (result)
{
string[] filenames = System.IO.Directory.GetFiles(inFolder);
foreach (string filename in filenames)
{
tmp = filename;
if (!tmp.EndsWith(@".zip"))
{
System.IO.File.Delete(tmp);
}
}
}
return(result);
}
catch (Exception e)
{
SummaException se = new SummaException(string.Format(@"Problem deleting file: {0} ...", tmp), e);
throw se;
//SummaException se = new SummaException("Problem deleting Summa .txt file ...", e);
//throw se;
}
}
public override void SetupData(XmlDocument doc)
{
XmlNodeList customers = null;
try
{
Summa.ErrorLevelFile = FileLogger.LogErrorLevelFile.UpdateMemberXMLFile;
Summa.ErrorStrDetail = doc.DocumentElement.Attributes["id"].Name;
FULLFILEPATH += SummaFileName.GetName(SummaFileName.SummaFileType.Customers, SummaCommon.GetStoreId(doc));
customers = doc.DocumentElement.SelectNodes("/UpdateMember/Member");
int counter = 0;
foreach (XmlNode customerNode in customers)
{
csvData.Add(new List <string>());
csvData[counter].Add(GetCustomerId(customerNode));
//string id = GetCustomerId(customerNode);
//CheckCustomerID.Check(id);
//csvData[counter].Add(id);
csvData[counter].Add(GetCustomerTitle(customerNode));
csvData[counter].Add(GetFirstName(customerNode));
csvData[counter].Add(GetMiddleName(customerNode));
csvData[counter].Add(GetLastName(customerNode));
csvData[counter].Add(GetNickName(customerNode));
csvData[counter].Add(GetGender(customerNode));
csvData[counter].Add(GetCustomerDOB(customerNode));
csvData[counter].Add(GetEnrolmentDate(customerNode));
csvData[counter].Add(GetCustomerCode(customerNode));
csvData[counter].Add(GetExternalCustomerId(customerNode));
csvData[counter].Add(GetActiveStatus(customerNode));
csvData[counter].Add(GetAddress1(customerNode));
csvData[counter].Add(GetAddress2(customerNode));
csvData[counter].Add(GetSuburb(customerNode));
csvData[counter].Add(GetCity(customerNode));
csvData[counter].Add(GetState(customerNode));
csvData[counter].Add(GetCountry(customerNode));
csvData[counter].Add(GetPostalAddress1(customerNode));
csvData[counter].Add(GetPostalAddress2(customerNode));
csvData[counter].Add(GetPostalAddressSuburb(customerNode));
csvData[counter].Add(GetPostalAddressCity(customerNode));
csvData[counter].Add(GetPostalAddressState(customerNode));
csvData[counter].Add(GetPostalAddressCountry(customerNode));
csvData[counter].Add(PostalCode(customerNode));
csvData[counter].Add(GetPhoneMobile(customerNode));
csvData[counter].Add(GetPhoneWork(customerNode));
csvData[counter].Add(GetPhoneHome(customerNode));
csvData[counter].Add(GetFax(customerNode));
csvData[counter].Add(GetEmail(customerNode));
csvData[counter].Add(GetBankAccount1(customerNode));
csvData[counter].Add(GetBankAccount2(customerNode));
csvData[counter].Add(GetBankAccount3(customerNode));
csvData[counter].Add(GetBankAccount4(customerNode));
csvData[counter].Add(GetWebsite(customerNode));
csvData[counter].Add(GetCompany(customerNode));
csvData[counter].Add(GetJobTitle(customerNode));
csvData[counter].Add(GetEthnicityId(customerNode));
csvData[counter].Add(GetMarriedStatus(customerNode));
csvData[counter].Add(GetNumberOfChildren(customerNode));
csvData[counter].Add(GetRankingId(customerNode));
csvData[counter].Add(GetIncomeId(customerNode));
csvData[counter].Add(GetOccupationId(customerNode));
csvData[counter].Add(GetCustomerGroupId(customerNode));
csvData[counter].Add(GetCurrentBalance(customerNode));
csvData[counter].Add(GetRewardBalance(customerNode));
csvData[counter].Add(GetGiftBalance(customerNode));
csvData[counter].Add(GetVoucherBalance(customerNode));
csvData[counter].Add(GetLogin(customerNode));
csvData[counter].Add(GetPassword(customerNode));
csvData[counter].Add(GetLastModified(customerNode));
csvData[counter].Add(GetIPAddress(customerNode));
csvData[counter].Add(GetExtra1(customerNode));
csvData[counter].Add(GetExtra2(customerNode));
csvData[counter].Add(GetExtra3(customerNode));
csvData[counter].Add(GetExtra4(customerNode));
csvData[counter].Add(GetExtra5(customerNode));
csvData[counter].Add(GetExtra6(customerNode));
csvData[counter].Add(GetExtra7(customerNode));
csvData[counter].Add(GetExtra8(customerNode));
csvData[counter].Add(GetExtra9(customerNode));
csvData[counter].Add(GetExtra10(customerNode));
csvData[counter].Add(GetComments(customerNode));
csvData[counter].Add(GetCardId(customerNode));
csvData[counter].Add(GetCardExpiryDate(customerNode));
csvData[counter].Add(GetCardActiveStatus(customerNode));
csvData[counter].Add(GetCardPrintStatus(customerNode));
csvData[counter].Add(GetStoreId(doc.DocumentElement));
//csvData[counter].Add(GetStoreId(customerNode));
counter++;
csvLineData.Add(new StringBuilder());
/*
* if ((counter == 1) || (counter > customers.Count))
* {
* csvLineData.Add(new StringBuilder());
* }
* else
* {
* csvLineData.Add(new StringBuilder(","));
* }
*/
}
}
catch (Exception e)
{
SummaException se = new SummaException("Problem processing customer", e);
se.Data = doc.OuterXml;
throw se;
}
}
public override void SetupData(XmlDocument doc)
{
FULLFILEPATH += SummaFileName.GetName(SummaFileName.SummaFileType.Products, SummaCommon.GetStoreId(doc));
List <string> productIds = new List <string>();
XmlNodeList menus = null;
try
{
// In case GetStoreId fails
Summa.ErrorLevelFile = FileLogger.LogErrorLevelFile.ListProductTypesXMLFile;
Summa.ErrorStrDetail = doc.DocumentElement.Attributes["id"].Name;
menus = doc.DocumentElement.SelectNodes("//Menu");
int lineCounter = 0;
foreach (XmlNode menuNode in menus)
{
XmlNodeList courses = null;
courses = menuNode.SelectNodes("./Courses/Course");
foreach (XmlNode courseNode in courses)
{
XmlNodeList items = null;
items = courseNode.SelectNodes("./Items/Item");
foreach (XmlNode itemNode in items)
{
XmlNodeList sizes = null;
sizes = itemNode.SelectNodes("./Sizes/Size");
foreach (XmlNode sizeNode in sizes)
{
csvData.Add(new List <string>());
string productId = SummaProductsListCommon.GetProductId(menuNode, courseNode, itemNode, sizeNode);
if (productIds.Contains(productId))
{
_singletonLogger.LogError(FileLogger.LogErrorLevel.InternalXMLError, FileLogger.LogErrorLevelFile.ListProductTypesXMLFile,
string.Format("Duplicate Product Id found: {0}, {1} ", productId,
SummaProductsListCommon.GetProductName(menuNode, courseNode, itemNode, sizeNode)), @"");
//Summa.LOGGER.Error("Duplicate Product Id found: {0}, {1] ",
// productId,
// SummaProductsListCommon.GetProductName(menuNode, courseNode, itemNode, sizeNode));
}
else
{
productIds.Add(productId);
csvData[lineCounter].Add(productId);
csvData[lineCounter].Add(SummaProductsListCommon.GetProductName(menuNode, courseNode, itemNode, sizeNode));
csvData[lineCounter].Add(SummaProductsListCommon.GetProductBarcode(itemNode));
csvData[lineCounter].Add(SummaProductsListCommon.GetProductPrice1(sizeNode));
csvData[lineCounter].Add(SummaProductsListCommon.GetProductPrice2(sizeNode));
csvData[lineCounter].Add(SummaProductsListCommon.GetProductGroupId(sizeNode));
csvData[lineCounter].Add(SummaProductsListCommon.GetProductDepartmentId(sizeNode));
csvData[lineCounter].Add(SummaProductsListCommon.GetProductCost(sizeNode));
csvData[lineCounter].Add(SummaProductsListCommon.GetStoreId(doc));
lineCounter++;
csvLineData.Add(new StringBuilder());
}
}
}
}
}
}
catch (Exception e) {
SummaException se = new SummaException("Problem processing products", e);
se.Data = doc.OuterXml;
throw se;
}
}
public override void SetupData(System.Xml.XmlDocument doc)
{
FULLFILEPATH += SummaFileName.GetName(SummaFileName.SummaFileType.DailyTotals, SummaCommon.GetStoreId(doc));
XmlNodeList fixedListTotals = null;
try {
fixedListTotals = doc.DocumentElement.SelectNodes("/TotalsCalculated/Calculated");
int counter = 0;
foreach (XmlNode fixedListTotalNode in fixedListTotals)
{
csvData.Add(new List <string>());
csvData[counter].Add(SummaFixedListTotals.GetId(fixedListTotalNode));
csvData[counter].Add(SummaFixedListTotals.GetCount(fixedListTotalNode));
#region Old Specs
//csvData[counter].Add(SummaFixedListTotals.GetTotalSales(fixedListTotalNode));
#endregion
#region Specs v1.2
int tId = Convert.ToInt16(SummaFixedListTotals.GetId(fixedListTotalNode));
if (tId == 4) // Discount always positive
{
string total = SummaFixedListTotals.GetSalesTotalXTax(fixedListTotalNode);
csvData[counter].Add(Convert.ToString(Math.Abs(Convert.ToDecimal(total))));
}
else
{
csvData[counter].Add(SummaFixedListTotals.GetSalesTotalXTax(fixedListTotalNode));
}
csvData[counter].Add(SummaFixedListTotals.GetSalesTotalTaxAmount(fixedListTotalNode));
#endregion
csvData[counter].Add(SummaFixedListTotals.GetTimestamp(fixedListTotalNode));
csvData[counter].Add(SummaCommon.GetStoreId(doc));
csvData[counter].Add(SummaCommon.GetTillId(doc));
counter++;
csvLineData.Add(new StringBuilder());
/*
* if ((counter == 1) || (counter > fixedListTotals.Count))
* {
* csvLineData.Add(new StringBuilder());
* }
* else
* {
* csvLineData.Add(new StringBuilder(","));
* }
*/
}
}
catch (Exception e) {
SummaException se = new SummaException("Problem processing fixed list totals", e);
se.Data = doc.OuterXml;
throw se;
}
}
public void WriteDataToCSV()
{
// TODO investigate threading issues, this method must be thread safe!
// exceptions will bubble up and be caught by Summa.cs
#region internal sanity check
if (fieldLengths.Length != shouldQuoteField.Length)
{
throw new Exception("Internal error: fieldsLengths and sholdQuoteField arrays should be same length!");
}
if (csvData.Count > 0)
{
if (csvData[0] != null)
{
if (csvData[0].Count != fieldLengths.Length)
{
throw new Exception("Internal error: CSV data item count and fieldLengths data structures should be same length!");
}
}
}
#endregion
try {
BuildCSVLines();
FileMode createMode;
if (AppendToFile)
{
createMode = FileMode.Append;
}
else
{
createMode = FileMode.Create;
}
// only write file if there is data
if (csvLineData.Count > 0)
{
using (FileStream csvFile = File.Open(FULLFILEPATH, createMode, FileAccess.Write, FileShare.None)) {
ASCIIEncoding asciiEncoder = new ASCIIEncoding();
foreach (StringBuilder b in csvLineData)
{
byte[] bytesToWrite = asciiEncoder.GetBytes(b.ToString());
csvFile.Write(bytesToWrite, 0, bytesToWrite.Length);
}
csvFile.Flush();
csvFile.Close();
}
}
else
{
Summa.SingletonLoggerStatic.LogWarning(string.Format("No data to write to file ({0}), skipping.", FULLFILEPATH));
//Summa.LOGGER.Debug(string.Format("No data to write to file ({0}), skipping.", FULLFILEPATH));
}
}
catch (IOException ioe) {
string message = "Unable to write to " + FULLFILEPATH;
SummaException se = new SummaException(message, ioe);
StringBuilder allCsvData = new StringBuilder();
foreach (StringBuilder sb in csvLineData)
{
allCsvData.Append(sb);
}
se.Data = allCsvData.ToString();
throw se;
}
}
public static string GetName(SummaFileType inFileType, string inStoreID)
{
switch (inFileType)
{
#region Lookup Files
case SummaFileType.PaymentMethodTypes: return(GetFileNamePrefix(inStoreID) + "PaymentType" + FileExtention);
case SummaFileType.Products: return(GetFileNamePrefix(inStoreID) + "Products" + FileExtention);
case SummaFileType.Categories: return(GetFileNamePrefix(inStoreID) + "Categories" + FileExtention);
case SummaFileType.SubCategories: return(GetFileNamePrefix(inStoreID) + "Subcategories" + FileExtention);
case SummaFileType.Operators: return(GetFileNamePrefix(inStoreID) + "Operators" + FileExtention);
case SummaFileType.DailyTotalList: return(GetFileNamePrefix(inStoreID) + "DailyTotalList" + FileExtention);
case SummaFileType.FreeList: return(GetFileNamePrefix(inStoreID) + "FreeList" + FileExtention);
#endregion
#region Sales (Transaction) Files
case SummaFileType.Transactions: return(GetFileNamePrefix(inStoreID) + "Transactions" + FileExtention);
case SummaFileType.TransactionDetails: return(GetFileNamePrefix(inStoreID) + "TransactionDetails" + FileExtention);
case SummaFileType.TransactionPaymentMethods: return(GetFileNamePrefix(inStoreID) + "TransactionPaymentMethods" + FileExtention);
case SummaFileType.TransactionCheck: return("TransactionCheck" + FileExtention);
//case SummaFileType.TransactionCheck: return GetFileNamePrefix(inStoreID) + "TransactionCheck" + FileExtention;
#endregion
#region Totals Files
case SummaFileType.DailyTotals: return(GetFileNamePrefix(inStoreID) + "DailyTotals" + FileExtention);
case SummaFileType.FreeListTotals: return(GetFileNamePrefix(inStoreID) + "FreeListTotals" + FileExtention);
case SummaFileType.HourlyTotals: return(GetFileNamePrefix(inStoreID) + "HourlyTotals" + FileExtention);
case SummaFileType.OperatorsTotals: return(GetFileNamePrefix(inStoreID) + "OperatorTotals" + FileExtention);
case SummaFileType.PaymentTotals: return(GetFileNamePrefix(inStoreID) + "PaymentTotals" + FileExtention);
case SummaFileType.ProductTotals: return(GetFileNamePrefix(inStoreID) + "ProductTotals" + FileExtention);
case SummaFileType.CategoriesTotals: return(GetFileNamePrefix(inStoreID) + "CategoriesTotals" + FileExtention);
case SummaFileType.GroupTotals: return(GetFileNamePrefix(inStoreID) + "GroupTotals" + FileExtention);
case SummaFileType.PatronCountsTotals: return(GetFileNamePrefix(inStoreID) + "PatronCountsTotals" + FileExtention);
#endregion
case SummaFileType.Customers: return(GetFileNamePrefix(inStoreID) + "Customers" + FileExtention);
case SummaFileType.CustomerRanking: return(GetFileNamePrefix(inStoreID) + "CustomerRanking" + FileExtention);
case SummaFileType.ListPatronsTypes: return(GetFileNamePrefix(inStoreID) + "ListPatronsTypes" + FileExtention);
case SummaFileType.Version: return(GetFileNamePrefix(inStoreID) + "Version" + FileExtention);
}
#region Not supported Summa File Type
SummaException se = new SummaException("Summa file type not supported");
se.Data = "File type: " + Convert.ToString((int)inFileType);
throw se;
#endregion
}
