private void loadOrders()
{
OrderBL orderBL = new OrderBL();
dgvOrders.DataSource = orderBL.GetOrders(cmbStatus.SelectedIndex > 0 ? int.Parse(cmbStatus.SelectedValue) : -1, DateTime.Parse(txtDateFrom.Text), DateTime.Parse(txtDateTo.Text), null);
dgvOrders.DataBind();
}
private void Page_Loaded(object sender, RoutedEventArgs e)
{
CboListBox.ItemsSource = GetServTables.GetInstance().Tables;
CboListBox.SelectedIndex = 0;
DtGridOrden.ItemsSource = OrderBL.GetInstance().GetDetailOrder(1);
}
public async Task TotalAmountCannotBeNegative()
{
//Arrange
OrderBL orderBL = new OrderBL();
Order order = new Order()
{
CustomerID = Guid.NewGuid(), OrderAmount = -10, TotalQuantity = 10
};
bool isAdded = false;
Guid newGuid;
string errorMessage = null;
//Act
try
{
(isAdded, newGuid) = await orderBL.AddOrderBL(order);
}
catch (Exception ex)
{
isAdded = false;
errorMessage = ex.Message;
}
finally
{
//Assert
Assert.IsFalse(isAdded, errorMessage);
}
}
public ManagerMenu(LocationBL locationbl, CustomerBL customerBL, OrderBL orderBL)
{
_locationBL = locationbl;
_customerBL = customerBL;
_orderBL = orderBL;
_inputValidation = new InputValidation();
}
//called by customer
public ActionResult OrderedItemsIndex(Guid CustomerID)
{
//creating and initializing viewmodel object
OrderViewModel orderViewModelList = new OrderViewModel();
OrderBL orderBL = new OrderBL();
//Order order = new Order();
List <Product> orderedItems = new List <Product>();
orderedItems = orderBL.ViewOrderedItemsBL(Guid.Parse(HttpContext.Session.GetString("customerID")));
List <ProductViewModel> productViewModelList = new List <ProductViewModel>();
foreach (var product in orderedItems)
{
ProductViewModel productView = new ProductViewModel()
{
ProductID = product.ProductID,
ProductName = product.ProductName,
ProductNumber = product.ProductNumber,
ProductDescription = product.ProductDescription,
PriceOfProduct = product.PriceOfProduct,
Stock = product.Stock
};
productViewModelList.Add(productView);
}
if (productViewModelList.Count == 0)
{
return(Content("No items"));
}
//calling view and passing viewmodel object to view
return(View(productViewModelList));
}
public void CancelOrderTest()
{
OrderBook book = new OrderBook("ERX", OrderAction.OrderBuy);
Exception e = Assert.Throws <ArgumentException>(() =>
book.CancelOrder("someId"));
Assert.Equal("Error Order Not Exists : OrderId: someId", e.Message);
IDictionary <String, OrderBL> orderIds = book.TestOrderIds;
List <OrderBL> orders = book.TestOrders;
for (int i = 0; i < 10; i++)
{
book.AddOrder(TestUtils.NewBuyLimitDayOrder(100M + i));
}
OrderBL order = TestUtils.NewBuyLimitDayOrder(101.101M);
book.AddOrder(order);
Assert.Equal(11, book.Count);
Assert.True(orderIds.ContainsKey(order.OrderId));
book.CancelOrder(order.OrderId);
Assert.Equal(OrderStatus.OrderCancelled, order.Status);
Assert.NotEqual(0, order.CanceledTimestamp);
Assert.Equal(10, book.Count);
Assert.False(orderIds.ContainsKey(order.OrderId));
Assert.Null(orders.Find(Orders.Predicates.ById(order.OrderId)));
}
// delete order
public void DeleteOrder(OrderBL entity)
{
if (entity == null)
{
throw new OrderNotFound();
}
else
{
try
{
using (var unitOfWork = unitOfWorkManager.Begin())
{
productService.UpdateQuantity(entity.OrderItems);
var objOrder = mapper.Map <OrderDL>(entity);
orderRepository.Delete(objOrder);
productService.UpdateQuantity(entity.OrderItems);
unitOfWork.Complete();
}
}
catch (Exception ex)
{
throw ex;
}
}
}
// GET: Orders
//URL: Order/OrderIndex
//function called by admin
public ActionResult OrderIndex()
{
//creating and initializing viewmodel object
List <OrderViewModel> orderViewModelList = new List <OrderViewModel>();
OrderBL orderBL = new OrderBL();
List <Order> ordersList = orderBL.ViewAllOrdersBL();
foreach (var order in ordersList)
{
OrderViewModel orderView = new OrderViewModel()
{
OrderID = order.OrderID,
CustomerID = order.CustomerID,
OrderNumber = order.OrderNumber,
OrderedItems = order.OrderedItems,
/*TotalCost = order.TotalCost,*/
OrderDateCreated = order.OrderDateCreated,
OrderStatus = order.OrderStatus
};
orderViewModelList.Add(orderView);
}
if (orderViewModelList.Count == 0)
{
return(RedirectToAction("OrderIndex", "Order"));
}
//calling view and passing viewmodel object to view
return(View(orderViewModelList));
}
public void TestAddOrder1()
{
OrderBL obl = new OrderBL();
Orders or = new Orders();
Assert.Null(obl.AddOrder(or));
}
// update order
//public void UpdateOrder(OrderBL entity)
//{
// if (entity == null)
// {
// throw new OrderNotFound();
// }
// else if (entity.OrderItems == null)
// {
// throw new OrderItemNotFound();
// }
// else
// {
// try
// {
// using (var unitOfWork = unitOfWorkManager.Begin())
// {
// var objOrder = mapper.Map<OrderDL>(entity);
// orderRepository.Update(objOrder);
// var OrderListItems = new List<OrderItemBL>();
// foreach (var item in entity.OrderItems)
// {
// var product = productRepository.GetAll().AsNoTracking()
// .FirstOrDefault(p => p.Id == item.ProductId);
// item.ProductName = product.Name;
// item.UnitPrice = product.UnitPrice;
// item.Quantity = item.Quantity;
// item.LineTotal = item.UnitPrice * item.Quantity;
// OrderListItems.Add(item);
// productService.UpdateQuantity(OrderListItems);
// unitOfWork.Complete();
// }
// }
// }
// catch (Exception ex)
// {
// throw new Exception(ex.Message);
// }
// }
//}
public void UpdateOrder(OrderBL entity)
{
var existingOrder = orderRepository.GetAll().AsNoTracking()
.Include(o => o.OrderItems)
.FirstOrDefault(i => i.Id == entity.Id);
// validate order
if (entity == null)
{
throw new OrderNotFound();
}
using (var unitOfWork = unitOfWorkManager.Begin())
{
try
{
var objOrder = mapper.Map <OrderDL>(entity);
orderRepository.Update(objOrder);
//var orderItems = mapper.Map<OrderItemDL>(entity.OrderItems);
productService.UpdateQuantity(entity.OrderItems);
unitOfWork.Complete();
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
}
public void DeleteEntireOrder(OrderBL orders)
{
var order = mapper.Map <OrderDL>(orders);
unitOfWork.OrderRepository.Delete(order);
unitOfWork.Save();
}
public void CreateOrder(OrderBL order)
{
foreach (var item in order.OrderLineItems)
{
var prodqty = unitOfWork.ProductRepository.GetByID(item.ProductId);
if (item.OrderitemQuantity >= 100)
{
throw new InvalidOperationException("Oh Sorry! Your Order cannot be added because the quantity is over the limit!");
}
if (item.OrderitemQuantity == 0 || item.OrderitemQuantity.ToString() == null)
{
throw new InvalidOperationException("Oh Sorry! Your order cannot be created because the quantity is not included!");
}
if (prodqty.Quantity <= 0)
{
throw new InvalidOperationException("Quantity is over!");
}
else
{
var ord = mapper.Map <OrderDL>(order);
unitOfWork.OrderRepository.Create(ord);
unitOfWork.Save();
productService.Update(item.ProductId, -(item.OrderitemQuantity));
}
}
}
public void ShowOrder()
{
Console.Clear();
OrderBL orderBL = new OrderBL();
List <Order> listOrder = new List <Order>();
listOrder = orderBL.ShowAllItemOrdered(customer.UserID);
if (listOrder == null)
{
Console.ReadKey();
}
else
{
if (listOrder.Count <= 0)
{
Console.WriteLine("You have not purchased anything");
}
else
{
var table = new ConsoleTable("SHOES CODE", "SHOES NAME", "DATE");
foreach (var item in listOrder)
{
table.AddRow(item.OrderItem.ShoesId, item.OrderItem.ShoesName, item.OrderDate?.ToString("yyyy-MM-dd"));
}
table.Write();
}
Console.WriteLine("Press any key to continue");
Console.ReadKey();
}
}
public void MenuCustomer(Customer cus)
{
customer = cus;
while (true)
{
OrderBL orderBL = new OrderBL();
string[] choice = { "Account Information", "List Shoes",
"View Cart", "Exit" };
short choose = Utility.MenuTemplate("Menu", choice);
switch (choose)
{
case 1:
ShowInfoCustomer(cus);
continue;
case 2:
ShowlistItems();
continue;
case 3:
ShopingCart();
continue;
// case 4:
// ShowOrder();
// continue;
}
break;
}
}
private Order createOrder(int userID)
{
Order order = new Order();
order.Date = DateTime.Now.ToUniversalTime();
order.Firstname = txtFirstname.Text;
order.Lastname = txtLastname.Text;
order.Address = txtAddress.Text;
order.City = txtCity.Text;
order.Phone = txtPhone.Text;
order.Email = txtEmail.Text;
order.Items = getItems();
order.User = new User(userID, string.Empty, string.Empty, string.Empty, string.Empty, string.Empty, string.Empty, string.Empty, null, string.Empty, string.Empty, DateTime.Now, string.Empty, 0, 1);
order.Name = (rdbUserType.SelectedValue == "2") ? txtCompanyName.Text : string.Empty;
order.Pib = (rdbUserType.SelectedValue == "2") ? txtPib.Text : string.Empty;
//order.Payment = (order.Name != string.Empty) ? new Payment(int.Parse(rdbPaymentCompany.SelectedValue), rdbPaymentCompany.SelectedItem.Text) : new Payment(int.Parse(rdbPayment.SelectedValue.ToString()), rdbPayment.SelectedItem.Text);
order.Payment = new Payment(int.Parse(rdbPayment.SelectedValue), rdbPayment.SelectedItem.Text);
order.Delivery = new Delivery(int.Parse(rdbDelivery.SelectedValue.ToString()), rdbDelivery.SelectedItem.Text);
CartBL cartBL = new CartBL();
order.Coupon = new Coupon(cartBL.GetCartCoupon(Session["cartID"].ToString()), string.Empty, 0, string.Empty, DateTime.Now, DateTime.Now, null, null);
order.OrderStatus = new OrderStatus(1, string.Empty);
order.Zip = txtZip.Text;
order.Comment = txtRemark.Text;
order.CartID = Session["cartID"].ToString();
OrderBL orderBL = new OrderBL();
orderBL.SaveOrder(order);
return(order);
}
public CustomerMenu(CustomerBL customerBL, OrderBL newOrder, LocationBL locationBL)
{
_customerBL = customerBL;
_orderBL = newOrder;
_locationBL = locationBL;
_inputValidation = new InputValidation();
}
public IActionResult CancelOrder(int id)
{
var orderBL = new OrderBL(_uow, _mapper);
orderBL.CancelOrder(id);
return(RedirectToAction("AccountPage", "Account"));
}
public ActionResult Add(OrderViewModel orderViewModel)
{
// Create object of OrderBL
OrderBL orderBL = new OrderBL();
//Creating object of Order EntityModel
Order order = new Order();
order.CustomerID = orderViewModel.CustomerID;
order.OrderNumber = orderViewModel.OrderNumber;
order.OrderedItems = orderViewModel.OrderedItems;
order.OrderDateCreated = orderViewModel.OrderDateCreated;
/*order.TotalCost = orderViewModel.TotalCost;*/
order.OrderStatus = orderViewModel.OrderStatus;
//Invoke the AddProduct method BL
bool isAdded = orderBL.CreateOrderBL(order);
if (isAdded)
{
//Go to Index action method of Product Controller
return(RedirectToAction("CustomerIndex", "CustomerHome"));
}
else
{
//Return plain html / plain string
return(Content("Order was not placed"));
}
}
public void ChangeOrder(OrderBL items)
{
var tempOrder = repository.GetAllIncluding().Include(i => i.OrderLineItems).First(o => o.Id == items.Id);
foreach (var item in items.OrderLineItems)
{
if (!item.IsDelete)
{
var getQty = new OrderBL(items.OrderLineItems);
var tempOrdLine = tempOrder.OrderLineItems.FirstOrDefault(f => f.Id == item.Id);
var tempDiff = tempOrdLine.OrderitemQuantity - item.OrderitemQuantity;
tempOrdLine.ProductId = item.ProductId;
tempOrdLine.OrderitemQuantity = item.OrderitemQuantity;
tempOrdLine.OrderitemDate = item.OrderitemDate;
tempOrdLine.OrderitemProductPrice = item.OrderitemProductPrice;
productService.UpdateProductQuantity(item.ProductId, tempDiff);
}
else
{
var ordItem = tempOrder.OrderLineItems.FirstOrDefault(o => o.Id == item.Id);
var deleteDiff = ordItem.OrderitemQuantity + 0;
productService.UpdateProductQuantity(item.ProductId, deleteDiff);
tempOrder.OrderLineItems.Remove(ordItem);
}
}
repository.Update(tempOrder);
unitOfWork.SaveChanges();
}
public void TestPerfAddOrder(List <IOrderModel> buyOrders, List <IOrderModel> sellOrders,
IDemoExchangeDbContextFactory <OrderContext> orderContextFactory)
{
int i = 0;
using OrderContext buy = orderContextFactory.Create();
foreach (IOrderModel request in buyOrders)
{
OrderBL order = new OrderBL(request.AccountId, request.Action, request.Ticker, request.Type, request.Quantity, request.OrderPrice, request.TimeInForce);
buy.Orders.Add((OrderEntity)order);
BuyBook.TestPerfAddOrderNoSort(order);
if ((i % 1000) == 0)
{
buy.SaveChanges();
}
}
buy.SaveChanges();
BuyBook.TestPerfSort();
i = 0;
using OrderContext sell = orderContextFactory.Create();
foreach (IOrderModel request in sellOrders)
{
OrderBL order = new OrderBL(request.AccountId, request.Action, request.Ticker, request.Type, request.Quantity, request.OrderPrice, request.TimeInForce);
sell.Orders.Add((OrderEntity)order);
SellBook.TestPerfAddOrderNoSort(order);
if ((i % 1000) == 0)
{
sell.SaveChanges();
}
}
sell.SaveChanges();
SellBook.TestPerfSort();
}
public InventoryMenu(LocationBL locBL, ProductBL prodBL, OrderBL orderBL, CustomerBL customerBL)
{
_locBL = locBL;
_prodBL = prodBL;
_orderBL = orderBL;
_customerBL = customerBL;
}
public void GetOrderInfoByOrderIDTest()
{
OrderBL orderBL = new OrderBL();
Order test = orderBL.GetOrderInfoByOrderID(3);
Assert.NotNull(test);
}
public void ShowOrder()
{
// Console.Clear();
OrderBL orderBL = new OrderBL();
List <Order> listOrder = new List <Order>();
listOrder = orderBL.ShowAllItemOrder(user.UserID);
if (listOrder == null)
{
Console.ReadKey();
}
else
{
if (listOrder.Count <= 0)
{
Console.WriteLine("Bạn chưa mua gì");
}
else
{
var table = new ConsoleTable("Mã đơn hàng", "Tên đồ uống", "Ngày mua");
foreach (var item in listOrder)
{
table.AddRow(item.OrderItem.ItemID, item.OrderItem.ItemName, item.OrderDate?.ToString("yyyy-MM-dd")); // table.AddRow("TỔNG TIỀN", "","", FormatCurrency(total));
}
table.Write();
}
Console.WriteLine("Nhấn phím bất kì để tiếp tục");
Console.ReadKey();
}
}
private void Page_Loaded(object sender, RoutedEventArgs e)
{
LoadMenuFood();
CboListBox.ItemsSource = GetServTables.GetInstance().Tables;
CboListBox.SelectedIndex = 0;
storyboard = this.TryFindResource("AlertOrdDone") as Storyboard;
storyboard2 = this.TryFindResource("AlertOrdrDoneOut") as Storyboard;
textBlock.Visibility = Visibility.Hidden;
if (OrderBL.GetInstance().NofPOrder() > 0)
{
NtfIcon.Visibility = Visibility.Visible;
NtfIcon.Badge = OrderBL.GetInstance().NofPOrder();
}
else
{
NtfIcon.Visibility = Visibility.Hidden;
}
ordrDone = false;
timer.Interval = TimeSpan.FromMilliseconds(100);
timer.Tick += Timer_Tick;
timer.Start();
timer2.Interval = TimeSpan.FromSeconds(1);
timer2.Tick += Timer2_Tick;
}
private void FillToGridViews()
{
//how i can write email here as session from login
string status = OrderBL.GetStatus(Session["emailUnblockedSession"].ToString());
DataTable dt = OrderBL.GetOrders(Session["emailUnblockedSession"].ToString());
if (status == "pending")
{
pendingID.DataSource = dt;
pendingID.DataBind();
}
else if (status == "accepted")
{
AcceptedID.DataSource = dt;
AcceptedID.DataBind();
}
else if (status == "cancelled")
{
CancelledID.DataSource = dt;
CancelledID.DataBind();
}
else if (status == "rejected")
{
RejectedID.DataSource = dt;
RejectedID.DataBind();
}
else if (status == "delivered")
{
DeliveredID.DataSource = dt;
DeliveredID.DataBind();
}
}
public static void ListApprovedorders()
{
Console.Clear();
OrderBL obl = new OrderBL();
var list = obl.GetAllOrderbyStatus(0);
if (list.Count != 0)
{
string line = "============================================================================================";
Console.WriteLine(line);
Console.WriteLine(" Order_id | User_ID | Date | Order Status |");
Console.WriteLine(line);
foreach (var orders in list)
{
if (orders.Order_status == 0)
{
Console.WriteLine("{0,-20} {1,-20} {2,-33} {3}", orders.Order_id, orders.user.User_id, orders.Date_Order, orders.Order_status);
}
}
Console.WriteLine(line);
Console.Write("\n Press Enter key to back menu... !");
Console.ReadLine();
}
else if (list.Count == 0)
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("Empty list, no invoices processed...!");
Console.ForegroundColor = ConsoleColor.Gray;
Console.ReadLine();
}
}
public ManagerMenu(LocationBL locationBL, OrderBL orderBL, InventoryBL inventoryBL, CustomerBL customerBL)
{
this.locationBL = locationBL;
this.orderBL = orderBL;
this.inventoryBL = inventoryBL;
this.customerBL = customerBL;
}
public void Begin(string pathFile)
{
using (var reader = new StreamReader(pathFile))
{
IService <ProductBL> productService = new ProductService(new ProductRepository(new SalesContext()), _mapper);
IService <OrderBL> orderService = new OrderService(new OrderRepository(new SalesContext()), _mapper);
IService <ManagerBL> managerService = new ManagerService(new ManagerRepository(new SalesContext()), _mapper);
IService <ReportBL> reportService = new ReportService(new ReportRepository(new SalesContext()), _mapper);
IService <CustomerBL> customerService = new CustomerService(new CustomerRepository(new SalesContext()), _mapper);
using (var csvReader = new CsvFileReader(pathFile))
{
csvReader.Dilimiter = ';';
string record = string.Empty;
while ((record = reader.ReadLine()) != null)
{
csvReader.CreateObject(record);
ProductBL product = csvReader.GetProduct();
CustomerBL customer = csvReader.GetCustomer();
ManagerBL manager = csvReader.GetManager();
DoWorkWithEntity(ref product, productService, _lock);
DoWorkWithEntity(ref manager, managerService, _lock);
DoWorkWithEntity(ref customer, customerService, _lock);
ReportBL report = csvReader.GetReport(manager.Id);
report.Manager = manager;
DoWorkWithEntity(ref report, reportService, _lock);
OrderBL order = csvReader.GetOrder(customer.Id, product.Id, report.Id);
DoWorkWithEntity(ref order, orderService, _lock);
}
}
}
}
public void ShowAnItem(int?itemId, int amount)
{
while (true)
{
Console.Clear();
Console.Clear();
var shoeList = new List <Shoes>();
Shoes shoes = new Shoes();
shoes = shoesBL.GetShoesById(itemId);
var table = new ConsoleTable("Name:", Convert.ToString(shoes.ShoesName));
table.AddRow("Size:", SubStringSize(shoes.ShoesSize));
table.AddRow("Price:", FormatCurrency(shoes.ShoesPrice));
table.AddRow("Color:", shoes.ShoesColor);
table.AddRow("Material:", shoes.ShoesMaterial);
table.AddRow("Brand:", shoes.ShoesBrand);
table.Write();
Console.WriteLine();
OrderBL orderBL = new OrderBL();
string[] choice = { "Add To Cart", "Back" };
short choose = Utility.MenuDetail("Menu", choice);
switch (choose)
{
case 1:
AddToCart(shoes, amount);
break;
}
break;
}
}
protected void cmbStatus_SelectedIndexChanged(object sender, EventArgs e)
{
if (cmbStatus.SelectedIndex > -1)
{
OrderBL orderBL = new OrderBL();
orderBL.UpdateOrderStatus(int.Parse(lblOrderID.Value), int.Parse(cmbStatus.SelectedValue), lblEmail.Text, lblCode.Text, lblFirstname.Text + " " + lblLastname.Text, cmbStatus.SelectedItem.Text, lblDate.Text);
}
}
