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));
}
