/// <summary>
/// Gets the content types from the database.
/// </summary>
private async Task <IEnumerable <ContentType> > GetTypes()
{
var types = _cache?.Get <IEnumerable <ContentType> >(CacheKey);
if (types == null)
{
types = await _repo.GetAll().ConfigureAwait(false);
_cache?.Set(CacheKey, types);
}
return(types);
}
private IEnumerable <IContent> ProcessQuery(Sql sql)
{
//NOTE: This doesn't allow properties to be part of the query
var dtos = Database.Fetch <DocumentDto, ContentVersionDto, ContentDto, NodeDto, DocumentPublishedReadOnlyDto>(sql);
//nothing found
if (dtos.Any() == false)
{
return(Enumerable.Empty <IContent>());
}
//content types
//NOTE: This should be ok for an SQL 'IN' statement, there shouldn't be an insane amount of content types
var contentTypes = _contentTypeRepository.GetAll(dtos.Select(x => x.ContentVersionDto.ContentDto.ContentTypeId).ToArray())
.ToArray();
var ids = dtos
.Where(dto => dto.TemplateId.HasValue && dto.TemplateId.Value > 0)
.Select(x => x.TemplateId.Value).ToArray();
//NOTE: This should be ok for an SQL 'IN' statement, there shouldn't be an insane amount of content types
var templates = ids.Length == 0 ? Enumerable.Empty <ITemplate>() : _templateRepository.GetAll(ids).ToArray();
var dtosWithContentTypes = dtos
//This select into and null check are required because we don't have a foreign damn key on the contentType column
// http://issues.umbraco.org/issue/U4-5503
.Select(x => new { dto = x, contentType = contentTypes.FirstOrDefault(ct => ct.Id == x.ContentVersionDto.ContentDto.ContentTypeId) })
.Where(x => x.contentType != null)
.ToArray();
//Go get the property data for each document
var docDefs = dtosWithContentTypes.Select(d => new DocumentDefinition(
d.dto.NodeId,
d.dto.VersionId,
d.dto.ContentVersionDto.VersionDate,
d.dto.ContentVersionDto.ContentDto.NodeDto.CreateDate,
d.contentType));
var propertyData = GetPropertyCollection(sql, docDefs);
return(dtosWithContentTypes.Select(d => CreateContentFromDto(
d.dto,
contentTypes.First(ct => ct.Id == d.dto.ContentVersionDto.ContentDto.ContentTypeId),
templates.FirstOrDefault(tem => tem.Id == (d.dto.TemplateId.HasValue ? d.dto.TemplateId.Value : -1)),
propertyData[d.dto.NodeId])));
}
private Tuple <IEnumerable <ContentType>, IEnumerable <Module> > ParseUSyncFiles(string folder)
{
//pages
var uSyncFolder = Directory
.GetDirectories(folder, "uSync", SearchOption.AllDirectories)
.First(i => Directory.GetDirectories(i, "v8", SearchOption.AllDirectories).Any());
_context.BaseFolder = uSyncFolder;
var contentTypeFiles = _contentTypeRepository.GetAll();
var dataTypeFiles = _dataTypeRepository.GetAll();
var blueprintFiles = _blueprintRepository.GetAll();
if (!blueprintFiles.Any())
{
textBoxResults.AppendText(Environment.NewLine + "Blueprints folder not found or empty!");
return(new Tuple <IEnumerable <ContentType>, IEnumerable <Module> >(null, null));
}
var contentTypes = contentTypeFiles.Build(dataTypeFiles, blueprintFiles);
foreach (var contentType in contentTypes)
{
ComputeNestedContentProperties(contentType, dataTypeFiles);
//ComputeNestedContentElementsProperties(contentType, dataTypeFiles, blueprintFiles);
//ComputeTreePickerMaxItems(dataTypeDocuments, allProperties);
ComputeNotes(contentType, dataTypeFiles);
var parentDocTypes = contentTypes.Where(i => i.ChildDocTypes.Contains(contentType.Alias));
contentType.ParentDocTypes = parentDocTypes.Select(i => i.Name).ToList();
var childDocTypesNames = new List <string>();
foreach (var childAlias in contentType.ChildDocTypes)
{
var name = contentTypes.FirstOrDefault(i => i.Alias == childAlias)?.Name;
if (!string.IsNullOrEmpty(name))
{
childDocTypesNames.Add(name);
}
}
contentType.ChildDocTypes = childDocTypesNames;
}
// fill nested content properties
foreach (var docType in contentTypes)
{
foreach (var prop in docType.PropertiesSelf)
{
if (prop.NestedContentDocTypes != null && prop.NestedContentDocTypes.Any())
{
var nestedContentList = new List <NestedContentDocType>();
foreach (var nestedContentDocType in prop.NestedContentDocTypes)
{
nestedContentDocType.Properties = contentTypes
.FirstOrDefault(i => i.Alias == nestedContentDocType.Alias)?.PropertiesSelf.ToList();
nestedContentList.Add(nestedContentDocType);
}
prop.NestedContentDocTypes = nestedContentList;
}
else if (prop.NestedContentElementsDocTypes != null && prop.NestedContentElementsDocTypes.Any())
{
foreach (var item in prop.NestedContentElementsDocTypes)
{
item.ContentType = contentTypes.First(i => i.Alias == item.NcContentTypeAlias);
}
}
}
}
var allModules = contentTypes
.SelectMany(i => i.Properties)
.Where(i => i.NestedContentElementsDocTypes != null && i.NestedContentElementsDocTypes.Any())
.SelectMany(i => i.NestedContentElementsDocTypes)
.GroupBy(i => i.NcContentTypeAlias)
.Select(g =>
{
var module = g.First();
if (!string.IsNullOrEmpty(module.NcContentTypeAlias))
{
module.ContentType = contentTypes.FirstOrDefault(c => c.Alias == module.NcContentTypeAlias);
}
return(module);
})
.OrderBy(i => i.Name)
.ToList();
var pages = contentTypes.Where(i => i.Alias.EndsWith("Page") || i.Alias.EndsWith("websiteSettings"));
return(new Tuple <IEnumerable <ContentType>, IEnumerable <Module> >(pages, allModules));
}
public ContentType[] GetAll()
{
return(_contentTypeRepository.GetAll());
}
