public CustomerOrderHistoryList()
{
try
{
CustomerOrderViewModel customerOrderViewModel = new CustomerOrderViewModel();
InitializeComponent();
CenterWindowOnScreen();
dpFromDate.SelectedDate = System.DateTime.Now;
dpToDate.SelectedDate = System.DateTime.Now;
customerOrderHistoryModel = customerOrderViewModel.GetCustomerOrderHistoryList(dpFromDate.SelectedDate.Value.ToString(CommonMethods.DateFormat), dpToDate.SelectedDate.Value.ToString(CommonMethods.DateFormat));
if (customerOrderHistoryModel.Count > 0)
{
lblInvoiceCount.Content = customerOrderHistoryModel[0].InvoiceCount;
lblInvoiceTotal.Content = customerOrderHistoryModel[0].InvoiceTotal;
}
else
{
lblInvoiceCount.Content = "0";
lblInvoiceTotal.Content = "0.00";
}
this.dgOrderList.ItemsSource = customerOrderHistoryModel;
}
catch (Exception ex)
{
SystemError.Register(ex);
}
}
private void btnSearchOrderList_Click(object sender, RoutedEventArgs e)
{
try
{
List <CustomerOrderHistoryModel> customerOrderHistoryModel = new List <CustomerOrderHistoryModel>();
CustomerOrderViewModel customerOrderViewModel = new CustomerOrderViewModel();
customerOrderHistoryModel = customerOrderViewModel.GetCustomerOrderHistoryList(dpFromDate.SelectedDate.Value.ToString(CommonMethods.DateFormat), dpToDate.SelectedDate.Value.ToString(CommonMethods.DateFormat));
this.dgOrderList.ItemsSource = customerOrderHistoryModel;
if (customerOrderHistoryModel.Count > 0)
{
lblInvoiceCount.Content = customerOrderHistoryModel[0].InvoiceCount;
lblInvoiceTotal.Content = customerOrderHistoryModel[0].InvoiceTotal;
}
else
{
lblInvoiceCount.Content = "0";
lblInvoiceTotal.Content = "0.00";
}
}
catch (Exception ex)
{
SystemError.Register(ex);
}
}
public CustomerOrderViewModel GetSingleOrder(int OrderID)
{
string Query = @"select * from [dbo].[Order] where id = @orderid";
var param = new { orderid = OrderID };
var Data = _Order.Get <Order>(Query, param).FirstOrDefault();
CustomerOrderViewModel Model = new CustomerOrderViewModel();
Model.ShipmentMethod = Data.ShippingMethod;
Model.ShipmentStatus = Enum.GetName(typeof(ShipmentStatusEnum), Data.ShippingStatusId);
Model.OrderPrice = (double)Data.OrderTotal;
Model.OrderID = OrderID;
Model.OrderStatus = Enum.GetName(typeof(OrderStatusEnum), Data.OrderStatusId);
Model.OrderDate = Data.CreatedOnUtc;
Model.OrderPrice = (double)Data.OrderTotal;
Model.BillingAddress = AddressMapping.ModelToViewModel(_addressService.GetAddressById(Data.BillingAddressId).Result);
Model.ShippingAddress = AddressMapping.ModelToViewModel(_addressService.GetAddressById(Data.ShippingAddressId).Result);
Model.PaymentStatus = Enum.GetName(typeof(PaymentStatusEnum), Data.PaymentStatusId);
Model.PaymentMethod = Data.PaymentMethodSystemName;
Model.ShipmentMethod = Data.ShippingMethod;
Model.ShipmentStatus = Enum.GetName(typeof(ShipmentStatusEnum), Data.ShippingStatusId);
string Query1 = @"select p.Name as ProductName,pic.PictureBinary,oi.UnitPriceInclTax as Price,oi.Quantity from [dbo].[Order] as o join
OrderItem as oi on o.Id = oi.OrderId join Product as p on oi.ProductId = p.Id join Product_Picture_Mapping as pm on p.Id = pm.ProductId
join Picture as pic on pic.Id = pm.PictureId where o.Id = @orderid";
Model.ProductsList = _Order.Get <CustomerShoppingCartViewModel>(Query1, param).ToList();
return(Model);
}
//客戶訂單
public ActionResult 客戶看訂單()
{
if (Session[CSession關鍵字.SK_LOGINED_CUSTOMER] != null)
{
tCustomer cust = Session[CSession關鍵字.SK_LOGINED_CUSTOMER] as tCustomer;
MotaiDataEntities db = new MotaiDataEntities();
List <tOrder> orders = db.tOrders.Where(o => o.oCustomerId.Equals(cust.CustomerId)).ToList();
List <CustomerOrderViewModel> OrderList = new List <CustomerOrderViewModel>();
foreach (var items in orders)
{
CustomerOrderViewModel order = new CustomerOrderViewModel();
order.oDate = items.oDate;
order.WarehouseName = db.tWarehouseNames.Where(w => w.WarehouseNameId.Equals(items.oWarehouseName)).FirstOrDefault().WarehouseName;
order.EmployeeName = db.tEmployees.Where(e => e.EmployeeId.Equals(items.oEmployeeId)).FirstOrDefault().eName;
order.cNote = items.cNote;
List <tOrderDetail> orderdetails = db.tOrderDetails.Where(od => od.oOrderId.Equals(items.OrderId)).ToList();
List <CustomerOrderDetailViewModel> OrderDetailList = new List <CustomerOrderDetailViewModel>();
foreach (var itemDetail in orderdetails)
{
CustomerOrderDetailViewModel orderdetail = new CustomerOrderDetailViewModel();
orderdetail.ProductNum = db.tProducts.Where(p => p.ProductId.Equals(itemDetail.oProductId)).FirstOrDefault().pNumber;
orderdetail.ProductName = db.tProducts.Where(p => p.ProductId.Equals(itemDetail.oProductId)).FirstOrDefault().pName;
orderdetail.oProductQty = itemDetail.oProductQty;
orderdetail.oNote = itemDetail.oNote;
OrderDetailList.Add(orderdetail);
}
order.CustomerOrderDetails = OrderDetailList;
OrderList.Add(order);
}
return(View(OrderList));
}
return(RedirectToAction("首頁"));
}
public string AddCustomerOrder(CustomerOrderViewModel obj)
{
try
{
using (NavAssignmentEntities db = new NavAssignmentEntities())
{
Order orderObj = new Order();
orderObj.CustomerId = obj.CustomerId;
orderObj.OrderType = obj.OrderType;
orderObj.PaymentType = obj.PaymentType;
orderObj.GrandTotal = obj.GrandTotal;
orderObj.deliveryDate = obj.deliveryDate;
orderObj.isStatus = true;
orderObj.createdDate = orderObj.updatedDate = DateTime.Now;
orderObj.noofItems = obj.noofItems;
db.Orders.Add(orderObj);
db.SaveChanges();
return("Ok");
}
}
catch (Exception)
{
throw;
}
}
public IActionResult AddressAndPayment(CustomerOrderViewModel orderViewModel)
{
if (orderViewModel != null)
{
CustomerOrder newOrder = new CustomerOrder
{
FirstName = orderViewModel.FirstName,
LastName = orderViewModel.LastName,
Address = orderViewModel.Address,
City = orderViewModel.City,
State = orderViewModel.State,
PostalCode = orderViewModel.PostalCode,
Country = orderViewModel.Country,
Phone = orderViewModel.Phone,
Email = orderViewModel.Email,
CardNumber = orderViewModel.CardNumber,
Expiration = orderViewModel.Expiration,
//SecCode = orderViewModel.SecCode,
CardOwner = orderViewModel.CardOwner,
DateCreated = DateTime.Now,
Amount = orderViewModel.Amount
};
_context.CustomerOrders.Add(newOrder);
_context.SaveChanges();
return(RedirectToAction("EmptyCart", "ShoppingCart", new { id = newOrder.Id }));
}
else
{
return(RedirectToAction("AddressAndPayment"));
}
}
public IActionResult AddCustomerOrder(CustomerOrderViewModel customerorder)
{
//ViewBag.Locations = new SelectList()
//if (customerorder is null)
//{
// throw new ArgumentNullException(nameof(customerorder));
//}
try
{
if (ModelState.IsValid)
{
var addtorepo = new CustomerOrderModel
{
LocationName = customerorder.LocationName,
AmountPurchased = customerorder.AmountPurchased,
CustomerName = customerorder.CustomerName,
ProductId = customerorder.ProductId,
};
_orderRepo.AddOrder(addtorepo);
_orderRepo.Save();
return(RedirectToAction(nameof(Index)));
}
return(View(customerorder));
}
catch
{
return(View(customerorder));
}
}
public ActionResult MakeAnOrder(CustomerOrderViewItemModel model)
{
var viewModel = new CustomerOrderViewModel();
if (TempData["OrderItems"] == null)
{
viewItems = new List <CustomerOrderViewItemModel>();
}
else
{
viewItems = (List <CustomerOrderViewItemModel>)TempData["OrderItems"];
}
if (Request.Params["add"] != null)
{
viewItems.Add(model);
TempData["OrderItems"] = viewItems;
viewModel.OrderItems = viewItems;
return(View(viewModel));
}
else
{
TempData["OrderItems"] = viewItems;
viewModel.OrderItems = viewItems;
return(MakeAnOrderComplete(viewModel));
}
}
private void btnChangePaymentMethod_Click(object sender, RoutedEventArgs e)
{
try
{
var order = (CustomerOrderHistoryModel)dgOrderList.SelectedItem;
if (string.IsNullOrEmpty(order.Payment) || order.Payment.Contains(","))
{
var messageBoxResult = WpfMessageBox.Show(StatusMessages.CustomerOrderHistory, StatusMessages.PaymentMethodModifyNotAllow, MessageBoxButton.OK, EnumUtility.MessageBoxImage.Warning);
cmbSelectPaymentMethod.Focus();
return;
}
ppChangePaymentMethod.IsOpen = true;
CustomerOrderViewModel customerOrderViewModel = new CustomerOrderViewModel();
List <PaymentMethodModel> paymentMethodModels = new List <PaymentMethodModel>();
paymentMethodModels = customerOrderViewModel.GetPaymentMethod();
cmbSelectPaymentMethod.ItemsSource = paymentMethodModels;
cmbSelectPaymentMethod.Text = "Select Payment";
cmbSelectPaymentMethod.IsEditable = true;
cmbSelectPaymentMethod.IsReadOnly = true;
cmbSelectPaymentMethod.SelectedValuePath = "Id";
cmbSelectPaymentMethod.DisplayMemberPath = "PaymentMethodName";
}
catch (Exception ex)
{
SystemError.Register(ex);
}
}
private ActionResult MakeAnOrderComplete(CustomerOrderViewModel model)
{
try
{
var cmd = new MakeNewOrderCommand {
CustomerId = new Guid(Request.Params["CustomerId"])
};
foreach (var item in model.OrderItems)
{
cmd.Quantities.Add(item.ProductId, item.Quantity);
}
using (var s = UnitOfWork)
{
var ctx = new ContextHandler <Order, MakeNewOrderRole>(repo);
ctx.Bind(cmd)
.Execute();
s.Commit();
}
return(MakeAnOrder());
}
catch (Exception err)
{
throw err;
}
}
public CustomerOrderAdd()
{
InitializeComponent();
_vm = new CustomerOrderViewModel();
this.DataContext = _vm;
_vm.DeliveryDate = DateTime.Now.AddDays(1);
_vm.OrderDate = DateTime.Now;
}
//客戶看訂單
public ActionResult 過往訂單()
{
if (Session[CSession關鍵字.SK_LOGINED_CUSTOMER] != null)
{
tCustomer cust = Session[CSession關鍵字.SK_LOGINED_CUSTOMER] as tCustomer;
MotaiDataEntities db = new MotaiDataEntities();
List <tOrder> orders = db.tOrders.Where(o => o.oCustomerId == cust.CustomerId).ToList();
List <CustomerOrderViewModel> OrderList = new List <CustomerOrderViewModel>();
foreach (var items in orders)
{
CustomerOrderViewModel order = new CustomerOrderViewModel();
order.oDate = items.oDate;
order.WarehouseName = db.tWarehouseNames.Where(w => w.WarehouseNameId.Equals(items.oWarehouseName)).FirstOrDefault().WarehouseName;
tEmployee employee = db.tEmployees.Where(e => e.EmployeeId == items.oEmployeeId).FirstOrDefault();
if (employee != null)
{
order.EmployeeName = employee.eName;
}
order.cNote = items.cNote;
List <tOrderDetail> orderdetails = db.tOrderDetails.Where(od => od.oOrderId == items.OrderId).ToList();
List <CustomerOrderDetailViewModel> OrderDetailList = new List <CustomerOrderDetailViewModel>();
int originPrice = 0;
foreach (var itemDetail in orderdetails)
{
CustomerOrderDetailViewModel orderdetail = new CustomerOrderDetailViewModel();
tProduct product = db.tProducts.Where(p => p.ProductId == itemDetail.oProductId).FirstOrDefault();
orderdetail.ProductNum = product.pNumber;
orderdetail.ProductName = product.pName;
orderdetail.ProductPrice = product.pPrice;
orderdetail.oProductQty = itemDetail.oProductQty;
orderdetail.oNote = itemDetail.oNote;
OrderDetailList.Add(orderdetail);
originPrice += Convert.ToInt32(product.pPrice) * itemDetail.oProductQty;
}
if (items.oPromotionId != null)
{
tPromotion promotion = db.tPromotions.Where(p => p.PromotionId == items.oPromotionId).FirstOrDefault();
order.TotalAmount = originPrice - Convert.ToInt32(promotion.pDiscount);
}
else
{
order.TotalAmount = originPrice;
}
List <tOrderPay> paylists = db.tOrderPays.Where(op => op.oOrderId == items.OrderId).ToList();
foreach (var itemPay in paylists)
{
order.AlreadyPay += Convert.ToInt32(itemPay.oPayment);
}
order.Unpaid = order.TotalAmount - order.AlreadyPay;
order.CustomerOrderDetails = OrderDetailList;
OrderList.Add(order);
}
return(View(OrderList));
}
return(RedirectToAction("首頁"));
}
public ActionResult MakeAnOrder()
{
var viewModel = new CustomerOrderViewModel();
if (TempData["OrderItems"] != null)
{
viewModel.OrderItems = (List<CustomerOrderViewItemModel>)TempData["OrderItems"];
}
return View(viewModel);
}
public IActionResult Create()
{
var CustomerOrder = new CustomerOrderViewModel
{
Customers = _customerService.GetAll().Result.ToList(),
Categories = _categoryService.GetAll().Result.ToList(),
};
return(View(CustomerOrder));
}
public ActionResult OrderEmployerViews()
{
List <CustomerOrder> orderCheck = db.CustomerOrder.ToList();
CustomerOrderViewModel orderVM = new CustomerOrderViewModel();
List <CustomerOrderViewModel> orderListVM = orderCheck.Select(x => new CustomerOrderViewModel {
FirstName = x.Customer.FirstName, LastName = x.Customer.LastName, PhoneNumber = x.Customer.PhoneNumber, RestaurantName = x.RestaurantName, ItemOrdered = x.ItemOrdered, Quantity = x.Quantity, Date_of_Order = x.Date_of_Order, CurbeSide = x.CurbeSide, WalkIn = x.WalkIn, Tips = x.Tips
}).ToList();
return(View(orderListVM));
}
public ActionResult MakeAnOrder()
{
var viewModel = new CustomerOrderViewModel();
if (TempData["OrderItems"] != null)
{
viewModel.OrderItems = (List <CustomerOrderViewItemModel>)TempData["OrderItems"];
}
return(View(viewModel));
}
private void btnModeofPaymentReportExport_Click(object sender, RoutedEventArgs e)
{
try
{
if (!DateValidated(dpFromDatePayment, dpToDatePayment))
{
var messageBoxResult = WpfMessageBox.Show(StatusMessages.AppTitle, "Please select FROM DATE grater than or equal to TO DATE", MessageBoxButton.OK, EnumUtility.MessageBoxImage.Warning);
return;
}
CommonMethods commonMethods = new CommonMethods();
string path = string.Empty, firstLine = string.Empty;
CustomerOrderViewModel customerOrderViewModel = new CustomerOrderViewModel();
List <ModeofPaymentReportModel> modeofPaymentReportModel = new List <ModeofPaymentReportModel>();
modeofPaymentReportModel = customerOrderViewModel.GetModOfPaymentReport(dpFromDatePayment.SelectedDate.Value.ToString(CommonMethods.DateFormat), dpToDatePayment.SelectedDate.Value.ToString(CommonMethods.DateFormat));
string fileName = "ModeOfPaymentReport_" + DateTime.Now.ToString("MM-dd-yyyy_HHmmss");
var saveFileDialog = new SaveFileDialog
{
FileName = fileName != "" ? fileName : "gpmfca-exportedDocument",
DefaultExt = ".xlsx",
Filter = "Common Seprated Documents (.xlsx)|*.xlsx"
};
if (saveFileDialog.ShowDialog() == true)
{
path = saveFileDialog.FileName;
firstLine = LoginDetail.ClientName;
DataTable dtData = new DataTable();
DataTable dtDataResult = new DataTable();
dtData = commonMethods.ConvertToDataTable(modeofPaymentReportModel);
//X axis column: PaymentMethodName
//Y axis column: BillDate
//Z axis column: BillAmount
//Null value: "-";
//Sum of values: true
dtDataResult = commonMethods.GetInversedDataTable(dtData, "PaymentMethodName", "BillDate", "BillAmount", " ", true);
commonMethods.WriteExcelModeOfPaymentFile(dtDataResult, path, firstLine);
}
}
catch (Exception ex)
{
SystemError.Register(ex);
}
}
public CustomerOrder create(CustomerOrderViewModel input)
{
return(new CustomerOrder()
{
CustomerOrderId = input.CustomerOrderId,
CustomerId = input.CustomerId,
TotalOrderQuantity = input.TotalOrderQuantity,
TotalAmount = input.TotalAmount,
OrderStatus = input.OrderStatus,
OrderDatetime = input.OrderDatetime,
PaymentStatus = input.PaymentStatus,
DeliveredQuantity = input.DeliveredQuantity
});
}
/// <summary>
/// convert customer order view model to domain
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public CustomerOrder ConvertToDomain(CustomerOrderViewModel model)
{
CustomerOrder customerOrder = new CustomerOrder();
customerOrder.CustomerOrderId = model.CustomerOrderId;
customerOrder.ProjectId = model.ProjectId;
customerOrder.PONumber = model.PONumber;
customerOrder.PODate = model.PODate ?? DateTime.Now;
customerOrder.DueDate = model.DueDate;
customerOrder.PortDate = model.PortDate;
customerOrder.ShipDate = model.ShipDate;
customerOrder.EstArrivalDate = model.EstArrivalDate;
customerOrder.CustomerId = model.CustomerId;
customerOrder.FoundryId = model.FoundryId;
customerOrder.CustomerAddressId = model.CustomerAddressId;
customerOrder.SiteId = model.SiteId;
customerOrder.Notes = model.OrderNotes;
customerOrder.ShipmentTermsId = model.ShipmentTermsId;
customerOrder.IsOpen = model.IsOpen;
customerOrder.IsHold = model.IsHold;
customerOrder.HoldExpirationDate = (model.IsHold) ? model.HoldExpirationDate : null;
customerOrder.HoldNotes = (model.IsHold) ? model.HoldNotes : null;
customerOrder.IsCanceled = model.IsCanceled;
customerOrder.CanceledDate = (model.IsCanceled) ? model.CanceledDate : null;
customerOrder.CancelNotes = (model.IsCanceled) ? model.CancelNotes : null;
customerOrder.IsComplete = model.IsComplete;
customerOrder.CompletedDate = model.CompletedDate;
customerOrder.IsSample = model.IsSample;
customerOrder.IsTooling = model.IsTooling;
customerOrder.IsProduction = model.IsProduction;
if (model.CustomerOrderParts != null && model.CustomerOrderParts.Count > 0)
{
var customerOrderParts = new List <CustomerOrderPart>();
foreach (var customerOrderPart in model.CustomerOrderParts)
{
customerOrderPart.CustomerOrderId = model.CustomerOrderId;
CustomerOrderPart orderPart = new CustomerOrderPartConverter().ConvertToDomain(customerOrderPart);
customerOrderParts.Add(orderPart);
}
customerOrder.CustomerOrderParts = customerOrderParts;
}
return(customerOrder);
}
public IHttpActionResult Post([FromBody] CustomerOrderViewModel cusomerOrderViewModel)
{
try
{
// Convert the CustomerOrderViewModel data into CustomerOrder model entity
CustomerOrder customerOrder = this._customerOrderFactory.create(cusomerOrderViewModel);
// Save the Customer Order details into the Customer_Order table
bool result = this._customerOrderBusiness.SaveCustomerOrder(customerOrder);
return(Ok(result));
}
catch (Exception ex)
{
return(InternalServerError(ex));
}
}
public CustomerOrderViewModel GetOrderSummary(long customerId, long eventId)
{
var order = _orderRepository.GetOrder(customerId, eventId);
var amountDue = (order.DiscountedTotal - order.TotalAmountPaid);
var vmModel = new CustomerOrderViewModel
{
CustomerId = customerId,
OrderTotal = order.DiscountedTotal,
PaymentTotal = order.TotalAmountPaid,
AmountOwed = amountDue,
CustomerName = _customerRepository.GetCustomer(customerId).Name.FullName,
OrderDetails = _orderService.GetOrderDetailViewData(order.Id),
Paymentdetails = _orderService.GetPaymentDetailViewData(order.Id),
};
return(vmModel);
}
public ActionResult AddCustomer(Customer customer)
{
var customerVM = new CustomerOrderViewModel
{
Id = customer.Id,
FirstName = customer.FirstName,
LastName = customer.LastName,
District = customer.District,
City = customer.City,
Adress = customer.Adress,
PhoneNumber = customer.PhoneNumber,
Zip = customer.Zip
};
//TempData["customerVM"] = customerVM;
return(RedirectToAction("AddOrder", "Order", new RouteValueDictionary(customerVM)));
}
public HttpResponseMessage AddCustomerOrder(CustomerOrderViewModel obj)
{
try
{
using (NavAssignmentEntities db = new NavAssignmentEntities())
{
CustomerOrder model = new CustomerOrder();
model.AddCustomerOrder(obj);
}
}
catch (Exception)
{
return(Request.CreateResponse(HttpStatusCode.BadRequest, "Somthing went wrong"));
}
return(Request.CreateResponse(HttpStatusCode.OK, "Successfull"));
}
public async Task <IActionResult> Order()
{
IdentityUser user = await _userManagerService.FindByNameAsync(User.Identity.Name);
//get all Orderedpackage for this user
if (User.IsInRole("Customer"))
{
IEnumerable <Order> order = _orderDataService.GetAll().Where(p => p.UserId == user.Id);
CustomerOrderViewModel vm = new CustomerOrderViewModel
{
GetOrders = order
};
return(View(vm));
}
return(View());
}
/// <summary>
/// convert customer order to list model
/// </summary>
/// <param name="order"></param>
/// <returns></returns>
public CustomerOrderViewModel ConvertToListView(CustomerOrder order)
{
CustomerOrderViewModel model = new CustomerOrderViewModel();
var _customerDynamicsRepository = new CustomerDynamicsRepository();
var _foundryDynamicsRepository = new FoundryDynamicsRepository();
var dynamicsCustomer = _customerDynamicsRepository.GetCustomer(order.CustomerId);
var dynamicsFoundry = _foundryDynamicsRepository.GetFoundry(order.FoundryId);
model.CustomerOrderId = order.CustomerOrderId;
model.CustomerName = (dynamicsCustomer != null) ? dynamicsCustomer.SHRTNAME : "N/A";
model.PONumber = (!string.IsNullOrEmpty(order.PONumber)) ? order.PONumber : "N/A";
model.FoundryName = (dynamicsFoundry != null && !string.IsNullOrEmpty(dynamicsFoundry.VENDSHNM)) ? dynamicsFoundry.VENDSHNM : "N/A";
model.PODate = order.PODate;
model.PODateStr = (order.PODate != null) ? order.PODate.ToShortDateString() : "N/A";
model.DueDate = (order.DueDate != null) ? order.DueDate : DateTime.MinValue;
model.DueDateStr = (order.DueDate != null) ? order.DueDate.Value.ToShortDateString() : "N/A";
model.IsOpen = order.IsOpen;
model.IsHold = order.IsHold;
model.IsCanceled = order.IsCanceled;
model.IsComplete = order.IsComplete;
model.Status = order.IsOpen ? "Open" : order.IsCanceled ? "Canceled" : order.IsComplete ? "Completed" : order.IsHold ? "Hold" : "N/A";
model.IsSample = order.IsSample;
model.IsTooling = order.IsTooling;
model.IsProduction = order.IsProduction;
model.OrderTypeDescription = order.IsSample ? "Sample" : order.IsTooling ? "Tooling" : order.IsProduction ? "Production" : "N/A";
model.CreatedDate = order.CreatedDate;
model.HoldExpirationDate = order.HoldExpirationDate;
model.HoldNotes = order.HoldNotes;
if (_customerDynamicsRepository != null)
{
_customerDynamicsRepository.Dispose();
_customerDynamicsRepository = null;
}
if (_foundryDynamicsRepository != null)
{
_foundryDynamicsRepository.Dispose();
_foundryDynamicsRepository = null;
}
return(model);
}
private void btnPPPaymentMethodApply_Click(object sender, RoutedEventArgs e)
{
try
{
CustomerOrderViewModel customerOrderViewModel = new CustomerOrderViewModel();
var order = (CustomerOrderHistoryModel)dgOrderList.SelectedItem;
if (cmbSelectPaymentMethod.SelectedIndex == -1)
{
var messageBoxResult = WpfMessageBox.Show(StatusMessages.CustomerOrderHistory, StatusMessages.PaymentMethodSelect, MessageBoxButton.OK, EnumUtility.MessageBoxImage.Warning);
cmbSelectPaymentMethod.Focus();
return;
}
customerOrderViewModel.UpdateBillDetailPaymentMethod(order.Id.ToString(), Convert.ToInt32(cmbSelectPaymentMethod.SelectedValue));
ppChangePaymentMethod.IsOpen = false;
btnSearchOrderList_Click(null, null);
}
catch (Exception ex)
{
SystemError.Register(ex);
}
}
public ActionResult AcceptOrder(CustomerOrderViewModel customerOrderViewModel)
{
try
{
var Result = webServices.Post(customerOrderViewModel, "CustomerOrder/CustomerOrderRejectAcceptByAdmin", false);
if (Result.StatusCode == System.Net.HttpStatusCode.Accepted)
{
if (Result.Data != "[]")
{
int Res = (new JavaScriptSerializer().Deserialize <int>(Result.Data));
}
}
return(Json("suceess", JsonRequestBehavior.AllowGet));
}
catch (Exception)
{
return(Json("Failed", JsonRequestBehavior.AllowGet));
}
}
public List <CustomerOrderViewModel> GetOrders(int CustomerID)
{
string Query = @"select ord.Id,ord.OrderStatusId,ord.CreatedOnUtc,ord.OrderTotal,adr.Address1,adr.City,adr.ZipPostalCode
from [dbo].[Order] as ord
join [dbo].[CustomerAddresses] cadr on ord.CustomerId = cadr.[Customer_Id]
join [dbo].[Address] adr on cadr.[Address_Id] = adr.Id
where ord.CustomerId = @custid";
var param = new { custid = CustomerID };
var Data = _Order.Get <Order>(Query, param).ToList();
List <CustomerOrderViewModel> Model = new List <CustomerOrderViewModel>();
foreach (var item in Data)
{
CustomerOrderViewModel Obj = new CustomerOrderViewModel();
Obj.OrderID = item.Id;
Obj.OrderStatus = Enum.GetName(typeof(OrderStatusEnum), item.OrderStatusId);
Obj.OrderDate = item.CreatedOnUtc;
Obj.OrderPrice = (double)item.OrderTotal;
Model.Add(Obj);
}
return(Model);
}
public ActionResult AddOrder(ShoppingCartService cart, CustomerOrderViewModel customerVM)
{
var orderLVM = new List <OrdersViewModel>();
var productLVM = new List <OrderProductsViewModel>();
foreach (var products in cart.GetCartLineItems)
{
var productVM = new OrderProductsViewModel
{
ProductId = products.Product.Id,
PricePerUnit = products.Product.Price,
Quantity = products.Quantity
};
productLVM.Add(productVM);
}
var order = new OrdersViewModel
{
OrdersProducts = productLVM
};
orderLVM.Add(order);
var customer = new CustomerOrderViewModel
{
FirstName = customerVM.FirstName,
LastName = customerVM.LastName,
District = customerVM.District,
Adress = customerVM.Adress,
City = customerVM.City,
PhoneNumber = customerVM.PhoneNumber,
Zip = customerVM.Zip,
Orders = orderLVM
};
return(View(customer));
}
private ActionResult MakeAnOrderComplete(CustomerOrderViewModel model)
{
try
{
var cmd = new MakeNewOrderCommand { CustomerId = new Guid(Request.Params["CustomerId"]) };
foreach (var item in model.OrderItems)
{
cmd.Quantities.Add(item.ProductId, item.Quantity);
}
using (var s = UnitOfWork)
{
var ctx = new ContextHandler<Order, MakeNewOrderRole>(repo);
ctx.Bind(cmd)
.Execute();
s.Commit();
}
return MakeAnOrder();
}
catch(Exception err)
{
throw err;
}
}
public IActionResult AddressAndPayment(decimal amount)
{
CustomerOrderViewModel customerOrderViewModel = new CustomerOrderViewModel(amount);
return(View(customerOrderViewModel));
}
public ActionResult MakeAnOrder(CustomerOrderViewItemModel model)
{
var viewModel = new CustomerOrderViewModel();
if (TempData["OrderItems"] == null)
viewItems = new List<CustomerOrderViewItemModel>();
else
viewItems = (List<CustomerOrderViewItemModel>)TempData["OrderItems"];
if (Request.Params["add"] != null)
{
viewItems.Add(model);
TempData["OrderItems"] = viewItems;
viewModel.OrderItems = viewItems;
return View(viewModel);
}
else
{
TempData["OrderItems"] = viewItems;
viewModel.OrderItems = viewItems;
return MakeAnOrderComplete(viewModel);
}
}
public IActionResult AddItem(CustomerOrderViewModel order,
int quantity, int orderId, int customerId)
{
///The action adds an item to the current order
///@param int quantity
///@param int orderId
///@param int customerId
///@param CustomerOrderViewModel order
Order nOrder = new Order
{
OrderId = orderId,
CustomerId = customerId
};
OrderItem orderItem = new OrderItem
{
OrderId = orderId,
ItemId = order.Item.ItemId
};
if (ModelState.IsValid)
{
//Check if the same orderId already exists
if (DineOutContext.Order_Item
.Any(x => x.OrderId == orderItem.OrderId) == true)
{
var checkItems = DineOutContext.Order_Item
.Where(x => x.OrderId == orderItem.OrderId)
.Where(x => x.ItemId == orderItem.ItemId);
OrderItem checkItem = new OrderItem();
foreach (var i in checkItems)
{
if (orderItem.ItemId == i.ItemId)
{
checkItem = i;
}
}
if (orderItem.ItemId == checkItem.ItemId)
{
checkItem.Quantity += quantity;
DineOutContext.Order_Item.Update(checkItem);
DineOutContext.SaveChanges();
}
else
{
orderItem.Quantity = quantity;
DineOutContext.Order_Item.Add(orderItem);
DineOutContext.SaveChanges();
}
}
else
{
orderItem.Quantity = quantity;
DineOutContext.Order_Item.Add(orderItem);
DineOutContext.SaveChanges();
}
orderData.Order = DineOutContext.Order.Find(nOrder.OrderId);
orderData.Customer
= DineOutContext.Customer.Find(nOrder.CustomerId);
orderData.Menu = DineOutContext.Menu.Find(order.Item.MenuId);
orderData.Items = DineOutContext.Item
.ToList().FindAll(x => x.MenuId == order.Item.MenuId);
orderData.Restaurant = DineOutContext.Restaurant
.Find(orderData.Menu.RestaurantId);
orderData.Item = DineOutContext.Item.Find(order.Item.ItemId);
orderData.OrderItems = DineOutContext.Order_Item
.ToList().FindAll(x => x.OrderId == nOrder.OrderId);
TempData["message"] = $"{orderData.Item.ItemName} is added";
return(View("OrderDetails", orderData));
}
else
{
orderData.Order = DineOutContext.Order.Find(nOrder.OrderId);
orderData.Customer
= DineOutContext.Customer.Find(nOrder.CustomerId);
orderData.Menu = DineOutContext.Menu.Find(order.Item.MenuId);
orderData.Items = DineOutContext.Item
.ToList().FindAll(x => x.MenuId == order.Item.MenuId);
orderData.Restaurant = DineOutContext.Restaurant
.Find(orderData.Menu.RestaurantId);
orderData.Item = DineOutContext.Item.Find(order.Item.ItemId);
TempData["message"] = "Sorry, there is an error. Plese try it again.";
return(View("OrderDetails", orderData));
}
}
private void OnSelectedMenuItem()
{
if (SelectedMenuItem == MenuResources.Repairs)
{
if (CustomerRepairViewModel == null)
CustomerRepairViewModel = new CustomerRepairViewModel(this.Messenger, this.UserLogin, this.SelectedCustomer){ParentViewModel = this};
DetailSectionViewModel = CustomerRepairViewModel;
return;
}
if (SelectedMenuItem == MenuResources.Detail)
{
SetSummaryView();
return;
}
if (SelectedMenuItem == MenuResources.Appointments)
{
DetailSectionViewModel = null;
if (CustomerAppointmentViewModel == null)
CustomerAppointmentViewModel = new CustomerAppointmentViewModel(this.Messenger, this.UserLogin, this.SelectedCustomer) { ParentViewModel = this };
DetailSectionViewModel = CustomerAppointmentViewModel;
return;
}
if (SelectedMenuItem == MenuResources.Orders)
{
DetailSectionViewModel = null;
if (CustomerOrderViewModel == null)
CustomerOrderViewModel = new CustomerOrderViewModel(this.Messenger, this.UserLogin, this.SelectedCustomer) { ParentViewModel = this };
DetailSectionViewModel = CustomerOrderViewModel;
return;
}
if (SelectedMenuItem == MenuResources.WarrantyInformed)
{
DetailSectionViewModel = null;
if (CustomerWarrantyInformedViewModel == null)
CustomerWarrantyInformedViewModel = new CustomerWarrantyInformedViewModel(this.Messenger, this.UserLogin, this.SelectedCustomer) { ParentViewModel = this };
DetailSectionViewModel = CustomerWarrantyInformedViewModel;
}
}
