Merge pull request #139 from umco/develop

Preparing for v0.5.0 release

Author: leekelleher

README.md

@@ -13,7 +13,7 @@ A nested content property editor for Umbraco 7 that allows you to use Doc Types
 
 ### Installation
 
-> *Note:* Nested Content has been developed against **Umbraco v7.1.4** and will support that version and above.
+> *Note:* Nested Content has been developed against **Umbraco v7.1.5** and will support that version and above.
 
 Nested Content can be installed from either Our Umbraco or NuGet package repositories, or build manually from the source-code:
 

appveyor.yml

@@ -1,5 +1,5 @@
 # version format
-version: 0.4.0.{build}
+version: 0.5.0.{build}
 
 # UMBRACO_PACKAGE_PRERELEASE_SUFFIX if a rtm release build this should be blank, otherwise if empty will default to alpha
 # example UMBRACO_PACKAGE_PRERELEASE_SUFFIX=beta

build/package.proj

@@ -18,7 +18,7 @@
 	<PropertyGroup>
 		<ProjectName>Our.Umbraco.NestedContent</ProjectName>
 		<PackageName>Nested Content</PackageName>
-		<MinUmbracoVersion>7.1.4</MinUmbracoVersion>
+		<MinUmbracoVersion>7.1.5</MinUmbracoVersion>
 		<Readme>Nested Content is a list editing property editor for Umbraco 7.1+</Readme>
 		<AuthorName>Matt Brailsford, Lee Kelleher</AuthorName>
 		<AuthorUrl>https://github.com/umco/umbraco-nested-content/graphs/contributors</AuthorUrl>

src/Our.Umbraco.NestedContent/Bootstrap.cs

@@ -1,24 +1,39 @@
-using Umbraco.Core;
-using Umbraco.Core.Events;
-using Umbraco.Core.Models;
-using Umbraco.Core.Services;
+using System;
+using Newtonsoft.Json;
+using Our.Umbraco.NestedContent.Helpers;
+using Umbraco.Core;
+using Umbraco.Core.Cache;
+using Umbraco.Core.Sync;
+using Umbraco.Web.Cache;
 
 namespace Our.Umbraco.NestedContent
 {
     public class Bootstrap : ApplicationEventHandler
     {
         protected override void ApplicationStarted(UmbracoApplicationBase umbracoApplication, ApplicationContext applicationContext)
         {
-            DataTypeService.Saved += ExpireCache;
+            CacheRefresherBase<DataTypeCacheRefresher>.CacheUpdated += DataTypeCacheRefresher_Updated;
         }
 
-        private void ExpireCache(IDataTypeService sender, SaveEventArgs<IDataTypeDefinition> e)
+        private void DataTypeCacheRefresher_Updated(DataTypeCacheRefresher sender, CacheRefresherEventArgs e)
         {
-            foreach (var dataType in e.SavedEntities)
+            if (e.MessageType == MessageType.RefreshByJson)
             {
-                ApplicationContext.Current.ApplicationCache.RuntimeCache.ClearCacheItem(
-                    string.Concat("Our.Umbraco.NestedContent.GetPreValuesCollectionByDataTypeId_", dataType.Id));
+                var payload = JsonConvert.DeserializeObject<JsonPayload[]>((string)e.MessageObject);
+                if (payload != null)
+                {
+                    foreach (var item in payload)
+                    {
+                        NestedContentHelper.ClearCache(item.Id);
+                    }
+                }
             }
         }
+
+        private class JsonPayload
+        {
+            public Guid UniqueId { get; set; }
+            public int Id { get; set; }
+        }
     }
 }

src/Our.Umbraco.NestedContent/Converters/NestedContentValueConverter.cs

@@ -8,9 +8,7 @@
 
 namespace Our.Umbraco.NestedContent.Converters
 {
-    [PropertyValueCache(PropertyCacheValue.All, PropertyCacheLevel.Content)]
-    [PropertyValueType(typeof(IEnumerable<IPublishedContent>))]
-    public class NestedContentValueConverter : PropertyValueConverterBase
+    public class NestedContentValueConverter : PropertyValueConverterBase, IPropertyValueConverterMeta
     {
         public override bool IsConverter(PublishedPropertyType propertyType)
         {
@@ -30,5 +28,15 @@ public override object ConvertDataToSource(PublishedPropertyType propertyType, o
 
             return null;
         }
+
+        public virtual Type GetPropertyValueType(PublishedPropertyType propertyType)
+        {
+            return typeof (IEnumerable<IPublishedContent>);
+        }
+
+        public virtual PropertyCacheLevel GetPropertyCacheLevel(PublishedPropertyType propertyType, PropertyCacheValue cacheValue)
+        {
+            return PropertyCacheLevel.Content;
+        }
     }
 }

src/Our.Umbraco.NestedContent/Converters/SingleNestedContentValueConverter.cs

@@ -7,9 +7,7 @@
 
 namespace Our.Umbraco.NestedContent.Converters
 {
-    [PropertyValueCache(PropertyCacheValue.All, PropertyCacheLevel.Content)]
-    [PropertyValueType(typeof(IPublishedContent))]
-    public class SingleNestedContentValueConverter : PropertyValueConverterBase
+    public class SingleNestedContentValueConverter : PropertyValueConverterBase, IPropertyValueConverterMeta
     {
         public override bool IsConverter(PublishedPropertyType propertyType)
         {
@@ -29,5 +27,15 @@ public override object ConvertDataToSource(PublishedPropertyType propertyType, o
 
             return null;
         }
+
+        public virtual Type GetPropertyValueType(PublishedPropertyType propertyType)
+        {
+            return typeof(IPublishedContent);
+        }
+
+        public virtual PropertyCacheLevel GetPropertyCacheLevel(PublishedPropertyType propertyType, PropertyCacheValue cacheValue)
+        {
+            return PropertyCacheLevel.Content;
+        }
     }
 }

src/Our.Umbraco.NestedContent/Extensions/ContentTypeServiceExtensions.cs

@@ -0,0 +1,19 @@
+using System;
+using Newtonsoft.Json.Linq;
+
+namespace Our.Umbraco.NestedContent.Extensions
+{
+    internal static class JsonExtensions
+    {
+        public static void Rename(this JToken token, string newName)
+        {
+            var parent = token.Parent;
+
+            if (parent == null)
+                throw new InvalidOperationException("The parent is missing.");
+
+            var newToken = new JProperty(newName, token);
+            parent.Replace(newToken);
+        }
+    }
+}

src/Our.Umbraco.NestedContent/Extensions/JsonExtensions.cs

@@ -27,7 +27,7 @@ public static bool IsSingleNestedContentProperty(this PublishedPropertyType publ
             }
 
             var preValueCollection = NestedContentHelper.GetPreValuesCollectionByDataTypeId(publishedProperty.DataTypeId);
-            var preValueDictionary = preValueCollection.AsPreValueDictionary();
+            var preValueDictionary = preValueCollection.PreValuesAsDictionary.ToDictionary(x => x.Key, x => x.Value.Value);
 
             int minItems, maxItems;
             return preValueDictionary.ContainsKey("minItems") &&
@@ -46,7 +46,7 @@ public static object ConvertPropertyToNestedContent(this PublishedPropertyType p
                     var processedValue = new List<IPublishedContent>();
 
                     var preValueCollection = NestedContentHelper.GetPreValuesCollectionByDataTypeId(propertyType.DataTypeId);
-                    var preValueDictionary = preValueCollection.AsPreValueDictionary();
+                    var preValueDictionary = preValueCollection.PreValuesAsDictionary.ToDictionary(x => x.Key, x => x.Value.Value);
 
                     for (var i = 0; i < rawValue.Count; i++)
                     {
@@ -90,16 +90,26 @@ public static object ConvertPropertyToNestedContent(this PublishedPropertyType p
                         }
 
                         // Get the current request node we are embedded in
-                        var pcr = UmbracoContext.Current.PublishedContentRequest;
+                        var pcr = UmbracoContext.Current == null ? null : UmbracoContext.Current.PublishedContentRequest;
                         var containerNode = pcr != null && pcr.HasPublishedContent ? pcr.PublishedContent : null;
 
-                        processedValue.Add(new DetachedPublishedContent(
+                        // Create the model based on our implementation of IPublishedContent
+                        IPublishedContent content = new DetachedPublishedContent(
                             nameObj == null ? null : nameObj.ToString(),
                             publishedContentType,
                             properties.ToArray(),
                             containerNode,
                             i,
-                            preview));
+                            preview);
+
+                        if (PublishedContentModelFactoryResolver.HasCurrent && PublishedContentModelFactoryResolver.Current.HasValue)
+                        {
+                            // Let the current model factory create a typed model to wrap our model
+                            content = PublishedContentModelFactoryResolver.Current.Factory.CreateModel(content);
+                        }
+
+                        // Add the (typed) model as a result
+                        processedValue.Add(content);
                     }
 
                     if (propertyType.IsSingleNestedContentProperty())