public BaseResponse <GetOrderItemResponse> CreateOrderItem(string orderId, CreateOrderItemRequest request)
{
var method = HttpMethod.Post;
var endpoint = $"/orders/{orderId}/items";
return(this.HttpClientUtil.SendRequest <GetOrderItemResponse>(method, endpoint, request));
}
public async Task AddItemToOrder()
{
await RunInContext(nameof(AddItemToOrder), async (repository, context) =>
{
//arrange
var orderId = "orderId";
string name = "name";
string description = "description";
int quantity = 10;
await context.Orders.AddAsync(new OrderEntity {
UserId = UserId, Id = orderId
});
await context.SaveChangesAsync();
var request = new CreateOrderItemRequest {
Description = description, Name = name, Quantity = quantity
};
//act
var addedItem = await repository.AddItemToOrder(UserId, orderId, request);
//assert
var dbOrderItem = await context.OrderItems.FirstAsync();
Assert.Equal(dbOrderItem.Id, addedItem);
Assert.Equal(dbOrderItem.Name, name);
Assert.Equal(dbOrderItem.Description, description);
Assert.Equal(dbOrderItem.Quantity, quantity);
});
}
public bool Validate(CreateOrderItemRequest requestToValidate)
{
return(!(string.IsNullOrEmpty(requestToValidate.ItemId.ToString()) ||
string.IsNullOrEmpty(requestToValidate.OrderId.ToString()) ||
string.IsNullOrEmpty(requestToValidate.Quantity.ToString()) ||
string.IsNullOrEmpty(requestToValidate.UnitPrice.ToString())));
}
public async Task <IActionResult> Create(CreateOrderItemRequest request)
{
var mapped = request.MapToDomainRequest(_mapper);
var response = await _service.Create(mapped);
return(StatusCode(response.Code, response));
}
public void GivenTheUserCreatesARequestToAddACatalogueItemToTheOrderWithId(string catalogueItemId, int orderId, Table requestInfoTable)
{
requestInfoTable.RowCount.Should().Be(1);
createOrderItemRequest = new CreateOrderItemRequest(
orderId,
catalogueItemId,
requestInfoTable.CreateInstance <RequestInfo>(),
settings);
}
private async Task <OrderItem> GetOrderItem(CreateOrderItemRequest requestOrderDetail)
{
var productId = new ProductIdentity(requestOrderDetail.ProductId);
var product = await _productReadRepository.FindAsync(productId);
if (product == null)
{
throw new InvalidRequestException($"Product id {requestOrderDetail.ProductId} is not valid because that product does not exist");
}
var quantity = requestOrderDetail.Quantity;
return(_orderFactory.CreateNewOrderItem(product, quantity));
}
public async Task <string> AddItemToOrder(ulong userId, string orderId, CreateOrderItemRequest request)
{
var order = await GetOrder(userId, orderId);
var orderItemId = Guid.NewGuid().ToString();
var newOrderItem = new OrderItemEntity
{
Id = orderItemId,
OrderId = order.Id,
Name = request.Name,
Description = request.Description,
Quantity = request.Quantity
};
await _ordersContext.OrderItems.AddAsync(newOrderItem);
await _ordersContext.SaveChangesAsync();
return(orderItemId);
}
public async Task <Response> Create(CreateOrderItemRequest request)
{
try
{
var item = _mapper.Map <OrderItem>(request);
_repository.Add(item);
if (await _repository.SaveChangesAsync())
{
var response = _mapper.Map <OrderItemResponse>(item);
return(OkResponse(null, response));
}
return(BadRequestResponse("Erro desconhecido."));
}
catch (Exception ex)
{
return(BadRequestResponse(ex.Message));
}
}
public OrderItem AddOrderItem(CreateOrderItemRequest newOrderItemObj)
{
using (var db = new SqlConnection(ConnectionString))
{
var newOrderItemQuery = db.QueryFirstOrDefault <OrderItem>(
@"Insert into OrderItem (orderId, itemId, quantity, unitPrice, specialRequest)
Output inserted.*
Values(@orderId,@itemId,@quantity,@unitPrice,@specialRequest)",
new
{
newOrderItemObj.OrderId,
newOrderItemObj.ItemId,
newOrderItemObj.Quantity,
newOrderItemObj.UnitPrice,
newOrderItemObj.SpecialRequest
});
if (newOrderItemQuery != null)
{
return(newOrderItemQuery);
}
throw new Exception("No OrderItem Found");
}
}
public async Task <ActionResult <string> > AddItemToOrder(string orderId, [FromBody] CreateOrderItemRequest item) => await _ordersRepository.AddItemToOrder(GetUserId(), orderId, item);
public static DomainCreateOrderItemRequest MapToDomainRequest(
this CreateOrderItemRequest request,
IMapper mapper)
{
return(mapper.Map <DomainCreateOrderItemRequest>(request));
}
