Bump version number

All default prevalue enrichment is now handled by the API method
GetAllPropertyEditors()

Gruntfile.js

@@ -57,10 +57,13 @@ module.exports = function(grunt) {
           'app/directives/archetypeproperty.js',
           'app/directives/archetypesubmitwatcher.js',
           'app/directives/archetypecustomview.js',
-          'app/directives/localize.js',
-          'app/services/localization.js',
-          'app/helpers/labelhelpers.js',
-          'app/resources/propertyeditor.js'
+          'app/directives/archetypeLocalize.js',
+          'app/services/archetypeLocalizationService.js',
+          'app/helpers/sampleLabelHelpers.js',
+          'app/resources/archetypePropertyEditorResource.js',
+          'app/services/archetypeService.js',
+          'app/services/archetypeLabelService.js',
+          'app/services/archetypeCacheService.js'
         ],
         dest: '<%= basePath %>/js/archetype.js'
       }

app/Umbraco/Archetype.Courier/DataResolvers/ArchetypeDataResolver.cs

@@ -62,7 +62,7 @@ namespace Archetype.Courier.DataResolvers
 					{
 						foreach (var property in config.Fieldsets.SelectMany(x => x.Properties))
 						{
-							item.Dependencies.Add(property.DataTypeGuid.ToString(), ProviderIDCollection.dataTypeItemProviderGuid);
+							item.Dependencies.Add(property.DataTypeGuid.ToString(), ItemProviderIds.dataTypeItemProviderGuid);
 						}
 
 						item.Prevalues[0].Value = JsonConvert.SerializeObject(config, Formatting.None);
@@ -76,7 +76,7 @@ namespace Archetype.Courier.DataResolvers
 			if (propertyData != null && propertyData.Value != null)
 			{
 				var dataType = ExecutionContext.DatabasePersistence.RetrieveItem<DataType>(new ItemIdentifier(propertyData.DataType.ToString(),
-					ProviderIDCollection.dataTypeItemProviderGuid));
+					ItemProviderIds.dataTypeItemProviderGuid));
 
 				//Fetch the Prevalues for the current Property's DataType (if its an 'Archetype config')
 				var prevalue = dataType.Prevalues.FirstOrDefault(x => x.Alias.ToLowerInvariant().Equals("archetypeconfig"));
@@ -94,7 +94,7 @@ namespace Archetype.Courier.DataResolvers
 				if (archetype != null)
 				{
 					// get the `PropertyItemProvider` from the collection.
-					var propertyItemProvider = ItemProviderCollection.Instance.GetProvider(ProviderIDCollection.propertyDataItemProviderGuid, ExecutionContext);
+					var propertyItemProvider = ItemProviderCollection.Instance.GetProvider(ItemProviderIds.propertyDataItemProviderGuid, ExecutionContext);
 
 					foreach (var property in archetype.Fieldsets.SelectMany(x => x.Properties))
 					{
@@ -111,7 +111,7 @@ namespace Archetype.Courier.DataResolvers
 								new ContentProperty
 								{
 									Alias = property.Alias,
-									DataType = ExecutionContext.DatabasePersistence.GetUniqueId(property.DataTypeId, NodeObjectTypes.DataType),
+									DataType = ExecutionContext.DatabasePersistence.GetUniqueId(property.DataTypeId, UmbracoNodeObjectTypeIds.DataType),
 									PropertyEditorAlias = property.PropertyEditorAlias,
 									Value = property.Value
 								}
@@ -157,7 +157,7 @@ namespace Archetype.Courier.DataResolvers
 
 								// (if packaging) add a dependency for the property's data-type
 								if (direction == Direction.Packaging)
-									item.Dependencies.Add(firstDataType.DataType.ToString(), ProviderIDCollection.dataTypeItemProviderGuid);
+									item.Dependencies.Add(firstDataType.DataType.ToString(), ItemProviderIds.dataTypeItemProviderGuid);
 							}
 						}
 					}
@@ -179,7 +179,7 @@ namespace Archetype.Courier.DataResolvers
 				{
 					var dataType = ExecutionContext.DatabasePersistence.RetrieveItem<DataType>(
 						new ItemIdentifier(property.DataTypeGuid.ToString(),
-							ProviderIDCollection.dataTypeItemProviderGuid));
+							ItemProviderIds.dataTypeItemProviderGuid));
 
 					if (dataType == null)
 						continue;
@@ -203,7 +203,7 @@ namespace Archetype.Courier.DataResolvers
 						{
 							propertyInst.DataTypeGuid = property.DataTypeGuid.ToString();
 							propertyInst.DataTypeId = ExecutionContext.DatabasePersistence.GetNodeId(
-								property.DataTypeGuid, NodeObjectTypes.DataType);
+								property.DataTypeGuid, UmbracoNodeObjectTypeIds.DataType);
 							propertyInst.PropertyEditorAlias = property.PropertyEditorAlias;
 						}
 					}

app/Umbraco/Umbraco.Archetype/Api/ArchetypeDataTypeController.cs

@@ -8,6 +8,9 @@ using Umbraco.Core.Models;
 using Umbraco.Web.Models.ContentEditing;
 using Umbraco.Web.Mvc;
 using Umbraco.Web.Editors;
+using Umbraco.Core.PropertyEditors;
+using Archetype.Extensions;
+using Newtonsoft.Json;
 
 namespace Archetype.Api
 {
@@ -19,7 +22,7 @@ namespace Archetype.Api
         {
             return
                 global::Umbraco.Core.PropertyEditors.PropertyEditorResolver.Current.PropertyEditors
-                    .Select(x => new {defaultPreValues = x.DefaultPreValues, alias = x.Alias, view = x.ValueEditor.View});
+                    .Select(x => new {defaultPreValues = x.DefaultPreValuesForArchetype(), alias = x.Alias, view = x.ValueEditor.View});
         }
 
         public object GetAll() 
@@ -35,6 +38,7 @@ namespace Archetype.Api
             {
                 throw new HttpResponseException(HttpStatusCode.NotFound);
             }
+
             var dataTypeDisplay = Mapper.Map<IDataTypeDefinition, DataTypeDisplay>(dataType);
             return new { selectedEditor = dataTypeDisplay.SelectedEditor, preValues = dataTypeDisplay.PreValues };
         }

app/Umbraco/Umbraco.Archetype/Archetype.Umbraco.csproj

@@ -234,6 +234,7 @@
     <Compile Include="Extensions\ArchetypeHelper.cs" />
     <Compile Include="Extensions\HtmlHelperExtensions.cs" />
     <Compile Include="Extensions\ArchetypePropertyModelExtensions.cs" />
+    <Compile Include="Extensions\PropertyEditorExtensions.cs" />
     <Compile Include="Extensions\StringExtensions.cs" />
     <Compile Include="Models\ArchetypeModel.cs" />
     <Compile Include="Models\ArchetypePreValue.cs" />

app/Umbraco/Umbraco.Archetype/Extensions/ArchetypeHelper.cs

@@ -3,6 +3,7 @@ using System.Linq;
 using Archetype.Models;
 using Newtonsoft.Json;
 using Umbraco.Core;
+using Umbraco.Core.Logging;
 using Umbraco.Core.Models;
 using Umbraco.Core.Models.PublishedContent;
 
@@ -42,6 +43,7 @@ namespace Archetype.Extensions
                 }
                 catch (Exception ex)
                 {
+                    LogHelper.Error<ArchetypeHelper>("DeserializeJsonToArchetype", ex);
                 }
 
                 return archetype;
@@ -66,6 +68,7 @@ namespace Archetype.Extensions
                 }
                 catch (Exception ex)
                 {
+                    LogHelper.Error<ArchetypeHelper>("DeserializeJsonToArchetype", ex);
                 }
 
                 return archetype;

app/Umbraco/Umbraco.Archetype/Extensions/PropertyEditorExtensions.cs

@@ -0,0 +1,58 @@
+using System.Collections.Generic;
+using System.Linq;
+using Newtonsoft.Json;
+using Umbraco.Core.PropertyEditors;
+
+namespace Archetype.Extensions
+{
+	public static class PropertyEditorExtensions
+    {
+		/// <summary>
+		/// Formats the default prevalues for a property editor for use within an Archetype clientside context
+		/// </summary>
+		/// <param name="propertyEditor">The property editor</param>
+		/// <returns>The formatted default prevalues</returns>
+		public static IDictionary<string, object> DefaultPreValuesForArchetype(this PropertyEditor propertyEditor)
+        {
+			if (propertyEditor.DefaultPreValues == null || propertyEditor.DefaultPreValues.Any() == false)
+			{
+				return propertyEditor.DefaultPreValues;
+			}
+			var view = propertyEditor.ValueEditor.View.ToLowerInvariant();
+
+			// This is the extension point for default prevalues formatting, in case we need to handle any other
+			// property editors later on. It should be replaced with a switch statement by then, or maybe some fancy 
+			// auto discovery of formatters :)
+			if (view == "imagecropper")
+			{
+				propertyEditor.FormatImageCropperDefaultPreValuesForArchetype();
+			}
+			return propertyEditor.DefaultPreValues;
+        }
+
+		/// <summary>
+		/// Format the default prevalues of the image cropper property editor
+		/// </summary>
+		/// <param name="propertyEditor"></param>
+		/// <remarks>
+		/// In order for the image cropper to work clientside, we need to make sure it's default prevalue "focalpoint" is returned
+		/// as a JSON object and not as the string it's defined as on the image cropper property editor.
+		/// </remarks>
+		private static void FormatImageCropperDefaultPreValuesForArchetype(this PropertyEditor propertyEditor)
+		{
+			const string focalPointKey = "focalPoint";
+
+			if (propertyEditor.DefaultPreValues.ContainsKey(focalPointKey) == false || propertyEditor.DefaultPreValues[focalPointKey] == null)
+			{
+				return;
+			}
+			var focalPoint = propertyEditor.DefaultPreValues[focalPointKey].ToString();
+			if (string.IsNullOrEmpty(focalPoint))
+			{
+				return;
+			}
+			// translate the JSON string to a JSON object
+			propertyEditor.DefaultPreValues[focalPointKey] = JsonConvert.DeserializeObject(focalPoint);
+		}
+    }
+}

app/Umbraco/Umbraco.Archetype/Models/ArchetypeFieldsetModel.cs

@@ -2,6 +2,7 @@ using System.Collections.Generic;
 using System.Linq;
 using Newtonsoft.Json;
 using Umbraco.Core;
+using System;
 
 namespace Archetype.Models
 {
@@ -16,6 +17,9 @@ namespace Archetype.Models
         [JsonProperty("properties")]
         public IEnumerable<ArchetypePropertyModel> Properties;
 
+        [JsonProperty("id")]
+        public Guid Id { get; set; }
+
         public ArchetypeFieldsetModel()
         {
             Properties = new List<ArchetypePropertyModel>();
@@ -84,4 +88,4 @@ namespace Archetype.Models
         #endregion
 
     }
-}
+}

app/Umbraco/Umbraco.Archetype/Models/ArchetypeModel.cs

@@ -1,7 +1,7 @@
 using System;
 using System.Collections;
 using System.Collections.Generic;
-using System.Linq;
+using System.Linq;
 using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
 
@@ -30,15 +30,22 @@ namespace Archetype.Models
 
         public string SerializeForPersistence()
         {
+            // clear the editor state before serializing (it's temporary state data)
+            foreach(var property in Fieldsets.SelectMany(f => f.Properties.Where(p => p.EditorState != null)).ToList())
+            {
+                property.EditorState = null;
+            }
+
             var json = JObject.Parse(JsonConvert.SerializeObject(this, new JsonSerializerSettings() { ReferenceLoopHandling = ReferenceLoopHandling.Ignore }));
+
             var propertiesToRemove = new String[] { "propertyEditorAlias", "dataTypeId", "dataTypeGuid", "hostContentType" };
 
             json.Descendants().OfType<JProperty>()
               .Where(p => propertiesToRemove.Contains(p.Name))
               .ToList()
-              .ForEach(x => x.Remove());
-
-            return json.ToString(Formatting.None);
+              .ForEach(x => x.Remove());
+
+            return json.ToString(Formatting.None);
         }
     }
 }

app/Umbraco/Umbraco.Archetype/Models/ArchetypePropertyModel.cs

@@ -26,6 +26,10 @@ namespace Archetype.Models
         [JsonProperty("dataTypeGuid")]
         internal string DataTypeGuid { get; set; }
 
+        // container for temporary editor state from the Umbraco backend
+        [JsonProperty("editorState")]
+        internal UmbracoEditorState EditorState { get; set; }
+
         [JsonProperty("hostContentType")]
         internal PublishedContentType HostContentType { get; set; }
 
@@ -88,5 +92,12 @@ namespace Archetype.Models
 
             return Attempt<T>.Fail();
         }
+
+        internal class UmbracoEditorState
+        {
+            // container for the names of any files selected for a property in the Umbraco backend
+            [JsonProperty("fileNames")]
+            public IEnumerable<string> FileNames;
+        }
     }
 }

app/Umbraco/Umbraco.Archetype/Properties/VersionInfo.cs

@@ -1,4 +1,4 @@
 using System.Reflection;
 
-[assembly: AssemblyVersion("1.7.5")]
-[assembly: AssemblyFileVersion("1.7.5")]
+[assembly: AssemblyVersion("1.9")]
+[assembly: AssemblyFileVersion("1.9")]

app/Umbraco/Umbraco.Archetype/PropertyEditors/ArcheTypePropertyEditor.cs

@@ -1,155 +1,192 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using Archetype.Extensions;
-using ClientDependency.Core;
-using Newtonsoft.Json;
-using Umbraco.Core;
-using Umbraco.Core.Logging;
-using Umbraco.Core.Models;
-using Umbraco.Core.Models.Editors;
-using Umbraco.Core.PropertyEditors;
-using Umbraco.Core.Services;
-using Umbraco.Web.PropertyEditors;
-
-namespace Archetype.PropertyEditors
-{
-	[PropertyEditorAsset(ClientDependencyType.Javascript, "/App_Plugins/Archetype/js/archetype.js")]
-	[PropertyEditor(Constants.PropertyEditorAlias, "Archetype", "/App_Plugins/Archetype/views/archetype.html", ValueType = "JSON")]
-	public class ArchetypePropertyEditor : PropertyEditor
-	{
-		#region Pre Value Editor
-
-		protected override PreValueEditor CreatePreValueEditor()
-		{
-			return new ArchetypePreValueEditor();
-		}
-
-		internal class ArchetypePreValueEditor : PreValueEditor
-		{
-			[PreValueField("archetypeConfig", "Config", "/App_Plugins/Archetype/views/archetype.config.html",
-				Description = "(Required) Describe your Archetype.")]
-			public string Config { get; set; }
-
-			[PreValueField("hideLabel", "Hide Label", "boolean",
-				Description = "Hide the Umbraco property title and description, making the Archetype span the entire page width")]
-			public bool HideLabel { get; set; }
-		}
-
-		#endregion
-
-		#region Value Editor
-
-		protected override PropertyValueEditor CreateValueEditor()
-		{
-			return new ArchetypePropertyValueEditor(base.CreateValueEditor());
-		}
-
-		internal class ArchetypePropertyValueEditor : PropertyValueEditorWrapper
-		{
-			protected JsonSerializerSettings _jsonSettings;
-
-			public ArchetypePropertyValueEditor(PropertyValueEditor wrapped)
-				: base(wrapped) { }
-
-			public override string ConvertDbToString(Property property, PropertyType propertyType, IDataTypeService dataTypeService)
-			{
-				if (property.Value == null || property.Value.ToString() == "")
-					return string.Empty;
-
-				var archetype = ArchetypeHelper.Instance.DeserializeJsonToArchetype(property.Value.ToString(), propertyType.DataTypeDefinitionId);
-
-				foreach (var fieldset in archetype.Fieldsets)
-				{
-                    foreach (var propDef in fieldset.Properties.Where(p => p.DataTypeGuid != null))
-					{
-                        try
-                        {
-                            if(propDef == null || propDef.DataTypeGuid == null) continue;
-                            var dtd = ArchetypeHelper.Instance.GetDataTypeByGuid(Guid.Parse(propDef.DataTypeGuid));
-						    var propType = new PropertyType(dtd) { Alias = propDef.Alias };
-						    var prop = new Property(propType, propDef.Value);
-						    var propEditor = PropertyEditorResolver.Current.GetByAlias(dtd.PropertyEditorAlias);
-						    propDef.Value = propEditor.ValueEditor.ConvertDbToString(prop, propType, dataTypeService);
-                        }
-                        catch (Exception ex)
-                        {
-                            LogHelper.Error<ArchetypePropertyValueEditor>(ex.Message, ex);
-                        }
-					}
-				}
-
-                return archetype.SerializeForPersistence();
-			}
-
-			public override object ConvertDbToEditor(Property property, PropertyType propertyType, IDataTypeService dataTypeService)
-			{
-				if (property.Value == null || property.Value.ToString() == "")
-					return string.Empty;;
-
-				var archetype = ArchetypeHelper.Instance.DeserializeJsonToArchetype(property.Value.ToString(), propertyType.DataTypeDefinitionId);
-
-				foreach (var fieldset in archetype.Fieldsets)
-				{
-                    foreach (var propDef in fieldset.Properties.Where(p => p.DataTypeGuid != null))
-					{
-                        try
-                        {
-                            var dtd = ArchetypeHelper.Instance.GetDataTypeByGuid(Guid.Parse(propDef.DataTypeGuid));
-                            var propType = new PropertyType(dtd) { Alias = propDef.Alias };
-                            var prop = new Property(propType, propDef.Value);
-                            var propEditor = PropertyEditorResolver.Current.GetByAlias(dtd.PropertyEditorAlias);
-                            propDef.Value = propEditor.ValueEditor.ConvertDbToEditor(prop, propType, dataTypeService);
-                        }
-                        catch (Exception ex)
-                        {
-                            LogHelper.Error<ArchetypePropertyValueEditor>(ex.Message, ex);
-                        }
-					}
-				}
-
-				return archetype;
-			}
-            public override object ConvertEditorToDb(ContentPropertyData editorValue, object currentValue)
-			{
-				if (editorValue.Value == null || editorValue.Value.ToString() == "")
-					return string.Empty;
-
-				var archetype = ArchetypeHelper.Instance.DeserializeJsonToArchetype(editorValue.Value.ToString(), editorValue.PreValues);
-
-				foreach (var fieldset in archetype.Fieldsets)
-				{    
-                    foreach (var propDef in fieldset.Properties.Where(p => p.DataTypeGuid != null))
-					{
-                        try
-                        {
-                            var dtd = ArchetypeHelper.Instance.GetDataTypeByGuid(Guid.Parse(propDef.DataTypeGuid));
-						    var preValues = ApplicationContext.Current.Services.DataTypeService.GetPreValuesCollectionByDataTypeId(dtd.Id);
-						    var propData = new ContentPropertyData(propDef.Value, preValues, new Dictionary<string, object>());
-                            var propEditor = PropertyEditorResolver.Current.GetByAlias(dtd.PropertyEditorAlias);
-						    propDef.Value = propEditor.ValueEditor.ConvertEditorToDb(propData, propDef.Value);
-                        }
-                        catch (Exception ex)
-                        {
-                            LogHelper.Error<ArchetypePropertyValueEditor>(ex.Message, ex);
-                        }
-					}
-				}
-
-                return archetype.SerializeForPersistence();
-			}
-
-		    internal virtual PropertyEditor GetPropertyEditor(IDataTypeDefinition dtd)
-		    {
-		        if (dtd.Id != 0) 
-                    return PropertyEditorResolver.Current.GetByAlias(dtd.PropertyEditorAlias);
-
-		        return dtd.PropertyEditorAlias.Equals(Constants.PropertyEditorAlias)
-		            ? new ArchetypePropertyEditor()
-                    : (PropertyEditor)new TextboxPropertyEditor();
-		    }
-		}
-
-		#endregion	
-	}
-}
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Archetype.Extensions;
+using ClientDependency.Core;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+using Umbraco.Core;
+using Umbraco.Core.Logging;
+using Umbraco.Core.Models;
+using Umbraco.Core.Models.Editors;
+using Umbraco.Core.PropertyEditors;
+using Umbraco.Core.Services;
+using Umbraco.Web.PropertyEditors;
+using Umbraco.Web.Models.ContentEditing;
+
+namespace Archetype.PropertyEditors
+{
+	[PropertyEditorAsset(ClientDependencyType.Javascript, "/App_Plugins/Archetype/js/archetype.js")]
+	[PropertyEditor(Constants.PropertyEditorAlias, "Archetype", "/App_Plugins/Archetype/views/archetype.html", ValueType = "JSON")]
+	public class ArchetypePropertyEditor : PropertyEditor
+	{
+		#region Pre Value Editor
+
+		protected override PreValueEditor CreatePreValueEditor()
+		{
+			return new ArchetypePreValueEditor();
+		}
+
+		internal class ArchetypePreValueEditor : PreValueEditor
+		{
+			[PreValueField("archetypeConfig", "Config", "/App_Plugins/Archetype/views/archetype.config.html",
+				Description = "(Required) Describe your Archetype.")]
+			public string Config { get; set; }
+
+			[PreValueField("hideLabel", "Hide Label", "boolean",
+				Description = "Hide the Umbraco property title and description, making the Archetype span the entire page width")]
+			public bool HideLabel { get; set; }
+		}
+
+		#endregion
+
+		#region Value Editor
+
+		protected override PropertyValueEditor CreateValueEditor()
+		{
+			return new ArchetypePropertyValueEditor(base.CreateValueEditor());
+		}
+
+		internal class ArchetypePropertyValueEditor : PropertyValueEditorWrapper
+		{
+			protected JsonSerializerSettings _jsonSettings;
+
+			public ArchetypePropertyValueEditor(PropertyValueEditor wrapped)
+				: base(wrapped)
+			{
+			}
+
+			public override string ConvertDbToString(Property property, PropertyType propertyType, IDataTypeService dataTypeService)
+			{
+				if(property.Value == null || property.Value.ToString() == "")
+					return string.Empty;
+
+				var archetype = ArchetypeHelper.Instance.DeserializeJsonToArchetype(property.Value.ToString(), propertyType.DataTypeDefinitionId);
+
+				foreach (var fieldset in archetype.Fieldsets)
+				{
+					foreach (var propDef in fieldset.Properties.Where(p => p.DataTypeGuid != null))
+					{
+						try
+						{
+							if(propDef == null || propDef.DataTypeGuid == null) continue;
+							var dtd = ArchetypeHelper.Instance.GetDataTypeByGuid(Guid.Parse(propDef.DataTypeGuid));
+							var propType = new PropertyType(dtd) {Alias = propDef.Alias};
+							var prop = new Property(propType, propDef.Value);
+							var propEditor = PropertyEditorResolver.Current.GetByAlias(dtd.PropertyEditorAlias);
+							propDef.Value = propEditor.ValueEditor.ConvertDbToString(prop, propType, dataTypeService);
+						}
+						catch (Exception ex)
+						{
+							LogHelper.Error<ArchetypePropertyValueEditor>(ex.Message, ex);
+						}
+					}
+				}
+
+				return archetype.SerializeForPersistence();
+			}
+
+			public override object ConvertDbToEditor(Property property, PropertyType propertyType, IDataTypeService dataTypeService)
+			{
+				if(property.Value == null || property.Value.ToString() == "")
+					return string.Empty;
+
+				var archetype = ArchetypeHelper.Instance.DeserializeJsonToArchetype(property.Value.ToString(), propertyType.DataTypeDefinitionId);
+
+				foreach (var fieldset in archetype.Fieldsets)
+				{
+					foreach (var propDef in fieldset.Properties.Where(p => p.DataTypeGuid != null))
+					{
+						try
+						{
+							var dtd = ArchetypeHelper.Instance.GetDataTypeByGuid(Guid.Parse(propDef.DataTypeGuid));
+							var propType = new PropertyType(dtd) {Alias = propDef.Alias};
+							var prop = new Property(propType, propDef.Value);
+							var propEditor = PropertyEditorResolver.Current.GetByAlias(dtd.PropertyEditorAlias);
+							propDef.Value = propEditor.ValueEditor.ConvertDbToEditor(prop, propType, dataTypeService);
+						}
+						catch (Exception ex)
+						{
+							LogHelper.Error<ArchetypePropertyValueEditor>(ex.Message, ex);
+						}
+					}
+				}
+
+				return archetype;
+			}
+
+			public override object ConvertEditorToDb(ContentPropertyData editorValue, object currentValue)
+			{
+				if(editorValue.Value == null || editorValue.Value.ToString() == "")
+					return string.Empty;
+
+				// attempt to deserialize the current property value as an Archetype
+				var currentArchetype = currentValue != null ? ArchetypeHelper.Instance.DeserializeJsonToArchetype(currentValue.ToString(), editorValue.PreValues) : null;
+				var archetype = ArchetypeHelper.Instance.DeserializeJsonToArchetype(editorValue.Value.ToString(), editorValue.PreValues);
+
+				// get all files uploaded via the file manager (if any)
+				var uploadedFiles = editorValue.AdditionalData.ContainsKey("files") ? editorValue.AdditionalData["files"] as IEnumerable<ContentItemFile> : null;
+				foreach (var fieldset in archetype.Fieldsets)
+				{
+					// assign an id to the fieldset if it has none (e.g. newly created fieldset)
+					fieldset.Id = fieldset.Id == Guid.Empty ? Guid.NewGuid() : fieldset.Id;
+					// find the corresponding fieldset in the current Archetype value (if any)
+					var currentFieldset = currentArchetype != null ? currentArchetype.Fieldsets.FirstOrDefault(f => f.Id == fieldset.Id) : null;
+					foreach (var propDef in fieldset.Properties)
+					{
+						try
+						{
+							// find the corresponding property in the current Archetype value (if any)
+							var currentProperty = currentFieldset != null ? currentFieldset.Properties.FirstOrDefault(p => p.Alias == propDef.Alias) : null;
+							var dtd = ArchetypeHelper.Instance.GetDataTypeByGuid(Guid.Parse(propDef.DataTypeGuid));
+							var preValues = ApplicationContext.Current.Services.DataTypeService.GetPreValuesCollectionByDataTypeId(dtd.Id);
+
+							var additionalData = new Dictionary<string, object>();
+
+							// figure out if we need to pass a files collection in the additional data to the property value editor
+							if(uploadedFiles != null)
+							{
+								if(dtd.PropertyEditorAlias == Constants.PropertyEditorAlias)
+								{
+									// it's a nested Archetype - just pass all uploaded files to the value editor
+									additionalData["files"] = uploadedFiles.ToList();
+								}
+								else if (propDef.EditorState != null && propDef.EditorState.FileNames != null && propDef.EditorState.FileNames.Any())
+								{
+									// pass the uploaded files that belongs to this property (if any) to the value editor
+									var propertyFiles = propDef.EditorState.FileNames.Select(f => uploadedFiles.FirstOrDefault(u => u.FileName == f)).Where(f => f != null).ToList();
+									if(propertyFiles.Any())
+									{
+										additionalData["files"] = propertyFiles;
+									}
+								}
+							}
+							var propData = new ContentPropertyData(propDef.Value, preValues, additionalData);
+							var propEditor = PropertyEditorResolver.Current.GetByAlias(dtd.PropertyEditorAlias);
+							// make sure to send the current property value (if any) to the PE ValueEditor
+							propDef.Value = propEditor.ValueEditor.ConvertEditorToDb(propData, currentProperty != null ? currentProperty.Value : null);
+						}
+						catch (Exception ex)
+						{
+							LogHelper.Error<ArchetypePropertyValueEditor>(ex.Message, ex);
+						}
+					}
+				}
+
+				return archetype.SerializeForPersistence();
+			}
+
+			internal virtual PropertyEditor GetPropertyEditor(IDataTypeDefinition dtd)
+			{
+				if(dtd.Id != 0)
+					return PropertyEditorResolver.Current.GetByAlias(dtd.PropertyEditorAlias);
+
+				return dtd.PropertyEditorAlias.Equals(Constants.PropertyEditorAlias)
+					? new ArchetypePropertyEditor()
+					: (PropertyEditor) new TextboxPropertyEditor();
+			}
+		}
+
+		#endregion	
+	}
+}

app/controllers/controller.js

@@ -1,4 +1,4 @@
-angular.module("umbraco").controller("Imulus.ArchetypeController", function ($scope, $http, assetsService, angularHelper, notificationsService, $timeout, entityResource) {
+angular.module("umbraco").controller("Imulus.ArchetypeController", function ($scope, $http, assetsService, angularHelper, notificationsService, $timeout, fileManager, entityResource, archetypeService, archetypeLabelService, archetypeCacheService, archetypePropertyEditorResource) {
 
     //$scope.model.value = "";
     $scope.model.hideLabel = $scope.model.config.hideLabel == 1;
@@ -17,77 +17,26 @@
 
     init();
 
-    //hold references to helper resources
+    //hold references to helper resources 
     $scope.resources = {
-        entityResource: entityResource
+        entityResource: entityResource,
+        archetypePropertyEditorResource: archetypePropertyEditorResource
+    }
+
+    //hold references to helper services 
+    $scope.services = {
+        archetypeService: archetypeService,
+        archetypeLabelService: archetypeLabelService,
+        archetypeCacheService: archetypeCacheService
     }
 
     //helper to get $eval the labelTemplate
-    $scope.getFieldsetTitle = function(fieldsetConfigModel, fieldsetIndex) {
-        if(!fieldsetConfigModel)
-            return "";
-        var fieldset = $scope.model.value.fieldsets[fieldsetIndex];
-        var fieldsetConfig = $scope.getConfigFieldsetByAlias(fieldset.alias);
-        var template = fieldsetConfigModel.labelTemplate;
-
-        if (template.length < 1)
-            return fieldsetConfig.label;
-
-        var rgx = /{{(.*?)}}*/g;
-        var results;
-        var parsedTemplate = template;
-
-        while ((results = rgx.exec(template)) !== null) {
-            // split the template in case it consists of multiple property aliases and/or functions
-            var parts = results[1].split("|");
-            var templateLabelValue = "";
-            for(var i = 0; i < parts.length; i++) {
-                // stop looking for a template label value if a previous template part already yielded a value
-                if(templateLabelValue != "") {
-                    break;
-                }
-                
-                var part = parts[i];
-                
-                //test for function
-                var beginIndexOf = part.indexOf("(");
-                var endIndexOf = part.indexOf(")");
-
-                if(beginIndexOf != -1 && endIndexOf != -1)
-                {
-                    var functionName = part.substring(0, beginIndexOf);
-                    var propertyAlias = part.substring(beginIndexOf + 1, endIndexOf);
-                    templateLabelValue = executeFunctionByName(functionName, window, $scope.getPropertyValueByAlias(fieldset, propertyAlias), $scope);
-                }
-                else {
-                    propertyAlias = part;
-                    templateLabelValue = $scope.getPropertyValueByAlias(fieldset, propertyAlias);
-                }                
-            }
-            parsedTemplate = parsedTemplate.replace(results[0], templateLabelValue);
-        }
-
-        return parsedTemplate;
-    };
-
-    function executeFunctionByName(functionName, context) {
-        var args = Array.prototype.slice.call(arguments).splice(2);
-
-        var namespaces = functionName.split(".");
-        var func = namespaces.pop();
-
-        for(var i = 0; i < namespaces.length; i++) {
-            context = context[namespaces[i]];
-        }
-
-        if(context && context[func]) {
-            return context[func].apply(this, args);
-        }
-
-        return "";
+    $scope.getFieldsetTitle = function (fieldsetConfigModel, fieldsetIndex) {
+        return archetypeLabelService.getFieldsetTitle($scope, fieldsetConfigModel, fieldsetIndex);
     }
 
     var draggedRteSettings;
+    var rteClass = ".mce-tinymce";
 
     //sort config
     $scope.sortableOptions = {
@@ -96,22 +45,30 @@
         handle: ".handle",
         start: function(ev, ui) {
             draggedRteSettings = {};
-            ui.item.parent().find('.mceNoEditor').each(function () {
+            ui.item.parent().find(rteClass).each(function () {
                 // remove all RTEs in the dragged row and save their settings
-                var id = $(this).attr('id');
-                draggedRteSettings[id] = _.findWhere(tinyMCE.editors, { id: id }).settings;
-                tinyMCE.execCommand('mceRemoveEditor', false, id);
+                var $element = $(this);
+                var wrapperId = $element.attr('id');
+                var $textarea = $element.siblings('textarea');
+                var textareaId = $textarea.attr('id');
+
+                draggedRteSettings[textareaId] = _.findWhere(tinyMCE.editors, { id: textareaId }).settings;
+                tinyMCE.execCommand('mceRemoveEditor', false, wrapperId);
             });
         },
         update: function (ev, ui) {
             $scope.setDirty();
         },
         stop: function (ev, ui) {
-            ui.item.parent().find('.mceNoEditor').each(function () {
-                var id = $(this).attr('id');
-                draggedRteSettings[id] = draggedRteSettings[id] || _.findWhere(tinyMCE.editors, { id: id }).settings;
-                tinyMCE.execCommand('mceRemoveEditor', false, id);
-                tinyMCE.init(draggedRteSettings[id]);
+            ui.item.parent().find(rteClass).each(function () {
+                var $element = $(this);
+                var wrapperId = $element.attr('id');
+                var $textarea = $element.siblings('textarea');
+                var textareaId = $textarea.attr('id');
+
+                draggedRteSettings[textareaId] = draggedRteSettings[textareaId] || _.findWhere(tinyMCE.editors, { id: textareaId }).settings;
+                tinyMCE.execCommand('mceRemoveEditor', false, wrapperId);
+                tinyMCE.init(draggedRteSettings[textareaId]);
             });
         }
     };
@@ -143,6 +100,7 @@
             if (confirm('Are you sure you want to remove this?')) {
                 $scope.setDirty();
                 $scope.model.value.fieldsets.splice($index, 1);
+                $scope.$broadcast("archetypeRemoveFieldset", {index: $index});
             }
         }
     }
@@ -294,11 +252,36 @@
     //developerMode helpers
     $scope.model.value.toString = stringify;
 
+    // issue 114: register handler for file selection
+    $scope.model.value.setFiles = setFiles;
+
     //encapsulate stringify (should be built into browsers, not sure of IE support)
     function stringify() {
         return JSON.stringify(this);
     }
 
+    // issue 114: handler for file selection
+    function setFiles(files) {
+        // get all currently selected files from file manager
+        var currentFiles = fileManager.getFiles();
+        
+        // get the files already selected for this archetype (by alias)
+        var archetypeFiles = [];
+        _.each(currentFiles, function (item) {
+            if (item.alias === $scope.model.alias) {
+                archetypeFiles.push(item.file);
+            }
+        });
+
+        // add the newly selected files
+        _.each(files, function (file) {
+            archetypeFiles.push(file);
+        });
+
+        // update the selected files for this archetype (by alias)
+        fileManager.setFiles($scope.model.alias, archetypeFiles);
+    }
+
     //watch for changes
     $scope.$watch('model.value', function (v) {
         if ($scope.model.config.developerMode) {
@@ -308,6 +291,11 @@
                 $scope.model.value.toString = stringify;
             }
         }
+
+        // issue 114: re-register handler for files selection and reset the currently selected files on the file manager
+        $scope.model.value.setFiles = setFiles;
+        fileManager.setFiles($scope.model.alias, []);
+
         // reset submit watcher counter on save
         $scope.activeSubmitWatcher = 0;
     });

app/directives/archetypeproperty.js

@@ -1,75 +1,33 @@
-angular.module("umbraco.directives").directive('archetypeProperty', function ($compile, $http, archetypePropertyEditorResource, umbPropEditorHelper, $timeout, $rootScope, $q, editorState) {
-
-    function getFieldsetByAlias(fieldsets, alias)
-    {
-        return _.find(fieldsets, function(fieldset){
-            return fieldset.alias == alias;
-        });
-    }
-
-    function getPropertyIndexByAlias(properties, alias){
-        for (var i in properties)
-        {
-            if (properties[i].alias == alias) {
-                return i;
-            }
-        }
-    }
-
-    function getPropertyByAlias(fieldset, alias){
-        return _.find(fieldset.properties, function(property){
-            return property.alias == alias; 
-        });
-    }
-
-    //helper that returns a JS ojbect from 'value' string or the original string
-    function jsonOrString(value, developerMode, debugLabel){
-        if(value && typeof value == 'string'){
-            try{
-                if(developerMode == '1'){
-                    console.log("Trying to parse " + debugLabel + ": " + value); 
-                }
-                value = JSON.parse(value);
-            }
-            catch(exception)
-            {
-                if(developerMode == '1'){
-                    console.log("Failed to parse " + debugLabel + "."); 
-                }
-            }
-        }
-
-        if(value && developerMode == '1'){
-            console.log(debugLabel + " post-parsing: ");
-            console.log(value); 
-        }
-
-        return value;
-    }
+angular.module("umbraco.directives").directive('archetypeProperty', function ($compile, $http, archetypePropertyEditorResource, umbPropEditorHelper, $timeout, $rootScope, $q, fileManager, editorState, archetypeService, archetypeCacheService) {
 
     var linker = function (scope, element, attrs, ngModelCtrl) {
-        var configFieldsetModel = getFieldsetByAlias(scope.archetypeConfig.fieldsets, scope.fieldset.alias);
+        var configFieldsetModel = archetypeService.getFieldsetByAlias(scope.archetypeConfig.fieldsets, scope.fieldset.alias);
         var view = "";
         var label = configFieldsetModel.properties[scope.propertyConfigIndex].label;
         var dataTypeGuid = configFieldsetModel.properties[scope.propertyConfigIndex].dataTypeGuid;
         var config = null;
         var alias = configFieldsetModel.properties[scope.propertyConfigIndex].alias;
         var defaultValue = configFieldsetModel.properties[scope.propertyConfigIndex].value;
-        var propertyAlias = getUniquePropertyAlias(scope);
-        propertyAliasParts = [];
-
+        var propertyAliasParts = [];
+        var propertyAlias = archetypeService.getUniquePropertyAlias(scope, propertyAliasParts);
+        
         //try to convert the defaultValue to a JS object
-        defaultValue = jsonOrString(defaultValue, scope.archetypeConfig.developerMode, "defaultValue");
+        defaultValue = archetypeService.jsonOrString(defaultValue, scope.archetypeConfig.developerMode, "defaultValue");
 
         //grab info for the selected datatype, prepare for view
         archetypePropertyEditorResource.getDataType(dataTypeGuid, scope.archetypeConfig.enableDeepDatatypeRequests, editorState.current.contentTypeAlias, scope.propertyEditorAlias, alias, editorState.current.id).then(function (data) {
             //transform preValues array into object expected by propertyeditor views
             var configObj = {};
+
             _.each(data.preValues, function(p) {
                 configObj[p.key] = p.value;
             });
+            
             config = configObj;
 
+            //caching for use by label templates later
+            archetypeCacheService.addDatatypeToCache(data, dataTypeGuid);
+
             //determine the view to use [...] and load it
             archetypePropertyEditorResource.getPropertyEditorMapping(data.selectedEditor).then(function(propertyEditor) {
                 var pathToView = umbPropEditorHelper.getViewPath(propertyEditor.view);
@@ -92,16 +50,15 @@ angular.module("umbraco.directives").directive('archetypeProperty', function ($c
                 validateProperty(scope.fieldset, property);
             });
 
-            // set invalid state if the fieldset contains invalid properties
-            // we need an unique validation key per fieldset in this ngModelCtrl scope, which leaves us with a potential problem: 
-            // if the user invalidates the last fieldset, attempts (and fails) to save and and subsequently deletes the invalid fieldset, 
-            // the validation key will persist on ngModelCtrl and thus the form will not submit.
-            // to fix this problem, the controller probably needs to raise an event (in removeRow) that can be intercepted here to
-            // clear the validation key.
             var validationKey = "validation-f" + scope.fieldsetIndex;
             ngModelCtrl.$setValidity(validationKey, scope.fieldset.isValid);
         });
 
+        scope.$on("archetypeRemoveFieldset", function (ev, args) {
+            var validationKey = "validation-f" + args.index;
+            ngModelCtrl.$setValidity(validationKey, true);
+        });
+
 
         // called when the value of any property in a fieldset changes
         function propertyValueChanged(fieldset, property) {
@@ -112,7 +69,7 @@ angular.module("umbraco.directives").directive('archetypeProperty', function ($c
 
         // validate a property in a fieldset
         function validateProperty(fieldset, property) {
-            var propertyConfig = getPropertyByAlias(configFieldsetModel, property.alias);
+            var propertyConfig = archetypeService.getPropertyByAlias(configFieldsetModel, property.alias);
             if (propertyConfig) {
                 // use property.value !== property.value to check for NaN values on numeric inputs
                 if (propertyConfig.required && (property.value == null || property.value === "" || property.value !== property.value)) {
@@ -140,33 +97,6 @@ angular.module("umbraco.directives").directive('archetypeProperty', function ($c
         }
     }
 
-    var propertyAliasParts = [];
-    var getUniquePropertyAlias = function (currentScope) {
-        if (currentScope.hasOwnProperty('fieldsetIndex') && currentScope.hasOwnProperty('property') && currentScope.hasOwnProperty('propertyConfigIndex'))
-        {
-            var currentPropertyAlias = "f" + currentScope.fieldsetIndex + "-" + currentScope.property.alias + "-p" + currentScope.propertyConfigIndex;
-            propertyAliasParts.push(currentPropertyAlias);
-        }
-        else if (currentScope.hasOwnProperty('isPreValue')) // Crappy way to identify this is the umbraco property scope
-        {
-            var umbracoPropertyAlias = currentScope.$parent.$parent.property.alias; // Crappy way to get the umbraco host alias once we identify its scope
-            propertyAliasParts.push(umbracoPropertyAlias);
-        }
-
-        if (currentScope.$parent)
-            getUniquePropertyAlias(currentScope.$parent);
-
-        return _.unique(propertyAliasParts).reverse().join("-");
-    };
-
-    var getFieldset = function(scope) {
-        return scope.archetypeRenderModel.fieldsets[scope.fieldsetIndex];
-    }
-
-    var getFieldsetProperty = function (scope) {
-        return getFieldset(scope).properties[scope.renderModelPropertyIndex];
-    }
-
     function loadView(view, config, defaultValue, alias, propertyAlias, scope, element, ngModelCtrl, propertyValueChanged) {
         if (view)
         {
@@ -183,15 +113,18 @@ angular.module("umbraco.directives").directive('archetypeProperty', function ($c
                     scope.model.config = {};
 
                     //ini the property value after test to make sure a prop exists in the renderModel
-                    scope.renderModelPropertyIndex = getPropertyIndexByAlias(getFieldset(scope).properties, alias);
+                    scope.renderModelPropertyIndex = archetypeService.getPropertyIndexByAlias(archetypeService.getFieldset(scope).properties, alias);
 
                     if (!scope.renderModelPropertyIndex)
                     {
-                        getFieldset(scope).properties.push(JSON.parse('{"alias": "' + alias + '", "value": "' + defaultValue + '"}'));
-                        scope.renderModelPropertyIndex = getPropertyIndexByAlias(getFieldset(scope).properties, alias);
+                        archetypeService.getFieldset(scope).properties.push(JSON.parse('{"alias": "' + alias + '", "value": "' + defaultValue + '"}'));
+                        scope.renderModelPropertyIndex = archetypeService.getPropertyIndexByAlias(archetypeService.getFieldset(scope).properties, alias);
                     }
                     scope.renderModel = {};
-                    scope.model.value = getFieldsetProperty(scope).value;
+                    scope.model.value = archetypeService.getFieldsetProperty(scope).value;
+
+                    //init the property editor state
+                    archetypeService.getFieldsetProperty(scope).editorState = {};
 
                     //set the config from the prevalues
                     scope.model.config = config;
@@ -211,33 +144,57 @@ angular.module("umbraco.directives").directive('archetypeProperty', function ($c
                         }
                     }
 
-                    //console.log(scope.model.config);
+                    //upload datatype hack
+                    if(view.indexOf('fileupload.html') != -1) {
+                        scope.propertyForm = scope.form;
+                        scope.model.validation = {};
+                        scope.model.validation.mandatory = 0;
+                    }
 
                     //some items need an alias
                     scope.model.alias = "archetype-property-" + propertyAlias;
+                    //some items also need an id (file upload for example)
+                    scope.model.id = propertyAlias;
 
                     //watch for changes since there is no two-way binding with the local model.value
                     scope.$watch('model.value', function (newValue, oldValue) {
-                        getFieldsetProperty(scope).value = newValue;
+                        archetypeService.getFieldsetProperty(scope).value = newValue;
 
                         // notify the linker that the property value changed
-                        propertyValueChanged(getFieldset(scope), getFieldsetProperty(scope));
+                        propertyValueChanged(archetypeService.getFieldset(scope), archetypeService.getFieldsetProperty(scope));
                     });
 
                     scope.$on('archetypeFormSubmitting', function (ev, args) {
                         // did the value change (if it did, it most likely did so during the "formSubmitting" event)
-                        var property = getFieldsetProperty(scope);
+                        var property = archetypeService.getFieldsetProperty(scope);
 
                         var currentValue = property.value;
 
                         if (currentValue != scope.model.value) {
-                            getFieldsetProperty(scope).value = scope.model.value;
+                            archetypeService.getFieldsetProperty(scope).value = scope.model.value;
 
                             // notify the linker that the property value changed
-                            propertyValueChanged(getFieldset(scope), getFieldsetProperty(scope));
+                            propertyValueChanged(archetypeService.getFieldset(scope), archetypeService.getFieldsetProperty(scope));
                         }
                     });
 
+                    // issue 114: handle file selection on property editors
+                    scope.$on("filesSelected", function (event, args) {
+                        // populate the fileNames collection on the property editor state
+                        var property = archetypeService.getFieldsetProperty(scope);
+                        property.editorState.fileNames = [];
+                        _.each(args.files, function (item) {
+                            property.editorState.fileNames.push(item.name);
+                        });
+
+                        // remove the files set for this property
+                        // NOTE: we can't use property.alias because the file manager registers the selected files on the assigned Archetype property alias (e.g. "archetype-property-archetype-property-archetype-property-content-0-2-0-1-0-0")
+                        fileManager.setFiles(scope.model.alias, []);
+
+                        // now tell the containing Archetype to pick up the selected files
+                        scope.archetypeRenderModel.setFiles(args.files);
+                    });
+
                     element.html(data).show();
                     $compile(element.contents())(scope);
 

app/helpers/labelhelpers.js

@@ -1,41 +0,0 @@
-var ArchetypeLabels = (function() {
-
-    var isEntityLookupLoading = false;
-    var entityNameLookupCache = [];
-
-    function getEntityById(scope, id, type) {
-
-        for (var i in entityNameLookupCache) {
-            if (entityNameLookupCache[i].id == id) {
-                return entityNameLookupCache[i].value;
-            }
-        }
-
-        if (!isEntityLookupLoading) {
-            isEntityLookupLoading = true;
-
-            scope.resources.entityResource.getById(id, type).then(function(entity) {
-                entityNameLookupCache.push({id: id, value: entity.name});
-
-                isEntityLookupLoading = false;
-                return entity.name;
-            });
-        }
-
-        return "";
-    }
-
-    return {
-        GetFirstDocumentEntityName: function ($scope, value) {
-            if (value) {
-                var id = value.split(",")[0];
-
-                if (id) {
-                    return getEntityById($scope, id, "Document");
-                }
-            }
-
-            return "";
-        }
-    }
-})();

app/helpers/sampleLabelHelpers.js

@@ -0,0 +1,70 @@
+var ArchetypeSampleLabelTemplates = (function() {
+
+    //public functions
+    return {
+        Entity: function (value, scope, args) {
+
+           if(!args.entityType) {
+                args = {entityType: "Document", propertyName: "name"}
+            }
+
+            if (value) {
+                //if handed a csv list, take the first only
+                var id = value.split(",")[0];
+
+                if (id) {
+                    var entity = scope.services.archetypeLabelService.getEntityById(scope, id, args.entityType);
+
+                    if(entity) {
+                        return entity[args.propertyName];
+                    }
+                }
+            }
+
+            return "";
+        },
+        UrlPicker: function(value, scope, args) {
+
+            if(!args.propertyName) {
+                args = {propertyName: "name"}
+            }
+
+            var entity;
+
+            switch (value.type) {
+                case "content":
+                    if(value.typeData.contentId) {
+                        entity = scope.services.archetypeLabelService.getEntityById(scope, value.typeData.contentId, "Document");
+                    }
+                    break;
+
+                case "media":
+                    if(value.typeData.mediaId) {
+                        entity = scope.services.archetypeLabelService.getEntityById(scope, value.typeData.mediaId, "Media");
+                    }
+                    break;
+
+                case "url":
+                    return value.typeData.url;
+                    
+                default:
+                    break;
+
+            }
+
+            if(entity) {
+                return entity[args.propertyName];
+            }
+
+            return "";
+        },
+        Rte: function (value, scope, args) {
+
+            if(!args.contentLength) {
+                args = {contentLength: 50}
+            }
+
+            return $(value).text().substring(0, args.contentLength);
+        }
+    }
+})();

app/less/archetype.less

@@ -2,11 +2,11 @@
 
 .archetypeEditor {
     width: 98%;
-    
+
     .open {
         position: relative;
     }
-    
+
     .dropdown-menu {
         top: auto;
         > li > a {
@@ -25,7 +25,12 @@
     .icon {
         color: #333;
     }
-    
+
+    .fieldsetIcon {
+        float: left;
+        padding-right: 4px;
+    }
+
     fieldset {
         border: 1px solid #dddddd;
         padding: 0;
@@ -56,9 +61,10 @@
         .archetypeFieldsetLabel {
             position: relative;
             width: 100%;
+            min-height: 42px;
 
             .label-sub {
-                padding: 8px 0;
+                padding: 8px 0 4px 0;
                 display: inline-block;
                 &.module-label {
                     width: 100%;
@@ -98,6 +104,7 @@
 
             .caret {
                 margin: 8px 1px 0 15px;
+                position: absolute;
 
                 &.caret-right {
                     border-bottom: 4px solid transparent;
@@ -110,10 +117,15 @@
 
             label {
                 margin-bottom: 0;
-                margin-left: 5px;
+                margin-left: 38px;
+                white-space: nowrap;
                 padding: 0;
+                width: ~"calc(100% - 132px)";
+                position: absolute;
                 span {
-                    display: inline-block;
+                    display: block;
+                    overflow: hidden;
+                    text-overflow: ellipsis;
                 }
                 &.dimmed {
                     color: #d9d9d9;

app/services/archetypeCacheService.js

@@ -0,0 +1,78 @@
+angular.module('umbraco.services').factory('archetypeCacheService', function (archetypePropertyEditorResource) {
+    //private
+
+    var isEntityLookupLoading = false;
+    var entityCache = [];
+
+    var isDatatypeLookupLoading = false;
+    var datatypeCache = [];
+
+    return {
+    	getDataTypeFromCache: function(guid) {
+        	return _.find(datatypeCache, function (dt){
+	            return dt.dataTypeGuid == guid;
+	        });
+    	},
+
+    	addDatatypeToCache: function(datatype, dataTypeGuid) {
+            var cachedDatatype = this.getDataTypeFromCache(dataTypeGuid);
+
+            if(!cachedDatatype) {
+            	datatype.dataTypeGuid = dataTypeGuid;
+            	datatypeCache.push(datatype);
+            }
+    	},
+ 
+		getDatatypeByGuid: function(guid) {
+			var cachedDatatype = this.getDataTypeFromCache(guid);
+
+	        if(cachedDatatype) {
+	            return cachedDatatype;
+	        }
+
+	        //go get it from server, but this should already be pre-populated from the directive, but I suppose I'll leave this in in case used ad-hoc
+	        if (!isDatatypeLookupLoading) {
+	            isDatatypeLookupLoading = true;
+
+	            archetypePropertyEditorResource.getDataType(guid).then(function(datatype) {
+
+	            	datatype.dataTypeGuid = guid;
+
+	                datatypeCache.push(datatype);
+
+	                isDatatypeLookupLoading = false;
+
+	                return datatype;
+	            });
+	        }
+
+	        return null;
+        },
+
+     	getEntityById: function(scope, id, type) {
+	        var cachedEntity = _.find(entityCache, function (e){
+	            return e.id == id;
+	        });
+
+	        if(cachedEntity) {
+	            return cachedEntity;
+	        }
+
+	        //go get it from server
+	        if (!isEntityLookupLoading) {
+	            isEntityLookupLoading = true;
+
+	            scope.resources.entityResource.getById(id, type).then(function(entity) {
+
+	                entityCache.push(entity);
+
+	                isEntityLookupLoading = false;
+
+	                return entity;
+	            });
+	        }
+
+	        return null;
+	    }
+    }
+});

app/services/archetypeLabelService.js

@@ -0,0 +1,265 @@
+angular.module('umbraco.services').factory('archetypeLabelService', function (archetypeCacheService) {
+    //private
+
+    function executeFunctionByName(functionName, context) {
+        var args = Array.prototype.slice.call(arguments).splice(2);
+
+        var namespaces = functionName.split(".");
+        var func = namespaces.pop();
+
+        for(var i = 0; i < namespaces.length; i++) {
+            context = context[namespaces[i]];
+        }
+
+        if(context && context[func]) {
+            return context[func].apply(this, args);
+        }
+
+        return "";
+    }
+
+    function getNativeLabel(datatype, value, scope) {
+
+    	switch (datatype.selectedEditor) {
+    		case "Imulus.UrlPicker":
+    			return imulusUrlPicker(value, scope, {});
+    		case "Umbraco.TinyMCEv3":
+    			return coreTinyMce(value, scope, {});
+            case "Umbraco.MultiNodeTreePicker":
+                return coreMntp(value, scope, datatype);
+            case "Umbraco.MediaPicker":
+                return coreMediaPicker(value, scope, datatype);
+            case "Umbraco.DropDown":
+                return coreDropdown(value, scope, datatype);
+    		default:
+    			return "";
+    	}
+    }
+
+    function coreDropdown(value, scope, args) {
+
+        if(!value)
+            return "";
+
+        var prevalue = args.preValues[0].value[value];
+
+        if(prevalue) {
+            return prevalue.value;
+        }
+
+        return "";
+    }
+
+    function coreMntp(value, scope, args) {
+        var ids = value.split(',');
+        var type = "Document";
+
+        switch(args.preValues[0].value.type) {
+            case 'content':
+                type = 'Document';
+                break;
+            case 'media':
+                type = 'media';
+                break;
+            case 'member':
+                type = 'member';
+                break;
+
+            default:
+                break;
+        }
+
+        var entityArray = [];
+
+        _.each(ids, function(id){
+            if(id) {
+
+                var entity = archetypeCacheService.getEntityById(scope, id, type);
+                
+                if(entity) {
+                    entityArray.push(entity.name);
+                }
+            }
+        });
+
+        return entityArray.join(', ');
+    }
+
+    function coreMediaPicker(value, scope, args) {
+        if(value) {
+             var entity = archetypeCacheService.getEntityById(scope, value, "media");     
+             
+            if(entity) {
+                return entity.name; 
+            }
+        }
+
+        return "";
+    }
+
+    function imulusUrlPicker(value, scope, args) {
+
+        if(!args.propertyName) {
+            args = {propertyName: "name"}
+        }
+
+        var entity;
+
+        switch (value.type) {
+            case "content":
+                if(value.typeData.contentId) {
+                    entity = archetypeCacheService.getEntityById(scope, value.typeData.contentId, "Document");
+                }
+                break;
+
+            case "media":
+                if(value.typeData.mediaId) {
+                    entity = archetypeCacheService.getEntityById(scope, value.typeData.mediaId, "Media");
+                }
+                break;
+
+            case "url":
+                return value.typeData.url;
+                
+            default:
+                break;
+
+        }
+
+        if(entity) {
+            return entity[args.propertyName];
+        }
+
+        return "";
+    }
+
+    function coreTinyMce(value, scope, args) {
+
+        if(!args.contentLength) {
+            args = {contentLength: 50}
+        }
+
+        var suffix = "";
+        var strippedText = $(value).text();
+
+        if(strippedText.length > args.contentLength) {
+        	suffix = "…";
+        }
+
+        return strippedText.substring(0, args.contentLength) + suffix;
+    }
+
+	return {
+		getFieldsetTitle: function(scope, fieldsetConfigModel, fieldsetIndex) {
+
+            //console.log(scope.model.config);
+
+            if(!fieldsetConfigModel)
+                return "";
+
+            var fieldset = scope.model.value.fieldsets[fieldsetIndex];
+            var fieldsetConfig = scope.getConfigFieldsetByAlias(fieldset.alias);
+            var template = fieldsetConfigModel.labelTemplate;
+
+            if (template.length < 1)
+                return fieldsetConfig.label;
+
+            var rgx = /({{(.*?)}})*/g;
+            var results;
+            var parsedTemplate = template;
+
+            var rawMatches = template.match(rgx);
+            
+            var matches = [];
+
+            _.each(rawMatches, function(match){
+                if(match) {
+                    matches.push(match);
+                }
+            });
+
+            _.each(matches, function (match) {
+
+                // split the template in case it consists of multiple property aliases and/or functions
+                var templates = match.replace("{{", '').replace("}}", '').split("|");
+                var templateLabelValue = "";
+
+                for(var i = 0; i < templates.length; i++) {
+                    // stop looking for a template label value if a previous template part already yielded a value
+                    if(templateLabelValue != "") {
+                        break;
+                    }
+                    
+                    var template = templates[i];
+                    
+                    //test for function
+                    var beginParamsIndexOf = template.indexOf("(");
+                    var endParamsIndexOf = template.indexOf(")");
+
+                    //if passed a function
+                    if(beginParamsIndexOf != -1 && endParamsIndexOf != -1)
+                    {
+                        var functionName = template.substring(0, beginParamsIndexOf);
+                        var propertyAlias = template.substring(beginParamsIndexOf + 1, endParamsIndexOf).split(',')[0];
+
+                        var args = {};
+
+                        var beginArgsIndexOf = template.indexOf(',');
+
+                        if(beginArgsIndexOf != -1) {
+
+                            var argsString = template.substring(beginArgsIndexOf + 1, endParamsIndexOf).trim();
+
+                            var normalizedJsonString = argsString.replace(/(\w+)\s*:/g, '"$1":');
+
+                            args = JSON.parse(normalizedJsonString);
+                        }
+
+                        templateLabelValue = executeFunctionByName(functionName, window, scope.getPropertyValueByAlias(fieldset, propertyAlias), scope, args);
+                    }
+                    //normal {{foo}} syntax
+                    else {
+                        propertyAlias = template;
+                        var rawValue = scope.getPropertyValueByAlias(fieldset, propertyAlias);
+
+                        templateLabelValue = rawValue;
+
+                        //determine the type of editor
+                        var propertyConfig = _.find(fieldsetConfigModel.properties, function(property){
+                            return property.alias == propertyAlias;
+                        });
+
+                        if(propertyConfig) {
+                        	var datatype = archetypeCacheService.getDatatypeByGuid(propertyConfig.dataTypeGuid);
+
+                        	if(datatype) {
+
+                            	//try to get built-in label
+                            	var label = getNativeLabel(datatype, templateLabelValue, scope);
+
+                            	if(label) {
+                        			templateLabelValue = label;
+                        		}
+                        		else {
+                        			templateLabelValue = templateLabelValue;
+                        		}
+                        	}
+                        }
+                        else {
+                        	return templateLabelValue;
+                        }
+
+                    }                
+                }
+
+                if(!templateLabelValue) {
+                    templateLabelValue = "";
+                }
+                
+                parsedTemplate = parsedTemplate.replace(match, templateLabelValue);
+            });
+
+            return parsedTemplate;
+        }
+	}
+});

app/services/archetypeService.js

@@ -0,0 +1,72 @@
+angular.module('umbraco.services').factory('archetypeService', function () {
+
+    //public
+    return {
+        //helper that returns a JS ojbect from 'value' string or the original string
+        jsonOrString: function (value, developerMode, debugLabel){
+            if(value && typeof value == 'string'){
+                try{
+                    if(developerMode == '1'){
+                        console.log("Trying to parse " + debugLabel + ": " + value); 
+                    }
+                    value = JSON.parse(value);
+                }
+                catch(exception)
+                {
+                    if(developerMode == '1'){
+                        console.log("Failed to parse " + debugLabel + "."); 
+                    }
+                }
+            }
+
+            if(value && developerMode == '1'){
+                console.log(debugLabel + " post-parsing: ");
+                console.log(value); 
+            }
+
+            return value;
+        },
+        getFieldsetByAlias: function (fieldsets, alias)
+        {
+            return _.find(fieldsets, function(fieldset){
+                return fieldset.alias == alias;
+            });
+        },
+        getPropertyIndexByAlias: function(properties, alias){
+            for (var i in properties)
+            {
+                if (properties[i].alias == alias) {
+                    return i;
+                }
+            }
+        },
+        getPropertyByAlias: function (fieldset, alias){
+            return _.find(fieldset.properties, function(property){
+                return property.alias == alias; 
+            });
+        },
+        getUniquePropertyAlias: function (currentScope, propertyAliasParts) {
+            if (currentScope.hasOwnProperty('fieldsetIndex') && currentScope.hasOwnProperty('property') && currentScope.hasOwnProperty('propertyConfigIndex'))
+            {
+                var currentPropertyAlias = "f" + currentScope.fieldsetIndex + "-" + currentScope.property.alias + "-p" + currentScope.propertyConfigIndex;
+                propertyAliasParts.push(currentPropertyAlias);
+            }
+            else if (currentScope.hasOwnProperty('isPreValue')) // Crappy way to identify this is the umbraco property scope
+            {
+                var umbracoPropertyAlias = currentScope.$parent.$parent.property.alias; // Crappy way to get the umbraco host alias once we identify its scope
+                propertyAliasParts.push(umbracoPropertyAlias);
+            }
+
+            if (currentScope.$parent)
+                this.getUniquePropertyAlias(currentScope.$parent, propertyAliasParts);
+
+            return _.unique(propertyAliasParts).reverse().join("-");
+        },
+        getFieldset: function(scope) {
+            return scope.archetypeRenderModel.fieldsets[scope.fieldsetIndex];
+        },
+        getFieldsetProperty: function (scope) {
+            return this.getFieldset(scope).properties[scope.renderModelPropertyIndex];
+        }
+    }
+});

config/meta.json

@@ -1,6 +1,6 @@
 {
 	"name": "Archetype",
-	"version": "1.7.5",
+	"version": "1.9",
 	"url": "http://github.com/imulus/archetype/",
 	"author": "Imulus - Kevin Giszewski - Tom Fulton - Lee Kelleher - Matt Brailsford - Kenn Jacobsen - Et. Al.",
 	"authorUrl": "http://imulus.com/",