Emesa Solutions

How to write your own language resolver and link manager in Sitecore

Tarek — Thu, 08 Mar 2012 20:03:02 +0000

Sometimes you may have to customize the site URLs depending on the language and Sitecore offers a way to do that in the LinkManager item in the web.config file but it’s very basic and so this is one case where you would want to create your own Language Resolver and Link Manager classes.

Let’s take a look at the default link manager item in the web.config file

Let’s say we have a bilingual site, English (en) and French Canadian (fr-CA), and we want the URLs to look like this:

en: http://website.com/AboutUs.aspx
fr-CA: http://website.com/fr/AboutUs.aspx

We can’t accomplish that with the default link manager, because if the languageEmbedding = always, the URL’s would look like this:

en: http://website.com/en/AboutUs.aspx
fr-CA: http://website.com/fr-CA/AboutUs.aspx

The solution is to write our own language resolver class that would resolve the “fr” to “fr-CA” and not providing a language would set the language to English.

Language Resolver

We need two things:

Set the languageEmbedding property in the LinkManager to “always”
Create our language resolver class
Patch the web.config file

Set the languageEmbedding property in the LinkManager to “always”

For now, change the property to “always” in the web.config. We will create our own later on and patch the config but for now we need it to test our language resolver class.

Create our language resolver class

Create a new class in your project and inherit it from “HttpRequestProcessor”, here’s the code:

using Sitecore.Data.Managers;
using Sitecore.Pipelines.HttpRequest;
using Sitecore.Web;

namespace Sitecore.Starterkit.Helpers
{
    public class DemoLanguageResolver : HttpRequestProcessor
    {
        public override void Process(HttpRequestArgs args)
        {
            // args.Context.Request.RawUrl = "/fr-CA/Services.aspx?sc_lang=en"

            var languageName = WebUtil.ExtractLanguageName(args.Context.Request.RawUrl);

            var languageParameter = WebUtil.ExtractUrlParm("sc_lang", args.Context.Request.RawUrl);

            var language = string.IsNullOrEmpty(languageParameter) ? languageName : languageParameter;

            Context.Language = LanguageManager.GetLanguage(language.StartsWith("fr") ? "fr-CA" : "en");
        }
    }
}

I used the “WebUtil” class to extract the language name and “sc_lang” parameter, which changes the language in Sitecore.

All what I’m doing is checking to see if the language is passed in the parameter or embedded in the URL, extract it then check if it starts with “fr”, if so use “fr-CA” otherwise use “en”.

Patch the web.config file

The default language resolver is defined in the web.config file in under “pipelines > httpRequestBegin”

Create a new config file and call it “LanguageResolver.config” (this could be named anything) in [\Website\App_Config\Include] and add the following:

We delete the existing processor then add ours to the list right after the DeviceResolver.

Rebuild the project. If we browse the site and go to (some page in your site) “http://website.com/AboutUs.aspx” we get the English version and “http://website.com/fr/AboutUs.aspx” we get the French Canadian version.

The only problem left is the links generated for the items on the site will still use the old URLs with “en” and “fr-CA” embedded.

Link Manager

Create our link manager class
Patch the web.config file

Create our link manager class

Create a new class in your project and inherit it from “LinkProvider”, here’s the code:

using Sitecore.Data.Items;
using Sitecore.Links;

namespace Sitecore.Starterkit.Helpers
{
    public class DemoLinkManager : LinkProvider
    {
        public override string GetItemUrl(Item item, UrlOptions options)
        {
            var url = base.GetItemUrl(item, options);

            url = url.Contains("/en/") ?
                    url.Replace("/en/", "/") :
                    url.Replace("/en.aspx", "/en");

            url = url.Contains("/fr-CA/") ?
                    url.Replace("/fr-CA/", "/fr/") :
                    url.Replace("/fr-CA.aspx", "/fr");

            return url;
        }
    }
}

All I did was replace the “fr-CA” with “fr” and remove “en” from the URL. The home page is special because the page name is the language name and it has the “aspx” extension.

Patch the web.config file

Create a new config file and call it “LinkManager.config” in [\Website\App_Config\Include] and add the following:


  
    
      MyLinkManager

We set the default link manager to our custom class and add it as a provider. The only thing I changed is the languageEmbedding property, changed it to “always”.

If you browse the site you should see that all the links now show “fr” instead of “fr-CA” for the French links and no “en” in the English links.

In Summary

By creating custom language resolver and link manager classes we are able to customize the URLs as we like without affecting the data. Note, if you want to confirm that your web.config file patches are working, browse your site/sitecore/admin/showconfig.aspx login as the admin if you’re not already and search for “LinkManager” and “LanguageResolver”.

How to manage user defined template fields in code

Tarek — Sun, 04 Mar 2012 22:12:59 +0000

If you want to reference one of the built-in fields in Sitecore you would use something like: Sitecore.Context.Item.Fields[Sitecore.FieldIDs.DisplayName]
However, if you want to use your own custom fields you would use: Sitecore.Context.Item.Fields["Title"];

A better way would be to use a class that references the field names instead of using strings everywhere in your application. In order to do that we’re going to use Microsoft CodeDOM (http://msdn.microsoft.com/en-us/library/650ax5cx.aspx).

We are going to do the following:

Create custom templates with fields
Create an aspx page to generate the class
Add the CodeDom code to generate the class and fields

Create custom templates

I created two templates in /sitecore/templates/User Defined, Breadcrumb [Title] and Site Section [Title, Description, Banner Image]

Create an aspx page to generate the class

We’ll create a page in [site directory]\Website\sitecore\admin\ and call it FieldsGenerator.aspx

This page will contain the code to generate the class with the our custom fields as properties and the location of the class will be in a folder in my project called “Helpers”, could be anywhere else.

Mine is here: C:\inetpub\wwwroot\Website1\Website\Helpers\Website1Fields.cs

Code-behind using CodeDom

The following code connects to the master database and grabs a unique list of all the fields in all the templates under /sitecore/templates/User Defined

Then uses CodeDom to create the namespace, class and fields then writes the generated class to C:\inetpub\wwwroot\Website1\Website\Helpers\Website1Fields.cs

In the process we print out the fields’ names on the screen.

using System;
using System.CodeDom;
using System.CodeDom.Compiler;
using System.IO;
using System.Linq;
using System.Reflection;

namespace Website1.sitecore.admin
{
    public partial class FieldsGenerator : System.Web.UI.Page
    {
        // generated file name and path
        private const string FilePath = @"C:\inetpub\wwwroot\Website1\Website\Helpers\Website1Fields.cs";

        protected void Page_Load(object sender, EventArgs e)
        {
            // admin and logged in
            if (Sitecore.Context.IsLoggedIn && Sitecore.Context.User.IsAdministrator)
            {
                GenerateClass();
            }
            else
            {
                // redirect user to the login page
                Response.Redirect(string.Format("~/sitecore/admin/login.aspx?returnUrl={0}",
                    this.Request.RawUrl), true);
            }
        }

        private void GenerateClass()
        {
            var master = Sitecore.Configuration.Factory.GetDatabase("master");

            // create a list of unique field names from all templates under "/sitecore/templates/User Defined"
            var fieldNames = (master.SelectItems("/sitecore/templates/User Defined//*[@@templatename='Template field']")
                .OrderBy(item => item.Name).Select(item => item.Name)).Distinct();

            var codeCompileUnit = new CodeCompileUnit();

            // create the namespace
            var codeNamespace = new CodeNamespace("Website1.Helpers");
            codeCompileUnit.Namespaces.Add(codeNamespace);

            // create the class and add comments
            var codeClass = new CodeTypeDeclaration("Website1Fields") { IsClass = true, TypeAttributes = TypeAttributes.Public };
            codeClass.Comments.Add(new CodeCommentStatement(string.Format("\n\tClass generated date and time: {0}", DateTime.Now.ToString("dddd, MMMM dd, yyyy h:mm:ss tt"))));
            codeClass.Comments.Add(new CodeCommentStatement("\n\tFields generated from templates in /sitecore/templates/User Defined"));
            codeClass.Comments.Add(new CodeCommentStatement("\n\tSitecore query used: /sitecore/templates/User Defined//*[@@templatename='Template field']\n"));
            codeNamespace.Types.Add(codeClass);

            // iterate through the fields and add them to the class as properties
            foreach (var fieldName in fieldNames)
            {
                var codeMemberField = new CodeMemberField()
                                      {
                                          Name = fieldName.Replace(" ", "").Replace("-", ""),
                                          Type = new CodeTypeReference(typeof(string)),
                                          Attributes = MemberAttributes.Public | MemberAttributes.Const,
                                          InitExpression = new CodePrimitiveExpression(fieldName)
                                      };

                codeClass.Members.Add(codeMemberField);

                Response.Write(fieldName + "
");
            }

            // create/update the class file
            using (var sw = new StreamWriter(FilePath))
            {
                var provider = CodeDomProvider.CreateProvider("CSharp");
                provider.GenerateCodeFromCompileUnit(codeCompileUnit, sw, new CodeGeneratorOptions { BracingStyle = "C" });

                Response.Write("Class generated!
");
            }
        }
    }
}

Now if we browse the page, in my case http://website1/sitecore/admin/FiedsGenerator.aspx then open the generated class we should get the following:

//------------------------------------------------------------------------------
// 
//     This code was generated by a tool.
//     Runtime Version:4.0.30319.225
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// 
//------------------------------------------------------------------------------

namespace Website1.Helpers
{

    //
    //	Class generated date and time: Sunday, March 04, 2012 5:01:32 PM
    //
    //	Fields generated from templates in /sitecore/templates/User Defined
    //
    //	Sitecore query used: /sitecore/templates/User Defined//*[@@templatename='Template field']
    //
    public class Website1Fields
    {

        public const string BannerImage = "Banner Image";

        public const string Description = "Description";

        public const string Title = "Title";
    }
}

Done. Now anywhere in my application I can reference a field like this:

Sitecore.Context.Item.Fields[Website1.Helpers.Website1Fields.Title]

In Summary

The class generation code could be in another project but for this simple site I placed it in the admin directory. You only have to regenerate the class (browse the page) when you change an existing field or add a new field. And with this approach you can take advantage of existing rename functions in Visual Studio instead of dealing Find & Replace with strings.

How to create applications in Sitecore using asp.net pages

Tarek — Wed, 08 Feb 2012 17:40:41 +0000

You can create applications either by using Sitecore’s Sheer UI (xaml like syntax) or an asp.net web page. In this post we’ll create an application using a web page to display information about the home item’s descendants.

We need to do two things:

Create the application, UI + logic
Create the application and shortcut in Sitecore

Create the application, UI + logic

First we need to decide where to create the web page, for this example I’m going to create it in: [Website1\Website\sitecore\admin\DisplayInfo.aspx]

In the front-end I added a grid view to display the items and styled the background to white:

Code-behind, even though this page will be accessed from Sitecore desktop we still need to check for security permissions and in case the page is accessed outside of the desktop. Simply, load the home item’s descendants in the grid view.

using System;

namespace Website1.sitecore.admin
{
    public partial class DisplayInfo : System.Web.UI.Page
    {
        protected void Page_Load(object sender, EventArgs e)
        {
            // check if user is logged in and is either the administrator or belongs to the MyRole role
            if (Sitecore.Context.IsLoggedIn && (Sitecore.Context.User.IsInRole(@"sitecore\MyRole") ||
                                                Sitecore.Context.User.IsAdministrator))
            {
                var masterDb = Sitecore.Data.Database.GetDatabase("master");

                gvInfo.DataSource = masterDb.SelectItems("/sitecore/content/Home//*");
                gvInfo.DataBind();
            }
            else
            {
                // redirect user to the login page
                Response.Redirect(string.Format("~/sitecore/admin/login.aspx?returnUrl={0}",
                    this.Request.RawUrl), true);
            }
        }
    }
}

So far we created our simple app to display info about the home item’s descendants. Browse: http://website1/sitecore/admin/displayinfo.aspx (replace website1 with your Sitecore instance)

If you’re not logged in you’ll be redirected to the admin login page; otherwise, you will see the list of items under your site’s Home item, mine looks like this:

Create the shortcut and reference the page in Sitecore

Switch to Sitecore and login to the desktop then select the core database.

Open the content editor and navigate to [/sitecore/content/Applications]

Insert an application from the insert menu and call it: Display Info

Enter the page location in the [Application] field: /sitecore/admin/displayinfo.aspx

Have a look at the other fields like icon, chrome and window state and size.

Now that we created the application item we’re going to add it to [Start Menu > All Applications] by navigating to [/sitecore/content/Documents and settings/All users/Start menu/Programs]

Insert a new application shortcut from the insert menu and call it: Display Info

In the [Application] field enter: /Applications/Display Info

Save your changes and refresh the desktop and you should see the application in the start menu under [Start Menu > All Applications > Display Info]

In Summary

Create the asp.net page
Check for permissions
Test the page outside of Sitecore desktop by browsing it; just makes it easier
Add a new application in content editor in the core database
Add a shortcut to the application in the start menu

How to add commands to the ribbon in content editor

Tarek — Fri, 03 Feb 2012 23:14:04 +0000

We need to do three things:

Create the code to execute when the ribbon button is clicked
Configure Sitecore to connect the button to the code
Create the button in the ribbon

Create the code to execute when the ribbon button is clicked

Let’s start with setting up the code, we need to create the command class and method to execute the command. I prefer to create a separate project for commands and other custom functions but for the sake of this example let’s create a folder under the [Website] directory and call it [Helpers] then create the class there and call it [DisplayInfo].

[\Website\Helpers\DisplayInfo.cs]

The following code displays a message box with the item name:

using System;
using Sitecore.Shell.Framework.Commands;

namespace Website1.Helpers
{
    [Serializable]
    public class DisplayInfo : Command
    {
        public override void Execute(CommandContext context)
        {
            // get the selected item
            var item = context.Items[0];

            // display message box with the item's name
            Sitecore.Context.ClientPage.ClientResponse.Alert("Item Name: " + item.Name);
        }
    }
}

Build the project.

Configure Sitecore to connect the button to the code

To configure Sitecore we have to modify the [web.config] file. We’ll do that by creating a new config file in [\Website\App_Config\Include\Commads.config] you can call it anything you want, I’ll use Commands.config.

The following XML adds the command to the main [web.config] file. The [name] is the text we will use later when we create the button, it is the key that will link the button the code, I used the format [site name : command name], my website is called [Website1] so [Website1:DisplayInfo]

The [type] lists the namespace, class and the dll where the class is located. From the code above, the namespace and class is [Website1.Helpers.DisplayInfo] and the dll is the project’s dll, Website1.dll

Create the button in the ribbon

Now let’s create the button in the ribbon, we’ll place it in the [Home] strip in its own chunk (group).

Let’s begin by logging into the desktop and switching to the [Core] database:

Open the content editor and navigate to [/sitecore/content/Applications/Content Editor/Ribbons/Chunks]

Here we will add a new chunk and call it [Item Info]:

Right click on [Chunks] and select insert from template
In the dialog, navigate to and select [/System/Ribbon/Chunk]
Call it: Item Info
Create the item

Insert “Item Info” in the [Header] field and save.

Now we’ll create a [Large Button] in the chunk, right click then select insert from template and navigate to [/System/Ribbon/Large Button] and call it: Display Info

Insert “Display Info” in the [Header] field and save.

Pick an icon, I chose [Applications/32x32/about.png]

In the [Click] field insert the [name] we used in the [Commads.config] file which was [Website1:DisplayInfo] and save the changes.

So far we have created the button and the chunk (group) that contains the button, the last step is to add it to the [Home] strip.

Navigate to
[/sitecore/content/Applications/Content Editor/Ribbons/Strips/Home]

Right click and select insert from template then navigate to and select [/System/Reference] and call it: Item Info

In the [Reference] field select [/sitecore/content/Applications/Content Editor/Ribbons/Chunks/Item Info] and save.

Close the content editor and open it again and you should see the button in the ribbon in the [Home] strip.

Done

In summary

Add the class and the code to execute to your project
Add the Commands.config file and populate the name and type according to your class, namespace and dll
Login to Sitecore desktop and switch to the core database
Add the chuck
Add the button to the chunk
Add a reference to the chunk in the strip
Build and reload the site

Emesa Solutions

How to write your own language resolver and link manager in Sitecore

How to manage user defined template fields in code

Class generated!

"); } } } }

How to create applications in Sitecore using asp.net pages

How to add commands to the ribbon in content editor