private static void addOrderToListIfCorrespondsToUserEmail(string userEmail, ComplexOrder order, List <OrderToDisplay> orders)
{
if (order.Client.Email == userEmail)
{
OrderToDisplay orderToDisplay = new OrderToDisplay();
List <Book> books = order.BooksToQuantity.Keys.ToList();
List <int> quantities = order.BooksToQuantity.Values.ToList();
List <BookData> booksData = new List <BookData>();
double totalPrice = 0.0;
for (int i = 0; i < books.Count; i++)
{
Book book = books[i];
int quantity = quantities[i];
BookData bookData = new BookData();
bookData.Id = book.Id;
bookData.Title = book.Title;
bookData.Price = book.Price;
booksData.Add(bookData);
totalPrice += book.Price * quantity;
}
orderToDisplay.books = booksData;
orderToDisplay.quantity = quantities;
orderToDisplay.state = order.State;
orderToDisplay.totalPrice = totalPrice;
orders.Add(orderToDisplay);
}
}
public void AddNewOrder(ComplexOrder complexOrder)
{
string[] newRow = { complexOrder.Id.ToString(), complexOrder.Product.Name,
complexOrder.Quantity.ToString(), complexOrder.Description };
LVAddDelegate lvAdd = notPickedOrdersList.Items.Add;
ListViewItem lvItem = new ListViewItem(newRow);
BeginInvoke(lvAdd, lvItem);
}
private string GenerateOrderReport(ComplexOrder complexOrder, string orderType)
{
string formattedTime = DateTime.Now.ToString(" dd-MM-yyyy hh:mm:ss");
string orderReport = "\n\n\n" + (orderType + " generated at " + formattedTime + "\n\n").PadLeft(15);
Client client = complexOrder.Client;
orderReport += ("Client " + client.Name + "\n\n").PadLeft(25);
orderReport = GenerateTableForOrderReport(complexOrder, orderReport);
return(orderReport);
}
private static string GenerateTableForOrderReport(ComplexOrder complexOrder, string orderReport)
{
orderReport += "Book Title".PadRight(20) + "Unit Price".PadRight(15) +
"Quantity".PadRight(15) + "Price".PadRight(15) + "\n\n";
double totalValue = 0.0;
foreach (KeyValuePair <Book, int> booksToQuantity in complexOrder.BooksToQuantity)
{
string bookTitle = booksToQuantity.Key.Title;
double unitaryPrice = booksToQuantity.Key.Price;
int quantity = booksToQuantity.Value;
double price = unitaryPrice * quantity;
totalValue += price;
orderReport += bookTitle.PadRight(20) + unitaryPrice.ToString().PadRight(15) +
quantity.ToString().PadRight(15) + price.ToString().PadRight(15) + "\n\n";
}
orderReport += "\n" + "Total Value".PadRight(20 + 15 + 15) + totalValue;
return(orderReport);
}
//[Test]
public void TestListOfObjects()
{
if (!this.Serializer.CanDeserialize(typeof(ComplexOrder)))
{
Assert.Ignore("Serialize does not support this data type");
}
using (var db = new BlobDatabase(this.Serializer))
{
db.CreateTable <ComplexOrder>();
var order = new ComplexOrder();
var count = db.Insert(order);
Assert.AreEqual(count, 1);
var orderCopy = db.Find <ComplexOrder>(order.Id);
Assert.AreEqual(order, orderCopy);
for (var n = 0; n < 10;)
{
order.Lines.Add(new ComplexLine()
{
ProductId = 1, Quantity = ++n, Status = OrderLineStatus.Placed, UnitPrice = (n / 10m)
});
db.Update(order);
orderCopy = db.Find <ComplexOrder>(order.Id);
Assert.AreEqual(order, orderCopy);
order.History.Add(new ComplexHistory()
{
Time = DateTime.UtcNow, Comment = string.Format("New history {0}", n)
});
db.Update(order);
orderCopy = db.Find <ComplexOrder>(order.Id);
Assert.AreEqual(order, orderCopy);
}
}
}
public void handleNewOrder(object sender, ComplexOrder complexOrder)
{
GUI.AddNewOrder(complexOrder);
}
public string GenerateInvoiceString(ComplexOrder solvedOrder)
{
return(GenerateOrderReport(solvedOrder, "Invoice"));
}
private string GeneratePendentOrderReport(ComplexOrder pendentOrder)
{
return(GenerateOrderReport(pendentOrder, "Pendent order report"));
}
public void RegisterOrdersListByClientId(string clientId, BasicOrderData basicOrderData)
{
Console.WriteLine("Store RegisterOrdersListByClientId");
int clientIdNumber = Convert.ToInt32(clientId);
Dictionary <Book, int> orderAvailableBooks = new Dictionary <Book, int>();
Dictionary <Book, int> orderPendentBooks = new Dictionary <Book, int>();
for (int i = 0; i < basicOrderData.BooksIds.Count; i++)
{
int bookId = basicOrderData.BooksIds[i];
int wantedQuantity = basicOrderData.BooksQuantity[i];
int availableQuantity = _booksAvailability[bookId];
if (availableQuantity >= wantedQuantity)
{
CreateOrIncrementEntryInDictionary(orderAvailableBooks, _booksCollectionMap[bookId], wantedQuantity);
if (availableQuantity == wantedQuantity)
{
GenerateStockFault(_booksCollectionMap[bookId], replenishmentDefaultValue);
}
}
else
{
int satisfiedQuantity = availableQuantity;
if (availableQuantity > 0)
{
CreateOrIncrementEntryInDictionary(orderAvailableBooks, _booksCollectionMap[bookId], satisfiedQuantity);
}
CreateOrIncrementEntryInDictionary(orderPendentBooks, _booksCollectionMap[bookId], wantedQuantity - satisfiedQuantity);
}
//removes all quantity wanted from availability to leave counters with current availability value
//a negative value indicates the quantity of that book that is already being waited for other people
_booksAvailability[bookId] -= wantedQuantity;
}
string orderString = "";
if (orderAvailableBooks.Count != 0)
{
ComplexOrder solvedOrder = new ComplexOrder(orderAvailableBooks,
_clientsMap[clientIdNumber], Order.DispatchedAtDate(), true);
_ordersSolved.Add(solvedOrder);
orderString += GenerateInvoiceString(solvedOrder);
string solvedOrderReport = solvedOrder.State;
solvedOrderReport += "\n\n";
solvedOrderReport = GenerateTableForOrderReport(solvedOrder, solvedOrderReport);
string clientEmail = solvedOrder.Client.Email;
string clientName = solvedOrder.Client.Name;
EmailSender.SendEmail(solvedOrderReport, "New Order", clientEmail, clientName);
}
if (orderPendentBooks.Count != 0)
{
ComplexOrder pendentOrder = new ComplexOrder(orderPendentBooks,
_clientsMap[clientIdNumber], Order.WaitingExpedition, false);
_pendentOrders.Add(pendentOrder);
orderString += GeneratePendentOrderReport(pendentOrder);
foreach (KeyValuePair <Book, int> bookToQuantity in pendentOrder.BooksToQuantity)
{
GenerateStockFault(bookToQuantity.Key, bookToQuantity.Value + replenishmentDefaultValue);
}
string pendentOrderReport = pendentOrder.State;
pendentOrderReport += "\n\n";
pendentOrderReport = GenerateTableForOrderReport(pendentOrder, pendentOrderReport);
string clientEmail = pendentOrder.Client.Email;
string clientName = pendentOrder.Client.Name;
EmailSender.SendEmail(pendentOrderReport, "Pending Order", clientEmail, clientName);
}
printerRestServiceProxy.PrintReceipt(orderString);
}
