public override async Task <UpdateProductResponse> UpdateProduct(UpdateProductRequest request, ServerCallContext context)
{
var productId = request.Product?.Id;
if (productId == null)
{
throw new RpcException(new Status(StatusCode.InvalidArgument, "Invalid product id to UpdateProduct"));
}
var result = _ProductsDataStore.FirstOrDefault(predicate => predicate.Id == productId);
if (result == null)
{
throw new RpcException(new Status(StatusCode.NotFound, $"The Product id {productId} wasn't found"));
}
result.Name = request.Product?.Name;
result.Description = request.Product?.Description;
//just test, return same product
return(await Task.FromResult(new UpdateProductResponse()
{
Product = request.Product
}));
}
public override async Task <ProductModel> UpdateProduct(UpdateProductRequest request, ServerCallContext context)
{
// 1. Mapping ProductModel to Product
var product = _mapper.Map <Product>(request.Product);
bool isExist = await _productsContext.Product.AnyAsync(p => p.ProductId == product.ProductId);
if (!isExist)
{
_logger.LogError($"Error: Product with ID = {product.ProductId} is not found.");
return(new ProductModel());
}
_productsContext.Entry(product).State = EntityState.Modified;
try
{
// 2. Update Product to Database
await _productsContext.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException exception)
{
_logger.LogError($"Error: {exception.Message}");
return(new ProductModel());
}
// 3. Resturn response: ProductModel
return(_mapper.Map <ProductModel>(product));
}
public async Task WhenPut_AndProductExists_AndPriceChanged_ThenNameChangedInRepo_AndStatusIs200()
{
// Arrange
var productId = 1;
var existingProduct = new Product(productId, "test product", 123);
_mockProductRepository
.Setup(x => x.GetProduct(It.IsAny <int>()))
.ReturnsAsync(existingProduct);
var newPrice = 321;
var request = new UpdateProductRequest
{
Price = newPrice
};
// Act
var result = await _controller.Put(productId, request);
// Assert
_mockProductRepository
.Verify(x => x.UpdateProduct(It.Is <Product>(y => y.Price == newPrice)), Times.Once);
result.Should().BeOfType(typeof(OkResult));
}
public Product Update(UpdateProductRequest model)
{
var product = AutoMapper.Mapper.Map <Product>(model);
_productRepository.Edit(product);
return(product);
}
public async Task <MessageResponse> Update(UpdateProductRequest request)
{
try
{
using (UnitOfWork uow = new UnitOfWork())
{
var product = mapper.Map <UpdateProductRequest, Product>(request);
// check category
if (request.ThumbnailImage != null)
{
product.Image = await fileService.UploadFileAsync(request.ThumbnailImage);
}
else
{
var p = await GetById(request.Id);
product.Image = p.ImagePath;
}
if (request.IsSoldOut)
{
product.Status = Data.Enums.ProductStatus.SoldOut;
}
uow.Products.Update(product);
await uow.SaveAsync();
return(new MessageResponse("success", "Cập nhật thành công"));
}
}
catch (Exception e)
{
return(new MessageResponse("error", "Cập nhật thất bại", $"Lỗi: {e.Message}"));
}
}
public void Should_Update_Product()
{
string randomString = $"{DateTime.Now:yyyyMMddHHmmssfff}";
CreateProductRequest createProductRequest = new CreateProductRequest
{
Description = "product-description",
Locale = Locale.TR.ToString(),
Name = $"product-name-{randomString}",
ConversationId = "123456789"
};
ProductResource productResource = Product.Create(createProductRequest, _options).Data;
UpdateProductRequest updateProductRequest = new UpdateProductRequest
{
Description = "updated-description",
Locale = Locale.TR.ToString(),
Name = $"updated-product-name-{randomString}",
ConversationId = "123456789",
ProductReferenceCode = productResource.ReferenceCode
};
ResponseData <ProductResource> response = Product.Update(updateProductRequest, _options);
PrintResponse(response);
Assert.AreEqual(response.Status, Status.SUCCESS.ToString());
Assert.AreEqual($"updated-product-name-{randomString}", response.Data.Name);
Assert.AreEqual("updated-description", response.Data.Description);
Assert.AreEqual(productResource.ReferenceCode, response.Data.ReferenceCode);
Assert.IsNotNull(response.SystemTime);
Assert.Null(response.ErrorMessage);
}
public UpdateProductResponse UpdateProduct(UpdateProductRequest request)
{
var response = new UpdateProductResponse {
Errors = new List <Error>()
};
try
{
Repository.UpdateProduct(request.ProductEntity);
response.Message = "Product updated successfully!";
}
catch (Exception ex)
{
response.Errors.Add(
new Error
{
CustomisedMessage = "Unable to update product",
StackTrace = ex.StackTrace,
SystemMessage = ex.Message,
});
Logger.Fatal(request);
Logger.Fatal(response, ex);
}
return(response);
}
//根据产品PK更新产品信息，如产品名称和产品描述
private static void TestUpdateProduct()
{
IClientProfile clientProfile = DefaultProfile.GetProfile("<your-region-id>", "<your-access-key-id>", "<your-access-key-secret>");
DefaultAcsClient client = new DefaultAcsClient(clientProfile);
UpdateProductRequest request = new UpdateProductRequest();
//更新的产品来源于CreateProductResponse
request.ProductKey = "<productKey>";
request.ProductName = "<productName>";
request.ProductDesc = "<productDesc>";
try
{
UpdateProductResponse response = client.GetAcsResponse(request);
Console.WriteLine(response.Success);
Console.WriteLine(response.ErrorMessage);
}
catch (ServerException e)
{
Console.WriteLine(e.ErrorCode);
Console.WriteLine(e.ErrorMessage);
}
catch (ClientException e)
{
Console.WriteLine(e.ErrorCode);
Console.WriteLine(e.ErrorMessage);
}
Console.ReadKey();
}
public void Update_InvalidObjectPassed_ReturnsBadRequest2()
{
// Arrange
var request = new UpdateProductRequest()
{
Id = 1,
ExpirationDate = DateTime.Now.AddDays(30),
CategoryIds = new int[] { 1, 2, 3 },
Rating = 11,
Name = "Test",
BrandId = 1,
};
_productController.ModelState.AddModelError("Rating", "Rating is out of range");
// Act
var badResponse = _productController.Update(request).Result;
// Assert
Assert.IsType <BadRequestObjectResult>(badResponse);
var response = (badResponse as BadRequestObjectResult).Value as SerializableError;
Assert.Equal(1, response.Count);
}
public async Task <UpdateProductResponse> CreateProduct([FromBody] UpdateProductRequest request)
{
/* VALIDATE */
var validator = _validatorResolver.Resolve <UpdateProductRequestValidator>();
ValidationResult validationResult = validator.Validate(request);
if (!validationResult.IsValid)
{
throw new ValidationException(validationResult.ToString());
}
var product = _mapper.Map <Product>(request);
product.CreatedOnUtc = DateTime.UtcNow;
product.UpdatedOnUtc = DateTime.UtcNow;
product.SKU = generateSku();
product.IsActive = true;
product.IsDeleted = false;
await _productService.CreateProduct(product);
var productResponse = _mapper.Map <UpdateProductResponse>(product);
return(productResponse);
}
public async Task <ResponseDTO> ValidateEntityUpdate(UpdateProductRequest request)
{
Expression <Func <ProductDTO, bool> > queryFilter = p => p.RowStatus;
var result = "";
queryFilter = p => p.RowStatus;
queryFilter = queryFilter.And(p => p.ProductId != request.ProductId);
queryFilter = queryFilter.And(p => p.Name == request.Name || p.ShortName == request.ShortName);
var product = await _productDataAcces.FirstOrDefaultAsync(queryFilter);
if (product != null)
{
result = "There is a product that contain some information that your are trying to update, try with another.";
}
var response = new ResponseDTO()
{
IsValid = string.IsNullOrEmpty(result),
Messages = new List <ApplicationMessage>()
};
response.Messages.Add(new ApplicationMessage()
{
Key = string.IsNullOrEmpty(result) ? "Ok" : "Error",
Message = result
});
return(response);
}
public async Task <UpdateProductResponse> UpdateProduct([FromBody] UpdateProductRequest request)
{
/* VALIDATE */
var validator = _validatorResolver.Resolve <UpdateProductRequestValidator>();
ValidationResult validationResult = validator.Validate(request);
if (!validationResult.IsValid)
{
throw new ValidationException(validationResult.ToString());
}
var product = await _productService.GetProductBySku(request.SKU);
if (ControlHelper.isEmpty(product))
{
throw new NotFoundException(nameof(Product));
}
product.ProductName = request.ProductName;
product.Description = request.Description;
product.Price = request.Price;
product.Quantity = request.Quantity;
await _productService.UpdateProduct(product);
var productResponse = _mapper.Map <UpdateProductResponse>(product);
return(productResponse);
}
public Product UpdateProduct(UpdateProductRequest request)
{
Name = request.Name;
Description = request.Description;
Price = request.Price;
ImageUrl = request.ImageUrl;
if (!string.IsNullOrEmpty(request.InventoryId))
{
InventoryId = request.InventoryId.ConvertTo <Guid>();
}
Updated = NewDateTime();
AddDomainEvent(new ProductUpdated
{
ProductId = Id.ToString(),
Name = Name,
Price = Price,
ImageUrl = ImageUrl,
Description = Description
});
return(this);
}
public override async Task <ProductModel> UpdateProduct(UpdateProductRequest request, ServerCallContext context)
{
var product = _mapper.Map <Product>(request.Product);
bool isExist = await _productDbContext.Product.AnyAsync(p => p.ProductId == product.ProductId);
if (!isExist)
{
throw new RpcException(new Status(StatusCode.NotFound, $"Product with ID={product.ProductId} is not found."));
}
_productDbContext.Entry(product).State = EntityState.Modified;
try
{
await _productDbContext.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
throw;
}
var productModel = _mapper.Map <ProductModel>(product);
return(productModel);
}
public async Task <IActionResult> Update([FromRoute] int productId, [FromBody] UpdateProductRequest updateToProduct)
{
if (ModelState.IsValid)
{
if (updateToProduct.Id.Equals(productId))
{
Product product = new Product
{
Id = productId,
Name = _capitalize.ToCapitalize(updateToProduct.Name),
Price = updateToProduct.Price
};
var updated = await _productrServices.UpdateProductAsync(product);
if (updated != null)
{
return(Ok(await _productrServices.GetProductsAsync()));
}
return(NotFound("Data Not Updated"));
}
return(ValidationProblem("route and data id need to be same"));
}
return(ValidationProblem());
}
public async Task <IActionResult> UpdateAsynk([FromRoute] Guid productId, [FromBody] UpdateProductRequest request)
{
var userOwnProduct = await _productService.UserOwnProductAsynk(productId, HttpContext.GetUserId());
if (!userOwnProduct)
{
return(BadRequest(new { error = "You do not have access to this product." }));
}
var product = await _productService.GetProductByIdAsynk(productId);
product.Name = request.Name;
product.Description = request.Description;
product.Quantity = request.Quantity;
product.Url = request.Url;
product.Price = request.Price;
var update = await _productService.UpdateProductAsynk(product);
if (update)
{
return(Ok(new Response <ProductResponse>(_mapper.Map <ProductResponse>(product))));
}
return(NotFound());
}
public async Task update_response_no_conent_if_product_is_updated()
{
var product = Builders.Product()
.WithName("product#1")
.Build();
await _fixture.Given
.AddProduct(product);
var request = new UpdateProductRequest()
{
ProductId = product.Id,
Name = "product#2",
Description = "description for product#2"
};
var response = await _fixture.TestServer
.CreateRequest(ApiDefinitions.V1.Product.Update())
.WithIdentity(Builders.Identity().WithDefaultClaims().Build())
.PutAsJsonAsync(request);
response.StatusCode
.Should()
.Be(StatusCodes.Status204NoContent);
}
public async Task update_response_no_content_if_product_is_updated()
{
var permission = Builders.Permission()
.WithManagementPermission()
.Build();
await _fixture.Given
.AddPermission(permission);
var product = Builders.Product()
.WithName("fooproduct")
.Build();
await _fixture.Given
.AddProduct(product);
var request = new UpdateProductRequest()
{
Name = "barproduct",
Description = "description for product#2"
};
var response = await _fixture.TestServer
.CreateRequest(ApiDefinitions.V3.Product.Update(product.Name))
.WithIdentity(Builders.Identity().WithDefaultClaims().Build())
.PutAsJsonAsync(request);
response.StatusCode
.Should()
.Be(StatusCodes.Status204NoContent);
}
public async Task update_response_forbidden_if_user_is_not_authorized()
{
var permission = Builders.Permission()
.WithReaderPermission()
.Build();
await _fixture.Given
.AddPermission(permission);
var product = Builders.Product()
.WithName("fooproduct")
.Build();
await _fixture.Given
.AddProduct(product);
var request = new UpdateProductRequest()
{
Name = "barpdroduct",
Description = "description for product#2"
};
var response = await _fixture.TestServer
.CreateRequest(ApiDefinitions.V3.Product.Update(product.Name))
.WithIdentity(Builders.Identity().WithDefaultClaims().Build())
.PutAsJsonAsync(request);
response.StatusCode
.Should()
.Be(StatusCodes.Status403Forbidden);
}
public async Task <Product> UpdateProductAsync(UpdateProductRequest request)
{
using (var context = _factory.GetContext())
{
Product product = context.Products.Find(request.Id);
if (product == null)
{
return(null);
}
Product productReq = _mapper.Map <Product>(request);
context.Entry(product).CurrentValues.SetValues(productReq);
var categoryProducts = context.CategoryProducts.Where(c => c.ProductId == request.Id).ToList();
context.RemoveRange(categoryProducts);
foreach (var id in request.CategoryIds)
{
CategoryProduct categoryProduct = new CategoryProduct {
CategoryId = id, ProductId = product.Id
};
context.CategoryProducts.Add(categoryProduct);
}
context.SaveChanges();
return(await GetProductByIdAsync(product.Id));
}
}
/// <inheritdoc/>
public async Task <Product> UpdateProductAsync(int productId, UpdateProductRequest updateRequest)
{
var dbProducts = await _context.Products.Where(p => p.Code == updateRequest.Code && p.Id != productId).ToArrayAsync();
if (dbProducts.Length > 0)
{
throw new RequestedResourceHasConflictException("code");
}
dbProducts = await _context.Products.Where(p => p.Id == productId).ToArrayAsync();
if (dbProducts.Length == 0)
{
throw new RequestedResourceNotFoundException();
}
var dbProduct = dbProducts[0];
_mapper.Map(updateRequest, dbProduct);
dbProduct.LastUpdatedBy = _userContext.UserId;
await _context.SaveChangesAsync();
return(_mapper.Map <Product>(dbProduct));
}
public void Update_InvalidObjectPassed_ReturnsBadRequest1()
{
// Arrange
var request = new UpdateProductRequest()
{
Id = 0,
ExpirationDate = DateTime.Now,
CategoryIds = new int[] { 10 },
};
_productController.ModelState.AddModelError("Id", "Id required");
_productController.ModelState.AddModelError("Name", "Name required");
_productController.ModelState.AddModelError("Rating", "Rating required");
_productController.ModelState.AddModelError("BrandId", "Invalid Brand");
_productController.ModelState.AddModelError("CategoryIds", "Invalid category");
_productController.ModelState.AddModelError("ExpirationDate", "Expiration date should expire not less than 30 days since now");
// Act
var badResponse = _productController.Update(request).Result;
// Assert
Assert.IsType <BadRequestObjectResult>(badResponse);
var response = (badResponse as BadRequestObjectResult).Value as SerializableError;
Assert.Equal(6, response.Count);
}
public async Task UpdateProduct(UpdateProductRequest updateProductRequest)
{
Product existing = await GetProductIfExists(updateProductRequest.Id)
?? throw new EntityNotFoundException("No product found with prodict id {productId}");;
_mapper.Map(updateProductRequest, existing);
await _productRepo.UpdateProduct(existing);
}
public async Task <IActionResult> Update(string productName, UpdateProductRequest request, CancellationToken cancellationToken = default)
{
request.CurrentName = productName;
await _mediator.Send(request, cancellationToken);
return(NoContent());
}
public async Task <RegisteredProduct> Handle(UpdateProductRequest request, CancellationToken cancellationToken)
{
var product = request.ToEntity();
this._dbContext.Products.Attach(product).State = EntityState.Modified;
await this._dbContext.SaveChangesAsync();
return(product.ToDTO());
}
public async Task <ResponseDTO> Update(UpdateProductRequest product)
{
if (ModelState.IsValid)
{
product.IsHazardous = product.IsHazardousBool.Value ? "1" : "0";
return(await _productsApplicationService.UpdateProductAsync(product));
}
return(ModelState.ToResponse());
}
public async Task <UpdateProductResponse> Handle(UpdateProductRequest message)
{
var result = await _productRepository.Update(message.Product);
return(new UpdateProductResponse
{
Success = result
});
}
public async Task <ProductEntity> UpdateProductAsync(UpdateProductRequest request)
{
var model = new ProductEntity()
{
ProductId = request.ProductId, Name = request.Name, Description = request.Description, Title = request.Title
};
return(await _repository.UpdateAsync(model));
}
public async Task <IActionResult> Update([FromForm] UpdateProductRequest request)
{
MessageResponse message = await productService.Update(request);
ViewBag.ImagePath = await userService.GetImageAsync(User.Identity.Name);
ShowMessage(message);
return(View(request));
}
public async Task <IActionResult> Put(string sku, [FromBody] UpdateProductRequest request)
{
var product = await _repository.FindBySkuAsync(sku);
product.Update(request.DisplayName, request.UnitPrice, request.Description);
await _repository.UnitOfWork.SaveChangesAsync();
return(Ok(product));
}
public ActionResult Update(UpdateProductRequest request, int? authuid)
{
request.AuthUid = authuid.Value;
request.Description = UrlDecode(request.Description);
request.Favorable = UrlDecode(request.Favorable);
request.Name = UrlDecode(request.Name);
request.RecommendedReason = UrlDecode(request.RecommendedReason);
return new RestfulResult { Data = this._productDataService.UpdateProduct(request) };
}
public ExecuteResult<ProductInfoResponse> UpdateProduct(UpdateProductRequest request)
{
if (request == null)
{
return new ExecuteResult<ProductInfoResponse>(null) { StatusCode = StatusCode.ClientError, Message = "参数错误" };
}
var entity = _productRepository.GetItem(request.ProductId);
if (entity == null)
{
return new ExecuteResult<ProductInfoResponse>(null) { StatusCode = StatusCode.ClientError, Message = "参数错误,没有找到指定product" };
}
if (request.RecommendUser == 0)
{
request.RecommendUser = request.AuthUid;
}
var source = MappingManager.ProductEntityMapping(request);
source.CreatedDate = entity.CreatedDate;
source.CreatedUser = entity.CreatedUser;
source.Status = entity.Status;
source.FavoriteCount = entity.FavoriteCount;
source.InvolvedCount = entity.InvolvedCount;
source.ShareCount = entity.ShareCount;
MappingManager.ProductEntityMapping(source, entity);
_productRepository.Update(entity);
return new ExecuteResult<ProductInfoResponse>(MappingManager.ProductInfoResponseMapping(entity));
}