public OrdersPage()
{
this.InitializeComponent();
_viewModel = App.Container.Resolve<OrdersViewModel>();
this.DataContext = _viewModel;
}
public OrdersViewModel GetModel(UserOrdersPart part)
{
OrdersViewModel viewModel = new OrdersViewModel();
viewModel.State = this.GetState(part);
this.UpdateState(part, viewModel);
this.LoadOrders(part, viewModel);
return viewModel;
}
private void LoadOrders(UserOrdersPart part, OrdersViewModel viewModel)
{
Exception exeption = this._webStoreClientServices.UsingClient(
c =>
{
OrderList orderList = c.StoreClient.GetOrders(viewModel.State.SortExpression.Value, viewModel.State.SortDirection.Value, part.EnablePaging && part.PageSize.HasValue ? part.PageSize.Value : Int32.MaxValue, viewModel.State.Page.Value - 1, false, false);
viewModel.State.PageCount = part.PageSize.HasValue ? (Int32)Math.Ceiling((Decimal)orderList.Count / (Decimal)part.PageSize) : 1;
viewModel.AddRange(orderList.Orders);
}
);
if (exeption == null && !viewModel.Any() && viewModel.State.Page > 1)
{
viewModel.State.Page = 1;
this.LoadOrders(part, viewModel);
}
}
public ActionResult Order()
{
ViewBag.lstCatePost = _postRepository.GetPost_Category();
var user = _userRepository.Find(User.Identity.GetUserId());
ViewBag.lstCatePost = _postRepository.GetPost_Category();
OrdersViewModel model = new OrdersViewModel()
{
Address = user.Address,
Email = user.Email,
FullName = user.FullName,
Mobile = user.PhoneNumber
};
return(View(model));
}
public void GetUnSubmittedOrders_ReturnsUnsubmittedOrders()
{
var ordersViewModel = new OrdersViewModel();
List <Order> orders = ordersViewModel.GetUnsubmittedOrders();
// Leave test if no results returned
if (orders.Count < 1)
{
return;
}
string actual = orders[0].Status;
string expected = "open";
Assert.AreEqual(expected, actual);
}
public ActionResult Edit(int id)
{
var order = _context.Orders.Include(m => m.OrderedItems).Include(m => m.Customer).ToList().SingleOrDefault(m => m.Id == id);
if (order == null)
{
return(HttpNotFound());
}
var viewModel = new OrdersViewModel
{
Order = order,
Customer = order.Customer,
OrderItems = order.OrderedItems
};
return(View(viewModel));
}
public async Task <IActionResult> Index()
{
var orders = await this.repository.GetOrdersAsync(this.User.Identity.Name);
if (orders == null)
{
orders = new List <Order>();
}
var model = new OrdersViewModel
{
DeliveryDate = DateTime.Today,
Orders = orders
};
return(View(model));
}
// GET: Order
public ActionResult Index(string userID, string status, int?pageNo)
{
OrdersViewModel model = new OrdersViewModel();
model.UserID = userID;
model.Status = status;
pageNo = pageNo.HasValue ? pageNo.Value > 0 ? pageNo.Value : 1 : 1;
var pageSize = ConfigurationsService.Instance.PageSize();
model.Orders = OrdersService.Instance.SearchOrders(userID, status, pageNo.Value, pageSize);
var totalRecords = OrdersService.Instance.SearchOrdersCount(userID, status);
model.Pager = new Pager(totalRecords, pageNo, pageSize);
return(View(model));
}
public ActionResult Index()
{
Orders o = new Orders();
List <Order> O = o.GO(this.HttpContext);
List <Order> IP = o.GOS(this.HttpContext, "In Progress");
List <Order> C = o.GOS(this.HttpContext, "Completed");
var OVM = new OrdersViewModel
{
O = O,
IP = IP,
C = C
};
return(View(OVM));
}
private OrdersViewModel ConvertOrdersDTOToOrdersListViewModel(OrdersDTO ordersDTO)
{
OrdersViewModel ordersListViewModel = new OrdersViewModel();
ordersListViewModel.Orders = ordersDTO.Orders.Select(r => new OrderViewModel
{
OrderId = r.OrderId.ToString()
, CustomerId = r.CustomerId.ToString()
, Make = r.Make
, Model = r.Model
, Color = r.Color
, Year = r.Year.ToString()
, OwnershipType = r.OwnershipType
}).ToList();
return(ordersListViewModel);
}
public IActionResult Orders()
{
double averageCheck = db.Orders.Average(o => o.TotalPrice);
double amountMoney = db.Orders.Sum(o => o.TotalPrice);
int numberOfOrders = db.Orders.Count();
int totalOrderedItems = db.OrderItemOrders.Count();
OrdersViewModel ovm = new OrdersViewModel()
{
AverageCheck = averageCheck.ToString("$0.##"),
AmountMoney = amountMoney.ToString("$0.##"),
NumberOfOrders = numberOfOrders,
TotalOrderedItems = totalOrderedItems
};
return(PartialView(ovm));
}
public OrdersViewModel GetOrdersViewModel(string orderId, OrderStatuses?orderStatus,
string userEmail, int page, int pageSize)
{
OrdersViewModel model = new OrdersViewModel
{
Orders = orderOperations.GetOrders(page, pageSize, orderStatus, userEmail, orderId),
PagingInfo = new PagingInfoViewModel
{
CurrentPage = page,
ItemsPerPage = pageSize,
TotalItems = orderRepository.GetAllOrders().Count()
},
SelectedStatus = orderStatus
};
return(model);
}
public async Task <IActionResult> Checkout(string username)
{
OrdersViewModel ordersView;
if (!string.IsNullOrEmpty(username))
{
ordersView = new OrdersViewModel();
User user = await userManager.FindByNameAsync(username);
if (user != null)
{
ordersView.Cart = cartService;
ordersView.User = user;
}
return(View(ordersView));
}
return(RedirectToAction("Index", "Home"));
}
// GET: Admin/Orders
public ActionResult Index()
{
var orders = db.Orders.ToList();
var listOfOrders = new List <OrdersViewModel>();
foreach (var order in orders)
{
var viewModel = new OrdersViewModel()
{
User = db.Users.SingleOrDefault(u => u.Id == order.UserID),
Order = order
};
listOfOrders.Add(viewModel);
}
return(View(listOfOrders));
}
public async Task <IViewComponentResult> InvokeAsync()
{
var model = new OrdersViewModel();
var orders = await _dbService.GetAllOrdersAsync();
foreach (var order in orders)
{
var o = new Order();
o.CustomerOrder = order;
o.Customer = order.Kund;
o.Delivered = order.Levererad;
o.KundId = order.KundId;
o.BestallningsId = order.BestallningId;
model.Orders.Add(o);
}
return(View(model));
}
public ActionResult Orders_createItem(OrdersViewModel model)
{
model.Contragents = mng.Contragents.GetContragents();
model.OrdersStatuses = mng.Orders.GetOrderStatuses();
string msg = "";
var user = mng.GetUser();
mng.Orders.SaveOreder(model, user, out msg);
ViewBag.Message = msg;
//ViewData["Message"] = msg;
//return PartialView(model);
return(RedirectToAction("Orders"));
//return RedirectToAction("Orders");
}
[HttpPost]// SaveOrder takes in a ViewModel from AJAX and processes the Data
public async Task <JsonResult> SaveOrder(OrdersViewModel model)
{
string result;
if (model.Vendor.VendorId == 0 || model.PurchaseOrder.DateOrdered == null || model.PurchaseOrder.DeliveryDate == null || model.OrderItems == null)
{
result = "Error! Form not Complete!";
return(Json(result));
}
//get the purchase Order and add its properties
var purchase = model.PurchaseOrder;
purchase.DateOrdered = Convert.ToDateTime(Request.Form["PurchaseOrder.DateOrdered"]);
purchase.DeliveryDate = Convert.ToDateTime(Request.Form["DeliveryDate"]);
purchase.LastModifiedBy = User.Identity.Name;
purchase.LastModifiedDate = DateTime.Now;
purchase.Vendor = await _context.Vendor.FirstOrDefaultAsync(v => v.VendorId == purchase.VendorID);
//store purchase order and get Id
_context.PurchaseOrder.Add(purchase);
await _context.SaveChangesAsync(); //new purchase order id
//Now add OrderItems with Purchase Id
foreach (OrderItem oi in model.OrderItems)
{
//add the purchase order Id
oi.PurchaseOrderID = purchase.PurchaseOrderId;
//add the Item
oi.Item = await _context.Item.FirstOrDefaultAsync(i => i.ItemId == oi.ItemID);
oi.Item.Measure = await _context.Measures.FirstOrDefaultAsync(m => m.MeasureId == oi.Item.MeasureID);
oi.Price = Convert.ToDecimal(oi.Price);
oi.LastModifiedBy = User.Identity.Name;
oi.LastModifiedDate = DateTime.Now;
_context.OrderItem.Add(oi);
}
await _context.SaveChangesAsync();
// save changes
result = "Purchase Order# " + purchase.PurchaseOrderId.ToString() + " Confirmed.";
return(Json(result));
}
public IActionResult Orders()
{
var dbOrders = StaticDb.Orders;
var orders = new List <OrderViewModel>();
foreach (var order in dbOrders)
{
var tempOrder = new OrderViewModel()
{
Id = order.Id,
FullName = order.User.FirstName + " " + order.User.LastName,
Address = order.User.Address,
Contact = order.User.Phone,
Price = order.Price,
IsDelievered = order.IsDelivered,
Pizzas = new List <PizzaViewModel>()
};
foreach (var pizza in order.Pizzas)
{
var tempPizza = new PizzaViewModel()
{
Name = pizza.Name,
Price = pizza.Price,
Size = pizza.Size
};
tempOrder.Pizzas.Add(tempPizza);
}
orders.Add(tempOrder);
}
var ordersViewModel = new OrdersViewModel()
{
FirstPizza = dbOrders[0].Pizzas[0].Name,
FirstPersonName = $"{dbOrders[0].User.FirstName} {dbOrders[0].User.LastName}",
NumberOfOrders = dbOrders.Count,
Orders = orders
};
return(View(ordersViewModel));
}
private void SimulateUpdateOrder(OrdersViewModel ordersViewModel)
{
if (currentOrderId <= 0)
{
// at least one order must be created for the update
return;
}
// ---------------------------------------------------
// In a non test mode we would receive the data of the
// updated order from the logic/model layer with the
// values updated with the correct business logic.
// For testing purposes get the order state directly
// from the view model list and update the values with
// a dummy logic.
// ---------------------------------------------------
// Choose a random order to update...
var randIndexToUpdate = random.Next(0, currentOrderId - 1);
var orderVM = ordersViewModel.GetOrderVMByIndex(randIndexToUpdate); // O(1)
// but simulate as if we had to find the order using the ID
orderVM = ordersViewModel.GetOrderVMByID(orderVM.Id);
var cumQtyToUpdate = int.Parse(orderVM.CumQty);
cumQtyToUpdate = int.Parse(orderVM.LeavesQty) > 0 ? cumQtyToUpdate + 1 : cumQtyToUpdate;
orderVM.CumQty = cumQtyToUpdate.ToString();
orderVM.LeavesQty = (int.Parse(orderVM.OrdQty) - cumQtyToUpdate).ToString();
// do some random chance to update the following fields
var chanceToUpdateValues = random.Next(1, 10);
if (chanceToUpdateValues % 2 == 0)
{
orderVM.TotalValue = random.Next(0, 1000).ToString();
}
if (chanceToUpdateValues % 3 == 0)
{
orderVM.AvailableValue = random.Next(0, 1000).ToString();
}
orderVM.GoalValue = random.Next(0, 1000).ToString();
Application.Current.Dispatcher.BeginInvokeOnMainThread(() => orderVM.Update());
}
public IActionResult Index()
{
// Domain models
List <Order> orders = _pizzaOrderService.GetAllOrders();
// View Models
// MAPPINT SECTION
List <OrderItemViewModel> viewOrders = new List <OrderItemViewModel>();
foreach (Order order in orders)
{
List <PizzaViewModel> pizzasView = new List <PizzaViewModel>();
foreach (var pizzaOrder in order.PizzaOrders)
{
pizzasView.Add(new PizzaViewModel()
{
Id = pizzaOrder.Pizza.Id,
Image = pizzaOrder.Pizza.Image,
Name = pizzaOrder.Pizza.Name,
Price = pizzaOrder.Pizza.Price,
Size = pizzaOrder.Pizza.Size
});
}
;
viewOrders.Add(new OrderItemViewModel()
{
FirstName = order.User.FirstName,
LastName = order.User.LastName,
Id = order.Id,
Price = order.Price,
Pizzas = pizzasView
});
}
OrdersViewModel model = new OrdersViewModel()
{
LastPizza = _pizzaOrderService.GetLastOrder().PizzaOrders[0].Pizza.Name,
MostPopularPizza = _pizzaOrderService.GetMostPopularPizza(),
NameOfFirstCustomer = _userService.GetLastUserName(),
OrderCount = _pizzaOrderService.GetOrderCount(),
Orders = viewOrders
};
// We send mapped view model to the view
return(View(model));
}
public IActionResult Index()
{
List <Order> orders = _pizzaOrderService.GetAllOrders();
//MAPPING SECTION
List <OrderItemViewModel> viewOrders = new List <OrderItemViewModel>();
foreach (var order in orders)
{
List <PizzaViewModel> pizzasView = new List <PizzaViewModel>();
foreach (var pizzaOrder in order.PizzaOrders)
{
pizzasView.Add(new PizzaViewModel()
{
Id = pizzaOrder.Pizza.Id,
Image = pizzaOrder.Pizza.Image,
Name = pizzaOrder.Pizza.Name,
Price = pizzaOrder.Pizza.Price,
Size = pizzaOrder.Pizza.PizzaSize
});
}
viewOrders.Add(new OrderItemViewModel()
{
Id = order.Id,
Firstname = order.User.FirstName,
Lastname = order.User.LastName,
Price = order.Price,
Pizzas = pizzasView
});
}
OrdersViewModel model = new OrdersViewModel()
{
LastPizza = _pizzaOrderService.GetLastOrder().PizzaOrders.FirstOrDefault().Pizza.Name,
MostPopularPizza = _pizzaOrderService.GetMostPopularPizza(),
NameOfFirstCustomer = _userService.GetLastUserName(),
OrderCount = _pizzaOrderService.GetOrderCount(),
Orders = viewOrders
};
return(View(model));
}
// GET: /<controller>/
public IActionResult Index(string statusMessage = "", string successMessage = "", string failureMessage = "")
{
var userId = _userManager.GetUserId(User);
var viewModel = new OrdersViewModel()
{
Orders = _context.Orders.
Where(x => x.UserId == userId).
Where(x => x.OrderStatusId != OrderHelper.StatusId(MasterStrings.Basket, _context)).
Include(x => x.OrderStatus).
Include(x => x.DeliveryType).
OrderByDescending(x => x.OrderPlacedDate).
ToList(),
StatusMessage = statusMessage,
SuccessMessage = successMessage,
FailureMessage = failureMessage
};
return(View(viewModel));
}
public IActionResult Orders()
{
var orders = _orderService.GetAllOrders();
var firstPizza = _orderService.GetFirstPizzaName();
var firstPersonName = _orderService.GetFirstPerson();
var numberOfOrder = _orderService.GetTotalNumberOfOrders();
var mostPopulatPizza = _orderService.GetMostPopularPizza();
var ordersViewModel = new OrdersViewModel()
{
Orders = orders,
FirstPersonName = firstPersonName,
FirstPizza = firstPizza,
NumberOfOrders = numberOfOrder,
MostPopularPizza = mostPopulatPizza
};
return(View(ordersViewModel));
}
public ActionResult MyOrders()
{
OrdersViewModel ordersViewModel = new OrdersViewModel();
try
{
OrdersDTO ordersDTO = orderBusinessContext.GetOrders(new Guid(Session["UserID"].ToString()));
ordersViewModel.Orders = OrdersMapper.Map <IEnumerable <OrderDTO>, IEnumerable <OrderViewModel> >(ordersDTO.Orders);
}
catch (NoOrderException ex)
{
return(View("NoOrders"));
}
catch (Exception ex)
{
return(View("InternalError"));
}
return(View(ordersViewModel));
}
public ViewResult DetailsOrder(int id)
{
Order order = db.Orders.Include(p => p.Product).Where(p => p.Id == id).First();
OrderViewModel orderView = new OrderViewModel
{
Id = order.Id,
NameProduct = order.Product.Name,
Date_of_order = order.Date_of_order,
Date_of_sale = order.Date_of_sale,
Price = order.Price,
Quantity = order.Quantity
};
OrdersViewModel viewModel = new OrdersViewModel
{
OrderViewModel = orderView
};
return(View(viewModel));
}
public IActionResult Add()
{
var customers = db.Customer.Select(a => new
{
Id = a.Id,
Name = a.Name
}).ToList();
var ordersViewModel = new OrdersViewModel
{
orders = new Orders()
{
Payments = "cash"
},
customers = new SelectList(customers, "Id", "Name")
};
return(View("Add", ordersViewModel));
}
protected override void OnDisposing()
{
if (disposed)
{
return;
}
if (AccountViewModel != null)
{
accountObservableSubscription.Dispose();
AccountViewModel.Dispose();
}
foreach (var subscription in symbolObservableSubscriptions.Values)
{
subscription.Dispose();
}
foreach (var symbol in Symbols)
{
symbol.Dispose();
}
if (SymbolsViewModel != null)
{
symbolsObservableSubscription.Dispose();
SymbolsViewModel.Dispose();
}
if (TradeViewModel != null)
{
tradeObservableSubscription.Dispose();
TradeViewModel.Dispose();
}
if (OrdersViewModel != null)
{
ordersObservableSubscription.Dispose();
OrdersViewModel.Dispose();
}
disposed = true;
}
public OrdersViewModel GetOrdersUnDelivered()
{
var model = new OrdersViewModel();
using (TomasosContext db = new TomasosContext())
{
model.Orders = db.Bestallning.Where(r => r.Levererad == false)
.OrderByDescending(r => r)
.ToList();
foreach (var order in model.Orders)
{
var customer = new Kund();
order.Kund = db.Kund.FirstOrDefault(r => r.KundId == order.KundId);
}
}
return(model);
}
public void TestCurrentOrderSetting()
{
Order order = new Order()
{
Id = 1
};
Mock <IServiceFactory> mockServiceFactory = new Mock <IServiceFactory>();
mockServiceFactory.Setup(mock => mock.CreateClient <IOrderService>().GetOrder(1)).Returns(order);
OrdersViewModel viewModel = new OrdersViewModel(mockServiceFactory.Object);
Assert.IsTrue(viewModel.CurrentOrderViewModel == null);
viewModel.EditOrderCommand.Execute(order);
Assert.IsTrue(viewModel.CurrentOrderViewModel != null && viewModel.CurrentOrderViewModel.Order.Id == order.Id);
}
public ActionResult Create(OrdersViewModel model)
{
try
{
if (ModelState.IsValid)
{
var order = Mapper.Map <OrdersViewModel, Orders>(model);
_unitOfWork.RepositoryFor <Orders, int>().Create(order);
_unitOfWork.Commit();
return(RedirectToRoute(new { controller = "Cars", action = "Details", id = model.CarsID }));
}
}
catch (DataException)
{
throw;
}
return(View());
}
public JsonResult Put(int id, [FromBody] OrdersViewModel model)
{
if (!ModelState.IsValid)
{
Response.StatusCode = (int)HttpStatusCode.BadRequest;
return Json(new { message = Validation.getValidationErrors(model) });
}
if (model.Items == null || model.Items.Count() == 0)
{
return Json(new { message = "Список товаров не может быть пустыми" });
}
IEnumerable<int> validItems = ItemsService.getValidItemsList(dapperService, model.Items).Select(x => x.Id);
if (validItems == null || validItems.Count() == 0)
{
return Json(new { message = "Следующие товары не существует в базе", model.Items });
}
List<int> inValidItems = new List<int>();
foreach (var i in model.Items)
{
if (!validItems.Contains(i))
{
inValidItems.Add(i);
}
}
if (inValidItems != null && inValidItems.Count() > 0)
{
return Json(new { message = "Следующие товары не существует в базе", Items = inValidItems });
}
if (!RegionsService.checkForExists(dapperService, model.RegionId))
{
return Json(new { message = $"RegionId={model.RegionId} не существует в базе" });
}
OrdersModel item = new OrdersModel()
{
Id = id,
RegionId = model.RegionId,
ItemsIds = model.Items
};
bool isSaved = ordersService.Update(item, id);
return Json(new { message = isSaved ? "Сохранено" : "Не cохранено" });
}
public JsonResult Post([FromBody] OrdersViewModel model)
{
if (!ModelState.IsValid)
{
Response.StatusCode = (int)HttpStatusCode.BadRequest;
return Json(new { message = Validation.getValidationErrors(model) });
}
if (model.Items == null || model.Items.Count() == 0)
{
return Json(new { message = "Список товаров не может быть пустыми" });
}
if (!Int32.TryParse(User.Claims.FirstOrDefault(x => x.Type == ClaimTypes.NameIdentifier)?.Value, out int id))
{
return Json(new { message = "Пользователь не существует" });
}
IEnumerable<int> validItems = ItemsService.getValidItemsList(dapperService, model.Items).Select(x => x.Id);
if (validItems == null || validItems.Count() == 0)
{
return Json(new { message = "Следующие товары не существует в базе", model.Items });
}
List<int> inValidItems = new List<int>();
foreach(var i in model.Items)
{
if(!validItems.Contains(i)){
inValidItems.Add(i);
}
}
if(inValidItems != null && inValidItems.Count() > 0)
{
return Json(new { message = "Следующие товары не существует в базе" , Items = inValidItems });
}
if (!RegionsService.checkForExists(dapperService, model.RegionId))
{
return Json(new { message = $"RegionId={model.RegionId} не существует в базе"});
}
OrdersModel items = new OrdersModel(model){
UserId = id
};
bool isSaved = ordersService.Save(items);
return Json(new { message = isSaved ? "Сохранено" : "Не cохранено" });
}
public IActionResult Post([FromBody] OrdersViewModel order)
{
this._cxt.Orders.Add(new Orders
{
CustomerID = order.OrderID,
CustomerName = order.CustomerName,
MoMoProvider = order.MoMoProvider,
MoMoNumber = order.MoMoNumber,
OrderDate = order.OrderDate,
OrderType = order.OrderType,
CollectionDate = order.CollectionDate,
SubTotal = order.SubTotal
});
this._cxt.SaveChanges();
var vm = new OrdersViewModel();
return(Created($"/api/Orders/{order.OrderID}", order));
//try
//{
// if (ModelState.IsValid)
// {
// var newOrder = this._mapper.Map<OrdersViewModel, Orders>(order);
// this._cxt.Orders.Add(newOrder);
// if (this._cxt.SaveChanges() > 0)
// {
// return Ok(newOrder); //Created($"/api/orders/{newOrder.CustomerID}", _mapper.Map<Orders, OrdersViewModel>(newOrder));
// }
// return BadRequest(ModelState);
// }
// else
// {
// return this.BadRequest(ModelState);
// }
//}
//catch (Exception ex)
//{
// return this.Ok();
//}
}
private void UpdateState(UserOrdersPart part, OrdersViewModel viewModel)
{
if ((part.EnablePaging && !viewModel.State.Page.HasValue) || (!part.EnablePaging) || viewModel.State.Page < 1)
{
viewModel.State.Page = 1;
}
if (part.EnableSorting)
{
if (!viewModel.State.SortDirection.HasValue)
{
viewModel.State.SortDirection = OrderSortDirection.Descending;
}
if (!viewModel.State.SortExpression.HasValue)
{
viewModel.State.SortExpression = OrderSortExpression.OrderNumber;
}
}
else
{
viewModel.State.SortDirection = OrderSortDirection.Descending;
viewModel.State.SortExpression = OrderSortExpression.OrderNumber;
}
}
protected override void OnLaunched(LaunchActivatedEventArgs args)
{
ViewModel = new OrdersViewModel();
Window.Current.Content = new MainPage() { DataContext = ViewModel };
Window.Current.Activate();
}
public MainPage()
{
InitializeComponent();
DataContext = new OrdersViewModel();
}
private void Application_Startup(object sender, StartupEventArgs e)
{
ViewModel = new OrdersViewModel();
this.RootVisual = new MainPage() { DataContext = ViewModel };
}