Sitecore Gadgets

Ensure valid Sitecore Internal Links in Page Editor (Update)

2011-12-09T09:19:00.001-08:00

A while back I published a solution to ensure correct links in page editor. Some folks used it and provided a valuable feedback suggesting improvements for RegEx statements to match links. This post is intended to update the solution with suggested improvements.

The suggested RegEx looks like this :
((http)|(https)):((//)|(\\\\))({0}).*?(~/link.aspx)

I updated both regular links and media links RegEx patterns with suggested modifications and re-assembled the package.

You can get from here.

Kudos to anonymous developer who provided the updated RegEx!

Rich Text auto-save

2011-11-28T16:40:00.001-08:00

Another customization to address rising demand for auto save functionality in Rich Text fields. Per Derek’s suggestion I started with an approach that we found in our knowledge base system. I expected that some customization would be required as it was created a while back and we updated Rich Text editor since then. Here is what we’ve done to achieve the goal. The customization introduces a few changes to the following files at /sitecore/shell/Controls/Rich Text Editor folder:

EditorPage.aspx – added some JS changes and changed class inheritance to a custom one.
EditorPage.js – made some JS changes.
EditorWindow.aspx – made some JS changes.

One can use any merger tool to see what changes were made to aforementioned files. I also included a link to Sitecore package that contains required customization.

Keep in mind that the package contains a DLL so that app pool will be recycled during the package installation.
Please BACKUP files listed above prior to installing the package.

Keep in mind that a Sitecore update that overrides any of the listed files will cease auto save functionality for RTE fields.

This feature was tested in Sitecore 6.4.1 Update-3 and Update-5 as well as Sitecore 6.5.0 Update-1.

Sitecore package link.

Enjoy!

Helicon URL Rewrite module with Sitecore in Integrated pipeline mode

2011-10-27T13:58:00.001-07:00

I recently happened to help a few customers resolve an issue with Helicon ISAPI URL Rewrite module when Sitecore runs in Integrated mode. So, I decided to make create a quick post about it as it took me awhile to figure out why this was happening. I even had to contact Helicon support channel to see if they had any insights into this issue.

The long story short Helicon module has to be configured in early request processing in order to work with Sitecore in Integrated pipeline mode. Here is the setting that you need to set up to make it happen: http://www.helicontech.com/isapi_rewrite/doc/NotificationType.htm

Now a few more details for those who still reading. So, why this becomes an issue when you run your Sitecore app in Integrated mode? The answer lies in the model that Integrated pipeline has. It’s different from Classic mode (aka IIS 6 model) which is based around ISAPI modules. For those who want to dive into details I’d recommend to read these articles: ASP.NET Application Life Cycle Overview for IIS 7.0 and Comparing Native-Code and Managed-Code Notifications [IIS 7].
As all native and managed modules can subscribe to the same processing events when you run you app in integrated mode, the Helicon ISAPI module turns out to be not the first one that accepts a request. The first event that gets raised is Authentication one. Sitecore Http Module gets subscribed to that event thus it’s the first one who intercepts the request. After the Http Module the request gets changed and it points to the physical file, which is a physical layout page for your dynamically constructed page represented by a Sitecore item. As a result Helicon module gets a “wrong” URL.

If you’re not satisfied with this workaround, consider using official Microsoft URL Rewrite module.

For those who are still looking for the solution it's a first link in this post .

Hope this will save someone a bit of time.

Advanced Publish Dialog

2011-09-09T14:47:00.001-07:00

Every once in a while our customers ask if it’s possible to terminate a publishing job. A demand for this functionality increased as our customers started pouring more and more content into their Sitecore implementations. Sometimes an innocent publishing job could become vicious and freeze other publications.

In this blog post I’m going to present an approach that allows a user to cancel a triggered publishing job. This became possible as new publishing pipelines were introduced in Sitecore 6.

Main idea of this tool was to add flexibility to control Publish Dialog UI through Sitecore security mechanism. For instance, hide or disable publish options and “Publish Subitems” checkbox using user security settings. This was implemented by introducing Sitecore setting items for Publish Dialog UI controls. The items located at /sitecore/system/Settings/Publish folder.

The security settings on publish option items as well as checkbox field, Disabled, control appearance and accessibility of the controls on Publish Dialog form.
There are a few more setting items under the /Behaviors branch described below:

Publish Cancel Behavior
Controls publish cancelling mechanism. If “Cancel with exception” field is checked, it throws an exception after publishing job is cancelled. This is necessary to suppress post publish events and prevent update of LastPublish property when needed.
Cancel Button
Controls accessibility of “Cancel” button in Publish Dialog form. By default it has standard behavior – button is disabled after one starts publishing process. When enabled, it’s possible to cancel current publishing job.
Confirm subitems publish
If enabled, it pops-up a confirmation dialog when “Publish Subitems” checkbox is selected. You can tweak the confirmation message at “/sitecore/system/Dictionary/A/Are you sure you want to publish subitems too” dictionary item in the Core database.

There are two versions of this component:

1. v1.1.1 – developed for AppPool running any .NET version

2. v1.2.0 – developed for AppPool running .NET 4.0 version ONLY. It takes advantage of a feature in .NET 4.0 that allows to speed up publishing by assigning multiple threads to publish items.

Setting that controls number of allowed threads for publishing process is located in /App_Config/Include/Sitecore.SharedSource.AdvancedPublishDialog.config file. By default allows 2 publishing threads.

<!--  Max number of concurrent threads for publishing process.
         If this setting is not set Environment.ProcessorCount variable will be used.
-->
<setting name="Publishing.MaxConcurrentThreads" value="2"/>

To observe and cancel publishing jobs an additional application was added to the component – Publish Status Manager. A link to this app appears in Publish Dialog form if a user has access to the app. It’s also possible to open the app from Sitecore start button, again, if the user has access to it.

From within the app one can select a job and hit “Cancel” button to terminate it. By clicking “Cancel all”, all publishing jobs will be forced to be finished.

A few words on how publishing cancel works and its consequences.
When one triggers publishing cancellation, the job gets set to Finished state which is utilized in customized ProcessQueue processor of <publish> pipeline to get off the publishing loop. If “Publish Cancel Behavior” is enabled (setting described above), then custom ProcessPublishCancel pipleline will throw an exception to suppress post publish events.

The caveats of cancelling publishing process.

Publishing of each item is an atomic operation. When you cancel the publishing, there is no mechanism to roll back changes for already processed items. The data for already published items will make their way to the publishing target database. The search indexes will index new data as soon as IndexingManager reads new entries from History table. New published data may not appear on the public site if old data sit in HTML cache of presentation controls and “publish:end” event did not rise to clear it out.

The “Cancel with exception” behavior on “Publish Cancel Behavior” setting item can suppress “publish:end” event and leave LastPublish property unchanged. This could be required if one wants to re-publish processed items, which got published before the publishing job was cancelled, at next Incremental publishing.
If this setting is not set, then caches will be cleared for all processed items whenever publishing is terminated. The LastPublish property will be updated with publish cancellation time. Next Incremental publish will pick up items from the point where they were left when publish cancel event got fired.

Having said this, I’d recommend to leave “Cancel with exception” field unchecked unless you have a strong requirement to republish processed items along with those that were skipped by publish cancellation event.

Here as screencast of quick overview of the component:

Advanced Publish Dialog for Sitecore

UPDATED on Sep 20, 2011
Support for v1.1.x was dropped as v1.2.x does not require AppPool to run .NET 4.0. The link to v1.1.x is no longer available.

Below are the links to the mentioned Sitecore packages:
Sitecore package of AdvancedPublishDialog.

If you have any enhancement ideas or additional features for this module, feel free to express them in the comments.
Enjoy!

Ensure valid Sitecore Internal Links in Page Editor

2011-06-28T15:50:00.000-07:00

(Updated on Dec 9, 2011)
Refer to this post for updated solution.

(Updated on July 27, 2011)

A workaround developed for one of our customers incited me to blog about it as I can see how many other may get affected by this issue.

The issue was that whenever an editor opens RTE control in Page Editor, to get access to all provided functions, and saves the changes, all internal links (that start with “~/link.aspx”) get prefixed with the host name that is used in the browser to access the Page Editor. I could recreate this behavior only in IE browser and only when it runs in compatibility mode. Got same results in both IE8 and IE9 running in compatibility mode. Normal mode of IE8 does not cause the issue.

To address this issue I hooked into <saveUI> pipeline my processor that corrects internal links based on regex that is passed to match a part of the link. Here is the code I came up with:

Code Snippet
 using System;
using System.Text.RegularExpressions;
using Sitecore.Configuration;
using Sitecore.Data.Fields;
using Sitecore.Data.Items;
using Sitecore.Pipelines.Save;
 
namespace Sitecore.Support.Pipelines.Save
{
   public class EnsureRichTextRelativeLinks
   {
      public void Process(SaveArgs args)
      {
         if (args.HasSheerUI)
         {
            if ((args.Result == "no") || (args.Result == "undefined"))
            {
               args.AbortPipeline();
            }
            else
            {
               for (int i = 0; i < args.Items.Length; i++)
               {
                  SaveArgs.SaveItem item = args.Items[i];
                  Item contentItem = Context.ContentDatabase.Items[item.ID, item.Language, item.Version];
                  if (contentItem != null)
                  {
                     foreach (SaveArgs.SaveField field in item.Fields)
                     {
                        Field fld = contentItem.Fields[field.ID];
                        if (fld != null && fld.Type.Equals("rich text", StringComparison.InvariantCultureIgnoreCase))
                        {
                           if (!string.IsNullOrEmpty(field.Value))
                           {
                              field.Value = EnsureRelativeLinks(field.Value);
                           }
                        }
                     }
                  }
               }
            }
         }
      }
 
      protected virtual string EnsureRelativeLinks(string fieldValue)
      {
         string internalLinkPattern = Settings.GetSetting("PageEditor.InternalLinkReplacePattern",
                                                          "((http)|(https)):((//)|(\\\\))({0}).*(~/link.aspx)");
         string internalLinkReplacementValue = Settings.GetSetting("PageEditor.InternalLinkReplacementValue",
                                                                   "~/link.aspx");
         string mediaLinkPattern = Settings.GetSetting("PageEditor.MediaLinkReplacePattern",
                                                       "((http)|(https)):((//)|(\\\\))({0}).*(~/media)");
         string mediaLinkReplacementValue = Settings.GetSetting("PageEditor.MediaLinkReplacementValue", "~/media");
         Regex linkPattern = new Regex(string.Format(internalLinkPattern, Sitecore.Web.WebUtil.GetHostName()), RegexOptions.IgnoreCase);
         Regex mediaPattern = new Regex(string.Format(mediaLinkPattern, Sitecore.Web.WebUtil.GetHostName()), RegexOptions.IgnoreCase);
         string value = linkPattern.Replace(fieldValue, internalLinkReplacementValue);
         value = mediaPattern.Replace(value, mediaLinkReplacementValue);
 
         return value;
      }
   }
}
 

I put regex pattern as well as replacement strings into include config file to make the adjustment easier if necessary. Here is how the config file looks like:

Code Snippet
 <configuration xmlns:patch="http://www.sitecore.net/xmlconfig/">
  <sitecore>
    <processors>
      <saveUI>
        <!-- 
        Fix to address an issue of internal links being converted to absolute links 
        after saving content of RTE field in IE browser running in compatibility mode.
        The fix is developed by Sitecore support and should be removed after the problem is fixed in the core product.
        -->
        <processor mode="on" type="Sitecore.Support.Pipelines.Save.EnsureRichTextRelativeLinks, Sitecore.Support.341310" patch:after="processor[@type='Sitecore.Pipelines.Save.ConvertLayoutField, Sitecore.Kernel']" />
      </saveUI>
    </processors>
    <settings>
      <!-- RegEx pattern to ensure valid internal links during the save event in Page Editor. 
           The issue occurs in IE browser running in compatibility mode.
           The pattern will be replaced to a value defined at PageEditor.InternalLinkReplacementValue
           The {0} parameter is used to insert a host name used in the browser to access Page Editor.
      -->
      <setting name="PageEditor.InternalLinkReplacePattern" value="((http)|(https)):((//)|(\\\\))({0}).*(~/link.aspx)" />
      <!-- Replacement string for regex pattern defined in PageEditor.InternalLinkReplacePattern setting.
      -->
      <setting name="PageEditor.InternalLinkReplacementValue" value="~/link.aspx" />
      <!-- RegEx pattern to ensure valid media links during the save event in Page Editor. 
           The issue occurs in IE browser running in compatibility mode.
           The pattern will be replaced to a value defined at PageEditor.MediaLinkReplacementValue
           The {0} parameter is used to insert a host name used in the browser to access Page Editor.
      -->
      <setting name="PageEditor.MediaLinkReplacePattern" value="((http)|(https)):((//)|(\\\\))({0}).*(~/media)" />
      <!-- Replacement string for regex pattern defined in PageEditor.MediaLinkReplacePattern setting.
      -->
      <setting name="PageEditor.MediaLinkReplacementValue" value="~/media" />
    </settings>
  </sitecore>
</configuration>
 

Oh yeah, I wasn’t sure if this could happen to media links (couldn’t reproduce it locally) but decided to add the same replacement functionality for “~/media” links as well. If you find it useless, feel free to remove that part :).

This code was developed and tested in Sitecore 6.4.1 rev.110324. It’s expected to work in any 6.4 version. Can’t see any problems with 6.5 but I haven’t tested it there.

As all the code fit into the snippet boxes above, I don’t provide links to sources for download. Though here is the link to Sitecore package that installs the fix.

Hope it saves you some time!

Upcoming Sitecore event: Dreamcore 2011

2011-01-21T11:46:00.001-08:00

The spring is coming and along with it our second Dreamcore event is coming too. If you want to know more about Sitecore’s functionality and the future of our product, book your seat in the Dreamcore 2011 bullet train.

All-in-1 Workflow

2010-10-26T14:25:00.001-07:00

In this article I’m going to describe an approach that we’ve taken creating a solution for a universal workflow requirement. The idea was to create one workflow for all content items as they all would follow the same workflow process.

Here is a use case that came from one of our wonderful customers:

All content items should have the same workflow process.
Different security roles may have or not have access to a workflow state at different parts of a content tree.
Workbox should respect aforementioned security configuration.

To understand what access rights provide editing permission to the user let’s take a look at the way Sitecore resolves access level to a content item.

Check if a user has Read (item:read) access to an item. If so, the user will be able to see the item in a Content Editor.
Check if the user has Write (item:write) access to the item. If the item is in workflow, check whether the user has Write access to a workflow state the item is in (workflowState:write). If either of those access rights is not granted, reclaim modification access.

As you can see both Write and Workflow State Write access rights are required for a user to edit the item.

This is the approach we came up with to address all the requirements. We can meet all requirements by extending standard Workflow class and using it to run workflow process.

First. Define additional access right that along with Workflow state Write one would determine access to items in workflow at different parts of the content tree. In this approach we decided to use “workflowState:write” access right which is available only to workflow related items by default. In this case the only thing we need to do is to make it available for all of the items. And it could be easily configured in web.config file:

Code Snippet
 <rules>
  <add prefix="workflowState:write" typeName="Sitecore.Data.Items.Item"/>
</rules>
 

Now you can set this right for any item in Security Editor. Just don’t forget to add an appropriate column to see it there.

Second. Extend default Sitecore.Workflows.Simple.Workflow class to take into account new security configuration.

Code Snippet
 namespace TwinPeaks.Workflows
{
    public class Workflow : Sitecore.Workflows.Simple.Workflow, IWorkflow
    {
        private const string CheckRequiredFieldName = "Check required";
 
        public Workflow(string workflowId, WorkflowProvider owner)
            : base(workflowId, owner)
        {
            Owner = owner;
        }
 
        /// <summary>
        /// Returns workflow state commands.
        /// </summary>
        /// <param name="item">Content item.</param>
        /// <returns></returns>
        public override WorkflowCommand[] GetCommands(Item item)
        {
            Assert.ArgumentNotNull(item, "item");
            string stateID = this.GetStateID(item);
            if (stateID.Length > 0)
            {
                return GetCommands(stateID, item);
            }
            return new WorkflowCommand[0];
        }
 
        /// <summary>
        /// Returns workflow state commands.
        /// </summary>
        /// <param name="stateId">Workflow state ID</param>
        /// <param name="item">Content item</param>
        /// <returns></returns>
        public WorkflowCommand[] GetCommands(string stateId, Item item)
        {
            Assert.ArgumentNotNullOrEmpty(stateId, "stateID");
            Item stateItem = GetStateItem(stateId);
            WorkflowState workflowState = GetState(stateId);
            if (stateItem == null || workflowState == null)
            {
                return new WorkflowCommand[0];
            }
            Item[] itemArray = stateItem.Children.ToArray();
            ArrayList list = new ArrayList();
            foreach (Item entity in itemArray)
            {
                if (entity != null)
                {
                    Template template = entity.Database.Engines.TemplateEngine.GetTemplate(entity.TemplateID);
                    if (workflowState.CheckRequired && !string.IsNullOrEmpty(AccessRight.WorkflowStateWrite.Name))
                    {
                        if (((template != null) && template.DescendsFromOrEquals(TemplateIDs.WorkflowCommand)) &&
                        AuthorizationManager.IsAllowed(entity, AccessRight.WorkflowCommandExecute, Context.User) &&
                        AuthorizationManager.IsAllowed(item, AccessRight.FromName(AccessRight.WorkflowStateWrite.Name), Context.User))
                        {
                            list.Add(new WorkflowCommand(entity.ID.ToString(), entity.DisplayName,
                                                         entity.Appearance.Icon, false,
                                                         entity["suppress comment"] == "1"));
                        }
                    }
                    else if (((template != null) && template.DescendsFromOrEquals(TemplateIDs.WorkflowCommand)) &&
                        AuthorizationManager.IsAllowed(entity, AccessRight.WorkflowCommandExecute, Context.User))
                    {
                        list.Add(new WorkflowCommand(entity.ID.ToString(), entity.DisplayName, entity.Appearance.Icon, false, entity["suppress comment"] == "1"));
                    }
                }
            }
            return (WorkflowCommand[])list.ToArray(typeof(WorkflowCommand));
        }
 
        /// <summary>
        /// Returns workflow state item
        /// </summary>
        /// <param name="stateId">Workflow state ID</param>
        /// <returns></returns>
        protected Item GetStateItem(string stateId)
        {
            ID iD = MainUtil.GetID(stateId, null);
            if (iD == (ID)null)
            {
                return null;
            }
            return ItemManager.GetItem(stateId, Language.Current, Version.Latest, Owner.Database, SecurityCheck.Disable);
        }
 
        /// <summary>
        /// Returns workflow state ID
        /// </summary>
        /// <param name="item">Content item</param>
        /// <returns></returns>
        protected string GetStateID(Item item)
        {
            Assert.ArgumentNotNull(item, "item");
            WorkflowInfo workflowInfo = item.Database.DataManager.GetWorkflowInfo(item);
            if (workflowInfo != null)
            {
                return workflowInfo.StateID;
            }
            return string.Empty;
        }
 
        /// <summary>
        /// Need to override to respect new right in Workbox application
        /// </summary> 
        public override DataUri[] GetItems(string stateId)
        {
            if (CheckStateAdvancedSecurity(stateId))
            {
                Assert.ArgumentNotNullOrEmpty(stateId, "stateID");
                Assert.IsTrue(ID.IsID(stateId), "Invalid state ID: " + stateId);
                DataUri[] itemsInWorkflowState =
                    Owner.Database.DataManager.GetItemsInWorkflowState(new WorkflowInfo(WorkflowID, stateId));
                DataUri[] filteredItems = ApplyAdvancedSecurity(itemsInWorkflowState, stateId);
                if (filteredItems != null)
                {
                    return filteredItems;
                }
                return new DataUri[0];
            }
            return base.GetItems(stateId);
        }
 
        /// <summary>
        /// Indicates if advanced security should be checked for a workflow state.
        /// </summary>
        /// <param name="stateId">Workflow satate ID</param>
        /// <returns></returns>
        protected bool CheckStateAdvancedSecurity(string stateId)
        {
            WorkflowState workflowState = GetState(stateId);
            if (workflowState != null && workflowState.CheckRequired && !string.IsNullOrEmpty(AccessRight.WorkflowStateWrite.Name))
            {
                return true;
            }
 
            return false;
        }
 
        /// <summary>
        /// Filters out items that a user should not have access to.
        /// </summary>
        /// <param name="items">DataUri array of content items.</param>
        /// <param name="stateId">Workflow state ID.</param>
        /// <returns></returns>
        protected DataUri[] ApplyAdvancedSecurity(DataUri[] items, string stateId)
        {
            if (items == null || items.Length == 0)
            {
                return new DataUri[0];
            }
            WorkflowState workflowState = GetState(stateId);
            if (workflowState == null)
            {
                return new DataUri[0];
            }
            var filteredItems =
                items.Where(
                    item => Owner.Database.GetItem(item) != null &&
                            AuthorizationManager.IsAllowed(Owner.Database.GetItem(item),
                                                           AccessRight.FromName(AccessRight.WorkflowStateWrite.Name),
                                                           Context.User));
            if (!filteredItems.GetEnumerator().MoveNext())
            {
                return new DataUri[0];
            }
            return filteredItems.ToArray();
        }
 
        /// <summary>
        /// Returns an extended WorkflowState object.
        /// </summary>
        /// <param name="stateId">Workflow state ID.</param>
        /// <returns></returns>
        new protected WorkflowState GetState(string stateId)
        {
            Assert.ArgumentNotNullOrEmpty(stateId, "stateId");
            Item stateItem = GetStateItem(stateId);
            if (stateItem != null)
            {
                return new WorkflowState(stateId, stateItem.DisplayName, stateItem.Appearance.Icon, stateItem[WorkflowFieldIDs.FinalState] == "1", stateItem[CheckRequiredFieldName] == "1");
            }
            return null;
        }
 
        /// <summary>
        /// Returns access result of whether the user has write access to the item.
        /// </summary>
        /// <param name="item">Content item.</param>
        /// <param name="account">User account</param>
        /// <param name="accessRight">Access right</param>
        /// <returns></returns>
        new public AccessResult GetAccess(Item item, Account account, AccessRight accessRight)
        {
            Assert.ArgumentNotNull(item, "item");
            Assert.ArgumentNotNull(account, "account");
            Assert.ArgumentNotNull(accessRight, "operation");
            Item stateItem = GetStateItem(item);
            if (stateItem == null)
            {
                return new AccessResult(AccessPermission.Allow, new AccessExplanation(item, account, AccessRight.ItemDelete, "The workflow state definition item not found.", new object[0]));
            }
            if (accessRight == AccessRight.ItemWrite)
            {
                return GetWriteAccessInformation(item, account, stateItem);
            }
            return base.GetAccess(item, account, accessRight);
        }
 
        /// <summary>
        /// Resolves whether the user has write access to the item.
        /// </summary>
        /// <param name="item">Content item.</param>
        /// <param name="account">User account.</param>
        /// <param name="stateItem">Workflow state item.</param>
        /// <returns></returns>
        protected AccessResult GetWriteAccessInformation(Item item, Account account, Item stateItem)
        {
            WorkflowState workflowState = GetState(stateItem.ID.ToString());
            if (workflowState != null && workflowState.CheckRequired)
            {
                if (AuthorizationManager.IsAllowed(stateItem, AccessRight.WorkflowStateWrite, account) && AuthorizationManager.IsAllowed(item, AccessRight.WorkflowStateWrite, account))
                {
                    return new AccessResult(AccessPermission.Allow, new AccessExplanation(item, account, AccessRight.ItemWrite, string.Format("The workflow state definition item allows writing (through the '{0}' access right).", AccessRight.WorkflowStateWrite.Name), new object[0]));
                }
            }
            else if (AuthorizationManager.IsAllowed(stateItem, AccessRight.WorkflowStateWrite, account))
            {
                return new AccessResult(AccessPermission.Allow, new AccessExplanation(item, account, AccessRight.ItemWrite, string.Format("The workflow state definition item allows writing (through the '{0}' access right).", AccessRight.WorkflowStateWrite.Name), new object[0]));
            }
            return new AccessResult(AccessPermission.Deny, new AccessExplanation(item, account, AccessRight.ItemWrite, string.Format("The workflow state definition item does not allow writing. To allow writing, grant the '{0}' access right to the workflow state definition item.", AccessRight.WorkflowStateWrite.Name), new object[0]));
        }
 
        /// <summary>
        /// Returns workflow state item the content item is in.
        /// </summary>
        /// <param name="item">Content item.</param>
        /// <returns></returns>
        protected Item GetStateItem(Item item)
        {
            Assert.ArgumentNotNull(item, "item");
            WorkflowInfo info = item.Database.DataManager.GetWorkflowInfo(item);
            if (info != null)
            {
                return item.Database.SelectSingleItem(info.StateID);
            }
            return null;
        }
 
        #region Properties
 
        protected WorkflowProvider Owner { get; set; }
 
        #endregion Properties
    }
}
 

To provide an ability to choose whether access to a workflow state should be combined with access to a content item, I extended System/Workflow/State template with a checkbox field that indicates whether a custom logic should be triggered. Here how it looks now:

I extended WorkflowState class with an appropriate property for the new field.

Code Snippet
 namespace TwinPeaks.Workflows
{
    public class WorkflowState : Sitecore.Workflows.WorkflowState
    {
        public WorkflowState(string stateId, string displayName, string icon, bool finalState, bool checkRequired) : base(stateId, displayName, icon, finalState)
        {
            CheckRequired = checkRequired;
        }
 
        /// <summary>
        /// Indicates if workflowState:write access right should be considered while resolving access to the item.
        /// </summary>
        public bool CheckRequired { get; private set; }
    }
}
 

Now in order to make Sitecore use our new Workflow class we need to override WorkflowProvider to return our extended Workflow instance.

Code Snippet
 using Sitecore;
using Sitecore.Data;
using Sitecore.Data.Items;
using Sitecore.Diagnostics;
using Sitecore.Workflows;
 
namespace TwinPeaks.Workflows
{
    /// <summary>
    /// This class overrides required methods to return an object of extended Workflow class.
    /// </summary>
    public class WorkflowProvider : Sitecore.Workflows.Simple.WorkflowProvider
    {
        public WorkflowProvider(string databaseName, HistoryStore historyStore) : base(databaseName, historyStore)
        {
        }
 
        public override IWorkflow GetWorkflow(Item item)
        {
            Assert.ArgumentNotNull(item, "item");
            string workflowID = GetWorkflowID(item);
            if (workflowID.Length > 0)
            {
                return new Workflow(workflowID, this);
            }
            return null;
        }
 
        public override IWorkflow GetWorkflow(string workflowID)
        {
            Assert.ArgumentNotNullOrEmpty(workflowID, "workflowID");
            Error.Assert(ID.IsID(workflowID), "The parameter 'workflowID' must be parseable to an ID");
            if (this.Database.Items[ID.Parse(workflowID)] != null)
            {
                return new Workflow(workflowID, this);
            }
            return null;
        }
 
        private static string GetWorkflowID(Item item)
        {
            Assert.ArgumentNotNull(item, "item");
            WorkflowInfo workflowInfo = item.Database.DataManager.GetWorkflowInfo(item);
            if (workflowInfo != null)
            {
                return workflowInfo.WorkflowID;
            }
            return string.Empty;
        }
 
        public override IWorkflow[] GetWorkflows()
        {
            Item item = this.Database.Items[ItemIDs.WorkflowRoot];
            if (item == null)
            {
                return new IWorkflow[0];
            }
            Item[] itemArray = item.Children.ToArray();
            IWorkflow[] workflowArray = new IWorkflow[itemArray.Length];
            for (int i = 0; i < itemArray.Length; i++)
            {
                workflowArray[i] = new Workflow(itemArray[i].ID.ToString(), this);
            }
            return workflowArray;
        }
    }
}
 

Third. Configure Sitecore solution to work with this customization. Below is a complete example of UniversalWorkflow.config file that could be placed into /App_Config/Include folder to enable this customization:

Code Snippet
 <configuration xmlns:patch="http://www.sitecore.net/xmlconfig/">
  <sitecore>
    <databases>
      <database id="master">
        <workflowProvider>
          <patch:attribute name="type">TwinPeaks.Workflows.WorkflowProvider, TwinPeaks.Workflows</patch:attribute>
        </workflowProvider>
      </database>
    </databases>
    <accessRights defaultProvider="config">
      <rules>
        <add prefix="workflowState:write" typeName="Sitecore.Data.Items.Item"/>
      </rules>
    </accessRights>
 
  </sitecore>
</configuration>
 

Why is this solution is worth to blog about? Because it allows us to address all the requirements by customizing only one thing – Workflow class. Both Workbox and Content Editor will respect security configuration if “check required” field is selected on a workflow state item.

Feel free to share your thoughts on this approach as well as suggest improvements or even better solution.
Hope you find it helpful.

Sitecore Lucene index does not remove old data

2010-10-20T15:17:00.000-07:00

Looks like interest to Sitecore implementation of Lucene index has raised since Dream Core event and developers have run into an issue with old data being kept in the index repository. In this article I want to show you how to go around this issue.
First of all let’s see why it’s happening. I ran into this issue when I started playing with new implementation of Lucene index in Sitecore 6. When I created an output of the results I saw duplicates of my data in there. I stated debugging my code and found that Lucene somehow recognizes raw GUID’s which breaks search criteria that Sitecore uses to find items during update/delete procedure.
To solve this issue I had to create additional field for Lucene index (_shorttemplateid) and store there short GUID for an item (item.ID.ToShortID()). Then override AddMatchCriteria method and dependent properties to use short template GUID for matching criteria. Below is the code example.

Code Snippet
 namespace LuceneExamples
{
   public class DatabaseCrawler : Sitecore.Search.Crawlers.DatabaseCrawler
   {
      #region Fields
 
      private bool _hasIncludes;
      private bool _hasExcludes;
      private Dictionary<string, bool> _templateFilter;
      private ArrayList _customFields;
 
      #endregion Fields
 
      #region ctor
 
      public DatabaseCrawler()
      {
         _templateFilter = new Dictionary<string, bool>();
         _customFields = new ArrayList();
      }
 
      #endregion ctor
 
      #region Base class methods
 
      // Should be overriden to add date fields in "yyyyMMddHHmmss" format. Otherwise it's not possible to create range queries for date values.
      // Also adds _shorttemplateid field which has a template id in ShortID format.
      protected override void AddAllFields(Document document, Item item, bool versionSpecific)
      {
         Assert.ArgumentNotNull(document, "document");
         Assert.ArgumentNotNull(item, "item");
         Sitecore.Collections.FieldCollection fields = item.Fields;
         fields.ReadAll();
         foreach (Sitecore.Data.Fields.Field field in fields)
         {
            if (!string.IsNullOrEmpty(field.Key) && (field.Shared != versionSpecific))
            {
               bool tokenize = base.IsTextField(field);
               if (IndexAllFields)
               {
                  if (field.TypeKey == "date" || field.TypeKey == "datetime")
                  {
                     IndexDateFields(document, field.Key, field.Value);
                  }
                  else
                  {
                     document.Add(CreateField(field.Key, field.Value, tokenize, 1f));
                  }
               }
               if (tokenize)
               {
                  document.Add(CreateField(BuiltinFields.Content, field.Value, true, 1f));
               }
            }
         }
         AddShortTemplateId(document, item);
         AddCustomFields(document, item);
      }
 
      /// <summary>
      /// Loops through the collection of custom fields and adds them to fields collection of each indexed item.
      /// </summary>
      /// <param name="document">Lucene document</param>
      /// <param name="item">Sitecore data item</param>
      private void AddCustomFields(Document document, Item item)
      {
         foreach(CustomField field in _customFields)
         {
            document.Add(CreateField(field.LuceneFieldName, field.GetFieldValue(item), field.StorageType, field.IndexType, Boost));
         }
      }
 
      /// <summary>
      /// Creates a Lucene field.
      /// </summary>
      /// <param name="fieldKey">Field name</param>
      /// <param name="fieldValue">Field value</param>
      /// <param name="storeType">Storage option</param>
      /// <param name="indexType">Index type</param>
      /// <param name="boost">Boosting parameter</param>
      /// <returns></returns>
      private Fieldable CreateField(string fieldKey, string fieldValue, Field.Store storeType, Field.Index indexType, float boost)
      {
         Field field = new Field(fieldKey, fieldValue, storeType, indexType);
         field.SetBoost(boost);
         return field;
      }
 
      /// <summary>
      /// Parses a configuration entry for a custom field and adds it to a collection of custom fields.
      /// </summary>
      /// <param name="node">Configuration entry</param>
      public void AddCustomField(XmlNode node)
      {
         CustomField field = CustomField.ParseConfigNode(node);
         if (field == null)
         {
            throw new InvalidOperationException("Could not parse custom field entry: " + node.OuterXml);
         }
         _customFields.Add(field);
      }
 
      // Method should use _shorttemplateid to allow one create combined/boolean search queries with template id reference.
      // Also used to create a matching criteria for update/delete actions.
      protected override void AddMatchCriteria(BooleanQuery query)
      {
         query.Add(new TermQuery(new Term(BuiltinFields.Database, Database)), BooleanClause.Occur.MUST);
         query.Add(new TermQuery(new Term(BuiltinFields.Path, Sitecore.Data.ShortID.Encode(Root).ToLowerInvariant())), BooleanClause.Occur.MUST);
         if (HasIncludes || HasExcludes)
         {
            foreach (KeyValuePair<string, bool> pair in TemplateFilter)
            {
               query.Add(new TermQuery(new Term(Constants.ShortTemplate, Sitecore.Data.ShortID.Encode(pair.Key).ToLowerInvariant())), pair.Value ? BooleanClause.Occur.SHOULD : BooleanClause.Occur.MUST_NOT);
            }
         }
      }
 
      // Method should be overriden because _hasIncludes and _hasExcludes variables were introduced.
      protected override bool IsMatch(Item item)
      {
          bool flag;
          Assert.ArgumentNotNull(item, "item");
          if (!RootItem.Axes.IsAncestorOf(item))
          {
              return false;
          }
          if (!HasIncludes && !HasExcludes)
          {
              return true;
          }
          if (!TemplateFilter.TryGetValue(item.TemplateID.ToString(), out flag))
          {
              return !HasIncludes;
          }
          return flag;
      }
 
      // Method required to override AddMatchCriteria one.
      new public void IncludeTemplate(string templateId)
      {
         Assert.ArgumentNotNullOrEmpty(templateId, "templateId");
         _hasIncludes = true;
         _templateFilter[templateId] = true;
      }
 
      // Method required to override AddMatchCriteria one.
      new public void ExcludeTemplate(string templateId)
      {
         Assert.ArgumentNotNullOrEmpty(templateId, "templateId");
         _hasExcludes = true;
         _templateFilter[templateId] = false;
      }
 
      #endregion Base class methods
 
      /// <summary>
      /// Converts Sitecore date and datetime fields to the recognizable format for Lucene API.
      /// </summary>
      /// <param name="doc">Lucene document object</param>
      /// <param name="fieldKey">Field name</param>
      /// <param name="fieldValue">Field value</param>
      private void IndexDateFields(Document doc, string fieldKey, string fieldValue)
      {
         DateTime dateTime = Sitecore.DateUtil.IsoDateToDateTime(fieldValue);
         string luceneDate = "";
         if (dateTime != DateTime.MinValue)
         {
            luceneDate = dateTime.ToString(Constants.DateTimeFormat);
         }
         doc.Add(CreateField(fieldKey, luceneDate, false, 1f));
      }
 
      /// <summary>
      /// Adds template id in ShortID format
      /// </summary>
      /// <param name="doc">Lucene document object</param>
      /// <param name="item">Sitecore item</param>
      private void AddShortTemplateId(Document doc, Item item)
      {
         doc.Add(CreateField(Constants.ShortTemplate, Sitecore.Data.ShortID.Encode(item.TemplateID).ToLowerInvariant(), false, 1f));
      }
 
      #region Properties
 
      protected bool HasIncludes
      {
         get
         {
            return _hasIncludes;
         }
         set
         {
            _hasIncludes = value;
         }
      }
 
      protected bool HasExcludes
      {
         get
         {
            return _hasExcludes;
         }
         set
         {
            _hasExcludes = value;
         }
      }
 
      protected Dictionary<string, bool> TemplateFilter
      {
         get
         {
            return _templateFilter;
         }
      }
 
      protected Item RootItem
      {
         get
         {
            return Sitecore.Data.Managers.ItemManager.GetItem(Root, Sitecore.Globalization.Language.Invariant,
                                                              Sitecore.Data.Version.Latest,
                                                              Sitecore.Data.Database.GetDatabase(Database),
                                                              Sitecore.SecurityModel.SecurityCheck.Disable);
         }
      }
 
      #endregion Properties
 
   }
}
 

This should solve this issue as well as add Lucene recognizable format for Sitecore date and datetime field types. Also it will allow to build Combined and Boolean search queries.

Update. Code for the Constants class:

   1: namespace LuceneExamples   2: {   3:    public class Constants   4:    {   5:       // special field for template id in ShortID format   6:       public const string ShortTemplate = "_shorttemplateid";   7:     8:       // searchable date-time format. All datetime field   9:       public const string DateTimeFormat = "yyyyMMddHHmmss";  10:    11:       // Path to lucene setting items: /sitecore/system/Settings/Lucene  12:       public const string LuceneSettingsPath = "{89783047-026C-45B5-AB5B-338E4A22446C}";  13:    }  14: }

Hope it saves someone a minute or two.

Remove old data form the index for Sitecore 6.2 (Update-4) and 6.3

2010-10-01T16:40:00.001-07:00

Previously I published an article explaining how to fix a glitch in Sitecore index that keeps old data after updating an item. In this article I updated the code since some issues were fixed in Sitecore 6.2 (Update-4) and 6.3.

Starting from 6.2 (Update-4) and 6.3 the _template field in Lucene index stores an item ID in ShortID format. Now it’s even easier to customize the DatabaseCrawler as the following methods were made virtual: AddItem, IndexVersion, DeleteItem and DeleteVersion. Also fields _hasIncludes, _hasExludes and _templateFilder were made protected which helps to shrink the fix even more.

Here is the code that fixes the outlined problem for these releases:

Code Snippet
 namespace Lucene.Search.Crawlers
{
    public class DatabaseCrawler : Sitecore.Search.Crawlers.DatabaseCrawler
    {
        protected override void AddMatchCriteria(Net.Search.BooleanQuery query)
        {
            query.Add(new TermQuery(new Term(BuiltinFields.Database, RootItem.Database.Name)), BooleanClause.Occur.MUST);
            query.Add(new TermQuery(new Term(BuiltinFields.Path, ShortID.Encode(RootItem.ID).ToLowerInvariant())), BooleanClause.Occur.MUST);
            if (this._hasIncludes || this._hasExcludes)
            {
                foreach (KeyValuePair<string, bool> pair in this._templateFilter)
                {
                    query.Add(new TermQuery(new Term(BuiltinFields.Template, ShortID.Encode(pair.Key).ToLowerInvariant())), pair.Value ? BooleanClause.Occur.SHOULD : BooleanClause.Occur.MUST_NOT);
                }
            }
        }
 
        protected Item RootItem
        {
            get
            {
                return Sitecore.Data.Managers.ItemManager.GetItem(Root, Sitecore.Globalization.Language.Invariant,
                                                                  Sitecore.Data.Version.Latest,
                                                                  Sitecore.Data.Database.GetDatabase(Database),
                                                                  Sitecore.SecurityModel.SecurityCheck.Disable);
            }
        }
 
        protected override Query GetVersionQuery(ID id, string language, string version)
        {
            Assert.ArgumentNotNull(id, "id");
            Assert.ArgumentNotNullOrEmpty(language, "language");
            Assert.ArgumentNotNullOrEmpty(version, "version");
            BooleanQuery query = new BooleanQuery();
            query.Add(new TermQuery(new Term(BuiltinFields.ID, GetItemID(id, language, version).ToLowerInvariant())), BooleanClause.Occur.MUST);
            this.AddMatchCriteria(query);
            return query;
        }
    }
}
 

Basically you need to make sure that the result of GetItemID method is in lower case as well as a term for _path field, in AddMatchCriteria method, is constructed with lower case query.

Adding custom fields to the index

2010-08-31T10:57:00.001-07:00

In this post I want to show how to address a missing feature that was a part of “old” lucene index implementation. This article will provide an example how one can customize Lucene search configuration so that it’s possible to add custom fields to the index.

First off, let’s create a configuration that would allow us to add additional fields to the indexed data.

<index id="News" type="Sitecore.Search.Index, Sitecore.Kernel">
  <param desc="name">$(id)</param>
  <param desc="folder">_news</param>
  <Analyzer ref="search/analyzer" />
  <locations hint="list:AddCrawler">
    <examples-news type="LuceneExamples.DatabaseCrawler,LuceneExamples">
      <Database>web</Database>
      <Root>/sitecore/content</Root>
      <IndexAllFields>true</IndexAllFields>
      <include hint="list:IncludeTemplate">
        <news>{788EF1BE-B71E-4D59-9276-50519BD4F641}</news>
        <tag>{4DD970FB-2695-4E50-96F3-A766F7D6CAF1}</tag>
      </include>
      <fields hint="raw:AddCustomField">
        <field luceneName="author" storageType="no" indexType="tokenized">__updated by</field>
        <field luceneName="changed" storageType="yes" indexType="untokenized">__updated</field>
      </fields>
    </examples-news>
  </locations>
</index>

There is a new configuration section in this example. It’s <fields> section that introduces two fields “author” and “changed”. These fields will be added to a fields collection of each indexed item. Basically, there is AddCustomField method that gets called for every <field> configuration entry to identify a custom field that is going to be added to the fields collection.

Description of configuration attributes:

luceneName is a field name that appears in lucene index.
storageType is a storage type for lucene field. It can have the following values:
- no
- yes
- compress
indexType is an index type for lucene field. It can have the following values:
- no
- tokenized
- untokenized
- nonorms

Refere to Lucene documentation to find out what each of these options mean: store and index.

Now all you need to do is to loop through the collection of custom fields in the overridden AddAllFields method and add them to the indexed data.

I created a custom class called CustomField that helps to manage custom field entries. Below is the example of this class as well as additional methods for extended DatabaseCrawler. Since code for the DatabaseCrawler was already published in this blog post, I’m not going to duplicate it here.

Here is a code for CustomField class.

using System.Xml;
using Sitecore.Data;
using Sitecore.Data.Items;
using Sitecore.Xml;
using Lucene.Net.Documents;

namespace LuceneExamples
{
   public class CustomField
   {
      public CustomField()
      {
         FieldID = ID.Null;
         FieldName = "";
         LuceneFieldName = "";
      }

      public ID FieldID
      {
         get;
         private set;
      }

      public string FieldName { get; private set; }

      public Field.Store StorageType { get; set; }

      public Field.Index IndexType { get; set; }

      public string LuceneFieldName { get; private set; }

      public static CustomField ParseConfigNode(XmlNode node)
      {
         CustomField field = new CustomField();
         string fieldName = XmlUtil.GetValue(node);
         if (ID.IsID(fieldName))
         {
            field.FieldID = ID.Parse(fieldName);
         }
         else
         {
            field.FieldName = fieldName;
         }
         field.LuceneFieldName = XmlUtil.GetAttribute("luceneName", node);
         field.StorageType = GetStorageType(node);
         field.IndexType = GetIndexType(node);

         if (!IsValidField(field))
         {
            return null;
         }

         return field;
      }

      public string GetFieldValue(Item item)
      {
         if (!ID.IsNullOrEmpty(FieldID))
         {
            return item[ID.Parse(FieldID)];
         }
         if(!string.IsNullOrEmpty(FieldName))
         {
            return item[FieldName];
         }
         return string.Empty;
      }

      private static bool IsValidField(CustomField field)
      {
         if ((!string.IsNullOrEmpty(field.FieldName) || !ID.IsNullOrEmpty(field.FieldID)) && !string.IsNullOrEmpty(field.LuceneFieldName))
         {
            return true;
         }
         return false;
      }

      private static Field.Index GetIndexType(XmlNode node)
      {
         string indexType = XmlUtil.GetAttribute("indexType", node);
         if (!string.IsNullOrEmpty(indexType))
         {
            switch (indexType.ToLowerInvariant())
            {
               case "no":
                  return Field.Index.NO;
               case "tokenized":
                  return Field.Index.TOKENIZED;
               case "untokenized":
                  return Field.Index.UN_TOKENIZED;
               case "nonorms":
                  return Field.Index.NO_NORMS;
            }
         }
         return Field.Index.TOKENIZED;
      }

      private static Field.Store GetStorageType(XmlNode node)
      {
         string storage = XmlUtil.GetAttribute("storageType", node);
         if (!string.IsNullOrEmpty(storage))
         {
            switch (storage.ToLowerInvariant())
            {
               case "no":
                  return Field.Store.NO;
               case "yes":
                  return Field.Store.YES;
               case "compress":
                  return Field.Store.COMPRESS;
            }
         }
         return Field.Store.NO;
      }
   }
}

And the code for additional methods for DatabaseCrawler.

/// <summary>
/// Loops through the collection of custom fields and adds them to fields collection of each indexed item.
/// </summary>
/// <param name="document">Lucene document</param>
/// <param name="item">Sitecore data item</param>
private void AddCustomFields(Document document, Item item)
{
   foreach(CustomField field in _customFields)
   {
      document.Add(CreateField(field.LuceneFieldName, field.GetFieldValue(item), field.StorageType, field.IndexType, Boost));
   }
}

/// <summary>
/// Creates a Lucene field.
/// </summary>
/// <param name="fieldKey">Field name</param>
/// <param name="fieldValue">Field value</param>
/// <param name="storeType">Storage option</param>
/// <param name="indexType">Index type</param>
/// <param name="boost">Boosting parameter</param>
/// <returns></returns>
private Fieldable CreateField(string fieldKey, string fieldValue, Field.Store storeType, Field.Index indexType, float boost)
{
   Field field = new Field(fieldKey, fieldValue, storeType, indexType);
   field.SetBoost(boost);
   return field;
}

/// <summary>
/// Parses a configuration entry for a custom field and adds it to a collection of custom fields.
/// </summary>
/// <param name="node">Configuration entry</param>
public void AddCustomField(XmlNode node)
{
   CustomField field = CustomField.ParseConfigNode(node);
   if (field == null)
   {
      throw new InvalidOperationException("Could not parse custom field entry: " + node.OuterXml);
   }
   _customFields.Add(field);
}

Last thing that is left to do is to call AddCustomFields method from AddAllFields one.

protected override void AddAllFields (Documentdocument, Itemitem, bool versionSpecific)
{
………………………………………
AddCustomFields(document, item);
}

You can take it even further and add support for some field interpreter for each field configuration entry.

Hope you'll find it useful.

Language filtered Multilist field

2010-08-03T15:06:00.001-07:00

Recently I happened to help one of our clients to create a custom Multilist field that gives you selecting options only if item has at least one translated version in a current content language. From content author’s point of view it makes a lot of sense. Why to give them an option that is not useful?

It’s being a while since I created a custom field that has to take into account content language selection. The main challenge for me was to retrieve that content language. I did remember that there is a property that the Content Editor (CE) sets at run-time for every field but could not recall its name. So after several minutes of browsing my code storage of all samples for all Sitecore versions, I finally found it. So, here are the properties that you need to define in your custom field if you are planning to use them afterwards:

- ItemLanauage – represents a content language selected in the CE.

- ItemID – contains the item ID the field belongs to.

- ItemVersion – contains selected item version.

- ReadOnly – indicates if field is a readonly. If it is, then it will be grayed out and not editable.

- Source – represents the source value from field definition on a data template.

- FieldID – contains the field ID.

In my example I needed only ItemLanguage property. When I put things together the code looked like this:

using Sitecore.Shell.Applications.ContentEditor;
using Sitecore.Data.Items;

namespace Sitecore.Shell.Applications.ContentEditor.CustomExtensions
{
    public class LanguageFilteredMultilist : Sitecore.Shell.Applications.ContentEditor.MultilistEx
    {
        #region Overrides

        protected override Item[] GetItems(Item current)
        {              
            Item[] items = base.GetItems(current);

            var filteredItems = items.Where(item => 
                    {
                        string lang = ItemLanguage;
                        if (!string.IsNullOrEmpty(lang))
                        {
                            var versions = Sitecore.Data.Managers.ItemManager.GetVersions(item, Sitecore.Data.Managers.LanguageManager.GetLanguage(lang, item.Database));
                            return versions.Count > 0;
                        }
                        return false;
                    }
                );   
            
            return filteredItems.ToArray<Item>();
        }

        #endregion Overrides

        // Content Editor sets this property. It has a content language from the Content Editor.
        public string ItemLanguage
        {
            get;
            set;
        }
    }
}

Simple enough isn’t it. Don’t forget to add your custom field to /App_Config/FieldTypes.config file if it’s supposed to contain references to other items. In my case it should be added since it’s a multilist. If you forget to do it, the LinkDatabase won’t update references for your field.

That’s all for now.

Teach User Manager how to search by email

2010-07-02T16:54:00.000-07:00

A couple of days ago one interesting issue popped out in my Inbox. Our customer wanted to search users by email address in User Manager application. Quite legitimate request. Especially if you have an integration with AD or CRM or whatever external security system with large number of users. I tried a couple of configuration changes with no luck. Then checked our support portal knowledge base and saw several request like that. I was surprised by the fact that you cannot search users by email.

After spending several hours investigating how search functionality in User Manager works and doing some "shaman dancing" around it, I ended up with a solution that requires to override a standard Sitecore.Security.Accounts.UserProvider and change its method called "GetUsersByName". As it turned out, search functionality of User Manager calls the GetUserByName method when one searches for a user.

This is how it looks:

namespace Sitecore.SharedSource.Security.Accounts

{

public class UserProvider : Sitecore.Security.Accounts.UserProvider

{

protected override IEnumerable GetUsersByName(int pageIndex, int pageSize, string userNameToMatch)

{

return FindUsers(pageIndex, pageSize, userNameToMatch);

}

protected IEnumerable FindUsers(int pageIndex, int pageSize, string userNameToMatch)

{

Assert.ArgumentNotNull(userNameToMatch, "userNameToMatch");

IEnumerable users = null;

string userWithNoWildcard = StringUtil.RemovePostfix(Settings.Authentication.VirtualMembershipWildcard, StringUtil.RemovePrefix(Settings.Authentication.VirtualMembershipWildcard, userNameToMatch));

if (Regex.IsMatch(userWithNoWildcard, @"^([0-9a-zA-Z]([-.\w]*[0-9a-zA-Z])*@([0-9a-zA-Z][-\w]*[0-9a-zA-Z]\.)+[a-zA-Z]{2,9})$"))

{

users = findByEmail(pageIndex, pageSize, userWithNoWildcard);

}

else

{

users = findUsername(pageIndex, pageSize, userNameToMatch);

}

return users;

}

protected IEnumerable findUsername(int pageIndex, int pageSize, string username)

{

int total;

return new Enumerable(delegate

{

return Membership.FindUsersByName(username, pageIndex, pageSize, out total).GetEnumerator();

delegate(object user)

{

return User.FromName(((MembershipUser)user).UserName, false);

});

}

protected IEnumerable findByEmail(int pageIndex, int pageSize, string userToMatch)

{

int total;

return new Enumerable(delegate

{

return Membership.FindUsersByEmail(userToMatch, pageIndex, pageSize, out total).GetEnumerator();

delegate(object user)

{

return User.FromName(((MembershipUser)user).UserName, false);

});

}

That's it! Simple enough, isn't it.

Thanks to Alex Shyba who helped me with some useful code!

After compiling the code and moving a dll to the /bin folder, don't forget to change a reference in web.config file to point it to a new UserProvider class.

   <userManager defaultProvider="default" enabled="true">
   <providers>
   <clear />
   <add name="default">
   <x:attribute name="type">Sitecore.SharedSource.Security.Accounts.UserProvider, YOUR_DLL_HERE</x:attribute>
   </add>
   </providers>
   </userManager>

For those who consider this so easy so that it's now worth to create a VS project I've built a ready-to-go Sitecore package with a dll and include file inside. Just install it and give it a try ;).

This is a Sitecore package.

Enjoy!

Working with Lucene Search Index in Sitecore 6. Part III - Code examples

2009-11-25T14:33:00.000-08:00

If you read my previous posts about Lucene search index, then you already know how to configure it and how it works in Sitecore application.

In this part we will take a look at API to see what can be achieved using the search index.

To search existing index we need to get an index instance somehow. I'm not going to show the code examples that you would write with old search index. If you're intrested in it, check out this article Lecene Search Engine.

Additional layer of API for new search index resides under Sitecore.Search namespace. In order to get a search index object, you would need to use members of SearchManager class.

To get an index by name use this line of code:

Index indx = Search.Manager.GetIndex(index_name);

If you want to use default system index, you can simply call SystemIndex property of SearchManager class. In order to use Sitecore API to look up for some info in the index, you need to created a search context.

It's easy to do by calling CreateSearchContext method of the index object we got previously. It's also possible to create a search context by using one for the constructors of IndexSearchContext class. In this case it will be easy to run search queries by passing a search index instance as a parameter to the search context.

To search information, we need to create a query and run it in the search context. Sitecore API has a few classes that you can use to build search queries. Let's take a look at each of them:

FullTextQuery - this type of query searches the index by "_content" field. All information from text fields (such as "Single-Line Text", "Rich Text", "Multi-Line Text", "text", "rich text", "html", "memo") is stored there. Data in this field are indexed and tokenized. Which means that the search operations running on these data are very efficient.

FieldQuery - this type of query allows you to search any field that was added to the index. By default database crawler adds all item fields to the index.

CombinedQuery - this type of query was designed to allow you create complex queries with additional conditions. For instance to find items which have specific work in title and belong to some category. When you add search queries to this type of query, you need to supply QueryOccurance parameter. It's Enum type that has the following members:

- Must - it's a logical AND operator in Lucene boolean query.

- MustNot - it's a logical NOT operator in Lucene boolean query.

- Should - it's a logical OR operation in Lucene boolean query.

You can read more about this operators in Query Parser Syntax article.

All of these query types are derived from QueryBase class.

There is one thing left until we jump from the theory to some code samples. To run defined queries, you need to use one of Search methods of IndexSearchContext object.

Now let's create a couple of samples to see a real code that goes behind the theory.

Sample 1: Searching text fields.

// Next samples will skip lines with getting the index instance and creating the search context.

// Get an index object

Index indx = SearchManager.GetIndex("my_index");

// Create a search context

using (IndexSearchContext searchContext = indx.CreateSearchContext())

{

// In following examples I will be using QueryBase class to create search queries.

FullTextQuery ftQuery = new FullTextQuery("welcome");

SearchHits results = searchContext.Search(ftQuery);

}

Sample 2: Searching item fields

Let's say we want to find items classified by some category. There is a trick searching by GUIDs so let's say our category is just a string name.

.....

// FieldQuery ctor accepts two parambers. First is a field name. The other one is a value we're looking for.

QueryBase query = FieldQuery("category", "slr");

SearchHits results = searchContext.Search(query);

.....

Sample 3: Searching by multiple conditions

Turned out that your category parameter is not enough to get required results. You client is screaming that there are too many items and business users cannot find ones they are looking for (is there anything they can find?).

Obviously you have some additional fields that can help to find more strict results. Let's say there is a rating field with values from 1 to 5.

That's where CombinedQuery gets into the game.

.....

// CombinedQuery object has Add method that should be used to add search queries to it. That's why we cannot use base class variable here.

CombinedQuery query = new CombinedQuery();

QueryBase catQuery = new FieldQuery("category", "slr");

QueryBase ratQuery = new FieldQuery("rating", "5");

query.Add(catQuery, QueryOccurance.Must);

query.Add(ratQuery, QueryOccurance.Must);

var hits = searchContext.Search(query);

.....

All results are presented as SearchHits object. Now you should use of following methods of SearchHits object to get the results as Sitecore items:

- FetchResults(int, int) - returns search results as SearchResultCollection. First parameter is a start position of an item you want to start fetching results from. Second one is count of items you want to fetch. By calling this function as mentioned below, you can get all results at once:

var results = hits.FetchResults(0, hits.Length);

- Slice(int) - returns all results as IEnumerable collection.

- Slice(int, int) - this method has similar signature to FetchResults but returns results as IEnumerable collection.

Here are a couple of examples the way you can transform SearchHits object into Sitecore items.

Sample 4: using FetchResults

.....

SearchResultCollection results = hits.FetchResults(0, hits.Length);

IEnumerable searchItems = from hit in results

select hit.GetObject();

}

.....

Sample 5: using Slice

.....

IList searchItems = List();

foreach(var hit in hits.Slice(0))

{

ItemUri itemUri = new ItemUri(hit.Url);

if (itemUri != null)

{

Item item = ItemManager.GetItem(itemUri.ItemID, itemUri.Language, itemUri.Version, Factory.GetDatabase(itemUri.DatabaseName));

if (item != null)

{

searchItems.Add(item);

}

.....

It's worth to mention that some variations of Search method of IndexSearchContext class can accept Lucene.Net.Search.Query as a search query parameter. It becomes very useful when you need to create a complex query which cannot be built with Sitecore query types.

Searching GUIDs.

New search index has lots of useful built-in fields that help to build strict queries.

Besides standard fields it has the following fields that contain GUIDs in ShortID format:

- _links - contains all references to current item

- _path - contains ShortIDs for every parent item in the path relative to current item

- _template - contains GUID of item's tempalte.

NOTE: this field is supposed to have ShortID value instead of GUID one. This field should not be used in combined queries prior to Sitecore 6.2 releases.

If you decide to add custom fields to your search index and they should have GUID values, you need to store them as ShortID in lower case format. Otherwise search will not be able to find any results. The reason why it happens is because Lucene recognizes GUIDs and applies special parsing for them. It works fine if search query has only one field to look into. If it's combined/complex query then it fails to find anything even if it's correct.

So, remember if you need to filter search results by template, you will have to customize DatabaseCrawler to add another field (e.g. _shorttemplateid) to store item template id in ShortID format.

Sample 1: Find all item references

.....

QueryBase query = FieldQuery("_links", ShortID.Encode(item.ID).ToLowerInvariant());

SearchHits results = searchContext.Search(query);

.....

Sample 6: Find all items based on specified template

.....

// Prior to Sitecore 6.2 release, you will need to add and use _shorttemplateid field

QueryBase query = FieldQuery("_template", ShortID.Encode(item.ID).ToLowerInvariant());

SearchHits results = searchContext.Search(query);

.....

Sample 7: Find items that are descendants of a specified one

.....

QueryBase query = FieldQuery("_path", ShortID.Encode(item.ID).ToLowerInvariant());

SearchHits results = searchContext.Search(query);

.....

Sample 8: Find items of a parent and belong to a specific template

.....

CombinedQuery query = new CombinedQuery();

query.Add(new FieldQuery("_shorttemplateid", ShortID.Encode(templateId).ToLowerInvariant()), QueryOccurance.Must);

query.Add(new FieldQuery("_path", ShortID.Encode(parent.ID).ToLowerInvariant())), QueryOccurance.Must);

.....

That's all I wanted to tell about Lucene search index in Sitecore 6. I hope it will help Lucene beginners to better understand the concept and get up to speed with Lucene search index abilities.

Enjoy!

Working with Lucene Search Index in Sitecore 6. Part II - How it works

2009-11-02T08:00:00.000-08:00

Here is second part of the Lucene search index overview for Sitecore 6. In this part we'll take a look at configuration settings and talk about how it works.

Sitecore 5 has Lucene engine as well. Let's step one Sitecore version back and see how Lucene works there. In web.config file there is a section /sitecore/indexes that contains Lucene index configuration. When index is configured, it should be added to /sitecore/databases/database/indexes section.

The web database does not have a search index by default. Even if you add it to aforementioned section, it won't work. Why? Because index configuration relies on HistoryEngine functionality. By default the web database does not have it. It's easy to add it though. Just add the HistoryEngine configuration section to the database.

You can find more configuration details from this article on SDN.

This index has the same configuration in Sitecore 6.

In addition to it, Sitecore 6 has a new Lucene index functionality. Which is more reliable and has Sitecore level API on top of Lucene one. In some cases you will still have to use Lucene API. For instance to create range queries.

Configuration settings for new search index located under /sitecore/search section.

The analyzer section defines a Lucene analyzer that is used to analyze and index content.

The categories section is used to categories search results. It's used for content tree search introduced in Sitecore 6. The search box is located right above the content tree in content editor.

The configuration section has indexes definitions with their configurations. An index definition should be created under /sitecore/search/configuration/indexes node.

First two parameters describe the index name and folder name where it should be stored:

<param desc="name">$(id)</param>
<param desc="folder">my_index_folderName</param>

Next setting is the analyzer that should be used for the index:

<Analyzer ref="search/analyzer" />

Lucene StandardAnalyzer covers most of the case scenarios. But it's possible to use any other analyzer if it's needed.

Following setting defines locations for the index:

<locations hint="list:AddCrawler">

It's possible to have multiple locations for one index. Moreover it's even possible to have content from different databases in the same index. Every child of the locations node has its own configuration for a particular part of the content. A name of location node is not predefined. You're welcome to name it the way you want. For example:

<locations hint="list:AddCrawler">
<sdn-site type="Sitecore.Search.Crawlers.DatabaseCrawler, Sitecore.Kernel">
...

</sdn-site>
</locations>

Every location has a database section. It defines indexing database for the location.

Then root section. The database crawler will index content beneath this path.

Next sibling node is the include section. Here it's possible to add templates items of which should be included to the index or excluded from it.

Example:

<include hint="list:IncludeTemplate">
<sampleItem>{76036F5E-CBCE-46D1-AF0A-4143F9B557AA}</sampleItem>

</include>
<include hint="list:ExcludeTemplate">
<layout>{3A45A723-64EE-4919-9D41-02FD40FD1466}</layout>
</include>

It does not make sense to use both of these settings for the one location. Use only one of them.

Next location setting is tags section. Here you can tag indexed content and use it during the search procedure.

Last setting is boost section. Here you have an ability to boost indexed content among other content that belongs to other locations.

And last but not the least, this search index uses the same HistoryEngine mechanism as old one. So, don't forget to copy configuration section from master database to a database where you want to add search index facilities to.

How it all works?

When an action performed on the item, database crawler updates entries in search index for the item. So that information in index is in sync with the one in database. How does it happen if "item:saved", "item:deleted", "item:renamed", "item:copied", "item:moved" do not have event handlers that trigger search index update? Thank to HistoryEngine that was mentioned several times already.

It is HistoryEngine that tracks any changes made to the item and fires appropriate event handler to process it.

IndexingManager is responsible for all operations to the search index. It subscribes to AddEntry event of HistoryEngine and as soon as an entry added to the History table, it triggers a job that updates the search index(es).

In web.config file there are a few settings that belong to indexing functionality.

Indexing.UpdateInterval - sets the interval between the IndexingManager checking its queue for pending actions. Default value is 5 minutes.
What does it mean? If for whatever reason pending job was not executed, the IndexingManager will re-run it if it finds it in pending state after 5 minutes pass.
Indexing.UpdateJobThrottle - sets the minimum time to wait between individual index update jobs. Default value 1 second.
When some operation is performed on the item, you can see this entry in Sitecore log file:
INFO Starting update of index for the database 'databaseName' ( pending).
This setting sets the interval between jobs like this. So that it does not overwhelm all CPU time if you're doing massive change to the items.
Indexing.ServerSpecificProperties - Indicates if server specific keys should be used for property values (such as 'last updated'). It's off by default.
This setting is designed for content delivery environments in web farms. As web database is shared, there could be a situation when one server has updated its search indexes and changed History table in the database. Other servers won't update their indexes because HistoryEngine wouldn't indicate there was a change. This setting prevents situations like this.

Well... this is it for now. In next part we will take a look at Sitecore Lucene API and create some search queries with it.

Enjoy!

Working with Lucene Search Index in Sitecore 6. Part I - Why/When to use

2009-10-02T08:48:00.001-07:00

How often did you stress yourself thinking on the question "What's the most efficient way to retrieve Sitecore items?"?

Here are possible ways to do it:

Sitecore API
Sitecore Query
SQL custom stored procedures
Lucene index

Let's take a look at each option briefly.

Sitecore API - the most popular way to get an item. All you need is an item ID and simple call of GetItem() method of database instance will get you the latest item version in current language. If you want an item in specific language, not a problem: GetItem(, ). Want specify version, not a problem either: GetItem(, , ). There are many ways to get an item through Sitecore API. My point is that it's the most easiest way to do it.

Sitecore Query - easy way to get a bunch of items filtered by some criteria. Build a string query, which kinda look like XPath query, and run it on a database instance. Read more about Sitecore Query.

SQL custom stored procedures - we all know how to create a SQL stored procedure. Connections strings already exist in Sitecore solution. All you need is to use some SQL management studio to create a stored procedure for the database. The question is why would you do it if API already exists? It makes sense only if you run complex query with lots of filtering conditions so that SQL will return you only items that you're searching for.

Lucene index - why would I use separate data storage/data index to get an item from Sitecore database? It does not make sense. Agree, for an item it does not but for a collection of items it has a perfect sense to do it. Why? Maybe because performance is much better when you are working with big amount of data. Moreover that's a search index. Which means that data are perfectly organized to be searched.

Let's talk about performance characteristics for each of these options and compare them.

Sitecore API - uses Sitecore data provider to pull out information from the database. If item that we're looking for is cached the call to SQL database is avoided and item gets retrieved from one of Sitecore caches. Using Sitecore caches gives you huge performance benefit. That's why we always worried about caches configuration in Sitecore solution. What if you need to get a number of items by some criteria, let's say template ID and belonging to some category (from here on I'm gonna use this condition for all item retrieval options). You run foreach or for or any other logic that goes through the content tree and checks for a TemplateID property and category field of every single item. If item resides in cache, it will be quick enough but still the code will have to request every single item from the content tree.

Sitecore Query - the picture with Sitecore Query is very similar to Sitecore API but it get's more slower when number of items is growing. Kim has a good article that explains Sitecore Query performance.

NOTE: I'm not talking about fast Sitecore Query introduced in Sitecore 6.

SQL stored procedures - it seems to be a good approach to go with if you're searching for items through the content tree. The thing is there will be only one stored procedure that executes query by specified criteria. Also you will have to consider caching option for retrieved items if you have very deep content tree and items of some specific time are not gathered under one branch. My point is that it can cost you more then the benefits that you will get. I would go with this approach only if I cannot do it with Lucene resources.

Lucene index - again it's search index. It perfectly fits searching options. When you search for items with specified criteria it neither requests an item instance nor runs query over database tables. It goes through the fields that you have in your index and compares their values to your search conditions. The only thing if search query uses custom fields to filter data by, the fields must be added to your index. Otherwise you will get zero results. It's very easy to do though. I will describe it in the next part of the article.

Conclusion: Let's answer those questions in the topic of this part.

Why to use lucene index?

The approach is one of the most (maybe event the best) efficient ones. Search is quick enough that in most cases you don't even need to implement custom caching for the retrieved data.

When to use lucene index?

When you need to run search queries with specific criteria on huge number of data.

Don't forget the rule - the more complex search query gets the slower it works ;).

In next part we will look into Lucene search index introduced in Sitecore 6.

Information about "old" Lucene index (it was introduced in Sitecore 5) you can find here.

Restrict access to advanced media upload options

2009-07-30T15:20:00.000-07:00

Sometimes you want to give an access to Advanced Media Upload for editors. When you do it, they get access to all the advanced options that you might not want to share with them.

This package allows you to configure access to advanced media upload options by tighten security on Sitecore items.

After installing the package, you can configure advanced options access for presets items at /sitecore/System/Settings/Media/Presets path.

Download the package.

YouTube Integration source code

2009-03-19T08:56:00.000-07:00

For those who's interested, the source code for YouTube data provider is available on Sitecore Trac system.

Enjoy!

YouTube Integration with Sitecore 6.0

2009-03-06T09:46:00.000-08:00

Recently I got a quite interesting task to build an integration between Sitecore CMS and YouTube repository. I finished that task and I'm willing to share my experience with public. I will describe code only partially. Only those parts I consider the most interesting.

We've been thinking about different approaches and have chosen Sitecore Data Provider approach. We decided to have items in CMS that would represent YouTube videos. One of the challenges was to integrate YouTube videos on the fly when an editor wants to add videos from one or other YouTube author.
This data provider works in read-only mode. If you want to extend this solution, you're welcome to do so.
So let's begin....

Templates

I created two templates that will represent root item for YouTube videos and YouTube video item itself. First one is called "YouTube branch" and the other one is "YouTube video".
YouTube branch is going to be a folder for YouTube video items. Unlike usual folders it has a field that determinates videos of what YouTube author to show beneath it.
YouTube video template extends Flash media template and adds two additional fields: Url and Preview. Url is obviously intended for a YouTube video url. Preview is an iframe field that will show us the preview of YouTube video.

Implementation

There is a required list of methods you must implement to get data provider working. Here are those methods:

- GetItemDefinition
- GetItemFields
- GetChildIDs
- GetParentID
- GetItemVersions

I'm not going to describe what they are for. You can find a detailed explanation on SDN.
One method is missing in this list. It's "GetTemplates" method. We can avoid implementing this method if required templates already exist in our data source.
I'm going to use master database as a source for YouTube video items. I created a couple of templates for this approach so that we can skip implementation of the "GetTemplates" method.
Also I made this data provider publish its items by implementing one publishing method:

- GetPublishQueue

This is how constructor looks for the data provider:
public YouTubeDataProvider(string rootTID, string resourceTID, string videoOwnerField, string contentDB)
{
prefix = ToString();
rootTemplateID = rootTID;
resourceTemplateID = resourceTID;
contentDatabase = contentDB;
videoOwnerFieldName = videoOwnerField;
_items = new Hashtable();
}

rootTemplateID contains an ID of YouTube branch template
resourceTemplateID contains an ID of YouTube video template
contentDatabase is a source database for our YouTube provider (it's master database)
videoOwnerFieldName is a field name of YouTube branch template where you specify an owner of YouTube videos.
_items is a temporary cache for our YouTube videos.
Since we need to use some sort of mapping between YouTube videos and Sitecore items, I'm going to use existing functionality of IDTable. That's what we need "prefix" variable for.

Now let's look at implementation of first method:
public override ItemDefinition GetItemDefinition(ID itemId, CallContext context)
{
ItemDefinition itemDef = null;
string itemName = string.Empty;
if (CanProcessYouTubeItem(itemId, context))
{
// method body
}
return itemDef;
}

The first thing we need to think of is how to determine if the item we are getting from data provider is our YouTube item. That's what CanProcessYouTubeItem method for. This method uses IDTable API to find out if an item comes from YouTube rather than SQL database. Here is the code for the method:
bool CanProcessYouTubeItem(ID id, CallContext context)
{
if (IDTable.GetKeys(prefix, id).Length > 0)
{
return true;
}
return false;
}

The same technic is used for GetItemFields, GetParentID and GetItemVersions methods. For GetChildIDs we had to use different code because we had to work with parent item. Here is a code for the method:
public override Sitecore.Collections.IDList GetChildIDs(ItemDefinition itemDefinition, CallContext context)
{
if (CanProcessParent(itemDefinition.ID, context))
{
// method body
}
return null;
}

CanProcessParent method checks if the item is our YouTube branch item. If it indicates that it is then we start processing our child items that are YouTube videos.
This is the code of the method:
bool CanProcessParent(ID id, CallContext context)
{
Item item = ContentDB.Items[id];
bool canProduce = false;
if (item != null && (ID.Parse(rootTemplateID) == item.TemplateID))
{
canProduce = true;
}
return canProduce;
}

After we get our items, we have to fill out their fields to finish our integration process. Information from YouTube video is mapped in GetItemFields method. This is the code:
public override FieldList GetItemFields(ItemDefinition itemDefinition, VersionUri versionUri, CallContext context)
{
FieldList fields = new FieldList();
if (CanProcessYouTubeItem(itemDefinition.ID, context))
{
string originalID = GetOriginalRecordID(itemDefinition.ID);
TemplateItem templateItem = ContentDB.Templates[resourceTemplateID];
if (templateItem != null)
{
YTItemInfo ytItemInfo = GetYTItemInfo(itemDefinition.ID);
if (ytItemInfo != null)
{
foreach (var field in templateItem.Fields)
{
fields.Add(field.ID, GetFieldValue(field, ytItemInfo));
}
}
}
}
return fields;
}

As you can see it's simply iterates through template fields and maps data from YouTube Entry to Sitecore YouTube video item.
We got YouTube video items in our content tree. But we cannot do anything with them on front-end. One option is to add our data provider to web database to get it working on front-end. But what if we make main data provider know about our items and just publish them as a real items. All I need to do is to get list of IDs of our items in GetPublishQueue method.
This is how the code looks:
public override IDList GetPublishQueue(DateTime from, DateTime to, CallContext context)
{
IDList list = new IDList();
foreach (var item in _items)
{
YTItemInfo ytItemInfo = (YTItemInfo) item;
list.Add(ytItemInfo.ItemID);
}
return list;
}

Since I did not use a publish queue table, YouTube items are going to be published every time to run publish operation on them. You can avoid this if you implement AddToPublishQueue and CleanupPublishQueue methods.

Here is a screen dump the way YouTube item looks in Sitecore media library:

This is a sitecore package that will install data provider on your Sitecore 6.0 CMS. I do not described provider configuration in this article. You can find it in /App_Config/Include folder after installing the package.
NOTE: if installation fails, that means that you run into a known issue. Reinstalling the package should solve it.

Adding buttons to inline-editing frame

2008-12-19T10:51:00.000-08:00

Today's post is dedicated to Sitecore inline-editor and some customization you can put into it. The question I'm going to address is:
"Is it possible to add custom buttons to inline-editor frame?"
The answer is simple as is: "Yes, it is" :). Wait... don't go away. Read further to find out the solution.

Our challenge is to add a button to inline-editor. Let's do that for Rich Text field.
I put this approach into the steps to outline this process. Let's start:

1) Open Sitecore Client and go to the Core database.
As you know (or maybe you're going to find out right away) Rich Text field has several profiles to give different sets of functionality to logged in users. Let's go to default profile and check its configuration, here is the path in content tree: "/sitecore/system/Settings/Html Editor Profiles/Rich Text Default".

2) The configuration node we're interested in is "WebEdit Buttons". Go ahead and expand it.
Beneath the node you can see all available buttons which are going to show up as soon as you put mouse cursor over the rich text data in Page Editor.

3) Since we're already here let's add our own button to the current set. A button should be created from "/sitecore/templates/System/WebEdit/WebEdit Button" template.

Header field contains the name of the button in inline-editor frame.
Icon field has the icon for the button
Click field is the most important part. It has command message that should be sent when you hit the button.

a) Here is the format of this field for the custom command: "javascript:return Sitecore.WebEdit.editControl($JavascriptParameters, "webedit:mybutton:message")"
Javascript command is required to set you command message that is passed as second parameter for the "editControl" function.
"webedit:mybutton:message" is command message. Don't be concerned about the format of this message. It can have any format you want. For instance: "webedit:mymessage" or "webedit:mybutton:mymessage". It's good when the first part of the message describes an area the message belongs to, e.g. "webedit:".

b) Here is another example to run JavaScript function through the button.
Click field should look like this: javascript:Sitecore.WebEdit.execute("js_function_name", true, "parameter_for_js_function");
This example changes the font size:
javascript:Sitecore.WebEdit.execute("fontsize", true, "20");

NOTE: if you use javascript function, the Header field for the button item should be left empty.

Tooltip field describes itself :).

4) This is the final step. You have to create a command handler that will do action you want.
I'm not going to touch command creation process here. You can find sample in John's article here.
NOTE: webedit command handler class must be inherited from Sitecore.Shell.Applications.WebEdit.Commands.WebEditCommand one.

Migrate from 5.3 to 6.0 (alpha)

2008-07-25T16:40:00.000-07:00

Today was my first experience with "alpha" version of Sitecore migration from 5.3 to 6.0.
What I can say, that was not so bad :-). Anyways, I have to say that my site was pretty simple and did not have heavy customization (no custom fields, default devices, no proxies).
I migrated only master database because I had only default security objects in my solution.
I followed all steps from documentation and did not face any problems. Altogether it took about 3 hours to migrate my content and clean up my solution from migration tool. Not bad! Again that was the first time when I saw this tool.
In addition I spent about 2+ hours to adjust my code to spin it in Sitecore 6.0.
The most common issue for my renderings was related to pulling out media url using "sc:fld()" function and media item variable.
I had to substitute "sc:fld()" for "sc:GetMediaUrl()".

I thought I would have to do some modifications to get in-line editing working in V6. I was surprised that old buddy "sc:dot" represented this opportunity.
So, as a result it is not so bad as it sounds at the first glance ;-).
You should try it out!

Share site resources among several sites

2008-04-17T08:27:00.000-07:00

If you have lots of sites with similar structure and presentation layer you can make them use resources of one Sitecore site from web.config file. To do this you can create custom SiteResolver and insert it in <httprequestbegin> pipeline just after the native SiteResolver processor.
Using this approach you should have custom SiteResolver processor and special config file where you can map your sites to the same instance of Sitecore site from web.config file. It shows you how you can set several host names for the same Sitecore site in web.config file.
NOTE: This approach is supposed to have “website” site in your web.config file.
Using this idea you can set not only host names but the whole site configuration for the same Sitecore site. In that case you will be able to share cache and other resources among several sites.
Below are the steps how to apply this approach:
1) Create custom SiteResolver and set add it in web.config file just after the native SiteResolver processor, as shown below:
<httprequestbegin>
………………
<processor type="Sitecore.Pipelines.HttpRequest.SiteResolver, Sitecore.Kernel" />
<processor type="SiteMapper.Pipelines.HttpRequest. SimilarSitesResolver, SiteMapper" />
………………
</httprequestbegin>

2) Create special config file (similar.sites.config) to map your sites with the following structure:
<sites>
<site mode="on" name="www.mysite" hostname="www.mysite.dk" language="da-DK" />
<site mode="on" name="www.mysite" hostname="www.mysite.uk" language="en-GB" />
<site mode="on" name="www.mysite" hostname="www.mysite.com" language="en" />
</sites>

As you can see all three sites have the same “name”. This name determine which site from web.config file should be used when you request any of these sites.
Example of web.config file:

<site mode="on" name="www.mysite" hostname=" www.mysite.com" language="en" virtualfolder="/" physicalfolder="/" rootpath="/sitecore/content" startitem="/www.mysite/home" database="web" domain="extranet" allowdebug="true" cachehtml="true" htmlcachesize="10MB" enablepreview="true" enablewebedit="true" enabledebugger="true" disableclientdata="false" />

<site name="website" virtualfolder="/" physicalfolder="/" rootpath="/sitecore/content" startitem="/flugger/home" database="master" domain="extranet" allowdebug="true" cachehtml="true" htmlcachesize="10MB" enablepreview="true" enablewebedit="true" enabledebugger="true" disableclientdata="false" />

NOTE: each Sitecore site in web.config file must have hostName attribute. Otherwise Sitecore will classify this site as a default website and you won’t get required results.

Here is Sitecore package.

Convert unversioned media to versioned

2008-03-31T13:03:00.000-07:00

This tool is intended to make a work with media be smoothly. By default Sitecore uploads media as unversioned data. In order to have different media data for different languages we need to upload media as versioned. Otherwise you won't be able to have different data for the same media item. Even if you change unversioned template to versioned.
After installing the package a "Make versioned" button will be available on Media tab.

You can convert media item as well as the whole media folder.

You can download sitecore package from here.

Cross Database TreeList Field

2008-03-03T10:40:00.000-08:00

Sometimes we would like to have an opportunity to get data from another database in sitecore field. Since we already have source code of TreeList field on SDN, I decided to adjust it a little bit to have such opportunity.
To allow cross db usage I had to add one parameter to the source query of TreeList field.
It's SourceDatabaseName parameter.
Here is example how to get users from security database in TreeList field.

DataSource=/sitecore/users&SourceDatabaseName=security

Here is the way it looks:

To get rid of broken links in this field I had to MultilistCrossDbField which is intended to validate links correctly in LinkDatabase. So, don't forget to add the line below into /App_Config/FieldTypes.config file:

<configuration>
............

<fieldtype name="tree list cross db" type="Custom.Data.Fields.MultilistCrossDbField,TreeListCrossDB">
</fieldtype>
</configuration>

I added support for "query:" definition into this field. Now you can use either "/sitecore/content" or "query:/sitecore/content/*" as a data source for the field.

Here is Sitecore Package for the field.
Here is source code.

Go To Item tool

2008-02-29T11:20:00.000-08:00

Sometimes you have item ID or somebody provides you with pretty long item path and you want to navigate to the item as fast as you can. Of course you can use DBBrowser tool but it's not very convenient switching between several browser windows, isn't it.
So, I created a "Go To Item" tool and I like to share it with Sitecore lovers :).
To get it working you have to install the attached Sitecore package on your Sitecore.
After installation you can see the "Go To Item" button on Developer tab.

After clicking the button you get dialog window where you should input item path/ID. Since /sitecore item is a root of any sitecore trees you can avoid it in item path.

Here is Sitecore package (follow readme instruction during installation).
Here is GoToItem sources.