public ActionResult Create(OrderVm ovm, int id) { Order Orderdomain = new Order() { OrderDate = DateTime.Now, ProductId = id, UserId = 1, ProductQuantity = ovm.ProductQuantity }; Service.Add(Orderdomain); Service.Commit(); //Service.Dispose(); return(RedirectToAction("Index")); //Order or = new Order() //{ // OrderDate = DateTime.Now, // ProductId = idProduct, // UserId = 1, // ProductQuantity = ovm.ProductQuantity //}; //Service.Add(or); //Service.Commit(); }
public OrderVm GetOrder(List <ProductVm> cart) { if (cart == null) { return(null); } var ord = new OrderVm(); ord.Total = 0; ord.products = GetProductsForCart(cart); var discountable = ord.products.Where(x => x.IsDiscountable); foreach (var item in discountable) { if (discountable.Count() > 1) { ord.Total += ((item.Price * 0.95) * item.Attendanties); } else { ord.Total += (item.Price * item.Attendanties); } } foreach (var item in ord.products.Where(x => !x.IsDiscountable)) { ord.Total += (item.Price); } return(ord); }
internal static CreateNewOrder GetCreateNewOrderCommand(OrderVm order) { return(new CreateNewOrder() { Order = order }); }
public async Task <IActionResult> Edit(int id, [Bind("OrderId,CustomerId,OrderNumber,OrderDate,RequiredDate,AdvancePaymentTax,IsOffer,OfferlDetails,Paid")] OrderVm Order) { if (id != Order.OrderId) { return(NotFound()); } if (ModelState.IsValid) { try { await _OrderMapper.BlUpdateAsync(Order); } catch (DbUpdateConcurrencyException) { var Exists = _OrderMapper.OrderExists((Order.OrderId)); if (!Exists) { return(NotFound()); } else { throw; } } var cust = _customerMapper.BlGetAllCustomer(); ViewData["CustomerId"] = new SelectList(cust, "CustomerId", "FullName"); return(RedirectToAction(nameof(Index))); } return(View(Order)); }
public async Task CanCreate() { var orderVm = new OrderVm(); orderVm.Customer = new CustomerVM() { Name = "test", Adress = new AdressVm() }; orderVm.GiftWrap = true; orderVm.OrderLines = new List <OrderLineVm>() { new OrderLineVm { Product = new ProductDTO(), Quantity = 1 }, new OrderLineVm { Product = new ProductDTO(), Quantity = 1 } }; var command = CommandFactory.GetCreateNewOrderCommand(orderVm); var result = await new CreateNewOrderHandler(context, mapper).Handle(command); Assert.AreEqual(1, result); Assert.AreEqual(1, context.Orders.Count()); }
public IActionResult OrderDetails(long orderId) { var orderVm = OrderVm.MapToViewModel(_orderBlProvider.GetSingle(orderId)); return(PartialView("_OrderDetail", orderVm)); }
//Create new order public bool CreateNew(OrderVM order, int userId) { OrderVm newOrder = new OrderVm { OrderDate = DateTime.Now, PickupTime = order.PickupTime, Qty = order.Qty, CustomerId = userId }; var itemDetails = db.FoodItem.Where(food => food.FoodId == order.FoodId).FirstOrDefault(); decimal price = Convert.ToDecimal(itemDetails.UnitPrice); decimal total = Convert.ToDecimal(order.Qty) * price; OrderItem orderItem = new OrderItem { OrderId = order.OrderId, FoodId = order.FoodId, Quantity = order.Qty, Total = total }; db.Orders.Add(newOrder); db.OrderItem.Add(orderItem); db.SaveChanges(); return(true); }
public ActionResult Edit(int id, int idu, OrderVm ovm) { try { if (ModelState.IsValid) { Order p = Service.getbyids(id, idu); p.ProductQuantity = ovm.ProductQuantity; if (p == null) { return(HttpNotFound()); } Service.Update(p); Service.Commit(); Service.Dispose(); return(RedirectToAction("Index")); } // TODO: Add delete logic here return(View(ovm)); } catch { return(View()); } }
public ActionResult Delete(int id, int idu, OrderVm ovm) { try { if (ModelState.IsValid) { if (id == null) { return(new HttpStatusCodeResult(HttpStatusCode.BadRequest)); } Order p = Service.getbyids(id, idu); if (p == null) { return(HttpNotFound()); } Service.Delete(p); Service.Commit(); return(RedirectToAction("Index")); } // TODO: Add delete logic here return(View(ovm)); } catch { return(View()); } }
public bool ProccessOrder(OrderVm order) { using (DatabaseEntities context = new DatabaseEntities()) { Customer cus = CreateCustomer(order); Order ord = CreateOrder(order, cus); List <Reservation> res = CreateListReservation(order.products.Where(x => x.IsRestaurant).ToList(), ord); List <ProductInOrder> proInOrd = CreateListProductInOrder(order.products.Where(x => !x.IsRestaurant).ToList(), ord); context.Customers.Add(cus); context.SaveChanges(); ord.fk_Client = cus.Id; context.Orders.Add(ord); context.SaveChanges(); res.ForEach(x => x.fk_Order_Id = ord.Id); proInOrd.ForEach(x => x.fk_Order_id = ord.Id); context.Reservations.AddRange(res); context.SaveChanges(); context.ProductInOrders.AddRange(proInOrd); context.SaveChanges(); } return(false); }
public ActionResult Checkout(OrderVm orderVm) { if (orderVm == null) { return(new HttpStatusCodeResult(HttpStatusCode.BadRequest)); } if (ModelState.IsValid) { if (OrderList != null) { foreach (var order in OrderList) { _orderLogic.Add(new Order { Name = orderVm.Name, Surname = orderVm.Surname, Email = orderVm.Email, PhoneNumber = orderVm.PhoneNumber, Quantity = order.Quantity, GameId = order.Id }); } SendEmail(OrderList, orderVm); Session["OrderedGames"] = null; } return(RedirectToAction("Index")); } return(View(orderVm)); }
public void AddOrderItem_IncorrectPrice_ShouldReturnOrderVmWithCorrectPrice() { var context = new ApplicationDbContext(_testcs); var service = new OrderService(context); OrderVm orderVm = new OrderVm() { coffeeName = "Latte", milkCount = 3, espressoCount = 3, isContainChocolate = false, price = 1 }; string username = "******"; var newOrderItem = service.AddOrderItem(orderVm, username); var orderFromDb = context.Orders .Include(o => o.Items) .ThenInclude(oi => oi.Coffee) .Where(o => o.IsPaymentCompleted == false) .FirstOrDefault(o => o.ClientId == username); var orderItemFromDb = orderFromDb.Items .Where(o => o.Coffee.Name == "Latte") .Where(o => o.MilkCount == 3) .Where(o => o.EspressoCount == 3) .Where(o => o.IsContainChocolate == false) .FirstOrDefault(o => o.Price == 7.5); Assert.IsNotNull(orderItemFromDb); Assert.IsNotNull(newOrderItem); Assert.That(orderVm.coffeeName, Is.EqualTo(orderItemFromDb.Coffee.Name)); Assert.That(orderVm.milkCount, Is.EqualTo(orderItemFromDb.MilkCount)); Assert.That(orderVm.espressoCount, Is.EqualTo(orderItemFromDb.EspressoCount)); Assert.That(orderVm.isContainChocolate, Is.EqualTo(orderItemFromDb.IsContainChocolate)); Assert.That(7.5, Is.EqualTo(orderItemFromDb.Price)); }
public async Task <OrderVm> CreateAsync(IList <CartItem> items, string userId) { var order = new Models.Order() { UserId = userId, OrderDate = DateTime.Today, Status = false }; _context.Add(order); await _context.SaveChangesAsync(); foreach (var item in items) { await _orderDetailService.CreateAsync(order.OrderId, item.Product.ProductId, item.Quantity); } var orderVm = new OrderVm() { OrderId = order.OrderId, UserId = userId, OrderDate = DateTime.Today, Status = false }; return(orderVm); }
public OrderVm GetOrderById(int id) { Order model = this.Context.Orders.Find(id); OrderVm vm = Mapper.Instance.Map <Order, OrderVm>(model); return(vm); }
public MainWindowVm() { var rnd = new Random(); Prices = new ObservableCollection <PriceEntryVm>(); for (int i = 0; i < 8; i++) { var entry = new PriceEntryVm(); Prices.Add(entry); entry.BuyOrders.CollectionChanged += OnOrderChanged; entry.SellOrders.CollectionChanged += OnOrderChanged; entry.Price = (decimal)110.91 + (decimal)i / 100; var numBuy = rnd.Next(5); for (int orderIndex = 0; orderIndex < numBuy; orderIndex++) { var order = new OrderVm(); order.Qty = rnd.Next(70) + 5; entry.BuyOrders.Add(order); } var numSell = rnd.Next(5); for (int orderIOndex = 0; orderIOndex < numSell; orderIOndex++) { var order = new OrderVm(); order.Qty = rnd.Next(70) + 5; entry.SellOrders.Add(order); } } }
public async Task <ActionResult <OrderVm> > GetOrderById(int id) { var order = await _context.Orders.Include(x => x.OrderDetails).FirstOrDefaultAsync(x => x.Id == id); if (order == null) { return(NotFound()); } List <OrderDetailVm> listOrderDetail = new(); foreach (var oddt in order.OrderDetails) { var oddtVm = new OrderDetailVm { ProductId = oddt.ProductId, Quantity = oddt.Quantity, UnitPrice = oddt.UnitPrice, }; listOrderDetail.Add(oddtVm); } var orderVm = new OrderVm { Status = order.Status, Id = order.Id, CraeteDate = order.CraeteDate, UserId = order.UserId, TotalPrice = order.TotalPrice, orderDetailVms = listOrderDetail }; return(orderVm); }
public ActionResult Process(OrderVm order) { if (ModelState.IsValid && pr.ProccessOrder(order)) { return(RedirectToAction("Succes")); } return(View("Index", order)); }
public async void Handle(ViewOrderEvent message) { await Activate().ConfigureAwait(false); OrderVm order = Orders.SingleOrDefault(entry => entry.Order.InvType.TypeId == message.InvType.TypeId); FocusedOrder = order; SelectedOrder = order; }
public static EditOrderCommand FromOrder(OrderVm order) { return(new EditOrderCommand() { OrderId = order.OrderId, Customer = order.Customer, IsGiftWrap = order.GiftWrap, Shipped = order.Shipped }); }
public async Task <Option <long, Error> > CreateAsync(OrderVm model) { var entity = Mapper.Map <OrderVm, Order>(model); await DbContext.Orders.AddAsync(entity); await DbContext.SaveChangesAsync(); return((await _orderItemsService.CreateRangeByUserIdAndOrderIdAsync(model.UserId, entity.Id)) .FlatMap(oi => entity.Id.Some <long, Error>())); }
private Order CreateOrder(OrderVm order, Customer cus) { return(new Order() { Date = DateTime.Now, fk_Client = cus.Id, Paymentmethod = order.PayemntMethod, Status = 1, }); }
public static void Send(OrderVm orderVm) { string caller = orderVm.CallerFirstName + " " + orderVm.CallerLastName; string message = string.Format("Dear {0}, We have received your Move Order #({1}). It will be completed soon.Encore Piano Moving.", caller, orderVm.OrderNumber); string callerNumber = orderVm.CallerPhoneNumber; if (!string.IsNullOrEmpty(callerNumber)) { Send(callerNumber, message); } }
private Customer CreateCustomer(OrderVm order) { return(new Customer() { Name = order.Name, lastName = order.Lastname, Prefix = order.Prefix, Email = order.Email, Createdon = DateTime.Now }); }
public OrderController() { _repositryOrder = new OrderDao(); _repositryShipping = new ShippingMethodDao(); _repositryPaymentMethod = new PaymentMethodDao(); _vm = new OrderVm(); _reposProduct = new ProductDAO(); _repositoryUser = new CustomerDAO(); _repositoryCountry = new CountryDAO(); _repositryOrderProductVariant = new OrderProductVariantDao(); }
public async Task <IHttpActionResult> Post(OrderVm orderVm) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } var order = await _orderRepository.CreateAsync(orderVm); return(Created(order)); }
public void AddOrder(OrderVm order) { var _order = new Order { CustomerId = order.CustomerId, Customer = _context.Customers.FirstOrDefault(n => n.Id == order.CustomerId), OrderDateTime = DateTime.Now }; _context.Order.Add(_order); _context.SaveChanges(); }
public ActionResult Checkout() { var cartCookie = CheckCart(); if (cartCookie.Value != "") { this.LoadDefaultMetaSEO(); var model = new OrderVm(); return(View(model)); } return(RedirectToAction("Index", "Tour")); }
public OrderVm AddOrderItem(OrderVm orderVm, string username) { if (orderVm == null) { throw new Exception("Order item is null"); } var bucketEntity = _dbContext.Orders .Include(o => o.Items) .ThenInclude(c => c.Coffee) .Where(o => o.ClientId == username) .FirstOrDefault(o => o.IsPaymentCompleted == false); if (bucketEntity == null) { bucketEntity = new Order(); bucketEntity.IsPaymentCompleted = false; bucketEntity.ClientId = username; bucketEntity.Items = new List <OrderItem>(); bucketEntity.PostalCode = String.Empty; bucketEntity.Street = String.Empty; bucketEntity.City = String.Empty; bucketEntity.HouseNumber = String.Empty; bucketEntity.PaymentCard = String.Empty; _dbContext.Orders.Add(bucketEntity); _dbContext.SaveChanges(); bucketEntity = _dbContext.Orders .Include(o => o.Items) .ThenInclude(c => c.Coffee) .Where(o => o.ClientId == username) .FirstOrDefault(o => o.IsPaymentCompleted == false); } OrderItem orderItem = Mapper.Map <OrderItem>(orderVm); orderItem.OrderId = bucketEntity.Id; orderItem.PaymentStatus = (PaymentStatus)1; // Set price double price = 0; price += orderItem.MilkCount * 1; price += orderItem.EspressoCount * 1.5; orderItem.Price = price; _dbContext.OrderItems.Add(orderItem); _dbContext.SaveChanges(); return(orderVm); }
public IActionResult NewOrder() { ViewBag.Customers = _settingsBlProvider.GetCustomers() .Select(t => new SelectModel() { label = t.Name, value = t.Id }).ToList(); var orderVm = new OrderVm(); return(PartialView("_NewOrder", orderVm)); }
public async Task <OrderVm> PlaceOrderAsync(OrderVm order) { var vm = AutoMapper.Mapper.Map <OrderVm, Order>(order); long existingOrder = 0; var countTask = Task.Factory.StartNew(() => existingOrder = CountPendingOrders().Result); countTask.Wait(); vm.SetEstimatedReadyTime(existingOrder); var dm = await _orderRepository.Add(vm); dm.ProcessOrder(dm, _eventPublisher); return(AutoMapper.Mapper.Map <Order, OrderVm>(dm)); }