public DTO.SubCategory CreateSubCategory(DataAccess.SubCategory subCategory, bool includeOnlyActive = true)
{
CheckHelper.ArgumentNotNull(subCategory, "subCategory");
CheckHelper.ArgumentWithinCondition(!subCategory.IsNew(), "!subCategory.IsNew()");
return
(_dtoCache.Get(
subCategory,
sc =>
{
var result =
new DTO.SubCategory
{
Id = sc.Id,
Name = sc.Name,
Active = sc.Active
};
CopyTrackableFields(result, sc);
return result;
},
(scDto, sc) =>
scDto.Category = CreateCategory(sc.Category, includeOnlyActive)));
}
public void UpdateSubCategory_Should_Throw_Exception_When_Current_User_Is_Not_Seller()
{
// Arrange
var container = ContainerMockFactory.Create();
var securityService = container.Get <ISecurityService>();
securityService.LogIn(UserMockFactory.Olesya.Login, EncryptServiceMockFactory.OlesyaPasswordData.Password);
var updatedSubCategory =
new DTO.SubCategory
{
Id = SubCategoryMockFactory.Girls_5_12.Id,
Name = "New SubCategory",
Category = container.Get <IDtoService>().CreateCategory(CategoryMockFactory.Men),
Active = true
};
var categoryService = container.Get <ICategoryService>();
// Act
// Assert
ExceptionAssert.Throw <InvalidOperationException>(
() => categoryService.UpdateSubCategory(updatedSubCategory),
"Only seller can change subcategory.");
}
public void CreateSubCategory(DTO.SubCategory createdSubCategory)
{
CheckHelper.ArgumentNotNull(createdSubCategory, "createdSubCategory");
CheckHelper.ArgumentWithinCondition(createdSubCategory.IsNew(), "SubCategory is not new.");
Container.Get <IValidateService>().CheckIsValid(createdSubCategory);
CheckHelper.ArgumentWithinCondition(!createdSubCategory.Category.IsNew(), "Category of SubCategory is new.");
CheckHelper.WithinCondition(SecurityService.IsLoggedIn, "User is not logged in.");
CheckHelper.WithinCondition(SecurityService.IsCurrentUserSeller, "Only seller can create subcategory.");
var persistentService = Container.Get <IPersistentService>();
var doesAnotherSubCategoryWithTheSameNameWithinTheSameCategoryExist =
persistentService
.GetEntitySet <SubCategory>()
.Any(sc =>
sc.Name == createdSubCategory.Name &&
sc.CategoryId == createdSubCategory.Category.Id);
if (doesAnotherSubCategoryWithTheSameNameWithinTheSameCategoryExist)
{
throw new CategoryServiceException("Подкатегория с заданным названием уже существует в данной категории.");
}
var category = persistentService.GetEntityById <DataAccess.Category>(createdSubCategory.Category.Id);
CheckHelper.NotNull(category, "Category does not exist.");
var subCategory =
new SubCategory
{
Name = createdSubCategory.Name,
CategoryId = category.Id,
Category = category,
Active = createdSubCategory.Active
};
subCategory.UpdateTrackFields(Container);
persistentService.Add(subCategory);
persistentService.SaveChanges();
createdSubCategory.Id = subCategory.Id;
createdSubCategory.CreateDate = subCategory.CreateDate;
createdSubCategory.CreateUser = subCategory.CreatedBy.GetFullName();
createdSubCategory.ChangeDate = subCategory.ChangeDate;
createdSubCategory.ChangeUser = subCategory.ChangedBy.GetFullName();
}
public void CreateSubCategory_Should_Create_SubCategory_When_SubCategory_With_The_Same_Name_In_Another_Category_Already_Exists()
{
// Arrange
var container = ContainerMockFactory.Create();
var securityService = container.Get <ISecurityService>();
securityService.LogIn(UserMockFactory.Diana.Login, EncryptServiceMockFactory.DianaPasswordData.Password);
var createdSubCategory =
new DTO.SubCategory
{
Name = SubCategoryMockFactory.Girls_5_12.Name,
Category = container.Get <IDtoService>().CreateCategory(CategoryMockFactory.Men),
Active = true
};
var categoryService = container.Get <ICategoryService>();
var persistentService = container.Get <IPersistentService>();
var timeService = container.Get <ITimeService>();
// Act
categoryService.CreateSubCategory(createdSubCategory);
// Assert
var actualSubCategory =
persistentService
.GetEntitySet <SubCategory>()
.Single(sc =>
sc.Name == SubCategoryMockFactory.Girls_5_12.Name &&
sc.CategoryId == CategoryMockFactory.Men.Id);
Assert.IsTrue(actualSubCategory.Id > 0);
Assert.AreEqual(SubCategoryMockFactory.Girls_5_12.Name, actualSubCategory.Name);
Assert.AreEqual(CategoryMockFactory.Men.Id, actualSubCategory.Category.Id);
Assert.AreEqual(CategoryMockFactory.Men.Name, actualSubCategory.Category.Name);
Assert.AreEqual(CategoryMockFactory.Men.Active, actualSubCategory.Category.Active);
Assert.IsTrue(actualSubCategory.Active);
Assert.AreEqual(timeService.UtcNow, actualSubCategory.CreateDate);
Assert.AreEqual(timeService.UtcNow, actualSubCategory.ChangeDate);
Assert.AreEqual(UserMockFactory.Diana, actualSubCategory.CreatedBy);
Assert.AreEqual(UserMockFactory.Diana, actualSubCategory.ChangedBy);
Assert.AreEqual(createdSubCategory, container.Get <IDtoService>().CreateSubCategory(actualSubCategory));
}
public void CreateSubCategory_Should_Create_SubCategory()
{
// Arrange
var container = ContainerMockFactory.Create();
var securityService = container.Get <ISecurityService>();
securityService.LogIn(UserMockFactory.Diana.Login, EncryptServiceMockFactory.DianaPasswordData.Password);
const string NEW_SUBCATEGORY_NAME = "New SubCategory";
var createdSubCategory =
new DTO.SubCategory
{
Name = NEW_SUBCATEGORY_NAME,
Category = container.Get <IDtoService>().CreateCategory(CategoryMockFactory.Men),
Active = true
};
var categoryService = container.Get <ICategoryService>();
var persistentService = container.Get <IPersistentService>();
var timeService = container.Get <ITimeService>();
// Act
categoryService.CreateSubCategory(createdSubCategory);
// Assert
var actualSubCategory =
persistentService
.GetEntitySet <SubCategory>()
.Single(sc => sc.Name == NEW_SUBCATEGORY_NAME);
Assert.IsTrue(actualSubCategory.Id > 0);
Assert.AreEqual(NEW_SUBCATEGORY_NAME, actualSubCategory.Name);
Assert.AreEqual(CategoryMockFactory.Men.Id, actualSubCategory.Category.Id);
Assert.AreEqual(CategoryMockFactory.Men.Name, actualSubCategory.Category.Name);
Assert.AreEqual(CategoryMockFactory.Men.Active, actualSubCategory.Category.Active);
Assert.IsTrue(actualSubCategory.Active);
Assert.AreEqual(timeService.UtcNow, actualSubCategory.CreateDate);
Assert.AreEqual(timeService.UtcNow, actualSubCategory.ChangeDate);
Assert.AreEqual(UserMockFactory.Diana, actualSubCategory.CreatedBy);
Assert.AreEqual(UserMockFactory.Diana, actualSubCategory.ChangedBy);
Assert.AreEqual(createdSubCategory, container.Get <IDtoService>().CreateSubCategory(actualSubCategory));
}
public DTO.Product[] GetActiveProductsBySubCategory(DTO.SubCategory subCategory)
{
CheckHelper.ArgumentNotNull(subCategory, "subCategory");
CheckHelper.ArgumentWithinCondition(!subCategory.IsNew(), "!subCategory.IsNew()");
CheckHelper.WithinCondition(SecurityService.IsLoggedIn, "User is not logged in.");
var persistentService = Container.Get<IPersistentService>();
var dtoService = Container.Get<IDtoService>();
return
persistentService
.GetActiveEntities<DataAccess.Product>()
.Where(p => p.SubCategoryId == subCategory.Id)
.OrderByDescending(p => p.ChangeDate)
.AsEnumerable()
.Select(p => dtoService.CreateProduct(p))
.ToArray();
}
public void UpdateSubCategory_Should_Update_SubCategory_When_Name_Is_Not_Changed()
{
// Arrange
var container = ContainerMockFactory.Create();
var securityService = container.Get <ISecurityService>();
securityService.LogIn(UserMockFactory.Diana.Login, EncryptServiceMockFactory.DianaPasswordData.Password);
var name = SubCategoryMockFactory.Girls_5_12.Name;
var createDate = SubCategoryMockFactory.Girls_5_12.CreateDate;
var createdBy = SubCategoryMockFactory.Girls_5_12.CreatedBy;
var updatedSubCategory =
new DTO.SubCategory
{
Id = SubCategoryMockFactory.Girls_5_12.Id,
Name = SubCategoryMockFactory.Girls_5_12.Name,
Category = container.Get <IDtoService>().CreateCategory(CategoryMockFactory.Children),
Active = false
};
var categoryService = container.Get <ICategoryService>();
var persistentService = container.Get <IPersistentService>();
var timeService = container.Get <ITimeService>();
// Act
categoryService.UpdateSubCategory(updatedSubCategory);
// Assert
var actualSubCategory = persistentService.GetEntityById <SubCategory>(SubCategoryMockFactory.Girls_5_12.Id);
Assert.AreEqual(name, actualSubCategory.Name);
Assert.AreEqual(CategoryMockFactory.Children.Id, actualSubCategory.Category.Id);
Assert.AreEqual(CategoryMockFactory.Children.Name, actualSubCategory.Category.Name);
Assert.AreEqual(CategoryMockFactory.Children.Active, actualSubCategory.Category.Active);
Assert.IsFalse(actualSubCategory.Active);
Assert.AreEqual(createDate, actualSubCategory.CreateDate);
Assert.AreEqual(timeService.UtcNow, actualSubCategory.ChangeDate);
Assert.AreEqual(createdBy, actualSubCategory.CreatedBy);
Assert.AreEqual(UserMockFactory.Diana, actualSubCategory.ChangedBy);
Assert.AreEqual(updatedSubCategory, container.Get <IDtoService>().CreateSubCategory(actualSubCategory));
}
public DTO.Size[] GetActiveSizes(DTO.SubCategory subCategory, DTO.Brand brand)
{
CheckHelper.ArgumentNotNull(subCategory, "subCategory");
CheckHelper.ArgumentWithinCondition(!subCategory.IsNew(), "!subCategory.IsNew()");
CheckHelper.ArgumentNotNull(brand, "brand");
CheckHelper.ArgumentWithinCondition(!brand.IsNew(), "!brand.IsNew()");
CheckHelper.WithinCondition(SecurityService.IsLoggedIn, "User is not logged in.");
var persistentService = Container.Get <IPersistentService>();
var dtoService = Container.Get <IDtoService>();
return
(persistentService
.GetActiveEntities <DataAccess.Size>()
.Where(s => s.SubCategoryId == subCategory.Id && s.BrandId == brand.Id)
.OrderBy(s => s.Name)
.AsEnumerable()
.Select(s => dtoService.CreateSize(s))
.ToArray());
}
public DTO.Size[] GetSizes(DTO.SubCategory subCategory, DTO.Brand brand, string filter)
{
CheckHelper.ArgumentNotNull(subCategory, "subCategory");
CheckHelper.ArgumentWithinCondition(!subCategory.IsNew(), "!subCategory.IsNew()");
CheckHelper.ArgumentNotNull(brand, "brand");
CheckHelper.ArgumentWithinCondition(!brand.IsNew(), "!brand.IsNew()");
CheckHelper.WithinCondition(SecurityService.IsLoggedIn, "User is not logged in.");
CheckHelper.WithinCondition(SecurityService.IsCurrentUserSeller, "Only seller can get all sizes.");
var query =
Container
.Get <IPersistentService>()
.GetEntitySet <DataAccess.Size>()
.Where(s => s.SubCategoryId == subCategory.Id && s.BrandId == brand.Id)
.AsQueryable();
if (!string.IsNullOrWhiteSpace(filter))
{
query =
query
.Where(s =>
s.Name.Contains(filter) ||
s.Height.Contains(filter) ||
s.Weight.Contains(filter));
}
var dtoService = Container.Get <IDtoService>();
return
(query
.OrderBy(s => s.Id)
.ToArray()
.Select(s => dtoService.CreateSize(s, false))
.ToArray());
}
public void UpdateSubCategory_Should_Throw_Exception_When_SubCategory_With_The_Same_Name_In_The_Same_Category_Already_Exists()
{
var container = ContainerMockFactory.Create();
var securityService = container.Get <ISecurityService>();
securityService.LogIn(UserMockFactory.Diana.Login, EncryptServiceMockFactory.DianaPasswordData.Password);
var updatedSubCategory =
new DTO.SubCategory
{
Id = SubCategoryMockFactory.Girls_5_12.Id,
Name = SubCategoryMockFactory.Boys_2_5.Name,
Category = container.Get <IDtoService>().CreateCategory(CategoryMockFactory.Children),
Active = true
};
var categoryService = container.Get <ICategoryService>();
// Act
// Assert
ExceptionAssert.Throw <CategoryServiceException>(
() => categoryService.UpdateSubCategory(updatedSubCategory),
"Подкатегория с заданным названием уже существует в данной категории.");
}
