protected void GenerateSiteMapIndexFile(SiteMapOptions options, int nFiles, bool compressed)
{
sitemapindex smIndex = new sitemapindex();
sitemap smap;
List <sitemap> smapList = new List <sitemap>();
for (int i = 1; i <= nFiles; i++)
{
smap = new sitemap();
if (compressed)
{
smap.loc = GetAbsoluteUrl("~/" + "SiteMap" + i + ".xml.gz");
}
else
{
smap.loc = GetAbsoluteUrl("~/" + "SiteMap" + i + ".xml");
}
smap.lastmod = LocaleHelper.LocalNow.ToString("yyyy-MM-ddTHH:mm:sszzzzzz");
smapList.Add(smap);
}
smIndex.sitemap = smapList.ToArray();
string fileData = XmlUtility.Utf8BytesToString(XmlUtility.Serialize(smIndex));
string fileName = Path.Combine(options.SiteMapDataPath, "SiteMapIndex.xml");
StreamWriter SiteMapIndexWriter = File.CreateText(fileName);
using (SiteMapIndexWriter)
{
SiteMapIndexWriter.Write(fileData);
SiteMapIndexWriter.Flush();
SiteMapIndexWriter.Close();
}
}
public IEnumerable <SitemapNode> GetSiteMapUrlSet(SiteMapOptions Options)
{
// Clean up
Options.Path = DataHelper.GetNotEmpty(Options.Path, "/").Replace("%", "");
Options.SiteName = DataHelper.GetNotEmpty(Options.SiteName, SiteContext.CurrentSiteName);
List <SitemapNode> Nodes = new List <SitemapNode>();
if (Options.ClassNames != null && Options.ClassNames.Count() > 0)
{
foreach (string ClassName in Options.ClassNames)
{
if (string.IsNullOrWhiteSpace(Options.UrlColumnName))
{
Nodes.AddRange(_Helper.GetSiteMapUrlSetForClass(Options.Path, ClassName, Options.SiteName, Options));
}
else
{
// Since it's not the specific node, but the page found at that url that we need, we will first get the urls, then cache on getting those items.
Nodes.AddRange(GetSiteMapUrlSetForClassWithUrlColumn(Options.Path, ClassName, Options.SiteName, Options));
}
}
}
else
{
Nodes.AddRange(_Helper.GetSiteMapUrlSetForAllClass(Options.Path, Options.SiteName, Options));
}
// Clean up, remove any that are not a URL
Nodes.RemoveAll(x => !Uri.IsWellFormedUriString(x.Url, UriKind.Absolute));
return(Nodes);
}
private List <SiteMapUrl> GetSiteMapItems(SiteMapOptions options)
{
List <SiteMapUrl> siteMapItems = new List <SiteMapUrl>();
//first get the ASP.NET SiteMap nodes
System.Web.SiteMapNode rootNode = System.Web.SiteMap.RootNode;
//PopulateAspNetSiteMapUrls(siteMapItems, rootNode, options);
if (options.IncludeCategories)
{
PopulateCategoryUrls(siteMapItems, options);
}
if (options.IncludeProducts)
{
PopulateProductUrls(siteMapItems, options);
}
if (options.IncludeWebpages)
{
PopulateWebpageUrls(siteMapItems, options);
}
return(siteMapItems);
}
public DocumentQuery GetDocumentQuery(string Path, SiteMapOptions Options, string ClassName = null)
{
var DocumentQuery = (string.IsNullOrWhiteSpace(ClassName) ? new DocumentQuery() : new DocumentQuery(ClassName));
DocumentQuery
.Path(Path, PathTypeEnum.Section)
.Culture(DataHelper.GetNotEmpty(Options.CultureCode, _repoContext.CurrentCulture()))
.OnSite(Options.SiteName)
.Published(Options.SelectOnlyPublished);
if (Options.CheckDocumentPermissions.HasValue)
{
DocumentQuery.CheckPermissions(Options.CheckDocumentPermissions.Value);
}
if (Options.CombineWithDefaultCulture.HasValue)
{
DocumentQuery.CombineWithDefaultCulture(Options.CombineWithDefaultCulture.Value);
}
if (Options.MaxRelativeLevel > -1)
{
// Get the nesting level of the give path
IKenticoSiteMapRepositoryHelper _CachableSelfHelper = (IKenticoSiteMapRepositoryHelper)_serviceProvider.GetService(typeof(IKenticoNavigationRepositoryHelper));
DocumentQuery.NestingLevel(Options.MaxRelativeLevel + _CachableSelfHelper.GetNodeLevel(Path, Options.SiteName));
}
if (!string.IsNullOrWhiteSpace(Options.WhereCondition))
{
DocumentQuery.Where(Options.WhereCondition);
}
return(DocumentQuery);
}
protected void GenerateButton_Click(object sender, EventArgs e)
{
// save the configured options
SiteMapOptions options = new SiteMapOptions();
options.Load(new CommonSiteMapOptionKeys());
string sitemapPath = SitemapPath.Text;
if (!string.IsNullOrEmpty(sitemapPath))
{
string newPath = Path.Combine(Request.MapPath("~/"), sitemapPath);
if (!Directory.Exists(newPath))
{
Directory.CreateDirectory(newPath);
}
options.SiteMapDataPath = newPath;
}
else
{
options.SiteMapDataPath = Request.MapPath("~/");
}
options.SiteMapFileName = "SiteMap.xml";
options.OverwriteSiteMapFile = true;
options.IncludeCategories = IndexItems.Items[0].Selected;
options.IncludeProducts = IndexItems.Items[1].Selected;
options.IncludeWebpages = IndexItems.Items[2].Selected;
options.CompressedSiteMapFileName = "SiteMap.xml.gz";
options.OverwriteCompressedFile = true;
options.DefaultUrlPriority = 0.5M;
options.DefaultChangeFrequency = (changefreq)Enum.Parse(typeof(changefreq), ChangeFrequency.SelectedValue);
options.Save(new CommonSiteMapOptionKeys());
// generate the map
List <string> messages = new List <string>();
CommonSiteMapProvider provider = new CommonSiteMapProvider();
bool success;
if (UseCompression.Checked)
{
success = provider.CreateAndCompressSiteMap(options, ref messages);
}
else
{
success = provider.CreateSiteMap(options, ref messages);
}
// report the outcome
if (success)
{
SuccessMessage.Visible = true;
SuccessMessage.Text = GetMessageLiteral(messages);
}
else
{
FailureMessage.Visible = true;
FailureMessage.Text = GetMessageLiteral(messages);
}
}
private void PopulateWebpageUrls(List <SiteMapUrl> siteMapItems, SiteMapOptions options)
{
Store store = AbleContext.Current.Store;
if (store == null)
{
return;
}
string url;
foreach (Webpage wp in store.Webpages)
{
if (wp.WebpageType == WebpageType.Content && wp.Visibility == CatalogVisibility.Public)
{
url = UrlGenerator.GetBrowseUrl(wp.Id, CatalogNodeType.Webpage, wp.Name);
siteMapItems.Add(new SiteMapUrl(GetAbsoluteUrl(url), options.DefaultChangeFrequency, options.DefaultUrlPriority));
}
}
}
private void PopulateProductUrls(List <SiteMapUrl> siteMapItems, SiteMapOptions options)
{
Store store = AbleContext.Current.Store;
if (store == null)
{
return;
}
string url;
foreach (Product prod in store.Products)
{
if (prod.Visibility == CatalogVisibility.Public)
{
url = UrlGenerator.GetBrowseUrl(prod.Id, CatalogNodeType.Product, prod.Name);
siteMapItems.Add(new SiteMapUrl(GetAbsoluteUrl(url), options.DefaultChangeFrequency, options.DefaultUrlPriority));
}
}
}
public DocumentQuery GetDocumentQuery(string Path, SiteMapOptions Options, string ClassName = null)
{
List <string> Columns = new List <string>(new string[] {
"NodeSiteID", "NodeAliasPath", "DocumentUrlPath", "DocumentCulture", "DocumentModifiedWhen", "NodeID"
});
if (!string.IsNullOrWhiteSpace(Options.UrlColumnName))
{
Columns.Add(Options.UrlColumnName);
}
var DocumentQuery = (string.IsNullOrWhiteSpace(ClassName) ? new DocumentQuery() : new DocumentQuery(ClassName));
DocumentQuery
.Path(Path, PathTypeEnum.Section)
.Culture(DataHelper.GetNotEmpty(Options.CultureCode, cultureName))
.OnSite(Options.SiteName)
.Published(Options.SelectOnlyPublished)
.Columns(Columns);
if (Options.CheckDocumentPermissions.HasValue)
{
DocumentQuery.CheckPermissions(Options.CheckDocumentPermissions.Value);
}
if (Options.CombineWithDefaultCulture.HasValue)
{
DocumentQuery.CombineWithDefaultCulture(Options.CombineWithDefaultCulture.Value);
}
if (Options.MaxRelativeLevel > -1)
{
// Get the nesting level of the give path
DocumentQuery.NestingLevel(Options.MaxRelativeLevel + DependencyResolver.Current.GetService <IKenticoSiteMapRepositoryHelper>().GetNodeLevel(Path, Options.SiteName));
}
if (!string.IsNullOrWhiteSpace(Options.WhereCondition))
{
DocumentQuery.Where(Options.WhereCondition);
}
return(DocumentQuery);
}
protected void Page_Load(object sender, EventArgs e)
{
if (!Page.IsPostBack)
{
// initialize form
SiteMapOptions options = new SiteMapOptions();
options.Load(new CommonSiteMapOptionKeys());
if (!string.IsNullOrEmpty(options.SiteMapDataPath))
{
SitemapPath.Text = options.SiteMapDataPath;
}
UseCompression.Checked = true;
IndexItems.Items[0].Selected = options.IncludeCategories;
IndexItems.Items[1].Selected = options.IncludeProducts;
IndexItems.Items[2].Selected = options.IncludeWebpages;
string changeFrequency = options.DefaultChangeFrequency.ToString();
ListItem selectedItem = ChangeFrequency.Items.FindByText(changeFrequency);
if (selectedItem != null)
{
selectedItem.Selected = true;
}
}
}
/// <summary>
/// Gets the SitemapNodes, looking up the page they point to automatically to get the accurate Document last modified.
/// </summary>
/// <param name="Path">The parent Nodealiaspath</param>
/// <param name="ClassName">The Class Name to query</param>
/// <param name="SiteName">The SiteName</param>
/// <param name="Options">The Options</param>
/// <returns>The SitemapNodes</returns>
private IEnumerable <SitemapNode> GetSiteMapUrlSetForClassWithUrlColumn(string Path, string ClassName, string SiteName, SiteMapOptions Options)
{
var DocumentQuery = _Helper.GetDocumentQuery(Path, Options, ClassName);
List <SitemapNode> SiteMapItems = new List <SitemapNode>();
foreach (var Page in DocumentQuery.TypedResult)
{
string Culture = !string.IsNullOrWhiteSpace(Options.CultureCode) ? Options.CultureCode : LocalizationContext.CurrentCulture.CultureCode;
var RelativeUrl = Page.GetStringValue(Options.UrlColumnName, _pageUrlRetriever.Retrieve(Page.NodeAliasPath, Culture, SiteName).RelativePath);
// Try to find page by NodeAliasPath
var ActualPage = (TreeNode)_generalDocumentRepository.GetDocumentByPath(RelativeUrl, SiteName, Columns: new string[] { "DocumentModifiedWhen", "NodeID", "DocumentCulture" });
if (ActualPage != null)
{
SiteMapItems.Add(ConvertToSiteMapUrl(RelativeUrl, SiteName, Page.DocumentModifiedWhen));
}
else
{
SiteMapItems.Add(ConvertToSiteMapUrl(RelativeUrl, SiteName, null));
}
}
return(SiteMapItems);
}
/// <summary>
/// Gets the SitemapNodes, looking up the page they point to automatically to get the accurate Document last modified.
/// </summary>
/// <param name="Path">The parent Nodealiaspath</param>
/// <param name="ClassName">The Class Name to query</param>
/// <param name="SiteName">The SiteName</param>
/// <param name="Options">The Options</param>
/// <returns>The SitemapNodes</returns>
private IEnumerable <SitemapNode> GetSiteMapUrlSetForClassWithUrlColumn(string Path, string ClassName, string SiteName, SiteMapOptions Options)
{
var DocumentQuery = _Helper.GetDocumentQuery(Path, Options, ClassName);
List <SitemapNode> SiteMapItems = new List <SitemapNode>();
foreach (string RelativeUrl in _Helper.GetRelativeUrls(Path, ClassName, SiteName, Options))
{
// Get the page, Dynamic Routing already has it's own internal Caching and adds to the output cache
var Page = (TreeNode)_DynamicRouteHelper.GetPage(RelativeUrl, Options.CultureCode, SiteName, new string[] { "DocumentModifiedWhen", "NodeID", "DocumentCulture" }, true);
if (Page != null)
{
SiteMapItems.Add(ConvertToSiteMapUrl(Page.RelativeURL, SiteName, Page.DocumentModifiedWhen));
}
else
{
SiteMapItems.Add(ConvertToSiteMapUrl(RelativeUrl, SiteName, null));
}
}
return(SiteMapItems);
}
public bool CreateAndCompressSiteMap(SiteMapOptions options, ref List <string> messages)
{
return(DoSiteMap(options, true, ref messages));
}
public bool CreateSiteMap(SiteMapOptions options, ref List <string> messages)
{
return(DoSiteMap(options, false, ref messages));
}
private void PopulateAspNetSiteMapUrls(List <SiteMapUrl> siteMapItems, System.Web.SiteMapNode siteMapNode, SiteMapOptions options)
{
if (siteMapNode == null)
{
return;
}
string nodeUrl = GetAbsoluteUrl(siteMapNode.Url);
siteMapItems.Add(new SiteMapUrl(nodeUrl, options.DefaultChangeFrequency, options.DefaultUrlPriority));
if (siteMapNode.HasChildNodes)
{
for (int i = 0; i < siteMapNode.ChildNodes.Count; i++)
{
PopulateAspNetSiteMapUrls(siteMapItems, siteMapNode.ChildNodes[i], options);
}
}
}
public IEnumerable <string> GetRelativeUrls(string Path, string ClassName, string SiteName, SiteMapOptions Options)
{
var DocumentQuery = GetDocumentQuery(Path, Options, ClassName);
return(DocumentQuery.TypedResult.Select(x => x.GetStringValue(Options.UrlColumnName, x.RelativeURL)));
}
public IEnumerable <SitemapNode> GetSiteMapUrlSetForAllClass(string Path, string SiteName, SiteMapOptions Options)
{
var DocumentQuery = GetDocumentQuery(Path, Options);
return(DocumentQuery.TypedResult.Select(x => ConvertNodeToSiteMapUrl(x, SiteName)));
}
private bool DoSiteMap(SiteMapOptions options, bool compress, ref List <string> messages)
{
string SiteMapFile = Path.Combine(options.SiteMapDataPath, options.SiteMapFileName);
string SiteMapData;
StreamWriter SiteMapWriter;
//get the data items to generate SiteMap for
List <SiteMapUrl> siteMapItems = GetSiteMapItems(options);
int maxUrls = 50000;
if (siteMapItems.Count > maxUrls)
{
//multiple sitemap files needed. It is best to devide them in equally sized files
int nFiles = (int)Math.Ceiling((double)siteMapItems.Count / maxUrls);
int nItems = (int)Math.Ceiling((double)siteMapItems.Count / nFiles);
int nLastFileItems = siteMapItems.Count - ((nFiles - 1) * nItems);
String fName, cfName;
int startIndex;
for (int i = 0; i < nFiles; i++)
{
startIndex = i * nItems;
fName = Path.Combine(options.SiteMapDataPath, "SiteMap" + (i + 1).ToString() + ".xml");
cfName = Path.Combine(options.SiteMapDataPath, fName + ".gz");
if (i == nFiles - 1)
{
//this is the last file
SiteMapData = GenerateSiteMap(siteMapItems, startIndex, nLastFileItems);
}
else
{
SiteMapData = GenerateSiteMap(siteMapItems, startIndex, nItems);
}
SiteMapWriter = File.CreateText(fName);
using (SiteMapWriter)
{
SiteMapWriter.Write(SiteMapData);
SiteMapWriter.Flush();
SiteMapWriter.Close();
}
if (compress)
{
CompressFile(fName, cfName);
}
}
messages.Add(string.Format("{0} SiteMap Files Created.", nFiles));
GenerateSiteMapIndexFile(options, nFiles, compress);
messages.Add("SiteMap Index File 'SiteMapIndex.xml' Created.");
}
else
{
if (File.Exists(SiteMapFile) && !options.OverwriteSiteMapFile)
{
messages.Add("SiteMap File Already Exists. You should either chose to overwrite the SiteMap file or provide a different name.");
return(false);
}
//generate the site map
SiteMapData = GenerateSiteMap(siteMapItems, 0, siteMapItems.Count);
SiteMapWriter = File.CreateText(SiteMapFile);
using (SiteMapWriter)
{
SiteMapWriter.Write(SiteMapData);
SiteMapWriter.Flush();
SiteMapWriter.Close();
}
messages.Add(string.Format("SiteMap File '{0}' Created.", options.SiteMapFileName));
if (compress)
{
string compressedFile = Path.Combine(options.SiteMapDataPath, options.CompressedSiteMapFileName);
if (File.Exists(compressedFile) && !options.OverwriteCompressedFile)
{
messages.Add(string.Format("Compressed SiteMap File '{0}' Already Exists. You should either chose to overwrite the compressed SiteMap file or provide a different name.", compressedFile));
return(false);
}
CompressFile(SiteMapFile, compressedFile);
messages.Add(string.Format("Compressed SiteMap File '{0}' Created.", options.CompressedSiteMapFileName));
}
}
return(true);
}
