Update langs and bump version number

Conflicts:
	app/directives/archetypeproperty.js

Gruntfile.js

@@ -55,8 +55,10 @@ module.exports = function(grunt) {
           'app/controllers/controller.js',
           'app/controllers/config.controller.js',
           'app/directives/archetypeproperty.js',
+          'app/directives/archetypecustomview.js',
           'app/directives/localize.js',
           'app/services/localization.js',
+          'app/helpers/labelhelpers.js',
           'app/resources/propertyeditor.js'
         ],
         dest: '<%= basePath %>/js/archetype.js'
@@ -66,7 +68,7 @@ module.exports = function(grunt) {
     copy: {
       html: {
         cwd: 'app/views/',
-        src: ['archetype.html', 'archetype.config.html'],
+        src: ['archetype.html', 'archetype.default.html', 'archetype.config.html'],
         dest: '<%= basePath %>/views',
         expand: true
       },
@@ -190,6 +192,7 @@ module.exports = function(grunt) {
         stdout: true,
         verbosity: 'quiet',
         maxCpuCount: 4,
+		version: 4.0,
         buildParameters: {
           WarningLevel: 2,
           NoWarn: 1607

README.md

@@ -2,6 +2,8 @@ Archetype
 =========
 ![alt tag](http://imulus.github.io/Archetype/images/logo.png)
 
+![alt tag](http://imulus.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>.
 

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,176 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Archetype.Models;
+using Archetype.PropertyConverters;
+using Newtonsoft.Json;
+using Umbraco.Core;
+using Umbraco.Core.Logging;
+using Umbraco.Core.Models;
+using Umbraco.Core.Models.PublishedContent;
+using Umbraco.Courier.Core;
+using Umbraco.Courier.DataResolvers;
+using Umbraco.Courier.ItemProviders;
+
+namespace Archetype.Courier.DataResolvers
+{
+	public class ArchetypeDataResolver : PropertyDataResolverProvider
+	{
+		private enum Direction
+		{
+			Extracting,
+			Packaging
+		}
+
+		public override string EditorAlias
+		{
+			get
+			{
+				return Archetype.Constants.PropertyEditorAlias;
+			}
+		}
+
+		public override void ExtractingDataType(DataType item)
+		{
+			// No longer need to extract the DataType (int) Ids as they now reference the Guid [LK]
+		}
+
+		public override void ExtractingProperty(Item item, ContentProperty propertyData)
+		{
+			ReplacePropertyDataIds(item, propertyData, Direction.Extracting);
+		}
+
+		public override void PackagingDataType(DataType item)
+		{
+			AddDataTypeDependencies(item);
+		}
+
+		public override void PackagingProperty(Item item, ContentProperty propertyData)
+		{
+			ReplacePropertyDataIds(item, propertyData, Direction.Packaging);
+		}
+
+		private void AddDataTypeDependencies(DataType item)
+		{
+			if (item.Prevalues != null && item.Prevalues.Count > 0)
+			{
+				var prevalue = item.Prevalues[0];
+				if (prevalue.Alias.InvariantEquals(Archetype.Constants.PreValueAlias) && !string.IsNullOrWhiteSpace(prevalue.Value))
+				{
+					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(), ProviderIDCollection.dataTypeItemProviderGuid);
+						}
+
+						item.Prevalues[0].Value = JsonConvert.SerializeObject(config, Formatting.None);
+					}
+				}
+			}
+		}
+
+		private void ReplacePropertyDataIds(Item item, ContentProperty propertyData, Direction direction)
+		{
+			if (propertyData != null && propertyData.Value != null)
+			{
+				// just look at the amount of dancing around we have to do in order to fake a `PublishedPropertyType`?!
+				var dataTypeId = PersistenceManager.Default.GetNodeId(propertyData.DataType, NodeObjectTypes.DataType);
+				var fakePropertyType = this.CreateDummyPropertyType(dataTypeId, this.EditorAlias);
+
+				var converter = new ArchetypeValueConverter();
+				var archetype = (ArchetypeModel)converter.ConvertDataToSource(fakePropertyType, propertyData.Value, false);
+
+				if (archetype != null)
+				{
+					// create a 'fake' provider, as ultimately only the 'Packaging' enum will be referenced.
+					var fakeItemProvider = new PropertyItemProvider();
+
+					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, this.EditorAlias, property.PropertyEditorAlias, property.Alias }),
+							Data = new List<ContentProperty>
+							{
+								new ContentProperty
+								{
+									Alias = property.Alias,
+									DataType = PersistenceManager.Default.GetUniqueId(property.DataTypeId, NodeObjectTypes.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, fakeItemProvider);
+							}
+							catch (Exception ex)
+							{
+								LogHelper.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, fakeItemProvider);
+							}
+							catch (Exception ex)
+							{
+								LogHelper.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(), ProviderIDCollection.dataTypeItemProviderGuid);
+							}
+						}
+					}
+
+					if (item.Name.Contains(string.Concat(this.EditorAlias, ": Nested")))
+					{
+						// if the Archetype is nested, then we only want to return the object itself - not a serialized string
+						propertyData.Value = archetype;
+					}
+					else
+					{
+						// if the Archetype is the root/container, then we can serialize it to a string
+						propertyData.Value = archetype.SerializeForPersistence();
+					}
+				}
+			}
+		}
+
+		private PublishedPropertyType CreateDummyPropertyType(int dataTypeId, string propertyEditorAlias)
+		{
+			return new PublishedPropertyType(null, new PropertyType(new DataTypeDefinition(-1, propertyEditorAlias) { Id = dataTypeId }));
+		}
+	}
+}

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

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

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

@@ -234,8 +234,17 @@
       <Name>Archetype.Umbraco</Name>
     </ProjectReference>
   </ItemGroup>
+  <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

@@ -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/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/Umbraco.Archetype.sln

@@ -14,6 +14,8 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Archetype.Tests", "Archetyp
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "DatabaseSizer", "DatabaseSizer\DatabaseSizer.csproj", "{0114C963-C514-49C1-B7AB-DCB1825F498C}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Archetype.Courier", "Archetype.Courier\Archetype.Courier.csproj", "{FE8BE437-8B11-4E49-9B02-F45994E6D723}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -32,6 +34,10 @@ Global
 		{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

@@ -38,5 +38,16 @@ namespace Archetype.Api
             var dataTypeDisplay = Mapper.Map<IDataTypeDefinition, DataTypeDisplay>(dataType);
             return new { selectedEditor = dataTypeDisplay.SelectedEditor, preValues = dataTypeDisplay.PreValues };
         }
+
+        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 };
+        }
     }
 }

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

@@ -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,16 @@
     </Reference>
     <Reference Include="SQLCE4Umbraco">
       <HintPath>..\packages\UmbracoCms.Core.7.1.2\lib\SQLCE4Umbraco.dll</HintPath>
+      <Private>False</Private>
     </Reference>
     <Reference Include="System" />
     <Reference Include="System.Core" />
     <Reference Include="System.Data.SqlServerCe, Version=4.0.0.0, Culture=neutral, PublicKeyToken=89845dcd8080cc91, processorArchitecture=MSIL">
-      <Private>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,36 +184,47 @@
     <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>
@@ -210,7 +232,9 @@
     <Compile Include="Constants.cs" />
     <Compile Include="Events\ExpireCache.cs" />
     <Compile Include="Extensions\ArchetypeHelper.cs" />
-    <Compile Include="Extensions\Extensions.cs" />
+    <Compile Include="Extensions\HtmlHelperExtensions.cs" />
+    <Compile Include="Extensions\ArchetypePropertyModelExtensions.cs" />
+    <Compile Include="Extensions\StringExtensions.cs" />
     <Compile Include="Models\ArchetypeModel.cs" />
     <Compile Include="Models\ArchetypePreValue.cs" />
     <Compile Include="Models\ArchetypePreValueFieldset.cs" />

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

@@ -4,14 +4,18 @@ using Archetype.Models;
 using Newtonsoft.Json;
 using Umbraco.Core;
 using Umbraco.Core.Models;
+using Umbraco.Core.Models.PublishedContent;
 
 namespace Archetype.Extensions
 {
     public class ArchetypeHelper
     {
-
         protected JsonSerializerSettings _jsonSettings;
-        protected ApplicationContext _app; 
+        protected ApplicationContext _app;
+
+        private static readonly ArchetypeHelper _instance = new ArchetypeHelper();
+
+        internal static ArchetypeHelper Instance { get { return _instance; } }
 
         internal ArchetypeHelper()
         {
@@ -22,11 +26,11 @@ namespace Archetype.Extensions
             _app = ApplicationContext.Current;
         }
 
-        internal Models.ArchetypeModel DeserializeJsonToArchetype(string sourceJson, PreValueCollection dataTypePreValues)
+        internal ArchetypeModel DeserializeJsonToArchetype(string sourceJson, PreValueCollection dataTypePreValues)
         {
             try
             {
-                var archetype = JsonConvert.DeserializeObject<Models.ArchetypeModel>(sourceJson, _jsonSettings);
+                var archetype = JsonConvert.DeserializeObject<ArchetypeModel>(sourceJson, _jsonSettings);
 
                 try
                 {
@@ -42,21 +46,21 @@ namespace Archetype.Extensions
             }
             catch
             {
-                return new Models.ArchetypeModel();
-            }         
+                return new ArchetypeModel();
+            }
         }
 
-        internal Models.ArchetypeModel DeserializeJsonToArchetype(string sourceJson, int dataTypeId)
+        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
                 {
                     // Get list of configured properties and their types and map them to the deserialized archetype model
                     var preValue = GetArchetypePreValueFromDataTypeId(dataTypeId);
-                    RetrieveAdditionalProperties(ref archetype, preValue);
+                    RetrieveAdditionalProperties(ref archetype, preValue, hostContentType);
                 }
                 catch (Exception ex)
                 {
@@ -66,12 +70,12 @@ namespace Archetype.Extensions
             }
             catch
             {
-                return new Models.ArchetypeModel();
+                return new ArchetypeModel();
             }
         }
 
-         private ArchetypePreValue GetArchetypePreValueFromDataTypeId(int dataTypeId)
-         {
+        private ArchetypePreValue GetArchetypePreValueFromDataTypeId(int dataTypeId)
+        {
             return _app.ApplicationCache.RuntimeCache.GetCacheItem(
                 Constants.CacheKey_PreValueFromDataTypeId + dataTypeId,
                 () =>
@@ -88,7 +92,7 @@ namespace Archetype.Extensions
                     return config;
 
                 }) as ArchetypePreValue;
-        }  
+        }
 
         private ArchetypePreValue GetArchetypePreValueFromPreValuesCollection(PreValueCollection dataTypePreValues)
         {
@@ -97,10 +101,9 @@ namespace Archetype.Extensions
             return preValue;
         }
 
-
         private 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));
         }
@@ -110,7 +113,7 @@ 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)
+        private void RetrieveAdditionalProperties(ref ArchetypeModel archetype, ArchetypePreValue preValue, PublishedContentType hostContentType = null)
         {
             foreach (var fieldset in preValue.Fieldsets)
             {
@@ -120,11 +123,12 @@ 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;
                             propertyInst.PropertyEditorAlias = property.PropertyEditorAlias;
+                            propertyInst.HostContentType = hostContentType;
                         }
                     }
                 }
@@ -136,7 +140,7 @@ 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.ArchetypePreValue preValue)
+        private void RetrieveAdditionalProperties(ref ArchetypePreValue preValue)
         {
             foreach (var fieldset in preValue.Fieldsets)
             {
@@ -146,6 +150,5 @@ namespace Archetype.Extensions
                 }
             }
         }
-
     }
-}
+}

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

@@ -0,0 +1,20 @@
+using Archetype.Models;
+using Umbraco.Core;
+using Umbraco.Core.Models;
+using Umbraco.Core.Models.PublishedContent;
+
+namespace Archetype.Extensions
+{
+    public static class ArchetypePropertyModelExtensions
+    {
+        public static bool IsArchetype(this ArchetypePropertyModel prop)
+        {
+            return prop.PropertyEditorAlias.InvariantEquals(Constants.PropertyEditorAlias);
+        }
+
+        internal static PublishedPropertyType CreateDummyPropertyType(this ArchetypePropertyModel prop)
+        {
+            return new PublishedPropertyType(prop.HostContentType, new PropertyType(new DataTypeDefinition(-1, prop.PropertyEditorAlias) { Id = prop.DataTypeId }));
+        }
+    }
+}

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

@@ -1,27 +0,0 @@
-using System;
-using System.Web;
-using System.Text;
-using System.Text.RegularExpressions;
-using System.Collections.Generic;
-using Umbraco.Core;
-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);
-        }
-    }
-}

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

@@ -0,0 +1,66 @@
+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
+{
+    public static class HtmlHelperExtensions
+    {
+        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 htmlHelper.RenderPartials(archetypeModel, partialPath, viewDataDictionary);
+        }
+
+        private static IHtmlString RenderPartials(this 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/StringExtensions.cs

@@ -0,0 +1,13 @@
+namespace Archetype.Extensions
+{
+    public static class StringExtensions
+    {
+        //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("]");
+        }
+    }
+}

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

@@ -10,6 +10,9 @@ namespace Archetype.Models
         [JsonProperty("alias")]
         public string Alias { get; set; }
 
+        [JsonProperty("disabled")]
+        public bool Disabled { get; set; }
+
         [JsonProperty("properties")]
         public IEnumerable<ArchetypePropertyModel> Properties;
 
@@ -29,12 +32,36 @@ namespace Archetype.Models
         {
             var property = GetProperty(propertyAlias);
 
-            if (property == 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.
+        public T GetValue<T>(string propertyAlias, T defaultValue)
+        {
+            var property = GetProperty(propertyAlias);
+
+            if (IsEmptyProperty(property)) 
+            {
+                return defaultValue;
+            }
+
+            return property.GetValue<T>();
+        }
+
+        private bool IsEmptyProperty(ArchetypePropertyModel property) 
+        {
+            return (property == null || property.Value == null || string.IsNullOrEmpty(property.Value.ToString()));
+        }
+
         public bool HasProperty(string propertyAlias)
         {
             return GetProperty(propertyAlias) != null;
@@ -43,7 +70,7 @@ namespace Archetype.Models
         public bool HasValue(string propertyAlias)
         {
             var property = GetProperty(propertyAlias);
-            if (property == null)
+            if (property == null || property.Value == null)
                 return false;
 
             return !string.IsNullOrEmpty(property.Value.ToString());
@@ -57,4 +84,4 @@ namespace Archetype.Models
         #endregion
 
     }
-}
+}

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

@@ -1,7 +1,7 @@
 using System;
 using System.Collections;
 using System.Collections.Generic;
-using System.Linq;
+using System.Linq;
 using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
 
@@ -20,7 +20,7 @@ namespace Archetype.Models
 
         public IEnumerator<ArchetypeFieldsetModel> GetEnumerator()
         {
-            return this.Fieldsets.GetEnumerator();
+            return this.Fieldsets.Where(f => f.Disabled == false).GetEnumerator();
         }
 
         IEnumerator IEnumerable.GetEnumerator()
@@ -31,14 +31,14 @@ namespace Archetype.Models
         internal string SerializeForPersistence()
         {
             var json = JObject.Parse(JsonConvert.SerializeObject(this));
-            var propertiesToRemove = new String[] { "propertyEditorAlias", "dataTypeId", "dataTypeGuid" };
+            var propertiesToRemove = new String[] { "propertyEditorAlias", "dataTypeId", "dataTypeGuid", "hostContentType" };
 
             json.Descendants().OfType<JProperty>()
               .Where(p => propertiesToRemove.Contains(p.Name))
               .ToList()
               .ForEach(x => x.Remove());
 
-            return json.ToString(Formatting.None);
+            return json.ToString(Formatting.None);//.DelintArchetypeJson();
         }
     }
 }

app/Umbraco/Umbraco.Archetype/Models/ArchetypePreValue.cs

@@ -20,6 +20,9 @@ namespace Archetype.Models
         [JsonProperty("enableCollapsing")]
         public bool EnableCollapsing { get; set; }
 
+        [JsonProperty("enableDisabling")]
+        public bool EnableDisabling { get; set; }
+
         [JsonProperty("hideFieldsetControls")]
         public bool HideFieldsetControls { get; set; }
 
@@ -44,6 +47,12 @@ 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; }
     }

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

@@ -33,6 +33,6 @@ namespace Archetype.Models
         public bool Required { get; set; }
 
         [JsonProperty("regEx")]
-        public bool RegEx { get; set; }
+        public string RegEx { get; set; }
     }
 }

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

@@ -1,15 +1,16 @@
 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 {
+    public class ArchetypePropertyModel
+    {
         [JsonProperty("alias")]
         public string Alias { get; internal set; }
 
@@ -25,6 +26,9 @@ namespace Archetype.Models
         [JsonProperty("dataTypeGuid")]
         internal string DataTypeGuid { get; set; }
 
+        [JsonProperty("hostContentType")]
+        internal PublishedContentType HostContentType { get; set; }
+
         public T GetValue<T>()
         {
 
@@ -51,7 +55,7 @@ namespace Archetype.Models
 
         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
@@ -69,6 +73,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)
@@ -77,14 +88,5 @@ namespace Archetype.Models
 
             return Attempt<T>.Fail();
         }
-
-        private PublishedPropertyType CreateDummyPropertyType(int dataTypeId, string propertyEditorAlias)
-        {
-            return new PublishedPropertyType(null,
-                new PropertyType(new DataTypeDefinition(-1, propertyEditorAlias)
-                {
-                    Id = dataTypeId
-                }));
-        }
     }
 }

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

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

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

@@ -1,16 +1,12 @@
 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
 {
     [PropertyValueType(typeof(Models.ArchetypeModel))]
     [PropertyValueCache(PropertyCacheValue.All, PropertyCacheLevel.Content)]
@@ -24,12 +20,13 @@ namespace Archetype.PropertyConverters
 
         public override bool IsConverter(PublishedPropertyType propertyType)
         {
-            return propertyType.PropertyEditorAlias.Equals(Constants.PropertyEditorAlias);
+            return !String.IsNullOrEmpty(propertyType.PropertyEditorAlias) 
+                && propertyType.PropertyEditorAlias.Equals(Constants.PropertyEditorAlias);
         }
 
         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,10 +36,14 @@ namespace Archetype.PropertyConverters
             if (!sourceString.DetectIsJson())
                 return defaultValue;
 
-            var archetype = new ArchetypeHelper().DeserializeJsonToArchetype(source.ToString(),
-                (propertyType != null ? propertyType.DataTypeId : -1));
+			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,23 +1,20 @@
 using System;
 using System.Collections.Generic;
-using System.Linq;
 using Archetype.Extensions;
 using ClientDependency.Core;
 using Newtonsoft.Json;
-using Newtonsoft.Json.Linq;
 using Umbraco.Core;
+using Umbraco.Core.Logging;
 using Umbraco.Core.Models;
 using Umbraco.Core.Models.Editors;
 using Umbraco.Core.PropertyEditors;
 using Umbraco.Core.Services;
 using Umbraco.Web.PropertyEditors;
-using Umbraco.Core.Logging;
 
 namespace Archetype.PropertyEditors
 {
 	[PropertyEditorAsset(ClientDependencyType.Javascript, "/App_Plugins/Archetype/js/archetype.js")]
-	[PropertyEditor("Imulus.Archetype", "Archetype", "/App_Plugins/Archetype/views/archetype.html",
-		ValueType = "JSON")]
+	[PropertyEditor("Imulus.Archetype", "Archetype", "/App_Plugins/Archetype/views/archetype.html", ValueType = "JSON")]
 	public class ArchetypePropertyEditor : PropertyEditor
 	{
 		#region Pre Value Editor
@@ -57,9 +54,11 @@ namespace Archetype.PropertyEditors
 			public override string ConvertDbToString(Property property, PropertyType propertyType, IDataTypeService dataTypeService)
 			{
 				if (property.Value == null || property.Value.ToString() == "")
-					return string.Empty;
+					return string.Empty;
+
+                //LogHelper.Info<ArchetypeHelper>(property.Value.ToString());
 
-			    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)
 				{
@@ -86,9 +85,11 @@ namespace Archetype.PropertyEditors
 			public override object ConvertDbToEditor(Property property, PropertyType propertyType, IDataTypeService dataTypeService)
 			{
 				if (property.Value == null || property.Value.ToString() == "")
-					return string.Empty;
+					return string.Empty;
+
+                //LogHelper.Info<ArchetypeHelper>(property.Value.ToString());
 
-			    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)
 				{
@@ -114,9 +115,11 @@ namespace Archetype.PropertyEditors
             public override object ConvertEditorToDb(ContentPropertyData editorValue, object currentValue)
 			{
 				if (editorValue.Value == null || editorValue.Value.ToString() == "")
-					return string.Empty;
+					return string.Empty;
+
+                //LogHelper.Info<ArchetypeHelper>(editorValue.Value.ToString());
 
-				var archetype = new ArchetypeHelper().DeserializeJsonToArchetype(editorValue.Value.ToString(), editorValue.PreValues);
+				var archetype = ArchetypeHelper.Instance.DeserializeJsonToArchetype(editorValue.Value.ToString(), editorValue.PreValues);
 
 				foreach (var fieldset in archetype.Fieldsets)
 				{
@@ -126,8 +129,8 @@ namespace Archetype.PropertyEditors
                         {
 						    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);
+						    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)
@@ -138,7 +141,17 @@ namespace Archetype.PropertyEditors
 				}
 
                 return archetype.SerializeForPersistence();
-			}
+			}
+
+		    internal virtual PropertyEditor GetPropertyEditor(IDataTypeDefinition dtd)
+		    {
+		        if (dtd.Id != 0) 
+                    return PropertyEditorResolver.Current.GetByAlias(dtd.PropertyEditorAlias);
+
+		        return dtd.PropertyEditorAlias.Equals(Constants.PropertyEditorAlias)
+		            ? new ArchetypePropertyEditor()
+                    : (PropertyEditor)new TextboxPropertyEditor();
+		    }
 		}
 
 		#endregion	

app/controllers/config.controller.js

@@ -6,7 +6,7 @@ angular.module("umbraco").controller("Imulus.ArchetypeConfigController", functio
     //define empty items
     var newPropertyModel = '{"alias": "", "remove": false, "collapse": false, "label": "", "helpText": "", "dataTypeGuid": "0cc0eba1-9960-42c9-bf9b-60e150b429ae", "value": ""}';
     var newFieldsetModel = '{"alias": "", "remove": false, "collapse": false, "labelTemplate": "", "icon": "", "label": "", "properties": [' + newPropertyModel + ']}';
-    var defaultFieldsetConfigModel = JSON.parse('{"showAdvancedOptions": false, "startWithAddButton": false, "hideFieldsetToolbar": false, "enableMultipleFieldsets": false, "hideFieldsetControls": false, "hidePropertyLabel": false, "maxFieldsets": null, "enableCollapsing": true, "fieldsets": [' + newFieldsetModel + ']}');
+    var defaultFieldsetConfigModel = JSON.parse('{"showAdvancedOptions": false, "startWithAddButton": false, "hideFieldsetToolbar": false, "enableMultipleFieldsets": false, "hideFieldsetControls": false, "hidePropertyLabel": false, "maxFieldsets": null, "enableCollapsing": true, "enableDisabling": true, "enableDeepDatatypeRequests": true, "fieldsets": [' + newFieldsetModel + ']}');
 
     //ini the model
     $scope.model.value = $scope.model.value || defaultFieldsetConfigModel;

app/controllers/controller.js

@@ -1,4 +1,4 @@
-angular.module("umbraco").controller("Imulus.ArchetypeController", function ($scope, $http, assetsService, angularHelper, notificationsService, $timeout) {
+angular.module("umbraco").controller("Imulus.ArchetypeController", function ($scope, $http, assetsService, angularHelper, notificationsService, $timeout, entityResource) {
 
     //$scope.model.value = "";
     $scope.model.hideLabel = $scope.model.config.hideLabel == 1;
@@ -11,8 +11,17 @@
 
     //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;
+
     init();
 
+    //hold references to helper resources
+    $scope.resources = {
+        entityResource: entityResource
+    }
+
     //helper to get $eval the labelTemplate
     $scope.getFieldsetTitle = function(fieldsetConfigModel, fieldsetIndex) {
         if(!fieldsetConfigModel)
@@ -29,14 +38,44 @@
         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);
+            var propertyAlias = "";
+
+            //test for function
+            var beginIndexOf = results[1].indexOf("(");
+            var endIndexOf = results[1].indexOf(")");
+
+            if(beginIndexOf != -1 && endIndexOf != -1)
+            {
+                var functionName = results[1].substring(0, beginIndexOf);
+                propertyAlias = results[1].substring(beginIndexOf + 1, endIndexOf);
+                parsedTemplate = parsedTemplate.replace(results[0], executeFunctionByName(functionName, window, $scope, $scope.getPropertyValueByAlias(fieldset, propertyAlias)));
+            }
+            else {
+                propertyAlias = results[1];
+                parsedTemplate = parsedTemplate.replace(results[0], $scope.getPropertyValueByAlias(fieldset, propertyAlias));
+            }
         }
 
         return parsedTemplate;
     };
 
+    function executeFunctionByName(functionName, context) {
+        var args = Array.prototype.slice.call(arguments).splice(2);
+
+        var namespaces = functionName.split(".");
+        var func = namespaces.pop();
+
+        for(var i = 0; i < namespaces.length; i++) {
+            context = context[namespaces[i]];
+        }
+
+        if(context && context[func]) {
+            return context[func].apply(this, args);
+        }
+
+        return "";
+    }
+
     //sort config
     $scope.sortableOptions = {
         axis: 'y',
@@ -83,6 +122,12 @@
         }
     }
 
+    $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();
+    }
+
     //helpers for determining if a user can do something
     $scope.canAdd = function ()
     {
@@ -108,6 +153,11 @@
         return countVisible() > 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 () {
         return $scope.model.config.startWithAddButton
@@ -263,6 +313,27 @@
         return (typeof property == 'undefined') ? true : property.isValid;
     }
 
+    //helper to lookup validity when given a fieldset
+    $scope.getFieldsetValidity = function (fieldset) {
+        if (fieldset.isValid == false) {
+            return false;
+        }
+
+        // recursive validation of nested fieldsets
+        var nestedFieldsetsValid = true;
+        _.each(fieldset.properties, function (property) {
+            if (property != null && property.value != null && property.propertyEditorAlias == "Imulus.Archetype") {
+                _.each(property.value.fieldsets, function (inner) {
+                    if ($scope.getFieldsetValidity(inner) == false) {
+                        nestedFieldsetsValid = false;
+                    }
+                });
+            }
+        });
+
+        return nestedFieldsetsValid;
+    }
+
     // helper to force the current form into the dirty state
     $scope.setDirty = function () {
         if($scope.form) {

app/directives/archetypecustomview.js

@@ -0,0 +1,22 @@
+angular.module("umbraco.directives").directive('archetypeCustomView', function ($compile, $http) {
+    var linker = function (scope, element, attrs) {
+
+        var view = "/App_plugins/Archetype/views/archetype.default.html";
+        if(scope.model.config.customViewPath) {
+            view = config.customViewPath;
+        }
+
+        $http.get(view, { cache: true }).then(function(data) {
+
+            element.html(data.data).show();
+
+            $compile(element.contents())(scope);
+        });
+    }
+
+    return {
+        restrict: "A",
+        replace: true,
+        link: linker
+    }
+});

app/directives/archetypeproperty.js

@@ -1,5 +1,5 @@
-angular.module("umbraco.directives").directive('archetypeProperty', function ($compile, $http, archetypePropertyEditorResource, umbPropEditorHelper, $timeout, $rootScope, $q) {
-    
+angular.module("umbraco.directives").directive('archetypeProperty', function ($compile, $http, archetypePropertyEditorResource, umbPropEditorHelper, $timeout, $rootScope, $q, editorState) {
+
     function getFieldsetByAlias(fieldsets, alias)
     {
         return _.find(fieldsets, function(fieldset){
@@ -55,13 +55,14 @@ angular.module("umbraco.directives").directive('archetypeProperty', function ($c
         var config = null;
         var alias = configFieldsetModel.properties[scope.propertyConfigIndex].alias;
         var defaultValue = configFieldsetModel.properties[scope.propertyConfigIndex].value;
-        var umbracoPropertyAlias = scope.umbracoPropertyAlias;
+        var propertyAlias = getUniquePropertyAlias(scope);
+        propertyAliasParts = [];
 
         //try to convert the defaultValue to a JS object
         defaultValue = 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) {
@@ -81,51 +82,86 @@ angular.module("umbraco.directives").directive('archetypeProperty', function ($c
 
                 var mergedConfig = _.extend(defaultConfigObj, config);
 
-                loadView(pathToView, mergedConfig, defaultValue, alias, umbracoPropertyAlias, scope, element, ngModelCtrl);
+                loadView(pathToView, mergedConfig, defaultValue, alias, propertyAlias, scope, element, ngModelCtrl, propertyValueChanged);
             });
         });
 
-        ngModelCtrl.$parsers.push(validate);
-        ngModelCtrl.$formatters.push(validate);
-
-        function validate(renderModel){
-            var valid = true;
-
-            _.each(renderModel, function(fieldset){
-                fieldset.isValid = true;
-                _.each(fieldset.properties, function(property){
-                    property.isValid = true;
-
-                    var propertyConfig = getPropertyByAlias(configFieldsetModel, property.alias);
-                    if (propertyConfig) {
-                        if(propertyConfig.required && (property.value == null || property.value === "")) {
-                            fieldset.isValid = false;
-                            property.isValid = false;
-                            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) {
-                                fieldset.isValid = false;
-                                property.isValid = false;
-                                valid = false;
-                            }
-                        }
-                    }
-                });
+        scope.$on("formSubmitting", function (ev, args) {
+            // validate all fieldset properties
+            _.each(scope.fieldset.properties, function (property) {
+                validateProperty(scope.fieldset, property);
             });
 
-            ngModelCtrl.$setValidity('validation', valid);
-            return renderModel;
+            // set invalid state if the fieldset contains invalid properties
+            // we need an unique validation key per fieldset in this ngModelCtrl scope, which leaves us with a potential problem: 
+            // if the user invalidates the last fieldset, attempts (and fails) to save and and subsequently deletes the invalid fieldset, 
+            // the validation key will persist on ngModelCtrl and thus the form will not submit.
+            // to fix this problem, the controller probably needs to raise an event (in removeRow) that can be intercepted here to
+            // clear the validation key.
+            var validationKey = "validation-f" + scope.fieldsetIndex;
+            ngModelCtrl.$setValidity(validationKey, scope.fieldset.isValid);
+        });
+
+        // called when the value of any property in a fieldset changes
+        function propertyValueChanged(fieldset, property) {
+            // it's the Umbraco way to hide the invalid state when altering an invalid property, even if the new value isn't valid either
+            property.isValid = true;
+            setFieldsetValidity(fieldset);
+        }
+
+        // validate a property in a fieldset
+        function validateProperty(fieldset, property) {
+            var propertyConfig = getPropertyByAlias(configFieldsetModel, property.alias);
+            if (propertyConfig) {
+                // use property.value !== property.value to check for NaN values on numeric inputs
+                if (propertyConfig.required && (property.value == null || property.value === "" || property.value !== property.value)) {
+                    property.isValid = false;
+                }
+                // issue 116: RegEx validate property value
+                // Only validate the property value if anything has been entered - RegEx is considered a supplement to "required".
+                if (property.isValid == true && propertyConfig.regEx && property.value) {
+                    var regEx = new RegExp(propertyConfig.regEx);
+                    if (regEx.test(property.value) == false) {
+                        property.isValid = false;
+                    }
+                }
+            }
+
+            setFieldsetValidity(fieldset);
+        }
+
+        function setFieldsetValidity(fieldset) {
+            // mark the entire fieldset as invalid if there are any invalid properties in the fieldset, otherwise mark it as valid
+            fieldset.isValid =
+                _.find(fieldset.properties, function (property) {
+                    return property.isValid == false
+                }) == null;
         }
     }
 
-    function loadView(view, config, defaultValue, alias, umbracoPropertyAlias, scope, element, ngModelCtrl) {
+    var propertyAliasParts = [];
+    var getUniquePropertyAlias = function (currentScope) {
+        if (currentScope.hasOwnProperty('fieldsetIndex') && currentScope.hasOwnProperty('property') && currentScope.hasOwnProperty('propertyConfigIndex'))
+        {
+            var currentPropertyAlias = "f" + currentScope.fieldsetIndex + "-" + currentScope.property.alias + "-p" + currentScope.propertyConfigIndex;
+            propertyAliasParts.push(currentPropertyAlias);
+        }
+        else if (currentScope.hasOwnProperty('isPreValue')) // Crappy way to identify this is the umbraco property scope
+        {
+            var umbracoPropertyAlias = currentScope.$parent.$parent.property.alias; // Crappy way to get the umbraco host alias once we identify its scope
+            propertyAliasParts.push(umbracoPropertyAlias);
+        }
+
+        if (currentScope.$parent)
+            getUniquePropertyAlias(currentScope.$parent);
+
+        return _.unique(propertyAliasParts).reverse().join("-");
+    };
+
+    function loadView(view, config, defaultValue, alias, propertyAlias, scope, element, ngModelCtrl, propertyValueChanged) {
         if (view)
         {
-            $http.get(view).success(function (data) {
+            $http.get(view, { cache: true }).success(function (data) {
                 if (data) {
                     if (scope.archetypeConfig.developerMode == '1')
                     {
@@ -150,18 +186,32 @@ angular.module("umbraco.directives").directive('archetypeProperty', function ($c
                     //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";
+                        }
+                    }
+
+                    //console.log(scope.model.config);
+
                     //some items need an alias
-                    scope.model.alias = "archetype-property-" + umbracoPropertyAlias + "-" + scope.fieldsetIndex + "-" + scope.propertyConfigIndex;
+                    scope.model.alias = "archetype-property-" + propertyAlias;
 
                     //watch for changes since there is no two-way binding with the local model.value
                     scope.$watch('model.value', function (newValue, oldValue) {
                         scope.archetypeRenderModel.fieldsets[scope.fieldsetIndex].properties[renderModelPropertyIndex].value = newValue;
 
-                        // don't set the current value twice - this will keep Umbraco from prompting to discard changes immediately after saving
-                        if (newValue != oldValue) {
-                            //trigger the validation pipeline
-                            ngModelCtrl.$setViewValue(ngModelCtrl.$viewValue);
-                        }
+                        // notify the linker that the property value changed
+                        propertyValueChanged(scope.archetypeRenderModel.fieldsets[scope.fieldsetIndex], scope.archetypeRenderModel.fieldsets[scope.fieldsetIndex].properties[renderModelPropertyIndex]);
                     });
 
                     element.html(data).show();
@@ -171,7 +221,7 @@ angular.module("umbraco.directives").directive('archetypeProperty', function ($c
                         var def = $q.defer();
                         def.resolve(true);
                         $rootScope.$apply();
-                    }, 500)
+                    }, 500);
                 }
             });
         }
@@ -180,11 +230,12 @@ angular.module("umbraco.directives").directive('archetypeProperty', function ($c
     return {
         require: "^ngModel",
         restrict: "E",
-        rep1ace: true,
+        replace: true,
         link: linker,
         scope: {
             property: '=',
             propertyConfigIndex: '=',
+            propertyEditorAlias: '=',
             archetypeConfig: '=',
             fieldset: '=',
             fieldsetIndex: '=',
@@ -193,4 +244,4 @@ angular.module("umbraco.directives").directive('archetypeProperty', function ($c
             umbracoForm: '='
         }
     }
-});
+});

app/directives/localize.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/helpers/labelhelpers.js

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

app/langs/da-dk.js

@@ -31,5 +31,9 @@
 	"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."
 }

app/langs/de-de.js

@@ -31,5 +31,9 @@
 	"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."
 }

app/langs/en-gb.js

@@ -31,5 +31,9 @@
 	"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."
 }

app/langs/en-us.js

@@ -31,5 +31,9 @@
 	"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."
 }

app/langs/es-es.js

@@ -31,5 +31,9 @@
 	"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."
 }

app/langs/fr-fr.js

@@ -31,5 +31,9 @@
 	"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."
 }

app/langs/he-il.js

@@ -31,5 +31,9 @@
 	"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."
 }

app/langs/it-it.js

@@ -31,5 +31,9 @@
 	"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."
 }

app/langs/ja-jp.js

@@ -31,5 +31,9 @@
 	"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."
 }

app/langs/ko-kr.js

@@ -31,5 +31,9 @@
 	"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."
 }

app/langs/nb-no.js

@@ -31,5 +31,9 @@
 	"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."
 }

app/langs/nl-nl.js

@@ -31,5 +31,9 @@
 	"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."
 }

app/langs/pl-pl.js

@@ -31,5 +31,9 @@
 	"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."
 }

app/langs/pt-br.js

@@ -31,5 +31,9 @@
 	"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."
 }

app/langs/ru-ru.js

@@ -31,5 +31,9 @@
 	"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."
 }

app/langs/sv-se.js

@@ -31,5 +31,9 @@
 	"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."
 }

app/langs/zh-cn.js

@@ -31,5 +31,9 @@
 	"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."
 }

app/less/archetype.less

@@ -1,9 +1,23 @@
-.archetypeEditor {
+/* TODO: clean this up */
+
+.archetypeEditor {
     width: 98%;
 
     .dropdown-menu {
         top: auto;
     }
+
+    .controls-no-label {
+        padding: 10px;
+    }
+
+    a+ul.dropdown-menu {
+        margin-left: 25px;
+    }
+
+    .icon {
+        color: #333;
+    }
 }
 
 .archetypeEditor fieldset{
@@ -18,7 +32,7 @@
 
 .archetypeEditor .archetypeFieldsetLabel {
     position: relative;
-    width: 100%%;
+    width: 100%;
 
     .label-sub {
         padding: 8px 0;
@@ -29,11 +43,12 @@
     }
 
     .dropdown-menu {
+        position: relative;
         padding: 0;
         border-radius: 0;
         box-shadow: none;
         margin-top: -10px;
-        margin-left: -200px;
+        /*margin-left: -200px;*/
     }
 
     span {
@@ -78,6 +93,9 @@
         span {
             display: inline-block;
         }
+        &.dimmed {
+            color: #d9d9d9;
+        }
     }
 }
 
@@ -88,6 +106,7 @@
     background-color: #fff;
     border-top: 1px solid silver;
     border-radius: 0 0 0 5px;
+    overflow: hidden;
 }
 
 .archetypeEditor .multiPropertyTextbox{
@@ -109,6 +128,9 @@
             &.handle {
                 cursor: move;
             }
+            &.dimmed {
+                color: #d9d9d9;
+            }
         }
     }
 }
@@ -134,7 +156,7 @@
 
 .archetypeEditor .archetypeProperty{
     clear: both;
-    overflow: hidden;
+    overflow: visible;
     margin-top: 3px;
 }
 
@@ -295,6 +317,10 @@
         span {
             color: #343434;
         }
+        &.dimmed span {
+            color: #d9d9d9;
+        }
+
     }
 }
 .archetypeEditor .archetypePropertyError{

app/resources/propertyeditor.js

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

app/services/localization.js

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

app/views/archetype.config.html

@@ -106,9 +106,13 @@
             <input type="checkbox" id="archetypeAdvancedOptionsMultipleFieldsets" ng-model="archetypeConfigRenderModel.enableMultipleFieldsets"/>
         </div>
         <div>
-            <label for="archetypeAdvancedOptionsCollapsing"><archetype-localize key="enableCollapsing">Enable Collapsing?</archetype-localize><small><archetype-localize key="enableCollapsingDescription">Allows multiple types of fieldsets within this archetype.</archetype-localize></small></label>
+            <label for="archetypeAdvancedOptionsCollapsing"><archetype-localize key="enableCollapsing">Enable Collapsing?</archetype-localize><small><archetype-localize key="enableCollapsingDescription">Enable fieldset collapsing.</archetype-localize></small></label>
             <input type="checkbox" id="archetypeAdvancedOptionsCollapsing" ng-model="archetypeConfigRenderModel.enableCollapsing"/>
         </div>
+        <div>
+            <label for="archetypeAdvancedOptionsDisabling"><archetype-localize key="enableDisabling">Enable Fieldset Disabling?</archetype-localize><small><archetype-localize key="enableDisablingDescription">Allows fieldsets to be individually enabled/disabled.</archetype-localize></small></label>
+            <input type="checkbox" id="archetypeAdvancedOptionsDisabling" ng-model="archetypeConfigRenderModel.enableDisabling" />
+        </div>
         <div>
             <label for="archetypeAdvancedOptionsFieldsetToolbar"><archetype-localize key="hideFieldsetToolbar">Hide Fieldset Toolbar?</archetype-localize><small><archetype-localize key="hideFieldsetToolbarDescription">Hides the fieldset toolbar that appears when more than one fieldset model appears.</archetype-localize></small></label>
             <input type="checkbox" id="archetypeAdvancedOptionsFieldsetToolbar" ng-model="archetypeConfigRenderModel.hideFieldsetToolbar"/>
@@ -125,6 +129,14 @@
             <label for="archetypeAdvancedOptionsCustomJs"><archetype-localize key="jsFile">JS File</archetype-localize><small><archetype-localize key="jsFileDescription">(Optional) Enter a path for a custom JS file to be included on the page.</archetype-localize></small></label>
             <input type="text" id="archetypeAdvancedOptionsCustomJs" ng-model="archetypeConfigRenderModel.customJsPath"/>
         </div>
+        <div>
+            <label for="archetypeAdvancedOptionsCustomView"><archetype-localize key="viewFile">View File</archetype-localize><small><archetype-localize key="viewFileDescription">(Optional) Enter a path for a custom view file to be used to render this Archetype.</archetype-localize></small></label>
+            <input type="text" id="archetypeAdvancedOptionsCustomView" ng-model="archetypeConfigRenderModel.customViewPath"/>
+        </div>
+        <div>
+            <label for="archetypeAdvancedOptionsDeepDatatypeRequest"><archetype-localize key="deepDatatypeRequest">Enable Deep Datatype Requests</archetype-localize><small><archetype-localize key="deepDatatypeRequestDescription">Allows for easier datatype interception at the cost of caching performance.</archetype-localize></small></label>
+            <input type="checkbox" id="archetypeAdvancedOptionsDeepDatatypeRequest" ng-model="archetypeConfigRenderModel.enableDeepDatatypeRequests"/>
+        </div>
         <div>
             <label for="archetypeAdvancedOptionsDeveloperMode"><archetype-localize key="toggleDeveloperMode">Toggle Developer Mode</archetype-localize><small><archetype-localize key="toggleDeveloperModeDescription">Toggle Developer Mode</archetype-localize></small></label>
             <input type="checkbox" id="archetypeAdvancedOptionsDeveloperMode" ng-model="archetypeConfigRenderModel.developerMode"/>

app/views/archetype.default.html

@@ -0,0 +1,63 @@
+<div class="archetypeEditor ng-class:model.config.customCssClass">
+    <textarea class="archetypeDeveloperModel" ng-show="model.config.developerMode" ng-model="model.value"></textarea>
+    <ul ui-sortable="sortableOptions" ng-model="model.value.fieldsets" ng-show="!showAddButton()">
+        <li ng-repeat="fieldset in model.value.fieldsets">
+            <fieldset ng-class="['archetype-fieldset-' + fieldset.alias, (getFieldsetValidity(fieldset) == false ? 'archetypeFieldsetError' : '')]" ng-init="fieldsetConfigModel = getConfigFieldsetByAlias(fieldset.alias)">
+                <div class="archetypeFieldsetLabel" ng-class="{enableCollapsing: model.config.enableCollapsing}">
+                    <div ng-click="focusFieldset(fieldset)" class="label-sub module-label">
+                        <span class="caret" ng-hide="fieldset.collapse || !model.config.enableCollapsing"></span>
+                        <span class="caret caret-right" ng-show="fieldset.collapse && model.config.enableCollapsing"></span>
+                        <label ng-class="{dimmed: fieldset.disabled}">
+                            <i class="fieldsetIcon icon ng-class:fieldsetConfigModel.icon"></i>
+                            <span ng-bind="getFieldsetTitle(fieldsetConfigModel, $index)"></span>
+                        </label>
+                    </div>
+                    <div class="archetypeEditorControls label-sub" ng-hide="model.config.hideFieldsetControls">
+                        <i class="icon icon-add dropdown-toggle" ng-show="canAdd()" data-toggle="{{ model.config.fieldsets.length > 1 ? 'dropdown' : ''}}" ng-click="model.config.fieldsets.length == 1 ? addRow(fieldset.alias, $index) : return"></i>
+                        <ul class="dropdown-menu umb-actions">
+                            <li ng-repeat="fieldsetModel in model.config.fieldsets" ng-click="addRow(fieldsetModel.alias, $parent.$index)">
+                                <a>
+                                    <i class="fieldsetIcon icon ng-class:fieldsetModel.icon"></i>
+                                    <span class="menu-label">{{fieldsetModel.label}}</span>
+                                </a>
+                            </li>
+                        </ul>
+                        <i class="icon icon-remove" ng-click="removeRow($index)" ng-show="canRemove()"></i>
+                        <i class="icon icon-power" ng-class="{dimmed: fieldset.disabled}" ng-click="enableDisable(fieldset)" ng-show="canDisable()"></i>
+                        <i class="icon icon-navigation handle" ng-show="canSort()"></i>
+                    </div>
+                </div>
+                <div class="archetypeCollapser animate-hide" ng-hide="model.config.enableCollapsing && isCollapsed(fieldset)">
+                    <form class="form-inline">
+                        <div ng-class="[property.alias, (getPropertyValidity($parent.$index, property.alias) === false ? 'archetypePropertyError' : '')]" class="archetypeProperty control-group" ng-repeat="property in fieldsetConfigModel.properties">
+                            <label ng-hide="model.config.hidePropertyLabels == '1'" class="control-label" for="archetype-property-{{model.alias}}-{{$parent.$index}}-{{$index}}">
+                                <span>{{property.label}}</span>
+                                <div class="archetypeFieldsetHelpText" ng-show="property.helpText">
+                                    <small>{{property.helpText}}</small>
+                                </div>
+                            </label>
+
+                            <div ng-class="[(model.config.hidePropertyLabels == '1' ? 'controls-no-label' : 'controls')]">
+                                <archetype-property class="archetypeEditor" property="property" property-editor-alias="model.alias" fieldset-index="$parent.$index" fieldset="fieldset" archetype-config="model.config" property-config-index="$index" archetype-render-model="model.value" umbraco-form="form"></archetype-property>
+                            </div>
+                        </div>
+                    </form>
+                </div>
+            </fieldset>
+        </li>
+    </ul>
+    <div ng-show="showAddButton()">
+        <a data-toggle="{{ model.config.fieldsets.length > 1 ? 'dropdown' : ''}}" ng-click="model.config.fieldsets.length == 1 ? addRow(model.config.fieldsets[0].alias, 0) : return" prevent-default>
+            <i class="icon icon-add dropdown-toggle"></i>
+            <localize key="general_add" class="archetypeAddButtonText">Add</localize>
+        </a>
+        <ul class="dropdown-menu umb-actions">
+            <li ng-repeat="fieldsetModel in model.config.fieldsets" ng-click="addRow(fieldsetModel.alias, 0)">
+                <a>
+                    <i class="fieldsetIcon icon ng-class:fieldsetModel.icon"></i>
+                    <span class="menu-label">{{fieldsetModel.label}}</span>
+                </a>
+            </li>
+        </ul>
+    </div>
+</div>

app/views/archetype.html

@@ -1,62 +1 @@
-<div class="archetypeEditor ng-class:model.config.customCssClass" ng-controller="Imulus.ArchetypeController">
-    <textarea class="archetypeDeveloperModel" ng-show="model.config.developerMode" ng-model="model.value"></textarea>
-    <ul ui-sortable="sortableOptions" ng-model="model.value.fieldsets" ng-show="!showAddButton()">
-        <li ng-repeat="fieldset in model.value.fieldsets">
-            <fieldset ng-class="{archetypeFieldsetError: !fieldset.isValid}" ng-init="fieldsetConfigModel = getConfigFieldsetByAlias(fieldset.alias)">
-                <div class="archetypeFieldsetLabel" ng-class="{enableCollapsing: model.config.enableCollapsing}">
-                    <div ng-click="focusFieldset(fieldset)" class="label-sub module-label">
-                        <span class="caret" ng-hide="fieldset.collapse || !model.config.enableCollapsing"></span>
-                        <span class="caret caret-right" ng-show="fieldset.collapse && model.config.enableCollapsing"></span>
-                        <label>
-                            <i class="fieldsetIcon icon ng-class:fieldsetConfigModel.icon"></i>
-                            <span ng-bind="getFieldsetTitle(fieldsetConfigModel, $index)"></span>
-                        </label>
-                    </div>
-                    <div class="archetypeEditorControls label-sub" ng-hide="model.config.hideFieldsetControls">
-                        <i class="icon icon-add dropdown-toggle" ng-show="canAdd()" data-toggle="{{ model.config.fieldsets.length > 1 ? 'dropdown' : ''}}" ng-click="model.config.fieldsets.length == 1 ? addRow(fieldset.alias, $index) : return"></i>
-                        <ul class="dropdown-menu umb-actions">
-                            <li ng-repeat="fieldsetModel in model.config.fieldsets" ng-click="addRow(fieldsetModel.alias, $parent.$index)">
-                                <a>
-                                    <i class="fieldsetIcon icon ng-class:fieldsetModel.icon"></i>
-                                    <span class="menu-label">{{fieldsetModel.label}}</span>
-                                </a>
-                            </li>
-                        </ul>
-                        <i class="icon icon-remove" ng-click="removeRow($index)" ng-show="canRemove()"></i>
-                        <i class="icon icon-navigation handle" ng-show="canSort()"></i>
-                    </div>
-                </div>
-                <div class="archetypeCollapser animate-hide" ng-hide="isCollapsed(fieldset)">
-                    <form class="form-inline">
-                        <div ng-class="{archetypePropertyError: getPropertyValidity($parent.$index, property.alias) === false}" class="archetypeProperty control-group" ng-repeat="property in fieldsetConfigModel.properties">
-                            <label ng-hide="archetypeConfig.hidePropertyLabels == '1'" class="control-label" for="archetype-property-{{model.alias}}-{{$parent.$index}}-{{$index}}">
-                                <span>{{property.label}}</span>
-                                <div class="archetypeFieldsetHelpText" ng-show="property.helpText">
-                                    <small>{{property.helpText}}</small>
-                                </div>
-                            </label>
-
-                            <div class="controls">
-                                <archetype-property class="archetypeEditor ng-class:property.alias" property="property" fieldset-index="$parent.$index" fieldset="fieldset" archetype-config="model.config" property-config-index="$index" archetype-render-model="model.value" umbraco-property-alias="model.alias" umbraco-form = "form"></archetype-property>
-                            </div>
-                        </div>
-                    </form>
-                </div>
-            </fieldset>
-        </li>
-    </ul>
-    <div ng-show="showAddButton()">
-        <a data-toggle="{{ model.config.fieldsets.length > 1 ? 'dropdown' : ''}}" ng-click="model.config.fieldsets.length == 1 ? addRow(fieldset.alias, 0) : return" prevent-default>
-            <i class="icon icon-add dropdown-toggle"></i>
-            <localize key="general_add" class="archetypeAddButtonText">Add</localize>
-        </a>
-        <ul class="dropdown-menu umb-actions">
-            <li ng-repeat="fieldsetModel in model.config.fieldsets" ng-click="addRow(fieldsetModel.alias, 0)">
-                <a>
-                    <i class="fieldsetIcon icon ng-class:fieldsetModel.icon"></i>
-                    <span class="menu-label">{{fieldsetModel.label}}</span>
-                </a>
-            </li>
-        </ul>
-    </div>
-</div>
+<div archetype-custom-view ng-controller="Imulus.ArchetypeController"></div>

config/meta.json

@@ -1,6 +1,6 @@
 {
 	"name": "Archetype",
-	"version": "1.0-beta",
+	"version": "1.5.0-beta",
 	"url": "http://github.com/imulus/archetype/",
 	"author": "Imulus",
 	"authorUrl": "http://imulus.com/",

package.json

@@ -27,5 +27,8 @@
   "repository": {
     "type": "git",
     "url": "https://github.com/imulus/Archetype.git"
+  },
+  "devDependencies": {
+    "grunt-msbuild": "^0.1.12"
   }
 }