public ActionResult PutProductOption(Guid productId, Guid productOptionId, ProductOptionDto productOption)
{
if (productId != productOption.ProductId)
{
string message = "product id [" + productId + "] does not match ProductId provided inside the product option request [" + productOption.ProductId + "]";
_logger.LogError(message);
return(BadRequest(message));
}
if (productOptionId != productOption.Id)
{
string message = "product option id [" + productOptionId + "] does not match Id provided inside the product option request [" + productOption.Id + "]";
_logger.LogError(message);
return(BadRequest(message));
}
try
{
_productsService.UpdateProductOption(_productOptionConverter.ToDO(productOption));
}
catch (InvalidArgumentException e)
{
return(BadRequest(e.Message));
}
catch (NotFoundException e)
{
return(NotFound(e.Message));
}
return(NoContent());
}
public IHttpActionResult Post(Guid id, [FromBody] ProductOptionDto productOption)
{
try
{
if (productOption == null || productOption.ProductId != id)
{
return(BadRequest());
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (!_productRepository.ProductExists(id))
{
return(NotFound());
}
var productOptionToAdd = Mapper.Map <ProductOption>(productOption);
_productOptionRepository.AddProductOptionToProduct(productOptionToAdd, id);
if (!_productOptionRepository.Save())
{
return(new ResponseMessageResult(new HttpResponseMessage(HttpStatusCode.InternalServerError)));
}
return(new ResponseMessageResult(new HttpResponseMessage(HttpStatusCode.Created)));
}
catch (Exception ex)
{
return(new ResponseMessageResult(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ex.Message)));
}
}
public ProductOptionDomain(ProductDomain root, ProductOptionDto dto)
{
Root = root;
Id = dto.Id;
Name = dto.Name;
Status = dto.Status ?? ProductOptionStatus.ACTIVE;
}
public IHttpActionResult Put(Guid id, Guid optionId, [FromBody] ProductOptionDto productOption)
{
try
{
if (productOption == null || productOption.ProductId != id || productOption.Id != optionId)
{
return(BadRequest());
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (!_productOptionRepository.ProductOptionExists(optionId))
{
return(NotFound());
}
var productOptionToUpdate = Mapper.Map <ProductOption>(productOption);
_productOptionRepository.UpdateProductOption(productOptionToUpdate);
if (!_productOptionRepository.Save())
{
return(InternalServerError());
}
return(new ResponseMessageResult(new HttpResponseMessage(HttpStatusCode.OK)));
}
catch (Exception ex)
{
return(new ResponseMessageResult(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ex.Message)));
}
}
public IHttpActionResult UpdateProductOption(Guid productId, Guid optionId, ProductOptionDto productOptionDto)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var productOption = _context.ProductOptions.SingleOrDefault(p => p.ProductId.Equals(productId) && p.Id.Equals(optionId));
if (productOption == null)
{
return(NotFound());
}
productOption.Name = productOptionDto.Name;
productOption.Description = productOptionDto.Description;
productOption.ProductId = productId;
try
{
_context.SaveChanges();
}
catch (Exception ex)
{
throw ex;
}
return(Ok());
}
public IHttpActionResult CreateProductOption(Guid productId, ProductOptionDto productOptionDto)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
if (_context.ProductOptions.Count(p => p.ProductId.Equals(productId) && p.Id.Equals(productOptionDto.Id)) > 0)
{
return(Conflict());
}
ProductOption newproductOptionDto = new ProductOption
{
Id = productOptionDto.Id,
ProductId = productId,
Name = productOptionDto.Name,
Description = productOptionDto.Description
};
try
{
_context.ProductOptions.Add(newproductOptionDto);
_context.SaveChanges();
}
catch (Exception ex)
{
throw ex;
}
return(Ok());
}
public async Task <IHttpActionResult> CreateOptionAsync(Guid productId, [FromBody] ProductOptionDto productOption)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
// Verify product ID is valid
var productToAddOptionTo = await _productRepository.GetByIdAsync(productId);
if (productToAddOptionTo == null)
{
return(BadRequest("Product doesn't exist."));
}
// Map Dto to Model
var productOptionToCreate = new ProductOption();
productOptionToCreate.MapDto(productOption, productId);
await _productOptionsRepository.SaveAsync(productId, productOptionToCreate);
// Verify save was successful
var newProductOption = await _productOptionsRepository.GetByIdAsync(productOptionToCreate.Id, productId);
if (newProductOption == null)
{
return(InternalServerError());
}
else
{
return(Created(new EntityUrlByID(Url.Request.RequestUri, newProductOption.Id).ToString(), newProductOption));
}
}
private void AddOption(ProductOptionDto dto)
{
var optionDomain = new ProductOptionDomain(this, dto);
Options.Add(optionDomain);
AddIntegratedEvent(ProductEventType.PRODUCT_OPTION_ADDED, dto.Id);
Modify();
}
private void UpdateOption(ProductOptionDomain optionDomain, ProductOptionDto dto)
{
optionDomain.Update(dto);
if (optionDomain.Modified)
{
AddIntegratedEvent(ProductEventType.PRODUCT_OPTION_UPDATED, dto.Id);
Modify();
}
}
public async Task AddAsync(ProductOptionDto productOptionDto)
{
var productOption = ProductOption.Create(productOptionDto.ProductId,
productOptionDto.Name,
productOptionDto.Description);
var product = await _productRepository.GetAsync(productOptionDto.ProductId);
product.AddProductOption(productOption);
await this._unitOfWork.CommitAsync();
}
public async Task UpdateAsync(Guid productId,
Guid productOptionId,
ProductOptionDto productOption)
{
var product = await _productRepository.GetAsync(productId);
product.UpdateProductOption(productOptionId,
productOption.Name,
productOption.Description);
await this._unitOfWork.CommitAsync();
}
public ActionResult PostProductOption(Guid productId, ProductOptionDto productOption)
{
try
{
productOption.ProductId = productId;
productOption = _productOptionConverter.FromDO(_productsService.CreateProductOption(productId, _productOptionConverter.ToDO(productOption)));
return(CreatedAtAction("GetProductOption", new { productId = productOption.ProductId, productOptionId = productOption.Id }, productOption));
} catch (InvalidArgumentException e)
{
return(BadRequest(e.Message));
}
}
public async Task <ActionResult> Add(ProductOptionDto productOptionDto)
{
try
{
await _productOptionService.AddAsync(productOptionDto);
return(Ok());
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
/// <summary>
/// Builds a mock of a ProductOptionDto
/// </summary>
/// <param name="productId">The id of the related product. If it not specified then a new random Guid will be created and assigned to this mock</param>
/// <returns></returns>
public static ProductOptionDto ProductOptionBuildOne(Guid?productId)
{
if (productId.GetValueOrDefault() == Guid.Empty)
{
productId = Guid.NewGuid();
}
var faker = new Bogus.Faker();
var prod = new ProductOptionDto();
prod.Name = faker.Commerce.Product();
prod.Description = faker.Commerce.ProductMaterial();
return(prod);
}
public static ProductOption ToDomainEntity(this ProductOptionDto model)
{
if (model == null)
{
return(null);
}
return(new ProductOption()
{
Id = model.Id,
Name = model.Name,
Description = model.Description
});
}
public async Task <IActionResult> CreateOptionAsync(Guid id, [FromBody] ProductOptionDto productOptionDto)
{
var product = await _productService.GetProductByIdAsync(id);
if (product == null)
{
return(NotFound());
}
var productOption = _mapper.ToProductOption(productOptionDto);
await _productService.UpdateProductAsync(product, productOption);
return(Created($"{Request?.Scheme}://{Request?.Host}{Request?.PathBase}{Request?.Path}/{productOption?.Id}", productOptionDto));
}
public ActionResult GetProductOption(Guid productId, Guid productOptionId)
{
try
{
ProductOptionDto po = _productOptionConverter.FromDO(_productsService.GetProductOption(productId, productOptionId));
if (po == null)
{
return(NotFound("product option with id [" + productOptionId + "] not found"));
}
return(Ok(po));
} catch (NotFoundException e)
{
return(NotFound(e.Message));
}
}
public async Task <bool> UpdateProductOptionAsync(ProductOptionDto productOptionDto)
{
var(product, productOption) =
await FindProductAndProductOption(productOptionDto.ProductId, productOptionDto.Id);
if (product is null || productOption is null)
{
return(false);
}
productOption.Update(productOptionDto.Name, productOptionDto.Description);
await _productRepository.UnitOfWork.SaveChangesAsync();
return(true);
}
public void ToDOTest()
{
ProductOptionDto dto = new ProductOptionDto
{
Id = Guid.NewGuid(),
Name = "Dummy",
Description = ""
};
ProductOption model = converter.ToDO(dto);
Assert.IsNotNull(model);
Assert.AreEqual(dto.Id, model.Id);
Assert.AreEqual(dto.Name, model.Name);
Assert.AreEqual(dto.Description, model.Description);
}
public ProductDtoBuilder WithOption(ProductOptionDto option)
{
if (Options == null)
{
Options = new List <ProductOptionDto>();
}
if (Options.Any(v => v.Index == option.Index))
{
throw new InvalidOperationException("Duplicate option index");
}
Options.Add(option);
return(this);
}
public void And_ProductId_Is_Not_Valid()
{
// Arrange
var productOption = new ProductOptionDto {
Description = "description", Name = "name", ProductId = Guid.Empty
};
// Act
var result = _validator.TestValidate(productOption);
// Assert
result.ShouldHaveValidationErrorFor(x => x.ProductId);
Assert.True(!result.IsValid);
Assert.True(result.Errors.Count == 1);
Assert.Contains(result.Errors, x => x.PropertyName == "ProductId" && x.ErrorMessage == ValidationErrors.ProductIdRequiredError);
}
public void And_Name_Is_Not_Valid(string name)
{
// Arrange
var productOption = new ProductOptionDto {
Description = "description", Name = name, ProductId = RandomBuilder.NextGuid()
};
// Act
var result = _validator.TestValidate(productOption);
// Assert
result.ShouldHaveValidationErrorFor(x => x.Name);
Assert.True(!result.IsValid);
Assert.True(result.Errors.Count == 1);
Assert.Contains(result.Errors, x => x.PropertyName == "Name" && x.ErrorMessage == ValidationErrors.NameRequiredError);
}
public async Task <IActionResult> Put(
[FromRoute] Guid productId,
[FromRoute] Guid productOptionId,
[FromBody] ProductOptionDto productOptionDto)
{
productOptionDto.Id = productOptionId;
productOptionDto.ProductId = productId;
var result = await _productService.UpdateProductOptionAsync(productOptionDto);
if (!result)
{
return(NotFound());
}
return(NoContent());
}
public async Task <int> AddProductOptionsForProdId(ProductOptionDto productOptionDto)
{
var product = productControllerInner.GetProductById(productOptionDto.ProductId);
if (product == null || product.Result.Items.Count == 0)
{
throw new HttpResponseException
{
Status = 500,
Value = $"Product with id {productOptionDto.ProductId} doesn't exist"
}
}
;
return(await productOptionInnerController.AddProductOption(productOptionDto));
}
public async Task <ProductOptionDto?> AddProductOptionAsync(ProductOptionDto productOptionDto)
{
var product = await FindProduct(productOptionDto.ProductId);
if (product is null)
{
return(null);
}
product.AddProductOption(productOptionDto.Id, productOptionDto.Name, productOptionDto.Description);
await _productRepository.UnitOfWork.SaveChangesAsync();
_logger.LogInformation("@{ProductOptionDto} added", productOptionDto);
return(product.ProductOptions.First(x => x.Id == productOptionDto.Id).ToDto(productOptionDto.ProductId));
}
public async Task UpdateProductOption(ProductOptionDto productOption)
{
Product product = await GetProduct(productOption.ProductId);
ProductOption existingOption = GetProductOption(product, productOption.Id.Value);
if (product.ProductOptions.Any(x => x.Id != existingOption.Id && x.Name == productOption.Name))
{
throw new DuplicateProductOptionException($"ProductOption cannot be updated as an Option with the same name already exists for Product - {productOption.ProductId}");
}
existingOption.Name = productOption.Name;
existingOption.Description = productOption.Description;
await _productRepository.SaveChangesAsync();
}
public void And_Name_Overflows_Max_Length()
{
// Arrange
string invalidName = RandomBuilder.NextString(ValidationLimits.NameMaxLength + 1);
var productOption = new ProductOptionDto {
Description = "description", Name = invalidName, ProductId = RandomBuilder.NextGuid()
};
// Act
var result = _validator.TestValidate(productOption);
// Assert
result.ShouldHaveValidationErrorFor(x => x.Name);
Assert.True(!result.IsValid);
Assert.True(result.Errors.Count == 1);
Assert.Contains(result.Errors, x => x.PropertyName == "Name" && x.ErrorMessage == ValidationErrors.NameMaxLengthError);
}
public async Task <ActionResult <ProductDto> > Post(
[FromRoute] Guid productId,
[FromBody] ProductOptionDto productOptionDto)
{
productOptionDto.ProductId = productId;
var createdProductOptionDto = await _productService.AddProductOptionAsync(productOptionDto);
if (createdProductOptionDto is null)
{
return(NotFound());
}
return(CreatedAtAction(nameof(Get),
new { productId, productOptionId = createdProductOptionDto.Id },
createdProductOptionDto));
}
public async void UpdateOptionAsync_InvalidOption_ReturnBadRequestStatus()
{
//Arrange
var productOptionDto = new ProductOptionDto(new Guid("1FA85F64-5717-4562-B3FC-2C963F66AFA6"), new Guid("0643CCF0-AB00-4862-B3C5-40E2731ABCC9"), "OptionOneOne", "OptionOneOneDescription");
_productService.Setup(s => s.GetProductByIdAsync(It.IsAny <Guid>())).ReturnsAsync(new Product());
var productsController = new ProductsController(_productService.Object, _mapper.Object);
//Act
var result = await productsController.UpdateOptionAsync(productOptionDto);
//Assert
var notFoundResult = Assert.IsType <NotFoundResult>(result);
Assert.Equal(404, notFoundResult.StatusCode);
}
public async Task <IActionResult> UpdateOptionAsync([FromBody] ProductOptionDto productOptionDto)
{
var product = await _productService.GetProductByIdAsync(productOptionDto.ProductId);
var option = product?.ProductOptions?.Where(p => p.Id == productOptionDto.Id).FirstOrDefault();
if (option == null)
{
return(NotFound());
}
option.Name = productOptionDto.Name;
option.Description = productOptionDto.Description;
var result = await _productService.UpdateProductAsync(product);
return(Ok(result));
}
