public UpdateProductDTO UpdateProductById(long id, [FromBody] ProductUpdateRequest productUpdateRequest)
{
var foundProduct = _productService.FindById(new ProductFindRequest
{
ProductId = id
}).FoundProduct;
var responseJson = new UpdateProductDTO();
if (foundProduct != null)
{
productUpdateRequest.Id = id;
var updateResponse = _productService.UpdateById(productUpdateRequest);
if (updateResponse.HasValidationErrors() || updateResponse.HasDBErrors())
{
responseJson.validationErrors = _convertErrorsToString(updateResponse.ValidationErrors);
responseJson.dbErrors = updateResponse.DBErrors;
responseJson.status = Status.Failed;
}
else
{
responseJson.product = СonvertProductToDTO(updateResponse.UpdatedProduct);
responseJson.status = Status.Success;
}
}
return(responseJson);
}
//PUT: api/Products
public ProductDTO Put(UpdateProductDTO product)
{
ProductBusiness productBusiness = new ProductBusiness()
{
Id = product.Id,
Name = product.Name,
Description = product.Description,
Price = product.Price,
Category = product.Category,
Brand = product.Brand,
ImageName = product.ImageName,
Stock = product.Stock
};
var updatedProduct = _productService.UpdateStockProduct(productBusiness, product.NewStock);
ProductDTO productDTO = new ProductDTO()
{
Id = updatedProduct.Id,
Name = updatedProduct.Name,
Description = updatedProduct.Description,
Price = updatedProduct.Price,
Category = updatedProduct.Category,
Brand = updatedProduct.Brand,
ImageName = updatedProduct.ImageName,
Stock = updatedProduct.Stock
};
return(productDTO);
}
public ServiceResponse <Product> UpdateProduct(UpdateProductDTO newProduct)
{
try
{
var product = _productRepository.GetById(newProduct.Id);
if (product == null)
{
return(new ServiceResponse <Product> {
Success = false, Message = $"Product with Id: {newProduct.Id} does not exist"
});
}
_productRepository.Update(_mapper.Map <Product>(newProduct));
return(new ServiceResponse <Product> {
Message = $"Succesfully updated product: Id: { product.Id }"
});
}catch (Exception e)
{
var errorMesage = $"Error updating product: Error message: {e.Message + " " + e.InnerException?.Message ?? ""}";
return(new ServiceResponse <Product> {
Success = false, Message = errorMesage
});
}
}
public FullProductDTO Update(UpdateProductDTO model)
{
var mappedProduct = Mapper.Map <Product>(model);
context.Entry(mappedProduct).State = EntityState.Modified;
context.SaveChanges();
return(Mapper.Map <FullProductDTO>(mappedProduct));
}
public async Task <ActionResult> UpdateProduct(int Id, [FromForm] UpdateProductDTO update)
{
var existingProduct = await _productService.FindByIdAsync(Id);
if (existingProduct == null)
{
return(NotFound());
}
await _productService.UpdateProductAsync(existingProduct, update);
return(NoContent());
}
public IActionResult PatchProduct([FromRoute] Guid productId, [FromBody] UpdateProductDTO productChanges, [FromServices] UpdateProductCommand updateProductCommand)
{
AddTrace(updateProductCommand);
updateProductCommand.ProductUpdate = productChanges;
updateProductCommand.Execute();
if (!updateProductCommand.IsSuccesful)
{
Logger.Warn("Product patch failed, attempted changes: {@productChanges} ", productChanges);
return(BadRequest(updateProductCommand.Errors));
}
return(NoContent());
}
public async Task <IActionResult> Update(UpdateProductDTO dto)
{
var productDto = await service.Update(dto);
if (productDto != null)
{
return(Ok());
}
else
{
return(BadRequest($"{nameof(productDto)} is null"));
}
}
public async Task <ProductDTO> Update(UpdateProductDTO updateDto)
{
if (updateDto == null)
{
return(null);
}
var dto = ProductConverter.Convert(updateDto);
var product = ProductConverter.Convert(dto);
product = await unitOfWork.Repository <Product>().Update(product);
return(ProductConverter.Convert(product));
}
public static Product Convert(UpdateProductDTO product)
{
if (product == null)
{
throw new ArgumentNullException(nameof(product));
}
return(new Product
{
Id = product.Id,
Title = product.Title,
CategoryId = product.CategoryId
});
}
public ActionResult <FullProductDTO> Edit([FromBody] UpdateProductDTO model)
{
if (Service.VerifyCode(model.Code, model.Id))
{
Service.Update(model);
return(Ok(model));
}
else
{
return(BadRequest(new
{
codeNotUnique = true
}));
}
}
public async Task <ProductDTO> Update(UpdateProductDTO updateDto)
{
if (updateDto == null)
{
return(null);
}
var dto = ProductConverter.Convert(updateDto);
dto.Category = await unitOfWork.Repository <Category>().Get(dto.CategoryId);
//var product = ProductConverter.Convert(dto);
var product = ProductConverter.Convert(await unitOfWork.Repository <Product>().Update(dto));
//product = ProductConverter.Convert(await unitOfWork.ProductRepository.GetFull(dto.Id));
return(product);
}
public async Task <IActionResult> PutProduct(int id, UpdateProductDTO product)
{
if (id != product.Id)
{
return(BadRequest());
}
var completed = await productsService.PutProduct(id, mapper.Map <Product>(product));
if (!completed)
{
return(NotFound());
}
else
{
return(Ok());
}
}
public static ProductDTO Convert(UpdateProductDTO product)
{
if (product == null)
{
throw new ArgumentNullException(nameof(product));
}
return(new ProductDTO
{
Id = product.Id,
Title = product.Title,
BrandId = product.BrandId,
CategoryId = product.CategoryId,
Description = product.Description,
Price = product.Price,
Quantity = product.Quantity,
//IsDeleted = false
});
}
public async Task UpdateProductCommandTest_ShouldReturtCorrectResponse(UpdateProductDTO productDTO, Product mappedProduct, Product retrivedProduct, bool productAlreadyExists, ResponseModel response)
{
//Arrange
var mockProductRepository = new Mock <IProductRepository>();
mockProductRepository.Setup(x => x.GetByIdAsync(It.IsAny <long>(), It.IsAny <CancellationToken>())).Returns(Task.FromResult(retrivedProduct));
mockProductRepository.Setup(x => x.ProductExists(It.IsAny <string>(), It.IsAny <long>(), It.IsAny <CancellationToken>())).Returns(Task.FromResult(productAlreadyExists));
mockProductRepository.Setup(x => x.UpdateAsync(It.IsAny <Product>(), It.IsAny <CancellationToken>())).Returns(Task.FromResult(default(object)));
var mockMapper = new Mock <IMapper>();
mockMapper.Setup(x => x.Map <Product>(It.IsAny <UpdateProductDTO>())).Returns(mappedProduct);
//Act
var handler = new UpdateProdcutCommand.UpdateProdcutCommandHandler(mockProductRepository.Object, mockMapper.Object);
var handledResponse = await handler.Handle(new UpdateProdcutCommand(productDTO), new CancellationToken());
//Assert
Assert.AreEqual(handledResponse.ResponseType, response.ResponseType);
Assert.AreEqual(handledResponse.Message, response.Message);
}
public UpdateProductDTO ParseProductForUpdate(List <string> values)
{
if (values.Count() < 5)
{
_logger.LogError(@"Error parsing while updating product. Not enough arguments");
return(null);
}
try
{
var product = new UpdateProductDTO
{
Id = int.Parse(values[0]),
Name = values[1],
PortionCount = int.Parse(values[2]),
Unit = values[3],
PortionSize = double.Parse(values[4])
};
if (product.PortionCount < 0)
{
_logger.LogError(@"Portion Count can't be negative integer");
return(null);
}
if (product.PortionSize < 0)
{
_logger.LogError(@"Portion size can't be negative integer");
return(null);
}
return(product);
}
catch (Exception e)
{
_logger.LogError($"Error parsing while updating product. Error message: {e.Message + " " + e.InnerException?.Message ?? ""}");
return(null);
}
}
public IHttpActionResult Post([FromBody] UpdateProductDTO model)
{
short memberId = _dataAccessProvider.GetMemberId(AuthKey);
if (memberId != -1)
{
if (ModelState.IsValid)
{
if (!_dataAccessProvider.IsProductExist(model.ProductID))
{
return(new ResponseMessageResult(Request.CreateErrorResponse((HttpStatusCode)404, new HttpError("Product Not Found"))));
}
string result = _dataAccessProvider.SaveProduct(model.ProductID, model.ProductGroup, model.StartDate, model.EndDate, model.Subject, model.Content,
model.OnHandStock, model.StandardPrice, model.MembershipPrice, memberId, model.IPAddress);
if (result.Length == 0)
{
return(Ok());
}
return(new ResponseMessageResult(Request.CreateErrorResponse((HttpStatusCode)422, new HttpError(Common.Common.ReplaceError(result)))));
}
return(new ResponseMessageResult(Request.CreateErrorResponse((HttpStatusCode)422, new HttpError("Form Error"))));
}
return(Unauthorized());
}
public async Task <IActionResult> UpdateProductAsUser(int productId, [FromForm] UpdateProductDTO product)
{
var userId = _userManager.GetUserId(User);
return(Ok(await _productService.UpdateAsUserAsync(productId, userId, product)));
}
/// <summary>
/// this method updates product in database
/// throws an exception on failure
/// </summary>
/// <param name="model">category model</param>
/// <param name="id">category id</param>
public async Task <ReadProductDTO> UpdateAsUserAsync(int id, string currentUserId, UpdateProductDTO productDTO)
{
var product = await _productRepository.GetByIdWithDetailsAsync(id);
if (product == null || currentUserId != product.UserId)
{
throw new AuctionException("Product not found", System.Net.HttpStatusCode.NotFound);
}
var photopath = productDTO.Photo == null ? null : await _fileManager.SaveImage(productDTO.Photo);
if (photopath != null)
{
_fileManager.DeleteImage(product.PhotoPath);
product.PhotoPath = photopath;
}
product = _mapper.Map(productDTO, product);
product.UserId = currentUserId;
_productRepository.Update(product);
await _productRepository.SaveAsync();
return(_mapper.Map <ReadProductDTO>(product));
}
public Task <string> UpdateAsync(UpdateProductDTO model, int id)
{
throw new NotImplementedException();
}
public async Task UpdateProductAsync(Product product, UpdateProductDTO update)
{
_mapper.Map <UpdateProductDTO, Product>(update, product);
await _context.SaveChangesAsync();
}
public UpdateProdcutCommand(UpdateProductDTO product)
{
Product = product;
}
public async Task <IActionResult> UpdateProduct([FromBody] UpdateProductDTO product)
{
var commandResult = await _mediator.Send(new UpdateProdcutCommand(product));
return(Ok(commandResult));
}
