Let's do purple

Add minimum fieldsets feature

.gitignore

@@ -17,6 +17,9 @@ tmp/
 pkg/*.nupkg
 pkg/*.zip
 
+*_versioned*
+
+
 [Dd]ebug/
 [Bb]uild/
 [Rr]elease/
@@ -59,4 +62,5 @@ VersionInfo.cs
 .builds
 .svn
 .hg
-.hgignore
+.hgignore
+app/Umbraco/.vs/config/applicationhost.config

Gruntfile.js

@@ -1,13 +1,38 @@
 module.exports = function(grunt) {
   require('load-grunt-tasks')(grunt);
-  var path = require('path')
-
+  var path = require('path');
+  
   grunt.initConfig({
     pkg: grunt.file.readJSON('package.json'),
     pkgMeta: grunt.file.readJSON('config/meta.json'),
     dest: grunt.option('target') || 'dist',
     basePath: path.join('<%= dest %>', 'App_Plugins', '<%= pkgMeta.name %>'),
 
+    'string-replace': {
+      version: {
+        files: {
+          "app/controllers/controller_versioned.js": "app/controllers/controller.js",
+          "app/less/archetype_versioned.less": "app/less/archetype.less",
+          "app/views/archetype.config.developer.dialog_versioned.html": "app/views/archetype.config.developer.dialog.html",
+          "app/views/archetype.config.stylescript.dialog_versioned.html": "app/views/archetype.config.stylescript.dialog.html",
+          "app/views/archetype.config.fieldset.dialog_versioned.html": "app/views/archetype.config.fieldset.dialog.html",
+          "app/views/archetype.config_versioned.html": "app/views/archetype.config.html",
+          "app/views/archetype_versioned.html": "app/views/archetype.html",
+          "app/views/archetype.default_versioned.html": "app/views/archetype.default.html"
+        },
+        options: {
+          replacements: [{
+            pattern: /{{VERSION}}/g,
+            replacement: '/* Version <%= pkgMeta.version %> */'
+          },
+          {
+            pattern: /{{VERSION_HTML}}/g,
+            replacement: '<!-- Version <%= pkgMeta.version %> -->'
+          }]
+        }
+      }
+    },
+    
     watch: {
       options: {
         spawn: false,
@@ -16,22 +41,27 @@ module.exports = function(grunt) {
 
       less: {
         files: ['app/**/*.less'],
-        tasks: ['less:dist']
+        tasks: ['string-replace', 'less:dist']
       },
 
       js: {
         files: ['app/**/*.js'],
-        tasks: ['concat:dist']
+        tasks: ['string-replace', 'concat:dist']
       },
 
       html: {
         files: ['app/**/*.html'],
-        tasks: ['copy:html']
+        tasks: ['string-replace', 'copy:html']
       },
 
       dll: {
         files: ['app/Umbraco/**/*.dll'],
         tasks: ['copy:dll']
+      },
+      
+      assets: {
+        files: ['assets/*.*'],
+        tasks: ['copy:assets']
       }
     },
 
@@ -41,7 +71,7 @@ module.exports = function(grunt) {
           paths: ["app/less", "lib/less", "vendor"],
         },
         files: {
-          '<%= basePath %>/css/archetype.css': 'app/less/archetype.less',
+          '<%= basePath %>/css/archetype.css': 'app/less/archetype_versioned.less',
         }
       }
     },
@@ -52,14 +82,20 @@ module.exports = function(grunt) {
       },
       dist: {
         src: [
-          'app/controllers/controller.js',
+          'app/controllers/controller_versioned.js',
           'app/controllers/config.controller.js',
+          'app/controllers/config.dialog.controller.js',
           '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/directives/archetypeclickoutside.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'
       }
@@ -68,8 +104,24 @@ module.exports = function(grunt) {
     copy: {
       html: {
         cwd: 'app/views/',
-        src: ['archetype.html', 'archetype.default.html', 'archetype.config.html'],
-        dest: '<%= basePath %>/views',
+        src: [
+            'archetype_versioned.html', 
+            'archetype.default_versioned.html', 
+            'archetype.config_versioned.html', 
+            'archetype.config.fieldset.dialog_versioned.html', 
+            'archetype.config.stylescript.dialog_versioned.html', 
+            'archetype.config.developer.dialog_versioned.html'
+        ],
+        dest: '<%= basePath %>/views/',
+        expand: true,
+        rename: function(dest, src) {
+            return dest + src.replace('_versioned','');
+          }
+      },
+      assets: {
+        cwd: 'assets/',
+        src: ['*.*'],
+        dest: '<%= basePath %>/assets',
         expand: true
       },
       dll: {
@@ -99,7 +151,13 @@ module.exports = function(grunt) {
           {
             cwd: '<%= dest %>/bin',
             src: ['*.dll'],
-            dest: 'tmp/nuget/lib/net40',
+            dest: 'tmp/nuget_binaries/lib/net40',
+            expand: true
+          },
+          {
+            cwd: 'app/Umbraco/Archetype.Courier/bin/Release/',
+            src: ['Archetype.Courier.dll'],
+            dest: 'tmp/nuget_courier/lib/net40',
             expand: true
           }
         ]
@@ -113,60 +171,118 @@ module.exports = function(grunt) {
     },
 
     nugetpack: {
-    	dist: {
-    		src: 'tmp/nuget/package.nuspec',
-    		dest: 'pkg'
-    	}
+        dist: {
+            src: 'tmp/nuget/package.nuspec',
+            dest: 'pkg'
+        },
+        dist_binaries: {
+            src: 'tmp/nuget_binaries/package_binaries.nuspec',
+            dest: 'pkg'
+        },
+        dist_courier: {
+            src: 'tmp/nuget_courier/package_courier.nuspec',
+            dest: 'pkg'
+        }
     },
 
     template: {
-    	'nuspec': {
-			'options': {
-    			'data': { 
-            name: '<%= pkgMeta.name %>',
-    				version: '<%= pkgMeta.version %>',
-            url: '<%= pkgMeta.url %>',
-            license: '<%= pkgMeta.license %>',
-            licenseUrl: '<%= pkgMeta.licenseUrl %>',
-            author: '<%= pkgMeta.author %>',
-            authorUrl: '<%= pkgMeta.authorUrl %>',
-
-    				files: [{ path: 'tmp/nuget/**', target: 'content/App_Plugins/Archetype'}]
-	    		}
-    		},
-    		'files': { 
-    			'tmp/nuget/package.nuspec': ['config/package.nuspec']
-    		}
-    	}
+        'nuspec': {
+            'options': {
+                'data': { 
+                    name: '<%= pkgMeta.name %>',
+                    version: '<%= pkgMeta.version %>',
+                    url: '<%= pkgMeta.url %>',
+                    license: '<%= pkgMeta.license %>',
+                    licenseUrl: '<%= pkgMeta.licenseUrl %>',
+                    author: '<%= pkgMeta.author %>',
+                    authorUrl: '<%= pkgMeta.authorUrl %>'
+                }
+            },
+            'files': { 
+                'tmp/nuget/package.nuspec': ['config/package.nuspec']
+            }
+        },
+        'nuspec_binaries': {
+            'options': {
+                'data': { 
+                    name: '<%= pkgMeta.name %>.Binaries',
+                    version: '<%= pkgMeta.version %>',
+                    url: '<%= pkgMeta.url %>',
+                    license: '<%= pkgMeta.license %>',
+                    licenseUrl: '<%= pkgMeta.licenseUrl %>',
+                    author: '<%= pkgMeta.author %>',
+                    authorUrl: '<%= pkgMeta.authorUrl %>'
+                }
+            },
+            'files': { 
+                'tmp/nuget_binaries/package_binaries.nuspec': ['config/package_binaries.nuspec']
+            }
+        },
+        'nuspec_courier': {
+            'options': {
+                'data': { 
+                    name: '<%= pkgMeta.name %>.Courier',
+                    version: '<%= pkgMeta.version %>',
+                    url: '<%= pkgMeta.url %>',
+                    license: '<%= pkgMeta.license %>',
+                    licenseUrl: '<%= pkgMeta.licenseUrl %>',
+                    author: '<%= pkgMeta.author %>',
+                    authorUrl: '<%= pkgMeta.authorUrl %>'
+                }
+            },
+            'files': { 
+                'tmp/nuget_courier/package_courier.nuspec': ['config/package_courier.nuspec']
+            }
+        }
     },
 
     umbracoPackage: {
-      options: {
-        name: "<%= pkgMeta.name %>",
-        version: '<%= pkgMeta.version %>',
-        url: '<%= pkgMeta.url %>',
-        license: '<%= pkgMeta.license %>',
-        licenseUrl: '<%= pkgMeta.licenseUrl %>',
-        author: '<%= pkgMeta.author %>',
-        authorUrl: '<%= pkgMeta.authorUrl %>',
-        manifest: 'config/package.xml',
-        readme: 'config/readme.txt',
-        sourceDir: 'tmp/umbraco',
-        outputDir: 'pkg',
+      dist: {
+        src: 'tmp/umbraco',
+        dest: 'pkg',
+        options: {
+          name: "<%= pkgMeta.name %>",
+          version: '<%= pkgMeta.version %>',
+          url: '<%= pkgMeta.url %>',
+          license: '<%= pkgMeta.license %>',
+          licenseUrl: '<%= pkgMeta.licenseUrl %>',
+          author: '<%= pkgMeta.author %>',
+          authorUrl: '<%= pkgMeta.authorUrl %>',
+          readme: '<%= grunt.file.read("config/readme.txt") %>'
+        }
       }
     },
 
     clean: {
       build: '<%= grunt.config("basePath").substring(0, 4) == "dist" ? "dist/**/*" : "null" %>',
-      tmp: ['tmp']
+      tmp: ['tmp'],
+      html: [
+        'app/views/*.html',
+        '!app/views/archetype.html', 
+        '!app/views/archetype.default.html', 
+        '!app/views/archetype.config.html', 
+        '!app/views/archetype.config.fieldset.dialog.html', 
+        '!app/views/archetype.config.stylescript.dialog.html', 
+        '!app/views/archetype.config.developer.dialog.html'
+        ],
+      js: [
+        'app/controllers/*.js',
+        '!app/controllers/controller.js',
+        '!app/controllers/config.controller.js',
+        '!app/controllers/config.dialog.controller.js'
+      ],
+      less: [
+        'app/less/*.less',
+        '!app/less/archetype.less'
+      ]
     },
 
     assemblyinfo: {
       options: {
-        files: ['app/Umbraco/Umbraco.Archetype/Archetype.Umbraco.csproj'],
+        files: ['app/Umbraco/Umbraco.Archetype/Archetype.Umbraco.csproj', 'app/Umbraco/Archetype.Courier/Archetype.Courier.csproj'],
         filename: 'VersionInfo.cs',
         info: {
-          version: '<%= (pkgMeta.version.indexOf("-") ? pkgMeta.version.substring(0, pkgMeta.version.indexOf("-")) : pkgMeta.version) %>', 
+          version: '<%= (pkgMeta.version.indexOf("-") > 0 ? pkgMeta.version.substring(0, pkgMeta.version.indexOf("-")) : pkgMeta.version) %>', 
           fileVersion: '<%= pkgMeta.version %>'
         }
       }
@@ -178,40 +294,29 @@ module.exports = function(grunt) {
       }
     },
 
-    jshint: {
-      options: {
-        jshintrc: '.jshintrc'
-      },
-      src: {
-        src: ['app/**/*.js', 'lib/**/*.js']
-      }
-    },
-
     msbuild: {
       options: {
         stdout: true,
         verbosity: 'quiet',
         maxCpuCount: 4,
-		version: 4.0,
+        version: 4.0,
         buildParameters: {
           WarningLevel: 2,
           NoWarn: 1607
         }
       },
       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',
           targets: ['Clean', 'Rebuild'],
         }
       }
     }
-
   });
 
-  grunt.registerTask('default', ['clean', 'less', 'concat', 'assemblyinfo', 'msbuild:dist', 'copy:dll', 'copy:config', 'copy:html']);
-
-  grunt.registerTask('nuget',   ['clean:tmp', 'default', 'copy:nuget', 'template:nuspec', 'nugetpack', 'clean:tmp']);
-  grunt.registerTask('umbraco', ['clean:tmp', 'default', 'copy:umbraco', 'umbracoPackage', 'clean:tmp']);
-  grunt.registerTask('package', ['clean:tmp', 'default', 'copy:nuget', 'template:nuspec', 'nugetpack', 'copy:umbraco', 'umbracoPackage', 'clean:tmp']);
+  grunt.registerTask('default', ['clean', 'string-replace', 'less', 'concat', 'assemblyinfo', 'msbuild:dist', 'copy:dll', 'copy:assets', 'copy:html', 'copy:config', 'clean:html', 'clean:js', 'clean:less']);
+  grunt.registerTask('nuget',   ['copy:nuget', 'template:nuspec', 'template:nuspec_binaries', 'template:nuspec_courier', 'nugetpack']);
+  grunt.registerTask('umbraco', ['copy:umbraco', 'umbracoPackage']);
+  grunt.registerTask('package', ['clean:tmp', 'default', 'nuget', 'copy:umbraco', 'umbracoPackage', 'clean:tmp']);
 };

LICENSE

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2014 Imulus
+Copyright (c) 2016 Kevin Giszewski LLC
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of
 this software and associated documentation files (the "Software"), to deal in

README.md

@@ -7,12 +7,24 @@ Archetype
 ## Installation
 Install the selected <a href='https://github.com/imulus/Archetype/releases'>release</a> through the Umbraco package installer or via <a href='http://www.nuget.org/packages/Archetype/'>NuGet</a>.
 
-
 ## Official Docs ##
-http://imulus.github.io/Archetype
+https://github.com/kgiszewski/ArchetypeManual
 
+## News and Updates ##
 Follow us on Twitter https://twitter.com/ArchetypeKit
 
+## Core Team ##
+* Kevin Giszewski (founder/project lead) - University of Notre Dame - https://kevin.giszewski.com/
+* Tom Fulton (founder) - Tonic - http://hellotonic.com/
+* Lee Kelleher - Umbrella - http://www.umbrellainc.co.uk/
+* Matt Brailsford - The Outfield - http://www.theoutfield.co.uk/
+* Kenn Jacobsen - Vertica - http://kennjacobsen.dk/
+
+## Donate!
+[![Donate](https://img.shields.io/badge/Donate-PayPal-green.svg)](https://www.paypal.com/cgi-bin/webscr?cmd=_s-xclick&hosted_button_id=KBKWLURGLGU6L)
+
+This project is funded by the core team members' time only. We don't charge for Archetype but it does take quite a bit of effort to keep it up-to-date with Umbraco core changes. If you're making a few bucks off of Archetype, we wouldn't refuse a donation :)
+
 ## Contribute ##
 
 Want to contribute to Archetype?  You'll want to use Grunt (our task runner) to help you integrate with a local copy of Umbraco.

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

@@ -1,20 +1,21 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using Archetype.Extensions;
 using Archetype.Models;
-using Archetype.PropertyConverters;
 using Newtonsoft.Json;
 using Umbraco.Core;
-using Umbraco.Core.Logging;
-using Umbraco.Core.Models;
-using Umbraco.Core.Models.PublishedContent;
 using Umbraco.Courier.Core;
+using Umbraco.Courier.Core.Logging;
 using Umbraco.Courier.Core.ProviderModel;
 using Umbraco.Courier.DataResolvers;
 using Umbraco.Courier.ItemProviders;
 
 namespace Archetype.Courier.DataResolvers
 {
+    /// <summary>
+    /// Lee Kelleher's implementation of Courier's PropertyDataResolverProvider for Archetype.
+    /// </summary>
 	public class ArchetypeDataResolver : PropertyDataResolverProvider
 	{
 		private enum Direction
@@ -23,40 +24,68 @@ namespace Archetype.Courier.DataResolvers
 			Packaging
 		}
 
+        /// <summary>
+        /// Gets the editor alias.
+        /// </summary>
+        /// <value>
+        /// The editor alias.
+        /// </value>
 		public override string EditorAlias
 		{
 			get
 			{
-				return Archetype.Constants.PropertyEditorAlias;
+				return Constants.PropertyEditorAlias;
 			}
 		}
 
+        /// <summary>
+        /// Extractings the type of the data.
+        /// </summary>
+        /// <param name="item">The item.</param>
 		public override void ExtractingDataType(DataType item)
 		{
 			// No longer need to extract the DataType (int) Ids as Archetype now references the Guid [LK]
 		}
 
+        /// <summary>
+        /// Extractings the property.
+        /// </summary>
+        /// <param name="item">The item.</param>
+        /// <param name="propertyData">The property data.</param>
 		public override void ExtractingProperty(Item item, ContentProperty propertyData)
 		{
 			ReplacePropertyDataIds(item, propertyData, Direction.Extracting);
 		}
 
+        /// <summary>
+        /// Packagings the type of the data.
+        /// </summary>
+        /// <param name="item">The item.</param>
 		public override void PackagingDataType(DataType item)
 		{
 			AddDataTypeDependencies(item);
 		}
 
+        /// <summary>
+        /// Packages the property.
+        /// </summary>
+        /// <param name="item">The item.</param>
+        /// <param name="propertyData">The property data.</param>
 		public override void PackagingProperty(Item item, ContentProperty propertyData)
 		{
 			ReplacePropertyDataIds(item, propertyData, Direction.Packaging);
 		}
 
+        /// <summary>
+        /// Adds the datatype dependencies.
+        /// </summary>
+        /// <param name="item">The item.</param>
 		private void AddDataTypeDependencies(DataType item)
 		{
 			if (item.Prevalues != null && item.Prevalues.Count > 0)
 			{
 				var prevalue = item.Prevalues[0];
-				if (prevalue.Alias.InvariantEquals(Archetype.Constants.PreValueAlias) && !string.IsNullOrWhiteSpace(prevalue.Value))
+				if (prevalue.Alias.InvariantEquals(Constants.PreValueAlias) && !string.IsNullOrWhiteSpace(prevalue.Value))
 				{
 					var config = JsonConvert.DeserializeObject<ArchetypePreValue>(prevalue.Value);
 
@@ -64,7 +93,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);
@@ -73,20 +102,36 @@ namespace Archetype.Courier.DataResolvers
 			}
 		}
 
+        /// <summary>
+        /// Replaces the property data Ids.
+        /// </summary>
+        /// <param name="item">The item.</param>
+        /// <param name="propertyData">The property data.</param>
+        /// <param name="direction">The direction.</param>
 		private void ReplacePropertyDataIds(Item item, ContentProperty propertyData, Direction direction)
 		{
 			if (propertyData != null && propertyData.Value != null)
 			{
-				var dataTypeId = ExecutionContext.DatabasePersistence.GetNodeId(propertyData.DataType, NodeObjectTypes.DataType);
-				var fakePropertyType = this.CreateDummyPropertyType(dataTypeId, this.EditorAlias);
+				var dataType = ExecutionContext.DatabasePersistence.RetrieveItem<DataType>(new ItemIdentifier(propertyData.DataType.ToString(),
+					ItemProviderIds.dataTypeItemProviderGuid));
 
-				var converter = new ArchetypeValueConverter();
-				var archetype = (ArchetypeModel)converter.ConvertDataToSource(fakePropertyType, propertyData.Value, false);
+				//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"));
+				var archetypePreValue = prevalue == null
+					? null
+					: JsonConvert.DeserializeObject<ArchetypePreValue>(prevalue.Value,
+						ArchetypeHelper.Instance.JsonSerializerSettings);
+				RetrieveAdditionalProperties(ref archetypePreValue);
+
+				//Deserialize the value of the current Property to an ArchetypeModel and set additional properties before converting values
+				var sourceJson = propertyData.Value.ToString();
+				var archetype = JsonConvert.DeserializeObject<ArchetypeModel>(sourceJson, ArchetypeHelper.Instance.JsonSerializerSettings);
+				RetrieveAdditionalProperties(ref archetype, archetypePreValue);
 
 				if (archetype != null)
 				{
 					// get the `PropertyItemProvider` from the collection.
-					var propertyItemProvider = ItemProviderCollection.Instance.GetProvider(ProviderIDCollection.propertyDataItemProviderGuid, this.ExecutionContext);
+					var propertyItemProvider = ItemProviderCollection.Instance.GetProvider(ItemProviderIds.propertyDataItemProviderGuid, ExecutionContext);
 
 					foreach (var property in archetype.Fieldsets.SelectMany(x => x.Properties))
 					{
@@ -94,16 +139,16 @@ namespace Archetype.Courier.DataResolvers
 							continue;
 
 						// create a 'fake' item for Courier to process
-						var fakeItem = new ContentPropertyData()
+						var fakeItem = new ContentPropertyData
 						{
 							ItemId = item.ItemId,
-							Name = string.Format("{0} [{1}: Nested {2} ({3})]", new[] { item.Name, this.EditorAlias, property.PropertyEditorAlias, property.Alias }),
+							Name = string.Format("{0} [{1}: Nested {2} ({3})]", new[] { item.Name, EditorAlias, property.PropertyEditorAlias, property.Alias }),
 							Data = new List<ContentProperty>
 							{
 								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
 								}
@@ -119,7 +164,7 @@ namespace Archetype.Courier.DataResolvers
 							}
 							catch (Exception ex)
 							{
-								LogHelper.Error<ArchetypeDataResolver>(string.Concat("Error packaging data value: ", fakeItem.Name), ex);
+								CourierLogHelper.Error<ArchetypeDataResolver>(string.Concat("Error packaging data value: ", fakeItem.Name), ex);
 							}
 
 							// pass up the dependencies and resources
@@ -135,7 +180,7 @@ namespace Archetype.Courier.DataResolvers
 							}
 							catch (Exception ex)
 							{
-								LogHelper.Error<ArchetypeDataResolver>(string.Concat("Error extracting data value: ", fakeItem.Name), ex);
+								CourierLogHelper.Error<ArchetypeDataResolver>(string.Concat("Error extracting data value: ", fakeItem.Name), ex);
 							}
 						}
 
@@ -149,7 +194,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);
 							}
 						}
 					}
@@ -160,9 +205,56 @@ namespace Archetype.Courier.DataResolvers
 			}
 		}
 
-		private PublishedPropertyType CreateDummyPropertyType(int dataTypeId, string propertyEditorAlias)
+        /// <summary>
+        /// Retrieves the additional properties.
+        /// </summary>
+        /// <param name="preValue">The pre value.</param>
+		private void RetrieveAdditionalProperties(ref ArchetypePreValue preValue)
 		{
-			return new PublishedPropertyType(null, new PropertyType(new DataTypeDefinition(-1, propertyEditorAlias) { Id = dataTypeId }));
+			if (preValue == null)
+				return;
+
+			foreach (var fieldset in preValue.Fieldsets)
+			{
+				foreach (var property in fieldset.Properties)
+				{
+					var dataType = ExecutionContext.DatabasePersistence.RetrieveItem<DataType>(
+						new ItemIdentifier(property.DataTypeGuid.ToString(),
+							ItemProviderIds.dataTypeItemProviderGuid));
+
+					if (dataType == null)
+						continue;
+
+					property.PropertyEditorAlias = dataType.PropertyEditorAlias;
+				}
+			}
+		}
+
+        /// <summary>
+        /// Retrieves the additional properties.
+        /// </summary>
+        /// <param name="archetype">The archetype.</param>
+        /// <param name="preValue">The pre value.</param>
+		private void RetrieveAdditionalProperties(ref ArchetypeModel archetype, ArchetypePreValue preValue)
+		{
+			foreach (var fieldset in preValue.Fieldsets)
+			{
+				var fieldsetAlias = fieldset.Alias;
+				foreach (var fieldsetInst in archetype.Fieldsets.Where(x => x.Alias == fieldsetAlias))
+				{
+					foreach (var property in fieldset.Properties)
+					{
+						var propertyAlias = property.Alias;
+						foreach (var propertyInst in fieldsetInst.Properties.Where(x => x.Alias == propertyAlias))
+						{
+							propertyInst.DataTypeGuid = property.DataTypeGuid.ToString();
+							propertyInst.DataTypeId = ExecutionContext.DatabasePersistence.GetNodeId(
+								property.DataTypeGuid, UmbracoNodeObjectTypeIds.DataType);
+							propertyInst.PropertyEditorAlias = property.PropertyEditorAlias;
+						}
+					}
+				}
+			}
 		}
 	}
 }

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

@@ -33,167 +33,168 @@
   <ItemGroup>
     <Reference Include="AutoMapper">
       <HintPath>..\packages\AutoMapper.3.0.0\lib\net40\AutoMapper.dll</HintPath>
-      <Private>False</Private>
+      <Private>True</Private>
     </Reference>
     <Reference Include="AutoMapper.Net4">
       <HintPath>..\packages\AutoMapper.3.0.0\lib\net40\AutoMapper.Net4.dll</HintPath>
-      <Private>False</Private>
+      <Private>True</Private>
     </Reference>
     <Reference Include="businesslogic, Version=1.0.5242.22740, Culture=neutral, processorArchitecture=MSIL">
       <SpecificVersion>False</SpecificVersion>
       <HintPath>..\packages\UmbracoCms.Core.7.1.2\lib\businesslogic.dll</HintPath>
-      <Private>False</Private>
+      <Private>True</Private>
     </Reference>
     <Reference Include="ClientDependency.Core">
       <HintPath>..\packages\ClientDependency.1.7.1.2\lib\ClientDependency.Core.dll</HintPath>
-      <Private>False</Private>
+      <Private>True</Private>
     </Reference>
     <Reference Include="ClientDependency.Core.Mvc">
       <HintPath>..\packages\ClientDependency-Mvc.1.7.0.4\lib\ClientDependency.Core.Mvc.dll</HintPath>
-      <Private>False</Private>
+      <Private>True</Private>
     </Reference>
     <Reference Include="cms, Version=1.0.5242.22741, Culture=neutral, processorArchitecture=MSIL">
       <SpecificVersion>False</SpecificVersion>
       <HintPath>..\packages\UmbracoCms.Core.7.1.2\lib\cms.dll</HintPath>
-      <Private>False</Private>
+      <Private>True</Private>
     </Reference>
     <Reference Include="controls, Version=1.0.5242.22742, Culture=neutral, processorArchitecture=MSIL">
       <SpecificVersion>False</SpecificVersion>
       <HintPath>..\packages\UmbracoCms.Core.7.1.2\lib\controls.dll</HintPath>
-      <Private>False</Private>
+      <Private>True</Private>
     </Reference>
     <Reference Include="CookComputing.XmlRpcV2">
       <HintPath>..\packages\xmlrpcnet.2.5.0\lib\net20\CookComputing.XmlRpcV2.dll</HintPath>
-      <Private>False</Private>
+      <Private>True</Private>
     </Reference>
     <Reference Include="Examine, Version=0.1.55.2941, Culture=neutral, processorArchitecture=MSIL">
       <SpecificVersion>False</SpecificVersion>
       <HintPath>..\packages\UmbracoCms.Core.7.1.2\lib\Examine.dll</HintPath>
-      <Private>False</Private>
+      <Private>True</Private>
     </Reference>
     <Reference Include="HtmlAgilityPack">
       <HintPath>..\packages\HtmlAgilityPack.1.4.6\lib\Net45\HtmlAgilityPack.dll</HintPath>
-      <Private>False</Private>
+      <Private>True</Private>
     </Reference>
     <Reference Include="ICSharpCode.SharpZipLib">
       <HintPath>..\packages\SharpZipLib.0.86.0\lib\20\ICSharpCode.SharpZipLib.dll</HintPath>
-      <Private>False</Private>
+      <Private>True</Private>
     </Reference>
     <Reference Include="ImageProcessor, Version=1.9.0.0, Culture=neutral, processorArchitecture=MSIL">
       <SpecificVersion>False</SpecificVersion>
       <HintPath>..\packages\ImageProcessor.1.9.0.0\lib\ImageProcessor.dll</HintPath>
-      <Private>False</Private>
+      <Private>True</Private>
     </Reference>
     <Reference Include="ImageProcessor.Web, Version=3.2.3.0, Culture=neutral, processorArchitecture=MSIL">
       <SpecificVersion>False</SpecificVersion>
       <HintPath>..\packages\ImageProcessor.Web.3.2.3.0\lib\net45\ImageProcessor.Web.dll</HintPath>
-      <Private>False</Private>
+      <Private>True</Private>
     </Reference>
     <Reference Include="interfaces, Version=1.0.5242.22737, Culture=neutral, processorArchitecture=MSIL">
       <SpecificVersion>False</SpecificVersion>
       <HintPath>..\packages\UmbracoCms.Core.7.1.2\lib\interfaces.dll</HintPath>
-      <Private>False</Private>
+      <Private>True</Private>
     </Reference>
     <Reference Include="log4net, Version=1.2.11.0, Culture=neutral, processorArchitecture=MSIL">
       <SpecificVersion>False</SpecificVersion>
       <HintPath>..\packages\UmbracoCms.Core.7.1.2\lib\log4net.dll</HintPath>
-      <Private>False</Private>
+      <Private>True</Private>
     </Reference>
     <Reference Include="Lucene.Net">
       <HintPath>..\packages\Lucene.Net.2.9.4.1\lib\net40\Lucene.Net.dll</HintPath>
-      <Private>False</Private>
+      <Private>True</Private>
     </Reference>
     <Reference Include="Microsoft.ApplicationBlocks.Data, Version=1.0.1559.20655, Culture=neutral">
       <SpecificVersion>False</SpecificVersion>
       <HintPath>..\packages\UmbracoCms.Core.7.1.2\lib\Microsoft.ApplicationBlocks.Data.dll</HintPath>
-      <Private>False</Private>
+      <Private>True</Private>
     </Reference>
     <Reference Include="Microsoft.Web.Helpers, Version=1.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL">
       <SpecificVersion>False</SpecificVersion>
       <HintPath>..\packages\UmbracoCms.Core.7.1.2\lib\Microsoft.Web.Helpers.dll</HintPath>
-      <Private>False</Private>
+      <Private>True</Private>
     </Reference>
     <Reference Include="Microsoft.Web.Infrastructure, Version=1.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL">
-      <Private>False</Private>
+      <Private>True</Private>
       <HintPath>..\packages\Microsoft.Web.Infrastructure.1.0.0.0\lib\net40\Microsoft.Web.Infrastructure.dll</HintPath>
     </Reference>
     <Reference Include="Microsoft.Web.Mvc.FixedDisplayModes">
       <HintPath>..\packages\Microsoft.AspNet.Mvc.FixedDisplayModes.1.0.1\lib\net40\Microsoft.Web.Mvc.FixedDisplayModes.dll</HintPath>
-      <Private>False</Private>
+      <Private>True</Private>
     </Reference>
     <Reference Include="MiniProfiler">
       <HintPath>..\packages\MiniProfiler.2.1.0\lib\net40\MiniProfiler.dll</HintPath>
-      <Private>False</Private>
+      <Private>True</Private>
     </Reference>
     <Reference Include="Moq">
       <HintPath>..\packages\Moq.4.2.1312.1622\lib\net40\Moq.dll</HintPath>
-      <Private>False</Private>
+      <Private>True</Private>
     </Reference>
     <Reference Include="MySql.Data">
       <HintPath>..\packages\MySql.Data.6.6.5\lib\net40\MySql.Data.dll</HintPath>
-      <Private>False</Private>
+      <Private>True</Private>
     </Reference>
     <Reference Include="Newtonsoft.Json, Version=6.0.0.0, Culture=neutral, PublicKeyToken=30ad4fe6b2a6aeed, processorArchitecture=MSIL">
       <SpecificVersion>False</SpecificVersion>
       <HintPath>..\packages\Newtonsoft.Json.6.0.2\lib\net45\Newtonsoft.Json.dll</HintPath>
-      <Private>False</Private>
+      <Private>True</Private>
     </Reference>
-    <Reference Include="nunit.framework">
-      <HintPath>..\packages\NUnit.2.6.3\lib\nunit.framework.dll</HintPath>
-      <Private>False</Private>
+    <Reference Include="nunit.framework, Version=2.6.4.14350, Culture=neutral, PublicKeyToken=96d09a1eb7f44a77, processorArchitecture=MSIL">
+      <HintPath>..\packages\NUnit.2.6.4\lib\nunit.framework.dll</HintPath>
+      <Private>True</Private>
     </Reference>
     <Reference Include="SQLCE4Umbraco, Version=1.0.5242.22741, Culture=neutral, processorArchitecture=MSIL">
       <SpecificVersion>False</SpecificVersion>
       <HintPath>..\packages\UmbracoCms.Core.7.1.2\lib\SQLCE4Umbraco.dll</HintPath>
-      <Private>False</Private>
+      <Private>True</Private>
     </Reference>
     <Reference Include="System" />
     <Reference Include="System.Core" />
     <Reference Include="System.Data.SqlServerCe, Version=4.0.0.0, Culture=neutral, PublicKeyToken=89845dcd8080cc91, processorArchitecture=MSIL">
-      <Private>False</Private>
+      <Private>True</Private>
       <HintPath>..\packages\UmbracoCms.Core.7.1.2\lib\System.Data.SqlServerCe.dll</HintPath>
     </Reference>
     <Reference Include="System.Data.SqlServerCe.Entity, Version=4.0.0.0, Culture=neutral, PublicKeyToken=89845dcd8080cc91, processorArchitecture=MSIL">
-      <Private>False</Private>
+      <Private>True</Private>
       <HintPath>..\packages\UmbracoCms.Core.7.1.2\lib\System.Data.SqlServerCe.Entity.dll</HintPath>
     </Reference>
     <Reference Include="System.Net.Http" />
     <Reference Include="System.Net.Http.Formatting, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL">
       <HintPath>..\packages\Microsoft.AspNet.WebApi.Client.4.0.30506.0\lib\net40\System.Net.Http.Formatting.dll</HintPath>
-      <Private>False</Private>
+      <Private>True</Private>
     </Reference>
     <Reference Include="System.Net.Http.WebRequest" />
+    <Reference Include="System.Web" />
     <Reference Include="System.Web.Helpers, Version=2.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL">
-      <Private>False</Private>
+      <Private>True</Private>
       <HintPath>..\packages\Microsoft.AspNet.WebPages.2.0.30506.0\lib\net40\System.Web.Helpers.dll</HintPath>
     </Reference>
     <Reference Include="System.Web.Http, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL">
       <HintPath>..\packages\Microsoft.AspNet.WebApi.Core.4.0.30506.0\lib\net40\System.Web.Http.dll</HintPath>
-      <Private>False</Private>
+      <Private>True</Private>
     </Reference>
     <Reference Include="System.Web.Http.WebHost, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL">
       <HintPath>..\packages\Microsoft.AspNet.WebApi.WebHost.4.0.30506.0\lib\net40\System.Web.Http.WebHost.dll</HintPath>
-      <Private>False</Private>
+      <Private>True</Private>
     </Reference>
     <Reference Include="System.Web.Mvc, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL">
-      <Private>False</Private>
+      <Private>True</Private>
       <HintPath>..\packages\Microsoft.AspNet.Mvc.4.0.30506.0\lib\net40\System.Web.Mvc.dll</HintPath>
     </Reference>
     <Reference Include="System.Web.Razor, Version=2.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL">
       <SpecificVersion>False</SpecificVersion>
       <HintPath>..\packages\Microsoft.AspNet.Razor.2.0.30506.0\lib\net40\System.Web.Razor.dll</HintPath>
-      <Private>False</Private>
+      <Private>True</Private>
     </Reference>
     <Reference Include="System.Web.WebPages, Version=2.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL">
-      <Private>False</Private>
+      <Private>True</Private>
       <HintPath>..\packages\Microsoft.AspNet.WebPages.2.0.30506.0\lib\net40\System.Web.WebPages.dll</HintPath>
     </Reference>
     <Reference Include="System.Web.WebPages.Deployment, Version=2.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL">
-      <Private>False</Private>
+      <Private>True</Private>
       <HintPath>..\packages\Microsoft.AspNet.WebPages.2.0.30506.0\lib\net40\System.Web.WebPages.Deployment.dll</HintPath>
     </Reference>
     <Reference Include="System.Web.WebPages.Razor, Version=2.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL">
-      <Private>False</Private>
+      <Private>True</Private>
       <HintPath>..\packages\Microsoft.AspNet.WebPages.2.0.30506.0\lib\net40\System.Web.WebPages.Razor.dll</HintPath>
     </Reference>
     <Reference Include="System.Xml.Linq" />
@@ -204,63 +205,65 @@
     <Reference Include="TidyNet, Version=1.0.0.0, Culture=neutral">
       <SpecificVersion>False</SpecificVersion>
       <HintPath>..\packages\UmbracoCms.Core.7.1.2\lib\TidyNet.dll</HintPath>
-      <Private>False</Private>
+      <Private>True</Private>
     </Reference>
     <Reference Include="umbraco, Version=1.0.5242.22743, Culture=neutral, processorArchitecture=MSIL">
       <SpecificVersion>False</SpecificVersion>
       <HintPath>..\packages\UmbracoCms.Core.7.1.2\lib\umbraco.dll</HintPath>
-      <Private>False</Private>
+      <Private>True</Private>
     </Reference>
     <Reference Include="Umbraco.Core, Version=1.0.5242.22738, Culture=neutral, processorArchitecture=MSIL">
       <SpecificVersion>False</SpecificVersion>
       <HintPath>..\packages\UmbracoCms.Core.7.1.2\lib\Umbraco.Core.dll</HintPath>
-      <Private>False</Private>
+      <Private>True</Private>
     </Reference>
     <Reference Include="umbraco.DataLayer, Version=1.0.5242.22740, Culture=neutral, processorArchitecture=MSIL">
       <SpecificVersion>False</SpecificVersion>
       <HintPath>..\packages\UmbracoCms.Core.7.1.2\lib\umbraco.DataLayer.dll</HintPath>
-      <Private>False</Private>
+      <Private>True</Private>
     </Reference>
     <Reference Include="umbraco.editorControls, Version=1.0.5242.22746, Culture=neutral, processorArchitecture=MSIL">
       <SpecificVersion>False</SpecificVersion>
       <HintPath>..\packages\UmbracoCms.Core.7.1.2\lib\umbraco.editorControls.dll</HintPath>
-      <Private>False</Private>
+      <Private>True</Private>
     </Reference>
     <Reference Include="umbraco.MacroEngines, Version=1.0.5242.22747, Culture=neutral, processorArchitecture=MSIL">
       <SpecificVersion>False</SpecificVersion>
       <HintPath>..\packages\UmbracoCms.Core.7.1.2\lib\umbraco.MacroEngines.dll</HintPath>
-      <Private>False</Private>
+      <Private>True</Private>
     </Reference>
     <Reference Include="umbraco.providers, Version=1.0.5242.22742, Culture=neutral, processorArchitecture=MSIL">
       <SpecificVersion>False</SpecificVersion>
       <HintPath>..\packages\UmbracoCms.Core.7.1.2\lib\umbraco.providers.dll</HintPath>
-      <Private>False</Private>
+      <Private>True</Private>
     </Reference>
     <Reference Include="Umbraco.Web.UI, Version=1.0.5242.22748, Culture=neutral, processorArchitecture=MSIL">
       <SpecificVersion>False</SpecificVersion>
       <HintPath>..\packages\UmbracoCms.Core.7.1.2\lib\Umbraco.Web.UI.dll</HintPath>
-      <Private>False</Private>
+      <Private>True</Private>
     </Reference>
     <Reference Include="umbraco.XmlSerializers, Version=1.0.5242.22743, Culture=neutral, processorArchitecture=MSIL">
       <SpecificVersion>False</SpecificVersion>
       <HintPath>..\packages\UmbracoCms.Core.7.1.2\lib\umbraco.XmlSerializers.dll</HintPath>
-      <Private>False</Private>
+      <Private>True</Private>
     </Reference>
     <Reference Include="UmbracoExamine, Version=0.6.0.22741, Culture=neutral, processorArchitecture=MSIL">
       <SpecificVersion>False</SpecificVersion>
       <HintPath>..\packages\UmbracoCms.Core.7.1.2\lib\UmbracoExamine.dll</HintPath>
-      <Private>False</Private>
+      <Private>True</Private>
     </Reference>
     <Reference Include="UrlRewritingNet.UrlRewriter, Version=2.0.60829.1, Culture=neutral, processorArchitecture=MSIL">
       <SpecificVersion>False</SpecificVersion>
       <HintPath>..\packages\UmbracoCms.Core.7.1.2\lib\UrlRewritingNet.UrlRewriter.dll</HintPath>
-      <Private>False</Private>
+      <Private>True</Private>
     </Reference>
   </ItemGroup>
   <ItemGroup>
     <Compile Include="Models\FieldsetTests.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="PropertyValueConverter\PropertyValueConverterTests.cs" />
+    <Compile Include="PublishedContent\ArchetypePublishedContentTests.cs" />
+    <Compile Include="PublishedContent\TypeConverterTests.cs" />
   </ItemGroup>
   <ItemGroup>
     <None Include="app.config" />
@@ -274,7 +277,9 @@
       <Private>True</Private>
     </ProjectReference>
   </ItemGroup>
-  <ItemGroup />
+  <ItemGroup>
+    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
+  </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <Import Project="$(SolutionDir)\.nuget\NuGet.targets" Condition="Exists('$(SolutionDir)\.nuget\NuGet.targets')" />
   <PropertyGroup>

app/Umbraco/Archetype.Tests/Models/FieldsetTests.cs

@@ -1,21 +1,21 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
+using System.IO;
 using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
 using Archetype.PropertyConverters;
 using NUnit.Framework;
 
 namespace Archetype.Tests.Models
 {
-
+    /// <summary>
+    /// Tests designed for the fieldsets.
+    /// </summary>
     [TestFixture]
     public class FieldsetTests
     {
-
         private string _sampleJson;
 
+        /// <summary>
+        /// Sets up the test to use sample JSON data.
+        /// </summary>
         [SetUp]
         public void SetUp()
         {

app/Umbraco/Archetype.Tests/PropertyValueConverter/PropertyValueConverterTests.cs

@@ -1,22 +1,21 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
+using System.IO;
 using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
 using Archetype.PropertyConverters;
-using Moq;
 using NUnit.Framework;
-using Umbraco.Core.Models.PublishedContent;
 
 namespace Archetype.Tests.PropertyValueConverter
 {
+    /// <summary>
+    /// Tests designed to test the PVC.
+    /// </summary>
     [TestFixture]
     public class PropertyValueConverterTests
     {
-
         private string _sampleJson;
 
+        /// <summary>
+        /// Sets up the test to use JSON data.
+        /// </summary>
         [SetUp]
         public void SetUp()
         {

app/Umbraco/Archetype.Tests/PublishedContent/ArchetypePublishedContentTests.cs

@@ -0,0 +1,156 @@
+using System;
+using System.Linq;
+using Archetype.Extensions;
+using Archetype.Models;
+using Archetype.PropertyConverters;
+using NUnit.Framework;
+using Umbraco.Core.Models;
+using Umbraco.Web;
+
+namespace Archetype.Tests.PublishedContent
+{
+    [TestFixture]
+    public class ArchetypePublishedContentTests
+    {
+        private ArchetypeModel _archetype;
+
+        [TestFixtureSetUp]
+        public void Init()
+        {
+            var archetypeJson = System.IO.File.ReadAllText("..\\..\\Data\\sample-1.json");
+            var converter = new ArchetypeValueConverter();
+
+            _archetype = (ArchetypeModel)converter.ConvertDataToSource(null, archetypeJson, false);
+        }
+
+        [Test]
+        public void ArchetypeModel_Initialized()
+        {
+            Assert.IsNotNull(_archetype);
+            Assert.IsNotEmpty(_archetype.Fieldsets);
+        }
+
+        [Test]
+        public void ArchetypeModel_To_PublishedContentSet()
+        {
+            var contentSet = _archetype.ToPublishedContentSet();
+
+            Assert.That(contentSet, Is.Not.Null);
+            Assert.That(contentSet, Is.Not.Empty);
+            Assert.That(contentSet, Is.All.InstanceOf<IPublishedContent>());
+        }
+
+        [Test]
+        public void ArchetypeFieldsetModel_To_PublishedContent()
+        {
+            var fieldset = _archetype.Fieldsets.FirstOrDefault();
+            var content = fieldset.ToPublishedContent();
+
+            Assert.That(content, Is.Not.Null);
+            Assert.That(content, Is.InstanceOf<IPublishedContent>());
+            Assert.That(content.Properties, Is.Not.Empty);
+            Assert.That(content.Properties, Is.All.InstanceOf<IPublishedProperty>());
+        }
+
+        [TestCase("boxHeadline", "Box 1 Title")]
+        [TestCase("link", "3175")]
+        [TestCase("link", 3175)]
+        [TestCase("show", "1")]
+        [TestCase("show", true)]
+        [TestCase("show", 1)]
+        public void ArchetypePublishedContent_Typed_Properties<T>(string propertyAlias, T expected)
+        {
+            var fieldset = _archetype.Fieldsets.FirstOrDefault();
+            var content = fieldset.ToPublishedContent();
+
+            var actual = content.GetPropertyValue<T>(propertyAlias);
+
+            Assert.AreEqual(actual, expected);
+        }
+
+        [Test]
+        public void Null_ArchetypeModel_Throws_Exception()
+        {
+            TestDelegate code = () =>
+            {
+                ArchetypeModel archetype = null;
+                archetype.ToPublishedContentSet();
+            };
+
+            Assert.Throws<ArgumentNullException>(code);
+        }
+
+        [Test]
+        public void Null_ArchetypeFieldsetModel_Throws_Exception()
+        {
+            TestDelegate code = () =>
+            {
+                ArchetypeFieldsetModel fieldset = null;
+                fieldset.ToPublishedContent();
+            };
+
+            Assert.Throws<ArgumentNullException>(code);
+        }
+
+        [Test]
+        public void ArchetypePublishedContent_GetIndex()
+        {
+            var contentSet = _archetype.ToPublishedContentSet();
+            var i = 0;
+
+            foreach (var content in contentSet)
+            {
+                Assert.AreEqual(content.GetIndex(), i);
+                i++;
+            }
+        }
+
+        [Test]
+        public void ArchetypePublishedContentSet_IsFirstIsLast()
+        {
+            var contentSet = _archetype.ToPublishedContentSet();
+
+            foreach (var content in contentSet)
+            {
+                var value = content.GetPropertyValue<string>("boxHeadline");
+
+                Assert.That(value == "Box 1 Title", Is.EqualTo(content.IsFirst()));
+                Assert.That(value == "Another Box", Is.EqualTo(content.IsLast()));
+            }
+        }
+
+        [Test]
+        public void ArchetypePublishedContentSet_PreviousNext()
+        {
+            var contentSet = _archetype.ToPublishedContentSet();
+            var list = contentSet.ToList();
+
+            Assert.That(list.Count, Is.EqualTo(2));
+
+            var first = list[0];
+            var last = list[1];
+
+            var next = first.Next();
+            Assert.AreEqual(next, last);
+
+            var prev = last.Previous();
+            Assert.AreEqual(prev, first);
+        }
+
+        [Test, ExpectedException(typeof(NullReferenceException))]
+        public void ArchetypePublishedContentSet_Siblings()
+        {
+            var contentSet = _archetype.ToPublishedContentSet();
+            var content = contentSet.FirstOrDefault();
+
+            var siblings = content.Siblings();
+            Assert.That(siblings, Is.Not.Null);
+
+            var following = content.FollowingSibling();
+            Assert.That(following, Is.Not.Null);
+
+            var preceding = content.PrecedingSibling();
+            Assert.That(preceding, Is.Not.Null);
+        }
+    }
+}

app/Umbraco/Archetype.Tests/PublishedContent/TypeConverterTests.cs

@@ -0,0 +1,68 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Archetype.Models;
+using Archetype.PropertyConverters;
+using NUnit.Framework;
+using Umbraco.Core;
+using Umbraco.Core.Models;
+
+namespace Archetype.Tests.PublishedContent
+{
+    [TestFixture]
+    public class TypeConverterTests
+    {
+        private ArchetypeModel _archetype;
+
+        [TestFixtureSetUp]
+        public void Init()
+        {
+            var archetypeJson = System.IO.File.ReadAllText("..\\..\\Data\\sample-1.json");
+            var converter = new ArchetypeValueConverter();
+
+            _archetype = (ArchetypeModel)converter.ConvertDataToSource(null, archetypeJson, false);
+        }
+
+        [TestCase(typeof(ArchetypeModel), true)]
+        [TestCase(typeof(ArchetypePublishedContentSet), true)]
+        [TestCase(typeof(IEnumerable<IPublishedContent>), true)]
+        [TestCase(typeof(string), true)]
+        [TestCase(typeof(int), false)]
+        [TestCase(typeof(ArchetypeFieldsetModel), false)]
+        public void ArchetypeModel_ConvertsTo_EnumerablePublishedContent(Type destinationType, bool expected)
+        {
+            Assert.IsNotNull(_archetype);
+
+            var attempt = _archetype.TryConvertTo(destinationType);
+
+            Assert.That(attempt.Success, Is.EqualTo(expected));
+
+            if (attempt.Success)
+            {
+                Assert.IsNotNull(attempt.Result);
+                Assert.That(attempt.Result, Is.InstanceOf(destinationType));
+            }
+        }
+
+        [TestCase(typeof(ArchetypeFieldsetModel), true)]
+        [TestCase(typeof(ArchetypePublishedContent), true)]
+        [TestCase(typeof(IPublishedContent), true)]
+        [TestCase(typeof(string), true)]
+        [TestCase(typeof(int), false)]
+        [TestCase(typeof(ArchetypeModel), false)]
+        public void ArchetypeFieldsetModel_ConvertsTo_PublishedContent(Type destinationType, bool expected)
+        {
+            CollectionAssert.IsNotEmpty(_archetype.Fieldsets);
+
+            var attempt = _archetype.First().TryConvertTo(destinationType);
+
+            Assert.That(attempt.Success, Is.EqualTo(expected));
+
+            if (attempt.Success)
+            {
+                Assert.IsNotNull(attempt.Result);
+                Assert.That(attempt.Result, Is.InstanceOf(destinationType));
+            }
+        }
+    }
+}

app/Umbraco/Archetype.Tests/packages.config

@@ -21,7 +21,7 @@
   <package id="Moq" version="4.2.1312.1622" targetFramework="net45" />
   <package id="MySql.Data" version="6.6.5" targetFramework="net45" />
   <package id="Newtonsoft.Json" version="6.0.2" targetFramework="net45" />
-  <package id="NUnit" version="2.6.3" targetFramework="net45" />
+  <package id="NUnit" version="2.6.4" targetFramework="net45" />
   <package id="SharpZipLib" version="0.86.0" targetFramework="net45" />
   <package id="UmbracoCms.Core" version="7.1.2" targetFramework="net45" />
   <package id="xmlrpcnet" version="2.5.0" targetFramework="net45" />

app/Umbraco/DatabaseSizer/Application.cs

@@ -1,49 +0,0 @@
-using System;
-using Umbraco.Core;
-using Umbraco.Core.Logging;
-
-namespace DatabaseSizer
-{
-    public class Application : ApplicationEventHandler
-    {
-        protected override void ApplicationStarted(UmbracoApplicationBase umbracoApplication, ApplicationContext applicationContext)
-        {
-            base.ApplicationStarted(umbracoApplication, applicationContext);
-
-            ExpandPrevalueValueColumnSize();
-        }
-
-        protected void ExpandPrevalueValueColumnSize()
-        {
-            try
-            {
-                var dbContext = ApplicationContext.Current.DatabaseContext;
-                var colCount =
-                    dbContext.Database.ExecuteScalar<int>(
-                        "SELECT COUNT(1) FROM INFORMATION_SCHEMA.COLUMNS WHERE DATA_TYPE = 'nvarchar' AND COLUMN_NAME = 'value' AND CHARACTER_MAXIMUM_LENGTH = 2500 AND TABLE_NAME = 'cmsDataTypePreValues'");
-
-                // Check column
-                if (colCount != 0)
-                {
-                    using (var trans = dbContext.Database.GetTransaction())
-                    {
-                        // Change column
-                        dbContext.Database.Execute("ALTER TABLE [cmsDataTypePreValues] ALTER COLUMN [value] ntext NULL;");
-
-                        trans.Complete();
-                    }
-
-                    LogHelper.Debug(typeof(Application), "Successfully expanded Prevalue table Value column");
-                }
-                else
-                {
-                    LogHelper.Debug(typeof(Application), "Prevalue table Value column is already expanded");
-                }
-            }
-            catch (Exception ex)
-            {
-                LogHelper.Error(typeof(Application), "Error expanding Prevalue table Value column", ex);
-            }
-        }
-    }
-}

app/Umbraco/DatabaseSizer/DatabaseSizer.csproj

@@ -1,250 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectGuid>{0114C963-C514-49C1-B7AB-DCB1825F498C}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <RootNamespace>DatabaseSizer</RootNamespace>
-    <AssemblyName>DatabaseSizer</AssemblyName>
-    <TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
-    <FileAlignment>512</FileAlignment>
-    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\</SolutionDir>
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-    <DebugSymbols>true</DebugSymbols>
-    <DebugType>full</DebugType>
-    <Optimize>false</Optimize>
-    <OutputPath>bin\Debug\</OutputPath>
-    <DefineConstants>DEBUG;TRACE</DefineConstants>
-    <ErrorReport>prompt</ErrorReport>
-    <WarningLevel>4</WarningLevel>
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-    <DebugType>pdbonly</DebugType>
-    <Optimize>true</Optimize>
-    <OutputPath>bin\Release\</OutputPath>
-    <DefineConstants>TRACE</DefineConstants>
-    <ErrorReport>prompt</ErrorReport>
-    <WarningLevel>4</WarningLevel>
-  </PropertyGroup>
-  <ItemGroup>
-    <Reference Include="AutoMapper">
-      <HintPath>..\packages\AutoMapper.3.0.0\lib\net40\AutoMapper.dll</HintPath>
-      <Private>False</Private>
-    </Reference>
-    <Reference Include="AutoMapper.Net4">
-      <HintPath>..\packages\AutoMapper.3.0.0\lib\net40\AutoMapper.Net4.dll</HintPath>
-      <Private>False</Private>
-    </Reference>
-    <Reference Include="businesslogic">
-      <HintPath>..\packages\UmbracoCms.Core.7.1.2\lib\businesslogic.dll</HintPath>
-      <Private>False</Private>
-    </Reference>
-    <Reference Include="ClientDependency.Core">
-      <HintPath>..\packages\ClientDependency.1.7.1.2\lib\ClientDependency.Core.dll</HintPath>
-      <Private>False</Private>
-    </Reference>
-    <Reference Include="ClientDependency.Core.Mvc">
-      <HintPath>..\packages\ClientDependency-Mvc.1.7.0.4\lib\ClientDependency.Core.Mvc.dll</HintPath>
-      <Private>False</Private>
-    </Reference>
-    <Reference Include="cms">
-      <HintPath>..\packages\UmbracoCms.Core.7.1.2\lib\cms.dll</HintPath>
-      <Private>False</Private>
-    </Reference>
-    <Reference Include="controls">
-      <HintPath>..\packages\UmbracoCms.Core.7.1.2\lib\controls.dll</HintPath>
-      <Private>False</Private>
-    </Reference>
-    <Reference Include="CookComputing.XmlRpcV2">
-      <HintPath>..\packages\xmlrpcnet.2.5.0\lib\net20\CookComputing.XmlRpcV2.dll</HintPath>
-      <Private>False</Private>
-    </Reference>
-    <Reference Include="Examine">
-      <HintPath>..\packages\UmbracoCms.Core.7.1.2\lib\Examine.dll</HintPath>
-      <Private>False</Private>
-    </Reference>
-    <Reference Include="HtmlAgilityPack">
-      <HintPath>..\packages\HtmlAgilityPack.1.4.6\lib\Net45\HtmlAgilityPack.dll</HintPath>
-      <Private>False</Private>
-    </Reference>
-    <Reference Include="ICSharpCode.SharpZipLib">
-      <HintPath>..\packages\SharpZipLib.0.86.0\lib\20\ICSharpCode.SharpZipLib.dll</HintPath>
-      <Private>False</Private>
-    </Reference>
-    <Reference Include="ImageProcessor">
-      <HintPath>..\packages\ImageProcessor.1.9.0.0\lib\ImageProcessor.dll</HintPath>
-      <Private>False</Private>
-    </Reference>
-    <Reference Include="ImageProcessor.Web">
-      <HintPath>..\packages\ImageProcessor.Web.3.2.3.0\lib\net45\ImageProcessor.Web.dll</HintPath>
-      <Private>False</Private>
-    </Reference>
-    <Reference Include="interfaces">
-      <HintPath>..\packages\UmbracoCms.Core.7.1.2\lib\interfaces.dll</HintPath>
-      <Private>False</Private>
-    </Reference>
-    <Reference Include="log4net">
-      <HintPath>..\packages\UmbracoCms.Core.7.1.2\lib\log4net.dll</HintPath>
-      <Private>False</Private>
-    </Reference>
-    <Reference Include="Lucene.Net">
-      <HintPath>..\packages\Lucene.Net.2.9.4.1\lib\net40\Lucene.Net.dll</HintPath>
-      <Private>False</Private>
-    </Reference>
-    <Reference Include="Microsoft.ApplicationBlocks.Data">
-      <HintPath>..\packages\UmbracoCms.Core.7.1.2\lib\Microsoft.ApplicationBlocks.Data.dll</HintPath>
-      <Private>False</Private>
-    </Reference>
-    <Reference Include="Microsoft.Web.Helpers">
-      <HintPath>..\packages\UmbracoCms.Core.7.1.2\lib\Microsoft.Web.Helpers.dll</HintPath>
-      <Private>False</Private>
-    </Reference>
-    <Reference Include="Microsoft.Web.Infrastructure, Version=1.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL">
-      <Private>False</Private>
-      <HintPath>..\packages\Microsoft.Web.Infrastructure.1.0.0.0\lib\net40\Microsoft.Web.Infrastructure.dll</HintPath>
-    </Reference>
-    <Reference Include="Microsoft.Web.Mvc.FixedDisplayModes">
-      <HintPath>..\packages\Microsoft.AspNet.Mvc.FixedDisplayModes.1.0.0\lib\net40\Microsoft.Web.Mvc.FixedDisplayModes.dll</HintPath>
-      <Private>False</Private>
-    </Reference>
-    <Reference Include="MiniProfiler">
-      <HintPath>..\packages\MiniProfiler.2.1.0\lib\net40\MiniProfiler.dll</HintPath>
-      <Private>False</Private>
-    </Reference>
-    <Reference Include="MySql.Data">
-      <HintPath>..\packages\MySql.Data.6.6.5\lib\net40\MySql.Data.dll</HintPath>
-      <Private>False</Private>
-    </Reference>
-    <Reference Include="Newtonsoft.Json">
-      <HintPath>..\packages\Newtonsoft.Json.6.0.2\lib\net45\Newtonsoft.Json.dll</HintPath>
-      <Private>False</Private>
-    </Reference>
-    <Reference Include="SQLCE4Umbraco">
-      <HintPath>..\packages\UmbracoCms.Core.7.1.2\lib\SQLCE4Umbraco.dll</HintPath>
-      <Private>False</Private>
-    </Reference>
-    <Reference Include="System" />
-    <Reference Include="System.Core" />
-    <Reference Include="System.Data.SqlServerCe, Version=4.0.0.0, Culture=neutral, PublicKeyToken=89845dcd8080cc91, processorArchitecture=MSIL">
-      <Private>False</Private>
-      <HintPath>..\packages\UmbracoCms.Core.7.1.2\lib\System.Data.SqlServerCe.dll</HintPath>
-    </Reference>
-    <Reference Include="System.Data.SqlServerCe.Entity, Version=4.0.0.0, Culture=neutral, PublicKeyToken=89845dcd8080cc91, processorArchitecture=MSIL">
-      <Private>False</Private>
-      <HintPath>..\packages\UmbracoCms.Core.7.1.2\lib\System.Data.SqlServerCe.Entity.dll</HintPath>
-    </Reference>
-    <Reference Include="System.Net.Http.Formatting, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL">
-      <HintPath>..\packages\Microsoft.AspNet.WebApi.Client.4.0.30506.0\lib\net40\System.Net.Http.Formatting.dll</HintPath>
-      <Private>False</Private>
-    </Reference>
-    <Reference Include="System.Web" />
-    <Reference Include="System.Web.Helpers, Version=2.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL">
-      <Private>False</Private>
-      <HintPath>..\packages\Microsoft.AspNet.WebPages.2.0.20710.0\lib\net40\System.Web.Helpers.dll</HintPath>
-    </Reference>
-    <Reference Include="System.Web.Http, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL">
-      <HintPath>..\packages\Microsoft.AspNet.WebApi.Core.4.0.20710.0\lib\net40\System.Web.Http.dll</HintPath>
-      <Private>False</Private>
-    </Reference>
-    <Reference Include="System.Web.Http.WebHost, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL">
-      <HintPath>..\packages\Microsoft.AspNet.WebApi.WebHost.4.0.20710.0\lib\net40\System.Web.Http.WebHost.dll</HintPath>
-      <Private>False</Private>
-    </Reference>
-    <Reference Include="System.Web.Mvc, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL">
-      <Private>False</Private>
-      <HintPath>..\packages\Microsoft.AspNet.Mvc.4.0.20710.0\lib\net40\System.Web.Mvc.dll</HintPath>
-    </Reference>
-    <Reference Include="System.Web.Razor, Version=2.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL">
-      <Private>False</Private>
-      <HintPath>..\packages\Microsoft.AspNet.Razor.2.0.20710.0\lib\net40\System.Web.Razor.dll</HintPath>
-    </Reference>
-    <Reference Include="System.Web.WebPages, Version=2.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL">
-      <Private>False</Private>
-      <HintPath>..\packages\Microsoft.AspNet.WebPages.2.0.20710.0\lib\net40\System.Web.WebPages.dll</HintPath>
-    </Reference>
-    <Reference Include="System.Web.WebPages.Deployment, Version=2.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL">
-      <Private>False</Private>
-      <HintPath>..\packages\Microsoft.AspNet.WebPages.2.0.20710.0\lib\net40\System.Web.WebPages.Deployment.dll</HintPath>
-    </Reference>
-    <Reference Include="System.Web.WebPages.Razor, Version=2.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL">
-      <Private>False</Private>
-      <HintPath>..\packages\Microsoft.AspNet.WebPages.2.0.20710.0\lib\net40\System.Web.WebPages.Razor.dll</HintPath>
-    </Reference>
-    <Reference Include="System.Xml.Linq" />
-    <Reference Include="System.Data.DataSetExtensions" />
-    <Reference Include="Microsoft.CSharp" />
-    <Reference Include="System.Data" />
-    <Reference Include="System.Xml" />
-    <Reference Include="TidyNet">
-      <HintPath>..\packages\UmbracoCms.Core.7.1.2\lib\TidyNet.dll</HintPath>
-      <Private>False</Private>
-    </Reference>
-    <Reference Include="umbraco">
-      <HintPath>..\packages\UmbracoCms.Core.7.1.2\lib\umbraco.dll</HintPath>
-      <Private>False</Private>
-    </Reference>
-    <Reference Include="Umbraco.Core">
-      <HintPath>..\packages\UmbracoCms.Core.7.1.2\lib\Umbraco.Core.dll</HintPath>
-      <Private>False</Private>
-    </Reference>
-    <Reference Include="umbraco.DataLayer">
-      <HintPath>..\packages\UmbracoCms.Core.7.1.2\lib\umbraco.DataLayer.dll</HintPath>
-      <Private>False</Private>
-    </Reference>
-    <Reference Include="umbraco.editorControls">
-      <HintPath>..\packages\UmbracoCms.Core.7.1.2\lib\umbraco.editorControls.dll</HintPath>
-      <Private>False</Private>
-    </Reference>
-    <Reference Include="umbraco.MacroEngines">
-      <HintPath>..\packages\UmbracoCms.Core.7.1.2\lib\umbraco.MacroEngines.dll</HintPath>
-      <Private>False</Private>
-    </Reference>
-    <Reference Include="umbraco.providers">
-      <HintPath>..\packages\UmbracoCms.Core.7.1.2\lib\umbraco.providers.dll</HintPath>
-      <Private>False</Private>
-    </Reference>
-    <Reference Include="Umbraco.Web.UI">
-      <HintPath>..\packages\UmbracoCms.Core.7.1.2\lib\Umbraco.Web.UI.dll</HintPath>
-      <Private>False</Private>
-    </Reference>
-    <Reference Include="umbraco.XmlSerializers">
-      <HintPath>..\packages\UmbracoCms.Core.7.1.2\lib\umbraco.XmlSerializers.dll</HintPath>
-      <Private>False</Private>
-    </Reference>
-    <Reference Include="UmbracoExamine">
-      <HintPath>..\packages\UmbracoCms.Core.7.1.2\lib\UmbracoExamine.dll</HintPath>
-      <Private>False</Private>
-    </Reference>
-    <Reference Include="UrlRewritingNet.UrlRewriter">
-      <HintPath>..\packages\UmbracoCms.Core.7.1.2\lib\UrlRewritingNet.UrlRewriter.dll</HintPath>
-      <Private>False</Private>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <Compile Include="Application.cs" />
-    <Compile Include="Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="app.config" />
-    <None Include="packages.config" />
-  </ItemGroup>
-  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
-  <Import Project="$(SolutionDir)\.nuget\NuGet.targets" Condition="Exists('$(SolutionDir)\.nuget\NuGet.targets')" />
-  <Target Name="EnsureNuGetPackageBuildImports" BeforeTargets="PrepareForBuild">
-    <PropertyGroup>
-      <ErrorText>This project references NuGet package(s) that are missing on this computer. Enable NuGet Package Restore to download them.  For more information, see http://go.microsoft.com/fwlink/?LinkID=322105. The missing file is {0}.</ErrorText>
-    </PropertyGroup>
-    <Error Condition="!Exists('$(SolutionDir)\.nuget\NuGet.targets')" Text="$([System.String]::Format('$(ErrorText)', '$(SolutionDir)\.nuget\NuGet.targets'))" />
-  </Target>
-  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
-       Other similar extension points exist, see Microsoft.Common.targets.
-  <Target Name="BeforeBuild">
-  </Target>
-  <Target Name="AfterBuild">
-  </Target>
-  -->
-</Project>

app/Umbraco/DatabaseSizer/Properties/AssemblyInfo.cs

@@ -1,36 +0,0 @@
-using System.Reflection;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-
-// General Information about an assembly is controlled through the following 
-// set of attributes. Change these attribute values to modify the information
-// associated with an assembly.
-[assembly: AssemblyTitle("DatabaseSizer.cs")]
-[assembly: AssemblyDescription("")]
-[assembly: AssemblyConfiguration("")]
-[assembly: AssemblyCompany("")]
-[assembly: AssemblyProduct("DatabaseSizer.cs")]
-[assembly: AssemblyCopyright("Copyright ©  2014")]
-[assembly: AssemblyTrademark("")]
-[assembly: AssemblyCulture("")]
-
-// Setting ComVisible to false makes the types in this assembly not visible 
-// to COM components.  If you need to access a type in this assembly from 
-// COM, set the ComVisible attribute to true on that type.
-[assembly: ComVisible(false)]
-
-// The following GUID is for the ID of the typelib if this project is exposed to COM
-[assembly: Guid("28dc35d2-3dfb-40b4-9093-bc47c91127ea")]
-
-// Version information for an assembly consists of the following four values:
-//
-//      Major Version
-//      Minor Version 
-//      Build Number
-//      Revision
-//
-// You can specify all the values or you can default the Build and Revision Numbers 
-// by using the '*' as shown below:
-// [assembly: AssemblyVersion("1.0.*")]
-[assembly: AssemblyVersion("1.0.0.0")]
-[assembly: AssemblyFileVersion("1.0.0.0")]

app/Umbraco/DatabaseSizer/app.config

@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<configuration>
-  <runtime>
-    <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
-      <dependentAssembly>
-        <assemblyIdentity name="Newtonsoft.Json" publicKeyToken="30ad4fe6b2a6aeed" culture="neutral" />
-        <bindingRedirect oldVersion="0.0.0.0-6.0.0.0" newVersion="6.0.0.0" />
-      </dependentAssembly>
-      <dependentAssembly>
-        <assemblyIdentity name="System.Web.Mvc" publicKeyToken="31bf3856ad364e35" culture="neutral" />
-        <bindingRedirect oldVersion="0.0.0.0-4.0.0.0" newVersion="4.0.0.0" />
-      </dependentAssembly>
-      <dependentAssembly>
-        <assemblyIdentity name="System.Web.WebPages" publicKeyToken="31bf3856ad364e35" culture="neutral" />
-        <bindingRedirect oldVersion="0.0.0.0-2.0.0.0" newVersion="2.0.0.0" />
-      </dependentAssembly>
-      <dependentAssembly>
-        <assemblyIdentity name="System.Web.Helpers" publicKeyToken="31bf3856ad364e35" culture="neutral" />
-        <bindingRedirect oldVersion="0.0.0.0-2.0.0.0" newVersion="2.0.0.0" />
-      </dependentAssembly>
-      <dependentAssembly>
-        <assemblyIdentity name="System.Web.WebPages.Razor" publicKeyToken="31bf3856ad364e35" culture="neutral" />
-        <bindingRedirect oldVersion="0.0.0.0-2.0.0.0" newVersion="2.0.0.0" />
-      </dependentAssembly>
-    </assemblyBinding>
-  </runtime>
-</configuration>

app/Umbraco/DatabaseSizer/packages.config

@@ -1,25 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="AutoMapper" version="3.0.0" targetFramework="net45" />
-  <package id="ClientDependency" version="1.7.1.2" targetFramework="net45" />
-  <package id="ClientDependency-Mvc" version="1.7.0.4" targetFramework="net45" />
-  <package id="HtmlAgilityPack" version="1.4.6" targetFramework="net45" />
-  <package id="ImageProcessor" version="1.9.0.0" targetFramework="net45" />
-  <package id="ImageProcessor.Web" version="3.2.3.0" targetFramework="net45" />
-  <package id="Lucene.Net" version="2.9.4.1" targetFramework="net45" />
-  <package id="Microsoft.AspNet.Mvc" version="4.0.20710.0" targetFramework="net45" />
-  <package id="Microsoft.AspNet.Mvc.FixedDisplayModes" version="1.0.0" targetFramework="net45" />
-  <package id="Microsoft.AspNet.Razor" version="2.0.20710.0" targetFramework="net45" />
-  <package id="Microsoft.AspNet.WebApi" version="4.0.30506.0" targetFramework="net45" />
-  <package id="Microsoft.AspNet.WebApi.Client" version="4.0.30506.0" targetFramework="net45" />
-  <package id="Microsoft.AspNet.WebApi.Core" version="4.0.20710.0" targetFramework="net45" />
-  <package id="Microsoft.AspNet.WebApi.WebHost" version="4.0.20710.0" targetFramework="net45" />
-  <package id="Microsoft.AspNet.WebPages" version="2.0.20710.0" targetFramework="net45" />
-  <package id="Microsoft.Web.Infrastructure" version="1.0.0.0" targetFramework="net45" />
-  <package id="MiniProfiler" version="2.1.0" targetFramework="net45" />
-  <package id="MySql.Data" version="6.6.5" targetFramework="net45" />
-  <package id="Newtonsoft.Json" version="6.0.2" targetFramework="net45" />
-  <package id="SharpZipLib" version="0.86.0" targetFramework="net45" />
-  <package id="UmbracoCms.Core" version="7.1.2" targetFramework="net45" />
-  <package id="xmlrpcnet" version="2.5.0" targetFramework="net45" />
-</packages>

app/Umbraco/Umbraco.Archetype.sln

@@ -1,6 +1,8 @@
 
 Microsoft Visual Studio Solution File, Format Version 12.00
-# Visual Studio 2012
+# Visual Studio 2013
+VisualStudioVersion = 12.0.40629.0
+MinimumVisualStudioVersion = 10.0.40219.1
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Archetype.Umbraco", "Umbraco.Archetype\Archetype.Umbraco.csproj", "{7D185D41-4228-4978-ACB8-83F9A48AD94F}"
 EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = ".nuget", ".nuget", "{D84AA4ED-85A6-484F-9E72-BE7AC9835821}"
@@ -12,8 +14,6 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = ".nuget", ".nuget", "{D84AA4
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Archetype.Tests", "Archetype.Tests\Archetype.Tests.csproj", "{21F3E6CF-B76F-4059-9474-1AF1CE63CD6B}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "DatabaseSizer", "DatabaseSizer\DatabaseSizer.csproj", "{0114C963-C514-49C1-B7AB-DCB1825F498C}"
-EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Archetype.Courier", "Archetype.Courier\Archetype.Courier.csproj", "{FE8BE437-8B11-4E49-9B02-F45994E6D723}"
 EndProject
 Global
@@ -30,10 +30,6 @@ Global
 		{21F3E6CF-B76F-4059-9474-1AF1CE63CD6B}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{21F3E6CF-B76F-4059-9474-1AF1CE63CD6B}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{21F3E6CF-B76F-4059-9474-1AF1CE63CD6B}.Release|Any CPU.Build.0 = Release|Any CPU
-		{0114C963-C514-49C1-B7AB-DCB1825F498C}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{0114C963-C514-49C1-B7AB-DCB1825F498C}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{0114C963-C514-49C1-B7AB-DCB1825F498C}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{0114C963-C514-49C1-B7AB-DCB1825F498C}.Release|Any CPU.Build.0 = Release|Any CPU
 		{FE8BE437-8B11-4E49-9B02-F45994E6D723}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
 		{FE8BE437-8B11-4E49-9B02-F45994E6D723}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{FE8BE437-8B11-4E49-9B02-F45994E6D723}.Release|Any CPU.ActiveCfg = Release|Any CPU

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

@@ -1,33 +1,48 @@
 using System.Collections.Generic;
 using System;
+using System.Diagnostics;
 using System.Linq;
 using System.Net;
+using System.Reflection;
 using System.Web.Http;
 using AutoMapper;
 using Umbraco.Core.Models;
 using Umbraco.Web.Models.ContentEditing;
 using Umbraco.Web.Mvc;
 using Umbraco.Web.Editors;
+using Archetype.Extensions;
 
 namespace Archetype.Api
 {
+    /// <summary>
+    /// Controller that handles datatype related interactions.
+    /// </summary>
     [PluginController("ArchetypeApi")]
     public class ArchetypeDataTypeController : UmbracoAuthorizedJsonController
     {
-
         public IEnumerable<object> GetAllPropertyEditors()
         {
             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});
         }
 
+        /// <summary>
+        /// Gets all datatypes.
+        /// </summary>
+        /// <returns></returns>
         public object GetAll() 
         {
             var dataTypes = Services.DataTypeService.GetAllDataTypeDefinitions();
             return dataTypes.Select(t => new { guid = t.Key, name = t.Name });
         }
 
+        /// <summary>
+        /// Gets the datatype by GUID.
+        /// </summary>
+        /// <param name="guid">The unique identifier.</param>
+        /// <returns></returns>
+        /// <exception cref="System.Web.Http.HttpResponseException"></exception>
         public object GetByGuid(Guid guid)
         {
             var dataType = Services.DataTypeService.GetDataTypeDefinitionById(guid);
@@ -35,10 +50,21 @@ namespace Archetype.Api
             {
                 throw new HttpResponseException(HttpStatusCode.NotFound);
             }
+
             var dataTypeDisplay = Mapper.Map<IDataTypeDefinition, DataTypeDisplay>(dataType);
             return new { selectedEditor = dataTypeDisplay.SelectedEditor, preValues = dataTypeDisplay.PreValues };
         }
 
+        /// <summary>
+        /// Gets the datatype by GUID.
+        /// </summary>
+        /// <param name="guid">The unique identifier.</param>
+        /// <param name="contentTypeAlias">The content type alias.</param>
+        /// <param name="propertyTypeAlias">The property type alias.</param>
+        /// <param name="archetypeAlias">The archetype alias.</param>
+        /// <param name="nodeId">The node identifier.</param>
+        /// <returns></returns>
+        /// <exception cref="System.Web.Http.HttpResponseException"></exception>
         public object GetByGuid(Guid guid, string contentTypeAlias, string propertyTypeAlias, string archetypeAlias, int nodeId)
         {
             var dataType = Services.DataTypeService.GetDataTypeDefinitionById(guid);
@@ -49,5 +75,26 @@ namespace Archetype.Api
             var dataTypeDisplay = Mapper.Map<IDataTypeDefinition, DataTypeDisplay>(dataType);
             return new { selectedEditor = dataTypeDisplay.SelectedEditor, preValues = dataTypeDisplay.PreValues, contentTypeAlias = contentTypeAlias, propertyTypeAlias = propertyTypeAlias, archetypeAlias = archetypeAlias, nodeId = nodeId };
         }
+
+        /// <summary>
+        /// Returns the DLL version from the file.
+        /// </summary>
+        /// <returns></returns>
+        public object GetDllVersion()
+        {
+            return new {dllVersion = _version()};
+        }
+
+        /// <summary>
+        /// Gets the DLL version from the file.
+        /// </summary>
+        /// <returns></returns>
+        private string _version()
+        {
+            var asm = Assembly.GetExecutingAssembly();
+            var fvi = FileVersionInfo.GetVersionInfo(asm.Location);
+
+            return fvi.FileVersion;
+        }
     }
 }

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

@@ -231,20 +231,29 @@
     <Compile Include="Api\ArchetypeDataTypeController.cs" />
     <Compile Include="Constants.cs" />
     <Compile Include="Events\ExpireCache.cs" />
+    <Compile Include="Extensions\ArchetypeFieldsetModelExtensions.cs" />
     <Compile Include="Extensions\ArchetypeHelper.cs" />
+    <Compile Include="Extensions\ArchetypeModelExtensions.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" />
     <Compile Include="Models\ArchetypePreValueFieldset.cs" />
+    <Compile Include="Models\ArchetypePreValueFieldsetGroup.cs" />
     <Compile Include="Models\ArchetypePreValueProperty.cs" />
     <Compile Include="Models\ArchetypeFieldsetModel.cs" />
     <Compile Include="Models\ArchetypePropertyModel.cs" />
+    <Compile Include="Models\ArchetypePublishedContent.cs" />
+    <Compile Include="Models\ArchetypePublishedContentSet.cs" />
+    <Compile Include="Models\ArchetypePublishedProperty.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="Properties\VersionInfo.cs" />
     <Compile Include="PropertyConverters\ArchetypeValueConverter.cs" />
     <Compile Include="PropertyEditors\ArchetypePropertyEditor.cs" />
+    <Compile Include="TypeConverters\ArchetypeFieldsetModelConverter.cs" />
+    <Compile Include="TypeConverters\ArchetypeModelConverter.cs" />
   </ItemGroup>
   <ItemGroup>
     <None Include="app.config" />

app/Umbraco/Umbraco.Archetype/Constants.cs

@@ -1,5 +1,8 @@
 namespace Archetype
 {
+    /// <summary>
+    /// Archetype constants.
+    /// </summary>
     public static class Constants
     {
         public const string PropertyEditorAlias = "Imulus.Archetype";

app/Umbraco/Umbraco.Archetype/Events/ExpireCache.cs

@@ -1,18 +1,16 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using Umbraco.Core;
+using Umbraco.Core;
 using Umbraco.Core.Models;
 using Umbraco.Core.Services;
-using Umbraco.Web;
 
 namespace Archetype.Events
 {
     public class ExpireCache : ApplicationEventHandler
     {
-
+        /// <summary>
+        /// Registers our ExpirePreValueCache handler on app starting.
+        /// </summary>
+        /// <param name="umbracoApplication"></param>
+        /// <param name="applicationContext"></param>
         protected override void ApplicationStarting(UmbracoApplicationBase umbracoApplication, ApplicationContext applicationContext)
         {
             base.ApplicationStarting(umbracoApplication, applicationContext);
@@ -20,6 +18,11 @@ namespace Archetype.Events
             DataTypeService.Saved += ExpirePreValueCache;
         }
 
+        /// <summary>
+        /// Expires the pre value cache when a datatype is saved.
+        /// </summary>
+        /// <param name="sender">The sender.</param>
+        /// <param name="e">The <see cref="Umbraco.Core.Events.SaveEventArgs{IDataTypeDefinition}"/> instance containing the event data.</param>
         void ExpirePreValueCache(IDataTypeService sender, global::Umbraco.Core.Events.SaveEventArgs<IDataTypeDefinition> e)
         {
             foreach (var dataType in e.SavedEntities)

app/Umbraco/Umbraco.Archetype/Extensions/ArchetypeFieldsetModelExtensions.cs

@@ -0,0 +1,25 @@
+using System.Linq;
+using Archetype.Models;
+using Umbraco.Core.Models;
+
+namespace Archetype.Extensions
+{
+    public static class ArchetypeFieldsetModelExtensions
+    {
+        public static IPublishedContent ToPublishedContent(this ArchetypeFieldsetModel fieldset)
+        {
+            return new ArchetypePublishedContent(fieldset);
+        }
+
+        public static IPublishedContent ToPublishedContent(this ArchetypeFieldsetModel fieldset, ArchetypeModel archetype)
+        {
+            var contentSet = archetype.ToPublishedContentSet();
+
+            var first = contentSet
+                .Cast<ArchetypePublishedContent>()
+                .FirstOrDefault(x => x.ArchetypeFieldset == fieldset);
+
+            return first ?? new ArchetypePublishedContent(fieldset);
+        }
+    }
+}

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

@@ -3,11 +3,15 @@ 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;
 
 namespace Archetype.Extensions
 {
+    /// <summary>
+    /// Helper class that handles several Archetype related interactions.
+    /// </summary>
     public class ArchetypeHelper
     {
         protected JsonSerializerSettings _jsonSettings;
@@ -17,6 +21,9 @@ namespace Archetype.Extensions
 
         internal static ArchetypeHelper Instance { get { return _instance; } }
 
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ArchetypeHelper"/> class.
+        /// </summary>
         internal ArchetypeHelper()
         {
             var dcr = new Newtonsoft.Json.Serialization.DefaultContractResolver();
@@ -26,6 +33,20 @@ namespace Archetype.Extensions
             _app = ApplicationContext.Current;
         }
 
+        /// <summary>
+        /// Gets the json serializer settings.
+        /// </summary>
+        /// <value>
+        /// The json serializer settings.
+        /// </value>
+        internal JsonSerializerSettings JsonSerializerSettings { get { return _jsonSettings; } }
+
+        /// <summary>
+        /// Deserializes the JSON to archetype.
+        /// </summary>
+        /// <param name="sourceJson">The source JSON.</param>
+        /// <param name="dataTypePreValues">The data type pre values.</param>
+        /// <returns></returns>
         internal ArchetypeModel DeserializeJsonToArchetype(string sourceJson, PreValueCollection dataTypePreValues)
         {
             try
@@ -40,6 +61,7 @@ namespace Archetype.Extensions
                 }
                 catch (Exception ex)
                 {
+                    LogHelper.Error<ArchetypeHelper>("DeserializeJsonToArchetype", ex);
                 }
 
                 return archetype;
@@ -50,6 +72,13 @@ namespace Archetype.Extensions
             }
         }
 
+        /// <summary>
+        /// Deserializes the JSON to archetype.
+        /// </summary>
+        /// <param name="sourceJson">The source JSON.</param>
+        /// <param name="dataTypeId">The data type identifier.</param>
+        /// <param name="hostContentType">Type of the host content.</param>
+        /// <returns></returns>
         internal ArchetypeModel DeserializeJsonToArchetype(string sourceJson, int dataTypeId, PublishedContentType hostContentType = null)
         {
             try
@@ -64,16 +93,22 @@ namespace Archetype.Extensions
                 }
                 catch (Exception ex)
                 {
+                    LogHelper.Error<ArchetypeHelper>(string.Format("DeserializeJsonToArchetype Error DatatypeId=>{0} SourceJson=>{1}", dataTypeId, sourceJson), ex);
                 }
 
                 return archetype;
             }
-            catch
+            catch (Exception ex)
             {
                 return new ArchetypeModel();
             }
         }
 
+        /// <summary>
+        /// Determines whether datatypeId has had it's PVC overridden.
+        /// </summary>
+        /// <param name="dataTypeId">The data type identifier.</param>
+        /// <returns></returns>
         internal bool IsPropertyValueConverterOverridden(int dataTypeId)
         {
             var prevalues = GetArchetypePreValueFromDataTypeId(dataTypeId);
@@ -83,6 +118,11 @@ namespace Archetype.Extensions
             return prevalues.OverrideDefaultPropertyValueConverter;
         }
 
+        /// <summary>
+        /// Gets the archetype pre value from data type identifier.
+        /// </summary>
+        /// <param name="dataTypeId">The data type identifier.</param>
+        /// <returns></returns>
         private ArchetypePreValue GetArchetypePreValueFromDataTypeId(int dataTypeId)
         {
             return _app.ApplicationCache.RuntimeCache.GetCacheItem(
@@ -103,6 +143,11 @@ namespace Archetype.Extensions
                 }) as ArchetypePreValue;
         }
 
+        /// <summary>
+        /// Gets the archetype pre value from pre values collection.
+        /// </summary>
+        /// <param name="dataTypePreValues">The data type pre values.</param>
+        /// <returns></returns>
         private ArchetypePreValue GetArchetypePreValueFromPreValuesCollection(PreValueCollection dataTypePreValues)
         {
             var preValueAsString = dataTypePreValues.PreValuesAsDictionary.First().Value.Value;
@@ -110,7 +155,12 @@ namespace Archetype.Extensions
             return preValue;
         }
 
-        private IDataTypeDefinition GetDataTypeByGuid(Guid guid)
+        /// <summary>
+        /// Gets the data type by unique identifier.
+        /// </summary>
+        /// <param name="guid">The unique identifier.</param>
+        /// <returns></returns>
+        internal IDataTypeDefinition GetDataTypeByGuid(Guid guid)
         {
             return (IDataTypeDefinition)ApplicationContext.Current.ApplicationCache.RuntimeCache.GetCacheItem(
                 Constants.CacheKey_DataTypeByGuid + guid,

app/Umbraco/Umbraco.Archetype/Extensions/ArchetypeModelExtensions.cs

@@ -0,0 +1,14 @@
+using System.Collections.Generic;
+using Archetype.Models;
+using Umbraco.Core.Models;
+
+namespace Archetype.Extensions
+{
+    public static class ArchetypeModelExtensions
+    {
+        public static IEnumerable<IPublishedContent> ToPublishedContentSet(this ArchetypeModel archetype)
+        {
+            return new ArchetypePublishedContentSet(archetype);
+        }
+    }
+}

app/Umbraco/Umbraco.Archetype/Extensions/ArchetypePropertyModelExtensions.cs

@@ -2,18 +2,37 @@ using Archetype.Models;
 using Umbraco.Core;
 using Umbraco.Core.Models;
 using Umbraco.Core.Models.PublishedContent;
+using Umbraco.Core.PropertyEditors;
 
 namespace Archetype.Extensions
 {
+    /// <summary>
+    /// ArchetypePropertyModel extensions.
+    /// </summary>
     public static class ArchetypePropertyModelExtensions
     {
+        /// <summary>
+        /// Determines whether this instance is an archetype.
+        /// </summary>
+        /// <param name="prop">The property.</param>
+        /// <returns></returns>
         public static bool IsArchetype(this ArchetypePropertyModel prop)
         {
             return prop.PropertyEditorAlias.InvariantEquals(Constants.PropertyEditorAlias);
         }
 
+        /// <summary>
+        /// Creates dummy property type.
+        /// </summary>
+        /// <param name="prop">The property.</param>
+        /// <returns></returns>
         internal static PublishedPropertyType CreateDummyPropertyType(this ArchetypePropertyModel prop)
         {
+            // We need to check if `PropertyValueConvertersResolver` exists,
+            // otherwise `PublishedPropertyType` will throw an exception outside of the Umbraco context.; e.g. unit-tests.
+            if (!PropertyValueConvertersResolver.HasCurrent)
+                return null;
+
             return new PublishedPropertyType(prop.HostContentType, new PropertyType(new DataTypeDefinition(-1, prop.PropertyEditorAlias) { Id = prop.DataTypeId }));
         }
     }

app/Umbraco/Umbraco.Archetype/Extensions/HtmlHelperExtensions.cs

@@ -7,60 +7,154 @@ using Umbraco.Core.Logging;
 
 namespace Archetype.Extensions
 {
+    /// <summary>
+    /// HtmlHelper extenions used for rendering an Archetype.
+    /// </summary>
     public static class HtmlHelperExtensions
     {
-        public static IHtmlString RenderArchetypePartials(this HtmlHelper htmlHelper, ArchetypeModel archetypeModel)
+        /// <summary>
+        /// Renders the partials based on the model, partial path and given viewdata dictionary.
+        /// </summary>
+        /// <param name="htmlHelper">The HTML helper.</param>
+        /// <param name="archetypeModel">The archetype model.</param>
+        /// <param name="partialPath">The partial path.</param>
+        /// <param name="viewDataDictionary">The view data dictionary.</param>
+        /// <returns></returns>
+        private static IHtmlString _renderPartials(this HtmlHelper htmlHelper, ArchetypeModel archetypeModel, string partialPath, ViewDataDictionary viewDataDictionary)
         {
-            return RenderPartials(htmlHelper, archetypeModel, null, null);
+            var sb = new StringBuilder();
+
+            foreach (var fieldsetModel in archetypeModel)
+            {
+                sb.AppendLine(_renderPartial(htmlHelper, fieldsetModel, partialPath, viewDataDictionary).ToString());
+            }
+
+            return new HtmlString(sb.ToString());
         }
 
-        public static IHtmlString RenderArchetypePartials(this HtmlHelper htmlHelper, ArchetypeModel archetypeModel, string partialPath)
-        {
-            return RenderPartials(htmlHelper, archetypeModel, partialPath, null);
-        }
-
-        public static IHtmlString RenderArchetypePartials(this HtmlHelper htmlHelper, ArchetypeModel archetypeModel, ViewDataDictionary viewDataDictionary)
-        {
-            return RenderPartials(htmlHelper, archetypeModel, null, viewDataDictionary);
-        }
-
-        public static IHtmlString RenderArchetypePartials(this HtmlHelper htmlHelper, ArchetypeModel archetypeModel, string partialPath, ViewDataDictionary viewDataDictionary)
-        {
-            return htmlHelper.RenderPartials(archetypeModel, partialPath, viewDataDictionary);
-        }
-
-        private static IHtmlString RenderPartials(this HtmlHelper htmlHelper, ArchetypeModel archetypeModel, string partialPath, ViewDataDictionary viewDataDictionary)
+        /// <summary>
+        /// Renders the fieldset partial
+        /// </summary>
+        /// <param name="htmlHelper">The HTML helper.</param>
+        /// <param name="fieldsetModel"></param>
+        /// <param name="partialPath">The partial path.</param>
+        /// <param name="viewDataDictionary">The view data dictionary.</param>
+        /// <returns></returns>
+        private static IHtmlString _renderPartial(HtmlHelper htmlHelper, ArchetypeFieldsetModel fieldsetModel, string partialPath, ViewDataDictionary viewDataDictionary)
         {
             var context = HttpContext.Current;
 
-            if (archetypeModel == null || context == null)
+            if (fieldsetModel == null || context == null)
             {
                 return new HtmlString("");
             }
 
             var sb = new StringBuilder();
 
+            //default
             var pathToPartials = "~/Views/Partials/Archetype/";
+
             if (!string.IsNullOrEmpty(partialPath))
             {
                 pathToPartials = partialPath;
             }
 
-            foreach (var fieldsetModel in archetypeModel)
-            {
-                var partial = pathToPartials + fieldsetModel.Alias + ".cshtml";
+            var partial = string.Format("{0}{1}.cshtml", pathToPartials, fieldsetModel.Alias);
 
-                if (System.IO.File.Exists(context.Server.MapPath(partial)))
-                {
-                    sb.AppendLine(htmlHelper.Partial(partial, fieldsetModel, viewDataDictionary).ToString());
-                }
-                else
-                {
-                    LogHelper.Info<ArchetypeModel>(string.Format("The partial for {0} could not be found.  Please create a partial with that name or rename your alias.", context.Server.MapPath(partial)));
-                }
+            if (System.IO.File.Exists(context.Server.MapPath(partial)))
+            {
+                sb.AppendLine(htmlHelper.Partial(partial, fieldsetModel, viewDataDictionary).ToString());
+            }
+            else
+            {
+                LogHelper.Info<ArchetypeModel>(string.Format("The partial for {0} could not be found.  Please create a partial with that name or rename your alias.", context.Server.MapPath(partial)));
             }
 
             return new HtmlString(sb.ToString());
         }
+
+        /// <summary>
+        /// Renders a single archtype partial from a fieldset
+        /// </summary>
+        /// <param name="htmlHelper">The HTML helper.</param>
+        /// <param name="fieldsetModel">The fieldset model.</param>
+        /// <returns></returns>
+        public static IHtmlString RenderArchetypePartial(this HtmlHelper htmlHelper, ArchetypeFieldsetModel fieldsetModel)
+        {
+            return _renderPartial(htmlHelper, fieldsetModel, null, null);
+        }
+
+        /// <summary>
+        /// Renders the archetype partial.
+        /// </summary>
+        /// <param name="htmlHelper">The HTML helper.</param>
+        /// <param name="fieldsetModel">The fieldset model.</param>
+        /// <param name="partialView">The partial view.</param>
+        /// <returns></returns>
+        public static IHtmlString RenderArchetypePartial(this HtmlHelper htmlHelper, ArchetypeFieldsetModel fieldsetModel, string partialView)
+        {
+            return _renderPartial(htmlHelper, fieldsetModel, partialView, null);
+        }
+
+        /// <summary>
+        /// Renders the archetype partial.
+        /// </summary>
+        /// <param name="htmlHelper">The HTML helper.</param>
+        /// <param name="fieldsetModel">The fieldset model.</param>
+        /// <param name="partialView">The partial view.</param>
+        /// <param name="viewDataDictionary">The view data dictionary.</param>
+        /// <returns></returns>
+        public static IHtmlString RenderArchetypePartial(this HtmlHelper htmlHelper, ArchetypeFieldsetModel fieldsetModel, string partialView, ViewDataDictionary viewDataDictionary)
+        {
+            return _renderPartial(htmlHelper, fieldsetModel, partialView, viewDataDictionary);
+        }
+
+        /// <summary>
+        /// Renders the archetype partials.
+        /// </summary>
+        /// <param name="htmlHelper">The HTML helper.</param>
+        /// <param name="archetypeModel">The archetype model.</param>
+        /// <returns></returns>
+        public static IHtmlString RenderArchetypePartials(this HtmlHelper htmlHelper, ArchetypeModel archetypeModel)
+        {
+            return _renderPartials(htmlHelper, archetypeModel, null, null);
+        }
+
+        /// <summary>
+        /// Renders the archetype partials.
+        /// </summary>
+        /// <param name="htmlHelper">The HTML helper.</param>
+        /// <param name="archetypeModel">The archetype model.</param>
+        /// <param name="partialPath">The partial path.</param>
+        /// <returns></returns>
+        public static IHtmlString RenderArchetypePartials(this HtmlHelper htmlHelper, ArchetypeModel archetypeModel, string partialPath)
+        {
+            return _renderPartials(htmlHelper, archetypeModel, partialPath, null);
+        }
+
+        /// <summary>
+        /// Renders the archetype partials.
+        /// </summary>
+        /// <param name="htmlHelper">The HTML helper.</param>
+        /// <param name="archetypeModel">The archetype model.</param>
+        /// <param name="viewDataDictionary">The view data dictionary.</param>
+        /// <returns></returns>
+        public static IHtmlString RenderArchetypePartials(this HtmlHelper htmlHelper, ArchetypeModel archetypeModel, ViewDataDictionary viewDataDictionary)
+        {
+            return _renderPartials(htmlHelper, archetypeModel, null, viewDataDictionary);
+        }
+
+        /// <summary>
+        /// Renders the archetype partials.
+        /// </summary>
+        /// <param name="htmlHelper">The HTML helper.</param>
+        /// <param name="archetypeModel">The archetype model.</param>
+        /// <param name="partialPath">The partial path.</param>
+        /// <param name="viewDataDictionary">The view data dictionary.</param>
+        /// <returns></returns>
+        public static IHtmlString RenderArchetypePartials(this HtmlHelper htmlHelper, ArchetypeModel archetypeModel, string partialPath, ViewDataDictionary viewDataDictionary)
+        {
+            return htmlHelper._renderPartials(archetypeModel, partialPath, viewDataDictionary);
+        }
     }
 }

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

@@ -0,0 +1,61 @@
+using System.Collections.Generic;
+using System.Linq;
+using Newtonsoft.Json;
+using Umbraco.Core.PropertyEditors;
+
+namespace Archetype.Extensions
+{
+    /// <summary>
+    /// PropertyEditor extensions.
+    /// </summary>
+	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/Extensions/StringExtensions.cs

@@ -1,8 +1,15 @@
 namespace Archetype.Extensions
 {
+    /// <summary>
+    /// String extensions.
+    /// </summary>
     public static class StringExtensions
     {
-        //lifted from the core as it is marked 'internal'
+        /// <summary>
+        /// Detects if the input string is JSON.
+        /// </summary>
+        /// <param name="input">The input.</param>
+        /// <returns></returns>
         public static bool DetectIsJson(this string input)
         {
             input = input.Trim();

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

@@ -1,10 +1,18 @@
+using System;
 using System.Collections.Generic;
+using System.ComponentModel;
 using System.Linq;
+using System.Web.Security;
+using Archetype.TypeConverters;
 using Newtonsoft.Json;
 using Umbraco.Core;
 
 namespace Archetype.Models
 {
+    /// <summary>
+    /// Model that represents a fieldset stored as content JSON.
+    /// </summary>
+    [TypeConverter(typeof(ArchetypeFieldsetModelConverter))]
     public class ArchetypeFieldsetModel
     {
         [JsonProperty("alias")]
@@ -16,6 +24,21 @@ namespace Archetype.Models
         [JsonProperty("properties")]
         public IEnumerable<ArchetypePropertyModel> Properties;
 
+        [JsonProperty("id")]
+        public Guid Id { get; set; }
+
+        [JsonProperty("releaseDate")]
+        public DateTime? ReleaseDate { get; set; }
+
+        [JsonProperty("expireDate")]
+        public DateTime? ExpireDate { get; set; }
+
+        [JsonProperty("allowedMemberGroups")]
+        public string AllowedMemberGroups { get; set; }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ArchetypeFieldsetModel"/> class.
+        /// </summary>
         public ArchetypeFieldsetModel()
         {
             Properties = new List<ArchetypePropertyModel>();
@@ -23,16 +46,27 @@ namespace Archetype.Models
 
         #region Helper Methods
 
+        /// <summary>
+        /// Gets the value and returns as string.
+        /// </summary>
+        /// <param name="propertyAlias">The property alias.</param>
+        /// <returns></returns>
         public string GetValue(string propertyAlias)
         {
             return GetValue<string>(propertyAlias);
         }
 
+        /// <summary>
+        /// Gets the value based on the type passed in as a generic.
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="propertyAlias">The property alias.</param>
+        /// <returns></returns>
         public T GetValue<T>(string propertyAlias)
         {
             var property = GetProperty(propertyAlias);
 
-            if (IsEmptyProperty(property)) 
+            if (IsEmptyProperty(property))
             {
                 return default(T);
             }
@@ -45,11 +79,18 @@ namespace Archetype.Models
         // however, this would require GetValue<T>(string propertyAlias) to call the common implementation
         // with a default(T) value, which could in theory result in a performance hit, if T for some reason
         // is costly to instantiate.
+        /// <summary>
+        /// Gets the value.
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="propertyAlias">The property alias.</param>
+        /// <param name="defaultValue">The default value.</param>
+        /// <returns></returns>
         public T GetValue<T>(string propertyAlias, T defaultValue)
         {
             var property = GetProperty(propertyAlias);
 
-            if (IsEmptyProperty(property)) 
+            if (IsEmptyProperty(property))
             {
                 return defaultValue;
             }
@@ -57,16 +98,31 @@ namespace Archetype.Models
             return property.GetValue<T>();
         }
 
-        private bool IsEmptyProperty(ArchetypePropertyModel property) 
+        /// <summary>
+        /// Determines whether the property is empty.
+        /// </summary>
+        /// <param name="property">The property.</param>
+        /// <returns></returns>
+        private bool IsEmptyProperty(ArchetypePropertyModel property)
         {
             return (property == null || property.Value == null || string.IsNullOrEmpty(property.Value.ToString()));
         }
 
+        /// <summary>
+        /// Determines whether the specified property alias has property.
+        /// </summary>
+        /// <param name="propertyAlias">The property alias.</param>
+        /// <returns></returns>
         public bool HasProperty(string propertyAlias)
         {
             return GetProperty(propertyAlias) != null;
         }
 
+        /// <summary>
+        /// Determines whether the specified property alias has value.
+        /// </summary>
+        /// <param name="propertyAlias">The property alias.</param>
+        /// <returns></returns>
         public bool HasValue(string propertyAlias)
         {
             var property = GetProperty(propertyAlias);
@@ -76,12 +132,42 @@ namespace Archetype.Models
             return !string.IsNullOrEmpty(property.Value.ToString());
         }
 
+        /// <summary>
+        /// Gets the property.
+        /// </summary>
+        /// <param name="propertyAlias">The property alias.</param>
+        /// <returns></returns>
         private ArchetypePropertyModel GetProperty(string propertyAlias)
         {
             return Properties.FirstOrDefault(p => p.Alias.InvariantEquals(propertyAlias));
         }
 
-        #endregion
+        /// <summary>
+        /// Is this fieldset disabled, either explicitly or by other means?
+        /// </summary>
+        /// <returns>true if this fieldset is disabled, false otherwise</returns>
+        internal bool IsAvailable()
+        {
+            // explicitly disabled or implicitly disabled through publishing?
+            var disabled = Disabled
+                   || (ReleaseDate.HasValue && ReleaseDate > DateTime.UtcNow)
+                   || (ExpireDate.HasValue && DateTime.UtcNow > ExpireDate);
+            if (disabled)
+            {
+                // yes - the fieldset is not available
+                return false;
+            }
+            // limitation on member group access?
+            if (string.IsNullOrEmpty(AllowedMemberGroups))
+            {
+                // no - the fieldset is available
+                return true;
+            }
+            // maybe - the fieldset is available if the current member is a member of the configured member groups
+            var currentUserGroups = Roles.GetRolesForUser() ?? new string[0];
+            return currentUserGroups.ContainsAny(AllowedMemberGroups.Split(','));
+        }
 
+        #endregion
     }
-}
+}

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

@@ -1,44 +1,65 @@
 using System;
 using System.Collections;
 using System.Collections.Generic;
-using System.Linq;
+using System.ComponentModel;
+using System.Linq;
+using Archetype.TypeConverters;
 using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
 
 namespace Archetype.Models
 {
+    /// <summary>
+    /// Model that represents an entire Archetype.
+    /// </summary>
     [JsonObject]
+    [TypeConverter(typeof(ArchetypeModelConverter))]
     public class ArchetypeModel : IEnumerable<ArchetypeFieldsetModel>
     {
         [JsonProperty("fieldsets")]
         public IEnumerable<ArchetypeFieldsetModel> Fieldsets { get; set; }
 
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ArchetypeModel"/> class.
+        /// </summary>
         public ArchetypeModel()
         {
             Fieldsets = new List<ArchetypeFieldsetModel>();
         }
 
+        /// <summary>
+        /// Returns an enumerator that iterates through the collection of fieldsets.
+        /// </summary>
+        /// <returns>
+        /// An enumerator that can be used to iterate through the collection.
+        /// </returns>
         public IEnumerator<ArchetypeFieldsetModel> GetEnumerator()
         {
-            return this.Fieldsets.Where(f => f.Disabled == false).GetEnumerator();
+            return this.Fieldsets.Where(f => f.IsAvailable()).GetEnumerator();
         }
 
+        //possibly obsolete?
         IEnumerator IEnumerable.GetEnumerator()
         {
             return this.GetEnumerator();
         }
 
+        /// <summary>
+        /// Serializes for persistence. This should be used for serialization as it cleans up the JSON before saving.
+        /// </summary>
+        /// <returns></returns>
         public string SerializeForPersistence()
         {
             var json = JObject.Parse(JsonConvert.SerializeObject(this, new JsonSerializerSettings() { ReferenceLoopHandling = ReferenceLoopHandling.Ignore }));
-            var propertiesToRemove = new String[] { "propertyEditorAlias", "dataTypeId", "dataTypeGuid", "hostContentType" };
+
+            var propertiesToRemove = new String[] { "propertyEditorAlias", "dataTypeId", "dataTypeGuid", "hostContentType", "editorState" };
 
             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/ArchetypePreValue.cs

@@ -1,8 +1,12 @@
-using System.Collections.Generic;
+using System;
+using System.Collections.Generic;
 using Newtonsoft.Json;
 
 namespace Archetype.Models
 {
+    /// <summary>
+    /// Model that represents the configured Archetype options.
+    /// </summary>
     public class ArchetypePreValue
     {
         [JsonProperty("showAdvancedOptions")]
@@ -12,6 +16,7 @@ namespace Archetype.Models
         public bool StartWithAddButton { get; set; }
 
         [JsonProperty("hideFieldsetToolbar")]
+        [Obsolete("This value is no longer used but is kept to prevent breaking changes.")]
         public bool HideFieldsetToolbar { get; set; }
 
         [JsonProperty("enableMultipleFieldsets")]
@@ -20,21 +25,42 @@ namespace Archetype.Models
         [JsonProperty("enableCollapsing")]
         public bool EnableCollapsing { get; set; }
 
+        [JsonProperty("enableMultipleOpen")]
+        public bool EnableMultipleOpen { get; set; }
+
+        [JsonProperty("enableCloning")]
+        public bool EnableCloning { get; set; }
+
         [JsonProperty("enableDisabling")]
         public bool EnableDisabling { get; set; }
 
+        [JsonProperty("enablePublishing")]
+        public bool EnablePublishing { get; set; }
+
+        [JsonProperty("enableCrossDragging")]
+        public bool EnableCrossDragging { get; set; }
+        
+        [JsonProperty("enableMemberGroups")]
+        public bool EnableMemberGroups { get; set; }
+
         [JsonProperty("hideFieldsetControls")]
         public bool HideFieldsetControls { get; set; }
 
         [JsonProperty("hidePropertyLabel")]
         public bool HidePropertyLabel { get; set; }
 
+        [JsonProperty("minFieldsets", NullValueHandling = NullValueHandling.Ignore)]
+        public int MinFieldsets { get; set; }
+
         [JsonProperty("maxFieldsets", NullValueHandling = NullValueHandling.Ignore)]
         public int MaxFieldsets { get; set; }
 
         [JsonProperty("fieldsets")]
         public IEnumerable<ArchetypePreValueFieldset> Fieldsets { get; set; }
 
+        [JsonProperty("fieldsetGroups")]
+        public IEnumerable<ArchetypePreValueFieldsetGroup> FieldsetGroups { get; set; }
+
         [JsonProperty("hidePropertyLabels")]
         public bool HidePropertyLabels { get; set; }
 

app/Umbraco/Umbraco.Archetype/Models/ArchetypePreValueFieldset.cs

@@ -3,6 +3,9 @@ using Newtonsoft.Json;
 
 namespace Archetype.Models
 {
+    /// <summary>
+    /// Model that represents configured Archetype fieldsets.
+    /// </summary>
     public class ArchetypePreValueFieldset
     {
         [JsonProperty("alias")]
@@ -23,7 +26,13 @@ namespace Archetype.Models
         [JsonProperty("label")]
         public string Label { get; set; }
 
+        [JsonProperty("previewImage")]
+        public string PreviewImage { get; set; }
+
         [JsonProperty("properties")]
         public IEnumerable<ArchetypePreValueProperty> Properties { get; set; }
+
+        [JsonProperty("group")]
+        public ArchetypePreValueFieldsetGroup Group { get; set; }
     }
 }

app/Umbraco/Umbraco.Archetype/Models/ArchetypePreValueFieldsetGroup.cs

@@ -0,0 +1,13 @@
+using Newtonsoft.Json;
+
+namespace Archetype.Models
+{
+    /// <summary>
+    /// Model that represents configured groupings of Archetype fieldsets.
+    /// </summary>
+    public class ArchetypePreValueFieldsetGroup
+    {
+        [JsonProperty("name")]
+        public string Name { get; set; }
+    }
+}

app/Umbraco/Umbraco.Archetype/Models/ArchetypePreValueProperty.cs

@@ -3,6 +3,9 @@ using Newtonsoft.Json;
 
 namespace Archetype.Models
 {
+    /// <summary>
+    /// Model that represents a configured property on an Archetype fieldset.
+    /// </summary>
     public class ArchetypePreValueProperty
     {
         [JsonProperty("alias")]

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

@@ -9,6 +9,9 @@ using Umbraco.Web;
 
 namespace Archetype.Models
 {
+    /// <summary>
+    /// Model that represents a stored property in Archetype.
+    /// </summary>
     public class ArchetypePropertyModel
     {
         [JsonProperty("alias")]
@@ -26,15 +29,23 @@ 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; }
 
+        /// <summary>
+        /// Gets the value based on the type given.
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <returns></returns>
         public T GetValue<T>()
         {
-
             // 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)
@@ -53,6 +64,13 @@ namespace Archetype.Models
             return default(T);
         }
 
+        /// <summary>
+        /// Tries to convert the value with property value converters.
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="value">The value.</param>
+        /// <param name="converters">The converters.</param>
+        /// <returns></returns>
         private Attempt<T> TryConvertWithPropertyValueConverters<T>(object value, IEnumerable<IPropertyValueConverter> converters)
         {
             var properyType = this.CreateDummyPropertyType();
@@ -88,5 +106,15 @@ namespace Archetype.Models
 
             return Attempt<T>.Fail();
         }
+
+        /// <summary>
+        /// Model that represents the current UmbracoEditorState
+        /// </summary>
+        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/Models/ArchetypePublishedContent.cs

@@ -0,0 +1,186 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Umbraco.Core;
+using Umbraco.Core.Models;
+using Umbraco.Core.Models.PublishedContent;
+
+namespace Archetype.Models
+{
+    public class ArchetypePublishedContent : IPublishedContent
+    {
+        private ArchetypeFieldsetModel _fieldset;
+
+        private IEnumerable<IPublishedContent> _parent;
+
+        private readonly Dictionary<string, IPublishedProperty> _properties;
+
+        public ArchetypePublishedContent(ArchetypeFieldsetModel fieldset, ArchetypePublishedContentSet parent = null)
+        {
+            if (fieldset == null)
+                throw new ArgumentNullException("fieldset");
+
+            _fieldset = fieldset;
+            _parent = parent ?? Enumerable.Empty<IPublishedContent>();
+
+            _properties = fieldset.Properties
+                .ToDictionary(
+                    x => x.Alias,
+                    x => new ArchetypePublishedProperty(x) as IPublishedProperty,
+                    StringComparer.InvariantCultureIgnoreCase);
+        }
+
+        internal ArchetypeFieldsetModel ArchetypeFieldset
+        {
+            get { return _fieldset; }
+        }
+
+        public IEnumerable<IPublishedContent> Children
+        {
+            get { return Enumerable.Empty<IPublishedContent>(); }
+        }
+
+        public IEnumerable<IPublishedContent> ContentSet
+        {
+            get { return _parent; }
+        }
+
+        public PublishedContentType ContentType
+        {
+            get { return default(PublishedContentType); }
+        }
+
+        public DateTime CreateDate
+        {
+            get { return DateTime.MinValue; }
+        }
+
+        public int CreatorId
+        {
+            get { return default(int); }
+        }
+
+        public string CreatorName
+        {
+            get { return default(string); }
+        }
+
+        public string DocumentTypeAlias
+        {
+            get { return _fieldset.Alias; }
+        }
+
+        public int DocumentTypeId
+        {
+            get { return default(int); }
+        }
+
+        public int GetIndex()
+        {
+            return _parent.IndexOf(this);
+        }
+
+        public IPublishedProperty GetProperty(string alias, bool recurse)
+        {
+            IPublishedProperty property;
+            return _properties.TryGetValue(alias, out property) ? property : null;
+        }
+
+        public IPublishedProperty GetProperty(string alias)
+        {
+            return this.GetProperty(alias, false);
+        }
+
+        public int Id
+        {
+            get { return default(int); }
+        }
+
+        public bool IsDraft
+        {
+            get { return _fieldset.IsAvailable() == false; }
+        }
+
+        public PublishedItemType ItemType
+        {
+            get { return PublishedItemType.Content; }
+        }
+
+        public int Level
+        {
+            get { return default(int); }
+        }
+
+        public string Name
+        {
+            get { return default(string); }
+        }
+
+        public IPublishedContent Parent
+        {
+            get { return default(IPublishedContent); }
+        }
+
+        public string Path
+        {
+            get { return default(string); }
+        }
+
+        public ICollection<IPublishedProperty> Properties
+        {
+            get { return _properties.Values; }
+        }
+
+        public int SortOrder
+        {
+            get { return default(int); }
+        }
+
+        public int TemplateId
+        {
+            get { return default(int); }
+        }
+
+        public DateTime UpdateDate
+        {
+            get { return default(DateTime); }
+        }
+
+        public string Url
+        {
+            get { return default(string); }
+        }
+
+        public string UrlName
+        {
+            get { return default(string); }
+        }
+
+        public Guid Version
+        {
+            get { return Guid.Empty; }
+        }
+
+        public int WriterId
+        {
+            get { return default(int); }
+        }
+
+        public string WriterName
+        {
+            get { return default(string); }
+        }
+
+        public object this[string alias]
+        {
+            get
+            {
+                var property = this.GetProperty(alias);
+
+                return property == null
+                    ? null
+                    : property.Value;
+            }
+        }
+    }
+}

app/Umbraco/Umbraco.Archetype/Models/ArchetypePublishedContentSet.cs

@@ -0,0 +1,39 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Archetype.Models
+{
+    public class ArchetypePublishedContentSet : IEnumerable<ArchetypePublishedContent>
+    {
+        private IEnumerable<ArchetypePublishedContent> _items { get; set; }
+
+        public ArchetypePublishedContentSet(ArchetypeModel archetype)
+        {
+            if (archetype == null)
+                throw new ArgumentNullException("archetype");
+
+            this.ArchetypeModel = archetype;
+
+            var count = archetype.Fieldsets.Count();
+
+            _items = archetype.Fieldsets
+                .Where(x => x.IsAvailable())
+                .Select(x => new ArchetypePublishedContent(x, this))
+                .ToArray();
+        }
+
+        internal ArchetypeModel ArchetypeModel { get; private set; }
+
+        public IEnumerator<ArchetypePublishedContent> GetEnumerator()
+        {
+            return _items.GetEnumerator();
+        }
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return this.GetEnumerator();
+        }
+    }
+}

app/Umbraco/Umbraco.Archetype/Models/ArchetypePublishedProperty.cs

@@ -0,0 +1,94 @@
+using System;
+using Archetype.Extensions;
+using Umbraco.Core.Logging;
+using Umbraco.Core.Models;
+using Umbraco.Core.Models.PublishedContent;
+
+namespace Archetype.Models
+{
+    public class ArchetypePublishedProperty : IPublishedProperty
+    {
+        private readonly object _rawValue;
+        private readonly Lazy<object> _sourceValue;
+        private readonly Lazy<object> _objectValue;
+        private readonly Lazy<object> _xpathValue;
+        private readonly ArchetypePropertyModel _property;
+        private readonly PublishedPropertyType _propertyType;
+
+        public ArchetypePublishedProperty(ArchetypePropertyModel property)
+        {
+            if (property == null)
+                throw new ArgumentNullException("property");
+
+            var preview = false;
+
+            _property = property;
+            _rawValue = property.Value;
+
+			// #418 - need to wrap this in a try/catch to prevent orphaned properties from breaking everything
+	        try
+	        {
+				_propertyType = property.CreateDummyPropertyType();
+
+				if (_propertyType != null)
+				{
+					_sourceValue = new Lazy<object>(() => _propertyType.ConvertDataToSource(_rawValue, preview));
+					_objectValue = new Lazy<object>(() => _propertyType.ConvertSourceToObject(_sourceValue.Value, preview));
+					_xpathValue = new Lazy<object>(() => _propertyType.ConvertSourceToXPath(_sourceValue.Value, preview));
+				}
+	        }
+	        catch(Exception ex)
+	        {
+		        LogHelper.Warn<ArchetypePublishedProperty>(string.Format("Could not create an IPublishedProperty for property: {0} - the error was: {1}", property.Alias, ex.Message));
+	        }
+        }
+
+        internal ArchetypePropertyModel ArchetypeProperty
+        {
+            get { return _property; }
+        }
+
+        public object DataValue
+        {
+            get
+            {
+                return _sourceValue != null
+                    ? _sourceValue.Value
+                    : _rawValue;
+            }
+        }
+
+        public bool HasValue
+        {
+            get
+            {
+                return _rawValue != null && !string.IsNullOrEmpty(_rawValue.ToString());
+            }
+        }
+
+        public string PropertyTypeAlias
+        {
+            get { return _property.Alias; }
+        }
+
+        public object Value
+        {
+            get
+            {
+                return _objectValue != null
+                    ? _objectValue.Value
+                    : _rawValue;
+            }
+        }
+
+        public object XPathValue
+        {
+            get
+            {
+                return _xpathValue != null
+                    ? _xpathValue.Value
+                    : _rawValue;
+            }
+        }
+    }
+}

app/Umbraco/Umbraco.Archetype/Properties/AssemblyInfo.cs

@@ -7,7 +7,7 @@ using System.Runtime.InteropServices;
 [assembly: AssemblyConfiguration("")]
 [assembly: AssemblyCompany("Imulus")]
 [assembly: AssemblyProduct("Archetype")]
-[assembly: AssemblyCopyright("Copyright \xa9 Imulus 2014")]
+[assembly: AssemblyCopyright("MIT Licensed")]
 [assembly: AssemblyTrademark("")]
 [assembly: AssemblyCulture("")]
 

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

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

app/Umbraco/Umbraco.Archetype/PropertyConverters/ArchetypeValueConverter.cs

@@ -8,15 +8,29 @@ using Umbraco.Core.Services;
 
 namespace Archetype.PropertyConverters
 {
+    /// <summary>
+    /// Default property value converter that models the JSON to a C# object.
+    /// </summary>
     [PropertyValueType(typeof(Models.ArchetypeModel))]
     [PropertyValueCache(PropertyCacheValue.All, PropertyCacheLevel.Content)]
     public class ArchetypeValueConverter : PropertyValueConverterBase
     {
+        /// <summary>
+        /// Gets the services.
+        /// </summary>
+        /// <value>
+        /// The services.
+        /// </value>
         public ServiceContext Services
         {
             get { return ApplicationContext.Current.Services; }
         }
 
+        /// <summary>
+        /// Determines whether the specified property type is converter for Archetype.
+        /// </summary>
+        /// <param name="propertyType">Type of the property.</param>
+        /// <returns></returns>
         public override bool IsConverter(PublishedPropertyType propertyType)
         {
             var isArcheTypePropertyEditor = !String.IsNullOrEmpty(propertyType.PropertyEditorAlias) 
@@ -27,6 +41,13 @@ namespace Archetype.PropertyConverters
             return !ArchetypeHelper.Instance.IsPropertyValueConverterOverridden(propertyType.DataTypeId);
         }
 
+        /// <summary>
+        /// Converts the data to source.
+        /// </summary>
+        /// <param name="propertyType">Type of the property.</param>
+        /// <param name="source">The source.</param>
+        /// <param name="preview">if set to <c>true</c> [preview].</param>
+        /// <returns></returns>
         public override object ConvertDataToSource(PublishedPropertyType propertyType, object source, bool preview)
         {
             var defaultValue = new ArchetypeModel();

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

@@ -1,6 +1,8 @@
-using System;
+using System;
 using System.Collections.Generic;
+using System.Linq;
 using Archetype.Extensions;
+using Archetype.Models;
 using ClientDependency.Core;
 using Newtonsoft.Json;
 using Umbraco.Core;
@@ -10,23 +12,34 @@ 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")]
+    /// <summary>
+    /// C# representation of the property editor. This is often done with package manifest instead.
+    /// </summary>
+	[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
 
+        /// <summary>
+        /// Creates a pre value editor instance
+        /// </summary>
+        /// <returns></returns>
 		protected override PreValueEditor CreatePreValueEditor()
 		{
 			return new ArchetypePreValueEditor();
 		}
 
+        /// <summary>
+        /// Class that represents the prevalue editor. This is often done with a package manifest instead.
+        /// </summary>
 		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; }
 
@@ -39,121 +52,227 @@ namespace Archetype.PropertyEditors
 
 		#region Value Editor
 
+        /// <summary>
+        /// Creates a value editor instance
+        /// </summary>
+        /// <returns></returns>
 		protected override PropertyValueEditor CreateValueEditor()
 		{
 			return new ArchetypePropertyValueEditor(base.CreateValueEditor());
 		}
 
+        /// <summary>
+        /// Class that represents the actual data editor. This is often done with a package manifest instead.
+        /// </summary>
 		internal class ArchetypePropertyValueEditor : PropertyValueEditorWrapper
 		{
 			protected JsonSerializerSettings _jsonSettings;
 
 			public ArchetypePropertyValueEditor(PropertyValueEditor wrapped)
-				: base(wrapped) { }
+				: base(wrapped)
+			{
+			}
 
+            /// <summary>
+            /// Converts the property value for use in the front-end cache
+            /// </summary>
+            /// <param name="property"></param>
+            /// <param name="propertyType"></param>
+            /// <param name="dataTypeService"></param>
+            /// <returns></returns>
 			public override string ConvertDbToString(Property property, PropertyType propertyType, IDataTypeService dataTypeService)
 			{
-				if (property.Value == null || property.Value.ToString() == "")
-					return string.Empty;
-
-                //LogHelper.Info<ArchetypeHelper>(property.Value.ToString());
+				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)
+					foreach (var propDef in fieldset.Properties.Where(p => p.DataTypeGuid != null))
 					{
-                        try
-                        {
-						    var dtd = dataTypeService.GetDataTypeDefinitionById(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);
-                        }
+						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();
+				return archetype.SerializeForPersistence();
 			}
 
+            /// <summary>
+            /// A method used to format the database value to a value that can be used by the editor
+            /// </summary>
+            /// <param name="property"></param>
+            /// <param name="propertyType"></param>
+            /// <param name="dataTypeService"></param>
+            /// <returns></returns>
+            /// <remarks>
+            /// The object returned will automatically be serialized into json notation. For most property editors
+            /// the value returned is probably just a string but in some cases a json structure will be returned.
+            /// </remarks>
 			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());
+				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)
+					foreach (var propDef in fieldset.Properties.Where(p => p.DataTypeGuid != null))
 					{
-                        try
-                        {
-                            var dtd = dataTypeService.GetDataTypeDefinitionById(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);
-                        }
+						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;
-
-                //LogHelper.Info<ArchetypeHelper>(editorValue.Value.ToString());
 
+            /// <summary>
+            /// A method to deserialize the string value that has been saved in the content editor
+            /// to an object to be stored in the database.
+            /// </summary>
+            /// <param name="editorValue"></param>
+            /// <param name="currentValue">The current value that has been persisted to the database for this editor. This value may be usesful for
+            /// how the value then get's deserialized again to be re-persisted. In most cases it will probably not be used.</param>
+            /// <returns></returns>
+            /// <remarks>
+            /// By default this will attempt to automatically convert the string value to the value type supplied by ValueType.
+            /// If overridden then the object returned must match the type supplied in the ValueType, otherwise persisting the
+            /// value to the DB will fail when it tries to validate the value type.
+            /// </remarks>
+			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)
 				{
+					// make sure the publishing dates are in UTC
+					fieldset.ReleaseDate = EnsureUtcDate(fieldset.ReleaseDate);
+					fieldset.ExpireDate = EnsureUtcDate(fieldset.ExpireDate);
+
+					// 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
-                        {
-						    var dtd = ApplicationContext.Current.Services.DataTypeService.GetDataTypeDefinitionById(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);
-                        }
+						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(fileName =>
+											uploadedFiles.FirstOrDefault(u => u.FileName != null &&
+												// #384, #389 and #394 - look for "safe" file names (using the ToSafeFileName() extension)
+												// - for backwards compatibility we'll look for the raw filename as well as the "safe" file name
+												(u.FileName.Equals(fileName, StringComparison.OrdinalIgnoreCase) || u.FileName.Equals(fileName.ToSafeFileName(), StringComparison.OrdinalIgnoreCase))
+											)
+                                        ).Where(f => f != null).ToList();
+									if(propertyFiles.Any())
+									{
+										additionalData["files"] = propertyFiles;
+									}
+								}
+							}
+							// #397 - pass along "cuid" and "puid" (part of the Umbraco 7.6 scheme)
+							if(editorValue.AdditionalData.ContainsKey("cuid"))
+							{
+								additionalData["cuid"] = editorValue.AdditionalData["cuid"];
+							}
+							if(editorValue.AdditionalData.ContainsKey("puid"))
+							{
+								additionalData["puid"] = editorValue.AdditionalData["puid"];
+							}
+							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();
-		    }
+				return archetype.SerializeForPersistence();
+			}
+
+            /// <summary>
+            /// Gets the property editor.
+            /// </summary>
+            /// <param name="dtd">The DTD.</param>
+            /// <returns></returns>
+			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();
+			}
+
+			/// <summary>
+			/// Ensures that a datetime is in UTC
+			/// </summary>
+			/// <param name="dateTime">The datetime</param>
+			/// <returns>The datetime in UTC (or null if it's not set)</returns>
+			private DateTime? EnsureUtcDate(DateTime? dateTime)
+			{
+				if(dateTime.HasValue == false || dateTime.Value.Kind == DateTimeKind.Utc)
+				{
+					return dateTime;
+				}
+				return new DateTime(dateTime.Value.Ticks, DateTimeKind.Utc);
+			}
 		}
 
-		#endregion	
+		#endregion
 	}
 }

app/Umbraco/Umbraco.Archetype/TypeConverters/ArchetypeFieldsetModelConverter.cs

@@ -0,0 +1,39 @@
+using System;
+using System.ComponentModel;
+using System.Globalization;
+using Archetype.Extensions;
+using Archetype.Models;
+using Umbraco.Core.Models;
+
+namespace Archetype.TypeConverters
+{
+    public class ArchetypeFieldsetModelConverter : TypeConverter
+    {
+        public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType)
+        {
+            if (destinationType == typeof(IPublishedContent) ||
+                destinationType == typeof(ArchetypePublishedContent))
+            {
+                return true;
+            }
+
+            if (destinationType == typeof(string))
+            {
+                // NOTE: The converter needs to return false here, otherwise `ArchetypeHelper.DeserializeJsonToArchetype` fails.
+                return false;
+            }
+
+            return base.CanConvertTo(context, destinationType);
+        }
+
+        public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType)
+        {
+            if (value is ArchetypeFieldsetModel && (destinationType == typeof(IPublishedContent) || destinationType == typeof(ArchetypePublishedContent)))
+            {
+                return ((ArchetypeFieldsetModel)value).ToPublishedContent();
+            }
+
+            return base.ConvertTo(context, culture, value, destinationType);
+        }
+    }
+}

app/Umbraco/Umbraco.Archetype/TypeConverters/ArchetypeModelConverter.cs

@@ -0,0 +1,34 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Globalization;
+using Archetype.Extensions;
+using Archetype.Models;
+using Umbraco.Core.Models;
+
+namespace Archetype.TypeConverters
+{
+    public class ArchetypeModelConverter : TypeConverter
+    {
+        public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType)
+        {
+            if (destinationType == typeof(ArchetypePublishedContentSet) ||
+                destinationType == typeof(IEnumerable<IPublishedContent>))
+            {
+                return true;
+            }
+
+            return base.CanConvertTo(context, destinationType);
+        }
+
+        public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType)
+        {
+            if (value is ArchetypeModel && (destinationType == typeof(ArchetypePublishedContentSet) || destinationType == typeof(IEnumerable<IPublishedContent>)))
+            {
+                return ((ArchetypeModel)value).ToPublishedContentSet();
+            }
+
+            return base.ConvertTo(context, culture, value, destinationType);
+        }
+    }
+}

app/controllers/config.controller.js

@@ -5,12 +5,18 @@ angular.module("umbraco").controller("Imulus.ArchetypeConfigController", functio
 
     //define empty items
     var newPropertyModel = '{"alias": "", "remove": false, "collapse": false, "label": "", "helpText": "", "dataTypeGuid": "0cc0eba1-9960-42c9-bf9b-60e150b429ae", "value": ""}';
-    var newFieldsetModel = '{"alias": "", "remove": false, "collapse": false, "labelTemplate": "", "icon": "", "label": "", "properties": [' + newPropertyModel + ']}';
-    var defaultFieldsetConfigModel = JSON.parse('{"showAdvancedOptions": false, "startWithAddButton": false, "hideFieldsetToolbar": false, "enableMultipleFieldsets": false, "hideFieldsetControls": false, "hidePropertyLabel": false, "maxFieldsets": null, "enableCollapsing": true, "enableDisabling": true, "enableDeepDatatypeRequests": true, "fieldsets": [' + newFieldsetModel + ']}');
+    var newFieldsetModel = '{"alias": "", "remove": false, "collapse": false, "labelTemplate": "", "icon": "", "label": "", "properties": [' + newPropertyModel + '], "group": null}';
+    var defaultFieldsetConfigModel = JSON.parse('{"showAdvancedOptions": false, "startWithAddButton": false, "hideFieldsetToolbar": false, "enableMultipleFieldsets": false, "hideFieldsetControls": false, "hidePropertyLabel": false, "maxFieldsets": null, "enableCollapsing": true, "enableMultipleOpen": true, "enableCloning": false, "enableDisabling": true, "enableDeepDatatypeRequests": false, "enablePublishing": false, "enableMemberGroups": false, "enableCrossDragging": false, "fieldsets": [' + newFieldsetModel + '], "fieldsetGroups": []}');
 
     //ini the model
     $scope.model.value = $scope.model.value || defaultFieldsetConfigModel;
 
+    $scope.dllVersion = "";
+
+    archetypePropertyEditorResource.getDllVersion().then(function(data){
+        $scope.dllVersion = data.dllVersion;
+    });
+
     //ini the render model
     initConfigRenderModel();
 
@@ -41,6 +47,12 @@ angular.module("umbraco").controller("Imulus.ArchetypeConfigController", functio
         }
     };
 
+    // added to track loaded fieldsets 
+    $scope.loadedFieldsets = [];
+    $scope.isLoaded = function (fieldset) {
+        return $scope.loadedFieldsets.indexOf(fieldset) >= 0;
+    }
+
     //function that determines how to manage expanding/collapsing fieldsets
     $scope.focusFieldset = function(fieldset){
         var iniState;
@@ -54,6 +66,7 @@ angular.module("umbraco").controller("Imulus.ArchetypeConfigController", functio
             if($scope.archetypeConfigRenderModel.fieldsets.length == 1 && fieldset.remove == false)
             {
                 fieldset.collapse = false;
+                $scope.loadedFieldsets.push(fieldset);
                 return;
             }
 
@@ -64,12 +77,14 @@ angular.module("umbraco").controller("Imulus.ArchetypeConfigController", functio
             else
             {
                 fieldset.collapse = false;
+                $scope.loadedFieldsets.push(fieldset);
             }
         });
 
         if(iniState)
         {
             fieldset.collapse = !iniState;
+            $scope.loadedFieldsets.push(fieldset);
         }
     }
 
@@ -104,7 +119,7 @@ angular.module("umbraco").controller("Imulus.ArchetypeConfigController", functio
 
     //ini the properties
     _.each($scope.archetypeConfigRenderModel.fieldsets, function(fieldset){
-            $scope.focusProperty(fieldset.properties);
+        $scope.focusProperty(fieldset.properties);
     });
 
     //setup JSON.stringify helpers
@@ -117,27 +132,20 @@ angular.module("umbraco").controller("Imulus.ArchetypeConfigController", functio
 
     //watch for changes
     $scope.$watch('archetypeConfigRenderModel', function (v) {
-        //console.log(v);
         if (typeof v === 'string') {
             $scope.archetypeConfigRenderModel = JSON.parse(v);
             $scope.archetypeConfigRenderModel.toString = stringify;
         }
     });
 
-    $scope.autoPopulateAlias = function(s) {
-        var modelType = s.hasOwnProperty('fieldset') ? 'fieldset' : 'property';
-        var modelProperty = s[modelType];
-
-        if (!modelProperty.aliasIsDirty) {
+    $scope.autoPopulateAlias = function (modelProperty) {
+        if (modelProperty && !modelProperty.aliasIsDirty) {
             modelProperty.alias = modelProperty.label.toUmbracoAlias();
         }
     }
 
-    $scope.markAliasDirty = function(s) {
-        var modelType = s.hasOwnProperty('fieldset') ? 'fieldset' : 'property';
-        var modelProperty = s[modelType];
-
-        if (!modelProperty.aliasIsDirty) {
+    $scope.markAliasDirty = function (modelProperty) {
+        if (modelProperty && !modelProperty.aliasIsDirty) {
             modelProperty.aliasIsDirty = true;;
         }
     }
@@ -238,8 +246,18 @@ angular.module("umbraco").controller("Imulus.ArchetypeConfigController", functio
     function initConfigRenderModel()
     {
         $scope.archetypeConfigRenderModel = $scope.model.value;
+        if (!$scope.archetypeConfigRenderModel.fieldsetGroups) {
+            $scope.archetypeConfigRenderModel.fieldsetGroups = [];
+        }
 
-        _.each($scope.archetypeConfigRenderModel.fieldsets, function(fieldset){
+        _.each($scope.archetypeConfigRenderModel.fieldsets, function(fieldset) {
+
+            if (fieldset.group) {
+                // tie the fieldset group back up to the actual group object, not the clone that's been persisted
+                fieldset.group = _.find($scope.archetypeConfigRenderModel.fieldsetGroups, function(fieldsetGroup) {
+                    return fieldsetGroup.name == fieldset.group.name;
+                })
+            }
 
             fieldset.remove = false;
             if (fieldset.alias.length > 0)
@@ -289,6 +307,24 @@ angular.module("umbraco").controller("Imulus.ArchetypeConfigController", functio
         $scope.model.value.fieldsets = fieldsets;
     }
 
+    $scope.showOptions = function ($event, template) {
+        $event.preventDefault();
+
+        dialogService.closeAll();
+
+        dialogService.open({
+            template: template,
+            show: true,
+            callback: function (data) {
+                // replace the entire render model if it was changed (in developer options)
+                if (data.model && data.modelChanged) {
+                    $scope.archetypeConfigRenderModel = data.model;
+                }
+            },
+            dialogData: { model: $scope.archetypeConfigRenderModel }
+        });
+    }
+
     //archetype css
-    assetsService.loadCss("/App_Plugins/Archetype/css/archetype.css");
+    assetsService.loadCss("../App_Plugins/Archetype/css/archetype.css");
 });

app/controllers/config.dialog.controller.js

@@ -0,0 +1,15 @@
+angular.module('umbraco').controller('ArchetypeConfigOptionsController', function ($scope) {
+    //handles a fieldset group add
+    $scope.addFieldsetGroup = function () {
+        $scope.dialogData.model.fieldsetGroups.push({ name: "" });
+    }
+
+    //handles a fieldset group removal
+    $scope.removeFieldsetGroup = function ($index) {
+        $scope.dialogData.model.fieldsetGroups.splice($index, 1);
+    }
+
+    $scope.apply = function(index) {
+        $scope.submit($scope.dialogData);
+    }
+});

app/controllers/controller.js

@@ -1,4 +1,8 @@
-angular.module("umbraco").controller("Imulus.ArchetypeController", function ($scope, $http, assetsService, angularHelper, notificationsService, $timeout, entityResource) {
+{{VERSION}}
+angular.module("umbraco").controller("Imulus.ArchetypeController", function ($scope, $http, $filter, $interpolate, assetsService, angularHelper, notificationsService, $timeout, fileManager, entityResource, archetypeService, archetypeLabelService, archetypeCacheService, archetypePropertyEditorResource, archetypeLocalizationService) {
+
+    // Variables.
+    var draggedParent;
 
     //$scope.model.value = "";
     $scope.model.hideLabel = $scope.model.config.hideLabel == 1;
@@ -14,66 +18,32 @@
 
     // store the umbraco property alias to help generate unique IDs.  Hopefully there's a better way to get this in the future :)
     $scope.umbracoHostPropertyAlias = $scope.$parent.$parent.model.alias;
+    
+    $scope.isDebuggingEnabled = Umbraco.Sys.ServerVariables.isDebuggingEnabled;
+
+    $scope.overlayMenu = {
+        show: false,
+        style: {}
+    };
 
     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) {
-            var propertyAlias = "";
-
-            //test for function
-            var beginIndexOf = results[1].indexOf("(");
-            var endIndexOf = results[1].indexOf(")");
-
-            if(beginIndexOf != -1 && endIndexOf != -1)
-            {
-                var functionName = results[1].substring(0, beginIndexOf);
-                propertyAlias = results[1].substring(beginIndexOf + 1, endIndexOf);
-                parsedTemplate = parsedTemplate.replace(results[0], executeFunctionByName(functionName, window, $scope.getPropertyValueByAlias(fieldset, propertyAlias), $scope));
-            }
-            else {
-                propertyAlias = results[1];
-                parsedTemplate = parsedTemplate.replace(results[0], $scope.getPropertyValueByAlias(fieldset, propertyAlias));
-            }
-        }
-
-        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);
     }
 
     //sort config
@@ -81,20 +51,279 @@
         axis: 'y',
         cursor: "move",
         handle: ".handle",
+        tolerance: "pointer",
+        activate: function(ev, ui) {
+
+            // Variables.
+            var parentItem = ui.item.parent();
+            var thisElement = parentItem[0];
+            var targetElement = ev.target;
+            var targetItem = angular.element(targetElement);
+
+            // The source of the drag can always be dropped back onto.
+            if (targetElement === thisElement) {
+                return;
+            }
+
+            // Variables.
+            var sourceScope = ui.item.scope();
+            var targetScope = targetItem.scope();
+            var valid = canMove(sourceScope, targetScope);
+
+            // If the sortable can't be moved to the target Archetype, disable
+            // the target Archetype's sortable temporarily.
+            if (!valid) {
+                var targetSortable = getSortableWidgetInstance(targetItem);
+                targetSortable.disable();
+                parentItem.sortable("refresh");
+                archetypeService.rememberDisabledSortable(targetSortable);
+            }
+
+        },
+        start: function(ev, ui) {
+            archetypeService.storeEditors(ui.item.parent());
+            $scope.$apply(function() {
+                draggedParent = ui.item.parent();
+                draggedParent.scope().doingSort = true;
+            });
+        },
         update: function (ev, ui) {
+
+            // Variables.
+            var targetScope = ui.item.sortable.droptarget.scope();
+            var sourceScope = ui.item.scope();
+            var sameScope = sourceScope === targetScope;
+            var sourceIndex = ui.item.sortable.index;
+
+            // Special constraints for when moving between Archetypes.
+            // If sourceScope is populated, we are in the first of the two updates (when
+            // moving between lists, ui-sortable calls the update function twice).
+            if (sourceScope && !sameScope) {
+
+                // Variables.
+                var valid = canMove(sourceScope, targetScope);
+
+                // If update isn't allowed, cancel the drag operation.
+                if (!valid) {
+                    ui.item.sortable.cancel();
+                    return;
+                }
+
+                // Clear the validations for this item.
+                clearValidations(ui.item.parent());
+                clearValidations(ui.item.sortable.droptarget);
+
+                // Reset "isValid" on the properties and fieldsets.
+                var fieldsetGroups = [
+                    $scope.model.value.fieldsets,
+                    targetScope.model.value.fieldsets
+                ];
+                _.each(fieldsetGroups, function(fieldsets) {
+                    recurseProperties(function(property, fieldset) {
+                        property.isValid = true;
+                        fieldset.isValid = true;
+                    }, fieldsets);
+                });
+
+                // Move the activated fieldset to the target Archetype.
+                var movedFieldset = $scope.model.value.fieldsets[sourceIndex];
+                var loadedIndex = $scope.loadedFieldsets.indexOf(movedFieldset);
+                if (loadedIndex >= 0) {
+                    $scope.loadedFieldsets.splice(loadedIndex, 1);
+                    if (targetScope.loadedFieldsets.indexOf(movedFieldset) < 0) {
+                        targetScope.loadedFieldsets.push(movedFieldset);
+                    }
+                }
+
+            }
+
+            // Set scope dirty.
             $scope.setDirty();
+
         },
         stop: function (ev, ui) {
 
+            // Done sorting.
+            draggedParent.scope().doingSort = false;
+
+            // Enable disabled sortables.
+            archetypeService.enableSortables();
+
+            // Restore rich text editors.
+            var parent = null;
+            var target = ui.item.sortable.droptarget;
+            if (target) {
+                parent = target.parent();
+            }
+            archetypeService.restoreEditors(parent);
+
         }
     };
 
+    // Clears the Angular validations in an Archetype.
+    function clearValidations(el) {
+        var combined = $(".archetypeSortable", el).add(el);
+        combined.each(function(index, item) {
+            var $item = angular.element(item);
+            var cont = $item.controller("ngModel");
+            var err = cont.$error;
+            var keys = Object.keys(err);
+            for (var i = 0; i < keys.length; i++) {
+                cont.$setValidity(keys[i], true);
+            }
+        });
+    }
+
+    // Enable cross-archetype dragging?
+    if ($scope.model.config.enableCrossDragging) {
+        $scope.sortableOptions.connectWith = ".archetypeSortable:not(.invalid)";
+    }
+
+    // Checks if the specified model's properties match all of the properties in any of
+    // the specified fieldsets, while also checking if the fieldset aliases match.
+    // This is an indicator of the compatibility of a fieldset model with a collection
+    // of fieldset configurations.
+    function modelMatchesAnyFieldset(model, fieldsets) {
+
+        // Loop through fieldsets to find a match.
+        for (var i = 0; i < fieldsets.length; i++) {
+            var fieldset = fieldsets[i];
+
+            // Confirm that this configured fielset contains exactly
+            // the same properties as those that were supplied.
+            var valid =
+                // Does the alias match?
+                model.alias === fieldset.alias &&
+                // Does this fieldset have all the properties?
+                arePropertiesSubset(model.properties, fieldset.properties) &&
+                // Does the property array have all the fieldset properties?
+                arePropertiesSubset(fieldset.properties, model.properties);
+
+            // Match found?
+            if (valid) {
+                return true;
+            }
+
+        }
+
+        // No match found.
+        return false;
+
+    }
+
+    // Checks if the specified array of fieldsets contains the specified fieldset.
+    function arrayContainsFieldset(fieldset, fieldsets) {
+        for (var i = 0; i < fieldsets.length; i++) {
+            if (fieldsets[i] === fieldset) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    // Confirms that an array of properties is a subset of another array of properties.
+    function arePropertiesSubset(subset, superset) {
+
+        // Loop through the subset of properties.
+        for (var j = 0; j < subset.length; j++) {
+            var subProperty = subset[j];
+            var matchedProp = false;
+
+            // Loop through the superset to find a matching property from the subset.
+            for (var k = 0; k < superset.length; k++) {
+                var superProperty = superset[k];
+                if (superProperty.alias === subProperty.alias &&
+                    superProperty.dataTypeGuid === subProperty.dataTypeGuid) {
+                    matchedProp = true;
+                    break;
+                }
+            }
+
+            // If no matching property could be found, the array is not a subset.
+            if (!matchedProp) {
+                return false;
+            }
+
+        }
+
+        // The array is a subset.
+        return true;
+
+    }
+
     //handles a fieldset add
+    $scope.openFieldsetPicker = function ($index, event) {
+        if ($scope.canAdd() == false) {
+            return;
+        }
+
+        var allFieldsets = [];
+        _.each($scope.model.config.fieldsets, function (fieldset) {
+            var icon = fieldset.icon;
+            allFieldsets.push({
+                alias: fieldset.alias,
+                label: fieldset.label,
+                icon: (fieldset.icon || "icon-document-dashed-line"), // default icon if none is chosen
+                group: fieldset.group ? fieldset.group.name : null,
+                previewImage: fieldset.previewImage
+            });
+        });
+        // sanity check
+        if (allFieldsets == 0) {
+            return;
+        }
+        if (allFieldsets.length == 1) {
+            // only one fieldset type - no need to display the picker
+            $scope.addRow(allFieldsets[0].alias, $index);
+            return;
+        }
+
+        $scope.overlayMenu.fieldsetGroups = [];
+        if ($scope.model.config.fieldsetGroups && $scope.model.config.fieldsetGroups.length > 0) {
+            _.each($scope.model.config.fieldsetGroups, function (fieldsetGroup) {
+                $scope.overlayMenu.fieldsetGroups.push({ name: fieldsetGroup.name, fieldsets: $filter("filter")(allFieldsets, { group: fieldsetGroup.name }, true) });
+            })
+        }
+        else {
+            $scope.overlayMenu.fieldsetGroups.push({ name: "", fieldsets: allFieldsets });
+        }
+        $scope.overlayMenu.index = $index;
+        $scope.overlayMenu.activeFieldsetGroup = $scope.overlayMenu.fieldsetGroups[0];
+
+        // calculate overlay position
+        // - yeah... it's jQuery (ungh!) but that's how the Grid does it.
+        var offset = $(event.target).offset();
+        var scrollTop = $(event.target).closest(".umb-panel-body").scrollTop();
+        if (offset.top < 400) {
+            $scope.overlayMenu.style.top = 300 + scrollTop;
+        }
+        else {
+            $scope.overlayMenu.style.top = offset.top - 150 + scrollTop;
+        }
+        $scope.overlayMenu.show = true;
+    };
+
+    $scope.closeFieldsetPicker = function () {
+        $scope.overlayMenu.show = false;
+        $scope.overlayMenu.fieldsetPreview = null;
+    };
+    
+    $scope.pickFieldset = function (fieldsetAlias, $index) {
+        $scope.closeFieldsetPicker();
+        $scope.addRow(fieldsetAlias, $index);
+    };    
+
+    $scope.openFieldsetPreview = function (fieldset) {
+        $scope.overlayMenu.fieldsetPreview = fieldset;
+    }
+
+    $scope.closeFieldsetPreview = function () {
+        $scope.overlayMenu.fieldsetPreview = null;
+    }
+
     $scope.addRow = function (fieldsetAlias, $index) {
-        if ($scope.canAdd())
-        {
-            if ($scope.model.config.fieldsets)
-            {
+        if ($scope.canAdd()) {
+            if ($scope.model.config.fieldsets) {
                 var newFieldset = getEmptyRenderFieldset($scope.getConfigFieldsetByAlias(fieldsetAlias));
 
                 if (typeof $index != 'undefined')
@@ -106,10 +335,22 @@
                     $scope.model.value.fieldsets.push(newFieldset);
                 }
             }
+
+            addCustomPropertiesToFieldset(newFieldset);
+
             $scope.setDirty();
 
+            $scope.$broadcast("archetypeAddFieldset", {index: $index, visible: countVisible()});
+
             newFieldset.collapse = $scope.model.config.enableCollapsing ? true : false;
+
+            // If the fieldset is not collapsed, it should be instantly loaded.
+            if (!newFieldset.collapse) {
+                $scope.loadedFieldsets.push(newFieldset);
+            }
+            
             $scope.focusFieldset(newFieldset);
+            $scope.handleMandatoryValidation();
         }
     }
 
@@ -118,6 +359,37 @@
             if (confirm('Are you sure you want to remove this?')) {
                 $scope.setDirty();
                 $scope.model.value.fieldsets.splice($index, 1);
+                $scope.$broadcast("archetypeRemoveFieldset", {index: $index});
+                $scope.handleMandatoryValidation();
+            }
+        }
+    }
+
+    $scope.cloneRow = function ($index) {
+        if ($scope.canClone() && typeof $index != 'undefined') {
+            var newFieldset = angular.copy($scope.model.value.fieldsets[$index]);
+
+            if(newFieldset) {
+
+                // Regenerate the temporary ID on each nested fieldset.
+                // This is done because no two fieldsets should have the same
+                // temporary ID.
+                recurseProperties(function(property) {
+                    archetypeService.ensureTemporaryId(property, true);
+                }, [newFieldset]);
+
+                $scope.model.value.fieldsets.splice($index + 1, 0, newFieldset);
+
+                $scope.setDirty();
+
+                newFieldset.collapse = $scope.model.config.enableCollapsing ? true : false;
+
+                // If the fieldset is not collapsed, it should be instantly loaded.
+                if (!newFieldset.collapse) {
+                    $scope.loadedFieldsets.push(newFieldset);
+                }
+
+                $scope.focusFieldset(newFieldset);
             }
         }
     }
@@ -126,11 +398,34 @@
         fieldset.disabled = !fieldset.disabled;
         // explicitly set the form as dirty when manipulating the enabled/disabled state of a fieldset
         $scope.setDirty();
+        $scope.handleMandatoryValidation();
     }
 
     //helpers for determining if a user can do something
-    $scope.canAdd = function ()
-    {
+    $scope.canAdd = function () {
+        if ($scope.model.config.maxFieldsets)
+        {
+            var visibleCount = countVisible();
+            var maxFieldsets = $scope.model.config.maxFieldsets;
+            return visibleCount < maxFieldsets;
+        }
+
+        return true;
+    };
+
+    //helper that returns if an item can be removed
+    $scope.canRemove = function () {
+        return countVisible() > 1 
+            || ($scope.model.config.maxFieldsets == 1 && $scope.model.config.fieldsets.length > 1)
+            || $scope.model.config.startWithAddButton;
+    };
+
+    $scope.canClone = function () {
+
+        if (!$scope.model.config.enableCloning) {
+            return false;
+        }
+
         if ($scope.model.config.maxFieldsets)
         {
             return countVisible() < $scope.model.config.maxFieldsets;
@@ -139,19 +434,19 @@
         return true;
     }
 
-    //helper that returns if an item can be removed
-    $scope.canRemove = function ()
-    {
-        return countVisible() > 1 
-            || ($scope.model.config.maxFieldsets == 1 && $scope.model.config.fieldsets.length > 1)
-            || $scope.model.config.startWithAddButton;
-    }
-
     //helper that returns if an item can be sorted
     $scope.canSort = function ()
     {
-        return countVisible() > 1;
-    }
+        // Sorting can occur if there are multiple fieldsets, or if there is only one
+        // fieldset that can be removed (in which case it can be sorted into an entirely
+        // different Archetype).
+        return countVisible() > 1 || $scope.canRemove();
+    };
+
+    //helper that returns if an item is the last and it's being sorted.
+    $scope.sortingLastItem = function() {
+        return $scope.doingSort && $scope.model.value.fieldsets.length <= 1;
+    };
 
     //helper that returns if an item can be disabled
     $scope.canDisable = function () {
@@ -165,10 +460,94 @@
             ///&& $scope.model.config.fieldsets.length == 1;
     }
 
+    //helper that returns if an item can use publishing
+    $scope.canPublish = function () {
+        return $scope.model.config.enablePublishing;
+    }
+
+    $scope.canUseMemberGroups = function() {
+        return $scope.model.config.enableMemberGroups;
+    }
+
+    //helper that returns if the "misc fieldset configuration" section should be visible
+    $scope.canConfigure = function () {
+        // currently the "misc fieldset configuration" section contains the publishing and the member groups setup
+        return $scope.canPublish() || $scope.canUseMemberGroups();
+    }
+
+    $scope.showDisableIcon = function (fieldset) {
+        if ($scope.canDisable() == false) {
+            return false;
+        }
+        // disabled state takes precedence over publishing
+        if (fieldset.disabled) {
+            return true;
+        }
+        return $scope.isDisabledByPublishing(fieldset) == false;
+    }
+
+    $scope.showPublishingIcon = function (fieldset) {
+        if ($scope.canPublish() == false) {
+            return false;
+        }
+        if ($scope.canDisable()) {
+            // disabled state takes precedence over publishing
+            if (fieldset.disabled) {
+                return false;
+            }
+            return $scope.isDisabledByPublishing(fieldset);
+        }
+        return true;
+    }
+
+    $scope.isDisabledByPublishing = function(fieldset) {
+        if ($scope.canPublish() === false) {
+            return false;
+        }
+        // NOTE: all comparison is done in local datetime
+        //       - that's fine because the selected local datetimes will be converted to UTC datetimes when submitted
+        if (fieldset.expireDateModel && fieldset.expireDateModel.value && (moment() > moment(fieldset.expireDateModel.value))) {
+            // an expired release affects the fieldset
+            return true;
+        }
+        if (fieldset.releaseDateModel && fieldset.releaseDateModel.value && (moment(fieldset.releaseDateModel.value) > moment())) {
+            // a pending release affects the fieldset
+            return true;
+        }
+        return false;
+    }
+
+    $scope.isDisabled = function(fieldset) {
+        if (fieldset.disabled) {
+            return true;
+        }
+        return $scope.isDisabledByPublishing(fieldset);
+    }
+
+    $scope.numberOfEnabledFieldsets = function () {
+        if (!$scope.model.value.fieldsets) {
+            return 0;
+        }
+        return _.filter($scope.model.value.fieldsets, function (f) {
+            return $scope.isDisabled(f) == false;
+        }).length;
+    }
+
     //helper, ini the render model from the server (model.value)
     function init() {
         $scope.model.value = removeNulls($scope.model.value);
         addDefaultProperties($scope.model.value.fieldsets);
+
+        $timeout(function () {
+            $scope.handleMandatoryValidation();
+        }, 50);
+
+        // localize the message for minimum fieldsets validation errors
+        archetypeLocalizationService.localize("minFieldsetsMessage").then(function (value) {
+            value = value || "You must add minimum {{minFieldsets}} items";
+            var exp = $interpolate(value);
+            $scope.minFieldsetsMessage = exp({ minFieldsets: $scope.model.config.minFieldsets });
+        });
     }
 
     function addDefaultProperties(fieldsets)
@@ -180,6 +559,36 @@
         });
     }
 
+    function addCustomProperties(fieldsets) {
+        // make sure we have loaded moment.js before using it
+        assetsService.loadJs("lib/moment/moment-with-locales.js").then(function() {
+            _.each(fieldsets, function(fieldset) {
+                addCustomPropertiesToFieldset(fieldset);
+            });
+        });
+    }
+
+    function addCustomPropertiesToFieldset(fieldset) {
+        // create models for publish configuration (utilizing the built-in datepicker data type)
+        // NOTE: all datetimes must be converted from UTC to local
+        fieldset.releaseDateModel = {
+            alias: _.uniqueId("archetypeReleaseDate_"),
+            view: "datepicker",
+            value: fromUtc(fieldset.releaseDate)
+        };
+        fieldset.expireDateModel = {
+            alias: _.uniqueId("archetypeExpireDate_"),
+            view: "datepicker",
+            value: fromUtc(fieldset.expireDate)
+        };
+        // create model for allowed member groups
+        fieldset.allowedMemberGroupsModel = {
+            alias: _.uniqueId("archetypeAllowedMemberGroups_"),
+            view: "membergrouppicker",
+            value: fieldset.allowedMemberGroups
+        };
+    }
+
     //helper to get the correct fieldset from config
     $scope.getConfigFieldsetByAlias = function(alias) {
         return _.find($scope.model.config.fieldsets, function(fieldset){
@@ -199,9 +608,15 @@
     {
         if(typeof fieldset.collapse === "undefined")
         {
-            fieldset.collapse = true;
+            fieldset.collapse = $scope.model.config.enableCollapsing ? true : false;
         }
         return fieldset.collapse;
+    };
+
+    // added to track loaded fieldsets 
+    $scope.loadedFieldsets = [];
+    $scope.isLoaded = function (fieldset) {
+        return $scope.loadedFieldsets.indexOf(fieldset) >= 0;
     }
 
     //helper for expanding/collapsing fieldsets
@@ -212,40 +627,76 @@
             return;
         }
 
-        var iniState;
-
-        if(fieldset)
+        // collapse all other fieldsets if "multiple open fieldsets" is not enabled
+        if(!$scope.model.config.enableMultipleOpen) 
         {
-            iniState = fieldset.collapse;
+            _.each($scope.model.value.fieldsets, function (f) {
+                if(f != fieldset)
+                {
+                    f.collapse = true;
+                }
+            });
         }
 
-        _.each($scope.model.value.fieldsets, function(fieldset){
-            fieldset.collapse = true;
-        });
-
         if(!fieldset && $scope.model.value.fieldsets.length == 1)
         {
             $scope.model.value.fieldsets[0].collapse = false;
+            $scope.loadedFieldsets.push($scope.model.value.fieldsets[0]);
             return;
         }
 
-        if(iniState && fieldset)
+        if(fieldset)
         {
-            fieldset.collapse = !iniState;
+            fieldset.collapse = !fieldset.collapse;
+            if($scope.loadedFieldsets.indexOf(fieldset) < 0)
+            {
+                $scope.loadedFieldsets.push(fieldset);
+            }
         }
     }
 
     //ini the fieldset expand/collapse
     $scope.focusFieldset();
 
+    // Fieldsets which cannot be collapsed should start expanded.
+    _.each($scope.model.value.fieldsets, function(fieldset) {
+        fieldset.collapse = $scope.model.config.enableCollapsing;
+    });
+    $scope.loadedFieldsets = _.where($scope.model.value.fieldsets, { collapse: false });
+
     //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) {
@@ -255,6 +706,22 @@
                 $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;
+
+        // init loaded fieldsets tracking
+        _.each($scope.model.value.fieldsets, function (fieldset) {
+            fieldset.collapse = $scope.model.config.enableCollapsing ? true : false;
+        });
+        $scope.loadedFieldsets = _.where($scope.model.value.fieldsets, { collapse: false });
+
+        // create properties needed for the backoffice to work (data that is not serialized to DB)
+        addCustomProperties($scope.model.value.fieldsets);
     });
 
     //helper to count what is visible
@@ -315,24 +782,21 @@
 
     //helper to lookup validity when given a fieldset
     $scope.getFieldsetValidity = function (fieldset) {
-        if (fieldset.isValid == false) {
-            return false;
-        }
 
-        // recursive validation of nested fieldsets
-        var nestedFieldsetsValid = true;
-        _.each(fieldset.properties, function (property) {
-            if (property != null && property.value != null && property.propertyEditorAlias == "Imulus.Archetype") {
-                _.each(property.value.fieldsets, function (inner) {
-                    if ($scope.getFieldsetValidity(inner) == false) {
-                        nestedFieldsetsValid = false;
-                    }
-                });
+        // Variables.
+        var valid = true;
+
+        // Recursive validation of nested fieldsets.
+        recurseFieldsets(function(item) {
+            if (item.isValid === false) {
+                valid = false;
             }
-        });
+        }, [fieldset]);
 
-        return nestedFieldsetsValid;
-    }
+        // Were all the nested fieldsets valid?
+        return valid;
+
+    };
 
     // helper to force the current form into the dirty state
     $scope.setDirty = function () {
@@ -341,17 +805,145 @@
         }
     }
 
+    $scope.minFieldsetsFulfilled = function () {
+        if (!$scope.model.config.minFieldsets) {
+            return true;
+        }
+        return $scope.numberOfEnabledFieldsets() >= $scope.model.config.minFieldsets;
+    }
+
     //custom js
     if ($scope.model.config.customJsPath) {
         assetsService.loadJs($scope.model.config.customJsPath);
     }
 
     //archetype css
-    assetsService.loadCss("/App_Plugins/Archetype/css/archetype.css");
+    assetsService.loadCss("../App_Plugins/Archetype/css/archetype.css");
 
     //custom css
     if($scope.model.config.customCssPath)
     {
         assetsService.loadCss($scope.model.config.customCssPath);
     }
+
+    // submit watcher handling:
+    // because some property editors use the "formSubmitting" event to set/clean up their model.value,
+    // we need to monitor the "formSubmitting" event from a custom property and broadcast our own event
+    // to forcefully update the appropriate model.value's
+    $scope.activeSubmitWatcher = 0;
+    $scope.submitWatcherOnLoad = function () {
+        $scope.activeSubmitWatcher++;
+        return $scope.activeSubmitWatcher;
+    }
+    $scope.submitWatcherOnSubmit = function (args) {
+        $scope.$broadcast("archetypeFormSubmitting", args);
+    }
+
+    // we'll use our own "archetypeFormSubmitting" event to save custom properties, as at least some 
+    // of the editors store their values back to the model on the core "formSubmitting" event
+    $scope.$on("archetypeFormSubmitting", function (ev, args) {
+        _.each($scope.model.value.fieldsets, function (fieldset) {
+            // extract the publish configuration from the fieldsets (and convert local datetimes to UTC)
+            fieldset.releaseDate = toUtc(fieldset.releaseDateModel.value);
+            fieldset.expireDate = toUtc(fieldset.expireDateModel.value);
+            // extract the allowed member groups 
+            fieldset.allowedMemberGroups = fieldset.allowedMemberGroupsModel.value;
+        });
+    });
+
+    // handle mandatory validation of the entire Archetype
+    // - no fieldsets = not valid
+    $scope.handleMandatoryValidation = function() {
+        var valid = true;
+        if ($scope.model.validation && $scope.model.validation.mandatory) {
+            valid = $scope.numberOfEnabledFieldsets() > 0;
+        }
+        $scope.model.mandatoryValidation = valid ? "valid" : null;
+    }
+
+    function toUtc(date) {
+        if (!date) {
+            return null;
+        }
+        return moment(date, "YYYY-MM-DD HH:mm:ss").utc().toDate();
+    }
+
+    function fromUtc(date) {
+        if (!date) {
+            return null;
+        }
+        return moment(moment.utc(date).toDate()).format("YYYY-MM-DD HH:mm:ss")
+    }
+
+    // Serializes and deserializes an item to return a snapshot of that item (e.g., so it is not
+    // changed before being inspected). Useful when troubleshooting.
+    // Modified from: http://stackoverflow.com/a/11616993/2052963
+    function jsonSnapshot(item) {
+        var cache = [];
+        var stringItem = JSON.stringify(item, function(key, value) {
+            if (typeof value === "object" && value !== null) {
+                if (cache.indexOf(value) !== -1) {
+                    return "[Removed Circular Reference Item]";
+                }
+                cache.push(value);
+            }
+            return value;
+        });
+        return JSON.parse(stringItem);
+    }
+
+    // Recursively processes each Archetype fieldset.
+    function recurseFieldsets(fn, fieldsets) {
+        if (!fieldsets || !fieldsets.length) {
+            return;
+        }
+        _.each(fieldsets, function(fieldset) {
+            fn(fieldset);
+            _.each(fieldset.properties, function (property) {
+                if (property != null && property.value != null && property.propertyEditorAlias === "Imulus.Archetype") {
+                    recurseFieldsets(fn, property.value.fieldsets);
+                }
+            });
+        });
+    }
+
+    // Recursively processes each Archetype fieldset property.
+    function recurseProperties(fn, fieldsets) {
+        recurseFieldsets(function(fieldset) {
+            _.each(fieldset.properties, function (property) {
+                fn(property, fieldset);
+            });
+        }, fieldsets);
+    }
+
+    // Indicates whether or not the fieldset can be moved between the source and target scope.
+    // The source scope is the scope of the fieldset being dragged.
+    // The target scope is the scope of the Archetype to drop into.
+    function canMove(sourceScope, targetScope) {
+        var targetFieldsetConfigs = targetScope.model.config.fieldsets;
+        var targetFieldsets = targetScope.model.value.fieldsets;
+        var sourceFieldset = sourceScope.fieldset;
+        var sameArchetype = arrayContainsFieldset(sourceFieldset, targetFieldsets);
+        var model = sourceScope.fieldsetConfigModel;
+        var canRemove = sourceScope.canRemove();
+        var canAdd = targetScope.canAdd();
+        var valid = sameArchetype || (canRemove && canAdd);
+        valid = valid && modelMatchesAnyFieldset(model, targetFieldsetConfigs);
+        return valid;
+    }
+
+    // This is an alternative to: element.sortable("instance")
+    // Workaround for this issue: https://github.com/imulus/Archetype/pull/356#issuecomment-218527910
+    // Snagged from this pull request: https://github.com/angular-ui/ui-sortable/pull/319
+    // More technical details here: https://github.com/angular-ui/ui-sortable/issues/316
+    function getSortableWidgetInstance(element) {
+        // this is a fix to support jquery-ui prior to v1.11.x
+        // otherwise we should be using `element.sortable('instance')`
+        var data = element.data('ui-sortable');
+        if (data && typeof data === 'object' && data.widgetFullName === 'ui-sortable') {
+            return data;
+        }
+        return null;
+    }
+
 });

app/directives/archetypeclickoutside.js

@@ -0,0 +1,29 @@
+angular.module("umbraco.directives")
+    .directive('archetypeClickOutside', function ($timeout, $parse) {
+        return {
+            restrict: 'A',
+            link: function (scope, element, attrs, ctrl) {
+                var fn = $parse(attrs.archetypeClickOutside);
+
+                // add click event handler (delayed so we don't trigger the callback immediately if this directive itself was triggered by a mouse click)
+                $timeout(function () {
+                  $(document).on("click", mouseClick);
+                }, 500);
+
+                function mouseClick(event) {  
+                    if($(event.target).closest(element).length > 0) {
+                        return;
+                    }
+                    var callback = function () {
+                        fn(scope, { $event: event });
+                    };
+                    scope.$apply(callback);
+                }
+
+                // unbind event
+                scope.$on('$destroy', function () {
+                    $(document).off("click", mouseClick);
+                });
+            }
+        };
+    });

app/directives/archetypecustomview.js

@@ -1,7 +1,7 @@
 angular.module("umbraco.directives").directive('archetypeCustomView', function ($compile, $http) {
     var linker = function (scope, element, attrs) {
 
-        var view = "/App_plugins/Archetype/views/archetype.default.html";
+        var view = "../App_plugins/Archetype/views/archetype.default.html";
         if(scope.model.config.customViewPath) {
             view = scope.model.config.customViewPath;
         }

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);
@@ -82,83 +40,12 @@ angular.module("umbraco.directives").directive('archetypeProperty', function ($c
 
                 var mergedConfig = _.extend(defaultConfigObj, config);
 
-                loadView(pathToView, mergedConfig, defaultValue, alias, propertyAlias, scope, element, ngModelCtrl, propertyValueChanged);
+                loadView(pathToView, mergedConfig, defaultValue, alias, propertyAlias, scope, element, ngModelCtrl, configFieldsetModel);
             });
         });
-
-        scope.$on("formSubmitting", function (ev, args) {
-            // validate all fieldset properties
-            _.each(scope.fieldset.properties, function (property) {
-                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);
-        });
-
-        // called when the value of any property in a fieldset changes
-        function propertyValueChanged(fieldset, property) {
-            // it's the Umbraco way to hide the invalid state when altering an invalid property, even if the new value isn't valid either
-            property.isValid = true;
-            setFieldsetValidity(fieldset);
-        }
-
-        // validate a property in a fieldset
-        function validateProperty(fieldset, property) {
-            var propertyConfig = 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)) {
-                    property.isValid = false;
-                }
-                // issue 116: RegEx validate property value
-                // Only validate the property value if anything has been entered - RegEx is considered a supplement to "required".
-                if (property.isValid == true && propertyConfig.regEx && property.value) {
-                    var regEx = new RegExp(propertyConfig.regEx);
-                    if (regEx.test(property.value) == false) {
-                        property.isValid = false;
-                    }
-                }
-            }
-
-            setFieldsetValidity(fieldset);
-        }
-
-        function setFieldsetValidity(fieldset) {
-            // mark the entire fieldset as invalid if there are any invalid properties in the fieldset, otherwise mark it as valid
-            fieldset.isValid =
-                _.find(fieldset.properties, function (property) {
-                    return property.isValid == false
-                }) == null;
-        }
     }
 
-    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("-");
-    };
-
-    function loadView(view, config, defaultValue, alias, propertyAlias, scope, element, ngModelCtrl, propertyValueChanged) {
+    function loadView(view, config, defaultValue, alias, propertyAlias, scope, element, ngModelCtrl, configFieldsetModel) {
         if (view)
         {
             $http.get(view, { cache: true }).success(function (data) {
@@ -174,14 +61,26 @@ 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
-                    var renderModelPropertyIndex = getPropertyIndexByAlias(scope.archetypeRenderModel.fieldsets[scope.fieldsetIndex].properties, alias);
+                    scope.renderModelPropertyIndex = archetypeService.getPropertyIndexByAlias(archetypeService.getFieldset(scope).properties, alias);
 
-                    if (!renderModelPropertyIndex)
+                    if (!scope.renderModelPropertyIndex)
                     {
-                        scope.archetypeRenderModel.fieldsets[scope.fieldsetIndex].properties.push(JSON.parse('{"alias": "' + alias + '", "value": "' + defaultValue + '"}'));
-                        renderModelPropertyIndex = getPropertyIndexByAlias(scope.archetypeRenderModel.fieldsets[scope.fieldsetIndex].properties, alias);
+                        var propertyValue = { alias: alias, value: defaultValue };
+                        archetypeService.getFieldset(scope).properties.push(propertyValue);
+                        scope.renderModelPropertyIndex = archetypeService.getPropertyIndexByAlias(archetypeService.getFieldset(scope).properties, alias);
+                    }
+
+                    scope.renderModel = {};
+                    scope.model.value = archetypeService.getFieldsetProperty(scope).value;
+
+                    // init the property editor state (while ensuring the temporary ID is retained
+                    // from any prior initializations).
+                    var fieldsetProperty = archetypeService.getFieldsetProperty(scope);
+                    var oldState = fieldsetProperty.editorState;
+                    archetypeService.ensureTemporaryId(fieldsetProperty);
+                    if (oldState) {
+                        fieldsetProperty.editorState.temporaryId = oldState.temporaryId;
                     }
-                    scope.model.value = scope.archetypeRenderModel.fieldsets[scope.fieldsetIndex].properties[renderModelPropertyIndex].value;
 
                     //set the config from the prevalues
                     scope.model.config = config;
@@ -201,17 +100,77 @@ angular.module("umbraco.directives").directive('archetypeProperty', function ($c
                         }
                     }
 
-                    //console.log(scope.model.config);
+                    //hacks for various built-in datatyps including upload, colorpicker and tags
+                    if (!scope.propertyForm) {
+                        scope.propertyForm = scope.form;
+                    }
+                    if (!scope.model.validation) {
+                        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) {
-                        scope.archetypeRenderModel.fieldsets[scope.fieldsetIndex].properties[renderModelPropertyIndex].value = newValue;
+                        
+                        archetypeService.getFieldsetProperty(scope).value = newValue;
 
                         // notify the linker that the property value changed
-                        propertyValueChanged(scope.archetypeRenderModel.fieldsets[scope.fieldsetIndex], scope.archetypeRenderModel.fieldsets[scope.fieldsetIndex].properties[renderModelPropertyIndex]);
+                        archetypeService.propertyValueChanged(archetypeService.getFieldset(scope), archetypeService.getFieldsetProperty(scope));
+                    });
+
+                    scope.$on('archetypeFormSubmitting', function (ev, args) {
+                        // #385 - revert the changes made in #311 to avoid publishing invalid fieldsets (leaving the code from #311 here, in case we figure out how to re-introduce "save as draft")
+                        // if(args.action !== 'save') {
+                        // validate all fieldset properties
+                        _.each(scope.fieldset.properties, function (property) {
+                            archetypeService.validateProperty(scope.fieldset, property, configFieldsetModel);
+                        });
+
+                        var validationKey = "validation-f" + scope.fieldsetIndex;
+
+                        ngModelCtrl.$setValidity(validationKey, scope.fieldset.isValid);
+                        // }
+
+                        // did the value change (if it did, it most likely did so during the "formSubmitting" event)
+                        var property = archetypeService.getFieldsetProperty(scope);
+
+                        var currentValue = property.value;
+
+                        if (currentValue != scope.model.value) {
+                            archetypeService.getFieldsetProperty(scope).value = scope.model.value;
+
+                            // notify the linker that the property value changed
+                            archetypeService.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);
+                    });
+
+                    scope.$on("archetypeRemoveFieldset", function (ev, args) {
+                        var validationKey = "validation-f" + args.index;
+                        ngModelCtrl.$setValidity(validationKey, true);
                     });
 
                     element.html(data).show();
@@ -244,4 +203,4 @@ angular.module("umbraco.directives").directive('archetypeProperty', function ($c
             umbracoForm: '='
         }
     }
-});
+});

app/directives/archetypesubmitwatcher.js

@@ -0,0 +1,25 @@
+angular.module("umbraco.directives").directive('archetypeSubmitWatcher', function ($rootScope) {
+    var linker = function (scope, element, attrs, ngModelCtrl) {
+        // call the load callback on scope to obtain the ID of this submit watcher
+        var id = scope.loadCallback ? scope.loadCallback() : 0;
+
+        scope.$on("formSubmitting", function (ev, args) {
+            // on the "formSubmitting" event, call the submit callback on scope to notify the Archetype controller to do it's magic
+            if (id == scope.activeSubmitWatcher) {
+                scope.submitCallback(args);
+            }
+        });
+    }
+
+    return {
+        restrict: "E",
+        replace: true,
+        link: linker,
+        template: "",
+        scope: {
+            loadCallback: '=',
+            submitCallback: '=',
+            activeSubmitWatcher: '='
+        }
+    }
+});

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.archetypeCacheService.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.archetypeCacheService.getEntityById(scope, value.typeData.contentId, "Document");
+                    }
+                    break;
+
+                case "media":
+                    if(value.typeData.mediaId) {
+                        entity = scope.services.archetypeCacheService.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/langs/da-dk.js

@@ -1,6 +1,7 @@
 {
 	"label": "Label",
 	"alias": "Alias",
+	"addFieldset": "Tilføj et element",
 	"hideFieldsetControls": "Skjul fieldsets?",
 	"hideFieldsetControlsDescription": "Skjuler kontrollerne tilføj/fjern/sortér.",
 	"toggleAdvanced": "Slå avancerede muligheder til/fra",
@@ -37,5 +38,25 @@
 	"deepDatatypeRequest":"Enable Deep Datatype Requests?",
 	"deepDatatypeRequestDescription":"Allows for easier datatype interception at the cost of caching performance.",
     "overrideDefaultConverterDescription":"Check this if you wish to use your own custom property value converter.",
-    "overrideDefaultConverter":"Override Default Property Value Converter?"
+    "overrideDefaultConverter":"Override Default Property Value Converter?",
+    "enableCloning":"Enable Cloning?",
+ 	"enableCloningDescription":"Enable Fieldset Cloning.",
+  "fieldsetGroups":"Fieldset-grupper",
+  "fieldsetGroupsDescription":"Hvis du har mange fieldsets, skal du måske overveje at gruppere dem i fieldset-vælgeren. Når du først har defineret dine grupper her, vil en gruppe-vælger dukke op i fieldset-editoren, og du kan derefter vælge grupper for alle dine fieldsets.",
+  "fieldsetGroupName":"Navn",
+  "addFieldsetGroup":"Tilføj gruppe",
+  "enablePublishing": "Aktivér fieldset-publicering?",
+  "enablePublishingDescription": "Tillad automatisk udgivelse og udløb for fieldsets",
+  "publish": "Publicering",
+  "publishHelpText": "Konfigurér udgivelses- og udløbsdato for dette element",
+  "publishReleaseDate": "Udgivelsesdato",
+  "publishExpireDate": "Udløbsdato",
+  "settings": "Indstillinger",
+  "enableMemberGroups": "Aktivér medlems-grupper",
+  "enableMemerGroupsDescription": "Tillad at fieldsets kun vises for specifikke medlems-grupper",
+  "allowedMemberGroups": "Tilladte medlems-grupper",
+  "allowedMemberGroupsHelpText": "Vælg de medlems-grupper, der skal kunne se dette element. Hvis der ikke er valgt nogen, kan alle se elementet.",
+  "previewFieldsetOpen": "(se eksempel)",
+  "previewFieldsetHeader": "Eksempel: ",
+  "previewFieldsetClose": "(luk eksempel)"
 }

app/langs/da.js

@@ -0,0 +1,62 @@
+{
+	"label": "Label",
+	"alias": "Alias",
+	"addFieldset": "Tilføj et element",
+	"hideFieldsetControls": "Skjul fieldsets?",
+	"hideFieldsetControlsDescription": "Skjuler kontrollerne tilføj/fjern/sortér.",
+	"toggleAdvanced": "Slå avancerede muligheder til/fra",
+	"toggleAdvancedDescription": "Vis avancerede muligheder.",
+	"hidePropertyLabels": "Skjul labels på egenskaber?",
+	"hidePropertyLabelsDescription": "Skjuler labels på egenskaber.",
+	"maxFieldsets": "Maks antal fieldsets",
+	"maxFieldsetsDescription": "Hvor mange fieldsets er tilladt? Hvis der skrives '1' vil deaktivere kontrollerne. Som standard er det ubegrænset.",
+	"enableMultipleFieldsets": "Aktivér flere Fieldsets?",
+	"enableMultipleFieldsetsDescription": "Tillader flere typer af fieldsets i denne archetype.",
+	"hideFieldsetToolbar": "Skjul Fieldset værktøjslinie?",
+	"hideFieldsetToolbarDescription": "Skjuler den fieldset værktøjslinie der fremkommer når der findes mere end ét fieldset.",
+	"customWrapperClass": "Egen Wrapper Class",
+	"customWrapperClassDescription": "(Mulighed) Angiv din egen CSS class som tilføjes på wrapper div'en.",
+	"cssFile": "CSS fil",
+	"cssFileDescription": "(Mulighed) Tilføj en sti til din egen CSS fil der skal inkluderes på siden.",
+	"jsFile": "JavaScript fil",
+	"jsFileDescription": "(Mulighed) Tilføj en sti til din egen JavaScript fil der skal inkluderes på siden.",
+	"toggleDeveloperMode": "Slå udvikler muligheder til/fra.",
+	"toggleDeveloperModeDescription": "Aktivér på udvikler muligheder.",
+	"configModel": "Konfigurationsmodel",
+	"configModelDescription": "Vær forsigt med at redigere teksten for neden, den kontrollerer skemaet for denne archetype.",
+	"helpText": "Hjælpe tekst",
+	"defaultValue": "Standard værdi",
+	"dataType": "Datatype",
+	"required": "Påkrævet",
+	"regEx": "RegEx validering",
+	"properties": "Egenskaber",
+	"labelTemplate": "Label skabelon",
+	"select": "Vælg",
+	"icon": "Ikon",
+	"enableDisabling": "Aktivér fieldset-deaktivering?",
+	"enableDisablingDescription": "Tillad brugere at aktivere/deaktivere individuelle fieldsets.",
+	"deepDatatypeRequest":"Enable Deep Datatype Requests?",
+	"deepDatatypeRequestDescription":"Allows for easier datatype interception at the cost of caching performance.",
+    "overrideDefaultConverterDescription":"Check this if you wish to use your own custom property value converter.",
+    "overrideDefaultConverter":"Override Default Property Value Converter?",
+    "enableCloning":"Enable Cloning?",
+ 	"enableCloningDescription":"Enable Fieldset Cloning.",
+  "fieldsetGroups":"Fieldset-grupper",
+  "fieldsetGroupsDescription":"Hvis du har mange fieldsets, skal du måske overveje at gruppere dem i fieldset-vælgeren. Når du først har defineret dine grupper her, vil en gruppe-vælger dukke op i fieldset-editoren, og du kan derefter vælge grupper for alle dine fieldsets.",
+  "fieldsetGroupName":"Navn",
+  "addFieldsetGroup":"Tilføj gruppe",
+  "enablePublishing": "Aktivér fieldset-publicering?",
+  "enablePublishingDescription": "Tillad automatisk udgivelse og udløb for fieldsets",
+  "publish": "Publicering",
+  "publishHelpText": "Konfigurér udgivelses- og udløbsdato for dette element",
+  "publishReleaseDate": "Udgivelsesdato",
+  "publishExpireDate": "Udløbsdato",
+  "settings": "Indstillinger",
+  "enableMemberGroups": "Aktivér medlems-grupper",
+  "enableMemerGroupsDescription": "Tillad at fieldsets kun vises for specifikke medlems-grupper",
+  "allowedMemberGroups": "Tilladte medlems-grupper",
+  "allowedMemberGroupsHelpText": "Vælg de medlems-grupper, der skal kunne se dette element. Hvis der ikke er valgt nogen, kan alle se elementet.",
+  "previewFieldsetOpen": "(se eksempel)",
+  "previewFieldsetHeader": "Eksempel: ",
+  "previewFieldsetClose": "(luk eksempel)"
+}

app/langs/de-de.js

@@ -1,6 +1,7 @@
 {
 	"label": "Label",
 	"alias": "Alias",
+	"addFieldset": "Add an item",
 	"hideFieldsetControls": "Hide Fieldset Controls?",
 	"hideFieldsetControlsDescription": "Hides the fieldset add/remove/sort controls.",
 	"toggleAdvanced": "Toggle Advanced Options",
@@ -37,5 +38,11 @@
 	"deepDatatypeRequest":"Enable Deep Datatype Requests?",
 	"deepDatatypeRequestDescription":"Allows for easier datatype interception at the cost of caching performance.",
     "overrideDefaultConverterDescription":"Check this if you wish to use your own custom property value converter.",
-    "overrideDefaultConverter":"Override Default Property Value Converter?"
+    "overrideDefaultConverter":"Override Default Property Value Converter?",
+    "enableCloning":"Enable Cloning?",
+ 	"enableCloningDescription":"Enable Fieldset Cloning.",
+  "fieldsetGroups":"Fieldset groups",
+  "fieldsetGroupsDescription":"If you have a lot of fieldsets to choose from, you may want to consider grouping them in the fieldset picker. Once you have created your groups here, a group picker will be displayed in the fieldset editor and you can assign your fieldsets to their respective groups.",
+  "fieldsetGroupName":"Name",
+  "addFieldsetGroup":"Add group"
 }

app/langs/de.js

@@ -0,0 +1,48 @@
+{
+	"label": "Label",
+	"alias": "Alias",
+	"addFieldset": "Add an item",
+	"hideFieldsetControls": "Hide Fieldset Controls?",
+	"hideFieldsetControlsDescription": "Hides the fieldset add/remove/sort controls.",
+	"toggleAdvanced": "Toggle Advanced Options",
+	"toggleAdvancedDescription": "Show advanced options.",
+	"hidePropertyLabels": "Hide Property Labels?",
+	"hidePropertyLabelsDescription": "Hides the property labels.",
+	"maxFieldsets": "Max Fieldsets",
+	"maxFieldsetsDescription": "How many Fieldsets are allowed? Entering '1' will disable the controls. Default is unlimited.",
+	"enableMultipleFieldsets": "Enable Multiple Fieldsets?",
+	"enableMultipleFieldsetsDescription": "Allows multiple types of fieldsets within this archetype.",
+	"hideFieldsetToolbar": "Hide Fieldset Toolbar?",
+	"hideFieldsetToolbarDescription": "Hides the fieldset toolbar that appears when more than one fieldset model appears.",
+	"customWrapperClass": "Custom Wrapper Class",
+	"customWrapperClassDescription": "(Optional) Enter a custom CSS class that will be applied to the wrapper div.",
+	"cssFile": "CSS File",
+	"cssFileDescription": "(Optional) Enter a path for a custom CSS file to be included on the page.",
+	"jsFile": "JS File",
+	"jsFileDescription": "(Optional) Enter a path for a custom JS file to be included on the page.",
+	"toggleDeveloperMode": "Toggle Developer Mode",
+	"toggleDeveloperModeDescription": "Turn on for developer options.",
+	"configModel": "Config Model",
+	"configModelDescription": "Be careful editing the text below, it controls the schema for this archetype.",
+	"helpText": "Help Text",
+	"defaultValue": "Default Value",
+	"dataType": "DataType",
+	"required": "Required",
+	"regEx": "RegEx Validation",
+	"properties": "Properties",
+	"labelTemplate": "Label Template",
+	"select": "Select",
+	"icon": "Icon",
+	"enableDisabling": "Enable Fieldset Disabling?",
+	"enableDisablingDescription": "Allows fieldsets to be individually enabled/disabled.",
+	"deepDatatypeRequest":"Enable Deep Datatype Requests?",
+	"deepDatatypeRequestDescription":"Allows for easier datatype interception at the cost of caching performance.",
+    "overrideDefaultConverterDescription":"Check this if you wish to use your own custom property value converter.",
+    "overrideDefaultConverter":"Override Default Property Value Converter?",
+    "enableCloning":"Enable Cloning?",
+ 	"enableCloningDescription":"Enable Fieldset Cloning.",
+  "fieldsetGroups":"Fieldset groups",
+  "fieldsetGroupsDescription":"If you have a lot of fieldsets to choose from, you may want to consider grouping them in the fieldset picker. Once you have created your groups here, a group picker will be displayed in the fieldset editor and you can assign your fieldsets to their respective groups.",
+  "fieldsetGroupName":"Name",
+  "addFieldsetGroup":"Add group"
+}

app/langs/en-gb.js

@@ -1,6 +1,7 @@
 {
 	"label": "Label",
 	"alias": "Alias", 
+	"addFieldset": "Add an item",
 	"hideFieldsetControls": "Hide Fieldset Controls?",
 	"hideFieldsetControlsDescription": "Hides the fieldset add/remove/sort controls.",
 	"toggleAdvanced": "Toggle Advanced Options",
@@ -37,5 +38,13 @@
 	"deepDatatypeRequest":"Enable Deep Datatype Requests?",
 	"deepDatatypeRequestDescription":"Allows for easier datatype interception at the cost of caching performance.",
     "overrideDefaultConverterDescription":"Check this if you wish to use your own custom property value converter.",
-    "overrideDefaultConverter":"Override Default Property Value Converter?"
+    "overrideDefaultConverter":"Override Default Property Value Converter?",
+    "enableCloning":"Enable Cloning?",
+ 	"enableCloningDescription":"Enable Fieldset Cloning.",
+	"enableCrossDragging":"Enable Cross-Archetype Dragging?",
+	"enableCrossDraggingDescription":"Allows fieldsets to be dragged into other Archetypes.",
+  "fieldsetGroups":"Fieldset groups",
+  "fieldsetGroupsDescription":"If you have a lot of fieldsets to choose from, you may want to consider grouping them in the fieldset picker. Once you have created your groups here, a group picker will be displayed in the fieldset editor and you can assign your fieldsets to their respective groups.",
+  "fieldsetGroupName":"Name",
+  "addFieldsetGroup":"Add group"
 }

app/langs/en-us.js

@@ -1,6 +1,7 @@
 {
 	"label": "Label",
 	"alias": "Alias",
+	"addFieldset": "Add an item",
 	"hideFieldsetControls": "Hide Fieldset Controls?",
 	"hideFieldsetControlsDescription": "Hides the fieldset add/remove/sort controls.",
 	"toggleAdvanced": "Toggle Advanced Options",
@@ -37,5 +38,13 @@
 	"deepDatatypeRequest":"Enable Deep Datatype Requests?",
 	"deepDatatypeRequestDescription":"Allows for easier datatype interception at the cost of caching performance.",
     "overrideDefaultConverterDescription":"Check this if you wish to use your own custom property value converter.",
-    "overrideDefaultConverter":"Override Default Property Value Converter?"
+    "overrideDefaultConverter":"Override Default Property Value Converter?",
+    "enableCloning":"Enable Cloning?",
+ 	"enableCloningDescription":"Enable Fieldset Cloning.",
+	"enableCrossDragging":"Enable Cross-Archetype Dragging?",
+	"enableCrossDraggingDescription":"Allows fieldsets to be dragged into other Archetypes.",
+  "fieldsetGroups":"Fieldset groups",
+  "fieldsetGroupsDescription":"If you have a lot of fieldsets to choose from, you may want to consider grouping them in the fieldset picker. Once you have created your groups here, a group picker will be displayed in the fieldset editor and you can assign your fieldsets to their respective groups.",
+  "fieldsetGroupName":"Name",
+  "addFieldsetGroup":"Add group"
 }

app/langs/en.js

@@ -0,0 +1,50 @@
+{
+	"label": "Label",
+	"alias": "Alias",
+	"addFieldset": "Add an item",
+	"hideFieldsetControls": "Hide Fieldset Controls?",
+	"hideFieldsetControlsDescription": "Hides the fieldset add/remove/sort controls.",
+	"toggleAdvanced": "Toggle Advanced Options",
+	"toggleAdvancedDescription": "Show advanced options.",
+	"hidePropertyLabels": "Hide Property Labels?",
+	"hidePropertyLabelsDescription": "Hides the property labels.",
+	"maxFieldsets": "Max Fieldsets",
+	"maxFieldsetsDescription": "How many Fieldsets are allowed? Entering '1' will disable the controls. Default is unlimited.",
+	"enableMultipleFieldsets": "Enable Multiple Fieldsets?",
+	"enableMultipleFieldsetsDescription": "Allows multiple types of fieldsets within this archetype.",
+	"hideFieldsetToolbar": "Hide Fieldset Toolbar?",
+	"hideFieldsetToolbarDescription": "Hides the fieldset toolbar that appears when more than one fieldset model appears.",
+	"customWrapperClass": "Custom Wrapper Class",
+	"customWrapperClassDescription": "(Optional) Enter a custom CSS class that will be applied to the wrapper div.",
+	"cssFile": "CSS File",
+	"cssFileDescription": "(Optional) Enter a path for a custom CSS file to be included on the page.",
+	"jsFile": "JS File",
+	"jsFileDescription": "(Optional) Enter a path for a custom JS file to be included on the page.",
+	"toggleDeveloperMode": "Toggle Developer Mode",
+	"toggleDeveloperModeDescription": "Turn on for developer options.",
+	"configModel": "Config Model",
+	"configModelDescription": "Be careful editing the text below, it controls the schema for this archetype.",
+	"helpText": "Help Text",
+	"defaultValue": "Default Value",
+	"dataType": "DataType",
+	"required": "Required",
+	"regEx": "RegEx Validation",
+	"properties": "Properties",
+	"labelTemplate": "Label Template",
+	"select": "Select",
+	"icon": "Icon",
+	"enableDisabling": "Enable Fieldset Disabling?",
+	"enableDisablingDescription": "Allows fieldsets to be individually enabled/disabled.",
+	"deepDatatypeRequest":"Enable Deep Datatype Requests?",
+	"deepDatatypeRequestDescription":"Allows for easier datatype interception at the cost of caching performance.",
+    "overrideDefaultConverterDescription":"Check this if you wish to use your own custom property value converter.",
+    "overrideDefaultConverter":"Override Default Property Value Converter?",
+    "enableCloning":"Enable Cloning?",
+ 	"enableCloningDescription":"Enable Fieldset Cloning.",
+	"enableCrossDragging":"Enable Cross-Archetype Dragging?",
+	"enableCrossDraggingDescription":"Allows fieldsets to be dragged into other Archetypes.",
+  "fieldsetGroups":"Fieldset groups",
+  "fieldsetGroupsDescription":"If you have a lot of fieldsets to choose from, you may want to consider grouping them in the fieldset picker. Once you have created your groups here, a group picker will be displayed in the fieldset editor and you can assign your fieldsets to their respective groups.",
+  "fieldsetGroupName":"Name",
+  "addFieldsetGroup":"Add group"
+}

app/langs/es-es.js

@@ -1,6 +1,7 @@
 {
 	"label": "Label",
 	"alias": "Alias",
+	"addFieldset": "Add an item",
 	"hideFieldsetControls": "Hide Fieldset Controls?",
 	"hideFieldsetControlsDescription": "Hides the fieldset add/remove/sort controls.",
 	"toggleAdvanced": "Toggle Advanced Options",
@@ -37,5 +38,11 @@
 	"deepDatatypeRequest":"Enable Deep Datatype Requests?",
 	"deepDatatypeRequestDescription":"Allows for easier datatype interception at the cost of caching performance.",
     "overrideDefaultConverterDescription":"Check this if you wish to use your own custom property value converter.",
-    "overrideDefaultConverter":"Override Default Property Value Converter?"
+    "overrideDefaultConverter":"Override Default Property Value Converter?",
+    "enableCloning":"Enable Cloning?",
+ 	"enableCloningDescription":"Enable Fieldset Cloning.",
+  "fieldsetGroups":"Fieldset groups",
+  "fieldsetGroupsDescription":"If you have a lot of fieldsets to choose from, you may want to consider grouping them in the fieldset picker. Once you have created your groups here, a group picker will be displayed in the fieldset editor and you can assign your fieldsets to their respective groups.",
+  "fieldsetGroupName":"Name",
+  "addFieldsetGroup":"Add group"
 }

app/langs/es.js

@@ -0,0 +1,48 @@
+{
+	"label": "Label",
+	"alias": "Alias",
+	"addFieldset": "Add an item",
+	"hideFieldsetControls": "Hide Fieldset Controls?",
+	"hideFieldsetControlsDescription": "Hides the fieldset add/remove/sort controls.",
+	"toggleAdvanced": "Toggle Advanced Options",
+	"toggleAdvancedDescription": "Show advanced options.",
+	"hidePropertyLabels": "Hide Property Labels?",
+	"hidePropertyLabelsDescription": "Hides the property labels.",
+	"maxFieldsets": "Max Fieldsets",
+	"maxFieldsetsDescription": "How many Fieldsets are allowed? Entering '1' will disable the controls. Default is unlimited.",
+	"enableMultipleFieldsets": "Enable Multiple Fieldsets?",
+	"enableMultipleFieldsetsDescription": "Allows multiple types of fieldsets within this archetype.",
+	"hideFieldsetToolbar": "Hide Fieldset Toolbar?",
+	"hideFieldsetToolbarDescription": "Hides the fieldset toolbar that appears when more than one fieldset model appears.",
+	"customWrapperClass": "Custom Wrapper Class",
+	"customWrapperClassDescription": "(Optional) Enter a custom CSS class that will be applied to the wrapper div.",
+	"cssFile": "CSS File",
+	"cssFileDescription": "(Optional) Enter a path for a custom CSS file to be included on the page.",
+	"jsFile": "JS File",
+	"jsFileDescription": "(Optional) Enter a path for a custom JS file to be included on the page.",
+	"toggleDeveloperMode": "Toggle Developer Mode",
+	"toggleDeveloperModeDescription": "Turn on for developer options.",
+	"configModel": "Config Model",
+	"configModelDescription": "Be careful editing the text below, it controls the schema for this archetype.",
+	"helpText": "Help Text",
+	"defaultValue": "Default Value",
+	"dataType": "DataType",
+	"required": "Required",
+	"regEx": "RegEx Validation",
+	"properties": "Properties",
+	"labelTemplate": "Label Template",
+	"select": "Select",
+	"icon": "Icon",
+	"enableDisabling": "Enable Fieldset Disabling?",
+	"enableDisablingDescription": "Allows fieldsets to be individually enabled/disabled.",
+	"deepDatatypeRequest":"Enable Deep Datatype Requests?",
+	"deepDatatypeRequestDescription":"Allows for easier datatype interception at the cost of caching performance.",
+    "overrideDefaultConverterDescription":"Check this if you wish to use your own custom property value converter.",
+    "overrideDefaultConverter":"Override Default Property Value Converter?",
+    "enableCloning":"Enable Cloning?",
+ 	"enableCloningDescription":"Enable Fieldset Cloning.",
+  "fieldsetGroups":"Fieldset groups",
+  "fieldsetGroupsDescription":"If you have a lot of fieldsets to choose from, you may want to consider grouping them in the fieldset picker. Once you have created your groups here, a group picker will be displayed in the fieldset editor and you can assign your fieldsets to their respective groups.",
+  "fieldsetGroupName":"Name",
+  "addFieldsetGroup":"Add group"
+}

app/langs/fr-fr.js

@@ -1,6 +1,7 @@
 {
 	"label": "Label",
 	"alias": "Alias",
+	"addFieldset": "Add an item",
 	"hideFieldsetControls": "Hide Fieldset Controls?",
 	"hideFieldsetControlsDescription": "Hides the fieldset add/remove/sort controls.",
 	"toggleAdvanced": "Toggle Advanced Options",
@@ -37,5 +38,11 @@
 	"deepDatatypeRequest":"Enable Deep Datatype Requests?",
 	"deepDatatypeRequestDescription":"Allows for easier datatype interception at the cost of caching performance.",
     "overrideDefaultConverterDescription":"Check this if you wish to use your own custom property value converter.",
-    "overrideDefaultConverter":"Override Default Property Value Converter?"
+    "overrideDefaultConverter":"Override Default Property Value Converter?",
+    "enableCloning":"Enable Cloning?",
+ 	"enableCloningDescription":"Enable Fieldset Cloning.",
+  "fieldsetGroups":"Fieldset groups",
+  "fieldsetGroupsDescription":"If you have a lot of fieldsets to choose from, you may want to consider grouping them in the fieldset picker. Once you have created your groups here, a group picker will be displayed in the fieldset editor and you can assign your fieldsets to their respective groups.",
+  "fieldsetGroupName":"Name",
+  "addFieldsetGroup":"Add group"
 }

app/langs/he-il.js

@@ -1,6 +1,7 @@
 {
 	"label": "Label",
 	"alias": "Alias",
+	"addFieldset": "Add an item",
 	"hideFieldsetControls": "Hide Fieldset Controls?",
 	"hideFieldsetControlsDescription": "Hides the fieldset add/remove/sort controls.",
 	"toggleAdvanced": "Toggle Advanced Options",
@@ -37,5 +38,11 @@
 	"deepDatatypeRequest":"Enable Deep Datatype Requests?",
 	"deepDatatypeRequestDescription":"Allows for easier datatype interception at the cost of caching performance.",
     "overrideDefaultConverterDescription":"Check this if you wish to use your own custom property value converter.",
-    "overrideDefaultConverter":"Override Default Property Value Converter?"
+    "overrideDefaultConverter":"Override Default Property Value Converter?",
+    "enableCloning":"Enable Cloning?",
+ 	"enableCloningDescription":"Enable Fieldset Cloning.",
+  "fieldsetGroups":"Fieldset groups",
+  "fieldsetGroupsDescription":"If you have a lot of fieldsets to choose from, you may want to consider grouping them in the fieldset picker. Once you have created your groups here, a group picker will be displayed in the fieldset editor and you can assign your fieldsets to their respective groups.",
+  "fieldsetGroupName":"Name",
+  "addFieldsetGroup":"Add group"
 }

app/langs/it-it.js

@@ -1,6 +1,7 @@
 {
 	"label": "Label",
 	"alias": "Alias",
+	"addFieldset": "Add an item",
 	"hideFieldsetControls": "Hide Fieldset Controls?",
 	"hideFieldsetControlsDescription": "Hides the fieldset add/remove/sort controls.",
 	"toggleAdvanced": "Toggle Advanced Options",
@@ -37,5 +38,11 @@
 	"deepDatatypeRequest":"Enable Deep Datatype Requests?",
 	"deepDatatypeRequestDescription":"Allows for easier datatype interception at the cost of caching performance.",
     "overrideDefaultConverterDescription":"Check this if you wish to use your own custom property value converter.",
-    "overrideDefaultConverter":"Override Default Property Value Converter?"
+    "overrideDefaultConverter":"Override Default Property Value Converter?",
+    "enableCloning":"Enable Cloning?",
+ 	"enableCloningDescription":"Enable Fieldset Cloning.",
+  "fieldsetGroups":"Fieldset groups",
+  "fieldsetGroupsDescription":"If you have a lot of fieldsets to choose from, you may want to consider grouping them in the fieldset picker. Once you have created your groups here, a group picker will be displayed in the fieldset editor and you can assign your fieldsets to their respective groups.",
+  "fieldsetGroupName":"Name",
+  "addFieldsetGroup":"Add group"
 }

app/langs/ja-jp.js

@@ -1,6 +1,7 @@
 {
 	"label": "Label",
 	"alias": "Alias",
+	"addFieldset": "Add an item",
 	"hideFieldsetControls": "Hide Fieldset Controls?",
 	"hideFieldsetControlsDescription": "Hides the fieldset add/remove/sort controls.",
 	"toggleAdvanced": "Toggle Advanced Options",
@@ -37,5 +38,11 @@
 	"deepDatatypeRequest":"Enable Deep Datatype Requests?",
 	"deepDatatypeRequestDescription":"Allows for easier datatype interception at the cost of caching performance.",
     "overrideDefaultConverterDescription":"Check this if you wish to use your own custom property value converter.",
-    "overrideDefaultConverter":"Override Default Property Value Converter?"
+    "overrideDefaultConverter":"Override Default Property Value Converter?",
+    "enableCloning":"Enable Cloning?",
+ 	"enableCloningDescription":"Enable Fieldset Cloning.",
+  "fieldsetGroups":"Fieldset groups",
+  "fieldsetGroupsDescription":"If you have a lot of fieldsets to choose from, you may want to consider grouping them in the fieldset picker. Once you have created your groups here, a group picker will be displayed in the fieldset editor and you can assign your fieldsets to their respective groups.",
+  "fieldsetGroupName":"Name",
+  "addFieldsetGroup":"Add group"
 }

app/langs/ko-kr.js

@@ -1,6 +1,7 @@
 {
 	"label": "Label",
 	"alias": "Alias",
+	"addFieldset": "Add an item",
 	"hideFieldsetControls": "Hide Fieldset Controls?",
 	"hideFieldsetControlsDescription": "Hides the fieldset add/remove/sort controls.",
 	"toggleAdvanced": "Toggle Advanced Options",
@@ -37,5 +38,11 @@
 	"deepDatatypeRequest":"Enable Deep Datatype Requests?",
 	"deepDatatypeRequestDescription":"Allows for easier datatype interception at the cost of caching performance.",
     "overrideDefaultConverterDescription":"Check this if you wish to use your own custom property value converter.",
-    "overrideDefaultConverter":"Override Default Property Value Converter?"
+    "overrideDefaultConverter":"Override Default Property Value Converter?",
+    "enableCloning":"Enable Cloning?",
+ 	"enableCloningDescription":"Enable Fieldset Cloning.",
+  "fieldsetGroups":"Fieldset groups",
+  "fieldsetGroupsDescription":"If you have a lot of fieldsets to choose from, you may want to consider grouping them in the fieldset picker. Once you have created your groups here, a group picker will be displayed in the fieldset editor and you can assign your fieldsets to their respective groups.",
+  "fieldsetGroupName":"Name",
+  "addFieldsetGroup":"Add group"
 }

app/langs/nb-no.js

@@ -1,6 +1,7 @@
 {
 	"label": "Label",
 	"alias": "Alias",
+	"addFieldset": "Add an item",
 	"hideFieldsetControls": "Hide Fieldset Controls?",
 	"hideFieldsetControlsDescription": "Hides the fieldset add/remove/sort controls.",
 	"toggleAdvanced": "Toggle Advanced Options",
@@ -37,5 +38,11 @@
 	"deepDatatypeRequest":"Enable Deep Datatype Requests?",
 	"deepDatatypeRequestDescription":"Allows for easier datatype interception at the cost of caching performance.",
     "overrideDefaultConverterDescription":"Check this if you wish to use your own custom property value converter.",
-    "overrideDefaultConverter":"Override Default Property Value Converter?"
+    "overrideDefaultConverter":"Override Default Property Value Converter?",
+    "enableCloning":"Enable Cloning?",
+ 	"enableCloningDescription":"Enable Fieldset Cloning.",
+  "fieldsetGroups":"Fieldset groups",
+  "fieldsetGroupsDescription":"If you have a lot of fieldsets to choose from, you may want to consider grouping them in the fieldset picker. Once you have created your groups here, a group picker will be displayed in the fieldset editor and you can assign your fieldsets to their respective groups.",
+  "fieldsetGroupName":"Name",
+  "addFieldsetGroup":"Add group"
 }

app/langs/nl-nl.js

@@ -1,6 +1,7 @@
 {
 	"label": "Label",
 	"alias": "Alias",
+	"addFieldset": "Add an item",
 	"hideFieldsetControls": "Hide Fieldset Controls?",
 	"hideFieldsetControlsDescription": "Hides the fieldset add/remove/sort controls.",
 	"toggleAdvanced": "Toggle Advanced Options",
@@ -37,5 +38,11 @@
 	"deepDatatypeRequest":"Enable Deep Datatype Requests?",
 	"deepDatatypeRequestDescription":"Allows for easier datatype interception at the cost of caching performance.",
     "overrideDefaultConverterDescription":"Check this if you wish to use your own custom property value converter.",
-    "overrideDefaultConverter":"Override Default Property Value Converter?"
+    "overrideDefaultConverter":"Override Default Property Value Converter?",
+    "enableCloning":"Enable Cloning?",
+ 	"enableCloningDescription":"Enable Fieldset Cloning.",
+  "fieldsetGroups":"Fieldset groups",
+  "fieldsetGroupsDescription":"If you have a lot of fieldsets to choose from, you may want to consider grouping them in the fieldset picker. Once you have created your groups here, a group picker will be displayed in the fieldset editor and you can assign your fieldsets to their respective groups.",
+  "fieldsetGroupName":"Name",
+  "addFieldsetGroup":"Add group"
 }

app/langs/pl-pl.js

@@ -1,6 +1,7 @@
 {
 	"label": "Label",
 	"alias": "Alias",
+	"addFieldset": "Add an item",
 	"hideFieldsetControls": "Hide Fieldset Controls?",
 	"hideFieldsetControlsDescription": "Hides the fieldset add/remove/sort controls.",
 	"toggleAdvanced": "Toggle Advanced Options",
@@ -37,5 +38,11 @@
 	"deepDatatypeRequest":"Enable Deep Datatype Requests?",
 	"deepDatatypeRequestDescription":"Allows for easier datatype interception at the cost of caching performance.",
     "overrideDefaultConverterDescription":"Check this if you wish to use your own custom property value converter.",
-    "overrideDefaultConverter":"Override Default Property Value Converter?"
+    "overrideDefaultConverter":"Override Default Property Value Converter?",
+    "enableCloning":"Enable Cloning?",
+ 	"enableCloningDescription":"Enable Fieldset Cloning.",
+  "fieldsetGroups":"Fieldset groups",
+  "fieldsetGroupsDescription":"If you have a lot of fieldsets to choose from, you may want to consider grouping them in the fieldset picker. Once you have created your groups here, a group picker will be displayed in the fieldset editor and you can assign your fieldsets to their respective groups.",
+  "fieldsetGroupName":"Name",
+  "addFieldsetGroup":"Add group"
 }

app/langs/pt-br.js

@@ -1,6 +1,7 @@
 {
 	"label": "Label",
 	"alias": "Alias",
+	"addFieldset": "Add an item",
 	"hideFieldsetControls": "Hide Fieldset Controls?",
 	"hideFieldsetControlsDescription": "Hides the fieldset add/remove/sort controls.",
 	"toggleAdvanced": "Toggle Advanced Options",
@@ -37,5 +38,11 @@
 	"deepDatatypeRequest":"Enable Deep Datatype Requests?",
 	"deepDatatypeRequestDescription":"Allows for easier datatype interception at the cost of caching performance.",
     "overrideDefaultConverterDescription":"Check this if you wish to use your own custom property value converter.",
-    "overrideDefaultConverter":"Override Default Property Value Converter?"
+    "overrideDefaultConverter":"Override Default Property Value Converter?",
+    "enableCloning":"Enable Cloning?",
+ 	"enableCloningDescription":"Enable Fieldset Cloning.",
+  "fieldsetGroups":"Fieldset groups",
+  "fieldsetGroupsDescription":"If you have a lot of fieldsets to choose from, you may want to consider grouping them in the fieldset picker. Once you have created your groups here, a group picker will be displayed in the fieldset editor and you can assign your fieldsets to their respective groups.",
+  "fieldsetGroupName":"Name",
+  "addFieldsetGroup":"Add group"
 }

app/langs/ru-ru.js

@@ -1,6 +1,7 @@
 {
 	"label": "Label",
 	"alias": "Alias",
+	"addFieldset": "Add an item",
 	"hideFieldsetControls": "Hide Fieldset Controls?",
 	"hideFieldsetControlsDescription": "Hides the fieldset add/remove/sort controls.",
 	"toggleAdvanced": "Toggle Advanced Options",
@@ -37,5 +38,11 @@
 	"deepDatatypeRequest":"Enable Deep Datatype Requests?",
 	"deepDatatypeRequestDescription":"Allows for easier datatype interception at the cost of caching performance.",
     "overrideDefaultConverterDescription":"Check this if you wish to use your own custom property value converter.",
-    "overrideDefaultConverter":"Override Default Property Value Converter?"
+    "overrideDefaultConverter":"Override Default Property Value Converter?",
+    "enableCloning":"Enable Cloning?",
+ 	"enableCloningDescription":"Enable Fieldset Cloning.",
+  "fieldsetGroups":"Fieldset groups",
+  "fieldsetGroupsDescription":"If you have a lot of fieldsets to choose from, you may want to consider grouping them in the fieldset picker. Once you have created your groups here, a group picker will be displayed in the fieldset editor and you can assign your fieldsets to their respective groups.",
+  "fieldsetGroupName":"Name",
+  "addFieldsetGroup":"Add group"
 }

app/langs/sv-se.js

@@ -1,6 +1,7 @@
 {
 	"label": "Label",
 	"alias": "Alias",
+	"addFieldset": "Add an item",
 	"hideFieldsetControls": "Hide Fieldset Controls?",
 	"hideFieldsetControlsDescription": "Hides the fieldset add/remove/sort controls.",
 	"toggleAdvanced": "Toggle Advanced Options",
@@ -37,5 +38,11 @@
 	"deepDatatypeRequest":"Enable Deep Datatype Requests?",
 	"deepDatatypeRequestDescription":"Allows for easier datatype interception at the cost of caching performance.",
     "overrideDefaultConverterDescription":"Check this if you wish to use your own custom property value converter.",
-    "overrideDefaultConverter":"Override Default Property Value Converter?"
+    "overrideDefaultConverter":"Override Default Property Value Converter?",
+    "enableCloning":"Enable Cloning?",
+ 	"enableCloningDescription":"Enable Fieldset Cloning.",
+  "fieldsetGroups":"Fieldset groups",
+  "fieldsetGroupsDescription":"If you have a lot of fieldsets to choose from, you may want to consider grouping them in the fieldset picker. Once you have created your groups here, a group picker will be displayed in the fieldset editor and you can assign your fieldsets to their respective groups.",
+  "fieldsetGroupName":"Name",
+  "addFieldsetGroup":"Add group"
 }

app/langs/zh-cn.js

@@ -1,6 +1,7 @@
 {
 	"label": "Label",
 	"alias": "Alias",
+	"addFieldset": "Add an item",
 	"hideFieldsetControls": "Hide Fieldset Controls?",
 	"hideFieldsetControlsDescription": "Hides the fieldset add/remove/sort controls.",
 	"toggleAdvanced": "Toggle Advanced Options",
@@ -37,5 +38,11 @@
 	"deepDatatypeRequest":"Enable Deep Datatype Requests?",
 	"deepDatatypeRequestDescription":"Allows for easier datatype interception at the cost of caching performance.",
     "overrideDefaultConverterDescription":"Check this if you wish to use your own custom property value converter.",
-    "overrideDefaultConverter":"Override Default Property Value Converter?"
+    "overrideDefaultConverter":"Override Default Property Value Converter?",
+    "enableCloning":"Enable Cloning?",
+ 	"enableCloningDescription":"Enable Fieldset Cloning.",
+  "fieldsetGroups":"Fieldset groups",
+  "fieldsetGroupsDescription":"If you have a lot of fieldsets to choose from, you may want to consider grouping them in the fieldset picker. Once you have created your groups here, a group picker will be displayed in the fieldset editor and you can assign your fieldsets to their respective groups.",
+  "fieldsetGroupName":"Name",
+  "addFieldsetGroup":"Add group"
 }

app/less/archetype.less

@@ -1,10 +1,28 @@
-/* TODO: clean this up */
+{{VERSION}}
 
 .archetypeEditor {
     width: 98%;
 
+    .usky-grid {
+        .cell-tools-menu {
+            height: 385px;
+        }
+        &.withGroups {
+            .cell-tools-menu {
+                height: 415px;
+            }
+        }
+    }
+
+    .open {
+        position: relative;
+    }
+
     .dropdown-menu {
         top: auto;
+        > li > a {
+            border-radius: 6px;
+        }
     }
 
     .controls-no-label {
@@ -12,18 +30,31 @@
     }
 
     a+ul.dropdown-menu {
-        margin-left: 25px;
+        margin-left: 0;
     }
 
-    .icon {
+    .fieldsetIcon {
+        float: left;
+        padding: 0 4px 0 0;
         color: #333;
+        vertical-align: text-bottom;
     }
-    
+
+    .caret {
+        margin: 8px 1px 0 2px;
+        &.caret-right {
+            border-bottom: 4px solid transparent;
+            border-top: 4px solid transparent;
+            border-left: 4px solid #ddd;
+            content: "";
+            margin-top: 6px;
+        }
+    }
+
     fieldset {
-        border: 1px solid #dddddd;
+        border-bottom: 1px dashed #dddddd;
         padding: 0;
         margin-bottom: 5px;
-        background-color: #f1f1f1;
         clear: both;
         display: inline-block;
         width: 100%;
@@ -44,18 +75,49 @@
                 }
 
             }
+            
+            .publishOptions {
+                .publishDate {
+                    display: inline-block;
+                    vertical-align: top;
+                    margin-right: 20px;
+                    
+                    label {
+                        padding: 0 !important;
+                        margin: 0 !important;
+                    }
+                }
+            }
         }
 
         .archetypeFieldsetLabel {
             position: relative;
             width: 100%;
+            min-height: 42px;
 
             .label-sub {
-                padding: 8px 0;
+                padding: 8px 0 8px 0;
                 display: inline-block;
+                min-height: 20px; /* this makes the header clickable when there's no icon and no text */
                 &.module-label {
                     width: 100%;
                 }
+                &:hover {
+                    cursor: pointer;
+    
+                    label  {
+                        span {
+                            text-decoration: underline;
+                        }
+                        &:hover {
+                            cursor: pointer;
+                        }
+                    }
+                    
+                    .caret-right {
+                        border-left-color: #333;
+                    }
+                }
             }
 
             .dropdown-menu {
@@ -64,7 +126,6 @@
                 border-radius: 0;
                 box-shadow: none;
                 margin-top: -10px;
-                /*margin-left: -200px;*/
             }
 
             span {
@@ -77,40 +138,26 @@
                 cursor: default;
             }
 
-            &.enableCollapsing:hover {
-                cursor: pointer;
-
-                label  {
-                    span {
-                        text-decoration: underline;
-                    }
-                    &:hover {
-                        cursor: pointer;
-                    }
-                }
-            }
-
             .caret {
-                margin: 8px 1px 0 15px;
-
-                &.caret-right {
-                    border-bottom: 4px solid transparent;
-                    border-top: 4px solid transparent;
-                    border-left: 4px solid #000000;
-                    content: "";
-                    margin-top: 6px;
-                }
+                position: absolute;
             }
 
             label {
                 margin-bottom: 0;
-                margin-left: 5px;
+                margin-left: 18px;
+                white-space: nowrap;
                 padding: 0;
+                width: ~"calc(100% - 144px)";
+                position: absolute;
                 span {
-                    display: inline-block;
+                    display: block;
+                    overflow: hidden;
+                    text-overflow: ellipsis;
                 }
                 &.dimmed {
-                    color: #d9d9d9;
+                    i, span {
+                        color: #d9d9d9 !important;
+                    }
                 }
             }
 
@@ -119,6 +166,33 @@
                 position: absolute;
                 right: 15px;
                 top: 0;
+
+                .icon {
+                    color: #ddd;
+                    padding: 2px;
+                    font-size: 16px;
+                    &:hover {
+                        color: #333;
+                    }
+                    &.icon-delete:hover {
+                        color: #b94a48;
+                    }
+                    &.icon-disabled {
+                        cursor: default;
+                        &:hover {
+                            color: #ddd;
+                        }
+                    }
+                    &.icon-active {
+                        color: #333;
+                        &:hover {
+                            color: #333;
+                        }
+                    }
+                }
+            }
+            
+            &:hover {
             }
         }
 
@@ -139,11 +213,9 @@
         .archetypeCollapser {
             clear: both;
             height: 100%;
-            padding-top: 12px;
+            padding: 12px 0 0 20px;
             background-color: #fff;
-            border-top: 1px solid silver;
             border-radius: 0 0 0 5px;
-            overflow: hidden;
 
             form {
                 margin-left:20px;
@@ -174,12 +246,25 @@
         border: 1px solid #b94a48;
     }
 
-    .archetypeAddButton:hover {
-        text-decoration: none;
-
-        .archetypeAddButtonText {
-            text-decoration: underline;
+    .archetypeAddButton {
+        color: #ddd;
+        .icon {
+            vertical-align: middle;
         }
+        &:hover {
+            color: #333;
+            text-decoration: none;
+            cursor: pointer;
+
+            .archetypeAddButtonText {
+                text-decoration: underline;
+            }
+
+            .icon {
+                color: #333;
+            }
+        }
+
     }
 
     .multiPropertyTextbox {
@@ -196,12 +281,117 @@
             color: #343434;
         }
     }
+
+    .fieldsetPicker {
+        .icon {
+            color: #333;
+        }
+        ul.elements li {
+            overflow: visible;
+            vertical-align: top;  
+            height: 90px;        
+            .fieldsetPreviewOpen {
+                font-style: italic;
+                a:hover {
+                    text-decoration: underline;
+                }
+            }
+        }
+        ul.groups {
+            display: block;
+            margin: 0;
+            padding: 4px;
+            li {
+                width: auto;
+                margin: 0;
+                padding: 0 20px;
+                font-weight: bold;
+                a {
+                    color: #d9d9d9;
+                    cursor: pointer;
+                }
+                &.active a, a:hover {
+                    color: #999;
+                    text-decoration: none;
+                }
+            }
+        }
+
+        .fieldsetPreview {
+            .fieldsetPreviewClose {
+                font-style: italic;
+                font-size: 12px;
+                text-align: center;
+            }
+            .fieldsetPreviewImage {
+                padding: 6px 0px;
+                img {
+                    height: auto;
+                    max-width: 100%;
+                    vertical-align: middle;
+                    border: 0;
+                    cursor: zoom-in;
+                }
+            }
+        }
+    }
+
+    .settingsWrapper {
+        &:hover {
+            caret {
+                background-color: #333;
+            }
+        }
+        .settingsHeader {
+            label {
+                display: inline-block;
+            }
+            &:hover {
+                cursor: pointer;
+                label {
+                    text-decoration: underline;
+                }
+
+                .caret-right {
+                    border-left-color: #333;
+                }
+            }
+        }
+        .settings {
+            padding: 14px;
+            background-color: #f8f8f8;
+            overflow: hidden;
+
+            .allowedGroups {
+                .umb-membergrouppicker a {
+                    i {
+                        padding-right: 0;
+                        font-size: inherit;
+                    }
+
+                    &:hover i {
+                        color: #333;
+                    }
+                }
+            }
+        }
+    }
+
+    // Necessary to ensure empty lists can be dropped onto when sorting nested fieldsets.
+    .archetypeSortable.archetypeEmpty {
+        &.archetypeCrossDraggable {
+            min-height: 42px;
+            border: 1px dashed #dddddd;
+            margin-top: 5px;
+        }
+    }
 }
 
 .archetypeEditor, .archetypeConfig {
     .archetypeEditorControls {
         float: right;
-
+    }
+    .archetypeEditorControls, .archetypeFieldsetGroups {
         i {
             cursor: pointer;
             &.handle {
@@ -217,6 +407,29 @@
 .archetypeConfig {
     margin-bottom: 20px;
 
+    .archetype-headline {
+
+        img {
+            margin-right: 5px;
+        }
+
+        small {
+            margin-left: 5px;
+        }
+
+        a {
+            float: right;
+
+            img {
+                width: 35px;
+            }
+        }
+    }
+
+    .manual-link {
+        color: blue;
+    }
+
     ul {
         list-style: none;
     }
@@ -227,6 +440,7 @@
 
     label {
         width: 120px;
+        padding-left: 0;
     }
 
     .archetypeEditorControls {
@@ -250,8 +464,11 @@
 
     .archetypeFieldsetOption {
         margin-bottom: 15px;
-        input[type=text]{
-            max-width: 300px;
+        margin-right: 15px;
+
+        input[type=text] {
+            max-width: 100%;
+            width: 100%;
         }
     }
 
@@ -262,15 +479,20 @@
         height: 130px;
     }
 
-    .archetypeOptions label{
-        width: 400px;
+    .archetypeOptions {
+        .btn {
+            margin-bottom: 5px;
+        }
+
+        label {
+            width: 400px;
+        }
     }
 
     .archetypePropertiesWrapper {
         border: 1px solid #ddd;
         padding: 8px;
         margin: -40px 10px 10px 140px;
-        max-width: 475px;
 
         ul {
             padding: 0;
@@ -283,12 +505,13 @@
             background-color: #eee;
 
             input[type=text] {
-                max-width: 190px;
-                width: auto;
+                max-width: 100%;
+                width: 100%;
             }
 
             select {
-                max-width: 160px;
+                max-width: 100%;
+                width: 100%;
             }
         }
 
@@ -298,16 +521,48 @@
     }
 
     .archetypeAdvancedOptions {
-        margin-top: 15px;
-        div {
-            margin-bottom: 10px;
-        }
         label {
-            width: 400px;
+            width: 100%;
+        }
+
+        input[type=text] {
+            width: 100%;
+        }
+
+        input[type=checkbox] {
+            margin-top: 0;
+            margin-right: 2px;
+        }
+
+        small {
+            color: #b3b3b3;
+        }
+
+        .archetypeFieldsetGroups {
+            padding: 0 10px;
+            margin-bottom: 20px;
+
+            ul {
+                padding: 0;
+                margin: 0;
+                margin-top: 15px;
+
+                li {
+
+                    label {
+                        width: 120px;
+                    }
+
+                    input {
+                        vertical-align: middle;
+                        width: 240px;
+                    }
+                }
+            }
         }
     }
 
-    .archetypeMaxFieldsets{
+    .archetypeMaxFieldsets {
         border: 1px solid #ddd;
         width: 40px;
         text-align: right;
@@ -320,8 +575,10 @@
 
     .archetypePropertyCollapser {
         margin-top: 10px;
+
         div {
             margin-bottom: 10px;
+            margin-right: 15px;
         }
     }
 
@@ -332,9 +589,17 @@
     .fieldsetIcon {
         margin-right: 10px;
     }
+
+    small {
+        color: #817f85;
+    }
 }
 
 .ui-sortable-placeholder {
     visibility: visible !important;
     background-color:   #d0e7f1 !important;
 }
+
+.archetype-dialog {
+    margin: 10px;
+}

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", { cache: true }), '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;
@@ -31,6 +31,11 @@ angular.module('umbraco.resources').factory('archetypePropertyEditorResource', f
 
                 return "";
             });
+        },
+        getDllVersion: function() {
+            return umbRequestHelper.resourcePromise(
+                $http.get("backoffice/ArchetypeApi/ArchetypeDataType/GetDllVersion", { cache: true }), 'Failed to retrieve dll version'
+            );
         }
     }
 }); 

app/services/archetypeCacheService.js

@@ -0,0 +1,106 @@
+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;
+     	},
+
+     	getEntityByUmbracoId: function(scope, udi, type) {
+	        var cachedEntity = _.find(entityCache, function (e){
+	            return e.udi == udi;
+	        });
+
+	        if(cachedEntity) {
+	            return cachedEntity;
+	        }
+
+	        //go get it from server
+	        if (!isEntityLookupLoading) {
+	            isEntityLookupLoading = true;
+
+	            scope.resources.entityResource.getByIds([udi], type).then(function (entities) {
+                  // prevent infinite lookups with a default entity
+                  var entity = entities.length > 0 ? entities[0] : { udi: udi, name: "" };
+
+                  entityCache.push(entity);
+
+                  isEntityLookupLoading = false;
+
+	                return entity;
+	            });
+	        }
+
+	        return null;
+     	}
+    }
+});

app/services/archetypeLabelService.js

@@ -0,0 +1,359 @@
+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.MultiNodeTreePicker2":
+                return coreMntpV2(value, scope, datatype);
+            case "Umbraco.MultipleMediaPicker":
+            case "Umbraco.MediaPicker":
+                return coreMediaPicker(value, scope, datatype);
+            case "Umbraco.MediaPicker2":
+                return coreMediaPickerV2(value, scope, datatype);
+            case "Umbraco.DropDown":
+                return coreDropdown(value, scope, datatype);
+    	    case "RJP.MultiUrlPicker":
+    	        return rjpMultiUrlPicker(value, scope, {});
+    	  case "Umbraco.ContentPickerAlias":
+    	    return coreContentPicker(value, scope, datatype);
+    	  case "Umbraco.ContentPicker2":
+    	    return coreContentPickerV2(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 coreMntpV2(value, scope, args) {
+        var ids = value.split(',');
+        if (ids.length == 0) {
+          return "";
+        }
+        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 entity;
+
+        _.each(ids, function (id) {            
+            if(id && !entity) {
+              entity = archetypeCacheService.getEntityByUmbracoId(scope, id, type);
+            }
+        });
+
+        return (entity != null ? entity.name : "") + (ids.length > 1 ? ", ..." : "");
+    }
+
+    function coreMediaPicker(value, scope, args) {
+        if(value) {
+             var entity = archetypeCacheService.getEntityById(scope, value, "media");     
+             
+            if(entity) {
+                return entity.name; 
+            }
+        }
+
+        return "";
+    }
+
+    function coreMediaPickerV2(value, scope, args) {
+        if(value) {
+            var entity = archetypeCacheService.getEntityByUmbracoId(scope, value, "media");
+             
+            if(entity) {
+                return entity.name; 
+            }
+        }
+
+        return "";
+    }
+
+    function coreContentPicker(value, scope, args) {
+      if (value) {
+        var entity = archetypeCacheService.getEntityById(scope, value, "document");
+
+        if (entity) {
+          return entity.name;
+        }
+      }
+
+      return "";
+    }
+
+    function coreContentPickerV2(value, scope, args) {
+      if (value) {
+        var entity = archetypeCacheService.getEntityByUmbracoId(scope, value, "document");
+
+        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 = $("<div/>").html(value).text();
+
+        if(strippedText.length > args.contentLength) {
+        	suffix = "…";
+        }
+
+        return strippedText.substring(0, args.contentLength) + suffix;
+    }
+
+	function rjpMultiUrlPicker(values, scope, args) {
+        var names = [];
+
+        _.each(values, function (value) {
+            if (value.name) {
+                names.push(value.name);
+            }
+        });
+
+        return names.join(", ");
+    }
+	
+	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 = "";
+                }
+                // handle collapsing dollar signs in labels (#387)
+                if (templateLabelValue.indexOf("$$") >= 0) {
+                    templateLabelValue = templateLabelValue.replace(/\$\$/g, "$$$$$$$$");
+                }
+                parsedTemplate = parsedTemplate.replace(match, templateLabelValue);
+            });
+
+            return parsedTemplate;
+        }
+	}
+});

app/services/archetypeLocalizationService.js

@@ -24,7 +24,7 @@ angular.module('umbraco.services').factory('archetypeLocalizationService', funct
         initLocalizedResources:function () {
             var deferred = $q.defer();
             userService.getCurrentUser().then(function(user){
-                $http.get("/App_plugins/Archetype/langs/" + user.locale + ".js", { cache: true }) 
+                $http.get("../App_plugins/Archetype/langs/" + user.locale + ".js", { cache: true }) 
                     .then(function(response){
                         service.resourceFileLoaded = true;
                         service.dictionary = response.data;

app/services/archetypeService.js

@@ -0,0 +1,220 @@
+angular.module('umbraco.services').factory('archetypeService', function () {
+
+    // Variables.
+    var draggedRteArchetype;
+    var rteClass = ".archetypeEditor .umb-rte textarea";
+    var editorSettings = {};
+    var disabledSortables = [];
+
+    //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, excludeUniqueId) {
+            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, true);
+
+            var reversed = _.unique(propertyAliasParts).reverse();
+
+            if (!excludeUniqueId) {
+                reversed.push(_.uniqueId("u-"));
+            }
+
+            return reversed.join("-");
+        },
+        getFieldset: function(scope) {
+            var renderModel = scope.archetypeRenderModel;
+            return renderModel ? renderModel.fieldsets[scope.fieldsetIndex] : null;
+        },
+        getFieldsetProperty: function (scope) {
+            var fieldset = this.getFieldset(scope);
+            return fieldset ? fieldset.properties[scope.renderModelPropertyIndex] : null;
+        },
+        setFieldsetValidity: function (fieldset) {
+            // mark the entire fieldset as invalid if there are any invalid properties in the fieldset, otherwise mark it as valid
+            fieldset.isValid =
+                _.find(fieldset.properties, function (property) {
+                    return property.isValid == false
+                }) == null;
+        },
+        validateProperty: function (fieldset, property, configFieldsetModel) {
+            var propertyConfig = this.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)) {
+                    property.isValid = false;
+                }
+                // issue 116: RegEx validate property value
+                // Only validate the property value if anything has been entered - RegEx is considered a supplement to "required".
+                if (property.isValid == true && propertyConfig.regEx && property.value) {
+                    var regEx = new RegExp(propertyConfig.regEx);
+                    if (regEx.test(property.value) == false) {
+                        property.isValid = false;
+                    }
+                }
+            }
+
+            this.setFieldsetValidity(fieldset);
+        },
+        // called when the value of any property in a fieldset changes
+        propertyValueChanged: function (fieldset, property) {
+            // it's the Umbraco way to hide the invalid state when altering an invalid property, even if the new value isn't valid either
+            property.isValid = true;
+            this.setFieldsetValidity(fieldset);
+        },
+        // This stores the rich text editors in all Archetypes (e.g., during a drag operation).
+        // Typically, the editors will be restored after the drag completes.
+        storeEditors: function (element) {
+
+            // If there are not tinyMCE editors, this may be undefined.
+            if (typeof tinyMCE === "undefined") {
+                return;
+            }
+
+            // Variables.
+            var self = this;
+            draggedRteArchetype = element;
+
+            // Empty the stored settings.
+            editorSettings = {};
+
+            // For fast lookups, store each editor by the element ID.
+            var editorsById = {};
+            for (var i = 0; i < tinyMCE.editors.length; i++) {
+                var tempEditor = tinyMCE.editors[i];
+                editorsById[tempEditor.id] = tempEditor;
+            }
+
+            // Process each rich text editor.
+            $(rteClass).each(function() {
+
+                // Variables.
+                var id = $(this).attr("id");
+                var editor = editorsById[id];
+
+                // Get the property's temporary ID.
+                var scope = angular.element(this).scope().$parent;
+                var property = self.getFieldsetProperty(scope);
+                var tempId = property ? property.editorState.temporaryId : null;
+
+                // Store the editor settings by the temporary ID?
+                if (editor && editor.settings && tempId) {
+                    editorSettings[tempId] = editor.settings;
+                }
+
+            });
+
+        },
+        // This restores the rich text editors in the specified Archetype
+        // (e.g., after a drop drop operation).
+        restoreEditors: function(element) {
+
+            // If there are not tinyMCE editors, this may be undefined.
+            if (typeof tinyMCE === "undefined") {
+                return;
+            }
+
+            // Variables.
+            var bothElements = element
+                ? element.add(draggedRteArchetype)
+                : draggedRteArchetype;
+            var self = this;
+
+            // Process each RTE in both Archetypes.
+            $(rteClass, bothElements).each(function () {
+
+                // Variables.
+                var id = $(this).attr("id");
+
+                // Get the stored editor settings.
+                var scope = angular.element(this).scope().$parent;
+                var property = self.getFieldsetProperty(scope);
+                var tempId = property ? property.editorState.temporaryId : null;
+                var settings = editorSettings[tempId];
+
+                // Remove and reinitialize the editor.
+                if (settings) {
+                    tinyMCE.execCommand("mceRemoveEditor", false, id);
+                    tinyMCE.init(settings);
+                }
+
+            });
+
+        },
+        // Ensures the specified property has a temporary ID in its editor state,
+        // optionally forcing one to be regenerated (if specified).
+        ensureTemporaryId: function(property, regenerateId) {
+            if (!property.editorState) {
+                property.editorState = {};
+            }
+            var editorState = property.editorState;
+            if (!editorState.temporaryId || regenerateId) {
+                editorState.temporaryId = _.uniqueId("property-temp-id-");
+            }
+        },
+        // Remembers a sortable that has been disabled (so it can be enabled later).
+        rememberDisabledSortable: function(sortable) {
+            disabledSortables.push(sortable);
+        },
+        // Enables all of the sortables that were disabled.
+        enableSortables: function() {
+            _.each(disabledSortables, function(sortable) {
+                sortable.enable();
+            });
+            disabledSortables = [];
+        }
+    }
+});

app/views/archetype.config.developer.dialog.html

@@ -0,0 +1,29 @@
+{{VERSION_HTML}}
+<div class="umb-panel archetype-dialog archetypeConfig" ng-controller="ArchetypeConfigOptionsController">
+    <div class="umb-panel-body no-header with-footer umb-scrollable archetypeAdvancedOptions">
+        <h3><archetype-localize key="developer_options">Developer Options</archetype-localize></h3>
+        <div>
+            <label for="archetypeAdvancedOptionsDeepDatatypeRequest"><input type="checkbox" id="archetypeAdvancedOptionsDeepDatatypeRequest" ng-model="dialogData.model.enableDeepDatatypeRequests" /><archetype-localize key="deepDatatypeRequest">Enable Deep Datatype Requests?</archetype-localize><small><archetype-localize key="deepDatatypeRequestDescription">Allows for easier datatype interception at the cost of caching performance.</archetype-localize></small></label>
+        </div>
+        <div>
+            <label for="archetypeAdvancedOptionsDeveloperMode"><input type="checkbox" id="archetypeAdvancedOptionsDeveloperMode" ng-model="dialogData.model.developerMode" /><archetype-localize key="toggleDeveloperMode">Enable Developer Mode?</archetype-localize><small><archetype-localize key="toggleDeveloperModeDescription">Toggle Developer Mode</archetype-localize></small></label>
+        </div>
+        <div>
+            <label for="archetypeOverrideDefaultConverter"><input type="checkbox" id="archetypeOverrideDefaultConverter" ng-model="dialogData.model.overrideDefaultPropertyValueConverter" /><archetype-localize key="overrideDefaultConverter">Override Default Property Value Converter?</archetype-localize><small><archetype-localize key="overrideDefaultConverterDescription">Check this if you wish to use your own custom property value converter.</archetype-localize></small></label>
+        </div>
+
+        <div>
+            <label for="archetypeAdvancedOptionsConfigModel"><archetype-localize key="configModel">Config Model</archetype-localize><small><archetype-localize key="configModelDescription">Be careful editing the text below, it controls the schema for this archetype.</archetype-localize></small></label>
+            <textarea class="archetypeDeveloperModel" id="archetypeAdvancedOptionsConfigModel" ng-model="dialogData.model" ng-change="dialogData.modelChanged = true"></textarea>
+        </div>
+    </div>
+    <div class="umb-panel-footer">
+        <div class="umb-el-wrap umb-panel-buttons">
+            <div class="btn-toolbar umb-btn-toolbar pull-right">
+                <button class="btn" ng-click="apply()">
+                    <archetype-localize key="button_close">Close</archetype-localize>
+                </button>
+            </div>
+        </div>
+    </div>
+</div>

app/views/archetype.config.fieldset.dialog.html

@@ -0,0 +1,78 @@
+{{VERSION_HTML}}
+<div class="umb-panel archetype-dialog archetypeConfig" ng-controller="ArchetypeConfigOptionsController">
+    <div class="umb-panel-body no-header with-footer umb-scrollable archetypeAdvancedOptions">
+        <h3><archetype-localize key="global_fieldset_options">Global Fieldset Options</archetype-localize></h3>
+        <div>
+            <label for="archetypeAdvancedOptionsStartWithAddButton"><input type="checkbox" id="archetypeAdvancedOptionsStartWithAddButton" ng-model="dialogData.model.startWithAddButton"/><archetype-localize key="startWithAddButton">Start With Add Button?</archetype-localize><small><archetype-localize key="startWithAddButtonDescription">Empty property shows an add button instead of providing a default fieldset.</archetype-localize></small></label>
+        </div>
+        <div>
+            <label for="archetypeAdvancedOptionsHideLabels"><input type="checkbox" id="archetypeAdvancedOptionsHideLabels" ng-model="dialogData.model.hidePropertyLabels"/><archetype-localize key="hidePropertyLabels">Hide Property Labels?</archetype-localize><small><archetype-localize key="hidePropertyLabelsDescription">Hides the property labels.</archetype-localize></small></label>       
+        </div>
+        <div>
+            <label for="archetypeAdvancedOptionsCollapsing"><input type="checkbox" id="archetypeAdvancedOptionsCollapsing" ng-model="dialogData.model.enableCollapsing"/><archetype-localize key="enableCollapsing">Enable Collapsing?</archetype-localize><small><archetype-localize key="enableCollapsingDescription">Enable fieldset collapsing.</archetype-localize></small></label>
+        </div>
+        <div>
+            <label for="archetypeAdvancedOptionsMultipleOpen"><input type="checkbox" id="archetypeAdvancedOptionsMultipleOpen" ng-model="dialogData.model.enableMultipleOpen" /><archetype-localize key="enableMultipleOpen">Enable Multiple Open Fieldsets?</archetype-localize><small><archetype-localize key="enableMultipleOpenDescription">When fieldset collapsing is enabled, this allows multiple fieldsets to be open at the same time.</archetype-localize></small></label>
+        </div>
+        <div>
+            <label for="archetypeAdvancedOptionsMinFieldsets"><archetype-localize key="minFieldsets">Min Fieldsets</archetype-localize><small><archetype-localize key="minFieldsetsDescription">How many Fieldsets are required? Default is none.</archetype-localize></small></label>
+            <input type="number" id="archetypeAdvancedOptionsMinFieldsets" class="archetypeMaxFieldsets" ng-model="dialogData.model.minFieldsets" />
+        </div>
+        <div>
+            <label for="archetypeAdvancedOptionsMaxFieldsets"><archetype-localize key="maxFieldsets">Max Fieldsets</archetype-localize><small><archetype-localize key="maxFieldsetsDescription">How many Fieldsets are allowed? Entering '1' will disable the controls. Default is unlimited.</archetype-localize></small></label>
+            <input type="number" id="archetypeAdvancedOptionsMaxFieldsets" class="archetypeMaxFieldsets" ng-model="dialogData.model.maxFieldsets"/>
+        </div>
+
+        <h4><archetype-localize key="fieldsetControls">Fieldset controls</archetype-localize></h4>
+        <div>
+            <label for="archetypeAdvancedOptionsHideControls"><input type="checkbox" id="archetypeAdvancedOptionsHideControls" ng-model="dialogData.model.hideFieldsetControls"/><archetype-localize key="hideFieldsetControls">Hide Fieldset Controls?</archetype-localize><small><archetype-localize key="hideFieldsetControlsDescription">Hides the fieldset add/remove/sort controls.</archetype-localize></small></label>
+        </div>
+
+        <div>
+            <label for="archetypeAdvancedOptionsCloning"><input type="checkbox" id="archetypeAdvancedOptionsCloning" ng-model="dialogData.model.enableCloning"/><archetype-localize key="enableCloning">Enable Cloning?</archetype-localize><small><archetype-localize key="enableCloningDescription">Enable fieldset cloning.</archetype-localize></small></label>
+        </div>
+        <div>
+            <label for="archetypeAdvancedOptionsDisabling"><input type="checkbox" id="archetypeAdvancedOptionsDisabling" ng-model="dialogData.model.enableDisabling" /><archetype-localize key="enableDisabling">Enable Fieldset Disabling?</archetype-localize><small><archetype-localize key="enableDisablingDescription">Allows fieldsets to be individually enabled/disabled.</archetype-localize></small></label>
+        </div>
+        <div>
+            <label for="archetypeAdvancedOptionsPublishing"><input type="checkbox" id="archetypeAdvancedOptionsPublishing" ng-model="dialogData.model.enablePublishing" /><archetype-localize key="enablePublishing">Enable Fieldset Publishing?</archetype-localize><small><archetype-localize key="enablePublishingDescription">Allows fieldsets to be automatically published and/or unpublished.</archetype-localize></small></label>
+        </div>
+        <div>
+            <label for="archetypeAdvancedOptionsCrossDragging"><input type="checkbox" id="archetypeAdvancedOptionsCrossDragging" ng-model="dialogData.model.enableCrossDragging" /><archetype-localize key="enableCrossDragging">Enable Cross-Archetype Dragging?</archetype-localize><small><archetype-localize key="enableCrossDraggingDescription">Allows fieldsets to be dragged into other Archetypes.</archetype-localize></small></label>
+		</div>
+		<div>
+            <label for="archetypeAdvancedOptionsMemberGroups"><input type="checkbox" id="archetypeAdvancedOptionsMemberGroups" ng-model="dialogData.model.enableMemberGroups" /><archetype-localize key="enableMemberGroups">Enable Member Group Access?</archetype-localize><small><archetype-localize key="enableMemerGroupsDescription">Allows fieldsets to be displayed for specified member groups only.</archetype-localize></small></label>
+        </div>
+        
+        <h4><archetype-localize key="multipleFieldsets">Multiple fieldsets</archetype-localize></h4>
+        <div>
+            <label for="archetypeAdvancedOptionsMultipleFieldsets"><input type="checkbox" id="archetypeAdvancedOptionsMultipleFieldsets" ng-model="dialogData.model.enableMultipleFieldsets"/><archetype-localize key="enableMultipleFieldsets">Enable Multiple Fieldsets?</archetype-localize><small><archetype-localize key="enableMultipleFieldsetsDescription">Allows multiple types of fieldsets within this archetype.</archetype-localize></small></label>
+        </div>
+
+        <div ng-show="dialogData.model.enableMultipleFieldsets">
+            <label><archetype-localize key="fieldsetGroups">Fieldset groups</archetype-localize></label>
+            <small><archetype-localize key="fieldsetGroupsDescription">If you have a lot of fieldsets to choose from, you may want to consider grouping them in the fieldset picker. Once you have created your groups here, a group picker will be displayed in the fieldset editor and you can assign your fieldsets to their respective groups.</archetype-localize></small>
+            <div class="archetypeFieldsetGroups">
+              <ul ui-sortable="sortableOptions" ng-model="dialogData.model.fieldsetGroups">
+                  <li ng-repeat="fieldsetGroup in dialogData.model.fieldsetGroups">
+                      <div>
+                          <input id="archetypeFieldsetGroupName_{{$index}}" type="text" ng-model="fieldsetGroup.name" />
+                          <i class="icon icon-delete" ng-click="removeFieldsetGroup($index)"></i>
+                          <i class="icon icon-navigation handle" ng-show="dialogData.model.fieldsetGroups.length > 1"></i>
+                      </div>
+                  </li>
+              </ul>
+              <label ng-click="addFieldsetGroup($index)"><i class="icon icon-add"></i> <archetype-localize key="addFieldsetGroup">Add fieldset group</archetype-localize></label>
+            </div>
+        </div>
+    </div>
+    <div class="umb-panel-footer">
+        <div class="umb-el-wrap umb-panel-buttons">
+            <div class="btn-toolbar umb-btn-toolbar pull-right">
+                <button class="btn" ng-click="apply()">
+                    <archetype-localize key="button_close">Close</archetype-localize>
+                </button>
+            </div>
+        </div>
+    </div>
+</div>

app/views/archetype.config.html

@@ -1,4 +1,8 @@
+{{VERSION_HTML}}
 <div class="archetypeConfig" ng-controller="Imulus.ArchetypeConfigController">
+    <h2 class="archetype-headline"><img src="../App_Plugins/Archetype/assets/logo_50.png"/>Archetype<small>{{dllVersion}}</small><a href="https://twitter.com/archetypekit" target="_blank"><img src="../App_Plugins/Archetype/assets/twitter.png"/></a></h2>
+    <p>At a minimum your Archetype needs at least one fieldset with at least one property. You can configure it to allow for multiple types of fieldsets within a single Archetype and you can even add another Archetype as a property. Please use the link below for the full manual:</p>
+    <p><a class="manual-link" href="https://github.com/kgiszewski/ArchetypeManual" target="_blank">Archetype Manual</a></p>
     <ul class="archetypeFieldsets" ui-sortable="sortableOptions" ng-model="archetypeConfigRenderModel.fieldsets">
         <li ng-repeat="fieldset in archetypeConfigRenderModel.fieldsets" ng-hide="fieldset.remove">
             <div class="archetypeFieldsetWrapper" >
@@ -8,18 +12,30 @@
                     <i class="icon icon-navigation handle" ng-show="canSortFieldset()"></i>
                 </div>
                 <div class="archetypeFieldsetTitle" ng-click="focusFieldset(fieldset)">{{fieldset.label}}</div>
-                <div class="archetypeFieldsetCollapser" ng-hide="fieldset.collapse && fieldset.label">
+                <div class="archetypeFieldsetCollapser" ng-hide="fieldset.collapse && fieldset.label" ng-if="isLoaded(fieldset)">
                     <div class="archetypeFieldsetOption">
                         <label for="archetypeFieldLabel_{{$index}}"><archetype-localize key="label">Label</archetype-localize></label>
-                        <input type="text" id="archetypeFieldLabel_{{$index}}" ng-model="fieldset.label" on-keyup="autoPopulateAlias(this)" />
+                        <input type="text" id="archetypeFieldLabel_{{$index}}" ng-model="fieldset.label" on-keyup="autoPopulateAlias(fieldset)" />
+                        <small>The label shown to the editors when adding a new fieldset.</small>
                     </div>
                     <div class="archetypeFieldsetOption">
                         <label for="archetypeFieldAlias_{{$index}}"><archetype-localize key="alias">Alias</archetype-localize></label>
-                        <input type="text" id="archetypeFieldAlias_{{$index}}" ng-model="fieldset.alias" on-keyup="markAliasDirty(this)" required/>
+                        <input type="text" id="archetypeFieldAlias_{{$index}}" ng-model="fieldset.alias" on-keyup="markAliasDirty(fieldset)" required/>
+                        <small>The alias used to identify the fieldset when rendering.</small>
+                    </div>
+                    <div class="archetypeFieldsetOption" ng-show="archetypeConfigRenderModel.fieldsetGroups.length">
+                        <label for="archetypeFieldsetGroup_{{$index}}"><archetype-localize key="fieldsetGroup">Group</archetype-localize></label>
+                        <select id="archetypeFieldsetGroup_{{$index}}" ng-model="fieldset.group" ng-options="fieldsetGroup as fieldsetGroup.name for fieldsetGroup in archetypeConfigRenderModel.fieldsetGroups"></select>
                     </div>
                     <div class="archetypeFieldsetOption">
                         <label for="archetypeFieldLabelTemplate_{{$index}}"><archetype-localize key="labelTemplate">Label Template</archetype-localize></label>
                         <input type="text" id="archetypeFieldLabelTemplate_{{$index}}" ng-model="fieldset.labelTemplate" />
+                        <small>Generates labels per fieldset. Can contain property aliases, e.g. "Article: &#123;&#123;title&#125;&#125;".</small>
+                    </div>
+                    <div class="archetypeFieldsetOption">
+                        <label for="archetypeFieldPreview_{{$index}}">Preview image</label>
+                        <input type="text" id="archetypeFieldPreview_{{$index}}" ng-model="fieldset.previewImage" on-keyup="markAliasDirty(fieldset)" />
+                        <small>A relative path to a preview image, e.g. "/assets/fieldset.png".</small>
                     </div>
                     <div class="archetypeFieldsetOption" ng-show="archetypeConfigRenderModel.enableMultipleFieldsets">
                         <label for="archetypeFieldIcon_{{$index}}"><archetype-localize key="icon">Icon</archetype-localize></label>
@@ -42,11 +58,11 @@
                                 <div class="archetypePropertyCollapser" ng-hide="property.collapse && property.label">
                                     <div>
                                         <label for="archetypePropertyLabel_{{$parent.$index}}_{{$index}}"><archetype-localize key="label">Label</archetype-localize></label>
-                                        <input type="text" id="archetypePropertyLabel_{{$parent.$index}}_{{$index}}" ng-model="property.label" on-keyup="autoPopulateAlias(this)"/>
+                                        <input type="text" id="archetypePropertyLabel_{{$parent.$index}}_{{$index}}" ng-model="property.label" on-keyup="autoPopulateAlias(property)"/>
                                     </div>
                                     <div>
                                         <label for="archetypePropertyAlias_{{$parent.$index}}_{{$index}}"><archetype-localize key="alias">Alias</archetype-localize></label>
-                                        <input type="text" id="archetypePropertyAlias_{{$parent.$index}}_{{$index}}" ng-model="property.alias" on-keyup="markAliasDirty(this)" required/>
+                                        <input type="text" id="archetypePropertyAlias_{{$parent.$index}}_{{$index}}" ng-model="property.alias" on-keyup="markAliasDirty(property)" required/>
                                     </div>
                                     <div>
                                         <label for="archetypePropertyHelpText_{{$parent.$index}}_{{$index}}"><archetype-localize key="helpText">Help Text</archetype-localize></label>
@@ -79,75 +95,9 @@
 
     <div class="archetypeOptions">
         <div>
-            <label for="archetypeOptionsToggle"><archetype-localize key="toggleAdvanced">Toggle Advanced Options</archetype-localize><small><archetype-localize key="toggleAdvancedDescription">Show advanced options.</archetype-localize></small></label>
-            <input type="checkbox" id="archetypeOptionsToggle" ng-model="archetypeConfigRenderModel.showAdvancedOptions"/>
-        </div>
-    </div>
-
-    <div class="archetypeAdvancedOptions" ng-show="archetypeConfigRenderModel.showAdvancedOptions">
-        <div>
-            <label for="archetypeAdvancedOptionsStartWithAddButton"><archetype-localize key="startWithAddButton">Start With Add Button?</archetype-localize><small><archetype-localize key="startWithAddButtonDescription">Empty property shows an add button instead of providing a default fieldset.</archetype-localize></small></label>
-            <input type="checkbox" id="archetypeAdvancedOptionsStartWithAddButton" ng-model="archetypeConfigRenderModel.startWithAddButton"/>
-        </div>
-        <div>
-            <label for="archetypeAdvancedOptionsHideControls"><archetype-localize key="hideFieldsetControls">Hide Fieldset Controls?</archetype-localize><small><archetype-localize key="hideFieldsetControlsDescription">Hides the fieldset add/remove/sort controls.</archetype-localize></small></label>
-            <input type="checkbox" id="archetypeAdvancedOptionsHideControls" ng-model="archetypeConfigRenderModel.hideFieldsetControls"/>
-        </div>
-        <div>
-            <label for="archetypeAdvancedOptionsHideLabels"><archetype-localize key="hidePropertyLabels">Hide Property Labels?</archetype-localize><small><archetype-localize key="hidePropertyLabelsDescription">Hides the property labels.</archetype-localize></small></label>
-            <input type="checkbox" id="archetypeAdvancedOptionsHideLabels" ng-model="archetypeConfigRenderModel.hidePropertyLabels"/>
-        </div>
-        <div>
-            <label for="archetypeAdvancedOptionsMaxFieldsets"><archetype-localize key="maxFieldsets">Max Fieldsets</archetype-localize><small><archetype-localize key="maxFieldsetsDescription">How many Fieldsets are allowed? Entering '1' will disable the controls. Default is unlimited.</archetype-localize></small></label>
-            <input type="number" id="archetypeAdvancedOptionsMaxFieldsets" class="archetypeMaxFieldsets" ng-model="archetypeConfigRenderModel.maxFieldsets"/>
-        </div>
-        <div>
-            <label for="archetypeAdvancedOptionsMultipleFieldsets"><archetype-localize key="enableMultipleFieldsets">Enable Multiple Fieldsets?</archetype-localize><small><archetype-localize key="enableMultipleFieldsetsDescription">Allows multiple types of fieldsets within this archetype.</archetype-localize></small></label>
-            <input type="checkbox" id="archetypeAdvancedOptionsMultipleFieldsets" ng-model="archetypeConfigRenderModel.enableMultipleFieldsets"/>
-        </div>
-        <div>
-            <label for="archetypeAdvancedOptionsCollapsing"><archetype-localize key="enableCollapsing">Enable Collapsing?</archetype-localize><small><archetype-localize key="enableCollapsingDescription">Enable fieldset collapsing.</archetype-localize></small></label>
-            <input type="checkbox" id="archetypeAdvancedOptionsCollapsing" ng-model="archetypeConfigRenderModel.enableCollapsing"/>
-        </div>
-        <div>
-            <label for="archetypeAdvancedOptionsDisabling"><archetype-localize key="enableDisabling">Enable Fieldset Disabling?</archetype-localize><small><archetype-localize key="enableDisablingDescription">Allows fieldsets to be individually enabled/disabled.</archetype-localize></small></label>
-            <input type="checkbox" id="archetypeAdvancedOptionsDisabling" ng-model="archetypeConfigRenderModel.enableDisabling" />
-        </div>
-        <div>
-            <label for="archetypeAdvancedOptionsFieldsetToolbar"><archetype-localize key="hideFieldsetToolbar">Hide Fieldset Toolbar?</archetype-localize><small><archetype-localize key="hideFieldsetToolbarDescription">Hides the fieldset toolbar that appears when more than one fieldset model appears.</archetype-localize></small></label>
-            <input type="checkbox" id="archetypeAdvancedOptionsFieldsetToolbar" ng-model="archetypeConfigRenderModel.hideFieldsetToolbar"/>
-        </div>
-        <div>
-            <label for="archetypeAdvancedOptionsCustomClass"><archetype-localize key="customWrapperClass">Custom Wrapper Class</archetype-localize><small><archetype-localize key="customWrapperClassDescription">(Optional) Enter a custom CSS class that will be applied to the wrapper div.</archetype-localize></small></label>
-            <input type="text" id="archetypeAdvancedOptionsCustomClass" ng-model="archetypeConfigRenderModel.customCssClass"/>
-        </div>
-        <div>
-            <label for="archetypeAdvancedOptionsCustomCss"><archetype-localize key="cssFile">CSS File</archetype-localize><small><archetype-localize key="cssFileDescription">(Optional) Enter a path for a custom CSS file to be included on the page.</archetype-localize></small></label>
-            <input type="text" id="archetypeAdvancedOptionsCustomCss" ng-model="archetypeConfigRenderModel.customCssPath"/>
-        </div>
-        <div>
-            <label for="archetypeAdvancedOptionsCustomJs"><archetype-localize key="jsFile">JS File</archetype-localize><small><archetype-localize key="jsFileDescription">(Optional) Enter a path for a custom JS file to be included on the page.</archetype-localize></small></label>
-            <input type="text" id="archetypeAdvancedOptionsCustomJs" ng-model="archetypeConfigRenderModel.customJsPath"/>
-        </div>
-        <div>
-            <label for="archetypeAdvancedOptionsCustomView"><archetype-localize key="viewFile">View File</archetype-localize><small><archetype-localize key="viewFileDescription">(Optional) Enter a path for a custom view file to be used to render this Archetype.</archetype-localize></small></label>
-            <input type="text" id="archetypeAdvancedOptionsCustomView" ng-model="archetypeConfigRenderModel.customViewPath"/>
-        </div>
-        <div>
-            <label for="archetypeAdvancedOptionsDeepDatatypeRequest"><archetype-localize key="deepDatatypeRequest">Enable Deep Datatype Requests?</archetype-localize><small><archetype-localize key="deepDatatypeRequestDescription">Allows for easier datatype interception at the cost of caching performance.</archetype-localize></small></label>
-            <input type="checkbox" id="archetypeAdvancedOptionsDeepDatatypeRequest" ng-model="archetypeConfigRenderModel.enableDeepDatatypeRequests"/>
-        </div>
-        <div>
-            <label for="archetypeAdvancedOptionsDeveloperMode"><archetype-localize key="toggleDeveloperMode">Enable Developer Mode?</archetype-localize><small><archetype-localize key="toggleDeveloperModeDescription">Toggle Developer Mode</archetype-localize></small></label>
-            <input type="checkbox" id="archetypeAdvancedOptionsDeveloperMode" ng-model="archetypeConfigRenderModel.developerMode"/>
-        </div>
-        <div>
-            <label for="archetypeOverrideDefaultConverter"><archetype-localize key="overrideDefaultConverter">Override Default Property Value Converter?</archetype-localize><small><archetype-localize key="overrideDefaultConverterDescription">Check this if you wish to use your own custom property value converter.</archetype-localize></small></label>
-            <input type="checkbox" id="archetypeOverrideDefaultConverter" ng-model="archetypeConfigRenderModel.overrideDefaultPropertyValueConverter" />
-        </div>
-        <div>
-            <label for="archetypeAdvancedOptionsConfigModel"><archetype-localize key="configModel">Config Model</archetype-localize><small><archetype-localize key="configModelDescription">Be careful editing the text below, it controls the schema for this archetype.</archetype-localize></small></label>
-            <textarea class="archetypeDeveloperModel" id="archetypeAdvancedOptionsConfigModel" ng-model="archetypeConfigRenderModel"></textarea>
+            <button class="btn btn-default" ng-click="showOptions($event, '../App_Plugins/archetype/views/archetype.config.fieldset.dialog.html')"><archetype-localize key="global_fieldset_options">Global Fieldset Options</archetype-localize></button>
+            <button class="btn btn-default" ng-click="showOptions($event, '../App_Plugins/archetype/views/archetype.config.stylescript.dialog.html')"><archetype-localize key="custom_style_script_options">Custom Style/Script Options</archetype-localize></button>
+            <button class="btn btn-default" ng-click="showOptions($event, '../App_Plugins/archetype/views/archetype.config.developer.dialog.html')"><archetype-localize key="developer_options">Developer Options</archetype-localize></button>
         </div>
     </div>
 </div>

app/views/archetype.config.stylescript.dialog.html

@@ -0,0 +1,31 @@
+{{VERSION_HTML}}
+<div class="umb-panel archetype-dialog archetypeConfig" ng-controller="ArchetypeConfigOptionsController">
+    <div class="umb-panel-body no-header with-footer umb-scrollable archetypeAdvancedOptions">
+        <h3><archetype-localize key="custom_style_script_options">Custom Style/Script Options</archetype-localize></h3>
+        <div>
+            <label for="archetypeAdvancedOptionsCustomClass"><archetype-localize key="customWrapperClass">Custom Wrapper Class</archetype-localize><small><archetype-localize key="customWrapperClassDescription">(Optional) Enter a custom CSS class that will be applied to the wrapper div.</archetype-localize></small></label>
+            <input type="text" id="archetypeAdvancedOptionsCustomClass" ng-model="dialogData.model.customCssClass"/>
+        </div>
+        <div>
+            <label for="archetypeAdvancedOptionsCustomCss"><archetype-localize key="cssFile">CSS File</archetype-localize><small><archetype-localize key="cssFileDescription">(Optional) Enter a path for a custom CSS file to be included on the page.</archetype-localize></small></label>
+            <input type="text" id="archetypeAdvancedOptionsCustomCss" ng-model="dialogData.model.customCssPath"/>
+        </div>
+        <div>
+            <label for="archetypeAdvancedOptionsCustomJs"><archetype-localize key="jsFile">JS File</archetype-localize><small><archetype-localize key="jsFileDescription">(Optional) Enter a path for a custom JS file to be included on the page.</archetype-localize></small></label>
+            <input type="text" id="archetypeAdvancedOptionsCustomJs" ng-model="dialogData.model.customJsPath"/>
+        </div>
+        <div>
+            <label for="archetypeAdvancedOptionsCustomView"><archetype-localize key="viewFile">View File</archetype-localize><small><archetype-localize key="viewFileDescription">(Optional) Enter a path for a custom view file to be used to render this Archetype.</archetype-localize></small></label>
+            <input type="text" id="archetypeAdvancedOptionsCustomView" ng-model="dialogData.model.customViewPath"/>
+        </div>
+    </div>
+    <div class="umb-panel-footer">
+        <div class="umb-el-wrap umb-panel-buttons">
+            <div class="btn-toolbar umb-btn-toolbar pull-right">
+                <button class="btn" ng-click="apply()">
+                    <archetype-localize key="button_close">Close</archetype-localize>
+                </button>
+            </div>
+        </div>
+    </div>
+</div>

app/views/archetype.default.html

@@ -1,36 +1,48 @@
+{{VERSION_HTML}}
 <div class="archetypeEditor ng-class:model.config.customCssClass">
     <textarea class="archetypeDeveloperModel" ng-show="model.config.developerMode" ng-model="model.value"></textarea>
-    <ul ui-sortable="sortableOptions" ng-model="model.value.fieldsets" ng-show="!showAddButton()">
+
+    <!-- "Add" button. -->
+    <div ng-show="showAddButton()">
+        <a class="archetypeAddButton" ng-click="openFieldsetPicker(0, $event)" prevent-default>
+            <i class="icon icon-add"></i>
+            <archetype-localize key="addFieldset">Add an item</archetype-localize>
+        </a>
+    </div>
+
+    <!-- Mandatory validation. -->
+    <input type="hidden" name="archetypeMandatory" ng-model="model.mandatoryValidation" ng-required="model.validation.mandatory" />
+    <div><span class="help-inline" val-msg-for="archetypeMandatory" val-toggle-msg="required"><archetype-localize key="required">Required</archetype-localize></span></div>
+
+    <!-- Min fieldsets validation. -->
+    <input type="hidden" name="archetypeMinFieldsets" ng-model="model.mandatoryMinFieldsets" ng-required="!minFieldsetsFulfilled()" />
+    <div><span class="help-inline" val-msg-for="archetypeMinFieldsets" val-toggle-msg="required">{{minFieldsetsMessage}}</span></div>
+
+    <!-- Fieldsets. -->
+    <ul ui-sortable="sortableOptions" class="archetypeSortable" ng-class="{archetypeEmpty: model.value.fieldsets.length === 0 || sortingLastItem(), archetypeCrossDraggable: model.config.enableCrossDragging}" ng-model="model.value.fieldsets">
         <li ng-repeat="fieldset in model.value.fieldsets">
             <fieldset ng-class="['archetype-fieldset-' + fieldset.alias, (getFieldsetValidity(fieldset) == false ? 'archetypeFieldsetError' : '')]" ng-init="fieldsetConfigModel = getConfigFieldsetByAlias(fieldset.alias)">
                 <div class="archetypeFieldsetLabel" ng-class="{enableCollapsing: model.config.enableCollapsing}">
                     <div ng-click="focusFieldset(fieldset)" class="label-sub module-label">
-                        <span class="caret" ng-hide="fieldset.collapse || !model.config.enableCollapsing"></span>
-                        <span class="caret caret-right" ng-show="fieldset.collapse && model.config.enableCollapsing"></span>
-                        <label ng-class="{dimmed: fieldset.disabled}">
+                        <span class="caret" ng-class="{'caret-right': isCollapsed(fieldset)}" ng-show="model.config.enableCollapsing"></span>
+                        <label ng-class="{dimmed: isDisabled(fieldset)}">
                             <i class="fieldsetIcon icon ng-class:fieldsetConfigModel.icon"></i>
                             <span ng-bind="getFieldsetTitle(fieldsetConfigModel, $index)"></span>
                         </label>
                     </div>
                     <div class="archetypeEditorControls label-sub" ng-hide="model.config.hideFieldsetControls">
-                        <i class="icon icon-add dropdown-toggle" ng-show="canAdd()" data-toggle="{{ model.config.fieldsets.length > 1 ? 'dropdown' : ''}}" ng-click="model.config.fieldsets.length == 1 ? addRow(fieldset.alias, $index) : return"></i>
-                        <ul class="dropdown-menu umb-actions">
-                            <li ng-repeat="fieldsetModel in model.config.fieldsets" ng-click="addRow(fieldsetModel.alias, $parent.$index)">
-                                <a>
-                                    <i class="fieldsetIcon icon ng-class:fieldsetModel.icon"></i>
-                                    <span class="menu-label">{{fieldsetModel.label}}</span>
-                                </a>
-                            </li>
-                        </ul>
-                        <i class="icon icon-remove" ng-click="removeRow($index)" ng-show="canRemove()"></i>
-                        <i class="icon icon-power" ng-class="{dimmed: fieldset.disabled}" ng-click="enableDisable(fieldset)" ng-show="canDisable()"></i>
+                        <i class="icon icon-add" ng-show="canAdd()" ng-click="openFieldsetPicker($index, $event)"></i>
                         <i class="icon icon-navigation handle" ng-show="canSort()"></i>
+                        <i class="icon icon-documents" ng-click="cloneRow($index)" ng-show="canClone()"></i>
+                        <i class="icon icon-power" ng-class="{'icon-active': fieldset.disabled}" ng-click="enableDisable(fieldset)" ng-show="showDisableIcon(fieldset)"></i>
+                        <i class="icon icon-time icon-disabled" ng-class="{'icon-active': isDisabledByPublishing(fieldset)}" ng-show="showPublishingIcon(fieldset)"></i>
+                        <i class="icon icon-delete" ng-click="removeRow($index)" ng-show="canRemove()"></i>
                     </div>
                 </div>
-                <div class="archetypeCollapser animate-hide" ng-hide="model.config.enableCollapsing && isCollapsed(fieldset)">
+                <div class="archetypeCollapser animate-hide" ng-hide="model.config.enableCollapsing && isCollapsed(fieldset)" ng-if="isLoaded(fieldset)">
                     <form class="form-inline">
                         <div ng-class="[('archetype-property-' + property.alias), (getPropertyValidity($parent.$index, property.alias) === false ? 'archetypePropertyError' : '')]" class="archetypeProperty control-group" ng-repeat="property in fieldsetConfigModel.properties">
-                            <label ng-hide="model.config.hidePropertyLabels == '1'" class="control-label" for="archetype-property-{{model.alias}}-{{$parent.$index}}-{{$index}}">
+                            <label ng-hide="model.config.hidePropertyLabels == '1'" class="control-label" for="archetype-property-{{model.alias}}-f{{$parent.$index}}-{{property.alias}}-p{{$index}}" ng-attr-title="{{ isDebuggingEnabled || model.config.developerMode ? property.alias : null }}">
                                 <span>{{property.label}}</span>
                                 <div class="archetypeFieldsetHelpText" ng-show="property.helpText">
                                     <small>{{property.helpText}}</small>
@@ -39,6 +51,56 @@
 
                             <div ng-class="[(model.config.hidePropertyLabels == '1' ? 'controls-no-label' : 'controls')]">
                                 <archetype-property class="archetypeEditor" property="property" property-editor-alias="model.alias" fieldset-index="$parent.$index" fieldset="fieldset" archetype-config="model.config" property-config-index="$index" archetype-render-model="model.value" umbraco-form="form"></archetype-property>
+                                <archetype-submit-watcher active-submit-watcher="activeSubmitWatcher" load-callback="submitWatcherOnLoad" submit-callback="submitWatcherOnSubmit"></archetype-submit-watcher>
+                            </div>
+                        </div>
+                        <div class="control-group archetypeProperty settingsWrapper" ng-show="canConfigure()">
+                            <div ng-click="showSettings = !showSettings" class="settingsHeader">
+                                <span class="caret" ng-show="showSettings"></span>
+                                <span class="caret caret-right" ng-hide="showSettings"></span>
+                                <label>
+                                    <span><archetype-localize key="settings">Settings</archetype-localize></span>
+                                </label>
+                            </div>
+                            <div class="settings" ng-show="showSettings">
+                                <!-- misc fieldset settings go here -->
+                                <div ng-if="fieldset.releaseDateModel" ng-show="canPublish()" class="control-group">
+                                    <label ng-hide="model.config.hidePropertyLabels == '1'" class="control-label">
+                                        <span><archetype-localize key="publish">Publishing</archetype-localize></span>
+                                        <div class="archetypeFieldsetHelpText">
+                                            <small><archetype-localize key="publishHelpText">Configure automatic publishing and/or unpublishing of this item</archetype-localize></small>
+                                        </div>
+                                    </label>
+                                    <div class="publishOptions" ng-class="[(model.config.hidePropertyLabels == '1' ? 'controls-no-label' : 'controls')]">
+                                        <div class="publishDate">
+                                            <label for="{{fieldset.releaseDateModel.alias}}">
+                                                <archetype-localize key="publishReleaseDate">Publish at</archetype-localize>
+                                            </label>
+                                            <umb-editor model="fieldset.releaseDateModel"></umb-editor>
+                                        </div>
+                                        <div class="publishDate">
+                                            <label for="{{fieldset.expireDateModel.alias}}">
+                                                <archetype-localize key="publishExpireDate">Unpublish at</archetype-localize>
+                                            </label>
+                                            <umb-editor model="fieldset.expireDateModel"></umb-editor>
+                                        </div>
+                                        <!-- we need a submit watcher here to make sure the publish dates are saved back to their models -->
+                                        <archetype-submit-watcher active-submit-watcher="activeSubmitWatcher" load-callback="submitWatcherOnLoad" submit-callback="submitWatcherOnSubmit"></archetype-submit-watcher>
+                                    </div>
+                                </div>
+                                <div ng-if="fieldset.allowedMemberGroupsModel" ng-show="canUseMemberGroups()" class="control-group allowedGroups">
+                                    <label ng-hide="model.config.hidePropertyLabels == '1'" class="control-label">
+                                        <span><archetype-localize key="allowedMemberGroups">Allowed member groups</archetype-localize></span>
+                                        <div class="archetypeFieldsetHelpText">
+                                            <small><archetype-localize key="allowedMemberGroupsHelpText">Choose the member groups that should be allowed to see this item. Leave empty to allow all member groups.</archetype-localize></small>
+                                        </div>
+                                    </label>
+                                    <div ng-class="[(model.config.hidePropertyLabels == '1' ? 'controls-no-label' : 'controls')]">
+                                        <umb-editor model="fieldset.allowedMemberGroupsModel"></umb-editor>
+                                    </div>
+                                    <!-- we need a submit watcher here to make sure the allowed member groups are saved back to the model -->
+                                    <archetype-submit-watcher active-submit-watcher="activeSubmitWatcher" load-callback="submitWatcherOnLoad" submit-callback="submitWatcherOnSubmit"></archetype-submit-watcher>
+                                </div>
                             </div>
                         </div>
                     </form>
@@ -46,18 +108,49 @@
             </fieldset>
         </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>
-            <i class="icon icon-add dropdown-toggle"></i>
-            <localize key="general_add" class="archetypeAddButtonText">Add</localize>
-        </a>
-        <ul class="dropdown-menu umb-actions">
-            <li ng-repeat="fieldsetModel in model.config.fieldsets" ng-click="addRow(fieldsetModel.alias, 0)">
-                <a>
-                    <i class="fieldsetIcon icon ng-class:fieldsetModel.icon"></i>
-                    <span class="menu-label">{{fieldsetModel.label}}</span>
-                </a>
-            </li>
-        </ul>
+
+    <!-- Fieldset picker. -->
+    <div class="usky-grid fieldsetPicker" ng-class="{withGroups: overlayMenu.fieldsetGroups.length > 1}" ng-if="overlayMenu.show">
+        <div class="cell-tools-menu" ng-style="overlayMenu.style" delayed-mouseleave="closeFieldsetPicker()" archetype-click-outside="closeFieldsetPicker()">
+            <div ng-show="!overlayMenu.fieldsetPreview">
+                <h5>
+                    <archetype-localize key="addFieldset">Add an item</archetype-localize>
+                </h5>
+                <ul class="groups" ng-show="overlayMenu.fieldsetGroups.length > 1">
+                    <li ng-repeat="fieldsetGroup in overlayMenu.fieldsetGroups" ng-class="{active: fieldsetGroup == overlayMenu.activeFieldsetGroup}">
+                        <a ng-click="overlayMenu.activeFieldsetGroup = fieldsetGroup">
+                            {{fieldsetGroup.name}}
+                        </a>
+                    </li>
+                </ul>
+                <ul class="elements">
+                    <li ng-repeat="fieldset in overlayMenu.activeFieldsetGroup.fieldsets">
+                        <a ng-click="pickFieldset(fieldset.alias, overlayMenu.index)" href>
+                            <i class="icon {{fieldset.icon}}"></i>
+                            {{fieldset.label}}
+                        </a>
+                        <div class="fieldsetPreviewOpen" ng-if="fieldset.previewImage">
+                            <a href ng-click="openFieldsetPreview(fieldset)"><archetype-localize key="previewFieldsetOpen">(see preview)</archetype-localize></a>
+                        </div>
+                    </li>
+                </ul>
+            </div>
+            <div ng-show="overlayMenu.fieldsetPreview" class="fieldsetPreview">
+                <h5>
+                    <archetype-localize key="previewFieldsetHeader">Preview: </archetype-localize>{{overlayMenu.fieldsetPreview.label}}
+                </h5>
+                <div class="fieldsetPreviewClose">
+                    <a href ng-click="closeFieldsetPreview()"><archetype-localize key="previewFieldsetClose">(close preview)</archetype-localize></a>
+                </div>
+                <div class="fieldsetPreviewImage">
+                    <a href="{{overlayMenu.fieldsetPreview.previewImage}}" target="_blank">
+                        <img ng-src="{{overlayMenu.fieldsetPreview.previewImage}}" />
+                    </a>
+                </div>
+                <div class="fieldsetPreviewClose">
+                    <a href ng-click="closeFieldsetPreview()"><archetype-localize key="previewFieldsetClose">(close preview)</archetype-localize></a>
+                </div>
+            </div>
+        </div>
     </div>
 </div>

app/views/archetype.html

@@ -1 +1,2 @@
+{{VERSION_HTML}}
 <div archetype-custom-view ng-controller="Imulus.ArchetypeController"></div>

config/meta.json

@@ -1,8 +1,8 @@
 {
 	"name": "Archetype",
-	"version": "1.6.0-beta",
+	"version": "1.15.1",
 	"url": "http://github.com/imulus/archetype/",
-	"author": "Imulus",
+	"author": "Imulus - Kevin Giszewski - Tom Fulton - Lee Kelleher - Matt Brailsford - Kenn Jacobsen - Et. Al.",
 	"authorUrl": "http://imulus.com/",
 	"license": "MIT",
 	"licenseUrl": "http://opensource.org/licenses/MIT"

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="Archetype.Binaries" version="<%= version %>" />
+        </dependencies>
+    </metadata>
 </package>

config/package.xml

@@ -1,39 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="no"?>
-<umbPackage>
-  <info>
-    <package>
-      <name><%= name %></name>
-      <version><%= version %></version>
-      <license url="<%= licenseUrl %>"><%= license %></license>
-      <url><%= url %></url>
-      <requirements>
-        <major>0</major>
-        <minor>0</minor>
-        <patch>0</patch>
-      </requirements>
-    </package>
-    <author>
-      <name><%= author %></name>
-      <website><%= authorUrl %></website>
-    </author>
-    <readme><![CDATA[<%= readmeContents %>]]></readme>
-  </info>
-  <DocumentTypes />
-  <Templates />
-  <Stylesheets />
-  <Macros />
-  <DictionaryItems />
-  <Languages />
-  <DataTypes />
-  <control />
-  <Actions />
-  <files>
-  	<% files.forEach(function(file) { %>
-  	<file>
-      <guid><%= file.guid %>.<%= file.ext %></guid>
-      <orgPath><%= file.dir %></orgPath>
-      <orgName><%= file.name %></orgName>
-    </file>
-	<% }); %>
-  </files>
-</umbPackage>

config/package_binaries.nuspec

@@ -0,0 +1,18 @@
+<?xml version="1.0"?>
+<package xmlns="http://schemas.microsoft.com/packaging/2011/08/nuspec.xsd">
+    <metadata>
+        <id>Archetype.Binaries</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 binaries 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.2.2" />
+        </dependencies>
+    </metadata>
+</package>

config/package_courier.nuspec

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

package.json

@@ -22,13 +22,14 @@
     "grunt-msbuild": "~0.1.9",
     "grunt-dotnet-assembly-info": "~1.0.9",
     "load-grunt-tasks": "~0.4.0",
-    "grunt-umbraco-package": "0.0.5"
+    "grunt-umbraco-package": "^1.0.0"
   },
   "repository": {
     "type": "git",
     "url": "https://github.com/imulus/Archetype.git"
   },
   "devDependencies": {
-    "grunt-msbuild": "^0.1.12"
+    "grunt-msbuild": "^0.1.12",
+    "grunt-string-replace": "^1.2.0"
   }
 }