/// <summary>
/// This constructor is for tests and is not intended to be used directly from application code.
/// </summary>
/// <remarks>
/// <para>Values are assumed to be consistent and are not checked.</para>
/// </remarks>
public PublishedContentType(int id, string alias, PublishedItemType itemType, IEnumerable <string> compositionAliases, Func <IPublishedContentType, IEnumerable <IPublishedPropertyType> > propertyTypes, ContentVariation variations, bool isElement = false)
: this(id, alias, itemType, compositionAliases, variations, isElement)
{
_propertyTypes = propertyTypes(this).ToArray();
InitializeIndexes();
}
public static IEnumerable <IGraphType> CreateGraphTypes(
IEnumerable <IContentTypeComposition> contentTypes,
PublishedItemType publishedItemType)
{
var interfaceGraphTypes = new Dictionary <string, IInterfaceGraphType>();
//TODO: Whitelist/blacklist content types
var contentTypeList = contentTypes.ToList();
var compositions = contentTypeList.SelectMany(x => x.ContentTypeComposition).Distinct().ToList();
foreach (var contentType in compositions)
{
var graphType = new PublishedContentCompositionGraphType(contentType, publishedItemType);
yield return(graphType);
interfaceGraphTypes.Add(contentType.Alias, graphType);
}
foreach (var contentType in contentTypeList.Except(compositions))
{
var graphType = new PublishedContentGraphType(contentType, publishedItemType, interfaceGraphTypes);
yield return(graphType);
}
}
public PublishedContentGraphType(IContentTypeComposition contentType, PublishedItemType itemType, IDictionary <string, IInterfaceGraphType> interfaceGraphTypes)
{
Name = contentType.Alias.ToPascalCase();
Description = contentType.Description;
IsTypeOf = content => ((IPublishedContent)content).ContentType.Alias == contentType.Alias;
Metadata = new Dictionary <string, object>
{
[Constants.Metadata.ContentTypeAlias] = contentType.Alias,
[Constants.Metadata.AllowedAtRoot] = contentType.AllowedAsRoot,
[Constants.Metadata.AllowedChildren] = contentType.AllowedContentTypes.Select(x => x.Alias).ToArray(),
};
Interface <PublishedContentInterfaceGraphType>();
foreach (IContentTypeComposition composition in contentType.ContentTypeComposition)
{
if (interfaceGraphTypes.TryGetValue(composition.Alias, out IInterfaceGraphType interfaceType))
{
AddResolvedInterface(interfaceType);
}
}
this.AddUmbracoBuiltInProperties();
this.AddUmbracoContentPropeties(contentType, itemType);
}
internal static string GetNodeTypeIcon(PublishedItemType nodeType)
{
return(nodeType == PublishedItemType.Content ? "icon-umb-content"
: nodeType == PublishedItemType.Media ? "icon-umb-media"
: nodeType == PublishedItemType.Member ? "icon-umb-members"
: null);
}
/// <summary>
/// Gets a published content type.
/// </summary>
/// <param name="itemType">An item type.</param>
/// <param name="id">An identifier.</param>
/// <returns>The published content type corresponding to the item type and identifier.</returns>
public PublishedContentType Get(PublishedItemType itemType, int id)
{
try
{
_lock.EnterUpgradeableReadLock();
if (_typesById.TryGetValue(id, out var type))
{
return(type);
}
type = CreatePublishedContentType(itemType, id);
try
{
_lock.EnterWriteLock();
return(_typesByAlias[GetAliasKey(type)] = _typesById[type.Id] = type);
}
finally
{
if (_lock.IsWriteLockHeld)
{
_lock.ExitWriteLock();
}
}
}
finally
{
if (_lock.IsUpgradeableReadLockHeld)
{
_lock.ExitUpgradeableReadLock();
}
}
}
/// <summary>
///
/// </summary>
/// <param name="searcherName"></param>
/// <param name="nodeType"></param>
/// <param name="sort"></param>
/// <param name="skip"></param>
/// <param name="take"></param>
/// <returns></returns>
internal static MatchesResult GetDetachedMatches(string searcherName, PublishedItemType nodeType, string filter, string sort, int skip, int take)
{
var matchesResult = new MatchesResult();
var lookQuery = new LookQuery(searcherName)
{
NodeQuery = new NodeQuery()
{
Type = nodeType,
Alias = !string.IsNullOrWhiteSpace(filter) ? filter : null,
DetachedQuery = DetachedQuery.OnlyDetached
}
};
QueryService.SetSort(lookQuery, sort);
var lookResult = lookQuery.Search();
matchesResult.TotalItemCount = lookResult.TotalItemCount;
matchesResult.Matches = lookResult
.Matches
.Skip(skip)
.Take(take)
.Select(x => (MatchesResult.Match)x)
.ToArray();
return(matchesResult);
}
private PublishedContentType CreatePublishedContentType(PublishedItemType itemType, int id)
{
if (GetPublishedContentTypeById != null)
{
return(GetPublishedContentTypeById(id));
}
IContentTypeComposition contentType;
switch (itemType)
{
case PublishedItemType.Content:
contentType = _contentTypeService.Get(id);
break;
case PublishedItemType.Media:
contentType = _mediaTypeService.Get(id);
break;
case PublishedItemType.Member:
contentType = _memberTypeService.Get(id);
break;
default:
throw new ArgumentOutOfRangeException(nameof(itemType));
}
if (contentType == null)
{
throw new Exception($"ContentTypeService failed to find a {itemType.ToString().ToLower()} type with id {id}.");
}
return(_publishedContentTypeFactory.CreateContentType(contentType));
}
private IReadOnlyCollection <IPublishedContentType> CreateContentTypes(PublishedItemType itemType, int[] ids)
{
// XxxTypeService.GetAll(empty) returns everything!
if (ids.Length == 0)
{
return(Array.Empty <IPublishedContentType>());
}
IEnumerable <IContentTypeComposition> contentTypes;
switch (itemType)
{
case PublishedItemType.Content:
contentTypes = _serviceContext.ContentTypeService.GetAll(ids);
break;
case PublishedItemType.Media:
contentTypes = _serviceContext.MediaTypeService.GetAll(ids);
break;
case PublishedItemType.Member:
contentTypes = _serviceContext.MemberTypeService.GetAll(ids);
break;
default:
throw new ArgumentOutOfRangeException(nameof(itemType));
}
// some may be missing - not checking here
return(contentTypes.Select(x => _publishedContentTypeFactory.CreateContentType(x)).ToList());
}
/// <summary>
/// Gets a published content type.
/// </summary>
/// <param name="itemType">An item type.</param>
/// <param name="key">An key.</param>
/// <returns>The published content type corresponding to the item key.</returns>
public IPublishedContentType Get(PublishedItemType itemType, Guid key)
{
try
{
_lock.EnterUpgradeableReadLock();
if (_keyToIdMap.TryGetValue(key, out var id))
{
return(Get(itemType, id));
}
var type = CreatePublishedContentType(itemType, key);
try
{
_lock.EnterWriteLock();
_keyToIdMap[key] = type.Id;
return(_typesByAlias[GetAliasKey(type)] = _typesById[type.Id] = type);
}
finally
{
if (_lock.IsWriteLockHeld)
{
_lock.ExitWriteLock();
}
}
}
finally
{
if (_lock.IsUpgradeableReadLockHeld)
{
_lock.ExitUpgradeableReadLock();
}
}
}
/// <summary>
///
/// </summary>
/// <param name="searcherName"></param>
/// <param name="sort"></param>
/// <param name="skip"></param>
/// <param name="take"></param>
/// <returns></returns>
internal static MatchesResult GetNodeTypeMatches(string searcherName, PublishedItemType nodeType, string sort, int skip, int take)
{
var matchesResult = new MatchesResult();
var lookQuery = new LookQuery(searcherName);
lookQuery.NodeQuery = new NodeQuery()
{
Type = nodeType
};
QueryService.SetSort(lookQuery, sort);
var lookResult = lookQuery.Search();
matchesResult.TotalItemCount = lookResult.TotalItemCount;
matchesResult.Matches = lookResult
.Matches
.Skip(skip)
.Take(take)
.Select(x => (MatchesResult.Match)x)
.ToArray();
return(matchesResult);
}
private static PublishedContentType CreatePublishedContentType(PublishedItemType itemType, string alias)
{
if (GetPublishedContentTypeCallback != null)
{
return(GetPublishedContentTypeCallback(alias));
}
IContentTypeComposition contentType;
switch (itemType)
{
case PublishedItemType.Content:
contentType = ApplicationContext.Current.Services.ContentTypeService.GetContentType(alias);
break;
case PublishedItemType.Media:
contentType = ApplicationContext.Current.Services.ContentTypeService.GetMediaType(alias);
break;
case PublishedItemType.Member:
contentType = ApplicationContext.Current.Services.MemberTypeService.Get(alias);
break;
default:
throw new ArgumentOutOfRangeException("itemType");
}
if (contentType == null)
{
throw new InvalidOperationException(string.Format("ContentTypeService failed to find a {0} type with alias \"{1}\".",
itemType.ToString().ToLower(), alias));
}
return(new PublishedContentType(contentType));
}
public PublishedContentGraphType(IContentTypeComposition contentType, PublishedItemType itemType, IDictionary <string, IInterfaceGraphType> interfaceGraphTypes)
{
Name = contentType.Alias.ToPascalCase();
Description = contentType.Description;
IsTypeOf = content => ((IPublishedContent)content).ContentType.Alias == contentType.Alias;
Metadata = new Dictionary <string, object>
{
[Constants.Metadata.ContentTypeAlias] = contentType.Alias,
[Constants.Metadata.AllowedAtRoot] = contentType.AllowedAsRoot,
[Constants.Metadata.AllowedChildren] = contentType.AllowedContentTypes.Select(x => x.Alias).ToArray(),
};
Interface <PublishedContentInterfaceGraphType>();
foreach (IContentTypeComposition composition in contentType.ContentTypeComposition)
{
if (interfaceGraphTypes.TryGetValue(composition.Alias, out IInterfaceGraphType interfaceType))
{
AddResolvedInterface(interfaceType);
}
}
// TODO: set this field name as a reserved property alias
Field <NonNullGraphType <PublishedContentDataGraphType> >()
.Name("_contentData")
.Description("Built in published content data.")
.Resolve(context => context.Source)
.SetDoctypeMetadata(GetMetadata <string>(Constants.Metadata.ContentTypeAlias));
this.AddUmbracoContentPropeties(contentType, itemType);
}
public IHttpActionResult GetDetachedFilters(
[FromUri] string searcherName,
[FromUri] PublishedItemType nodeType)
{
var searcher = (BaseSearchProvider)this.RequestContext.RouteData.Values["searcher"];
return(this.Ok(QueryService.GetDetachedFilters(searcherName, nodeType)));
}
private PublishedContentType(int id, string alias, PublishedItemType itemType, IEnumerable <string> compositionAliases, ContentVariation variations)
{
Id = id;
Alias = alias;
ItemType = itemType;
CompositionAliases = new HashSet <string>(compositionAliases, StringComparer.InvariantCultureIgnoreCase);
Variations = variations;
}
public IHttpActionResult GetNodeTypeMatches(
[FromUri] string searcherName,
[FromUri] PublishedItemType nodeType,
[FromUri] string sort,
[FromUri] int skip,
[FromUri] int take)
{
return(this.Ok(QueryService.GetNodeTypeMatches(searcherName, nodeType, sort, skip, take)));
}
private PublishedContentType(Guid key, int id, string alias, PublishedItemType itemType, IEnumerable <string> compositionAliases, ContentVariation variations, bool isElement)
{
Key = key;
Id = id;
Alias = alias;
ItemType = itemType;
CompositionAliases = new HashSet <string>(compositionAliases, StringComparer.InvariantCultureIgnoreCase);
Variations = variations;
IsElement = isElement;
}
public static PublishedContentType Get(PublishedItemType itemType, string alias)
{
var key = string.Format("PublishedContentType_{0}_{1}",
itemType.ToString().ToLowerInvariant(), alias.ToLowerInvariant());
var type = ApplicationContext.Current.ApplicationCache.StaticCache.GetCacheItem <PublishedContentType>(key,
() => CreatePublishedContentType(itemType, alias));
return(type);
}
internal NodeTypeTreeNode(FormDataCollection queryStrings) : base("nodeType-" + queryStrings["searcherName"] + "|" + queryStrings["nodeType"], queryStrings)
{
this.SearcherName = queryStrings["searcherName"];
this.NodeType = (PublishedItemType)Enum.Parse(typeof(PublishedItemType), queryStrings["nodeType"], true);
this.Icon = IconService.GetNodeTypeIcon(this.NodeType);
this.Name = this.NodeType == PublishedItemType.Content ? "Content"
: this.NodeType == PublishedItemType.Media ? "Media"
: this.NodeType == PublishedItemType.Member ? "Members"
: null;
}
/// <summary>
/// This constructor is for tests and is not intended to be used directly from application code.
/// </summary>
/// <remarks>
/// <para>Values are assumed to be consistent and are not checked.</para>
/// </remarks>
public PublishedContentType(int id, string alias, PublishedItemType itemType, IEnumerable <string> compositionAliases, IEnumerable <PublishedPropertyType> propertyTypes, ContentVariation variations, bool isElement = false)
: this(id, alias, itemType, compositionAliases, variations, isElement)
{
var propertyTypesA = propertyTypes.ToArray();
foreach (var propertyType in propertyTypesA)
{
propertyType.ContentType = this;
}
_propertyTypes = propertyTypesA;
InitializeIndexes();
}
private IPublishedContentType CreatePublishedContentType(PublishedItemType itemType, Guid key)
{
IContentTypeComposition contentType = itemType switch
{
PublishedItemType.Content => _contentTypeService.Get(key),
PublishedItemType.Media => _mediaTypeService.Get(key),
PublishedItemType.Member => _memberTypeService.Get(key),
_ => throw new ArgumentOutOfRangeException(nameof(itemType)),
};
if (contentType == null)
{
throw new Exception($"ContentTypeService failed to find a {itemType.ToString().ToLower()} type with key \"{key}\".");
}
return(_publishedContentTypeFactory.CreateContentType(contentType));
}
public static ComplexGraphType <IPublishedContent> AddUmbracoContentPropeties(
this ComplexGraphType <IPublishedContent> graphType,
IContentTypeComposition contentType,
PublishedItemType publishedItemType)
{
var publishedContentType = PublishedContentType.Get(publishedItemType, contentType.Alias);
foreach (var property in contentType.CompositionPropertyTypes)
{
//TODO: black/whitelist properties
if (property.PropertyEditorAlias == Constants.PropertyEditors.ListViewAlias ||
property.PropertyEditorAlias == Constants.PropertyEditors.FolderBrowserAlias ||
property.Alias.StartsWith("umbracoMember"))
{
continue;
}
var publishedPropertyType = publishedContentType.GetPropertyType(property.Alias);
var resolver = GraphQLValueResolversResolver.Current.FindResolver(publishedPropertyType)
?? new DefaultValueResolver();
var propertyGraphType = resolver.GetGraphQLType(publishedPropertyType);
if (property.Mandatory)
{
propertyGraphType = typeof(NonNullGraphType <>).MakeGenericType(propertyGraphType);
}
graphType.Field(
propertyGraphType,
property.Alias.ToCamelCase(),
property.Description,
resolve: context =>
{
var publishedProperty = context.Source.GetProperty(property.Alias);
return(publishedProperty == null
? null
: resolver.Resolve(publishedPropertyType, publishedProperty.Value));
}
).SetPermissions(graphType);
}
return(graphType);
}
// looks safer but probably useless... ppl should not call these methods directly
// and if they do... they have to take care about not doing stupid things
//public static PublishedPropertyType GetModelPropertyType2<T>(Expression<Func<T, object>> selector)
// where T : PublishedContentModel
//{
// var type = typeof (T);
// var s1 = type.GetField("ModelTypeAlias", BindingFlags.Public | BindingFlags.Static);
// var alias = (s1.IsLiteral && s1.IsInitOnly && s1.FieldType == typeof(string)) ? (string)s1.GetValue(null) : null;
// var s2 = type.GetField("ModelItemType", BindingFlags.Public | BindingFlags.Static);
// var itemType = (s2.IsLiteral && s2.IsInitOnly && s2.FieldType == typeof(PublishedItemType)) ? (PublishedItemType)s2.GetValue(null) : 0;
// var contentType = PublishedContentType.Get(itemType, alias);
// // etc...
//}
public static PublishedContentType GetModelContentType(PublishedItemType itemType, string alias)
{
var facade = Current.UmbracoContext.PublishedSnapshot; // fixme inject!
switch (itemType)
{
case PublishedItemType.Content:
return(facade.Content.GetContentType(alias));
case PublishedItemType.Media:
return(facade.Media.GetContentType(alias));
case PublishedItemType.Member:
return(facade.Members.GetContentType(alias));
default:
throw new ArgumentOutOfRangeException(nameof(itemType));
}
}
private static PublishedContentType CreatePublishedContentType(PublishedItemType itemType, string alias)
{
if (GetPublishedContentTypeCallback != null)
{
return(GetPublishedContentTypeCallback(alias));
}
var contentType = itemType == PublishedItemType.Content
? (IContentTypeComposition)ApplicationContext.Current.Services.ContentTypeService.GetContentType(alias)
: (IContentTypeComposition)ApplicationContext.Current.Services.ContentTypeService.GetMediaType(alias);
if (contentType == null)
{
throw new Exception(string.Format("ContentTypeService failed to find a {0} type with alias \"{1}\".",
itemType.ToString().ToLower(), alias));
}
return(new PublishedContentType(contentType));
}
internal static FiltersResult GetDetachedFilters(string searcherName, PublishedItemType nodeType)
{
var filtersResult = new FiltersResult();
filtersResult.Aliases = new LookQuery(searcherName)
{
NodeQuery = new NodeQuery()
{
Type = nodeType, DetachedQuery = DetachedQuery.OnlyDetached
}
}
.Search()
.Matches
.Select(x => x.Alias)
.Distinct()
.OrderBy(x => x)
.ToArray();
return(filtersResult);
}
/// <summary>
/// gets the icon associated with the docType, mediaType or memberType (by alias)
/// </summary>
/// <param name="nodeType">whether it's a node, media or member</param>
/// <param name="isDetached">flag indicating the item is detached (so will always be a document type_</param>
/// <param name="alias">alias of the node, media or member type</param>
/// <returns></returns>
internal static string GetAliasIcon(PublishedItemType nodeType, bool isDetached, string alias)
{
string icon = null;
try
{
if (nodeType == PublishedItemType.Content || isDetached)
{
var contentType = ApplicationContext.Current.Services.ContentTypeService.GetContentType(alias);
icon = contentType.Icon;
}
else
{
switch (nodeType)
{
case PublishedItemType.Media:
var mediaType = ApplicationContext.Current.Services.ContentTypeService.GetMediaType(alias);
icon = mediaType.Icon;
break;
case PublishedItemType.Member:
var memberType = ApplicationContext.Current.Services.MemberTypeService.Get(alias);
icon = memberType.Icon;
break;
}
}
}
catch
{
icon = "icon-alert-alt";
}
return(icon);
}
private IPublishedContentType CreatePublishedContentType(PublishedItemType itemType, int id)
{
if (GetPublishedContentTypeById != null)
{
return(GetPublishedContentTypeById(id));
}
IContentTypeComposition contentType = itemType switch
{
PublishedItemType.Content => _contentTypeService.Get(id),
PublishedItemType.Media => _mediaTypeService.Get(id),
PublishedItemType.Member => _memberTypeService.Get(id),
_ => throw new ArgumentOutOfRangeException(nameof(itemType)),
};
if (contentType == null)
{
throw new Exception($"ContentTypeService failed to find a {itemType.ToString().ToLower()} type with id {id}.");
}
return(_publishedContentTypeFactory.CreateContentType(contentType));
}
private static PublishedContentType GetPublishedContentType(PublishedItemType type, string alias)
{
var dataType = new DataType(new VoidEditor(Mock.Of <ILogger>()))
{
Id = 1
};
var dataTypeService = Mock.Of <IDataTypeService>();
Mock.Get(dataTypeService)
.Setup(x => x.GetDataType(It.IsAny <int>()))
.Returns <int>(id => id == 1 ? dataType : null);
Mock.Get(dataTypeService)
.Setup(x => x.GetAll())
.Returns(new[] { dataType });
var factory = new PublishedContentTypeFactory(Mock.Of <IPublishedModelFactory>(), new PropertyValueConverterCollection(Array.Empty <IPropertyValueConverter>()), dataTypeService);
return(factory.CreateContentType(0, alias, new string[] {},
new List <PublishedPropertyType>(Enumerable.Range(0, 10).Select(x => factory.CreatePropertyType("prop" + x, 1)))));
}
/// <summary>
/// Gets a published content type.
/// </summary>
/// <param name="itemType">An item type.</param>
/// <param name="alias">An alias.</param>
/// <returns>The published content type corresponding to the item type and alias.</returns>
public IPublishedContentType Get(PublishedItemType itemType, string alias)
{
var aliasKey = GetAliasKey(itemType, alias);
try
{
_lock.EnterUpgradeableReadLock();
if (_typesByAlias.TryGetValue(aliasKey, out var type))
{
return(type);
}
type = CreatePublishedContentType(itemType, alias);
try
{
_lock.EnterWriteLock();
if (type.TryGetKey(out var key))
{
_keyToIdMap[key] = type.Id;
}
return(_typesByAlias[aliasKey] = _typesById[type.Id] = type);
}
finally
{
if (_lock.IsWriteLockHeld)
{
_lock.ExitWriteLock();
}
}
}
finally
{
if (_lock.IsUpgradeableReadLockHeld)
{
_lock.ExitUpgradeableReadLock();
}
}
}
// looks safer but probably useless... ppl should not call these methods directly
// and if they do... they have to take care about not doing stupid things
// public static PublishedPropertyType GetModelPropertyType2<T>(Expression<Func<T, object>> selector)
// where T : PublishedContentModel
// {
// var type = typeof (T);
// var s1 = type.GetField("ModelTypeAlias", BindingFlags.Public | BindingFlags.Static);
// var alias = (s1.IsLiteral && s1.IsInitOnly && s1.FieldType == typeof(string)) ? (string)s1.GetValue(null) : null;
// var s2 = type.GetField("ModelItemType", BindingFlags.Public | BindingFlags.Static);
// var itemType = (s2.IsLiteral && s2.IsInitOnly && s2.FieldType == typeof(PublishedItemType)) ? (PublishedItemType)s2.GetValue(null) : 0;
// var contentType = PublishedContentType.Get(itemType, alias);
// // etc...
// }
public static IPublishedContentType?GetModelContentType(
IPublishedSnapshotAccessor publishedSnapshotAccessor,
PublishedItemType itemType,
string alias)
{
IPublishedSnapshot publishedSnapshot = publishedSnapshotAccessor.GetRequiredPublishedSnapshot();
switch (itemType)
{
case PublishedItemType.Content:
return(publishedSnapshot.Content?.GetContentType(alias));
case PublishedItemType.Media:
return(publishedSnapshot.Media?.GetContentType(alias));
case PublishedItemType.Member:
return(publishedSnapshot.Members?.GetContentType(alias));
default:
throw new ArgumentOutOfRangeException(nameof(itemType));
}
}
public static string GetLinkType(PublishedItemType itemType)
{
switch (itemType)
{
case PublishedItemType.Unknown:
return(string.Empty);
case PublishedItemType.Element:
return(LinkType.Element.ToString());
case PublishedItemType.Content:
return(LinkType.Content.ToString());
case PublishedItemType.Media:
return(LinkType.Media.ToString());
case PublishedItemType.Member:
return(LinkType.Member.ToString());
default:
throw new ArgumentOutOfRangeException(nameof(itemType), itemType, null);
}
}
private static IList<TypeModel> GetTypes(PublishedItemType itemType, IContentTypeBase[] contentTypes)
{
var typeModels = new List<TypeModel>();
// get the types and the properties
foreach (var contentType in contentTypes)
{
var typeModel = new TypeModel
{
Id = contentType.Id,
Alias = contentType.Alias,
ClrName = contentType.Alias.ToCleanString(CleanStringType.ConvertCase | CleanStringType.PascalCase),
ParentId = contentType.ParentId,
Name = contentType.Name,
Description = contentType.Description
};
switch (itemType)
{
case PublishedItemType.Content:
typeModel.ItemType = TypeModel.ItemTypes.Content;
break;
case PublishedItemType.Media:
typeModel.ItemType = TypeModel.ItemTypes.Media;
break;
case PublishedItemType.Member:
typeModel.ItemType = TypeModel.ItemTypes.Member;
break;
default:
throw new InvalidOperationException(string.Format("Unsupported PublishedItemType \"{0}\".", itemType));
}
typeModels.Add(typeModel);
var publishedContentType = PublishedContentType.Get(itemType, contentType.Alias);
foreach (var propertyType in contentType.PropertyTypes)
{
var propertyModel = new PropertyModel
{
Alias = propertyType.Alias,
ClrName = propertyType.Alias.ToCleanString(CleanStringType.ConvertCase | CleanStringType.PascalCase),
Name = propertyType.Name,
Description = propertyType.Description
};
var publishedPropertyType = publishedContentType.GetPropertyType(propertyType.Alias);
propertyModel.ClrType = publishedPropertyType.ClrType;
typeModel.Properties.Add(propertyModel);
}
}
// wire the base types
foreach (var typeModel in typeModels.Where(x => x.ParentId > 0))
{
typeModel.BaseType = typeModels.SingleOrDefault(x => x.Id == typeModel.ParentId);
// Umbraco 7.4 introduces content types containers, so even though ParentId > 0, the parent might
// not be a content type - here we assume that BaseType being null while ParentId > 0 means that
// the parent is a container (and we don't check).
typeModel.IsParent = typeModel.BaseType != null;
}
// discover mixins
foreach (var contentType in contentTypes)
{
var typeModel = typeModels.SingleOrDefault(x => x.Id == contentType.Id);
if (typeModel == null) throw new Exception("Panic: no type model matching content type.");
IEnumerable<IContentTypeComposition> compositionTypes;
var contentTypeAsMedia = contentType as IMediaType;
var contentTypeAsContent = contentType as IContentType;
var contentTypeAsMember = contentType as IMemberType;
if (contentTypeAsMedia != null) compositionTypes = contentTypeAsMedia.ContentTypeComposition;
else if (contentTypeAsContent != null) compositionTypes = contentTypeAsContent.ContentTypeComposition;
else if (contentTypeAsMember != null) compositionTypes = contentTypeAsMember.ContentTypeComposition;
else throw new Exception(string.Format("Panic: unsupported type \"{0}\".", contentType.GetType().FullName));
foreach (var compositionType in compositionTypes)
{
var compositionModel = typeModels.SingleOrDefault(x => x.Id == compositionType.Id);
if (compositionModel == null) throw new Exception("Panic: composition type does not exist.");
if (compositionType.Id == contentType.ParentId) continue;
// add to mixins
typeModel.MixinTypes.Add(compositionModel);
// mark as mixin - as well as parents
compositionModel.IsMixin = true;
while ((compositionModel = compositionModel.BaseType) != null)
compositionModel.IsMixin = true;
}
}
return typeModels;
}
public static PublishedContentType Get(PublishedItemType itemType, string alias)
{
var key = string.Format("PublishedContentType_{0}_{1}",
itemType == PublishedItemType.Content ? "content" : "media", alias.ToLowerInvariant());
var type = ApplicationContext.Current.ApplicationCache.StaticCache.GetCacheItem<PublishedContentType>(key,
() => CreatePublishedContentType(itemType, alias));
return type;
}
private static PublishedContentType CreatePublishedContentType(PublishedItemType itemType, string alias)
{
if (GetPublishedContentTypeCallback != null)
return GetPublishedContentTypeCallback(alias);
var contentType = itemType == PublishedItemType.Content
? (IContentTypeComposition) ApplicationContext.Current.Services.ContentTypeService.GetContentType(alias)
: (IContentTypeComposition) ApplicationContext.Current.Services.ContentTypeService.GetMediaType(alias);
if (contentType == null)
throw new Exception(string.Format("ContentTypeService failed to find a {0} type with alias \"{1}\".",
itemType.ToString().ToLower(), alias));
return new PublishedContentType(contentType);
}
