public async Task UpdateCategoryAsync_ValidRequest_ProductUpdated()
{
var newCategory = new UpdateProductCategoryRequest()
{
Code = "cc"
};
var mockUserContext = new Mock <IUserContext>();
var mockProductContext = new Mock <IProductCatalogueContext>();
List <DbCategory> categoryList = new List <DbCategory>()
{
new DbCategory()
{
Id = 1
},
new DbCategory()
{
Id = 2
}
};
mockProductContext.Setup(c => c.Categories).ReturnsEntitySet(categoryList);
mockUserContext.Setup(c => c.UserId).Returns(1);
var service = new ProductCategoryService(mockProductContext.Object, mockUserContext.Object);
var updatedProduct = await service.UpdateCategoryAsync(1, newCategory);
Assert.Equal(newCategory.Code, updatedProduct.Code);
}
public async Task CreateCategoryAsync_UniqueCode_ProductWithSpecifiedCodeCreated()
{
const string newCode = "cc";
var newCategory = new UpdateProductCategoryRequest()
{
Code = newCode
};
var mockUserContext = new Mock <IUserContext>();
var mockProductContext = new Mock <IProductCatalogueContext>();
List <DbCategory> categoryList = new List <DbCategory>()
{
new DbCategory()
{
Id = 1
},
new DbCategory()
{
Id = 2
}
};
mockProductContext.Setup(c => c.Categories).ReturnsEntitySet(categoryList);
mockUserContext.Setup(c => c.UserId).Returns(1);
var service = new ProductCategoryService(mockProductContext.Object, mockUserContext.Object);
var product = await service.CreateCategoryAsync(newCategory);
Assert.Equal(newCode, product.Code);
}
public async Task UpdateCategoryAsync_IdNotPresent_RequestedResourceNotFoundExceptionThrown()
{
var newCategory = new UpdateProductCategoryRequest()
{
Code = "bb"
};
var mockUserContext = new Mock <IUserContext>();
var mockProductContext = new Mock <IProductCatalogueContext>();
List <DbCategory> categoryList = new List <DbCategory>()
{
new DbCategory()
{
Id = 1
},
new DbCategory()
{
Id = 2
}
};
mockProductContext.Setup(c => c.Categories).ReturnsEntitySet(categoryList);
var service = new ProductCategoryService(mockProductContext.Object, mockUserContext.Object);
Assert.ThrowsAsync <RequestedResourceNotFoundException>(() => service.UpdateCategoryAsync(3, newCategory));
}
/// <inheritdoc/>
public async Task <ProductCategory> UpdateCategoryAsync(int categoryId, UpdateProductCategoryRequest updateRequest)
{
var dbCategories = await _context.Categories.Where(c => c.Code == updateRequest.Code && c.Id != categoryId).ToArrayAsync();
if (dbCategories.Length > 0)
{
throw new RequestedResourceHasConflictException("code");
}
dbCategories = await _context.Categories.Where(c => c.Id == categoryId).ToArrayAsync();
var dbCategory = dbCategories.FirstOrDefault();
if (dbCategory == null)
{
throw new RequestedResourceNotFoundException();
}
_mapper.Map(updateRequest, dbCategory);
dbCategory.LastUpdatedBy = _userContext.UserId;
await _context.SaveChangesAsync();
dbCategories = await _context.Categories.Where(c => c.Id == categoryId).ToArrayAsync();
return(dbCategories.Select(c => _mapper.Map <ProductCategory>(c)).FirstOrDefault());
}
public IHttpActionResult Update(UpdateProductCategoryRequest model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
try
{
var productCategory = _productCategoryService.GetById(model.ID);
if (productCategory != null)
{
productCategory.UpdateProductCategory(model);
var result = _productCategoryService.Update(productCategory);
if (result != null)
{
var productCategoryVm = Mapper.Map <ProductCategoryDetailResponse>(result);
return(Ok(productCategoryVm));
}
}
}
catch (Exception ex)
{
Log.Website(ex);
}
return(BadRequest());
}
public async Task <IActionResult> UpdateProductCategory(int id, [FromBody] UpdateProductCategoryRequest updateRequest)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
await _categoryService.UpdateCategoryAsync(id, updateRequest);
return(NoContent());
}
public async Task <IActionResult> AddProductCategory([FromBody] UpdateProductCategoryRequest createRequest)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var category = await _categoryService.CreateCategoryAsync(createRequest);
var location = string.Format("/api/categories/{0}", category.Id);
return(Created(location, category));
}
public static void UpdateProductCategory(this ProductCategory model, UpdateProductCategoryRequest request)
{
model.ID = request.ID;
model.Name = request.Name;
model.Alias = request.Alias;
model.Description = request.Description;
model.DisplayOrder = request.DisplayOrder;
model.HotFlag = request.HotFlag;
model.Image = request.Image;
model.Status = request.Status;
model.UpdateBy = request.UpdateBy;
model.UpdateDate = request.UpdateDate;
model.ParentID = request.ParentID;
model.MetaDescription = request.MetaDescription;
model.MetaKeyword = request.MetaKeyword;
}
public async Task CreateCategoryAsync_RequestedResourceHasConflictException(
[Frozen] Mock <IProductCatalogueContext> context,
ProductCategoryService service,
IFixture fixture)
{
var categories = fixture.CreateMany <DbProductCategory>(5).ToList();
var products = fixture.CreateMany <CatalogueProduct>(5).ToList();
var updateCategory = new UpdateProductCategoryRequest {
Code = categories[0].Code
};
context.Setup(x => x.Products).ReturnsEntitySet(products);
context.Setup(x => x.Categories).ReturnsEntitySet(categories);
Func <Task> act = async() => await service.CreateCategoryAsync(updateCategory);
act.Should().Throw <RequestedResourceHasConflictException>();
}
public async Task <IHttpActionResult> AddProductCategoryAsync([FromBody] UpdateProductCategoryRequest createRequest)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
try
{
var category = await _categoryService.CreateCategoryAsync(createRequest);
var location = string.Format("/api/categories/{0}", category.Id);
return(Created <ProductCategory>(location, category));
}
catch (RequestedResourceHasConflictException)
{
return(Conflict());
}
}
/// <inheritdoc/>
public async Task <ProductCategory> CreateCategoryAsync(UpdateProductCategoryRequest createRequest)
{
var dbCategories = await _context.Categories.Where(c => c.Code == createRequest.Code).ToArrayAsync();
if (dbCategories.Length > 0)
{
throw new RequestedResourceHasConflictException("code");
}
var dbCategory = _mapper.Map <UpdateProductCategoryRequest, DbProductCategory>(createRequest);
dbCategory.CreatedBy = _userContext.UserId;
dbCategory.LastUpdatedBy = _userContext.UserId;
_context.Categories.Add(dbCategory);
await _context.SaveChangesAsync();
return(_mapper.Map <ProductCategory>(dbCategory));
}
public async Task <IHttpActionResult> AddProductCategory([FromBody] UpdateProductCategoryRequest createRequest)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
try
{
var category = await _categoryService.CreateCategoryAsync(createRequest);
var location = string.Format("/api/categories/{0}", category.Id);
return(Created <ProductCategory>(location, category));
}
catch (RequestedResourceHasConflictException ex)
{
return(ResponseMessage(Request.CreateErrorResponse(HttpStatusCode.Conflict, ex.Message)));
}
catch (Exception)
{
return(this.InternalServerError());
}
}
public async Task <IHttpActionResult> UpdateProductCategory([FromUri] int id, [FromBody] UpdateProductCategoryRequest updateRequest)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
await _categoryService.UpdateCategoryAsync(id, updateRequest);
return(ResponseMessage(Request.CreateResponse(HttpStatusCode.NoContent)));
}
public async Task <IHttpActionResult> UpdateProductCategoryAsync([FromUri] int id, [FromBody] UpdateProductCategoryRequest updateRequest)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id < 1)
{
return(BadRequest($"Argument {nameof(id)} must be greater than zero."));
}
try
{
await _categoryService.UpdateCategoryAsync(id, updateRequest);
return(ResponseMessage(Request.CreateResponse(HttpStatusCode.NoContent)));
}
catch (RequestedResourceHasConflictException)
{
return(Conflict());
}
catch (RequestedResourceNotFoundException)
{
return(NotFound());
}
}
public async Task <IActionResult> UpdateProductCategory([FromRoute] Guid productCategoryId, [FromBody] UpdateProductCategoryRequest updateProductCategoryRequest)
{
var productCategory = await _productCategoryService
.GetProductCategoryByIdAsync(productCategoryId);
if (productCategory == null)
{
return(BadRequest());
}
productCategory.ProductCategoryName = updateProductCategoryRequest.ProductCategoryName;
var updated = await _productCategoryService
.UpdateProductCategoryAsync(productCategory);
if (updated)
{
return(Ok(new Response <ProductCategoryResponse>(_mapper.Map <ProductCategoryResponse>(productCategory))));
}
return(NotFound());
}
public async Task <IHttpActionResult> UpdateProductCategory([FromUri] int id, [FromBody] UpdateProductCategoryRequest updateRequest)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
try
{
var result = await _categoryService.UpdateCategoryAsync(id, updateRequest);
return(this.Ok(result));
}
catch (RequestedResourceHasConflictException ex)
{
return(ResponseMessage(Request.CreateErrorResponse(HttpStatusCode.Conflict, ex.Message)));
}
catch (RequestedResourceNotFoundException ex)
{
return(this.BadRequest(ex.Message));
}
catch (Exception)
{
return(this.InternalServerError());
}
}
