This depends on a core PR.

Update dll to v1.12.1
Revert "Fix #304 "
2015-12-14 09:53:01 -05:00 · 2015-12-03 08:44:40 -05:00 · 2015-12-03 08:43:23 -05:00 · 2015-11-16 13:25:54 -05:00 · 2015-11-16 13:24:36 -05:00 · 2015-11-16 12:50:11 -05:00
37 changed files with 891 additions and 92 deletions
@@ -279,7 +279,7 @@ module.exports = function(grunt) {
    }
  });

-  grunt.registerTask('default', ['clean', 'string-replace', 'less', 'concat', 'assemblyinfo', 'msbuild:dist', 'copy:dll', 'copy:assets', 'copy:config', 'clean:html', 'clean:js', 'clean:less']);
+  grunt.registerTask('default', ['clean', 'string-replace', 'less', 'concat', 'assemblyinfo', 'msbuild:dist', 'copy:dll', 'copy:assets', 'copy:html', 'copy:config', 'clean:html', 'clean:js', 'clean:less']);

  grunt.registerTask('nuget',   ['clean:tmp', 'default', 'copy:nuget', 'template:nuspec', 'nugetpack', 'clean:tmp']);
  grunt.registerTask('umbraco', ['clean:tmp', 'default', 'copy:umbraco', 'umbracoPackage', 'clean:tmp']);
@@ -13,6 +13,9 @@ using Umbraco.Courier.ItemProviders;

 namespace Archetype.Courier.DataResolvers
 {
+    /// <summary>
+    /// Lee Kelleher's implementation of Courier's PropertyDataResolverProvider for Archetype.
+    /// </summary>
 	public class ArchetypeDataResolver : PropertyDataResolverProvider
 	{
 		private enum Direction
@@ -21,6 +24,12 @@ namespace Archetype.Courier.DataResolvers
 			Packaging
 		}

+        /// <summary>
+        /// Gets the editor alias.
+        /// </summary>
+        /// <value>
+        /// The editor alias.
+        /// </value>
 		public override string EditorAlias
 		{
 			get
@@ -29,26 +38,48 @@ namespace Archetype.Courier.DataResolvers
 			}
 		}

+        /// <summary>
+        /// Extractings the type of the data.
+        /// </summary>
+        /// <param name="item">The item.</param>
 		public override void ExtractingDataType(DataType item)
 		{
 			// No longer need to extract the DataType (int) Ids as Archetype now references the Guid [LK]
 		}

+        /// <summary>
+        /// Extractings the property.
+        /// </summary>
+        /// <param name="item">The item.</param>
+        /// <param name="propertyData">The property data.</param>
 		public override void ExtractingProperty(Item item, ContentProperty propertyData)
 		{
 			ReplacePropertyDataIds(item, propertyData, Direction.Extracting);
 		}

+        /// <summary>
+        /// Packagings the type of the data.
+        /// </summary>
+        /// <param name="item">The item.</param>
 		public override void PackagingDataType(DataType item)
 		{
 			AddDataTypeDependencies(item);
 		}

+        /// <summary>
+        /// Packages the property.
+        /// </summary>
+        /// <param name="item">The item.</param>
+        /// <param name="propertyData">The property data.</param>
 		public override void PackagingProperty(Item item, ContentProperty propertyData)
 		{
 			ReplacePropertyDataIds(item, propertyData, Direction.Packaging);
 		}

+        /// <summary>
+        /// Adds the datatype dependencies.
+        /// </summary>
+        /// <param name="item">The item.</param>
 		private void AddDataTypeDependencies(DataType item)
 		{
 			if (item.Prevalues != null && item.Prevalues.Count > 0)
@@ -71,6 +102,12 @@ namespace Archetype.Courier.DataResolvers
 			}
 		}

+        /// <summary>
+        /// Replaces the property data Ids.
+        /// </summary>
+        /// <param name="item">The item.</param>
+        /// <param name="propertyData">The property data.</param>
+        /// <param name="direction">The direction.</param>
 		private void ReplacePropertyDataIds(Item item, ContentProperty propertyData, Direction direction)
 		{
 			if (propertyData != null && propertyData.Value != null)
@@ -168,6 +205,10 @@ namespace Archetype.Courier.DataResolvers
 			}
 		}

+        /// <summary>
+        /// Retrieves the additional properties.
+        /// </summary>
+        /// <param name="preValue">The pre value.</param>
 		private void RetrieveAdditionalProperties(ref ArchetypePreValue preValue)
 		{
 			if (preValue == null)
@@ -189,6 +230,11 @@ namespace Archetype.Courier.DataResolvers
 			}
 		}

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

 namespace Archetype.Tests.Models
 {
-
+    /// <summary>
+    /// Tests designed for the fieldsets.
+    /// </summary>
    [TestFixture]
    public class FieldsetTests
    {
-
        private string _sampleJson;

+        /// <summary>
+        /// Sets up the test to use sample JSON data.
+        /// </summary>
        [SetUp]
        public void SetUp()
        {
@@ -1,22 +1,21 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
+using System.IO;
 using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
 using Archetype.PropertyConverters;
-using Moq;
 using NUnit.Framework;
-using Umbraco.Core.Models.PublishedContent;

 namespace Archetype.Tests.PropertyValueConverter
 {
+    /// <summary>
+    /// Tests designed to test the PVC.
+    /// </summary>
    [TestFixture]
    public class PropertyValueConverterTests
    {
-
        private string _sampleJson;

+        /// <summary>
+        /// Sets up the test to use JSON data.
+        /// </summary>
        [SetUp]
        public void SetUp()
        {
@@ -0,0 +1,95 @@
+using System;
+using System.Linq;
+using Archetype.Extensions;
+using Archetype.Models;
+using Archetype.PropertyConverters;
+using NUnit.Framework;
+using Umbraco.Core.Models;
+using Umbraco.Web;
+
+namespace Archetype.Tests.PublishedContent
+{
+    [TestFixture]
+    public class ArchetypePublishedContentTests
+    {
+        private ArchetypeModel _archetype;
+
+        [TestFixtureSetUp]
+        public void Init()
+        {
+            var archetypeJson = System.IO.File.ReadAllText("..\\..\\Data\\sample-1.json");
+            var converter = new ArchetypeValueConverter();
+
+            _archetype = (ArchetypeModel)converter.ConvertDataToSource(null, archetypeJson, false);
+        }
+
+        [Test]
+        public void ArchetypeModel_Initialized()
+        {
+            Assert.IsNotNull(_archetype);
+            Assert.IsNotEmpty(_archetype.Fieldsets);
+        }
+
+        [Test]
+        public void ArchetypeModel_To_PublishedContentSet()
+        {
+            var contentSet = _archetype.ToPublishedContentSet();
+
+            Assert.That(contentSet, Is.Not.Null);
+            Assert.That(contentSet, Is.Not.Empty);
+            Assert.That(contentSet, Is.All.InstanceOf<IPublishedContent>());
+        }
+
+        [Test]
+        public void ArchetypeFieldsetModel_To_PublishedContent()
+        {
+            var fieldset = _archetype.Fieldsets.FirstOrDefault();
+            var content = fieldset.ToPublishedContent();
+
+            Assert.That(content, Is.Not.Null);
+            Assert.That(content, Is.InstanceOf<IPublishedContent>());
+            Assert.That(content.Properties, Is.Not.Empty);
+            Assert.That(content.Properties, Is.All.InstanceOf<IPublishedProperty>());
+        }
+
+        [TestCase("boxHeadline", "Box 1 Title")]
+        [TestCase("link", "3175")]
+        [TestCase("link", 3175)]
+        [TestCase("show", "1")]
+        [TestCase("show", true)]
+        [TestCase("show", 1)]
+        public void ArchetypePublishedContent_Typed_Properties<T>(string propertyAlias, T expected)
+        {
+            var fieldset = _archetype.Fieldsets.FirstOrDefault();
+            var content = fieldset.ToPublishedContent();
+
+            var actual = content.GetPropertyValue<T>(propertyAlias);
+
+            Assert.AreEqual(actual, expected);
+        }
+
+        [Test]
+        public void Null_ArchetypeModel_Throws_Exception()
+        {
+            TestDelegate code = () =>
+            {
+                ArchetypeModel archetype = null;
+                archetype.ToPublishedContentSet();
+            };
+
+            Assert.Throws<ArgumentNullException>(code);
+        }
+
+        [Test]
+        public void Null_ArchetypeFieldsetModel_Throws_Exception()
+        {
+            TestDelegate code = () =>
+            {
+                ArchetypeFieldsetModel fieldset = null;
+                fieldset.ToPublishedContent();
+            };
+
+            Assert.Throws<ArgumentNullException>(code);
+        }
+    }
+}
@@ -21,7 +21,7 @@
  <package id="Moq" version="4.2.1312.1622" targetFramework="net45" />
  <package id="MySql.Data" version="6.6.5" targetFramework="net45" />
  <package id="Newtonsoft.Json" version="6.0.2" targetFramework="net45" />
-  <package id="NUnit" version="2.6.3" targetFramework="net45" />
+  <package id="NUnit" version="2.6.4" targetFramework="net45" />
  <package id="SharpZipLib" version="0.86.0" targetFramework="net45" />
  <package id="UmbracoCms.Core" version="7.1.2" targetFramework="net45" />
  <package id="xmlrpcnet" version="2.5.0" targetFramework="net45" />
@@ -4,6 +4,10 @@ using Umbraco.Core.Logging;

 namespace DatabaseSizer
 {
+    /// <summary>
+    /// A now obsolete project that handled an Umbraco core limitation.
+    /// </summary>
+    [Obsolete("This project is now obsolete with 7.2.2+")]
    public class Application : ApplicationEventHandler
    {
        protected override void ApplicationStarted(UmbracoApplicationBase umbracoApplication, ApplicationContext applicationContext)
@@ -14,10 +14,12 @@ using Archetype.Extensions;

 namespace Archetype.Api
 {
+    /// <summary>
+    /// Controller that handles datatype related interactions.
+    /// </summary>
    [PluginController("ArchetypeApi")]
    public class ArchetypeDataTypeController : UmbracoAuthorizedJsonController
    {
-
        public IEnumerable<object> GetAllPropertyEditors()
        {
            return
@@ -25,12 +27,22 @@ namespace Archetype.Api
                    .Select(x => new {defaultPreValues = x.DefaultPreValuesForArchetype(), alias = x.Alias, view = x.ValueEditor.View});
        }

+        /// <summary>
+        /// Gets all datatypes.
+        /// </summary>
+        /// <returns></returns>
        public object GetAll() 
        {
            var dataTypes = Services.DataTypeService.GetAllDataTypeDefinitions();
            return dataTypes.Select(t => new { guid = t.Key, name = t.Name });
        }

+        /// <summary>
+        /// Gets the datatype by GUID.
+        /// </summary>
+        /// <param name="guid">The unique identifier.</param>
+        /// <returns></returns>
+        /// <exception cref="System.Web.Http.HttpResponseException"></exception>
        public object GetByGuid(Guid guid)
        {
            var dataType = Services.DataTypeService.GetDataTypeDefinitionById(guid);
@@ -43,6 +55,16 @@ namespace Archetype.Api
            return new { selectedEditor = dataTypeDisplay.SelectedEditor, preValues = dataTypeDisplay.PreValues };
        }

+        /// <summary>
+        /// Gets the datatype by GUID.
+        /// </summary>
+        /// <param name="guid">The unique identifier.</param>
+        /// <param name="contentTypeAlias">The content type alias.</param>
+        /// <param name="propertyTypeAlias">The property type alias.</param>
+        /// <param name="archetypeAlias">The archetype alias.</param>
+        /// <param name="nodeId">The node identifier.</param>
+        /// <returns></returns>
+        /// <exception cref="System.Web.Http.HttpResponseException"></exception>
        public object GetByGuid(Guid guid, string contentTypeAlias, string propertyTypeAlias, string archetypeAlias, int nodeId)
        {
            var dataType = Services.DataTypeService.GetDataTypeDefinitionById(guid);
@@ -54,11 +76,19 @@ namespace Archetype.Api
            return new { selectedEditor = dataTypeDisplay.SelectedEditor, preValues = dataTypeDisplay.PreValues, contentTypeAlias = contentTypeAlias, propertyTypeAlias = propertyTypeAlias, archetypeAlias = archetypeAlias, nodeId = nodeId };
        }

+        /// <summary>
+        /// Returns the DLL version from the file.
+        /// </summary>
+        /// <returns></returns>
        public object GetDllVersion()
        {
            return new {dllVersion = _version()};
        }

+        /// <summary>
+        /// Gets the DLL version from the file.
+        /// </summary>
+        /// <returns></returns>
        private string _version()
        {
            var asm = Assembly.GetExecutingAssembly();
@@ -231,7 +231,9 @@
    <Compile Include="Api\ArchetypeDataTypeController.cs" />
    <Compile Include="Constants.cs" />
    <Compile Include="Events\ExpireCache.cs" />
+    <Compile Include="Extensions\ArchetypeFieldsetModelExtensions.cs" />
    <Compile Include="Extensions\ArchetypeHelper.cs" />
+    <Compile Include="Extensions\ArchetypeModelExtensions.cs" />
    <Compile Include="Extensions\HtmlHelperExtensions.cs" />
    <Compile Include="Extensions\ArchetypePropertyModelExtensions.cs" />
    <Compile Include="Extensions\PropertyEditorExtensions.cs" />
@@ -243,6 +245,9 @@
    <Compile Include="Models\ArchetypePreValueProperty.cs" />
    <Compile Include="Models\ArchetypeFieldsetModel.cs" />
    <Compile Include="Models\ArchetypePropertyModel.cs" />
+    <Compile Include="Models\ArchetypePublishedContent.cs" />
+    <Compile Include="Models\ArchetypePublishedContentSet.cs" />
+    <Compile Include="Models\ArchetypePublishedProperty.cs" />
    <Compile Include="Properties\AssemblyInfo.cs" />
    <Compile Include="Properties\VersionInfo.cs" />
    <Compile Include="PropertyConverters\ArchetypeValueConverter.cs" />
@@ -1,5 +1,8 @@
 namespace Archetype
 {
+    /// <summary>
+    /// Archetype constants.
+    /// </summary>
    public static class Constants
    {
        public const string PropertyEditorAlias = "Imulus.Archetype";
@@ -1,18 +1,16 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using Umbraco.Core;
+using Umbraco.Core;
 using Umbraco.Core.Models;
 using Umbraco.Core.Services;
-using Umbraco.Web;

 namespace Archetype.Events
 {
    public class ExpireCache : ApplicationEventHandler
    {
-
+        /// <summary>
+        /// Registers our ExpirePreValueCache handler on app starting.
+        /// </summary>
+        /// <param name="umbracoApplication"></param>
+        /// <param name="applicationContext"></param>
        protected override void ApplicationStarting(UmbracoApplicationBase umbracoApplication, ApplicationContext applicationContext)
        {
            base.ApplicationStarting(umbracoApplication, applicationContext);
@@ -20,6 +18,11 @@ namespace Archetype.Events
            DataTypeService.Saved += ExpirePreValueCache;
        }

+        /// <summary>
+        /// Expires the pre value cache when a datatype is saved.
+        /// </summary>
+        /// <param name="sender">The sender.</param>
+        /// <param name="e">The <see cref="Umbraco.Core.Events.SaveEventArgs{IDataTypeDefinition}"/> instance containing the event data.</param>
        void ExpirePreValueCache(IDataTypeService sender, global::Umbraco.Core.Events.SaveEventArgs<IDataTypeDefinition> e)
        {
            foreach (var dataType in e.SavedEntities)
@@ -0,0 +1,13 @@
+using Archetype.Models;
+using Umbraco.Core.Models;
+
+namespace Archetype.Extensions
+{
+    public static class ArchetypeFieldsetModelExtensions
+    {
+        public static IPublishedContent ToPublishedContent(this ArchetypeFieldsetModel fieldset)
+        {
+            return new ArchetypePublishedContent(fieldset);
+        }
+    }
+}
@@ -9,6 +9,9 @@ using Umbraco.Core.Models.PublishedContent;

 namespace Archetype.Extensions
 {
+    /// <summary>
+    /// Helper class that handles several Archetype related interactions.
+    /// </summary>
    public class ArchetypeHelper
    {
        protected JsonSerializerSettings _jsonSettings;
@@ -18,6 +21,9 @@ namespace Archetype.Extensions

        internal static ArchetypeHelper Instance { get { return _instance; } }

+        /// <summary>
+        /// Initializes a new instance of the <see cref="ArchetypeHelper"/> class.
+        /// </summary>
        internal ArchetypeHelper()
        {
            var dcr = new Newtonsoft.Json.Serialization.DefaultContractResolver();
@@ -27,8 +33,20 @@ namespace Archetype.Extensions
            _app = ApplicationContext.Current;
        }

+        /// <summary>
+        /// Gets the json serializer settings.
+        /// </summary>
+        /// <value>
+        /// The json serializer settings.
+        /// </value>
        internal JsonSerializerSettings JsonSerializerSettings { get { return _jsonSettings; } }

+        /// <summary>
+        /// Deserializes the JSON to archetype.
+        /// </summary>
+        /// <param name="sourceJson">The source JSON.</param>
+        /// <param name="dataTypePreValues">The data type pre values.</param>
+        /// <returns></returns>
        internal ArchetypeModel DeserializeJsonToArchetype(string sourceJson, PreValueCollection dataTypePreValues)
        {
            try
@@ -54,6 +72,13 @@ namespace Archetype.Extensions
            }
        }

+        /// <summary>
+        /// Deserializes the JSON to archetype.
+        /// </summary>
+        /// <param name="sourceJson">The source JSON.</param>
+        /// <param name="dataTypeId">The data type identifier.</param>
+        /// <param name="hostContentType">Type of the host content.</param>
+        /// <returns></returns>
        internal ArchetypeModel DeserializeJsonToArchetype(string sourceJson, int dataTypeId, PublishedContentType hostContentType = null)
        {
            try
@@ -79,6 +104,11 @@ namespace Archetype.Extensions
            }
        }

+        /// <summary>
+        /// Determines whether datatypeId has had it's PVC overridden.
+        /// </summary>
+        /// <param name="dataTypeId">The data type identifier.</param>
+        /// <returns></returns>
        internal bool IsPropertyValueConverterOverridden(int dataTypeId)
        {
            var prevalues = GetArchetypePreValueFromDataTypeId(dataTypeId);
@@ -88,6 +118,11 @@ namespace Archetype.Extensions
            return prevalues.OverrideDefaultPropertyValueConverter;
        }

+        /// <summary>
+        /// Gets the archetype pre value from data type identifier.
+        /// </summary>
+        /// <param name="dataTypeId">The data type identifier.</param>
+        /// <returns></returns>
        private ArchetypePreValue GetArchetypePreValueFromDataTypeId(int dataTypeId)
        {
            return _app.ApplicationCache.RuntimeCache.GetCacheItem(
@@ -108,6 +143,11 @@ namespace Archetype.Extensions
                }) as ArchetypePreValue;
        }

+        /// <summary>
+        /// Gets the archetype pre value from pre values collection.
+        /// </summary>
+        /// <param name="dataTypePreValues">The data type pre values.</param>
+        /// <returns></returns>
        private ArchetypePreValue GetArchetypePreValueFromPreValuesCollection(PreValueCollection dataTypePreValues)
        {
            var preValueAsString = dataTypePreValues.PreValuesAsDictionary.First().Value.Value;
@@ -115,6 +155,11 @@ namespace Archetype.Extensions
            return preValue;
        }

+        /// <summary>
+        /// Gets the data type by unique identifier.
+        /// </summary>
+        /// <param name="guid">The unique identifier.</param>
+        /// <returns></returns>
        internal IDataTypeDefinition GetDataTypeByGuid(Guid guid)
        {
            return (IDataTypeDefinition)ApplicationContext.Current.ApplicationCache.RuntimeCache.GetCacheItem(
@@ -0,0 +1,14 @@
+using System.Collections.Generic;
+using Archetype.Models;
+using Umbraco.Core.Models;
+
+namespace Archetype.Extensions
+{
+    public static class ArchetypeModelExtensions
+    {
+        public static IEnumerable<IPublishedContent> ToPublishedContentSet(this ArchetypeModel archetype)
+        {
+            return new ArchetypePublishedContentSet(archetype);
+        }
+    }
+}
@@ -2,18 +2,37 @@ using Archetype.Models;
 using Umbraco.Core;
 using Umbraco.Core.Models;
 using Umbraco.Core.Models.PublishedContent;
+using Umbraco.Core.PropertyEditors;

 namespace Archetype.Extensions
 {
+    /// <summary>
+    /// ArchetypePropertyModel extensions.
+    /// </summary>
    public static class ArchetypePropertyModelExtensions
    {
+        /// <summary>
+        /// Determines whether this instance is an archetype.
+        /// </summary>
+        /// <param name="prop">The property.</param>
+        /// <returns></returns>
        public static bool IsArchetype(this ArchetypePropertyModel prop)
        {
            return prop.PropertyEditorAlias.InvariantEquals(Constants.PropertyEditorAlias);
        }

+        /// <summary>
+        /// Creates dummy property type.
+        /// </summary>
+        /// <param name="prop">The property.</param>
+        /// <returns></returns>
        internal static PublishedPropertyType CreateDummyPropertyType(this ArchetypePropertyModel prop)
        {
+            // We need to check if `PropertyValueConvertersResolver` exists,
+            // otherwise `PublishedPropertyType` will throw an exception outside of the Umbraco context.; e.g. unit-tests.
+            if (!PropertyValueConvertersResolver.HasCurrent)
+                return null;
+
            return new PublishedPropertyType(prop.HostContentType, new PropertyType(new DataTypeDefinition(-1, prop.PropertyEditorAlias) { Id = prop.DataTypeId }));
        }
    }
@@ -7,28 +7,67 @@ using Umbraco.Core.Logging;

 namespace Archetype.Extensions
 {
+    /// <summary>
+    /// HtmlHelper extenions used for rendering an Archetype.
+    /// </summary>
    public static class HtmlHelperExtensions
    {
+        /// <summary>
+        /// Renders the archetype partials.
+        /// </summary>
+        /// <param name="htmlHelper">The HTML helper.</param>
+        /// <param name="archetypeModel">The archetype model.</param>
+        /// <returns></returns>
        public static IHtmlString RenderArchetypePartials(this HtmlHelper htmlHelper, ArchetypeModel archetypeModel)
        {
            return RenderPartials(htmlHelper, archetypeModel, null, null);
        }

+        /// <summary>
+        /// Renders the archetype partials.
+        /// </summary>
+        /// <param name="htmlHelper">The HTML helper.</param>
+        /// <param name="archetypeModel">The archetype model.</param>
+        /// <param name="partialPath">The partial path.</param>
+        /// <returns></returns>
        public static IHtmlString RenderArchetypePartials(this HtmlHelper htmlHelper, ArchetypeModel archetypeModel, string partialPath)
        {
            return RenderPartials(htmlHelper, archetypeModel, partialPath, null);
        }

+        /// <summary>
+        /// Renders the archetype partials.
+        /// </summary>
+        /// <param name="htmlHelper">The HTML helper.</param>
+        /// <param name="archetypeModel">The archetype model.</param>
+        /// <param name="viewDataDictionary">The view data dictionary.</param>
+        /// <returns></returns>
        public static IHtmlString RenderArchetypePartials(this HtmlHelper htmlHelper, ArchetypeModel archetypeModel, ViewDataDictionary viewDataDictionary)
        {
            return RenderPartials(htmlHelper, archetypeModel, null, viewDataDictionary);
        }

+        /// <summary>
+        /// Renders the archetype partials.
+        /// </summary>
+        /// <param name="htmlHelper">The HTML helper.</param>
+        /// <param name="archetypeModel">The archetype model.</param>
+        /// <param name="partialPath">The partial path.</param>
+        /// <param name="viewDataDictionary">The view data dictionary.</param>
+        /// <returns></returns>
        public static IHtmlString RenderArchetypePartials(this HtmlHelper htmlHelper, ArchetypeModel archetypeModel, string partialPath, ViewDataDictionary viewDataDictionary)
        {
            return htmlHelper.RenderPartials(archetypeModel, partialPath, viewDataDictionary);
        }

+        /// <summary>
+        /// Renders the partials based on the model, partial path and given viewdata dictionary.
+        /// </summary>
+        /// <param name="htmlHelper">The HTML helper.</param>
+        /// <param name="archetypeModel">The archetype model.</param>
+        /// <param name="partialPath">The partial path.</param>
+        /// <param name="viewDataDictionary">The view data dictionary.</param>
+        /// <returns></returns>
        private static IHtmlString RenderPartials(this HtmlHelper htmlHelper, ArchetypeModel archetypeModel, string partialPath, ViewDataDictionary viewDataDictionary)
        {
            var context = HttpContext.Current;
@@ -5,6 +5,9 @@ using Umbraco.Core.PropertyEditors;

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

 namespace Archetype.Models
 {
+    /// <summary>
+    /// Model that represents a fieldset stored as content JSON.
+    /// </summary>
    public class ArchetypeFieldsetModel
    {
        [JsonProperty("alias")]
@@ -20,6 +23,9 @@ namespace Archetype.Models
        [JsonProperty("id")]
        public Guid Id { get; set; }

+        /// <summary>
+        /// Initializes a new instance of the <see cref="ArchetypeFieldsetModel"/> class.
+        /// </summary>
        public ArchetypeFieldsetModel()
        {
            Properties = new List<ArchetypePropertyModel>();
@@ -27,11 +33,22 @@ namespace Archetype.Models

        #region Helper Methods

+        /// <summary>
+        /// Gets the value and returns as string.
+        /// </summary>
+        /// <param name="propertyAlias">The property alias.</param>
+        /// <returns></returns>
        public string GetValue(string propertyAlias)
        {
            return GetValue<string>(propertyAlias);
        }

+        /// <summary>
+        /// Gets the value based on the type passed in as a generic.
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="propertyAlias">The property alias.</param>
+        /// <returns></returns>
        public T GetValue<T>(string propertyAlias)
        {
            var property = GetProperty(propertyAlias);
@@ -49,6 +66,13 @@ namespace Archetype.Models
        // however, this would require GetValue<T>(string propertyAlias) to call the common implementation
        // with a default(T) value, which could in theory result in a performance hit, if T for some reason
        // is costly to instantiate.
+        /// <summary>
+        /// Gets the value.
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="propertyAlias">The property alias.</param>
+        /// <param name="defaultValue">The default value.</param>
+        /// <returns></returns>
        public T GetValue<T>(string propertyAlias, T defaultValue)
        {
            var property = GetProperty(propertyAlias);
@@ -61,16 +85,31 @@ namespace Archetype.Models
            return property.GetValue<T>();
        }

+        /// <summary>
+        /// Determines whether the property is empty.
+        /// </summary>
+        /// <param name="property">The property.</param>
+        /// <returns></returns>
        private bool IsEmptyProperty(ArchetypePropertyModel property) 
        {
            return (property == null || property.Value == null || string.IsNullOrEmpty(property.Value.ToString()));
        }

+        /// <summary>
+        /// Determines whether the specified property alias has property.
+        /// </summary>
+        /// <param name="propertyAlias">The property alias.</param>
+        /// <returns></returns>
        public bool HasProperty(string propertyAlias)
        {
            return GetProperty(propertyAlias) != null;
        }

+        /// <summary>
+        /// Determines whether the specified property alias has value.
+        /// </summary>
+        /// <param name="propertyAlias">The property alias.</param>
+        /// <returns></returns>
        public bool HasValue(string propertyAlias)
        {
            var property = GetProperty(propertyAlias);
@@ -80,12 +119,16 @@ namespace Archetype.Models
            return !string.IsNullOrEmpty(property.Value.ToString());
        }

+        /// <summary>
+        /// Gets the property.
+        /// </summary>
+        /// <param name="propertyAlias">The property alias.</param>
+        /// <returns></returns>
        private ArchetypePropertyModel GetProperty(string propertyAlias)
        {
            return Properties.FirstOrDefault(p => p.Alias.InvariantEquals(propertyAlias));
        }

        #endregion
-
    }
 }
@@ -7,27 +7,44 @@ using Newtonsoft.Json.Linq;

 namespace Archetype.Models
 {
+    /// <summary>
+    /// Model that represents an entire Archetype.
+    /// </summary>
    [JsonObject]
    public class ArchetypeModel : IEnumerable<ArchetypeFieldsetModel>
    {
        [JsonProperty("fieldsets")]
        public IEnumerable<ArchetypeFieldsetModel> Fieldsets { get; set; }

+        /// <summary>
+        /// Initializes a new instance of the <see cref="ArchetypeModel"/> class.
+        /// </summary>
        public ArchetypeModel()
        {
            Fieldsets = new List<ArchetypeFieldsetModel>();
        }

+        /// <summary>
+        /// Returns an enumerator that iterates through the collection of fieldsets.
+        /// </summary>
+        /// <returns>
+        /// An enumerator that can be used to iterate through the collection.
+        /// </returns>
        public IEnumerator<ArchetypeFieldsetModel> GetEnumerator()
        {
            return this.Fieldsets.Where(f => f.Disabled == false).GetEnumerator();
        }

+        //possibly obsolete?
        IEnumerator IEnumerable.GetEnumerator()
        {
            return this.GetEnumerator();
        }

+        /// <summary>
+        /// Serializes for persistence. This should be used for serialization as it cleans up the JSON before saving.
+        /// </summary>
+        /// <returns></returns>
        public string SerializeForPersistence()
        {
            var json = JObject.Parse(JsonConvert.SerializeObject(this, new JsonSerializerSettings() { ReferenceLoopHandling = ReferenceLoopHandling.Ignore }));
@@ -4,6 +4,9 @@ using Newtonsoft.Json;

 namespace Archetype.Models
 {
+    /// <summary>
+    /// Model that represents the configured Archetype options.
+    /// </summary>
    public class ArchetypePreValue
    {
        [JsonProperty("showAdvancedOptions")]
@@ -3,6 +3,9 @@ using Newtonsoft.Json;

 namespace Archetype.Models
 {
+    /// <summary>
+    /// Model that represents configured Archetype fieldsets.
+    /// </summary>
    public class ArchetypePreValueFieldset
    {
        [JsonProperty("alias")]
@@ -2,6 +2,9 @@ using Newtonsoft.Json;

 namespace Archetype.Models
 {
+    /// <summary>
+    /// Model that represents configured groupings of Archetype fieldsets.
+    /// </summary>
    public class ArchetypePreValueFieldsetGroup
    {
        [JsonProperty("name")]
@@ -3,6 +3,9 @@ using Newtonsoft.Json;

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

 namespace Archetype.Models
 {
+    /// <summary>
+    /// Model that represents a stored property in Archetype.
+    /// </summary>
    public class ArchetypePropertyModel
    {
        [JsonProperty("alias")]
@@ -33,6 +36,11 @@ namespace Archetype.Models
        [JsonProperty("hostContentType")]
        internal PublishedContentType HostContentType { get; set; }

+        /// <summary>
+        /// Gets the value based on the type given.
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <returns></returns>
        public T GetValue<T>()
        {
            // Try Umbraco's PropertyValueConverters
@@ -56,6 +64,13 @@ namespace Archetype.Models
            return default(T);
        }

+        /// <summary>
+        /// Tries to convert the value with property value converters.
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="value">The value.</param>
+        /// <param name="converters">The converters.</param>
+        /// <returns></returns>
        private Attempt<T> TryConvertWithPropertyValueConverters<T>(object value, IEnumerable<IPropertyValueConverter> converters)
        {
            var properyType = this.CreateDummyPropertyType();
@@ -92,6 +107,9 @@ namespace Archetype.Models
            return Attempt<T>.Fail();
        }

+        /// <summary>
+        /// Model that represents the current UmbracoEditorState
+        /// </summary>
        internal class UmbracoEditorState
        {
            // container for the names of any files selected for a property in the Umbraco backend
@@ -0,0 +1,183 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Umbraco.Core;
+using Umbraco.Core.Models;
+using Umbraco.Core.Models.PublishedContent;
+
+namespace Archetype.Models
+{
+    public class ArchetypePublishedContent : IPublishedContent
+    {
+        private ArchetypeFieldsetModel _fieldset;
+
+        private readonly Dictionary<string, IPublishedProperty> _properties;
+
+        public ArchetypePublishedContent(ArchetypeFieldsetModel fieldset)
+        {
+            if (fieldset == null)
+                throw new ArgumentNullException("fieldset");
+
+            _fieldset = fieldset;
+
+            _properties = fieldset.Properties
+                .ToDictionary(
+                    x => x.Alias,
+                    x => new ArchetypePublishedProperty(x) as IPublishedProperty,
+                    StringComparer.InvariantCultureIgnoreCase);
+        }
+
+        internal ArchetypeFieldsetModel ArchetypeFieldset
+        {
+            get { return _fieldset; }
+        }
+
+        public IEnumerable<IPublishedContent> Children
+        {
+            get { return Enumerable.Empty<IPublishedContent>(); }
+        }
+
+        public IEnumerable<IPublishedContent> ContentSet
+        {
+            get { return Enumerable.Empty<IPublishedContent>(); }
+        }
+
+        public PublishedContentType ContentType
+        {
+            get { return default(PublishedContentType); }
+        }
+
+        public DateTime CreateDate
+        {
+            get { return DateTime.MinValue; }
+        }
+
+        public int CreatorId
+        {
+            get { return default(int); }
+        }
+
+        public string CreatorName
+        {
+            get { return default(string); }
+        }
+
+        public string DocumentTypeAlias
+        {
+            get { return _fieldset.Alias; }
+        }
+
+        public int DocumentTypeId
+        {
+            get { return default(int); }
+        }
+
+        public int GetIndex()
+        {
+            return default(int);
+        }
+
+        public IPublishedProperty GetProperty(string alias, bool recurse)
+        {
+            IPublishedProperty property;
+            return _properties.TryGetValue(alias, out property) ? property : null;
+        }
+
+        public IPublishedProperty GetProperty(string alias)
+        {
+            return this.GetProperty(alias, false);
+        }
+
+        public int Id
+        {
+            get { return default(int); }
+        }
+
+        public bool IsDraft
+        {
+            get { return _fieldset.Disabled; }
+        }
+
+        public PublishedItemType ItemType
+        {
+            get { return PublishedItemType.Content; }
+        }
+
+        public int Level
+        {
+            get { return default(int); }
+        }
+
+        public string Name
+        {
+            get { return default(string); }
+        }
+
+        public IPublishedContent Parent
+        {
+            get { return default(IPublishedContent); }
+        }
+
+        public string Path
+        {
+            get { return default(string); }
+        }
+
+        public ICollection<IPublishedProperty> Properties
+        {
+            get { return _properties.Values; }
+        }
+
+        public int SortOrder
+        {
+            get { return default(int); }
+        }
+
+        public int TemplateId
+        {
+            get { return default(int); }
+        }
+
+        public DateTime UpdateDate
+        {
+            get { return default(DateTime); }
+        }
+
+        public string Url
+        {
+            get { return default(string); }
+        }
+
+        public string UrlName
+        {
+            get { return default(string); }
+        }
+
+        public Guid Version
+        {
+            get { return Guid.Empty; }
+        }
+
+        public int WriterId
+        {
+            get { return default(int); }
+        }
+
+        public string WriterName
+        {
+            get { return default(string); }
+        }
+
+        public object this[string alias]
+        {
+            get
+            {
+                var property = this.GetProperty(alias);
+
+                return property == null
+                    ? null
+                    : property.Value;
+            }
+        }
+    }
+}
@@ -0,0 +1,36 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Archetype.Models
+{
+    public class ArchetypePublishedContentSet : IEnumerable<ArchetypePublishedContent>
+    {
+        private IEnumerable<ArchetypePublishedContent> _items { get; set; }
+
+        public ArchetypePublishedContentSet(ArchetypeModel archetype)
+        {
+            if (archetype == null)
+                throw new ArgumentNullException("archetype");
+
+            this.ArchetypeModel = archetype;
+
+            _items = archetype.Fieldsets
+                .Where(x => x.Disabled == false)
+                .Select(x => new ArchetypePublishedContent(x));
+        }
+
+        internal ArchetypeModel ArchetypeModel { get; private set; }
+
+        public IEnumerator<ArchetypePublishedContent> GetEnumerator()
+        {
+            return _items.GetEnumerator();
+        }
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return this.GetEnumerator();
+        }
+    }
+}
@@ -0,0 +1,85 @@
+using System;
+using Archetype.Extensions;
+using Umbraco.Core.Models;
+using Umbraco.Core.Models.PublishedContent;
+
+namespace Archetype.Models
+{
+    public class ArchetypePublishedProperty : IPublishedProperty
+    {
+        private readonly object _rawValue;
+        private readonly Lazy<object> _sourceValue;
+        private readonly Lazy<object> _objectValue;
+        private readonly Lazy<object> _xpathValue;
+        private readonly ArchetypePropertyModel _property;
+        private readonly PublishedPropertyType _propertyType;
+
+        public ArchetypePublishedProperty(ArchetypePropertyModel property)
+        {
+            if (property == null)
+                throw new ArgumentNullException("property");
+
+            var preview = false;
+
+            _property = property;
+            _rawValue = property.Value;
+
+            _propertyType = property.CreateDummyPropertyType();
+
+            if (_propertyType != null)
+            {
+                _sourceValue = new Lazy<object>(() => _propertyType.ConvertDataToSource(_rawValue, preview));
+                _objectValue = new Lazy<object>(() => _propertyType.ConvertSourceToObject(_sourceValue.Value, preview));
+                _xpathValue = new Lazy<object>(() => _propertyType.ConvertSourceToXPath(_sourceValue.Value, preview));
+            }
+        }
+
+        internal ArchetypePropertyModel ArchetypeProperty
+        {
+            get { return _property; }
+        }
+
+        public object DataValue
+        {
+            get
+            {
+                return _sourceValue != null
+                    ? _sourceValue.Value
+                    : _rawValue;
+            }
+        }
+
+        public bool HasValue
+        {
+            get
+            {
+                return _rawValue != null && !string.IsNullOrEmpty(_rawValue.ToString());
+            }
+        }
+
+        public string PropertyTypeAlias
+        {
+            get { return _property.Alias; }
+        }
+
+        public object Value
+        {
+            get
+            {
+                return _objectValue != null
+                    ? _objectValue.Value
+                    : _rawValue;
+            }
+        }
+
+        public object XPathValue
+        {
+            get
+            {
+                return _xpathValue != null
+                    ? _xpathValue.Value
+                    : _rawValue;
+            }
+        }
+    }
+}
@@ -1,4 +1,4 @@
 using System.Reflection;

-[assembly: AssemblyVersion("1.11")]
-[assembly: AssemblyFileVersion("1.11")]
+[assembly: AssemblyVersion("1.12.1")]
+[assembly: AssemblyFileVersion("1.12.1")]
@@ -8,15 +8,29 @@ using Umbraco.Core.Services;

 namespace Archetype.PropertyConverters
 {
+    /// <summary>
+    /// Default property value converter that models the JSON to a C# object.
+    /// </summary>
    [PropertyValueType(typeof(Models.ArchetypeModel))]
    [PropertyValueCache(PropertyCacheValue.All, PropertyCacheLevel.Content)]
    public class ArchetypeValueConverter : PropertyValueConverterBase
    {
+        /// <summary>
+        /// Gets the services.
+        /// </summary>
+        /// <value>
+        /// The services.
+        /// </value>
        public ServiceContext Services
        {
            get { return ApplicationContext.Current.Services; }
        }

+        /// <summary>
+        /// Determines whether the specified property type is converter for Archetype.
+        /// </summary>
+        /// <param name="propertyType">Type of the property.</param>
+        /// <returns></returns>
        public override bool IsConverter(PublishedPropertyType propertyType)
        {
            var isArcheTypePropertyEditor = !String.IsNullOrEmpty(propertyType.PropertyEditorAlias) 
@@ -27,6 +41,13 @@ namespace Archetype.PropertyConverters
            return !ArchetypeHelper.Instance.IsPropertyValueConverterOverridden(propertyType.DataTypeId);
        }

+        /// <summary>
+        /// Converts the data to source.
+        /// </summary>
+        /// <param name="propertyType">Type of the property.</param>
+        /// <param name="source">The source.</param>
+        /// <param name="preview">if set to <c>true</c> [preview].</param>
+        /// <returns></returns>
        public override object ConvertDataToSource(PublishedPropertyType propertyType, object source, bool preview)
        {
            var defaultValue = new ArchetypeModel();
@@ -15,17 +15,27 @@ using Umbraco.Web.Models.ContentEditing;

 namespace Archetype.PropertyEditors
 {
+    /// <summary>
+    /// C# representation of the property editor. This is often done with package manifest instead.
+    /// </summary>
 	[PropertyEditorAsset(ClientDependencyType.Javascript, "../App_Plugins/Archetype/js/archetype.js")]
 	[PropertyEditor(Constants.PropertyEditorAlias, "Archetype", "../App_Plugins/Archetype/views/archetype.html", ValueType = "JSON")]
 	public class ArchetypePropertyEditor : PropertyEditor
 	{
 		#region Pre Value Editor

+        /// <summary>
+        /// Creates a pre value editor instance
+        /// </summary>
+        /// <returns></returns>
 		protected override PreValueEditor CreatePreValueEditor()
 		{
 			return new ArchetypePreValueEditor();
 		}

+        /// <summary>
+        /// Class that represents the prevalue editor. This is often done with a package manifest instead.
+        /// </summary>
 		internal class ArchetypePreValueEditor : PreValueEditor
 		{
 			[PreValueField("archetypeConfig", "Config", "../App_Plugins/Archetype/views/archetype.config.html",
@@ -41,11 +51,18 @@ namespace Archetype.PropertyEditors

 		#region Value Editor

+        /// <summary>
+        /// Creates a value editor instance
+        /// </summary>
+        /// <returns></returns>
 		protected override PropertyValueEditor CreateValueEditor()
 		{
 			return new ArchetypePropertyValueEditor(base.CreateValueEditor());
 		}

+        /// <summary>
+        /// Class that represents the actual data editor. This is often done with a package manifest instead.
+        /// </summary>
 		internal class ArchetypePropertyValueEditor : PropertyValueEditorWrapper
 		{
 			protected JsonSerializerSettings _jsonSettings;
@@ -55,6 +72,13 @@ namespace Archetype.PropertyEditors
 			{
 			}

+            /// <summary>
+            /// Converts the property value for use in the front-end cache
+            /// </summary>
+            /// <param name="property"></param>
+            /// <param name="propertyType"></param>
+            /// <param name="dataTypeService"></param>
+            /// <returns></returns>
 			public override string ConvertDbToString(Property property, PropertyType propertyType, IDataTypeService dataTypeService)
 			{
 				if(property.Value == null || property.Value.ToString() == "")
@@ -85,6 +109,17 @@ namespace Archetype.PropertyEditors
 				return archetype.SerializeForPersistence();
 			}

+            /// <summary>
+            /// A method used to format the database value to a value that can be used by the editor
+            /// </summary>
+            /// <param name="property"></param>
+            /// <param name="propertyType"></param>
+            /// <param name="dataTypeService"></param>
+            /// <returns></returns>
+            /// <remarks>
+            /// The object returned will automatically be serialized into json notation. For most property editors
+            /// the value returned is probably just a string but in some cases a json structure will be returned.
+            /// </remarks>
 			public override object ConvertDbToEditor(Property property, PropertyType propertyType, IDataTypeService dataTypeService)
 			{
 				if(property.Value == null || property.Value.ToString() == "")
@@ -114,6 +149,19 @@ namespace Archetype.PropertyEditors
 				return archetype;
 			}

+            /// <summary>
+            /// A method to deserialize the string value that has been saved in the content editor
+            /// to an object to be stored in the database.
+            /// </summary>
+            /// <param name="editorValue"></param>
+            /// <param name="currentValue">The current value that has been persisted to the database for this editor. This value may be usesful for
+            /// how the value then get's deserialized again to be re-persisted. In most cases it will probably not be used.</param>
+            /// <returns></returns>
+            /// <remarks>
+            /// By default this will attempt to automatically convert the string value to the value type supplied by ValueType.
+            /// If overridden then the object returned must match the type supplied in the ValueType, otherwise persisting the
+            /// value to the DB will fail when it tries to validate the value type.
+            /// </remarks>
 			public override object ConvertEditorToDb(ContentPropertyData editorValue, object currentValue)
 			{
 				if(editorValue.Value == null || editorValue.Value.ToString() == "")
@@ -175,6 +223,11 @@ namespace Archetype.PropertyEditors
 				return archetype.SerializeForPersistence();
 			}

+            /// <summary>
+            /// Gets the property editor.
+            /// </summary>
+            /// <param name="dtd">The DTD.</param>
+            /// <returns></returns>
 			internal virtual PropertyEditor GetPropertyEditor(IDataTypeDefinition dtd)
 			{
 				if(dtd.Id != 0)
@@ -468,7 +468,7 @@ angular.module("umbraco").controller("Imulus.ArchetypeController", function ($sc
        $scope.activeSubmitWatcher++;
        return $scope.activeSubmitWatcher;
    }
-    $scope.submitWatcherOnSubmit = function () {
-        $scope.$broadcast("archetypeFormSubmitting");
+    $scope.submitWatcherOnSubmit = function (args) {
+        $scope.$broadcast("archetypeFormSubmitting", args);
    }
 });
@@ -115,14 +115,16 @@ angular.module("umbraco.directives").directive('archetypeProperty', function ($c
                    });

                    scope.$on('archetypeFormSubmitting', function (ev, args) {
-                        // validate all fieldset properties
-                        _.each(scope.fieldset.properties, function (property) {
-                            archetypeService.validateProperty(scope.fieldset, property, configFieldsetModel);
-                        });
+                        if(args.action !== 'save') {
+                            // validate all fieldset properties
+                            _.each(scope.fieldset.properties, function (property) {
+                                archetypeService.validateProperty(scope.fieldset, property, configFieldsetModel);
+                            });

-                        var validationKey = "validation-f" + scope.fieldsetIndex;
+                            var validationKey = "validation-f" + scope.fieldsetIndex;

-                        ngModelCtrl.$setValidity(validationKey, scope.fieldset.isValid);
+                            ngModelCtrl.$setValidity(validationKey, scope.fieldset.isValid);
+                        }

                        // did the value change (if it did, it most likely did so during the "formSubmitting" event)
                        var property = archetypeService.getFieldsetProperty(scope);
@@ -3,9 +3,10 @@ angular.module("umbraco.directives").directive('archetypeSubmitWatcher', functio
        // call the load callback on scope to obtain the ID of this submit watcher
        var id = scope.loadCallback();
        scope.$on("formSubmitting", function (ev, args) {
+
            // on the "formSubmitting" event, call the submit callback on scope to notify the Archetype controller to do it's magic
            if (id == scope.activeSubmitWatcher) {
-                scope.submitCallback();
+                scope.submitCallback(args);
            }
        });
    }
@@ -21,7 +21,7 @@
                        <i class="icon icon-delete" ng-click="removeRow($index)" ng-show="canRemove()"></i>
                    </div>
                </div>
-                <div class="archetypeCollapser animate-hide" ng-hide="model.config.enableCollapsing && isCollapsed(fieldset)">
+                <div class="archetypeCollapser animate-hide" ng-hide="model.config.enableCollapsing && isCollapsed(fieldset)" ng-if="!isCollapsed(fieldset)">
                    <form class="form-inline">
                        <div ng-class="[('archetype-property-' + property.alias), (getPropertyValidity($parent.$index, property.alias) === false ? 'archetypePropertyError' : '')]" class="archetypeProperty control-group" ng-repeat="property in fieldsetConfigModel.properties">
                            <label ng-hide="model.config.hidePropertyLabels == '1'" class="control-label" for="archetype-property-{{model.alias}}-{{$parent.$index}}-{{$index}}">
@@ -1,6 +1,6 @@
 {
 	"name": "Archetype",
-	"version": "1.11",
+	"version": "1.12.1",
 	"url": "http://github.com/imulus/archetype/",
 	"author": "Imulus - Kevin Giszewski - Tom Fulton - Lee Kelleher - Matt Brailsford - Kenn Jacobsen - Et. Al.",
 	"authorUrl": "http://imulus.com/",
Author	SHA1	Message	Date
kgiszewski	e640a9b4f4	This depends on a core PR.	2015-12-14 09:53:01 -05:00
kgiszewski	bb056a01dd	Update dll to v1.12.1	2015-12-03 08:44:40 -05:00
kgiszewski	608b12aa10	Revert "Fix #304 " This reverts commit `f4e449f030`. Conflicts: app/Umbraco/Umbraco.Archetype/Models/ArchetypeModel.cs	2015-12-03 08:43:23 -05:00
kgiszewski	7e76e98c0f	Bump version to 1.12.0	2015-11-16 13:25:54 -05:00
kgiszewski	f4e449f030	Fix #304	2015-11-16 13:24:36 -05:00
kgiszewski	1e97caa7e8	Merge branch 'pr/303'	2015-11-16 12:50:11 -05:00
leekelleher	b0dcefaf06	Refactored the PublishedContent/Property classes. Streamlines how the properties are stored and retrieved internally, (dictionary is faster than linq loops). Removed the `Initialize` method, as we can do the set-up within the constructor.	2015-11-05 11:58:45 +00:00
kgiszewski	716972bc17	Merge branch 'pr/301'	2015-11-04 15:34:11 -05:00
leekelleher	4d4eab39e8	ArchetypeModel to IPublishedContent Adds extension methods for `ArchetypeModel` and `ArchetypeFieldsetModel` for converting to Umbraco's `IPublishedContent`. Included unit-tests to support the deserialization and verify property-value retrieval. Modifies `ArchetypePropertyModelExtensions.CreateDummyPropertyType` extension method, to test if the `PropertyValueConvertersResolver` is available, (otherwise the unit-tests throw an exception from Umbraco's `PublishedPropertyType`).	2015-11-04 15:43:39 +00:00
kgiszewski	6acaf65ec3	Add missing XML docs.	2015-11-02 11:35:37 -05:00
kgiszewski	a2b2567350	Fix unit tests.	2015-11-02 10:55:02 -05:00
Mark	f5f4e80800	Added "lazy loading" for fieldset properties I've had a big performance problem when loading big child archetypes in an archetype, by adding a ng-if the digest cycle isn't called directly when loading the directive	2015-10-26 10:52:27 +01:00
Mark	b42695bd0d	Merge remote-tracking branch 'imulus/master'	2015-10-26 10:46:19 +01:00
kgiszewski	f405239115	Fixed goofed up packages, bump to v1.11.1	2015-10-08 13:42:19 -04:00