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;
        }
 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);
 }
Example #3
0
        private void AddURL(SitemapUrl sitemapUrl, XmlWriter writer)
        {
            writer.WriteStartElement("url");
            writer.WriteElementString("loc", sitemapUrl.Url);
            writer.WriteElementString("lastmod", sitemapUrl.LastModified.ToString("yyyy-MM-dd"));
            writer.WriteElementString("changefreq", sitemapUrl.ChangeFrequency.ToString().ToLower());
            writer.WriteElementString("priority", sitemapUrl.Priority.ToString("F01", CultureInfo.InvariantCulture));

            if (sitemapUrl.AlternateUrls != null)
            {
                foreach (var alternate in sitemapUrl.AlternateUrls)
                {
                    writer.WriteStartElement("link", "http://www.w3.org/1999/xhtml");
                    writer.WriteAttributeString("rel", "alternate");
                    writer.WriteAttributeString("hreflang", alternate.Language);
                    writer.WriteAttributeString("href", alternate.Url);
                    writer.WriteEndElement();
                }
            }

            writer.WriteEndElement();
        }
Example #4
0
        private static void RenderSitemapUrl(HtmlTextWriter writer, SitemapUrl sitemapUrl)
        {
            writer.RenderBeginTag(HtmlTextWriterTag.Li);

            writer.AddAttribute(HtmlTextWriterAttribute.Href, sitemapUrl.Url);
            writer.RenderBeginTag(HtmlTextWriterTag.A);
            writer.Write(sitemapUrl.Text);
            writer.RenderEndTag(); // a

            if (sitemapUrl.Children.Count > 0)
            {
                writer.RenderBeginTag(HtmlTextWriterTag.Ul);

                foreach (var url in sitemapUrl.Children)
                {
                    RenderSitemapUrl(writer, url);
                }

                writer.RenderEndTag(); // ul
            }

            writer.RenderEndTag(); // li
        }
Example #5
0
        public async Task <IActionResult> SitemapXml()
        {
            var seller = await HttpContext.GetSellerAsync();

            var sitemapList = new SitemapUrlList();

            var products = await _productService.GetQuery().Where(x => x.SellerId == seller.Id && x.Published && !string.IsNullOrWhiteSpace(x.Slug)).Select(x => new { x.Slug }).ToListAsync();

            var categories = await _categoryService.GetQuery().Where(x => x.SellerId == seller.Id && x.Published && !string.IsNullOrWhiteSpace(x.Slug)).Select(x => new { x.Slug }).ToListAsync();

            sitemapList.Add(SitemapUrl.CreateUrl(Url.ContentLink(Url.Action(nameof(Index)))));
            sitemapList.AddRange(from product in products select SitemapUrl.CreateUrl(Url.ContentLink(Url.Action(nameof(Products), "Store", new { slug = product.Slug }))));
            sitemapList.AddRange(from category in categories select SitemapUrl.CreateUrl(Url.ContentLink(Url.Action(nameof(Products), "Store", new { slug = category.Slug }))));
            sitemapList.Add(SitemapUrl.CreateUrl(Url.ContentLink(Url.Action(nameof(Products)))));
            sitemapList.Add(SitemapUrl.CreateUrl(Url.ContentLink(Url.Action(nameof(About)))));
            sitemapList.Add(SitemapUrl.CreateUrl(Url.ContentLink(Url.Action(nameof(Contact)))));
            sitemapList.Add(SitemapUrl.CreateUrl(Url.ContentLink(Url.Action(nameof(Terms)))));
            sitemapList.Add(SitemapUrl.CreateUrl(Url.ContentLink(Url.Action(nameof(PrivacyPolicy)))));
            sitemapList.Add(SitemapUrl.CreateUrl(Url.ContentLink(Url.Action(nameof(ReturnPolicy)))));
            sitemapList.Add(SitemapUrl.CreateUrl(Url.ContentLink(Url.Action(nameof(ReviewPolicy)))));

            return(File(Encoding.UTF8.GetBytes(sitemapList.ToXml()), WebPathHelper.GetMimeType(".xml")));
        }
Example #6
0
        public void WriteUrl(SitemapUrl sitemapUrl)
        {
            Guard.ArgumentIsNotNull(sitemapUrl, "sitemapUrl");

            // Empty location is something that should never occurs
            if (!String.IsNullOrWhiteSpace(sitemapUrl.Location))
            {
                _xmlWriter.WriteStartElement("url");
                _xmlWriter.WriteElementString("loc", sitemapUrl.Location);

                if (sitemapUrl.LastModified.HasValue)
                {
                    var lastModified = sitemapUrl.LastModified.Value;
                    // Format of the date time should be as defined by http://www.w3.org/TR/NOTE-datetime
                    _xmlWriter.WriteElementString("lastmod", lastModified.ToString("yyyy-MM-dd", CultureInfo.InvariantCulture));
                }

                if (sitemapUrl.Frequency.HasValue)
                {
                    var changefreq = sitemapUrl.Frequency.Value.ToString().ToLower();
                    _xmlWriter.WriteElementString("changefreq", changefreq);
                }

                if (sitemapUrl.Priority.HasValue)
                {
                    var priority = sitemapUrl.Priority.Value;
                    if (Math.Abs(priority - 0.5) > 0.001)
                    {
                        _xmlWriter.WriteElementString("priority", priority.ToString(CultureInfo.InvariantCulture));
                    }

                }

                _xmlWriter.WriteEndElement();
            }
        }
Example #7
0
        public List <SitemapUrl> GetPageUrls()
        {
            List <SitemapUrl> result = new List <SitemapUrl>();

            XElement sitemap = XElement.Load(_sitemapUrl);

            XName url     = XName.Get("url", "http://www.sitemaps.org/schemas/sitemap/0.9");
            XName loc     = XName.Get("loc", "http://www.sitemaps.org/schemas/sitemap/0.9");
            XName wait    = XName.Get("wait", "http://www.mysite.com/data/blog/1.0");
            XName waitfor = XName.Get("waitfor", "http://www.mysite.com/data/blog/1.0");

            foreach (var urlElement in sitemap.Elements(url))
            {
                var locElement     = urlElement.Element(loc);
                var waitElement    = urlElement.Element(wait);
                var waitForElement = urlElement.Element(waitfor);

                SitemapUrl sitemapUrl = new SitemapUrl();
                if (locElement != null)
                {
                    sitemapUrl.Loc = locElement.Value;
                }
                if (waitElement != null)
                {
                    sitemapUrl.WaitTime = Convert.ToInt32(waitElement.Value);
                }
                if (waitForElement != null)
                {
                    sitemapUrl.WaitForElementId = waitForElement.Value;
                }

                result.Add(sitemapUrl);
            }

            return(result);
        }
        public void SitemapUrlPriorityShouldBeInvariantCulture()
        {
            var sb              = new StringBuilder();
            var responseWriter  = new StringWriter(sb);
            var contentProvider = new Mock <ISitemapContentProvider>();

            contentProvider.Setup(s => s.GetSitemapUrls(It.IsAny <Uri>()))
            .Returns(() => new List <SitemapUrl>
            {
                SitemapUrl.Create("http://localtest.me/index.html", DateTimeOffset.UtcNow, priority: 1.1)
            });

            Configure.With(c => c.UsingContentProvider(contentProvider.Object));

            var httpContext = new Mock <HttpContextBase>(MockBehavior.Loose);

            httpContext.Setup(s => s.Request).Returns(() =>
                                                      new HttpRequestWrapper(new HttpRequest("sitemap.xml", "http://localtest.me/sitemap.xml", "")));
            httpContext.Setup(s => s.Response).Returns(() => new HttpResponseWrapper(new HttpResponse(responseWriter)));

            var handler = new SitemapifyHttpHandler();

            handler.ProcessRequest(httpContext.Object);

            var document = XDocument.Parse(sb.ToString());

            var sitemapUrlElement = (from urls in
                                     document.Descendants(XName.Get("urlset", SitemapUrl.SitemapNs))
                                     .Elements(XName.Get("url", SitemapUrl.SitemapNs))
                                     select urls).First();

            var priority = sitemapUrlElement.Element(XName.Get("priority", SitemapUrl.SitemapNs));

            priority.Should().NotBeNull();
            priority.Value.Should().Be("1.1");
        }
Example #9
0
        public override List <SitemapUrl> GetUrls(int portalId, PortalSettings ps, string version)
        {
            var _eventLogController = new EventLogController();

            _eventLogController.AddLog("Message", "OpenNews SiteMap Provider being intialised", ps, -1, EventLogController.EventLogType.ADMIN_ALERT);
            List <SitemapUrl> results = new List <SitemapUrl>();
            var onMods = ModuleController.Instance.GetModulesByDefinition(PortalSettings.Current.PortalId, "dnn_OpenNewsSPA").Cast <ModuleInfo>().ToList();

            onMods.ToList().ForEach(m => {
                var urlOptions = new ModuleUrlOptions();
                UrlDataController.GetEverythingForProvider(m.TabID).ForEach(u => {
                    string url  = Globals.NavigateURL(m.TabID, ps, "", u.qsValue);
                    var pageUrl = new SitemapUrl
                    {
                        Url             = url,
                        Priority        = (float)0.5,
                        LastModified    = u.urlDate,
                        ChangeFrequency = SitemapChangeFrequency.Daily
                    };
                    results.Add(pageUrl);
                });
            });
            return(results);
        }
        public override List <SitemapUrl> GetUrls(int portalId, PortalSettings ps, string version)
        {
            var productsRepo = Factory.CreateRepo <ProductRepository>();
            var products     = productsRepo.FindAllPagedWithCache(1, int.MaxValue);

            var        urls    = new List <SitemapUrl>();
            SitemapUrl pageUrl = null;

            if (HccRequestContext.Current != null) // Localize HccRequestContext
            {
                HccRequestContext.Current = HccRequestContextUtils.GetContextWithCulture(HccRequestContext.Current, ps.CultureCode);
            }

            foreach (var product in products)
            {
                if (product.IsAvailableForSale)
                {
                    pageUrl = GetPageUrl(product);
                    urls.Add(pageUrl);
                }
            }

            return(urls);
        }
Example #11
0
        public override List <SitemapUrl> GetUrls(int portalID, PortalSettings ps, string version)
        {
            var sitemapUrls = new List <SitemapUrl>();

            var objDesktopModule = default(DesktopModuleInfo);

            objDesktopModule = DesktopModuleController.GetDesktopModuleByModuleName("DNN_Events", portalID);

            var objModules          = new ModuleController();
            var objModule           = default(ModuleInfo);
            var lstModules          = objModules.GetModulesByDefinition(portalID, objDesktopModule.FriendlyName);
            var moduleIds           = new ArrayList();
            var visibleModuleIds    = new ArrayList();
            var visibleTabModuleIds = new ArrayList();

            foreach (ModuleInfo tempLoopVar_objModule in lstModules)
            {
                objModule = tempLoopVar_objModule;
                var objTabPermissions = TabPermissionController.GetTabPermissions(objModule.TabID, portalID);
                var objTabPermission  = default(TabPermissionInfo);

                foreach (TabPermissionInfo tempLoopVar_objTabPermission in objTabPermissions)
                {
                    objTabPermission = tempLoopVar_objTabPermission;

                    if (objTabPermission.PermissionKey == "VIEW" && objTabPermission.RoleName != "" &&
                        objTabPermission.AllowAccess && (objTabPermission.RoleID == -1) |
                        (objTabPermission.RoleID == -3))
                    {
                        if (objModule.InheritViewPermissions)
                        {
                            visibleTabModuleIds.Add("Tab" + objModule.TabID + "Mod" + objModule.ModuleID);
                            visibleModuleIds.Add(objModule.ModuleID);
                            break;
                        }

                        var objModulePermission = default(ModulePermissionInfo);
                        // ReSharper disable LoopCanBeConvertedToQuery
                        foreach (ModulePermissionInfo tempLoopVar_objModulePermission in objModule.ModulePermissions)
                        {
                            objModulePermission = tempLoopVar_objModulePermission;
                            // ReSharper restore LoopCanBeConvertedToQuery
                            if (objModulePermission.PermissionKey == "VIEW" && objModulePermission.RoleName != "" &&
                                objModulePermission.AllowAccess && (objModulePermission.RoleID == -1) |
                                (objModulePermission.RoleID == -3))
                            {
                                visibleTabModuleIds.Add("Tab" + objModule.TabID + "Mod" + objModule.ModuleID);
                                visibleModuleIds.Add(objModule.ModuleID);
                                break;
                            }
                        }
                    }
                }
            }
            foreach (ModuleInfo tempLoopVar_objModule in lstModules)
            {
                objModule = tempLoopVar_objModule;

                // This check for objModule = Nothing because of error in DNN 5.0.0 in GetModulesByDefinition
                if (ReferenceEquals(objModule, null))
                {
                    continue;
                }

                if (objModule.IsDeleted)
                {
                    continue;
                }

                if (moduleIds.Contains(objModule.ModuleID))
                {
                    continue;
                }

                if (!visibleTabModuleIds.Contains("Tab" + objModule.TabID + "Mod" + objModule.ModuleID))
                {
                    continue;
                }

                moduleIds.Add(objModule.ModuleID);
                var settings = EventModuleSettings.GetEventModuleSettings(objModule.ModuleID, null);
                if (!settings.EnableSitemap)
                {
                    continue;
                }

                if (settings.SocialGroupModule == EventModuleSettings.SocialModule.UserProfile)
                {
                    continue;
                }

                var iCategoryIDs = new ArrayList();
                if (settings.Enablecategories == EventModuleSettings.DisplayCategories.DoNotDisplay)
                {
                    iCategoryIDs = settings.ModuleCategoryIDs;
                }
                else
                {
                    iCategoryIDs.Add("-1");
                }

                var ilocationIDs = new ArrayList();
                if (settings.Enablelocations == EventModuleSettings.DisplayLocations.DoNotDisplay)
                {
                    ilocationIDs = settings.ModuleLocationIDs;
                }
                else
                {
                    ilocationIDs.Add("-1");
                }

                var objEventTimeZoneUtilities = new EventTimeZoneUtilities();
                var currDate    = objEventTimeZoneUtilities.ConvertFromUTCToModuleTimeZone(DateTime.UtcNow, settings.TimeZoneId);
                var dtStartDate = DateAndTime.DateAdd(DateInterval.Day, Convert.ToDouble(-settings.SiteMapDaysBefore), currDate);
                var dtEndDate   = DateAndTime.DateAdd(DateInterval.Day, settings.SiteMapDaysAfter, currDate);

                var objEventInfoHelper = new EventInfoHelper(objModule.ModuleID, objModule.TabID, portalID, settings);

                var lstevents = default(ArrayList);
                lstevents = objEventInfoHelper.GetEvents(dtStartDate, dtEndDate, settings.MasterEvent, iCategoryIDs, ilocationIDs, -1, -1);

                var objEvent = default(EventInfo);

                foreach (EventInfo tempLoopVar_objEvent in lstevents)
                {
                    objEvent = tempLoopVar_objEvent;
                    if (settings.Enforcesubcalperms && !visibleModuleIds.Contains(objEvent.ModuleID))
                    {
                        continue;
                    }
                    var pageUrl = new SitemapUrl();
                    pageUrl.Url             = objEventInfoHelper.DetailPageURL(objEvent, false);
                    pageUrl.Priority        = settings.SiteMapPriority;
                    pageUrl.LastModified    = objEvent.LastUpdatedAt;
                    pageUrl.ChangeFrequency = SitemapChangeFrequency.Daily;
                    sitemapUrls.Add(pageUrl);
                }
            }

            return(sitemapUrls);
        }
        public override List <SitemapUrl> GetUrls(int portalId, PortalSettings ps, string version)
        {
            CultureInfo current   = Thread.CurrentThread.CurrentCulture;
            CultureInfo currentUI = Thread.CurrentThread.CurrentUICulture;

            BBStoreController controller = new BBStoreController();
            List <SitemapUrl> retVal     = new List <SitemapUrl>();

            ModuleController moduleController = new ModuleController();
            ArrayList        mods             = moduleController.GetModules(portalId);

            // Lets build the Languages Collection
            LocaleController            lc  = new LocaleController();
            Dictionary <string, Locale> loc = lc.GetLocales(PortalSettings.Current.PortalId);

            // Productgroups
            foreach (var mod in mods)
            {
                ModuleInfo modInfo = (ModuleInfo)mod;
                if (modInfo.ModuleDefinition.FriendlyName == "BBStore Product Groups")
                {
                    bool fixedRoot = (modInfo.ModuleSettings["RootLevelFixed"] != null && Convert.ToBoolean(modInfo.ModuleSettings["RootLevelFixed"]));
                    int  rootLevel = (modInfo.ModuleSettings["RootLevel"] != null ? Convert.ToInt32(modInfo.ModuleSettings["RootLevel"]) : -1);
                    List <ProductGroupInfo> productGroups = new List <ProductGroupInfo>();
                    if (rootLevel > -1 && fixedRoot)
                    {
                        productGroups.Add(controller.GetProductGroup(portalId, rootLevel));
                    }
                    else if (rootLevel > -1 && !fixedRoot)
                    {
                        productGroups = controller.GetProductSubGroupsByNode(portalId, "en-US", rootLevel, false, false, false);
                    }
                    else if (rootLevel == -1 && fixedRoot)
                    {
                        productGroups.Add(new ProductGroupInfo()
                        {
                            ProductGroupId = -1
                        });
                    }
                    else
                    {
                        productGroups = controller.GetProductGroups(portalId);
                    }

                    List <ProductGroupInfo> sortedGroups = productGroups.OrderBy(p => p.ProductGroupId).ToList();
                    foreach (ProductGroupInfo productGroup in sortedGroups)
                    {
                        foreach (KeyValuePair <string, Locale> lang in loc)
                        {
                            // Set language to product Language
                            Thread.CurrentThread.CurrentCulture   = CultureInfo.CreateSpecificCulture(lang.Key);
                            Thread.CurrentThread.CurrentUICulture = new CultureInfo(lang.Key);

                            // Lets check if we already have this
                            string name = "", url = "";
                            ProductGroupLangInfo pgl = controller.GetProductGroupLang(productGroup.ProductGroupId, lang.Key);
                            if (pgl != null)
                            {
                                name = HttpUtility.UrlEncode(pgl.ProductGroupName);
                            }
                            if (name != String.Empty)
                            {
                                url = Globals.NavigateURL(modInfo.TabID, "", "productGroup=" + productGroup.ProductGroupId.ToString(), "name=" + name);
                            }
                            else
                            {
                                url = Globals.NavigateURL(modInfo.TabID, "", "productGroup=" + productGroup.ProductGroupId.ToString());
                            }
                            if (retVal.Find(r => r.Url == url) == null)
                            {
                                var pageUrl = new SitemapUrl
                                {
                                    Url             = url,
                                    Priority        = (float)0.5,
                                    LastModified    = DateTime.Now.AddDays(-1),
                                    ChangeFrequency = SitemapChangeFrequency.Daily
                                };
                                retVal.Add(pageUrl);
                            }
                        }
                    }
                }
            }

            foreach (var mod in mods)
            {
                // First we need to know where our ProductModule sits
                ModuleInfo modInfo = (ModuleInfo)mod;
                if (modInfo.ModuleDefinition.FriendlyName == "BBStore Product" || modInfo.ModuleDefinition.FriendlyName == "BBStore Simple Product")
                {
                    int tabId = modInfo.TabID;

                    int productId = -1;
                    if (modInfo.ModuleSettings["ProductId"] != null)
                    {
                        productId = Convert.ToInt32(modInfo.ModuleSettings["ProductId"]);
                    }

                    if (productId < 0)
                    {
                        // We've got a dynamic module ! Here we show all products that are not disbaled !
                        List <SimpleProductInfo> products = controller.GetSimpleProducts(portalId).FindAll(p => p.Disabled == false);
                        foreach (SimpleProductInfo product in products)
                        {
                            foreach (KeyValuePair <string, Locale> lang in loc)
                            {
                                // Set language to product Language
                                Thread.CurrentThread.CurrentCulture   = CultureInfo.CreateSpecificCulture(lang.Key);
                                Thread.CurrentThread.CurrentUICulture = new CultureInfo(lang.Key);

                                // Lets check if we already have this
                                string name = "", url = "";
                                SimpleProductLangInfo spl = controller.GetSimpleProductLang(product.SimpleProductId, lang.Key);
                                if (spl != null)
                                {
                                    name = HttpUtility.UrlEncode(spl.Name);
                                }
                                if (name != string.Empty)
                                {
                                    url = Globals.NavigateURL(tabId, "", "productid=" + product.SimpleProductId.ToString(), "name=" + name);
                                }
                                else
                                {
                                    url = Globals.NavigateURL(tabId, "", "productid=" + product.SimpleProductId.ToString());
                                }

                                if (retVal.Find(r => r.Url == url) == null)
                                {
                                    var pageUrl = new SitemapUrl
                                    {
                                        Url             = url,
                                        Priority        = (float)0.3,
                                        LastModified    = product.LastModifiedOnDate,
                                        ChangeFrequency = SitemapChangeFrequency.Daily
                                    };
                                    retVal.Add(pageUrl);
                                }
                            }
                        }
                    }
                    else
                    {
                        // This is a fixed module !
                        SimpleProductInfo product = controller.GetSimpleProductByProductId(portalId, productId);
                        foreach (KeyValuePair <string, Locale> lang in loc)
                        {
                            // Set language to product Language
                            Thread.CurrentThread.CurrentCulture   = CultureInfo.CreateSpecificCulture(lang.Key);
                            Thread.CurrentThread.CurrentUICulture = new CultureInfo(lang.Key);

                            // Lets check if we already have this
                            string name = "", url = "";
                            SimpleProductLangInfo spl = controller.GetSimpleProductLang(productId, lang.Key);
                            if (spl != null)
                            {
                                name = HttpUtility.UrlEncode(spl.Name);
                            }
                            if (name != string.Empty)
                            {
                                url = Globals.NavigateURL(tabId, "", "name=" + name);
                            }
                            else
                            {
                                url = Globals.NavigateURL(tabId);
                            }

                            if (retVal.Find(r => r.Url == url) == null)
                            {
                                var pageUrl = new SitemapUrl
                                {
                                    Url             = url,
                                    Priority        = (float)0.4,
                                    LastModified    = product.LastModifiedOnDate,
                                    ChangeFrequency = SitemapChangeFrequency.Daily
                                };
                                retVal.Add(pageUrl);
                            }
                        }
                    }
                }

                // Reset values
                Thread.CurrentThread.CurrentCulture   = current;
                Thread.CurrentThread.CurrentUICulture = currentUI;
            }
            return(retVal);
        }
 public void Create(SitemapUrl url)
 {
     _context.SitemapUrls.Add(url);
     _context.SaveChanges();
 }