Use relative paths for API endpoints

Since the backoffice has `<base href="/yourvdir/umbraco">`, we can just use relative links here to support virtual directories

If this does not work, alternatively we can look at `Umbraco.Sys.ServerVariables.umbracoSettings.umbracoPath`

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'
       }
@@ -74,7 +77,7 @@ module.exports = function(grunt) {
         expand: true
       },
       dll: {
-        cwd: 'app/Umbraco/Umbraco.Archetype/bin/Release/',
+        cwd: 'app/Umbraco/Umbraco.Archetype/bin/Debug/',
         src: 'Archetype.dll',
         dest: '<%= dest %>/bin/',
         expand: true
@@ -164,7 +167,7 @@ module.exports = function(grunt) {
 
     assemblyinfo: {
       options: {
-        files: ['app/Umbraco/Umbraco.Archetype/Archetype.Umbraco.csproj'],
+        files: ['app/Umbraco/Umbraco.Archetype/Archetype.Umbraco.csproj', 'app/Umbraco/Umbraco.Archetype/Archetype.Courier.csproj'],
         filename: 'VersionInfo.cs',
         info: {
           version: '<%= (pkgMeta.version.indexOf("-") > 0 ? pkgMeta.version.substring(0, pkgMeta.version.indexOf("-")) : pkgMeta.version) %>', 
@@ -200,9 +203,9 @@ module.exports = function(grunt) {
         }
       },
       dist: {
-        src: ['app/Umbraco/Umbraco.Archetype/Archetype.Umbraco.csproj'],
+        src: ['app/Umbraco/Umbraco.Archetype/Archetype.Umbraco.csproj','app/Umbraco/Archetype.Courier/Archetype.Courier.csproj'],
         options: {
-          projectConfiguration: 'Release',
+          projectConfiguration: 'Debug',
           targets: ['Clean', 'Rebuild'],
         }
       }

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/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/Models/ArchetypePropertyModel.cs

@@ -34,7 +34,7 @@ namespace Archetype.Models
 
             // Try Umbraco's PropertyValueConverters
             var converters = UmbracoContext.Current != null ? PropertyValueConvertersResolver.Current.Converters : Enumerable.Empty<IPropertyValueConverter>();
-            if (converters.Any())
+            if (!string.IsNullOrWhiteSpace(this.PropertyEditorAlias) && converters.Any())
             {
                 var convertedAttempt = TryConvertWithPropertyValueConverters<T>(Value, converters);
                 if (convertedAttempt.Success)

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

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

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

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using Archetype.Extensions;
 using ClientDependency.Core;
 using Newtonsoft.Json;
@@ -13,8 +14,8 @@ 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")]
+	[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
@@ -26,7 +27,7 @@ namespace Archetype.PropertyEditors
 
 		internal class ArchetypePreValueEditor : PreValueEditor
 		{
-			[PreValueField("archetypeConfig", "Config", "/App_Plugins/Archetype/views/archetype.config.html",
+			[PreValueField("archetypeConfig", "Config", "~/App_Plugins/Archetype/views/archetype.config.html",
 				Description = "(Required) Describe your Archetype.")]
 			public string Config { get; set; }
 
@@ -56,13 +57,11 @@ namespace Archetype.PropertyEditors
 				if (property.Value == null || property.Value.ToString() == "")
 					return string.Empty;
 
-                //LogHelper.Info<ArchetypeHelper>(property.Value.ToString());
-
 				var archetype = ArchetypeHelper.Instance.DeserializeJsonToArchetype(property.Value.ToString(), propertyType.DataTypeDefinitionId);
 
 				foreach (var fieldset in archetype.Fieldsets)
 				{
-					foreach (var propDef in fieldset.Properties)
+                    foreach (var propDef in fieldset.Properties.Where(p => p.DataTypeGuid != null))
 					{
                         try
                         {
@@ -86,15 +85,13 @@ namespace Archetype.PropertyEditors
 			public override object ConvertDbToEditor(Property property, PropertyType propertyType, IDataTypeService dataTypeService)
 			{
 				if (property.Value == null || property.Value.ToString() == "")
-					return string.Empty;
-
-                //LogHelper.Info<ArchetypeHelper>(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)
+                    foreach (var propDef in fieldset.Properties.Where(p => p.DataTypeGuid != null))
 					{
                         try
                         {
@@ -118,13 +115,11 @@ namespace Archetype.PropertyEditors
 				if (editorValue.Value == null || editorValue.Value.ToString() == "")
 					return string.Empty;
 
-                //LogHelper.Info<ArchetypeHelper>(editorValue.Value.ToString());
-
 				var archetype = ArchetypeHelper.Instance.DeserializeJsonToArchetype(editorValue.Value.ToString(), editorValue.PreValues);
 
 				foreach (var fieldset in archetype.Fieldsets)
-				{
-					foreach (var propDef in fieldset.Properties)
+				{    
+                    foreach (var propDef in fieldset.Properties.Where(p => p.DataTypeGuid != null))
 					{
                         try
                         {

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, entityResource, archetypeService, archetypeLabelService, archetypeCacheService, archetypePropertyEditorResource) {
 
     //$scope.model.value = "";
     $scope.model.hideLabel = $scope.model.config.hideLabel == 1;
@@ -17,92 +17,58 @@
 
     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 = {
         axis: 'y',
         cursor: "move",
         handle: ".handle",
         start: function(ev, ui) {
-            ui.item.parent().find('.umb-rte textarea').each(function () {
-                tinyMCE.execCommand('mceRemoveEditor', false, $(this).attr('id'));
+            draggedRteSettings = {};
+            ui.item.parent().find(rteClass).each(function () {
+                // remove all RTEs in the dragged row and save their settings
+                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('.umb-rte textarea').each(function () {
-                tinyMCE.execCommand('mceAddEditor', false, $(this).attr('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]);
             });
         }
     };
@@ -134,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});
             }
         }
     }

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, 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,15 @@ 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;
 
                     //set the config from the prevalues
                     scope.model.config = config;
@@ -211,27 +141,28 @@ angular.module("umbraco.directives").directive('archetypeProperty', function ($c
                         }
                     }
 
-                    //console.log(scope.model.config);
-
                     //some items need an alias
                     scope.model.alias = "archetype-property-" + 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 currentValue = getFieldsetProperty(scope).value;
+                        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));
                         }
                     });
 

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;
@@ -181,6 +193,7 @@
 
     .archetypeAddButton:hover {
         text-decoration: none;
+        cursor: pointer;
 
         .archetypeAddButtonText {
             text-decoration: underline;

app/resources/archetypePropertyEditorResource.js

@@ -3,24 +3,24 @@ angular.module('umbraco.resources').factory('archetypePropertyEditorResource', f
         getAllDataTypes: function() {
             // Hack - grab DataTypes from Tree API, as `dataTypeService.getAll()` isn't implemented yet
             return umbRequestHelper.resourcePromise(
-                $http.get("/umbraco/backoffice/ArchetypeApi/ArchetypeDataType/GetAll"), 'Failed to retrieve datatypes from tree service'
+                $http.get("backoffice/ArchetypeApi/ArchetypeDataType/GetAll"), 'Failed to retrieve datatypes from tree service'
             );
         },
         getDataType: function (guid, useDeepDatatypeLookup, contentTypeAlias, propertyTypeAlias, archetypeAlias, nodeId) {
             if(useDeepDatatypeLookup) {
             	return umbRequestHelper.resourcePromise(
-            		$http.get("/umbraco/backoffice/ArchetypeApi/ArchetypeDataType/GetByGuid?guid=" + guid + "&contentTypeAlias=" + contentTypeAlias + "&propertyTypeAlias=" + propertyTypeAlias + "&archetypeAlias=" + archetypeAlias + "&nodeId=" + nodeId), 'Failed to retrieve datatype'
+            		$http.get("backoffice/ArchetypeApi/ArchetypeDataType/GetByGuid?guid=" + guid + "&contentTypeAlias=" + contentTypeAlias + "&propertyTypeAlias=" + propertyTypeAlias + "&archetypeAlias=" + archetypeAlias + "&nodeId=" + nodeId), 'Failed to retrieve datatype'
         		);
             }
             else {
                 return umbRequestHelper.resourcePromise(
-                    $http.get("/umbraco/backoffice/ArchetypeApi/ArchetypeDataType/GetByGuid?guid=" + guid , { cache: true }), 'Failed to retrieve datatype'
+                    $http.get("backoffice/ArchetypeApi/ArchetypeDataType/GetByGuid?guid=" + guid , { cache: true }), 'Failed to retrieve datatype'
                 );
             }
         },
         getPropertyEditorMapping: function(alias) {
             return umbRequestHelper.resourcePromise(
-                $http.get("/umbraco/backoffice/ArchetypeApi/ArchetypeDataType/GetAllPropertyEditors", { cache: true }), 'Failed to retrieve datatype mappings'
+                $http.get("backoffice/ArchetypeApi/ArchetypeDataType/GetAllPropertyEditors", { cache: true }), 'Failed to retrieve datatype mappings'
             ).then(function (data) {
                 var result = _.find(data, function(d) {
                     return d.alias === alias;

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];
+        }
+    }
+});

app/views/archetype.default.html

@@ -49,7 +49,7 @@
         </li>
     </ul>
     <div ng-show="showAddButton()">
-        <a data-toggle="{{ model.config.fieldsets.length > 1 ? 'dropdown' : ''}}" ng-click="model.config.fieldsets.length == 1 ? addRow(model.config.fieldsets[0].alias, 0) : return" prevent-default>
+        <a class="archetypeAddButton" data-toggle="{{ model.config.fieldsets.length > 1 ? 'dropdown' : ''}}" ng-click="model.config.fieldsets.length == 1 ? addRow(model.config.fieldsets[0].alias, 0) : return" prevent-default>
             <i class="icon icon-add dropdown-toggle"></i>
             <localize key="general_add" class="archetypeAddButtonText">Add</localize>
         </a>

config/meta.json

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

config/package.nuspec

@@ -1,15 +1,18 @@
 <?xml version="1.0"?>
 <package xmlns="http://schemas.microsoft.com/packaging/2011/08/nuspec.xsd">
-        <metadata>
-                <id>Archetype</id>
-                <version><%= version %></version>
-                <title><%= name %></title>
-                <authors>imulus, kgiszewski, tomfulton</authors>
-                <owners>imulus, kgiszewski, tomfulton</owners>
-                <projectUrl>http://github.com/imulus/archetype</projectUrl>
-                <description><![CDATA[Archetype for Umbraco]]></description>
-                <tags>umbraco</tags>
-                <iconUrl>http://github.com/imulus/archetype/raw/master/assets/logo.png</iconUrl>
-                <licenseUrl><%= licenseUrl %></licenseUrl>
-        </metadata>
+    <metadata>
+        <id>Archetype</id>
+        <version><%= version %></version>
+        <title><%= name %></title>
+        <authors>imulus, kgiszewski, tomfulton</authors>
+        <owners>imulus, kgiszewski, tomfulton</owners>
+        <projectUrl>http://github.com/imulus/archetype</projectUrl>
+        <description><![CDATA[Archetype for Umbraco]]></description>
+        <tags>umbraco</tags>
+        <iconUrl>http://github.com/imulus/archetype/raw/master/assets/logo.png</iconUrl>
+        <licenseUrl><%= licenseUrl %></licenseUrl>
+        <dependencies>
+            <dependency id="UmbracoCms.Core" version="7.1.6" />
+        </dependencies>
+    </metadata>
 </package>