Blog

 public async Task Index(int? year, int? month)

 @model NavigationItem
 
 
 Dancing Goat  toggle navigation   
  

 @model NavigationItem@if (Model.ChildNavigationItems == null || !Model.ChildNavigationItems.Any()){ 
@Html.DisplayFor(vm => vm.Title)
}else{ 
  @Html.DisplayFor(vm => vm.Title)   
 @foreach (var item in Model.ChildNavigationItems) { @Html.DisplayFor(vm => item, 'NavigationItemMain-2') } 
 
}

/// 
/// Gets the root  item either off of the  or the Delivery/Preview API endpoint./// 
/// The explicit codename of the root item. If , the value supplied in the constructor is taken./// The explicit maximum depth of the hierarchy to be fetched/// The root item of either the explicit codename, or default codenamepublic async Task GetNavigationAsync(string navigationCodeName = null, int? maxDepth = null){ string cn = navigationCodeName ?? _navigationCodename; int d = maxDepth ?? _maxDepth; return await _cache.GetOrCreate(NAVIGATION_CACHE_KEY, async entry => { var navigation = await LoadNavigationItemsAsync(cn, d); var emptyList = new List(); // Add the UrlPath property values to the navigation items first. AddUrlPaths(emptyList, navigation, string.Empty); emptyList.Clear(); // Then, add the RedirectPath, Parent, and AllParents property values. UrlPath value is needed for that, hence a separate iteration through the hierarchy. AddRedirectPathsAndParents(navigation, emptyList, navigation); entry.AbsoluteExpirationRelativeToNow = TimeSpan.FromMinutes(_navigationCacheExpirationMinutes); return navigation; });}

 await _navigationProvider.GetNavigationAsync()

 var navigation = await _menuItemGenerator.GenerateItemsAsync(await _navigationProvider.GetNavigationAsync());

public async Task LoadNavigationItemsAsync(string navigationCodeName = null, int? maxDepth = null){ string cn = navigationCodeName ?? _navigationCodename; int d = maxDepth ?? _maxDepth; var response = await _client.GetItemsAsync( new EqualsFilter('system.type', ITEM_TYPE), new EqualsFilter('system.codename', cn), new LimitParameter(1), new DepthParameter(d) ); return response.Items.FirstOrDefault();}private void AddUrlPaths(IList processedParents, NavigationItem currentItem, string pathStub){ if (processedParents == null) { throw new ArgumentNullException(nameof(processedParents)); } if (currentItem == null) { throw new ArgumentNullException(nameof(currentItem)); } // Check for infinite loops. if (!processedParents.Contains(currentItem)) { AddUrlPath(currentItem, pathStub); processedParents.Add(currentItem); // Spawn a tree of recursions. foreach (var currentChild in currentItem.ChildNavigationItems) { AddUrlPaths(processedParents, currentChild, currentItem.UrlPath); } }}private void AddRedirectPathsAndParents(NavigationItem cachedNavigation, IList processedParents, NavigationItem currentItem){ if (currentItem == null) { throw new ArgumentNullException(nameof(currentItem)); } // Check for infinite loops. if (!processedParents.Contains(currentItem)) { var redirect = currentItem.RedirectToItem.FirstOrDefault(); if (redirect != null) { currentItem.RedirectPath = GetRedirectPath(cachedNavigation, redirect); } currentItem.Parent = processedParents.Count > 0 ? processedParents.Last() : null; currentItem.AllParents = processedParents; processedParents.Add(currentItem); // Spawn a tree of recursions. foreach (var currentChild in currentItem.ChildNavigationItems) { AddRedirectPathsAndParents(cachedNavigation, processedParents, currentChild); } }}private void AddUrlPath(NavigationItem navigationItem, string pathStub){ if (navigationItem == null) { throw new ArgumentNullException(nameof(navigationItem)); } if (navigationItem.UrlSlug != _rootToken && navigationItem.UrlSlug != _homepageToken) { navigationItem.UrlPath = !string.IsNullOrEmpty(pathStub) ? $'{pathStub}/{navigationItem.UrlSlug}' : navigationItem.UrlSlug; } else { navigationItem.UrlPath = string.Empty; }}private string GetRedirectPath(NavigationItem cachedNavigation, NavigationItem itemToLocate){ if (cachedNavigation == null) { throw new ArgumentNullException(nameof(cachedNavigation)); } if (itemToLocate == null) { throw new ArgumentNullException(nameof(itemToLocate)); } if (cachedNavigation.UrlPath == null) { throw new ArgumentException($'The {nameof(cachedNavigation.UrlPath)} property cannot be null.', nameof(cachedNavigation.UrlPath)); } var match = cachedNavigation.ChildNavigationItems.FirstOrDefault(i => i.System.Codename == itemToLocate.System.Codename); if (match != null) { return match.UrlPath; } else { return cachedNavigation.ChildNavigationItems.Select(i => GetRedirectPath(i, itemToLocate)).FirstOrDefault(r => !string.IsNullOrEmpty(r)); }}

 private Dictionary>> _startingUrls = new Dictionary>>();

/// 
/// Wraps all methods that generate additional navigation items./// 
/// The original root navigation item/// A copy of the  with additional itemspublic async Task GenerateItemsAsync(NavigationItem sourceItem){ return await _cache.GetOrCreateAsync('generatedNavigationItems', async entry => { foreach (var url in _startingUrls) { sourceItem = await url.Value(sourceItem, url.Key); } entry.AbsoluteExpirationRelativeToNow = TimeSpan.FromMinutes(_navigationCacheExpirationMinutes); return sourceItem; });}

 /// 
/// Traverses the original hierarchy, creates a lightweight clone of it (not all original properties), and adds  items for the Blog section./// 
/// The root /// Dictionary of years and months of existing 'Article' content items/// The starting URL where new year and month  items will be added/// Flag indicating whether flat structure like 'October 2014' should be generated/// Collection of processed parent navigation items/// A copy of  with generated Blog navigation itemsprivate NavigationItem ProcessLevelForBlog(NavigationItem currentItem, IDictionary yearsMonths, string startingUrl, bool flat, IList processedParents){ processedParents = processedParents ?? new List(); var newItem = new NavigationItem(); // Check for infinite loops. if (!processedParents.Contains(currentItem)) { // Add only those properties that are needed to render the menu (as opposed to routing the incoming requests). newItem.Title = currentItem.Title; newItem.UrlPath = currentItem.UrlPath; newItem.AllParents = processedParents; processedParents.Add(currentItem); // The '/blog' item is currently being iterated over. if (currentItem.UrlPath.Equals(startingUrl, StringComparison.OrdinalIgnoreCase)) { // Example of a flat variant: 'October 2014', 'November 2014' etc. if (flat) { var items = new List(); items.AddRange(yearsMonths.OrderBy(k => k.Key, new YearMonthComparer()).Select(i => GetItem(startingUrl, i.Value, i.Key.Year, i.Key.Month))); newItem.ChildNavigationItems = items.ToList(); } // Example of a deep variant: // '2014' // '10' // '11' else { var yearItems = new List(); // Distill years of existing 'Article' items. foreach (var year in yearsMonths.Distinct(new YearEqualityComparer())) { var yearItem = GetItem(startingUrl, null, year.Key.Year); yearItems.Add(yearItem); var monthItems = new List(); // Distill months. foreach (var month in yearsMonths.Keys.Where(k => k.Year == year.Key.Year).OrderBy(k => k.Month)) { monthItems.Add(GetItem(startingUrl, null, year.Key.Year, month.Month)); } yearItem.ChildNavigationItems = monthItems; } newItem.ChildNavigationItems = yearItems; } } else { newItem.ChildNavigationItems = currentItem.ChildNavigationItems.Select(i => ProcessLevelForBlog(i, yearsMonths, startingUrl, flat, processedParents)).ToList(); } return newItem; } return null;}

 app.UseMvc(routes =>{ routes.MapRoute( name: 'facetedNavigation', template: 'blog/{year?}/{month?}', defaults: new { controller = 'Blog', action = 'Index' }); routes.MapRoute( name: 'staticContent', template: '{*urlPath}', defaults: new { controller = 'StaticContent', action = 'Index' }, constraints: new { urlPath = new StaticContentConstraint(app.ApplicationServices.GetRequiredService()) }); routes.MapRoute( name: 'default', template: '{controller=Home}/{action=Index}/{id?}');});

public async Task Index(int? year, int? month){ List filters = new List(); filters.AddRange(new IQueryParameter[] { new EqualsFilter('system.type', TYPE_NAME), new DepthParameter(0), new OrderParameter(ELEMENT_NAME) }); string yearString = null; string monthString = null; if (year.HasValue && !month.HasValue) { yearString = $'{year}-01'; monthString = $'{year + 1}-01'; } else if (year.HasValue && month.HasValue) { if (month < 12) { yearString = $'{year}-{GetMonthFormatted(month.Value)}'; monthString = $'{year}-{GetMonthFormatted(month.Value + 1)}'; } else { yearString = $'{year}-12'; monthString = $'{year + 1}-01'; } } if (year.HasValue) { filters.Add(new RangeFilter(ELEMENT_NAME, yearString, monthString)); } var pageBody = await _deliveryClient.GetItemsAsync
(filters); var navigation = await _menuItemGenerator.GenerateItemsAsync(await _navigationProvider.GetNavigationAsync()); var pageViewModel = new PageViewModel { Navigation = navigation, Body = pageBody.Items }; return View(DEFAULT_VIEW, pageViewModel);}

 using System.Collections.Generic;namespace NavigationMenusMvc.Models{ public class ContentResolverResults { public bool Found { get; set; } public IEnumerable ContentItemCodenames { get; set; } public string ViewName { get; set; } public string RedirectUrl { get; set; } }}

public async Task Index(string urlPath){ ContentResolverResults results; try { results = await _contentResolver.ResolveRelativeUrlPathAsync(urlPath); } catch (Exception ex) { return new ContentResult { Content = $'There was an error while resolving the URL. Check if your URL was correct and try again. Details: {ex.Message}', StatusCode = 500 }; } if (results != null) { if (results.Found) { if (results.ContentItemCodenames != null && results.ContentItemCodenames.Any()) { return await RenderViewAsync(results.ContentItemCodenames, results.ViewName); } else if (!string.IsNullOrEmpty(results.RedirectUrl)) { return LocalRedirectPermanent($'/{results.RedirectUrl}'); } } else if (!string.IsNullOrEmpty(results.RedirectUrl)) { return RedirectPermanent(results.RedirectUrl); } } return NotFound();}

 #region 'Public methods'/// 
/// Resolves the relative URL path into  containing either the codenames of content items, or a redirect URL./// 
/// The relative URL from the HTTP request/// The . If Found is true and the RedirectUrl isn't empty, then it means a local redirect to a static content URL.public async Task ResolveRelativeUrlPathAsync(string urlPath, string navigationCodeName = null, int? maxDepth = null){ string cn = navigationCodeName ?? _navigationCodename; int d = maxDepth ?? _maxDepth; // Get the 'Navigation' item, ideally with 'depth' set to the actual depth of the menu. var navigationItem = await _navigationProvider.GetNavigationAsync(cn, d); // Strip the trailing slash and split. string[] urlSlugs = NavigationProvider.GetUrlSlugs(urlPath); // Recursively iterate over modular content and match the URL slugs for the each recursion level. return await ProcessUrlLevelAsync(urlSlugs, navigationItem, _rootLevel);}/// 
/// Gets the codenames of  content items using ./// 
/// The shallow content items to be fetched again using their codenames/// The codenamespublic static IEnumerable GetContentItemCodenames(IEnumerable