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)); }