public virtual ActionResult EditNode(string code)
{
var node = sitemapService.LoadNode(code);
if (node==null) node=new SitemapItem();
var editableNode = new SitemapItemEditModel(node);
return View("EditNode", editableNode);
}
/// <summary>
/// Tries to write out a change frequency based on the last modified date.
/// </summary>
/// <param name="url"></param>
public void Tiered_LastMod_ChangeFreq(SitemapItem url)
{
DateTime now = DateTime.Today;
var span = now - url.LastMod;
if (span.TotalDays > 30)
{
url.changefreq = "monthly";
url.priority = "0.6";
}
else if (span.TotalDays > 7)
{
url.changefreq = "weekly";
url.priority = "0.7";
}
else if (span.TotalDays > 1)
{
url.changefreq = "daily";
url.priority = "0.8";
}
else if (span.TotalHours > 1)
{
url.changefreq = "hourly";
url.priority = "0.9";
}
}
public ActionResult Products()
{
var sitemapItems = new List <SitemapItem>();
String key = String.Format("ProductSitemapItemCache-{0}", StoreId);
ProductSitemapItemCache.TryGet(key, out sitemapItems);
if (sitemapItems == null)
{
sitemapItems = new List <SitemapItem>();
var products = ProductRepository.GetProductByTypeAndCategoryIdFromCache(StoreId, StoreConstants.ProductType, -1);
var categories = ProductCategoryService.GetProductCategoriesByStoreIdFromCache(StoreId,
StoreConstants.ProductType);
foreach (var product in products)
{
var cat = categories.FirstOrDefault(r => r.Id == product.ProductCategoryId);
if (cat != null)
{
var productDetailLink = LinkHelper.GetProductIdRouteValue(product, cat.Name);
var siteMap = new SitemapItem(Url.AbsoluteAction("Product", "Products", new { id = productDetailLink }),
changeFrequency: SitemapChangeFrequency.Monthly, priority: 1.0);
sitemapItems.Add(siteMap);
}
}
ProductSitemapItemCache.Set(key, sitemapItems, MemoryCacheHelper.CacheAbsoluteExpirationPolicy(ProjectAppSettings.CacheLongSeconds));
}
return(new SitemapResult(sitemapItems));
}
/// <summary>
/// Gets Navigation Links for the context navigation panel for the given request URL path.
/// </summary>
/// <param name="requestUrlPath">The request URL path.</param>
/// <param name="localization">The Localization.</param>
/// <returns>The Navigation Links.</returns>
public NavigationLinks GetContextNavigationLinks(string requestUrlPath, Localization localization)
{
using (new Tracer(requestUrlPath, localization))
{
SitemapItem navModel = GetNavigationModel(localization);
if (!(navModel is TaxonomyNode))
{
// No Navigation Taxonomy found in this Localization; fallback to the StaticNavigationProvider.
return(_fallbackNavigationProvider.GetContextNavigationLinks(requestUrlPath, localization));
}
SitemapItem contextNode = navModel.FindSitemapItem(requestUrlPath.NormalizePageUrlPath());
if (contextNode != null && !(contextNode is TaxonomyNode))
{
contextNode = contextNode.Parent;
}
List <Link> links = new List <Link>();
if (contextNode != null)
{
links.AddRange(contextNode.Items.Where(i => i.Visible).Select(i => i.CreateLink(localization)));
}
return(new NavigationLinks
{
Items = links
});
}
}
public async Task <ActionResult> Brands()
{
var sitemapItems = new List <SitemapItem>();
String key = String.Format("BrandsSiteMap-{0}", StoreId);
ProductSitemapItemCache.TryGet(key, out sitemapItems);
if (sitemapItems == null)
{
sitemapItems = new List <SitemapItem>();
var brandsTask = BrandService.GetBrandsAsync(StoreId, null, true);
await Task.WhenAll(brandsTask);
var brands = brandsTask.Result;
foreach (var brand in brands)
{
var brandDetailLink = LinkHelper.GetBrandIdRouteValue(brand);
var siteMap = new SitemapItem(Url.AbsoluteAction("detail", "brands", new { id = brandDetailLink }),
changeFrequency: SitemapChangeFrequency.Monthly, priority: 1.0);
sitemapItems.Add(siteMap);
}
ProductSitemapItemCache.Set(key, sitemapItems, MemoryCacheHelper.CacheAbsoluteExpirationPolicy(ProjectAppSettings.CacheLongSeconds));
}
return(new SitemapResult(sitemapItems));
}
/// <summary>
/// Gets Navigation Links for the context navigation panel for the given request URL path.
/// </summary>
/// <param name="requestUrlPath">The request URL path.</param>
/// <param name="localization">The Localization.</param>
/// <returns>The Navigation Links.</returns>
public virtual NavigationLinks GetContextNavigationLinks(string requestUrlPath, Localization localization)
{
using (new Tracer(requestUrlPath, localization))
{
NavigationLinks navigationLinks = new NavigationLinks();
SitemapItem sitemapItem = GetNavigationModel(localization); // Start with Sitemap root Item.
int levels = requestUrlPath.Split('/').Length;
while (levels > 1 && sitemapItem.Items != null)
{
SitemapItem newParent = sitemapItem.Items.FirstOrDefault(i => i.Type == "StructureGroup" && requestUrlPath.StartsWith(i.Url, StringComparison.InvariantCultureIgnoreCase));
if (newParent == null)
{
break;
}
sitemapItem = newParent;
}
if (sitemapItem != null && sitemapItem.Items != null)
{
foreach (SitemapItem item in sitemapItem.Items.Where(i => i.Visible))
{
navigationLinks.Items.Add(CreateLink(item));
}
}
return(navigationLinks);
}
}
//
// GET: /Sitemap/
public ActionResult Index()
{
var sitemapItems = new List <SitemapItem>();
var siteMap = new SitemapItem(Url.QualifiedAction("index", "home"),
changeFrequency: SitemapChangeFrequency.Monthly, priority: 1.0);
sitemapItems.Add(siteMap);
siteMap = new SitemapItem(Url.QualifiedAction("index", "brands"),
changeFrequency: SitemapChangeFrequency.Monthly, priority: 1.0);
sitemapItems.Add(siteMap);
siteMap = new SitemapItem(Url.QualifiedAction("index", "retailers"),
changeFrequency: SitemapChangeFrequency.Monthly, priority: 1.0);
sitemapItems.Add(siteMap);
siteMap = new SitemapItem(Url.QualifiedAction("index", "productcategories"),
changeFrequency: SitemapChangeFrequency.Monthly, priority: 1.0);
sitemapItems.Add(siteMap);
siteMap = new SitemapItem(Url.QualifiedAction("index", "news"),
changeFrequency: SitemapChangeFrequency.Monthly, priority: 1.0);
sitemapItems.Add(siteMap);
siteMap = new SitemapItem(Url.QualifiedAction("index", "blogs"),
changeFrequency: SitemapChangeFrequency.Monthly, priority: 1.0);
sitemapItems.Add(siteMap);
siteMap = new SitemapItem(Url.QualifiedAction("index", "photogallery"),
changeFrequency: SitemapChangeFrequency.Monthly, priority: 1.0);
sitemapItems.Add(siteMap);
return(new SitemapResult(sitemapItems));
}
/// <summary>
/// Gets Navigation Links for the context navigation panel for the given request URL path.
/// </summary>
/// <param name="requestUrlPath">The request URL path.</param>
/// <param name="localization">The Localization.</param>
/// <returns>The Navigation Links.</returns>
public NavigationLinks GetContextNavigationLinks(string requestUrlPath, Localization localization)
{
using (new Tracer(requestUrlPath, localization))
{
var navModel = GetNavigationModel(localization);
if (navModel == null)
{
return(null);
}
return(SiteConfiguration.CacheProvider.GetOrAdd(
$"GetContextNavigationLinks:{requestUrlPath}-{localization.Id}",
CacheRegions.DynamicNavigation,
() =>
{
SitemapItem contextNode = navModel.FindSitemapItem(requestUrlPath.NormalizePageUrlPath());
if (contextNode != null && !(contextNode is TaxonomyNode))
{
contextNode = contextNode.Parent;
}
List <Link> links = new List <Link>();
if (contextNode != null)
{
links.AddRange(
contextNode.Items.Where(i => i.Visible).Select(i => i.CreateLink(localization)));
}
return new NavigationLinks
{
Items = links
};
}));
}
}
private PageListModel.PageItem MapRecursive(Guid siteId, SitemapItem item, int level, int expandedLevels, IEnumerable <Guid> drafts)
{
var model = new PageListModel.PageItem
{
Id = item.Id,
SiteId = siteId,
Title = item.MenuTitle,
TypeName = item.PageTypeName,
Published = item.Published.HasValue ? item.Published.Value.ToString("yyyy-MM-dd") : null,
Status = drafts.Contains(item.Id) ? _localizer.General[PageListModel.PageItem.Draft] :
!item.Published.HasValue ? _localizer.General[PageListModel.PageItem.Unpublished] : "",
EditUrl = "manager/page/edit/",
IsExpanded = level < expandedLevels,
IsCopy = item.OriginalPageId.HasValue,
IsRestricted = item.Permissions.Count > 0,
IsScheduled = item.Published.HasValue && item.Published.Value > DateTime.Now,
IsUnpublished = !item.Published.HasValue,
Permalink = item.Permalink
};
foreach (var child in item.Items)
{
model.Items.Add(MapRecursive(siteId, child, level + 1, expandedLevels, drafts));
}
return(model);
}
public void GetNavigationSubtree_FullTaxonomies_Success()
{
NavigationFilter testNavFilter = new NavigationFilter {
DescendantLevels = -1
};
SitemapItem[] taxonomyRoots = _testOnDemandNavigationProvider.GetNavigationSubtree(null, testNavFilter, TestFixture.ParentLocalization).ToArray();
Assert.IsNotNull(taxonomyRoots, "taxonomyRoots");
OutputJson(taxonomyRoots);
TaxonomyNode testTaxonomyRoot = GetTestTaxonomy(taxonomyRoots);
Assert.IsNotNull(testTaxonomyRoot.Items, "testTaxonomyRoot.Items");
Assert.AreEqual(2, testTaxonomyRoot.Items.Count, "testTaxonomyRoot.Items.Count");
SitemapItem topLevelKeyword1 = testTaxonomyRoot.Items.FirstOrDefault(i => i.Title == TestFixture.TopLevelKeyword1Title);
Assert.IsNotNull(topLevelKeyword1, "topLevelKeyword1");
SitemapItem keyword11 = topLevelKeyword1.Items.FirstOrDefault(i => i.Title == TestFixture.Keyword1_1Title);
Assert.IsNotNull(keyword11, "keyword11");
SitemapItem keyword112 = keyword11.Items.FirstOrDefault(i => i.Title == "Keyword 1.1.2");
Assert.IsNotNull(keyword112, "keyword112");
Assert.IsNotNull(keyword112.Items, "keyword112.Items");
Assert.AreEqual(1, keyword112.Items.Count, "keyword112.Items.Count");
}
/// <summary>
/// Gets Navigation Links for the context navigation panel for the given request URL path.
/// </summary>
/// <param name="requestUrlPath">The request URL path.</param>
/// <param name="localization">The Localization.</param>
/// <returns>The Navigation Links.</returns>
public virtual NavigationLinks GetContextNavigationLinks(string requestUrlPath, Localization localization)
{
using (new Tracer(requestUrlPath, localization))
{
// Find the context Sitemap Item; start with Sitemap root.
SitemapItem contextSitemapItem = GetNavigationModel(localization);
if (requestUrlPath.Contains("/"))
{
while (contextSitemapItem.Items != null)
{
SitemapItem matchingChildSg = contextSitemapItem.Items.FirstOrDefault(i => i.Type == SitemapItem.Types.StructureGroup && requestUrlPath.StartsWith(i.Url, StringComparison.InvariantCultureIgnoreCase));
if (matchingChildSg == null)
{
// No matching child SG found => current contextSitemapItem reflects the context SG.
break;
}
contextSitemapItem = matchingChildSg;
}
}
if (contextSitemapItem.Items == null)
{
throw new DxaException($"Context SitemapItem has no child items: {contextSitemapItem}");
}
return(new NavigationLinks
{
Items = contextSitemapItem.Items.Where(i => i.Visible).Select(i => i.CreateLink(localization)).ToList()
});
}
}
public SitemapPipeline()
{
Dependencies.AddRange(nameof(HomePipeline), nameof(PortfolioPages), nameof(ResumePages));
ProcessModules = new ModuleList {
new ReplaceDocuments(Dependencies.ToArray()),
new SetMetadata(Keys.SitemapItem, Config.FromDocument((doc, _) =>
{
var siteMapItem = new SitemapItem(doc.Destination.FullPath)
{
LastModUtc = doc.Get <DateTime?>(ContentfulKeys.System.UpdatedAt, null)
};
if (!siteMapItem.LastModUtc.HasValue)
{
siteMapItem.LastModUtc = DateTime.UtcNow;
siteMapItem.ChangeFrequency = SitemapChangeFrequency.Weekly;
}
else
{
siteMapItem.ChangeFrequency = SitemapChangeFrequency.Monthly;
}
return(siteMapItem);
})),
new GenerateSitemap(),
};
OutputModules = new ModuleList {
new WriteFiles(),
};
}
/// <summary>
/// Gets Navigation Links for the breadcrumb trail for the given request URL path.
/// </summary>
/// <param name="requestUrlPath">The request URL path.</param>
/// <param name="localization">The Localization.</param>
/// <returns>The Navigation Links.</returns>
public virtual NavigationLinks GetBreadcrumbNavigationLinks(string requestUrlPath, Localization localization)
{
using (new Tracer(requestUrlPath, localization))
{
int levels = requestUrlPath.Split('/').Length;
SitemapItem currentItem = GetNavigationModel(localization); // Start with Sitemap root.
List <Link> links = new List <Link> {
currentItem.CreateLink(localization)
};
while (levels > 1 && currentItem.Items != null)
{
currentItem = currentItem.Items.FirstOrDefault(i => requestUrlPath.StartsWith(i.Url, StringComparison.InvariantCultureIgnoreCase));
if (currentItem == null)
{
break;
}
links.Add(currentItem.CreateLink(localization));
levels--;
}
return(new NavigationLinks
{
Items = links
});
}
}
private static Url BuildUrl(List <Link> links, SitemapItem sitemapItem, bool languageFallbackEnabled)
{
var matchedItem = links.FirstOrDefault(link => link.Item == sitemapItem.Item);
if (matchedItem == null)
{
Logger.Warn(
$"Unable to retrieve item from alternate links: {sitemapItem.Item.Paths.FullPath}, language: {sitemapItem.Item.Language.Name}");
return(null);
}
var loc = matchedItem.Href;
var sitemapGetModifiedDateArgs = new SitemapGetModifiedDateArgs(sitemapItem.Item, DateTime.MinValue, languageFallbackEnabled);
CorePipeline.Run("sitemap.GetModifiedDate", sitemapGetModifiedDateArgs);
var lastmod = sitemapGetModifiedDateArgs.LastModified;
if (lastmod == DateTime.MinValue)
{
Logger.Warn(
$"No modified date found for item: {sitemapItem.Item.Paths.FullPath}, language: {sitemapItem.Item.Language.Name}");
return(null);
}
var url = new Url
{
Loc = loc,
Lastmod = lastmod.ToString("yyyy-MM-dd"),
Link = links
};
return(url);
}
private XElement CreateItemElement(SitemapItem item)
{
XElement itemElement = new XElement(nsSitemap + "siteMapNode", new XElement(nsSitemap + "loc", item.Url.ToLower()));
if (item.LastModified.HasValue)
{
itemElement.Add(new XElement(nsSitemap + "lastmod", item.LastModified.Value.ToString("yyyy-MM-dd")));
}
if (item.ChangeFrequency.HasValue)
{
itemElement.Add(new XElement(nsSitemap + "changefreq", item.ChangeFrequency.Value.ToString().ToLower()));
}
if (item.Priority.HasValue)
{
itemElement.Add(new XElement(nsSitemap + "priority", item.Priority.Value.ToString(CultureInfo.InvariantCulture)));
}
foreach (var alternateLink in item.AlternateLinks)
{
itemElement.Add(new XElement(nsXhtml + "link",
new XAttribute("rel", "alternate"),
new XAttribute("hreflang", alternateLink.Language),
new XAttribute("href", alternateLink.Url)));
}
return(itemElement);
}
/// <summary>
/// Retrieves a rendered HTML site map
/// </summary>
/// <param name="entity">The sitemap entity</param>
/// <returns>Rendered site map HTML.</returns>
public virtual ActionResult SiteMap(SitemapItem entity)
{
SitemapItem model = SiteConfiguration.NavigationProvider.GetNavigationModel(WebRequestContext.Localization);
SetupViewData(entity);
return(View(entity.MvcData.ViewName, model));
}
private List <SitemapItem> GetArchiveItems(Guid id, int level)
{
var model = new List <SitemapItem>();
var posts = api.Posts.GetAll(id).Where(p => p.Published <= DateTime.Now).ToList();
for (int i = 0; i < posts.Count; i++)
{
DynamicPost item = posts[i];
var smItem = new SitemapItem
{
ParentId = id,
SortOrder = i,
Title = item.Title,
NavigationTitle = item.Title,
PageTypeName = item.TypeId,
Permalink = item.Permalink,
Published = item.Published,
Created = item.Created,
LastModified = item.LastModified,
Id = item.Id,
Level = level + 1
};
model.Add(smItem);
}
return(model);
}
public virtual void AssignMeta(SitemapItem url, UrlMetaEntry defaultEntry, UrlMetaEntry overrideEntry)
{
//url.priority = LmUtil.EmptyFallback(url.Asset.Raw["xmlsm_priority"], url.Asset.Raw[SitemapConstants.FieldNames.Sitemap_Priority], "");
url.priority = url.Asset.Raw[SitemapConstants.FieldNames.Sitemap_Priority];
if (string.IsNullOrEmpty(url.priority))
{
if (defaultEntry != null && defaultEntry.Meta != null)
{
url.priority = defaultEntry.Meta.priority.ToString("0.0");
}
}
if (overrideEntry != null && overrideEntry.Meta != null)
{
url.priority = overrideEntry.Meta.priority.ToString("0.0");
}
//url.changefreq = LmUtil.EmptyFallback(url.Asset.Raw["xmlsm_changefreq"], url.Asset.Raw[SitemapConstants.FieldNames.Sitemap_ChangeFrequency], "");
url.changefreq = url.Asset.Raw[SitemapConstants.FieldNames.Sitemap_ChangeFreq];
if (string.IsNullOrEmpty(url.changefreq))
{
if (defaultEntry != null && defaultEntry.Meta != null)
{
url.changefreq = defaultEntry.Meta.changefreq;
}
}
if (overrideEntry != null && overrideEntry.Meta != null)
{
url.changefreq = overrideEntry.Meta.changefreq ?? "unspecified";
}
}
private static void FixupSitemapRecursive(List <SitemapItem> toc, bool removePageNodes, bool orderNodes)
{
if (toc == null)
{
return;
}
for (int i = 0; i < toc.Count; i++)
{
SitemapItem entry = toc[i];
if (removePageNodes && entry.Type == "Page")
{
toc.RemoveAt(i);
i--;
continue;
}
if (entry.Url != null)
{
// Note the / prefix is important here otherwise the react UI will fail since it splits on / chars.
entry.Url = $"/{entry.Url.TrimStart('/')}";
}
if (entry.Items == null)
{
continue;
}
if (orderNodes)
{
entry.Items = SortSitemapItems(entry.Items);
}
FixupSitemap(entry.Items, removePageNodes, orderNodes);
}
}
/// <summary>
/// Retrieves a Google XML site map
/// </summary>
/// <returns>Google site map XML.</returns>
public virtual ActionResult SiteMapXml()
{
using (new Tracer())
{
SitemapItem model = SiteConfiguration.NavigationProvider.GetNavigationModel(WebRequestContext.Localization);
return(View("SiteMapXml", model));
}
}
/// <summary>
/// Retrieves a JSON site map
/// </summary>
/// <returns>Site map JSON.</returns>
public virtual ActionResult SiteMapJson()
{
using (new Tracer())
{
SitemapItem model = SiteConfiguration.NavigationProvider.GetNavigationModel(WebRequestContext.Localization);
return(Json(model, JsonRequestBehavior.AllowGet));
}
}
/// <summary>
/// Generates a local url for the given sitemap item.
/// </summary>
/// <param name="app">The application service</param>
/// <param name="item">The sitemap item</param>
/// <returns>The url</returns>
public static string Url(this IApplicationService app, SitemapItem item)
{
if (item != null)
{
return(Url(app, item.Permalink));
}
return("");
}
private static void AssertProperSitemapItemForPage(SitemapItem pageSitemapItem, string subject)
{
StringAssert.Matches(pageSitemapItem.Id, new Regex(@"t\d+-p\d+"), subject + ".Id");
Assert.AreEqual(SitemapItem.Types.Page, pageSitemapItem.Type, subject + ".Type");
Assert.IsNotNull(pageSitemapItem.Title, subject + ".Title");
Assert.IsNotNull(pageSitemapItem.Url, subject + ".Url");
Assert.IsNotNull(pageSitemapItem.PublishedDate, subject + ".PublishedDate");
Assert.IsTrue(pageSitemapItem.Visible, subject + ".Visible");
}
public void AddNode(SitemapItem item)
{
_articleDbContext.SitemapItems.Add(new SitemapItem()
{
Code = item.Code,
ParentCode = item.ParentCode,
SortOrder = item.SortOrder
});
}
public SitemapItemEditModel(SitemapItem item)
{
Code = item.Code;
ParentCode = item.ParentCode;
SortOrder = item.SortOrder;
Layout = item.Layout;
RenderOptions = item.RenderOptions;
RedirectToUrl = item.RedirectToUrl;
Category = item.Category;
}
public void TestBasicCreatePriorityMinMax()
{
var testUri = new Uri("http://example.com");
var item1 = new SitemapItem(testUri, null, null, 0.0);
Assert.Equal(0.0, item1.Priority.Value);
var item2 = new SitemapItem(testUri, null, null, 1.0);
Assert.Equal(1.0, item2.Priority.Value);
}
public void UpdateSiteItem(ref SitemapItem item)
{
item.Layout = Layout;
item.RedirectToUrl = RedirectToUrl;
item.RenderOptions = RenderOptions;
item.Category = Category;
// update also un-editable members
item.Code = Code;
item.ParentCode = ParentCode;
item.SortOrder = SortOrder;
}
public void TestBasicCreate1()
{
var testUri = new Uri("http://example.com");
var item = new SitemapItem(new Uri("http://example.com"));
Assert.NotNull(item);
Assert.Equal(testUri.AbsoluteUri, item.Location.AbsoluteUri);
Assert.False(item.LastModified.HasValue);
Assert.False(item.ChangeFrequency.HasValue);
Assert.False(item.Priority.HasValue);
}
/// <summary>
/// Gets Navigation Links for the top navigation menu for the given request URL path.
/// </summary>
/// <param name="requestUrlPath">The request URL path.</param>
/// <param name="localization">The Localization.</param>
/// <returns>The Navigation Links.</returns>
public virtual NavigationLinks GetTopNavigationLinks(string requestUrlPath, Localization localization)
{
using (new Tracer(requestUrlPath, localization))
{
SitemapItem sitemapRoot = GetNavigationModel(localization);
return(new NavigationLinks
{
Items = sitemapRoot.Items.Where(i => i.Visible).Select(i => RewriteIndexPage(i, sitemapRoot).CreateLink(localization)).ToList()
});
}
}
/// <summary>
/// Convert empty URL into a null value for the given <see cref="SitemapItem"/> and its decendants.
/// </summary>
private void NullifyEmptyUrl(SitemapItem sitemapItem)
{
if (sitemapItem.Url == string.Empty)
{
sitemapItem.Url = null;
}
foreach (SitemapItem childItem in sitemapItem.Items)
{
NullifyEmptyUrl(childItem);
}
}
public XDocument GetSitemapXML(string siteDomain, Sitemap model)
{
var posts = context.Content.Where(c => c.Type.ToLower() == "post" && c.IsDeleted == false && c.isPublished == true).ToList();
var pages = context.Content.Where(c => c.Type.ToLower() == "page" && c.IsDeleted == false && c.isPublished == true).ToList();
var categories = context.Category.Where(c => c.IsDeleted == false).ToList();
var tags = context.Label.Where(c => c.IsDeleted == false).ToList();
var items = new List <SitemapItem>();
var homeTag = new SitemapItem(siteDomain + "home/index", DateTime.UtcNow, NITASA.Areas.Admin.Helper.Sitemap.SitemapChangeFrequency.Daily, 1.0);
items.Add(homeTag);
foreach (var post in posts)
{
items.Add(new SitemapItem(
(siteDomain + "content/" + post.URL),
(post.ModifiedOn.HasValue ? post.ModifiedOn.Value : (DateTime?)null),
(model.postFreqency.HasValue ? model.postFreqency.Value : SitemapChangeFrequency.Never),
(model.postPriority.HasValue?model.postPriority.Value:1)));
}
foreach (var page in pages)
{
items.Add(new SitemapItem(
(siteDomain + "content/" + page.URL),
(page.ModifiedOn.HasValue ? page.ModifiedOn.Value : (DateTime?)null),
(model.postFreqency.HasValue ? model.postFreqency.Value : SitemapChangeFrequency.Monthly),
(model.postPriority.HasValue ? model.postPriority.Value : 1)));
}
foreach (var cat in categories)
{
items.Add(new SitemapItem(
(siteDomain + "category/" + cat.Slug),
(cat.ModifiedOn.HasValue ? cat.ModifiedOn.Value : (DateTime?)null),
(model.postFreqency.HasValue ? model.postFreqency.Value : SitemapChangeFrequency.Monthly),
(model.postPriority.HasValue ? model.postPriority.Value : 1)));
}
foreach (var tag in tags)
{
items.Add(new SitemapItem(
(siteDomain + "label/" + tag.Slug),
(tag.ModifiedOn.HasValue ? tag.ModifiedOn.Value : (DateTime?)null),
(model.postFreqency.HasValue ? model.postFreqency.Value : SitemapChangeFrequency.Monthly),
(model.postPriority.HasValue ? model.postPriority.Value : 1)));
}
SitemapGenerator generator = new SitemapGenerator();
var file = generator.GenerateSiteMap(items);
return(file);
}
public void TestBasicCreateBadPriority()
{
var testUri = new Uri("http://example.com");
var lastModified = DateTime.UtcNow;
Assert.Throws <ArgumentOutOfRangeException>(() => new SitemapItem(testUri, lastModified, SitemapChangeFrequency.Hourly, -0.5));
Assert.Throws <ArgumentOutOfRangeException>(() => new SitemapItem(testUri, lastModified, SitemapChangeFrequency.Hourly, 1.5));
var item1 = new SitemapItem(testUri, null, null, 0.0);
Assert.Equal(0.0, item1.Priority.Value);
}
public void Transform(Engine engine, Package package)
{
_engine = engine;
_package = package;
_config = GetNavigationConfiguration(GetComponent());
SitemapItem sitemap = GenerateStructureGroupNavigation(Publication.RootStructureGroup);
string sitemapJson = JsonSerialize(sitemap);
package.PushItem(Package.OutputName, package.CreateStringItem(ContentType.Text, sitemapJson));
}
internal static SitemapItem Convert(ISitemapItem item)
{
if (item == null)
{
return(null);
}
SitemapItem result = null;
if (item is TaxonomySitemapItem)
{
result = new TaxonomyNode();
}
else if (item is PageSitemapItem)
{
result = new SitemapItem();
}
result.Type = item.Type;
result.Title = item.Title;
result.Id = item.Id;
result.OriginalTitle = item.OriginalTitle;
if (item.Visible.HasValue)
{
result.Visible = item.Visible.Value;
}
if (item.PublishedDate != null)
{
result.PublishedDate = DateTime.ParseExact(item.PublishedDate, "MM/dd/yyyy HH:mm:ss", null);
}
result.Url = item.Url;
if (!(item is TaxonomySitemapItem))
{
return(result);
}
TaxonomySitemapItem tsi = (TaxonomySitemapItem)item;
TaxonomyNode node = (TaxonomyNode)result;
node.Key = tsi.Key;
node.ClassifiedItemsCount = tsi.ClassifiedItemsCount ?? 0;
node.Description = tsi.Description;
node.HasChildNodes = tsi.HasChildNodes.HasValue && tsi.HasChildNodes.Value;
node.IsAbstract = tsi.Abstract.HasValue && tsi.Abstract.Value;
if (tsi.Items == null || tsi.Items.Count <= 0)
{
return(result);
}
foreach (var x in tsi.Items)
{
result.Items.Add(Convert(x));
}
return(result);
}
public virtual ActionResult SaveNode(SitemapItemEditModel editedNode)
{
var node = sitemapService.LoadNode(editedNode.Code);
if (node != null)
{
editedNode.UpdateSiteItem(ref node);
sitemapService.SaveNode(node);
}
else
{
// create new node
node = new SitemapItem();
editedNode.UpdateSiteItem(ref node);
sitemapService.AddNode(node);
}
return Redirect("~/closewin.html");
}
public void SaveNode(SitemapItem item)
{
SitemapItem node = _sitemapRepository.LoadNode(item.Code);
if (node != null)
{
node.ParentCode = item.ParentCode;
node.SortOrder = item.SortOrder;
node.Layout = item.Layout;
node.RedirectToUrl = item.RedirectToUrl;
node.RenderOptions = item.RenderOptions;
_sitemapRepository.SaveChanges();
}
}
public void AddNode(SitemapItem node)
{
_sitemapRepository.AddNode(node);
_sitemapRepository.SaveChanges();
}
private void deleteNodeRecursive(SitemapItem root)
{
var children = _articleDbContext.SitemapItems.Where(i => i.ParentCode == root.Code).ToList();
foreach (var child in children)
{
deleteNodeRecursive(child);
_articleDbContext.SitemapItems.Remove(child);
}
_articleDbContext.SitemapItems.Remove(root);
}
private void loadChildren(TreeNode<SitemapItem> root)
{
List<SitemapItem> items =
_articleDbContext.SitemapItems.Where(i => i.ParentCode == root.Data.Code)
.OrderBy(i => i.SortOrder)
.ThenBy(i => i.Code).ToList();
foreach (SitemapItem sitemapItem in items)
{
var child = new SitemapItem(sitemapItem);
loadChildren(root.AddChild(child));
}
}
