/// <summary>
///
/// </summary>
/// <param name="inPaymentsSectionNode"></param>
/// <param name="outOrderHeaderAccount"></param>
void readWebOrderPaymentsComplete(
XmlNode inPaymentsSectionNode,
DTO_WebOrderAccount outOrderHeaderAccount)
{
outOrderHeaderAccount.Payments.PaymentRequired =
stringToBool(getXMLOrderAttribute(inPaymentsSectionNode, @"required", @"yes"));
}
/// <summary>
///
/// </summary>
void saveOrderAccountSection(
string inOrderHandle, // Incomplete Order Handle
UInt32 inCovers, // Covers
string inMemberNumber, // Member Number
string inMemberNamer, // Member Name
List <string> inComments, // Comments
DTO_WebOrderDelivery inDeliverySection, // Delivery Section
DTO_WebOrderPayments inPaymentsSection, // Payments Section,
List <DTO_WebOrderItem> inOrderItems) // Order Items
{
DTO_WebOrderAccount orderAccount = createOrderAccountSection(
inCovers, // Covers
inMemberNumber, // Member Number
inMemberNamer, // Member Name
inComments, // Comments
inDeliverySection, // Delivery Section
inPaymentsSection, // Payments Section,
inOrderItems); // Order Items
DTO_WebOrderResponse response = webmateClient_.SaveIncompleteOrderAccountSection(
inOrderHandle,
orderAccount);
if (!response.Succesful)
{
throw new Exception(string.Format(@"{0}: {1}", response.Message, response.Description));
}
}
/// <summary>
///
/// </summary>
/// <param name="inOrder"></param>
/// <returns></returns>
WebOrderDBInfo createWebOrderDBInfo(WebOrder inOrder)
{
WebOrderDBInfo result = new WebOrderDBInfo();
//....................................................
DTO_WebOrderHeader headerSection = inOrder.GetCompleteHeaderSection();
DTO_WebOrderAccount accountSection = inOrder.GetCompleteAccountSection();
result.GUID = inOrder.Handle;
result.Name = accountSection.Name;
result.StoreName = headerSection.StoreName;
result.OrderDate = headerSection.OrderDate;
result.ExpectedDate = headerSection.ExpectedDate;
result.Status = WebOrderDB.WebOrderStatus.ewosReceived;
result.Recipient = accountSection.Delivery.Recipient;
result.StreetNo = accountSection.Delivery.StreetNo;
result.StreetName = accountSection.Delivery.StreetName;
result.Suburb = accountSection.Delivery.Suburb;
result.City = accountSection.Delivery.City;
result.Country = accountSection.Delivery.Country;
result.Note = accountSection.Delivery.Note;
result.Phone = accountSection.Delivery.Phone;
result.Comments = accountSection.Comments;
result.PaymentRequired = accountSection.Payments.PaymentRequired;
result.OrderTotal = headerSection.OrderTotal;
result.Email = accountSection.Email;
result.OrderType = accountSection.OrderType;
//....................................................
return(result);
}
/// <summary>
///
/// </summary>
/// <returns></returns>
DTO_WebOrderAccount createOrderAccountSection(
UInt32 inCovers, // Covers
string inMemberNumber, // Member Number
string inMemberNamer, // Member Name
List <string> inComments, // Comments
DTO_WebOrderDelivery inDeliverySection, // Delivery Section
DTO_WebOrderPayments inPaymentsSection, // Payments Section,
List <DTO_WebOrderItem> inOrderItems) // Order Items
{
DTO_WebOrderAccount result = new DTO_WebOrderAccount();
//.........................................
result.Covers = inCovers;
result.MemberNumber = inMemberNumber;
result.Name = inMemberNamer;
result.Comments = inComments.ToArray();
result.Delivery = inDeliverySection;
result.Payments = inPaymentsSection;
result.OrderItems = inOrderItems.ToArray();
//.........................................
return(result);
}
public bool CreateWebOrderAccount(
UInt32 inCovers,
string inName,
string inMemberNumber,
DTO_WebOrderPayments inPayments,
DTO_WebOrderComments inComments,
DTO_WebOrderItems inItems,
ref DTO_WebOrderAccount outOrderAccount)
{
errorMsg_ = "";
errorCode_ = ResponseCode.Successful;
inPayments.PropertyChanged += propertyChangedEventHandler;
inComments.PropertyChanged += propertyChangedEventHandler;
inItems.PropertyChanged += propertyChangedEventHandler;
DTO_WebOrderResponse response = wcfClient_.CreateWebOrderAccount(
1, // Covers
"Jorge", // Name
"001-001", // Member Number
inPayments, // Payments
inComments, // Comments
inItems, // Items
ref outOrderAccount);
if (!response.Succesful)
{
errorMsg_ = response.Message;
errorCode_ = response.ResponseCode;
}
return(response.Succesful);
}
/// <summary>
///
/// </summary>
/// <returns></returns>
DTO_WebOrderAccount getEmptyAccountSection()
{
DTO_WebOrderAccount result = new DTO_WebOrderAccount();
//..................................
result.Covers = 0;
result.Name = @"";
result.MemberNumber = @"";
result.Delivery = new DTO_WebOrderDelivery();
result.Delivery.Recipient = @"";
result.Delivery.StreetNo = @"";
result.Delivery.StreetName = @"";
result.Delivery.Suburb = @"";
result.Delivery.City = @"";
result.Delivery.Country = @"";
result.Delivery.Note = @"";
result.Delivery.Phone = @"";
List <string> commentList = new List <string>();
List <DTO_WebOrderItem> itemList = new List <DTO_WebOrderItem>();
result.Comments = commentList.ToArray();
result.Payments = new DTO_WebOrderPayments();
result.OrderItems = itemList.ToArray();
result.Email = @"";
result.OrderType = @"";
//..................................
return(result);
}
public void GetAccount_ValidHandle()
{
using (WCFServiceTestSettings settings = new WCFServiceTestSettings())
{
string handle = "";
settings.Client.OpenWebOrder(out handle);
DTO_WebOrderAccount account = settings.CreateAccountSection();
var response = settings.Client.SaveIncompleteOrderAccountSection(handle, account);
DTO_WebOrderAccount accountPart = new DTO_WebOrderAccount();
settings.Client.RetrieveIncompleteOrderAccountSection(out accountPart, handle);
Assert.AreEqual(account.Comments.Length, accountPart.Comments.Length);
Assert.AreEqual(account.Covers, accountPart.Covers);
Assert.AreEqual(account.Delivery.City, accountPart.Delivery.City);
Assert.AreEqual(account.Delivery.Country, accountPart.Delivery.Country);
Assert.AreEqual(account.Delivery.Note, accountPart.Delivery.Note);
Assert.AreEqual(account.Delivery.Phone, accountPart.Delivery.Phone);
Assert.AreEqual(account.Delivery.Recipient, accountPart.Delivery.Recipient);
Assert.AreEqual(account.Delivery.StreetName, accountPart.Delivery.StreetName);
Assert.AreEqual(account.Delivery.StreetNo, accountPart.Delivery.StreetNo);
Assert.AreEqual(account.Delivery.Suburb, accountPart.Delivery.Suburb);
Assert.AreEqual(account.MemberNumber, accountPart.MemberNumber);
Assert.AreEqual(account.Name, accountPart.Name);
Assert.AreEqual(account.OrderItems.Length, accountPart.OrderItems.Length);
Assert.AreEqual(account.Payments.PaymentRequired, accountPart.Payments.PaymentRequired);
}
}
/// <summary>
///
/// </summary>
/// <param name="inItemsSectionNode"></param>
/// <param name="outOrderHeaderAccount"></param>
void readWebOrderItemsComplete(
XmlNode inItemsSectionNode,
DTO_WebOrderAccount outOrderHeaderAccount)
{
XmlNodeList itemNodeList = XMLDocManager.GetNodeList(inItemsSectionNode, @"Item");
List <DTO_WebOrderItem> itemList = new List <DTO_WebOrderItem>();
foreach (XmlNode itemNode in itemNodeList)
{
DTO_WebOrderItem item = new DTO_WebOrderItem();
item.UID = getXMLOrderAttribute(itemNode, @"uid", @"");
item.BasePrice = Convert.ToDecimal(getXMLOrderAttribute(itemNode, @"basePrice", @"0.00"));
item.Qty = Convert.ToSingle(getXMLOrderAttribute(itemNode, @"quantity", @"0.0"));
item.DiscountID = Convert.ToUInt32(getXMLOrderAttribute(itemNode, @"discountID", @"0"));
item.Note = getXMLOrderAttribute(itemNode, @"note", @"");
item.ItemOptions = readWebOrderItemOptionsComplete(itemNode.FirstChild); // Options node
item.ItemSides = readWebOrderItemSidesComplete(itemNode.FirstChild.NextSibling); // Sides node
itemList.Add(item);
}
outOrderHeaderAccount.OrderItems = itemList.ToArray();
}
/// <summary>
///
/// </summary>
/// <param name="inOrder"></param>
/// <returns></returns>
WebOrderDBItem[] createWebOrderDBItems(WebOrder inOrder, WebOrderDB inWebOrderDB, int inMenuKey) //changes for menu_key
{
List <WebOrderDBItem> result = new List <WebOrderDBItem>();
//....................................................
DTO_WebOrderAccount accountSection = inOrder.GetCompleteAccountSection();
DTO_WebOrderHeader headerSection = inOrder.GetCompleteHeaderSection();
foreach (DTO_WebOrderItem orderItem in accountSection.OrderItems)
{
WebOrderDBItem item = new WebOrderDBItem();
item.ThirdPartyCodeKey = dbGetThirdPartyCodeKey(orderItem.UID, inWebOrderDB, inMenuKey); //changes for menu_key
item.Qty = orderItem.Qty;
item.Price = orderItem.BasePrice;
item.PriceLevel0 = orderItem.BasePrice;
item.PriceLevel1 = orderItem.BasePrice;
item.TabName = accountSection.Name;
item.TimeStamp = headerSection.OrderDate;
item.Note = orderItem.Note;
//--------------------------------------------------------
// Options are ignored in this version of Webmate
//--------------------------------------------------------
/*
* foreach (DTO_WebOrderItemOption orderItemOption in orderItem.ItemOptions)
* {
* WebOrderDBItemOption option = new WebOrderDBItemOption();
* option.OptionKey = Convert.ToInt32(orderItemOption.UID);
* item.ItemOptions.Add(option);
* }
*/
foreach (DTO_WebOrderItemSide orderItemSide in orderItem.ItemSides)
{
WebOrderDBItemSide side = new WebOrderDBItemSide();
side.ThirdPartyCodeKey = dbGetThirdPartyCodeKey(orderItemSide.UID, inWebOrderDB, inMenuKey); //changes for menu_key
side.Qty = orderItemSide.Qty;
side.Price = orderItemSide.BasePrice;
side.PriceLevel0 = orderItemSide.BasePrice;
side.PriceLevel1 = orderItemSide.BasePrice;
side.TimeStamp = headerSection.OrderDate;
side.TransactionNumber = orderItemSide.UID;
side.TabName = accountSection.Name;
side.Note = orderItem.Note;
item.ItemSides.Add(side);
}
result.Add(item);
}
//....................................................
return(result.ToArray());
}
public void GetAccount_InvalidHandle()
{
using (WCFServiceTestSettings settings = new WCFServiceTestSettings())
{
string handle = "e6a9bb54-da25-102b-9a03-2db401e887ec";
DTO_WebOrderAccount account = new DTO_WebOrderAccount();
var response = settings.Client.RetrieveIncompleteOrderAccountSection(out account, handle);
Assert.IsFalse(response.Succesful);
}
}
public void SaveAccount_ValidHandle()
{
using (WCFServiceTestSettings settings = new WCFServiceTestSettings())
{
string handle = "";
settings.Client.OpenWebOrder(out handle);
DTO_WebOrderAccount account = settings.CreateAccountSection();
var response = settings.Client.SaveIncompleteOrderAccountSection(handle, account);
Assert.IsTrue(response.Succesful);
}
}
public int getMenuKeyFormChit(WebOrderDB webOrderDB)
{
int menu_key = 0;
DTO_WebOrderAccount accountSection = WebOrder.GetCompleteAccountSection();
string inorderType = accountSection.OrderType;
if (inorderType != "" || inorderType != null)
{
menu_key = webOrderDB.GetPOSChitDetails(inorderType);
}
return(menu_key);
}
/// <summary>
///
/// </summary>
/// <returns></returns>
Guid initDBWebOrder()
{
_headerSection = getEmptyHeaderSection();
_fromSection = getEmptyFromSection();
_accountSection = getEmptyAccountSection();
//...............................................
web_order_commit = new WebOrderCommit();
xml_doc = new XmlDocument();
//...............................................
return(Guid.NewGuid());
}
/// <summary>
///
/// </summary>
/// <param name="inCommentsSectionNode"></param>
/// <param name="outOrderHeaderAccount"></param>
void readWebOrderCommentsComplete(
XmlNode inCommentsSectionNode,
DTO_WebOrderAccount outOrderHeaderAccount)
{
XmlNodeList commentNodeList = XMLDocManager.GetNodeList(inCommentsSectionNode, @"Comment");
List <string> commentList = new List <string>();
foreach (XmlNode commentNode in commentNodeList)
{
commentList.Add(commentNode.InnerText);
}
outOrderHeaderAccount.Comments = commentList.ToArray();
}
/// <summary>
///
/// </summary>
/// <param name="inOrderHandle"></param>
/// <param name="incompleteAccount"></param>
public void RetrieveIncompleteAccountSection(
string inOrderHandle,
out DTO_WebOrderAccount incompleteAccount)
{
try
{
retrieveIncompleteAccount(inOrderHandle, out incompleteAccount);
}
catch (Exception ex)
{
errorMs_ = ex.Message;
throw;
}
}
public void CommitOrder_EmptyItems()
{
using (WCFServiceTestSettings settings = new WCFServiceTestSettings())
{
string handle = "";
settings.Client.OpenWebOrder(out handle);
settings.Client.SaveIncompleteOrderHeaderSection(handle, settings.CreateHeaderSection());
settings.Client.SaveIncompleteOrderFromSection(handle, settings.CreateFromSection());
DTO_WebOrderAccount account = settings.CreateAccountSection();
account.OrderItems = new DTO_WebOrderItem[] {};
settings.Client.SaveIncompleteOrderAccountSection(handle, account);
var response = settings.Client.CommitOrder(handle);
Assert.IsFalse(response.Succesful);
}
}
/// <summary>
///
/// </summary>
/// <param name="inOrderHandle"></param>
/// <param name="incompleteAccount"></param>
private void retrieveIncompleteAccount(string inOrderHandle, out DTO_WebOrderAccount incompleteAccount)
{
if (string.IsNullOrEmpty(inOrderHandle))
{
throw new Exception("Invalid order handle");
}
DTO_WebOrderResponse response = webmateClient_.RetrieveIncompleteOrderAccountSection(
out incompleteAccount,
inOrderHandle);
if (!response.Succesful)
{
throw new Exception(response.Message);
}
}
public void GetStatus_Failed()
{
using (WCFServiceTestSettings settings = new WCFServiceTestSettings())
{
string handle = "";
settings.Client.OpenWebOrder(out handle);
settings.Client.SaveIncompleteOrderHeaderSection(handle, settings.CreateHeaderSection());
settings.Client.SaveIncompleteOrderFromSection(handle, settings.CreateFromSection());
DTO_WebOrderAccount account = settings.CreateAccountSection();
account.OrderItems[0].UID = "50";
settings.Client.SaveIncompleteOrderAccountSection(handle, account);
settings.Client.CommitOrder(handle);
WebOrderStatus status = WebOrderStatus.Unknown;
var response = settings.Client.GetCommittedWebOrderStatus(out status, settings.siteName, settings.storeName, handle);
Assert.IsTrue(response.Succesful);
Assert.AreEqual(status, WebOrderStatus.NotAccepted);
}
}
/// <summary>
///
/// </summary>
/// <param name="inWebOrderHandle"></param>
/// <param name="intOrderAccount"></param>
/// <returns></returns>
public DTO_WebOrderResponse SaveIncompleteOrderAccountSection(
string inOrderHandle,
DTO_WebOrderAccount intOrderAccountSection)
{
try
{
try
{
JsonSerializer serializer = new JsonSerializer();
serializer.NullValueHandling = NullValueHandling.Ignore;
string fileName = WebOrderURLManager.Instance.CacheOrderURL + @"\" + "WebOrder_" + inOrderHandle + DateTime.Now.ToString("dd-mm-yy HH-MM-ss") + ".txt";
using (StreamWriter sw = new StreamWriter(fileName))
{
using (JsonWriter writer = new JsonTextWriter(sw))
{
serializer.Serialize(writer, intOrderAccountSection);
}
}
}
catch (Exception ex)
{
}
if ((getWebOrder(inOrderHandle).AccountSection = intOrderAccountSection) != null)
{
// WebOrder successfuly open
return(createResponseNoError());
}
else
{
// WebOrder: Failed to create an order
return(createResponseError(@"Failed to set order's account section",
string.Format(@"Invalid order handle [{0}]", inOrderHandle),
ResponseCode.FailedToCreateOrderAccountSection));
}
}
catch (Exception exc)
{
// WebOrder: Failed to create an order
return(createResponseError(@"Failed to set order's account section", exc.Message, ResponseCode.FailedToCreateOrderAccountSection));
}
}
/// <summary>
///
/// </summary>
/// <param name="inDeliverySectionNode"></param>
/// <param name="outOrderHeaderAccount"></param>
void readWebOrderDeliveryComplete(
XmlNode inDeliverySectionNode,
DTO_WebOrderAccount outOrderHeaderAccount)
{
outOrderHeaderAccount.Delivery.Recipient =
getXMLOrderAttribute(inDeliverySectionNode, @"recipient", @"");
outOrderHeaderAccount.Delivery.StreetNo =
getXMLOrderAttribute(inDeliverySectionNode, @"streetNo", @"");
outOrderHeaderAccount.Delivery.StreetName =
getXMLOrderAttribute(inDeliverySectionNode, @"streetName", @"");
outOrderHeaderAccount.Delivery.Suburb =
getXMLOrderAttribute(inDeliverySectionNode, @"suburb", @"");
outOrderHeaderAccount.Delivery.City =
getXMLOrderAttribute(inDeliverySectionNode, @"city", @"");
outOrderHeaderAccount.Delivery.Country =
getXMLOrderAttribute(inDeliverySectionNode, @"country", @"");
outOrderHeaderAccount.Delivery.Note =
getXMLOrderAttribute(inDeliverySectionNode, @"note", @"");
outOrderHeaderAccount.Delivery.Phone =
getXMLOrderAttribute(inDeliverySectionNode, @"phone", @"");
}
/// <summary>
///
/// </summary>
/// <param name="inOrderHandle"></param>
/// <param name="outHeader"></param>
/// <returns></returns>
public DTO_WebOrderResponse RetrieveIncompleteOrderAccountSection(
string inOrderHandle,
out DTO_WebOrderAccount outAccountSection)
{
try
{
outAccountSection = getWebOrder(inOrderHandle).AccountSection;
// WebOrder's header successfuly retrieved
return(createResponseNoError());
}
catch (Exception exc)
{
//outAccountSection = getWebOrder(inOrderHandle).EmptyAccountSection;
outAccountSection = null;
// WebOrder: Failed to retrieve an order's account section
return(createResponseError(@"Failed to retrieve order's account section",
exc.Message,
ResponseCode.FailedToRetrieveOrderAccountSection));
}
}
/// <summary>
///
/// </summary>
/// <param name="intOrderAccount"></param>
/// <returns></returns>
void setAccountSection(DTO_WebOrderAccount intOrderAccount)
{
_accountSection.Covers = intOrderAccount.Covers;
_accountSection.Name = intOrderAccount.Name;
_accountSection.MemberNumber = intOrderAccount.MemberNumber;
_accountSection.Comments = intOrderAccount.Comments;
_accountSection.Payments.PaymentRequired = intOrderAccount.Payments.PaymentRequired;
_accountSection.OrderItems = intOrderAccount.OrderItems;
_accountSection.Delivery.Recipient = intOrderAccount.Delivery.Recipient;
_accountSection.Delivery.StreetNo = intOrderAccount.Delivery.StreetNo;
_accountSection.Delivery.StreetName = intOrderAccount.Delivery.StreetName;
_accountSection.Delivery.Suburb = intOrderAccount.Delivery.Suburb;
_accountSection.Delivery.City = intOrderAccount.Delivery.City;
_accountSection.Delivery.Country = intOrderAccount.Delivery.Country;
_accountSection.Delivery.Note = intOrderAccount.Delivery.Note;
_accountSection.Delivery.Phone = intOrderAccount.Delivery.Phone;
_accountSection.Email = intOrderAccount.Email;
_accountSection.OrderType = intOrderAccount.OrderType;
web_order_commit.SetAccountSection(_handle.ToString(), intOrderAccount);
}
/// <summary>
///
/// </summary>
/// <param name="inHeader"></param>
/// <param name="inFrom"></param>
/// <param name="inAccount"></param>
/// <param name="outWebOrder"></param>
/// <returns></returns>
public bool OpenWebOrder(
DTO_WebOrderHeader inHeader,
DTO_WebOrderFrom inFrom,
DTO_WebOrderAccount inAccount,
ref DTO_WebOrder outWebOrder)
{
errorMsg_ = "";
errorCode_ = ResponseCode.Successful;
inHeader.PropertyChanged += propertyChangedEventHandler;
inFrom.PropertyChanged += propertyChangedEventHandler;
inAccount.PropertyChanged += propertyChangedEventHandler;
DTO_WebOrderResponse response = wcfClient_.OpenWebOrder(inHeader, inFrom, inAccount, ref outWebOrder);
if (!response.Succesful)
{
errorMsg_ = response.Message;
errorCode_ = response.ResponseCode;
}
return(response.Succesful);
}
/// <summary>
///
/// </summary>
/// <param name="inWebOrderHandle"></param>
/// <param name="outOrderAccount"></param>
public void LoadAccountSection(string inWebOrderHandle, DTO_WebOrderAccount outOrderAccount)
{
web_order_xml_manager.LoadIncompleteAccountSection(inWebOrderHandle, outOrderAccount);
}
/// <summary>
///
/// </summary>
/// <param name="inWebOrderHandle"></param>
/// <param name="intOrderAccount"></param>
/// <returns></returns>
public void SetAccountSection(string inWebOrderHandle, DTO_WebOrderAccount intOrderAccount)
{
web_order_xml_manager.SetIncompleteAccountSection(inWebOrderHandle, intOrderAccount);
}
