public ViewResult ProductUpdated(ProductUpdateRequestDto updatedProduct)
{
if (ModelState.IsValid)
{
return(View("ProductUpdated", updatedProduct));
}
return(View());
}
public async Task <BaseResponse <ProductDto> > UpdateProduct([FromBody] ProductUpdateRequestDto model)
{
if (ModelState.IsValid)
{
return(await _productService.UpdateProduct(model));
}
return(new FailureResponse <ProductDto>(GetErrorMessages()));
}
public void Map_ProductUpdateRequest_To_Product_Should_Work(ProductUpdateRequestDto data)
{
var mapper = new MapperFixture().Mapper;
var result = mapper.Map <Product>(data);
result.Should().NotBeNull();
result.Id.Should().Be(data.Id);
}
private async Task PrepareImage(ProductUpdateRequestDto model, DbProduct create)
{
if (model.Image != null && model.Image.Id == null)
{
var dbModel = _mapper.Map <DbImage>(model.Image);
dbModel.Buffer = Convert.FromBase64String(model.Image.Base64String);
var dbImage = await _imageRepository.Add(dbModel);
create.ImageId = dbImage.Id;
}
}
public IActionResult Put(ProductUpdateRequestDto request)
{
if (ModelState.IsValid)
{
Trace.WriteLine("Put");
dataBaseBridge.Update(request);
return(RedirectToAction("Index"));
}
Response.StatusCode = 400;
return(Content("Invalid request !!!"));
}
public ViewResult EditProduct(ProductUpdateRequestDto request)
{
if (ModelState.IsValid)
{
Trace.WriteLine("doUpdate");
dataBaseBridge.Update(request);
return(View("ProductUpdated", request));
}
Trace.WriteLine("Not valid");
return(View());
}
public ViewResult EditProduct(Guid id)
{
Trace.WriteLine("Edit");
Product product = dataBaseBridge.GetProduct(id);
ProductUpdateRequestDto request = new ProductUpdateRequestDto();
request.Id = product.Id;
request.NewName = product.Name;
request.NewPrice = product.Price;
return(View(request));
}
public async Task <IActionResult> Put(Guid id, [FromBody] ProductUpdateRequestDto productDto)
{
if (!ModelState.IsValid)
{
return(BadRequest(string.Join("\n", ModelState.Values
.SelectMany(x => x.Errors)
.Select(x => x.ErrorMessage))));
}
await _productService.UpdateAsync(id, productDto.Name, productDto.Price);
return(NoContent());
}
public ProductUpdateRequestBuilder WithDefaultValues()
{
_productUpdateRequest = new ProductUpdateRequestDto
{
Id = Guid.NewGuid(),
Name = $"Test Name {DateTime.Now.Ticks}",
Description = $"Test Description {DateTime.Now.Ticks}",
Price = 100,
DeliveryPrice = 5
};
return(this);
}
public IActionResult PutProduct(ProductUpdateRequestDto request)
{
if (ModelState.IsValid)
{
_productService.UpdateProduct(request.Id, request.Name, request.Price);
return(View(request));
}
else
{
return(Content("Błędne dane"));
}
}
public async Task <ActionResult> Put([FromBody] ProductUpdateRequestDto request)
{
try
{
var product = _mapper.Map <Product>(request);
await _productService.Update(product);
return(Ok());
}
catch (Exception e)
{
return(BadRequest(e.Message));
}
}
public void Not_Have_Error_When_Request_Is_Valid()
{
var productUpdateRequest = new ProductUpdateRequestDto
{
Description = "Testing",
Name = "Test",
Id = Guid.NewGuid(),
Price = 10,
DeliveryPrice = 1
};
var result = _validator.TestValidate(productUpdateRequest);
Assert.Empty(result.Errors);
}
public void Have_Multiple_Errors_When_Id_Price_DeliveryPrice_Are_Not_Provided()
{
var productUpdateRequest = new ProductUpdateRequestDto
{
Description = "Testing",
Name = "Test"
};
var result = _validator.TestValidate(productUpdateRequest);
Assert.Equal(3, result.Errors.Count);
result.ShouldHaveValidationErrorFor(request => request.Id);
result.ShouldHaveValidationErrorFor(request => request.Price);
result.ShouldHaveValidationErrorFor(request => request.DeliveryPrice);
}
public void Have_Error_When_Id_Is_Empty()
{
var productUpdateRequest = new ProductUpdateRequestDto
{
Description = "Testing",
Name = "Test",
Id = Guid.Empty,
Price = 10,
DeliveryPrice = 1
};
var result = _validator.TestValidate(productUpdateRequest);
Assert.Equal(1, result.Errors.Count);
result.ShouldHaveValidationErrorFor(x => x.Id);
}
public void Put([FromBody] ProductUpdateRequestDto request)
{
if (!ModelState.IsValid)
{
return;
}
Product foundProduct = _productRepository.FindById(request.Id);
if (foundProduct == null)
{
return;
}
foundProduct.Name = request.Name;
foundProduct.Price = request.Price;
_productRepository.Update(foundProduct);
}
public async Task <IActionResult> Put(Guid id, [FromBody] ProductUpdateRequestDto productUpdateRequestDto)
{
if (id != productUpdateRequestDto.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
Product product = await _context.Product.FirstOrDefaultAsync(d => d.Id == id);
product.Name = productUpdateRequestDto.Name;
product.Price = productUpdateRequestDto.Price;
_context.Update(product);
await _context.SaveChangesAsync();
ProductDto productDto = new ProductDto()
{
Id = product.Id,
Name = product.Name,
Price = product.Price
};
return(Json(productDto));
}
catch (DbUpdateConcurrencyException)
{
if (!ProductExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
}
return(BadRequest());
}
public async Task <BaseResponse <ProductDto> > UpdateProduct(ProductUpdateRequestDto model)
{
var update = _mapper.Map <DbProduct>(model);
try
{
await PrepareImage(model, update);
var updated = await _productRepository.Update(update);
var result = _mapper.Map <ProductDto>(updated);
if (result.Image != null)
{
result.Image.Base64String = model.Image?.Base64String;
}
return(new SuccessResponse <ProductDto>(result));
}
catch (Exception ex)
{
return(new FailureResponse <ProductDto>(new[] { "Ошибка при обновлении продукта", ex.Message }));
}
}
public async Task <IActionResult> UpdateProduct(Guid id, ProductUpdateRequestDto productUpdateRequest)
{
try
{
_logger.LogDebug($"Received {nameof(UpdateProduct)} request with {{@ProductUpdateRequest}}", productUpdateRequest);
if (id != productUpdateRequest.Id)
{
return(BadRequest("Parameter mismatch between the route and the payload"));
}
await _service.UpdateAsync(_mapper.Map <Product>(productUpdateRequest));
_logger.LogDebug($"Returned {nameof(UpdateProduct)} response for Id {productUpdateRequest.Id}");
return(CreatedAtAction(nameof(UpdateProduct),
new { id = productUpdateRequest.Id },
productUpdateRequest.Id));
}
catch (ProductNotFoundException exception)
{
_logger.LogError(exception, exception.Message);
return(NotFound(exception.Message));
}
}
public UpdateProductCommand(Guid productId, ProductUpdateRequestDto productUpdateRequestDto)
{
ProductId = productId;
ProductUpdateRequestDto = productUpdateRequestDto;
}
public void Update(ProductUpdateRequestDto request)
{
DbImplementation.UpdateProduct(request);
}
public async Task<IActionResult> UpdateProduct(Guid productId,
[FromBody] ProductUpdateRequestDto productUpdateRequestDto)
{
var commandResult = await _mediator.Send(new UpdateProductCommand(productId, productUpdateRequestDto));
return commandResult ? Ok(commandResult.Result) : StatusCode(500, commandResult.FailureReason);
}
public void UpdateProduct(ProductUpdateRequestDto request)
{
string updateProductCommand = "UPDATE Products SET Name = '" + request.NewName + "', Price = " + FormatWithComma(request.NewPrice) + " WHERE Id='" + request.Id + "';";
CreateAndCommitTransaction(updateProductCommand);
}
