Blog posts by Sunylcumar blog

Render ContentArea without wrapping them in surrounding div

Sun, 18 May 2025 14:31:41 GMT

CustomContentAreaRenderer is a specialized class that overrides the default ContentAreaRenderer. It customizes the rendering behavior for content area items, specifically by rendering content items without wrapping them in a surrounding <div> element, which is typically used in the default implementation.

public class CustomContentAreaRenderer : ContentAreaRenderer
{
    protected override void RenderContentAreaItem(
    IHtmlHelper htmlHelper,
    ContentAreaItem contentAreaItem,
    string templateTag,
    string htmlTag,
    string cssClass)
    {
        if (contentAreaItem == null)
        {
            return;
        }

        var content = contentAreaItem.LoadContent();
        if (content == null)
        {
            return;
        }

        // Directly render the content item without surrounding div
        htmlHelper.RenderContentData(content, false);
    }
}

Indexing a content item programatically

Sun, 18 May 2025 14:26:27 GMT

public bool IndexContent(int contentId, bool contentOnly, bool childrenOnly, string language)
{
    // Retrieve the content
    var contentReference = new ContentReference(contentId);
    var contentItems = new List<IContent>();

    if (contentReference != null && contentReference != ContentReference.EmptyReference)
    {
        if (contentOnly)
        {
            var contentItem = _contentRepository.Get<IContent>(contentReference);
            try
            {
                // Index the content
                _contentIndexer.Index(contentItem);
                return true;
            }
            catch (Exception ex)
            {
                _logger.Error($"Error in IndexContent, exception is {ex}");
                return false;
            }
        }
        else
        {
            if (childrenOnly)
            {
                //Get the children of the content
                var children = _contentRepository.GetChildren<IContent>(contentReference);
                if (children != null && children.Any())
                    contentItems = children.ToList();
            }
            else
            {
                //Get the descendants of the content
                var descendants = _contentRepository.GetDescendents(contentReference).Select(_contentRepository.Get<IContent>);
                if (descendants != null && descendants.Any())
                    contentItems = descendants.ToList();
            }
            // Save the updated content
            if (contentItems != null && contentItems.Count > 0)
            {
                foreach (var contentItem in contentItems)
                {
                    try
                    {
                        // Index the content
                        _contentIndexer.Index(contentItem);
                    }
                    catch (Exception ex)
                    {
                        _logger.Error($"Error in IndexContent, exception is {ex}");
                    }
                }
                return true;
            }
        }
    }
    return false;
}

Add a new menu item to the Admin Menu in Optimizely CMS

Sun, 18 May 2025 14:10:36 GMT

Create a new Controller called CustomMenuController and decorate with [Authorize(Roles ="CMSAdmins")] so that it will be accessed by admins only

namespace AdminMenu.Controllers
{
    [Route("episerver/CustomMenu")]
    [Authorize(Roles ="CMSAdmins")]
    public class CustomMenuController : Controller
    {
        [HttpGet("")]
        public IActionResult Index()
        {
            return View("~/Views/CustomMenu /Index.cshtml");
        }     
    }
}

Create a view under Views/CustomMenu/Index.cshtml for the controller

@{
Layout = null;
}
<html lang="en">
<head>    
    <title>Custom Menu</title>
    <meta charset="utf-8">
    <meta http-equiv="X-UA-Compatible" content="IE=Edge" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <link rel="shortcut icon" href="/Util/images/favicon.ico" type="image/x-icon" />
    <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.0/dist/css/bootstrap.min.css" rel="stylesheet">
</head>

 <body>
    @Html.AntiForgeryToken()
    @Html.Raw(Html.CreatePlatformNavigationMenu())
    <div class="margin-100">
        <div class="container mt-5">
          <h1>This is a custom menu example</h1>
          <p>Custom menu implementation</p>
       </div> 
     </div>  
    <required-client-resources area="Footer" />
</body>
</html>

Create a new class called MenuItem that inherits IMenuProvider

namespace FEO.CMS.Global.Business.MenuProviders
{
    [MenuProvider]
    public class CustomMenuProvider : IMenuProvider
    {
        public IEnumerable<MenuItem> GetMenuItems()
        {
            var menuItems = new List<MenuItem>();

            menuItems.Add(new UrlMenuItem("Custom Admin Menu",
              "/global/cms/CustomAdminMenu",
             "/EPiServer/CustomMenu")
            {
                SortIndex = SortIndex.First + 25,
                AuthorizationPolicy = CmsPolicyNames.CmsAdmin
            });
            return menuItems;
        }
       
    }
}

Thats all, run the application and you can find a new menu item under the admin menu

Helper method to encode query string properly

Tue, 13 May 2025 09:26:19 GMT

When using Url.ContentUrl() in Optimizely 12, encodes spaces as + in the query string. If you want to encode the spaces as %20, use the below helper method.

 public static string GetEncodedUrl(string href)
 {
     var decodedHref = System.Web.HttpUtility.UrlDecode(href);
     int questionMarkIndex = decodedHref.IndexOf('?');
     string path = questionMarkIndex >= 0 ? decodedHref.Substring(0, questionMarkIndex) : decodedHref;
     var relativeUrl = UrlResolver.GetUrl(path);
     string query = questionMarkIndex >= 0 ? decodedHref.Substring(questionMarkIndex + 1).Replace("&amp;", "&") : string.Empty;     
     var encodedQuery = !string.IsNullOrEmpty(query) ? $"?{Uri.EscapeUriString(query)}" : query;
     return $"{relativeUrl}{encodedQuery}";
 }

Get ContentReference from GUID

Tue, 13 May 2025 09:23:02 GMT

Optimizely CMS 12 provides a Utility function to retrieve Content Reference from a Guid by ussing the below static method.

var contentReference = PermanentLinkUtility.FindContentReference(new Guid("9812C961-4A51-4C8C-9580-0DED7764C1B2"));

Creating a Dropdownlist in Optimizely CMS: Populate ISelectionFactory with values from another block's properties

Mon, 12 May 2025 14:28:46 GMT

Create a Block to hold selection options

using EPiServer.Cms.Shell.UI.ObjectEditing.EditorDescriptors;
using EPiServer.PlugIn;
using EPiServer.Shell.ObjectEditing;
using System.ComponentModel.DataAnnotations;
namespace MyApp.Models.Blocks
{
    [ContentType(DisplayName = "Select Options Block", Description = "")]
    public class SelectOptionsBlock : BlockData
    {
        [CultureSpecific]     
        [Display(Name = "Selection Options", Description = "List of options for the selection list.",  GroupName = SystemTabNames.Content, Order = 100)]
        [EditorDescriptor(EditorDescriptorType = typeof(CollectionEditorDescriptor<SelectionOption>))]
        public virtual IList<SelectionOption> SelectionOptions { get; set; }
    }

    public class SelectionOption
    {
        public string Text { get; set; }
        public string Value { get; set; }
    }

    [PropertyDefinitionTypePlugIn]
    public class SelectionOptionProperty : PropertyList<SelectionOption> { }

}

Create a page where you want to have the selection list and add the following 2 properties

namespace MyApp.Models.Pages
{
    [ContentType(DisplayName = "SelectionList Page", Description = "Page with a selection list populated from a block.", GroupName = SiteGroupNames.Specialized)]
    public class SelectionListPage : PageData
    {
        [CultureSpecific]
        [Display(Name = "Select Options Block", Description = "", GroupName = SystemTabNames.Content, Order = 1)]
        [AllowedTypes(typeof(SelectOptionsBlock))]
        public virtual ContentReference SelectOptionsBlockContent { get; set; }

        [CultureSpecific]
        [Display(Name = "Select List", Description = "",  GroupName = SystemTabNames.Content,  Order = 1)]
        [SelectOne(SelectionFactoryType = typeof(ItemSelectionFactory))]
        public virtual string SelectList { get; set; }
    }
}

Now create a selection list factory

using EPiServer.ServiceLocation;
using EPiServer.Shell.ObjectEditing;
using SVP.Models.Blocks;
namespace MyApp.Business.SelectionFactories
{
    public class ItemSelectionFactory : ISelectionFactory
    {
        public IEnumerable<ISelectItem> GetSelections(ExtendedMetadata metadata)
        {
            var loader = ServiceLocator.Current.GetInstance<IContentLoader>();
            var list = new List<SelectItem>();  
            dynamic contentMetadata = metadata;
            var ownerContent = contentMetadata.OwnerContent as IContent;            
            //create a dynamic object of current content type
            dynamic parentItem = ownerContent;
            //check if the block containing the select options is added to the current content (page or block)
            if (parentItem.SelectOptionsBlockContent != null)
            {
                //Get the block containing select options
                var optionsBlock = loader.Get<SelectOptionsBlock> parentItem.SelectOptionsBlockContent);
                //check if the optionsBlock has any items
                if (optionsBlock.SelectionOptions != null && optionsBlock.SelectionOptions.Count > 0)
                {
                    foreach (var listItem in optionsBlock.SelectionOptions)
                    {
                        list.Add(new SelectItem() { Text = listItem.Text, Value = listItem.Value });
                    }
                }
            }
            return list;
        }
    }
}

From the CMS, create a new block of type SelectOptionsBlock and add the necessary select options and publish it.

Select this newly created block in your page that you have created to have the selection list and publish the page.

Custom Sitemap.xml generator in Optimizely CMS 12

Tue, 07 Jan 2025 13:07:15 GMT

This is a step by step guide to generate sitemap.xml file for all the sites in optimizely cms 12. The sitemaps are generated under wwwroot/sitemaps with the name of the site configured.

Step 1: Add a new field in Home Page to store the name of the sitemap file

Step 2: Create an interface for Sitemap generator service

Step 3: Implement the interface with sitemap generation logic

Step 4: Register the Service in startup.cs

Step 5: Create a scheduled job that will run the sitemap generator service

Step 6: Create a Controlller that will serve sitemap

Step 7: Access the sitemap using the the url for example https://localhost:5000/seo-sitemap.xml

Home.cs

namespace CustomSitemap.Web.Pages
{
    [ContentType(DisplayName = "Home Page", GroupName = "Corporate", GUID = "8F0896B1-E3F2-4E8C-81AC-4FE52C519402")]
    public class HomePage : PageData
    {        
        [Display(Name = "SEO sitemap.xml file name",
            Description = "Provide meaning full name for SEO sitemap like site-sitemap.xml",
          GroupName = SystemTabNames.Settings,
          Order = 550)]
        public virtual string SitemapFileName { get; set; }
    }
}

ISitemapGeneratorService.cs

namespace CustomSitemap.Web.Business.Sitemap
{
    public interface ISitemapGeneratorService
    {
        IEnumerable<SiteDefinition> GetAllSites();
        bool GenerateSitemaps();
        void DeleteSitemaps();
    }
}

SitemapGeneratorService.cs

using EPiServer.Filters;
using EPiServer.Web;
using EPiServer.Web.Routing;
using EPiServer.Logging;
using System.Globalization;
using CustomSitemap.Web.Business.Extensions;

namespace CustomSitemap.Web.Business.Sitemap
{
 /// <summary>
/// Get the site names from configuration and generate sitemap with the sitename and save to wwwroot/sitemaps
/// </summary>    
public class SitemapGeneratorService : ISitemapGeneratorService
    {
        private readonly IContentLoader _contentLoader;
        private readonly IContentRepository _contentRepository;
        private readonly UrlResolver _urlResolver;
        private readonly ISiteDefinitionRepository _siteDefinitionRepository;
        private readonly ILanguageBranchRepository _languageBranchRepository;
        private readonly IWebHostEnvironment _webHostingEnvironment;
        private readonly EPiServer.Logging.ILogger _logger;

        /// <summary>
        /// constructor
        /// </summary>
        /// <param name="contentLoader"></param>
        /// <param name="urlResolver"></param>
        /// <param name="siteDefinitionRepository"></param>
        public SitemapGeneratorService(
            IContentLoader contentLoader,
            IContentRepository contentRepository,
            UrlResolver urlResolver,
            ISiteDefinitionRepository siteDefinitionRepository,
            ILanguageBranchRepository languageBranchRepository,
            IWebHostEnvironment webHostingEnvironment) 
        {
            _contentLoader = contentLoader;
            _contentRepository = contentRepository;
            _urlResolver = urlResolver;
            _siteDefinitionRepository = siteDefinitionRepository;
            _languageBranchRepository = languageBranchRepository;
            _webHostingEnvironment = webHostingEnvironment;
            _logger = LogManager.GetLogger(typeof(SitemapGeneratorService));
        }

        /// <summary>
        /// List all the sites created in optimizely cms
        /// </summary>
        /// <returns></returns>
        public IEnumerable<SiteDefinition> GetAllSites()
        {
            return _siteDefinitionRepository.List();
        }
        
        public void DeleteSitemaps()
        {
            // Get the path to the wwwroot folder
            var wwwrootPath = _webHostingEnvironment.WebRootPath;
            
            // Check if the directory exists
            if (!Directory.Exists(wwwrootPath))
                return;

            // Get the path for sitemap files wwwroot/sitemaps
            var sitemapsPath = Path.Combine(_webHostingEnvironment.WebRootPath, "sitemaps");            
            var sitemapFiles = Directory.GetFiles(sitemapsPath, "*sitemap.xml", SearchOption.TopDirectoryOnly);

            foreach (var file in sitemapFiles)
            {
                try
                {
                    // Delete each file
                    File.Delete(file);
                    _logger.Warning($"Deleted: {file}");
                }
                catch (Exception ex)
                {
                    // Log the error or handle it as needed
                    _logger.Error($"Error deleting file {file}: {ex.Message}");
                }
            }
        }

        public bool GenerateSitemaps()
        {
            try
            {
                //Delete already created sitemap files
                DeleteSitemaps();

                // Iterate over all sites and generate sitemaps
                foreach (var siteDefinition in GetAllSites())
                {
                    //get the start page for the current site
                    var startPage = _contentLoader.Get<PageData>(siteDefinition.StartPage);                    
                    
                    //get the url of the host
                    var primaryHostUrl = siteDefinition.Hosts.FirstOrDefault(host => host.Type == HostDefinitionType.Primary).Url;

                    //generate sitemap
                    var sitemapContent = GenerateSitemapForSite(startPage, primaryHostUrl);

                    // Save the generated sitemap.xml to a specified location
                    var sitemapPath = Path.Combine(_webHostingEnvironment.WebRootPath, "sitemaps", siteDefinition.Name.Replace(" ", "-").ToLower() + "-sitemap.xml");
                    File.WriteAllText(sitemapPath, sitemapContent);
                }

                return true;
            }
            catch
            {
                return false;
            }
        }

        private string GenerateSitemapForSite(PageData startPage, Uri primaryHostUrl)
        {
            var publishedFilter = new FilterPublished();
            var accessFilter = new FilterAccess();
            var sitemapEntries = new List<string>();

            //var availablePageLanguages = FilterForVisitor.Filter(pageLanguagesBranches).OfType<PageData>();
            //var currentPageLanguages = availablePageLanguages.Select(page => page.Language.Name).ToList();

           //Get the available languages for the start page of the site
            var pageLanguagesBranches = _contentRepository.GetLanguageBranches<PageData>(startPage.ContentLink).ToList();
            
            //var hostname = startPage.
            foreach (var availablePage in pageLanguagesBranches)
            {
                var culture = new CultureInfo(availablePage.Language.Name);                
                
                //Add home page to the sitemap
                var homePageUrl = _urlResolver.GetUrl(availablePage.ContentLink, availablePage.Language.Name);
                sitemapEntries.Add($"<url><loc>{homePageUrl}</loc><lastmod>{Convert.ToDateTime(availablePage.GetLastPublishDate()).ToString("yyyy-MM-ddTHH:mm:sszzz")}</lastmod><priority>0.80</priority></url>");

                //get the children of the home page
                var pages = _contentLoader.GetDescendents(availablePage.ContentLink);

                foreach (var pageLink in pages)
                {
                    if (_contentLoader.TryGet(pageLink, culture, out PageData page))
                    {
                        //check if the page is set to exclude from sitemap 
                        bool excludeFromSitemap = bool.TryParse(page["ExcludeFromSitemap"] as string, out bool result);

                        //if the page is published, is allowed in the sitemap and is not a shortcut
                        if (!publishedFilter.ShouldFilter(page) && !accessFilter.ShouldFilter(page) && !excludeFromSitemap && page.LinkType != PageShortcutType.Shortcut)
                        {
                            var url = _urlResolver.GetUrl(page.ContentLink, availablePage.Language.Name);
                            if (!string.IsNullOrEmpty(url))
                            {
                                sitemapEntries.Add($"<url><loc>{url}</loc><lastmod>{Convert.ToDateTime(page.GetLastPublishDate()).ToString("yyyy-MM-ddTHH:mm:sszzz")}</lastmod><priority>0.64</priority></url>");
                            }
                        }
                    }
                }
            }

            return $"<urlset xmlns=\"http://www.sitemaps.org/schemas/sitemap/0.9\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xsi:schemaLocation=\"http://www.sitemaps.org/schemas/sitemap/0.9 http://www.sitemaps.org/schemas/sitemap/0.9/sitemap.xsd\">{string.Join("", sitemapEntries)}</urlset>";
        }
    }
}

Startup.cs

public void ConfigureServices(IServiceCollection services)
{
	services.AddTransient<ISitemapGeneratorService, SitemapGeneratorService>();
	services.AddCms();
}

SitemapGeneratorJob.cs

namespace CustomSitemap.Web.Business.ScheduledJobs
{
    /// <summary>
    /// Scheduled job for generating SEO sitemaps.
    /// </summary>
    [ScheduledPlugIn(DisplayName = "Generate SEO Sitemaps", Description = "Generates sitemap for each site", GUID = "5C3DDEC2-0CD5-4734-B8EE-FDA8BE08C46E")]
    public class SitemapGeneratorJob : ScheduledJobBase
    {
        private readonly EPiServer.Logging.ILogger _logger;        
        private ISitemapGeneratorService _sitemapGeneratorService;
        private readonly IWebHostEnvironment _environment;
        private bool _stopSignaled;
        /// <summary>
        /// Default constructor
        /// </summary>
        /// <param name="siteConfigService"></param>
        public SitemapGeneratorJob(
            ISitemapGeneratorService sitemapGeneratorService,
            IWebHostEnvironment environment)
        {
            _sitemapGeneratorService = sitemapGeneratorService;
            _logger = LogManager.GetLogger(typeof(SitemapGeneratorJob));
            IsStoppable = true;
            _environment = environment;
        }

        /// <summary>
        /// stop
        /// </summary>
        public override void Stop()
        {
            _stopSignaled = true;
        }

        /// <summary>
        /// Set the primary hosts
        /// </summary>
        /// <returns></returns>
        public override string Execute()
        {
            OnStatusChanged("Starting execution of SitemapGeneratorJob");

            _logger.Information("Starting the job : SitemapGeneratorJob");

            //Call the method to Generate Sitemaps

            if (_environment.IsDevelopment())
            {
                _logger.Information($"Current environment is {_environment.EnvironmentName}");
                _logger.Warning($"This job is not intended to run on the environment {_environment.EnvironmentName}");
                return "SitemapGeneratorJob will not run in development environment";
            }
            var status = _sitemapGeneratorService.GenerateSitemaps();

            if (!status)
                return "SitemapGeneratorJob did not run successfully. Please check the logs for more information";

            if (_stopSignaled)
            {                
                return "SitemapGeneratorJob was stopped";
            }

            return "SitemapGeneratorJob completed successfully";
        }
    }
}

SitemapController.cs

namespace CustomSitemap.Web.Controllers
{
    /// <summary>
    /// controller to get SEO sitemap or regular xml file.
    /// </summary>
    [Route("{sitemapName}.xml")]
    public class SitemapController : Controller
    {
        private readonly IWebHostEnvironment _webHostEnvironment;
        private readonly ISiteDefinitionResolver _siteDefinitionResolver;
        private readonly IHttpContextAccessor _httpContextAccessor;
        private readonly IContentLoader _contentLoader;
        
        public SitemapController(IWebHostEnvironment webHostEnvironment,
            ISiteDefinitionResolver siteDefinitionResolver,
            IHttpContextAccessor httpContextAccessor,
            IContentLoader contentLoader)
        {
            _webHostEnvironment = webHostEnvironment;
            _siteDefinitionResolver = siteDefinitionResolver;
            _httpContextAccessor = httpContextAccessor;
            _contentLoader = contentLoader;
        }

        /// <summary>
        /// action method to serve sitemap or any xml file
        /// </summary>
        /// <param name="sitemapName"></param>
        /// <returns></returns>
        [HttpGet]
        public IActionResult Index(string sitemapName)
        {
            if (!string.IsNullOrEmpty(sitemapName) && !sitemapName.ToLower().EndsWith(".xml"))
            {
                sitemapName = $"{sitemapName}.xml";
            }

            //get the start page for the site
            var startPage = _contentLoader.Get<PageData>(ContentReference.StartPage);
            //read the sitemap file name from the home page
            var sitemapFileName = startPage["SitemapFileName"] as string;            

            //if the requested file name is same as sitemap file name configured in home page or if it is not configured but it is sitemap.xml
            if ((!string.IsNullOrEmpty(sitemapFileName) && sitemapFileName.Equals(sitemapName, StringComparison.OrdinalIgnoreCase)) || (string.IsNullOrEmpty(sitemapFileName) && sitemapName.ToLower().Equals("sitemap.xml")))
            {
                var httpContext = _httpContextAccessor.HttpContext;
                if (httpContext == null)
                {
                    return NotFound();
                }

                // Attempt to resolve the site by host
                var currentSite = _siteDefinitionResolver.GetByHostname(httpContext.Request.Host.Host, true);

                // Fallback to hostname with port
                if (currentSite == null)
                {
                    var hostWithPort = httpContext.Request.Host.Value; // Host with port, e.g., "localhost:5000"
                    currentSite = _siteDefinitionResolver.GetByHostname(hostWithPort, true);
                }

                //get the sitemap from wwwroot/sitemaps
                var filePath = Path.Combine(_webHostEnvironment.WebRootPath, "sitemaps", currentSite.Name.Replace(" ", "-").ToLower() + "-sitemap.xml");
                if (!System.IO.File.Exists(filePath))
                {
                    return NotFound();
                }

                //read the contents of the sitemap file and return
                var fileContent = System.IO.File.ReadAllText(filePath);
                return Content(fileContent, "application/xml");
            }
            else
            {
                //this is not a sitemap file, so try getting the requested file from wwwroot
                var filePath = Path.Combine(_webHostEnvironment.WebRootPath, sitemapName);
                if (!System.IO.File.Exists(filePath))
                {
                    return NotFound();
                }
                
                //return the requested file
                var fileContent = System.IO.File.ReadAllText(filePath);
                return Content(fileContent, "application/xml");
            }
        }
    }
}