/// <inheritdoc />
public IEnumerable <IPublishedContent> GetContentByTag(string tag, string?group = null, string?culture = null)
{
IEnumerable <int> ids = _tagService.GetTaggedContentByTag(tag, group, culture)
.Select(x => x.EntityId);
return(_contentQuery.Content(ids));
}
// Method One
private string GetMediaFromPublishedContentQuery()
{
var willBeEMpty = _publishedContentQuery.Content(2181)?.Url();
var cheerleaderUrl = _publishedContentQuery.Media(2181)?.Url();
// _contentService.GetById(2182).?.Url(); HAS NO URL as it might not be published!!!
return(cheerleaderUrl);
}
public vmBlock_DataLink Convert(Link link, UmbracoMappingContext context)
{
if (link != null)
{
if (link.Type == LinkType.External)
{
return(new vmBlock_DataLink()
{
Title = link.Name,
Label = link.Name,
Href = link.Url,
IsExternalLink = true,
IsNewTab = link.Target == "_blank"
});
}
else
{
var id = link.Udi as GuidUdi;
if (id != null)
{
var content = contentQuery.Content(id);
if (content != null)
{
var name = string.IsNullOrEmpty(link.Name) ? content.Name : link.Name;
var udi = context.Model != null ? new GuidUdi("document", context.Model.Key) : null;
var d = new vmBlock_DataLink()
{
Title = name,
Label = name,
Href = link.Url,
IsActive = link.Udi == udi,
IsNewTab = link.Target == "_blank"
};
return(d);
}
var media = contentQuery.Media(id);
if (media != null)
{
var name = string.IsNullOrEmpty(link.Name) ? media.Name : link.Name;
var d = new vmBlock_DataLink()
{
Title = name,
Label = name,
Href = media.Url(),
IsNewTab = link.Target == "_blank"
};
return(d);
}
}
}
}
return(null);
}
/// <summary>
/// Returns the content id based on the configured ContentErrorPage section.
/// </summary>
internal static int?GetContentIdFromErrorPageConfig(
ContentErrorPage errorPage,
IEntityService entityService,
IPublishedContentQuery publishedContentQuery,
int?domainContentId)
{
if (errorPage.HasContentId)
{
return(errorPage.ContentId);
}
if (errorPage.HasContentKey)
{
// need to get the Id for the GUID
// TODO: When we start storing GUIDs into the IPublishedContent, then we won't have to look this up
// but until then we need to look it up in the db. For now we've implemented a cached service for
// converting Int -> Guid and vice versa.
Attempt <int> found = entityService.GetId(errorPage.ContentKey, UmbracoObjectTypes.Document);
if (found)
{
return(found.Result);
}
return(null);
}
if (errorPage.ContentXPath.IsNullOrWhiteSpace() == false)
{
try
{
// we have an xpath statement to execute
var xpathResult = UmbracoXPathPathSyntaxParser.ParseXPathQuery(
xpathExpression: errorPage.ContentXPath,
nodeContextId: domainContentId,
getPath: nodeid =>
{
IEntitySlim ent = entityService.Get(nodeid);
return(ent.Path.Split(',').Reverse());
},
publishedContentExists: i => publishedContentQuery.Content(i) != null);
// now we'll try to execute the expression
IPublishedContent nodeResult = publishedContentQuery.ContentSingleAtXPath(xpathResult);
if (nodeResult != null)
{
return(nodeResult.Id);
}
}
catch (Exception ex)
{
StaticApplicationLogging.Logger.LogError(ex, "Could not parse xpath expression: {ContentXPath}", errorPage.ContentXPath);
return(null);
}
}
return(null);
}
/// <inheritdoc />
public IPublishedContent GetPublishedContent(Guid contentId, CancellationToken cancellationToken)
{
var content = _publishedContent.Content(contentId);
if (content is null)
{
throw new KeyNotFoundException($"Unable to get published content {contentId}. Content does not exist.");
}
return(content);
}
public IActionResult Get(Guid id, int level = 0)
{
var content = _publishedContent.Content(id);
var dictionary = new Dictionary <string, object>
{
{ "addUrl", true }
};
if (level <= 0)
{
return(Ok(_contentResolver.Value.ResolveContent(content, dictionary)));
}
dictionary.Add("level", level);
return(Ok(_contentResolver.Value.ResolveContent(content, dictionary)));
}
public CheeryQueryController(
//IPublishedContentCache cache /// causes an error
UmbracoHelper helper,
IPublishedContentQuery publishedContentQuery,
IContentService contentService,
IUmbracoContextFactory umbracoContextFactory)
{
_helper = helper;
_publishedContentQuery = publishedContentQuery;
_contentService = contentService;
_umbracoContextFactory = umbracoContextFactory;
var page = helper.Content(2141);
var otherPage = publishedContentQuery.Content(2141);
IPublishedContent anotherPage = null;
using (var cref = umbracoContextFactory.EnsureUmbracoContext())
{
var cache = cref.UmbracoContext.Content;
anotherPage = cache.GetById(2141);
}
}
public PartialViewResult GetPreviewMarkup([FromForm] PreviewData data, [FromQuery] int pageId)
{
var page = default(IPublishedContent);
// If the page is new, then the ID will be zero
if (pageId > 0)
{
// Get page container node
page = _contentQuery.Content(pageId);
if (page == null)
{
// If unpublished, then fake PublishedContent
page = new UnpublishedContent(pageId, _contentService, _contentTypeService, _dataTypeService, _propertyEditorCollection, _publishedContentTypeFactory);
}
}
if (_umbracoContext.UmbracoContext.PublishedRequest == null)
{
var request = _router.CreateRequestAsync(new Uri(Request.GetDisplayUrl())).Result;
request.SetPublishedContent(page);
_umbracoContext.UmbracoContext.PublishedRequest = request.Build();
}
// Set the culture for the preview
if (page != null && page.Cultures != null)
{
var currentCulture = string.IsNullOrWhiteSpace(data.Culture) ? page.GetCultureFromDomains() : data.Culture;
if (currentCulture != null && page.Cultures.ContainsKey(currentCulture))
{
var culture = new CultureInfo(page.Cultures[currentCulture].Culture);
// _umbracoContext.UmbracoContext.PublishedRequest.Culture = culture; // TODO: Not sure if this is needed?
System.Threading.Thread.CurrentThread.CurrentCulture = culture;
System.Threading.Thread.CurrentThread.CurrentUICulture = culture;
_umbracoContext.UmbracoContext.VariationContextAccessor.VariationContext = new VariationContext(culture.Name);
}
}
// Get content node object
var content = _dtgeHelper.ConvertValueToContent(data.Id, data.ContentTypeAlias, data.Value);
// Construct preview model
var model = new PreviewModel
{
Page = page,
Item = content,
EditorAlias = data.EditorAlias,
PreviewViewPath = data.PreviewViewPath,
ViewPath = data.ViewPath
};
// Render view
var partialName = "~/App_Plugins/DocTypeGridEditor/Render/DocTypeGridEditorPreviewer.cshtml";
var viewData = new ViewDataDictionary(new EmptyModelMetadataProvider(), new ModelStateDictionary());
viewData.Model = model;
return(new PartialViewResult()
{
ViewName = partialName,
ViewData = viewData
});
}
private IEnumerable <IPublishedContent> PostTemplateValue(QueryModel model, StringBuilder queryExpression)
{
var indent = Environment.NewLine + " ";
// set the source
IPublishedContent sourceDocument;
if (model.Source != null && model.Source.Id > 0)
{
sourceDocument = _publishedContentQuery.Content(model.Source.Id);
if (sourceDocument == null)
{
queryExpression.AppendFormat("Umbraco.Content({0})", model.Source.Id);
}
else
{
queryExpression.AppendFormat("Umbraco.Content(Guid.Parse(\"{0}\"))", sourceDocument.Key);
}
}
else
{
sourceDocument = _publishedContentQuery.ContentAtRoot().FirstOrDefault();
queryExpression.Append("Umbraco.ContentAtRoot().FirstOrDefault()");
}
// get children, optionally filtered by type
IEnumerable <IPublishedContent> contents;
queryExpression.Append(indent);
if (model.ContentType != null && !model.ContentType.Alias.IsNullOrWhiteSpace())
{
contents = sourceDocument == null
? Enumerable.Empty <IPublishedContent>()
: sourceDocument.ChildrenOfType(_variationContextAccessor, model.ContentType.Alias);
queryExpression.AppendFormat(".ChildrenOfType(\"{0}\")", model.ContentType.Alias);
}
else
{
contents = sourceDocument == null
? Enumerable.Empty <IPublishedContent>()
: sourceDocument.Children(_variationContextAccessor);
queryExpression.Append(".Children()");
}
// apply filters
foreach (var condition in model.Filters.Where(x => !x.ConstraintValue.IsNullOrWhiteSpace()))
{
//x is passed in as the parameter alias for the linq where statement clause
var operation = condition.BuildCondition <IPublishedContent>("x");
//for review - this uses a tonized query rather then the normal linq query.
contents = contents.Where(operation.Compile());
queryExpression.Append(indent);
queryExpression.AppendFormat(".Where({0})", operation);
}
// always add IsVisible() to the query
contents = contents.Where(x => x.IsVisible(_publishedValueFallback));
queryExpression.Append(indent);
queryExpression.Append(".Where(x => x.IsVisible())");
// apply sort
if (model.Sort != null && !model.Sort.Property.Alias.IsNullOrWhiteSpace())
{
contents = SortByDefaultPropertyValue(contents, model.Sort);
queryExpression.Append(indent);
queryExpression.AppendFormat(model.Sort.Direction == "ascending"
? ".OrderBy(x => x.{0})"
: ".OrderByDescending(x => x.{0})"
, model.Sort.Property.Alias);
}
// take
if (model.Take > 0)
{
contents = contents.Take(model.Take);
queryExpression.Append(indent);
queryExpression.AppendFormat(".Take({0})", model.Take);
}
return(contents);
}