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; }