public void Can_Persist_Member_Type()
{
IScopeProvider provider = ScopeProvider;
using (IScope scope = provider.CreateScope())
{
MemberTypeRepository repository = CreateRepository(provider);
var memberType = (IMemberType)MemberTypeBuilder.CreateSimpleMemberType();
repository.Save(memberType);
IMemberType sut = repository.Get(memberType.Id);
Dictionary <string, PropertyType> standardProps = ConventionsHelper.GetStandardPropertyTypeStubs(ShortStringHelper);
Assert.That(sut, Is.Not.Null);
Assert.That(sut.PropertyGroups.Count, Is.EqualTo(2));
Assert.That(sut.PropertyTypes.Count(), Is.EqualTo(3 + standardProps.Count));
Assert.That(sut.PropertyGroups.Any(x => x.HasIdentity == false || x.Id == 0), Is.False);
Assert.That(sut.PropertyTypes.Any(x => x.HasIdentity == false || x.Id == 0), Is.False);
TestHelper.AssertPropertyValuesAreEqual(sut, memberType);
}
}
public void Built_In_Member_Type_Properties_Missing_Are_Automatically_Added_When_Creating()
{
Dictionary <string, PropertyType> stubs = ConventionsHelper.GetStandardPropertyTypeStubs(ShortStringHelper);
IScopeProvider provider = ScopeProvider;
using (provider.CreateScope())
{
MemberTypeRepository repository = CreateRepository(provider);
IMemberType memberType = MemberTypeBuilder.CreateSimpleMemberType();
// created without the stub properties
Assert.AreEqual(1, memberType.PropertyGroups.Count);
Assert.AreEqual(3, memberType.PropertyTypes.Count());
// add one stub property, others are still missing
memberType.AddPropertyType(stubs.First().Value, Constants.Conventions.Member.StandardPropertiesGroupAlias, Constants.Conventions.Member.StandardPropertiesGroupName);
// saving *new* member type adds the (missing) stub properties
repository.Save(memberType);
// saving has added (and saved) the (missing) stub properties
Assert.AreEqual(2, memberType.PropertyGroups.Count);
Assert.AreEqual(3 + stubs.Count, memberType.PropertyTypes.Count());
// getting with stub properties
memberType = repository.Get(memberType.Id);
Assert.AreEqual(2, memberType.PropertyGroups.Count);
Assert.AreEqual(3 + stubs.Count, memberType.PropertyTypes.Count());
}
}
private MemberRepository CreateRepository(IDatabaseUnitOfWork unitOfWork, out MemberTypeRepository memberTypeRepository)
{
memberTypeRepository = new MemberTypeRepository(unitOfWork, NullCacheProvider.Current);
var tagRepo = new TagsRepository(unitOfWork, NullCacheProvider.Current);
var repository = new MemberRepository(unitOfWork, NullCacheProvider.Current, memberTypeRepository, tagRepo);
return repository;
}
private MemberRepository CreateRepository(IDatabaseUnitOfWork unitOfWork, out MemberTypeRepository memberTypeRepository)
{
memberTypeRepository = new MemberTypeRepository(unitOfWork, NullCacheProvider.Current);
var repository = new MemberRepository(unitOfWork, NullCacheProvider.Current, memberTypeRepository);
return(repository);
}
private MemberRepository CreateRepository(IDatabaseUnitOfWork unitOfWork, out MemberTypeRepository memberTypeRepository, out MemberGroupRepository memberGroupRepository)
{
memberTypeRepository = new MemberTypeRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of <ILogger>(), SqlSyntax);
memberGroupRepository = new MemberGroupRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of <ILogger>(), SqlSyntax, CacheHelper.CreateDisabledCacheHelper());
var tagRepo = new TagRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of <ILogger>(), SqlSyntax);
var repository = new MemberRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of <ILogger>(), SqlSyntax, memberTypeRepository, memberGroupRepository, tagRepo, Mock.Of <IContentSection>());
return(repository);
}
private MemberRepository CreateRepository(IScopeProvider provider, out MemberTypeRepository memberTypeRepository, out MemberGroupRepository memberGroupRepository)
{
var accessor = (IScopeAccessor)provider;
memberTypeRepository = new MemberTypeRepository(accessor, AppCaches.Disabled, Logger);
memberGroupRepository = new MemberGroupRepository(accessor, AppCaches.Disabled, Logger);
var tagRepo = new TagRepository(accessor, AppCaches.Disabled, Logger);
var repository = new MemberRepository(accessor, AppCaches.Disabled, Logger, memberTypeRepository, memberGroupRepository, tagRepo, Mock.Of <ILanguageRepository>());
return(repository);
}
public IntegralDetailsService(
IntegralDetailsRepository integralDetailsRepository,
WeiXinUserRepository weiXinUserRepository,
IntegralConfigRepository integralConfigRepository,
MemberTypeRepository memberTypeRepository)
{
_integralDetailsRepository = integralDetailsRepository;
_weiXinUserRepository = weiXinUserRepository;
_integralConfigRepository = integralConfigRepository;
_memberTypeRepository = memberTypeRepository;
}
public void Cannot_Persist_Member_Type_Without_Alias()
{
IScopeProvider provider = ScopeProvider;
using (IScope scope = provider.CreateScope())
{
MemberTypeRepository repository = CreateRepository(provider);
MemberType memberType = MemberTypeBuilder.CreateSimpleMemberType();
memberType.Alias = null;
Assert.Throws <InvalidOperationException>(() => repository.Save(memberType));
}
}
private MemberRepository CreateRepository(IScopeProvider provider, out MemberTypeRepository memberTypeRepository, out MemberGroupRepository memberGroupRepository)
{
var accessor = (IScopeAccessor)provider;
var templateRepository = Mock.Of <ITemplateRepository>();
var commonRepository = new ContentTypeCommonRepository(accessor, templateRepository, AppCaches);
var languageRepository = new LanguageRepository(accessor, AppCaches.Disabled, Logger);
memberTypeRepository = new MemberTypeRepository(accessor, AppCaches.Disabled, Logger, commonRepository, languageRepository);
memberGroupRepository = new MemberGroupRepository(accessor, AppCaches.Disabled, Logger);
var tagRepo = new TagRepository(accessor, AppCaches.Disabled, Logger);
var repository = new MemberRepository(accessor, AppCaches.Disabled, Logger, memberTypeRepository, memberGroupRepository, tagRepo, Mock.Of <ILanguageRepository>());
return(repository);
}
public void Can_Get_Member_Type_By_Guid_Id()
{
IScopeProvider provider = ScopeProvider;
using (IScope scope = provider.CreateScope())
{
MemberTypeRepository repository = CreateRepository(provider);
IMemberType memberType = MemberTypeBuilder.CreateSimpleMemberType();
repository.Save(memberType);
memberType = repository.Get(memberType.Key);
Assert.That(memberType, Is.Not.Null);
}
}
public void Bug_Changing_Built_In_Member_Type_Property_Type_Aliases_Results_In_Exception()
{
Dictionary <string, PropertyType> stubs = ConventionsHelper.GetStandardPropertyTypeStubs(ShortStringHelper);
IScopeProvider provider = ScopeProvider;
using (provider.CreateScope())
{
MemberTypeRepository repository = CreateRepository(provider);
IMemberType memberType = MemberTypeBuilder.CreateSimpleMemberType("mtype");
// created without the stub properties
Assert.AreEqual(1, memberType.PropertyGroups.Count);
Assert.AreEqual(3, memberType.PropertyTypes.Count());
// saving *new* member type adds the stub properties
repository.Save(memberType);
// saving has added (and saved) the stub properties
Assert.AreEqual(2, memberType.PropertyGroups.Count);
Assert.AreEqual(3 + stubs.Count, memberType.PropertyTypes.Count());
foreach (KeyValuePair <string, PropertyType> stub in stubs)
{
IPropertyType prop = memberType.PropertyTypes.First(x => x.Alias == stub.Key);
prop.Alias += "__0000";
}
// saving *existing* member type does *not* ensure stub properties
repository.Save(memberType);
// therefore, nothing has changed
Assert.AreEqual(2, memberType.PropertyGroups.Count);
Assert.AreEqual(3 + stubs.Count, memberType.PropertyTypes.Count());
// fetching ensures that the stub properties are there
memberType = repository.Get("mtype");
Assert.IsNotNull(memberType);
Assert.AreEqual(2, memberType.PropertyGroups.Count);
Assert.AreEqual(3 + (stubs.Count * 2), memberType.PropertyTypes.Count());
}
}
private static List <PropertyType> GetPropertyTypes(MemberTypeReadOnlyDto dto, MemberType memberType, Dictionary <string, PropertyType> standardProps)
{
//Find PropertyTypes that does not belong to a PropertyTypeGroup
var propertyTypes = new List <PropertyType>();
foreach (var typeDto in dto.PropertyTypes.Where(x => (x.PropertyTypeGroupId.HasValue == false || x.PropertyTypeGroupId.Value == 0) && x.Id.HasValue))
{
//Internal dictionary for adding "MemberCanEdit" and "VisibleOnProfile" properties to each PropertyType
memberType.MemberTypePropertyTypes.Add(typeDto.Alias,
new MemberTypePropertyProfileAccess(typeDto.ViewOnProfile, typeDto.CanEdit, typeDto.IsSensitive));
//ensures that any built-in membership properties have their correct dbtype assigned no matter
//what the underlying data type is
var propDbType = MemberTypeRepository.GetDbTypeForBuiltInProperty(
typeDto.Alias,
typeDto.DbType.EnumParse <ValueStorageType>(true),
standardProps);
var propertyType = new PropertyType(
typeDto.PropertyEditorAlias,
propDbType.Result,
//This flag tells the property type that it has an explicit dbtype and that it cannot be changed
// which is what we want for the built-in properties.
propDbType.Success,
typeDto.Alias)
{
DataTypeId = typeDto.DataTypeId,
Description = typeDto.Description,
Id = typeDto.Id.Value,
Mandatory = typeDto.Mandatory,
Name = typeDto.Name,
SortOrder = typeDto.SortOrder,
ValidationRegExp = typeDto.ValidationRegExp,
PropertyGroupId = null,
CreateDate = dto.CreateDate,
UpdateDate = dto.CreateDate,
Key = typeDto.UniqueId
};
propertyTypes.Add(propertyType);
}
return(propertyTypes);
}
private MemberRepository CreateRepository(IScopeProvider provider, out MemberTypeRepository memberTypeRepository, out MemberGroupRepository memberGroupRepository)
{
var accessor = (IScopeAccessor)provider;
var templateRepository = Mock.Of <ITemplateRepository>();
var commonRepository = new ContentTypeCommonRepository(accessor, templateRepository, AppCaches);
var languageRepository = new LanguageRepository(accessor, AppCaches.Disabled, Logger);
memberTypeRepository = new MemberTypeRepository(accessor, AppCaches.Disabled, Logger, commonRepository, languageRepository);
memberGroupRepository = new MemberGroupRepository(accessor, AppCaches.Disabled, Logger);
var tagRepo = new TagRepository(accessor, AppCaches.Disabled, Logger);
var relationTypeRepository = new RelationTypeRepository(accessor, AppCaches.Disabled, Logger);
var entityRepository = new EntityRepository(accessor);
var relationRepository = new RelationRepository(accessor, Logger, relationTypeRepository, entityRepository);
var propertyEditors = new Lazy <PropertyEditorCollection>(() => new PropertyEditorCollection(new DataEditorCollection(Enumerable.Empty <IDataEditor>())));
var dataValueReferences = new DataValueReferenceFactoryCollection(Enumerable.Empty <IDataValueReferenceFactory>());
var repository = new MemberRepository(accessor, AppCaches.Disabled, Logger, memberTypeRepository, memberGroupRepository, tagRepo, Mock.Of <ILanguageRepository>(), relationRepository, relationTypeRepository, propertyEditors, dataValueReferences);
return(repository);
}
public void Built_In_Member_Type_Properties_Are_Not_Reused_For_Different_Member_Types()
{
IScopeProvider provider = ScopeProvider;
using (IScope scope = provider.CreateScope())
{
MemberTypeRepository repository = CreateRepository(provider);
IMemberType memberType1 = MemberTypeBuilder.CreateSimpleMemberType();
IMemberType memberType2 = MemberTypeBuilder.CreateSimpleMemberType("test2");
repository.Save(memberType1);
repository.Save(memberType2);
int[] m1Ids = memberType1.PropertyTypes.Select(x => x.Id).ToArray();
int[] m2Ids = memberType2.PropertyTypes.Select(x => x.Id).ToArray();
Assert.IsFalse(m1Ids.Any(m2Ids.Contains));
}
}
public void Can_Delete_MemberType()
{
// Arrange
IScopeProvider provider = ScopeProvider;
using (IScope scope = provider.CreateScope())
{
MemberTypeRepository repository = CreateRepository(provider);
// Act
IMemberType memberType = MemberTypeBuilder.CreateSimpleMemberType();
repository.Save(memberType);
IMemberType contentType2 = repository.Get(memberType.Id);
repository.Delete(contentType2);
bool exists = repository.Exists(memberType.Id);
// Assert
Assert.That(exists, Is.False);
}
}
public void Can_Get_All_Member_Types_By_Guid_Ids()
{
IScopeProvider provider = ScopeProvider;
using (IScope scope = provider.CreateScope())
{
MemberTypeRepository repository = CreateRepository(provider);
MemberType memberType1 = MemberTypeBuilder.CreateSimpleMemberType();
repository.Save(memberType1);
MemberType memberType2 = MemberTypeBuilder.CreateSimpleMemberType();
memberType2.Name = "AnotherType";
memberType2.Alias = "anotherType";
repository.Save(memberType2);
IEnumerable <IMemberType> result = ((IReadRepository <Guid, IMemberType>)repository).GetMany(memberType1.Key, memberType2.Key);
// there are 3 because of the Member type created for init data
Assert.AreEqual(2, result.Count());
}
}
public void Can_Get_Member_Types_By_Guid_Id()
{
IScopeProvider provider = ScopeProvider;
using (IScope scope = provider.CreateScope())
{
MemberTypeRepository repository = CreateRepository(provider);
MemberType memberType1 = MemberTypeBuilder.CreateSimpleMemberType();
repository.Save(memberType1);
MemberType memberType2 = MemberTypeBuilder.CreateSimpleMemberType();
memberType2.Name = "AnotherType";
memberType2.Alias = "anotherType";
repository.Save(memberType2);
IMemberType result = repository.Get(memberType1.Key);
// there are 3 because of the Member type created for init data
Assert.IsNotNull(result);
Assert.AreEqual(memberType1.Key, result.Key);
}
}
public void Can_Persist_Member_Type_Same_Property_Keys()
{
IScopeProvider provider = ScopeProvider;
using (IScope scope = provider.CreateScope())
{
MemberTypeRepository repository = CreateRepository(provider);
var memberType = (IMemberType)MemberTypeBuilder.CreateSimpleMemberType();
repository.Save(memberType);
scope.Complete();
Guid[] propertyKeys = memberType.PropertyTypes.Select(x => x.Key).OrderBy(x => x).ToArray();
Guid[] groupKeys = memberType.PropertyGroups.Select(x => x.Key).OrderBy(x => x).ToArray();
memberType = repository.Get(memberType.Id);
Guid[] propertyKeys2 = memberType.PropertyTypes.Select(x => x.Key).OrderBy(x => x).ToArray();
Guid[] groupKeys2 = memberType.PropertyGroups.Select(x => x.Key).OrderBy(x => x).ToArray();
Assert.IsTrue(propertyKeys.SequenceEqual(propertyKeys2));
Assert.IsTrue(groupKeys.SequenceEqual(groupKeys2));
}
}
public void Can_Get_All_Members_When_No_Properties_Assigned()
{
IScopeProvider provider = ScopeProvider;
using (IScope scope = provider.CreateScope())
{
MemberTypeRepository repository = CreateRepository(provider);
MemberType memberType1 = MemberTypeBuilder.CreateSimpleMemberType();
memberType1.PropertyTypeCollection.Clear();
repository.Save(memberType1);
MemberType memberType2 = MemberTypeBuilder.CreateSimpleMemberType();
memberType2.PropertyTypeCollection.Clear();
memberType2.Name = "AnotherType";
memberType2.Alias = "anotherType";
repository.Save(memberType2);
IEnumerable <IMemberType> result = repository.GetMany();
// there are 3 because of the Member type created for init data
Assert.AreEqual(3, result.Count());
}
}
private static PropertyGroupCollection GetPropertyTypeGroupCollection(MemberTypeReadOnlyDto dto, MemberType memberType, Dictionary <string, PropertyType> standardProps)
{
// see PropertyGroupFactory, repeating code here...
var propertyGroups = new PropertyGroupCollection();
foreach (var groupDto in dto.PropertyTypeGroups.Where(x => x.Id.HasValue))
{
var group = new PropertyGroup(MemberType.IsPublishingConst);
// if the group is defined on the current member type,
// assign its identifier, else it will be zero
if (groupDto.ContentTypeNodeId == memberType.Id)
{
// note: no idea why Id is nullable here, but better check
if (groupDto.Id.HasValue == false)
{
throw new Exception("GroupDto.Id has no value.");
}
group.Id = groupDto.Id.Value;
}
group.Key = groupDto.UniqueId;
group.Name = groupDto.Text;
group.SortOrder = groupDto.SortOrder;
group.PropertyTypes = new PropertyTypeCollection(MemberType.IsPublishingConst);
//Because we are likely to have a group with no PropertyTypes we need to ensure that these are excluded
var localGroupDto = groupDto;
var typeDtos = dto.PropertyTypes.Where(x => x.Id.HasValue && x.Id > 0 && x.PropertyTypeGroupId.HasValue && x.PropertyTypeGroupId.Value == localGroupDto.Id.Value);
foreach (var typeDto in typeDtos)
{
//Internal dictionary for adding "MemberCanEdit" and "VisibleOnProfile" properties to each PropertyType
memberType.MemberTypePropertyTypes.Add(typeDto.Alias,
new MemberTypePropertyProfileAccess(typeDto.ViewOnProfile, typeDto.CanEdit, typeDto.IsSensitive));
var tempGroupDto = groupDto;
//ensures that any built-in membership properties have their correct dbtype assigned no matter
//what the underlying data type is
var propDbType = MemberTypeRepository.GetDbTypeForBuiltInProperty(
typeDto.Alias,
typeDto.DbType.EnumParse <ValueStorageType>(true),
standardProps);
var propertyType = new PropertyType(
typeDto.PropertyEditorAlias,
propDbType.Result,
//This flag tells the property type that it has an explicit dbtype and that it cannot be changed
// which is what we want for the built-in properties.
propDbType.Success,
typeDto.Alias)
{
DataTypeId = typeDto.DataTypeId,
Description = typeDto.Description,
Id = typeDto.Id.Value,
Name = typeDto.Name,
Mandatory = typeDto.Mandatory,
SortOrder = typeDto.SortOrder,
ValidationRegExp = typeDto.ValidationRegExp,
PropertyGroupId = new Lazy <int>(() => tempGroupDto.Id.Value),
CreateDate = memberType.CreateDate,
UpdateDate = memberType.UpdateDate,
Key = typeDto.UniqueId
};
// reset dirty initial properties (U4-1946)
propertyType.ResetDirtyProperties(false);
group.PropertyTypes.Add(propertyType);
}
// reset dirty initial properties (U4-1946)
group.ResetDirtyProperties(false);
propertyGroups.Add(group);
}
return(propertyGroups);
}
private PropertyGroupCollection GetPropertyTypeGroupCollection(MemberTypeReadOnlyDto dto, MemberType memberType, Dictionary <string, PropertyType> standardProps)
{
var propertyGroups = new PropertyGroupCollection();
foreach (var groupDto in dto.PropertyTypeGroups.Where(x => x.Id.HasValue))
{
var group = new PropertyGroup();
//Only assign an Id if the PropertyGroup belongs to this ContentType
if (groupDto.ContentTypeNodeId == memberType.Id)
{
group.Id = groupDto.Id.Value;
if (groupDto.ParentGroupId.HasValue)
{
group.ParentId = groupDto.ParentGroupId.Value;
}
}
else
{
//If the PropertyGroup is inherited, we add a reference to the group as a Parent.
group.ParentId = groupDto.Id;
}
group.Name = groupDto.Text;
group.SortOrder = groupDto.SortOrder;
group.PropertyTypes = new PropertyTypeCollection();
//Because we are likely to have a group with no PropertyTypes we need to ensure that these are excluded
var localGroupDto = groupDto;
var typeDtos = dto.PropertyTypes.Where(x => x.Id.HasValue && x.Id > 0 && x.PropertyTypeGroupId.HasValue && x.PropertyTypeGroupId.Value == localGroupDto.Id.Value);
foreach (var typeDto in typeDtos)
{
//Internal dictionary for adding "MemberCanEdit" and "VisibleOnProfile" properties to each PropertyType
memberType.MemberTypePropertyTypes.Add(typeDto.Alias,
new MemberTypePropertyProfileAccess(typeDto.ViewOnProfile, typeDto.CanEdit));
var tempGroupDto = groupDto;
//ensures that any built-in membership properties have their correct dbtype assigned no matter
//what the underlying data type is
var propDbType = MemberTypeRepository.GetDbTypeForBuiltInProperty(
typeDto.Alias,
typeDto.DbType.EnumParse <DataTypeDatabaseType>(true),
standardProps);
var propertyType = new PropertyType(
typeDto.PropertyEditorAlias,
propDbType.Result,
//This flag tells the property type that it has an explicit dbtype and that it cannot be changed
// which is what we want for the built-in properties.
propDbType.Success,
typeDto.Alias)
{
DataTypeDefinitionId = typeDto.DataTypeId,
Description = typeDto.Description,
Id = typeDto.Id.Value,
Name = typeDto.Name,
Mandatory = typeDto.Mandatory,
SortOrder = typeDto.SortOrder,
ValidationRegExp = typeDto.ValidationRegExp,
PropertyGroupId = new Lazy <int>(() => tempGroupDto.Id.Value),
CreateDate = memberType.CreateDate,
UpdateDate = memberType.UpdateDate
};
//on initial construction we don't want to have dirty properties tracked
// http://issues.umbraco.org/issue/U4-1946
propertyType.ResetDirtyProperties(false);
group.PropertyTypes.Add(propertyType);
}
//on initial construction we don't want to have dirty properties tracked
// http://issues.umbraco.org/issue/U4-1946
group.ResetDirtyProperties(false);
propertyGroups.Add(group);
}
return(propertyGroups);
}
public MemberTypeService(MemberTypeRepository memberTypeRepository)
{
_memberTypeRepository = memberTypeRepository;
}
