private static IPublishedContent FindContentByAlias(ContextualPublishedContentCache cache, int rootNodeId, string alias) { if (alias == null) throw new ArgumentNullException("alias"); // the alias may be "foo/bar" or "/foo/bar" // there may be spaces as in "/foo/bar, /foo/nil" // these should probably be taken care of earlier on alias = alias.TrimStart('/'); var xpathBuilder = new StringBuilder(); xpathBuilder.Append(XPathStringsDefinition.Root); if (rootNodeId > 0) xpathBuilder.AppendFormat(XPathStrings.DescendantDocumentById, rootNodeId); XPathVariable var = null; if (alias.Contains('\'') || alias.Contains('"')) { // use a var, as escaping gets ugly pretty quickly var = new XPathVariable("alias", alias); alias = "$alias"; } xpathBuilder.AppendFormat(XPathStrings.DescendantDocumentByAlias, alias); var xpath = xpathBuilder.ToString(); // note: it's OK if var is null, will be ignored return cache.GetSingleByXPath(xpath, var); }
public void SetUp() { TestHelper.SetupLog4NetForTests(); //create the app context ApplicationContext.Current = new ApplicationContext(false); _httpContextFactory = new FakeHttpContextFactory("~/Home"); //ensure the StateHelper is using our custom context StateHelper.HttpContext = _httpContextFactory.HttpContext; UmbracoSettings.UseLegacyXmlSchema = false; var cache = new PublishedContentCache { GetXmlDelegate = (context, preview) => { var doc = new XmlDocument(); doc.LoadXml(GetXml()); return(doc); } }; _umbracoContext = new UmbracoContext( _httpContextFactory.HttpContext, ApplicationContext.Current, new PublishedCaches(cache, new PublishedMediaCache())); _cache = _umbracoContext.ContentCache; }
public override void Initialize() { base.Initialize(); _httpContextFactory = new FakeHttpContextFactory("~/Home"); //ensure the StateHelper is using our custom context StateHelper.HttpContext = _httpContextFactory.HttpContext; var settings = SettingsForTests.GenerateMockSettings(); var contentMock = Mock.Get(settings.Content); contentMock.Setup(x => x.UseLegacyXmlSchema).Returns(false); SettingsForTests.ConfigureSettings(settings); _xml = new XmlDocument(); _xml.LoadXml(GetXml()); var cache = new PublishedContentCache { GetXmlDelegate = (context, preview) => _xml }; _umbracoContext = new UmbracoContext( _httpContextFactory.HttpContext, ApplicationContext, new PublishedCaches(cache, new PublishedMediaCache(ApplicationContext)), new WebSecurity(_httpContextFactory.HttpContext, ApplicationContext)); _cache = _umbracoContext.ContentCache; }
/// <summary> /// Initializes the <see cref="ExpiryRulesFromUmbraco" /> class. /// </summary> /// <param name="umbracoCache">The Umbraco content cache.</param> public ExpiryRulesFromUmbraco(ContextualPublishedContentCache umbracoCache) { _umbracoCache = umbracoCache ?? throw new ArgumentNullException(nameof(umbracoCache)); _expiryRules = _umbracoCache.GetAtRoot().FirstOrDefault(node => node.DocumentTypeAlias == "expiryRules"); GetDocumentTypeRules(); GetPageRules(); GetDefaults(); }
/// <summary> /// Constructor used to return results from the caches /// </summary> /// <param name="contentCache"></param> /// <param name="mediaCache"></param> public PublishedContentQuery(ContextualPublishedContentCache contentCache, ContextualPublishedMediaCache mediaCache) { if (contentCache == null) { throw new ArgumentNullException("contentCache"); } if (mediaCache == null) { throw new ArgumentNullException("mediaCache"); } _contentCache = contentCache; _mediaCache = mediaCache; }
private static IPublishedContent FindContentByAlias(ContextualPublishedContentCache cache, int rootNodeId, string alias) { if (alias == null) { throw new ArgumentNullException("alias"); } // the alias may be "foo/bar" or "/foo/bar" // there may be spaces as in "/foo/bar, /foo/nil" // these should probably be taken care of earlier on alias = alias.TrimStart('/'); var xpathBuilder = new StringBuilder(); if (rootNodeId > 0) { xpathBuilder.AppendFormat(XPathStrings.DescendantDocumentById, rootNodeId); } else { xpathBuilder.Append(XPathStringsDefinition.Root); } XPathVariable var = null; if (alias.Contains('\'') || alias.Contains('"')) { // use a var, as escaping gets ugly pretty quickly var = new XPathVariable("alias", alias); alias = "$alias"; } xpathBuilder.AppendFormat(XPathStrings.DescendantDocumentByAlias, alias); var xpath = xpathBuilder.ToString(); // note: it's OK if var is null, will be ignored return(cache.GetSingleByXPath(xpath, var)); }
public override void Initialize() { base.Initialize(); _httpContextFactory = new FakeHttpContextFactory("~/Home"); //ensure the StateHelper is using our custom context StateHelper.HttpContext = _httpContextFactory.HttpContext; UmbracoSettings.UseLegacyXmlSchema = false; _xml = new XmlDocument(); _xml.LoadXml(GetXml()); var cache = new PublishedContentCache { GetXmlDelegate = (context, preview) => _xml }; _umbracoContext = new UmbracoContext( _httpContextFactory.HttpContext, ApplicationContext.Current, new PublishedCaches(cache, new PublishedMediaCache())); _cache = _umbracoContext.ContentCache; }
private IEnumerable <IPublishedContent> TypedDocumentsByXPath(XPathExpression xpath, XPathVariable[] vars, ContextualPublishedContentCache cache) { var doc = cache.GetByXPath(xpath, vars); return(doc); }
private IPublishedContent TypedDocumentByXPath(string xpath, XPathVariable[] vars, ContextualPublishedContentCache cache) { var doc = cache.GetSingleByXPath(xpath, vars); return(doc); }
public PublishedContentQuery(ContextualPublishedContentCache contentCache, ContextualPublishedMediaCache mediaCache) { _contentCache = contentCache; _mediaCache = mediaCache; }
public void SetUp() { TestHelper.SetupLog4NetForTests(); //create the app context ApplicationContext.Current = new ApplicationContext(false); _httpContextFactory = new FakeHttpContextFactory("~/Home"); //ensure the StateHelper is using our custom context StateHelper.HttpContext = _httpContextFactory.HttpContext; UmbracoSettings.UseLegacyXmlSchema = false; var cache = new PublishedContentCache { GetXmlDelegate = (context, preview) => { var doc = new XmlDocument(); doc.LoadXml(GetXml()); return doc; } }; _umbracoContext = new UmbracoContext( _httpContextFactory.HttpContext, ApplicationContext.Current, new PublishedCaches(cache, new PublishedMediaCache())); _cache = _umbracoContext.ContentCache; }
/// <summary> /// Gets a dynamic content identified by its unique identifier. /// </summary> /// <param name="cache">The contextual cache.</param> /// <param name="contentId">The content unique identifier.</param> /// <returns>The dynamic content, or null.</returns> public static dynamic GetDynamicById(this ContextualPublishedContentCache cache, int contentId) { var content = cache.GetById(contentId); return(content == null ? DynamicNull.Null : new DynamicPublishedContent(content).AsDynamic()); }
private Page GetPageFromUrl(Uri url, IUserService userService, IContentService contentService, ContextualPublishedContentCache contentCache) { var result = new Page(); var absoluteUrl = new Uri(Request.RequestUri, url); var match = Regex.Match(absoluteUrl.Fragment, "^#/content/content/edit/([0-9]+)$"); if (match.Success) { var pageId = int.Parse(match.Groups[1].Value, CultureInfo.InvariantCulture); var page = contentService.GetById(pageId); if (page != null) { result.NodeId = page.Id; result.Name = page.Name; result.LastEditedDate = page.UpdateDate; result.LastEditedBy = GetUser(page.WriterId, userService); } } else { var page = contentCache.GetByRoute(absoluteUrl.AbsolutePath); if (page != null) { result.NodeId = page.Id; result.Url = new Uri(page.UrlAbsolute()); result.Name = page.Name; result.LastEditedDate = page.UpdateDate; result.LastEditedBy = GetUser(page.WriterId, userService); } } return(result); }
protected IPublishedContent FindContentByAlias(ContextualPublishedContentCache cache, int rootContentId, string alias) { Mandate.ParameterNotNullOrEmpty(alias, "alias"); StringBuilder xpathBuilder = new StringBuilder(); bool hideTopLevelNodeFromPath = GlobalSettings.HideTopLevelNodeFromPath; // Build xPath if (rootContentId == 0) { if (hideTopLevelNodeFromPath) { xpathBuilder.Append(XPathStringsDefinition.RootDocuments); // first node is not in the url } else { xpathBuilder.Append(XPathStringsDefinition.Root); } } else { xpathBuilder.Append(XPathStringsDefinition.Root); xpathBuilder.AppendFormat(XPathStringsDefinition.DescendantDocumentById, rootContentId); // always "hide top level" when there's a domain } // the alias may be "foo/bar" or "/foo/bar" // there may be spaces as in "/foo/bar, /foo/nil" // these should probably be taken care of earlier on alias = alias.RemoveLeadingAndTrailingSlashAndBackslash(); // .TrimStart('/'); string[] urlNames = alias.Split(SlashChar, StringSplitOptions.RemoveEmptyEntries); // We don't care about the level anymore because we do it by child anyway string urlName; for (int i = 0; i < urlNames.Length; i++) { urlName = urlNames[i].RemoveLeadingAndTrailingSlashAndBackslash(); // If the top level nodes are hidden the level is +1 /*if (GlobalSettings.HideTopLevelNodeFromPath) * { * // First I thought this is problematic... * // because we do not know if the backend user has overridden the urls e.g. * // normal: /test1/test2 means that "/" is the first one (because of hide top level node from path) * // overridden /test/test1/test2 so "/" is NOT the first one ("/" is overridden to "test") * // but that's ok because we hide the textboxes in the root if it's HideTopLevelNodeFromPath * // because then it makes no sense he overrides the url if it's "/" * * if (level == 1) * { * xPathBuilder.Append("/"); // Needs to be descendants because we start at level 2 * } * * level++; * }*/ xpathBuilder.AppendFormat(XPathStringsDefinition.ChildDocumentByUrlName, Core.Constants.Conventions.Content.UrlAlias, urlName); } //LogHelper.Info<ContentFinderByUrlAlias>("xPath: " + xpathBuilder.ToString()); // xPath is like: /root//* [@isDoc and ((@urlName = 'frontpage' or langProperty = 'frontpage') and @level = 1)]/* [@isDoc and ((@urlName = 'textpage' or langProperty = 'textpage') and @level = 2)] ... return(cache.GetSingleByXPath(xpathBuilder.ToString() /*, aliasVariable*/)); }
public override void Initialize() { base.Initialize(); _httpContextFactory = new FakeHttpContextFactory("~/Home"); //ensure the StateHelper is using our custom context StateHelper.HttpContext = _httpContextFactory.HttpContext; var settings = SettingsForTests.GetMockSettings(); var contentMock = Mock.Get(settings.Content); contentMock.Setup(x => x.UseLegacyXmlSchema).Returns(false); SettingsForTests.ConfigureSettings(settings); _xml = new XmlDocument(); _xml.LoadXml(GetXml()); var cache = new PublishedContentCache { GetXmlDelegate = (context, preview) => _xml }; _umbracoContext = new UmbracoContext( _httpContextFactory.HttpContext, ApplicationContext.Current, new PublishedCaches(cache, new PublishedMediaCache()), new WebSecurity(_httpContextFactory.HttpContext, ApplicationContext.Current)); _cache = _umbracoContext.ContentCache; }
public PublishedContentStore(ContextualPublishedContentCache contentCache) { _contentCache = contentCache; }
/// <summary> /// Gets a dynamic content resulting from an XPath query. /// </summary> /// <param name="cache">The contextual cache.</param> /// <param name="xpath">The XPath query.</param> /// <param name="vars">Optional XPath variables</param> /// <returns>The dynamic content, or null.</returns> public static dynamic GetDynamicSingleByXPath(this ContextualPublishedContentCache cache, XPathExpression xpath, params XPathVariable[] vars) { var content = cache.GetSingleByXPath(xpath, vars); return(content == null ? DynamicNull.Null : new DynamicPublishedContent(content).AsDynamic()); }
private IPublishedContent TypedDocumentByXPath(string xpath, XPathVariable[] vars, ContextualPublishedContentCache cache) { var doc = cache.GetSingleByXPath(xpath, vars); return doc; }
public RedirectPublishedContentFinder(ContextualPublishedContentCache publishedCache) { this.publishedCache = publishedCache; }
/// <summary> /// Gets dynamic contents at root. /// </summary> /// <param name="cache">The contextual cache.</param> /// <returns>The dynamic contents.</returns> public static dynamic GetDynamicAtRoot(this ContextualPublishedContentCache cache) { var content = cache.GetAtRoot(); return(new DynamicPublishedContentList(content.Select(c => new DynamicPublishedContent(c)))); }
/// <summary> /// Gets dynamic contents resulting from an XPath query. /// </summary> /// <param name="cache">The contextual cache.</param> /// <param name="xpath">The XPath query.</param> /// <param name="vars">Optional XPath variables</param> /// <returns>The dynamic contents.</returns> public static dynamic GetDynamicByXPath(this ContextualPublishedContentCache cache, XPathExpression xpath, params XPathVariable[] vars) { var content = cache.GetByXPath(xpath, vars); return(new DynamicPublishedContentList(content.Select(c => new DynamicPublishedContent(c)))); }
private IEnumerable<IPublishedContent> TypedDocumentsByXPath(XPathExpression xpath, XPathVariable[] vars, ContextualPublishedContentCache cache) { var doc = cache.GetByXPath(xpath, vars); return doc; }