public async Task UpdateProductAsync(int id, EditProductDto product, CancellationToken cancellationToken = default(CancellationToken))
{
var p = new Product
{
Id = id,
Name = product.Name,
Price = product.Price,
BrandId = product.BrandId,
CategoryId = product.CategoryId,
ManufactureCountryId = product.ManufactureCountryId
};
_dbContext.Attach(p).State = EntityState.Modified;
try
{
await _dbContext.SaveChangesAsync(cancellationToken);
}
catch (DbUpdateConcurrencyException ex)
{
throw new ItemNotFoundException(id, "Product", ex);
}
catch (DbUpdateException ex)
{
throw new InvalidItemException(p, ex);
}
}
public async Task <ServiceResponse <GetProductDto> > EditProductr(EditProductDto editProductr)
{
var product = await _dBContext.Product.FirstOrDefaultAsync(x => x.Id == editProductr.Id);
//var characters = await _dBContext.Characters.Include(x => x.Weapon).AsNoTracking().ToListAsync();
if (product == null)
{
return(ResponseResult.Failure <GetProductDto>("Product not found."));
}
var productgroup = await _dBContext.ProductGroup.Include(x => x.Product).FirstOrDefaultAsync(x => x.Id == editProductr.Id);
//var characters = await _dBContext.Characters.Include(x => x.Weapon).AsNoTracking().ToListAsync();
if (productgroup == null)
{
return(ResponseResult.Failure <GetProductDto>("ProductGroup not found."));
}
product.Name = editProductr.Name;
product.Price = editProductr.Price;
product.StockCount = editProductr.StockCount;
product.ProductGroupId = editProductr.ProductGroupId;
_dBContext.Product.Update(product);
await _dBContext.SaveChangesAsync();
var dto = _mapper.Map <GetProductDto>(product);
return(ResponseResult.Success(dto));
}
public async Task <ServiceResponse <GetProductDto> > EditProductr(EditProductDto editProduct)
{
var productgroup = await _dbContext.ProductGroups.FirstOrDefaultAsync(x => x.Id == editProduct.ProductGroupId);
if (productgroup == null)
{
return(ResponseResult.Failure <GetProductDto>("productgroup not found."));
}
var product = await _dbContext.Products.FirstOrDefaultAsync(x => x.Id == editProduct.Id);
//var characters = await _dBContext.Characters.Include(x => x.Weapon).AsNoTracking().ToListAsync();
if (product == null)
{
return(ResponseResult.Failure <GetProductDto>("Product not found."));
}
product.Name = editProduct.Name;
product.Price = editProduct.Price;
product.Qty = editProduct.Qty;
product.IsActive = editProduct.IsActive;
product.UserId = Guid.Parse(GetUserId());
product.CreatedDate = Now();
product.ProductGroupId = editProduct.ProductGroupId;
_dbContext.Products.Update(product);
await _dbContext.SaveChangesAsync();
var dto = _mapper.Map <GetProductDto>(product);
return(ResponseResult.Success(dto));
}
public async Task <ReturnData <bool> > EditAsync(int id, EditProductDto model)
{
var result = new ReturnData <bool>();
var check = await _context.Products.FirstOrDefaultAsync(i => i.Number == model.Number);
if (check != null)
{
result.Message = "存在相同编码，修改失败";
result.Result = false;
return(result);
}
var products = await _context.Products.FirstOrDefaultAsync(i => i.Id == id);
if (products != null)
{
var checktime = await CheckTimeOut.Check(products.LastUpTime, model.LastUpTime);
if (!checktime.Success)
{
return(checktime);
}
products.Name = model.Name;
products.LastUpTime = DateTime.Now;
products.Price = model.Price;
products.Number = model.Number;
}
result.Result = await _context.SaveChangesAsync() > 0;
return(result);
}
public void Edit(EditProductDto dto)
{
var product = _mapper.Map <Product>(dto);
ValidateProduct(product);
productMongoRepository.Edit(product);
}
public virtual ActionResult UpdateDetails(EditProductDto dto)
{
bool isSuccess = false;
string alertMessage = string.Empty;
if (ModelState.IsValid)
{
var duplicate = _inventoryService.GetAll().Where(i => i.ProductCode == dto.ProductCode && i.ProductId != dto.ProductId).Count();
if (duplicate >= 1)
{
alertMessage = string.Format(Messages.DuplicateItem, "Product");
}
else
{
ProductDto newDetails = new ProductDto()
{
ProductId = dto.ProductId,
CategoryId = dto.CategoryId,
QuantityUnitId = dto.QuantityUnitId,
ProductCode = dto.ProductCode,
ProductName = dto.ProductName,
ProductDescription = dto.ProductDescription,
ProductSize = dto.ProductSize,
CurrentNum = dto.CurrentNum,
DRNum = dto.DRNum,
CartonNum = dto.CartonNum,
Quantity = dto.Quantity
};
isSuccess = _inventoryService.UpdateDetails(newDetails);
if (!isSuccess)
{
alertMessage = string.Format(Messages.ErrorOccuredDuringProcessingThis, "updating in product");
}
else
{
alertMessage = Messages.UpdateSuccess;
}
}
}
else
{
alertMessage = Messages.ErrorOccuredDuringProcessingOrRequiredFields;
}
var jsonResult = new
{
isSuccess = isSuccess,
alertMessage = alertMessage
};
return(Json(jsonResult, JsonRequestBehavior.AllowGet));
}
public Product EditProduct(int id, EditProductDto productDto)
{
var product = GetProduct(id);
_context.Products.Update(product);
_context.SaveChanges();
return(product);
}
public async Task <IActionResult> Edit(int id, [FromBody] EditProductDto dto)
{
var command = new EditProductCommand(
id: id,
productName: dto.ProductName);
await _editHandler
.HandleAsync(command);
return(Ok());
}
public IActionResult EditProduct([FromQuery] int id, [FromBody] EditProductDto bookDto)
{
try
{
var result = _products.EditProduct(id, bookDto);
return(Ok(result));
}
catch (BadRequestException ex)
{
return(BadRequest(ex.Message));
}
}
/// <summary>
/// Edit Product details
/// </summary>
/// <param name="productDto">EditProductDto</param>
public ProductDto Edit(EditProductDto productDto)
{
var product = _unitOfWork.ProductRepository.GetById(productDto.Id) ?? throw new CustomException(HttpStatusCode.NotFound, Constants.ErrorProductNotFound);
var category = _unitOfWork.CategoryRepository.GetById(productDto.CategoryId) ?? throw new CustomException(HttpStatusCode.NotFound, Constants.ErrorCategoryNotFound);
product.CategoryId = category.Id;
product.Name = productDto.Name;
product.UnitPrice = productDto.UnitPrice;
product.AvailableQuantity = productDto.AvailableQuantity;
product.Image = productDto.Image;
_unitOfWork.Commit();
return(_mapper.Map <ProductDto>(product));
}
public async Task <bool> EditProductAsync(EditProductDto product)
{
var productEdit = await _dbContext.Products.FindAsync(product.Id);
productEdit.Code = product.Code;
productEdit.ExtraDescription = product.ExtraDescription;
productEdit.Price = product.Price;
productEdit.SpecialPrice = product.SpecialPrice;
productEdit.SizeId = product.Size.Id;
productEdit.ColorPrimaryId = product.ColorPrimary.Id;
productEdit.ColorSecondaryId = product.ColorSecondary.Id;
return(await _dbContext.SaveChangesAsync() > 0);
}
public IActionResult Edit(EditProductDto editProductDto)
{
try
{
var updatedProduct = _productService.Edit(editProductDto);
return(Ok(updatedProduct));
}
catch (CustomException exception)
{
_logger.LogError(exception.Message);
var message = exception.ErrorDetails;
return(StatusCode(message.StatusCode, message));
}
}
public async Task <IActionResult> Edit([FromRoute, Required] int productId, [FromBody] EditProductDto body)
{
try
{
return(await _mediator.Send(new EditProductCommand
{
ProductId = productId,
Body = body
}));
}
catch (Exception ex)
{
_logger.LogError(ex, "Error in {0}", HttpContext.Request.Path);
return(BadRequest(ErrorMessages.InternalExceptionModel));
}
}
public bool EditProduct(EditProductDto updatedProduct, Guid id)
{
using (var db = new SqlConnection(_connectionString))
{
var sql = @"Update [Product]
SET [Title] = @title,
[ImgUrl] = @imgUrl,
[TypeId] = @typeId,
[QuantityInStock] = @quantityInStock,
[Description] = @description,
[Price] = @price,
[CategoryId] = @categoryId
Where Id = @id";
updatedProduct.Id = id;
return(db.Execute(sql, updatedProduct) == 1);
}
}
public async Task <ServiceResponse <GetProductDto> > EditProduct(EditProductDto editProduct)
{
try
{
var product = await _dbContext.Products.FirstOrDefaultAsync(x => x.Id == editProduct.Id);
if (product is null)
{
var msg = $"This Product ID {editProduct.Id} not found.";
_log.LogError(msg);
return(ResponseResult.Failure <GetProductDto>(msg));
}
var productgroupId = await _dbContext.ProductGroups.FirstOrDefaultAsync(x => x.Id == editProduct.ProductGroupId);
if (productgroupId is null)
{
var msg = $"This Product Groups ID {editProduct.Id} not found.";
return(ResponseResult.Failure <GetProductDto>(msg));
}
product.Name = editProduct.Name;
product.StockCount = editProduct.StockCount;
product.Price = editProduct.Price;
product.ProductGroupId = editProduct.ProductGroupId;
_dbContext.Products.Update(product);
await _dbContext.SaveChangesAsync();
var productToReturn = await _dbContext.Products
.Include(x => x.ProductGroup)
.Where(x => x.Id == product.Id)
.FirstOrDefaultAsync();
_log.LogInformation("Update done.");
var dto = _mapper.Map <GetProductDto>(productToReturn);
return(ResponseResult.Success(dto));
}
catch (Exception ex)
{
_log.LogError(ex.Message);
return(ResponseResult.Failure <GetProductDto>(ex.Message));
}
}
public async Task <ServiceResponse <GetProductDto> > EditProduct(EditProductDto editProduct)
{
//Find product from id
var product = await _dBContext.Products.Include(x => x.ProductGroup).FirstOrDefaultAsync(x => x.Id == editProduct.Id);
//return if not found
if (product == null)
{
return(ResponseResult.Failure <GetProductDto>($"Product Id '{editProduct.Id}' is not found"));
}
var productGrp = await _dBContext.ProductGroups.FirstOrDefaultAsync(x => x.Id == editProduct.ProductGroupId);
if (productGrp == null)
{
return(ResponseResult.Failure <GetProductDto>($"ProductGroup Id {editProduct.ProductGroupId} is not found"));
}
//let's update data
try
{
product.Name = editProduct.Name;
product.Price = editProduct.Price;
product.ProductGroupId = editProduct.ProductGroupId;
product.StockCount = editProduct.StockCount;
product.IsActive = editProduct.IsActive;
//code update data
_dBContext.Update(product);
//Save update above
await _dBContext.SaveChangesAsync();
//Get productDto to return
GetProductDto prodDto = _mapper.Map <GetProductDto>(product);
return(ResponseResult.Success(prodDto));
}
catch (System.Exception ex)
{
//Write log
_log.LogError($"Update product is error detail: {ex.Message}");
//Return
return(ResponseResult.Failure <GetProductDto>($"Update product error detail: {ex.Message}"));
}
}
public async Task AddProductAsync(EditProductDto product, CancellationToken cancellationToken = default(CancellationToken))
{
var p = new Product
{
Name = product.Name,
Price = product.Price,
BrandId = product.BrandId,
CategoryId = product.CategoryId,
ManufactureCountryId = product.ManufactureCountryId
};
try
{
_dbContext.Add(p);
await _dbContext.SaveChangesAsync(cancellationToken);
}
catch (DbUpdateException ex)
{
throw new InvalidItemException(p, ex);
}
}
public async Task <IActionResult> EditProduct([FromBody] EditProductDto model)
{
var product = await _productsRepository
.GetByIdAsync(model.ProductId);
if (product == null)
{
return(BadRequest("Product not found or incorrent product id"));
}
product.Price = model.Price;
product.Name = model.Name;
product.Discount = model.Discount;
product.Description = model.Description;
product.PriceWithDiscount = _productService.CalculatePriceDiscount(product.Price, product.Discount);
product.IsAvailable = model.IsAvailable;
return(this.JsonResult(new
{
product,
Result = await _productsRepository.UpdateAsync(product)
}));
}
public async Task <ActionResult> Edit(int id, [FromBody] EditProductDto input)
{
if (id <= 0)
{
return(BadRequest("Invalid Product Id"));
}
var product = await _unitOfWork.GetRepo <Product>().GetByID(id);
if (product == null)
{
return(NotFound("There is no product with the specified Id"));
}
product.Edit(input.Name, input.Price);
if (await _unitOfWork.Complete())
{
return(Ok());
}
return(BadRequest($"Failed to edit product with Id : {id}"));
}
public async Task <IActionResult> Edit([FromForm] EditProductDto dataToEdit)
{
var oldData = await _productRepo.Find(dataToEdit.ProductId);
var pathToDelete = Path.Combine(_hostingEnvironment.WebRootPath, oldData.ImageUrl);
var imageUrl = oldData.ImageUrl;
if (oldData.ProductName != dataToEdit.ProductName)
{
if (!dataToEdit.isAddNewFiles)
{
var filesInOldFolder = Directory.GetFiles(pathToDelete);
if (filesInOldFolder.Count() > 0)
{
var newPath = Path.Combine(_hostingEnvironment.WebRootPath, _productImagesFolder + dataToEdit.ProductName);
if (!Directory.Exists(newPath))
{
System.IO.Directory.CreateDirectory(newPath);
}
foreach (var item in filesInOldFolder)
{
var sourceFile = Path.Combine(pathToDelete, Path.GetFileName(item));
var destFile = Path.Combine(newPath, Path.GetFileName(item));
System.IO.File.Copy(sourceFile, destFile, true);
}
}
imageUrl = _productImagesFolder + dataToEdit.ProductName;
}
else
{
if (Request.Form.Files.Count > 0)
{
imageUrl = await UploadFile(Request.Form.Files, dataToEdit.ProductName);
}
}
DeleteAllFileInPath(pathToDelete);
}
else
{
if (dataToEdit.isAddNewFiles)
{
DeleteAllFileInPath(pathToDelete);
if (Request.Form.Files.Count > 0)
{
imageUrl = await UploadFile(Request.Form.Files, dataToEdit.ProductName);
}
}
}
var product = _mapper.Map <Product>(dataToEdit);
product.ImageUrl = imageUrl;
var isUpdate = await _productRepo.UpdateAsync(product, dataToEdit.ProductId);
if (isUpdate != null)
{
return(CreatedAtRoute("GetProducts", null));
}
else
{
return(BadRequest());
}
}
public async Task <IActionResult> OutStock(EditProductDto model, int id)
{
var result = await _service.EditAsync(id, model);
return(Ok(result));
}
public async Task <IActionResult> EditProduct(EditProductDto editProduct)
{
return(Ok(await _proService.EditProduct(editProduct)));
}
public async Task <IActionResult> EditProduct([FromRoute] int productHeaderId, [FromBody] EditProductDto product)
{
try
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (!await _productRepository.ProductHeaderExistsAsync(productHeaderId))
{
return(NotFound());
}
if (!await _productRepository.ProductExistsAsync(productHeaderId, product.Id))
{
ModelState.AddModelError("product", "Product not found");
return(BadRequest(ModelState));
}
if (await _productRepository.IsDuplicateProductAsync(productHeaderId, product))
{
ModelState.AddModelError("product", "Product already exists");
return(BadRequest(ModelState));
}
var wasProductEdited = await _productRepository.EditProductAsync(product);
if (wasProductEdited)
{
return(Ok());
}
return(NoContent());
}
catch (Exception e)
{
_logger.LogCritical($"PUT {Route}/{productHeaderId}/products - {e.GetType().Name} - {e.Message} - {e.StackTrace}");
return(StatusCode(500, "An error ocurred in server"));
}
}
public Task Post([FromBody] EditProductDto product)
{
return(_productsService.AddProductAsync(product, HttpContext.RequestAborted));
}
public IActionResult EditProduct(EditProductDto editedProduct, Guid id)
{
_repo.EditProduct(editedProduct, id);
return(Ok());
}
public Task Put(int productId, [FromBody] EditProductDto product)
{
return(_productsService.UpdateProductAsync(productId, product, HttpContext.RequestAborted));
}
public async Task <bool> IsDuplicateProductAsync(int productHeaderId, EditProductDto product)
{
return(await _dbContext.Products.AnyAsync(c =>
c.Code.Equals(product.Code, StringComparison.InvariantCultureIgnoreCase) && c.Id != product.Id));
}
