public async Task <IActionResult> PutAsync(int id, [FromBody] SaveProductResource resource)
{
try
{
Log.Logger.Information("Update product {@resource} was executed", resource);
var product = _mapper.Map <SaveProductResource, Product>(resource);
var result = await _productService.UpdateAsync(id, product);
if (!result.Success)
{
return(BadRequest(new ErrorResource(result.Message)));
}
var productResource = _mapper.Map <Product, ProductResource>(result.Resource);
Log.Logger.Information("Product {@resource} updated successfully", productResource);
return(Ok(productResource));
}
catch (Exception ex)
{
Log.Logger.Error(ex, "Error trying to update product: {@resource}. Error: {error}", resource, ex.Message);
return(BadRequest(ex.Message));
}
}
public async Task <ActionResult <ProductResource> > UpdateProduct(int id, [FromBody] SaveProductResource saveProductResource)
{
var validator = new SaveProductResourceValidator();
var validationResult = await validator.ValidateAsync(saveProductResource);
var requestIsInvalid = id == 0 || !validationResult.IsValid;
if (requestIsInvalid)
{
return(BadRequest(validationResult.Errors)); // this needs refining, but for demo it is ok
}
var productToBeUpdate = await _productService.GetProductById(id);
if (productToBeUpdate == null)
{
return(NotFound());
}
var product = _mapper.Map <SaveProductResource, Product>(saveProductResource);
await _productService.UpdateProduct(productToBeUpdate, product);
var updatedProduct = await _productService.GetProductById(id);
var updatedProductResource = _mapper.Map <Product, ProductResource>(updatedProduct);
return(Ok(updatedProductResource));
}
public async Task <IActionResult> PostAsync([FromBody] SaveProductResource resource)
{
try
{
Log.Logger.Information("Add new product {@resource} was executed", resource);
if (!ModelState.IsValid)
{
return(BadRequest(ModelState.GetErrorMessages()));
}
var product = _mapper.Map <SaveProductResource, Product>(resource);
var result = await _productService.SaveAsync(product);
if (!result.Success)
{
return(BadRequest(new ErrorResource(result.Message)));
}
var productResource = _mapper.Map <Product, ProductResource>(result.Resource);
Log.Logger.Information("Product {@resource} added successfully", productResource);
return(Ok(productResource));
}
catch (Exception ex)
{
Log.Logger.Error(ex, "Error trying to add new product: {@resource}. Error: {error}", resource, ex.Message);
return(BadRequest(ex.Message));
}
}
public async Task <IActionResult> PostAsync([FromBody] SaveProductResource resource)
{
// validating the request data
if (!ModelState.IsValid)
{
return(BadRequest(ModelState.GetErrorMessages()));
}
// mapping the resource to our model
var product = _mapper.Map <SaveProductResource, Product>(resource);
// get result from model (return response)
var result = await _productService.SaveAsync(product);
// API returns a bad request
if (!result.Success)
{
return(BadRequest(result.Message));
}
// API maps the new category (now including data such as the new Id) to our previously created ProductResource
// get product from response
var productResource = _mapper.Map <Product, ProductResource>(result.Product);
// sends it to the client
return(Ok(productResource));
}
public ProductResource AddProduct([FromBody] SaveProductResource resource)
{
var product = mapper.Map <SaveProductResource, Product>(resource);
var result = productService.AddProduct(product);
var productResource = mapper.Map <Product, ProductResource>(result);
return(productResource);
}
public async Task <ActionResult <ProductResource> > Create(SaveProductResource productResource)
{
var product = mapper.Map <SaveProductResource, Product>(productResource);
var newProduct = await service.Create(product);
var returnProduct = mapper.Map <Product, ProductResource>(newProduct);
return(CreatedAtAction(nameof(GetAll), new { id = product.Id }, returnProduct));
}
public ProductResource EditProduct(int id, [FromBody] SaveProductResource resource)
{
var product = mapper.Map <SaveProductResource, Product>(resource);
product.Id = id;
var result = productService.EditProduct(product);
var productResource = mapper.Map <Product, ProductResource>(result);
return(productResource);
}
public async Task <IActionResult> PutAsync(int id, [FromBody] SaveProductResource resource)
{
var product = _mapper.Map <SaveProductResource, Product>(resource);
var result = await _productService.UpdateAsync(id, product);
if (!result.Success)
{
return(BadRequest(result.Message));
}
var productResource = _mapper.Map <Product, ProductResource>(result.Resource);
return(Ok(productResource));
}
public async Task <IActionResult> PostAsync([FromBody] SaveProductResource resource)
{
var product = _mapper.Map <SaveProductResource, Product>(resource);
var result = await _productService.SaveAsync(product);
if (!result.Success)
{
return(BadRequest(new ErrorResource(result.Message)));
}
var productResource = _mapper.Map <Product, ProductResource>(result.Product);
return(Ok(productResource));
}
public async Task<IActionResult> PutAsync(int id, [FromBody]SaveProductResource resource)
{
if (!ModelState.IsValid)
return BadRequest(ModelState.GetErrorMessages());
var product = mapper.Map<SaveProductResource, Product>(resource);
var result = await productService.UpdateAsync(id, product);
if (!result.Success)
return BadRequest(result.Message);
var productResource = mapper.Map<Product, ProductResource>(result.Product);
return Ok(productResource);
}
public async Task <IActionResult> Post([FromBody] SaveProductResource resource)
{
var product = _mapper.Map <SaveProductResource, Product>(resource);
var result = await _productService.InsertAsync(product);
var productResource = _mapper.Map <Product, ProductResource>(result.Resource);
if (!result.Success)
{
return(BadRequest());
}
return(Ok(productResource));
}
public async Task <IActionResult> PutAsync(int id, [FromBody] SaveProductResource resource)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState.GetErrorMessages()));
}
var product = mapper.Map <SaveProductResource, Product>(resource);
var productResponse = await productService.UpdateAsync(id, product);
var productResource = mapper.Map <Product, ProductResource>(productResponse.Product);
var result = productResponse.GetResponseResult(productResource);
return(Ok(result));
}
public void Test_UpdateProduct()
{
var saveproduct = new SaveProductResource
{
Description = "testUpdate"
};
var product = Mapper.Map <SaveProductResource, Product>(saveproduct);
product.Id = 101;
_mockService.Setup(x => x.EditProduct(product)).Returns(product);
var actual = _sut.EditProduct(product.Id, saveproduct);
Assert.IsNull(actual);
}
public void Test_AddProduct()
{
var saveproduct = new SaveProductResource
{
Description = "testAdd"
};
var product = Mapper.Map <Product>(saveproduct);
product.Id = GetProductData().ToList().Max(i => i.Id) + 1;
_mockService.Setup(x => x.AddProduct(product)).Returns(product);
var actual = _sut.AddProduct(saveproduct);
Assert.IsNull(actual);
}
public async Task <IActionResult> Post([FromBody]
SaveProductResource resource)
{
var category = _mapper.Map <SaveProductResource, Product>(resource);
var result = await _productService.Save(category);
if (!result.Success)
{
return(BadRequest(result.Message));
}
var productResource = _mapper.Map <Product, ProductResource>(result.Resource);
return(Ok(productResource));
}
public async Task <IActionResult> PostAsync([FromBody] SaveProductResource resource)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState.GetErrorMessages()));
}
var product = _mapper.Map <SaveProductResource, Product>(resource);
var result = await _productService.SaveAsync(product);
if (!result.Success)
{
return(BadRequest(result.Message));
}
return(Ok(_mapper.Map <Product, ProductResource>(result.Resource)));
}
public async Task <IActionResult> AddProductAsync([FromBody] SaveProductResource saveProductResource)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var product = Mapper.Map <SaveProductResource, Product>(saveProductResource);
productRepository.Add(product);
await unitOfWork.CompleteAsync();
product = await productRepository.GetProduct(product.Id);
var productResource = mapper.Map <Product, ProductResource>(product);
return(Ok(productResource));
}
public async Task <IActionResult> UpdateProduct(int id, [FromBody] SaveProductResource updateProductResource)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState.GetErrorMessages()));
}
var mappedProduct = _mapper.Map <SaveProductResource, Product>(updateProductResource);
var result = await _productService.Update(id, mappedProduct);
if (!result.Success)
{
return(BadRequest(result.Message));
}
var productResource = _mapper.Map <Product, ProductResource>(result.Product);
return(Ok(productResource));
}
public async Task <ActionResult> RegisterByTypeProductId(int typeproductId, [FromBody] SaveProductResource saveProductResource)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState.GetErrorMessages()));
}
var entity = _mapper.Map <SaveProductResource, Product>(saveProductResource);
var result = await _product.SaveByTypeProductIdAsync(typeproductId, entity);
if (!result.Success)
{
return(BadRequest(result.Message));
}
var Resource = _mapper.Map <Product, ProductResource>(result.Product);
return(Ok(Resource));
}
public async Task <IActionResult> PutAsync(int id, [FromBody] SaveProductResource resource)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState.GetErrorMessages()));
}
var product = _mapper.Map <SaveProductResource, Product>(resource); //create instance of product
var result = await _productService.UpdateAsync(id, product); //Update instance
if (!result.Success)
{
return(BadRequest(result.Message));
}
var ProductResource = _mapper.Map <Product, ProductResource>(result.Product);
return(Ok(ProductResource));
}
public async Task <IActionResult> PostAsync([FromBody] SaveProductResource resource)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState.GetErrorMessages()));
}
var product = _mapper.Map <SaveProductResource, Product>(resource);
var result = await _productService.SaveAsync(product);
if (!result.Success)
{
return(BadRequest(result.Message));
}
var productResource = (List <ProductResource>)_mapper.Map <IEnumerable <Product>, IEnumerable <ProductResource> >(result.Product);
return(CreatedAtRoute("NewProduct", new { id = productResource[0].Id.ToString() }, productResource));
}
public async Task <IActionResult> UpdateProduct(int id, [FromBody] SaveProductResource producToUpdate)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
Product product = await productRepository.GetProduct(id);
if (product == null)
{
return(NotFound());
}
mapper.Map <SaveProductResource, Product>(producToUpdate, product);
await unitOfWork.CompleteAsync();
product = await productRepository.GetProduct(product.Id);
return(Ok(mapper.Map <Product, ProductResource>(product)));
}
public async Task <IActionResult> PutAsync(int id, [FromBody] SaveProductResource resource)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState.GetErrorMessages()));
}
var product = _mapper.Map <SaveProductResource, Product>(resource);
var result = await _productService.UpdateAsync(id, product);
if (!result.Success)
{
return(BadRequest(result.Message));
}
var productResource = _mapper.Map <IEnumerable <Product>, IEnumerable <ProductResource> >(result.Product);
return(Ok(productResource));
}
public async Task <IActionResult> PutAsync(int id, [FromBody] SaveProductResource resource, CancellationToken cancellationToken)
{
if (!ModelState.IsValid)
{
return(BadRequest(new ErrorResource("invalid request")));
}
var product = _mapper.Map <SaveProductResource, Product>(resource);
var result = await _productService.UpdateAsync(id, product, cancellationToken);
if (!result.Success)
{
return(BadRequest(new ErrorResource(result.Message)));
}
var productResource = _mapper.Map <Product, ProductResource>(result.Resource);
return(Ok(productResource));
}
public async Task <ActionResult <ProductResource> > CreateProduct([FromBody] SaveProductResource saveProductResource)
{
var validator = new SaveProductResourceValidator();
var validationResult = await validator.ValidateAsync(saveProductResource);
if (!validationResult.IsValid)
{
return(BadRequest(validationResult.Errors)); // this needs refining, but for demo it is ok
}
var productToCreate = _mapper.Map <SaveProductResource, Product>(saveProductResource);
var newProduct = await _productService.CreateProduct(productToCreate);
var product = await _productService.GetProductById(newProduct.ProductId);
var productResource = _mapper.Map <Product, ProductResource>(product);
return(Ok(productResource));
}
public async Task <IActionResult> UpdateProductAsync(long id, [FromBody] SaveProductResource productResource)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var product = _mapper.Map <SaveProductResource, Product>(productResource);
var result = await _productService.UpdateProductAsync(id, product);
if (!result.Success)
{
return(BadRequest(result.Message));
}
var resource = _mapper.Map <Product, ProductResource>(result.Product);
return(Ok(resource));
}
public async Task <IActionResult> PutProductAsync(int id, [FromBody] SaveProductResource Resource)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState.GetErrorMessages()));
}
//Map category model to SaveCategory Resource
var resources = _mapper.Map <SaveProductResource, Product>(Resource);
var result = await _productService.UpdateProductAsync(id, resources);
//check if response is successful
if (!result._isSuccessful)
{
return(BadRequest(result._message));
}
//map
var ProductCategory = _mapper.Map <Product, ProductResource>(result.Product);
return(Ok(ProductCategory));
}
public async Task <IActionResult> PutAsync(int id, [FromBody] SaveProductResource resource)
{
var validator = new ProductValidator();
var validationResult = validator.ValidateIfNullModel(resource);
if (!validationResult.IsValid)
{
return(ValidationErrorResult.Create(validationResult, typeof(SaveProductResource).Name));
}
var product = _mapper.Map <SaveProductResource, Product>(resource);
var result = await _productService.UpdateAsync(id, product);
if (!result.Success)
{
return(BadRequest(new ErrorResource(result.Message)));
}
var productResource = _mapper.Map <Product, ProductResource>(result.Product);
return(Ok(productResource));
}
public async Task <IActionResult> CreateProduct([FromBody] SaveProductResource productResource)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var product = mapper.Map <SaveProductResource, Product>(productResource);
product.LastUpdate = DateTime.Now;
repository.Add(product);
await unitOfWork.CompleteAsync();
product = await repository.GetProduct(product.Id);
var result = mapper.Map <Product, ProductResource>(product);
return(Ok(result));
}
public async Task <IActionResult> UpdateProduct(int id, [FromBody] SaveProductResource productResource)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var product = await repository.GetProduct(id);
if (product == null)
{
return(NotFound());
}
mapper.Map <SaveProductResource, Product>(productResource, product);
product.LastUpdate = DateTime.Now;
// context.Articles.Add(article);
await unitOfWork.CompleteAsync();
var result = mapper.Map <Product, ProductResource>(product);
return(Ok(result));
}
