protected ContentTypeBase(IContentTypeBase parent)
{
Mandate.ParameterNotNull(parent, "parent");
_parentId = new Lazy<int>(() => parent.Id);
_allowedContentTypes = new List<ContentTypeSort>();
_propertyGroups = new PropertyGroupCollection();
_propertyTypes = new PropertyTypeCollection();
}
protected ContentTypeBase(int parentId)
{
Mandate.ParameterCondition(parentId != 0, "parentId");
_parentId = new Lazy<int>(() => parentId);
_allowedContentTypes = new List<ContentTypeSort>();
_propertyGroups = new PropertyGroupCollection();
_propertyTypes = new PropertyTypeCollection();
}
public static PropertyGroup FindTab(this PropertyGroupCollection groups, string alias)
{
var tab = groups.FirstOrDefault(x => x.Alias.InvariantEquals(alias));
if (tab != null)
{
return(tab);
}
var tempAlias = GetTempTabAlias(alias);
tab = groups.FirstOrDefault(x => x.Alias.InvariantEquals(tempAlias));
if (tab != null)
{
return(tab);
}
return(null);
}
public static IEnumerable <PropertyGroup> BuildEntity(
IEnumerable <PropertyTypeGroupDto> groupDtos,
bool isPublishing,
int contentTypeId,
DateTime createDate,
DateTime updateDate,
Func <string?, ValueStorageType, string?, PropertyType> propertyTypeCtor)
{
// groupDtos contains all the groups, those that are defined on the current
// content type, and those that are inherited from composition content types
var propertyGroups = new PropertyGroupCollection();
foreach (PropertyTypeGroupDto groupDto in groupDtos)
{
var group = new PropertyGroup(isPublishing);
try
{
group.DisableChangeTracking();
// if the group is defined on the current content type,
// assign its identifier, else it will be zero
if (groupDto.ContentTypeNodeId == contentTypeId)
{
group.Id = groupDto.Id;
}
group.Key = groupDto.UniqueId;
group.Type = (PropertyGroupType)groupDto.Type;
group.Name = groupDto.Text;
group.Alias = groupDto.Alias;
group.SortOrder = groupDto.SortOrder;
group.PropertyTypes = new PropertyTypeCollection(isPublishing);
// Because we are likely to have a group with no PropertyTypes we need to ensure that these are excluded
IEnumerable <PropertyTypeDto> typeDtos = groupDto.PropertyTypeDtos?.Where(x => x.Id > 0) ??
Enumerable.Empty <PropertyTypeDto>();
foreach (PropertyTypeDto typeDto in typeDtos)
{
PropertyTypeGroupDto tempGroupDto = groupDto;
PropertyType propertyType = propertyTypeCtor(
typeDto.DataTypeDto.EditorAlias,
typeDto.DataTypeDto.DbType.EnumParse <ValueStorageType>(true),
typeDto.Alias);
try
{
propertyType.DisableChangeTracking();
propertyType.Alias = typeDto.Alias ?? string.Empty;
propertyType.DataTypeId = typeDto.DataTypeId;
propertyType.DataTypeKey = typeDto.DataTypeDto.NodeDto.UniqueId;
propertyType.Description = typeDto.Description;
propertyType.Id = typeDto.Id;
propertyType.Key = typeDto.UniqueId;
propertyType.Name = typeDto.Name ?? string.Empty;
propertyType.Mandatory = typeDto.Mandatory;
propertyType.MandatoryMessage = typeDto.MandatoryMessage;
propertyType.SortOrder = typeDto.SortOrder;
propertyType.ValidationRegExp = typeDto.ValidationRegExp;
propertyType.ValidationRegExpMessage = typeDto.ValidationRegExpMessage;
propertyType.PropertyGroupId = new Lazy <int>(() => tempGroupDto.Id);
propertyType.CreateDate = createDate;
propertyType.UpdateDate = updateDate;
propertyType.Variations = (ContentVariation)typeDto.Variations;
// reset dirty initial properties (U4-1946)
propertyType.ResetDirtyProperties(false);
group.PropertyTypes.Add(propertyType);
}
finally
{
propertyType.EnableChangeTracking();
}
}
// reset dirty initial properties (U4-1946)
group.ResetDirtyProperties(false);
propertyGroups.Add(group);
}
finally
{
group.EnableChangeTracking();
}
}
return(propertyGroups);
}
private void MapGroupsAndProperties(IDictionary <int, IContentTypeComposition> contentTypes)
{
var sql1 = Sql()
.Select <PropertyTypeGroupDto>()
.From <PropertyTypeGroupDto>()
.InnerJoin <ContentTypeDto>().On <PropertyTypeGroupDto, ContentTypeDto>((ptg, ct) => ptg.ContentTypeNodeId == ct.NodeId)
.OrderBy <ContentTypeDto>(x => x.NodeId)
.AndBy <PropertyTypeGroupDto>(x => x.SortOrder, x => x.Id);
var groupDtos = Database.Fetch <PropertyTypeGroupDto>(sql1);
var sql2 = Sql()
.Select <PropertyTypeDto>(r => r.Select(x => x.DataTypeDto, r1 => r1.Select(x => x.NodeDto)))
.AndSelect <MemberPropertyTypeDto>()
.From <PropertyTypeDto>()
.InnerJoin <DataTypeDto>().On <PropertyTypeDto, DataTypeDto>((pt, dt) => pt.DataTypeId == dt.NodeId)
.InnerJoin <NodeDto>().On <DataTypeDto, NodeDto>((dt, n) => dt.NodeId == n.NodeId)
.InnerJoin <ContentTypeDto>().On <PropertyTypeDto, ContentTypeDto>((pt, ct) => pt.ContentTypeId == ct.NodeId)
.LeftJoin <PropertyTypeGroupDto>().On <PropertyTypeDto, PropertyTypeGroupDto>((pt, ptg) => pt.PropertyTypeGroupId == ptg.Id)
.LeftJoin <MemberPropertyTypeDto>().On <PropertyTypeDto, MemberPropertyTypeDto>((pt, mpt) => pt.Id == mpt.PropertyTypeId)
.OrderBy <ContentTypeDto>(x => x.NodeId)
.AndBy <PropertyTypeGroupDto>(x => x.SortOrder, x => x.Id) // NULLs will come first or last, never mind, we deal with it below
.AndBy <PropertyTypeDto>(x => x.SortOrder, x => x.Id);
var propertyDtos = Database.Fetch <PropertyTypeCommonDto>(sql2);
var builtinProperties = Constants.Conventions.Member.GetStandardPropertyTypeStubs();
var groupIx = 0;
var propertyIx = 0;
foreach (var contentType in contentTypes.Values)
{
// only IContentType is publishing
var isPublishing = contentType is IContentType;
// get group-less properties (in case NULL is ordered first)
var noGroupPropertyTypes = new PropertyTypeCollection(isPublishing);
while (propertyIx < propertyDtos.Count && propertyDtos[propertyIx].ContentTypeId == contentType.Id && propertyDtos[propertyIx].PropertyTypeGroupId == null)
{
noGroupPropertyTypes.Add(MapPropertyType(contentType, propertyDtos[propertyIx], builtinProperties));
propertyIx++;
}
// get groups and their properties
var groupCollection = new PropertyGroupCollection();
while (groupIx < groupDtos.Count && groupDtos[groupIx].ContentTypeNodeId == contentType.Id)
{
var group = MapPropertyGroup(groupDtos[groupIx], isPublishing);
groupCollection.Add(group);
groupIx++;
while (propertyIx < propertyDtos.Count && propertyDtos[propertyIx].ContentTypeId == contentType.Id && propertyDtos[propertyIx].PropertyTypeGroupId == group.Id)
{
group.PropertyTypes.Add(MapPropertyType(contentType, propertyDtos[propertyIx], builtinProperties));
propertyIx++;
}
}
contentType.PropertyGroups = groupCollection;
// get group-less properties (in case NULL is ordered last)
while (propertyIx < propertyDtos.Count && propertyDtos[propertyIx].ContentTypeId == contentType.Id && propertyDtos[propertyIx].PropertyTypeGroupId == null)
{
noGroupPropertyTypes.Add(MapPropertyType(contentType, propertyDtos[propertyIx], builtinProperties));
propertyIx++;
}
contentType.NoGroupPropertyTypes = noGroupPropertyTypes;
// ensure builtin properties
if (contentType is MemberType memberType)
{
// ensure that the group exists (ok if it already exists)
memberType.AddPropertyGroup(Constants.Conventions.Member.StandardPropertiesGroupName);
// ensure that property types exist (ok if they already exist)
foreach (var(alias, propertyType) in builtinProperties)
{
var added = memberType.AddPropertyType(propertyType, Constants.Conventions.Member.StandardPropertiesGroupName);
if (added)
{
var access = new MemberTypePropertyProfileAccess(false, false, false);
memberType.MemberTypePropertyTypes[alias] = access;
}
}
}
}
}
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);
}
private PropertyGroupCollection GetPropertyTypeGroupCollection(MemberTypeReadOnlyDto dto, MemberType memberType)
{
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 Tuple <bool, bool, int>(typeDto.CanEdit, typeDto.ViewOnProfile, typeDto.Id.Value));
var tempGroupDto = groupDto;
var propertyType = new PropertyType(typeDto.ControlId,
typeDto.DbType.EnumParse <DataTypeDatabaseType>(true))
{
Alias = typeDto.Alias,
DataTypeDefinitionId = typeDto.DataTypeId,
Description = typeDto.Description,
Id = typeDto.Id.Value,
Name = typeDto.Name,
HelpText = typeDto.HelpText,
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);
}
protected override PropertyGroupViewModel CreatePropertyGroup(string tag, string translatedTag, PropertyGroupCollection lst)
{
if (tag == "Properties" && (_dataType is ObjectClass || _dataType is CompoundObject))
{
return ViewModelFactory.CreateViewModel<MultiplePropertyGroupViewModel.Factory>()
.Invoke(
DataContext,
this,
tag,
translatedTag,
lst.Concat(new[] {
ViewModelFactory.CreateViewModel<LabeledViewContainerViewModel.Factory>().Invoke(DataContext, this, "Preview", "", ViewModelFactory.CreateViewModel<PropertiesPrewiewViewModel.Factory>().Invoke(DataContext, this, _dataType))
})
.ToArray());
}
else if (tag == "GUI")
{
return ViewModelFactory.CreateViewModel<CustomPropertyGroupViewModel.Factory>()
.Invoke(
DataContext,
this,
tag,
translatedTag,
new[] {
ViewModelFactory.CreateViewModel<StackPanelViewModel.Factory>()
.Invoke(
DataContext,
this,
tag,
new[] {
ViewModelFactory.CreateViewModel<GroupBoxViewModel.Factory>().Invoke(DataContext, this, "Settings", lst.GetWithKeys().Where(kv => !kv.Key.StartsWith("Show")).Select(kv => kv.Value)),
ViewModelFactory.CreateViewModel<GroupBoxViewModel.Factory>().Invoke(DataContext, this, "Display", lst.GetWithKeys().Where(kv => kv.Key.StartsWith("Show")).Select(kv => kv.Value)),
})
});
}
else
{
return base.CreatePropertyGroup(tag, translatedTag, lst);
}
}
public IEnumerable <PropertyGroup> BuildEntity(IEnumerable <PropertyTypeGroupDto> dto)
{
var propertyGroups = new PropertyGroupCollection();
foreach (var groupDto in dto)
{
var group = new PropertyGroup();
//Only assign an Id if the PropertyGroup belongs to this ContentType
if (groupDto.ContentTypeNodeId == _id)
{
group.Id = groupDto.Id;
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 typeDtos = groupDto.PropertyTypeDtos.Where(x => x.Id > 0);
foreach (var typeDto in typeDtos)
{
var tempGroupDto = groupDto;
var propertyType = _propertyTypeCtor(typeDto.DataTypeDto.PropertyEditorAlias,
typeDto.DataTypeDto.DbType.EnumParse <DataTypeDatabaseType>(true),
typeDto.Alias);
propertyType.Alias = typeDto.Alias;
propertyType.DataTypeDefinitionId = typeDto.DataTypeId;
propertyType.Description = typeDto.Description;
propertyType.Id = typeDto.Id;
propertyType.Key = typeDto.UniqueId;
propertyType.Name = typeDto.Name;
propertyType.Mandatory = typeDto.Mandatory;
propertyType.SortOrder = typeDto.SortOrder;
propertyType.ValidationRegExp = typeDto.ValidationRegExp;
propertyType.PropertyGroupId = new Lazy <int>(() => tempGroupDto.Id);
propertyType.CreateDate = _createDate;
propertyType.UpdateDate = _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 IEnumerable <PropertyGroup> BuildEntity(IEnumerable <PropertyTypeGroupDto> groupDtos)
{
// groupDtos contains all the groups, those that are defined on the current
// content type, and those that are inherited from composition content types
var propertyGroups = new PropertyGroupCollection();
foreach (var groupDto in groupDtos)
{
var group = new PropertyGroup();
try
{
group.DisableChangeTracking();
// if the group is defined on the current content type,
// assign its identifier, else it will be zero
if (groupDto.ContentTypeNodeId == _contentTypeId)
{
group.Id = groupDto.Id;
}
group.Name = groupDto.Text;
group.SortOrder = groupDto.SortOrder;
group.PropertyTypes = new PropertyTypeCollection();
group.Key = groupDto.UniqueId;
//Because we are likely to have a group with no PropertyTypes we need to ensure that these are excluded
var typeDtos = groupDto.PropertyTypeDtos.Where(x => x.Id > 0);
foreach (var typeDto in typeDtos)
{
var tempGroupDto = groupDto;
var propertyType = _propertyTypeCtor(typeDto.DataTypeDto.PropertyEditorAlias,
typeDto.DataTypeDto.DbType.EnumParse <DataTypeDatabaseType>(true),
typeDto.Alias);
try
{
propertyType.DisableChangeTracking();
propertyType.Alias = typeDto.Alias;
propertyType.DataTypeDefinitionId = typeDto.DataTypeId;
propertyType.Description = typeDto.Description;
propertyType.Id = typeDto.Id;
propertyType.Key = typeDto.UniqueId;
propertyType.Name = typeDto.Name;
propertyType.Mandatory = typeDto.Mandatory;
propertyType.SortOrder = typeDto.SortOrder;
propertyType.ValidationRegExp = typeDto.ValidationRegExp;
propertyType.PropertyGroupId = new Lazy <int>(() => tempGroupDto.Id);
propertyType.CreateDate = _createDate;
propertyType.UpdateDate = _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);
}
finally
{
propertyType.EnableChangeTracking();
}
}
//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);
}
finally
{
group.EnableChangeTracking();
}
}
return(propertyGroups);
}
public TabDiffgram(TabConfiguration configuration, PropertyGroupCollection propertyGroups, ServiceContext serviceContext)
: base(configuration, serviceContext)
{
this.propertyGroups = propertyGroups;
Properties = new Dictionary <string, PropertyTypeDiffgram>();
}
protected override PropertyGroupViewModel CreatePropertyGroup(string tag, string translatedTag, PropertyGroupCollection lst)
{
return base.CreatePropertyGroup(tag, translatedTag, lst);
}
