public async Task Update_WhenDoesntHaveAuthenticationToken_ShouldReturn401Code()
{
// Arrange
var updateProductData = new UpdateProductCommand
{
Id = Guid.NewGuid(),
Name = "",
Price = 0
};
var client = _factory.CreateClient();
// Act
var response = await client.PutAsync($"{TestConstants.ProductApiBaseUrl}/{updateProductData.Id}", updateProductData.SerializeToStringContent());
// Assert
Assert.Equal(HttpStatusCode.Unauthorized, response.StatusCode);
}
public Task <HttpResponseMessage> Put(int id, [FromBody] dynamic body)
{
var command = new UpdateProductCommand(
id: id,
title: (string)body.title,
category: (int)body.category,
description: (string)body.description,
weight: (string)body.weight,
price: (decimal)body.price,
image: (string)body.image,
quantityOnHand: (int)body.quantityOnHand
);
var product = _service.Update(command);
return(CreateResponse(HttpStatusCode.OK, product));
}
public ActionResult <UpdateProductResponse> UpdateProduct(Guid id, Product product)
{
try
{
var command = new UpdateProductCommand {
Id = id, Product = product
};
var response = _mediator.Send(command);
return(Ok(response));
}
catch (Exception e)
{
_logger.LogInformation(e.Message);
return(BadRequest(e.Message));
}
}
public async Task Handle_GivenValidId_ShouldUpdatePersistedProduct()
{
var command = new UpdateProductCommand
{
Id = 1,
Title = "This thing is also done.",
};
var handler = new UpdateProductCommand.UpdateProductCommandHandler(Context);
await handler.Handle(command, CancellationToken.None);
var entity = Context.Products.Find(command.Id);
entity.ShouldNotBeNull();
entity.Title.ShouldBe(command.Title);
}
public async Task OnGetAsync()
{
var detail = await _productQuery.GetProductDetailAsync(Id);
Command = new UpdateProductCommand
{
Id = detail.Id,
Description = detail.Description,
Name = detail.Name,
CategoryId = detail.CategoryId,
BrandId = detail.BrandId,
StoreId = detail.StoreId,
UnitPrice = detail.UnitPrice
};
await LoadData();
}
public async Task <ICommandResult> HandleAsync(UpdateProductCommand command)
{
command.Validate();
if (command.Invalid)
{
return(new GenericCommandResult <ProductEntity>(false, command.Notifications));
}
var product = await _repository.GetAsync(command.Id);
product.SetName(command.Name);
product.SetPrice(command.Price);
await _repository.UpdateAsync(product);
return(new GenericCommandResult <ProductEntity>(true, product));
}
public async Task <IActionResult> Edit(int id, [Bind("Id,Name,Price,Category,Description,PhotoUrl")]
UpdateProductCommand command)
{
if (id != command.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
await Mediator.Send(command);
return(RedirectToAction(nameof(Index)));
}
return(View(command));
}
public async Task <(ProductViewModel Model, List <string> Errors)> ExceuteUpdate(ProductViewModel model)
{
UpdateProductCommand command = new UpdateProductCommand()
{
Id = model.Id,
Name = model.Name,
NoOfUnit = model.NoOfUnit,
ReOrderLevel = model.ReOrderLevel,
UnitPrice = model.UnitPrice
};
var result = await _bus.Send(command);
return(model, !string.IsNullOrEmpty(result.ErrorMessage) ? new List <string> {
result.ErrorMessage
} : new List <string>());
}
public async Task Should_UpdateProduct_Returns200()
{
//arrange
var command = GetCreateProductCommand();
var createdProduct = await CreateProductAsync(command);
var updateCommand = new UpdateProductCommand(createdProduct.Id,
"testName",
123,
"testDescription",
new DimensionsDto
{
Height = 1.0M,
Length = 2.0M,
Weight = 3.0M,
Width = 4.0M
});
//act
var path = $"{ProductController.Update()}/{createdProduct.Id}";
var putResponse = await Client.PutAsJsonAsync(path, updateCommand);
var getResponse = await GetProductAsync(createdProduct.Id);
var stringResult = await getResponse.Content.ReadAsStringAsync();
var responseProduct = JsonConvert.DeserializeObject <ProductViewModel>(stringResult);
//assert
putResponse.StatusCode.Should().Be(HttpStatusCode.OK);
getResponse.StatusCode.Should().Be(HttpStatusCode.OK);
command.Should().NotBeNull();
command.Name.Should().Be(createdProduct.Name);
command.Description.Should().Be(createdProduct.Description);
command.BarCode.Should().Be(createdProduct.BarCode);
command.Price.Should().Be(createdProduct.Price);
command.Dimensions.Should().Be(createdProduct.Dimensions);
command.ManufacturerId.Should().Be(createdProduct.ManufacturerId);
responseProduct.Id.Should().Be(updateCommand.Id);
responseProduct.Name.Should().Be(updateCommand.Name);
responseProduct.Price.Should().Be(updateCommand.Price);
responseProduct.Description.Should().Be(updateCommand.Description);
responseProduct.Dimensions.Should().Be(updateCommand.Dimensions);
}
public void ShouldThrowProductNotFoundException()
{
// Update Product Command
var updateProductCommand = new UpdateProductCommand
{
AvailableToSell = false,
// created brand id
BrandId = Guid.NewGuid().ToString(),
// created product category id
ProductCategoryId = Guid.NewGuid().ToString(),
Name = "Test Product Name Update",
PhotoUrl = "Test Product PhotoUrl Update",
Barcode = "Test Product Barcode Update",
Id = Guid.NewGuid().ToString()
};
FluentActions.Invoking(() => SendAsync(updateProductCommand)).Should().Throw <ProductNotFoundException>();
}
public async Task <IActionResult> UpdateProduct(Guid prodid, Product product)
{
var query = new UpdateProductCommand(product, prodid);
var output = await _mediator.Send(query);
if (!String.IsNullOrEmpty(output.Name))
{
ModelState.AddModelError("product", output.Name);
return(BadRequest(ModelState));
}
else if (output.ID == Guid.Empty)
{
ModelState.AddModelError("product", "Product deos not exist");
return(BadRequest(ModelState));
}
return(CreatedAtAction(nameof(GetProductByID), new { categid = output.ID }, output));
}
public async Task <IActionResult> UpdateProduct([FromRoute] Guid id, [FromBody] UpdateProductCommand command)
{
if (id != command.Id)
{
return(BadRequest("Product id in route not match id in payload"));
}
try
{
var productDto = await Mediator.Send(command);
return(CreatedAtAction("GetProduct", new { id = productDto.Id }, productDto));
}
catch (NotFoundException e)
{
return(NotFound(e.Message));
}
}
public async Task GivenUpdateProductCommand_ReturnsSuccessStatusCode()
{
var command = new UpdateProductCommand
{
ProductId = 77,
ProductName = "Original Frankfurter grüne Soße",
SupplierId = 12,
CategoryId = 2,
UnitPrice = 15.00m,
Discontinued = false
};
var content = Utilities.GetRequestContent(command);
var response = await _client.PutAsync($"/api/products/update", content);
response.EnsureSuccessStatusCode();
}
public async Task <IActionResult> Put(Guid id, [FromBody] UpdateProductCommand command)
{
command.Id = id;
try
{
await _updateHandler.HandleAsync(command);
}
catch (ArgumentException ex)
{
return(NotFound(ex.Message));
}
catch (ModelException ex)
{
return(BadRequest(ex.Message));
}
return(Ok());
}
public void Should_Update_Product_When_Command_Is_Valid()
{
var products = _fakeProductRepository.GetAllAsync();
var product = products.Result.FirstOrDefault();
var command = new UpdateProductCommand
{
Id = product.Id,
Name = "Produto teste",
Description = "Descrição produto teste",
Price = 100
};
var result = _handler.Handle(command);
Assert.AreNotEqual(null, result);
Assert.AreEqual(true, _handler.Valid);
}
public ICommandResult Handle(UpdateProductCommand command)
{
command.Validate();
if (command.Invalid)
{
return(new GenericCommandResult(false, "Ocorreu um erro na atualização do produto, verifique os dados...", command.Notifications));
}
Product product = _repository.GetById(command.Id);
product.Name = command.Name;
product.Value = command.Value;
product.Image = command.Image;
_repository.Update(product);
return(new GenericCommandResult(true, "Produto atualizado com sucesso", product));
}
public async Task GivenUpdateProductCommandWithInvalidId_ReturnsNotFoundStatusCode()
{
var invalidCommand = new UpdateProductCommand
{
ProductId = 0,
ProductName = "Original Frankfurter grüne Soße",
SupplierId = 12,
CategoryId = 2,
UnitPrice = 15.00m,
Discontinued = false
};
var content = Utilities.GetRequestContent(invalidCommand);
var response = await _client.PutAsync($"/api/products/update", content);
Assert.Equal(HttpStatusCode.NotFound, response.StatusCode);
}
public bool UpdateProduct(UpdateProductCommand updateProductCommand)
{
using (var db = new SqlConnection(_connectionString))
{
var sql = @"UPDATE [dbo].[Product]
SET [Title] = @Title
,[Category] = @Category
,[RentalPrice] = @RentalPrice
,[SalesPrice] = @SalesPrice
,[IsForSale] = @IsForSale
,[IsRgb] = @IsRgb
,[Description] = @Description
,[ImageUrl] = @ImageUrl
WHERE [Id] = @Id";
return(db.Execute(sql, updateProductCommand) == 1);
}
}
public async Task <IActionResult> Put(int id, [FromBody] Product product)
{
try
{
//Log Information - Request
_logger.LogInformation($"Received Request : HTTPPUT api/products");
//Check if Product exists.
Product productInDb = await _mediator.Send(new FindProductByIdQuery()
{
ProductId = id
});
if (productInDb == null)
{
// Log warning and return HTTP 404
_logger.LogWarning($"Not Found : HTTPPUT api/products/{id}");
return(NotFound());
}
//Create command object
UpdateProductCommand updateCmd = new UpdateProductCommand
{
ProductId = product.ProductId,
Description = product.Description,
Name = product.Name,
UnitPrice = product.UnitPrice,
UnitsInStock = product.UnitsInStock,
IsActive = product.IsActive
};
//Send command
await _mediator.Send(updateCmd);
//Return
return(NoContent());
}
catch (Exception ex)
{
// Log the failure and return HTTP 500
_logger.LogError($"Error at HTTPPUT api/products/{id}:{ex}");
return(StatusCode(StatusCodes.Status500InternalServerError));
}
}
public UpdateProductHandlerTests()
{
_productRepository = Substitute.For <IProductRepository>();
var productValid = _fixture.Create <ProductEntity>();
_productRepository.GetAsync(productValid.Id).Returns(productValid);
_handler = new ProductHandler(_productRepository);
_commandWithoutName = _fixture
.Build <UpdateProductCommand>()
.Without(x => x.Name)
.With(x => x.Id, productValid.Id)
.Create();
_commandWithName = _fixture
.Build <UpdateProductCommand>()
.With(x => x.Name, _fixture.Create <string>())
.With(x => x.Id, productValid.Id)
.Create();
_commandWithPriceZero = _fixture
.Build <UpdateProductCommand>()
.With(x => x.Price, 0)
.With(x => x.Id, productValid.Id)
.Create();
_commandWithPriceGreaterZero = _fixture
.Build <UpdateProductCommand>()
.With(x => x.Price, 450)
.With(x => x.Id, productValid.Id)
.Create();
_commandWithInvalidId = _fixture
.Build <UpdateProductCommand>()
.Without(x => x.Id)
.Create();
_commandWithValidId = _fixture
.Build <UpdateProductCommand>()
.With(x => x.Id, productValid.Id)
.Create();
}
public Task <bool> Handle(UpdateProductCommand request, CancellationToken cancellationToken)
{
if (!request.IsValid())
{
return(Task.FromResult(false));
}
var produto = new Produto(request.id, request.nome, request.fornecedor, request.marca, request.valor);
_repository.Update(produto);
_repository.Save();
if (produto == null)
{
throw new Exception("Valor não pode ser nulo");
}
return(Task.FromResult(true));
}
public Task <bool> Handle(UpdateProductCommand message, CancellationToken cancellationToken)
{
if (!message.IsValid())
{
NotifyValidationErrors(message);
return(Task.FromResult(false));
}
var product = new Product(message.Id, message.Name);
_productRepository.Update(product);
if (Commit())
{
Bus.RaiseEvent(new ProductUpdatedEvent(product.Id, product.Name));
}
return(Task.FromResult(true));
}
public void HandleUpdate(UpdateProductCommand command, IAppUnitOfWorkFactory uowFactory)
{
using (IAppUnitOfWork uow = uowFactory.Create())
{
Product product = uow.ProductRepository.Get(command.ProductId, Product.IncludeAll);
Company company = uow.CompanyRepository.Get(command.CompanyId);
if (company == null)
{
throw new DomainException("The assigned company not found");
}
User updater = uow.Users.FirstOrDefault(u => u.Id == command.UpdatedByUserId);
if (updater == null)
{
throw new DomainException("Can not find updater");
}
// Delete properties
foreach (ProductProperty removedProperty in product.Properties.Where(oldP => !command.Properties.Any(newP => newP.Id == oldP.Id)).ToList())
{
product.Properties.Remove(removedProperty);
uow.ProductPropertyRepository.Remove(removedProperty);
}
// Update existing properties
foreach (ProductProperty existProperty in product.Properties)
{
ProductProperty updatedProperty = command.Properties.SingleOrDefault(pp => pp.Id == existProperty.Id);
existProperty.Name = updatedProperty.Name;
existProperty.Value = updatedProperty.Value;
}
// Add new properties
foreach (ProductProperty property in command.Properties.Where(pp => pp.Id == 0))
{
product.Properties.Add(property);
}
product.Company = company;
product.Name = command.Name;
product.Comment = command.Comment;
product.Quantity = command.Quantity;
product.Sku = command.Sku;
product.IsActive = command.IsActive;
product.UpdatedAt = DateTime.Now;
uow.SaveChanges();
}
}
public Task <bool> Handle(UpdateProductCommand request, CancellationToken cancellationToken)
{
var product = new Product(request.Id, request.Name, request.Description, request.ShortDescription, request.Price);
if (!request.IsValid())
{
NotifyValidationErrors(request);
return(Task.FromResult(false));
}
_repository.Update(product);
if (Commit())
{
Bus.RaiseEvent(new ProductUpdatedEvent());
}
return(Task.FromResult(true));
}
public void Update(string name, string?description, decimal price, decimal deliveryPrice)
{
var command = new UpdateProductCommand
{
Name = name,
Description = description,
Price = price,
DeliveryPrice = deliveryPrice
};
var validator = new UpdateProductCommandValidator();
validator.ValidateAndThrow(command);
Name = command.Name;
Description = command.Description;
Price = command.Price;
DeliveryPrice = command.DeliveryPrice;
}
public Task <bool> Handle(UpdateProductCommand command, CancellationToken cancellationToken)
{
if (!command.IsValid())
{
NotifyErrors(command);
return(Task.FromResult(false));
}
var product = new Product(command.Id, command.Name, command.Price, command.QuantityOnHand);
_productRepository.Update(product);
if (!Commit())
{
return(Task.FromResult(false));
}
return(Task.FromResult(true));
}
public Product Update(Product product)
{
// Execute Business validation
var command = new UpdateProductCommand(UnitOfWork, product);
DataBusManager.ExecuteCommand(command);
if (command.Success)
{
// Success execution
}
else if (command.Fail)
{
// Fail Execution
}
return(command.Product);
}
public async Task <ActionResult> Update([FromServices] UpdateProductHandler handler,
[FromBody] UpdateProductCommand command)
{
try
{
var result = (CommandResult)handler.handle(command);
if (!result.Success)
{
return(BadRequest(result));
}
return(Ok(result));
}
catch (Exception e)
{
return(BadRequest(e));
}
}
public IHttpActionResult Update([FromBody] UpdateProductCommand command)
{
if (command == null)
{
return(BadRequest(DefaultMessages.InvalidBody));
}
ValidationError error = new UpdateProductCommandValidation().Validate(command);
if (error.IsInvalid)
{
return(BadRequest(error.Error));
}
if (_repository.FindById(command.Id) == null)
{
return(BadRequest("Não existe um Produto com este código."));
}
_repository.Update(command);
return(Ok());
}
public async Task <IActionResult> UpdateProduct([FromBody] Application.Models.Product product)
{
if (product == null)
{
throw new ArgumentNullException(nameof(product));
}
var command = new UpdateProductCommand(product);
var result = await this._Mediator.Send(command);
if (result.Status == CommandResultStatus.Success)
{
return(new OkObjectResult(result.Result));
}
else
{
return(new BadRequestObjectResult("Something went wrong"));
}
}
