public async Task <IActionResult> PlaceOrder([FromBody] OrderForCreateDto orderForCreateDto)
{
var order = _mapper.Map <Order>(orderForCreateDto);
if (Request.Headers.ContainsKey("id"))
{
var user = await _repo.GetUserById(int.Parse(Request.Headers["id"].First()));
user.Orders.Add(order);
}
foreach (var item in orderForCreateDto.ListOfOrderDetailDto)
{
var orderDetail = new OrderDetail();
var product = await _repo.GetProductById(item.ProductId);
orderDetail.PricePerUnit = item.PricePerUnit;
orderDetail.Quantity = item.Quantity;
orderDetail.Product = product;
orderDetail.ProductShortName = item.ProductShortName;
order.OrderDetails.Add(orderDetail);
}
_repo.Add(order);
if (await _repo.SaveAll())
{
return(CreatedAtRoute(nameof(GetOrderById), new { controller = "Order", id = order.Id }, order));
}
throw new Exception($"Error, cannot create your order");
}
private Order Map(OrderForCreateDto orderForCreateDto)
{
var order = new Order
{
CartId = orderForCreateDto.CartId,
CreatedAt = orderForCreateDto.CreatedAt,
Item = orderForCreateDto.Item,
OrderStatus = orderForCreateDto.OrderStatus,
Products = orderForCreateDto.Products,
UserId = orderForCreateDto.UserId
};
return(order);
}
public async Task <ActionResult <Order> > CreateOrder(OrderForCreateDto orderDto)
{
var email = HttpContext.User?.RetrieveEmail();
var address = _mapper.Map <Address>(orderDto.ShipToAddress);
var order = await _orderService.CreateOrderAsync(email, orderDto.DeliveryMethodId, orderDto.BasketId, address);
if (order == null)
{
return(ApiResponse.BadRequest("Failed to create order"));
}
return(Ok(order));
}
public async Task <IActionResult> PlaceOrder(OrderForCreateDto orderForCreate)
{
if (ModelState.IsValid)
{
var bookId = Guid.Parse(orderForCreate.BookId);
var book = await _booksRepository.GetItemByIdAsync(bookId);
var user = await _userManager.FindByNameAsync(orderForCreate.UserName);
var existingOrder = _repository.FindItemAsync(
o => o.UserId == user.Id &&
o.BookId == bookId &&
o.OrderDate.ToShortDateString() == DateTime.Today.ToShortDateString());
if (existingOrder != null)
{
_logger.LogWarning($"This user {user.Id} has already order book with id {bookId} today.");
}
var order = new Order
{
Id = GuidCreator.CreateGuid(),
BookId = book.Id,
UserId = user.Id,
OrderCost = book.Cost,
OrderDate = DateTime.UtcNow,
DeliveryAdress = $"city:{user.City}, adress(post office #): {user.DeliveryAdress}."
};
var result = await _repository.AddItemAsync(order);
if (result > 0)
{
_logger.LogInformation($"New book with id {order.Id} successfully created.");
return(Ok());
}
_logger.LogError($"Failed to place new order, order info: bookId {book.Id}, userId {user.Id}.");
return(StatusCode(500));
}
_logger.LogError("Invalid request model, some fields are missed or have invalid format.");
return(BadRequest(ModelState.Values));
}
public async Task <IActionResult> CreateOrder([FromBody] OrderForCreateDto order)
{
if (!ModelState.IsValid)
{
_logger.LogError($"Invalid model state for the OrderForCreateDto object");
return(UnprocessableEntity(ModelState));
}
if (order == null)
{
_logger.LogError("OrderForCreateDto object sent from client is null. ");
return(BadRequest("OrderForCreateDto object is null"));
}
var orderEntity = _mapper.Map <Order>(order);
await _serviceManager.Order.CreateOrderAsync(orderEntity);
await _serviceManager.SaveAsync();
var orderToReturn = _mapper.Map <OrderDto>(orderEntity);
return(CreatedAtRoute("OrderById", new { id = orderToReturn.Id }, orderToReturn));
}
// [ValidateAntiForgeryToken]
public async Task <IActionResult> CreateOrder(int productId, OrderForCreateDto orderForCreateDto)
{
var userFromRepo = await _repo.GetUser(int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value));
if (userFromRepo.Id != int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value))
{
return(Unauthorized());
}
orderForCreateDto.UserId = userFromRepo.Id;
var orderToCreate = _mapper.Map <Order>(orderForCreateDto);
orderToCreate.OrderDate = DateTime.Now;
orderToCreate.Status = "Pending";
orderToCreate.ToAddress = userFromRepo.Address;
userFromRepo.Orders.Add(orderToCreate);
await _repo.SaveAll();
return(Ok());
}
public async Task <IActionResult> PlaceOrder(OrderForCreateDto orderForCreateDto, int userId)
{
var currentLoggedInUser = Convert.ToInt32(User.FindFirst(ClaimTypes.NameIdentifier).Value);
var userFromRepo = await _unitOfWork.UserRepository.GetUser(currentLoggedInUser);
if (currentLoggedInUser != userId)
{
return(Unauthorized());
}
var notAvaibleProducts = await _unitOfWork.ProductRepository.
GetProductQuantityLessThanZero(orderForCreateDto.Products);
if (notAvaibleProducts != null)
{
var notAvaiableProductNames = _unitOfWork.ProductRepository
.GetNotAviableProductNames(ref notAvaibleProducts);
return(StatusCode(424, new { Message, notAvaiableProductNames, notAvaibleProducts }));
}
var order = Map(orderForCreateDto);
try
{
order.Products = orderForCreateDto.Products;
await _unitOfWork.GenericOrderRepository.Create(order);
userFromRepo.Orders.Add(order);
await _unitOfWork.UserRepository.UpdateUserInfo(userFromRepo, currentLoggedInUser);
await _unitOfWork.SaveChangesAysnc();
return(StatusCode(201));
}
catch (Exception)
{
throw;
}
}
public async Task <IActionResult> CreateOrder(OrderForCreateDto orderForCreate)
{
var userId = User.FindFirst(ClaimTypes.NameIdentifier).Value;
var user = await _userManager.FindByIdAsync(userId);
float totalPrice = 0;
var order = new Order
{
NumberOfItems = orderForCreate.OrderProducts.Count,
UserId = user.Id
};
_productService.Add(order);
await _productService.SaveAll();
for (int i = 0; i < orderForCreate.OrderProducts.Count; i++)
{
var orderProduct = new OrderProducts
{
OrderId = order.OrderId,
ProductId = orderForCreate.OrderProducts[i].Product.ProductId,
Quantity = orderForCreate.OrderProducts[i].Quantity,
};
totalPrice += orderForCreate.OrderProducts[i].Product.UnitPrice * orderForCreate.OrderProducts[i].Quantity;
_productService.Add(orderProduct);
}
order.TotalPrice = totalPrice;
if (await _productService.SaveAll())
{
return(CreatedAtRoute("GetOrder", new { controller = "Orders", id = order.OrderId }, order));
}
return(BadRequest($"Error while saving {order.OrderId}"));
}
public PlaceNewOrderCommand(OrderForCreateDto order)
{
OrderToCreateDto = order;
}
public async Task <ActionResult <OrderDto> > CreateOrderForCustomer(int customerID, OrderForCreateDto orderForCreateDto)
{
//Change status to waiting for treatment of order
orderForCreateDto.StatusID = 1;
_orm.OpenConn();
if (!await _orm.CustomerExist(customerID))
{
return(NotFound());
}
Order orderFromDB = _mapper.Map <Order>(orderForCreateDto);
orderFromDB.CustomerID = customerID;
Order result = await _orm.CreateOrderAndOrderLines(orderFromDB);
OrderDto orderDto = _mapper.Map <OrderDto>(result);
await _orm.CloseConn();
return(CreatedAtRoute("GetOrder", new { customerID = customerID, orderID = orderDto.Ordernumber }, orderDto));
}
public async Task <IActionResult> CreateOrder(OrderForCreateDto orderForCreateDto)
{
var result = await Mediator.Send(new PlaceNewOrderCommand(orderForCreateDto));
return(HandleResult(result));
}
