/// <inheritdoc /> /// <exception cref="System.ArgumentNullException"> /// The <paramref name="browser" /> parameter is <c>null</c>. /// </exception> /// <exception cref="System.ArgumentNullException"> /// The <paramref name="response" /> parameter is <c>null</c>. /// </exception> /// <exception cref="System.ArgumentNullException"> /// The <paramref name="result" /> parameter is <c>null</c>. /// </exception> public void Initialize(IBrowser browser, HttpResponseMessage response, HttpResult result) { if (browser == null) { throw new ArgumentNullException("browser"); } if (response == null) { throw new ArgumentNullException("response"); } if (result == null) { throw new ArgumentNullException("result"); } // Look at the content type header to determine the correct type of page to return var mediaType = DetermineMediaType(response); var contentType = browser.ContentTypeResolver.DeterminePageType(mediaType); if (contentType == PageContentType.Html) { _resolvedPage = new DynamicHtmlPage(); } else if (contentType == PageContentType.Binary) { _resolvedPage = new BinaryPageWrapper(); } else { _resolvedPage = new TextPageWrapper(); } ResolvedPage.Initialize(browser, response, result); }
/// <inheritdoc /> public bool IsOn(Uri location) { return(ResolvedPage.IsOn(location)); }
private static ResolvedPage ResolvePage( ref Dictionary <string, AgilityRouteCacheItem> routes, AgilityRouteCacheItem routeItem, string dynamicRoute, string languageCode, string websiteName, ref List <ResolvedPage> resolvedPages, string url) { AgilityPage page = BaseCache.GetPageFromID(routeItem.PageID, languageCode, websiteName, url); if (string.IsNullOrEmpty(dynamicRoute)) { //make sure we have the page, if not, then kick out if (page == null) { return(null); } if (!string.IsNullOrEmpty(page.DynamicPageContentViewReferenceName) || !string.IsNullOrEmpty(page.DynamicPageParentFieldName)) { //we have NO dynamic route, but the page is dynamic, kick out return(null); } //not a dynamic page (a static page nested under a dynamic one...) return(new ResolvedPage(page, null)); } else { //resolve the Dynamic Route if (string.IsNullOrEmpty(routeItem.ChildDynamicPagePath)) { //no dynamic page attached to this static page.. kick out return(null); } //get the route item for the child dynamic page if (!routes.TryGetValue(routeItem.ChildDynamicPagePath, out routeItem)) { return(null); } //get the dynamic page page = BaseCache.GetPageFromID(routeItem.PageID, languageCode, websiteName, url); if (page == null) { Agility.Web.Tracing.WebTrace.WriteWarningLine(string.Format("Routing: could not load page with id: {0} in language {1} websitename {2} url {3}", routeItem.PageID, languageCode, websiteName, url)); return(null); } if (string.IsNullOrEmpty(page.DynamicPageContentViewReferenceName) && string.IsNullOrEmpty(page.DynamicPageParentFieldName)) { //we have a dynamic route, but the page is not dynamic, kick out return(null); } string contentReferenceName = page.DynamicPageContentViewReferenceName; int parentContentID = -1; if (string.IsNullOrEmpty(contentReferenceName)) { if (!string.IsNullOrEmpty(page.DynamicPageParentFieldName)) { for (int i = resolvedPages.Count - 1; i >= 0; i--) { DynamicPageFormulaItem dpParent = resolvedPages[i].DynamicPageItem; if (dpParent == null) { continue; } //get the content reference name from the parent page... object fieldValueObj = dpParent.GetContentItemValue(page.DynamicPageParentFieldName); if (fieldValueObj != null) { contentReferenceName = fieldValueObj as string; break; } } } } else if (!string.IsNullOrEmpty(page.DynamicPageParentFieldName)) { //filter the dynamic page list by the parent field... for (int i = resolvedPages.Count - 1; i >= 0; i--) { DynamicPageFormulaItem dpParent = resolvedPages[i].DynamicPageItem; if (dpParent == null) { continue; } if (dpParent != null) { parentContentID = dpParent.ContentID; break; } } if (parentContentID < 1) { return(null); } } //if we didn't resolve a content view, kick out... if (string.IsNullOrEmpty(contentReferenceName)) { return(null); } //create/update the dynamic page index with this page id and dynamic page list reference name BaseCache.UpdateDynamicPageIndex(page.ID, contentReferenceName); //get the content first if we are in development or staging mode... if (AgilityContext.CurrentMode == Enum.Mode.Staging || Agility.Web.Configuration.Current.Settings.DevelopmentMode) { AgilityContentServer.AgilityContent content = BaseCache.GetContent(contentReferenceName, page.LanguageCode, AgilityContext.WebsiteName); } //get the dynamic page list dictionary for this page (this method also updates if neccessary)... DynamicPageFormulaItemIndex dpIndex = BaseCache.GetDynamicPageFormulaIndex(page.ID, contentReferenceName, page.LanguageCode, page, true); DynamicPageFormulaItem dpItem = null; if (dpIndex == null || !dpIndex.TryGetValue(dynamicRoute, out dpItem)) { //check if friendly-making the route would result in a match string friendly = DynamicPageFormulaItem.MakePathFriendly(dynamicRoute); if (friendly == dynamicRoute || !dpIndex.TryGetValue(friendly, out dpItem)) { //we didn't find the item, and making the given path friendly didn't work either. Kick out. return(null); } //there's an item, but only after fixing the path. redirect. string baseUrl = Data.GetSiteMapNode(page.ID).PagePath; string redirectUrl = baseUrl.LastIndexOf('/') > 0 ? baseUrl.Substring(0, baseUrl.LastIndexOf('/')) + friendly : friendly; if (url.ToLower().EndsWith(".aspx")) { redirectUrl += ".aspx"; } //add the current query string.. string query = AgilityContext.HttpContext.Request.QueryString.Value; if (!string.IsNullOrEmpty(query)) { redirectUrl += query; } //set the url to get this page, and the ActionResult or HttpModule will 301 redirect to it. ResolvedPage resolvedPage = new ResolvedPage(page, dpItem); resolvedPage.RedirectURL = redirectUrl; return(resolvedPage); } //check parent content if neccessary if (parentContentID > 0 && !string.IsNullOrEmpty(page.DynamicPageParentFieldName)) { object testParentContentIDObj = dpItem.GetContentItemValue(page.DynamicPageParentFieldName); if (testParentContentIDObj != null) { int testParentContentID = -1; string testParentContentIDStr = string.Format("{0}", testParentContentIDObj); if (int.TryParse(testParentContentIDStr, out testParentContentID)) { //if the value is an int, test for equality... if (parentContentID != testParentContentID) { return(null); } } else { //value is NOT an int, test for "in" '[id],' or ',[id],' or ',[id]' if (!testParentContentIDStr.StartsWith(string.Format("{0},", parentContentID)) && !testParentContentIDStr.EndsWith(string.Format(",{0}", parentContentID)) && !testParentContentIDStr.Contains(string.Format(",{0},", parentContentID))) { return(null); } } } } return(new ResolvedPage(page, dpItem)); } }
internal static List <ResolvedPage> ResolveRoutePath(string path, string languageCode) { if (string.IsNullOrEmpty(path)) { return(null); } path = path.ToLowerInvariant(); List <ResolvedPage> lstResolvedPages = new List <ResolvedPage>(); AgilityRouteCacheItem routeItem = null; string websiteName = AgilityContext.WebsiteName; Dictionary <string, AgilityRouteCacheItem> routes = AgilityRouteTable.GetRouteTable(languageCode, AgilityContext.CurrentChannel.ID); #region *** STATIC PAGE *** //STATIC PAGE if (routes.TryGetEncoded(path, out routeItem)) { var appRelativeCurrentExecutionFilePath = "/"; //try to resolve the entire path first... if that works, we can kick out right away... AgilityPage page = BaseCache.GetPageFromID(routeItem.PageID, languageCode, websiteName, appRelativeCurrentExecutionFilePath); if (page == null) { return(null); } if (!string.IsNullOrEmpty(page.DynamicPageContentViewReferenceName) || !string.IsNullOrEmpty(page.DynamicPageParentFieldName)) { //we are on a static page, but we don't have the dynamic part of the URL in place... s if (Agility.Web.HttpModules.AgilityHttpModule.CheckPreviewMode(AgilityContext.HttpContext)) { AgilityContext.IsResponseEnded = true; } else //if (AgilityContext.IsPreview || Configuration.Current.Settings.DevelopmentMode) { //add in the dynamic part of the URL if we are in preview mode... RedirectToDynamicPreviewUrl(routes, path, languageCode); } return(null); } lstResolvedPages.Add(new ResolvedPage(page)); return(lstResolvedPages); } #endregion //DYNAMIC PAGE //if we can't find the path, start peeling off parts of the path left to right and get the //static paths combined with the dynamic paths string[] pathParts = path.Split(new char[] { '/' }, StringSplitOptions.RemoveEmptyEntries); //if there are less than 2 parts to the path, it CAN'T be a dynamic path... if (pathParts.Length < 2) { return(null); } string staticRoute = ""; string dynamicRoute = string.Empty; AgilityRouteCacheItem testRouteItem = null; routeItem = null; ResolvedPage parentPage = null; //Assume we are a WEB SITE (not a virtual directory) string url = "/"; //loop the rest of the path... bool foundRoute = false; // signal that we found a route, we can return safely bool foundDynamicRoute = false; //signal that we found a dynamic route var pathIndex = -1; foreach (string pathPart in pathParts) { pathIndex++; foundRoute = false; // init to not found for every iteration string testStaticRoute = string.Format("{0}/{1}", staticRoute, pathPart); //check for a secondary static route (eg: /Static1/Dyn1/Dyn2/Static2 if (routes.TryGetValue(testStaticRoute, out testRouteItem)) { foundRoute = true; // static route means we found a route //found a static route, add it to the list of resolved pages... AgilityPage page = BaseCache.GetPageFromID(testRouteItem.PageID, languageCode, websiteName, null); if (page == null) { //assume a null page means a folder... lstResolvedPages.Add(new ResolvedPage(null)); staticRoute = testStaticRoute; routeItem = testRouteItem; continue; } //todo... ////check if this page is routing to a dynamic page redirect... (/path/dynamic-page/item-[contentid] //if (!string.IsNullOrEmpty(page.DynamicPageContentViewReferenceName) // || !string.IsNullOrEmpty(page.DynamicPageParentFieldName)) //{ // if (pathParts.Length == pathIndex + 1) // { // xxx // //check for item- in the last part of the path to see if this is a redirect... // } //} parentPage = new ResolvedPage(page); lstResolvedPages.Add(parentPage); routeItem = testRouteItem; staticRoute = testStaticRoute; } else { //did not find a static route, add this to the dynamic route... dynamicRoute = string.Format("{0}/{1}", dynamicRoute, pathPart); //if we have a dynamic Route left over, and the static page was set, then we have our first page candidate.. if (routeItem != null) { //derive a resolved page from routeItem and dynamic route... ResolvedPage resolvedPage = ResolvePage(ref routes, routeItem, dynamicRoute, languageCode, websiteName, ref lstResolvedPages, url); if (resolvedPage != null) { foundRoute = true; foundDynamicRoute = true; parentPage = resolvedPage; lstResolvedPages.Add(resolvedPage); parentPage = resolvedPage; dynamicRoute = string.Empty; //now the NEXT route item becomes the child of this dynamic page.. if (!string.IsNullOrEmpty(routeItem.ChildDynamicPagePath) && routes.TryGetValue(routeItem.ChildDynamicPagePath, out testRouteItem)) { staticRoute = routeItem.ChildDynamicPagePath; routeItem = testRouteItem; } } } } } //if we didn't manage to find a dynamic page in there, return null; if (foundRoute && foundDynamicRoute) { return(lstResolvedPages); } return(null); }