public static void UpdateDynamicPageFormFormulas(AgilityContent existingContent, AgilityContent deltaContent)
{
if (deltaContent == null || deltaContent.DataSet == null)
{
return;
}
Dictionary <string, List <int> > dpIndex = BaseCache.GetDynamicPageIndex();
List <int> lstPageIDs = null;
if (dpIndex.TryGetValue(deltaContent.ReferenceName.ToLowerInvariant(), out lstPageIDs))
{
foreach (int pageID in lstPageIDs)
{
AgilityPage page = BaseCache.GetPageFromID(pageID, deltaContent.LanguageCode, AgilityContext.WebsiteName, null);
if (page != null)
{
//update all of the DynamicPageIndexes that this content appears on...
BaseCache.UpdateDynamicPageFormulaIndex(page, existingContent, deltaContent, deltaContent.ReferenceName, existingContent == null);
}
}
}
}
public static void UpdateDynamicPageIndex(AgilityPage page)
{
if (!string.IsNullOrEmpty(page.DynamicPageContentViewReferenceName) ||
!string.IsNullOrEmpty(page.DynamicPageParentFieldName))
{
if (!string.IsNullOrEmpty(page.DynamicPageContentViewReferenceName.ToLowerInvariant()))
{
BaseCache.UpdateDynamicPageIndex(page.ID, page.DynamicPageContentViewReferenceName.ToLowerInvariant());
}
//update the Dynamic Page Formula Index that use this page...
BaseCache.ClearDynamicDynamicPageFormulaIndex(page);
}
}
private static AgilityPage GetPage(HttpContext context)
{
AgilityPage _page = context.Items["Agility.Web.AgilityContext.Page"] as AgilityPage;
if (_page == null)
{
string url = AgilityContext.HttpContext.Request.Path;
url = HttpUtility.UrlPathEncode(url);
_page = Agility.Web.Data.GetPage(url);
context.Items["Agility.Web.AgilityContext.Page"] = _page;
}
return(_page);
}
public async Task <HtmlString> InvokeAsync()
{
AgilityContext.HttpContext = HttpContext;
AgilityPage currentPage = AgilityContext.Page;
if (currentPage == null)
{
return(null);
}
StringBuilder sb = new StringBuilder(Environment.NewLine);
string scriptTopGlobal;
string scriptBottomGlobal;
string scriptBottomPage = null;
//output the id of any page a/b test experiments
var experiments = BaseCache.GetExperiments(AgilityContext.WebsiteName);
var experiment = experiments.GetForPage(currentPage.ID);
if (experiment != null)
{
if (experiment.Variants != null &&
experiment.Variants.Any(v => !string.IsNullOrWhiteSpace(v.URL)))
{
//PAGE REDIRECT EXPERIMENTS ONLY
AgilityContext.ExperimentKeys.Add(experiment.Key);
sb.AppendLine("<script type='text/javascript'>");
//get the winner
if (experiment.WinningVariant != null)
{
sb.AppendFormat("window.AgilityExperimentWinningVariant = {{ experiment: '{0}' variant: {1}, url: '{2}' }};",
experiment.Key,
experiment.WinningVariant.ID,
AgilityHelpers.ResolveUrl(experiment.WinningVariant.URL)
);
}
else
{
sb.Append("window.AgilityExperimentVariants = [");
foreach (var v in experiment.Variants)
{
sb.AppendFormat("{{ experiment: '{0}', variant: {1}, url: '{2}' }},",
experiment.Key,
v.ID,
AgilityHelpers.ResolveUrl(v.URL)
);
}
sb.AppendLine("];");
sb.AppendLine("</script>");
}
}
}
else if (currentPage.ServerPage.ExperimentIDs != null)
{
foreach (int exId in currentPage.ServerPage.ExperimentIDs)
{
experiment = experiments.GetExperiment(exId);
if (experiment != null)
{
AgilityContext.ExperimentKeys.Add(experiment.Key);
}
}
}
//add the Javascript tracking stuff
if (currentPage.IncludeInStatsTracking)
{
//global script
if (!string.IsNullOrEmpty(AgilityContext.Domain.StatsTrackingScript))
{
scriptTopGlobal = AgilityContext.Domain.StatsTrackingScript;
if (scriptTopGlobal.IndexOf(AgilityHelpers.GLOBAL_SCRIPT_SEPARATOR) != -1)
{
scriptBottomGlobal = scriptTopGlobal.Substring(scriptTopGlobal.IndexOf(AgilityHelpers.GLOBAL_SCRIPT_SEPARATOR) + AgilityHelpers.GLOBAL_SCRIPT_SEPARATOR.Length);
scriptTopGlobal = scriptTopGlobal.Substring(0, scriptTopGlobal.IndexOf(AgilityHelpers.GLOBAL_SCRIPT_SEPARATOR));
}
if (!string.IsNullOrEmpty(scriptTopGlobal))
{
sb.Append(scriptTopGlobal);
sb.Append(Environment.NewLine);
}
}
}
string scriptTopPage = null;
//custom script for this page
if (!string.IsNullOrEmpty(currentPage.CustomAnalyticsScript))
{
scriptTopPage = currentPage.CustomAnalyticsScript;
if (scriptTopPage.IndexOf(AgilityHelpers.GLOBAL_SCRIPT_SEPARATOR) != -1)
{
scriptBottomPage = scriptTopPage.Substring(scriptTopPage.IndexOf(AgilityHelpers.GLOBAL_SCRIPT_SEPARATOR) + AgilityHelpers.GLOBAL_SCRIPT_SEPARATOR.Length);
scriptTopPage = scriptTopPage.Substring(0, scriptTopPage.IndexOf(AgilityHelpers.GLOBAL_SCRIPT_SEPARATOR));
}
if (!string.IsNullOrEmpty(scriptTopPage))
{
sb.Append(scriptTopPage);
sb.Append(Environment.NewLine);
}
}
return(new HtmlString(sb.ToString()));
}
public override void ExecuteResult(ActionContext context)
{
try
{
EmptyResult empty = new EmptyResult();
//check if the request has been already served (set in route constraint)
object constraintCheck = context.HttpContext.Items["Agility.Web.RequestPreviouslyHandledInRouteConstraint"];
if (constraintCheck is bool && ((bool)constraintCheck))
{
empty.ExecuteResult(context);
return;
}
HttpRequest Request = context.HttpContext.Request;
HttpResponse Response = context.HttpContext.Response;
//initialize the offline processing...
//HACK: OFFLINE: this should be started in the Startup
//if (!OfflineProcessing.IsOfflineThreadRunning)
//{
// OfflineProcessing.StartOfflineThread();
//}
string url = UriHelper.GetEncodedUrl(Request);
string rawUrl = Request.GetEncodedPathAndQuery();
//check if this is Robots.txt and a publishwithagility.com domain (used for staging only)
if ((
Request.Host.Value.IndexOf(".publishwithagility.com", StringComparison.CurrentCultureIgnoreCase) != -1 ||
Request.Host.Value.IndexOf(".azurewebsites.net", StringComparison.CurrentCultureIgnoreCase) != -1) &&
string.Equals(rawUrl, "/robots.txt", StringComparison.CurrentCultureIgnoreCase))
{
Response.ContentType = "text/plain";
StringBuilder sb = new StringBuilder();
sb.AppendLine("User-agent: *");
sb.Append("Disallow: /");
var task = Response.WriteAsync(sb.ToString());
task.Wait();
empty.ExecuteResult(context);
AgilityCache.TurnOffCacheInProgress();
return;
}
//don't allow ANY urls to end with /
if (!Current.Settings.IgnoreTrailingSlash)
{
if (rawUrl != "/" && rawUrl.EndsWith("/"))
{
string newUrl = rawUrl.TrimEnd('/');
AgilityHttpModule.RedirectResponse(newUrl, 301);
AgilityCache.TurnOffCacheInProgress();
return;
}
}
if (AgilityContext.BuildAgilityContext())
{
empty.ExecuteResult(context);
AgilityCache.TurnOffCacheInProgress();
return;
}
//pre-process the request for any channel or redirections that we encounter...
string pagePath = AgilityPagePath;
if (!IgnorePrechecks)
{
if (AgilityHttpModule.HandleChannelsAndRedirects(ref pagePath, LanguageCode))
{
empty.ExecuteResult(context);
AgilityCache.TurnOffCacheInProgress();
return;
}
}
//use the first page in the sitemap if there is no page passed in...
if (string.IsNullOrEmpty(pagePath) || pagePath == "/" || pagePath == "~/")
{
pagePath = BaseCache.GetDefaultPagePath(AgilityContext.LanguageCode, AgilityContext.WebsiteName, string.Empty);
}
//check to see if the site should be in "preview mode"
if (AgilityHttpModule.CheckPreviewMode(context.HttpContext))
{
empty.ExecuteResult(context);
AgilityCache.TurnOffCacheInProgress();
return;
}
AgilityPage page = null;
if (!string.IsNullOrEmpty(pagePath))
{
//add the ~ if neccessary
if (!pagePath.StartsWith("~/"))
{
if (!pagePath.StartsWith("/"))
{
pagePath = string.Format("~/{0}", pagePath);
}
else
{
pagePath = string.Format("~{0}", pagePath);
}
}
page = Agility.Web.Data.GetPage(pagePath, LanguageCode);
//check if this page is a folder, kick out...
if (page != null &&
string.IsNullOrEmpty(page.TemplatePath) &&
page.TemplateID < 1 &&
string.IsNullOrEmpty(page.RedirectURL))
{
page = null;
}
}
if (AgilityContext.IsResponseEnded)
{
//check if we've ended the response...
empty.ExecuteResult(context);
AgilityCache.TurnOffCacheInProgress();
return;
}
if (page == null)
{
//possibly route the page if it is a page template...
string aspxPath = context.HttpContext.Request.PathBase;
int previewIndex = aspxPath.IndexOf("TemplatePreview/", StringComparison.CurrentCultureIgnoreCase);
if (previewIndex > -1)
{
aspxPath = aspxPath.Substring(previewIndex + "TemplatePreview/".Length);
aspxPath = string.Format("~/{0}", aspxPath);
if (!aspxPath.EndsWith(".aspx", StringComparison.CurrentCultureIgnoreCase))
{
//assume we wanted to render a .cshtml file
aspxPath = string.Format("{0}.cshtml", aspxPath);
}
//load the page def in Preview mode...
int pageDefinitionID = 0;
if (int.TryParse(Request.Query["agilityPageDefinitionID"], out pageDefinitionID) &&
pageDefinitionID > 0)
{
AgilityContext.IsTemplatePreview = true;
string pageTitle = string.Empty;
AgilityContentServer.AgilityPageDefinition _currentPageDefinition = BaseCache.GetPageDefinition(pageDefinitionID, AgilityContext.WebsiteName);
if (_currentPageDefinition != null)
{
AgilityContext.CurrentPageTemplateInPreview = _currentPageDefinition;
pageTitle = string.Format("Template Preview - {0}", _currentPageDefinition.Name);
ViewData.Model = new AgilityTemplateModel()
{
Page = new AgilityPage()
{
Title = pageTitle
}
};
ViewResult templateView = new ViewResult()
{
//TODO: handle template preview with inline code...
ViewName = _currentPageDefinition.TemplatePath,
ViewData = ViewData
};
return;
}
}
}
//
//404 - we can't load the page, so we have to throw a 404
//TODO: figure out how to return a 404
context.HttpContext.Response.StatusCode = 404;
return;
}
//if we get here and we don't have a page, throw a 404
if (page == null)
{
context.HttpContext.Response.StatusCode = 404;
return;
}
//set the dynamic page formula items from the last ones that were loaded...
AgilityContext.DynamicPageFormulaItem = AgilityContext.LastLoadedDynamicPageFormulaItem;
//check if this page is a redirect
if (!string.IsNullOrEmpty(page.RedirectURL))
{
//redirect to the link specified on the page
AgilityHttpModule.RedirectResponse(page.RedirectURL);
AgilityCache.TurnOffCacheInProgress();
return;
}
//set the current language and culture based on the language code...
AgilityHttpModule.SetLanguageAndCultureBasedOnPage(page);
//set the page in context (Context.items)
AgilityContext.Page = page;
//setup ouput caching
AgilityHttpModule.SetupOutputCaching(context.HttpContext.Request, context.HttpContext.Response, page);
//assemble the model data
ViewData.Model = new AgilityTemplateModel()
{
Page = page
};
ViewData["Title"] = page.Title;
string templatePath = string.Empty;
DataView dv = Data.GetContentView(AgilityDynamicCodeFile.REFNAME_AgilityPageCodeTemplates, AgilityDynamicCodeFile.LANGUAGECODE_CODE);
if (dv != null && dv.Count > 0)
{
string filter = string.Format("ReferenceName = '{0}' AND Visible = true", page.TemplateID);
DataRow[] rows = dv.Table.Select(filter);
if (rows.Length > 0)
{
templatePath = string.Format("~/Views/{0}/DynamicAgilityCode/{1}/{2}.cshtml",
rows[0]["VersionID"],
AgilityDynamicCodeFile.REFNAME_AgilityPageCodeTemplates,
page.TemplateID);
}
else
{
}
}
if (string.IsNullOrEmpty(templatePath))
{
//if it's not in code, check the regular template path
templatePath = page.TemplatePath;
}
if (string.IsNullOrEmpty(templatePath))
{
//still null? throw an error...
throw new ApplicationException("The template for this page is not available.");
}
//get the view engine
var tempdata = HtmlHelperViewExtensions.GetServiceOrFail <ITempDataDictionaryFactory>(context.HttpContext);
var engine = HtmlHelperViewExtensions.GetServiceOrFail <IRazorViewEngine>(context.HttpContext);
ViewEngineResult viewResult = engine.GetView(null, templatePath, true);
var tempDataDict = tempdata.GetTempData(context.HttpContext);
StringWriter sw = new StringWriter();
if (!viewResult.Success || viewResult?.View == null)
{
throw new ApplicationException("The template for this page is not available.");
}
var viewContext = new ViewContext(context, viewResult.View, ViewData, tempDataDict, sw, new HtmlHelperOptions());
//render the view...
var t = viewResult.View.RenderAsync(viewContext);
t.Wait();
string s = sw.GetStringBuilder().ToString();
//set the content type
Response.ContentType = "text/html";
t = Response.WriteAsync(s);
t.Wait();
//ViewResult view = new ViewResult()
//{
// ViewName = templatePath,
// ViewData = ViewData
//};
//view.ExecuteResult(context);
}
//TODO: do we get an HttpException here?
//catch (HttpException hex)
//{
// if (hex.InnerException != null)
// {
// if (hex.InnerException.InnerException != null && hex.InnerException.InnerException is HttpException)
// {
// //http exceptions thrown from Partial Controllers are buried...
// throw hex.InnerException.InnerException;
// }
// }
// throw hex;
//}
catch (Exception ex)
{
StringBuilder sb = new StringBuilder();
sb.Append("ViewData: ").AppendLine();
foreach (string key in ViewData.Keys)
{
sb.AppendFormat("{0}: {1}", key, ViewData[key]).AppendLine();
}
ApplicationException aex = new ApplicationException(sb.ToString(), ex);
AgilityHttpModule.HandleIntializationException(aex);
}
}
private static void RedirectToDynamicPreviewUrl(Dictionary <string, AgilityRouteCacheItem> routes, string path, string languageCode)
{
List <string> urlPaths = new List <string>();
string[] pathParts = path.Split(new char[] { '/' }, StringSplitOptions.RemoveEmptyEntries);
string staticRoute = string.Empty;
AgilityRouteCacheItem routeItem = null;
//keep some parent objects...
AgilityPage parentPage = null;
DynamicPageFormulaItem dpItemParent = null;
AgilityContent parentContent = null;
int previewContentID = -1;
int previewVersionID = -1;
if (!int.TryParse(AgilityContext.HttpContext.Request.Query["previewContentID"], out previewContentID))
{
if (!int.TryParse(AgilityContext.HttpContext.Request.Query["previewVersionID"], out previewVersionID))
{
int.TryParse(AgilityContext.HttpContext.Request.Query["ContentID"], out previewContentID);
}
}
foreach (string pathPart in pathParts)
{
string testStaticRoute = string.Format("{0}/{1}", staticRoute, pathPart);
if (routes.TryGetValue(testStaticRoute, out routeItem))
{
int pageID = routeItem.PageID;
//get the page...
AgilityPage page = BaseCache.GetPageFromID(pageID, languageCode, AgilityContext.WebsiteName, null);
if (page == null)
{
//if the page is null at this point, assume it's a folder page and jsut insert the static path...
urlPaths.Add(pathPart);
staticRoute = testStaticRoute;
continue;
}
string contentReferenceName = null;
int parentContentID = -1;
if (string.IsNullOrEmpty(page.DynamicPageContentViewReferenceName) &&
string.IsNullOrEmpty(page.DynamicPageParentFieldName))
{
//static page...
urlPaths.Add(pathPart);
}
else
{
//dynamic page..
if (!string.IsNullOrEmpty(page.DynamicPageContentViewReferenceName))
{
contentReferenceName = page.DynamicPageContentViewReferenceName;
if (!string.IsNullOrEmpty(page.DynamicPageParentFieldName))
{
if (parentPage == null || dpItemParent == null)
{
return;
}
//we have to match up to the parent page...
parentContentID = dpItemParent.ContentID;
}
}
else if (!string.IsNullOrEmpty(page.DynamicPageParentFieldName))
{
//get the dynamic content from the PARENT page
if (parentPage == null || dpItemParent == null)
{
return;
}
object obj = dpItemParent.GetContentItemValue(page.DynamicPageParentFieldName);
if (obj != null)
{
contentReferenceName = string.Format("{0}", obj);
}
}
if (string.IsNullOrEmpty(contentReferenceName))
{
return;
}
//get the content first if we are in development or staging mode...
AgilityContentServer.AgilityContent content = BaseCache.GetContent(contentReferenceName, languageCode, AgilityContext.WebsiteName);
//get the dynamic content for this page
DynamicPageFormulaItemIndex dpIndex = BaseCache.GetDynamicPageFormulaIndex(pageID, contentReferenceName, languageCode, page, true);
if (dpIndex == null || dpIndex.Count == 0)
{
return;
}
DynamicPageFormulaItem dpItem = null;
//try to use the preview url
if (previewVersionID > 0 || previewContentID > 0)
{
DataRow row = null;
if (previewContentID > 0)
{
row = content.GetItemByContentID(previewContentID);
}
else
{
DataRow[] rows = content.DataSet.Tables["ContentItems"].Select(string.Format("VersionID = {0}", previewVersionID));
if (rows.Length > 0)
{
row = rows[0];
}
}
if (row != null)
{
string pageName = string.Format("/{0}", DynamicPageFormulaItem.ResolveFormula(page.DynamicPageName, row, true)).ToLowerInvariant();
if (dpIndex.TryGetValue(pageName, out dpItem))
{
//adjust the parent if we need to...
if (!string.IsNullOrEmpty(page.DynamicPageParentFieldName) && dpItemParent != null)
{
//grab the parent id...
object parentIDObj = dpItem.GetContentItemValue(page.DynamicPageParentFieldName);
if (parentIDObj != null)
{
string parentIDStr = string.Format("{0}", parentIDObj);
if (parentIDStr.IndexOf(",") != -1)
{
parentIDStr = parentIDStr.Substring(0, parentIDStr.IndexOf(","));
}
int adjustedParentID = -1;
if (int.TryParse(parentIDStr, out adjustedParentID))
{
if (dpItemParent.ContentID != adjustedParentID)
{
// if the parent id DOES NOT match, we need to do some URL jigging...
DataRow parentRow = parentContent.GetItemByContentID(adjustedParentID);
parentContentID = adjustedParentID;
if (parentRow != null)
{
//get the parent page name and switch it up in the url..
string parentPageName = string.Format("/{0}", DynamicPageFormulaItem.ResolveFormula(parentPage.DynamicPageName, parentRow, true)).ToLowerInvariant();
urlPaths[urlPaths.Count - 1] = parentPageName.Substring(1);
}
}
}
}
}
}
}
}
if (dpItem == null)
{
//use the first one if we don't have an item yet...
dpItem = dpIndex.Values.FirstOrDefault();
}
if (parentContentID > 1 && previewVersionID < 1 && previewContentID < 1)
{
//unless we have a parent id to follow...
foreach (DynamicPageFormulaItem item in dpIndex.Values)
{
object testParentContentIDObj = item.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)
{
dpItem = item;
break;
}
}
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)))
{
dpItem = item;
break;
}
}
}
}
}
if (dpItem == null)
{
return;
}
urlPaths.Add(dpItem.Name.TrimStart("/".ToCharArray()));
dpItemParent = dpItem;
parentContent = content;
}
staticRoute = testStaticRoute;
parentPage = page;
}
else
{
//if we can't find a static route, kick out.
return;
}
}
if (urlPaths.Count > 0)
{
StringBuilder sbUrl = new StringBuilder("~/");
sbUrl.Append(string.Join("/", urlPaths.ToArray()));
if (AgilityContext.HttpContext.Request.Path.Value.EndsWith(".aspx", StringComparison.CurrentCultureIgnoreCase))
{
sbUrl.Append(".aspx");
}
if (!string.IsNullOrEmpty(AgilityContext.HttpContext.Request.QueryString.Value))
{
sbUrl.Append(AgilityContext.HttpContext.Request.QueryString.Value);
}
string redirectUrl = sbUrl.ToString();
//strip off the querystrings that we don't want...
redirectUrl = Agility.Web.Util.Url.RemoveQueryString(redirectUrl, "ContentID&VersionID&previewContentID&previewVersionID");
Agility.Web.HttpModules.AgilityHttpModule.RedirectResponse(redirectUrl, 301);
AgilityContext.IsResponseEnded = true;
}
}
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);
}
internal static string GetStatusPanelScript()
{
//Add the Style Sheets for the StatusBar and Edit In Place:
StringBuilder sb = new StringBuilder();
//HACK
bool isPublished = false;
bool containsUnpublishedModules = false;
string pageTemplatePath = string.Empty;
int pageTemplateID = -1;
int pageID = -1;
if (AgilityContext.Page != null)
{
AgilityPage page = AgilityContext.Page;
pageID = page.ID;
if (page.IsPublished)
{
isPublished = true;
}
if (!string.IsNullOrEmpty(page.TemplatePath) && page.TemplateID > 0)
{
pageTemplatePath = page.TemplatePath;
if (pageTemplatePath.StartsWith("~/"))
{
pageTemplatePath = pageTemplatePath.Substring(1);
string appPath = "/";
if (appPath != "/")
{
pageTemplatePath = string.Format("{0}{1}{2}", appPath, "/TemplatePreview", pageTemplatePath);
}
else
{
pageTemplatePath = string.Format("{0}{1}", "/TemplatePreview", pageTemplatePath);
}
}
pageTemplateID = page.TemplateID;
}
bool switchMode = false;
if (AgilityContext.CurrentMode == Agility.Web.Enum.Mode.Live)
{
//if the site is in live mode, switch to staging to check if any modules are required publishing.
switchMode = true;
AgilityContext.CurrentMode = Agility.Web.Enum.Mode.Staging;
}
//check if there are any modules that have not yet been publish
foreach (ContentSection sect in AgilityContext.Page.ContentSections)
{
if (sect.ModuleID > 0)
{
AgilityContentServer.AgilityModule module = BaseCache.GetModule(sect.ModuleID, AgilityContext.WebsiteName);
if (module != null && !module.IsPublished && module.IsPublishedSpecified)
{
containsUnpublishedModules = true;
}
}
}
if (switchMode)
{
AgilityContext.CurrentMode = Agility.Web.Enum.Mode.Live;
}
}
//generate the preview key
string securityKey = Current.Settings.SecurityKey;
byte[] data = UnicodeEncoding.Unicode.GetBytes(string.Format("{0}_{1}_Preview", -1, securityKey));
SHA512 shaM = new SHA512Managed();
byte[] result = shaM.ComputeHash(data);
string previewKey = Convert.ToBase64String(result);
string appendQuery = string.Format("agilitypreviewkey={0}&agilityts={1}&lang={2}",
HttpUtility.UrlEncode(previewKey),
DateTime.Now.ToString("yyyyMMddhhmmss"),
HttpUtility.UrlEncode(AgilityContext.LanguageCode));
string pageUrl = AgilityContext.UrlForPreviewBar;
if (string.IsNullOrEmpty(pageUrl))
{
pageUrl = AgilityContext.HttpContext.Request.GetEncodedUrl();
}
string innerUrl = Agility.Web.Util.Url.ModifyQueryString(
HttpUtility.UrlPathEncode(pageUrl),
appendQuery,
"ispreview");
string subject = string.Format("Agility {0} Preview", AgilityContext.WebsiteName);
string body = string.Format("Click the link below to preview the {0} site:\n{1}\n____________________\nSent from Agility\nhttp://www.agilitycms.com",
AgilityContext.WebsiteName,
innerUrl);
string previewURL = string.Format("mailto:?subject={0}&body={1}",
HttpUtility.UrlEncode(subject).Replace("+", "%20"),
HttpUtility.UrlEncode(body).Replace("+", "%20"));
//channel listing
string[] channels = (from c in BaseCache.GetDigitalChannels(AgilityContext.WebsiteName).Channels
select string.Format("{{Name:\"{0}\",ID:'{1}'}}", c.DisplayName.Replace("\"", "\\\""), c.ReferenceName)).ToArray();
string uniqueID = Guid.NewGuid().ToString();
string previewDateStr = AgilityContext.PreviewDateTime.ToString("yyyy-M-d h:mm tt", CultureInfo.InvariantCulture);
if (AgilityContext.PreviewDateTime == DateTime.MinValue)
{
previewDateStr = string.Empty;
}
//output the script for the onload
sb.Append("<script type='text/javascript'>");
//output the context object
sb.AppendFormat(@"var agilityContextObj = {{
currentMode:""{0}"",
isPreview:{1},
isTemplatePreview:{2},
languageCode:""{3}"",
websiteName:""{4}"",
isDevelopmentMode:{5},
controlUniqueID:""{6}"",
previewDateTime:""{7}"",
isPublished:{8},
containsUnpublishedModules:{9},
pageTemplatePath:""{10}"",
pageTemplateID:{11},
previewURL:""{12}"",
cookieDomain:""{13}"",
pageID:""{14}"",
errorLink:{15},
channel:'{16}',
channels:[{17}]
}}; " ,
new object[] {
AgilityContext.CurrentMode, //0
AgilityContext.IsPreview.ToString().ToLowerInvariant(), //1
AgilityContext.IsTemplatePreview.ToString().ToLowerInvariant(), //2
AgilityContext.LanguageCode, //3
AgilityContext.WebsiteName.Replace("\"", "\\\"").Replace(" ", ""), //4
Current.Settings.DevelopmentMode.ToString().ToLowerInvariant(), //5
uniqueID, //6
previewDateStr, //7
isPublished.ToString().ToLowerInvariant(), //8
containsUnpublishedModules.ToString().ToLowerInvariant(), //9
pageTemplatePath.Replace("\"", "\\\""), //10
pageTemplateID, //11
previewURL.Replace("\"", "\\\""), //12
Current.Settings.CookieDomain, //13
pageID,
Current.Settings.DevelopmentMode && WebTrace.HasErrorOccurred ? string.Format("'{0}?enc={1}'", Agility.Web.HttpModules.AgilityHttpModule.ECMS_ERRORS_KEY, HttpUtility.UrlEncode(WebTrace.GetEncryptionQueryStringForLogFile(DateTime.Now))) : "null",
AgilityContext.CurrentChannel.ReferenceName,
string.Join(",", channels)
});
sb.Append(Environment.NewLine);
sb.Append("var agilityLanguages = [");
foreach (Language lang in AgilityContext.Domain.Languages)
{
sb.AppendFormat("['{0}', '{1}'],", lang.LanguageName, lang.LanguageCode);
}
sb = sb.Remove(sb.Length - 1, 1);
sb.Append("];");
sb.Append(Environment.NewLine);
sb.Append("</script>");
sb.Append("<script type='text/javascript' src='https://media.agilitycms.com/preview-bar/2018-11/agility-preview-bar.es5.min.js'></script>");
return(sb.ToString());
}
public static Task <IHtmlContent> RenderContentZone(this IViewComponentHelper component, AgilityPage page, string zoneName)
{
try
{
HttpContext currentContext = AgilityContext.HttpContext;
String websiteName = AgilityContext.WebsiteName;
if (page == null)
{
if (AgilityContext.IsTemplatePreview)
{
//TODO render the template preview
//var templates = from cs in AgilityContext.CurrentPageTemplateInPreview.ContentSections
// where string.Equals(cs.Name, zoneName, StringComparison.CurrentCultureIgnoreCase)
// orderby cs.XModuleOrder
// select cs;
//TextWriter tw = helper.ViewContext.Writer;
//foreach (var cs in templates)
//{
// tw.Write(string.Format("<div class=\"AgilityContentSectionDefinition\"><div class=\"ContentSectionTitle\">{0}</div></div>", cs.Name));
//}
}
return(Task.Run <IHtmlContent>(() => { return new HtmlString("TODO: implement template preview"); }));
}
//regular page rendering
var sections = from cs in page.ContentSections
where string.Equals(cs.Name, zoneName, StringComparison.CurrentCultureIgnoreCase)
orderby cs.ModuleOrder
select cs;
List <Task <string> > sectionTasks = new List <Task <string> >();
DateTime dtStart = DateTime.Now;
foreach (var cs in sections)
{
//only continue if we have a content ref name...
if (string.IsNullOrEmpty(cs.ContentReferenceName))
{
continue;
}
//keep track of the various way this module can be rendered
List <ModuleRender> renders = new List <ModuleRender>()
{
new ModuleRender()
{
ContentReferenceName = cs.ContentReferenceName
}
};
//if this content zone is part of a Module AB test Experiment
if (cs.ExperimentID > 0)
{
var lst = BaseCache.GetExperiments(AgilityContext.WebsiteName);
AgilityContentServer.AgilityExperiment experiment = lst.GetExperiment(cs.ExperimentID);
if (experiment != null)
{
foreach (var variant in experiment.Variants.Where(v => !string.IsNullOrWhiteSpace(v.ContentReferenceName)))
{
renders.Add(new ModuleRender()
{
ContentReferenceName = variant.ContentReferenceName,
Variant = variant
});
}
}
}
foreach (ModuleRender moduleRender in renders)
{
try
{
string contentReferenceName = moduleRender.ContentReferenceName;
Agility.Web.AgilityContentServer.AgilityContent moduleContent = BaseCache.GetContent(contentReferenceName, AgilityContext.LanguageCode, websiteName);
if (moduleContent == null ||
moduleContent.DataSet == null ||
moduleContent.DataSet.Tables["ContentItems"] == null ||
moduleContent.DataSet.Tables["ContentItems"].Rows.Count == 0)
{
continue;
}
DataRowView drv = moduleContent.DataSet.Tables["ContentItems"].DefaultView[0];
int moduleContentID = -1;
int moduleVersionID = -1;
if (!int.TryParse($"{drv["ContentID"]}", out moduleContentID))
{
moduleContentID = -1;
}
if (!int.TryParse($"{drv["VersionID"]}", out moduleVersionID))
{
moduleVersionID = -1;
}
Agility.Web.AgilityContentServer.AgilityModule module = BaseCache.GetModule(cs.ModuleID, websiteName);
if (module == null)
{
continue;
}
object model = new AgilityModuleModel()
{
ModuleContentName = contentReferenceName,
ModuleProperties = drv,
LanguageCode = AgilityContext.LanguageCode
};
string viewComponentName = null;
string agilityCodeRefName = null;
using (StringReader sr = new StringReader(module.XmlSchema))
{
DataSet ds = new DataSet();
ds.ReadXmlSchema(sr);
viewComponentName = ds.ExtendedProperties["ViewComponent"] as string;
agilityCodeRefName = ds.ExtendedProperties["AgilityCodeRefName"] as string;
}
if (!string.IsNullOrEmpty(viewComponentName))
{
#region *** VIEW COMPONENTS **
var viewComponentFactory = HtmlHelperViewExtensions.GetServiceOrFail <IViewComponentSelector>(AgilityContext.HttpContext);
var componentDesc = viewComponentFactory.SelectComponent(viewComponentName);
if (componentDesc == null)
{
throw new ApplicationException(string.Format("The view component {0} was not found.", viewComponentName));
}
MethodInfo method = componentDesc.MethodInfo;
if (method == null)
{
throw new ApplicationException(string.Format("The component invoke method was not found in the component {0}", viewComponentName));
}
ParameterInfo[] paramAry = method.GetParameters();
if (paramAry.Length > 0)
{
ParameterInfo paramInfo = paramAry[0];
Type paramType = paramInfo.ParameterType;
if (paramType.IsSubclassOf(typeof(AgilityContentItem)) || paramType == typeof(AgilityContentItem))
{
ConstructorInfo ci = paramType.GetConstructor(System.Type.EmptyTypes);
if (ci == null)
{
throw new ApplicationException(string.Format("No default constructor found for type {0}", paramType.Name));
}
AgilityContentItem moduleItem = ci.Invoke(new object[0]) as AgilityContentItem;
moduleItem.DataRow = drv.Row;
moduleItem.LanguageCode = AgilityContext.LanguageCode;
moduleItem.ReferenceName = contentReferenceName;
moduleItem.ContentID = moduleContentID;
moduleItem.VersionID = moduleVersionID;
try
{
Task <IHtmlContent> task = component.InvokeAsync(viewComponentName, moduleItem);
moduleRender.RenderTask = task;
moduleRender.ContentID = moduleContentID;
}
catch (Exception ex)
{
moduleRender.PreRenderedContent = new HtmlString($"<p>Error rendering Component {viewComponentName}</p><pre>{ex}</pre>");
moduleRender.ContentID = moduleContentID;
}
}
else
{
throw new ApplicationException(string.Format("The component invoke method parameter was not of type AgilityContent in the component {0}", viewComponentName));
}
#endregion
}
}
else if (!string.IsNullOrEmpty(agilityCodeRefName))
{
#region *** Agility Inline Code ***
DataView dv = Data.GetContentView(AgilityDynamicCodeFile.REFNAME_AgilityModuleCodeTemplates, AgilityDynamicCodeFile.LANGUAGECODE_CODE);
string filter = string.Format("ReferenceName = '{0}' AND Visible = true", agilityCodeRefName);
DataRow[] rows = dv.Table.Select(filter);
if (rows.Length > 0)
{
string modulePath =
$"~/Views/{rows[0]["VersionID"]}/DynamicAgilityCode/{AgilityDynamicCodeFile.REFNAME_AgilityModuleCodeTemplates}/{agilityCodeRefName}.cshtml";
AgilityContentItem moduleItem = new AgilityContentItem();
moduleItem.DataRow = drv.Row;
moduleItem.LanguageCode = AgilityContext.LanguageCode;
moduleItem.ReferenceName = contentReferenceName;
moduleItem.ContentID = moduleContentID;
moduleItem.VersionID = moduleVersionID;
//moduleItem.InlineCodePath = modulePath;
try
{
Task <IHtmlContent> task = component.InvokeAsync("AgilityInlineCode", new { inlineCodePath = modulePath, module = moduleItem });
moduleRender.RenderTask = task;
moduleRender.ContentID = moduleContentID;
}
catch (Exception ex)
{
moduleRender.PreRenderedContent = new HtmlString($"<p>Error rendering Inline Code</p><pre>{ex}</pre>");
moduleRender.ContentID = moduleContentID;
}
}
else
{
moduleRender.PreRenderedContent = new HtmlString($"<p>Error rendering Inline Code</p>");
moduleRender.ContentID = moduleContentID;
}
#endregion
}
else if (!string.IsNullOrEmpty(module.ControlPath))
{
#region *** Control Path - Partial View ***
string className = GetClassName(module.ReferenceName ?? module.Name);
string typeName = string.Format("Module_{0}", className);
Type paramType = Agility.Web.Utils.FileUtils.GetTypeFromReflection(null, typeName);
if (paramType.IsSubclassOf(typeof(AgilityContentItem)) || paramType == typeof(AgilityContentItem))
{
ConstructorInfo ci = paramType.GetConstructor(System.Type.EmptyTypes);
if (ci == null)
{
throw new ApplicationException(string.Format("No default constructor found for type {0}", paramType.Name));
}
AgilityContentItem moduleItem = ci.Invoke(new object[0]) as AgilityContentItem;
moduleItem.DataRow = drv.Row;
moduleItem.LanguageCode = AgilityContext.LanguageCode;
moduleItem.ReferenceName = contentReferenceName;
moduleItem.ContentID = moduleContentID;
moduleItem.VersionID = moduleVersionID;
try
{
Task <IHtmlContent> task = component.InvokeAsync("AgilityPartialView", new { partialViewPath = module.ControlPath, module = moduleItem });
moduleRender.RenderTask = task;
moduleRender.ContentID = moduleContentID;
}
catch (Exception ex)
{
moduleRender.PreRenderedContent = new HtmlString($"<p>Error rendering Partial View at {module.ControlPath}</p><pre>{ex}</pre>");
moduleRender.ContentID = moduleContentID;
}
}
else
{
throw new ApplicationException(string.Format("The component invoke method parameter was not of type AgilityContent in the component {0}", viewComponentName));
}
#endregion
}
else if (!string.IsNullOrEmpty(module.Markup))
{
if (module.Markup.StartsWith("@"))
{
#region *** Inline Razor Markup ***
AgilityContentItem item = new AgilityContentItem();
item.DataRow = drv.Row;
item.LanguageCode = AgilityContext.LanguageCode;
item.ReferenceName = contentReferenceName;
item.ContentID = moduleContentID;
item.VersionID = moduleVersionID;
model = item;
string viewPath = string.Format("~/Views/DynamicAgilityModule/MVC/{0}/{1}.cshtml", AgilityContext.CurrentMode, module.ID);
try
{
Task <IHtmlContent> task = component.InvokeAsync("AgilityInlineCode", new { inlineCodePath = viewPath, module = item });
moduleRender.RenderTask = task;
moduleRender.ContentID = moduleContentID;
}
catch (Exception ex)
{
moduleRender.PreRenderedContent = new HtmlString($"<p>Error rendering Dynamic Agility Module</p><pre>{ex}</pre>");
moduleRender.ContentID = moduleContentID;
}
#endregion
}
}
}
catch (Exception ex)
{
if (Current.Settings.DevelopmentMode)
{
moduleRender.PreRenderedContent = new HtmlString($"<div>Could not output zone {cs.Name}</div><div>{ex.ToString().Replace("\n", "<br/>")}</div>");
}
else
{
moduleRender.PreRenderedContent = new HtmlString($"<!-- Could not output zone {cs.Name} - See web log -->");
Agility.Web.Tracing.WebTrace.WriteException(ex);
}
}
}
Task <string> sectionTask = Task <string> .Run(() =>
{
AgilityContext.HttpContext = currentContext;
var rendersToOutput = renders.Where(r => r.RenderTask != null || r.PreRenderedContent != null).ToList();
return(AgilityHelpers.RenderModuleHtml(rendersToOutput, cs));
});
sectionTasks.Add(sectionTask);
}
Task <IHtmlContent> retTask = Task.Run <IHtmlContent>(() =>
{
AgilityContext.HttpContext = currentContext;
try
{
Task.WaitAll(sectionTasks.ToArray());
} catch { }
using (StringWriter htmlStringWriter = new StringWriter())
{
foreach (var t in sectionTasks)
{
if (t.IsFaulted)
{
Agility.Web.Tracing.WebTrace.WriteException(t.Exception, $"Error rendering module in zone {zoneName} - {t.AsyncState}");
}
else
{
htmlStringWriter.Write(t.Result);
}
}
TimeSpan ts = DateTime.Now - dtStart;
if (ts.TotalSeconds > 1)
{
string renderTimeMessage = string.Format("Content Zone: {0} - Render Time: {1:F2} seconds.", zoneName, ts.TotalMilliseconds / 1000);
Agility.Web.Tracing.WebTrace.WriteVerboseLine(renderTimeMessage);
htmlStringWriter.Write(string.Format("<!-- {0} -->", renderTimeMessage));
}
return(new HtmlString(htmlStringWriter.ToString()));
}
});
return(retTask);
}
catch (Exception ex)
{
string errHtml = null;
string msg = string.Format("Could not output content zone {0}.", zoneName);
if (ex is InvalidOperationException && ex.Message.Contains("No route"))
{
msg +=
@" This error is usually caused by a missing route in your Global.asax.cs. Ensure the following route is defined after the normal Agility route.\n
routes.MapRoute(""Default"", ""{controller}/{action}/{id}"",\n
new { controller = """", action = """", id = """" }\n
);";
}
if (Current.Settings.DevelopmentMode)
{
errHtml = ex.ToString().Replace("\n", "<br/>");
}
else
{
errHtml = msg;
}
Agility.Web.Tracing.WebTrace.WriteException(ex, msg);
return(Task.Run <IHtmlContent>(() => { return new HtmlString(errHtml); }));
}
}
public async Task <HtmlString> InvokeAsync()
{
AgilityContext.HttpContext = HttpContext;
AgilityPage currentPage = AgilityContext.Page;
StringBuilder sb = new StringBuilder(Environment.NewLine);
if (currentPage != null)
{
//canonical link
if (!string.IsNullOrEmpty(AgilityContext.CanonicalLink))
{
sb.AppendFormat("<link rel=\"canonical\" href=\"{0}\" />", AgilityContext.CanonicalLink);
sb.Append(Environment.NewLine);
}
//set the page specific meta tags
sb.Append("<meta name=\"description\" content=\"").Append(currentPage.MetaTags).Append("\" />");
sb.Append(Environment.NewLine);
if (!string.IsNullOrEmpty(currentPage.MetaKeyWords))
{
sb.Append("<meta name=\"keywords\" content=\"").Append(currentPage.MetaKeyWords).Append("\" />");
sb.Append(Environment.NewLine);
}
string rawTags = currentPage.MetaTagsRaw;
if (rawTags == null)
{
rawTags = string.Empty;
}
if (!string.IsNullOrEmpty(rawTags))
{
sb.Append(Agility.Web.Util.Url.ResolveTildaUrlsInHtml(rawTags));
sb.Append(Environment.NewLine);
}
if (!string.IsNullOrEmpty(AgilityContext.TwitterCardSite))
{
if (rawTags.IndexOf("<meta name=\"twitter:site\"", StringComparison.CurrentCultureIgnoreCase) == -1)
{
string site = AgilityContext.TwitterCardSite;
if (!site.StartsWith("@"))
{
site = string.Format("@{0}", site);
}
sb.AppendFormat("<meta name=\"twitter:site\" value=\"{0}\" />", site);
}
string twitterCardType = "summary";
if (!string.IsNullOrEmpty(AgilityContext.FeaturedImageUrl))
{
twitterCardType = "summary_large_image";
sb.AppendFormat("<meta name=\"twitter:image:src\" content=\"{0}\" />", AgilityContext.FeaturedImageUrl);
}
sb.AppendFormat("<meta name=\"twitter:card\" content=\"{0}\" />", twitterCardType);
sb.AppendFormat("<meta name=\"twitter:title\" content=\"{0}\" />", currentPage.Title);
sb.AppendFormat("<meta name=\"twitter:description\" content=\"{0}\" />", currentPage.MetaTags);
}
if (Current.Settings.OutputOpenGraph)
{
sb.AppendFormat("<meta name=\"og:title\" content=\"{0}\" />", currentPage.Title);
sb.AppendFormat("<meta name=\"og:description\" content=\"{0}\" />", currentPage.MetaTags);
if (!string.IsNullOrEmpty(AgilityContext.FeaturedImageUrl))
{
sb.AppendFormat("<meta name=\"og:image\" content=\"{0}\" />", AgilityContext.FeaturedImageUrl);
sb.Append(Environment.NewLine);
}
}
//content language
sb.Append("<meta http-equiv='content-language' content='").Append(currentPage.LanguageCode).Append("'/>");
sb.Append(Environment.NewLine);
//default css...
string globalCss = AgilityContext.Domain.GlobalCss;
if (!string.IsNullOrEmpty(globalCss))
{
string url = AgilityHelpers.ResolveUrl(string.Format("~/{0}/global.css",
Agility.Web.HttpModules.AgilityHttpModule.ECMS_EDITOR_CSS_KEY));
sb.AppendFormat("<link rel=\"stylesheet\" type=\"text/css\" href=\"{0}\" />", url);
}
//set the custom agility meta tags
sb.Append("<meta name=\"generator\" content=\"Agility CMS\" />");
sb.Append(Environment.NewLine);
sb.AppendFormat("<meta name=\"agility_timestamp\" content=\"{0:yyyy/MM/dd hh:mm:ss tt}\" />", DateTime.Now);
sb.AppendFormat("<meta name=\"agility_attributes\" content=\"Mode={0}, IsPreview={1}, Language={2}, Machine={3}, CustomOutputCache={4}\" />",
AgilityContext.CurrentMode,
AgilityContext.IsPreview,
AgilityContext.LanguageCode,
Environment.MachineName,
AgilityCache.UseAgilityOutputCache);
sb.Append(Environment.NewLine);
}
//add the StatusPanelEmitter if in preview mode, development mode, or edit in place
if (AgilityContext.IsPreview ||
Current.Settings.DevelopmentMode ||
AgilityContext.IsTemplatePreview)
{
sb.Append(StatusPanelEmitter.GetStatusPanelCssOnly());
}
return(new HtmlString(sb.ToString()));
}
/// <summary>
/// Output the bottom scripts defined in the Page and Globally, as well as the Form Builder scripts if the Form module was used on this page.
/// </summary>
/// <param name="helper"></param>
public static HtmlString RenderAgilityBottomScripts(this IHtmlHelper helper)
{
AgilityPage currentPage = AgilityContext.Page;
if (currentPage == null)
{
return(new HtmlString(""));
}
StringBuilder sb = new StringBuilder(Environment.NewLine);
string scriptTopGlobal;
string scriptBottomGlobal;
string scriptBottomPage = null;
//add the Javascript tracking stuff
if (currentPage.IncludeInStatsTracking)
{
//global script
if (!string.IsNullOrEmpty(AgilityContext.Domain.StatsTrackingScript))
{
scriptTopGlobal = AgilityContext.Domain.StatsTrackingScript;
scriptBottomGlobal = string.Empty;
if (scriptTopGlobal.IndexOf(GLOBAL_SCRIPT_SEPARATOR) != -1)
{
scriptBottomGlobal = scriptTopGlobal.Substring(scriptTopGlobal.IndexOf(GLOBAL_SCRIPT_SEPARATOR) + GLOBAL_SCRIPT_SEPARATOR.Length);
scriptTopGlobal = scriptTopGlobal.Substring(0, scriptTopGlobal.IndexOf(GLOBAL_SCRIPT_SEPARATOR));
}
if (!string.IsNullOrEmpty(scriptBottomGlobal))
{
sb.Append(scriptBottomGlobal);
sb.Append(Environment.NewLine);
}
}
}
string scriptTopPage = null;
//custom script for this page
if (!string.IsNullOrEmpty(currentPage.CustomAnalyticsScript))
{
scriptTopPage = currentPage.CustomAnalyticsScript;
if (scriptTopPage.IndexOf(GLOBAL_SCRIPT_SEPARATOR) != -1)
{
scriptBottomPage = scriptTopPage.Substring(scriptTopPage.IndexOf(GLOBAL_SCRIPT_SEPARATOR) + GLOBAL_SCRIPT_SEPARATOR.Length);
scriptTopPage = scriptTopPage.Substring(0, scriptTopPage.IndexOf(GLOBAL_SCRIPT_SEPARATOR));
}
if (!string.IsNullOrEmpty(scriptBottomPage))
{
sb.Append(scriptBottomPage);
sb.Append(Environment.NewLine);
}
}
return(new HtmlString(sb.ToString()));
}
internal static bool IsStagingItemOutOfDate(object existingItem)
{
if (existingItem == null)
{
return(true);
}
AgilityContent existingItem_Content = existingItem as AgilityContent;
AgilitySitemap existingItem_Sitemap = existingItem as AgilitySitemap;
AgilityPage existingItem_Page = existingItem as AgilityPage;
AgilityModule existingItem_Module = existingItem as AgilityModule;
AgilityAssetMediaGroup existingItem_Gallery = existingItem as AgilityAssetMediaGroup;
if (existingItem_Content != null)
{
//CONTENT
int versionID = 0;
int maxVersionIDInDataSet = 0;
if (existingItem_Content.DataSet != null)
{
if (existingItem_Content.DataSet.ExtendedProperties.ContainsKey("MaxVersionID"))
{
int.TryParse(string.Format("{0}", existingItem_Content.DataSet.ExtendedProperties["MaxVersionID"]), out maxVersionIDInDataSet);
}
DataTable dt = existingItem_Content.DataSet.Tables["ContentItems"];
if (dt != null && dt.Columns["VersionID"] != null)
{
try
{
object maxObj = dt.Compute("max(VersionID)", "");
if (!int.TryParse($"{maxObj}", out versionID))
{
versionID = -1;
}
} catch (Exception ex)
{
throw ex;
}
}
if (maxVersionIDInDataSet > versionID)
{
versionID = maxVersionIDInDataSet;
}
}
int latestVersionID = CheckContentIndex(versionID, existingItem_Content.ReferenceName, existingItem_Content.LanguageCode);
if (latestVersionID > 0)
{
if (existingItem_Content.DataSet != null)
{
existingItem_Content.DataSet.ExtendedProperties["MaxVersionID"] = latestVersionID;
}
return(true);
}
else
{
return(false);
}
}
else if (existingItem_Page != null)
{
//PAGE
return(CheckPageIndex(existingItem_Page.ZVersionID, existingItem_Page.ID, existingItem_Page.LanguageCode));
}
else if (existingItem_Module != null)
{
//MODULE DEF
return(CheckContentDefinitionIndex(existingItem_Module.ID, existingItem_Module.LastAccessDate));
}
else if (existingItem_Sitemap != null)
{
//SITEMAP
return(CheckPageIndex(existingItem_Sitemap.XMaxPageVersionID, -1, existingItem_Sitemap.LanguageCode));
}
else if (existingItem_Gallery != null)
{
//MEDIA GROUPING/GALLERY
DateTime dtModifiedOn = existingItem_Gallery.ModifiedOn;
if (existingItem_Gallery.Media != null && existingItem_Gallery.Media.Length > 0)
{
//check for the most recent item..
DateTime dtItem = existingItem_Gallery.Media.Max(d => d.ModifiedOn);
if (dtItem > dtModifiedOn)
{
dtModifiedOn = dtItem;
}
}
return(CheckMediaGalleryIndex(existingItem_Gallery.ID, dtModifiedOn));
}
return(true);
}
public bool Match(HttpContext httpContext, IRouter route, string routeKey, RouteValueDictionary values, RouteDirection routeDirection)
{
AgilityContext.HttpContext = httpContext;
//TODO: handle malicious request throttling (read)
//ErrorTraceElement elem = Current.Settings.Trace.ErrorTraceTypes.FindDangerousRequestMatch();
////if the TraceElement exists and this path IS NOT the specified throttleRedirect
//if (elem != null && !string.Equals(HttpContext.Current.Request.Path, elem.RequestThrottleRedirect, StringComparison.OrdinalIgnoreCase))
//{
// bool throttle = AgilityHttpModule.HandleDangerousRequest(elem, HttpContext.Current.Request, HttpContext.Current.Response);
// if (throttle) return false;
//}
string controllerName = values["Controller"] as string;
if (!string.Equals(controllerName, "Agility"))
{
return(false);
}
if (!string.IsNullOrEmpty(httpContext.Request.Query["lang"]))
{
//if the languagecode is in the URL, redirect...
return(true);
}
string domain = httpContext.Request.Host.Value;
string sitemapPath = values["sitemapPath"] as string;
string languageCode = values["languageCode"] as string;
//ECMS_DOCUMENTS_KEY = "ecm
//ECMS_DOCUMENTS_KEY2 = "ec
//ECMS_RSS_KEY = "ecmsrss.a
//ECMS_ERRORS_KEY = "ecmser
//ECMS_EDITOR_CSS_KEY = "ec
if (!string.IsNullOrEmpty(sitemapPath) &&
(sitemapPath.IndexOf(AgilityHttpModule.ECMS_DOCUMENTS_KEY2, StringComparison.CurrentCultureIgnoreCase) != -1 ||
sitemapPath.IndexOf(AgilityHttpModule.ECMS_RSS_KEY, StringComparison.CurrentCultureIgnoreCase) != -1 ||
sitemapPath.IndexOf(AgilityHttpModule.ECMS_ERRORS_KEY, StringComparison.CurrentCultureIgnoreCase) != -1 ||
sitemapPath.IndexOf(AgilityHttpModule.ECMS_EDITOR_CSS_KEY, StringComparison.CurrentCultureIgnoreCase) != -1 ||
sitemapPath.IndexOf(AgilityHttpModule.DynamicCodePrepend, StringComparison.CurrentCultureIgnoreCase) != -1 ||
sitemapPath.IndexOf("TemplatePreview/", StringComparison.CurrentCultureIgnoreCase) >= 0 ||
(!string.IsNullOrEmpty(httpContext.Request.Query["agilitypreviewkey"]))
)
)
{
return(true);
}
try
{
//test to see if the language code is in the URL...
string pathWithOutSlash = sitemapPath;
if (pathWithOutSlash == null)
{
pathWithOutSlash = string.Empty;
}
if (pathWithOutSlash.StartsWith("~/"))
{
pathWithOutSlash = pathWithOutSlash.Substring(2);
}
if (pathWithOutSlash.StartsWith("/"))
{
pathWithOutSlash = pathWithOutSlash.Substring(1);
}
string languageCodeTest = null;
//strip out the language from the url (first folder path)
int index = pathWithOutSlash.IndexOf("/");
if (index > 0)
{
languageCodeTest = pathWithOutSlash.Substring(0, index);
pathWithOutSlash = pathWithOutSlash.Substring(index + 1);
}
else
{
languageCodeTest = pathWithOutSlash;
pathWithOutSlash = string.Empty;
}
AgilityContentServer.AgilityDomainConfiguration config = BaseCache.GetDomainConfiguration(AgilityContext.WebsiteName);
//if (config == null) throw new Exception("Could not access the Domain Configuration.");
if (config != null && config.Languages != null)
{
var lang = config.Languages.FirstOrDefault(l => string.Equals(l.LanguageCode, languageCodeTest, StringComparison.CurrentCultureIgnoreCase));
if (lang != null)
{
//found the language code in the URL, switch up the values...
sitemapPath = pathWithOutSlash;
languageCode = languageCodeTest;
}
}
}
catch (Exception ex)
{
Agility.Web.Tracing.WebTrace.WriteException(ex);
}
if (HttpModules.AgilityHttpModule.HandleChannelsAndRedirects(ref sitemapPath, languageCode))
{
//set a variable that says we can redirect now...
httpContext.Items["Agility.Web.RequestPreviouslyHandledInRouteConstraint"] = true;
return(true);
}
AgilityPage agilityPage = Agility.Web.Data.GetPage(sitemapPath, languageCode);
return(agilityPage != null || AgilityContext.IsResponseEnded);
}
