public async Task <ServiceResponse <GetProductDto> > UpdateProduct(UpdateProductDto updatedProduct)
{
ServiceResponse <GetProductDto> serviceResponse = new ServiceResponse <GetProductDto>();
try
{
Product product = await _context.Products.FirstOrDefaultAsync(p => p.ProductID == updatedProduct.ProductID);
if (product != null)
{
product.ProductName = updatedProduct.ProductName;
product.ListPrice = updatedProduct.ListPrice;
product.UnitsInStock = updatedProduct.UnitsInStock;
product.CategoryID = updatedProduct.CategoryID;
product.Description = updatedProduct.Description;
product.OrderedQuantity = updatedProduct.OrderedQuantity;
_context.Products.Update(product);
await _context.SaveChangesAsync();
serviceResponse.Data = _mapper.Map <GetProductDto>(product);
}
else
{
serviceResponse.Success = false;
serviceResponse.Message = "Product not found";
}
}
catch (Exception ex)
{
serviceResponse.Success = false;
serviceResponse.Message = ex.Message;
}
return(serviceResponse);
}
public void Put()
{
var target = new ProductsController(this._EFProductRepository, this._MockMapper);
var newProduct = new UpdateProductDto
{
Name = "TestProduct01-Edit",
Price = 20M,
Description = "Add description edit",
ProductTag = new List <UpdateProductTagDto>
{
new UpdateProductTagDto {
Name = "TestProduct01-Tag01-Edit"
},
new UpdateProductTagDto {
Name = "TestProduct01-Tag02-Edit"
}
},
ProductImage = new UpdateProductImageDto {
Url = "jysk.dk/TestProduct01-Edit/"
}
};
var okResult = target.Put(3, newProduct) as OkObjectResult;
var product = (ReturnProductDto)okResult.Value;
Assert.Equal(200, okResult.StatusCode);
Assert.Equal("TestProduct01-Edit", product.Name.ToString());
Assert.Equal(20M, product.Price);
Assert.Equal("Add description edit", product.Description.ToString());
Assert.Equal("TestProduct01-Tag01-Edit", product.ProductTag[0].Name.ToString());
Assert.Equal(2, product.ProductTag.Count());
}
public async Task <IActionResult> UpdateProduct(UpdateProductDto updateProductResource)
{
var product = _mapper.Map <UpdateProductDto, Product>(updateProductResource);
await _productService.UpdateProduct(product);
return(RedirectToAction("ProductList"));
}
public async Task <ServiceResponse <ProductDto> > UpdateProduct(UpdateProductDto updateProduct)
{
ServiceResponse <ProductDto> response = new ServiceResponse <ProductDto>();
Product product = await _db.Products
.Include(x => x.ProductGroup)
.Include(x => x.Promotions)
.FirstOrDefaultAsync(x => x.ProductId == updateProduct.ProductId);
if (product == null)
{
// response.IsSuccess = false;
// response.Message = "ProductId not Found";
return(ResponseResult.Failure <ProductDto>("ProductId not Found"));
}
try
{
product.ProductDetail = updateProduct.ProductDetail;
product.ProductGroupId = updateProduct.ProductGroupId;
product.PromotionId = updateProduct.PromotionId;
product.Stock = updateProduct.Stock;
product.Price = updateProduct.Price;
product.UpdateDate = DateTime.Now;
_db.Products.Update(product);
await _db.SaveChangesAsync();
response.Data = _mapper.Map <ProductDto>(product);
}
catch (Exception ex)
{
response.IsSuccess = false;
response.Message = ex.Message;
}
return(response);
}
public void Execute(UpdateProductDto request)
{
if (_context.Products.Any(x => x.Id == request.Id))
{
var oneProduct = _context.Products.Find(request.Id);
if (request.Name == oneProduct.Name)
{
_validator.ValidateAndThrow(request);
oneProduct.Name = request.Name;
oneProduct.Description = request.Description;
oneProduct.Price = request.Price;
//oneProduct.Slika = UploadJedneSlike.UploadJednaSlika(request.Slika);
oneProduct.Quantity += request.Quantity;
oneProduct.ModifiedAt = DateTime.Now;
_context.SaveChanges();
}
else
{
_validatorName.ValidateAndThrow(request);
oneProduct.Name = request.Name;
oneProduct.Description = request.Description;
oneProduct.Price = request.Price;
//oneProduct.Slika = UploadJedneSlike.UploadJednaSlika(request.Slika);
oneProduct.Quantity += request.Quantity;
oneProduct.ModifiedAt = DateTime.Now;
_context.SaveChanges();
}
}
else
{
throw new EntityNotFoundException(request.Id, typeof(Product));
}
}
public async Task <IActionResult> UpdateProductAsync([FromBody] UpdateProductDto request)
{
try
{
var updateProductCommand = new UpdateProductCommand(request.ProductKey, request.EffectiveStartDate, request.ProductName, request.ProductDisplayName, request.PrintIssn, request.OnlineIssn,
request.ProductTypeCode, request.ProductStatusCode, request.PublisherProductCode, request.LegacyIdSpid);
await _mediator.Send(updateProductCommand);
return(Ok());
}
catch (Exception ex)
{
_logger.LogError(ex, "Something went wrong in AddProductAsync");
var errorResponse = new ProblemDetails()
{
Title = "An unexpected error occurred. Please try again later.",
Status = StatusCodes.Status500InternalServerError,
Detail = ex.Message
};
return(StatusCode(StatusCodes.Status500InternalServerError, errorResponse));
}
}
public void Update(Guid id, UpdateProductDto product)
{
Product productToUpdate = _repository.GetByFilter <Product>(p => p.Id == id);
if (productToUpdate == null)
{
return;
}
if (product.CategoryId != null)
{
productToUpdate.CategoryId = product.CategoryId;
}
if (product.Name != null)
{
productToUpdate.Name = product.Name;
}
if (product.Description != null)
{
productToUpdate.Description = product.Description;
}
if (product.StartPrice != 0 && productToUpdate.FinalPrice == null)
{
productToUpdate.StartPrice = product.StartPrice;
}
if (product.Deadline > DateTime.Now)
{
productToUpdate.Deadline = product.Deadline;
}
_repository.Update(productToUpdate);
_repository.Save();
}
public async Task <ProductDto> UpdateProduct(UpdateProductDto input)
{
Product product = await _productRepository.GetAll().Where(p => p.Id == input.Id).FirstOrDefaultAsync();
product.UpdateProduct(input.Name, input.Price, input.Description);
_productRepository.Update(product);
return(ObjectMapper.Map <ProductDto>(product));
}
public async Task <ActionResult <ProductDto> > Put(int id, [FromBody] UpdateProductDto requestModel)
{
var item = await _query.Update(id, requestModel);
var model = _mapper.Map <ProductDto>(item);
return(model);
}
public Task <ApiResponse <string> > AddProduct(string id, UpdateProductDto productDto)
{
return(Catch(async() =>
{
var command = new UpdateProductCommand(id, productDto);
var result = await MessageBus.DispatchCommand(command);
return result.Payload;
}));
}
public async Task UpdateAsync(UpdateProductDto input)
{
// Remover primeiro as existentes
var productDb = _productManager.GetProductByID(input.Id);
foreach (var provider in productDb.Providers.ToList())
{
productDb.Providers.Remove(provider);
}
foreach (var providerId in input.ProviderIds)
{
var providerDb = _providerManager.GetProviderByID(providerId);
productDb.Providers.Add(providerDb);
}
// Se o estoque mudou, cria uma movimentação
if (productDb.Stock != input.Stock)
{
var userId = 1;
if (AbpSession.UserId != null)
{
userId = unchecked ((int)AbpSession.UserId);
}
User user = await _userManager.FindByIdAsync(userId);
var movement = new Movement();
movement.Product = productDb;
movement.User = user;
movement.PreviousQtd = productDb.Stock;
movement.CurrentQtd = input.Stock;
// Se o estoque aumentou, cria uma movimentação positiva
if (productDb.Stock > input.Stock)
{
movement.Signal = "-";
}
else
{
movement.Signal = "+";
}
await _movementManager.Create(movement);
}
productDb.Name = input.Name;
productDb.Description = input.Description;
productDb.Brand = input.Brand;
productDb.EntryDate = input.EntryDate;
productDb.ExpirationDate = input.ExpirationDate;
productDb.Value = input.Value;
productDb.Stock = input.Stock;
_productManager.Update(productDb);
}
public async Task <IActionResult> UpdateProduct(UpdateProductDto updatedProduct)
{
ServiceResponse <GetProductDto> response = await _productRepository.UpdateProduct(updatedProduct);
if (response.Data == null)
{
return(NotFound(response));
}
return(Ok(response));
}
public async Task UpdateProductAsync(UpdateProductDto updateProductDto)
{
var product = await _productRepository.FindAsync(updateProductDto.Id);
product.Name = updateProductDto.Name;
product.Feature = updateProductDto.Feature;
product.Description = updateProductDto.Description;
product.Price = updateProductDto.Price;
await _productRepository.UpdateAsync(product);
}
public async Task <IActionResult> Update(UpdateProductDto updateProductDto)
{
var response = await _services.UpdateProductAsync(updateProductDto);
if (!response.Success)
{
return(BadRequest(response));
}
return(Ok(response));
}
public async Task <IActionResult> Update(UpdateProductDto productDto)
{
if (!ModelState.IsValid)
{
ViewBag.CreateProductElements = (await _productService.GetCreateProductElements()).Data;
return(View(productDto));
}
IResult result = await _productService.UpdateProduct(productDto);
return(RedirectToAction(nameof(Products), "Product"));
}
public UpdateProductDto Update(UpdateProductDto entity, bool isSave = false)
{
var mapperOnject = mapper.Map <Product>(entity);
products.Update(mapperOnject);
if (isSave)
{
SaveChanges();
}
return(entity);
}
public IActionResult Render(UpdateProductDto request, Result <GetProductResponse> response)
{
if (!response.Status)
{
return(GetErrorResponse(response));
}
return(new ObjectResult(response.Data)
{
StatusCode = (int)(HttpStatusCode.Accepted)
});
}
/// <summary>
/// Update product
/// </summary>
/// <param name="productCommand"></param>
/// <returns></returns>
public async Task <UpdateProductDto> UpdateProduct(IUpdateProductCommand productCommand)
{
UpdateProductDto response = null;
try
{
var product = Product.CreateProduct(productCommand);
if (product == null)
{
return(await Task.Run(() => response = new UpdateProductDto(null)));
}
if (product.Errors.Count > 0)
{
return(await Task.Run(() => response = new UpdateProductDto(product)));
}
var existingProduct = _repository.Product.GetProductById(product.Id);
if (existingProduct != null)
{
var result = _repository.Product.GetByCondition(x =>
(x.Code.Equals(product.Code) || x.Name.Equals(product.Name)) && x.Id != product.Id);
if (result?.Count() == 0)
{
_repository.Product.UpdateProduct(existingProduct, product);
_repository.Save();
response = new UpdateProductDto(product);
}
}
else
{
response = new UpdateProductDto(product)
{
Errors = new List <Error>
{
new Error("Product", "Product doesn't exists")
}
};
}
return(await Task.Run(() => response));
}
catch (Exception e)
{
Console.WriteLine(e);
response = UpdateProductDto.PrepareExceptionResponse(null, "ERROR_SYSTEM");
return(await Task.Run(() => response));
}
}
public async Task <Result <GetProductResponse> > Handle(UpdateProductDto request, CancellationToken cancellationToken)
{
var serviceRequest = new UpdateProductRequest
{
CorrelationId = request.CorrelationId,
ProductCode = request.ProductCode,
ProductName = request.ProductDescription
};
var operation = await _mediator.Send(serviceRequest, cancellationToken);
return(operation);
}
public async Task <IActionResult> Update(Guid id, UpdateProductDto updateProductDto)
{
if (id == Guid.Empty)
{
return(BadRequest(Constants.InvalidIdError));
}
var updatedProduct = await _productService.UpdateProductAsync(id, updateProductDto);
var productDto = _mapper.Map <Product, ProductDto>(updatedProduct);
return(Ok(productDto));
}
public async Task<bool> UpdateProduct(UpdateProductDto updateProductDto)
{
var product = await _unitOfWork.ProductRepository.FindByIdAsync(updateProductDto.Id);
if(product != null)
{
var newProduct = _mapper.Map<UpdateProductDto, Products>(updateProductDto);
_unitOfWork.ProductRepository.Update(newProduct);
return await _unitOfWork.SaveAsync() > 0;
}
return await _unitOfWork.SaveAsync() > 0;
}
public static IEnumerable <ValidationResult> Validate(this UpdateProductDto updateProductDto)
{
if (updateProductDto.Name.StartsWith("-") ||
updateProductDto.Name.EndsWith("-"))
{
yield return(new ValidationResult(nameof(updateProductDto.Name), "Invalid product name", Constants.Constants.ModelInvalidError));
}
if (updateProductDto.DeliveryPrice < decimal.Zero || updateProductDto.Price <= decimal.Zero)
{
yield return(new ValidationResult(nameof(updateProductDto.Price), "Invalid product price/deliver price", Constants.Constants.ModelInvalidError));
}
}
public async Task <Product> UpdateProduct(int id, UpdateProductDto input, [Service] CatalogDbContext dbContext)
{
var product = await dbContext.Products.FindAsync(id);
product.Name = input.Name;
product.Price = input.Price;
product.Quantity = input.Quantity;
product.CategoryId = input.CategoryId;
product.Discontinued = input.Discontinued;
await dbContext.SaveChangesAsync();
return(product);
}
public ProductUpdatedEvent(UpdateProductDto product)
{
Id = product.Id;
if (product.Errors != null && product.Errors.Count > 0)
{
Errors = new List <IError>();
product.Errors?.ForEach(e =>
{
var createError = new Error(e.Field, e.Message);
Errors.Add(createError);
});
}
}
public async Task <Product> UpdateProduct(UpdateProductDto updatedproduct)
{
using (var context = new DataBaseContext())
{
Product product = await context.Products.FirstOrDefaultAsync(s => s.Id == updatedproduct.Id);
product.ProductName = updatedproduct.ProductName;
product.ProductDetail = updatedproduct.ProductDetail;
product.CategoryId = updatedproduct.CategoryId;
context.Products.Update(product);
await context.SaveChangesAsync();
return(product);
}
}
public IActionResult Put(string id, [FromBody] UpdateProductDto product)
{
try
{
_productsService.Update(id, product);
return(NoContent());
}
catch (ProductException ex)
{
return(StatusCode(StatusCodes.Status400BadRequest, ex.Message));
}
catch (Exception ex)
{
return(StatusCode(StatusCodes.Status500InternalServerError, "Something unexpected occurred. Please contact the system administration."));
}
}
public ServiceResult UpdateProduct(UpdateProductDto dto)
{
var serviceResult = dto.IsValid();
if (serviceResult.IsSuccess)
{
var entity = _dbContext
.Products
.AsNoTracking()
.FirstOrDefault(c => c.Id == dto.Id);
if (entity == null)
{
serviceResult.AddError("محصولی یافت نشد");
}
else
{
if (dto.ImageFile != null)
{
var uploadServiceResult = Upload(dto.ImageFile, FileType.ProductImage, 500 * 1024);
if (uploadServiceResult.IsSuccess)
{
dto.ImageName = uploadServiceResult.Data;
DeleteFile(entity.PrimaryImage, FileType.ProductImage);
}
else
{
serviceResult.AddError(uploadServiceResult.Errors.FirstOrDefault());
}
}
else
{
dto.ImageName = entity.PrimaryImage;
}
var updatedProduct = dto.ToEntity();
updatedProduct.ImagesJson = entity.ImagesJson;
Update(updatedProduct);
serviceResult = Save("محصول با موفقیت ویرایش شد");
}
}
return(serviceResult);
}
public HttpStatusCode UpdateProduct(int productId, UpdateProductDto updateProductDto, string userId)
{
Product product = _ctx.Products.FirstOrDefault(f => f.Id == productId);
product.Name = updateProductDto.ProductName;
product.IsPublished = updateProductDto.IsProductPublished;
product.LastModifiedDate = DateTime.Now;
Subcategory subcategory = _ctx.Subcategories.FirstOrDefault(f => f.Id == updateProductDto.SubcategoryId);
product.Subcategory = subcategory;
product.SubcategoryId = subcategory.Id;
try
{
_ctx.Entry(product).State = EntityState.Modified;
_ctx.SaveChanges();
}
catch (Exception ex)
{
return(HttpStatusCode.InternalServerError);
}
ApplicationUser user = _ctx.Users.FirstOrDefault(f => f.Id == userId);
SystemAttribute systemAttribute = _ctx.SystemAttributes.FirstOrDefault(f => f.Id == product.SystemAttributeId);
systemAttribute.IsPublished = updateProductDto.IsProductPublished;
systemAttribute.LastModifiedBy = user.UserName;
systemAttribute.LastModified = DateTime.Now;
systemAttribute.VersioNumber = systemAttribute.VersioNumber;
systemAttribute.Version++;
try
{
_ctx.Entry(systemAttribute).State = EntityState.Modified;
_ctx.SaveChanges();
}
catch (Exception ex)
{
return(HttpStatusCode.InternalServerError);
}
return(HttpStatusCode.OK);
}
public void UpdateProduct(UpdateProductDto updateProduct)
{
var product = _uow.Product.Table
.Include(e => e.ProductImage)
.FirstOrDefault(e => e.Id == updateProduct.Id);
if (product == null)
{
throw new BusinessException("Ürün bulunamadı.");
}
product.Name = updateProduct.Name;
product.Description = updateProduct.Description;
product.Image = updateProduct.MainPhoto;
product.ProductImage = updateProduct.Photos;
product.IsActive = updateProduct.IsActive;
product.Price = updateProduct.Price;
_uow.Product.Update(product);
var productCategories = _uow.ProductToCategory.Table
.Where(c => c.ProductId == updateProduct.Id);
foreach (var pCat in productCategories)
{
if (!updateProduct.CategoryIds.Contains(pCat.CategoryId))
{
_uow.ProductToCategory.Delete(pCat);
}
}
foreach (var pCatNew in updateProduct.CategoryIds)
{
if (!productCategories.Any(e => e.CategoryId == pCatNew && e.ProductId == updateProduct.Id))
{
_uow.ProductToCategory.Insert(new ProductToCategory
{
ProductId = updateProduct.Id,
CategoryId = pCatNew
});
}
}
_uow.SaveChanges();
}
public async Task <IActionResult> UpdateProduct(UpdateProductDto updateProduct)
{
try
{
ServiceResponse <ProductDto> response = await _productService.UpdateProduct(updateProduct);
if (response.Data == null)
{
return(NotFound(response));
}
return(Ok(response));
}
catch (Exception)
{
_logger.LogError("Failed to execute PUT");
return(BadRequest());
}
}
