public ActionResult <OrderItemDto> UpdateOrder(int order_num, [FromBody] OrderUpdateDto orderUpdateDto)
{
if (orderUpdateDto == null)
{
return(BadRequest());
}
OrderItem existingOrderItem = _orderRepository.GetSingle(order_num);
if (existingOrderItem == null)
{
return(NotFound());
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
Mapper.Map(orderUpdateDto, existingOrderItem);
_orderRepository.Update(order_num, existingOrderItem);
if (!_orderRepository.Save())
{
throw new Exception("Updating a orderitem failed on save.");
}
return(Ok(Mapper.Map <OrderItemDto>(existingOrderItem)));
}
public IActionResult Update(Guid id, [FromBody] OrderUpdateDto order)
{
try {
if (order == null)
{
return(BadRequest("Order object is null"));
}
if (!ModelState.IsValid)
{
return(BadRequest("Invalid model object"));
}
var orderEntity = _repository.Order.GetById(id);
if (orderEntity == null)
{
return(NotFound());
}
_mapper.Map(order, orderEntity);
_repository.Order.Update(orderEntity);
_repository.Save();
return(NoContent());
} catch (Exception ex) {
return(StatusCode(500, "Internal server error"));
}
}
public ActionResult <OrderItemDto> PartiallyUpdateOrder(int order_num, [FromBody] JsonPatchDocument <OrderUpdateDto> patchDoc)
{
if (patchDoc == null)
{
return(BadRequest());
}
OrderItem existingEntity = _orderRepository.GetSingle(order_num);
if (existingEntity == null)
{
return(NotFound());
}
OrderUpdateDto orderUpdateDto = Mapper.Map <OrderUpdateDto>(existingEntity);
patchDoc.ApplyTo(orderUpdateDto, ModelState);
TryValidateModel(orderUpdateDto);
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
Mapper.Map(orderUpdateDto, existingEntity);
OrderItem updated = _orderRepository.Update(order_num, existingEntity);
if (!_orderRepository.Save())
{
throw new Exception("Updating a orderitem failed on save.");
}
return(Ok(Mapper.Map <OrderItemDto>(updated)));
}
public async Task <OrderUpdateResultDto> UpdateAsync(string orderNumber, OrderUpdateDto orderUpdateDto)
{
var orderToUpdate = this.parkingLotContext.Orders
.FirstOrDefault(_ => _.OrderNumber == orderNumber);
if (orderToUpdate != null &&
orderToUpdate.Status == OrderStatus.Open &&
orderToUpdate.ParkingLotName == orderUpdateDto.ParkingLotName &&
orderToUpdate.PlateNumber == orderUpdateDto.PlateNumber &&
orderToUpdate.CreationTimeOffset == orderUpdateDto.CreationTimeOffset)
{
orderToUpdate.Status = OrderStatus.Close;
orderToUpdate.CloseTimeOffset = DateTimeOffset.Now;
var parkingLot = this.parkingLotContext.ParkingLots
.First(_ => _.Name == orderToUpdate.ParkingLotName);
parkingLot.AvailablePosition += 1;
}
await this.parkingLotContext.SaveChangesAsync();
return(new OrderUpdateResultDto()
{
OrderStatus = orderToUpdate.Status
});
}
public IActionResult UpdateOrder(int?orderId, [FromBody] OrderUpdateDto model)
{
if (model == null)
{
return(this.BadRequest("The request object cannot be null."));
}
if (orderId != null)
{
model.OrderId = orderId;
}
if (!this.ModelState.IsValid)
{
return(this.BadRequest(this.ModelState));
}
try
{
this._logger.LogInformation("Updating order.", model, orderId);
OrderDetailDto order = this._orderService.UpdateOrder(model);
this._logger.LogInformation("Updated order successfully.", order);
return(this.Ok(order));
}
catch (ArgumentException ex)
{
this._logger.LogWarning("Failed to update order.", model, orderId);
return(this.BadRequest(ex.Message));
}
}
public void UpdateState(int id, OrderUpdateDto model)
{
var entry = _context.Orders.Single(x => x.OrderId == id);
entry.StateId = model.StateId;
_context.SaveChanges();
}
public async Task UpdateOrderAsync(Guid orderId, [FromBody] OrderUpdateDto model, CancellationToken cancellationToken = default)
{
var command = _mapper.Map <OrderUpdateCommand>(model);
command.OrderId = orderId;
await _mediator.Send(command, cancellationToken);
Response.StatusCode = StatusCodes.Status204NoContent;
}
public async Task <IActionResult> UpdateOrder(OrderUpdateDto updatedOrder)
{
ServiceResponse <OrderGetDto> response = await _orderService.UpdateOrder(updatedOrder);
if (response.Data == null)
{
return(NotFound(response));
}
return(Ok(response));
}
public OrderDto UpdateOrder(OrderUpdateDto orderUpdate)
{
Pedido pedido = _galaxyTallerContext.Pedido.Where(p => p.PedidoId == orderUpdate.OrderId).FirstOrDefault();
pedido.UsuarioId = orderUpdate.UserId;
pedido.ClienteId = orderUpdate.ClientId;
_galaxyTallerContext.Pedido.Update(pedido);
_galaxyTallerContext.SaveChanges();
return(GetOrder(pedido.PedidoId));
}
public ActionResult UpdateOrder(int id, OrderUpdateDto orderUpdateDto)
{
var orderModelFromRepo = _order.GetOrderById(id);
if (orderModelFromRepo == null)
{
return(NotFound());
}
_mapper.Map(orderUpdateDto, orderModelFromRepo);
_order.UpdateOrder(orderModelFromRepo);
_order.SaveChanges();
return(NoContent());
}
public IActionResult UpdateOrder(OrderUpdateDto orderUpdateDto)
{
var updatingOrder = _orderService.GetById(orderUpdateDto.Id);
if (updatingOrder == null)
{
return(BadRequest(Messages.OrderNotFound));
}
if (orderUpdateDto.OrderStatusId != null)
{
updatingOrder.OrderStatusId = (int)orderUpdateDto.OrderStatusId;
}
_orderService.Update(updatingOrder);
return(Ok(Messages.OrderUpdated));
}
public IActionResult UpdateOrder(int id, OrderUpdateDto orderUpdateDto)
{
var oderToUpdate = _orderRepository.GetOrderById(id);
if (oderToUpdate == null)
{
return(NotFound());
}
var orderModel = _mapper.Map(orderUpdateDto, oderToUpdate);
_orderRepository.UpdateOrder(orderModel);
_orderRepository.SaveChanges();
return(NoContent());
}
/// <summary>
/// Update of order by identifier
/// </summary>
/// <param name="orderId"></param>
/// <param name="dto"></param>
public async Task <Order> UpdateOrder(int orderId, OrderUpdateDto dto)
{
// Get order entity
var entity = ProductContext.Orders
.Include(c => c.Customer)
.Include(c => c.OrderProducts)
.SingleOrDefault(c => c.Id == orderId);
if (entity == null)
{
return(null);
}
// Creation of new instances of OrderProducts
var orderProducts = new List <OrderProduct>();
if (dto.ProductIds == null)
{
return(null);
}
foreach (var dtoProductId in dto.ProductIds)
{
orderProducts.Add(new OrderProduct
{
OrderProductId = Guid.NewGuid().ToString(),
OrderId = orderId,
ProductId = dtoProductId,
Order = null,
Product = null
});
}
entity.CustomerId = dto.CustomerId;
entity.OrderProducts = orderProducts;
await Context.SaveChangesAsync();
return(entity);
}
/// <summary>
/// Updates an order.
/// </summary>
/// <param name="model">The order to be updated.</param>
/// <returns>The details of the updated order.</returns>
/// <exception cref="ArgumentException">OrderId is required.</exception>
/// <exception cref="ArgumentException">No Order found with given OrderId.</exception>
public OrderDetailDto UpdateOrder(OrderUpdateDto model)
{
if (model.OrderId == null)
{
throw new ArgumentException("OrderId is required.");
}
Order order = this._orderStore.GetOrder(model.OrderId.Value);
if (order == null)
{
throw new ArgumentException("No order found with given OrderId.");
}
// Note that since this is a reference type, there is no need to call any further store-level methods.
order.Description = model.Description;
order.LastModOn = DateTimeOffset.UtcNow;
return(new OrderDetailDto(order));
}
public void UpdateOrder_Fail_NotFound()
{
// Setup Fixtures.
OrderUpdateDto dto = TestValues.OrderUpdateDto;
// Setup Mocks.
this._orderStoreMock
.Setup(m => m.GetOrder(
It.Is <int>(oId => oId == dto.OrderId)))
.Returns(null as Order)
.Verifiable();
// Execute SUT.
ArgumentException result = Assert.Throws <ArgumentException>(() => this._sut.UpdateOrder(dto));
// Verify Results.
Assert.Equal("No order found with given OrderId.", result.Message);
this._orderStoreMock.Verify();
}
public async Task <IActionResult> UpdateOrder(string orderID, [FromBody] OrderUpdateDto order)
{
var role = User.FindFirst(ClaimTypes.Role)?.Value;
Guid userID = new Guid(User.FindFirst(ClaimTypes.NameIdentifier)?.Value);
var orderEntity = await orderRepository.GetOrderByID(orderID);
if (orderEntity == null)
{
return(NotFound());
}
if (!role.Equals("Admin") && !orderEntity.UserID.Equals(userID))
{
return(Unauthorized());
}
mapper.Map(order, orderEntity);
orderRepository.UpdateOrder(orderEntity);
await orderRepository.SaveAsync();
return(NoContent());
}
public void UpdateOrder_Pass()
{
// Setup Fixtures.
OrderUpdateDto model = TestValues.OrderUpdateDto;
// Setup Mocks.
this._orderServiceMock
.Setup(m => m.UpdateOrder(
It.Is <OrderUpdateDto>(dto => dto.Description.Equals(model.Description))))
.Returns(TestValues.OrderDetailDto)
.Verifiable();
// Execute SUT.
IActionResult result = this._sut.UpdateOrder(model.OrderId, model);
// Verify Results.
OkObjectResult okResult = Assert.IsType <OkObjectResult>(result);
OrderDetailDto details = Assert.IsType <OrderDetailDto>(okResult.Value);
Assert.Equal(model.Description, details.Description);
this._orderServiceMock.Verify();
}
public async Task <ServiceResponse <OrderGetDto> > UpdateOrder(OrderUpdateDto updatedOrder)
{
ServiceResponse <OrderGetDto> serviceResponse = new ServiceResponse <OrderGetDto>();
try{
Order order = await _context.Orders.FirstOrDefaultAsync(u => u.id == updatedOrder.id);
order.id = updatedOrder.id;
order.transactionid = updatedOrder.transaction;
order.productid = updatedOrder.product;
order.quantity = updatedOrder.quantity;
_context.Orders.Update(order);
await _context.SaveChangesAsync();
serviceResponse.Data = _mapper.Map <OrderGetDto>(order);
}
catch (Exception ex) {
serviceResponse.Success = false;
serviceResponse.Message = ex.Message;
}
return(serviceResponse);
}
public async Task Should_update_order_status_when_car_leaves()
{
var client = GetClient();
var parkingLot = SeedParkingLot();
var parkingLotContent = SerializeRequestBody(parkingLot);
await client.PostAsync(RootUriForParkingLots, parkingLotContent);
var newOrder = SeedOrder();
var orderContent = SerializeRequestBody(newOrder);
var createResponse = await client.PostAsync(RootUri, orderContent);
var createdOrder = await DeserializeResponseBodyAsync <OrderDto>(createResponse);
createResponse.EnsureSuccessStatusCode();
var getOrderResponse = await client.GetAsync($"{RootUri}/{createdOrder.OrderNumber}");
getOrderResponse.EnsureSuccessStatusCode();
var orderUpdate = await DeserializeResponseBodyAsync <OrderDto>(getOrderResponse);
var orderUpdateDto = new OrderUpdateDto(orderUpdate);
var updateResponse = await client.PatchAsync(createResponse.Headers.Location, SerializeRequestBody(orderUpdateDto));
updateResponse.EnsureSuccessStatusCode();
var orderResult = await DeserializeResponseBodyAsync <OrderUpdateResultDto>(updateResponse);
Assert.Equal(OrderStatus.Close, orderResult.OrderStatus);
var getResponse = await client.GetAsync($"{RootUri}/dev/{createdOrder.OrderNumber}");
getResponse.EnsureSuccessStatusCode();
var updatedOrder = await DeserializeResponseBodyAsync <OrderEntity>(getResponse);
Assert.Equal(OrderStatus.Close, updatedOrder.Status);
Assert.True(updatedOrder.CloseTimeOffset.HasValue);
}
public void UpdateOrder_Pass()
{
// Setup Fixtures.
OrderUpdateDto dto = TestValues.OrderUpdateDto;
dto.Description = "updated_description";
Order order = TestValues.Order;
// Setup Mocks.
this._orderStoreMock
.Setup(m => m.GetOrder(
It.Is <int>(oId => oId == dto.OrderId)))
.Returns(order)
.Verifiable();
// Execute SUT.
OrderDetailDto result = this._sut.UpdateOrder(dto);
// Verify Results.
Assert.True(DateTimeOffset.UtcNow - result.LastModOn < TimeSpan.FromSeconds(1));
Assert.Equal(dto.Description, result.Description);
this._orderStoreMock.Verify();
}
public async Task <ActionResult> UpdateOrder([FromBody] OrderUpdateDto dto)
{
var entity = await _unitOfWork.OrderRepository.UpdateOrder(dto.OrderId, dto);
if (entity == null)
{
BadRequest("Data cannot be processed");
}
var productIds = entity.OrderProducts.Select(c => c.ProductId).ToList();
var products = new List <Product>();
foreach (var i in productIds)
{
var entityProduct = await _unitOfWork.ProductRepository.Get(i);
// Unnecessary data is nullified
entityProduct.OrderProducts = null;
// Added new entity to the product collection
products.Add(entityProduct);
}
return(Ok(new { entity.Id, entity.CreationDate, entity.CustomerId, products }));
}
public async Task <IActionResult> Put([FromBody] OrderUpdateDto updateModel)
{
await _orderData.UpdateOrder(updateModel.OrderId, updateModel.OrderName);
return(Ok());
}
public OrderDto UpdateOrder(int orderId, OrderUpdateDto orderUpdate)
{
orderUpdate.OrderId = orderId;
return(_orderRepository.UpdateOrder(orderUpdate));
}
public ActionResult UpdateState(int orderId, OrderUpdateDto model)
{
_orderService.UpdateState(orderId, model);
return(Ok());
}
public Task UpdateAsync(int Id, OrderUpdateDto model)
{
throw new NotImplementedException();
}
public async Task ConfirmOrder(OrderUpdateDto input)
{
var order = await _orderManager.GetAsync(input.Id);
await _orderManager.ConfirmCustomer(order);
}
public async Task <ActionResult <OrderUpdateResultDto> > UpdateAsync(string orderNumber, OrderUpdateDto orderUpdateDto)
{
var orderToUpdate = await this.orderService.GetInDevAsync(orderNumber);
if (orderToUpdate == null)
{
return(NotFound(new Dictionary <string, string>()
{
{ "error", "the order is not found" }
}));
}
if (orderToUpdate.ParkingLotName != orderUpdateDto.ParkingLotName &&
orderToUpdate.PlateNumber != orderUpdateDto.PlateNumber &&
orderToUpdate.CreationTimeOffset != orderUpdateDto.CreationTimeOffset)
{
return(BadRequest(new Dictionary <string, string>()
{
{ "error", "the order is not recognized" }
}));
}
if (orderToUpdate.Status == OrderStatus.Close)
{
return(BadRequest(new Dictionary <string, string>()
{
{ "error", "the order is already closed" }
}));
}
var updateResult = await this.orderService.UpdateAsync(orderNumber, orderUpdateDto);
return(Ok(updateResult));
}
public async Task ConfirmDriver(OrderUpdateDto input)
{
var result = await _orderManager.GetAsync(input.Id);
await _orderManager.ConfirmDriver(result, input.DriverId);
}
public ActionResult <OrderDto> UpdateAuthor(int orderId, [FromBody] OrderUpdateDto orderUpdate)
{
OrderDto order = _orderApplicationService.UpdateOrder(orderId, orderUpdate);
return(Ok(order));
}
