public IActionResult OneClickOrder(CreateOrderViewModel input)
{
var receiverEmail = new MailAddress("*****@*****.**", "Receiver");
var senderEmail = new MailAddress("*****@*****.**", "Sender");
var password = "******";
var sub = "Поръчка: " + input.Name;
var body = "Имена: " + input.Name + " Адрес: " + input.Adress + " Телефон: " + input.Telephone + " Имейл: " + input.Email;
var smtp = new SmtpClient
{
Host = "smtp.gmail.com",
Port = 587,
EnableSsl = true,
DeliveryMethod = SmtpDeliveryMethod.Network,
UseDefaultCredentials = false,
Credentials = new NetworkCredential(senderEmail.Address, password),
};
using (var mess = new MailMessage("*****@*****.**", "*****@*****.**")
{
Subject = sub,
Body = body,
})
{
smtp.Send(mess);
}
return(this.RedirectToAction("ById", "BedSets", new { id = input.ProductId }));
}
public IActionResult Index()
{
_shopCart.ListShopItems = _shopCart.getShopItems();
if (_shopCart.ListShopItems.Count == 0)
{
ModelState.AddModelError("", "У вас должны быть товары в корзине!");
return(RedirectToAction("Index", "ShopCart"));
}
CreateOrderViewModel order = new CreateOrderViewModel();
order.Price = _shopCart.cPrice(_shopCart.getShopItems());
string userId = HttpContext.Session.GetString("UserId");
UserData user = new UserData();
user = _context.UserData.FirstOrDefault(u => u.Id == userId);
order.UserDataId = new Guid(user.Id);
order.Name = user.Name;
order.Surname = user.Surname;
order.Patronymic = user.Patronymic;
order.PhoneNumber = user.PhoneNumber;
order.Email = user.Email;
return(View(order));
}
/// <summary>
/// CreateAsync
/// </summary>
/// <param name="model"></param>
/// <param name="id"></param>
/// <returns></returns>
public async Task CreateAsync(CreateOrderViewModel model, string id)
{
var cartBooks = await _context.CartBooks.Where(x => x.UserId == id).ToListAsync();
var orderBooks = new List <OrderBook>();
foreach (var book in cartBooks)
{
orderBooks.Add(new OrderBook {
BookId = book.BookId, Count = book.Count
});
}
var order = new Order
{
Address = model.Address,
Comment = model.Comment,
CreateAt = DateTime.Now,
DeliveryTypeId = model.DeliveryTypeId,
OrderStateId = 1,
PaymentTypeId = model.PaymentTypeId,
UserId = id,
OrderBooks = orderBooks
};
await _context.Orders.AddAsync(order);
_context.CartBooks.RemoveRange(cartBooks);
await _context.SaveChangesAsync();
}
public async Task <IActionResult> Create(CreateOrderViewModel model)
{
if (!ModelState.IsValid)
{
return(this.RedirectToAction(actionName: "All", controllerName: "Events"));
}
var user = await this.userManager.FindByNameAsync(this.User.Identity.Name);
var @event = this.eventsService.GetById(model.EventId);
if (@event.TotalTickets < model.TicketsCount)
{
return(this.RedirectToAction(actionName: "All", controllerName: "Events"));
}
var result = this.ordersService.Create(user, @event, model.TicketsCount);
if (!result)
{
return(this.RedirectToAction(actionName: "All", controllerName: "Events"));
}
return(this.RedirectToAction(actionName: "MyEvents", controllerName: "Events"));
}
public ActionResult Get([Bind(Include = "Id")] CreateOrderViewModel model)
{
var userId = User.Identity.GetUserId();
var order = db.Orders.SingleOrDefault(o => o.BookId == model.Id && o.AplicationUserId == userId);
if (ModelState.IsValid)
{
if (order == null)
{
db.Orders.Add(new Order
{
BookId = model.Id,
AplicationUserId = User.Identity.GetUserId()
});
db.SaveChanges();
return(RedirectToAction("Index"));
}
}
Book book = db.Books.First(o => o.Id == model.Id);
var vm = Mapper.Map <BookViewModel>(book);
ModelState.AddModelError(String.Empty, "You already have this eBook.");
return(View(vm));
}
public async Task <ActionResult> Edit(CreateOrderViewModel model)
{
try
{
Customer customer = await _customerRepository.GetCustomerByNameAsync(model.CustomerName);
if (customer == null)
{
ViewBag.Error = "Customer does not Exist, Please register the customer";
//Ensure there must be a customer
return(View("Edit", model));
}
Order order = await _orderRepository.GetByIDAsync(model.OrderID);
//order.
await _orderRepository.AddCustomerToOrderAsync(model.OrderID, customer.CustomerID);
await _orderRepository.SaveAll();
// TODO: Add insert logic here
return(RedirectToAction("Index"));
}
catch
{
return(View("Edit", model));
}
}
public ActionResult Update(int id)
{
_logger.Info("Start Update(GET) - OrderController");
CheckForAuthorization();
ViewBag.Title = "Chỉnh sửa đơn đặt hàng | Nhà phân phối sữa Vitamilk | Nhà phân phối sữa hàng đầu Việt Nam";
var order = _orderService.GetOrder(id);
var model = new CreateOrderViewModel();
if (order != null)
{
model = new CreateOrderViewModel
{
idOrder = order.idOrder,
idDistributor = order.idDistributor,
distributorName = order.Distributor.name,
Total = order.Total,
PaymentType = order.PaymentType.ToString(),
DeliveryType = order.DeliveryType.ToString(),
EstimateDateOfDelivery = order.EstimateDateOfDelivery,
OrderDetails = order.OrderDetails.ToList(),
Consignee = order.Consignee,
Action = "Update",
Products = _productService.GetAllProducts(),
Statuses = order.Statuses
};
_logger.Info("Success: Complete Update(GET) - OrderController");
}
else
{
_logger.Info("Error: Update(GET) - OrderController | Can not find any order with given id!");
}
return(View("Create", model));
}
public async Task <IActionResult> Create(CreateOrderViewModel vm, int id)
{
var loggedUser = await _userManagerService.FindByNameAsync(User.Identity.Name);
if (ModelState.IsValid)
{
Order order = new Order
{
PackageId = vm.PackageId,
UserId = loggedUser.Id,
Email = vm.Email,
Mobile = vm.Mobile,
OrderDate = DateTime.Now,
DepartingDate = vm.DepartingDate,
NumberOfAdult = vm.NumberOfAdult,
Comment = vm.Comment,
IsActive = true
};
_orderRepo.Create(order);
return(RedirectToAction("Index", "Customer", new { id = loggedUser.Id }));
}
vm.PackageId = id;
vm.Package = _packRepo.GetSingle(p => p.PackageId == id);
return(View(vm));
}
public IActionResult Create(CreateOrderViewModel model)
{
if (!this.shoppingCartService.AnyProducts(this.User.Identity.Name))
{
this.TempData["error"] = ERROR_MESSAGE_TO_CONTINUE_ADD_PRODUCTS;
return(RedirectToAction("Index", "Home"));
}
if (!ModelState.IsValid)
{
return(RedirectToAction(nameof(Create)));
}
var order = this.orderService.GetProcessingOrder(this.User.Identity.Name);
if (order == null)
{
order = this.orderService.CreateOrder(this.User.Identity.Name);
}
decimal deliveryPrice = suppliersService.GetDiliveryPrice(model.SupplierId, model.DeliveryType);
this.orderService.SetOrderDetails(order, model.FullName, model.PhoneNumber, model.PaymentType, model.DeliveryAddressId.Value, deliveryPrice);
return(this.RedirectToAction(nameof(Complete)));
}
public ActionResult Update(CreateOrderViewModel model, [Bind(Prefix = "OrderDetails")] List <OrderDetail> OrderDetails)
{
_logger.Info("Start Update(POST) - OrderController");
if (GetCurrentUser() != null)
{
var order = new Order
{
idOrder = model.idOrder,
idDistributor = model.idDistributor,
Total = model.Total,
DeliveryType = Convert.ToBoolean(model.DeliveryType),
PaymentType = Convert.ToBoolean(model.PaymentType),
EstimateDateOfDelivery = model.EstimateDateOfDelivery,
Statuses = model.Statuses,
CreatedDate = DateTime.Now,
UpdatedDate = DateTime.Now,
Consignee = model.Consignee,
idConsignee = model.Consignee.idConsignee,
OrderDetails = model.OrderDetails,
idStaff = model.idStaff
};
var result = _orderService.UpdateOrder(order);
if (result == "thanh cong")
{
TempData["success"] = "thanh cong";
}
else
{
TempData["fail"] = result;
}
return(RedirectToAction("Update", new { id = model.idOrder }));
}
_logger.Info("Success: Complete Update(POST) - OrderController");
return(RedirectToAction("Index", "Home"));
}
public IActionResult Create()
{
if (!this.shoppingCartService.AnyProducts(this.User.Identity.Name))
{
this.TempData["error"] = ERROR_MESSAGE_TO_CONTINUE_ADD_PRODUCTS;
return(RedirectToAction("Index", "Home"));
}
var addresses = this.adressesService.GetAllUserAddresses(this.User.Identity.Name);
var addressesViewModel = mapper.Map <IList <OrderAdressViewModel> >(addresses);
var user = this.usersService.GetUserByUsername(this.User.Identity.Name);
var fullName = $"{user.FirstName} {user.LastName}";
var suppliers = this.suppliersService.All();
var supplierViewModels = mapper.Map <IList <SupplierViewModel> >(suppliers);
var createOrderViewModel = new CreateOrderViewModel
{
OrderAddressesViewModel = addressesViewModel.ToList(),
FullName = fullName,
PhoneNumber = user.PhoneNumber,
SuppliersViewModel = supplierViewModels
};
return(this.View(createOrderViewModel));
}
//Send email to confirm that the order is successufuly done (not shipped yet)
public static void SendEmail(CreateOrderViewModel model, string products)
{
MailMessage mm = new MailMessage("*****@*****.**", model.Member.EmailId);
mm.Body = "Hi " + model.Member.FristName + " " + model.Member.LastName + "\n \n" +
"You have successfully made a order on PepeSurfShop! \n \n " +
"Here you can see the details of your order: \n " +
"\n" +
"\n" +
"Shipping adress : " + model.ShippingDetails.Adress + "\n" +
"City : " + model.ShippingDetails.City + "\n" +
"Country : " + model.ShippingDetails.Country + "\n" +
"\n" +
"\n" + products +
"\n" +
"Total price : " + model.ShippingDetails.AmountPaid.ToString() + "\n" +
"";
mm.Subject = "Your PepeSurfShop Order";
mm.IsBodyHtml = false;
SmtpClient smtp = new SmtpClient();
smtp.Host = "smtp.gmail.com";
smtp.Port = 587;
smtp.EnableSsl = true;
NetworkCredential nc = new NetworkCredential("*****@*****.**", "Qwerty.1234");
smtp.UseDefaultCredentials = true;
smtp.Credentials = nc;
smtp.Send(mm);
}
public async Task AddOrderAsyncTest()
{
var options = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString()).Options;
var dbContext = new ApplicationDbContext(options);
dbContext.Products.Add(new Product
{
Id = 1,
Quantity = 2,
});
dbContext.ApplicationUsers.Add(new ApplicationUser
{
Id = "TestId",
});
await dbContext.SaveChangesAsync();
var repository = new EfDeletableEntityRepository <Order>(dbContext);
var service = new OrdersService(repository);
var orderModel = new CreateOrderViewModel
{
Adress = "TestAdress",
ProductId = 1,
UserId = "TestId",
};
await service.AddOrderAsync(orderModel);
var order = repository.All().Where(a => a.ProductId == 1).FirstOrDefault();
Assert.True(service.AlreadyOrdered("TestId", 1));
Assert.Equal(DeliveryState.Ordered, order.State);
Assert.Equal("TestAdress", order.Adress);
}
public IActionResult Create(CreateOrderViewModel model)
{
if (!ModelState.IsValid)
{
PopulateCreateViewModel(model);
return(View(model));
}
try
{
model.Command.VoucherPercentageDiscount = 10;
var response = _mediator.Send(model.Command).Result;
_logger.LogInformation($"Order {response} created.");
TempData["success"] = "true";
return(RedirectToAction("Create")); // PRG (post/redirect/get) pattern
}
// Domain errors are displayed to the user, but other errors are not.
catch (Exception e) when(e is DomainException || e is AggregateException && e.InnerException is DomainException)
{
ModelState.AddModelError("", e.Message);
PopulateCreateViewModel(model);
return(View(model));
}
}
/// <summary>
/// 把ProcedToCheckout()傳回來的CreateOrderViewModel轉成對應的Order
/// 因為Order可能是「送餐到府」也有可能是「來店取餐」，所以需要做到判斷
/// </summary>
/// <param name="viewModel"></param>
/// <param name="userId"></param>
/// <returns></returns>
private Order ConvertViewModelToOrder(CreateOrderViewModel viewModel, string userId)
{
Order order = new Order()
{
UserId = userId,
OrderDateTime = DateTime.Now,
RequireDateTime = viewModel.RequireDateTime,
TotalPrice = 0,
PaymentMethodId = viewModel.PaymentMethodId,
CollectionMethodId = viewModel.CollectionMethodId,
Comment = viewModel.Comment
};
if ((viewModel.PaymentMethodId == 1) && (viewModel.IsUserRegAddress == false))
{
order.Address_AddCity = viewModel.AddCity;
order.Address_AddDistrict = viewModel.AddDistrict;
order.Address_AddFull = viewModel.AddFull;
order.Address_PostCode = viewModel.PostCode;
}
else
{
Customer customer = customerRepo.GetSingleEntity(x => x.UserId == User.Identity.Name);
order.Address_AddCity = customer.Address.AddCity;
order.Address_AddDistrict = customer.Address.AddDistrict;
order.Address_AddFull = customer.Address.AddFull;
order.Address_PostCode = customer.Address.PostCode;
}
return(order);
}
public void CanCreateNewOrder()
{
//arrange
#region arrange
CreateOrderViewModel model = new CreateOrderViewModel();
int customerId = 3;
CustomerFullData customerFullData = new CustomerFullData
{
Customer = Repositories.CustomerRepository.Customers.FirstOrDefault(c => c.CustomerId == customerId),
Addresses = Repositories.AddressRepository.Addresses.Where(a => a.CustomerId == customerId)
};
model.CustomerFullData = customerFullData;
model.SelectedAddress = customerFullData.Addresses.First();
Cart orderCart = new Cart();
orderCart.AddItem(Repositories.ProductRepository.Products.First(p => p.Name == "P1"), 1);
orderCart.AddItem(Repositories.ProductRepository.Products.First(p => p.Name == "P3"), 3);
_target.SetCart(orderCart);
#endregion
//act
RedirectToActionResult result = (RedirectToActionResult)_target.CreateOrder(model).Result;
//assert
Assert.Equal("Completed", result.ActionName);
}
public ActionResult ProcedToCheckout(CreateOrderViewModel viewModel)
{
var customer = orderRepo.GetSingleEntity(x => x.UserId == User.Identity.Name);
if (ModelState.IsValid)
{
Order order = ConvertViewModelToOrder(viewModel, User.Identity.Name);
orderRepo.Insert(order);
orderRepo.SaveChanges();
shoppingCartLogic = ShoppingCartLogic.GetShoppingCart(this.HttpContext);
order.TotalPrice = shoppingCartLogic.ShoppingCartToOrderDetails(order);
orderRepo.Update(order);
orderRepo.SaveChanges();
return(RedirectToAction("Index"));
}
viewModel.PaymentMethods = paymentMethodRepo.GetWithFilterAndOrder();
viewModel.CollectionMethods = collectionRepo.GetWithFilterAndOrder();
return(View(viewModel));
}
/// <summary>
/// Редактирование заказа
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public ActionResult Edit(int id)
{
var model = new CreateOrderViewModel();
var orderNums = new List <CreateOrderNum>();
foreach (var nomenclature in Context.Nomenclatures)
{
orderNums.Add(new CreateOrderNum
{
Name = nomenclature.Name,
Count = nomenclature.Count,
IsBuy = false
});
}
var order = Context.Orders
.Include(x => x.OrderNoms)
.Include(x => x.OrderNoms.Select(y => y.Nomenclature))
.Single(x => x.Id == id);
foreach (var orderNom in order.OrderNoms)
{
var orderNomResult = orderNums.Single(x => x.Name.Equals(orderNom.Nomenclature.Name));
orderNomResult.IsBuy = true;
orderNomResult.CountBuy = orderNom.CountInOrder;
orderNomResult.Count += orderNom.CountInOrder;
}
model.OrderNums = orderNums;
model.Adress = order.Adres;
return(View(model));
}
public async Task <IActionResult> MakeOrder(CreateOrderViewModel viewModel)
{
if (ModelState.IsValid)
{
OrderModel order = new OrderModel();
string items_string_list = "";
//When Created Id is +1 so in order of asigning it to the order item it needs to be decleared here
int orderId = _orderRepository.OrdersCount();
orderId++;
//Add right order items to the database
for (int i = 0; i < viewModel.OrderItems.Count; i++)
{
viewModel.OrderItems[i].OrderId = orderId;
order.FullItemsAmmount += viewModel.OrderItems[i].Ammount;
_orderItemRepository.Add(viewModel.OrderItems[i]);
items_string_list += $"Product: {viewModel.OrderItems[i].ProductName} | Quantity: {viewModel.OrderItems[i].Ammount} \n";
}
order.OrderDate = DateTime.Now;
order.SupplierName = viewModel.SupplierName;
_orderRepository.AddOrder(order);
SuppliersModel supplier = _supplierRepository.GetSupplier(viewModel.SupplierId);
//Send email with order
//await PostMail(supplier, order, items_string_list);
return(RedirectToAction("DisplayOrders"));
}
return(View());
}
public IActionResult OrderTickets(CreateOrderViewModel model)
{
var userId = this.User.FindFirst(ClaimTypes.NameIdentifier).Value;
this.ordersService.OrderTickets(model.EventId, userId, model.TicketsCount);
return(this.RedirectToAction("Index", "Home"));
}
public IActionResult Index(CreateOrderViewModel order)
{
_shopCart.ListShopItems = _shopCart.getShopItems();
if (ModelState.IsValid)
{
Order newOrder = new Order();
newOrder.Id = Guid.NewGuid();
string userId = HttpContext.Session.GetString("UserId");
newOrder.UserDataId = new Guid(userId);
newOrder.Name = order.Name;
newOrder.Surname = order.Surname;
newOrder.Patronymic = order.Patronymic;
newOrder.PhoneNumber = order.PhoneNumber;
newOrder.Email = order.Email;
newOrder.Address = order.Address;
newOrder.Price = order.Price;
newOrder.DateAdding = DateTime.UtcNow;
newOrder.Status = "created";
_dataManager.Orders.CreateOrder(newOrder);
return(RedirectToAction("Thanks", "UserMain"));
}
return(View(order));
}
public IActionResult Create()
{
var model = new CreateOrderViewModel();
PopulateCreateViewModel(model);
return(View(model));
}
public async Task <IActionResult> Create(CreateOrderViewModel viewModel)
{
if (ModelState.IsValid)
{
var currentEvent = await this.db
.Events.FirstOrDefaultAsync(x => x.Id == viewModel.EventId);
if (viewModel.TicketsCount > currentEvent.TotalTickets)
{
ModelState.AddModelError(string.Empty, "Event does not have enough tickets!");
return(RedirectToAction("All", "Events"));
}
currentEvent.TotalTickets -= viewModel.TicketsCount;
this.db.Events.Update(currentEvent);
var order = this.mapper.Map <CreateOrderViewModel, Order>(viewModel);
await this.db.Orders.AddAsync(order);
await this.db.SaveChangesAsync();
if (User.IsInRole("Admin"))
{
return(RedirectToAction("All", "Orders"));
}
return(RedirectToAction("MyEvents", "Events"));
}
ModelState.AddModelError(string.Empty, "Try placing your order again.");
return(RedirectToAction("All", "Events"));
}
public IActionResult Create()
{
var viewOrder = new CreateOrderViewModel
{
Items = this.context.Items
.Select(x => new
{
x.Id, x.Name
})
.ToDictionary
(
key => key.Id,
value => value.Name
),
Employees = this.context.Employees
.Select(x => new
{
x.Id, x.Name
})
.ToDictionary
(
key => key.Id,
value => value.Name
)
};
return(this.View(viewOrder));
}
public async Task <IActionResult> MakeOrder()
{
var userId = httpContextAccessor.HttpContext.User.FindFirst(ClaimTypes.NameIdentifier).Value;
var viewModel = new CreateOrderViewModel();
viewModel.Appetizers = this.context.Dishes
.Where(d => d.Type.ToLower() == "appetizer")
.Select(this.dishMapper.MapFrom)
.ToList();
viewModel.MainDishes = this.context.Dishes
.Where(d => d.Type.ToLower() == "main")
.Select(this.dishMapper.MapFrom)
.ToList();
viewModel.MainDishes = this.context.Dishes
.Where(d => d.Type.ToLower() == "dessert")
.Select(this.dishMapper.MapFrom)
.ToList();
viewModel.AvailableDays = await this.userService.GetAvailableDays(userId);
viewModel.ClientType = context.AppUsers.Find(userId).IsVIP;
return(View(viewModel));
}
public ActionResult Create()
{
CreateOrderViewModel model = new CreateOrderViewModel();
model.AvailableCustomers = GetAvailableCustomers();
return(View(model));
}
public async Task <IActionResult> Create(CreateOrderViewModel model)
{
var currentUser = await _userService.GetUserAsync(User);
await _orderService.CreateAsync(model, currentUser.Id);
return(RedirectToAction("Index", "Home"));
}
// GET: Order/Delete/5
public async Task <ActionResult> Delete(int id)
{
Order order = await _orderRepository.GetByIDAsync(id);
CreateOrderViewModel ovm = new CreateOrderViewModel(order);
return(View(ovm));
}
public async Task <ActionResult> CreateOrder(CreateOrderViewModel order)
{
await _orderService.CreateOrder(
order.CustomerId,
order.SalesPersonId,
order.SelectedProductCodes.Select(pc => Tuple.Create(pc, 1)).ToList());
return(Redirect("Index"));
}
public ActionResult MakeOrder()
{
ViewBag.Managers = new SelectList(_managerService.GetManagers(), "ManagerId", "SecondName");
ViewBag.Clients = new SelectList(_clientService.GetClients(), "ClientId", "Name");
ViewBag.Products = new SelectList(_productService.GetProducts(), "ProductId", "Name");
CreateOrderViewModel createOrderViewModel = new CreateOrderViewModel();
return(View(createOrderViewModel));
}
