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)); }