/// <summary>
/// Tries to find and assign an Umbraco document to a <c>PublishedContentRequest</c>.
/// </summary>
/// <param name="pcr">The <c>PublishedContentRequest</c>.</param>
/// <returns>A value indicating whether an Umbraco document was found and assigned.</returns>
public bool TrySetDocument(PublishedContentRequest pcr)
{
LogHelper.Debug<LookupByLegacy404>("Looking for a page to handle 404.");
// TODO - replace the whole logic and stop calling into library!
var error404 = global::umbraco.library.GetCurrentNotFoundPageId();
var id = int.Parse(error404);
IPublishedContent content = null;
if (id > 0)
{
LogHelper.Debug<LookupByLegacy404>("Got id={0}.", () => id);
content = pcr.RoutingContext.PublishedContentStore.GetDocumentById(
pcr.RoutingContext.UmbracoContext,
id);
if (content == null)
LogHelper.Debug<LookupByLegacy404>("Could not find content with that id.");
else
LogHelper.Debug<LookupByLegacy404>("Found corresponding content.");
}
else
{
LogHelper.Debug<LookupByLegacy404>("Got nothing.");
}
pcr.PublishedContent = content;
pcr.Is404 = true;
return content != null;
}
public PublishedContentRequestBuilder(PublishedContentRequest publishedContentRequest)
{
if (publishedContentRequest == null) throw new ArgumentNullException("publishedContentRequest");
_publishedContentRequest = publishedContentRequest;
_umbracoContext = publishedContentRequest.RoutingContext.UmbracoContext;
_routingContext = publishedContentRequest.RoutingContext;
}
[TestCase("http://domain1.com/en/bar/nil", "en-US", 100111)] // ok, alias includes "en/"
public void Lookup_By_Url_Alias_And_Domain(string inputUrl, string expectedCulture, int expectedNode)
{
SetDomains1();
var routingContext = GetRoutingContext(inputUrl);
var url = routingContext.UmbracoContext.CleanedUmbracoUrl; //very important to use the cleaned up umbraco url
var pcr = new PublishedContentRequest(url, routingContext);
// must lookup domain
pcr.Engine.FindDomain();
if (expectedNode > 0)
Assert.AreEqual(expectedCulture, pcr.Culture.Name);
var finder = new ContentFinderByUrlAlias();
var result = finder.TryFindContent(pcr);
if (expectedNode > 0)
{
Assert.IsTrue(result);
Assert.AreEqual(pcr.PublishedContent.Id, expectedNode);
}
else
{
Assert.IsFalse(result);
}
}
/// <summary>
/// Tries to find and assign an Umbraco document to a <c>PublishedContentRequest</c>.
/// </summary>
/// <param name="docRequest">The <c>PublishedContentRequest</c>.</param>
/// <returns>A value indicating whether an Umbraco document was found and assigned.</returns>
public bool TryFindContent(PublishedContentRequest docRequest)
{
IPublishedContent node = null;
var path = docRequest.Uri.GetAbsolutePathDecoded();
var nodeId = -1;
if (path != "/") // no id if "/"
{
var noSlashPath = path.Substring(1);
if (!Int32.TryParse(noSlashPath, out nodeId))
nodeId = -1;
if (nodeId > 0)
{
LogHelper.Debug<ContentFinderByIdPath>("Id={0}", () => nodeId);
node = docRequest.RoutingContext.UmbracoContext.ContentCache.GetById(nodeId);
if (node != null)
{
docRequest.PublishedContent = node;
LogHelper.Debug<ContentFinderByIdPath>("Found node with id={0}", () => docRequest.PublishedContent.Id);
}
else
{
nodeId = -1; // trigger message below
}
}
}
if (nodeId == -1)
LogHelper.Debug<ContentFinderByIdPath>("Not a node id");
return node != null;
}
/// <summary>
/// For each request, this function checks to see if its a virtual Blog URL targeted to
/// Authors, Categories, Tags & RSS and routes accordingly
/// </summary>
/// <param name="contentRequest"></param>
/// <returns>True for a virtual URL or false for an exsting CMS Page</returns>
public bool TryFindContent(PublishedContentRequest contentRequest)
{
string fullUri = contentRequest.Uri.AbsolutePath;
Regex reg = new Regex("author|category|tag|rss");
if (reg.IsMatch(fullUri)) { //Simple regex match to see if it's a possible url to redirect. If not, lets not worry about the overhead and just return false
if (uQuery.GetNodesByType("BlogEntry").Where(r => r.Url.StartsWith(fullUri, StringComparison.InvariantCultureIgnoreCase)).Count() > 0) {
//We've found a match to a blog entry, so no need to redirect
return false;
}
//Get All Blog listings. This should only be a handful at Max
var allNodes = uQuery.GetNodesByType("BlogListing").OrderByDescending(n => n.Level);
foreach (var node in allNodes) {
string parentUri = node.Url;
bool isChild = fullUri.StartsWith(parentUri, StringComparison.InvariantCultureIgnoreCase);
if (isChild) {
//Its a virtual URL that is a child of a Blog listing.
contentRequest.PublishedContent = new UmbracoHelper(UmbracoContext.Current).TypedContent(node.Id);
return true;
}
}
}
return false;
}
protected override void OnPreInit(EventArgs e)
{
base.OnPreInit(e);
// handle the infamous umbDebugShowTrace, etc
Page.Trace.IsEnabled &= GlobalSettings.DebugMode && !String.IsNullOrWhiteSpace(Request["umbDebugShowTrace"]);
// get the document request and the page
_docRequest = UmbracoContext.Current.PublishedContentRequest;
_upage = _docRequest.UmbracoPage;
//we need to check this for backwards compatibility in case people still arent' using master pages
if (UmbracoSettings.UseAspNetMasterPages)
{
var args = new RequestInitEventArgs()
{
Page = _upage,
PageId = _upage.PageID,
Context = Context
};
FireBeforeRequestInit(args);
//if we are cancelling then return and don't proceed
if (args.Cancel) return;
this.MasterPageFile = template.GetMasterPageName(_upage.Template);
// reset the friendly path so it's used by forms, etc.
Context.RewritePath(UmbracoContext.Current.OriginalRequestUrl.PathAndQuery);
//fire the init finished event
FireAfterRequestInit(args);
}
}
/// <summary>
/// Tries to find an Umbraco document for a <c>PublishedContentRequest</c> and a route.
/// </summary>
/// <param name="docreq">The document request.</param>
/// <param name="route">The route.</param>
/// <returns>The document node, or null.</returns>
protected IPublishedContent LookupDocumentNode(PublishedContentRequest docreq, string route)
{
LogHelper.Debug<LookupByNiceUrl>("Test route \"{0}\"", () => route);
// first ask the cache for a node
// return '0' if in preview mode
var nodeId = !docreq.RoutingContext.UmbracoContext.InPreviewMode
? docreq.RoutingContext.UmbracoContext.RoutesCache.GetNodeId(route)
: 0;
// if a node was found, get it by id and ensure it exists
// else clear the cache
IPublishedContent node = null;
if (nodeId > 0)
{
node = docreq.RoutingContext.PublishedContentStore.GetDocumentById(
docreq.RoutingContext.UmbracoContext,
nodeId);
if (node != null)
{
docreq.PublishedContent = node;
LogHelper.Debug<LookupByNiceUrl>("Cache hit, id={0}", () => nodeId);
}
else
{
docreq.RoutingContext.UmbracoContext.RoutesCache.ClearNode(nodeId);
}
}
// if we still have no node, get it by route
if (node == null)
{
LogHelper.Debug<LookupByNiceUrl>("Cache miss, query");
node = docreq.RoutingContext.PublishedContentStore.GetDocumentByRoute(
docreq.RoutingContext.UmbracoContext,
route);
if (node != null)
{
docreq.PublishedContent = node;
LogHelper.Debug<LookupByNiceUrl>("Query matches, id={0}", () => docreq.DocumentId);
var iscanon = _doDomainLookup && !DomainHelper.ExistsDomainInPath(docreq.Domain, node.Path);
if (!iscanon)
LogHelper.Debug<LookupByNiceUrl>("Non canonical url");
// do not store if previewing or if non-canonical
if (!docreq.RoutingContext.UmbracoContext.InPreviewMode && iscanon)
docreq.RoutingContext.UmbracoContext.RoutesCache.Store(docreq.DocumentId, route);
}
else
{
LogHelper.Debug<LookupByNiceUrl>("Query does not match");
}
}
return node;
}
/// <summary>
/// Tries to find and assign an Umbraco document to a <c>PublishedContentRequest</c>.
/// </summary>
/// <param name="docRequest">The <c>PublishedContentRequest</c>.</param>
/// <returns>A value indicating whether an Umbraco document was found and assigned.</returns>
public virtual bool TrySetDocument(PublishedContentRequest docRequest)
{
string route;
if (docRequest.HasDomain)
route = docRequest.Domain.RootNodeId.ToString() + DomainHelper.PathRelativeToDomain(docRequest.DomainUri, docRequest.Uri.GetAbsolutePathDecoded());
else
route = docRequest.Uri.GetAbsolutePathDecoded();
var node = LookupDocumentNode(docRequest, route);
return node != null;
}
public override bool TryFindContent(PublishedContentRequest contentRequest)
{
// eg / or /path/to/whatever
var url = contentRequest.Uri.GetAbsolutePathDecoded();
var mdRoot = "/" + MarkdownLogic.BaseUrl;
if (url.StartsWith("/projects/umbraco-pro/contour/documentation"))
mdRoot = "/projects";
// ensure it's a md url
if (url.StartsWith(mdRoot) == false)
return false; // not for us
// find the root content
var node = FindContent(contentRequest, mdRoot);
if (node == null)
return false;
// kill those old urls
foreach (var s in new []{ "master", "v480" })
if (url.StartsWith(mdRoot + "/" + s))
{
url = url.Replace(mdRoot + "/" + s, mdRoot);
contentRequest.SetRedirectPermanent(url);
return true;
}
// find the md file
var mdFilepath = FindMarkdownFile(url);
if (mdFilepath == null)
{
// clear the published content (that was set by FindContent) to cause a 404, and in
// both case return 'true' because there's no point other finders try to handle the request
contentRequest.PublishedContent = null;
return true;
}
// set the context vars
var httpContext = contentRequest.RoutingContext.UmbracoContext.HttpContext;
httpContext.Items[MarkdownLogic.MarkdownPathKey] = mdFilepath;
httpContext.Items["topicTitle"] = string.Join(" - ", httpContext.Request.RawUrl
.Split(new[] { '/' }, StringSplitOptions.RemoveEmptyEntries)
.Skip(1)
.Reverse());
// override the template
const string altTemplate = "DocumentationSubpage";
var templateIsSet = contentRequest.TrySetTemplate(altTemplate);
//httpContext.Trace.Write("Markdown Files Handler",
// string.Format("Template changed to: '{0}' is {1}", altTemplate, templateIsSet));
// be happy
return true;
}
public void Lookup_By_Url_Alias(string urlAsString, int nodeMatch)
{
var routingContext = GetRoutingContext(urlAsString);
var url = routingContext.UmbracoContext.CleanedUmbracoUrl; //very important to use the cleaned up umbraco url
var docRequest = new PublishedContentRequest(url, routingContext);
var lookup = new LookupByAlias();
var result = lookup.TrySetDocument(docRequest);
Assert.IsTrue(result);
Assert.AreEqual(docRequest.DocumentId, nodeMatch);
}
public void Match_Document_By_Url(string urlString, int expectedId)
{
var routingContext = GetRoutingContext(urlString);
var url = routingContext.UmbracoContext.CleanedUmbracoUrl; //very important to use the cleaned up umbraco url
var docreq = new PublishedContentRequest(url, routingContext);
var lookup = new LookupByNiceUrl();
var result = lookup.TrySetDocument(docreq);
Assert.IsTrue(result);
Assert.AreEqual(expectedId, docreq.DocumentId);
}
private string GetTemplateAliasByContentAccept(PublishedContentRequest docRequest)
{
HttpContext context = HttpContext.Current;
string template = null;
if (ConfigurationManager.AppSettings.AllKeys.Contains("WG2K.Hypermedia.Templates." + context.Request.ContentType))
template = ConfigurationManager.AppSettings["WG2K.Hypermedia.Templates." + context.Request.ContentType];
if (template != null)
{
return template;
}
return "unknown";
}
/// <summary>
/// Initializes a new instance of the <see cref="PublishedContentRequestEngine"/> class with a content request.
/// </summary>
/// <param name="pcr">The content request.</param>
public PublishedContentRequestEngine(PublishedContentRequest pcr)
{
_pcr = pcr;
_routingContext = pcr.RoutingContext;
var umbracoContext = _routingContext.UmbracoContext;
if (_routingContext == null) throw new ArgumentException("pcr.RoutingContext is null.");
if (umbracoContext == null) throw new ArgumentException("pcr.RoutingContext.UmbracoContext is null.");
if (umbracoContext.RoutingContext != _routingContext) throw new ArgumentException("RoutingContext confusion.");
// no! not set yet.
//if (umbracoContext.PublishedContentRequest != _pcr) throw new ArgumentException("PublishedContentRequest confusion.");
}
//NOTE: This is the manual way we could assign culture this but I think there's more logic for edge case scenarios in Umbraco's Prepare method.
// I've just left this code here as an example
protected override void PreparePublishedContentRequest(PublishedContentRequest publishedContentRequest)
{
//if (_hostsAndIds.Any(x => x.Item2 == publishedContentRequest.PublishedContent.Parent.Id))
//{
// var hostAndId = _hostsAndIds.Single(x => x.Item2 == publishedContentRequest.PublishedContent.Parent.Id);
// var domain = Domain.GetDomain(hostAndId.Item1);
// publishedContentRequest.Culture = new CultureInfo(domain.Language.CultureAlias);
//}
base.PreparePublishedContentRequest(publishedContentRequest);
}
public void Lookup_By_Id(string urlAsString, int nodeMatch)
{
var routingContext = GetRoutingContext(urlAsString);
var url = routingContext.UmbracoContext.CleanedUmbracoUrl; //very important to use the cleaned up umbraco url
var docRequest = new PublishedContentRequest(url, routingContext);
var lookup = new ContentFinderByIdPath();
var result = lookup.TryFindContent(docRequest);
Assert.IsTrue(result);
Assert.AreEqual(docRequest.PublishedContent.Id, nodeMatch);
}
public void Match_Document_By_Url(string urlString, int expectedId)
{
var routingContext = GetRoutingContext(urlString);
var url = routingContext.UmbracoContext.CleanedUmbracoUrl; //very important to use the cleaned up umbraco url
var docreq = new PublishedContentRequest(url, routingContext);
var lookup = new ContentFinderByNiceUrl();
SettingsForTests.HideTopLevelNodeFromPath = false;
var result = lookup.TryFindContent(docreq);
Assert.IsTrue(result);
Assert.AreEqual(expectedId, docreq.PublishedContent.Id);
}
public bool TryFindContent(PublishedContentRequest request)
{
//Get the requested URL path + query
var path = request.Uri.PathAndQuery.ToLower();
//Check the table
var matchedRedirect = RedirectRepository.FindRedirect(path);
if (matchedRedirect == null) return false;
//Found one, set the 301 redirect on the request and return
request.SetRedirectPermanent(matchedRedirect.NewUrl);
return true;
}
public async Task<bool> TryFindContentAsync(PublishedContentRequest pcr)
{
var path = (string)pcr.RouteData.Values["_umbracoRoute"];
var content = await _contentCache.GetByRouteAsync(false, path);
if (content != null)
{
pcr.PublishedContent = content;
return true;
}
return false;
}
/// <summary>
/// The prepare slug.
/// </summary>
/// <param name="contentRequest">
/// The content request.
/// </param>
/// <returns>
/// The <see cref="string"/>.
/// </returns>
private static string PrepareSlug(PublishedContentRequest contentRequest)
{
var slug = contentRequest.Uri.AbsolutePath.EnsureNotStartsOrEndsWith('/');
// Check if there were any overrides to the slug in the merchello.config
var prefix = MerchelloConfiguration.Current.GetProductSlugCulturePrefix(contentRequest.Culture.Name);
if (prefix.IsNullOrWhiteSpace()) return slug;
// enforce the prefix is present in the slug
return !slug.StartsWith(prefix) ?
string.Empty :
slug.Replace(prefix, string.Empty).EnsureNotStartsOrEndsWith('/');
}
public void Initialize(PublishedContentRequest pcr)
{
if (Initialized) return;
PublishedContentRequest = pcr;
////TODO: This name/etc. is temporary from old testing
//AltTemplate = _httpContextAccessor.HttpContext.Request.Query["altTemplate"];
//if (string.IsNullOrEmpty(AltTemplate))
//{
// AltTemplate = "Umbraco";
//}
Initialized = true;
}
/// <summary>
/// Tries to find a <see cref="IProductContent"/> by it's unique slug.
/// </summary>
/// <param name="contentRequest">
/// The content request.
/// </param>
/// <returns>
/// A value indicating whether or not the product was found by slug.
/// </returns>
public bool TryFindContent(PublishedContentRequest contentRequest)
{
if (contentRequest.Uri.AbsolutePath == "/") return false;
var slug = PrepareSlug(contentRequest);
// this can happen if there is a prefix configured in the merchello.config which does not exist in the Uri
if (slug.IsNullOrWhiteSpace()) return false;
// This may have a db fallback so we want this content finder to happen after Umbraco's content finders.
var content = Merchello.TypedProductContentBySlug(slug);
if (content == null) return false;
contentRequest.PublishedContent = content;
return true;
}
[TestCase("/some/other/page.aspx?umbPageId=1046", 1046)] //TODO: Should this match??
public void Lookup_By_Page_Id(string urlAsString, int nodeMatch)
{
var routingContext = GetRoutingContext(urlAsString);
var url = routingContext.UmbracoContext.CleanedUmbracoUrl; //very important to use the cleaned up umbraco url
var docRequest = new PublishedContentRequest(url, routingContext);
var lookup = new LookupByPageIdQuery();
//we need to manually stub the return output of HttpContext.Request["umbPageId"]
routingContext.UmbracoContext.HttpContext.Request.Stub(x => x["umbPageID"])
.Return(routingContext.UmbracoContext.HttpContext.Request.QueryString["umbPageID"]);
var result = lookup.TrySetDocument(docRequest);
Assert.IsTrue(result);
Assert.AreEqual(docRequest.DocumentId, nodeMatch);
}
public void Match_Document_By_Url_With_Template(string urlAsString)
{
var template = Template.MakeNew("test", new User(0));
var altTemplate = Template.MakeNew("blah", new User(0));
var routingContext = GetRoutingContext(urlAsString, template);
var url = routingContext.UmbracoContext.CleanedUmbracoUrl; //very important to use the cleaned up umbraco url
var docRequest = new PublishedContentRequest(url, routingContext);
var lookup = new LookupByNiceUrlAndTemplate();
var result = lookup.TrySetDocument(docRequest);
Assert.IsTrue(result);
Assert.IsNotNull(docRequest.PublishedContent);
Assert.IsNotNull(docRequest.Template);
Assert.AreEqual("blah".ToUpperInvariant(), docRequest.Template.Alias.ToUpperInvariant());
}
public async void RouteUmbracoContentAsync_Umbraco_Context_Initialized()
{
var router = new UmbracoRouter(Mock.Of<IRouter>());
var httpCtxAccessor = new Mock<IHttpContextAccessor>();
var httpContext = new Mock<HttpContext>();
httpContext.Setup(context => context.Request).Returns(Mock.Of<HttpRequest>());
httpCtxAccessor.Setup(accessor => accessor.HttpContext).Returns(httpContext.Object);
var umbCtx = new UmbracoContext(httpCtxAccessor.Object);
var urlProvider = new UrlProvider(umbCtx, Enumerable.Empty<IUrlProvider>());
var routingCtx = new RoutingContext(Enumerable.Empty<IContentFinder>(), Mock.Of<ILastChanceContentFinder>(), urlProvider);
var pcr = new PublishedContentRequest(routingCtx, Mock.Of<ITemplateService>(), Mock.Of<ILoggerFactory>(), httpCtxAccessor.Object);
var result = await router.RouteUmbracoContentAsync(umbCtx, pcr, new RouteData());
Assert.Equal(true, umbCtx.Initialized);
Assert.Equal(false, result);
}
internal async Task<bool> RouteUmbracoContentAsync(UmbracoContext umbCtx, PublishedContentRequest pcr, RouteData routeData)
{
//Initialize the context, this will be called a few times but the initialize logic
// only executes once. There might be a nicer way to do this but the RouteContext and
// other request scoped instances are not available yet.
umbCtx.Initialize(pcr);
//Prepare the request if it hasn't already been done
if (pcr.IsPrepared == false)
{
if (await pcr.PrepareAsync(routeData))
{
if (umbCtx.HasContent == false) return false;
}
}
return umbCtx.HasContent;
}
/// <summary>
/// Tries to find an Umbraco document for a <c>PublishedContentRequest</c> and a route.
/// </summary>
/// <param name="docreq">The document request.</param>
/// <param name="route">The route.</param>
/// <returns>The document node, or null.</returns>
protected IPublishedContent FindContent(PublishedContentRequest docreq, string route)
{
LogHelper.Debug<ContentFinderByNiceUrl>("Test route \"{0}\"", () => route);
var node = docreq.RoutingContext.UmbracoContext.ContentCache.GetByRoute(route);
if (node != null)
{
docreq.PublishedContent = node;
LogHelper.Debug<ContentFinderByNiceUrl>("Got content, id={0}", () => node.Id);
}
else
{
LogHelper.Debug<ContentFinderByNiceUrl>("No match.");
}
return node;
}
public bool TryFindContent(PublishedContentRequest contentRequest)
{
if (!contentRequest.HasDomain) return false;
var contentCache = contentRequest.RoutingContext.UmbracoContext.ContentCache;
var domainRoot = contentCache.GetById(contentRequest.Domain.RootNodeId);
//var firstSegment = contentRequest.Uri.AbsolutePath.Split(new[] { '/' },
// StringSplitOptions.RemoveEmptyEntries).First();
//var root = domainRoot.Children.FirstOrDefault(x => x.UrlName == firstSegment);
// root = root ?? domainRoot;
var page = domainRoot.Descendants().FirstOrDefault(x => x.Name == "404");
if (page == null) return false;
contentRequest.PublishedContent = page;
var wcd = umbraco.cms.businesslogic.web.Domain.GetDomainsById(domainRoot.Id, true).SingleOrDefault(x => x.IsWildcard);
if (wcd != null)
contentRequest.Culture = new CultureInfo(wcd.Language.CultureAlias);
return true;
}
public void DoNotPolluteCache()
{
SettingsForTests.UseDirectoryUrls = true;
SettingsForTests.HideTopLevelNodeFromPath = false; // ignored w/domains
var requestMock = Mock.Get(UmbracoSettings.RequestHandler);
requestMock.Setup(x => x.UseDomainPrefixes).Returns(true);
InitializeLanguagesAndDomains();
SetDomains1();
RoutingContext routingContext;
string url = "http://domain1.com/1001-1/1001-1-1";
// get the nice url for 100111
routingContext = GetRoutingContext(url);
Assert.AreEqual("http://domain2.com/1001-1-1/", routingContext.UrlProvider.GetUrl(100111, true));
// check that the proper route has been cached
var cache = routingContext.UmbracoContext.ContentCache.InnerCache as PublishedContentCache;
if (cache == null) throw new Exception("Unsupported IPublishedContentCache, only the Xml one is supported.");
var cachedRoutes = cache.RoutesCache.GetCachedRoutes();
Assert.AreEqual("10011/1001-1-1", cachedRoutes[100111]);
// route a rogue url
url = "http://domain1.com/1001-1/1001-1-1";
var uri = routingContext.UmbracoContext.CleanedUmbracoUrl; //very important to use the cleaned up umbraco url
var pcr = new PublishedContentRequest(uri, routingContext);
pcr.Engine.FindDomain();
Assert.IsTrue(pcr.HasDomain);
// check that it's been routed
var lookup = new ContentFinderByNiceUrl();
var result = lookup.TryFindContent(pcr);
Assert.IsTrue(result);
Assert.AreEqual(100111, pcr.PublishedContent.Id);
// has the cache been polluted?
cachedRoutes = cache.RoutesCache.GetCachedRoutes();
Assert.AreEqual("10011/1001-1-1", cachedRoutes[100111]); // no
//Assert.AreEqual("1001/1001-1/1001-1-1", cachedRoutes[100111]); // yes
// what's the nice url now?
Assert.AreEqual("http://domain2.com/1001-1-1/", routingContext.UrlProvider.GetUrl(100111)); // good
//Assert.AreEqual("http://domain1.com/1001-1/1001-1-1", routingContext.NiceUrlProvider.GetNiceUrl(100111, true)); // bad
}
public void Match_Document_By_Url_With_Template(string urlAsString)
{
var template = CreateTemplate("test");
var altTemplate = CreateTemplate("blah");
var routingContext = GetRoutingContext(urlAsString, template);
var url = routingContext.UmbracoContext.CleanedUmbracoUrl; //very important to use the cleaned up umbraco url
var docRequest = new PublishedContentRequest(url, routingContext);
var lookup = new ContentFinderByNiceUrlAndTemplate();
SettingsForTests.HideTopLevelNodeFromPath = false;
var result = lookup.TryFindContent(docRequest);
Assert.IsTrue(result);
Assert.IsNotNull(docRequest.PublishedContent);
Assert.IsNotNull(docRequest.TemplateAlias);
Assert.AreEqual("blah".ToUpperInvariant(), docRequest.TemplateAlias.ToUpperInvariant());
}
private static bool TryRedirect(PublishedContentRequest contentRequest, bool includeQuery)
{
bool redirect = false;
string path = string.Format("{0}{1}{2}", contentRequest.Uri.Authority
, contentRequest.Uri.AbsolutePath
, includeQuery ? contentRequest.Uri.Query : String.Empty
);
RedirectInfo redirectInfo;
if (RedirectFromTo.TryGetValue(path, out redirectInfo) && !string.IsNullOrWhiteSpace(redirectInfo.To))
{
contentRequest.SetRedirect(redirectInfo.To, redirectInfo.StatusCode);
redirect = true;
}
return redirect;
}
// notes
//
// at the moment we load the legacy INotFoundHandler
// excluding those that have been replaced by proper finders,
// and run them.
/// <summary>
/// Tries to find and assign an Umbraco document to a <c>PublishedContentRequest</c>.
/// </summary>
/// <param name="docRequest">The <c>PublishedContentRequest</c>.</param>
/// <returns>A value indicating whether an Umbraco document was found and assigned.</returns>
public bool TryFindContent(PublishedContentRequest docRequest)
{
HandlePageNotFound(docRequest);
return(docRequest.HasPublishedContent);
}
// notes
//
// at the moment we load the legacy INotFoundHandler
// excluding those that have been replaced by proper finders,
// and run them.
/// <summary>
/// Tries to find and assign an Umbraco document to a <c>PublishedContentRequest</c>.
/// </summary>
/// <param name="docRequest">The <c>PublishedContentRequest</c>.</param>
/// <returns>A value indicating whether an Umbraco document was found and assigned.</returns>
public bool TrySetDocument(PublishedContentRequest docRequest)
{
HandlePageNotFound(docRequest);
return(docRequest.HasNode);
}
//FIXME: this is temporary and should be obsoleted
void HandlePageNotFound(PublishedContentRequest docRequest)
{
var url = NotFoundHandlerHelper.GetLegacyUrlForNotFoundHandlers();
LogHelper.Debug <LookupByNotFoundHandlers>("Running for legacy url='{0}'.", () => url);
foreach (var handler in GetNotFoundHandlers())
{
IPublishedContentLookup lookup = null;
LogHelper.Debug <LookupByNotFoundHandlers>("Handler '{0}'.", () => handler.GetType().FullName);
// replace with our own implementation
if (handler is global::umbraco.SearchForAlias)
{
lookup = new LookupByAlias();
}
else if (handler is global::umbraco.SearchForProfile)
{
lookup = new LookupByProfile();
}
else if (handler is global::umbraco.SearchForTemplate)
{
lookup = new LookupByNiceUrlAndTemplate();
}
else if (handler is global::umbraco.handle404)
{
lookup = new LookupByLegacy404();
}
if (lookup != null)
{
LogHelper.Debug <LookupByNotFoundHandlers>("Replace handler '{0}' by new lookup '{1}'.", () => handler.GetType().FullName, () => lookup.GetType().FullName);
if (lookup.TrySetDocument(docRequest))
{
// do NOT set docRequest.PublishedContent again here as
// it would clear any template that the finder might have set
LogHelper.Debug <LookupByNotFoundHandlers>("Lookup '{0}' found node with id={1}.", () => lookup.GetType().FullName, () => docRequest.PublishedContent.Id);
if (docRequest.Is404)
{
LogHelper.Debug <LookupByNotFoundHandlers>("Lookup '{0}' set status to 404.", () => lookup.GetType().FullName);
}
// if we found a document, break, don't look at more handler -- we're done
break;
}
// if we did not find a document, continue, look at other handlers
continue;
}
// else it's a legacy handler, run
if (handler.Execute(url) && handler.redirectID > 0)
{
docRequest.PublishedContent = docRequest.RoutingContext.PublishedContentStore.GetDocumentById(
docRequest.RoutingContext.UmbracoContext,
handler.redirectID);
if (!docRequest.HasNode)
{
LogHelper.Debug <LookupByNotFoundHandlers>("Handler '{0}' found node with id={1} which is not valid.", () => handler.GetType().FullName, () => handler.redirectID);
break;
}
LogHelper.Debug <LookupByNotFoundHandlers>("Handler '{0}' found valid node with id={1}.", () => handler.GetType().FullName, () => handler.redirectID);
if (docRequest.RoutingContext.UmbracoContext.HttpContext.Response.StatusCode == 404)
{
LogHelper.Debug <LookupByNotFoundHandlers>("Handler '{0}' set status code to 404.", () => handler.GetType().FullName);
docRequest.Is404 = true;
}
//// check for caching
//if (handler.CacheUrl)
//{
// if (url.StartsWith("/"))
// url = "/" + url;
// var cacheKey = (currentDomain == null ? "" : currentDomain.Name) + url;
// var culture = currentDomain == null ? null : currentDomain.Language.CultureAlias;
// SetCache(cacheKey, new CacheEntry(handler.redirectID.ToString(), culture));
// HttpContext.Current.Trace.Write("NotFoundHandler",
// string.Format("Added to cache '{0}', {1}.", url, handler.redirectID));
//}
// if we found a document, break, don't look at more handler -- we're done
break;
}
// if we did not find a document, continue, look at other handlers
}
}
private static void HandlePageNotFound(PublishedContentRequest docRequest)
{
var url = NotFoundHandlerHelper.GetLegacyUrlForNotFoundHandlers();
LogHelper.Debug <ContentFinderByNotFoundHandlers>("Running for legacy url='{0}'.", () => url);
foreach (var handler in NotFoundHandlerHelper.GetNotFoundHandlers())
{
var handlerName = handler.GetType().FullName;
LogHelper.Debug <ContentFinderByNotFoundHandlers>("Handler '{0}'.", () => handlerName);
var finder = NotFoundHandlerHelper.SubsituteFinder(handler);
if (finder != null)
{
var finderName = finder.GetType().FullName;
LogHelper.Debug <ContentFinderByNotFoundHandlers>("Replace handler '{0}' by new finder '{1}'.", () => handlerName, () => finderName);
// can't find a document => continue with other handlers
if (finder.TryFindContent(docRequest) == false)
{
continue;
}
// found a document => break, don't run other handlers, we're done
// in theory an IContentFinder can return true yet set no document
// but none of the substitued finders (see SubstituteFinder) do it.
// do NOT set docRequest.PublishedContent again here
// as it would clear any template that the finder might have set
LogHelper.Debug <ContentFinderByNotFoundHandlers>("Finder '{0}' found node with id={1}.", () => finderName, () => docRequest.PublishedContent.Id);
if (docRequest.Is404)
{
LogHelper.Debug <ContentFinderByNotFoundHandlers>("Finder '{0}' set status to 404.", () => finderName);
}
LogHelper.Debug <ContentFinderByNotFoundHandlers>("Handler '{0}' found valid node with id={1}.", () => handlerName, () => docRequest.PublishedContent.Id);
break;
}
// else it's a legacy handler: run
// can't find a document => continue with other handlers
if (handler.Execute(url) == false || handler.redirectID <= 0)
{
continue;
}
// found a document ID => ensure it's a valid document
var redirectId = handler.redirectID;
docRequest.PublishedContent = docRequest.RoutingContext.UmbracoContext.ContentCache.GetById(redirectId);
if (docRequest.HasPublishedContent == false)
{
// the handler said it could handle the url, and returned a content ID
// yet that content ID is invalid... should we run the other handlers?
// I don't think so, not here, let the "last chance" finder take care.
// so, break.
LogHelper.Debug <ContentFinderByNotFoundHandlers>("Handler '{0}' found node with id={1} which is not valid.", () => handlerName, () => redirectId);
break;
}
// found a valid document => break, don't run other handlers, we're done
LogHelper.Debug <ContentFinderByNotFoundHandlers>("Handler '{0}' found valid node with id={1}.", () => handlerName, () => redirectId);
if (docRequest.RoutingContext.UmbracoContext.HttpContext.Response.StatusCode == 404)
{
LogHelper.Debug <ContentFinderByNotFoundHandlers>("Handler '{0}' set status code to 404.", () => handlerName);
docRequest.Is404 = true;
}
break;
}
}