public IActionResult Create(CreateOrderInputModel model) { if (!ModelState.IsValid) { return(RedirectToAction("Error", "Orders")); } var employee = this.context.Employees .FirstOrDefault(e => e.Name == model.EmployeeName); var item = this.context.Items .FirstOrDefault(i => i.Name == model.ItemName); var order = this.mapper.Map <Order>(model); order.DateTime = DateTime.Now; order.Type = Enum.Parse <OrderType>(model.OrderType); order.Employee = employee; order.OrderItems.Add(new OrderItem() { Item = item, Order = order, Quantity = model.Quantity }); this.context.Orders.Add(order); this.context.SaveChanges(); return(this.RedirectToAction("All", "Orders")); }
public async Task <CreateOrderInputModel> AddBasketContentToOrderByUserAsync(string username) { var user = await this.GetUserWithAllPropertiesAsync(username); var order = new CreateOrderInputModel { User = this.mapper.Map <CreateOrderUserInputModel>(user), Products = this.mapper.Map <ICollection <CreateOrderProductInputModel> >(user.Basket.BasketItems) }; if (order.Products.Count == ServicesConstants.InvalidProductsCountInOrder) { throw new ServiceException(string.Format(ExceptionMessages.InvalidBasketContent, user.Id)); } if (user.Address != null) { order.DeliveryAddress = new CreateOrderAddressInputModel { Id = user.Address.Id, StreetName = user.Address.StreetName, StreetNumber = user.Address.StreetNumber, City = new CreateOrderCityInputModel { Id = user.Address.City.Id, Name = user.Address.City.Name, PostCode = user.Address.City.PostCode } }; } return(order); }
public async Task <int> StartCompletingUserOderAsync(string username, CreateOrderInputModel model) { var user = await this.GetUserWithAllPropertiesAsync(username); var order = this.mapper.Map <Order>(model); order.KeepFitUser = user; order.ReceiverFullName = user.FullName; order.ReceiverPhoneNumber = user.PhoneNumber; order.DeliveryAddress = user.Address; order.Products = this.mapper.Map <ICollection <ProductOrder> >(user.Basket.BasketItems); if (order.Products.Count == ServicesConstants.InvalidProductsCountInOrder) { throw new ServiceException(string.Format(ExceptionMessages.InvalidBasketContent, user.Id)); } var basketPriceWithoutDelivery = await this.basketService.GetBasketTotalPriceAsync(username); this.CalculateDeliveryPrice(order, basketPriceWithoutDelivery); order.TotalPrice = basketPriceWithoutDelivery + order.DeliveryPrice; this.CalculateDeliveryDate(order); this.context.Orders.Add(order); await this.context.SaveChangesAsync(); return(order.Id); }
public async Task <IActionResult> Create(CreateOrderInputModel input) { if (!this.ModelState.IsValid) { return(this.View(input)); } await this.ordersService.CreateAsync(input); var htmlUser = new StringBuilder(); htmlUser.AppendLine($"<h1>Здравейте {input.Name} {input.Surname}!</h1>"); htmlUser.AppendLine($"<h1>Вие си поръчахте хороскоп</h1>"); htmlUser.AppendLine($"<h1>Ще се свържем с вас на телефон {input.Phone} и на имейл {input.Email} за повече информация</h1>"); await this.emailSender.SendEmailAsync( GlobalConstants.SystemEmail, GlobalConstants.SystemName, input.Email, input.Name, htmlUser.ToString()); var htmlAdmin = new StringBuilder(); htmlAdmin.AppendLine($"<h1>Клиент {input.Name} {input.Surname} ви поръча хороскоп!</h1>"); htmlAdmin.AppendLine($"<h1>телефон {input.Phone} имейл {input.Email}</h1>"); await this.emailSender.SendEmailAsync( GlobalConstants.SystemEmail, GlobalConstants.SystemName, GlobalConstants.SystemEmail, GlobalConstants.SystemName, htmlAdmin.ToString()); return(this.RedirectToAction("ThankYou")); }
public async Task <bool> CreateOrderAsync(CreateOrderInputModel input) { var product = this.productsRepository.All().FirstOrDefault(x => x.Id == input.ProductId); var picture = this.pictureRepository.All().FirstOrDefault(x => x.ProductId == product.Id).Url; if (product != null && input.Quantity > 0) { var order = new Order() { UserId = input.UserId, Product = product, ProductId = product.Id, PicUrl = picture, Color = input.Color, Size = input.Size, Quantity = input.Quantity, TotalPrice = product.Price * input.Quantity, CreatedOn = DateTime.Now, IsDeleted = false, }; this.ordersRepository.Add(order); await this.ordersRepository.SaveChangesAsync(); return(true); } throw new InvalidOperationException(GlobalConstants.CreateOrderError); }
public IActionResult Create(CreateOrderInputModel model) { if (!ModelState.IsValid) { return(RedirectToAction("Error", "Home")); } var order = mapper.Map <Order>(model); order.DateTime = DateTime.Now; Enum.TryParse(model.OrderType, out OrderType orderType); order.Type = orderType; var item = context.Items.FirstOrDefault(i => i.Name == model.ItemName); var employee = context.Employees.FirstOrDefault(e => e.Name == model.EmployeeName); order.Employee = employee; order.OrderItems.Add(new OrderItem { Order = order, ItemId = item.Id, Quantity = model.Quantity }); context.Orders.Add(order); context.SaveChanges(); return(this.RedirectToAction("All", "Orders")); }
public IActionResult Create(CreateOrderInputModel model) { var employee = this.context.Employees .FirstOrDefault(e => e.Name == model.EmployeeName); var item = this.context.Items .FirstOrDefault(i => i.Name == model.ItemName); var order = mapper.Map <Order>(model); order.Type = Enum.Parse <OrderType>(model.OrderType); order.Employee = employee; order.EmployeeId = employee.Id; order.DateTime = DateTime.Now; order.TotalPrice = model.Quantity * item.Price; order.OrderItems.Add(new OrderItem { ItemId = item.Id, Quantity = model.Quantity, Order = order }); this.context.Orders.Add(order); this.context.SaveChanges(); return(this.RedirectToAction("All")); }
public async Task <IActionResult> AddToFavourites([FromBody] CreateOrderInputModel input) { if (this.ModelState.IsValid) { try { var user = this.accountService.GetById(input.ApplicationUserId); input.ApplicationUser = user; var result = await this.orderService.AddToFavouriteOrder(input); if (result != null) { //await this.hub.Clients.All.BroadcastMessage(); return(this.Ok(result)); } } catch (Exception e) { return(this.BadRequest(e.Message)); } } return(this.BadRequest("Failed to create order")); }
public IActionResult Create(CreateOrderInputModel model) { if (!ModelState.IsValid) { return(RedirectToAction("Error", "Home")); } var order = this.mapper.Map <Order>(model); var orderItem = new OrderItem() { Order = order, ItemId = model.ItemId, Quantity = model.Quantity }; this.context.OrderItems.Add(orderItem); order.OrderItems.Add(orderItem); order.DateTime = DateTime.Now; this.context.Orders.Add(order); this.context.SaveChanges(); return(this.RedirectToAction("All", "Orders")); }
public IActionResult Create(CreateOrderInputModel model) { if (!ModelState.IsValid) { return(RedirectToAction("Error", "Home")); } var order = mapper.Map <Order>(model); var employee = this.context.Employees.FirstOrDefault(x => x.Name == model.Employee); order.EmployeeId = employee.Id; var item = this.context.Items.FirstOrDefault(x => x.Name == model.Item); order.Type = Enum.Parse <OrderType>(model.Type); order.OrderItems.Add(new OrderItem { ItemId = item.Id, Order = order, Quantity = model.Quantity }); context.Orders.Add(order); context.SaveChanges(); return(this.RedirectToAction("All", "Orders")); }
public async Task StartCompletingOrder_ShouldWork(string deliveryType, int deliveryPrice) { this.Initialize(); this.SeedProducts(); this.SeedUsers(); this.SeedAddresses(); this.SeedBasketItemsToUser(); var input = new CreateOrderInputModel() { PaymentType = PaymentType.Cash, DeliveryType = deliveryType, }; var orderId = await this .service .StartCompletingUserOderAsync(UserOneName, input); var order = this.context.Orders.First(x => x.Id == orderId); Assert.Equal(OrderTotalPrice + deliveryPrice, order.TotalPrice); Assert.Equal(PaymentType.Cash, order.PaymentType); Assert.Equal(OrderStatus.NotPayed, order.Status); Assert.Equal(FullName, order.KeepFitUser.FullName); Assert.Equal(Phone, order.KeepFitUser.PhoneNumber); Assert.Equal(UserOneId, order.KeepFitUser.Id); }
public IActionResult Create(CreateOrderInputModel model) { if (this.ModelState.IsValid == false) { return(this.RedirectToAction("Error", "Home")); } Order order = this.mapper.Map <Order>(model); order.DateTime = DateTime.Now; order.Type = Enum.Parse <OrderType>(model.OrderType); order.OrderItems.Add(new OrderItem() { Quantity = model.Quantity, ItemId = model.ItemId, Order = order }); this.context.Orders.Add(order); this.context.SaveChanges(); return(this.RedirectToAction("All", "Orders")); }
public IActionResult Create(CreateOrderInputModel model) { //customer, empId, ItemId, Qty Item item = context.Items.FirstOrDefault(x => x.Name == model.ItemName); var test = model.EmployeeName; var empId = model.EmployeeName.Split('-', StringSplitOptions.RemoveEmptyEntries).TakeLast(1) .Select(int.Parse).FirstOrDefault(); var order = new Order() { Customer = model.Customer, DateTime = DateTime.Now, Type = Enum.Parse <OrderType>(model.OrderType), TotalPrice = model.Quantity * item.Price, EmployeeId = empId }; var orderItem = new OrderItem() { ItemId = item.Id, Item = item, Order = order }; context.OrderItems.Add(orderItem); context.Orders.Add(order); context.SaveChanges(); return(this.RedirectToAction("All", "Orders")); }
public async Task <string> AddToFavouriteOrder(CreateOrderInputModel input) { if (input != null) { var order = new FavouriteOrder() { ApplicationUser = input.ApplicationUser, ApplicationUserId = input.ApplicationUserId, Location = input.Location, LocationLat = input.LocationLat, LocationLong = input.LocationLong, Destination = input.Destination, DestinationLat = input.DestinationLat, DestinationLong = input.DestinationLong, IncreasePrice = input.IncreasePrice, TotalPrice = input.TotalPrice, CreatedOn = DateTime.UtcNow }; this.favOrderRepository.Add(order); await this.favOrderRepository.SaveChangesAsync(); return(order.ToString()); } throw new InvalidOperationException("Creating order failed!"); }
public IActionResult Create(CreateOrderInputModel model) { if (!ModelState.IsValid) { return(RedirectToAction("Error", "Home")); } var order = this.mapper.Map <Order>(model); var item = this.context.Items.FirstOrDefault(i => i.Id == model.ItemId); order.DateTime = DateTime.Now; order.OrderItems.Add(new OrderItem() { Item = item, Quantity = model.Quantity }); order.TotalPrice = model.Quantity * item.Price; this.context.Orders.Add(order); this.context.SaveChanges(); return(this.RedirectToAction("All", "Orders")); }
public IActionResult Create(CreateOrderInputModel model) { if (!ModelState.IsValid) { return(RedirectToAction("Error", "Home")); } var item = this.context.Items.First(i => i.Name == model.ItemName); var employee = this.context.Employees.First(i => i.Name == model.EmployeeName); var order = mapper.Map <Order>(model); order.DateTime = DateTime.Now; order.EmployeeId = employee.Id; order.OrderItems.Add(new OrderItem() { ItemId = item.Id, Quantity = model.Quantity }); this.context.Orders.Add(order); this.context.SaveChanges(); return(this.RedirectToAction("All", "Orders")); }
public IActionResult Create(CreateOrderInputModel model) { if (!ModelState.IsValid) { return(RedirectToAction("Error", "Home")); } var order = mapper.Map <Order>(model); order.DateTime = DateTime.Now; OrderType orderType = Enum.Parse <OrderType>(model.OrderType); order.Type = orderType; context.Orders.Add(order); context.SaveChanges(); order.OrderItems.Add(new OrderItem() { ItemId = model.ItemId, OrderId = order.Id, Quantity = model.Quantity }); context.SaveChanges(); return(this.RedirectToAction("All", "Orders")); }
public ActionResult Create([FromForm] int courseId) { try { var course = this.courseService.GetCourseById <DetailsCourseViewModel>(courseId); var userId = this.User.FindFirstValue(ClaimTypes.NameIdentifier); var customer = this.customerService.GetCustomerByUserId(userId); var model = new CreateOrderInputModel() { CourseId = courseId, CustomerId = customer.Id, ActualPriceWhenOrder = course.Price }; var order = this.orderService.Create(model).GetAwaiter().GetResult(); return(this.RedirectToAction("Details", "Orders", new { Area = "", id = order.Id })); } catch (Exception error) { //todo handle exceptions with filter and log it return(this.View("_Error", error)); } }
public async Task <IActionResult> ProceedToOrder(CreateOrderInputModel input) { var user = await this.userManager.GetUserAsync(this.User); await this.ordersService.CreateOrderAsync(user.Id, input.Address); return(this.Redirect("/Orders/CompletedOrder")); }
public IActionResult Create(CreateOrderInputModel model) { CreateOrderDto order = this.mapper.Map <CreateOrderDto>(model); this.orderService.Create(order); return(this.RedirectToAction("All", "Orders")); }
public async Task <Order> Create(CreateOrderInputModel model) { var order = Mapper.Map <Order>(model); await this.orderRepository.AddAsync(order); await this.orderRepository.SaveChangesAsync(); return(order); }
public IActionResult Create() { var categories = this.categoriesService.GetAll <CategoryDropDowwViewModel>(); var viewModel = new CreateOrderInputModel { Categories = categories, }; return(this.View(viewModel)); }
public IActionResult Create(CreateOrderInputModel model) { if (!ModelState.IsValid) { return(RedirectToAction("Error", "Home")); } var oreder = this.mapper.Map <Order>(model); return(this.RedirectToAction("All", "Orders")); }
public async Task <ActionResult <CreateOrderOutputModel> > Create(CreateOrderInputModel input) { var result = await this.orderService.CreateAsync(input, this.currentUserService.UserId); if (!result.Succeeded) { return(BadRequest(result.Errors)); } return(new CreateOrderOutputModel(result.Data)); }
public IActionResult Create(CreateOrderInputModel model) { if (!ModelState.IsValid) { return(RedirectToAction("Error", "Home")); } Order newOrder = mapper.Map <Order>(model); context.Orders.Add(newOrder); context.SaveChanges(); return(RedirectToAction("All", "Orders")); }
public IActionResult Create(CreateOrderInputModel model) { var order = this.mapper.Map <Order>(model); var orderItem = this.mapper.Map <OrderItem>(model); order.OrderItems.Add(orderItem); this.context.Orders.Add(order); this.context.SaveChanges(); return(this.RedirectToAction("All", "Orders")); }
public async Task <IActionResult> Create(CreateOrderInputModel createOrderInputModel) { if (!ModelState.IsValid) { return(RedirectToAction(nameof(Create), createOrderInputModel)); } decimal deliveryPrice = this.supplierService.GetDeliveryPrice(createOrderInputModel.SupplierId, createOrderInputModel.ShippingTo); var orderServiceModel = createOrderInputModel.To <OrderServiceModel>(); var order = await this.orderService.CreateAsync(orderServiceModel, this.User.Identity.Name, deliveryPrice); return(this.RedirectToAction(nameof(Complete), new { id = order.Id })); }
public async Task <Result <int> > CreateAsync(CreateOrderInputModel input, string userId) { try { var orderLines = input.OrderLines .Select(x => new OrderLine { ProductId = x.ProductId, Quantity = x.Quantity }) .ToList(); var order = new Order { UserId = userId, OrderLines = orderLines, PhoneNumber = input.PhoneNumber, Address = input.Address, Status = OrderStatus.New }; var messageData = new OrderCreatedMessage { Products = orderLines.Select(ol => new OrderCreatedProduct { ProductId = ol.ProductId, Quantity = ol.Quantity }).ToList() }; var message = new Message(messageData); await this.SaveAsync(order, message); await this.publisher.Publish(messageData); await this.MarkMessageAsPublished(message.Id); return(Result <int> .SuccessWith(order.Id)); } catch (Exception e) { var errorMessage = "Failed to save order"; this.logger.LogError(e, errorMessage); return(Result <int> .Failure(new [] { errorMessage })); } }
public IActionResult Create(CreateOrderInputModel model) { if (!ModelState.IsValid) { return(RedirectToAction("Error", "Home")); } var orders = this.mapper.Map <Order>(model); this.context.Orders.Add(orders); this.context.SaveChanges(); return(this.RedirectToAction("All", "Orders")); }
public async Task StartCompletingOrderInvalidProducts_ShouldThrow() { this.Initialize(); this.SeedProducts(); this.SeedUsers(); this.SeedAddresses(); var input = new CreateOrderInputModel() { PaymentType = PaymentType.Cash, DeliveryType = DeliveryType.Express.ToString(), }; await Assert.ThrowsAsync <ServiceException>(() => this.service.StartCompletingUserOderAsync(UserOneName, input)); }