public void Map_OrderResponse_CorrectOrderId()
{
var src = new OrderResponseDto {
OrderDetails = new ResponseOrderDto {
OrderId = Guid.NewGuid()
}
};
var dest = _mapper.Map <OrderResponse>(src);
Assert.Equal(src.OrderDetails.OrderId, dest.OrderDetails.OrderId);
}
public async Task <IActionResult> AddOrder(OrderRequestDto order)
{
int userId = Convert.ToInt32(HttpContext.Items["userId"]);
OrderResponseDto orderResponse = await _service.Add(order, userId);
return(Ok(new Response <OrderResponseDto>
{
StatusCode = (int)HttpStatusCode.OK,
Message = ResponseMessage.SUCCESSFUL,
Data = orderResponse
}));
}
public async Task <ActionResult <OrderResponseDto> > Get(string id)
{
var order = await _orderRepository.GetById(id);
var response = new OrderResponseDto {
Id = order.Id,
DateOrdered = order.DateOrdered,
User = _mapper.Map <UserResponseDto>(await _userRepository.GetById(order.UserId)),
Menu = await _menuRepository.GetById(order.MenuId),
DailyChoice = await _dailyChoiceRepository.GetById(order.DailyChoiceId)
};
return(Ok(response));
}
public async Task <OrderResponseDto> Add(int userId, int bookId, int quantity, int addressId, string guid)
{
OrderResponseDto orderResponse = null;
using (SqlConnection connection = _dBContext.GetConnection())
{
await connection.OpenAsync();
var transaction = await connection.BeginTransactionAsync();
try {
SqlCommand command = new SqlCommand("sp_orders_create", connection, (SqlTransaction)transaction)
{
CommandType = System.Data.CommandType.StoredProcedure
};
command.Parameters.AddWithValue("@userId", userId);
command.Parameters.AddWithValue("@bookId", bookId);
command.Parameters.AddWithValue("@quantity", quantity);
command.Parameters.AddWithValue("@addressId", addressId);
command.Parameters.AddWithValue("@guid", guid);
using (SqlDataReader reader = await command.ExecuteReaderAsync())
{
while (await reader.ReadAsync())
{
orderResponse = new OrderResponseDto();
orderResponse.Book = _booksRepository.MapReaderTobook(reader);
orderResponse.User = _userRepository.MapUserFromReader(reader, "userId");
orderResponse.Address = MapReaderToAddressDto(reader);
orderResponse.OrderedDate = Convert.ToDateTime(reader["ordertime"]);
orderResponse.Quantity = (int)reader["orderedQuantity"];
orderResponse.OrderId = (string)reader["orderId"];
}
}
await transaction.CommitAsync();
await connection.CloseAsync();
}
catch
{
await transaction.RollbackAsync();
throw;
}
finally
{
await connection.CloseAsync();
}
}
return(orderResponse);
}
public void Map_OrderResponse_CorrectOrderItemPrice()
{
decimal price = Factory.GetInteger();
var src = new OrderResponseDto {
OrderDetails = new ResponseOrderDto {
OrderItems = new[] { new OrderItemExtendedDto {
GrossUnitPrice = price
} }
}
};
var dest = _mapper.Map <OrderResponse>(src);
Assert.Equal(price, dest.OrderDetails.OrderItems.First().GrossUnitPrice);
}
public void Map_OrderResponse_CorrectOrderItemLineNumber()
{
int lineNumber = Factory.GetInteger();
var src = new OrderResponseDto {
OrderDetails = new ResponseOrderDto {
OrderItems = new[] { new OrderItemExtendedDto {
LineNumber = lineNumber
} }
}
};
var dest = _mapper.Map <OrderResponse>(src);
Assert.Equal(lineNumber, dest.OrderDetails.OrderItems.First().LineNumber);
}
public async Task <ActionResult <OrderResponseDto> > GetUserOrder(int id)
{
string buyerEmail = HttpContext.User.GetUserEmail();
Order order = await _orderService.GetOrderAsync(id, buyerEmail);
if (order == null)
{
return(NotFound(new ApiErrorResponse(404, $"order no. {id} was not found")));
}
else
{
OrderResponseDto response = _mapper.Map <OrderResponseDto>(order);
return(Ok(response));
}
}
public async Task <IActionResult> GetOrderAsync(string id)
{
try
{
var customer = await _orderHandler.GetCustomerAsync(id);
var tickets = await _orderHandler.GetOrderedTicketsAsync(id);
if (tickets.Count() == 0)
{
return(OnNotFoundError($"No tickets found related to the order with the given ID: '{id}'."));
}
var customerDto = MapToDto(customer);
var ticketDto = MapToDtoEnumerable(tickets);
var order = new OrderResponseDto {
Id = id, Customer = customerDto, Tickets = ticketDto
};
var response = new ResponseWrapper(order);
return(Ok(response));
}
catch (ArgumentNullException ex)
{
return(OnInvalidParameterError($"Passed '{nameof(id)}' is invalid", ex));
}
catch (FormatException ex)
{
return(OnInvalidParameterError($"Passed '{nameof(id)}' has invalid format. {ex.Message}", ex));
}
catch (InvalidOperationException ex)
{
return(OnNotFoundError($"'{nameof(Customer)}' or '{nameof(Ticket)}' not found.", ex));
}
catch (InternalDbServiceException ex)
{
LogInternalDbServiceException(ex);
throw;
}
catch (Exception ex)
{
LogUnexpectedException(ex);
throw;
}
}
public async Task <OrderResponseDto> Add(OrderRequestDto orderRequest, int userId)
{
try {
var guid = Guid.NewGuid();
OrderResponseDto order = await _repository.Add(userId, orderRequest.bookId, orderRequest.quantity, orderRequest.addressId, guid.ToString());
await _cacheRepository.DeleteAsync(userId.ToString(), orderRequest.bookId);
Message message = new Message(new string[] { order.User.Email },
"Order successfully placed!",
$"{_emailItems.ItemDetailHtml(order.Book.Title, order.Book.Author, order.Book.Image, order.Book.Price, order.Book.Quantity)+ _emailItems.OrderDetailHtml(order.OrderId, order.OrderedDate, order.Book.Price)}");
_mqServices.AddToQueue(message);
return(order);
}
catch (SqlException e) when(e.Number == SqlErrorNumbers.CONSTRAINT_VOILATION)
{
throw new BookstoreException("Invalid user!");
}
}
