public Sitemap CreateSitemap(Func<CmsPage, string> generateEntryUrl, string homePage)
{
IEnumerable<CmsPage> entries = pageData.LoadAllPublished();
int defaultPageId = settingData.Get(Constant.Settings.DefaultPageId).GetIntValue();
var sitemap = new Sitemap();
foreach (CmsPage page in entries)
{
if (IsDefaultPage(page,
defaultPageId))
{
AddHomePage(sitemap,
page,
homePage);
continue;
}
var url = new SitemapUrl();
url.Location = generateEntryUrl(page);
url.ChangeFrequency = CalculateFrequency(page.ModifiedAt);
url.Priority = 0.7;
url.LastModified = page.ModifiedAt.ToString();
sitemap.Add(url);
}
return sitemap;
}
/// <summary>
/// Default constructor, creates a new model.
/// </summary>
public ListModel()
{
Pages = new List <Sitemap>();
Templates = PageTemplate.GetFields("pagetemplate_id, pagetemplate_name, pagetemplate_preview, pagetemplate_description",
"pagetemplate_site_template = 0", new Params()
{
OrderBy = "pagetemplate_name ASC"
});
AllPages = Sitemap.GetFields("page_id, page_title, page_navigation_title, pagetemplate_name, sitetree_name", "page_draft = 1 AND page_original_id IS NULL AND (page_parent_id IS NULL OR page_parent_id NOT IN (SELECT sitetree_id FROM sitetree))",
new Params()
{
OrderBy = "sitetree_name, COALESCE(page_navigation_title, page_title)"
});
SitePage = new Dictionary <Guid, Guid>();
SiteWarnings = new Dictionary <Guid, int>();
TotalSiteWarnings = new Dictionary <Guid, int>();
PageWarnings = new Dictionary <Guid, int>();
using (var db = new DataContext()) {
SiteTrees = db.SiteTrees.OrderBy(s => s.Name).ToList();
foreach (var site in SiteTrees)
{
SitePage[site.Id] = db.Pages.Where(p => p.SiteTreeId == site.Id && p.ParentId == site.Id).Select(p => p.Id).SingleOrDefault();
SiteWarnings[site.Id] = 0 + (String.IsNullOrEmpty(site.MetaTitle) ? 1 : 0) + (String.IsNullOrEmpty(site.MetaDescription) ? 1 : 0);
TotalSiteWarnings[site.Id] =
Page.GetScalar("SELECT COUNT(*) FROM page WHERE page_draft = 1 AND page_sitetree_id = @0 AND page_parent_id != @0 AND page_original_id IS NULL AND page_published IS NOT NULL AND page_keywords IS NULL", site.Id) +
Page.GetScalar("SELECT COUNT(*) FROM page WHERE page_draft = 1 AND page_sitetree_id = @0 AND page_parent_id != @0 AND page_original_id IS NULL AND page_published IS NOT NULL AND page_description IS NULL", site.Id);
}
}
}
public virtual Task LoadSitemapItemRecordsAsync(Store store, Sitemap sitemap, string baseUrl, Action <ExportImportProgressInfo> progressCallback = null)
{
var progressInfo = new ExportImportProgressInfo();
var sitemapItemRecords = new List <SitemapItemRecord>();
var customOptions = new SitemapItemOptions();
var customSitemapItems = sitemap.Items.Where(si => si.ObjectType.EqualsInvariant(SitemapItemTypes.Custom)).ToList();
var totalCount = customSitemapItems.Count;
if (totalCount > 0)
{
var processedCount = 0;
progressInfo.Description = $"Custom: Starting records generation for {totalCount} custom items";
progressCallback?.Invoke(progressInfo);
foreach (var customSitemapItem in customSitemapItems)
{
customSitemapItem.ItemsRecords = GetSitemapItemRecords(store, customOptions, customSitemapItem.UrlTemplate, baseUrl);
processedCount++;
progressInfo.Description = $"Custom: Have been generated {processedCount} of {totalCount} records for custom items";
progressCallback?.Invoke(progressInfo);
}
}
return(Task.CompletedTask);
}
public ActionResult SiteMapXml()
{
string domain = Request.Url.Host;
Sitemap sitemap = new Sitemap();
using (ContentRepository content_repository = new ContentRepository())
{
long totals;
foreach (var item in content_repository.GetActive((string[])null, null, null, null, 1, Int64.MaxValue, out totals, "content_in_sitemap = true", null, domain))
{
sitemap.Add(new Location()
{
Url = string.Format("http://{0}{1}", Request.Url.Host, item.content_url)
});
}
}
XmlSerializer xs = new XmlSerializer(typeof(Sitemap));
MemoryStream ms = new MemoryStream();
XmlTextWriter xw = new XmlTextWriter(ms, Encoding.UTF8);
xs.Serialize(xw, sitemap);
ms.Position = 0;
return(File(ms, "text/xml"));
}
public Guid[] Blocks(Sitemap page) {
var query = Templates.Where(t => t.BlockTypes.Contains(page.TemplateId));
if (page.IsBlock)
query = query.Where(t => t.IsBlock);
return query.Select(t => t.Id).ToArray();
}
/// <summary>
/// Refreshes the model from the database.
/// </summary>
public virtual void Refresh()
{
if (Page != null)
{
if (!Page.IsNew) // Page.Id != Guid.Empty) {
{
Page = Page.GetSingle(Page.Id, true);
CanDelete = Page.GetScalar("SELECT count(*) FROM page WHERE page_parent_id = @0", Page.Id) == 0;
GetRelated();
}
else
{
Template = PageTemplate.GetSingle("pagetemplate_id = @0", Page.TemplateId);
// Get placement ref title
if (Page.ParentId != Guid.Empty || Page.Seqno > 1)
{
Page refpage = null;
if (Page.Seqno > 1)
{
if (Page.ParentId != Guid.Empty)
{
refpage = Page.GetSingle("page_parent_id = @0 AND page_seqno = @1", Page.ParentId, Page.Seqno - 1);
}
else
{
refpage = Page.GetSingle("page_parent_id IS NULL AND page_seqno = @0", Page.Seqno - 1);
}
}
else
{
refpage = Page.GetSingle(Page.ParentId, true);
}
PlaceRef = refpage.Title;
}
// Get page position
Parents = BuildParentPages(Sitemap.GetStructure(Page.SiteTreeInternalId, false), Page);
Parents.Insert(0, new PagePlacement()
{
Level = 1, IsSelected = Page.ParentId == Guid.Empty
});
Siblings = BuildSiblingPages(Page.Id, Page.ParentId, Page.Seqno, Page.ParentId, Page.SiteTreeInternalId);
// Initialize regions
foreach (var reg in Regions)
{
if (Extend.ExtensionManager.ExtensionTypes.ContainsKey(reg.Type))
{
var m = Extend.ExtensionManager.ExtensionTypes[reg.Type].GetMethod("Init");
if (m != null)
{
m.Invoke(reg.Body, new object[] { this });
}
}
}
}
}
}
protected void btnXmlWatch_Click(object sender, EventArgs e)
{
Sitemap site = new Sitemap();
site.ProcessTextRequest(this.Context);
Page.ClientScript.RegisterStartupScript(GetType(), "confirm", "confirm('sitemap.xml biên dịch thành công tại địa chỉ : " + path + " .')", true);
return;
}
public void Set_SiteUrl_LastModified_To_Null_When_Missing()
{
var document = XDocument.Parse("<?xml version=\"1.0\" encoding=\"UTF - 8\"?><urlset xmlns = \"http://www.sitemaps.org/schemas/sitemap/0.9\" xmlns:xhtml=\"http://www.w3.org/1999/xhtml\"><url><loc>https://aspetraining.com/</loc><priority>1</priority></url></urlset>");
Target = new Sitemap(document);
Target.SiteUrls.First().LastUpdated.ShouldBeNull();
}
public ActionResult DeleteConfirmed(string id)
{
Sitemap sitemap = db.Sitemap.Find(id);
db.Sitemap.Remove(sitemap);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public void StaticPageSiteMap(Sitemap sm)
{
AddToSiteMap(sm, "https://zavoshsoftware.com", 0.9D, Location.eChangeFrequency.weekly);
AddToSiteMap(sm, "https://zavoshsoftware.com/portfolio", 0.7D, Location.eChangeFrequency.weekly);
AddToSiteMap(sm, "https://zavoshsoftware.com/contact", 0.5D, Location.eChangeFrequency.yearly);
}
public void Return_Single_Site_Url_For_One_Entry()
{
Document = XDocument.Parse(SingleUrlSiteMap);
Target = new Sitemap(Document);
Target.SiteUrls.Count().ShouldBe(1);
}
public void Return_Empty_Collection_When_No_Urls()
{
Document = XDocument.Parse(EmptySiteMap);
Target = new Sitemap(Document);
Target.SiteUrls.ShouldBeEmpty();
}
public void Return_SiteUrl_With_MMAP_Root_Address_For_One_Entry()
{
Document = XDocument.Parse(SingleUrlSiteMap);
Target = new Sitemap(Document);
Target.SiteUrls.First().Url.ShouldBe("https://makemeaprogrammer.com/");
}
public void Return_Url_Last_Modified_Of_January_18_2020()
{
Document = XDocument.Parse(SingleUrlSiteMap);
Target = new Sitemap(Document);
Target.SiteUrls.First().LastUpdated.Value.DayOfYear.ShouldBe(18);
}
public bool Subpages(Sitemap page) {
var template = Templates.SingleOrDefault(t => t.Id == page.TemplateId);
if (template != null) {
return !template.IsBlock && template.Subpages;
}
return false;
}
public async Task <IActionResult> GetSitemap()
{
var page = 1;
var key = "sitemap";
var xml = _cache.Get(key)?.ToString();
if (string.IsNullOrEmpty(xml))
{
IPagedList <Publication> publications;
IPagedList <Vacancy> vacancies;
var sitemap = new Sitemap();
var events = GetCustomPages();
foreach (var url in events)
{
sitemap.Add(CreateUrl(url));
}
page = 1;
do
{
publications = await _publicationService.GetPublications(null, page);
page++;
foreach (var p in publications)
{
var publication = new PublicationViewModel(p, _settings.WebSiteUrl);
sitemap.Add(CreateUrl(publication.ShareUrl.ToString()));
}
}while (publications.HasNextPage);
page = 1;
do
{
vacancies = await _vacancyService.GetVacancies(page);
page++;
foreach (var v in vacancies)
{
var vacancy = new VacancyViewModel(v, _settings.WebSiteUrl);
sitemap.Add(CreateUrl(vacancy.ShareUrl.ToString()));
}
}while (vacancies.HasNextPage);
xml = sitemap.ToXml();
_cache.Set(key, xml, TimeSpan.FromMinutes(10));
}
return(Content(xml, "application/xml"));
}
public void TourSiteMap(Sitemap sm)
{
List <Models.Tour> tours = db.Tours.Where(current => current.IsDelete == false).ToList();
foreach (Models.Tour tour in tours)
{
AddToSiteMap(sm, "https://www.bektashtravel.com/tour/" + tour.TourCategory.UrlParam + "/" + tour.Code, 0.7D, Location.eChangeFrequency.weekly, tour.SubmitDate);
}
}
/// <summary>
/// Gets the list model for all available pages.
/// </summary>
/// <returns>The model.</returns>
public static ListModel Get()
{
ListModel m = new ListModel();
m.SiteMap = Sitemap.GetStructure(false);
m.Pages = Sitemap.GetStructure(false).Flatten();
return(m);
}
public void BlogSiteMap(Sitemap sm)
{
List <Blog> blogs = db.Blogs.Where(current => current.IsDelete == false).Include(c => c.BlogGroup).ToList();
foreach (Blog blog in blogs)
{
AddToSiteMap(sm, "https://www.bektashtravel.com/blog/" + blog.BlogGroup.UrlParam + "/" + blog.UrlParam, 0.9D, Location.eChangeFrequency.monthly, blog.LastModificationDate.Value);
}
}
public Sitemap CreateNewSitemap()
{
var entity = new Sitemap();
PopulateBaseFields(entity);
entity.Title = ProvideRandomString(MaxLength.Name);
return(entity);
}
public void TourTypeSiteMap(Sitemap sm)
{
List <Models.Type> types = db.Types.Where(current => current.IsDelete == false).ToList();
foreach (Models.Type type in types)
{
AddToSiteMap(sm, "https://www.bektashtravel.com/tour/" + type.UrlParam, 0.9D, Location.eChangeFrequency.weekly, type.SubmitDate);
}
}
/// <summary>
/// Invokes the middleware.
/// </summary>
/// <param name="context">The current http context</param>
/// <param name="api">The current api</param>
/// <param name="service">The application service</param>
/// <returns>An async task</returns>
public override async Task Invoke(HttpContext context, IApi api, IApplicationService service)
{
var useSitemapRouting = _config != null ? _config.UseSitemapRouting : true;
if (useSitemapRouting && !IsHandled(context) && !context.Request.Path.Value.StartsWith("/manager/assets/"))
{
var url = context.Request.Path.HasValue ? context.Request.Path.Value : "";
var host = context.Request.Host.Host;
var scheme = context.Request.Scheme;
var port = context.Request.Host.Port;
var prefix = service.Site.SitePrefix != null ?
$"/{ service.Site.SitePrefix }" : "";
var baseUrl = scheme + "://" + host + (port.HasValue ? $":{port}" : "") + prefix;
if (url.ToLower() == "/sitemap.xml")
{
_logger?.LogInformation($"Sitemap.xml requested, generating");
// Get the requested site by hostname
var siteId = service.Site.Id;
// Get the sitemap for the site
var pages = await api.Sites.GetSitemapAsync(siteId);
if (App.Hooks.OnGenerateSitemap != null)
{
// We need to clone the sitemap as it might be cached
// if we're going to modify it.
pages = App.Hooks.OnGenerateSitemap(Utils.DeepClone(pages));
}
// Generate sitemap.xml
var sitemap = new Sitemap();
foreach (var page in pages)
{
if (!page.MetaIndex)
{
continue;
}
var urls = await GetPageUrlsAsync(api, page, baseUrl).ConfigureAwait(false);
if (urls.Count > 0)
{
sitemap.AddRange(urls);
}
}
context.Response.ContentType = "application/xml";
await context.Response.WriteAsync(sitemap.ToXml());
return;
}
}
await _next.Invoke(context);
}
public void AddToSiteMap(Sitemap sm, string url, double?priority, Location.eChangeFrequency frequency)
{
sm.Add(new Location()
{
Url = url,
LastModified = DateTime.UtcNow,
Priority = priority,
ChangeFrequency = frequency
});
}
public void PortfolioGroupSiteMap(Sitemap sm)
{
List <Models.PortfolioGroup> portfolioGroups = db.PortfolioGroups.Where(current => current.IsDelete == false && current.ParentId != null && current.IsActive == true).ToList();
foreach (PortfolioGroup portfolioGroup in portfolioGroups)
{
var encoded = HttpUtility.UrlPathEncode("https://zavoshsoftware.com/portfolio/" + portfolioGroup.UrlParameter);
AddToSiteMap(sm, encoded, 0.7D, Location.eChangeFrequency.weekly);
}
}
public void PortfolioSiteMap(Sitemap sm)
{
List <Models.Portfolio> portfolios = db.Portfolios.Where(current => current.IsDelete == false && current.IsActive == true).ToList();
foreach (Portfolio portfolio in portfolios)
{
var encoded = HttpUtility.UrlPathEncode("https://zavoshsoftware.com/Portfoliodetail/" + portfolio.UrlParameter);
AddToSiteMap(sm, encoded, 0.7D, Location.eChangeFrequency.monthly);
}
}
private static string FormatTitle(Sitemap s)
{
string prefix = "";
for (int n = 0; n < s.Level - 1; n++)
{
prefix += "-";
}
return(prefix + s.Title);
}
public bool Subpages(Sitemap page)
{
var template = Templates.SingleOrDefault(t => t.Id == page.TemplateId);
if (template != null)
{
return(!template.IsBlock && template.Subpages);
}
return(false);
}
public ActionResult Delete(string id = null)
{
Sitemap sitemap = db.Sitemap.Find(id);
if (sitemap == null)
{
return(HttpNotFound());
}
return(View(sitemap));
}
public Guid[] Blocks(Sitemap page)
{
var query = Templates.Where(t => t.BlockTypes.Contains(page.TemplateId));
if (page.IsBlock)
{
query = query.Where(t => t.IsBlock);
}
return(query.Select(t => t.Id).ToArray());
}
/// <summary>
/// Clear Jquery datatable
/// </summary>
public ActionResult ClearRestoreData()
{
int pos = Sitemap.FindIndex(item => item.ControllerName == RouteData.Values["controller"].ToString());
if (0 <= pos)
{
Sitemap[pos].RestoreData = null;
}
return(new EmptyResult());
}
public ActionResult Edit(Sitemap sitemap)
{
if (ModelState.IsValid)
{
db.Entry(sitemap).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(sitemap));
}
private void AddHomePage(Sitemap sitemap, CmsPage page, string homePage)
{
var url = new SitemapUrl();
url.Location = homePage;
url.ChangeFrequency = CalculateFrequency(page.ModifiedAt);
url.Priority = 0.9;
url.LastModified = page.ModifiedAt.ToString();
sitemap.Insert(0,
url);
}
public string BlocksString(Sitemap page) {
var blocks = Blocks(page);
var sb = new StringBuilder();
foreach (var block in blocks) {
if (sb.Length > 0)
sb.Append(",");
sb.Append(block.ToString());
}
return sb.ToString();
}
/// <summary>
/// Save Jquery datatable
/// </summary>
/// <param name="data"></param>
protected void SaveRestoreData(object data)
{
if (data != null)
{
int pos = Sitemap.FindIndex(item => item.ControllerName == RouteData.Values["controller"].ToString());
if (0 <= pos)
{
Sitemap[pos].RestoreData = data;
}
}
}
public ActionResult Sitemap(string language)
{
Sitemap sm = new Sitemap();
StaticPageSiteMap(sm);
ProductsSiteMap(sm);
PortfolioGroupSiteMap(sm);
PortfolioSiteMap(sm);
return(new XmlResult(sm));
}
public DefaultPagesApiOperations(IPagesService pages, IPageService page, IContentService content, IWidgetService widget, IWidgetsService widgets,
IRedirectsService redirects, IRedirectService redirect, Sitemap.ISitemapService sitemap, ISitemapsService sitemaps, ISitemapService sitemapNew)
{
Pages = pages;
Page = page;
Content = content;
Widget = widget;
Widgets = widgets;
Redirect = redirect;
Redirects = redirects;
Sitemap = sitemap;
Sitemaps = sitemaps;
SitemapNew = sitemapNew;
}
private static List<Sitemap> BuildSitemaps(List<Url> urls)
{
var sitemaps = new List<Sitemap>();
var sitemap = new Sitemap();
var numberOfUrls = urls.Count;
for (var i = 0; i < numberOfUrls; i++)
{
if (i%MaxNumberOfUrlsPerSitemap == 0)
{
sitemap = new Sitemap();
sitemaps.Add(sitemap);
}
sitemap.Add(urls[i]);
}
return sitemaps;
}
protected string GenerateXml(ContentItem startItem, Sitemap result = null)
{
IEnumerable<N2.ContentItem> pages = Find.Items
.Where
.Parent.Eq(startItem)
.And.Published.Le(DateTime.Now)
.And.Type.NotEq(typeof(SitemapXml)) // Minimize selection as
.And.Type.NotEq(typeof(CustomCssContent)) // much as possible
.And.Type.NotEq(typeof(CustomJavaScriptContent))
.And.Type.NotEq(typeof(RedirectPage))
.And.Type.NotEq(typeof(FeedPage))
.And.State.NotEq(ContentState.Deleted)
.And.State.NotEq(ContentState.Draft)
.And.State.NotEq(ContentState.New)
.And.State.NotEq(ContentState.Unpublished)
//.And.State.Eq(ContentState.Published)
.Select()
.Where(item =>
item.IsPage
&& SitemapDecorator.AutoDefineOnType(item.GetType())
&& !item.GetDetail<bool>(EditModeFields.Syndication.ExcludeFromSiteMapName, false))
.Union(new N2.ContentItem[] { startItem });
result = result ?? new Sitemap();
foreach (N2.ContentItem page in pages)
{
string url = (page is WebPage)
? ((WebPage)page).CanonicalUrl //TODO: Fully qualify
: page.GetSafeUrl();
if (!result.Where(item => item.Loc == url).Any())
{
SitemapUrl pageUrl = new SitemapUrl()
{
LastModifiedDate = page.Updated,
Loc = url
};
result.Add(pageUrl);
}
if (page != startItem)
GenerateXml(page, result);
}
return result.ToString();
}
/// <summary>
/// To the json.
/// </summary>
/// <param name="sitemap">The sitemap.</param>
/// <returns>json representation of the sitemap.</returns>
private static string ToJson(Sitemap sitemap)
{
var map = new ArchivedSitemap
{
Title = sitemap.Title,
RootNodes = sitemap.Nodes != null
? GetSitemapNodesInHierarchy(
sitemap.Nodes.Distinct().Where(f => f.ParentNode == null).OrderBy(sitemapNode => sitemapNode.DisplayOrder).ToList(),
sitemap.Nodes.Distinct().ToList())
: new List<ArchivedNode>()
};
var serializer = new JavaScriptSerializer();
var serialized = serializer.Serialize(map);
return serialized;
}
/// <summary>
/// Saves the node (does not archive sitemap).
/// </summary>
/// <param name="nodeUpdated"></param>
/// <param name="sitemap">The sitemap.</param>
/// <param name="nodeId">The id.</param>
/// <param name="version">The version.</param>
/// <param name="url">The URL.</param>
/// <param name="title">The title.</param>
/// <param name="macro">The macro.</param>
/// <param name="pageId">The page identifier.</param>
/// <param name="usePageTitleAsNodeTitle">if set to <c>true</c> [use page title as node title].</param>
/// <param name="displayOrder">The display order.</param>
/// <param name="parentId">The parent id.</param>
/// <param name="isDeleted">if set to <c>true</c> node is deleted.</param>
/// <param name="parentNode">The parent node.</param>
/// <param name="nodeList"></param>
/// <returns>
/// Updated or newly created sitemap node.
/// </returns>
public SitemapNode SaveNode(out bool nodeUpdated, Sitemap sitemap, Guid nodeId, int version, string url, string title, string macro, Guid pageId, bool usePageTitleAsNodeTitle, int displayOrder, Guid parentId, bool isDeleted = false, SitemapNode parentNode = null, List<SitemapNode> nodeList = null)
{
nodeUpdated = false;
var node = nodeId.HasDefaultValue()
? new SitemapNode()
: nodeList != null ? nodeList.First(n => n.Id == nodeId) : repository.First<SitemapNode>(nodeId);
if (isDeleted)
{
if (!node.Id.HasDefaultValue())
{
repository.Delete(node);
nodeUpdated = true;
}
}
else
{
var updated = false;
if (node.Sitemap == null)
{
node.Sitemap = sitemap;
}
if (node.Title != title)
{
updated = true;
node.Title = title;
}
if (node.Page != (!pageId.HasDefaultValue() ? repository.AsProxy<PageProperties>(pageId) : null))
{
updated = true;
node.Page = !pageId.HasDefaultValue() ? repository.AsProxy<PageProperties>(pageId) : null;
}
if (node.UsePageTitleAsNodeTitle != (!pageId.HasDefaultValue() && usePageTitleAsNodeTitle))
{
updated = true;
node.UsePageTitleAsNodeTitle = !pageId.HasDefaultValue() && usePageTitleAsNodeTitle;
}
if (node.Url != (node.Page != null ? null : url))
{
updated = true;
node.Url = node.Page != null ? null : url;
node.UrlHash = node.Page != null ? null : url.UrlHash();
}
if (node.DisplayOrder != displayOrder)
{
updated = true;
node.DisplayOrder = displayOrder;
}
SitemapNode newParent;
if (parentNode != null && !parentNode.Id.HasDefaultValue())
{
newParent = parentNode;
}
else
{
newParent = parentId.HasDefaultValue()
? null
: repository.AsProxy<SitemapNode>(parentId);
}
if (node.ParentNode != newParent)
{
updated = true;
node.ParentNode = newParent;
}
if (cmsConfiguration.EnableMacros && node.Macro != macro)
{
node.Macro = macro;
updated = true;
}
if (updated)
{
node.Version = version;
repository.Save(node);
nodeUpdated = true;
}
}
return node;
}
/// <summary>
/// Saves the tags.
/// </summary>
/// <param name="sitemap">The sitemap.</param>
/// <param name="tags">The tags.</param>
/// <param name="newCreatedTags">The new created tags.</param>
public void SaveTags(Sitemap sitemap, IList<string> tags, out IList<Tag> newCreatedTags)
{
var trimmedTags = new List<string>();
if (tags != null)
{
foreach (var tag in tags)
{
trimmedTags.Add(tag.Trim());
}
}
newCreatedTags = new List<Tag>();
Tag tagAlias = null;
// Tags merge:
var sitemapTags = unitOfWork.Session
.QueryOver<SitemapTag>()
.Where(t => !t.IsDeleted && t.Sitemap.Id == sitemap.Id)
.JoinQueryOver(t => t.Tag, JoinType.InnerJoin)
.Where(t => !t.IsDeleted)
.List<SitemapTag>();
// Remove deleted tags:
for (var i = sitemapTags.Count - 1; i >= 0; i--)
{
var tag = trimmedTags.FirstOrDefault(s => s.ToLower() == sitemapTags[i].Tag.Name.ToLower());
if (tag == null)
{
unitOfWork.Session.Delete(sitemapTags[i]);
}
}
// Add new tags:
List<string> tagsInsert = new List<string>();
foreach (var tag in trimmedTags)
{
var existSitemapTag = sitemapTags.FirstOrDefault(sitemapTag => sitemapTag.Tag.Name.ToLower() == tag.ToLower());
if (existSitemapTag == null)
{
tagsInsert.Add(tag);
}
}
if (tagsInsert.Count <= 0)
{
return;
}
// Get existing tags:
var existingTags = unitOfWork.Session.QueryOver(() => tagAlias)
.Where(t => !t.IsDeleted)
.Where(Restrictions.In(Projections.Property(() => tagAlias.Name), tagsInsert))
.List<Tag>();
foreach (var tag in tagsInsert)
{
var sitemapTag = new SitemapTag { Sitemap = sitemap };
var existTag = existingTags.FirstOrDefault(t => t.Name.ToLower() == tag.ToLower());
if (existTag != null)
{
sitemapTag.Tag = existTag;
}
else
{
var newTag = new Tag { Name = tag };
unitOfWork.Session.SaveOrUpdate(newTag);
newCreatedTags.Add(newTag);
sitemapTag.Tag = newTag;
}
unitOfWork.Session.SaveOrUpdate(sitemapTag);
}
}
/// <summary>
/// Archives the sitemap.
/// </summary>
/// <param name="sitemap">The sitemap.</param>
public void ArchiveSitemap(Sitemap sitemap)
{
var archive = new SitemapArchive
{
Sitemap = sitemap,
Title = sitemap.Title,
ArchivedVersion = ToJson(sitemap)
};
repository.Save(archive);
}
public SitemapResult(Sitemap sitemap)
{
this.Sitemap = sitemap;
}
private static string FormatTitle(Sitemap s) {
string prefix = "";
for (int n = 0; n < s.Level - 1; n++)
prefix += "-";
return prefix + s.Title;
}
/// <summary>
/// Restores the nodes.
/// </summary>
/// <param name="sitemap">The sitemap.</param>
/// <param name="parentNode">The parent node.</param>
/// <param name="childNodes">The child nodes.</param>
private void RestoreTheNodes(Sitemap sitemap, SitemapNode parentNode, IEnumerable<SitemapNode> childNodes)
{
foreach (var node in childNodes)
{
var restoredNode = new SitemapNode
{
Sitemap = sitemap,
ParentNode = parentNode,
Title = node.Title,
UsePageTitleAsNodeTitle = node.UsePageTitleAsNodeTitle,
Macro = node.Macro,
};
if (node.Page != null)
{
var node1 = node;
var page = repository.FirstOrDefault<PageProperties>(properties => properties.Id == node1.Page.Id && !properties.IsDeleted);
restoredNode.Page = page;
restoredNode.Url = page != null ? null : node.Url;
restoredNode.UrlHash = page != null ? null : node.UrlHash;
}
else
{
restoredNode.Page = null;
restoredNode.Url = node.Url;
restoredNode.UrlHash = node.UrlHash;
}
repository.Save(restoredNode);
foreach (var translation in node.Translations)
{
var translation1 = translation;
var language = repository.FirstOrDefault<Language>(l => l.Id == translation1.Language.Id && !l.IsDeleted);
if (language == null)
{
continue;
}
var restoredTranslation = new SitemapNodeTranslation
{
Node = restoredNode,
Language = language,
Title = translation.Title,
UsePageTitleAsNodeTitle = translation.UsePageTitleAsNodeTitle,
Macro = translation.Macro
};
if (restoredNode.Page == null)
{
restoredTranslation.Url = restoredNode.Url;
restoredTranslation.UrlHash = restoredNode.Url.UrlHash();
}
repository.Save(restoredTranslation);
}
RestoreTheNodes(sitemap, restoredNode, node.ChildNodes);
}
}
/// <summary>
/// Adds the nodes.
/// </summary>
/// <param name="sitemap">The sitemap.</param>
/// <param name="archivedNodes">The archived nodes.</param>
/// <param name="parentNode">The parent node.</param>
/// <returns>
/// Sitemap node list.
/// </returns>
private static List<SitemapNode> AddNodes(Sitemap sitemap, IEnumerable<ArchivedNode> archivedNodes, SitemapNode parentNode)
{
var nodes = new List<SitemapNode>();
foreach (var archivedNode in archivedNodes)
{
var node = new SitemapNode
{
Title = archivedNode.Title,
Url = archivedNode.Url,
Page = !archivedNode.PageId.HasDefaultValue()
? new PageProperties
{
Id = archivedNode.PageId
}
: null,
UsePageTitleAsNodeTitle = archivedNode.UsePageTitleAsNodeTitle,
DisplayOrder = archivedNode.DisplayOrder,
ParentNode = parentNode,
Macro = archivedNode.Macro
};
node.ChildNodes = AddNodes(sitemap, archivedNode.Nodes, node);
node.Translations = AddTranslations(archivedNode, node);
nodes.Add(node);
}
nodes.ForEach(sitemap.Nodes.Add);
return nodes.OrderBy(node => node.DisplayOrder).ToList();
}
/// <summary>
/// Renders an LI element for the given sitemap node.
/// </summary>
/// <param name="curr">The current page</param>
/// <param name="page">The sitemap element</param>
/// <param name="str">The string builder</param>
/// <param name="stoplevel">The desired stop level</param>
private void RenderLI(Page curr, Sitemap page, StringBuilder str, int stoplevel)
{
if (page.GroupId == Guid.Empty || HttpContext.Current.User.IsMember(page.GroupId)) {
str.AppendLine("<li" + (curr.Id == page.Id ? " class=\"active\"" :
(ChildActive(page, curr.Id) ? " class=\"active-child \"" : "")) + ">") ;
str.AppendLine(String.Format("<a href=\"{0}\">{1}</a>", GenerateUrl(page),
!String.IsNullOrEmpty(page.NavigationTitle) ? page.NavigationTitle : page.Title)) ;
if (page.Pages.Count > 0)
RenderUL(curr, page.Pages, str, stoplevel) ;
str.AppendLine("</li>") ;
}
}
/// <summary>
/// Renders an LI element for the given sitemap node.
/// </summary>
/// <param name="curr">The current page</param>
/// <param name="page">The sitemap element</param>
/// <param name="str">The string builder</param>
/// <param name="stoplevel">The desired stop level</param>
private void RenderLI(Page curr, Sitemap page, StringBuilder str, int stoplevel) {
if (page.GroupId == Guid.Empty || HttpContext.Current.User.IsMember(page.GroupId)) {
var active = curr.Id == page.Id;
var childactive = ChildActive(page, curr.Id);
// Render item start
if (Hooks.Menu.RenderItemStart != null) {
Hooks.Menu.RenderItemStart(this, str, page, active, childactive);
} else {
var hasChild = page.Pages.Count > 0 ? " has-child" : "";
str.AppendLine("<li" + (curr.Id == page.Id ? " class=\"active" + hasChild + "\"" :
(ChildActive(page, curr.Id) ? " class=\"active-child" + hasChild + "\"" :
(page.Pages.Count > 0 ? " class=\"has-child\"" : ""))) + ">");
}
// Render item link
if (Hooks.Menu.RenderItemLink != null) {
Hooks.Menu.RenderItemLink(this, str, page);
} else {
str.AppendLine(String.Format("<a href=\"{0}\">{1}</a>", GenerateUrl(page),
!String.IsNullOrEmpty(page.NavigationTitle) ? page.NavigationTitle : page.Title));
}
// Render subpages
if (page.Pages.Count > 0)
RenderUL(curr, page.Pages, str, stoplevel);
// Render item end
if (Hooks.Menu.RenderItemEnd != null) {
Hooks.Menu.RenderItemEnd(this, str, page, active, childactive);
} else {
str.AppendLine("</li>");
}
}
}
/// <summary>
/// Checks if the given sitemap is active or has an active child
/// </summary>
/// <param name="page">The sitemap element</param>
/// <param name="id">The page id to search for</param>
/// <returns>If a child is selected</returns>
private bool ChildActive(Sitemap page, Guid id) {
if (page.Id == id)
return true;
foreach (Sitemap sr in page.Pages) {
if (ChildActive(sr, id))
return true;
}
return false;
}
/// <summary>
/// From the json forms sitemap.
/// </summary>
/// <param name="archivedVersion">The archived version.</param>
/// <returns>the sitemap made from json.</returns>
private static Sitemap FromJson(string archivedVersion)
{
var serializer = new JavaScriptSerializer();
var deserialized = serializer.Deserialize<ArchivedSitemap>(archivedVersion);
if (deserialized != null)
{
var sitemap = new Sitemap()
{
Title = deserialized.Title,
Nodes = new List<SitemapNode>()
};
AddNodes(sitemap, deserialized.RootNodes, null);
return sitemap;
}
return null;
}
