Bump version number to v1.3.0

Fix #168
Merge branch 'master' into pr/166
2014-06-30 10:48:07 -04:00 · 2014-06-30 10:45:48 -04:00 · 2014-06-30 10:39:59 -04:00 · 2014-06-30 09:47:10 -04:00 · 2014-06-28 12:51:36 +02:00 · 2014-06-28 12:42:36 +02:00
58 changed files with 3051 additions and 837 deletions
@@ -222,15 +222,30 @@
    <Compile Include="Models\FieldsetTests.cs" />
    <Compile Include="Properties\AssemblyInfo.cs" />
    <Compile Include="PropertyValueConverter\PropertyValueConverterTests.cs" />
-    <Compile Include="Serialization\ArchetypeJsonConverterComplexModelTest.cs" />
-    <Compile Include="Serialization\ArchetypeJsonConverterTest.cs" />
-    <Compile Include="Serialization\JsonTestStrings.cs" />
-    <Compile Include="Serialization\JsonTestModels.cs" />
+    <Compile Include="Serialization\Base\ArchetypeJsonConverterTestBase.cs" />
+    <Compile Include="Serialization\Base\RegressionTestBase.cs" />
+    <Compile Include="Serialization\Delinter\ArchetypeJsonDelinterTest.cs" />
+    <Compile Include="Serialization\Regression\ArchetypeJsonConverterLegacySetUpTest.cs" />
+    <Compile Include="Serialization\Regression\ArchetypeJsonConverterTest.cs" />
+    <Compile Include="Serialization\Regression\JsonTestLegacyModelSetUp.cs" />
+    <Compile Include="Serialization\Regression\SerializationTestHelper.cs" />
+    <Compile Include="Serialization\Regression\JsonTestModels.cs" />
+    <Compile Include="Serialization\Regression\JsonTestStrings.cs" />
+    <Compile Include="Serialization\UseCases\ArchetypeJsonConverterTest.cs" />
+    <Compile Include="Serialization\UseCases\Complex\ArchetypeJsonConverterTest.cs" />
+    <Compile Include="Serialization\UseCases\Complex\JsonTestModels.cs" />
+    <Compile Include="Serialization\UseCases\Complex\JsonTestStrings.cs" />
+    <Compile Include="Serialization\UseCases\Enumerable\ArchetypeJsonConverterTest.cs" />
+    <Compile Include="Serialization\UseCases\Enumerable\JsonTestModels.cs" />
+    <Compile Include="Serialization\UseCases\Enumerable\JsonTestStrings.cs" />
+    <Compile Include="Serialization\UseCases\JsonTestModels.cs" />
+    <Compile Include="Serialization\UseCases\JsonTestStrings.cs" />
  </ItemGroup>
  <ItemGroup>
    <None Include="app.config" />
    <None Include="Data\sample-1.json" />
    <None Include="packages.config" />
+    <None Include="SupportingFiles\config\umbracoSettings.config" />
  </ItemGroup>
  <ItemGroup>
    <ProjectReference Include="..\Umbraco.Archetype\Archetype.Umbraco.csproj">
@@ -241,6 +256,13 @@
  <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>xcopy  $(ProjectDir)SupportingFiles\config\* $(TargetDir)config /I /O /X /E /K /D /Y</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">
@@ -5,7 +5,9 @@ using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
 using Archetype.PropertyConverters;
+using Archetype.Tests.Serialization.UseCases;
 using NUnit.Framework;
+using Archetype.Tests.Serialization;

 namespace Archetype.Tests.Models
 {
@@ -34,6 +36,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()
        {
@@ -47,6 +61,24 @@ namespace Archetype.Tests.Models
            Assert.That(fieldset.GetValue<string>("blurb") == "A blurb here");
        }

+        [Test]
+        public void Can_Convert_Property_Default_Value_Types() 
+		{
+            var converter = new ArchetypeValueConverter();
+            var result = (Archetype.Models.ArchetypeModel)converter.ConvertDataToSource(null, _sampleJson, false);
+
+            var fieldset = result.Fieldsets.First();
+
+            Assert.That(fieldset.GetValue<int>("noSuchInteger", 1234) == 1234);
+            Assert.That(fieldset.GetValue<bool>("noSuchBoolean", true) == true);
+            Assert.That(fieldset.GetValue<bool>("noSuchBoolean", false) == false);
+            Assert.That(fieldset.GetValue<string>("noSuchString", "noSuchString default value") == "noSuchString default value");
+
+            var contactDetails = fieldset.GetValue<ContactDetails>("noSuchContact", new ContactDetails { Address = "some street, some city", Name = "someone" });
+            Assert.That(contactDetails.Address == "some street, some city");
+            Assert.That(contactDetails.Name == "someone");
+        }
+
        [Test]
        public void Returns_String_When_No_Type_Specified()
        {
@@ -0,0 +1,33 @@
+using Archetype.PropertyConverters;
+using at = Archetype.Models;
+using Newtonsoft.Json;
+
+namespace Archetype.Tests.Serialization.Base
+{
+    public abstract class ArchetypeJsonConverterTestBase
+    {
+        public at.ArchetypeModel ConvertModelToArchetype<T>(T model)
+        {
+            var converter = new ArchetypeValueConverter();
+            var json = JsonConvert.SerializeObject(model);
+            var archetype = (at.ArchetypeModel)converter.ConvertDataToSource(null, json, false);
+            return archetype;
+        }
+
+        public string ConvertModelToArchetypeJson<T>(T model, Formatting formatting = Formatting.None)
+        {
+            return JsonConvert.SerializeObject(model, formatting);
+        }
+
+        public T ConvertArchetypeJsonToModel<T>(string json)
+        {
+            return JsonConvert.DeserializeObject<T>(json);
+        }
+
+        public T ConvertModelToArchetypeAndBack<T>(T model)
+        {
+            var json = ConvertModelToArchetypeJson(model);
+            return ConvertArchetypeJsonToModel<T>(json);
+        }
+    }
+}
@@ -0,0 +1,166 @@
+using System.Collections;
+using System.Linq;
+using System.Reflection;
+using Archetype.Serialization;
+using Moq;
+using Newtonsoft.Json;
+using NUnit.Framework;
+using Umbraco.Core;
+using Umbraco.Core.Persistence;
+using Umbraco.Core.Services;
+
+namespace Archetype.Tests.Serialization.Base
+{
+    public abstract class RegressionTestBase : ArchetypeJsonConverterTestBase
+    {
+        protected void SimpleModel_Regression_Battery<T>(T model)
+        {
+            var archetype = ConvertModelToArchetype(model);
+            Assert.IsNotNull(archetype);
+
+            var archetypeJson = archetype.SerializeForPersistence();
+            var modelJson = ConvertModelToArchetypeJson(model, Formatting.Indented);
+
+            Assert.IsNotNullOrEmpty(modelJson);
+
+            var result = ConvertModelToArchetypeAndBack(model);
+            var resultfromArchetypeJson = ConvertArchetypeJsonToModel<T>(archetypeJson);
+
+            Assert.IsInstanceOf<T>(result);
+            Assert.IsInstanceOf<T>(resultfromArchetypeJson);
+            AssertAreEqual(model, result);
+            AssertAreEqual(model, resultfromArchetypeJson);
+        }
+
+        protected void SimpleModels_Regression_Battery<T>(T model)
+            where T : IList
+        {
+            var archetype = ConvertModelToArchetype(model);
+            Assert.IsNotNull(archetype);
+
+            var archetypeJson = archetype.SerializeForPersistence();
+            var modelJson = ConvertModelToArchetypeJson(model, Formatting.Indented);
+
+            Assert.IsNotNullOrEmpty(modelJson);
+
+            var result = ConvertModelToArchetypeAndBack(model);
+            var resultfromArchetypeJson = ConvertArchetypeJsonToModel<T>(archetypeJson);
+
+            Assert.IsInstanceOf<T>(result);
+            Assert.IsInstanceOf<T>(resultfromArchetypeJson);
+
+            Assert.AreEqual(model.Count, result.Count);
+            Assert.AreEqual(model.Count, resultfromArchetypeJson.Count);
+
+            foreach (var resultItem in result)
+            {
+                var index = result.IndexOf(resultItem);
+                AssertAreEqual(model[index], resultItem);
+            }
+
+            foreach (var resultItem in resultfromArchetypeJson)
+            {
+                var index = resultfromArchetypeJson.IndexOf(resultItem);
+                AssertAreEqual(model[index], resultItem);
+            }
+        }
+
+        protected void CompoundModel_Regression_Battery<T>(T model)
+        {
+            var archetype = ConvertModelToArchetype(model);
+            Assert.IsNotNull(archetype);
+
+            var archetypeJson = archetype.SerializeForPersistence();
+            var modelJson = ConvertModelToArchetypeJson(model, Formatting.Indented);
+
+            Assert.IsNotNullOrEmpty(modelJson);
+
+            var result = ConvertModelToArchetypeAndBack(model);
+            var resultfromArchetypeJson = ConvertArchetypeJsonToModel<T>(archetypeJson);
+
+            Assert.IsInstanceOf<T>(result);
+            AssertAreEqual(model, result);
+
+            Assert.IsInstanceOf<T>(resultfromArchetypeJson);
+            AssertAreEqual(model, resultfromArchetypeJson);
+        }
+
+        protected void NestedModel_Regression_Battery<T>(T model)
+        {
+            CompoundModel_Regression_Battery(model);
+        }
+
+        protected void ComplexModel_Regression_Battery<T>(T model)
+        {
+            CompoundModel_Regression_Battery(model);
+        }
+
+        protected void AssertAreEqual<T>(T model, T result)
+        {
+            foreach (var propInfo in model.GetSerialiazableProperties())
+            {
+                var expected = GetExpectedValue(model, propInfo);
+                var actual = GetActualValue(result, propInfo);
+                
+                if (propInfo.PropertyType.Namespace.Equals("System"))
+                {
+                    Assert.AreEqual(expected, actual);                 
+                    continue;
+                }
+
+                var list = expected as IList;
+                if (list != null)
+                {
+                    foreach (var expectedItem in list)
+                    {
+                        var index = list.IndexOf(expectedItem);
+                        AssertAreEqual(expectedItem, ((IList)actual)[index]);
+                    }
+                    continue;
+                }
+
+                AssertAreEqual(expected, actual);
+            }
+        }
+
+        protected void EnsureUmbracoContext(Mock<IDataTypeService> dataTypeService)
+        {
+            var cacheHelper = CacheHelper.CreateDisabledCacheHelper();
+            var serviceContext = new ServiceContext(
+                Mock.Of<IContentService>(),
+                Mock.Of<IMediaService>(),
+                Mock.Of<IContentTypeService>(),
+                dataTypeService.Object,
+                Mock.Of<IFileService>(),
+                Mock.Of<ILocalizationService>(),
+                Mock.Of<IPackagingService>(),
+                Mock.Of<IEntityService>(),
+                Mock.Of<IRelationService>(),
+                Mock.Of<IMemberGroupService>(),
+                Mock.Of<IMemberTypeService>(),
+                Mock.Of<IMemberService>(),
+                Mock.Of<IUserService>(),
+                Mock.Of<ISectionService>(),
+                Mock.Of<IApplicationTreeService>(),
+                Mock.Of<ITagService>(),
+                Mock.Of<INotificationService>()
+                );
+
+            ApplicationContext.EnsureContext(
+                new DatabaseContext(Mock.Of<IDatabaseFactory>()), serviceContext, cacheHelper, true);
+        }
+
+        private object GetExpectedValue<T>(T expected, PropertyInfo propInfo)
+        {
+            return propInfo.GetValue(expected, null);
+        }
+
+        private object GetActualValue<T>(T actual, PropertyInfo propInfo)
+        {
+            var actualProp = actual.GetSerialiazableProperties().SingleOrDefault(pinfo => pinfo.Name.Equals(propInfo.Name));
+            return actualProp != null
+                ? actualProp.GetValue(actual, null)
+                : null;
+        }
+    }
+}
@@ -0,0 +1,253 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Archetype.PropertyEditors;
+using Archetype.Serialization;
+using Archetype.Tests.Serialization.Base;
+using Moq;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+using NUnit.Framework;
+using Umbraco.Core.Models;
+using Umbraco.Core.Models.Editors;
+using Umbraco.Core.PropertyEditors;
+using Umbraco.Core.Services;
+
+namespace Archetype.Tests.Serialization.Delinter
+{
+    [TestFixture]
+    public class ArchetypeJsonDelinterTest : RegressionTestBase
+    {
+        private const string _ESCAPED_JSON = @"{""fieldsets"":[{""properties"":[{""alias"":""slides"",""value"":""2680""}],""alias"":""slides""},{""properties"":[{""alias"":""captions"",""value"":""{\""fieldsets\"":[{\""properties\"":[{\""alias\"":\""textstring\"",\""value\"":\""test1 test1\""}],\""alias\"":\""textstringArray\""},{\""properties\"":[{\""alias\"":\""textstring\"",\""value\"":\""test2  test2\""}],\""alias\"":\""textstringArray\""},{\""properties\"":[{\""alias\"":\""textstring\"",\""value\"":\""test3b   test3b\""}],\""alias\"":\""textstringArray\""}]}""}],""alias"":""captions""}]}";
+        private const string _JSON = @"{""fieldsets"":[{""properties"":[{""alias"":""slides"",""value"":""2680""}],""alias"":""slides""},{""properties"":[{""alias"":""captions"",""value"":{""fieldsets"":[{""properties"":[{""alias"":""textstring"",""value"":""test1 test1""}],""alias"":""textstringArray""},{""properties"":[{""alias"":""textstring"",""value"":""test2  test2""}],""alias"":""textstringArray""},{""properties"":[{""alias"":""textstring"",""value"":""test3b   test3b""}],""alias"":""textstringArray""}]}}],""alias"":""captions""}]}";
+        private const string _ESCAPED_JSON_DEEP_NESTED = @"{""fieldsets"":[{""properties"":[{""alias"":""pages"",""value"":""""},{""alias"":""captions"",""value"":""{\""fieldsets\"":[{\""properties\"":[{\""alias\"":\""captions\"",\""value\"":\""{\\\""fieldsets\\\"":[{\\\""properties\\\"":[{\\\""alias\\\"":\\\""textString\\\"",\\\""value\\\"":\\\""{\\\\\\\""fieldsets\\\\\\\"":[{\\\\\\\""properties\\\\\\\"":[{\\\\\\\""alias\\\\\\\"":\\\\\\\""textString\\\\\\\"",\\\\\\\""value\\\\\\\"":\\\\\\\""\\\\\\\""}],\\\\\\\""alias\\\\\\\"":\\\\\\\""textItem\\\\\\\""}]}\\\""}],\\\""alias\\\"":\\\""textList\\\""}]}\""}],\""alias\"":\""captions\""}]}""}],""alias"":""pages""}]}";
+        private const string _ESCAPED_JSON_FROM_APP = @"{
+  ""alias"": ""captions"",
+  ""value"": ""{\""fieldsets\"":[{\""properties\"":[{\""alias\"":\""textstring\"",\""value\"":\""test1 test1\""}],\""alias\"":\""textstringArray\""},{\""properties\"":[{\""alias\"":\""textstring\"",\""value\"":\""test2  test2\""}],\""alias\"":\""textstringArray\""},{\""properties\"":[{\""alias\"":\""textstring\"",\""value\"":\""test3b   test3b\""}],\""alias\"":\""textstringArray\""}]}""
+}";
+
+        private SlideShow _referenceModel;
+        private NestedClass _nestedClass;
+
+        [SetUp]
+        public void SetUp()
+        {
+            _referenceModel = new SlideShow()
+            {
+                Slides = "2680",
+                Captions = new Captions()
+                {
+                    new TextString(){Text = "test1 test1"},
+                    new TextString(){Text = "test2  test2"},
+                    new TextString(){Text = "test3b   test3b"}
+                }
+            };
+
+            _nestedClass = GetNestedClass();
+            _nestedClass.SlideShow = _referenceModel;
+            _nestedClass.Nested = GetNestedClass();
+            _nestedClass.Nested.SlideShow = _referenceModel;
+            _nestedClass.Nested.Nested = GetNestedClass();
+
+        }
+
+        [Test]
+        public void Delinter_RemoveNewLine_ByPasses_Values()
+        {
+            const string _JSON_WITH_RESERVED_CHARS = @"{
+  ""alias"": ""captions"",
+  ""value"": ""{   \""fieldsets\"":    [
+{
+              \""properties\"":
+    [
+{          \""alias\"":    \""textstring\""   ,    \""value\"":\""test1 \r\n  test1\r\n\""}],        \""alias\"":\""textstringArray\""    },{\""properties\"":  [   {   \""alias\"":\""textstring\"",\""value\"":\""test2\r\ntest2\""}],\""alias\"":\""textstringArray\""},{\""properties\"":[{\""alias\"":\""textstring\"",\""value\"":\""test3b \""quote\""   \\r\\r\\rtest3\""}],\""alias\"":\""textstringArray\""   }    ]    }""
+}";
+
+            var referenceModel = new Captions()
+            {
+                new TextString() {Text = @"test1 
+  test1
+"},
+                new TextString() {Text = @"test2
+test2"},
+                new TextString() {Text = @"test3b ""quote""   \r\r\rtest3"}
+            };
+
+            var delintedJson = _JSON_WITH_RESERVED_CHARS.DelintArchetypeJson();
+            var actualModel = ConvertArchetypeJsonToModel<Captions>(delintedJson);
+
+            var t = JToken.Parse(delintedJson).ToString(Formatting.None);
+
+            Assert.IsInstanceOf<Captions>(actualModel);
+            Assert.IsNotNull(actualModel);
+
+            Assert.AreEqual(3, actualModel.Count);
+
+            foreach (var refItem in referenceModel)
+            {
+                var index = referenceModel.IndexOf(refItem);
+                AssertAreEqual(refItem, actualModel.ElementAt(index));
+            }
+        }
+
+        [Test]
+        public void ReferenceJsonAndModel_Equal_ExpectedJsonAndModel()
+        {
+            const string expectedJson = _JSON;
+
+            var expectedModel = ConvertArchetypeJsonToModel<SlideShow>(expectedJson);
+            var referenceModel = ConvertModelToArchetypeAndBack(_referenceModel);
+
+            Assert.IsInstanceOf<SlideShow>(expectedModel);
+            Assert.IsInstanceOf<SlideShow>(referenceModel);
+
+            Assert.AreEqual(3, expectedModel.Captions.Count);
+            Assert.AreEqual(3, referenceModel.Captions.Count);
+
+            AssertAreEqual(expectedModel, referenceModel);
+        }
+
+        [Test]
+        public void UnescapedJsonAndModel_Equal_ExpectedJsonAndModel()
+        {
+            const string expectedJson = _JSON;
+            var unescapedJson = _ESCAPED_JSON.DelintArchetypeJson();
+
+            var expectedModel = ConvertArchetypeJsonToModel<SlideShow>(expectedJson);
+            var actualModel = ConvertArchetypeJsonToModel<SlideShow>(unescapedJson);
+
+            Assert.IsInstanceOf<SlideShow>(expectedModel);
+            Assert.IsInstanceOf<SlideShow>(actualModel);
+
+            Assert.AreEqual(3, expectedModel.Captions.Count);
+            Assert.AreEqual(3, actualModel.Captions.Count);
+
+            AssertAreEqual(expectedModel, actualModel);
+        }
+
+        [Test]
+        public void EscapedJson_FromApp_SerializesToModel()
+        {
+            var delintedJson = _ESCAPED_JSON_FROM_APP.DelintArchetypeJson();
+
+            var referenceModel = new Captions()
+            {
+                new TextString() {Text = "test1 test1"},
+                new TextString() {Text = "test2  test2"},
+                new TextString() {Text = "test3b   test3b"}
+            };
+
+            var actualModel = ConvertArchetypeJsonToModel<Captions>(delintedJson);
+
+            Assert.IsInstanceOf<Captions>(actualModel);
+            Assert.AreEqual(3, actualModel.Count);
+
+            foreach (var refItem in referenceModel)
+            {
+                var index = referenceModel.IndexOf(refItem);
+                AssertAreEqual(refItem, actualModel.ElementAt(index));
+            }
+        }
+
+        [Test]
+        public void DeepNestedJson_Escapes_Correctly()
+        {
+            var propGuid = new Guid();
+            var dtd = new DataTypeDefinition(-1, String.Empty) { Id = 0 };
+
+            var dataTypeService = new Mock<IDataTypeService>();
+            dataTypeService.Setup(dts => dts.GetDataTypeDefinitionById(Guid.Parse(propGuid.ToString()))).Returns(dtd);
+            dataTypeService.Setup(dts => dts.GetPreValuesCollectionByDataTypeId(dtd.Id)).Returns(new PreValueCollection(new Dictionary<string, PreValue>()));
+
+            var propValueEditor = new Mock<ArchetypePropertyEditor.ArchetypePropertyValueEditor>(new PropertyValueEditor());
+            propValueEditor.Setup(pe => pe.GetPropertyEditor(dtd)).Returns(new ArchetypePropertyEditor());
+
+            var archetype = ConvertModelToArchetype(_nestedClass);
+
+            foreach (var prop in archetype.Fieldsets.SelectMany(fs => fs.Properties))
+            {
+                prop.DataTypeGuid = propGuid.ToString();
+                if (prop.Value.ToString().Contains("fieldsets"))
+                    prop.PropertyEditorAlias = Constants.PropertyEditorAlias;
+            }
+
+            var archetypeJson = JsonConvert.SerializeObject(archetype);
+            Assert.IsNotNullOrEmpty(archetypeJson);
+
+            EnsureUmbracoContext(dataTypeService);
+
+            var propEditor = new ArchetypePropertyEditor.ArchetypePropertyValueEditor(new PropertyValueEditor());
+            var convertedJson = propEditor.ConvertEditorToDb(new ContentPropertyData(JObject.FromObject(archetype),
+                new PreValueCollection(new Dictionary<string, PreValue>()), new Dictionary<string, object>()),
+                archetypeJson);
+
+            Assert.IsNotNull(convertedJson);
+
+            var delintedJson = convertedJson.ToString().DelintArchetypeJson();
+            Assert.IsNotNullOrEmpty(delintedJson);
+
+            var modelfromArchetypeJson = ConvertArchetypeJsonToModel<NestedClass>(archetypeJson);
+            var modelfromConvertedJson = ConvertArchetypeJsonToModel<NestedClass>(delintedJson);
+
+            Assert.IsInstanceOf<NestedClass>(modelfromArchetypeJson);
+            Assert.IsInstanceOf<NestedClass>(modelfromConvertedJson);
+
+            Assert.AreEqual(3, modelfromArchetypeJson.SlideShow.Captions.Count);
+            Assert.AreEqual(3, modelfromConvertedJson.SlideShow.Captions.Count);
+
+            Assert.AreEqual(3, modelfromArchetypeJson.Nested.SlideShow.Captions.Count);
+            Assert.AreEqual(3, modelfromConvertedJson.Nested.SlideShow.Captions.Count);
+
+            AssertAreEqual(modelfromArchetypeJson, modelfromConvertedJson);
+
+        }
+
+        #region private methods
+
+        private NestedClass GetNestedClass()
+        {
+            return new NestedClass();
+        }
+
+        #endregion
+
+        #region classes
+
+        [AsArchetype("slides")]
+        [JsonConverter(typeof(ArchetypeJsonConverter))]
+        public class SlideShow
+        {
+            [JsonProperty("slides")]
+            public string Slides { get; set; }
+            [AsFieldset]
+            [JsonProperty("captions")]
+            public Captions Captions { get; set; }
+        }
+
+        [AsArchetype("textstringArray")] /* Note: when inheriting from a list, archetype alias is not used */
+        [JsonConverter(typeof(ArchetypeJsonConverter))]
+        public class Captions : List<TextString>
+        {
+        }
+
+        [AsArchetype("textstringArray")] /* due to hard coded string calues above, must have same archetype alias as list class */
+        [JsonConverter(typeof(ArchetypeJsonConverter))]
+        public class TextString
+        {
+            [JsonProperty("textstring")]
+            public String Text { get; set; }
+        }
+
+        [AsArchetype("nestedClass")]
+        [JsonConverter(typeof(ArchetypeJsonConverter))]
+        public class NestedClass
+        {
+            [JsonProperty("nestedClass")]
+            public NestedClass Nested { get; set; }
+            [JsonProperty("slides")]
+            public SlideShow SlideShow { get; set; }
+        }
+
+        #endregion
+    }
+}
@@ -0,0 +1,25 @@
+using System.Linq;
+using Newtonsoft.Json;
+using NUnit.Framework;
+
+namespace Archetype.Tests.Serialization.Regression
+{
+    [TestFixture]
+    public class ArchetypeJsonConverterLegacySetUpTest
+    {
+        [Test]
+        public void Deserialize_SlideShow_FromArchetype()
+        {
+            var result = JsonConvert.DeserializeObject<SlideShow>(JsonTestStrings._SLIDES_JSON);
+
+            Assert.NotNull(result);
+            Assert.IsInstanceOf<SlideShow>(result);
+
+            Assert.AreEqual("1,2,3,4,5", result.Slides);
+            Assert.AreEqual("Test 1", result.Captions.TextStringArray.ElementAt(0).Text);
+            Assert.AreEqual("Test 2", result.Captions.TextStringArray.ElementAt(1).Text);
+            Assert.AreEqual("Test 3", result.Captions.TextStringArray.ElementAt(2).Text);
+            Assert.AreEqual("Test 4", result.Captions.TextStringArray.ElementAt(3).Text);
+        }
+    }
+}
@@ -0,0 +1,150 @@
+using Archetype.Tests.Serialization.Base;
+using Newtonsoft.Json;
+using NUnit.Framework;
+
+namespace Archetype.Tests.Serialization.Regression
+{
+    [TestFixture]
+    public class ArchetypeJsonConverterTest : RegressionTestBase
+    {
+        private SerializationTestHelper _testHelper;
+
+        [SetUp]
+        public void SetUp()
+        {
+            _testHelper = new SerializationTestHelper();
+        }
+
+        [Test]
+        public void EmptyArray_Returns_Null()
+        {
+            var archetypeJson = @"{""fieldsets"": []}";
+            var result = ConvertArchetypeJsonToModel<SimpleModel>(archetypeJson);
+
+            Assert.IsNull(result);
+        }
+        
+        [Test]
+        public void SimpleModel_Regression_Battery()
+        {
+            var simpleModel = _testHelper.GetModel<SimpleModel>();
+            SimpleModel_Regression_Battery(simpleModel);
+
+            var json = ConvertModelToArchetypeJson(simpleModel, Formatting.Indented);
+            Assert.AreEqual(JsonTestStrings._SIMPLE_JSON, json);
+        }
+
+        [Test]
+        public void SimpleModelWithFieldsets_Regression_Battery()
+        {
+            var simpleModel = _testHelper.GetModel<SimpleModelWithFieldsets>();
+            SimpleModel_Regression_Battery(simpleModel);
+        }
+
+        [Test]
+        public void SimpleModelWithMixedFieldsets_Regression_Battery()
+        {
+            var simpleModel = _testHelper.GetModel<SimpleModelWithMixedFieldsets>();
+            SimpleModel_Regression_Battery(simpleModel);
+        }
+
+        [Test]
+        public void SimpleModels_Regression_Battery()
+        {
+            var simpleModels = _testHelper.GetModel<SimpleModels>();
+            SimpleModels_Regression_Battery(simpleModels);
+        }
+
+        [Test]
+        public void SimpleModelsWithFieldsets_Regression_Battery()
+        {
+            var simpleModels = _testHelper.GetModel<SimpleModelsWithFieldsets>();
+            SimpleModels_Regression_Battery(simpleModels);
+        }
+
+        [Test]
+        public void SimpleModelsWithMixedFieldsets_Regression_Battery()
+        {
+            var simpleModels = _testHelper.GetModel<SimpleModelsWithMixedFieldsets>();
+            SimpleModels_Regression_Battery(simpleModels);
+        }
+
+        [Test]
+        public void CompoundModel_Regression_Battery()
+        {
+            var compoundModel = _testHelper.GetModel<CompoundModel>();
+            CompoundModel_Regression_Battery(compoundModel);
+        }
+
+        [Test]
+        public void CompoundModelWithMixedFieldsetVariant1_Regression_Battery()
+        {
+            var compoundModel = _testHelper.GetModel<CompoundModelWithMixedFieldsetVariant1>();
+            CompoundModel_Regression_Battery(compoundModel);
+        }
+
+        [Test]
+        public void CompoundModelWithMixedFieldsetVariant2_Regression_Battery()
+        {
+            var compoundModel = _testHelper.GetModel<CompoundModelWithMixedFieldsetVariant2>();
+            CompoundModel_Regression_Battery(compoundModel);
+        }
+
+        [Test]
+        public void CompoundModelWithFieldset_Regression_Battery()
+        {
+            var compoundModel = _testHelper.GetModel<CompoundModelWithFieldset>();
+            CompoundModel_Regression_Battery(compoundModel);
+        }
+
+        [Test]
+        public void CompoundModelWithList_Regression_Battery()
+        {
+            var compoundModelWithList = _testHelper.GetModel<CompoundModelWithList>();
+            CompoundModel_Regression_Battery(compoundModelWithList);
+        }
+
+        [Test]
+        public void CompoundModelWithMixedFieldsetWithList_Regression_Battery()
+        {
+            var compoundModelWithList = _testHelper.GetModel<CompoundModelWithMixedFieldsetWithList>();
+            CompoundModel_Regression_Battery(compoundModelWithList);
+        }
+
+        [Test]
+        public void CompoundModelWithFieldsetWithList_Regression_Battery()
+        {
+            var compoundModelWithList = _testHelper.GetModel<CompoundModelWithFieldsetWithList>();
+            CompoundModel_Regression_Battery(compoundModelWithList);
+        }
+
+        [Test]
+        public void NestedModel_Regression_Battery()
+        {
+            var nestedModel = _testHelper.GetModel<NestedModel>();
+            NestedModel_Regression_Battery(nestedModel);
+        }
+
+        [Test]
+        public void NestedModelWithMixedFieldset_Regression_Battery()
+        {
+            var nestedModel = _testHelper.GetModel<NestedModelWithMixedFieldset>();
+            NestedModel_Regression_Battery(nestedModel);
+        }
+
+        [Test]
+        public void NestedModelWithFieldset_Regression_Battery()
+        {
+            var nestedModel = _testHelper.GetModel<NestedModelWithFieldset>();
+            NestedModel_Regression_Battery(nestedModel);
+        }
+
+        [Test]
+        public void ComplexModel_Regression_Battery()
+        {
+            var complexModel = _testHelper.GetModel<ComplexModel>();
+            NestedModel_Regression_Battery(complexModel);
+        }
+
+    }
+}
@@ -0,0 +1,41 @@
+using System;
+using System.Collections.Generic;
+using Archetype.Serialization;
+using Newtonsoft.Json;
+
+namespace Archetype.Tests.Serialization.Regression
+{
+    [AsArchetype("textstringArray")]
+    [JsonConverter(typeof(ArchetypeJsonConverter))]
+    public class TextString
+    {
+        [JsonProperty("textstring")]
+        public String Text { get; set; }
+    }
+
+    [AsArchetype("textstringArray")]
+    [JsonConverter(typeof(ArchetypeJsonConverter))]
+    public class TextStringArray : List<TextString>
+    {
+
+    }
+
+    [AsArchetype("captions")]
+    [JsonConverter(typeof(ArchetypeJsonConverter))]
+    public class Captions
+    {
+        [JsonProperty("captions")]
+        public TextStringArray TextStringArray { get; set; }
+    }
+
+    [AsArchetype("slides")]
+    [JsonConverter(typeof(ArchetypeJsonConverter))]
+    public class SlideShow
+    {
+        [JsonProperty("slides")]
+        public string Slides { get; set; }
+        [AsFieldset]
+        [JsonProperty("captions")]
+        public Captions Captions { get; set; }
+    }
+}
@@ -0,0 +1,257 @@
+using System;
+using System.Collections.Generic;
+using Archetype.Serialization;
+using Newtonsoft.Json;
+
+namespace Archetype.Tests.Serialization.Regression
+{
+    [AsArchetype("simpleModel")]
+    [JsonConverter(typeof(ArchetypeJsonConverter))]
+    public class SimpleModel
+    {
+        [JsonProperty("text")]        
+        public String Text { get; set; }
+        [JsonProperty("integer")]
+        public int Id { get; set; }
+        [JsonProperty("nullableInteger")]
+        public int? NullableId { get; set; }
+        [JsonProperty("double")]
+        public double Amount { get; set; }
+        [JsonProperty("nullableDouble")]
+        public double? NullableAmount { get; set; }
+        [JsonProperty("dateTime")]
+        public DateTime DateOne { get; set; }
+        [JsonProperty("nullableDateTime")]
+        public DateTime? DateTwo { get; set; }
+    }
+
+    [AsArchetype("simpleModel")]
+    [JsonConverter(typeof(ArchetypeJsonConverter))]
+    public class SimpleModelWithFieldsets
+    {
+        [AsFieldset]
+        [JsonProperty("text")]
+        public string Text { get; set; }
+        [AsFieldset]
+        [JsonProperty("integer")]
+        public int Id { get; set; }
+        [AsFieldset]
+        [JsonProperty("nullableInteger")]
+        public int? NullableId { get; set; }
+        [AsFieldset]
+        [JsonProperty("double")]
+        public double Amount { get; set; }
+        [AsFieldset]
+        [JsonProperty("nullableDouble")]
+        public double? NullableAmount { get; set; }
+        [AsFieldset]
+        [JsonProperty("dateTime")]
+        public DateTime DateOne { get; set; }
+        [AsFieldset]
+        [JsonProperty("nullableDateTime")]
+        public DateTime? DateTwo { get; set; }
+    }
+
+    [AsArchetype("simpleModel")]
+    [JsonConverter(typeof(ArchetypeJsonConverter))]
+    public class SimpleModelWithMixedFieldsets
+    {
+        [AsFieldset]
+        [JsonProperty("text")]
+        public string Text { get; set; }
+        [JsonProperty("integer")]
+        public int Id { get; set; }
+        [AsFieldset]
+        [JsonProperty("nullableInteger")]
+        public int? NullableId { get; set; }
+        [JsonProperty("double")]
+        public double Amount { get; set; }
+        [AsFieldset]
+        [JsonProperty("nullableDouble")]
+        public double? NullableAmount { get; set; }
+        [AsFieldset]
+        [JsonProperty("dateTime")]
+        public DateTime DateOne { get; set; }
+        public DateTime? DateTwo { get; set; }
+    }
+
+    [AsArchetype("simpleModels")]
+    [JsonConverter(typeof(ArchetypeJsonConverter))]
+    public class SimpleModels : List<SimpleModel>
+    {
+    }
+
+    [AsArchetype("simpleModels")]
+    [JsonConverter(typeof(ArchetypeJsonConverter))]
+    public class SimpleModelsWithFieldsets : List<SimpleModelWithFieldsets>
+    {
+    }
+
+    [AsArchetype("simpleModels")]
+    [JsonConverter(typeof(ArchetypeJsonConverter))]
+    public class SimpleModelsWithMixedFieldsets : List<SimpleModelWithMixedFieldsets>
+    {
+    }
+
+    [AsArchetype("compoundModel")]
+    [JsonConverter(typeof(ArchetypeJsonConverter))]
+    public class CompoundModel
+    {
+        [JsonProperty("simpleModel")]
+        public SimpleModel SimpleModel { get; set; }
+        [JsonProperty("text")]
+        public String Text { get; set; }
+        [JsonProperty("integer")]
+        public int Id { get; set; }
+    }
+
+    [AsArchetype("compoundModelWithMixedFieldset")]
+    [JsonConverter(typeof(ArchetypeJsonConverter))]
+    public class CompoundModelWithMixedFieldsetVariant1
+    {
+        [AsFieldset]
+        [JsonProperty("simpleModel")]
+        public SimpleModel SimpleModel { get; set; }
+        [JsonProperty("text")]
+        public String Text { get; set; }
+        [JsonProperty("integer")]
+        public int Id { get; set; }
+    }
+
+    [AsArchetype("compoundModelWithMixedFieldset")]
+    [JsonConverter(typeof(ArchetypeJsonConverter))]
+    public class CompoundModelWithMixedFieldsetVariant2
+    {        
+        [JsonProperty("simpleModel")]
+        public SimpleModel SimpleModel { get; set; }
+        [AsFieldset]
+        [JsonProperty("text")]
+        public String Text { get; set; }
+        [AsFieldset]
+        [JsonProperty("integer")]
+        public int Id { get; set; }
+    }
+
+    [AsArchetype("compoundModel")]
+    [JsonConverter(typeof(ArchetypeJsonConverter))]
+    public class CompoundModelWithFieldset
+    {
+        [AsFieldset]
+        [JsonProperty("simpleModel")]
+        public SimpleModel SimpleModel { get; set; }
+        [AsFieldset]
+        [JsonProperty("text")]
+        public String Text { get; set; }
+        [AsFieldset]
+        [JsonProperty("integer")]
+        public int Id { get; set; }
+    }
+
+    [AsArchetype("compoundModelWithList")]
+    [JsonConverter(typeof(ArchetypeJsonConverter))]
+    public class CompoundModelWithList
+    {
+        [JsonProperty("simpleModelList")]
+        public List<SimpleModel> SimpleModelList { get; set; }
+        [JsonProperty("text")]
+        public String Text { get; set; }
+        [JsonProperty("integer")]
+        public int Id { get; set; }
+    }
+
+    [AsArchetype("compoundModelWithList")]
+    [JsonConverter(typeof(ArchetypeJsonConverter))]
+    public class CompoundModelWithMixedFieldsetWithList
+    {
+        [JsonProperty("simpleModelList")]
+        public List<SimpleModel> SimpleModelList { get; set; }
+        [AsFieldset]
+        [JsonProperty("text")]
+        public String Text { get; set; }
+        [JsonProperty("integer")]
+        public int Id { get; set; }
+    }
+
+    [AsArchetype("compoundModelWithList")]
+    [JsonConverter(typeof(ArchetypeJsonConverter))]
+    public class CompoundModelWithFieldsetWithList
+    {
+        [AsFieldset]
+        [JsonProperty("simpleModelList")]
+        public List<SimpleModel> SimpleModelList { get; set; }
+        [AsFieldset]
+        [JsonProperty("text")]
+        public String Text { get; set; }
+        [AsFieldset]
+        [JsonProperty("integer")]
+        public int Id { get; set; }
+    }
+
+    [AsArchetype("nestedModel")]
+    [JsonConverter(typeof(ArchetypeJsonConverter))]
+    public class NestedModel
+    {
+        [JsonProperty("compoundModel")]
+        public CompoundModel CompoundModel { get; set; }
+        [JsonProperty("simpleModel")]
+        public SimpleModel SimpleModel { get; set; }
+        [JsonProperty("text")]
+        public String Text { get; set; }
+        [JsonProperty("integer")]
+        public int Id { get; set; }
+    }
+
+    [AsArchetype("nestedModel")]
+    [JsonConverter(typeof(ArchetypeJsonConverter))]
+    public class NestedModelWithMixedFieldset
+    {
+        [JsonProperty("compoundModel")]
+        public CompoundModel CompoundModel { get; set; }
+        [AsFieldset]
+        [JsonProperty("simpleModel")]
+        public SimpleModel SimpleModel { get; set; }
+        [JsonProperty("text")]
+        public String Text { get; set; }
+        [AsFieldset]
+        [JsonProperty("integer")]
+        public int Id { get; set; }
+    }
+
+    [AsArchetype("nestedModel")]
+    [JsonConverter(typeof(ArchetypeJsonConverter))]
+    public class NestedModelWithFieldset
+    {
+        [AsFieldset]
+        [JsonProperty("compoundModel")]
+        public CompoundModel CompoundModel { get; set; }
+        [AsFieldset]
+        [JsonProperty("simpleModel")]
+        public SimpleModel SimpleModel { get; set; }
+        [AsFieldset]
+        [JsonProperty("text")]
+        public String Text { get; set; }
+        [AsFieldset]
+        [JsonProperty("integer")]
+        public int Id { get; set; }
+    }
+
+    [AsArchetype("complexModel")]
+    [JsonConverter(typeof(ArchetypeJsonConverter))]
+    public class ComplexModel
+    {
+        [JsonProperty("compoundModels")]
+        public CompoundModelWrapper CompoundModelWrapper { get; set; }
+        [JsonProperty("text")]
+        public String Text { get; set; }
+    }
+
+    [AsArchetype("compoundModelWrapper")]
+    [JsonConverter(typeof(ArchetypeJsonConverter))]
+    public class CompoundModelWrapper
+    {
+        [JsonProperty("compoundModels")]
+        public List<CompoundModel> CompoundModels { get; set; }
+        [JsonProperty("text")]
+        public String Text { get; set; }
+    }
+}
@@ -0,0 +1,124 @@
+namespace Archetype.Tests.Serialization.Regression
+{
+    public class JsonTestStrings
+    {
+        public const string _SIMPLE_JSON = @"{
+  ""fieldsets"": [
+    {
+      ""alias"": ""simpleModel"",
+      ""properties"": [
+        {
+          ""alias"": ""text"",
+          ""value"": ""Test \r\nText \""quote\"" \r\n""
+        },
+        {
+          ""alias"": ""integer"",
+          ""value"": ""123""
+        },
+        {
+          ""alias"": ""nullableInteger"",
+          ""value"": """"
+        },
+        {
+          ""alias"": ""double"",
+          ""value"": ""5.67""
+        },
+        {
+          ""alias"": ""nullableDouble"",
+          ""value"": """"
+        },
+        {
+          ""alias"": ""dateTime"",
+          ""value"": ""01/01/2000 00:00:00""
+        },
+        {
+          ""alias"": ""nullableDateTime"",
+          ""value"": """"
+        }
+      ]
+    }
+  ]
+}";
+        public const string _ESCAPED_JSON =
+@"{
+   ""fieldsets"":[
+      {
+         ""properties"":[
+            {
+               ""alias"":""pages"",
+               ""value"":""2439,2440,2441,2442,2443,2444,2445,2446,2447,2448,2449,2450,2451,2452,2453""
+            },
+            {
+               ""alias"":""captions"",
+               ""value"":""{\""fieldsets\"":[{\""properties\"":[{\""alias\"":\""captions\"",\""value\"":\""{\\\""fieldsets\\\"":[{\\\""properties\\\"":[{\\\""alias\\\"":\\\""textString\\\"",\\\""value\\\"":\\\""{\\\\\\\""fieldsets\\\\\\\"":[{\\\\\\\""properties\\\\\\\"":[{\\\\\\\""alias\\\\\\\"":\\\\\\\""textString\\\\\\\"",\\\\\\\""value\\\\\\\"":\\\\\\\""First Page\\\\\\\"",\\\\\\\""propertyEditorAlias\\\\\\\"":\\\\\\\""Umbraco.Textbox\\\\\\\"",\\\\\\\""dataTypeId\\\\\\\"":-88,\\\\\\\""dataTypeGuid\\\\\\\"":\\\\\\\""0cc0eba1-9960-42c9-bf9b-60e150b429ae\\\\\\\""}],\\\\\\\""alias\\\\\\\"":\\\\\\\""textItem\\\\\\\""}]}\\\"",\\\""propertyEditorAlias\\\"":\\\""Imulus.Archetype\\\"",\\\""dataTypeId\\\"":3764,\\\""dataTypeGuid\\\"":\\\""496cfe35-448f-4b59-9c75-050798afdce4\\\""}],\\\""alias\\\"":\\\""textList\\\""},{\\\""properties\\\"":[{\\\""alias\\\"":\\\""textString\\\"",\\\""value\\\"":\\\""{\\\\\\\""fieldsets\\\\\\\"":[{\\\\\\\""properties\\\\\\\"":[{\\\\\\\""alias\\\\\\\"":\\\\\\\""textString\\\\\\\"",\\\\\\\""value\\\\\\\"":\\\\\\\""Second Page\\\\\\\"",\\\\\\\""propertyEditorAlias\\\\\\\"":\\\\\\\""Umbraco.Textbox\\\\\\\"",\\\\\\\""dataTypeId\\\\\\\"":-88,\\\\\\\""dataTypeGuid\\\\\\\"":\\\\\\\""0cc0eba1-9960-42c9-bf9b-60e150b429ae\\\\\\\""}],\\\\\\\""alias\\\\\\\"":\\\\\\\""textItem\\\\\\\""}]}\\\"",\\\""propertyEditorAlias\\\"":\\\""Imulus.Archetype\\\"",\\\""dataTypeId\\\"":3764,\\\""dataTypeGuid\\\"":\\\""496cfe35-448f-4b59-9c75-050798afdce4\\\""}],\\\""alias\\\"":\\\""textList\\\""},{\\\""properties\\\"":[{\\\""alias\\\"":\\\""textString\\\"",\\\""value\\\"":\\\""{\\\\\\\""fieldsets\\\\\\\"":[{\\\\\\\""properties\\\\\\\"":[{\\\\\\\""alias\\\\\\\"":\\\\\\\""textString\\\\\\\"",\\\\\\\""value\\\\\\\"":\\\\\\\""Third Page\\\\\\\"",\\\\\\\""propertyEditorAlias\\\\\\\"":\\\\\\\""Umbraco.Textbox\\\\\\\"",\\\\\\\""dataTypeId\\\\\\\"":-88,\\\\\\\""dataTypeGuid\\\\\\\"":\\\\\\\""0cc0eba1-9960-42c9-bf9b-60e150b429ae\\\\\\\""}],\\\\\\\""alias\\\\\\\"":\\\\\\\""textItem\\\\\\\""}]}\\\"",\\\""propertyEditorAlias\\\"":\\\""Imulus.Archetype\\\"",\\\""dataTypeId\\\"":3764,\\\""dataTypeGuid\\\"":\\\""496cfe35-448f-4b59-9c75-050798afdce4\\\""}],\\\""alias\\\"":\\\""textList\\\""},{\\\""properties\\\"":[{\\\""alias\\\"":\\\""textString\\\"",\\\""value\\\"":\\\""{\\\\\\\""fieldsets\\\\\\\"":[{\\\\\\\""properties\\\\\\\"":[{\\\\\\\""alias\\\\\\\"":\\\\\\\""textString\\\\\\\"",\\\\\\\""value\\\\\\\"":\\\\\\\""Fourth Page\\\\\\\"",\\\\\\\""propertyEditorAlias\\\\\\\"":\\\\\\\""Umbraco.Textbox\\\\\\\"",\\\\\\\""dataTypeId\\\\\\\"":-88,\\\\\\\""dataTypeGuid\\\\\\\"":\\\\\\\""0cc0eba1-9960-42c9-bf9b-60e150b429ae\\\\\\\""}],\\\\\\\""alias\\\\\\\"":\\\\\\\""textItem\\\\\\\""}]}\\\"",\\\""propertyEditorAlias\\\"":\\\""Imulus.Archetype\\\"",\\\""dataTypeId\\\"":3764,\\\""dataTypeGuid\\\"":\\\""496cfe35-448f-4b59-9c75-050798afdce4\\\""}],\\\""alias\\\"":\\\""textList\\\""}]}\"",\""propertyEditorAlias\"":\""Imulus.Archetype\"",\""dataTypeId\"":3765,\""dataTypeGuid\"":\""4ed439b3-0ee7-447a-a64e-b2b486b86379\""}],\""alias\"":\""captions\""}]}""
+            }
+         ],
+         ""alias"":""pages""
+      }
+   ]
+}";
+
+        public const string _SLIDES_JSON =
+                    @"{
+  ""fieldsets"": [
+    {
+      ""alias"": ""captions"",
+      ""properties"": [
+        {
+          ""alias"": ""captions"",
+          ""value"": {
+            ""fieldsets"": [
+              {
+                ""alias"": ""textstringArray"",
+                ""properties"": [
+                  {
+                    ""alias"": ""textstring"",
+                    ""value"": ""Test 1""
+                  }
+                ]
+              },
+              {
+                ""alias"": ""textstringArray"",
+                ""properties"": [
+                  {
+                    ""alias"": ""textstring"",
+                    ""value"": ""Test 2""
+                  }
+                ]
+              },
+              {
+                ""alias"": ""textstringArray"",
+                ""properties"": [
+                  {
+                    ""alias"": ""textstring"",
+                    ""value"": ""Test 3""
+                  }
+                ]
+              },
+              {
+                ""alias"": ""textstringArray"",
+                ""properties"": [
+                  {
+                    ""alias"": ""textstring"",
+                    ""value"": ""Test 4""
+                  }
+                ]
+              }
+            ]
+          }
+        }
+      ]
+    },
+    {
+      ""alias"": ""slides"",
+      ""properties"": [
+        {
+          ""alias"": ""slides"",
+          ""value"": ""1,2,3,4,5""
+        }
+      ]
+    }
+  ]
+}";
+    }
+}
@@ -0,0 +1,220 @@
+using System;
+using System.Collections.Generic;
+
+namespace Archetype.Tests.Serialization.Regression
+{       
+    public class SerializationTestHelper
+    {
+        public T GetModel<T>()
+        {
+            try
+            {
+                return (T)GetType().GetMethod("Get" + typeof(T).Name).Invoke(this, null);
+            }
+            catch
+            {
+                return default(T);                
+            }
+        }        
+        
+        public SimpleModel GetSimpleModel()
+        {
+            return new SimpleModel
+            {
+                Amount = 5.67,
+                NullableAmount = null,
+                DateOne = new DateTime(2000, 1, 1),
+                DateTwo = null,
+                Id = 123,
+                NullableId = null,
+                Text = @"Test 
+Text ""quote"" 
+"
+            };
+        }
+
+        public SimpleModelWithFieldsets GetSimpleModelWithFieldsets()
+        {
+            return new SimpleModelWithFieldsets
+            {
+                Amount = 5.67,
+                NullableAmount = null,
+                DateOne = new DateTime(2000, 1, 1),
+                DateTwo = null,
+                Id = 123,
+                NullableId = null,
+                Text = "Test Text"
+            };
+        }
+
+        public SimpleModelWithMixedFieldsets GetSimpleModelWithMixedFieldsets()
+        {
+            return new SimpleModelWithMixedFieldsets
+            {
+                Amount = 5.67,
+                NullableAmount = null,
+                DateOne = new DateTime(2000, 1, 1),
+                DateTwo = null,
+                Id = 123,
+                NullableId = null,
+                Text = "Test Text"
+            };
+        }
+
+        public SimpleModels GetSimpleModels()
+        {
+            return new SimpleModels
+            {
+                GetSimpleModel(),
+                GetSimpleModel(),
+                GetSimpleModel()
+            };
+        }
+
+        public SimpleModelsWithFieldsets GetSimpleModelsWithFieldsets()
+        {
+            return new SimpleModelsWithFieldsets
+            {
+                GetSimpleModelWithFieldsets(),
+                GetSimpleModelWithFieldsets(),
+                GetSimpleModelWithFieldsets()
+            };
+        }
+
+        public SimpleModelsWithMixedFieldsets GetSimpleModelsWithMixedFieldsets()
+        {
+            return new SimpleModelsWithMixedFieldsets
+            {
+                GetSimpleModelWithMixedFieldsets(),
+                GetSimpleModelWithMixedFieldsets(),
+                GetSimpleModelWithMixedFieldsets()
+            };
+        }
+
+        public CompoundModel GetCompoundModel()
+        {
+            return new CompoundModel
+            {
+                Id = -1,
+                SimpleModel = GetModel<SimpleModel>(),
+                Text = typeof(CompoundModel).Name
+            };
+        }
+
+        public CompoundModelWithMixedFieldsetVariant1 GetCompoundModelWithMixedFieldsetVariant1()
+        {
+            return new CompoundModelWithMixedFieldsetVariant1
+            {
+                Id = -1,
+                SimpleModel = GetModel<SimpleModel>(),
+                Text = typeof(CompoundModelWithMixedFieldsetVariant1).Name
+            };
+        }
+
+        public CompoundModelWithMixedFieldsetVariant2 GetCompoundModelWithMixedFieldsetVariant2()
+        {
+            return new CompoundModelWithMixedFieldsetVariant2
+            {
+                Id = -1,
+                SimpleModel = GetModel<SimpleModel>(),
+                Text = typeof(CompoundModelWithMixedFieldsetVariant2).Name
+            };
+        }
+
+        public CompoundModelWithFieldset GetCompoundModelWithFieldset()
+        {
+            return new CompoundModelWithFieldset
+            {
+                Id = -1,
+                SimpleModel = GetModel<SimpleModel>(),
+                Text = typeof(CompoundModelWithFieldset).Name
+            };
+        }
+
+        public CompoundModelWithList GetCompoundModelWithList()
+        {
+            return new CompoundModelWithList
+            {
+                Id = 10,
+                SimpleModelList = GetModel<SimpleModels>(),
+                Text = typeof(CompoundModelWithList).Name
+            };
+        }
+
+        public CompoundModelWithMixedFieldsetWithList GetCompoundModelWithMixedFieldsetWithList()
+        {
+            return new CompoundModelWithMixedFieldsetWithList
+            {
+                Id = 11,
+                SimpleModelList = GetModel<SimpleModels>(),
+                Text = typeof(CompoundModelWithMixedFieldsetWithList).Name
+            };
+        }
+
+        public CompoundModelWithFieldsetWithList GetCompoundModelWithFieldsetWithList()
+        {
+            return new CompoundModelWithFieldsetWithList
+            {
+                Id = 12,
+                SimpleModelList = GetModel<SimpleModels>(),
+                Text = typeof(CompoundModelWithFieldsetWithList).Name
+            };
+        }
+
+        public NestedModel GetNestedModel()
+        {
+            return new NestedModel
+            {
+                CompoundModel = GetModel<CompoundModel>(),
+                Id = 53,
+                SimpleModel = GetModel<SimpleModel>(),
+                Text = typeof(NestedModel).Name
+            };
+        }
+
+        public NestedModelWithMixedFieldset GetNestedModelWithMixedFieldset()
+        {
+            return new NestedModelWithMixedFieldset
+            {
+                CompoundModel = GetModel<CompoundModel>(),
+                Id = 54,
+                SimpleModel = GetModel<SimpleModel>(),
+                Text = typeof(NestedModelWithMixedFieldset).Name
+            };
+        }
+
+        public NestedModelWithFieldset GetNestedModelWithFieldset()
+        {
+            return new NestedModelWithFieldset
+            {
+                CompoundModel = GetModel<CompoundModel>(),
+                Id = 55,
+                SimpleModel = GetModel<SimpleModel>(),
+                Text = typeof(NestedModelWithFieldset).Name
+            };
+        }
+
+        public CompoundModelWrapper GetCompoundModelWrapper()
+        {
+            return new CompoundModelWrapper
+            {
+                CompoundModels = new List<CompoundModel>
+                {
+                    GetModel<CompoundModel>(),
+                    GetModel<CompoundModel>(),
+                    GetModel<CompoundModel>()
+                },
+                Text = typeof(CompoundModelWrapper).Name
+            };
+        }
+
+        public ComplexModel GetComplexModel()
+        {
+            return new ComplexModel
+            {
+                CompoundModelWrapper = GetModel<CompoundModelWrapper>(),
+                Text = typeof(ComplexModel).Name
+            };
+        }
+    }
+}
@@ -1,12 +1,12 @@
 using System;
-using Archetype.PropertyConverters;
+using Archetype.Tests.Serialization.Base;
 using Newtonsoft.Json;
 using NUnit.Framework;

-namespace Archetype.Tests.Serialization
+namespace Archetype.Tests.Serialization.UseCases
 {
    [TestFixture]
-    public class ArchetypeJsonConverterTest
+    public class ArchetypeJsonConverterTest : ArchetypeJsonConverterTestBase
    {
        private ContactDetails _contactDetails;
        private CompanyDetails _companyDetails;
@@ -60,32 +60,32 @@ namespace Archetype.Tests.Serialization
        #region serialization tests

        [Test]
-        public void MergerDetailsModel_Serializes_To_Archetype_Property()
+        public void Convert_MergerDetailsModel_To_ArchetypeJson()
        {
-            var result = JsonConvert.SerializeObject(_mergerDetails, Formatting.Indented);
+            var result = ConvertModelToArchetypeJson(_mergerDetails, Formatting.Indented);
            Assert.AreEqual(JsonTestStrings._MERGER_DETAILS_JSON, result);
        }        
        
        [Test]
-        public void ContactDetailsModel_Serializes_To_Archetype_Property()
+        public void Convert_ContactDetailsModel_To_ArchetypeJson()
        {
-            var result = JsonConvert.SerializeObject(_contactDetails, Formatting.Indented);
+            var result = ConvertModelToArchetypeJson(_contactDetails, Formatting.Indented);
            Assert.AreEqual(JsonTestStrings._CONTACT_DETAILS_JSON, result);
        }

        [Test]
-        public void CompanyDetailsModel_Fieldset_Serializes_As_Expected()
+        public void Convert_CompanyDetailsModel_To_ArchetypeJson()
        {
-            var result = JsonConvert.SerializeObject(_companyDetails, Formatting.Indented);
+            var result = ConvertModelToArchetypeJson(_companyDetails, Formatting.Indented);

            Assert.AreEqual(JsonTestStrings._COMPANY_DETAILS_JSON, result);

        }

        [Test]
-        public void AnnualStatementModel_Fieldset_Serializes_As_Expected()
+        public void Convert_AnnualStatementModel_To_ArchetypeJson()
        {
-            var result = JsonConvert.SerializeObject(_annualStatement, Formatting.Indented);
+            var result = ConvertModelToArchetypeJson(_annualStatement, Formatting.Indented);

            Assert.AreEqual(JsonTestStrings._ANNUAL_STATEMENT_JSON, result);

@@ -94,14 +94,14 @@ namespace Archetype.Tests.Serialization
        [Test]
        public void NullValues_Serialize_To_Empty_String()
        {
-            var result = JsonConvert.SerializeObject(new ContactDetails());
+            var result = ConvertModelToArchetypeJson(new ContactDetails());

            Assert.AreEqual(JsonTestStrings._NULL_VALUES_JSON, result);

        }

        [Test]
-        public void ConvertModelToArchetype()
+        public void Convert_ContactDetailsModel_To_Archetype()
        {
            var model = new ContactDetails
            {
@@ -109,25 +109,17 @@ namespace Archetype.Tests.Serialization
                Email = "email"
            };

-            var converter = new ArchetypeValueConverter();
-            var json = JsonConvert.SerializeObject(model);
-            var archetype = (Archetype.Models.ArchetypeModel)converter.ConvertDataToSource(null, json, false);
-
-            Assert.NotNull(archetype);
+            Assert.NotNull(ConvertModelToArchetype(model));
        }

        [Test]
-        public void ConvertNumericAndDateModelToArchetype()
+        public void Convert_AnnualStatementModel_To_Archetype()
        {
-            var converter = new ArchetypeValueConverter();
-            var json = JsonConvert.SerializeObject(_annualStatement);
-            var archetype = (Archetype.Models.ArchetypeModel)converter.ConvertDataToSource(null, json, false);
-
-            Assert.NotNull(archetype);
+            Assert.NotNull(ConvertModelToArchetype(_annualStatement));
        }

        [Test]
-        public void ConvertCompoundModelToArchetype()
+        public void Convert_AllContactDetailsModel_To_Archetype()
        {
            var item1 = new ContactDetails
            {
@@ -147,15 +139,11 @@ namespace Archetype.Tests.Serialization
                AdminDetails = item2
            };

-            var converter = new ArchetypeValueConverter();
-            var json = JsonConvert.SerializeObject(model, Formatting.Indented);
-            var archetype = (Archetype.Models.ArchetypeModel)converter.ConvertDataToSource(null, json, false);
-
-            Assert.NotNull(archetype);
+            Assert.NotNull(ConvertModelToArchetype(model));
        }

        [Test]
-        public void ConvertEnumerableModelToArchetype()
+        public void Convert_ContactDetailsListModel_To_Archetype()
        {
            var item1 = new ContactDetails
            {
@@ -175,15 +163,11 @@ namespace Archetype.Tests.Serialization
                item2
            };

-            var converter = new ArchetypeValueConverter();
-            var json = JsonConvert.SerializeObject(model, Formatting.Indented);
-            var archetype = (Archetype.Models.ArchetypeModel)converter.ConvertDataToSource(null, json, false);
-
-            Assert.NotNull(archetype);
+            Assert.NotNull(ConvertModelToArchetype(model));
        }

        [Test]
-        public void ConvertNestedModelToArchetype()
+        public void Convert_CompanyDetailsModel_To_Archetype()
        {
            var model = new CompanyDetails
            {
@@ -195,11 +179,7 @@ namespace Archetype.Tests.Serialization
                }
            };

-            var converter = new ArchetypeValueConverter();
-            var json = JsonConvert.SerializeObject(model, Formatting.Indented);
-            var archetype = (Archetype.Models.ArchetypeModel)converter.ConvertDataToSource(null, json, false);
-
-            Assert.NotNull(archetype);
+            Assert.NotNull(ConvertModelToArchetype(model));
        }

        #endregion
@@ -207,9 +187,9 @@ namespace Archetype.Tests.Serialization
        #region deserialization tests

        [Test]
-        public void DeserializeModelFromArchetype()
+        public void Convert_ArchetypeJson_To_ContactDetailsModel()
        {
-            var result = JsonConvert.DeserializeObject<ContactDetails>(JsonTestStrings._CONTACT_DETAILS_JSON);
+            var result = ConvertArchetypeJsonToModel<ContactDetails>(JsonTestStrings._CONTACT_DETAILS_JSON);

            Assert.NotNull(result);
            Assert.IsInstanceOf<ContactDetails>(result);
@@ -228,9 +208,9 @@ namespace Archetype.Tests.Serialization
        }

        [Test]
-        public void DeserializeNumericAndDateModelFromArchetype()
+        public void Convert_ArchetypeJson_To_AnnualStatementModel()
        {
-            var result = JsonConvert.DeserializeObject<AnnualStatement>(JsonTestStrings._ANNUAL_STATEMENT_JSON);
+            var result = ConvertArchetypeJsonToModel<AnnualStatement>(JsonTestStrings._ANNUAL_STATEMENT_JSON);

            Assert.NotNull(result);
            Assert.IsInstanceOf<AnnualStatement>(result);
@@ -244,7 +224,7 @@ namespace Archetype.Tests.Serialization
        }

        [Test]
-        public void DeserializeNumericAndDateModel_NullableDate_HasValue_FromArchetype()
+        public void Convert_ArchetypeJson_To_AnnualStatementModel_NullableDate_HasValue()
        {
            var annualStatement = new AnnualStatement
            {
@@ -256,8 +236,7 @@ namespace Archetype.Tests.Serialization
                Profit = 1123456.78m
            };

-            var json = JsonConvert.SerializeObject(annualStatement);
-            var result = JsonConvert.DeserializeObject<AnnualStatement>(json);
+            var result = ConvertModelToArchetypeAndBack(annualStatement);

            Assert.NotNull(result);
            Assert.IsInstanceOf<AnnualStatement>(result);
@@ -271,7 +250,7 @@ namespace Archetype.Tests.Serialization
        }

        [Test]
-        public void DeserializeCompoundModelFromArchetype()
+        public void Convert_ArchetypeJson_To_AllContactDetailsModel()
        {
            var item1 = new ContactDetails
            {
@@ -291,8 +270,7 @@ namespace Archetype.Tests.Serialization
                AdminDetails = item2
            };

-            var json = JsonConvert.SerializeObject(model, Formatting.Indented);
-            var result = JsonConvert.DeserializeObject<AllContactDetails>(json);
+            var result = ConvertModelToArchetypeAndBack(model);

            Assert.NotNull(result);
            Assert.IsInstanceOf<AllContactDetails>(result);
@@ -304,7 +282,7 @@ namespace Archetype.Tests.Serialization
        }

        [Test]
-        public void DeserializeEnumerableModelFromArchetype()
+        public void Convert_ArchetypeJson_To_ContactDetailsListModel()
        {
            var item1 = new ContactDetails
            {
@@ -324,8 +302,7 @@ namespace Archetype.Tests.Serialization
                item2
            };

-            var json = JsonConvert.SerializeObject(model, Formatting.Indented);
-            var result = JsonConvert.DeserializeObject<ContactDetailsList>(json);
+            var result = ConvertModelToArchetypeAndBack(model);

            Assert.NotNull(result);
            Assert.IsInstanceOf<ContactDetailsList>(result);
@@ -338,7 +315,7 @@ namespace Archetype.Tests.Serialization
        }

        [Test]
-        public void DeserializeNestedModelFromArchetype()
+        public void Convert_ArchetypeJson_To_CompanyDetailsModel()
        {
            var model = new CompanyDetails
            {
@@ -350,8 +327,7 @@ namespace Archetype.Tests.Serialization
                }
            };

-            var json = JsonConvert.SerializeObject(model, Formatting.Indented);
-            var result = JsonConvert.DeserializeObject<CompanyDetails>(json);
+            var result = ConvertModelToArchetypeAndBack(model);

            Assert.NotNull(result);
            Assert.IsInstanceOf<CompanyDetails>(result);
@@ -1,12 +1,12 @@
 using System.Linq;
-using Archetype.PropertyConverters;
+using Archetype.Tests.Serialization.Base;
 using Newtonsoft.Json;
 using NUnit.Framework;

-namespace Archetype.Tests.Serialization
+namespace Archetype.Tests.Serialization.UseCases.Complex
 {
    [TestFixture]
-    public class ArchetypeJsonConverterComplexModelTest
+    public class ArchetypeJsonConverterTest : ArchetypeJsonConverterTestBase
    {
        private TextList _textList;
        private Captions _captions;
@@ -27,26 +27,22 @@ namespace Archetype.Tests.Serialization
        #region complex nested model tests

        [Test]
-        public void PageDetailsModel_Serializes_To_Archetype_Property()
+        public void Convert_PageDetailsModel_To_ArchetypeJson()
        {
-            var result = JsonConvert.SerializeObject(_pageDetails, Formatting.Indented);
+            var result = ConvertModelToArchetypeJson(_pageDetails, Formatting.Indented);
            Assert.AreEqual(JsonTestStrings._PAGE_DETAILS_JSON, result);
        }

        [Test]
-        public void ConvertComplexModelToArchetype()
+        public void Convert_PageDetailsModel_To_Archetype()
        {
-            var converter = new ArchetypeValueConverter();
-            var json = JsonConvert.SerializeObject(_pageDetails, Formatting.Indented);
-            var archetype = (Archetype.Models.ArchetypeModel)converter.ConvertDataToSource(null, json, false);
-
-            Assert.NotNull(archetype);
+            Assert.NotNull(ConvertModelToArchetype(_pageDetails));
        }

        [Test]
-        public void DeserializeComplexModelFromArchetype()
+        public void Convert_ArchetypeJson_To_PageDetailsModel()
        {
-            var result = JsonConvert.DeserializeObject<PageDetails>(JsonTestStrings._PAGE_DETAILS_JSON);
+            var result = ConvertArchetypeJsonToModel<PageDetails>(JsonTestStrings._PAGE_DETAILS_JSON);

            Assert.NotNull(result);
            Assert.IsInstanceOf<PageDetails>(result);
@@ -59,10 +55,9 @@ namespace Archetype.Tests.Serialization
        }

        [Test]
-        public void SerializeThenDeserializeComplexModelFromArchetype()
+        public void Convert_PageDetailsModel_To_Archetype_AndBack()
        {
-            var json = JsonConvert.SerializeObject(_pageDetails);
-            var result = JsonConvert.DeserializeObject<PageDetails>(json);
+            var result = ConvertModelToArchetypeAndBack(_pageDetails);

            Assert.NotNull(result);
            Assert.IsInstanceOf<PageDetails>(result);
@@ -78,26 +73,22 @@ namespace Archetype.Tests.Serialization
        #region complex nested tree model tests

        [Test]
-        public void ConvertComplexNestedModelToArchetype()
+        public void Convert_PagesModel_To_Archetype()
        {
-            var converter = new ArchetypeValueConverter();
-            var json = JsonConvert.SerializeObject(_pages, Formatting.Indented);
-            var archetype = (Archetype.Models.ArchetypeModel)converter.ConvertDataToSource(null, json, false);
-
-            Assert.NotNull(archetype);
+            Assert.NotNull(ConvertModelToArchetype(_pages));
        }

        [Test]
-        public void PagesModel_Serializes_To_Archetype_Property()
+        public void Convert_PagesModel_To_ArchetypeJson()
        {
-            var result = JsonConvert.SerializeObject(_pages, Formatting.Indented);
+            var result = ConvertModelToArchetypeJson(_pages, Formatting.Indented);
            Assert.AreEqual(JsonTestStrings._PAGES_JSON, result);
        }

        [Test]
-        public void DeserializeComplexTreeModelFromArchetype()
+        public void Convert_ArchetypeJson_To_PagesModel()
        {
-            var result = JsonConvert.DeserializeObject<PageList>(JsonTestStrings._PAGES_JSON);
+            var result = ConvertArchetypeJsonToModel<PageList>(JsonTestStrings._PAGES_JSON);

            Assert.NotNull(result);
            Assert.IsInstanceOf<PageList>(result);
@@ -124,10 +115,9 @@ namespace Archetype.Tests.Serialization
        }

        [Test]
-        public void SerializeThenDeserializeComplexTreeModelFromArchetype()
+        public void Convert_PagesModel_To_Archetype_AndBack()
        {
-            var json = JsonConvert.SerializeObject(_pages);
-            var result = JsonConvert.DeserializeObject<PageList>(json);
+            var result = ConvertModelToArchetypeAndBack(_pages);

            Assert.NotNull(result);
            Assert.IsInstanceOf<PageList>(result);
@@ -0,0 +1,92 @@
+using System.Collections.Generic;
+using Archetype.Serialization;
+using Newtonsoft.Json;
+
+namespace Archetype.Tests.Serialization.UseCases.Complex
+{
+    #region complex nested model
+
+    [AsArchetype("pages")]
+    [JsonConverter(typeof(ArchetypeJsonConverter))]
+    public class PageDetails
+    {
+        [JsonProperty("pages")]
+        public string Pages { get; set; }
+        [AsFieldset]
+        [JsonProperty("captions")]
+        public Captions Captions { get; set; }
+    }
+
+    [AsArchetype("captions")]
+    [JsonConverter(typeof(ArchetypeJsonConverter))]
+    public class Captions
+    {
+        [JsonProperty("captions")]
+        public TextList TextStringArray { get; set; }
+    }
+
+    [AsArchetype("textstringArray")]
+    [JsonConverter(typeof(ArchetypeJsonConverter))]
+    public class TextList : List<TextItem>
+    {
+    }
+
+    [AsArchetype("textstringArray")]
+    [JsonConverter(typeof(ArchetypeJsonConverter))]
+    public class TextItem
+    {
+        [JsonProperty("textstring")]
+        public string TextString { get; set; }
+    }
+
+    #endregion
+
+    #region complex nested tree model
+
+    public abstract class PageBase
+    {
+        public string PageTitle { get; set; }
+        public string BodyText { get; set; }
+    }
+
+    [AsArchetype("slideShow")]
+    [JsonConverter(typeof(ArchetypeJsonConverter))]
+    public class SlideShow
+    {
+        public string Slides { get; set; }
+    }
+
+    [AsArchetype("seo")]
+    [JsonConverter(typeof(ArchetypeJsonConverter))]
+    public class Seo
+    {
+        public string MetaTitle { get; set; }
+        public string MetaDescription { get; set; }
+    }
+
+    [AsArchetype("TextPage")]
+    [JsonConverter(typeof(ArchetypeJsonConverter))]
+    public class TextPage : PageBase
+    {
+        [AsFieldset]
+        public SlideShow Media { get; set; }
+
+        [AsFieldset]
+        public Seo Seo { get; set; }
+    }
+
+    [AsArchetype("TextPageList")]
+    [JsonConverter(typeof(ArchetypeJsonConverter))]
+    public class TextPageList : List<TextPage>
+    {
+    }
+
+    [AsArchetype("Pages")]
+    [JsonConverter(typeof(ArchetypeJsonConverter))]
+    public class PageList
+    {
+        public TextPageList Pages { get; set; }
+    }
+
+    #endregion
+}
@@ -1,435 +1,245 @@
-namespace Archetype.Tests.Serialization
-{
-    public class JsonTestStrings
-    {
-        public const string _MERGER_DETAILS_JSON =
-            @"{
-  ""fieldsets"": [
-    {
-      ""alias"": ""mergerDetails"",
-      ""properties"": [
-        {
-          ""alias"": ""MergerDate"",
-          ""value"": ""07/06/2014 08:09:10""
-        }
-      ]
-    }
-  ]
-}";
-
-        public const string _ANNUAL_STATEMENT_JSON =
-            @"{
-  ""fieldsets"": [
-    {
-      ""alias"": ""annualStatement"",
-      ""properties"": [
-        {
-          ""alias"": ""FiscalYearStart"",
-          ""value"": ""01/09/2013 00:00:00""
-        },
-        {
-          ""alias"": ""FiscalYearEnd"",
-          ""value"": ""31/08/2014 00:00:00""
-        },
-        {
-          ""alias"": ""DividendPaymentDate"",
-          ""value"": """"
-        },
-        {
-          ""alias"": ""TotalShares"",
-          ""value"": ""345678""
-        },
-        {
-          ""alias"": ""Sales"",
-          ""value"": ""123456700.89""
-        },
-        {
-          ""alias"": ""Profit"",
-          ""value"": ""1123456.78""
-        }
-      ]
-    }
-  ]
-}";
-
-        public const string _CONTACT_DETAILS_JSON =
-            @"{
-  ""fieldsets"": [
-    {
-      ""alias"": ""contactDetails"",
-      ""properties"": [
-        {
-          ""alias"": ""name"",
-          ""value"": ""Test""
-        },
-        {
-          ""alias"": ""address"",
-          ""value"": ""Test Address""
-        },
-        {
-          ""alias"": ""telephone"",
-          ""value"": ""111""
-        },
-        {
-          ""alias"": ""mobile"",
-          ""value"": ""000""
-        },
-        {
-          ""alias"": ""fax"",
-          ""value"": ""000""
-        },
-        {
-          ""alias"": ""email"",
-          ""value"": ""test@test.com""
-        },
-        {
-          ""alias"": ""webSite"",
-          ""value"": {
-            ""fieldsets"": [
-              {
-                ""alias"": ""urlPicker"",
-                ""properties"": [
-                  {
-                    ""alias"": ""title"",
-                    ""value"": ""The Test Company""
-                  },
-                  {
-                    ""alias"": ""url"",
-                    ""value"": ""http://test.com""
-                  },
-                  {
-                    ""alias"": ""content"",
-                    ""value"": """"
-                  },
-                  {
-                    ""alias"": ""media"",
-                    ""value"": """"
-                  },
-                  {
-                    ""alias"": ""openInNewWindow"",
-                    ""value"": ""1""
-                  }
-                ]
-              }
-            ]
-          }
-        }
-      ]
-    }
-  ]
-}";
-
-        public const string _COMPANY_DETAILS_JSON =
-            @"{
-  ""fieldsets"": [
-    {
-      ""alias"": ""companyDetails"",
-      ""properties"": [
-        {
-          ""alias"": ""region"",
-          ""value"": ""Test Region""
-        },
-        {
-          ""alias"": ""contactDetails"",
-          ""value"": {
-            ""fieldsets"": [
-              {
-                ""alias"": ""contactDetails"",
-                ""properties"": [
-                  {
-                    ""alias"": ""name"",
-                    ""value"": ""Test""
-                  },
-                  {
-                    ""alias"": ""address"",
-                    ""value"": ""Test Address""
-                  },
-                  {
-                    ""alias"": ""telephone"",
-                    ""value"": ""111""
-                  },
-                  {
-                    ""alias"": ""mobile"",
-                    ""value"": ""000""
-                  },
-                  {
-                    ""alias"": ""fax"",
-                    ""value"": ""000""
-                  },
-                  {
-                    ""alias"": ""email"",
-                    ""value"": ""test@test.com""
-                  },
-                  {
-                    ""alias"": ""webSite"",
-                    ""value"": {
-                      ""fieldsets"": [
-                        {
-                          ""alias"": ""urlPicker"",
-                          ""properties"": [
-                            {
-                              ""alias"": ""title"",
-                              ""value"": ""The Test Company""
-                            },
-                            {
-                              ""alias"": ""url"",
-                              ""value"": ""http://test.com""
-                            },
-                            {
-                              ""alias"": ""content"",
-                              ""value"": """"
-                            },
-                            {
-                              ""alias"": ""media"",
-                              ""value"": """"
-                            },
-                            {
-                              ""alias"": ""openInNewWindow"",
-                              ""value"": ""1""
-                            }
-                          ]
-                        }
-                      ]
-                    }
-                  }
-                ]
-              }
-            ]
-          }
-        }
-      ]
-    }
-  ]
-}";
-
-        public const string _PAGE_DETAILS_JSON =
-            @"{
-  ""fieldsets"": [
-    {
-      ""alias"": ""pages"",
-      ""properties"": [
-        {
-          ""alias"": ""pages"",
-          ""value"": ""2439,2440,2441,2442,2443,2444,2445,2446,2447,2448,2449,2450,2451,2452,2453""
-        }
-      ]
-    },
-    {
-      ""alias"": ""captions"",
-      ""properties"": [
-        {
-          ""alias"": ""captions"",
-          ""value"": {
-            ""fieldsets"": [
-              {
-                ""alias"": ""textstringArray"",
-                ""properties"": [
-                  {
-                    ""alias"": ""textstring"",
-                    ""value"": ""First Page""
-                  }
-                ]
-              },
-              {
-                ""alias"": ""textstringArray"",
-                ""properties"": [
-                  {
-                    ""alias"": ""textstring"",
-                    ""value"": ""Second Page""
-                  }
-                ]
-              },
-              {
-                ""alias"": ""textstringArray"",
-                ""properties"": [
-                  {
-                    ""alias"": ""textstring"",
-                    ""value"": ""Third Page""
-                  }
-                ]
-              },
-              {
-                ""alias"": ""textstringArray"",
-                ""properties"": [
-                  {
-                    ""alias"": ""textstring"",
-                    ""value"": ""Fourth Page""
-                  }
-                ]
-              }
-            ]
-          }
-        }
-      ]
-    }
-  ]
-}";
-
-        public const string _PAGES_JSON =
-            @"{
-  ""fieldsets"": [
-    {
-      ""alias"": ""Pages"",
-      ""properties"": [
-        {
-          ""alias"": ""Pages"",
-          ""value"": {
-            ""fieldsets"": [
-              {
-                ""alias"": ""TextPage"",
-                ""properties"": [
-                  {
-                    ""alias"": ""Media"",
-                    ""value"": {
-                      ""fieldsets"": [
-                        {
-                          ""alias"": ""slideShow"",
-                          ""properties"": [
-                            {
-                              ""alias"": ""Slides"",
-                              ""value"": ""1,2,3,4,5,6,7,8""
-                            }
-                          ]
-                        }
-                      ]
-                    }
-                  },
-                  {
-                    ""alias"": ""Seo"",
-                    ""value"": {
-                      ""fieldsets"": [
-                        {
-                          ""alias"": ""seo"",
-                          ""properties"": [
-                            {
-                              ""alias"": ""MetaTitle"",
-                              ""value"": ""Test Meta Title""
-                            },
-                            {
-                              ""alias"": ""MetaDescription"",
-                              ""value"": ""Test Meta Description""
-                            }
-                          ]
-                        }
-                      ]
-                    }
-                  },
-                  {
-                    ""alias"": ""PageTitle"",
-                    ""value"": ""Home Page""
-                  },
-                  {
-                    ""alias"": ""BodyText"",
-                    ""value"": ""Home Page Body""
-                  }
-                ]
-              },
-              {
-                ""alias"": ""TextPage"",
-                ""properties"": [
-                  {
-                    ""alias"": ""Media"",
-                    ""value"": {
-                      ""fieldsets"": [
-                        {
-                          ""alias"": ""slideShow"",
-                          ""properties"": [
-                            {
-                              ""alias"": ""Slides"",
-                              ""value"": ""1,2,3,4,5,6,7,8""
-                            }
-                          ]
-                        }
-                      ]
-                    }
-                  },
-                  {
-                    ""alias"": ""Seo"",
-                    ""value"": {
-                      ""fieldsets"": [
-                        {
-                          ""alias"": ""seo"",
-                          ""properties"": [
-                            {
-                              ""alias"": ""MetaTitle"",
-                              ""value"": ""Test Meta Title""
-                            },
-                            {
-                              ""alias"": ""MetaDescription"",
-                              ""value"": ""Test Meta Description""
-                            }
-                          ]
-                        }
-                      ]
-                    }
-                  },
-                  {
-                    ""alias"": ""PageTitle"",
-                    ""value"": ""About us Page""
-                  },
-                  {
-                    ""alias"": ""BodyText"",
-                    ""value"": ""About us Page Body""
-                  }
-                ]
-              },
-              {
-                ""alias"": ""TextPage"",
-                ""properties"": [
-                  {
-                    ""alias"": ""Media"",
-                    ""value"": {
-                      ""fieldsets"": [
-                        {
-                          ""alias"": ""slideShow"",
-                          ""properties"": [
-                            {
-                              ""alias"": ""Slides"",
-                              ""value"": ""1,2,3,4,5,6,7,8""
-                            }
-                          ]
-                        }
-                      ]
-                    }
-                  },
-                  {
-                    ""alias"": ""Seo"",
-                    ""value"": {
-                      ""fieldsets"": [
-                        {
-                          ""alias"": ""seo"",
-                          ""properties"": [
-                            {
-                              ""alias"": ""MetaTitle"",
-                              ""value"": ""Test Meta Title""
-                            },
-                            {
-                              ""alias"": ""MetaDescription"",
-                              ""value"": ""Test Meta Description""
-                            }
-                          ]
-                        }
-                      ]
-                    }
-                  },
-                  {
-                    ""alias"": ""PageTitle"",
-                    ""value"": ""Contact us Page""
-                  },
-                  {
-                    ""alias"": ""BodyText"",
-                    ""value"": ""Contact us Page Body""
-                  }
-                ]
-              }
-            ]
-          }
-        }
-      ]
-    }
-  ]
-}";
-
-        public const string _NULL_VALUES_JSON = @"{""fieldsets"":[{""alias"":""contactDetails"",""properties"":[{""alias"":""name"",""value"":""""},{""alias"":""address"",""value"":""""},{""alias"":""telephone"",""value"":""""},{""alias"":""mobile"",""value"":""""},{""alias"":""fax"",""value"":""""},{""alias"":""email"",""value"":""""},{""alias"":""webSite"",""value"":""""}]}]}";
-    }
-}
+namespace Archetype.Tests.Serialization.UseCases.Complex
+{
+    public class JsonTestStrings
+    {
+        public const string _PAGE_DETAILS_JSON =
+            @"{
+  ""fieldsets"": [
+    {
+      ""alias"": ""captions"",
+      ""properties"": [
+        {
+          ""alias"": ""captions"",
+          ""value"": {
+            ""fieldsets"": [
+              {
+                ""alias"": ""captions"",
+                ""properties"": [
+                  {
+                    ""alias"": ""captions"",
+                    ""value"": {
+                      ""fieldsets"": [
+                        {
+                          ""alias"": ""textstringArray"",
+                          ""properties"": [
+                            {
+                              ""alias"": ""textstring"",
+                              ""value"": ""First Page""
+                            }
+                          ]
+                        },
+                        {
+                          ""alias"": ""textstringArray"",
+                          ""properties"": [
+                            {
+                              ""alias"": ""textstring"",
+                              ""value"": ""Second Page""
+                            }
+                          ]
+                        },
+                        {
+                          ""alias"": ""textstringArray"",
+                          ""properties"": [
+                            {
+                              ""alias"": ""textstring"",
+                              ""value"": ""Third Page""
+                            }
+                          ]
+                        },
+                        {
+                          ""alias"": ""textstringArray"",
+                          ""properties"": [
+                            {
+                              ""alias"": ""textstring"",
+                              ""value"": ""Fourth Page""
+                            }
+                          ]
+                        }
+                      ]
+                    }
+                  }
+                ]
+              }
+            ]
+          }
+        }
+      ]
+    },
+    {
+      ""alias"": ""pages"",
+      ""properties"": [
+        {
+          ""alias"": ""pages"",
+          ""value"": ""2439,2440,2441,2442,2443,2444,2445,2446,2447,2448,2449,2450,2451,2452,2453""
+        }
+      ]
+    }
+  ]
+}";
+
+        public const string _PAGES_JSON =
+            @"{
+  ""fieldsets"": [
+    {
+      ""alias"": ""Pages"",
+      ""properties"": [
+        {
+          ""alias"": ""Pages"",
+          ""value"": {
+            ""fieldsets"": [
+              {
+                ""alias"": ""TextPage"",
+                ""properties"": [
+                  {
+                    ""alias"": ""Media"",
+                    ""value"": {
+                      ""fieldsets"": [
+                        {
+                          ""alias"": ""slideShow"",
+                          ""properties"": [
+                            {
+                              ""alias"": ""Slides"",
+                              ""value"": ""1,2,3,4,5,6,7,8""
+                            }
+                          ]
+                        }
+                      ]
+                    }
+                  },
+                  {
+                    ""alias"": ""Seo"",
+                    ""value"": {
+                      ""fieldsets"": [
+                        {
+                          ""alias"": ""seo"",
+                          ""properties"": [
+                            {
+                              ""alias"": ""MetaTitle"",
+                              ""value"": ""Test Meta Title""
+                            },
+                            {
+                              ""alias"": ""MetaDescription"",
+                              ""value"": ""Test Meta Description""
+                            }
+                          ]
+                        }
+                      ]
+                    }
+                  },
+                  {
+                    ""alias"": ""PageTitle"",
+                    ""value"": ""Home Page""
+                  },
+                  {
+                    ""alias"": ""BodyText"",
+                    ""value"": ""Home Page Body""
+                  }
+                ]
+              },
+              {
+                ""alias"": ""TextPage"",
+                ""properties"": [
+                  {
+                    ""alias"": ""Media"",
+                    ""value"": {
+                      ""fieldsets"": [
+                        {
+                          ""alias"": ""slideShow"",
+                          ""properties"": [
+                            {
+                              ""alias"": ""Slides"",
+                              ""value"": ""1,2,3,4,5,6,7,8""
+                            }
+                          ]
+                        }
+                      ]
+                    }
+                  },
+                  {
+                    ""alias"": ""Seo"",
+                    ""value"": {
+                      ""fieldsets"": [
+                        {
+                          ""alias"": ""seo"",
+                          ""properties"": [
+                            {
+                              ""alias"": ""MetaTitle"",
+                              ""value"": ""Test Meta Title""
+                            },
+                            {
+                              ""alias"": ""MetaDescription"",
+                              ""value"": ""Test Meta Description""
+                            }
+                          ]
+                        }
+                      ]
+                    }
+                  },
+                  {
+                    ""alias"": ""PageTitle"",
+                    ""value"": ""About us Page""
+                  },
+                  {
+                    ""alias"": ""BodyText"",
+                    ""value"": ""About us Page Body""
+                  }
+                ]
+              },
+              {
+                ""alias"": ""TextPage"",
+                ""properties"": [
+                  {
+                    ""alias"": ""Media"",
+                    ""value"": {
+                      ""fieldsets"": [
+                        {
+                          ""alias"": ""slideShow"",
+                          ""properties"": [
+                            {
+                              ""alias"": ""Slides"",
+                              ""value"": ""1,2,3,4,5,6,7,8""
+                            }
+                          ]
+                        }
+                      ]
+                    }
+                  },
+                  {
+                    ""alias"": ""Seo"",
+                    ""value"": {
+                      ""fieldsets"": [
+                        {
+                          ""alias"": ""seo"",
+                          ""properties"": [
+                            {
+                              ""alias"": ""MetaTitle"",
+                              ""value"": ""Test Meta Title""
+                            },
+                            {
+                              ""alias"": ""MetaDescription"",
+                              ""value"": ""Test Meta Description""
+                            }
+                          ]
+                        }
+                      ]
+                    }
+                  },
+                  {
+                    ""alias"": ""PageTitle"",
+                    ""value"": ""Contact us Page""
+                  },
+                  {
+                    ""alias"": ""BodyText"",
+                    ""value"": ""Contact us Page Body""
+                  }
+                ]
+              }
+            ]
+          }
+        }
+      ]
+    }
+  ]
+}";
+    }
+}
@@ -0,0 +1,143 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Archetype.Models;
+using Archetype.PropertyConverters;
+using Archetype.Tests.Serialization.Base;
+using Newtonsoft.Json;
+using NUnit.Framework;
+
+namespace Archetype.Tests.Serialization.UseCases.Enumerable
+{
+    [TestFixture]
+    public class ArchetypeJsonConverterTest : ArchetypeJsonConverterTestBase
+    {
+        private Feedbacks _feedbacks;
+        private Captions _captions;
+
+        
+        [SetUp]
+        public void SetUp()
+        {
+            _feedbacks = new Feedbacks
+            {
+                new Feedback{Testimonial = "Testimonial 1"},
+                new Feedback{Testimonial = "Testimonial 2"},
+                new Feedback{Testimonial = "Testimonial 3"}
+            };
+
+            _captions = new Captions()
+            {
+                TextArray = new List<Text>
+                {
+                    new Text{TextString = "Caption 1"},
+                    new Text{TextString = "Caption 2"},
+                    new Text{TextString = "Caption 3"}
+                }
+            };
+        }
+
+        #region Feedback - single fieldset with multiple items
+
+        [Test]
+        public void Convert_FeedbackModel_To_Archetype()
+        {
+            var converter = new ArchetypeValueConverter();
+            var json = JsonConvert.SerializeObject(_feedbacks);
+            var archetype = (ArchetypeModel)converter.ConvertDataToSource(null, json, false);
+
+            Assert.NotNull(archetype);
+        }
+
+        [Test]
+        public void Convert_FeedbackModel_To_ArchetypeJson()
+        {
+            var json = ConvertModelToArchetypeJson(_feedbacks, Formatting.Indented);
+            Assert.AreEqual(JsonTestStrings._FEEDBACK_JSON, json);
+        }
+
+        [Test]
+        public void Convert_ArchetypeJson_To_FeedbackModel()
+        {
+            var result = ConvertArchetypeJsonToModel<Feedbacks>(JsonTestStrings._FEEDBACK_JSON);
+            Assert.NotNull(result);
+            Assert.AreEqual(3, result.Count);
+
+            foreach (var feedback in result)
+            {
+                Assert.AreEqual(String.Format("Testimonial {0}", result.IndexOf(feedback) + 1),
+                    feedback.Testimonial);
+            }
+        }
+
+        [Test]
+        public void Convert_FeedbackModel_To_Archetype_AndBack()
+        {
+            var result = ConvertModelToArchetypeAndBack(_feedbacks);
+            Assert.NotNull(result);
+
+            Assert.AreEqual(3, result.Count);
+
+            foreach (var feedback in result)
+            {
+                var index = result.IndexOf(feedback);
+                Assert.AreEqual(_feedbacks.ElementAt(index).Testimonial, feedback.Testimonial);
+            }
+        }
+
+        #endregion
+
+        #region Captions - a root fieldset which contains another fieldset list
+
+        [Test]
+        public void Convert_CaptionsModel_To_Archetype()
+        {
+            var converter = new ArchetypeValueConverter();
+            var json = JsonConvert.SerializeObject(_captions);
+            var archetype = (ArchetypeModel)converter.ConvertDataToSource(null, json, false);
+
+            Assert.NotNull(archetype);
+        }
+
+        [Test]
+        public void Convert_CaptionsModel_To_ArchetypeJson()
+        {
+            var json = ConvertModelToArchetypeJson(_captions, Formatting.Indented);
+            Assert.AreEqual(JsonTestStrings._CAPTIONS_JSON, json);
+        }
+
+        [Test]
+        public void Convert_ArchetypeJson_To_CaptionsModel()
+        {
+            var result = ConvertArchetypeJsonToModel<Captions>(JsonTestStrings._CAPTIONS_JSON);
+            Assert.NotNull(result);
+            Assert.NotNull(result.TextArray);
+
+            Assert.AreEqual(3, result.TextArray.Count);
+
+            foreach (var caption in result.TextArray)
+            {
+                Assert.AreEqual(String.Format("Caption {0}", result.TextArray.IndexOf(caption) + 1),
+                    caption.TextString);
+            }
+        }
+
+        [Test]
+        public void Convert_CaptionsModel_To_Archetype_AndBack()
+        {
+            var result = ConvertModelToArchetypeAndBack(_captions);
+            Assert.NotNull(result);
+            Assert.NotNull(result.TextArray);
+
+            Assert.AreEqual(3, result.TextArray.Count);
+
+            foreach (var caption in result.TextArray)
+            {
+                var index = result.TextArray.IndexOf(caption);
+                Assert.AreEqual(_captions.TextArray.ElementAt(index).TextString, caption.TextString);
+            }
+        }
+
+        #endregion
+    }
+}
@@ -0,0 +1,58 @@
+using System;
+using System.Collections.Generic;
+using Archetype.Serialization;
+using Newtonsoft.Json;
+
+namespace Archetype.Tests.Serialization.UseCases.Enumerable
+{
+    #region Feedback - single fieldset with multiple items
+
+    [AsArchetype("feedbacks")] /* Note: when inheriting from a list, archetype alias is not used */
+    [JsonConverter(typeof(ArchetypeJsonConverter))]
+    public class Feedbacks : List<Feedback>
+    {
+    }
+
+    [AsArchetype("feedback")] /* Must have same archetype alias as list class */
+    [JsonConverter(typeof(ArchetypeJsonConverter))]
+    public class Feedback
+    {
+        [JsonProperty("testimonial")]
+        public String Testimonial { get; set; }
+    }
+
+    #endregion   
+ 
+    #region Captions - a root fieldset which contains another fieldset list
+
+    [AsArchetype("captions")]
+    [JsonConverter(typeof(ArchetypeJsonConverter))]
+    public class Captions
+    {
+        [JsonProperty("captions")]
+        public List<Text> TextArray { get; set; }
+    }
+
+    [AsArchetype("textArray")]
+    [JsonConverter(typeof(ArchetypeJsonConverter))]
+    public class Text
+    {
+        [JsonProperty("textstring")]
+        public String TextString { get; set; }
+    }
+
+    #endregion
+
+
+    [AsArchetype("aboutUs")]
+    [JsonConverter(typeof(ArchetypeJsonConverter))]
+    public class AboutUs
+    {
+        [AsFieldset]
+        [JsonProperty("contacts")]
+        public IEnumerable<ContactDetails> Contacts { get; set; } 
+        [AsFieldset]
+        [JsonProperty("testimonials")]
+        public IEnumerable<String> Testimonials { get; set; }
+    }
+}
@@ -0,0 +1,86 @@
+namespace Archetype.Tests.Serialization.UseCases.Enumerable
+{
+    public class JsonTestStrings
+    {
+        public const string _ABOUT_US_JSON =
+            @"";
+
+        public const string _FEEDBACK_JSON =
+            @"{
+  ""fieldsets"": [
+    {
+      ""alias"": ""feedback"",
+      ""properties"": [
+        {
+          ""alias"": ""testimonial"",
+          ""value"": ""Testimonial 1""
+        }
+      ]
+    },
+    {
+      ""alias"": ""feedback"",
+      ""properties"": [
+        {
+          ""alias"": ""testimonial"",
+          ""value"": ""Testimonial 2""
+        }
+      ]
+    },
+    {
+      ""alias"": ""feedback"",
+      ""properties"": [
+        {
+          ""alias"": ""testimonial"",
+          ""value"": ""Testimonial 3""
+        }
+      ]
+    }
+  ]
+}";
+
+        public const string _CAPTIONS_JSON =
+            @"{
+  ""fieldsets"": [
+    {
+      ""alias"": ""captions"",
+      ""properties"": [
+        {
+          ""alias"": ""captions"",
+          ""value"": {
+            ""fieldsets"": [
+              {
+                ""alias"": ""textArray"",
+                ""properties"": [
+                  {
+                    ""alias"": ""textstring"",
+                    ""value"": ""Caption 1""
+                  }
+                ]
+              },
+              {
+                ""alias"": ""textArray"",
+                ""properties"": [
+                  {
+                    ""alias"": ""textstring"",
+                    ""value"": ""Caption 2""
+                  }
+                ]
+              },
+              {
+                ""alias"": ""textArray"",
+                ""properties"": [
+                  {
+                    ""alias"": ""textstring"",
+                    ""value"": ""Caption 3""
+                  }
+                ]
+              }
+            ]
+          }
+        }
+      ]
+    }
+  ]
+}";
+    }
+}
@@ -3,7 +3,7 @@ using System.Collections.Generic;
 using Archetype.Serialization;
 using Newtonsoft.Json;

-namespace Archetype.Tests.Serialization
+namespace Archetype.Tests.Serialization.UseCases
 {
    #region json test Models

@@ -89,91 +89,5 @@ namespace Archetype.Tests.Serialization
        public decimal MergerValue { get; set; }
    }

-    #endregion
-
-    #region complex nested model
-
-    [AsArchetype("pages")]
-    [JsonConverter(typeof(ArchetypeJsonConverter))]
-    public class PageDetails
-    {
-        [JsonProperty("pages")]
-        public string Pages { get; set; }
-        [AsFieldset]
-        [JsonProperty("captions")]
-        public Captions Captions { get; set; }
-    }
-
-    [AsArchetype("captions")]
-    [JsonConverter(typeof(ArchetypeJsonConverter))]
-    public class Captions
-    {
-        [JsonProperty("captions")]
-        public TextList TextStringArray { get; set; }
-    }
-
-    [AsArchetype("textstringArray")]
-    [JsonConverter(typeof(ArchetypeJsonConverter))]
-    public class TextList : List<TextItem>
-    {
-    }
-
-    [AsArchetype("textstringArray")]
-    [JsonConverter(typeof(ArchetypeJsonConverter))]
-    public class TextItem
-    {
-        [JsonProperty("textstring")]
-        public string TextString { get; set; }
-    }
-
-    #endregion
-
-    #region complex nested tree model
-
-    public abstract class PageBase
-    {
-        public string PageTitle { get; set; }
-        public string BodyText { get; set; }
-    }
-
-    [AsArchetype("slideShow")]
-    [JsonConverter(typeof(ArchetypeJsonConverter))]
-    public class SlideShow
-    {
-        public string Slides { get; set; }
-    }
-
-    [AsArchetype("seo")]
-    [JsonConverter(typeof(ArchetypeJsonConverter))]
-    public class Seo
-    {
-        public string MetaTitle { get; set; }
-        public string MetaDescription { get; set; }
-    }
-
-    [AsArchetype("TextPage")]
-    [JsonConverter(typeof(ArchetypeJsonConverter))]
-    public class TextPage : PageBase
-    {
-        [AsFieldset]
-        public SlideShow Media { get; set; }
-
-        [AsFieldset]
-        public Seo Seo { get; set; }
-    }
-
-    [AsArchetype("TextPageList")]
-    [JsonConverter(typeof(ArchetypeJsonConverter))]
-    public class TextPageList : List<TextPage>
-    {
-    }
-
-    [AsArchetype("Pages")]
-    [JsonConverter(typeof(ArchetypeJsonConverter))]
-    public class PageList
-    {
-        public TextPageList Pages { get; set; }
-    }
-
-    #endregion
+    #endregion    
 }
@@ -0,0 +1,207 @@
+namespace Archetype.Tests.Serialization.UseCases
+{
+    public class JsonTestStrings
+    {
+        public const string _MERGER_DETAILS_JSON =
+            @"{
+  ""fieldsets"": [
+    {
+      ""alias"": ""mergerDetails"",
+      ""properties"": [
+        {
+          ""alias"": ""MergerDate"",
+          ""value"": ""07/06/2014 08:09:10""
+        }
+      ]
+    }
+  ]
+}";
+
+        public const string _ANNUAL_STATEMENT_JSON =
+            @"{
+  ""fieldsets"": [
+    {
+      ""alias"": ""annualStatement"",
+      ""properties"": [
+        {
+          ""alias"": ""FiscalYearStart"",
+          ""value"": ""01/09/2013 00:00:00""
+        },
+        {
+          ""alias"": ""FiscalYearEnd"",
+          ""value"": ""31/08/2014 00:00:00""
+        },
+        {
+          ""alias"": ""DividendPaymentDate"",
+          ""value"": """"
+        },
+        {
+          ""alias"": ""TotalShares"",
+          ""value"": ""345678""
+        },
+        {
+          ""alias"": ""Sales"",
+          ""value"": ""123456700.89""
+        },
+        {
+          ""alias"": ""Profit"",
+          ""value"": ""1123456.78""
+        }
+      ]
+    }
+  ]
+}";
+
+        public const string _CONTACT_DETAILS_JSON =
+            @"{
+  ""fieldsets"": [
+    {
+      ""alias"": ""contactDetails"",
+      ""properties"": [
+        {
+          ""alias"": ""name"",
+          ""value"": ""Test""
+        },
+        {
+          ""alias"": ""address"",
+          ""value"": ""Test Address""
+        },
+        {
+          ""alias"": ""telephone"",
+          ""value"": ""111""
+        },
+        {
+          ""alias"": ""mobile"",
+          ""value"": ""000""
+        },
+        {
+          ""alias"": ""fax"",
+          ""value"": ""000""
+        },
+        {
+          ""alias"": ""email"",
+          ""value"": ""test@test.com""
+        },
+        {
+          ""alias"": ""webSite"",
+          ""value"": {
+            ""fieldsets"": [
+              {
+                ""alias"": ""urlPicker"",
+                ""properties"": [
+                  {
+                    ""alias"": ""title"",
+                    ""value"": ""The Test Company""
+                  },
+                  {
+                    ""alias"": ""url"",
+                    ""value"": ""http://test.com""
+                  },
+                  {
+                    ""alias"": ""content"",
+                    ""value"": """"
+                  },
+                  {
+                    ""alias"": ""media"",
+                    ""value"": """"
+                  },
+                  {
+                    ""alias"": ""openInNewWindow"",
+                    ""value"": ""1""
+                  }
+                ]
+              }
+            ]
+          }
+        }
+      ]
+    }
+  ]
+}";
+
+        public const string _COMPANY_DETAILS_JSON =
+            @"{
+  ""fieldsets"": [
+    {
+      ""alias"": ""companyDetails"",
+      ""properties"": [
+        {
+          ""alias"": ""region"",
+          ""value"": ""Test Region""
+        },
+        {
+          ""alias"": ""contactDetails"",
+          ""value"": {
+            ""fieldsets"": [
+              {
+                ""alias"": ""contactDetails"",
+                ""properties"": [
+                  {
+                    ""alias"": ""name"",
+                    ""value"": ""Test""
+                  },
+                  {
+                    ""alias"": ""address"",
+                    ""value"": ""Test Address""
+                  },
+                  {
+                    ""alias"": ""telephone"",
+                    ""value"": ""111""
+                  },
+                  {
+                    ""alias"": ""mobile"",
+                    ""value"": ""000""
+                  },
+                  {
+                    ""alias"": ""fax"",
+                    ""value"": ""000""
+                  },
+                  {
+                    ""alias"": ""email"",
+                    ""value"": ""test@test.com""
+                  },
+                  {
+                    ""alias"": ""webSite"",
+                    ""value"": {
+                      ""fieldsets"": [
+                        {
+                          ""alias"": ""urlPicker"",
+                          ""properties"": [
+                            {
+                              ""alias"": ""title"",
+                              ""value"": ""The Test Company""
+                            },
+                            {
+                              ""alias"": ""url"",
+                              ""value"": ""http://test.com""
+                            },
+                            {
+                              ""alias"": ""content"",
+                              ""value"": """"
+                            },
+                            {
+                              ""alias"": ""media"",
+                              ""value"": """"
+                            },
+                            {
+                              ""alias"": ""openInNewWindow"",
+                              ""value"": ""1""
+                            }
+                          ]
+                        }
+                      ]
+                    }
+                  }
+                ]
+              }
+            ]
+          }
+        }
+      ]
+    }
+  ]
+}";
+
+        public const string _NULL_VALUES_JSON = @"{""fieldsets"":[{""alias"":""contactDetails"",""properties"":[{""alias"":""name"",""value"":""""},{""alias"":""address"",""value"":""""},{""alias"":""telephone"",""value"":""""},{""alias"":""mobile"",""value"":""""},{""alias"":""fax"",""value"":""""},{""alias"":""email"",""value"":""""},{""alias"":""webSite"",""value"":""""}]}]}";
+    }
+}
@@ -0,0 +1,109 @@
+<?xml version="1.0" encoding="utf-8" ?>
+<settings>
+
+  <!-- 
+    umbracoSettings.config configuration documentation can be found here: 
+    http://our.umbraco.org/documentation/using-umbraco/config-files/umbracoSettings/
+    Many of the optional settings are not explicitly listed here 
+    but can be found in the online documentation.
+    -->
+  
+  <content>
+    
+    <errors>
+      <error404>1</error404>
+      <!--
+        <error404>
+            <errorPage culture="default">1</errorPage>
+            <errorPage culture="en-US">200</errorPage>
+        </error404>
+       -->      
+    </errors>
+    
+    <notifications>
+      <!-- the email that should be used as from mail when umbraco sends a notification -->
+      <email>your@email.here</email>
+    </notifications>
+
+    <!-- Show property descriptions in editing view "icon|text|none" -->
+    <PropertyContextHelpOption>text</PropertyContextHelpOption>
+
+    <!-- The html injected into a (x)html page if Umbraco is running in preview mode -->
+    <PreviewBadge><![CDATA[<a id="umbracoPreviewBadge" style="position: absolute; top: 0; right: 0; border: 0; width: 149px; height: 149px; background: url('{1}/preview/previewModeBadge.png') no-repeat;" href="{0}/endPreview.aspx?redir={2}"><span style="display:none;">In Preview Mode - click to end</span></a>]]></PreviewBadge>
+
+    <!-- Cache cycle of Media and Member data fetched from the umbraco.library methods -->
+    <!-- In seconds. 0 will disable cache -->
+    <UmbracoLibraryCacheDuration>1800</UmbracoLibraryCacheDuration>
+
+    <!-- How Umbraco should handle errors during macro execution. Can be one of the following values:
+         - inline - show an inline error within the macro but allow the page to continue rendering. Historial Umbraco behaviour.
+         - silent - Silently suppress the error and do not render the offending macro.
+         - throw  - Throw an exception which can be caught by the global error handler defined in Application_OnError. If no such
+                    error handler is defined then you'll see the Yellow Screen Of Death (YSOD) error page.
+         Note the error can also be handled by the umbraco.macro.Error event, where you can log/alarm with your own code and change the behaviour per event. -->
+    <MacroErrors>inline</MacroErrors>
+
+    <!-- These file types will not be allowed to be uploaded via the upload control for media and content -->
+    <disallowedUploadFiles>ashx,aspx,ascx,config,cshtml,vbhtml,asmx,air,axd</disallowedUploadFiles>
+
+    <!-- Defines the default document type property used when adding properties in the back-office (if missing or empty, defaults to Textstring -->
+    <defaultDocumentTypeProperty>Textstring</defaultDocumentTypeProperty>
+  </content>
+
+  <security>
+    <!-- set to true to auto update login interval (and there by disabling the lock screen -->
+    <keepUserLoggedIn>false</keepUserLoggedIn>
+    <!-- change in 4.8: Disabled users are now showed dimmed and last in the tree. If you prefer not to display them set this to true -->
+    <hideDisabledUsersInBackoffice>false</hideDisabledUsersInBackoffice>
+  </security>
+
+  <requestHandler>
+    <!-- this will ensure that urls are unique when running with multiple root nodes -->
+    <useDomainPrefixes>false</useDomainPrefixes>
+    <!-- this will add a trailing slash (/) to urls when in directory url mode -->
+    <addTrailingSlash>true</addTrailingSlash>   
+  </requestHandler>
+
+  <templates>
+    <!-- To switch the default rendering engine to MVC, change this value from WebForms to Mvc -->
+    <defaultRenderingEngine>Mvc</defaultRenderingEngine>
+  </templates>
+
+  <scheduledTasks>
+    <!-- add tasks that should be called with an interval (seconds) -->
+    <!--    <task log="true" alias="test60" interval="60" url="http://localhost/umbraco/test.aspx"/>-->
+  </scheduledTasks>
+
+  <!-- distributed calls make umbraco use webservices to handle cache refreshing -->
+  <distributedCall enable="false">
+    <!-- the id of the user who's making the calls -->
+    <!-- needed for security, umbraco will automatically look up correct login and passwords -->
+    <user>0</user>
+    <servers>
+      <!-- add ip number or hostname, make sure that it can be reached from all servers -->
+      <!-- you can also add optional attributes to force a protocol or port number (see #2) -->
+      <!-- <server>127.0.0.1</server>-->
+      <!-- <server forceProtocol="http|https" forcePortnumber="80|443">127.0.0.1</server>-->
+    </servers>
+  </distributedCall>
+
+  <!-- 
+    web.routing
+      @trySkipIisCustomErrors
+        Tries to skip IIS custom errors.
+        Starting with IIS 7.5, this must be set to true for Umbraco 404 pages to show. Else, IIS will take
+        over and render its build-in error page. See MS doc for HttpResponseBase.TrySkipIisCustomErrors.
+        The default value is false, for backward compatibility reasons, which means that IIS _will_ take
+        over, and _prevent_ Umbraco 404 pages to show.
+      @internalRedirectPreservesTemplate
+        By default as soon as we're not displaying the initial document, we reset the template set by the
+        finder or by the alt. template. Set this option to true to preserve the template set by the finder
+        or by the alt. template, in case of an internal redirect.
+        (false by default, and in fact should remain false unless you know what you're doing)
+  -->
+  <web.routing
+    trySkipIisCustomErrors="false"
+    internalRedirectPreservesTemplate="false">
+  </web.routing>
+
+</settings>
@@ -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" />
@@ -242,11 +242,12 @@
    <Compile Include="Properties\AssemblyInfo.cs" />
    <Compile Include="Properties\VersionInfo.cs" />
    <Compile Include="PropertyConverters\ArchetypeValueConverter.cs" />
+    <Compile Include="Serialization\ArchetypeJsonDelinter.cs" />
    <Compile Include="Serialization\AsArchetypeAttribute.cs" />
+    <Compile Include="PropertyEditors\ArchetypePropertyEditor.cs" />
    <Compile Include="Serialization\ArchetypeJsonConverter.cs" />
    <Compile Include="Serialization\AsFieldsetAttribute.cs" />
    <Compile Include="Serialization\SerializationExtensions.cs" />
-    <Compile Include="PropertyEditors\ArchetypePropertyEditor.cs" />
  </ItemGroup>
  <ItemGroup>
    <None Include="app.config" />
@@ -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 || property.Value == null || string.IsNullOrEmpty(property.Value.ToString()))
+            if (IsEmptyProperty(property)) 
+            {
                return default(T);
+            }

            return property.GetValue<T>();
        }

+        // issue 142: support default T value supplied by caller
+        // this code would look nicer if the two GetValue<T>() methods had one common implementation.
+        // however, this would require GetValue<T>(string propertyAlias) to call the common implementation
+        // with a default(T) value, which could in theory result in a performance hit, if T for some reason
+        // is costly to instantiate.
+        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;
@@ -1,7 +1,8 @@
 using System;
 using System.Collections;
 using System.Collections.Generic;
-using System.Linq;
+using System.Linq;
+using Archetype.Serialization;
 using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;

@@ -20,7 +21,7 @@ namespace Archetype.Models

        public IEnumerator<ArchetypeFieldsetModel> GetEnumerator()
        {
-            return this.Fieldsets.GetEnumerator();
+            return this.Fieldsets.Where(f => f.Disabled == false).GetEnumerator();
        }

        IEnumerator IEnumerable.GetEnumerator()
@@ -38,7 +39,7 @@ namespace Archetype.Models
              .ToList()
              .ForEach(x => x.Remove());

-            return json.ToString(Formatting.None);
+            return json.ToString(Formatting.None).DelintArchetypeJson();
        }
    }
 }
@@ -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; }

@@ -1,4 +1,4 @@
 using System.Reflection;

-[assembly: AssemblyVersion("1.2.1")]
-[assembly: AssemblyFileVersion("1.2.1-beta")]
+[assembly: AssemblyVersion("1.3.0")]
+[assembly: AssemblyFileVersion("1.3.0-beta")]
@@ -1,3 +1,4 @@
+using System;
 using Archetype.Extensions;
 using Archetype.Models;
 using Umbraco.Core;
@@ -19,7 +20,8 @@ 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)
@@ -34,7 +36,7 @@ namespace Archetype.PropertyConverters
            if (!sourceString.DetectIsJson())
                return defaultValue;

-            using (var timer = DisposableTimer.DebugDuration<ArchetypeValueConverter>(string.Format("ConvertDataToSource ({0})", propertyType.PropertyTypeAlias)))
+			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),
@@ -123,8 +123,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)
@@ -135,7 +135,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	
@@ -6,6 +6,7 @@ using System.IO;
 using System.Linq;
 using System.Reflection;
 using System.Text;
+using Archetype.Models;
 using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;

@@ -13,6 +14,10 @@ namespace Archetype.Serialization
 {
    public class ArchetypeJsonConverter : JsonConverter
    {
+        private const string _ROOT_FS_ALIAS = "rootFs";
+        
+        #region public methods
+
        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
        {
            var models = GenerateModels(value);
@@ -23,13 +28,7 @@ namespace Archetype.Serialization
            if (models.Count == 1 && models[0] == null) 
                return;

-            var jObj = new JObject
-            {
-                {
-                    "fieldsets", 
-                     new JArray( new JRaw(SerializeModels(models)))
-                }
-            };
+            var jObj = SerializeModelToFieldset(models);

            writer.WriteRaw(ApplyFormatting(jObj.ToString(), writer.Formatting));
        }
@@ -41,25 +40,268 @@ namespace Archetype.Serialization
            if (jToken == null)
                return null;

-            var obj = Activator.CreateInstance(objectType);
-
-            if (null != obj as IEnumerable<object>
-                && jToken["fieldsets"] != null && jToken["fieldsets"].Any())
-            {
-                return DeserializeEnumerableObject(obj, jToken);
-            }
-
-            return null == jToken as JArray 
-                        ? DeserializeObject(obj, jToken) 
-                        : PopulateProperties(obj, jToken);
+            return DeserializeJson(objectType, GetDelintedJToken(jToken));
        }

        public override bool CanConvert(Type objectType)
        {
-            return IsValueArchetypeDatatype(objectType);
+            return IsTypeArchetypeDatatype(objectType);
        }

-        #region private methods
+        #endregion
+
+        #region private methods - deserialization
+
+        private JToken GetDelintedJToken(JToken jToken)
+        {
+            return JToken.Parse(jToken.ToString(Formatting.None).DelintArchetypeJson());
+        }
+
+        private object DeserializeJson(Type objectType, JToken jToken)
+        {
+
+            var obj = Activator.CreateInstance(objectType);
+
+            if (null != obj as IEnumerable<object>)
+            {
+                JToken enumerableToken;
+
+                if (TryParseJTokenAsEnumerable(jToken, out enumerableToken)
+                    || (jToken.SelectToken("value") != null && TryParseJTokenAsEnumerable(jToken["value"], out enumerableToken)))
+                    return DeserializeEnumerableObject(obj, enumerableToken);
+            }
+
+            return null == jToken as JArray
+                        ? DeserializeObject(obj, jToken)
+                        : PopulateProperties(obj, jToken);
+        }
+
+        private object DeserializeEnumerableObject(object obj, JToken jToken)
+        {
+            var model = obj as IEnumerable<object>;
+            var fsToken = jToken;
+
+            var itemType = model.GetType().GetGenericArguments().FirstOrDefault();
+
+            if (itemType == null)
+            {
+                itemType = model.GetType().BaseType.GetGenericArguments().First();
+                fsToken = fsToken["fieldsets"];
+            }
+
+            foreach (var fs in fsToken.Where(fs => fs["alias"].ToString().Equals(GetFieldsetName(itemType))))
+            {
+                var item = DeserializeJson(itemType, fs["properties"]);
+
+                obj.GetType().GetMethod("Add").Invoke(obj, new[] { item });
+            }
+
+            return obj;
+        }
+
+        private object DeserializeObject(object obj, JToken jToken)
+        {
+            if (jToken.SelectToken("value") != null
+                && String.IsNullOrEmpty(jToken.SelectToken("value").ToString()))
+                return obj;
+            
+            var properties = GetSerialiazableProperties(obj).ToList();
+            var asFieldset = properties.Where(HasAsFieldsetAttribute).ToList();
+
+            foreach (var propInfo in asFieldset)
+            {
+                var propAlias = GetJsonPropertyName(propInfo);
+                var fsJToken = propInfo.PropertyType.Namespace.Equals("System") 
+                                ? GetFieldsetJTokenFromAlias(propAlias, jToken)
+                                : GetFieldsetJTokenFromPropertyAlias(propInfo, jToken);
+
+                var propJToken = GetPropertyJToken(fsJToken, propAlias);
+
+                if (propJToken == null)
+                    continue;
+
+                var propValue = GetPropertyValue(propInfo, propJToken);
+
+                propInfo.SetValue(obj, propValue);
+            }
+
+            if (properties.All(HasAsFieldsetAttribute))
+                return obj;
+
+            var objToken = GetFieldsetJTokenFromTypeAlias(obj.GetType(), jToken);
+
+            if (objToken == null)
+                return obj;
+
+            if (objToken.SelectToken("properties") != null)
+                return PopulateProperties(obj, objToken["properties"]);
+
+            if ((objToken is JArray) && (objToken as JArray).Count <= 0)
+                return null;
+
+            if (!(objToken is JArray))
+                return PopulateProperties(obj, new JArray(objToken));
+
+            var defaultFsProperties = properties.Where(pInfo => !HasAsFieldsetAttribute(pInfo)).ToList();                
+
+            foreach (var property in defaultFsProperties)
+            {
+                var propJToken = ParseJTokenFromItems(objToken, GetJsonPropertyName(property));
+                PopulateProperty(obj, propJToken["properties"], property);
+            }
+
+            return PopulateProperties(obj, new JArray(objToken));
+        }
+
+        private JToken GetPropertyJToken(JToken fsJToken, string propAlias)
+        {
+            if (fsJToken == null)
+                return null;
+            
+            //make recursive
+            if (fsJToken.SelectToken("properties") != null)
+                return GetPropertyAliasJToken(propAlias, fsJToken["properties"]);
+
+            var nestedPropJToken = fsJToken
+                .SingleOrDefault(p => p.SelectToken("alias").ToString().Equals(propAlias));
+
+            return nestedPropJToken != null ? GetPropertyAliasJToken(propAlias, nestedPropJToken["properties"]) : null;
+        }
+
+        private JToken GetFieldsetJTokenFromTypeAlias(Type objType, JToken jToken)
+        {
+            var objAlias = GetFieldsetName(objType);
+            return GetFieldsetJTokenFromAlias(objAlias, jToken);
+        }
+
+        private JToken GetFieldsetJTokenFromPropertyAlias(PropertyInfo propInfo, JToken jToken)
+        {
+            var objAlias = GetJsonPropertyName(propInfo);
+            return GetFieldsetJTokenFromAlias(objAlias, jToken);
+        }
+
+        private JToken GetFieldsetJTokenFromAlias(string objAlias, JToken jToken)
+        {
+            JToken propJToken;
+
+            if (TryParseJTokenFromNamedFieldset(jToken, objAlias, out propJToken))
+                return propJToken;
+
+            if (TryParseJTokenFromNestedFieldset(jToken, objAlias, out propJToken))
+                return propJToken;
+
+            if (TryParseJTokenFromDefaultFieldset(jToken, out propJToken))
+                return propJToken;
+
+            return propJToken
+                        ?? ParseJTokenFromItem(jToken, objAlias);
+        }
+
+        private object PopulateProperties(object obj, JToken jToken)
+        {
+            var properties = GetSerialiazableProperties(obj);
+
+            foreach (var propertyInfo in properties)
+            {
+                PopulateProperty(obj, jToken, propertyInfo);
+            }
+
+            return obj;
+        }
+
+        private void PopulateProperty(object obj, JToken jToken, PropertyInfo propertyInfo)
+        {
+            var propAlias = GetJsonPropertyName(propertyInfo);
+            var propJToken = GetPropertyAliasJToken(propAlias, jToken);
+
+            if (propJToken == null)
+                return;
+
+            var propValue = GetPropertyValue(propertyInfo, propJToken);
+            propertyInfo.SetValue(obj, propValue);
+        }
+
+        private JToken GetPropertyAliasJToken(string propAlias, JToken jToken)
+        {
+            return jToken.SingleOrDefault(p => p.SelectToken("alias").ToString().Equals(propAlias));
+        }
+
+        private object GetPropertyValue(PropertyInfo propertyInfo, JToken propJToken)
+        {
+            return IsTypeArchetypeDatatype(propertyInfo.PropertyType)
+                ? DeserializeJson(propertyInfo.PropertyType, propJToken)
+                    : IsTypeIEnumerableArchetypeDatatype(propertyInfo.PropertyType)
+                    ? DeserializeJson(propertyInfo.PropertyType, propJToken["value"].SelectToken("fieldsets"))
+                : GetDeserializedPropertyValue(propJToken, propertyInfo.PropertyType);
+        }
+
+        private JToken ParseJTokenFromItem(JToken jToken, string itemAlias)
+        {
+            return (jToken.SelectToken("alias") != null && jToken["alias"].ToString().Equals(itemAlias))
+                    ? jToken
+                    : null;
+        }
+
+        private JToken ParseJTokenFromItems(JToken jToken, string itemAlias)
+        {
+            return jToken.SingleOrDefault(jT => ParseJTokenFromItem(jT, itemAlias) != null);
+        }
+
+        private bool TryParseJTokenFromNamedFieldset(JToken jToken, string objAlias, out JToken resultToken)
+        {
+            resultToken = null;
+
+            if (jToken.SelectToken("fieldsets") == null)
+                return false;
+
+            resultToken = jToken["fieldsets"].SingleOrDefault(p => p.SelectToken("alias").ToString().Equals(objAlias));
+
+            return resultToken != null;
+        }
+
+        private bool TryParseJTokenFromNestedFieldset(JToken jToken, string objAlias, out JToken resultToken)
+        {
+            resultToken = null;
+
+            if (jToken.SelectToken("value") == null || !jToken["value"].HasValues
+                                    || jToken["value"]["fieldsets"] == null)
+                return false;
+
+            resultToken = jToken["value"]["fieldsets"].SingleOrDefault(p => p.SelectToken("alias").ToString().Equals(objAlias));
+
+            return resultToken != null;
+        }
+
+        private bool TryParseJTokenFromDefaultFieldset(JToken jToken, out JToken resultToken)
+        {
+            resultToken = jToken.SelectToken("fieldsets");
+
+            return resultToken != null;
+        }
+
+        private bool TryParseJTokenAsEnumerable(JToken jToken, out JToken resultToken)
+        {
+            resultToken = null;
+            
+            //To Do: Strange newtonsoft behaviour
+            var fsToken = jToken.Parent != null
+                ? jToken.Parent.Children().First() is JArray
+                    ? jToken.Parent.Children().First()
+                    : jToken.Parent.Children().First()["fieldsets"] 
+                : jToken.SelectToken("fieldsets");
+
+            var jTokenEnumerable = jToken != null
+                && fsToken != null && fsToken is JArray;
+
+            if (jTokenEnumerable)
+                resultToken = jToken;
+
+            return jTokenEnumerable;
+        }
+
+        #endregion
+
+        #region private methods - serialization

        private string ApplyFormatting(string json, Formatting formatting)
        {
@@ -78,113 +320,52 @@ namespace Archetype.Serialization
            if (!PropertyLayoutHasFieldsets(properties))
                return new List<object>() { value };

-            var dynamicModel = new ExpandoObject() as IDictionary<string, object>;
+            models = new List<object>();
+
+            var fieldsetModels = properties.Where(HasAsFieldsetAttribute)
+                .Select(pInfo =>
+                {
+                    var fsModel = GetDynamicModel(GetJsonPropertyName(pInfo));
+                    fsModel.Add(GetJsonPropertyName(pInfo), pInfo.GetValue(value));
+                    return fsModel;
+                });
+
+            models = ((IEnumerable<object>)models).Concat(fieldsetModels).ToList();
+
+            var remainingProps = properties.Where(pInfo => !HasAsFieldsetAttribute(pInfo)).ToList();
+
+            if (!remainingProps.Any())
+                return models;
+
+            var dynamicModel = GetDynamicModel(GetFieldsetName(value.GetType()));

            foreach (var pInfo in properties.Where(pInfo => !HasAsFieldsetAttribute(pInfo)))
            {
                dynamicModel.Add(GetJsonPropertyName(pInfo), pInfo.GetValue(value));
            }

-            var fieldsetModels = properties.Where(HasAsFieldsetAttribute)
-                .Select(pInfo => pInfo.GetValue(value));
-
-            models = new List<object>
-            {
-                dynamicModel,                
-            };
-
-            models = ((IEnumerable<object>)models).Concat(fieldsetModels).ToList();
+            models.Add(dynamicModel);

            return models;
        }

-        private object DeserializeEnumerableObject(object obj, JToken jToken)
+        private IDictionary<string, object> GetDynamicModel(string rootFsAlias)
        {
-            var model = obj as IEnumerable<object>;
+            var dynamicModel = new ExpandoObject() as IDictionary<string, object>;
+            dynamicModel.Add(_ROOT_FS_ALIAS, rootFsAlias);
+            return dynamicModel;
+        }

-            var itemType = model.GetType().BaseType.GetGenericArguments().First();
-            foreach (var fs in jToken["fieldsets"].Where(fs => fs["alias"].ToString().Equals(GetFieldsetName(itemType))))
+        private JObject SerializeModelToFieldset(IEnumerable models)
+        {
+            var jObj = new JObject
            {
-                var item = JsonConvert.DeserializeObject(
-                    fs["properties"].ToString(), itemType, GetArchetypeDatatypeConverter());
-
-                obj.GetType().GetMethod("Add").Invoke(obj, new[] { item });
-            }
-
-            return obj;
-        }
-
-        private object DeserializeObject(object obj, JToken jToken)
-        {
-            var properties = GetSerialiazableProperties(obj).ToList();
-            var asFieldset = properties.Where(HasAsFieldsetAttribute).ToList();
-
-            foreach (var propInfo in asFieldset)
-            {
-                var propAlias = GetJsonPropertyName(propInfo);
-                var fsJToken = GetFieldsetProperties(propInfo.PropertyType, jToken);
-                var propJToken =
-                    fsJToken.Single(p => p.SelectToken("alias").ToString().Equals(propAlias));
-
-                if (propJToken == null)
-                    continue;
-
-                var propValue = IsValueArchetypeDatatype(propInfo.PropertyType)
-                ? JsonConvert.DeserializeObject(fsJToken.ToString(), propInfo.PropertyType,
-                    GetArchetypeDatatypeConverter())
-                : GetDeserializedPropertyValue(fsJToken, propInfo.PropertyType); ;
-
-                propInfo.SetValue(obj, propValue);
-            }
-
-            return PopulateProperties(obj, GetFieldsetProperties(obj.GetType(), jToken));
-        }
-
-        private JToken GetFieldsetProperties(Type objType, JToken jToken)
-        {
-            var objAlias = GetFieldsetName(objType);
-            return
-                jToken["fieldsets"].Single(p => p.SelectToken("alias").ToString().Equals(objAlias)).SelectToken("properties");
-        }
-
-        private object PopulateProperties(object obj, JToken jToken)
-        {
-            var properties = GetSerialiazableProperties(obj);
-
-            foreach (var propertyInfo in properties)
-            {
-                var propAlias = GetJsonPropertyName(propertyInfo);
-
-                var propJToken = jToken.SingleOrDefault(p => p.SelectToken("alias").ToString().Equals(propAlias));
-
-                if (propJToken == null)
-                    continue;
-
-                var propValue = GetPropertyValue(propertyInfo, propJToken);
-
-                propertyInfo.SetValue(obj, propValue);
-            }
-
-            return obj;
-        }
-
-        private object GetPropertyValue(PropertyInfo propertyInfo, JToken propJToken)
-        {
-            return IsValueArchetypeDatatype(propertyInfo.PropertyType)
-                ? JsonConvert.DeserializeObject(propJToken["value"].ToString(), propertyInfo.PropertyType,
-                    GetArchetypeDatatypeConverter())
-                : GetDeserializedPropertyValue(propJToken["value"], propertyInfo.PropertyType);
-        }
-
-        private bool PropertyLayoutHasFieldsets(IEnumerable<PropertyInfo> properties)
-        {
-            return properties.Any(HasAsFieldsetAttribute);
-        }
-
-        private static bool HasAsFieldsetAttribute(PropertyInfo pInfo)
-        {
-            return pInfo
-                .GetCustomAttributes(typeof(AsFieldsetAttribute), true).Length > 0;
+                {
+                    "fieldsets",
+                    new JArray(new JRaw(SerializeModels(models)))
+                }
+            };
+            return jObj;
        }

        private IEnumerable SerializeModels(IEnumerable models)
@@ -200,7 +381,7 @@ namespace Archetype.Serialization
                return null;

            var jObj = IsExpandoObject(value) 
-                ? GetJObjectFromExpandoObject(value as IDictionary<string, object>) 
+                ? GetJObjectFromExpandoObject(value as IDictionary<string, object>)
                : GetJObject(value);

            var fieldsetJson = new StringBuilder();
@@ -214,31 +395,48 @@ namespace Archetype.Serialization
            return fieldsetJson.ToString();
        }

+        private bool PropertyLayoutHasFieldsets(IEnumerable<PropertyInfo> properties)
+        {
+            return properties.Any(HasAsFieldsetAttribute);
+        }
+
+        private static bool HasAsFieldsetAttribute(PropertyInfo pInfo)
+        {
+            return pInfo
+                .GetCustomAttributes(typeof(AsFieldsetAttribute), true).Length > 0;
+        }
+
        private bool IsExpandoObject(object value)
        {
            return value.GetType().Name.Equals(typeof (ExpandoObject).Name);
        }

-        private JObject GetJObjectFromExpandoObject(IEnumerable<KeyValuePair<string, object>> obj)
+        private JObject GetJObjectFromExpandoObject(IDictionary<string, object> expandoObj)
        {
-            var property = obj.ElementAt(0);
-            var alias = property.Key;
-            var value = property.Value;
-
            var jObj = new JObject
-                {
-                    {
-                        "alias",
-                        new JValue(alias)
-                    }
-                };
-
-            var fsProperties = new List<JObject>
            {
-                new JObject {new JProperty("alias", alias), new JProperty("value", value)}
+                {
+                    "alias",
+                    new JValue(expandoObj[_ROOT_FS_ALIAS])
+                }
            };
-            jObj.Add("properties", new JRaw(JsonConvert.SerializeObject(fsProperties)));

+            var fsProperties = new List<JObject>();
+
+            foreach (var item in expandoObj.SkipWhile(i => i.Key.Equals(_ROOT_FS_ALIAS)))
+            {
+                var property = item;
+                var alias = property.Key;
+                var value = property.Value;
+
+                fsProperties.Add(new JObject 
+                {
+                    new JProperty("alias", alias), 
+                    new JProperty("value", value != null ? JToken.FromObject(value) : value)
+                });                
+            }
+
+            jObj.Add("properties", new JRaw(JsonConvert.SerializeObject(fsProperties)));
            return jObj;
        }

@@ -252,7 +450,7 @@ namespace Archetype.Serialization
                    }
                };

-            var properties = GetSerialiazableProperties(obj);
+            var properties = GetProperties(obj);

            var fsProperties = new List<JObject>();

@@ -262,14 +460,12 @@ namespace Archetype.Serialization
                var jProperty = new JProperty("alias", GetJsonPropertyName(propertyInfo));
                fsProperty.Add(jProperty);

-                var propValue = propertyInfo.GetValue(obj, null);
+                var propValue = propertyInfo.GetIndexParameters().Length == 0 
+                                    ? propertyInfo.GetValue(obj, null)
+                                    : obj as string;

                fsProperty.Add(
-                    new JProperty("value",
-                                  IsValueArchetypeDatatype(propValue)
-                                      ? new JRaw(JsonConvert.SerializeObject(propValue,
-                                                                             GetArchetypeDatatypeConverter()))
-                                      : new JValue(GetSerializedPropertyValue(propValue))));
+                    new JProperty("value", GetJPropertyValue(propValue)));

                fsProperties.Add(fsProperty);
            }
@@ -279,11 +475,29 @@ namespace Archetype.Serialization
            return jObj;
        }

+        private object GetJPropertyValue(object value)
+        {
+            return IsValueArchetypeDatatype(value)
+                ? new JRaw(JsonConvert.SerializeObject(value))
+                : IsValueIEnumerableArchetypeDatatype(value)
+                    ? new JRaw(SerializeModelToFieldset(value as IEnumerable))
+                    : new JValue(GetSerializedPropertyValue(value));
+        }
+
+        private IEnumerable<PropertyInfo> GetProperties(object obj)
+        {
+            if (obj.GetType() !=  typeof(string))
+                return GetSerialiazableProperties(obj);
+
+            var indexer = ((DefaultMemberAttribute)obj.GetType()
+                .GetCustomAttributes(typeof(DefaultMemberAttribute), true)[0]).MemberName;
+
+            return new List<PropertyInfo> { obj.GetType().GetProperty(indexer) };
+        }
+
        private IEnumerable<PropertyInfo> GetSerialiazableProperties(object obj)
        {
-            return obj.GetType()
-                .GetProperties(BindingFlags.Instance | BindingFlags.Public)
-                .Where(prop => !Attribute.IsDefined(prop, typeof(JsonIgnoreAttribute)));
+            return obj.GetSerialiazableProperties();
        }

        private string GetJsonPropertyName(PropertyInfo property)
@@ -302,22 +516,6 @@ namespace Archetype.Serialization
            return archetypeDatatypeAttribute != null ? archetypeDatatypeAttribute.FieldsetName : type.Name;
        }

-        private bool IsValueArchetypeDatatype(object value)
-        {
-            return value != null &&
-                IsValueArchetypeDatatype(value.GetType());
-        }
-
-        private bool IsValueArchetypeDatatype(Type type)
-        {
-            return type.GetCustomAttributes(typeof(AsArchetypeAttribute), true).Length > 0;
-        }
-
-        private JsonConverter GetArchetypeDatatypeConverter()
-        {
-            return (JsonConverter)Activator.CreateInstance(GetType());
-        }
-
        private string GetSerializedPropertyValue(object propValue)
        {
            if (propValue == null)
@@ -330,18 +528,20 @@ namespace Archetype.Serialization
        }

        private object GetDeserializedPropertyValue(JToken jToken, Type type)
-        {            
-            if (String.IsNullOrEmpty(jToken.ToString()))
-                return GetDefault(type);
+        {
+            return String.IsNullOrEmpty(jToken.ToString()) 
+                        ? GetDefault(type) 
+                        : GetTypedValue(jToken, type);
+        }

-            var localType = Nullable.GetUnderlyingType(type) ?? type;
+        private object GetTypedValue(JToken jToken, Type type)
+        {
+            var property = JsonConvert.DeserializeObject<ArchetypePropertyModel>(jToken.ToString());

-            if (localType == typeof(bool))
-                return jToken.ToString() == "1";
+            var method = typeof(ArchetypePropertyModel).GetMethod("GetValue");
+            var getValue = method.MakeGenericMethod(type);

-            return localType == typeof(DateTime) 
-                ? Convert.ToDateTime(jToken.ToString())
-                : jToken.ToObject(localType);
+            return getValue.Invoke(property, null);
        }

        private object GetDefault(Type type)
@@ -350,5 +550,36 @@ namespace Archetype.Serialization
        }

        #endregion
+
+        #region private methods - common
+
+        private bool IsValueIEnumerableArchetypeDatatype(object value)
+        {
+            if (value as IEnumerable != null && value.GetType().IsGenericType)
+                return IsTypeArchetypeDatatype(value.GetType().GetGenericArguments()[0]);
+
+            return false;
+        }
+
+        private bool IsTypeIEnumerableArchetypeDatatype(Type type)
+        {
+            if (typeof(IEnumerable).IsAssignableFrom(type) && type.IsGenericType)
+                return IsTypeArchetypeDatatype(type.GetGenericArguments()[0]);
+
+            return false;
+        }
+
+        private bool IsValueArchetypeDatatype(object value)
+        {
+            return value != null &&
+                IsTypeArchetypeDatatype(value.GetType());
+        }
+
+        private bool IsTypeArchetypeDatatype(Type type)
+        {
+            return type.GetCustomAttributes(typeof(AsArchetypeAttribute), true).Length > 0;
+        }
+
+        #endregion
    }
 }
@@ -0,0 +1,105 @@
+using System;
+using System.Linq;
+using System.Collections.Generic;
+using System.Text.RegularExpressions;
+
+namespace Archetype.Serialization
+{
+    public enum DelinterStep
+    {     
+        RemoveNewLine = 0,
+        RemoveWhiteSpace,
+        UnescapeLabels,
+        UnescapeAlias,
+        UnescapeValues,
+        FixNestedFieldsets
+    }
+
+    public enum DelinterAction
+    {
+        Remove = 0,
+        RemoveWhiteSpace,
+        UnescapeLabels,
+        UnescapeValues,
+        FixNestedFieldsets
+    }
+    
+    public class ArchetypeJsonDelinter
+    {
+        public IDictionary<DelinterStep, DelinterAction> Pipeline { get; private set; }
+        public IDictionary<DelinterStep, Regex> Tokens { get; private set; }
+        public IDictionary<DelinterAction, Func<string, Regex, string>> Actions { get; private set; }
+
+        public ArchetypeJsonDelinter()
+        {
+            Init();
+        }
+
+        public string Execute(string input)
+        {
+            var buffer = input;
+
+            foreach (var step in Pipeline.Keys)
+            {
+                var action = Pipeline[step];
+                buffer = Actions[action](buffer, Tokens[step]);             
+            }
+
+            return buffer;
+        }
+
+        private void Init()
+        {
+            Tokens = new Dictionary<DelinterStep, Regex>
+            {
+                {DelinterStep.RemoveNewLine, new Regex(@"(?<=\,){0,1}(\\+r\\+n)(?=\\*?""(alias|value|properties|fieldsets)\\*?"":\{*?(\\*|""|\[))|(\r|\n)+|(\\+r\\+n)(?=\s*?(\{|\}|\]))|(\\+r\\n+)(?=\s+\\*?""(alias|value|properties|fieldsets))")},                
+                {DelinterStep.RemoveWhiteSpace, new Regex(@"(""\S+?"":)(\s+?)("")|([\{\[\}\],]|(?<!\\)"")(\s+)([\{\[\}\],]|(?<!\\)"")")},
+                {DelinterStep.UnescapeLabels, new Regex(@"\\+""(fieldsets|properties|alias|value)\\+"":(\s*)")},
+                {DelinterStep.UnescapeAlias, new Regex(@"""(alias)"":\\+""(.*?)\\+""")},
+                {DelinterStep.UnescapeValues, new Regex(@"""(value)"":\\+""(.*?)\\+""(?=\s*?\})")},
+                {DelinterStep.FixNestedFieldsets, new Regex(@"""(value)"":\s*?""\{\s*?(""fieldsets""[\S\s]+?)}""")}
+            };
+
+            Actions = new Dictionary<DelinterAction, Func<string, Regex, string>>
+            {
+                {DelinterAction.Remove, (input, pattern) =>
+                    RecursiveReplace(input, pattern, match => String.Empty)
+                },
+                {DelinterAction.RemoveWhiteSpace, (input, pattern) =>
+                    RecursiveReplace(input.Trim(), pattern, match =>
+                        String.Format("{0}{1}{2}{3}", match.Groups[1].Value, 
+                            match.Groups[3].Value, match.Groups[4].Value, match.Groups[6].Value))
+                },
+                {DelinterAction.UnescapeLabels, (input, pattern) =>
+                    RecursiveReplace(input, pattern, match => String.Format(@"""{0}"":", match.Groups[1].Value))
+                },
+                {DelinterAction.UnescapeValues, (input, pattern) =>
+                    RecursiveReplace(input, pattern, match => String.Format(@"""{0}"":""{1}""", match.Groups[1].Value, match.Groups[2].Value))
+                },
+                {DelinterAction.FixNestedFieldsets, (input, pattern) =>
+                    RecursiveReplace(input, pattern, match => String.Format(@"""{0}"":{{{1}}}", match.Groups[1].Value, match.Groups[2].Value))
+                }
+            };
+            
+            Pipeline = new Dictionary<DelinterStep, DelinterAction>
+            {
+                {DelinterStep.RemoveNewLine, DelinterAction.Remove},                                              
+                {DelinterStep.UnescapeLabels, DelinterAction.UnescapeLabels},
+                {DelinterStep.UnescapeAlias, DelinterAction.UnescapeValues},
+                {DelinterStep.UnescapeValues, DelinterAction.UnescapeValues},
+                {DelinterStep.FixNestedFieldsets, DelinterAction.FixNestedFieldsets},
+                {DelinterStep.RemoveWhiteSpace, DelinterAction.RemoveWhiteSpace},  
+            };
+        }
+
+        private string RecursiveReplace(string input, Regex pattern, Func<Match, string> matchFunc)
+        {
+            var buffer = input;
+            while (pattern.IsMatch(buffer))
+            {
+                buffer = pattern.Replace(buffer, match => matchFunc(match));
+            }
+            return buffer;            
+        }
+    }
+}
@@ -3,6 +3,8 @@ using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
+using System.Reflection;
+using Archetype.Extensions;
 using Newtonsoft.Json;
 using Umbraco.Core.Models;
 using Umbraco.Web;
@@ -20,6 +22,16 @@ namespace Archetype.Serialization
            return (string)contentPage.Properties.Single(p => p.PropertyTypeAlias == propertyAlias).DataValue;
        }

+        public static IEnumerable<PropertyInfo> GetSerialiazableProperties(this object obj)
+        {
+            if (obj == null)
+                return new List<PropertyInfo>();
+            
+            return obj.GetType()
+                .GetProperties(BindingFlags.Instance | BindingFlags.Public)
+                .Where(prop => !Attribute.IsDefined(prop, typeof(JsonIgnoreAttribute)));
+        }
+
        public static T GetModelFromArchetype<T>(this IPublishedContent content,
            string cmsFieldAlias, bool returnInstanceIfNull = false)
            where T : class, new()
@@ -28,5 +40,14 @@ namespace Archetype.Serialization
            return JsonConvert.DeserializeObject<T>(archetypeJson) ??
                   (returnInstanceIfNull ? Activator.CreateInstance<T>() : default(T));
        }
+
+        public static string DelintArchetypeJson(this string input)
+        {
+            if (!input.DetectIsJson())
+                return String.Empty;
+
+            var delinter = new ArchetypeJsonDelinter();
+            return delinter.Execute(input);
+        }
    }
 }
@@ -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, "fieldsets": [' + newFieldsetModel + ']}');

    //ini the model
    $scope.model.value = $scope.model.value || defaultFieldsetConfigModel;
@@ -11,6 +11,10 @@

    //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();

    //helper to get $eval the labelTemplate
@@ -83,6 +87,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 +118,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 +278,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) {
@@ -1,23 +1,13 @@
 angular.module("umbraco.directives").directive('archetypeCustomView', function ($compile, $http) {
    var linker = function (scope, element, attrs) {

-        var config = scope.archetype.config.archetypeConfig;
-
        var view = "/App_plugins/Archetype/views/archetype.default.html";
-        if(config.customViewPath) {
+        if(scope.model.config.customViewPath) {
            view = config.customViewPath;
        }

        $http.get(view).then(function(data) {

-            scope.model = {};
-            scope.model.value = scope.archetype.value;
-            scope.model.config = scope.archetype.config;
-
-            scope.$watch('model.value', function (newValue, oldValue) {
-                scope.archetype.value = newValue;
-            });
-
            element.html(data.data).show();

            $compile(element.contents())(scope);
@@ -27,9 +17,6 @@ angular.module("umbraco.directives").directive('archetypeCustomView', function (
    return {
        restrict: "A",
        replace: true,
-        link: linker,
-        scope: {
-            archetype: "="
-        }
+        link: linker
    }
 });
@@ -55,7 +55,8 @@ 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 = [];
        // initialize container for invalid fieldset property identifiers (store on ngModelCtrl to separate Archetype validations, e.g. when there two Archetype properties on the same document)
        if(ngModelCtrl.invalidProperties == null) {
            ngModelCtrl.invalidProperties = [];
@@ -85,7 +86,7 @@ angular.module("umbraco.directives").directive('archetypeProperty', function ($c

                var mergedConfig = _.extend(defaultConfigObj, config);

-                loadView(pathToView, mergedConfig, defaultValue, alias, umbracoPropertyAlias, scope, element, ngModelCtrl, validateProperty);
+                loadView(pathToView, mergedConfig, defaultValue, alias, propertyAlias, scope, element, ngModelCtrl, validateProperty);
            });
        });

@@ -155,7 +156,27 @@ angular.module("umbraco.directives").directive('archetypeProperty', function ($c
        }
    }

-    function loadView(view, config, defaultValue, alias, umbracoPropertyAlias, scope, element, ngModelCtrl, validateProperty) {
+    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, validateProperty) {
        if (view)
        {
            $http.get(view).success(function (data) {
@@ -184,7 +205,7 @@ angular.module("umbraco.directives").directive('archetypeProperty', function ($c
                    scope.model.config = 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) {
@@ -31,5 +31,7 @@
 	"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."
 }
@@ -31,5 +31,7 @@
 	"properties": "Properties",
 	"labelTemplate": "Label Template",
 	"select": "Select",
-	"icon": "Icon"
+	"icon": "Icon",
+	"enableDisabling": "Enable Fieldset Disabling?",
+	"enableDisablingDescription": "Allows fieldsets to be individually enabled/disabled."
 }
@@ -31,5 +31,7 @@
 	"properties": "Properties",
 	"labelTemplate": "Label Template",
 	"select": "Select",
-	"icon": "Icon"
+	"icon": "Icon",
+	"enableDisabling": "Enable Fieldset Disabling?",
+	"enableDisablingDescription": "Allows fieldsets to be individually enabled/disabled."
 }
@@ -31,5 +31,7 @@
 	"properties": "Properties",
 	"labelTemplate": "Label Template",
 	"select": "Select",
-	"icon": "Icon"
+	"icon": "Icon",
+	"enableDisabling": "Enable Fieldset Disabling?",
+	"enableDisablingDescription": "Allows fieldsets to be individually enabled/disabled."
 }
@@ -31,5 +31,7 @@
 	"properties": "Properties",
 	"labelTemplate": "Label Template",
 	"select": "Select",
-	"icon": "Icon"
+	"icon": "Icon",
+	"enableDisabling": "Enable Fieldset Disabling?",
+	"enableDisablingDescription": "Allows fieldsets to be individually enabled/disabled."
 }
@@ -31,5 +31,7 @@
 	"properties": "Properties",
 	"labelTemplate": "Label Template",
 	"select": "Select",
-	"icon": "Icon"
+	"icon": "Icon",
+	"enableDisabling": "Enable Fieldset Disabling?",
+	"enableDisablingDescription": "Allows fieldsets to be individually enabled/disabled."
 }
@@ -31,5 +31,7 @@
 	"properties": "Properties",
 	"labelTemplate": "Label Template",
 	"select": "Select",
-	"icon": "Icon"
+	"icon": "Icon",
+	"enableDisabling": "Enable Fieldset Disabling?",
+	"enableDisablingDescription": "Allows fieldsets to be individually enabled/disabled."
 }
@@ -31,5 +31,7 @@
 	"properties": "Properties",
 	"labelTemplate": "Label Template",
 	"select": "Select",
-	"icon": "Icon"
+	"icon": "Icon",
+	"enableDisabling": "Enable Fieldset Disabling?",
+	"enableDisablingDescription": "Allows fieldsets to be individually enabled/disabled."
 }
@@ -31,5 +31,7 @@
 	"properties": "Properties",
 	"labelTemplate": "Label Template",
 	"select": "Select",
-	"icon": "Icon"
+	"icon": "Icon",
+	"enableDisabling": "Enable Fieldset Disabling?",
+	"enableDisablingDescription": "Allows fieldsets to be individually enabled/disabled."
 }
@@ -31,5 +31,7 @@
 	"properties": "Properties",
 	"labelTemplate": "Label Template",
 	"select": "Select",
-	"icon": "Icon"
+	"icon": "Icon",
+	"enableDisabling": "Enable Fieldset Disabling?",
+	"enableDisablingDescription": "Allows fieldsets to be individually enabled/disabled."
 }
@@ -31,5 +31,7 @@
 	"properties": "Properties",
 	"labelTemplate": "Label Template",
 	"select": "Select",
-	"icon": "Icon"
+	"icon": "Icon",
+	"enableDisabling": "Enable Fieldset Disabling?",
+	"enableDisablingDescription": "Allows fieldsets to be individually enabled/disabled."
 }
@@ -31,5 +31,7 @@
 	"properties": "Properties",
 	"labelTemplate": "Label Template",
 	"select": "Select",
-	"icon": "Icon"
+	"icon": "Icon",
+	"enableDisabling": "Enable Fieldset Disabling?",
+	"enableDisablingDescription": "Allows fieldsets to be individually enabled/disabled."
 }
@@ -31,5 +31,7 @@
 	"properties": "Properties",
 	"labelTemplate": "Label Template",
 	"select": "Select",
-	"icon": "Icon"
+	"icon": "Icon",
+	"enableDisabling": "Enable Fieldset Disabling?",
+	"enableDisablingDescription": "Allows fieldsets to be individually enabled/disabled."
 }
@@ -31,5 +31,7 @@
 	"properties": "Properties",
 	"labelTemplate": "Label Template",
 	"select": "Select",
-	"icon": "Icon"
+	"icon": "Icon",
+	"enableDisabling": "Enable Fieldset Disabling?",
+	"enableDisablingDescription": "Allows fieldsets to be individually enabled/disabled."
 }
@@ -31,5 +31,7 @@
 	"properties": "Properties",
 	"labelTemplate": "Label Template",
 	"select": "Select",
-	"icon": "Icon"
+	"icon": "Icon",
+	"enableDisabling": "Enable Fieldset Disabling?",
+	"enableDisablingDescription": "Allows fieldsets to be individually enabled/disabled."
 }
@@ -31,5 +31,7 @@
 	"properties": "Properties",
 	"labelTemplate": "Label Template",
 	"select": "Select",
-	"icon": "Icon"
+	"icon": "Icon",
+	"enableDisabling": "Enable Fieldset Disabling?",
+	"enableDisablingDescription": "Allows fieldsets to be individually enabled/disabled."
 }
@@ -31,5 +31,7 @@
 	"properties": "Properties",
 	"labelTemplate": "Label Template",
 	"select": "Select",
-	"icon": "Icon"
+	"icon": "Icon",
+	"enableDisabling": "Enable Fieldset Disabling?",
+	"enableDisablingDescription": "Allows fieldsets to be individually enabled/disabled."
 }
@@ -4,6 +4,10 @@
    .dropdown-menu {
        top: auto;
    }
+
+    .controls-no-label {
+        padding: 10px;
+    }
 }

 .archetypeEditor fieldset{
@@ -78,6 +82,9 @@
        span {
            display: inline-block;
        }
+        &.dimmed {
+            color: #d9d9d9;
+        }
    }
 }

@@ -109,6 +116,9 @@
            &.handle {
                cursor: move;
            }
+            &.dimmed {
+                color: #d9d9d9;
+            }
        }
    }
 }
@@ -295,6 +305,10 @@
        span {
            color: #343434;
        }
+        &.dimmed span {
+            color: #d9d9d9;
+        }
+
    }
 }
 .archetypeEditor .archetypePropertyError{
@@ -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"/>
@@ -1,13 +1,13 @@
-<div class="archetypeEditor ng-class:model.config.customCssClass" ng-controller="Imulus.ArchetypeController">
+<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="[fieldset.alias, (!fieldset.isValid ? 'archetypeFieldsetError' : '')]" ng-init="fieldsetConfigModel = getConfigFieldsetByAlias(fieldset.alias)">
+            <fieldset ng-class="[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>
+                        <label ng-class="{dimmed: fieldset.disabled}">
                            <i class="fieldsetIcon icon ng-class:fieldsetConfigModel.icon"></i>
                            <span ng-bind="getFieldsetTitle(fieldsetConfigModel, $index)"></span>
                        </label>
@@ -23,13 +23,14 @@
                            </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="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="archetypeConfig.hidePropertyLabels == '1'" class="control-label" for="archetype-property-{{model.alias}}-{{$parent.$index}}-{{$index}}">
+                            <label ng-hide="archetypeConfig.hidePropertyLabels == '1'" class="control-label" for="archetype-property-{{umbracoHostPropertyAlias}}-f{{$parent.$index}}-{{property.alias}}-p{{$index}}">
                                <span>{{property.label}}</span>
                                <div class="archetypeFieldsetHelpText" ng-show="property.helpText">
                                    <small>{{property.helpText}}</small>
@@ -37,7 +38,7 @@
                            </label>

                            <div class="controls">
-                                <archetype-property class="archetypeEditor" 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>
+                                <archetype-property class="archetypeEditor" property="property" 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>
@@ -1 +1 @@
-<div archetype-custom-view archetype="model"></div>
+<div archetype-custom-view ng-controller="Imulus.ArchetypeController"></div>
@@ -1,6 +1,6 @@
 {
 	"name": "Archetype",
-	"version": "1.2.1-beta",
+	"version": "1.3.0-beta",
 	"url": "http://github.com/imulus/archetype/",
 	"author": "Imulus",
 	"authorUrl": "http://imulus.com/",
Author	SHA1	Message	Date
Kevin Giszewski	bdd3c2088c	Bump version number to v1.3.0	2014-06-30 10:48:07 -04:00
Kevin Giszewski	80b41e4a5f	Fix #168	2014-06-30 10:45:48 -04:00
Kevin Giszewski	d60e7ba2f4	Merge branch 'master' into pr/166	2014-06-30 10:39:59 -04:00
Kevin Giszewski	4524320db2	Merge branch 'master' into pr/166	2014-06-30 09:47:10 -04:00
kjac	90ca77c9a9	Add localization to new config item	2014-06-28 12:51:36 +02:00
kjac	8332a841eb	Implement #165 - enable/disable fieldsets	2014-06-28 12:42:36 +02:00
kjac	d6a13b2335	Merge remote-tracking branch 'upstream/master'	2014-06-28 11:25:59 +02:00
cankoluman	987e5cf470	Issue #AR-8_line_endings: fix build	2014-06-27 14:27:48 +01:00
cankoluman	f2e5b83795	Issue #AR-8_line_endings: fix line endings so we match the upstream	2014-06-27 14:16:54 +01:00
cankoluman	066e807847	Merge remote-tracking branch 'origin/dev/AR-6_legacy_nesting' into dev/AR-8_line_endings Conflicts: app/Umbraco/Archetype.Tests/Serialization/UseCases/ArchetypeJsonConverterTest.cs app/Umbraco/Archetype.Tests/Serialization/UseCases/Complex/ArchetypeJsonConverterTest.cs app/Umbraco/Archetype.Tests/Serialization/UseCases/JsonTestModels.cs app/Umbraco/Umbraco.Archetype/Extensions/Extensions.cs app/Umbraco/Umbraco.Archetype/Properties/VersionInfo.cs app/Umbraco/Umbraco.Archetype/Serialization/ArchetypeJsonConverter.cs app/Umbraco/Umbraco.Archetype/Serialization/AsArchetypeAttribute.cs app/Umbraco/Umbraco.Archetype/Serialization/AsFieldsetAttribute.cs app/Umbraco/Umbraco.Archetype/Serialization/SerializationExtensions.cs config/meta.json	2014-06-27 12:47:52 +01:00
cankoluman	d8378ed6bb	Merge remote-tracking branch 'origin/dev/AR-1_serialization' into dev/AR-8_line_endings Conflicts: app/Umbraco/Archetype.Tests/Serialization/UseCases/ArchetypeJsonConverterTest.cs app/Umbraco/Archetype.Tests/Serialization/UseCases/Complex/ArchetypeJsonConverterTest.cs app/Umbraco/Archetype.Tests/Serialization/UseCases/JsonTestModels.cs app/Umbraco/Umbraco.Archetype/Archetype.Umbraco.csproj app/Umbraco/Umbraco.Archetype/Extensions/Extensions.cs app/Umbraco/Umbraco.Archetype/Properties/VersionInfo.cs app/Umbraco/Umbraco.Archetype/PropertyConverters/ArchetypeValueConverter.cs app/Umbraco/Umbraco.Archetype/Serialization/ArchetypeJsonConverter.cs app/Umbraco/Umbraco.Archetype/Serialization/AsArchetypeAttribute.cs app/Umbraco/Umbraco.Archetype/Serialization/AsFieldsetAttribute.cs app/Umbraco/Umbraco.Archetype/Serialization/SerializationExtensions.cs	2014-06-27 12:42:40 +01:00
kjac	19ee2b890c	Merge remote-tracking branch 'upstream/master'	2014-06-27 06:33:15 +02:00
Kevin Giszewski	c953f12412	Merge branch 'pr/157' into pr/164	2014-06-26 15:58:31 -04:00
kjac	601f2c0d81	Fix issue #162 + improve nested validation highlighting The fieldset.isValid property isn't necessarily initialized when the view looks for it to determine fieldset validity. I've introduced a validation method that counters this problem. The validation method also ensures that any validation errors in nested Archetypes are highlighted on the parent/root Archetype	2014-06-26 14:58:55 +02:00
kjac	283dd8af76	Merge remote-tracking branch 'upstream/master'	2014-06-26 14:23:40 +02:00
Tom Fulton	c83942dc5c	Update field labels to match new property alias scheme Only for the first level, since focusing an Archetype isn't really a thing	2014-06-25 22:03:22 -04:00
Tom Fulton	a0ff42a84f	Merge branch 'master' into fix/unique-aliases Conflicts: app/views/archetype.default.html	2014-06-25 21:49:24 -04:00
Tom Fulton	ed97d586b4	Make property aliases even more unique archetype-property-<umbracoPropertyAlias>-<fieldsetIndex>-<archetypePropertyAlias>-<archetypePropertyIndex>-<and so on...>	2014-06-25 21:46:46 -04:00
Kevin Giszewski	1bd09799b4	Fix for #160	2014-06-25 18:42:41 +02:00
Kevin Giszewski	0b77ddeef1	Fix 'hide property label'	2014-06-25 18:42:40 +02:00
kjac	2b2d0b4b0d	Fix code formatting	2014-06-25 18:42:39 +02:00
kjac	dc992293e1	Add default value overload to GetValue() Fix issue #142	2014-06-25 18:42:39 +02:00
kjac	0bc1451a5c	Fixing the unit tests The call to DisposableTimer.DebugDuration() in ArchetypeValueConverter.ConvertDataToSource() expects the propertyType parameter to be not null, but the implementation of ArchetypeValueConverter.ConvertDataToSource() allows the propertyType parameter to be null. This breaks some of the unit tests. I've added a null check in the call to DisposableTimer.DebugDuration() to counter this issue.	2014-06-25 18:42:38 +02:00
Kevin Giszewski	f052ed70a9	Merge pull request #161 from imulus/feature/fix-customviews Fix for #160	2014-06-25 10:29:22 -04:00
Kevin Giszewski	0dedd7fb2d	Fix for #160	2014-06-25 10:28:30 -04:00
Kevin Giszewski	cb6455c34a	Merge branch 'master' into develop	2014-06-25 08:35:07 -04:00
Kevin Giszewski	f99ef697db	Fix 'hide property label'	2014-06-25 08:34:54 -04:00
Tom Fulton	aac015dc0b	Refactor property aliases for uniqueness Old: archetype-property-<umbracoPropertyAlias>-<fieldsetIndex>-<propertyIndex> New: archetype-property-<umbracoPropertyAlias>-<archetypePropertyAlias>-<fieldsetIndex> Basically, this adds the archetypePropertyAlias into the mix, to fix a case where you might have the same Archetype nested on a host Archetype twice (ie box 1 links, box 2 links within the same Archetype - there was no uniqueness) It also adds in the Property Alias in place of the Property "Index" (unintended side effect, but seems cool :))	2014-06-23 20:58:42 -04:00
Kevin Giszewski	f7ef096ba6	Merge branch 'master' into develop	2014-06-20 08:41:49 -04:00
Kevin Giszewski	a17e5b5372	Merge branch 'master' into develop	2014-06-20 08:27:04 -04:00
kjac	16a73e0c82	Fix code formatting	2014-06-20 11:06:33 +02:00
cankoluman	a56864b731	Issue #AR-6_legacy_nesting: update version counter to match VersionInfo.cs	2014-06-20 09:59:15 +01:00
kjac	2f195dd588	Add default value overload to GetValue() Fix issue #142	2014-06-20 10:58:21 +02:00
kjac	35309b863c	Fixing the unit tests The call to DisposableTimer.DebugDuration() in ArchetypeValueConverter.ConvertDataToSource() expects the propertyType parameter to be not null, but the implementation of ArchetypeValueConverter.ConvertDataToSource() allows the propertyType parameter to be null. This breaks some of the unit tests. I've added a null check in the call to DisposableTimer.DebugDuration() to counter this issue.	2014-06-20 10:56:29 +02:00
cankoluman	da9085c244	Merge remote-tracking branch 'upstream/develop' into dev/AR-6_legacy_nesting Conflicts: app/Umbraco/Archetype.Tests/Serialization/UseCases/ArchetypeJsonConverterTest.cs app/Umbraco/Archetype.Tests/Serialization/UseCases/Complex/ArchetypeJsonConverterTest.cs app/Umbraco/Archetype.Tests/Serialization/UseCases/JsonTestModels.cs app/Umbraco/Umbraco.Archetype/Archetype.Umbraco.csproj app/Umbraco/Umbraco.Archetype/Extensions/Extensions.cs app/Umbraco/Umbraco.Archetype/Properties/VersionInfo.cs app/Umbraco/Umbraco.Archetype/Serialization/ArchetypeJsonConverter.cs app/Umbraco/Umbraco.Archetype/Serialization/AsArchetypeAttribute.cs app/Umbraco/Umbraco.Archetype/Serialization/AsFieldsetAttribute.cs app/Umbraco/Umbraco.Archetype/Serialization/SerializationExtensions.cs	2014-06-20 09:35:13 +01:00
cankoluman	1d8703e211	Issue #AR-6_legacy_nesting: fix issue where legacy nested model deserialization failed after the empty fieldset fix, - add legacy deserialization test	2014-06-18 11:04:25 +01:00
kjac	0ebf07d0f4	Merge remote-tracking branch 'upstream/master'	2014-06-18 06:25:55 +02:00
kjac	2b4cc2c429	Merge remote-tracking branch 'upstream/master'	2014-06-17 18:39:34 +02:00
Kevin Giszewski	ec446b6800	Merge branch 'pr/137' into develop	2014-06-17 07:05:06 -04:00
cankoluman	67f21ee4d8	Merge branch 'dev/AR-1_serialization' into stable	2014-06-17 11:17:23 +01:00
cankoluman	0573d99218	Merge branch 'stable' into dev/AR-1_serialization	2014-06-17 11:16:28 +01:00
cankoluman	a520d86ec4	Issue #AR-5_empty_json: Handle the case where the archetype json is empty: {""fieldsets"": []} Currently this throws an exception. Handle by setting returned model to null.	2014-06-17 11:13:25 +01:00
kjac	0048330863	Merge branch 'master' into issue131_optimized	2014-06-16 16:43:07 +02:00
kjac	d07c16160a	Merge remote-tracking branch 'upstream/master'	2014-06-16 16:42:25 +02:00
cankoluman	310771303c	Merge branch 'dev/AR-1_serialization' into stable	2014-06-02 14:25:12 +01:00
kjac	aafeebfc62	Merge remote-tracking branch 'upstream/master'	2014-05-29 11:16:01 +02:00
cankoluman	b6d2b7e1dd	Merge branch 'dev/AR-4_delinter_fixes' into dev/AR-1_serialization	2014-05-21 14:23:26 +01:00
cankoluman	1179147041	Issue #AR-4-delinter_fixes: simplify replace	2014-05-21 14:22:11 +01:00
cankoluman	0cfcaa3364	Issue #AR-4-delinter_fixes: change heuristic for space removal	2014-05-21 14:15:54 +01:00
cankoluman	14777a98dc	Issue #AR-4-delinter_fixes: removed buggy escaped json tests	2014-05-20 16:22:47 +01:00
cankoluman	a306424162	Issue #AR-4-delinter_fixes: fix issue where escaped new lines were being removed inside value quotes	2014-05-20 15:05:44 +01:00
cankoluman	d124622089	Issue #AR-4-delinter_fixes: refactor delinter	2014-05-20 13:07:18 +01:00
cankoluman	d9a25d1bb3	Issue #AR-4-delinter_fixes: fix all regexes except white space	2014-05-20 12:18:48 +01:00
cankoluman	cda17ac754	Issue #AR-4-delinter_fixes: update remove new line	2014-05-20 10:39:09 +01:00
cankoluman	d5329935aa	Issue #AR-4-delinter_fixes: fixed all test failures due to jToken navigation errors. To Do: fix erros due to incorrect space removal	2014-05-20 09:32:01 +01:00
cankoluman	1913f8bf14	Issue #AR-4-delinter_fixes: create single entry point for deserialization - 15 tests failing now	2014-05-19 16:25:20 +01:00
cankoluman	6f2eaa9859	Issue #AR-4-delinter_fixes: trying to fix delinter regex	2014-05-19 16:08:00 +01:00
cankoluman	31074ec9db	Issue #AR-4-delinter_fixes: trying to sort out issue with \r\n being replaced inside values	2014-05-16 17:19:05 +01:00
cankoluman	512ecbdb05	Issue #AR-1_serialization: fixes after merge of upstream master	2014-05-15 17:02:06 +01:00
cankoluman	9a97e9102e	Merge branch 'master' into dev/AR-1_serialization Conflicts: app/Umbraco/Archetype.Tests/Archetype.Tests.csproj app/Umbraco/Umbraco.Archetype.sln app/Umbraco/Umbraco.Archetype/Archetype.Umbraco.csproj app/Umbraco/Umbraco.Archetype/Extensions/Extensions.cs app/Umbraco/Umbraco.Archetype/PropertyConverters/ArchetypeValueConverter.cs	2014-05-15 16:48:08 +01:00
cankoluman	e9b2f4aeee	Merge remote-tracking branch 'upstream/master'	2014-05-15 16:43:25 +01:00
cankoluman	bdb7f247c3	Issue #AR-1_serialization: add delinter to SerializeForPersistence()	2014-05-15 16:23:48 +01:00
cankoluman	08c09a8820	Issue #AR-1_serialization: moved Delinter so serialization namespace, - fix small issue with space detection in fieldset delinter	2014-05-15 16:13:29 +01:00
cankoluman	ac84c35f67	Issue #AR-1_serialization: fix issue where property alias was incorrectly set from type alias	2014-05-15 15:06:41 +01:00
cankoluman	bff8bcc562	Issue #AR-1_serialization: fix overflow issue affecting deserialization in recursively nested models	2014-05-15 14:55:12 +01:00
cankoluman	8fc209abc1	Issue #AR-1_serialization: move delinter tests into serialization tests	2014-05-15 12:42:15 +01:00
cankoluman	a6a961d52a	Issue #AR-1_serialization: added additional unescape model tests	2014-05-15 12:38:11 +01:00
cankoluman	b289892727	Issue #AR-1_serialization: initial commit of delinter	2014-05-15 12:25:44 +01:00
cankoluman	4051734313	Issue #AR-1_serialization: got json escape test to work, added json unescape extension and tests, To Do: migrate test code from ArcheTypePropertyEditor if possible.	2014-05-14 12:28:37 +01:00
cankoluman	ae242feed6	Issue #AR-1_serialization: add test to try to create escaped json - this still produces unescaped json. However, internal virtual PropertyEditor GetPropertyEditor(IDataTypeDefinition dtd) { return dtd.Id == 0 ? new ArchetypePropertyEditor() : PropertyEditorResolver.Current.GetByAlias(dtd.PropertyEditorAlias); } would produce nested json. But this spec looks incorrect.	2014-05-13 15:44:33 +01:00
cankoluman	f1df0f2ad9	Issue #AR-1_serialization: add tests comparing models generated object serializer and archetype.SerializeForPersistence() pathwways. Note: SerializeForPersistence() does not generate escaped json when used on its own. All tests passing.	2014-05-13 10:20:12 +01:00
cankoluman	475fe7c81f	Issue #AR-1_serialization: fix error in IsConverter when PropertyEditorAlias is null, - relax property token navigation so that if a nested token is not found, we return null.	2014-05-12 17:15:20 +01:00
cankoluman	9b1b3d1793	Merge branch 'dev/AR-3_ienumerable_support' into dev/AR-1_serialization	2014-05-09 16:58:23 +01:00
cankoluman	f1f8b7db22	Merge branch 'dev/AR-1_serialization' into dev/AR-3_ienumerable_support	2014-05-09 16:56:49 +01:00
cankoluman	475bca3c05	Merge branch 'master' into dev/AR-1_serialization	2014-05-09 16:53:51 +01:00
cankoluman	77c501f2dd	Merge remote-tracking branch 'upstream/master'	2014-05-09 16:52:55 +01:00
cankoluman	5db9bb972b	Issue #AR-3_IEnumerable_support: separate use case tests	2014-05-09 16:51:33 +01:00
cankoluman	f931e4a31f	Issue #AR-3_IEnumerable_support: fix incorrect hard-coded json, some changes to tests.	2014-05-09 16:42:30 +01:00
cankoluman	bc246b947f	Issue #AR-3_IEnumerable_support: add nested model regression tests	2014-05-09 15:42:58 +01:00
cankoluman	ec642fa69f	Issue #AR-3_IEnumerable_support: fix issue with property extraction	2014-05-09 15:27:19 +01:00
cankoluman	1ba1fa2d83	Issue #AR-3_IEnumerable_support: added compound model regression tests	2014-05-09 14:42:31 +01:00
cankoluman	7c02539751	Issue #AR-3_IEnumerable_support: re-factor regression tests	2014-05-09 13:05:04 +01:00
cankoluman	bc6fff6f73	Issue #AR-3_IEnumerable_support: regression testing - fixed issue where the default fieldset name was not assigned properly during dynamic model generation	2014-05-09 11:14:39 +01:00
cankoluman	911a74e43e	Issue #AR-3_IEnumerable_support: regression testing - fixes to [AsFieldset] handling, - use ExpandoObject for all dynamically generated models - add additional JToken parsers - To Do: deal with multiple item fieldset	2014-05-08 16:56:51 +01:00
cankoluman	934df00281	Issue #AR-3_IEnumerable_support: start on regression tests.	2014-05-07 17:03:08 +01:00
cankoluman	df8d3a8888	Issue #AR-3_IEnumerable_support: clean-up	2014-05-07 15:37:57 +01:00
cankoluman	e341732f83	Issue #AR-3_IEnumerable_support: move complex model tests to sub-folder	2014-05-07 14:24:35 +01:00
cankoluman	6c5a5c8393	Issue #AR-3_IEnumerable_support: add missing tests	2014-05-07 14:17:14 +01:00
cankoluman	5e23d845d5	Issue #AR-3_IEnumerable_support: apply naming convention to unit tests	2014-05-07 14:11:26 +01:00
cankoluman	11befe727c	Issue #AR-3_IEnumerable_support: all tests passing - but branching logic is difficult.	2014-05-07 13:01:07 +01:00
cankoluman	ed9ba7d41f	Issue #AR-3_IEnumerable_support: add IEnumerable deserialization - tests pass. However, some regression errors in compex model use case	2014-05-06 16:54:08 +01:00
cankoluman	1ae967e002	Issue #AR-3_IEnumerable_support: add IEnumerable serialization support - Captions serialization tests passing. - needs cleaning up.	2014-05-06 15:01:50 +01:00
cankoluman	72303c1c83	Issue #AR-3_IEnumerable_support: fix json for simple list model - simple list model passes	2014-05-06 12:13:37 +01:00
cankoluman	bc6580995a	Issue #AR-3_IEnumerable_support: re-factor tests, add Enumerable tests - all failing as baseline.	2014-05-06 11:39:10 +01:00
cankoluman	52ff09f089	Merge remote-tracking branch 'origin/dev/AR-2_property_value_converters' into dev/AR-1_serialization	2014-05-01 16:51:16 +01:00
cankoluman	34e65ba57e	Issue #AR-1_property_value_converters: switched to using Archetype's native GetValue<T> when getting property values, - added umbracoSettings.config to the test project: conversion of decimal numbers, e.g. '12345.34' triggers 'NormalizeNumberDecimalSeparator' which in turn requires via 'DefaultShortStringHelper' that the umbracoSettings.config file is loaded. We added this to make sure tests deserializing decimal numbers pass.	2014-05-01 16:13:19 +01:00
cankoluman	87da7e1243	Issue #AR-1_serialization: fix tests that were failing due to changes in line-end encodings.	2014-05-01 14:24:26 +01:00
cankoluman	ed86255cf0	Merge branch 'master' into dev/AR-1_serialization Conflicts: app/Umbraco/Umbraco.Archetype/Archetype.Umbraco.csproj app/Umbraco/Umbraco.Archetype/Properties/VersionInfo.cs	2014-05-01 14:17:39 +01:00
cankoluman	518f68951d	Merge remote-tracking branch 'upstream/master'	2014-05-01 14:12:17 +01:00