Added advanced options for Lateral Fallback

Added options for clipping text at x characters and appending an
ellipsis. This requires advanced XML based config settings in the field.
See code for example.

Author: seankearney

src/Processors.Sitecore.Master/sitecore/templates/System/Templates/Sections/Fallback/Fallback/__FallbackFields.item

@@ -13,9 +13,9 @@ templatekey: Template field
 field: {AB162CC0-DC80-4ABF-8871-998EE5D7BA32}
 name: Type
 key: type
-content-length: 15
+content-length: 16
 
-Name Value List
+Single-Line Text
 ----field----
 field: {BA3F86A2-4A1C-4D78-B63D-91C2779C1B5E}
 name: __Sortorder
@@ -87,7 +87,7 @@ sitecore\admin
 ----version----
 language: en
 version: 1
-revision: b2c9b530-8aa0-4214-92c8-500bc65e5676
+revision: 834742a5-dab0-4afe-b861-fd1dc079fd82
 
 ----field----
 field: {19A69332-A23E-4E70-8D16-B2640CB24CC8}
@@ -144,21 +144,21 @@ name: __Revision
 key: __revision
 content-length: 36
 
-b2c9b530-8aa0-4214-92c8-500bc65e5676
+834742a5-dab0-4afe-b861-fd1dc079fd82
 ----field----
 field: {D9CF14B1-FA16-4BA6-9288-E8A174D4D522}
 name: __Updated
 key: __updated
 content-length: 34
 
-20120702T103009:634768218094173456
+20130923T124654:635155372147379973
 ----field----
 field: {BADD9CF9-53E0-4D0C-BCC0-2D784C282F6A}
 name: __Updated by
 key: __updated by
 content-length: 14
 
-sitecore\Admin
+sitecore\admin
 ----version----
 language: ja-JP
 version: 1

src/Processors/Data/Items/FallbackItem.cs

@@ -1,6 +1,7 @@
 using System.Collections.Generic;
 using System.Collections.Specialized;
 using System.Linq;
+using System.Xml;
 using FieldFallback.Data;
 using Sitecore.Data;
 using Sitecore.Data.Fields;
@@ -13,14 +14,11 @@ internal class FallbackItem : CustomItemBase
     {
         public static readonly ID FallbackFields = new ID("{8A826BE2-C878-49DA-A0F7-32DB6718E2FB}");
 
-        private NameValueCollection _fallbackConfiguration;
-        private Dictionary<ID, List<Field>> _fallbackDefinition;
-
         private FallbackItem(Item innerItem) : base(innerItem)
         {
-          
+            Initialize();
         }
-        
+
         public static implicit operator FallbackItem(Item item)
         {
             if (item == null)
@@ -30,7 +28,7 @@ public static implicit operator FallbackItem(Item item)
 
             return new FallbackItem(item);
         }
-        
+
         /// <summary>
         /// Gets a value indicating whether this item has lateral fallback configured.
         /// </summary>
@@ -41,58 +39,32 @@ public bool HasLateralFallback
         {
             get
             {
-                return FallbackConfiguration.HasKeys();
-            }
-        }
-
-        /// <summary>
-        /// Gets the fallback configuration from the "FallbackFields" field.
-        /// </summary>
-        /// <value>The fallback configuration.</value>
-        protected NameValueCollection FallbackConfiguration
-        {
-            get
-            {
-                if (_fallbackConfiguration == null)
-                {
-                    // don't use fallback on this configuration field
-                    using (new FallbackDisabler())
-                    {
-                        _fallbackConfiguration = WebUtil.ParseUrlParameters(InnerItem[FallbackFields]);
-                    }
-                }
-                return _fallbackConfiguration ?? new NameValueCollection(0);
+                return FallbackDefinition.Keys.Count > 0;
             }
         }
 
         /// <summary>
         /// Gets the fallback definition.
         /// </summary>
         /// <value>The fallback definition.</value>
-        protected Dictionary<ID, List<Field>> FallbackDefinition
+        protected Dictionary<ID, Setting> FallbackDefinition
         {
-            get
-            {
-                if (_fallbackDefinition == null)
-                {
-                    _fallbackDefinition = InitializeLateralFallbackConfiguration();
-                }
-                return _fallbackDefinition;
-            }
+            get;
+            private set;
         }
 
         /// <summary>
         /// Gets the fallback fields for the given field.
         /// </summary>
         /// <param name="field">The field.</param>
         /// <returns></returns>
-        public List<Field> GetFallbackFields(Field field)
+        public Setting GetFallbackFields(Field field)
         {
             if (DoesFieldHaveLateralFallback(field))
             {
                 return FallbackDefinition[field.ID];
             }
-            return new List<Field>(0);
+            return null;
         }
 
         /// <summary>
@@ -114,51 +86,134 @@ public IEnumerable<ID> GetFieldsThatFallbackTo(Field field)
         {
             foreach (ID key in FallbackDefinition.Keys)
             {
-                if (FallbackDefinition[key].Any(f => f.ID == field.ID))
+                if (FallbackDefinition[key].SourceFields.Any(f => f.ID == field.ID))
                 {
                     yield return key;
                 }
             }
         }
 
-        /// <summary>
-        /// Converts the NameValueCollection into Dictionary<ID, List<Field>> 
-        /// where the key is the ID of the field to recieve the fallback value
-        /// and the values are the list of fields to check for a fallback value
-        /// </summary>
-        /// <returns></returns>
-        private Dictionary<ID, List<Field>> InitializeLateralFallbackConfiguration()
+        private void Initialize()
         {
-            Dictionary<ID, List<Field>> dic; 
-            if (!HasLateralFallback)
+            var _fallbackDefinition = new Dictionary<ID, Setting>();
+
+            // don't use fallback on this configuration field
+            using (new FallbackDisabler())
             {
-                dic = new Dictionary<ID, List<Field>>(0);
+                // try to get this fields as an XML field
+                // Original version of this field was key/value pair
+                // It was converted to XML to support advanced options
+                XmlField test = InnerItem.Fields[FallbackFields];
+                if (test.Xml == null)
+                {
+                    ParseNameValueConfiguration(InnerItem[FallbackFields], _fallbackDefinition);
+                }
+                else
+                {
+                    ParseXmlConfiguration(test, _fallbackDefinition);
+                }
             }
-            else
+            FallbackDefinition = _fallbackDefinition;
+        }
+
+        private void ParseNameValueConfiguration(string oldConfigurationValue, Dictionary<ID, Setting> settings)
+        {
+            NameValueCollection fallbackConfiguration = WebUtil.ParseUrlParameters(oldConfigurationValue);
+            foreach (string fieldName in fallbackConfiguration.AllKeys)
             {
-                dic = new Dictionary<ID, List<Field>>();
-                foreach (string fieldName in FallbackConfiguration.AllKeys)
-                {
-                    Field mainField = InnerItem.Fields[fieldName];
+                Field mainField = InnerItem.Fields[fieldName];
 
-                    if (mainField != null)
+                if (mainField != null)
+                {
+                    List<Field> fallbackFields = new List<Field>();
+                    List<string> fallbackFieldNames = fallbackConfiguration.GetValues(fieldName).FirstOrDefault().Split(new char[] { '|', ',', ';' }, System.StringSplitOptions.RemoveEmptyEntries).ToList();
+                    foreach (string fallbackFieldName in fallbackFieldNames)
                     {
-                        List<Field> fallbackFields = new List<Field>();
-                        List<string> fallbackFieldNames = FallbackConfiguration.GetValues(fieldName).FirstOrDefault().Split(new char[]{'|', ',', ';'}, System.StringSplitOptions.RemoveEmptyEntries).ToList();
-                        foreach (string fallbackFieldName in fallbackFieldNames)
+                        Field f = InnerItem.Fields[fallbackFieldName];
+                        if (f != null)
                         {
-                            Field f = InnerItem.Fields[fallbackFieldName];
-                            if (f != null)
-                            {
-                                fallbackFields.Add(f);
-                            }
+                            fallbackFields.Add(f);
                         }
+                    }
+
+                    Setting setting = new Setting();
+                    setting.SourceFields = fallbackFields;
 
-                        dic.Add(mainField.ID, fallbackFields);
+                    settings.Add(mainField.ID, setting);
+                }
+            }
+        }
+
+        private void ParseXmlConfiguration(XmlField fallbackField, Dictionary<ID, Setting> settings)
+        {
+            // complex structure...
+            // TODO: Create a nice Sitecore field editing interface for this
+
+            /// <fallback>
+            ///     <setting target="{id}" source="{id}|{id}|{id}..." enableEllipsis="true|false" clipAt="{number chars}" />
+            ///     <setting target="{id}" source="{id}|{id}|{id}..." enableEllipsis="true|false" clipAt="{number chars}" />
+            ///     ...
+            /// </fallback>
+
+            foreach (XmlNode child in fallbackField.Xml.FirstChild.ChildNodes)
+            {
+                XmlAttribute target = child.Attributes["target"];
+                XmlAttribute source = child.Attributes["source"];
+                XmlAttribute enableEllipsis = child.Attributes["enableEllipsis"];
+                XmlAttribute clipAt = child.Attributes["clipAt"];
+
+                /// TODO: Guard against improper input.. move to factory
+                Setting setting = new Setting();
+
+                if (enableEllipsis != null)
+                {
+                    setting.UseEllipsis = bool.Parse(enableEllipsis.Value);
+                }
+
+                if (clipAt != null)
+                {
+                    int i;
+                    if (int.TryParse(clipAt.Value, out i) && i > 0)
+                    {
+                        setting.ClipAt = i;
+                    }
+                }
+
+                List<Field> fallbackFields = new List<Field>();
+                List<string> fallbackFieldNames = source.Value.Split(new char[] { '|', ',', ';' }, System.StringSplitOptions.RemoveEmptyEntries).ToList();
+                foreach (string fallbackFieldName in fallbackFieldNames)
+                {
+                    Field f = InnerItem.Fields[fallbackFieldName];
+                    if (f != null)
+                    {
+                        fallbackFields.Add(f);
                     }
                 }
+
+                setting.SourceFields = fallbackFields;
+
+                ID targetID = new Sitecore.Data.ID(target.Value);
+
+                settings.Add(targetID, setting);
+
             }
-            return dic;
+        }
+
+        internal class Setting
+        {
+            public List<Sitecore.Data.Fields.Field> SourceFields { get; set; }
+
+            public bool TruncateText
+            {
+                get
+                {
+                    return ClipAt.HasValue;
+                }
+            }
+
+            public bool UseEllipsis { get; set; }
+
+            public int? ClipAt { get; set; }
         }
     }
 }