/// <summary>
/// Gets the allowed children
/// </summary>
/// <param name="types"></param>
/// <param name="contentTypeService"></param>
/// <returns></returns>
private static IEnumerable <ContentTypeSort> FetchAllowedContentTypes(Type[] types, IContentTypeService contentTypeService)
{
if (types == null)
{
return(new ContentTypeSort[0]);
}
List <ContentTypeSort> contentTypeSorts = new List <ContentTypeSort>();
List <string> aliases = GetAliasesFromTypes(types);
var contentTypes = contentTypeService.GetAllContentTypes().Where(x => aliases.Contains(x.Alias)).ToArray();
int length = contentTypes.Length;
for (int i = 0; i < length; i++)
{
ContentTypeSort sort = new ContentTypeSort();
sort.Alias = contentTypes[i].Alias;
int id = contentTypes[i].Id;
sort.Id = new Lazy <int>(() => { return(id); });
sort.SortOrder = i;
contentTypeSorts.Add(sort);
}
return(contentTypeSorts);
}
public void Can_Deep_Clone_Content_Type_Sort()
{
var contentType = new ContentTypeSort(new Lazy <int>(() => 3), 4, "test");
var clone = (ContentTypeSort)contentType.DeepClone();
Assert.AreNotSame(clone, contentType);
Assert.AreEqual(clone, contentType);
Assert.AreEqual(clone.Id.Value, contentType.Id.Value);
Assert.AreEqual(clone.SortOrder, contentType.SortOrder);
Assert.AreEqual(clone.Alias, contentType.Alias);
}
public void Can_Deep_Clone_Content_Type_Sort()
{
ContentTypeSort contentType = BuildContentTypeSort();
var clone = (ContentTypeSort)contentType.DeepClone();
Assert.AreNotSame(clone, contentType);
Assert.AreEqual(clone, contentType);
Assert.AreEqual(clone.Id.Value, contentType.Id.Value);
Assert.AreEqual(clone.SortOrder, contentType.SortOrder);
Assert.AreEqual(clone.Alias, contentType.Alias);
}
/// <summary>
/// Convention to resolve referenced child content types
/// </summary>
/// <param name="types"></param>
/// <param name="currentType"> </param>
/// <returns></returns>
private static IEnumerable <ContentTypeSort> AllowedChildContentTypesConvention(IEnumerable <Type> types, Type currentType)
{
var contentTypeSorts = new List <ContentTypeSort>();
int order = 0;
foreach (var type in types)
{
if (type == currentType)
{
continue; //If the referenced type is equal to the current type we skip it to avoid a circular dependency
}
var isResolved = _contentTypeCache.ContainsKey(type.FullName);
var lazy = isResolved ? _contentTypeCache[type.FullName].ContentType : GetContentTypeDefinition(type);
var contentTypeSort = new ContentTypeSort(new Lazy <int>(() => lazy.Value.Id), order, lazy.Value.Alias);
contentTypeSorts.Add(contentTypeSort);
order++;
}
return(contentTypeSorts);
}
// Umbraco.Code.MapAll -SortOrder
private static void Map(EntityBasic source, ContentTypeSort target, MapperContext context)
{
target.Alias = source.Alias;
target.Id = new Lazy <int>(() => Convert.ToInt32(source.Id));
}
private bool IsContentTypeAllowedUnderContentType(IMediaType targetContent, IMediaType contentToTest)
{
ContentTypeSort cts = targetContent.AllowedContentTypes.Where(x => x.Id.Value == contentToTest.Id).FirstOrDefault();
return(cts != null);
}
