// GET: Polygomy
public ActionResult Index()
{
Polygomy Page = DynamicRouteHelper.GetPage <Polygomy>();
HttpContext.Kentico().PageBuilder().Initialize(Page.DocumentID);
// Get Categories
List <int> PageCategories = TreeCategoryInfoProvider.GetTreeCategories()
.WhereEquals("NodeID", Page.NodeID)
.Select(x => x.CategoryID).ToList();
PolygomyViewModel model = new PolygomyViewModel()
{
MemeCategories = CategoryInfoProvider.GetCategories()
.WhereIn("CategoryID", PageCategories)
.Select(x => x.CategoryDisplayName).ToArray(),
};
if (PageCategories.Count > 0)
{
model.Memes = MemeProvider.GetMemes()
.Where(RelHelper.GetNodeCategoryWhere(PageCategories.Select(x => (object)x)))
.ToList();
}
return(View("NEWCC/Polygomy", model));
}
/// <summary>
/// Build Node (and upward), and build the children and update recursively only if changes detected.
/// </summary>
/// <param name="UrlSlugID"></param>
public static void UrlSlugModified(int UrlSlugID)
{
// Convert UrlSlugID to NodeID
int NodeID = UrlSlugInfoProvider.GetUrlSlugInfo(UrlSlugID).UrlSlugNodeID;
DynamicRouteHelper.RebuildRoutesByNode(NodeID);
}
/// <summary>
/// Renders the Dynamic Route View (no model)
/// </summary>
/// <returns></returns>
public ActionResult RenderView()
{
var node = DynamicRouteHelper.GetPage();
var routeConfig = DynamicRouteHelper.GetRouteConfiguration(node);
HttpContext.Kentico().PageBuilder().Initialize(node.DocumentID);
return(View(routeConfig.ViewName));
}
protected void btnCheckUrl_Click(object sender, EventArgs e)
{
ITreeNode Node = DynamicRouteHelper.GetPage(tbxRouteToTest.Text);
if (Node != null)
{
ltrPageFound.Text = $"FOUND! {Node.NodeAliasPath} {Node.ClassName} {Node.DocumentCulture}";
}
else
{
ltrPageFound.Text = "No Node Found";
}
}
/// <summary>
/// Gets the node based on the current request url and then renders the template result.
/// </summary>
public ActionResult Index()
{
ITreeNode FoundNode = DynamicRouteHelper.GetPage();
if (FoundNode != null)
{
HttpContext.Kentico().PageBuilder().Initialize(FoundNode.DocumentID);
return(new TemplateResult(FoundNode.DocumentID));
}
else
{
return(new HttpNotFoundResult());
}
}
/// <summary>
/// Returns true if a Page is found using the Dynamic Routing
/// </summary>
/// <param name="httpContext"></param>
/// <param name="route"></param>
/// <param name="parameterName"></param>
/// <param name="values"></param>
/// <param name="routeDirection"></param>
/// <returns></returns>
public bool Match(HttpContextBase httpContext, Route route, string parameterName, RouteValueDictionary values, RouteDirection routeDirection)
{
string controllerName = values.ContainsKey("controller")
? ValidationHelper.GetString(values["controller"], "")
: "";
if (controllerName.Equals("KenticoFormWidget", StringComparison.InvariantCultureIgnoreCase))
{
return(false);
}
var page = DynamicRouteHelper.GetPage();
return(page != null && !DynamicRouteInternalHelper.UrlSlugExcludedClassNames().Contains(page.ClassName.ToLower()));
}
/// <summary>
/// Renders the View with either an ITreeNode model or the given Model Type
/// </summary>
/// <returns></returns>
public ActionResult RenderViewWithModel()
{
var node = DynamicRouteHelper.GetPage();
var routeConfig = DynamicRouteHelper.GetRouteConfiguration(node);
HttpContext.Kentico().PageBuilder().Initialize(node.DocumentID);
// Convert type
if (routeConfig.ModelType != null)
{
return(View(routeConfig.ViewName, Convert.ChangeType(node, routeConfig.ModelType)));
}
else
{
return(View(routeConfig.ViewName, node));
}
}
// GET: ShotgunWedding
public ActionResult Index()
{
ShotgunWedding Page = DynamicRouteHelper.GetPage <ShotgunWedding>();
HttpContext.Kentico().PageBuilder().Initialize(Page.DocumentID);
ShotgunWeddingViewModel model = new ShotgunWeddingViewModel()
{
ConcertTitle = Page.ConcertName
};
foreach (Guid NodeGuid in Page.Songs.Split(";".ToCharArray(), StringSplitOptions.RemoveEmptyEntries)
.Select(x => ValidationHelper.GetGuid(x, Guid.Empty)))
{
model.Songs.Add(SongProvider.GetSong(NodeGuid, LocalizationContext.CurrentCulture.CultureCode, SiteContext.CurrentSiteName));
}
return(View("NEWCC/ShotgunWedding", model));
}
/// <summary>
/// Gets the node based on the current request url and then renders the template result.
/// </summary>
public ActionResult Index(string TemplateControllerName = null)
{
ITreeNode FoundNode = DynamicRouteHelper.GetPage();
if (FoundNode != null)
{
HttpContext.Kentico().PageBuilder().Initialize(FoundNode.DocumentID);
if (!string.IsNullOrWhiteSpace(TemplateControllerName))
{
// Adjust the route data to point to the template's controller if it has one.
HttpContext.Request.RequestContext.RouteData.Values["Controller"] = TemplateControllerName;
}
return(new TemplateResult(FoundNode.DocumentID));
}
else
{
return(new HttpNotFoundResult());
}
}
/// <summary>
/// Gets the page, and based on the Class of the Page, attempts to get the Dynamic routing information and processes.
/// </summary>
/// <param name="context"></param>
public void ProcessRequest(HttpContext context)
{
var node = DynamicRouteHelper.GetPage();
var routePair = ResolveRouteValues(node);
RequestRoutingEventArgs RequestArgs = new RequestRoutingEventArgs()
{
Page = node,
Configuration = routePair,
CurrentRequestContext = RequestContext
};
// Use event to allow users to overwrite the Dynamic Routing Data
using (var RequestRoutingHandler = DynamicRoutingEvents.RequestRouting.StartEvent(RequestArgs))
{
// Setup routing with new values
RequestArgs.CurrentRequestContext.RouteData.Values["Controller"] = routePair.ControllerName;
RequestArgs.CurrentRequestContext.RouteData.Values["Action"] = routePair.ActionName;
foreach (string Key in routePair.RouteValues.Keys)
{
RequestArgs.CurrentRequestContext.RouteData.Values[Key] = routePair.RouteValues[Key];
}
// Allow users to adjust the RequestContext further
RequestRoutingHandler.FinishEvent();
// Pass back context
RequestContext = RequestArgs.CurrentRequestContext;
}
IControllerFactory factory = ControllerBuilder.Current.GetControllerFactory();
IController controller = factory.CreateController(RequestContext, routePair.ControllerName);
controller.Execute(RequestContext);
factory.ReleaseController(controller);
}
// GET: ArrangedMarriage
public ActionResult Index()
{
ArrangedMarriage Page = DynamicRouteHelper.GetPage <ArrangedMarriage>();
HttpContext.Kentico().PageBuilder().Initialize(Page.DocumentID);
ArrangedMarriageViewModel model = new ArrangedMarriageViewModel()
{
CarTitle = Page.CarName
};
// Get Tires
model.Tires = DocumentHelper.GetDocuments <CarPart>()
.Path($"{Page.NodeAliasPath}/Tires", PathTypeEnum.Children)
.OrderBy("NodeOrder")
.ToList();
model.Rims = DocumentHelper.GetDocuments <CarPart>()
.Path($"{Page.NodeAliasPath}/Rims", PathTypeEnum.Children)
.OrderBy("NodeOrder")
.ToList();
return(View("NEWCC/ArrangedMarriage", model));
}
/// <summary>
/// Rebuilds the Url Slugs affected by a class Url Pattern Change.
/// </summary>
/// <param name="ClassName"></param>
public static void ClassUrlPatternChanged(string ClassName)
{
DynamicRouteHelper.RebuildRoutesByClass(ClassName);
}
public static void CultureVariationSettingsChanged(string SiteName)
{
// Build all, update all
DynamicRouteHelper.RebuildRoutesBySite(SiteName);
}
/// <summary>
/// Returns an error message when the page is found but no DynamicRouting assembly tags were configured.
/// </summary>
/// <returns></returns>
public ActionResult RouteValuesNotFound()
{
var node = DynamicRouteHelper.GetPage();
return(Content($"<h1>No Route Value Found</h1><p>No DynamicRouting assembly tag was found for the class <strong>{node.ClassName}</strong>, could not route page {node.NodeAliasPath}</p>"));
}
/// <summary>
/// Build ParentNode, and Parent's immediate children, build the children and update recursively only if changes detected.
/// </summary>
/// <param name="NodeID"></param>
public static void DocumentInsertUpdated(int NodeID)
{
DynamicRouteHelper.RebuildRoutesByNode(NodeID);
}
/// <summary>
/// Build both ParentNodes, and Parent's immediate children, build the children and update recursively only if changes detected.
/// </summary>
/// <param name="OldParentNodeID"></param>
/// <param name="NewParentNodeID"></param>
public static void DocumentMoved(int OldParentNodeID, int NewParentNodeID)
{
DynamicRouteHelper.RebuildRoutesByNode(OldParentNodeID);
DynamicRouteHelper.RebuildRoutesByNode(NewParentNodeID);
}
/// <summary>
/// Build ParentNodes, and Parent's immediate children, build the children and update recursively only if changes detected.
/// </summary>
/// <param name="ParentNodeID"></param>
public static void DocumentDeleted(int ParentNodeID)
{
DynamicRouteHelper.RebuildRoutesByNode(ParentNodeID);
}
public static void SiteDefaultLanguageChanged(string SiteName)
{
// Build all, update all
DynamicRouteHelper.RebuildRoutesBySite(SiteName);
}
// GET: KissingCousins
public ActionResult Index()
{
// Temp
/*HeroBanners Temp = new HeroBanners();
* Temp.Banners = new List<HeroBanner>();
* Temp.Banners.Add(new HeroBanner()
* {
* Banner = new BannerHero()
* {
* Name = "Image Banner",
* AltText = "This is an image",
* ImageUrl = "https://via.placeholder.com/1200x200.png?text=First+Slide",
* Url = "http://www.devtrev.com"
* }
* });
* Temp.Banners.Add(new HeroBanner()
* {
* Banner = new CTAHero()
* {
* Name = "Call to Action Banner",
* CallToAction = "Click me!",
* BackgroundImageUrl = "https://via.placeholder.com/1200x200.png?text=Second+Slide",
* Url = "https://www.babylonbee.com"
* }
* });
* string Serialized = Newtonsoft.Json.JsonConvert.SerializeObject(Temp);
*/
KissingCousins Page = DynamicRouteHelper.GetPage <KissingCousins>();
HttpContext.Kentico().PageBuilder().Initialize(Page.DocumentID);
ViewBag.MetaData = Page.GetPageTypeComponent <Component_MetaData>("MetaData");
KissingCousinsViewModel model = new KissingCousinsViewModel()
{
PageName = Page.MenuName
};
// Pass to ViewBag
/*if(!string.IsNullOrWhiteSpace(Page.MetaData))
* {
* ViewBag.MetaData = JsonConvert.DeserializeObject<MetaDataModel>(Page.MetaData);
* }*/
if (!string.IsNullOrWhiteSpace(Page.Banners))
{
model.Banners = new List <IHeroBanner>();
dynamic data = System.Web.Helpers.Json.Decode(Page.Banners);
foreach (dynamic banner in data.Banners)
{
// Based on the type, Serialize it back to string then deserialize it into the proper object class
switch (banner.BannerType.ToLower())
{
case "bannerhero":
model.Banners.Add(JsonConvert.DeserializeObject <BannerHero>(JsonConvert.SerializeObject(banner.Banner)));
break;
case "ctahero":
model.Banners.Add(JsonConvert.DeserializeObject <CTAHero>(JsonConvert.SerializeObject(banner.Banner)));
break;
}
}
}
return(View("NEWCC/KissingCousins", model));
}
