Merge pull request #436 from kgiszewski/feature/slow-the-updates-roll

Feature/slow the updates roll

.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,13 +82,22 @@ 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/controllers/config.global.controller.js',
           'app/directives/archetypeproperty.js',
+          'app/directives/archetypesubmitwatcher.js',
           'app/directives/archetypecustomview.js',
-          'app/directives/localize.js',
-          'app/services/localization.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',
+          'app/services/archetypeGlobalConfigService.js'
         ],
         dest: '<%= basePath %>/js/archetype.js'
       }
@@ -67,8 +106,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: {
@@ -98,7 +153,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
           }
         ]
@@ -112,60 +173,119 @@ 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',
+        '!app/controllers/config.global.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 %>'
         }
       }
@@ -177,40 +297,30 @@ 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']);
+  grunt.registerTask('assets',  ['clean', 'string-replace', 'less', 'concat', 'assemblyinfo', 'copy:assets', 'copy:html', 'copy:config', 'clean:html', 'clean:js', 'clean:less']);
 };

Information Collection Disclosure.md

@@ -0,0 +1,13 @@
+# Information Collection Disclosure
+
+As of version v1.16.0, we are checking your installed version of Archetype against the current version. In this process we collect the current version of Archetype along with the current version of Umbraco that you are running. We use these values to help determine a response message to you. You may opt-out of this process by 'un-checking' the option in any of the Archetypes you have configured in the `Developer->Data Types` section of Umbraco. 
+
+![opt out](assets/optout3.png)
+
+This is a global setting that will set an `AppSetting` and update a file located at `~/config/archetype.config.js`. If you manually change the setting it will require an app reload to refresh to runtime values. If somehow this file becomes corrupt, a new file will be generated and you will again have to opt out.
+
+We identify your install only by a randomly generated GUID. We WILL NOT store your IP address or hostname during the update check. 
+
+Part of the reason we collect this information is to also ascertain how many active installs exist. If this number is sufficiently high, we can plan accordingly and attempt to keep this project going.
+
+We would ask that you reach out to the Archetype team via creating an issue on this site if you have any questions or concerns. We truly want Archetype to be a win-win for all involved. 

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

@@ -1,18 +1,37 @@
 Archetype
 =========
-![alt tag](http://imulus.github.io/Archetype/images/logo.png)
+![alt tag](http://kgiszewski.github.io/Archetype/images/logo.png)
 
-![alt tag](http://imulus.github.io/Archetype/images/example1.png)
+![alt tag](http://kgiszewski.github.io/Archetype/images/example1.png)
 
 ## 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>.
-
+Install the selected <a href='https://github.com/kgiszewski/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
 
+Get up and running in 15 minutes! https://www.youtube.com/watch?v=79LksNwGjLk
+
+## News and Updates ##
 Follow us on Twitter https://twitter.com/ArchetypeKit
 
+## Core Team ##
+* Kevin Giszewski (founder/project lead) - Tonic - 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/
+
+## Sponsor us\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 :)
+
+[Learn more](Sponsors.md) about sponsorship!
+
+## Information Collection Disclosure
+Please read the information disclosure [here](Information%20Collection%20Disclosure.md).
+
 ## 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.

Sponsors.md

@@ -0,0 +1,13 @@
+# Sponsorship
+
+Are you a company that depends on Archetype? We would love for you to sponsor us! Here's some suggested ways below!
+
+## Sponsor a Sprint
+
+We have a [backlog](https://github.com/kgiszewski/Archetype/issues), it gets worked on when either we have a personal need, we get bored or when we get a sponsorship. If you want to sponsor a sprint, we can give you thanks on social media and if you're really generous, we can put your logo and link on a well placed spot in a version release. [Contact us](https://twitter.com/ArchetypeKit) to get started.
+
+## Donations
+
+If you want to quietly support us, you can also send us a donation:
+
+[![Donate](https://img.shields.io/badge/Donate-PayPal-green.svg)](https://www.paypal.com/cgi-bin/webscr?cmd=_s-xclick&hosted_button_id=KBKWLURGLGU6L)

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

@@ -0,0 +1,116 @@
+<?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>{FE8BE437-8B11-4E49-9B02-F45994E6D723}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>Archetype.Courier</RootNamespace>
+    <AssemblyName>Archetype.Courier</AssemblyName>
+    <TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
+    <FileAlignment>512</FileAlignment>
+    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\</SolutionDir>
+    <RestorePackages>true</RestorePackages>
+  </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="businesslogic">
+      <HintPath>..\packages\UmbracoCms.Core.7.1.2\lib\businesslogic.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="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="Newtonsoft.Json">
+      <HintPath>..\packages\Newtonsoft.Json.6.0.2\lib\net45\Newtonsoft.Json.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="System" />
+    <Reference Include="System.Core" />
+    <Reference Include="Microsoft.CSharp" />
+    <Reference Include="System.Xml" />
+    <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.Courier.Core">
+      <HintPath>lib\Umbraco.Courier.Core.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="Umbraco.Courier.DataResolvers">
+      <HintPath>lib\Umbraco.Courier.DataResolvers.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="Umbraco.Courier.Providers">
+      <HintPath>lib\Umbraco.Courier.Providers.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>
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="..\Umbraco.Archetype\Properties\VersionInfo.cs">
+      <Link>Properties\VersionInfo.cs</Link>
+    </Compile>
+    <Compile Include="DataResolvers\ArchetypeDataResolver.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="packages.config" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\Umbraco.Archetype\Archetype.Umbraco.csproj">
+      <Project>{7d185d41-4228-4978-acb8-83f9a48ad94f}</Project>
+      <Name>Archetype.Umbraco</Name>
+      <Private>True</Private>
+    </ProjectReference>
+  </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/Archetype.Courier/DataResolvers/ArchetypeDataResolver.cs

@@ -0,0 +1,260 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Archetype.Extensions;
+using Archetype.Models;
+using Newtonsoft.Json;
+using Umbraco.Core;
+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
+		{
+			Extracting,
+			Packaging
+		}
+
+        /// <summary>
+        /// Gets the editor alias.
+        /// </summary>
+        /// <value>
+        /// The editor alias.
+        /// </value>
+		public override string EditorAlias
+		{
+			get
+			{
+				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(Constants.PreValueAlias) && !string.IsNullOrWhiteSpace(prevalue.Value))
+				{
+					var config = JsonConvert.DeserializeObject<ArchetypePreValue>(prevalue.Value);
+
+					if (config != null && config.Fieldsets != null)
+					{
+						foreach (var property in config.Fieldsets.SelectMany(x => x.Properties))
+						{
+							item.Dependencies.Add(property.DataTypeGuid.ToString(), ItemProviderIds.dataTypeItemProviderGuid);
+						}
+
+						item.Prevalues[0].Value = JsonConvert.SerializeObject(config, Formatting.None);
+					}
+				}
+			}
+		}
+
+        /// <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 dataType = ExecutionContext.DatabasePersistence.RetrieveItem<DataType>(new ItemIdentifier(propertyData.DataType.ToString(),
+					ItemProviderIds.dataTypeItemProviderGuid));
+
+				//Fetch the Prevalues for the current Property's DataType (if its an 'Archetype config')
+				var prevalue = dataType.Prevalues.FirstOrDefault(x => x.Alias.ToLowerInvariant().Equals("archetypeconfig"));
+				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(ItemProviderIds.propertyDataItemProviderGuid, ExecutionContext);
+
+					foreach (var property in archetype.Fieldsets.SelectMany(x => x.Properties))
+					{
+						if (property == null || string.IsNullOrWhiteSpace(property.PropertyEditorAlias))
+							continue;
+
+						// create a 'fake' item for Courier to process
+						var fakeItem = new ContentPropertyData
+						{
+							ItemId = item.ItemId,
+							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, UmbracoNodeObjectTypeIds.DataType),
+									PropertyEditorAlias = property.PropertyEditorAlias,
+									Value = property.Value
+								}
+							}
+						};
+
+						if (direction == Direction.Packaging)
+						{
+							try
+							{
+								// run the 'fake' item through Courier's data resolvers
+								ResolutionManager.Instance.PackagingItem(fakeItem, propertyItemProvider);
+							}
+							catch (Exception ex)
+							{
+								CourierLogHelper.Error<ArchetypeDataResolver>(string.Concat("Error packaging data value: ", fakeItem.Name), ex);
+							}
+
+							// pass up the dependencies and resources
+							item.Dependencies.AddRange(fakeItem.Dependencies);
+							item.Resources.AddRange(fakeItem.Resources);
+						}
+						else if (direction == Direction.Extracting)
+						{
+							try
+							{
+								// run the 'fake' item through Courier's data resolvers
+								ResolutionManager.Instance.ExtractingItem(fakeItem, propertyItemProvider);
+							}
+							catch (Exception ex)
+							{
+								CourierLogHelper.Error<ArchetypeDataResolver>(string.Concat("Error extracting data value: ", fakeItem.Name), ex);
+							}
+						}
+
+						if (fakeItem.Data != null && fakeItem.Data.Any())
+						{
+							var firstDataType = fakeItem.Data.FirstOrDefault();
+							if (firstDataType != null)
+							{
+								// set the resolved property data value
+								property.Value = firstDataType.Value;
+
+								// (if packaging) add a dependency for the property's data-type
+								if (direction == Direction.Packaging)
+									item.Dependencies.Add(firstDataType.DataType.ToString(), ItemProviderIds.dataTypeItemProviderGuid);
+							}
+						}
+					}
+
+					// serialize the Archetype back to a string
+					propertyData.Value = archetype.SerializeForPersistence();
+				}
+			}
+		}
+
+        /// <summary>
+        /// Retrieves the additional properties.
+        /// </summary>
+        /// <param name="preValue">The pre value.</param>
+		private void RetrieveAdditionalProperties(ref ArchetypePreValue preValue)
+		{
+			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.Courier/Properties/AssemblyInfo.cs

@@ -0,0 +1,14 @@
+using System.Reflection;
+using System.Runtime.InteropServices;
+
+[assembly: AssemblyTitle("Archetype.Courier")]
+[assembly: AssemblyDescription("A set of tools to support Archetype with Umbraco Courier")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("Umbrella Inc Ltd")]
+[assembly: AssemblyProduct("Archetype.Courier")]
+[assembly: AssemblyCopyright("Copyright \xa9 Lee Kelleher, Umbrella Inc Ltd 2014")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+[assembly: ComVisible(false)]
+[assembly: Guid("6F05C431-ABBF-4D77-9D3D-5AF6C8E318AF")]

app/Umbraco/Archetype.Courier/packages.config

@@ -4,8 +4,8 @@
   <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="ImageProcessor" version="1.8.7.0" targetFramework="net45" />
+  <package id="ImageProcessor.Web" version="3.2.1.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" />

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

@@ -33,67 +33,85 @@
   <ItemGroup>
     <Reference Include="AutoMapper">
       <HintPath>..\packages\AutoMapper.3.0.0\lib\net40\AutoMapper.dll</HintPath>
+      <Private>True</Private>
     </Reference>
     <Reference Include="AutoMapper.Net4">
       <HintPath>..\packages\AutoMapper.3.0.0\lib\net40\AutoMapper.Net4.dll</HintPath>
+      <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>True</Private>
     </Reference>
     <Reference Include="ClientDependency.Core">
       <HintPath>..\packages\ClientDependency.1.7.1.2\lib\ClientDependency.Core.dll</HintPath>
+      <Private>True</Private>
     </Reference>
     <Reference Include="ClientDependency.Core.Mvc">
       <HintPath>..\packages\ClientDependency-Mvc.1.7.0.4\lib\ClientDependency.Core.Mvc.dll</HintPath>
+      <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>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>True</Private>
     </Reference>
     <Reference Include="CookComputing.XmlRpcV2">
       <HintPath>..\packages\xmlrpcnet.2.5.0\lib\net20\CookComputing.XmlRpcV2.dll</HintPath>
+      <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>True</Private>
     </Reference>
     <Reference Include="HtmlAgilityPack">
       <HintPath>..\packages\HtmlAgilityPack.1.4.6\lib\Net45\HtmlAgilityPack.dll</HintPath>
+      <Private>True</Private>
     </Reference>
     <Reference Include="ICSharpCode.SharpZipLib">
       <HintPath>..\packages\SharpZipLib.0.86.0\lib\20\ICSharpCode.SharpZipLib.dll</HintPath>
+      <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>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>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>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>True</Private>
     </Reference>
     <Reference Include="Lucene.Net">
       <HintPath>..\packages\Lucene.Net.2.9.4.1\lib\net40\Lucene.Net.dll</HintPath>
+      <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>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>True</Private>
     </Reference>
     <Reference Include="Microsoft.Web.Infrastructure, Version=1.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL">
       <Private>True</Private>
@@ -101,26 +119,33 @@
     </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>True</Private>
     </Reference>
     <Reference Include="MiniProfiler">
       <HintPath>..\packages\MiniProfiler.2.1.0\lib\net40\MiniProfiler.dll</HintPath>
+      <Private>True</Private>
     </Reference>
     <Reference Include="Moq">
       <HintPath>..\packages\Moq.4.2.1312.1622\lib\net40\Moq.dll</HintPath>
+      <Private>True</Private>
     </Reference>
     <Reference Include="MySql.Data">
       <HintPath>..\packages\MySql.Data.6.6.5\lib\net40\MySql.Data.dll</HintPath>
+      <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>True</Private>
     </Reference>
-    <Reference Include="nunit.framework">
-      <HintPath>..\packages\NUnit.2.6.3\lib\nunit.framework.dll</HintPath>
+    <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>True</Private>
     </Reference>
     <Reference Include="System" />
     <Reference Include="System.Core" />
@@ -135,17 +160,21 @@
     <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>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>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>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>True</Private>
     </Reference>
     <Reference Include="System.Web.Mvc, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL">
       <Private>True</Private>
@@ -176,56 +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>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>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>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>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>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>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>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>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>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>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>True</Private>
     </Reference>
   </ItemGroup>
   <ItemGroup>
     <Compile Include="Models\FieldsetTests.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="PropertyValueConverter\PropertyValueConverterTests.cs" />
-    <Compile Include="Serialization\ArchetypeJsonConverterComplexModelTest.cs" />
-    <Compile Include="Serialization\ArchetypeJsonConverterTest.cs" />
-    <Compile Include="Serialization\JsonTestStrings.cs" />
-    <Compile Include="Serialization\JsonTestModels.cs" />
+    <Compile Include="PublishedContent\ArchetypePublishedContentTests.cs" />
+    <Compile Include="PublishedContent\TypeConverterTests.cs" />
   </ItemGroup>
   <ItemGroup>
     <None Include="app.config" />
@@ -236,11 +274,22 @@
     <ProjectReference Include="..\Umbraco.Archetype\Archetype.Umbraco.csproj">
       <Project>{7D185D41-4228-4978-ACB8-83F9A48AD94F}</Project>
       <Name>Archetype.Umbraco</Name>
+      <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>
+    <PreBuildEvent>
+    </PreBuildEvent>
+  </PropertyGroup>
+  <PropertyGroup>
+    <PostBuildEvent>
+    </PostBuildEvent>
+  </PropertyGroup>
   <!-- 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">

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()
         {
@@ -34,6 +34,18 @@ namespace Archetype.Tests.Models
             Assert.That(propertyValue == "Box 1 Title");
         }
 
+        [Test]
+        public void Can_Get_Fieldset_Property_Default_Value_By_Alias() 
+		{
+            var converter = new ArchetypeValueConverter();
+            var result = (Archetype.Models.ArchetypeModel)converter.ConvertDataToSource(null, _sampleJson, false);
+
+            var fieldset = result.Fieldsets.First();
+            var propertyValue = fieldset.GetValue<string>("noSuchProperty", "noSuchProperty default value");
+
+            Assert.That(propertyValue == "noSuchProperty default value");
+        }
+
         [Test]
         public void Can_Convert_Property_Value_Types()
         {
@@ -45,7 +57,7 @@ namespace Archetype.Tests.Models
             Assert.That(fieldset.GetValue<int>("link") == 3175);
             Assert.That(fieldset.GetValue<bool>("show") == true);
             Assert.That(fieldset.GetValue<string>("blurb") == "A blurb here");
-        }
+        }  
 
         [Test]
         public void Returns_String_When_No_Type_Specified()
@@ -59,6 +71,5 @@ namespace Archetype.Tests.Models
             Assert.That(property is string);
             Assert.That(property == "3175");
         }
-
     }
 }

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/Serialization/ArchetypeJsonConverterComplexModelTest.cs

@@ -1,216 +0,0 @@
-using System.Linq;
-using Archetype.PropertyConverters;
-using Newtonsoft.Json;
-using NUnit.Framework;
-
-namespace Archetype.Tests.Serialization
-{
-    [TestFixture]
-    public class ArchetypeJsonConverterComplexModelTest
-    {
-        private TextList _textList;
-        private Captions _captions;
-        private PageDetails _pageDetails;
-
-        private SlideShow _slides;
-        private Seo _seo;
-        private TextPageList _textPages;
-        private PageList _pages;
-        
-        [SetUp]
-        public void SetUp()
-        {
-            InitComplexModels();
-            InitComplexTreeModel();
-        }
-
-        #region complex nested model tests
-
-        [Test]
-        public void PageDetailsModel_Serializes_To_Archetype_Property()
-        {
-            var result = JsonConvert.SerializeObject(_pageDetails, Formatting.Indented);
-            Assert.AreEqual(JsonTestStrings._PAGE_DETAILS_JSON, result);
-        }
-
-        [Test]
-        public void ConvertComplexModelToArchetype()
-        {
-            var converter = new ArchetypeValueConverter();
-            var json = JsonConvert.SerializeObject(_pageDetails, Formatting.Indented);
-            var archetype = (Archetype.Models.ArchetypeModel)converter.ConvertDataToSource(null, json, false);
-
-            Assert.NotNull(archetype);
-        }
-
-        [Test]
-        public void DeserializeComplexModelFromArchetype()
-        {
-            var result = JsonConvert.DeserializeObject<PageDetails>(JsonTestStrings._PAGE_DETAILS_JSON);
-
-            Assert.NotNull(result);
-            Assert.IsInstanceOf<PageDetails>(result);
-
-            Assert.AreEqual("2439,2440,2441,2442,2443,2444,2445,2446,2447,2448,2449,2450,2451,2452,2453", result.Pages);
-            Assert.AreEqual("First Page", result.Captions.TextStringArray.ElementAt(0).TextString);
-            Assert.AreEqual("Second Page", result.Captions.TextStringArray.ElementAt(1).TextString);
-            Assert.AreEqual("Third Page", result.Captions.TextStringArray.ElementAt(2).TextString);
-            Assert.AreEqual("Fourth Page", result.Captions.TextStringArray.ElementAt(3).TextString);
-        }
-
-        [Test]
-        public void SerializeThenDeserializeComplexModelFromArchetype()
-        {
-            var json = JsonConvert.SerializeObject(_pageDetails);
-            var result = JsonConvert.DeserializeObject<PageDetails>(json);
-
-            Assert.NotNull(result);
-            Assert.IsInstanceOf<PageDetails>(result);
-
-            Assert.AreEqual(_pageDetails.Pages, result.Pages);
-            Assert.AreEqual(_pageDetails.Captions.TextStringArray.ElementAt(0).TextString, result.Captions.TextStringArray.ElementAt(0).TextString);
-            Assert.AreEqual(_pageDetails.Captions.TextStringArray.ElementAt(1).TextString, result.Captions.TextStringArray.ElementAt(1).TextString);
-            Assert.AreEqual(_pageDetails.Captions.TextStringArray.ElementAt(2).TextString, result.Captions.TextStringArray.ElementAt(2).TextString);
-            Assert.AreEqual(_pageDetails.Captions.TextStringArray.ElementAt(3).TextString, result.Captions.TextStringArray.ElementAt(3).TextString);
-        }
-        #endregion
-
-        #region complex nested tree model tests
-
-        [Test]
-        public void ConvertComplexNestedModelToArchetype()
-        {
-            var converter = new ArchetypeValueConverter();
-            var json = JsonConvert.SerializeObject(_pages, Formatting.Indented);
-            var archetype = (Archetype.Models.ArchetypeModel)converter.ConvertDataToSource(null, json, false);
-
-            Assert.NotNull(archetype);
-        }
-
-        [Test]
-        public void PagesModel_Serializes_To_Archetype_Property()
-        {
-            var result = JsonConvert.SerializeObject(_pages, Formatting.Indented);
-            Assert.AreEqual(JsonTestStrings._PAGES_JSON, result);
-        }
-
-        [Test]
-        public void DeserializeComplexTreeModelFromArchetype()
-        {
-            var result = JsonConvert.DeserializeObject<PageList>(JsonTestStrings._PAGES_JSON);
-
-            Assert.NotNull(result);
-            Assert.IsInstanceOf<PageList>(result);
-
-            Assert.AreEqual("1,2,3,4,5,6,7,8", result.Pages.ElementAt(0).Media.Slides);
-            Assert.AreEqual("1,2,3,4,5,6,7,8", result.Pages.ElementAt(1).Media.Slides);
-            Assert.AreEqual("1,2,3,4,5,6,7,8", result.Pages.ElementAt(2).Media.Slides);
-
-            Assert.AreEqual("Test Meta Title", result.Pages.ElementAt(0).Seo.MetaTitle);
-            Assert.AreEqual("Test Meta Description", result.Pages.ElementAt(0).Seo.MetaDescription);
-            Assert.AreEqual("Test Meta Title", result.Pages.ElementAt(1).Seo.MetaTitle);
-            Assert.AreEqual("Test Meta Description", result.Pages.ElementAt(1).Seo.MetaDescription);
-            Assert.AreEqual("Test Meta Title", result.Pages.ElementAt(2).Seo.MetaTitle);
-            Assert.AreEqual("Test Meta Description", result.Pages.ElementAt(2).Seo.MetaDescription);
-
-            Assert.AreEqual("Home Page Body", result.Pages.ElementAt(0).BodyText);
-            Assert.AreEqual("Home Page", result.Pages.ElementAt(0).PageTitle);
-            Assert.AreEqual("About us Page Body", result.Pages.ElementAt(1).BodyText);
-            Assert.AreEqual("About us Page", result.Pages.ElementAt(1).PageTitle);
-            Assert.AreEqual("Contact us Page Body", result.Pages.ElementAt(2).BodyText);
-            Assert.AreEqual("Contact us Page", result.Pages.ElementAt(2).PageTitle);
-
-
-        }
-
-        [Test]
-        public void SerializeThenDeserializeComplexTreeModelFromArchetype()
-        {
-            var json = JsonConvert.SerializeObject(_pages);
-            var result = JsonConvert.DeserializeObject<PageList>(json);
-
-            Assert.NotNull(result);
-            Assert.IsInstanceOf<PageList>(result);
-
-            Assert.AreEqual(_pages.Pages.ElementAt(0).Media.Slides, result.Pages.ElementAt(0).Media.Slides);
-            Assert.AreEqual(_pages.Pages.ElementAt(1).Media.Slides, result.Pages.ElementAt(1).Media.Slides);
-            Assert.AreEqual(_pages.Pages.ElementAt(2).Media.Slides, result.Pages.ElementAt(2).Media.Slides);
-
-            Assert.AreEqual(_pages.Pages.ElementAt(0).Seo.MetaTitle, result.Pages.ElementAt(0).Seo.MetaTitle);
-            Assert.AreEqual(_pages.Pages.ElementAt(0).Seo.MetaDescription, result.Pages.ElementAt(0).Seo.MetaDescription);
-            Assert.AreEqual(_pages.Pages.ElementAt(1).Seo.MetaTitle, result.Pages.ElementAt(1).Seo.MetaTitle);
-            Assert.AreEqual(_pages.Pages.ElementAt(1).Seo.MetaDescription, result.Pages.ElementAt(1).Seo.MetaDescription);
-            Assert.AreEqual(_pages.Pages.ElementAt(2).Seo.MetaTitle, result.Pages.ElementAt(2).Seo.MetaTitle);
-            Assert.AreEqual(_pages.Pages.ElementAt(2).Seo.MetaDescription, result.Pages.ElementAt(2).Seo.MetaDescription);
-
-            Assert.AreEqual(_pages.Pages.ElementAt(0).BodyText, result.Pages.ElementAt(0).BodyText);
-            Assert.AreEqual(_pages.Pages.ElementAt(0).PageTitle, result.Pages.ElementAt(0).PageTitle);
-            Assert.AreEqual(_pages.Pages.ElementAt(1).BodyText, result.Pages.ElementAt(1).BodyText);
-            Assert.AreEqual(_pages.Pages.ElementAt(1).PageTitle, result.Pages.ElementAt(1).PageTitle);
-            Assert.AreEqual(_pages.Pages.ElementAt(2).BodyText, result.Pages.ElementAt(2).BodyText);
-            Assert.AreEqual(_pages.Pages.ElementAt(2).PageTitle, result.Pages.ElementAt(2).PageTitle);
-
-
-        }
-
-        #endregion
-
-        #region utility methods
-
-        private void InitComplexModels()
-        {
-            _textList = new TextList
-            {
-                new TextItem{TextString = "First Page"},
-                new TextItem{TextString = "Second Page"},
-                new TextItem{TextString = "Third Page"},
-                new TextItem{TextString = "Fourth Page"}
-            };
-
-            _captions = new Captions {TextStringArray = _textList};
-
-            _pageDetails = new PageDetails
-            {
-                Captions = _captions,
-                Pages = "2439,2440,2441,2442,2443,2444,2445,2446,2447,2448,2449,2450,2451,2452,2453"
-            };            
-        }
-
-        private void InitComplexTreeModel()
-        {
-            _slides = new SlideShow{Slides = "1,2,3,4,5,6,7,8"};
-            _seo = new Seo{MetaDescription = "Test Meta Description", MetaTitle = "Test Meta Title"};
-            _textPages = new TextPageList
-            {
-                new TextPage()
-                {
-                    PageTitle = "Home Page",
-                    BodyText = "Home Page Body",
-                    Media = _slides,
-                    Seo = _seo
-                },
-                new TextPage()
-                {
-                    PageTitle = "About us Page",
-                    BodyText = "About us Page Body",
-                    Media = _slides,
-                    Seo = _seo
-                },
-                new TextPage()
-                {
-                    PageTitle = "Contact us Page",
-                    BodyText = "Contact us Page Body",
-                    Media = _slides,
-                    Seo = _seo
-                }
-            };
-
-            _pages = new PageList
-            {
-                Pages = _textPages
-            };
-        }
-
-        #endregion
-    }
-}

app/Umbraco/Archetype.Tests/Serialization/ArchetypeJsonConverterTest.cs

@@ -1,367 +0,0 @@
-using System;
-using Archetype.PropertyConverters;
-using Newtonsoft.Json;
-using NUnit.Framework;
-
-namespace Archetype.Tests.Serialization
-{
-    [TestFixture]
-    public class ArchetypeJsonConverterTest
-    {
-        private ContactDetails _contactDetails;
-        private CompanyDetails _companyDetails;
-        private AnnualStatement _annualStatement;
-        private MergerDetails _mergerDetails;
-        private UrlPicker _webSite;
-
-        [SetUp]
-        public void SetUp()
-        {
-            _webSite = new UrlPicker
-            {
-                Url = "http://test.com",
-                Title = "The Test Company",
-                OpenInNewWindow = true
-            };
-
-            _mergerDetails = new MergerDetails
-            {
-                MergerDate = new DateTime(2014,6,7,8,9,10),
-                MergerValue = 12345676890.12m
-            };
-
-            _contactDetails = new ContactDetails
-            {
-                Address = "Test Address",
-                Email = "test@test.com",
-                Fax = "000",
-                Mobile = "000",
-                Name = "Test",
-                Telephone = "111",
-                WebSite = _webSite
-            };
-
-            _companyDetails = new CompanyDetails
-            {
-                Region = "Test Region",
-                ContactDetails = _contactDetails
-            };
-
-            _annualStatement = new AnnualStatement
-            {
-                FiscalYearStart = new DateTime(2013, 9, 1),
-                FiscalYearEnd = new DateTime(2014, 8, 31),
-                TotalShares = 345678,
-                Sales = 123456700.89,
-                Profit = 1123456.78m
-            };
-        }
-
-        #region serialization tests
-
-        [Test]
-        public void MergerDetailsModel_Serializes_To_Archetype_Property()
-        {
-            var result = JsonConvert.SerializeObject(_mergerDetails, Formatting.Indented);
-            Assert.AreEqual(JsonTestStrings._MERGER_DETAILS_JSON, result);
-        }        
-        
-        [Test]
-        public void ContactDetailsModel_Serializes_To_Archetype_Property()
-        {
-            var result = JsonConvert.SerializeObject(_contactDetails, Formatting.Indented);
-            Assert.AreEqual(JsonTestStrings._CONTACT_DETAILS_JSON, result);
-        }
-
-        [Test]
-        public void CompanyDetailsModel_Fieldset_Serializes_As_Expected()
-        {
-            var result = JsonConvert.SerializeObject(_companyDetails, Formatting.Indented);
-
-            Assert.AreEqual(JsonTestStrings._COMPANY_DETAILS_JSON, result);
-
-        }
-
-        [Test]
-        public void AnnualStatementModel_Fieldset_Serializes_As_Expected()
-        {
-            var result = JsonConvert.SerializeObject(_annualStatement, Formatting.Indented);
-
-            Assert.AreEqual(JsonTestStrings._ANNUAL_STATEMENT_JSON, result);
-
-        }
-
-        [Test]
-        public void NullValues_Serialize_To_Empty_String()
-        {
-            var result = JsonConvert.SerializeObject(new ContactDetails());
-
-            Assert.AreEqual(JsonTestStrings._NULL_VALUES_JSON, result);
-
-        }
-
-        [Test]
-        public void ConvertModelToArchetype()
-        {
-            var model = new ContactDetails
-            {
-                Address = "addr",
-                Email = "email"
-            };
-
-            var converter = new ArchetypeValueConverter();
-            var json = JsonConvert.SerializeObject(model);
-            var archetype = (Archetype.Models.ArchetypeModel)converter.ConvertDataToSource(null, json, false);
-
-            Assert.NotNull(archetype);
-        }
-
-        [Test]
-        public void ConvertNumericAndDateModelToArchetype()
-        {
-            var converter = new ArchetypeValueConverter();
-            var json = JsonConvert.SerializeObject(_annualStatement);
-            var archetype = (Archetype.Models.ArchetypeModel)converter.ConvertDataToSource(null, json, false);
-
-            Assert.NotNull(archetype);
-        }
-
-        [Test]
-        public void ConvertCompoundModelToArchetype()
-        {
-            var item1 = new ContactDetails
-            {
-                Address = "addr",
-                Email = "email"
-            };
-
-            var item2 = new ContactDetails
-            {
-                Address = "addr1",
-                Name = "email2"
-            };
-
-            var model = new AllContactDetails
-            {
-                UserDetails = item1,
-                AdminDetails = item2
-            };
-
-            var converter = new ArchetypeValueConverter();
-            var json = JsonConvert.SerializeObject(model, Formatting.Indented);
-            var archetype = (Archetype.Models.ArchetypeModel)converter.ConvertDataToSource(null, json, false);
-
-            Assert.NotNull(archetype);
-        }
-
-        [Test]
-        public void ConvertEnumerableModelToArchetype()
-        {
-            var item1 = new ContactDetails
-            {
-                Address = "addr",
-                Email = "email"
-            };
-
-            var item2 = new ContactDetails
-            {
-                Address = "addr1",
-                Name = "email2"
-            };
-
-            var model = new ContactDetailsList
-            {
-                item1,
-                item2
-            };
-
-            var converter = new ArchetypeValueConverter();
-            var json = JsonConvert.SerializeObject(model, Formatting.Indented);
-            var archetype = (Archetype.Models.ArchetypeModel)converter.ConvertDataToSource(null, json, false);
-
-            Assert.NotNull(archetype);
-        }
-
-        [Test]
-        public void ConvertNestedModelToArchetype()
-        {
-            var model = new CompanyDetails
-            {
-                Region = "Test Region",
-                ContactDetails = new ContactDetails
-                {
-                    Address = "addr1",
-                    Name = "email2"
-                }
-            };
-
-            var converter = new ArchetypeValueConverter();
-            var json = JsonConvert.SerializeObject(model, Formatting.Indented);
-            var archetype = (Archetype.Models.ArchetypeModel)converter.ConvertDataToSource(null, json, false);
-
-            Assert.NotNull(archetype);
-        }
-
-        #endregion
-
-        #region deserialization tests
-
-        [Test]
-        public void DeserializeModelFromArchetype()
-        {
-            var result = JsonConvert.DeserializeObject<ContactDetails>(JsonTestStrings._CONTACT_DETAILS_JSON);
-
-            Assert.NotNull(result);
-            Assert.IsInstanceOf<ContactDetails>(result);
-
-            Assert.AreEqual("Test Address", result.Address);
-            Assert.AreEqual("test@test.com", result.Email);
-            Assert.AreEqual("000", result.Fax);
-            Assert.AreEqual("000", result.Mobile);
-            Assert.AreEqual("Test", result.Name);
-            Assert.AreEqual("111", result.Telephone);
-            Assert.AreEqual(_webSite.Content, result.WebSite.Content);
-            Assert.AreEqual(_webSite.Media, result.WebSite.Media);
-            Assert.AreEqual(_webSite.OpenInNewWindow, result.WebSite.OpenInNewWindow);
-            Assert.AreEqual(_webSite.Title, result.WebSite.Title);
-            Assert.AreEqual(_webSite.Url, result.WebSite.Url);
-        }
-
-        [Test]
-        public void DeserializeNumericAndDateModelFromArchetype()
-        {
-            var result = JsonConvert.DeserializeObject<AnnualStatement>(JsonTestStrings._ANNUAL_STATEMENT_JSON);
-
-            Assert.NotNull(result);
-            Assert.IsInstanceOf<AnnualStatement>(result);
-
-            Assert.AreEqual(new DateTime(2013, 9, 1), result.FiscalYearStart);
-            Assert.AreEqual(new DateTime(2014, 8, 31), result.FiscalYearEnd);
-            Assert.IsNull(result.DividendPaymentDate);
-            Assert.AreEqual(345678, result.TotalShares);
-            Assert.AreEqual(123456700.89, result.Sales);
-            Assert.AreEqual(1123456.78m, result.Profit);
-        }
-
-        [Test]
-        public void DeserializeNumericAndDateModel_NullableDate_HasValue_FromArchetype()
-        {
-            var annualStatement = new AnnualStatement
-            {
-                FiscalYearStart = new DateTime(2013, 9, 1),
-                FiscalYearEnd = new DateTime(2014, 8, 31),
-                DividendPaymentDate = new DateTime(2014,9,15,10,15,30),
-                TotalShares = 345678,
-                Sales = 123456700.89,
-                Profit = 1123456.78m
-            };
-
-            var json = JsonConvert.SerializeObject(annualStatement);
-            var result = JsonConvert.DeserializeObject<AnnualStatement>(json);
-
-            Assert.NotNull(result);
-            Assert.IsInstanceOf<AnnualStatement>(result);
-
-            Assert.AreEqual(annualStatement.FiscalYearStart, result.FiscalYearStart);
-            Assert.AreEqual(annualStatement.FiscalYearEnd, result.FiscalYearEnd);
-            Assert.AreEqual(annualStatement.DividendPaymentDate, result.DividendPaymentDate);
-            Assert.AreEqual(annualStatement.TotalShares, result.TotalShares);
-            Assert.AreEqual(annualStatement.Sales, result.Sales);
-            Assert.AreEqual(annualStatement.Profit, result.Profit);
-        }
-
-        [Test]
-        public void DeserializeCompoundModelFromArchetype()
-        {
-            var item1 = new ContactDetails
-            {
-                Address = "addr",
-                Email = "email"
-            };
-
-            var item2 = new ContactDetails
-            {
-                Address = "addr1",
-                Name = "email2"
-            };
-
-            var model = new AllContactDetails
-            {
-                UserDetails = item1,
-                AdminDetails = item2
-            };
-
-            var json = JsonConvert.SerializeObject(model, Formatting.Indented);
-            var result = JsonConvert.DeserializeObject<AllContactDetails>(json);
-
-            Assert.NotNull(result);
-            Assert.IsInstanceOf<AllContactDetails>(result);
-
-            Assert.AreEqual(item1.Address, result.UserDetails.Address);
-            Assert.AreEqual(item1.Email, result.UserDetails.Email);
-            Assert.AreEqual(item2.Address, result.AdminDetails.Address);
-            Assert.AreEqual(item2.Name, result.AdminDetails.Name);
-        }
-
-        [Test]
-        public void DeserializeEnumerableModelFromArchetype()
-        {
-            var item1 = new ContactDetails
-            {
-                Address = "addr",
-                Email = "email"
-            };
-
-            var item2 = new ContactDetails
-            {
-                Address = "addr1",
-                Name = "email2"
-            };
-
-            var model = new ContactDetailsList
-            {
-                item1,
-                item2
-            };
-
-            var json = JsonConvert.SerializeObject(model, Formatting.Indented);
-            var result = JsonConvert.DeserializeObject<ContactDetailsList>(json);
-
-            Assert.NotNull(result);
-            Assert.IsInstanceOf<ContactDetailsList>(result);
-            Assert.AreEqual(result.Count, 2);
-
-            Assert.AreEqual(item1.Address, result[0].Address);
-            Assert.AreEqual(item1.Email, result[0].Email);
-            Assert.AreEqual(item2.Address, result[1].Address);
-            Assert.AreEqual(item2.Name, result[1].Name);
-        }
-
-        [Test]
-        public void DeserializeNestedModelFromArchetype()
-        {
-            var model = new CompanyDetails
-            {
-                Region = "Test Region",
-                ContactDetails = new ContactDetails
-                {
-                    Address = "addr1",
-                    Name = "email2"
-                }
-            };
-
-            var json = JsonConvert.SerializeObject(model, Formatting.Indented);
-            var result = JsonConvert.DeserializeObject<CompanyDetails>(json);
-
-            Assert.NotNull(result);
-            Assert.IsInstanceOf<CompanyDetails>(result);
-
-            Assert.AreEqual(model.Region, result.Region);
-            Assert.AreEqual(model.ContactDetails.Address, result.ContactDetails.Address);
-            Assert.AreEqual(model.ContactDetails.Name, result.ContactDetails.Name);
-        }
-
-        #endregion
-
-    }
-}

app/Umbraco/Archetype.Tests/Serialization/JsonTestModels.cs

@@ -1,179 +0,0 @@
-using System;
-using System.Collections.Generic;
-using Archetype.Serialization;
-using Newtonsoft.Json;
-
-namespace Archetype.Tests.Serialization
-{
-    #region json test Models
-
-    [AsArchetype("urlPicker")]
-    [JsonConverter(typeof(ArchetypeJsonConverter))]
-    public class UrlPicker
-    {
-        [JsonProperty("title")]
-        public string Title { get; set; }
-        [JsonProperty("url")]
-        public string Url { get; set; }
-        [JsonProperty("content")]
-        public int? Content { get; set; }
-        [JsonProperty("media")]
-        public int? Media { get; set; }
-        [JsonProperty("openInNewWindow")]
-        public bool OpenInNewWindow { get; set; }
-    }
-
-    [AsArchetype("contactDetails")]
-    [JsonConverter(typeof(ArchetypeJsonConverter))]
-    public class ContactDetails
-    {
-        [JsonProperty("name")]
-        public string Name { get; set; }
-        [JsonProperty("address")]
-        public string Address { get; set; }
-        [JsonProperty("telephone")]
-        public string Telephone { get; set; }
-        [JsonProperty("mobile")]
-        public string Mobile { get; set; }
-        [JsonProperty("fax")]
-        public string Fax { get; set; }
-        [JsonProperty("email")]
-        public string Email { get; set; }
-        [JsonProperty("webSite")]
-        public UrlPicker WebSite { get; set; }
-    }
-
-    [AsArchetype("companyDetails")]
-    [JsonConverter(typeof(ArchetypeJsonConverter))]
-    public class CompanyDetails
-    {
-        [JsonProperty("region")]
-        public string Region { get; set; }
-        [JsonProperty("contactDetails")]
-        public ContactDetails ContactDetails { get; set; }
-    }
-
-    [AsArchetype("allContactDetails")]
-    [JsonConverter(typeof(ArchetypeJsonConverter))]
-    public class AllContactDetails
-    {
-        public ContactDetails UserDetails { get; set; }
-        public ContactDetails AdminDetails { get; set; }
-
-    }
-
-    [AsArchetype("contactDetailsList")]
-    [JsonConverter(typeof(ArchetypeJsonConverter))]
-    public class ContactDetailsList : List<ContactDetails>
-    {
-    }
-
-    [AsArchetype("annualStatement")]
-    [JsonConverter(typeof(ArchetypeJsonConverter))]
-    public class AnnualStatement
-    {
-        public DateTime FiscalYearStart { get; set; }
-        public DateTime FiscalYearEnd { get; set; }
-        public DateTime? DividendPaymentDate { get; set; }
-        public Int32 TotalShares { get; set; }
-        public Double Sales { get; set; }
-        public Decimal Profit { get; set; }
-    }
-
-    [AsArchetype("mergerDetails")]
-    [JsonConverter(typeof(ArchetypeJsonConverter))]
-    public class MergerDetails
-    {
-        public DateTime MergerDate { get; set; }
-        [JsonIgnore]
-        public decimal MergerValue { get; set; }
-    }
-
-    #endregion
-
-    #region complex nested model
-
-    [AsArchetype("pages")]
-    [JsonConverter(typeof(ArchetypeJsonConverter))]
-    public class PageDetails
-    {
-        [JsonProperty("pages")]
-        public string Pages { get; set; }
-        [AsFieldset]
-        [JsonProperty("captions")]
-        public Captions Captions { get; set; }
-    }
-
-    [AsArchetype("captions")]
-    [JsonConverter(typeof(ArchetypeJsonConverter))]
-    public class Captions
-    {
-        [JsonProperty("captions")]
-        public TextList TextStringArray { get; set; }
-    }
-
-    [AsArchetype("textstringArray")]
-    [JsonConverter(typeof(ArchetypeJsonConverter))]
-    public class TextList : List<TextItem>
-    {
-    }
-
-    [AsArchetype("textstringArray")]
-    [JsonConverter(typeof(ArchetypeJsonConverter))]
-    public class TextItem
-    {
-        [JsonProperty("textstring")]
-        public string TextString { get; set; }
-    }
-
-    #endregion
-
-    #region complex nested tree model
-
-    public abstract class PageBase
-    {
-        public string PageTitle { get; set; }
-        public string BodyText { get; set; }
-    }
-
-    [AsArchetype("slideShow")]
-    [JsonConverter(typeof(ArchetypeJsonConverter))]
-    public class SlideShow
-    {
-        public string Slides { get; set; }
-    }
-
-    [AsArchetype("seo")]
-    [JsonConverter(typeof(ArchetypeJsonConverter))]
-    public class Seo
-    {
-        public string MetaTitle { get; set; }
-        public string MetaDescription { get; set; }
-    }
-
-    [AsArchetype("TextPage")]
-    [JsonConverter(typeof(ArchetypeJsonConverter))]
-    public class TextPage : PageBase
-    {
-        [AsFieldset]
-        public SlideShow Media { get; set; }
-
-        [AsFieldset]
-        public Seo Seo { get; set; }
-    }
-
-    [AsArchetype("TextPageList")]
-    [JsonConverter(typeof(ArchetypeJsonConverter))]
-    public class TextPageList : List<TextPage>
-    {
-    }
-
-    [AsArchetype("Pages")]
-    [JsonConverter(typeof(ArchetypeJsonConverter))]
-    public class PageList
-    {
-        public TextPageList Pages { get; set; }
-    }
-
-    #endregion
-}

app/Umbraco/Archetype.Tests/Serialization/JsonTestStrings.cs

@@ -1,435 +0,0 @@
-namespace Archetype.Tests.Serialization
-{
-    public class JsonTestStrings
-    {
-        public const string _MERGER_DETAILS_JSON =
-            @"{
-  ""fieldsets"": [
-    {
-      ""alias"": ""mergerDetails"",
-      ""properties"": [
-        {
-          ""alias"": ""MergerDate"",
-          ""value"": ""07/06/2014 08:09:10""
-        }
-      ]
-    }
-  ]
-}";
-
-        public const string _ANNUAL_STATEMENT_JSON =
-            @"{
-  ""fieldsets"": [
-    {
-      ""alias"": ""annualStatement"",
-      ""properties"": [
-        {
-          ""alias"": ""FiscalYearStart"",
-          ""value"": ""01/09/2013 00:00:00""
-        },
-        {
-          ""alias"": ""FiscalYearEnd"",
-          ""value"": ""31/08/2014 00:00:00""
-        },
-        {
-          ""alias"": ""DividendPaymentDate"",
-          ""value"": """"
-        },
-        {
-          ""alias"": ""TotalShares"",
-          ""value"": ""345678""
-        },
-        {
-          ""alias"": ""Sales"",
-          ""value"": ""123456700.89""
-        },
-        {
-          ""alias"": ""Profit"",
-          ""value"": ""1123456.78""
-        }
-      ]
-    }
-  ]
-}";
-
-        public const string _CONTACT_DETAILS_JSON =
-            @"{
-  ""fieldsets"": [
-    {
-      ""alias"": ""contactDetails"",
-      ""properties"": [
-        {
-          ""alias"": ""name"",
-          ""value"": ""Test""
-        },
-        {
-          ""alias"": ""address"",
-          ""value"": ""Test Address""
-        },
-        {
-          ""alias"": ""telephone"",
-          ""value"": ""111""
-        },
-        {
-          ""alias"": ""mobile"",
-          ""value"": ""000""
-        },
-        {
-          ""alias"": ""fax"",
-          ""value"": ""000""
-        },
-        {
-          ""alias"": ""email"",
-          ""value"": ""test@test.com""
-        },
-        {
-          ""alias"": ""webSite"",
-          ""value"": {
-            ""fieldsets"": [
-              {
-                ""alias"": ""urlPicker"",
-                ""properties"": [
-                  {
-                    ""alias"": ""title"",
-                    ""value"": ""The Test Company""
-                  },
-                  {
-                    ""alias"": ""url"",
-                    ""value"": ""http://test.com""
-                  },
-                  {
-                    ""alias"": ""content"",
-                    ""value"": """"
-                  },
-                  {
-                    ""alias"": ""media"",
-                    ""value"": """"
-                  },
-                  {
-                    ""alias"": ""openInNewWindow"",
-                    ""value"": ""1""
-                  }
-                ]
-              }
-            ]
-          }
-        }
-      ]
-    }
-  ]
-}";
-
-        public const string _COMPANY_DETAILS_JSON =
-            @"{
-  ""fieldsets"": [
-    {
-      ""alias"": ""companyDetails"",
-      ""properties"": [
-        {
-          ""alias"": ""region"",
-          ""value"": ""Test Region""
-        },
-        {
-          ""alias"": ""contactDetails"",
-          ""value"": {
-            ""fieldsets"": [
-              {
-                ""alias"": ""contactDetails"",
-                ""properties"": [
-                  {
-                    ""alias"": ""name"",
-                    ""value"": ""Test""
-                  },
-                  {
-                    ""alias"": ""address"",
-                    ""value"": ""Test Address""
-                  },
-                  {
-                    ""alias"": ""telephone"",
-                    ""value"": ""111""
-                  },
-                  {
-                    ""alias"": ""mobile"",
-                    ""value"": ""000""
-                  },
-                  {
-                    ""alias"": ""fax"",
-                    ""value"": ""000""
-                  },
-                  {
-                    ""alias"": ""email"",
-                    ""value"": ""test@test.com""
-                  },
-                  {
-                    ""alias"": ""webSite"",
-                    ""value"": {
-                      ""fieldsets"": [
-                        {
-                          ""alias"": ""urlPicker"",
-                          ""properties"": [
-                            {
-                              ""alias"": ""title"",
-                              ""value"": ""The Test Company""
-                            },
-                            {
-                              ""alias"": ""url"",
-                              ""value"": ""http://test.com""
-                            },
-                            {
-                              ""alias"": ""content"",
-                              ""value"": """"
-                            },
-                            {
-                              ""alias"": ""media"",
-                              ""value"": """"
-                            },
-                            {
-                              ""alias"": ""openInNewWindow"",
-                              ""value"": ""1""
-                            }
-                          ]
-                        }
-                      ]
-                    }
-                  }
-                ]
-              }
-            ]
-          }
-        }
-      ]
-    }
-  ]
-}";
-
-        public const string _PAGE_DETAILS_JSON =
-            @"{
-  ""fieldsets"": [
-    {
-      ""alias"": ""pages"",
-      ""properties"": [
-        {
-          ""alias"": ""pages"",
-          ""value"": ""2439,2440,2441,2442,2443,2444,2445,2446,2447,2448,2449,2450,2451,2452,2453""
-        }
-      ]
-    },
-    {
-      ""alias"": ""captions"",
-      ""properties"": [
-        {
-          ""alias"": ""captions"",
-          ""value"": {
-            ""fieldsets"": [
-              {
-                ""alias"": ""textstringArray"",
-                ""properties"": [
-                  {
-                    ""alias"": ""textstring"",
-                    ""value"": ""First Page""
-                  }
-                ]
-              },
-              {
-                ""alias"": ""textstringArray"",
-                ""properties"": [
-                  {
-                    ""alias"": ""textstring"",
-                    ""value"": ""Second Page""
-                  }
-                ]
-              },
-              {
-                ""alias"": ""textstringArray"",
-                ""properties"": [
-                  {
-                    ""alias"": ""textstring"",
-                    ""value"": ""Third Page""
-                  }
-                ]
-              },
-              {
-                ""alias"": ""textstringArray"",
-                ""properties"": [
-                  {
-                    ""alias"": ""textstring"",
-                    ""value"": ""Fourth Page""
-                  }
-                ]
-              }
-            ]
-          }
-        }
-      ]
-    }
-  ]
-}";
-
-        public const string _PAGES_JSON =
-            @"{
-  ""fieldsets"": [
-    {
-      ""alias"": ""Pages"",
-      ""properties"": [
-        {
-          ""alias"": ""Pages"",
-          ""value"": {
-            ""fieldsets"": [
-              {
-                ""alias"": ""TextPage"",
-                ""properties"": [
-                  {
-                    ""alias"": ""Media"",
-                    ""value"": {
-                      ""fieldsets"": [
-                        {
-                          ""alias"": ""slideShow"",
-                          ""properties"": [
-                            {
-                              ""alias"": ""Slides"",
-                              ""value"": ""1,2,3,4,5,6,7,8""
-                            }
-                          ]
-                        }
-                      ]
-                    }
-                  },
-                  {
-                    ""alias"": ""Seo"",
-                    ""value"": {
-                      ""fieldsets"": [
-                        {
-                          ""alias"": ""seo"",
-                          ""properties"": [
-                            {
-                              ""alias"": ""MetaTitle"",
-                              ""value"": ""Test Meta Title""
-                            },
-                            {
-                              ""alias"": ""MetaDescription"",
-                              ""value"": ""Test Meta Description""
-                            }
-                          ]
-                        }
-                      ]
-                    }
-                  },
-                  {
-                    ""alias"": ""PageTitle"",
-                    ""value"": ""Home Page""
-                  },
-                  {
-                    ""alias"": ""BodyText"",
-                    ""value"": ""Home Page Body""
-                  }
-                ]
-              },
-              {
-                ""alias"": ""TextPage"",
-                ""properties"": [
-                  {
-                    ""alias"": ""Media"",
-                    ""value"": {
-                      ""fieldsets"": [
-                        {
-                          ""alias"": ""slideShow"",
-                          ""properties"": [
-                            {
-                              ""alias"": ""Slides"",
-                              ""value"": ""1,2,3,4,5,6,7,8""
-                            }
-                          ]
-                        }
-                      ]
-                    }
-                  },
-                  {
-                    ""alias"": ""Seo"",
-                    ""value"": {
-                      ""fieldsets"": [
-                        {
-                          ""alias"": ""seo"",
-                          ""properties"": [
-                            {
-                              ""alias"": ""MetaTitle"",
-                              ""value"": ""Test Meta Title""
-                            },
-                            {
-                              ""alias"": ""MetaDescription"",
-                              ""value"": ""Test Meta Description""
-                            }
-                          ]
-                        }
-                      ]
-                    }
-                  },
-                  {
-                    ""alias"": ""PageTitle"",
-                    ""value"": ""About us Page""
-                  },
-                  {
-                    ""alias"": ""BodyText"",
-                    ""value"": ""About us Page Body""
-                  }
-                ]
-              },
-              {
-                ""alias"": ""TextPage"",
-                ""properties"": [
-                  {
-                    ""alias"": ""Media"",
-                    ""value"": {
-                      ""fieldsets"": [
-                        {
-                          ""alias"": ""slideShow"",
-                          ""properties"": [
-                            {
-                              ""alias"": ""Slides"",
-                              ""value"": ""1,2,3,4,5,6,7,8""
-                            }
-                          ]
-                        }
-                      ]
-                    }
-                  },
-                  {
-                    ""alias"": ""Seo"",
-                    ""value"": {
-                      ""fieldsets"": [
-                        {
-                          ""alias"": ""seo"",
-                          ""properties"": [
-                            {
-                              ""alias"": ""MetaTitle"",
-                              ""value"": ""Test Meta Title""
-                            },
-                            {
-                              ""alias"": ""MetaDescription"",
-                              ""value"": ""Test Meta Description""
-                            }
-                          ]
-                        }
-                      ]
-                    }
-                  },
-                  {
-                    ""alias"": ""PageTitle"",
-                    ""value"": ""Contact us Page""
-                  },
-                  {
-                    ""alias"": ""BodyText"",
-                    ""value"": ""Contact us Page Body""
-                  }
-                ]
-              }
-            ]
-          }
-        }
-      ]
-    }
-  ]
-}";
-
-        public const string _NULL_VALUES_JSON = @"{""fieldsets"":[{""alias"":""contactDetails"",""properties"":[{""alias"":""name"",""value"":""""},{""alias"":""address"",""value"":""""},{""alias"":""telephone"",""value"":""""},{""alias"":""mobile"",""value"":""""},{""alias"":""fax"",""value"":""""},{""alias"":""email"",""value"":""""},{""alias"":""webSite"",""value"":""""}]}]}";
-    }
-}

app/Umbraco/Archetype.Tests/app.config

@@ -1,6 +1,14 @@
 <?xml version="1.0" encoding="utf-8"?>
 <configuration>
-  <runtime>
+    <configSections>
+      <sectionGroup name="umbracoConfiguration">
+        <section name="settings" type="Umbraco.Core.Configuration.UmbracoSettings.UmbracoSettingsSection, Umbraco.Core" requirePermission="false" />
+      </sectionGroup>
+    </configSections>
+    <umbracoConfiguration>
+      <settings configSource="config\umbracoSettings.config" />
+    </umbracoConfiguration>
+    <runtime>
     <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
       <dependentAssembly>
         <assemblyIdentity name="System.Web.Mvc" publicKeyToken="31bf3856ad364e35" culture="neutral" />

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,213 +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>
-    </Reference>
-    <Reference Include="AutoMapper.Net4">
-      <HintPath>..\packages\AutoMapper.3.0.0\lib\net40\AutoMapper.Net4.dll</HintPath>
-    </Reference>
-    <Reference Include="businesslogic">
-      <HintPath>..\packages\UmbracoCms.Core.7.1.2\lib\businesslogic.dll</HintPath>
-    </Reference>
-    <Reference Include="ClientDependency.Core">
-      <HintPath>..\packages\ClientDependency.1.7.1.2\lib\ClientDependency.Core.dll</HintPath>
-    </Reference>
-    <Reference Include="ClientDependency.Core.Mvc">
-      <HintPath>..\packages\ClientDependency-Mvc.1.7.0.4\lib\ClientDependency.Core.Mvc.dll</HintPath>
-    </Reference>
-    <Reference Include="cms">
-      <HintPath>..\packages\UmbracoCms.Core.7.1.2\lib\cms.dll</HintPath>
-    </Reference>
-    <Reference Include="controls">
-      <HintPath>..\packages\UmbracoCms.Core.7.1.2\lib\controls.dll</HintPath>
-    </Reference>
-    <Reference Include="CookComputing.XmlRpcV2">
-      <HintPath>..\packages\xmlrpcnet.2.5.0\lib\net20\CookComputing.XmlRpcV2.dll</HintPath>
-    </Reference>
-    <Reference Include="Examine">
-      <HintPath>..\packages\UmbracoCms.Core.7.1.2\lib\Examine.dll</HintPath>
-    </Reference>
-    <Reference Include="HtmlAgilityPack">
-      <HintPath>..\packages\HtmlAgilityPack.1.4.6\lib\Net45\HtmlAgilityPack.dll</HintPath>
-    </Reference>
-    <Reference Include="ICSharpCode.SharpZipLib">
-      <HintPath>..\packages\SharpZipLib.0.86.0\lib\20\ICSharpCode.SharpZipLib.dll</HintPath>
-    </Reference>
-    <Reference Include="ImageProcessor">
-      <HintPath>..\packages\ImageProcessor.1.9.0.0\lib\ImageProcessor.dll</HintPath>
-    </Reference>
-    <Reference Include="ImageProcessor.Web">
-      <HintPath>..\packages\ImageProcessor.Web.3.2.3.0\lib\net45\ImageProcessor.Web.dll</HintPath>
-    </Reference>
-    <Reference Include="interfaces">
-      <HintPath>..\packages\UmbracoCms.Core.7.1.2\lib\interfaces.dll</HintPath>
-    </Reference>
-    <Reference Include="log4net">
-      <HintPath>..\packages\UmbracoCms.Core.7.1.2\lib\log4net.dll</HintPath>
-    </Reference>
-    <Reference Include="Lucene.Net">
-      <HintPath>..\packages\Lucene.Net.2.9.4.1\lib\net40\Lucene.Net.dll</HintPath>
-    </Reference>
-    <Reference Include="Microsoft.ApplicationBlocks.Data">
-      <HintPath>..\packages\UmbracoCms.Core.7.1.2\lib\Microsoft.ApplicationBlocks.Data.dll</HintPath>
-    </Reference>
-    <Reference Include="Microsoft.Web.Helpers">
-      <HintPath>..\packages\UmbracoCms.Core.7.1.2\lib\Microsoft.Web.Helpers.dll</HintPath>
-    </Reference>
-    <Reference Include="Microsoft.Web.Infrastructure, Version=1.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL">
-      <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.0\lib\net40\Microsoft.Web.Mvc.FixedDisplayModes.dll</HintPath>
-    </Reference>
-    <Reference Include="MiniProfiler">
-      <HintPath>..\packages\MiniProfiler.2.1.0\lib\net40\MiniProfiler.dll</HintPath>
-    </Reference>
-    <Reference Include="MySql.Data">
-      <HintPath>..\packages\MySql.Data.6.6.5\lib\net40\MySql.Data.dll</HintPath>
-    </Reference>
-    <Reference Include="Newtonsoft.Json">
-      <HintPath>..\packages\Newtonsoft.Json.6.0.2\lib\net45\Newtonsoft.Json.dll</HintPath>
-    </Reference>
-    <Reference Include="SQLCE4Umbraco">
-      <HintPath>..\packages\UmbracoCms.Core.7.1.2\lib\SQLCE4Umbraco.dll</HintPath>
-    </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>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>True</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>
-    </Reference>
-    <Reference Include="System.Web" />
-    <Reference Include="System.Web.Helpers, Version=2.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL">
-      <Private>True</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>
-    </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>
-    </Reference>
-    <Reference Include="System.Web.Mvc, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL">
-      <Private>True</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>True</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>True</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>True</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>True</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>
-    </Reference>
-    <Reference Include="umbraco">
-      <HintPath>..\packages\UmbracoCms.Core.7.1.2\lib\umbraco.dll</HintPath>
-    </Reference>
-    <Reference Include="Umbraco.Core">
-      <HintPath>..\packages\UmbracoCms.Core.7.1.2\lib\Umbraco.Core.dll</HintPath>
-    </Reference>
-    <Reference Include="umbraco.DataLayer">
-      <HintPath>..\packages\UmbracoCms.Core.7.1.2\lib\umbraco.DataLayer.dll</HintPath>
-    </Reference>
-    <Reference Include="umbraco.editorControls">
-      <HintPath>..\packages\UmbracoCms.Core.7.1.2\lib\umbraco.editorControls.dll</HintPath>
-    </Reference>
-    <Reference Include="umbraco.MacroEngines">
-      <HintPath>..\packages\UmbracoCms.Core.7.1.2\lib\umbraco.MacroEngines.dll</HintPath>
-    </Reference>
-    <Reference Include="umbraco.providers">
-      <HintPath>..\packages\UmbracoCms.Core.7.1.2\lib\umbraco.providers.dll</HintPath>
-    </Reference>
-    <Reference Include="Umbraco.Web.UI">
-      <HintPath>..\packages\UmbracoCms.Core.7.1.2\lib\Umbraco.Web.UI.dll</HintPath>
-    </Reference>
-    <Reference Include="umbraco.XmlSerializers">
-      <HintPath>..\packages\UmbracoCms.Core.7.1.2\lib\umbraco.XmlSerializers.dll</HintPath>
-    </Reference>
-    <Reference Include="UmbracoExamine">
-      <HintPath>..\packages\UmbracoCms.Core.7.1.2\lib\UmbracoExamine.dll</HintPath>
-    </Reference>
-    <Reference Include="UrlRewritingNet.UrlRewriter">
-      <HintPath>..\packages\UmbracoCms.Core.7.1.2\lib\UrlRewritingNet.UrlRewriter.dll</HintPath>
-    </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/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,7 +14,7 @@ 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}"
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Archetype.Courier", "Archetype.Courier\Archetype.Courier.csproj", "{FE8BE437-8B11-4E49-9B02-F45994E6D723}"
 EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
@@ -28,10 +30,10 @@ 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
+		{FE8BE437-8B11-4E49-9B02-F45994E6D723}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE

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

@@ -8,26 +8,64 @@ using Umbraco.Core.Models;
 using Umbraco.Web.Models.ContentEditing;
 using Umbraco.Web.Mvc;
 using Umbraco.Web.Editors;
+using Archetype.Extensions;
+using Archetype.Models;
 
 namespace Archetype.Api
 {
+    /// <summary>
+    /// Controller that handles datatype related interactions.
+    /// </summary>
+    /// <seealso cref="Umbraco.Web.Editors.UmbracoAuthorizedJsonController" />
     [PluginController("ArchetypeApi")]
     public class ArchetypeDataTypeController : UmbracoAuthorizedJsonController
     {
+        private static DateTime _lastVersionCheck;
+        private const int IntervalInDaysBetweenVersionChecks = 7;
 
         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 });
         }
 
-        public object GetAll() 
+        /// <summary>
+        /// Gets all datatypes.
+        /// </summary>
+        /// <returns>System.Object.</returns>
+        public object GetAll()
         {
             var dataTypes = Services.DataTypeService.GetAllDataTypeDefinitions();
             return dataTypes.Select(t => new { guid = t.Key, name = t.Name });
         }
 
+        /// <summary>
+        /// Gets all details.
+        /// </summary>
+        /// <returns>System.Object.</returns>
+        public object GetAllDetails()
+        {
+            var dataTypes = Services.DataTypeService.GetAllDataTypeDefinitions();
+
+            var list = new List<object>();
+
+            foreach (var dataType in dataTypes)
+            {
+                var dataTypeDisplay = Mapper.Map<IDataTypeDefinition, DataTypeDisplay>(dataType);
+
+                list.Add(new { selectedEditor = dataTypeDisplay.SelectedEditor, preValues = dataTypeDisplay.PreValues, dataTypeGuid = dataType.Key });
+            }
+
+            return list;
+        }
+
+        /// <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,8 +73,99 @@ 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);
+
+            if (dataType == null)
+            {
+                throw new HttpResponseException(HttpStatusCode.NotFound);
+            }
+
+            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 = ArchetypeHelper.Instance.DllVersion() };
+        }
+
+        /// <summary>
+        /// Globals the settings.
+        /// </summary>
+        /// <returns>System.Object.</returns>
+        [HttpGet]
+        public object GlobalSettings()
+        {
+            return new
+            {
+                isCheckingForUpdates = ArchetypeGlobalSettings.Instance.CheckForUpdates
+            };
+        }
+
+        /// <summary>
+        /// Sets the check for updates.
+        /// </summary>
+        /// <param name="isChecking">if set to <c>true</c> [is checking].</param>
+        [HttpPost]
+        public void SetCheckForUpdates([FromBody] bool isChecking)
+        {
+            ArchetypeGlobalSettings.Instance.CheckForUpdates = isChecking;
+            ArchetypeGlobalSettings.Instance.Save();
+        }
+
+        /// <summary>
+        /// Checks for updates.
+        /// </summary>
+        /// <returns>System.Object.</returns>
+        [HttpPost]
+        public object CheckForUpdates()
+        {
+            if (!ArchetypeGlobalSettings.Instance.CheckForUpdates || !IsItTimeToCheck())
+            {
+                return new
+                {
+                    isUpdateAvailable = false
+                };
+            }
+
+            var updateNotificationModel = ArchetypeHelper.Instance.CheckForUpdates();
+            _lastVersionCheck = DateTime.UtcNow;
+
+            return new
+            {
+                isUpdateAvailable = updateNotificationModel.IsUpdateAvailable,
+                headline = updateNotificationModel.Headline,
+                type = updateNotificationModel.Type,
+                message = updateNotificationModel.Message,
+                url = updateNotificationModel.Url
+            };
+        }
+
+        internal bool IsItTimeToCheck()
+        {
+            return _lastVersionCheck.AddDays(IntervalInDaysBetweenVersionChecks) < DateTime.UtcNow;
+        }
     }
 }

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

@@ -1,4 +1,4 @@
-<?xml version="1.0" encoding="utf-8"?>
+<?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>
@@ -42,6 +42,7 @@
     </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>
@@ -53,9 +54,11 @@
     </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>
@@ -63,6 +66,7 @@
     </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>
@@ -74,15 +78,19 @@
     </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>
@@ -90,9 +98,11 @@
     </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>
@@ -116,15 +126,17 @@
     </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.Configuration" />
     <Reference Include="System.Core" />
     <Reference Include="System.Data.SqlServerCe, Version=4.0.0.0, Culture=neutral, PublicKeyToken=89845dcd8080cc91, processorArchitecture=MSIL">
-      <Private>True</Private>
+      <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>True</Private>
+      <Private>False</Private>
       <HintPath>..\packages\UmbracoCms.Core.7.1.2\lib\System.Data.SqlServerCe.Entity.dll</HintPath>
     </Reference>
     <Reference Include="System.Net.Http" />
@@ -173,58 +185,79 @@
     <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="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\Extensions.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\ArchetypeConfigFileModel.cs" />
+    <Compile Include="Models\ArchetypeGlobalSettings.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="Models\ArchetypeUpdateNotification.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="Properties\VersionInfo.cs" />
     <Compile Include="PropertyConverters\ArchetypeValueConverter.cs" />
-    <Compile Include="Serialization\AsArchetypeAttribute.cs" />
-    <Compile Include="Serialization\ArchetypeJsonConverter.cs" />
-    <Compile Include="Serialization\AsFieldsetAttribute.cs" />
-    <Compile Include="Serialization\SerializationExtensions.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";
@@ -9,5 +12,8 @@
         public const string CacheKey_DataTypeByGuid = "";
 
         public const string CacheKey_PreValueFromDataTypeId = "Archetype_GetArchetypePreValueFromDataTypeId_";
+
+        public const string UmbracoVersionAlias = "umbracoConfigurationStatus";
+        public const string NotificationUrl = "https://api.gizmo42.com/v1/archetype/check-for-updates";
     }
 }

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

@@ -1,33 +1,96 @@
 using System;
+using System.Configuration;
 using System.Linq;
+using System.Net.Http;
+using System.Text;
 using Archetype.Models;
 using Newtonsoft.Json;
 using Umbraco.Core;
+using Umbraco.Core.Logging;
 using Umbraco.Core.Models;
 using Umbraco.Core.Models.PublishedContent;
+using System.Reflection;
+using System.Diagnostics;
+using System.Net;
 
+/// <summary>
+/// The Extensions namespace.
+/// </summary>
 namespace Archetype.Extensions
 {
+    /// <summary>
+    /// Helper class that handles several Archetype related interactions.
+    /// </summary>
     public class ArchetypeHelper
     {
-
+        /// <summary>
+        /// The json settings
+        /// </summary>
         protected JsonSerializerSettings _jsonSettings;
-        protected ApplicationContext _app; 
+        /// <summary>
+        /// The application
+        /// </summary>
+        protected ApplicationContext _app;
+        /// <summary>
+        /// The pad lock
+        /// </summary>
+        private static readonly object _padLock = new object();
+        /// <summary>
+        /// The instance
+        /// </summary>
+        private static ArchetypeHelper _instance = new ArchetypeHelper();
 
-        internal ArchetypeHelper()
+        /// <summary>
+        /// Gets the instance.
+        /// </summary>
+        /// <value>The instance.</value>
+        internal static ArchetypeHelper Instance {
+            get
+            {
+                if (_instance == null)
+                {
+                    lock (_padLock)
+                    {
+                        if (_instance == null)
+                        {
+                            _instance = new ArchetypeHelper();
+                        }
+                    }
+                }
+
+                return _instance;
+            }
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ArchetypeHelper" /> class.
+        /// </summary>
+        private ArchetypeHelper()
         {
             var dcr = new Newtonsoft.Json.Serialization.DefaultContractResolver();
-            dcr.DefaultMembersSearchFlags |= System.Reflection.BindingFlags.NonPublic;
+            dcr.DefaultMembersSearchFlags |= BindingFlags.NonPublic;
 
             _jsonSettings = new JsonSerializerSettings { ContractResolver = dcr };
             _app = ApplicationContext.Current;
         }
 
-        internal Models.ArchetypeModel DeserializeJsonToArchetype(string sourceJson, PreValueCollection dataTypePreValues)
+        /// <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>ArchetypeModel.</returns>
+        internal ArchetypeModel DeserializeJsonToArchetype(string sourceJson, PreValueCollection dataTypePreValues)
         {
             try
             {
-                var archetype = JsonConvert.DeserializeObject<Models.ArchetypeModel>(sourceJson, _jsonSettings);
+                var archetype = JsonConvert.DeserializeObject<ArchetypeModel>(sourceJson, _jsonSettings);
 
                 try
                 {
@@ -37,21 +100,29 @@ namespace Archetype.Extensions
                 }
                 catch (Exception ex)
                 {
+                    LogHelper.Error<ArchetypeHelper>("DeserializeJsonToArchetype", ex);
                 }
 
                 return archetype;
             }
             catch
             {
-                return new Models.ArchetypeModel();
-            }         
+                return new ArchetypeModel();
+            }
         }
 
-        internal Models.ArchetypeModel DeserializeJsonToArchetype(string sourceJson, int dataTypeId, PublishedContentType hostContentType = null)
+        /// <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>ArchetypeModel.</returns>
+        internal ArchetypeModel DeserializeJsonToArchetype(string sourceJson, int dataTypeId, PublishedContentType hostContentType = null)
         {
             try
             {
-                var archetype = JsonConvert.DeserializeObject<Models.ArchetypeModel>(sourceJson, _jsonSettings);
+                var archetype = JsonConvert.DeserializeObject<ArchetypeModel>(sourceJson, _jsonSettings);
 
                 try
                 {
@@ -61,18 +132,83 @@ 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 Models.ArchetypeModel();
+                return new ArchetypeModel();
             }
         }
 
-         private ArchetypePreValue GetArchetypePreValueFromDataTypeId(int dataTypeId)
-         {
+        /// <summary>
+        /// Determines whether datatypeId has had it's PVC overridden.
+        /// </summary>
+        /// <param name="dataTypeId">The data type identifier.</param>
+        /// <returns><c>true</c> if [is property value converter overridden] [the specified data type identifier]; otherwise, <c>false</c>.</returns>
+        internal bool IsPropertyValueConverterOverridden(int dataTypeId)
+        {
+            var prevalues = GetArchetypePreValueFromDataTypeId(dataTypeId);
+
+            if (prevalues == null)
+                return false;
+
+            return prevalues.OverrideDefaultPropertyValueConverter;
+        }
+
+        /// <summary>
+        /// Checks for updates.
+        /// </summary>
+        /// <returns>ArchetypeUpdateNotification.</returns>
+        internal ArchetypeUpdateNotification CheckForUpdates()
+        {
+            try
+            {
+                using (var client = new HttpClient())
+                {
+                    var content = new StringContent(JsonConvert.SerializeObject(new
+                    {
+                        umbracoVersion = ConfigurationManager.AppSettings[Constants.UmbracoVersionAlias],
+                        archetypeVersion = DllVersion(),
+                        id = ArchetypeGlobalSettings.Instance.Id
+                    }), Encoding.UTF8, "application/json");
+
+                    client.DefaultRequestHeaders.Add("x-api-key-id", ArchetypeGlobalSettings.Instance.ApiKey.ToString());
+
+                    var response = client.PostAsync(new Uri(Constants.NotificationUrl), content).Result;
+
+                    if (response.StatusCode == HttpStatusCode.OK)
+                    {
+                        var responseString = response.Content.ReadAsStringAsync().Result;
+
+                        return JsonConvert.DeserializeObject<ArchetypeUpdateNotification>(responseString);
+                    }
+
+                    return new ArchetypeUpdateNotification
+                    {
+                        IsUpdateAvailable = false
+                    };
+                }
+            }
+            catch (Exception ex)
+            {
+                //if anything goes wrong let's make sure we don't break their site
+                return new ArchetypeUpdateNotification
+                {
+                    IsUpdateAvailable = false
+                };
+            }
+        }
+
+        /// <summary>
+        /// Gets the archetype pre value from data type identifier.
+        /// </summary>
+        /// <param name="dataTypeId">The data type identifier.</param>
+        /// <returns>ArchetypePreValue.</returns>
+        private ArchetypePreValue GetArchetypePreValueFromDataTypeId(int dataTypeId)
+        {
             return _app.ApplicationCache.RuntimeCache.GetCacheItem(
                 Constants.CacheKey_PreValueFromDataTypeId + dataTypeId,
                 () =>
@@ -89,8 +225,13 @@ namespace Archetype.Extensions
                     return config;
 
                 }) as ArchetypePreValue;
-        }  
+        }
 
+        /// <summary>
+        /// Gets the archetype pre value from pre values collection.
+        /// </summary>
+        /// <param name="dataTypePreValues">The data type pre values.</param>
+        /// <returns>ArchetypePreValue.</returns>
         private ArchetypePreValue GetArchetypePreValueFromPreValuesCollection(PreValueCollection dataTypePreValues)
         {
             var preValueAsString = dataTypePreValues.PreValuesAsDictionary.First().Value.Value;
@@ -98,10 +239,14 @@ 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>IDataTypeDefinition.</returns>
+        internal IDataTypeDefinition GetDataTypeByGuid(Guid guid)
         {
-            return (IDataTypeDefinition) ApplicationContext.Current.ApplicationCache.RuntimeCache.GetCacheItem(
+            return (IDataTypeDefinition)ApplicationContext.Current.ApplicationCache.RuntimeCache.GetCacheItem(
                 Constants.CacheKey_DataTypeByGuid + guid,
                 () => _app.Services.DataTypeService.GetDataTypeDefinitionById(guid));
         }
@@ -111,7 +256,8 @@ namespace Archetype.Extensions
         /// </summary>
         /// <param name="archetype">The Archetype to add the additional metadata to</param>
         /// <param name="preValue">The configuration of the Archetype</param>
-        private void RetrieveAdditionalProperties(ref Models.ArchetypeModel archetype, ArchetypePreValue preValue, PublishedContentType hostContentType = null)
+        /// <param name="hostContentType">Type of the host content.</param>
+        private void RetrieveAdditionalProperties(ref ArchetypeModel archetype, ArchetypePreValue preValue, PublishedContentType hostContentType = null)
         {
             foreach (var fieldset in preValue.Fieldsets)
             {
@@ -121,7 +267,7 @@ namespace Archetype.Extensions
                     foreach (var property in fieldset.Properties)
                     {
                         var propertyAlias = property.Alias;
-                        foreach ( var propertyInst in fieldsetInst.Properties.Where(x => x.Alias == propertyAlias))
+                        foreach (var propertyInst in fieldsetInst.Properties.Where(x => x.Alias == propertyAlias))
                         {
                             propertyInst.DataTypeGuid = property.DataTypeGuid.ToString();
                             propertyInst.DataTypeId = GetDataTypeByGuid(property.DataTypeGuid).Id;
@@ -136,9 +282,8 @@ namespace Archetype.Extensions
         /// <summary>
         /// Retrieves additional metadata that isn't available on the stored model of an ArchetypePreValue
         /// </summary>
-        /// <param name="archetype">The Archetype to add the additional metadata to</param>
         /// <param name="preValue">The configuration of the Archetype</param>
-        private void RetrieveAdditionalProperties(ref Models.ArchetypePreValue preValue)
+        private void RetrieveAdditionalProperties(ref ArchetypePreValue preValue)
         {
             foreach (var fieldset in preValue.Fieldsets)
             {
@@ -149,5 +294,17 @@ namespace Archetype.Extensions
             }
         }
 
+
+        /// <summary>
+        /// Gets the DLL version from the file.
+        /// </summary>
+        /// <returns>System.String.</returns>
+        internal string DllVersion()
+        {
+            var asm = Assembly.GetExecutingAssembly();
+            var fvi = FileVersionInfo.GetVersionInfo(asm.Location);
+
+            return fvi.FileVersion;
+        }
     }
-}
+}

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

@@ -0,0 +1,39 @@
+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/Extensions.cs

@@ -1,84 +0,0 @@
-using System;
-using System.Web;
-using System.Web.Mvc;
-using System.Web.Mvc.Html;
-using System.Text;
-using System.Text.RegularExpressions;
-using System.Collections.Generic;
-using Umbraco.Core;
-using Umbraco.Core.Logging;
-using Umbraco.Web;
-using Archetype.Models;
-
-namespace Archetype.Extensions
-{
-    public static class Extensions
-    {
-        //lifted from the core as it is marked 'internal'
-        public static bool DetectIsJson(this string input)
-        {
-            input = input.Trim();
-            return input.StartsWith("{") && input.EndsWith("}")
-                   || input.StartsWith("[") && input.EndsWith("]");
-        }
-
-        public static bool IsArchetype(this ArchetypePropertyModel prop)
-        {
-            return prop.PropertyEditorAlias.InvariantEquals(Constants.PropertyEditorAlias);
-        }
-
-        public static IHtmlString RenderArchetypePartials(this HtmlHelper htmlHelper, ArchetypeModel archetypeModel)
-        {
-            return RenderPartials(htmlHelper, archetypeModel, null, null);
-        }
-
-        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 RenderPartials(htmlHelper, archetypeModel, partialPath, viewDataDictionary);
-        }
-
-        private static IHtmlString RenderPartials(HtmlHelper htmlHelper, ArchetypeModel archetypeModel, string partialPath, ViewDataDictionary viewDataDictionary)
-        {
-            var context = HttpContext.Current;
-
-            if (archetypeModel == null || context == null)
-            {
-                return new HtmlString("");
-            }
-
-            var sb = new StringBuilder();
-            
-            var pathToPartials = "~/Views/Partials/Archetype/";
-            if (!string.IsNullOrEmpty(partialPath))
-            {
-                pathToPartials = partialPath;
-            }
-
-            foreach (var fieldsetModel in archetypeModel)
-            {
-                var partial = pathToPartials + fieldsetModel.Alias + ".cshtml";
-
-                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());
-        }
-    }
-}

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

@@ -0,0 +1,160 @@
+using System.Text;
+using System.Web;
+using System.Web.Mvc;
+using System.Web.Mvc.Html;
+using Archetype.Models;
+using Umbraco.Core.Logging;
+
+namespace Archetype.Extensions
+{
+    /// <summary>
+    /// HtmlHelper extenions used for rendering an Archetype.
+    /// </summary>
+    public static class HtmlHelperExtensions
+    {
+        /// <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)
+        {
+            var sb = new StringBuilder();
+
+            foreach (var fieldsetModel in archetypeModel)
+            {
+                sb.AppendLine(_renderPartial(htmlHelper, fieldsetModel, partialPath, viewDataDictionary).ToString());
+            }
+
+            return new HtmlString(sb.ToString());
+        }
+
+        /// <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 (fieldsetModel == null || context == null)
+            {
+                return new HtmlString("");
+            }
+
+            var sb = new StringBuilder();
+
+            //default
+            var pathToPartials = "~/Views/Partials/Archetype/";
+
+            if (!string.IsNullOrEmpty(partialPath))
+            {
+                pathToPartials = partialPath;
+            }
+
+            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)));
+            }
+
+            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

@@ -0,0 +1,20 @@
+namespace Archetype.Extensions
+{
+    /// <summary>
+    /// String extensions.
+    /// </summary>
+    public static class StringExtensions
+    {
+        /// <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();
+            return input.StartsWith("{") && input.EndsWith("}")
+                   || input.StartsWith("[") && input.EndsWith("]");
+        }
+    }
+}

app/Umbraco/Umbraco.Archetype/Models/ArchetypeConfigFileModel.cs

@@ -0,0 +1,10 @@
+using System;
+
+namespace Archetype.Models
+{
+    public class ArchetypeConfigFileModel
+    {
+        public Guid Id { get; set; }
+        public bool CheckForUpdates { get; set; }
+    }
+}

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

@@ -1,18 +1,44 @@
+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")]
         public string Alias { get; set; }
 
+        [JsonProperty("disabled")]
+        public bool Disabled { get; set; }
+
         [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>();
@@ -20,26 +46,83 @@ 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 (property == null || property.Value == null || string.IsNullOrEmpty(property.Value.ToString()))
+            if (IsEmptyProperty(property))
+            {
                 return default(T);
+            }
 
             return property.GetValue<T>();
         }
 
+        // issue 142: support default T value supplied by caller
+        // this code would look nicer if the two GetValue<T>() methods had one common implementation.
+        // 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))
+            {
+                return defaultValue;
+            }
+
+            return property.GetValue<T>();
+        }
+
+        /// <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);
@@ -49,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/ArchetypeGlobalSettings.cs

@@ -0,0 +1,134 @@
+using System;
+using System.IO;
+using System.Text;
+using Newtonsoft.Json;
+using Umbraco.Core.IO;
+using Umbraco.Core.Logging;
+
+namespace Archetype.Models
+{
+    public class ArchetypeGlobalSettings
+    {
+        public bool CheckForUpdates { get; set; }
+        public Guid Id { get; set; }
+
+        public Guid ApiKey = _getApiKey();
+
+        private static ArchetypeGlobalSettings _instance;
+
+        private static string _pathToConfig = @"~/Config/Archetype.config.js";
+
+        private static readonly string _mappedPathToConfig = IOHelper.MapPath(_pathToConfig);
+
+        private static object _padLock = new object();
+
+        private ArchetypeGlobalSettings()
+        {
+            
+        }
+
+        public static ArchetypeGlobalSettings Instance
+        {
+            get
+            {
+                if (_instance == null)
+                {
+                    lock (_padLock)
+                    {
+                        if (_instance == null)
+                        {
+                            _instance = new ArchetypeGlobalSettings();
+
+                            _loadSettingsFromConfigFile();
+                        }
+                    }
+                }
+
+                return _instance;
+            }
+        }
+
+        public void Save()
+        {
+            lock (_padLock)
+            {
+                //write to JSON
+                var configFileModel = new ArchetypeConfigFileModel
+                {
+                    Id = _instance.Id,
+                    CheckForUpdates = _instance.CheckForUpdates
+                };
+
+                var serializedJson = JsonConvert.SerializeObject(configFileModel, Formatting.Indented);
+
+                File.WriteAllText(_mappedPathToConfig, serializedJson);
+            }
+        }
+
+        private static void _loadSettingsFromConfigFile()
+        {
+            try
+            {
+                if (File.Exists(_mappedPathToConfig))
+                {
+                    //load
+                    var deserializedConfigFile = JsonConvert.DeserializeObject<ArchetypeConfigFileModel>(File.ReadAllText(_mappedPathToConfig));
+
+                    if (deserializedConfigFile != null)
+                    {
+                        _instance.Id = deserializedConfigFile.Id;
+                        _instance.CheckForUpdates = deserializedConfigFile.CheckForUpdates;
+                    }
+                    else
+                    {
+                        _createNewConfigFile("Config file model was null!");
+                    }
+                }
+                else
+                {
+                    _createNewConfigFile("Config file was missing!");
+                }
+            }
+            catch (Exception ex)
+            {
+                LogHelper.Error<ArchetypeGlobalSettings>(ex.Message, ex);
+
+                _createNewConfigFile("Exception!");
+            }
+        }
+
+        private static void _createNewConfigFile(string reason)
+        {
+            //write a new file with defaults
+            LogHelper.Info<ArchetypeGlobalSettings>(string.Format("Generating a new config file reason: {0}", reason));
+
+            _instance.Id = Guid.NewGuid();
+            _instance.CheckForUpdates = true;
+            _instance.Save();
+        }
+
+        private static Guid _getApiKey()
+        {
+            //this is just obfuscation and an attempt to keep out most but not the determined hacker
+            var array = new []
+            {
+                "RTA4MUZDRjA=",
+                "NzkzQS1BRDIw",
+                "OTI3QjFDNjkwQTYy",
+                "MjI0OQ=="
+            };
+
+            return new Guid(string.Format("{0}-{1}-{3}-{2}",
+                _decodeBase64(array[0]),
+                _decodeBase64(array[1]),
+                _decodeBase64(array[2]),
+                _decodeBase64(array[3])
+            ));
+        }
+
+        private static string _decodeBase64(string input)
+        {
+            return Encoding.UTF8.GetString(Convert.FromBase64String(input));
+        }
+    }
+}

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

@@ -1,37 +1,58 @@
 using System;
 using System.Collections;
 using System.Collections.Generic;
+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")]
-        internal IEnumerable<ArchetypeFieldsetModel> Fieldsets { get; set; }
+        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.GetEnumerator();
+            return this.Fieldsets.Where(f => f.IsAvailable()).GetEnumerator();
         }
 
+        //possibly obsolete?
         IEnumerator IEnumerable.GetEnumerator()
         {
             return this.GetEnumerator();
         }
 
-        internal string SerializeForPersistence()
+        /// <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));
-            var propertiesToRemove = new String[] { "propertyEditorAlias", "dataTypeId", "dataTypeGuid", "hostContentType" };
+            var json = JObject.Parse(JsonConvert.SerializeObject(this, new JsonSerializerSettings() { ReferenceLoopHandling = ReferenceLoopHandling.Ignore }));
+
+            var propertiesToRemove = new String[] { "propertyEditorAlias", "dataTypeId", "dataTypeGuid", "hostContentType", "editorState" };
 
             json.Descendants().OfType<JProperty>()
               .Where(p => propertiesToRemove.Contains(p.Name))

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,18 +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; }
 
@@ -44,7 +73,16 @@ namespace Archetype.Models
         [JsonProperty("customJsPath")]
         public string CustomJsPath { get; set; }
 
+        [JsonProperty("customViewPath")]
+        public string CustomViewPath { get; set; }
+
+        [JsonProperty("enableDeepDatatypeRequests")]
+        public bool EnableDeepDatatypeRequests { get; set; }
+        
         [JsonProperty("developerMode")]
         public bool DeveloperMode { get; set; }
+
+        [JsonProperty("overrideDefaultPropertyValueConverter")]
+        public bool OverrideDefaultPropertyValueConverter { 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

@@ -1,20 +1,24 @@
 using System.Collections.Generic;
 using System.Linq;
+using Archetype.Extensions;
 using Newtonsoft.Json;
 using Umbraco.Core;
-using Umbraco.Core.Models;
 using Umbraco.Core.Models.PublishedContent;
 using Umbraco.Core.PropertyEditors;
 using Umbraco.Web;
 
 namespace Archetype.Models
 {
-    public class ArchetypePropertyModel {
+    /// <summary>
+    /// Model that represents a stored property in Archetype.
+    /// </summary>
+    public class ArchetypePropertyModel
+    {
         [JsonProperty("alias")]
-        public string Alias { get; internal set; }
+        public string Alias { get; set; }
 
         [JsonProperty("value")]
-        public object Value { get; internal set; }
+        public object Value { get; set; }
 
         [JsonProperty("propertyEditorAlias")]
         public string PropertyEditorAlias { get; internal set; }
@@ -25,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)
@@ -52,9 +64,16 @@ 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 = CreateDummyPropertyType(DataTypeId, PropertyEditorAlias);
+            var properyType = this.CreateDummyPropertyType();
 
             // In umbraco, there are default value converters that try to convert the 
             // value if all else fails. The problem is, they are also in the list of
@@ -72,6 +91,13 @@ namespace Archetype.Models
                 if (value2 is T)
                     return Attempt<T>.Succeed((T)value2);
 
+                // If ConvertDataToSource failed try ConvertSourceToObject.
+                var value3 = converter.ConvertSourceToObject(properyType, value2, false);
+
+                // If the value is of type T, just return it
+                if (value3 is T)
+                    return Attempt<T>.Succeed((T)value3);
+
                 // Value is not final value type, so try a regular type conversion aswell
                 var convertAttempt = value2.TryConvertTo<T>();
                 if (convertAttempt.Success)
@@ -81,13 +107,14 @@ namespace Archetype.Models
             return Attempt<T>.Fail();
         }
 
-        private PublishedPropertyType CreateDummyPropertyType(int dataTypeId, string propertyEditorAlias)
+        /// <summary>
+        /// Model that represents the current UmbracoEditorState
+        /// </summary>
+        internal class UmbracoEditorState
         {
-            return new PublishedPropertyType(this.HostContentType,
-                new PropertyType(new DataTypeDefinition(-1, propertyEditorAlias)
-                {
-                    Id = dataTypeId
-                }));
+            // 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/Models/ArchetypeUpdateNotification.cs

@@ -0,0 +1,11 @@
+namespace Archetype.Models
+{
+    public class ArchetypeUpdateNotification
+    {
+        public bool IsUpdateAvailable { get; set; }
+        public string Headline { get; set; }
+        public string Type { get; set; }
+        public string Message { get; set; }
+        public string Url { get; set; }
+    }
+}

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

@@ -5,9 +5,9 @@ using System.Runtime.InteropServices;
 [assembly: AssemblyTitle("Archetype")]
 [assembly: AssemblyDescription("Archetype's supporting code library for Umbraco")]
 [assembly: AssemblyConfiguration("")]
-[assembly: AssemblyCompany("Imulus")]
+[assembly: AssemblyCompany("Kevin Giszewski LLC")]
 [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.2")]
-[assembly: AssemblyFileVersion("1.2-beta")]
+[assembly: AssemblyVersion("1.17.1")]
+[assembly: AssemblyFileVersion("1.17.1")]

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

@@ -1,35 +1,56 @@
 using System;
-using System.Collections.Generic;
-using System.Linq;
-using Archetype.Extensions;
+using Archetype.Extensions;
 using Archetype.Models;
-using Newtonsoft.Json;
 using Umbraco.Core;
-using Umbraco.Core.Models;
 using Umbraco.Core.Models.PublishedContent;
 using Umbraco.Core.PropertyEditors;
 using Umbraco.Core.Services;
-
-namespace Archetype.PropertyConverters
+
+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)
         {
-            return propertyType.PropertyEditorAlias.Equals(Constants.PropertyEditorAlias);
+            var isArcheTypePropertyEditor = !String.IsNullOrEmpty(propertyType.PropertyEditorAlias) 
+                && propertyType.PropertyEditorAlias.Equals(Constants.PropertyEditorAlias);
+            if (!isArcheTypePropertyEditor)
+                return false;
+
+            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 Models.ArchetypeModel();
+            var defaultValue = new ArchetypeModel();
 
             if (source == null)
                 return defaultValue;
@@ -39,11 +60,14 @@ namespace Archetype.PropertyConverters
             if (!sourceString.DetectIsJson())
                 return defaultValue;
 
-            var archetype = new ArchetypeHelper().DeserializeJsonToArchetype(source.ToString(),
-                (propertyType != null ? propertyType.DataTypeId : -1),
-                (propertyType != null ? propertyType.ContentType : null));
+			using (var timer = DisposableTimer.DebugDuration<ArchetypeValueConverter>(string.Format("ConvertDataToSource ({0})", propertyType != null ? propertyType.PropertyTypeAlias : "null")))
+            {
+                var archetype = ArchetypeHelper.Instance.DeserializeJsonToArchetype(sourceString,
+                    (propertyType != null ? propertyType.DataTypeId : -1),
+                    (propertyType != null ? propertyType.ContentType : null));
 
-            return archetype;
+                return archetype;
+            }
         }
     }
 }

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

@@ -1,34 +1,45 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using Archetype.Extensions;
+using Archetype.Models;
 using ClientDependency.Core;
 using Newtonsoft.Json;
-using Newtonsoft.Json.Linq;
 using Umbraco.Core;
+using Umbraco.Core.Logging;
 using Umbraco.Core.Models;
 using Umbraco.Core.Models.Editors;
 using Umbraco.Core.PropertyEditors;
 using Umbraco.Core.Services;
 using Umbraco.Web.PropertyEditors;
-using Umbraco.Core.Logging;
+using Umbraco.Web.Models.ContentEditing;
 
 namespace Archetype.PropertyEditors
 {
-	[PropertyEditorAsset(ClientDependencyType.Javascript, "/App_Plugins/Archetype/js/archetype.js")]
-	[PropertyEditor("Imulus.Archetype", "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; }
 
@@ -41,105 +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() == "")
+				if(property.Value == null || property.Value.ToString() == "")
 					return string.Empty;
 
-			    var archetype = new ArchetypeHelper().DeserializeJsonToArchetype(property.Value.ToString(), propertyType.DataTypeDefinitionId);
+				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<ArchetypeHelper>(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() == "")
+				if(property.Value == null || property.Value.ToString() == "")
 					return string.Empty;
 
-			    var archetype = new ArchetypeHelper().DeserializeJsonToArchetype(property.Value.ToString(), propertyType.DataTypeDefinitionId);
+				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<ArchetypeHelper>(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)
+
+            /// <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() == "")
+				if(editorValue.Value == null || editorValue.Value.ToString() == "")
 					return string.Empty;
 
-				var archetype = new ArchetypeHelper().DeserializeJsonToArchetype(editorValue.Value.ToString(), editorValue.PreValues);
+				// 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<ArchetypeHelper>(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();
+				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/Serialization/ArchetypeJsonConverter.cs

@@ -1,354 +0,0 @@
-using System;
-using System.Collections;
-using System.Collections.Generic;
-using System.Dynamic;
-using System.IO;
-using System.Linq;
-using System.Reflection;
-using System.Text;
-using Newtonsoft.Json;
-using Newtonsoft.Json.Linq;
-
-namespace Archetype.Serialization
-{
-    public class ArchetypeJsonConverter : JsonConverter
-    {
-        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
-        {
-            var models = GenerateModels(value);
-
-            if (models.Count < 1)
-                return;
-
-            if (models.Count == 1 && models[0] == null) 
-                return;
-
-            var jObj = new JObject
-            {
-                {
-                    "fieldsets", 
-                     new JArray( new JRaw(SerializeModels(models)))
-                }
-            };
-
-            writer.WriteRaw(ApplyFormatting(jObj.ToString(), writer.Formatting));
-        }
-
-        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
-        {
-            var jToken = JToken.ReadFrom(reader);
-
-            if (jToken == null)
-                return null;
-
-            var obj = Activator.CreateInstance(objectType);
-
-            if (null != obj as IEnumerable<object>
-                && jToken["fieldsets"] != null && jToken["fieldsets"].Any())
-            {
-                return DeserializeEnumerableObject(obj, jToken);
-            }
-
-            return null == jToken as JArray 
-                        ? DeserializeObject(obj, jToken) 
-                        : PopulateProperties(obj, jToken);
-        }
-
-        public override bool CanConvert(Type objectType)
-        {
-            return IsValueArchetypeDatatype(objectType);
-        }
-
-        #region private methods
-
-        private string ApplyFormatting(string json, Formatting formatting)
-        {
-            return JToken.Parse(json).ToString(formatting);
-        }
-
-        private IList GenerateModels(object value)
-        {
-            var models = value as IList;
-
-            if (null != models)
-                return models;
-
-            var properties = GetSerialiazableProperties(value).ToList();
-
-            if (!PropertyLayoutHasFieldsets(properties))
-                return new List<object>() { value };
-
-            var dynamicModel = new ExpandoObject() as IDictionary<string, object>;
-
-            foreach (var pInfo in properties.Where(pInfo => !HasAsFieldsetAttribute(pInfo)))
-            {
-                dynamicModel.Add(GetJsonPropertyName(pInfo), pInfo.GetValue(value));
-            }
-
-            var fieldsetModels = properties.Where(HasAsFieldsetAttribute)
-                .Select(pInfo => pInfo.GetValue(value));
-
-            models = new List<object>
-            {
-                dynamicModel,                
-            };
-
-            models = ((IEnumerable<object>)models).Concat(fieldsetModels).ToList();
-
-            return models;
-        }
-
-        private object DeserializeEnumerableObject(object obj, JToken jToken)
-        {
-            var model = obj as IEnumerable<object>;
-
-            var itemType = model.GetType().BaseType.GetGenericArguments().First();
-            foreach (var fs in jToken["fieldsets"].Where(fs => fs["alias"].ToString().Equals(GetFieldsetName(itemType))))
-            {
-                var item = JsonConvert.DeserializeObject(
-                    fs["properties"].ToString(), itemType, GetArchetypeDatatypeConverter());
-
-                obj.GetType().GetMethod("Add").Invoke(obj, new[] { item });
-            }
-
-            return obj;
-        }
-
-        private object DeserializeObject(object obj, JToken jToken)
-        {
-            var properties = GetSerialiazableProperties(obj).ToList();
-            var asFieldset = properties.Where(HasAsFieldsetAttribute).ToList();
-
-            foreach (var propInfo in asFieldset)
-            {
-                var propAlias = GetJsonPropertyName(propInfo);
-                var fsJToken = GetFieldsetProperties(propInfo.PropertyType, jToken);
-                var propJToken =
-                    fsJToken.Single(p => p.SelectToken("alias").ToString().Equals(propAlias));
-
-                if (propJToken == null)
-                    continue;
-
-                var propValue = IsValueArchetypeDatatype(propInfo.PropertyType)
-                ? JsonConvert.DeserializeObject(fsJToken.ToString(), propInfo.PropertyType,
-                    GetArchetypeDatatypeConverter())
-                : GetDeserializedPropertyValue(fsJToken, propInfo.PropertyType); ;
-
-                propInfo.SetValue(obj, propValue);
-            }
-
-            return PopulateProperties(obj, GetFieldsetProperties(obj.GetType(), jToken));
-        }
-
-        private JToken GetFieldsetProperties(Type objType, JToken jToken)
-        {
-            var objAlias = GetFieldsetName(objType);
-            return
-                jToken["fieldsets"].Single(p => p.SelectToken("alias").ToString().Equals(objAlias)).SelectToken("properties");
-        }
-
-        private object PopulateProperties(object obj, JToken jToken)
-        {
-            var properties = GetSerialiazableProperties(obj);
-
-            foreach (var propertyInfo in properties)
-            {
-                var propAlias = GetJsonPropertyName(propertyInfo);
-
-                var propJToken = jToken.SingleOrDefault(p => p.SelectToken("alias").ToString().Equals(propAlias));
-
-                if (propJToken == null)
-                    continue;
-
-                var propValue = GetPropertyValue(propertyInfo, propJToken);
-
-                propertyInfo.SetValue(obj, propValue);
-            }
-
-            return obj;
-        }
-
-        private object GetPropertyValue(PropertyInfo propertyInfo, JToken propJToken)
-        {
-            return IsValueArchetypeDatatype(propertyInfo.PropertyType)
-                ? JsonConvert.DeserializeObject(propJToken["value"].ToString(), propertyInfo.PropertyType,
-                    GetArchetypeDatatypeConverter())
-                : GetDeserializedPropertyValue(propJToken["value"], propertyInfo.PropertyType);
-        }
-
-        private bool PropertyLayoutHasFieldsets(IEnumerable<PropertyInfo> properties)
-        {
-            return properties.Any(HasAsFieldsetAttribute);
-        }
-
-        private static bool HasAsFieldsetAttribute(PropertyInfo pInfo)
-        {
-            return pInfo
-                .GetCustomAttributes(typeof(AsFieldsetAttribute), true).Length > 0;
-        }
-
-        private IEnumerable SerializeModels(IEnumerable models)
-        {
-            var fieldsetJson = (from object model in models where null != model select SerializeModel(model)).ToList();
-
-            return String.Join(",", fieldsetJson);
-        }
-
-        private string SerializeModel(object value)
-        {
-            if (value == null)
-                return null;
-
-            var jObj = IsExpandoObject(value) 
-                ? GetJObjectFromExpandoObject(value as IDictionary<string, object>) 
-                : GetJObject(value);
-
-            var fieldsetJson = new StringBuilder();
-            var fieldsetWriter = new StringWriter(fieldsetJson);
-
-            using (var jsonWriter = new JsonTextWriter(fieldsetWriter))
-            {
-                jObj.WriteTo(jsonWriter);
-            }
-
-            return fieldsetJson.ToString();
-        }
-
-        private bool IsExpandoObject(object value)
-        {
-            return value.GetType().Name.Equals(typeof (ExpandoObject).Name);
-        }
-
-        private JObject GetJObjectFromExpandoObject(IEnumerable<KeyValuePair<string, object>> obj)
-        {
-            var property = obj.ElementAt(0);
-            var alias = property.Key;
-            var value = property.Value;
-
-            var jObj = new JObject
-                {
-                    {
-                        "alias",
-                        new JValue(alias)
-                    }
-                };
-
-            var fsProperties = new List<JObject>
-            {
-                new JObject {new JProperty("alias", alias), new JProperty("value", value)}
-            };
-            jObj.Add("properties", new JRaw(JsonConvert.SerializeObject(fsProperties)));
-
-            return jObj;
-        }
-
-        private JObject GetJObject(object obj)
-        {
-            var jObj = new JObject
-                {
-                    {
-                        "alias",
-                        new JValue(GetFieldsetName(obj.GetType()))
-                    }
-                };
-
-            var properties = GetSerialiazableProperties(obj);
-
-            var fsProperties = new List<JObject>();
-
-            foreach (var propertyInfo in properties)
-            {
-                var fsProperty = new JObject();
-                var jProperty = new JProperty("alias", GetJsonPropertyName(propertyInfo));
-                fsProperty.Add(jProperty);
-
-                var propValue = propertyInfo.GetValue(obj, null);
-
-                fsProperty.Add(
-                    new JProperty("value",
-                                  IsValueArchetypeDatatype(propValue)
-                                      ? new JRaw(JsonConvert.SerializeObject(propValue,
-                                                                             GetArchetypeDatatypeConverter()))
-                                      : new JValue(GetSerializedPropertyValue(propValue))));
-
-                fsProperties.Add(fsProperty);
-            }
-
-            jObj.Add("properties", new JRaw(JsonConvert.SerializeObject(fsProperties)));
-
-            return jObj;
-        }
-
-        private IEnumerable<PropertyInfo> GetSerialiazableProperties(object obj)
-        {
-            return obj.GetType()
-                .GetProperties(BindingFlags.Instance | BindingFlags.Public)
-                .Where(prop => !Attribute.IsDefined(prop, typeof(JsonIgnoreAttribute)));
-        }
-
-        private string GetJsonPropertyName(PropertyInfo property)
-        {
-            var attributes = property.GetCustomAttributes(true);
-            var jsonPropAttribute = (JsonPropertyAttribute)attributes.FirstOrDefault(attr => attr is JsonPropertyAttribute);
-
-            return jsonPropAttribute != null ? jsonPropAttribute.PropertyName : property.Name;
-        }
-
-        private string GetFieldsetName(Type type)
-        {
-            var attributes = type.GetCustomAttributes(true);
-            var archetypeDatatypeAttribute = (AsArchetypeAttribute)attributes.FirstOrDefault(attr => attr is AsArchetypeAttribute);
-
-            return archetypeDatatypeAttribute != null ? archetypeDatatypeAttribute.FieldsetName : type.Name;
-        }
-
-        private bool IsValueArchetypeDatatype(object value)
-        {
-            return value != null &&
-                IsValueArchetypeDatatype(value.GetType());
-        }
-
-        private bool IsValueArchetypeDatatype(Type type)
-        {
-            return type.GetCustomAttributes(typeof(AsArchetypeAttribute), true).Length > 0;
-        }
-
-        private JsonConverter GetArchetypeDatatypeConverter()
-        {
-            return (JsonConverter)Activator.CreateInstance(GetType());
-        }
-
-        private string GetSerializedPropertyValue(object propValue)
-        {
-            if (propValue == null)
-                return String.Empty;
-
-            if (propValue is bool)
-                return (bool)propValue ? GetSerializedPropertyValue(1) : GetSerializedPropertyValue(0);
-
-            return String.Format("{0}", propValue);
-        }
-
-        private object GetDeserializedPropertyValue(JToken jToken, Type type)
-        {            
-            if (String.IsNullOrEmpty(jToken.ToString()))
-                return GetDefault(type);
-
-            var localType = Nullable.GetUnderlyingType(type) ?? type;
-
-            if (localType == typeof(bool))
-                return jToken.ToString() == "1";
-
-            return localType == typeof(DateTime) 
-                ? Convert.ToDateTime(jToken.ToString())
-                : jToken.ToObject(localType);
-        }
-
-        private object GetDefault(Type type)
-        {
-            return type.IsValueType ? Activator.CreateInstance(type) : null;
-        }
-
-        #endregion
-    }
-}

app/Umbraco/Umbraco.Archetype/Serialization/AsArchetypeAttribute.cs

@@ -1,14 +0,0 @@
-using System;
-
-namespace Archetype.Serialization
-{
-    public class AsArchetypeAttribute : Attribute
-    {
-        public string FieldsetName { get; set; }
-
-        public AsArchetypeAttribute(string fieldsetname)
-        {
-            FieldsetName = fieldsetname;
-        }
-    }
-}

app/Umbraco/Umbraco.Archetype/Serialization/AsFieldsetAttribute.cs

@@ -1,8 +0,0 @@
-using System;
-
-namespace Archetype.Serialization
-{
-    public class AsFieldsetAttribute : Attribute
-    {
-    }
-}

app/Umbraco/Umbraco.Archetype/Serialization/SerializationExtensions.cs

@@ -1,32 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using Newtonsoft.Json;
-using Umbraco.Core.Models;
-using Umbraco.Web;
-
-namespace Archetype.Serialization
-{
-    public static class SerializationExtensions
-    {
-        //temporary
-        public static string GetPropertyDataValue(this IPublishedContent contentPage, string propertyAlias)
-        {
-            if (contentPage == null || !contentPage.HasProperty(propertyAlias))
-                return null;
-
-            return (string)contentPage.Properties.Single(p => p.PropertyTypeAlias == propertyAlias).DataValue;
-        }
-
-        public static T GetModelFromArchetype<T>(this IPublishedContent content,
-            string cmsFieldAlias, bool returnInstanceIfNull = false)
-            where T : class, new()
-        {
-            var archetypeJson = content.GetPropertyDataValue(cmsFieldAlias);
-            return JsonConvert.DeserializeObject<T>(archetypeJson) ??
-                   (returnInstanceIfNull ? Activator.CreateInstance<T>() : default(T));
-        }
-    }
-}

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

@@ -1,16 +1,33 @@
-angular.module("umbraco").controller("Imulus.ArchetypeConfigController", function ($scope, $http, assetsService, dialogService, archetypePropertyEditorResource) {
+angular.module("umbraco").controller("Imulus.ArchetypeConfigController", function ($scope, $http, assetsService, dialogService, archetypePropertyEditorResource, archetypeGlobalConfigService, notificationsService) {
 
     //$scope.model.value = "";
     //console.log($scope.model.value);
 
     //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, "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;
+    });
+       
+    archetypeGlobalConfigService.checkForUpdates().then(function(data) {
+        if(data.isUpdateAvailable) {
+            notificationsService.add({
+                headline: data.headline,
+                type: data.type,
+                message: data.message,
+                url: data.url
+            });
+        }
+    });
+
     //ini the render model
     initConfigRenderModel();
 
@@ -41,6 +58,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 +77,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 +88,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 +130,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 +143,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 +257,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 +318,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,16 @@
+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/config.global.controller.js

@@ -0,0 +1,21 @@
+angular.module('umbraco').controller('ArchetypeConfigGlobalOptionsController', function ($scope, archetypeGlobalConfigService) {
+    $scope.globalSettings = {};
+  
+    $scope.confirmCheckNewVersionChange = function() {      
+        archetypeGlobalConfigService.setCheckForUpdates($scope.globalSettings.checkForNewVersion);
+    }
+    
+    function getGlobalSettings()
+    {
+        archetypeGlobalConfigService.globalSettings().then(function(data) {          
+            $scope.globalSettings.checkForNewVersion = data.isCheckingForUpdates;
+        });
+    }    
+    
+    init();
+       
+    function init()
+    {      
+        getGlobalSettings();
+    }
+});

app/controllers/controller.js

@@ -1,4 +1,10 @@
-angular.module("umbraco").controller("Imulus.ArchetypeController", function ($scope, $http, assetsService, angularHelper, notificationsService, $timeout) {
+{{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;
+    
+    var isCacheInitialized = false;
 
     //$scope.model.value = "";
     $scope.model.hideLabel = $scope.model.config.hideLabel == 1;
@@ -11,51 +17,347 @@
 
     //ini the model
     $scope.model.value = $scope.model.value || getDefaultModel($scope.model.config);
+
+    // 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();
-
+    
     //helper to get $eval the labelTemplate
-    $scope.getFieldsetTitle = function(fieldsetConfigModel, fieldsetIndex) {
-        if(!fieldsetConfigModel)
+    $scope.fieldsetTitles = [];
+    $scope.getFieldsetTitle = function (fieldsetConfigModel, fieldsetIndex) {
+       
+        if(!isCacheInitialized) {         
             return "";
-        var fieldset = $scope.model.value.fieldsets[fieldsetIndex];
-        var fieldsetConfig = $scope.getConfigFieldsetByAlias(fieldset.alias);
-        var template = fieldsetConfigModel.labelTemplate;
+        }
+    
+        // Ensure the collection of titles is large enough.
+        ensureEnoughTitles(fieldsetIndex + 1);
+        var title = $scope.fieldsetTitles[fieldsetIndex];
 
-        if (template.length < 1)
-            return fieldsetConfig.label;
-
-        var rgx = /{{(.*?)}}*/g;
-        var results;
-        var parsedTemplate = template;
-
-        while ((results = rgx.exec(template)) !== null) {
-            var propertyAlias = results[1];
-            var propertyValue = $scope.getPropertyValueByAlias(fieldset, propertyAlias);
-            parsedTemplate = parsedTemplate.replace(results[0], propertyValue);
+        // Return the title if it's already been loaded.
+        if (title.loaded) {
+            return title.value;
         }
 
-        return parsedTemplate;
+        // Return early if the title is still loading.
+        if (title.loading) {
+            return;
+        }
+
+        // Start loading the title.
+        title.loading = true;
+        title.loaded = false;
+        title.value = null;
+
+        archetypeLabelService.getFieldsetTitle($scope, fieldsetConfigModel, fieldsetIndex).then(function(value) {
+            // Finished loading the title.
+            title.loaded = true;
+            title.loading = false;
+            title.value = value;
+        });
     };
 
+    /**
+     * Ensure the collection of fieldset titles is large enough to accommodate the number of fieldsets.
+     * @param count The number of fieldsets.
+     */
+    function ensureEnoughTitles(count) {
+        while ($scope.fieldsetTitles.length < count) {
+            $scope.fieldsetTitles.push({
+                loading: false,
+                loaded: false,
+                value: null
+            });
+        }
+    }
+
     //sort config
     $scope.sortableOptions = {
         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.getEditors().addClass('archetypeDragging');
+            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);
+
+            archetypeService.getEditors().removeClass('archetypeDragging');
         }
     };
 
+    // 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')
@@ -67,10 +369,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();
         }
     }
 
@@ -79,13 +393,73 @@
             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);
+            }
+        }
+    }
+
+    $scope.enableDisable = function (fieldset) {
+        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;
@@ -94,31 +468,131 @@
         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 () {
+        return $scope.model.config.enableDisabling;
     }
 
     //helpers for determining if the add button should be shown
     $scope.showAddButton = function () {
+        var visible = countVisible();
+        return (visible === 0 && $scope.model.config.startWithAddButton) 
+            || (visible > 0 && $scope.canAdd());
+    }
+
+    //helper for determining if no content is available yet
+    $scope.showEmptyContentHint = function () {
         return $scope.model.config.startWithAddButton
             && countVisible() === 0;
             ///&& $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);
+        
+        archetypeCacheService.initialize().then(function() {
+            isCacheInitialized = true;
+        });
+
+        $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)
@@ -130,6 +604,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){
@@ -149,9 +653,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
@@ -162,40 +672,84 @@
             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);
+    }
+
+    // Deep watch for changes.
+    $scope.$watch('model.value', function () {
+
+        // Empty titles. If the value has changed, the titles may have changed.
+        $scope.fieldsetTitles = [];
+
+    }, true);
+
     //watch for changes
     $scope.$watch('model.value', function (v) {
         if ($scope.model.config.developerMode) {
@@ -205,6 +759,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
@@ -263,6 +833,24 @@
         return (typeof property == 'undefined') ? true : property.isValid;
     }
 
+    //helper to lookup validity when given a fieldset
+    $scope.getFieldsetValidity = function (fieldset) {
+
+        // Variables.
+        var valid = true;
+
+        // Recursive validation of nested fieldsets.
+        recurseFieldsets(function(item) {
+            if (item.isValid === false) {
+                valid = false;
+            }
+        }, [fieldset]);
+
+        // Were all the nested fieldsets valid?
+        return valid;
+
+    };
+
     // helper to force the current form into the dirty state
     $scope.setDirty = function () {
         if($scope.form) {
@@ -270,17 +858,144 @@
         }
     }
 
+    $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/archetypeLocalize.js

@@ -12,7 +12,7 @@ angular.module("umbraco.directives").directive('archetypeLocalize', function (ar
 
 	return {
 	    restrict: "E",
-	    rep1ace: true,
+	    replace: true,
 	    link: linker,
 	    scope: {
 	    	key: '@'

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,18 +1,12 @@
 angular.module("umbraco.directives").directive('archetypeCustomView', function ($compile, $http) {
     var linker = function (scope, element, attrs) {
 
-        var config = scope.archetype.config.archetypeConfig;
-
-        var view = "/App_plugins/Archetype/views/archetype.default.html";
-        if(config.customViewPath) {
-            view = config.customViewPath;
+        var view = "../App_plugins/Archetype/views/archetype.default.html";
+        if(scope.model.config.customViewPath) {
+            view = scope.model.config.customViewPath;
         }
 
-        $http.get(view).then(function(data) {
-
-            scope.model = {};
-            scope.model.value = scope.archetype.value;
-            scope.model.config = scope.archetype.config;
+        $http.get(view, { cache: true }).then(function(data) {
 
             element.html(data.data).show();
 
@@ -23,9 +17,6 @@ angular.module("umbraco.directives").directive('archetypeCustomView', function (
     return {
         restrict: "A",
         replace: true,
-        link: linker,
-        scope: {
-            archetype: "="
-        }
+        link: linker
     }
 });

app/directives/archetypeproperty.js

@@ -1,76 +1,28 @@
-angular.module("umbraco.directives").directive('archetypeProperty', function ($compile, $http, archetypePropertyEditorResource, umbPropEditorHelper, $timeout, $rootScope, $q) {
-
-    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) {
 
     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 umbracoPropertyAlias = scope.umbracoPropertyAlias;
-        // initialize container for invalid fieldset property identifiers (store on ngModelCtrl to separate Archetype validations, e.g. when there two Archetype properties on the same document)
-        if(ngModelCtrl.invalidProperties == null) {
-            ngModelCtrl.invalidProperties = [];
-        }
-
+        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).then(function (data) {
+        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;
 
             //determine the view to use [...] and load it
@@ -85,80 +37,15 @@ angular.module("umbraco.directives").directive('archetypeProperty', function ($c
 
                 var mergedConfig = _.extend(defaultConfigObj, config);
 
-                loadView(pathToView, mergedConfig, defaultValue, alias, umbracoPropertyAlias, scope, element, ngModelCtrl, validateProperty);
+                loadView(pathToView, mergedConfig, defaultValue, alias, propertyAlias, scope, element, ngModelCtrl, configFieldsetModel);
             });
         });
-
-        scope.$on("formSubmitting", function (ev, args) {
-            // "hard" validate to highlight any erroneous entries
-            _.each(scope.fieldset.properties, function (property) {
-                validateProperty(scope.fieldset, property, true);
-            });
-        });
-
-        scope.$on("formSubmitted", function (ev, args) {
-            // reset the nested fieldset validation state after submit
-            ngModelCtrl.invalidProperties = [];
-        });
-
-        // need to pass the property fieldset here to clear any invalid state of the fieldset when validating a single 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
-        function validateProperty(fieldset, property, markAsInvalid) {
-            var valid = true;
-            fieldset.isValid = true;
-            property.isValid = true;
-            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)) {
-                    valid = 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 (valid == true && propertyConfig.regEx && property.value) {
-                    var regEx = new RegExp(propertyConfig.regEx);
-                    if (regEx.test(property.value) == false) {
-                        valid = false;
-                    }
-                }
-                // only mark the property as invalid when doing a "hard" validation
-                if (valid == false && markAsInvalid == true) {
-                    property.isValid = false;
-                }
-            }
-
-            // handle nested fieldset validation by storing the identifier of all invalid fieldset properties 
-            var fieldsetIdentifier = scope.umbracoPropertyAlias + "_" + scope.fieldsetIndex;
-            var propertyIdentifier = fieldsetIdentifier + "_" + property.alias;
-            var propertyIdentifierIndex = ngModelCtrl.invalidProperties.indexOf(propertyIdentifier);
-            if (valid == false) {
-                if (propertyIdentifierIndex == -1) {
-                    ngModelCtrl.invalidProperties.push(propertyIdentifier);
-                }
-            }
-            else {
-                if (propertyIdentifierIndex != -1) {
-                    ngModelCtrl.invalidProperties.splice(propertyIdentifierIndex, 1);
-                }
-            }
-            
-            if (markAsInvalid) {
-                // mark the entire fieldset as invalid if there are any invalid properties in the fieldset, otherwise mark it as valid
-                fieldset.isValid =
-                    _.find(ngModelCtrl.invalidProperties, function (item) {
-                        return item.indexOf(fieldsetIdentifier) == 0
-                    }) == null;
-            }
-
-            // set invalid state if one or more fieldsets contain invalid properties
-            ngModelCtrl.$setValidity('validation', ngModelCtrl.invalidProperties.length == 0);
-        }
     }
 
-    function loadView(view, config, defaultValue, alias, umbracoPropertyAlias, scope, element, ngModelCtrl, validateProperty) {
+    function loadView(view, config, defaultValue, alias, propertyAlias, scope, element, ngModelCtrl, configFieldsetModel) {
         if (view)
         {
-            $http.get(view).success(function (data) {
+            $http.get(view, { cache: true }).success(function (data) {
                 if (data) {
                     if (scope.archetypeConfig.developerMode == '1')
                     {
@@ -171,28 +58,116 @@ 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;
 
+                    /*
+                        Property Specific Hacks
+
+                        Preference is to not do these, but unless we figure out core issues, this is quickest fix.
+                    */
+
+                    //MNTP *single* hack
+                    if(scope.model.config.maxNumber && scope.model.config.multiPicker)
+                    {
+                        if(scope.model.config.maxNumber == "1")
+                        {
+                            scope.model.config.multiPicker = "0";
+                        }
+                    }
+
+                    //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-" + umbracoPropertyAlias + "-" + scope.fieldsetIndex + "-" + scope.propertyConfigIndex;
+                    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;
 
-                        // call validation method for the property when the value changes 
-                        // use "soft" validation to mimic the default umbraco validation style (show error highlights on submit, not while entering data)
-                        validateProperty(scope.archetypeRenderModel.fieldsets[scope.fieldsetIndex], scope.archetypeRenderModel.fieldsets[scope.fieldsetIndex].properties[renderModelPropertyIndex], false);
+                        // notify the linker that the property value changed
+                        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();
@@ -216,6 +191,7 @@ angular.module("umbraco.directives").directive('archetypeProperty', function ($c
         scope: {
             property: '=',
             propertyConfigIndex: '=',
+            propertyEditorAlias: '=',
             archetypeConfig: '=',
             fieldset: '=',
             fieldsetIndex: '=',

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/sampleLabelHelpers.js

@@ -0,0 +1,51 @@
+//create a namespace (optional)
+var ArchetypeSampleLabelHelpers = {};
+
+//create a function
+//you will add it to your label template field as `{{ArchetypeSampleLabelHelpers.testPromise(someArchetypePropertyAlias)}}`
+ArchetypeSampleLabelHelpers.testPromise = function(value) {   
+    //you can inject services
+    return function ($timeout, archetypeCacheService) {        
+        //best to return a promise
+        //NOTE: $timeout returns a promise
+        return $timeout(function () {
+            return "As Promised: " + value;
+        }, 1000);
+    }
+}
+
+ArchetypeSampleLabelHelpers.testEntityPromise = function(value, scope, args) {
+    //hey look, args!
+    //{{ArchetypeSampleLabelHelpers.testEntityPromise(someArchetypePropertyAlias, {foo: 1})}}
+    console.log(args);
+    
+    return function ($q, entityResource) {    
+        var deferred = $q.defer();
+    
+        entityResource.getById(args.foo, 'document').then(function(entity) {
+            console.log("Hello from testEntityPromise");
+            console.log(entity);
+            deferred.resolve(entity.name);
+        });
+    
+        return deferred.promise;
+    }
+}
+
+ArchetypeSampleLabelHelpers.testEntityPromise2 = function(value, scope, args) {  
+    //hey look, args but we're also using the built-in archetypeCacheService
+    //{{ArchetypeSampleLabelHelpers.testEntityPromise(someArchetypePropertyAlias, {foo: 1234})}}
+    console.log(args);        
+    
+    return function ($q, archetypeCacheService) {    
+        var deferred = $q.defer();
+    
+        archetypeCacheService.getEntityById(args.foo, 'document').then(function(entity) {
+            console.log("Hello from testEntityPromise2");
+            console.log(entity);
+            deferred.resolve(entity.name);
+        });
+    
+        return deferred.promise;
+    }
+}

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",
@@ -31,5 +32,31 @@
 	"properties": "Egenskaber",
 	"labelTemplate": "Label skabelon",
 	"select": "Vælg",
-	"icon": "Ikon"
+	"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/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",
@@ -31,5 +32,17 @@
 	"properties": "Properties",
 	"labelTemplate": "Label Template",
 	"select": "Select",
-	"icon": "Icon"
+	"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/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",
@@ -10,7 +11,7 @@
 	"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.",
+	"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",
@@ -22,7 +23,7 @@
 	"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.",
+	"configModelDescription": "Be careful editing the text below, it controls the schema for this Archetype.",
 	"helpText": "Help Text",
 	"defaultValue": "Default Value",
 	"dataType": "DataType",
@@ -31,5 +32,19 @@
 	"properties": "Properties",
 	"labelTemplate": "Label Template",
 	"select": "Select",
-	"icon": "Icon"
+	"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/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",
@@ -10,7 +11,7 @@
 	"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.",
+	"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",
@@ -22,7 +23,7 @@
 	"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.",
+	"configModelDescription": "Be careful editing the text below, it controls the schema for this Archetype.",
 	"helpText": "Help Text",
 	"defaultValue": "Default Value",
 	"dataType": "DataType",
@@ -31,5 +32,19 @@
 	"properties": "Properties",
 	"labelTemplate": "Label Template",
 	"select": "Select",
-	"icon": "Icon"
+	"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/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",
@@ -31,5 +32,17 @@
 	"properties": "Properties",
 	"labelTemplate": "Label Template",
 	"select": "Select",
-	"icon": "Icon"
+	"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/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",
@@ -31,5 +32,17 @@
 	"properties": "Properties",
 	"labelTemplate": "Label Template",
 	"select": "Select",
-	"icon": "Icon"
+	"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/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",
@@ -31,5 +32,17 @@
 	"properties": "Properties",
 	"labelTemplate": "Label Template",
 	"select": "Select",
-	"icon": "Icon"
+	"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/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",
@@ -31,5 +32,17 @@
 	"properties": "Properties",
 	"labelTemplate": "Label Template",
 	"select": "Select",
-	"icon": "Icon"
+	"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/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",
@@ -31,5 +32,17 @@
 	"properties": "Properties",
 	"labelTemplate": "Label Template",
 	"select": "Select",
-	"icon": "Icon"
+	"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/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",
@@ -31,5 +32,17 @@
 	"properties": "Properties",
 	"labelTemplate": "Label Template",
 	"select": "Select",
-	"icon": "Icon"
+	"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/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",
@@ -31,5 +32,17 @@
 	"properties": "Properties",
 	"labelTemplate": "Label Template",
 	"select": "Select",
-	"icon": "Icon"
+	"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/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",
@@ -31,5 +32,17 @@
 	"properties": "Properties",
 	"labelTemplate": "Label Template",
 	"select": "Select",
-	"icon": "Icon"
+	"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/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",
@@ -31,5 +32,17 @@
 	"properties": "Properties",
 	"labelTemplate": "Label Template",
 	"select": "Select",
-	"icon": "Icon"
+	"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/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",
@@ -31,5 +32,17 @@
 	"properties": "Properties",
 	"labelTemplate": "Label Template",
 	"select": "Select",
-	"icon": "Icon"
+	"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/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",
@@ -31,5 +32,17 @@
 	"properties": "Properties",
 	"labelTemplate": "Label Template",
 	"select": "Select",
-	"icon": "Icon"
+	"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/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",
@@ -31,5 +32,17 @@
 	"properties": "Properties",
 	"labelTemplate": "Label Template",
 	"select": "Select",
-	"icon": "Icon"
+	"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/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",
@@ -31,5 +32,17 @@
 	"properties": "Properties",
 	"labelTemplate": "Label Template",
 	"select": "Select",
-	"icon": "Icon"
+	"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/less/archetype.less

@@ -1,321 +1,714 @@
-.archetypeEditor {
+{{VERSION}}
+
+.archetypeEditor {
     width: 98%;
 
+    .usky-grid {
+        .cell-tools-menu {
+            height: 385px;
+        }
+        &.withGroups {
+            .cell-tools-menu {
+                height: 415px;
+            }
+        }
+    }
+
+    .open {
+        position: relative;
+    }
+
     .dropdown-menu {
         top: auto;
-    }
-}
-
-.archetypeEditor fieldset{
-    border: 1px solid #dddddd;
-    padding: 0;
-    margin-bottom: 5px;
-    background-color: #f1f1f1;
-    clear: both;
-    display: inline-block;
-    width: 100%;
-}
-
-.archetypeEditor .archetypeFieldsetLabel {
-    position: relative;
-    width: 100%%;
-
-    .label-sub {
-        padding: 8px 0;
-        display: inline-block;
-        &.module-label {
-            width: 100%;
+        > li > a {
+            border-radius: 6px;
         }
     }
 
-    .dropdown-menu {
-        padding: 0;
-        border-radius: 0;
-        box-shadow: none;
-        margin-top: -10px;
-        margin-left: -200px;
+    .controls-no-label {
+        padding: 10px;
     }
 
-    span {
-        font-weight: bold;
-
-        &.menu-label { font-weight: normal; }
+    a+ul.dropdown-menu {
+        margin-left: 0;
     }
 
-    label:hover {
-        cursor: default;
-    }
-
-    &.enableCollapsing:hover {
-        cursor: pointer;
-
-        label  {
-            span {
-                text-decoration: underline;
-            }
-            &:hover {
-                cursor: pointer;
-            }
-        }
+    .fieldsetIcon {
+        float: left;
+        padding: 0 10px 0 0;
+        vertical-align: text-bottom;
     }
 
     .caret {
-        margin: 8px 1px 0 15px;
-
+        margin: 8px 1px 0 2px;
         &.caret-right {
             border-bottom: 4px solid transparent;
             border-top: 4px solid transparent;
-            border-left: 4px solid #000000;
+            border-left: 4px solid #ddd;
             content: "";
             margin-top: 6px;
         }
     }
 
-    label{
-        margin-bottom: 0;
-        margin-left: 5px;
+    fieldset {
+        border-bottom: 1px dashed #dddddd;
         padding: 0;
-        span {
-            display: inline-block;
+        clear: both;
+        display: inline-block;
+        width: 100%;
+
+        .archetypeProperty {
+            clear: both;
+            overflow: visible;
+            margin-top: 3px;
+
+            label {
+                padding-left: 5px !important;
+
+                span {
+                    color: #343434;
+                }
+                &.dimmed span {
+                    color: #d9d9d9;
+                }
+
+            }
+            
+            .publishOptions {
+                .publishDate {
+                    display: inline-block;
+                    vertical-align: top;
+                    margin-right: 20px;
+                    
+                    label {
+                        padding: 0 !important;
+                        margin: 0 !important;
+                    }
+                }
+            }
+        }
+
+        .archetypeFieldsetLabel {
+            position: relative;
+            width: 100%;
+            background: white;
+
+            .label-sub {
+                padding: 18px 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 {
+                position: relative;
+                padding: 0;
+                border-radius: 0;
+                box-shadow: none;
+                margin-top: -10px;
+            }
+
+            span {
+                // font-weight: bold;
+
+                &.menu-label { font-weight: normal; }
+            }
+
+            label:hover {
+                cursor: default;
+            }
+
+            .caret {
+                position: absolute;
+            }
+
+            label {
+                margin-bottom: 0;
+                margin-left: 18px;
+                padding: 0;
+                display: block;
+                span {
+                    display: block;
+                    overflow: hidden;
+                    text-overflow: ellipsis;
+                    max-height: 40px;
+                    -webkit-line-clamp: 2;
+                    -webkit-box-orient: vertical;
+                    display: -webkit-box;
+                }
+            }
+
+            &.dimmed {
+                label {
+                    color: #d9d9d9 !important;
+                }
+            }
+
+            .archetypeEditorControls {
+                float: none;
+                position: absolute;
+                right: 0;
+                top: 0;
+                height: 100%; 
+                padding: 0;
+                display: flex;
+                align-items: center;
+                opacity: 0;
+                transition: opacity .15s ease-in-out;
+                -moz-transition: opacity .15s ease-in-out;
+                -webkit-transition: opacity .15s ease-in-out;
+                background: white;
+
+                &:before {
+                    content: ' ';
+                    position: absolute;
+                    display: block; 
+                    left: -40px;
+                    width: 40px;
+                    top: 0;
+                    bottom: 0;
+                    background: -webkit-linear-gradient(90deg, rgba(255,255,255,0), white);
+                    background: -moz-linear-gradient(90deg, rgba(255,255,255,0), white);
+                    background: linear-gradient(90deg, rgba(255,255,255,0), white);
+                }
+
+                .icon {
+                    display: inline-block;
+                    height: 28px;
+                    width: 28px;
+                    line-height: 28px;
+                    border-radius: 14px;
+                    border: 1px solid #d6d6d6;
+                    color: #5f5f5f;
+                    background: white;
+                    font-size: 16px;
+                    text-align: center;
+                    margin-left: 8px;
+
+                    &:hover {
+                        background: #f3f3f5;
+                    }
+                    &.icon-trash:hover {
+                        background: #fe5b57;
+                        border-color: #fe5b57;
+                        color: white;
+                    }
+                    &.icon-disabled {
+                        cursor: default;
+                        &:hover {
+                            color: #ddd;
+                            background: white;
+                        }
+                    }
+                    &.icon-active {
+                        color: #bbb;
+                        &:hover {
+                            color: white;
+                        }
+                    }
+                }
+            }
+
+            &:hover .archetypeEditorControls {
+                opacity: 1;
+            }
+        }
+
+        &.is-open > .archetypeFieldsetLabel .archetypeEditorControls {
+            opacity: 1;
+        }
+
+        .archetypePropertyError {
+            margin-bottom: 5px;
+            padding-top: 3px;
+            padding-bottom: 3px;
+
+            label {
+
+                span {
+                    color: #b94a48;
+                    font-weight: bold;
+                }
+            }
+        }
+
+        .archetypeCollapser {
+            clear: both;
+            height: 100%;
+            padding: 24px 20px 0 20px;
+            background-color: #fafafa;
+            border-top: 1px dashed #e0e0e0;
+            line-height: 20px;
+
+            .archetypeFieldsetLabel {
+                background: #fafafa;
+            }
+
+            .archetypeEditorControls {
+                background: #fafafa;
+
+                &:before {
+                    background: -webkit-linear-gradient(90deg, rgba(250,250,250,0), #fafafa);
+                    background: -moz-linear-gradient(90deg, rgba(250,250,250,0), #fafafa);
+                    background: linear-gradient(90deg, rgba(250,250,250,0), #fafafa);
+                }
+            }
+
+            form {
+                margin-left:20px;
+
+                .control-label {
+                    padding-top: 0 !important;
+                }
+            }
+
+            .archetypeFieldsetHelpText {
+                clear:both;
+                margin-bottom: 3px;
+                font-size: 12px;
+            }
         }
     }
-}
 
-.archetypeEditor .archetypeCollapser{
-    clear: both;
-    height: 100%;
-    padding-top: 12px;
-    background-color: #fff;
-    border-top: 1px solid silver;
-    border-radius: 0 0 0 5px;
-}
+    .archetypeDeveloperModel
+    {
+        font-family: monospace;
+        width: 98%;
+        min-height: 100px;
+        margin-bottom: 10px;
+        border: 1px solid red;
+    }
 
-.archetypeEditor .multiPropertyTextbox{
-    margin-bottom: 3px;
-}
+    .archetypeFieldsetError {
+        border: 1px solid #b94a48;
+    }
 
-.archetypeEditor ul{
-    list-style: none;
-    margin-left: 0;
-}
+    .archetypeFooter {
+        text-align: center;
+        margin-top: 20px;
+    }
 
-.archetypeEditor,
-.archetypeConfig {
-    .archetypeEditorControls {
-        float: right;
+    .archetypeAddButton {
+        display: inline-block;
+        height: 28px;
+        width: 28px;
+        line-height: 28px;
+        border-radius: 14px;
+        border: 1px solid #b6b6b6;
+        color: #5f5f5f;
+        background: white;
+        font-size: 16px;
+        text-align: center;
+        text-decoration: none;
+        cursor: pointer;
 
-        i {
-            cursor: pointer;
-            &.handle {
-                cursor: move;
+        &:hover {
+            background: #00aea2;
+            border-color: #00aea2;
+            color: white;
+        }
+    }
+
+    .archetypeEmptyContent {
+        text-align: center;
+        margin-bottom: 20px;
+
+        span {
+            display: inline-block;
+            padding: 10px 20px;
+            clear: both;
+            font-size: 14px;
+            color: #555;
+            background: #f8f8f8;
+            border-radius: 15px;
+        }
+    }
+
+    .archetypeCrossDraggable + .archetypeEmptyContent {
+        margin-top: -42px;
+    }
+
+    &.archetypeDragging .archetypeCrossDraggable + .archetypeEmptyContent {
+        display: none;
+    }
+
+    // Necessary to ensure empty lists can be dropped onto when sorting nested fieldsets.
+    .archetypeSortable.archetypeEmpty.archetypeCrossDraggable {
+        min-height: 40px;
+        border: 1px dashed transparent;
+    }
+
+    &.archetypeDragging .archetypeSortable.archetypeEmpty.archetypeCrossDraggable {
+        min-height: 56px;
+        border-color: #dddddd;
+    }
+
+
+    .archetypeCollapser .archetypeEmptyContent span {
+        background: #f2f2f2;
+    }
+
+    .multiPropertyTextbox {
+        margin-bottom: 3px;
+    }
+
+    ul {
+        list-style: none;
+        margin-left: 0;
+    }
+    li {
+        line-height: 20px;
+    }
+
+    .show-validation.ng-invalid .control-group.error .control-label {
+        span {
+            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;
+                    }
+                }
             }
         }
     }
 }
 
-.archetypeEditor .archetypeEditorControls {
-    float: none;
-    position: absolute;
-    right: 15px;
-    top: 0;
-}
-
-.archetypeConfig .archetypeEditorControls {
-    float: right;
-}
-
-.archetypeEditor form {
-    margin-left:20px;
-
-    .control-label {
-        padding-top: 0 !important;
+.archetypeEditor, .archetypeConfig {
+    .archetypeEditorControls {
+        float: right;
     }
-}
-
-.archetypeEditor .archetypeProperty{
-    clear: both;
-    overflow: hidden;
-    margin-top: 3px;
-}
-
-.archetypeEditor .archetypeDeveloperModel
-{
-    font-family: monospace;
-    width: 98%;
-    min-height: 100px;
-    margin-bottom: 10px;
-    border: 1px solid red;
-}
-
-.archetypeEditor .archetypeFieldsetToolbar {
-    margin-bottom: 10px;
-    overflow: hidden;
-
-    li {
-        float: left;
-        padding: 2px 4px;
-        margin-right: 10px;
-        border: 1px solid #ddd;
-        cursor: pointer;
+    
+    .archetypeEditorControls, .archetypeFieldsetGroups {
+        i {
+            cursor: pointer;
+            &.handle {
+                cursor: move;
+            }
+            &.dimmed {
+                color: #d9d9d9;
+            }
+        }
     }
 }
 
-.archetypeEditor .archetypeFieldsetHeaderText{
-    clear:both;
-    margin-bottom: 3px;
-    font-size: 12px;
-}
-
-.archetypeEditor .archetypeFieldsetFooterText{
-    clear:both;
-    margin-bottom: 3px;
-    font-size: 12px;
-}
-
-.archetypeEditor .archetypeFieldsetHelpText{
-    clear:both;
-    margin-bottom: 3px;
-    font-size: 12px;
-}
-
 .archetypeConfig {
     margin-bottom: 20px;
-}
 
-.archetypeConfig ul{
-    list-style: none;
-}
+    .archetype-headline {
 
-.archetypeConfig li{
-    background-color: #fff;
-}
+        img {
+            margin-right: 5px;
+        }
 
-.archetypeConfig label{
-    width: 120px;
-}
+        small {
+            margin-left: 5px;
+        }
 
-.archetypeConfig .archetypeFieldsetWrapper{
-    border: 1px solid #ccc;
-    padding: 10px;
-    margin-bottom: 10px;
-}
+        a {
+            float: right;
 
-.archetypeConfig .archetypeFieldsetOption{
-    margin-bottom: 15px;
-    input[type=text]{
-        max-width: 300px;
+            img {
+                width: 35px;
+            }
+        }
     }
-}
 
-.archetypeConfig .archetypeDeveloperModel {
-    font-family: monospace;
-    width: 88%;
-    margin: 5px 10px 10px;
-    height: 130px;
-}
-
-.archetypeConfig .archetypePropertiesWrapper {
-    border: 1px solid #ddd;
-    padding: 8px;
-    margin: -40px 10px 10px 140px;
-    max-width: 475px;
+    .manual-link {
+        color: blue;
+    }
+    
+    .donate-link {
+        font-weight: 700;
+    }
+    
+    .sponsors {
+        padding-bottom: 10px;
+        margin-bottom: 5px;
+        margin-left: 5px;
+        display: inline-table;
+        float: right;
+        
+        a {
+            float: none;
+        }
+        
+        h4 {
+            border-bottom: 1px solid #ccc;
+        }
+    }
 
     ul {
-        padding: 0;
-        margin: 0;
+        list-style: none;
     }
 
     li {
+        background-color: #fff;
+    }
+
+    label {
+        width: 120px;
+        padding-left: 0;
+    }
+
+    .archetypeEditorControls {
+        float: right;
+    }
+
+    .archetypeFieldsets {
+        margin-left: 0;
+        border-top: 5px solid;
+        padding-top: 5px;
+    }
+
+    .archetypeFieldsetWrapper {
+        border: 1px solid #ccc;
         padding: 10px;
         margin-bottom: 10px;
-        background-color: #eee;
+    }
+
+    .archetypeFieldsetTitle {
+        cursor: pointer;
+        overflow: hidden;
+    }
+
+    .archetypeFieldsetOption {
+        margin-bottom: 15px;
+        margin-right: 15px;
 
         input[type=text] {
-            max-width: 190px;
-            width: auto;
-        }
-
-        select {
-            max-width: 160px;
+            max-width: 100%;
+            width: 100%;
         }
     }
 
-    li:last-child {
-        margin-bottom: 0;
+    .archetypeDeveloperModel {
+        font-family: monospace;
+        width: 88%;
+        margin: 5px 10px 10px;
+        height: 130px;
     }
-}
 
-.archetypeConfig .archetypeFieldsets {
-    margin-left: 0;
-}
+    .archetypeOptions {
+        .btn {
+            margin-bottom: 5px;
+        }
 
-.archetypeConfig .archetypeFieldsetTitle {
-    cursor: pointer;
-    overflow: hidden;
-}
-
-.archetypeConfig .archetypeOptions label{
-    width: 400px;
-}
-
-.archetypeConfig .archetypeAdvancedOptions {
-    margin-top: 15px;
-    div {
-        margin-bottom: 10px;
-    }
-    label {
-        width: 400px;
-    }
-}
-
-.archetypeConfig .archetypeMaxFieldsets{
-    border: 1px solid #ddd;
-    width: 40px;
-    text-align: right;
-}
-
-.archetypeConfig .archetypePropertyTitle {
-    cursor: pointer;
-    overflow: hidden;
-}
-
-.archetypeConfig .archetypePropertyCollapser{
-    margin-top: 10px;
-    div {
-        margin-bottom: 10px;
-    }
-}
-
-.archetypeEditor .archetypeFieldsetError{
-    border: 1px solid #b94a48;
-}
-
-.archetypeEditor .archetypeProperty {
-    label {
-        span {
-            color: #343434;
+        label {
+            width: 400px;
         }
     }
-}
-.archetypeEditor .archetypePropertyError{
-    margin-bottom: 5px;
-    padding-top: 3px;
-    padding-bottom: 3px;
 
-    label {
+    .archetypePropertiesWrapper {
+        border: 1px solid #ddd;
+        padding: 8px;
+        margin: -40px 10px 10px 140px;
 
-        span {
-            color: #b94a48;
-            font-weight: bold;
+        ul {
+            padding: 0;
+            margin: 0;
+        }
+
+        li {
+            padding: 10px;
+            margin-bottom: 10px;
+            background-color: #eee;
+
+            input[type=text] {
+                max-width: 100%;
+                width: 100%;
+            }
+
+            select {
+                max-width: 100%;
+                width: 100%;
+            }
+        }
+
+        li:last-child {
+            margin-bottom: 0;
         }
     }
-}
 
-.archetypeEditor .archetypeAddButton:hover {
-    text-decoration: none;
+    .archetypeAdvancedOptions {
+        label {
+            width: 100%;
+        }
 
-    .archetypeAddButtonText {
-        text-decoration: underline;
+        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 {
+        border: 1px solid #ddd;
+        width: 40px;
+        text-align: right;
+    }
+
+    .archetypePropertyTitle {
+        cursor: pointer;
+        overflow: hidden;
+    }
+
+    .archetypePropertyCollapser {
+        margin-top: 10px;
+
+        div {
+            margin-bottom: 10px;
+            margin-right: 15px;
+        }
+    }
+
+    .archetypeFieldsetCollapser {
+        margin-top: 15px;
+    }
+
+    .fieldsetIcon {
+        margin-right: 10px;
+    }
+
+    small {
+        color: #817f85;
     }
 }
 
@@ -324,16 +717,6 @@
     background-color:   #d0e7f1 !important;
 }
 
-.archetypeConfig .archetypeFieldsetCollapser {
-    margin-top: 15px;
-}
-
-.archetypeConfig .fieldsetIcon {
-    margin-right: 10px;
-}
-
-.archetypeEditor .show-validation.ng-invalid .control-group.error .control-label {
-    span {
-        color: #343434;
-    }
-}
+.archetype-dialog {
+    margin: 10px;
+}

app/resources/archetypePropertyEditorResource.js

@@ -0,0 +1,46 @@
+angular.module('umbraco.resources').factory('archetypePropertyEditorResource', function($q, $http, umbRequestHelper){
+    return { 
+        getAllDataTypes: function() {
+            // Hack - grab DataTypes from Tree API, as `dataTypeService.getAll()` isn't implemented yet
+            return umbRequestHelper.resourcePromise(
+                $http.get("backoffice/ArchetypeApi/ArchetypeDataType/GetAll"), 'Failed to retrieve datatypes from tree service'
+            );
+        },
+        getAllDataTypesForCache: function() {
+            return umbRequestHelper.resourcePromise(
+                $http.get("backoffice/ArchetypeApi/ArchetypeDataType/GetAllDetails"), 'Failed to retrieve datatypes from tree service'
+            );
+        },
+        getDataType: function (guid, useDeepDatatypeLookup, contentTypeAlias, propertyTypeAlias, archetypeAlias, nodeId) {
+            if(useDeepDatatypeLookup) {
+            	return umbRequestHelper.resourcePromise(
+            		$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("backoffice/ArchetypeApi/ArchetypeDataType/GetByGuid?guid=" + guid , { cache: true }), 'Failed to retrieve datatype'
+                );
+            }
+        },
+        getPropertyEditorMapping: function(alias) {
+            return umbRequestHelper.resourcePromise(
+                $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;
+                });
+
+                if (result != null) 
+                    return result;
+
+                return "";
+            });
+        },
+        getDllVersion: function() {
+            return umbRequestHelper.resourcePromise(
+                $http.get("backoffice/ArchetypeApi/ArchetypeDataType/GetDllVersion", { cache: true }), 'Failed to retrieve dll version'
+            );
+        }
+    }
+}); 

app/resources/propertyeditor.js

@@ -1,29 +0,0 @@
-angular.module('umbraco.resources').factory('archetypePropertyEditorResource', function($q, $http, umbRequestHelper){
-    return { 
-        getAllDataTypes: function() {
-            // Hack - grab DataTypes from Tree API, as `dataTypeService.getAll()` isn't implemented yet
-            return umbRequestHelper.resourcePromise(
-                $http.get("/umbraco/backoffice/ArchetypeApi/ArchetypeDataType/GetAll"), 'Failed to retrieve datatypes from tree service'
-            );
-        },
-        getDataType: function(guid) {
-        	return umbRequestHelper.resourcePromise(
-        		$http.get("/umbraco/backoffice/ArchetypeApi/ArchetypeDataType/GetByGuid?guid=" + guid), 'Failed to retrieve datatype'
-    		);
-        },
-        getPropertyEditorMapping: function(alias) {
-            return umbRequestHelper.resourcePromise(
-                $http.get("/umbraco/backoffice/ArchetypeApi/ArchetypeDataType/GetAllPropertyEditors"), 'Failed to retrieve datatype mappings'
-            ).then(function (data) {
-                var result = _.find(data, function(d) {
-                    return d.alias === alias;
-                });
-
-                if (result != null) 
-                    return result;
-
-                return "";
-            });
-        }
-    }
-}); 

app/services/archetypeCacheService.js

@@ -0,0 +1,87 @@
+angular.module('umbraco.services').factory('archetypeCacheService', function (archetypePropertyEditorResource, $q, entityResource) {
+    //private
+    var entityCache = [];
+    var datatypeCache = [];
+    
+    return {
+        initialize: function() {
+            return archetypePropertyEditorResource.getAllDataTypesForCache().then(function(data) {
+                _.each(data, function(datatype) {
+                    datatypeCache[datatype.dataTypeGuid] = datatype;
+                });
+            });
+        },
+        
+        getDataTypeFromCache: function(guid) {
+            return datatypeCache[guid];
+        },
+ 
+        getDatatypeByGuid: function(guid) {
+            var cachedDatatype = this.getDataTypeFromCache(guid);
+            
+            if(cachedDatatype) {
+                return cachedDatatype;
+            }
+
+            return null;
+        },
+
+        getEntityById: function(id, type) {
+            var deferred = $q.defer();
+            
+            //console.log(entityCache);
+                
+            var cachedEntity = entityCache[id];
+
+            if(cachedEntity) {
+                //console.log("Found ID " + id);
+                
+                deferred.resolve(cachedEntity);
+                
+                return deferred.promise;
+            }
+
+            //go get it from server
+            entityResource.getById(id, type).then(function(entity) {
+                entityCache[id] = entity;
+                
+                //console.log("entity ID is now resolved into cache...");
+                //console.log(entityCache);
+                
+                deferred.resolve(entity);
+            });
+
+            return deferred.promise;
+        },
+
+        //perhaps this should return a promise?
+        getEntityByUmbracoId: function(udi, type) {
+            var deferred = $q.defer();
+            
+            var cachedEntity = entityCache[udi];
+
+            if(cachedEntity) {
+                //console.log("Found UDI " + udi);
+                
+                deferred.resolve(cachedEntity);
+                
+                return deferred.promise;
+            }
+
+            //go get it from server
+            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[udi] = entity;
+                
+                //console.log("entity UDI is now resolved into cache...");
+                //console.log(entityCache);
+
+                deferred.resolve(entity);
+            });
+
+            return deferred.promise;
+        }
+    }
+});

app/services/archetypeGlobalConfigService.js

@@ -0,0 +1,19 @@
+angular.module('umbraco.services').factory('archetypeGlobalConfigService', function ($q, $http, umbRequestHelper) {
+    return {
+        globalSettings: function () {
+            return umbRequestHelper.resourcePromise(
+                $http.get("backoffice/ArchetypeApi/ArchetypeDataType/globalSettings"), 'Failed to get whether or not we are checking for updates!'
+            );
+        },
+        setCheckForUpdates: function (isChecking) {
+            return umbRequestHelper.resourcePromise(
+                $http.post("backoffice/ArchetypeApi/ArchetypeDataType/SetCheckForUpdates", isChecking), 'Failed to update check status!'
+            );
+        },
+        checkForUpdates: function () {
+            return umbRequestHelper.resourcePromise(
+                $http.post("backoffice/ArchetypeApi/ArchetypeDataType/checkForUpdates", { }), 'Failed to check for updates!'
+            );
+        }
+    }
+});