public IActionResult UpdateOrder(int id, [FromBody] OrderForUpdateDto order)
{
try
{
if (order == null)
{
_logger.LogError("order object sent from client is null.");
return(BadRequest("order object is null"));
}
if (!ModelState.IsValid)
{
_logger.LogError("Invalid order object sent from client.");
return(BadRequest("Invalid model object"));
}
var orderEntity = _repository.Order.GetOrderById(id);
if (orderEntity == null)
{
_logger.LogError($"order with id: {id}, hasn't been found in db.");
return(NotFound());
}
_mapper.Map(order, orderEntity);
_repository.Order.UpdateOrder(orderEntity);
_repository.Save();
return(NoContent());
}
catch (Exception ex)
{
_logger.LogError($"Something went wrong inside UpdateOrder action: {ex.InnerException.Message}");
return(StatusCode(500, "Internal server error"));
}
}
public IActionResult UpdateOrderForCustomer(Guid customerId, Guid orderId, OrderForUpdateDto order)
{
if (!this.customersRepository.CustomerExists(customerId))
{
return(this.NotFound());
}
var orderForCustomer = this.customersRepository.GetOrder(customerId, orderId);
if (orderForCustomer == null)
{
var orderToAdd = this.mapper.Map <Order>(order);
orderToAdd.Id = orderId;
this.customersRepository.AddOrder(customerId, orderToAdd);
this.customersRepository.Save();
var orderToReturn = this.mapper.Map <OrderDto>(orderToAdd);
return(CreatedAtRoute("GetOrderForCustomer",
new { customerId, orderId = orderToReturn.Id },
orderToReturn));
}
this.mapper.Map(order, orderForCustomer);
this.customersRepository.UpdateOrder(orderForCustomer);
this.customersRepository.Save();
return(this.NoContent());
}
public async Task <IActionResult> PutOrder([FromRoute] int id, [FromBody] OrderForUpdateDto orderForUpdateDto)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
//if (id != order.Id)
//{
// return BadRequest();
//}
var order = await _repository.GetAsync(id);
if (order == null)
{
return(NotFound());
}
_mapper.Map(orderForUpdateDto, order);
if (await _unitOfWork.SaveAsync())
{
return(NoContent());
}
throw new Exception($"Updating order {id} failed on save");
}
public void UpdateOrderAsync(OrderForUpdateDto order)
{
var orderEntity = _mapper.Map <OrderEntity>(order);
_context.Entry(orderEntity).State = EntityState.Modified;
_context.Entry(orderEntity).Property(x => x.CreatedDate).IsModified = false;
_context.Entry(orderEntity).Property(x => x.OrderNumber).IsModified = false;
}
public async Task <IActionResult> UpdateOrder(int id, [FromBody] OrderForUpdateDto order)
{
var orderEntity = HttpContext.Items["entity"] as Order;
_mapper.Map(order, orderEntity);
_repository.Order.UpdateOrder(orderEntity);
await _repository.SaveAsync();
return(NoContent());
}
public async Task <IActionResult> UpdateOrder(int id, OrderForUpdateDto orderForUpdateDto)
{
var orderFromRepo = await _repo.Get(id);
_mapper.Map(orderForUpdateDto, orderFromRepo);
if (await _repo.SaveAll())
{
return(NoContent());
}
throw new Exception($"Updating order {id} failed on save");
}
public ActionResult PartiallyUpdateOrderForCustomer(Guid customerId, Guid OrderId, JsonPatchDocument <OrderForUpdateDto> patchDocument)
{
if (!this.customersRepository.CustomerExists(customerId))
{
return(NotFound());
}
var orderForCustomerFromRepo = this.customersRepository.GetOrder(customerId, OrderId);
if (orderForCustomerFromRepo == null)
{
var orderDto = new OrderForUpdateDto();
patchDocument.ApplyTo(orderDto, ModelState);
if (!TryValidateModel(orderDto))
{
return(ValidationProblem(ModelState));
}
var orderToAdd = this.mapper.Map <Order>(orderDto);
orderToAdd.Id = OrderId;
this.customersRepository.AddOrder(customerId, orderToAdd);
this.customersRepository.Save();
var orderToReturn = this.mapper.Map <OrderDto>(orderToAdd);
return(CreatedAtRoute("GetOrderForCustomer",
new { customerId, orderId = orderToReturn.Id },
orderToReturn));
}
var orderToPatch = this.mapper.Map <OrderForUpdateDto>(orderForCustomerFromRepo);
patchDocument.ApplyTo(orderToPatch, ModelState);
if (!TryValidateModel(orderToPatch))
{
return(ValidationProblem(ModelState));
}
this.mapper.Map(orderToPatch, orderForCustomerFromRepo);
this.customersRepository.UpdateOrder(orderForCustomerFromRepo);
this.customersRepository.Save();
return(NoContent());
}
public async Task <OrderDto> UpdateOrderAsync(OrderForUpdateDto order)
{
var orderInDb = await _orderAccessor.GetOrderAsync(order.Id);
if (orderInDb == null)
{
return(null);
}
if (order.OrderStatus == "Complete" &&
(orderInDb.CompletedDate != null ||
order.CompletedDate != DateTime.MinValue))
{
order.CompletedDate = DateTime.Now;
}
var incomingProductIds = order.LineItems.Select(x => x.ProductId).ToList();
var dbProductIds = orderInDb.LineItems.Select(x => x.ProductId).ToList();
var lineItemsToDelete = orderInDb.LineItems
.Where(x => !incomingProductIds
.Contains(x.ProductId))
.ToList();
if (lineItemsToDelete.Any())
{
_orderAccessor.DeleteLineItems(lineItemsToDelete);
}
var lineItemsToAdd = order.LineItems
.Where(x => !dbProductIds.Contains(x.ProductId)).ToList();
if (lineItemsToAdd.Any())
{
await _orderAccessor.AddLineItems(_mapper.Map <List <LineItemDto> >(lineItemsToAdd));
}
var lineItemsToUpdate = order.LineItems.Where(x => dbProductIds.Contains(x.ProductId)).ToList();
if (lineItemsToUpdate.Any())
{
_orderAccessor.UpdateLineItems(lineItemsToUpdate);
}
_orderAccessor.UpdateOrderAsync(order);
await _orderAccessor.Commit();
return(await GetOrderAsync(order.Id));
}
public async Task <IActionResult> CancelUserOrder(int orderId, [FromBody] OrderForUpdateDto orderForUpdateDto)
{
if (Request.Headers.ContainsKey("id"))
{
if (int.Parse(Request.Headers["id"].First()) == int.Parse(User.FindFirst(ClaimTypes.NameIdentifier)?.Value))
{
var order = await _repo.GetOrderById(orderId);
order.OrderStatus = orderForUpdateDto.OrderStatus;
if (await _repo.SaveAll())
{
return(NoContent());
}
}
}
return(Unauthorized("id not match or not found"));
}
public async Task <IActionResult> UpdateOrderStatus(int id, [FromBody] OrderForUpdateDto orderForUpdateDto)
{
var order = await _repo.GetOrderById(id);
if (order == null)
{
return(NotFound());
}
order.OrderStatus = orderForUpdateDto.OrderStatus;
if (await _repo.SaveAll())
{
return(NoContent());
}
throw new Exception($"Updating order status failed on save");
}
public async Task <IActionResult> UpdateOrder(int orderId, [FromBody] OrderForUpdateDto input)
{
if (ModelState.IsValid)
{
var orderInDB = await _ordersService.GetOrderByIdAsync(orderId);
if (orderInDB == null)
{
return(NotFound(orderId));
}
var result = await _ordersService.UpdateOrderAsync(_mapper.Map(input, orderInDB));
if (result)
{
return(Ok());
}
}
return(BadRequest(ModelState));
}
public async Task <IActionResult> UpdateOrder(int id, int userId, OrderForUpdateDto orderForUpdateDto)
{
if (userId != int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value))
{
return(Unauthorized());
}
var orderFromRepo = await _repo.GetOrder(userId, id);
_mapper.Map(orderForUpdateDto, orderFromRepo);
if (await _repo.SaveAll())
{
return(NoContent());
}
return(BadRequest("Could not update order."));
}
public async Task <IActionResult> UpdateOrder(int id, [FromBody] OrderForUpdateDto order)
{
if (order == null)
{
_logger.LogError($"OrderForUpdateDto object sent from client is null. ");
return(BadRequest("OrderForUpdateDto object is null"));
}
var orderEntity = await _serviceManager.Order.GetOrderAsync(id, trackChanges : false);
if (orderEntity == null)
{
_logger.LogInfo($"Order with id: {id} doesn't exist in the database.");
return(NotFound());
}
_mapper.Map(order, orderEntity);
_serviceManager.Order.UpdateOrder(orderEntity);
_serviceManager.Save();
return(NoContent());
}
public async Task <IActionResult> PartiallyUpdateOrderForCustomer(string customerId,
int orderId,
[FromBody] JsonPatchDocument <OrderForUpdateDto> patchDocument)
{
if (!await _customerService.Exists(customerId))
{
return(NotFound("Customer Not Found!"));
}
var order = await _orderService.GetByCustomerIdAndOrderId(customerId, orderId);
if (order == null)
{
var orderDto = new OrderForUpdateDto();
patchDocument.ApplyTo(orderDto, ModelState);
if (!await TryUpdateModelAsync(orderDto))
{
return(ValidationProblem(ModelState));
}
var orderAdded = _mapper.Map <OrderDto>(await _orderService.AddAsync(_mapper.Map <Order>(orderDto)));
return(CreatedAtRoute("GetOrderForCustomer",
new { customerId, orderId = orderAdded.OrderID },
orderAdded));
}
var orderToPatch = _mapper.Map <OrderForUpdateDto>(order);
patchDocument.ApplyTo(orderToPatch, ModelState);
if (!await TryUpdateModelAsync(orderToPatch))
{
return(ValidationProblem(ModelState));
}
_mapper.Map(orderToPatch, order);
await _orderService.UpdateAsync(order);
return(NoContent());
}
public async void LineItemsInDbNotPassedInWithUpdateDtoShouldBeDeleted()
{
// Arrange
var orderInDb = new OrderDto
{
Id = 1,
Customer = new CustomerDto {
Id = 1
},
LineItems = new List <LineItemDto>
{
new LineItemDto {
OrderId = 1, ProductId = 1
},
new LineItemDto {
OrderId = 1, ProductId = 2
}
}
};
var orderToUpdate = new OrderForUpdateDto
{
Id = 1,
CustomerId = 1,
LineItems = new List <LineItemForUpdateDto>
{
new LineItemForUpdateDto {
OrderId = 1, ProductId = 1
}
}
};
var mockAccessor = new MockOrderAccessor().MockOrderInDb(orderInDb);
var manager = new OrderManager(mockAccessor.Object, new MockAutoMapper().Object);
// Act
var result = await manager.UpdateOrderAsync(orderToUpdate);
// Assert
mockAccessor.VerifyDeleteLineItems(Times.Once());
}
public async Task <IActionResult> UpdateOrder(int id, [FromBody] OrderForUpdateDto orderForUpdateDto)
{
try
{
if (orderForUpdateDto == null)
{
logger.LogError("Order object sent from client is null.");
return(BadRequest("Order for Update is Null."));
}
if (!ModelState.IsValid)
{
logger.LogError("Invalid order object sent from client.");
return(BadRequest("Invalid Order to Update."));
}
var orderToUpdate = await repository.Orders.GetOrderByIDAsync(id);
if (orderToUpdate == null)
{
logger.LogError($"Order with id: {id}, hasn't been found in db");
return(NotFound());
}
mapper.Map(orderForUpdateDto, orderToUpdate);
repository.Orders.UpdateOrder(orderToUpdate);
await repository.SaveAsync();
return(NoContent());
}
catch (Exception ex)
{
logger.LogError($"UpdateOrder(): {ex.Message} {ex.StackTrace} {ex.InnerException}");
return(StatusCode(StatusCodes.Status500InternalServerError, "Internal Server Error"));
}
}
public IActionResult Put(int id, [FromBody] OrderForUpdateDto order)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (!_clientRepository.ClientExists(order.ClientId))
{
return(NotFound());
}
var orderFetched = _orderRepository.GetOrder(id);
if (orderFetched == null)
{
return(NotFound());
}
_mapper.Map(order, orderFetched);
_orderRepository.Save();
return(NoContent());
}
public async Task <IActionResult> UpdateOrder([FromBody] OrderForUpdateDto order)
{
var newOrder = await _orderManager.UpdateOrderAsync(order);
return(Ok(newOrder));
}
public async Task <IActionResult> UpdateOrderForCustomer(string customerId, int orderId, OrderForUpdateDto model)
{
if (!await _customerService.Exists(customerId))
{
return(NotFound("Customer Not Found!"));
}
var order = await _orderService.GetByCustomerIdAndOrderId(customerId, orderId);
// If the order doesn't exists then will be created (upserting)
if (order == null)
{
order = await _orderService.AddAsync(_mapper.Map <Order>(model));
var orderAdded = _mapper.Map <OrderDto>(order);
return(CreatedAtRoute("GetOrderForCustomer",
new { customerId, orderId = orderAdded.OrderID },
orderAdded));
}
_mapper.Map(model, order);
await _orderService.UpdateAsync(order);
return(NoContent());
}
