public async Task EditProductAsync(EditProductRequest request, CancellationToken ct)
{
request.Validate();
if (request.Price == 0)
{
throw new Exception("O preço do produto não pode ser R$0,00");
}
var product = request.ConvertToEntity();
var productregistred = await _productRepository.GetProductByIdAsync(product.ProductId, ct);
if (productregistred == null || productregistred.ProductId == Guid.Empty)
{
throw new Exception("Produto não encotrado para o ID fornecido");
}
if (request.File != null)
{
var urlImage = await ManagerImage.SaveFileAsync(request.File);
product.UrlImage = urlImage;
ManagerImage.DeleteFile(productregistred.UrlImage);
}
else
{
product.UrlImage = productregistred.UrlImage;
}
await _productRepository.EditProductAsync(product, ct);
}
//[Authorize(Roles = "manager, publisher")]
public async Task <ActionResult> EditGame(int productId, [FromBody] EditProductRequest request)
{
var gameModel = request.ToProductModel();
await _productService.Edit(productId, gameModel);
return(Ok());
}
private StringContent GetItemJson(string name)
{
var request = new EditProductRequest()
{
Name = name
};
var jsonContent = new StringContent(JsonConvert.SerializeObject(request), Encoding.UTF8, "application/json");
return(jsonContent);
}
public static Product ToProductModel(this EditProductRequest request)
{
return(new Product
{
Description = request.Description,
Name = request.Name,
Availability = request.Availability,
ManufacturerId = request.ManufacturerId,
Price = request.Price,
CategoryId = request.CategoryId,
});
}
public string Edit(Product product)
{
string response = null;
var result = new EditProductRequest(product).Execute(Api.Client);
if (result.Status == 200)
{
response = result.Data;
product.Clean();
}
return(response);
}
public async Task <IHttpActionResult> EditProduct(EditProductRequest request, CancellationToken cancellationToken)
{
try
{
var command = mapper.Map <EditProductCommnand>(request);
var response = await mediator.Send(command, cancellationToken);
return(Ok(response));
}
catch (NullReferenceException ex)
{
return(BadRequest(ex.Message));
}
}
public async Task <IActionResult> Edit([FromRoute] int sku, [FromBody] EditProductRequest model)
{
if (ModelState.IsValid)
{
var command = _mapper.ConvertRequestToCommand <EditProductCommand>(model);
command.Sku = sku;
await _mediator.Send(command);
return(NoContent());
}
return(BadRequest(ModelState.ToErrorResponse()));
}
public async Task <IActionResult> EditProductAsync([FromForm] EditProductRequest request, CancellationToken ct)
{
try
{
ct.ThrowIfCancellationRequested();
await _productService.EditProductAsync(request, ct);
return(Ok(new RequestResponse {
Message = "Produto registrado com sucesso"
}));
}
catch (Exception ex)
{
return(BadRequest(ex));
}
}
public async Task Products_Edit_ReturnsCreatedResponse()
{
var createModel = new CreateProductRequest
(
sku: random.Next(10, int.MaxValue)
, name: "TEST"
, inventory: new CreateProductInventoryRequest
(
warehouses: new CreateProductWarehouseRequest[]
{
new CreateProductWarehouseRequest(quantity: 10, locality: "SP", type: "MAIN_STORAGE"),
new CreateProductWarehouseRequest(quantity: 2, locality: "RJ", type: "ECOMMERCE")
}
)
);
await _controller.Create(new ApiVersion(1, 0), createModel);
var editModel = new EditProductRequest(
name: "UPDATED",
inventory: new EditProductInventoryRequest
(
warehouses: new EditProductWarehouseRequest[]
{
new EditProductWarehouseRequest(quantity: 15, locality: "SP", type: "MAIN_STORAGE"),
new EditProductWarehouseRequest(quantity: 3, locality: "RJ", type: "ECOMMERCE"),
new EditProductWarehouseRequest(quantity: 2, locality: "MG", type: "CONTAINER")
}
)
);
var result = await _controller.Edit(sku : createModel.Sku, model : editModel);
var actual = Assert.IsType <NoContentResult>(result);
var expect = (int)HttpStatusCode.NoContent;
Assert.Equal(expect, actual.StatusCode);
}
public async Task Products_Edit_NotFoundSku_ThrowsApiException()
{
var model = new EditProductRequest
(
name: "TEST"
, inventory: new EditProductInventoryRequest
(
warehouses: new EditProductWarehouseRequest[]
{
new EditProductWarehouseRequest(quantity: 1, locality: "SP", type: "MAIN_STORAGE")
}
)
);
var actual = await Assert.ThrowsAsync <ApiException>(() => _controller.Edit(sku: int.MaxValue, model));
var expectCode = ErrorConstants.ProductNotFound.Code;
var expectName = ErrorConstants.ProductNotFound.Name;
var expectMessage = ErrorConstants.ProductNotFound.Message;
Assert.Equal(expectCode, actual.Code);
Assert.Equal(expectName, actual.Name);
Assert.Equal(expectMessage, actual.Message);
}
public async Task Products_Edit_DuplicatedWarehouses_ThrowsApiException()
{
var createModel = new CreateProductRequest
(
sku: random.Next(3, int.MaxValue)
, name: "TEST"
, inventory: new CreateProductInventoryRequest
(
warehouses: new CreateProductWarehouseRequest[]
{
new CreateProductWarehouseRequest(quantity: 10, locality: "SP", type: "MAIN_STORAGE"),
new CreateProductWarehouseRequest(quantity: 2, locality: "RJ", type: "ECOMMERCE")
}
)
);
await _controller.Create(new ApiVersion(1, 0), createModel);
var editModel = new EditProductRequest(
name: "UPDATED",
inventory: new EditProductInventoryRequest
(
warehouses: new EditProductWarehouseRequest[]
{
new EditProductWarehouseRequest(quantity: 15, locality: "SP", type: "MAIN_STORAGE"),
new EditProductWarehouseRequest(quantity: 3, locality: "RJ", type: "ECOMMERCE"),
new EditProductWarehouseRequest(quantity: 2, locality: "RJ", type: "ECOMMERCE")
}
)
);
var actual = await Assert.ThrowsAsync <ValidationException>(() => _controller.Edit(sku: createModel.Sku, model: editModel));
Assert.Contains(actual.Errors, x => x.ErrorMessage.Equals("The warehouse must be unique."));
Assert.Contains(actual.Errors, x => x.PropertyName.Equals(nameof(CreateProductInventoryRequest.Warehouses)));
}
public async Task Products_Edit_InvalidBody_ThrowsApiException()
{
var model = new EditProductRequest(name: "TEST", inventory: null);
await Assert.ThrowsAsync <ArgumentNullException>(() => _controller.Edit(sku: int.MaxValue, model));
}
public async Task <IActionResult> EditProduct([FromRoute(Name = "product_id")] Int32 productId, [FromBody] EditProductRequest request)
{
// validate input
if (!ModelState.IsValid)
{
return(HttpResult.BadRequest(ModelState));
}
// locate product
var foundProduct = await _bagsContext.Products
.WithUnsafeIncludes()
.Where(product => product.Id == productId)
.SingleOrDefaultAsync();
if (foundProduct == null)
{
return(HttpResult.NotFound($"{productId}"));
}
// update the product
foundProduct.Name = request.Name;
if (request.Images != null)
{
foundProduct.ImagesJson = JsonConvert.SerializeObject(request.Images);
}
await _bagsContext.SaveChangesAsync();
return(HttpResult.Ok(foundProduct.ToUnsafeExpandedWireFormat(_amazon)));
}
public async Task <ProductDto> EditProduct(int productId, [FromBody] EditProductRequest request, CancellationToken cancellationToken = default)
{
return(await _productService.EditProductAsync(productId, request.Name, cancellationToken));
}
