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