Bump version to 8.0.2

(cherry picked from commit 173df80e3d)

# Conflicts:
#	src/Umbraco.Core/Services/Implement/MediaService.cs

src/SolutionInfo.cs

@@ -18,5 +18,5 @@ using System.Resources;
 [assembly: AssemblyVersion("8.0.0")]
 
 // these are FYI and changed automatically
-[assembly: AssemblyFileVersion("8.0.1")]
-[assembly: AssemblyInformationalVersion("8.0.1")]
+[assembly: AssemblyFileVersion("8.0.2")]
+[assembly: AssemblyInformationalVersion("8.0.2")]

src/Umbraco.Core/Composing/Composers.cs

@@ -70,7 +70,23 @@ namespace Umbraco.Core.Composing
             }
         }
 
-        private IEnumerable<Type> PrepareComposerTypes()
+        internal IEnumerable<Type> PrepareComposerTypes()
+        {
+            var requirements = GetRequirements();
+
+            // only for debugging, this is verbose
+            //_logger.Debug<Composers>(GetComposersReport(requirements));
+
+            var sortedComposerTypes = SortComposers(requirements);
+
+            // bit verbose but should help for troubleshooting
+            //var text = "Ordered Composers: " + Environment.NewLine + string.Join(Environment.NewLine, sortedComposerTypes) + Environment.NewLine;
+            _logger.Debug<Composers>("Ordered Composers: {SortedComposerTypes}", sortedComposerTypes);
+
+            return sortedComposerTypes;
+        }
+
+        internal Dictionary<Type, List<Type>> GetRequirements(bool throwOnMissing = true)
         {
             // create a list, remove those that cannot be enabled due to runtime level
             var composerTypeList = _composerTypes
@@ -89,25 +105,69 @@ namespace Umbraco.Core.Composing
             // enable or disable composers
             EnableDisableComposers(composerTypeList);
 
-            // sort the composers according to their dependencies
-            var requirements = new Dictionary<Type, List<Type>>();
-            foreach (var type in composerTypeList) requirements[type] = null;
-            foreach (var type in composerTypeList)
+            void GatherInterfaces<TAttribute>(Type type, Func<TAttribute, Type> getTypeInAttribute, HashSet<Type> iset, List<Type> set2)
+                where TAttribute : Attribute
             {
-                GatherRequirementsFromRequireAttribute(type, composerTypeList, requirements);
-                GatherRequirementsFromRequiredByAttribute(type, composerTypeList, requirements);
+                foreach (var attribute in type.GetCustomAttributes<TAttribute>())
+                {
+                    var typeInAttribute = getTypeInAttribute(attribute);
+                    if (typeInAttribute != null && // if the attribute references a type ...
+                        typeInAttribute.IsInterface && // ... which is an interface ...
+                        typeof(IComposer).IsAssignableFrom(typeInAttribute) && // ... which implements IComposer ...
+                        !iset.Contains(typeInAttribute)) // ... which is not already in the list
+                    {
+                        // add it to the new list
+                        iset.Add(typeInAttribute);
+                        set2.Add(typeInAttribute);
+
+                        // add all its interfaces implementing IComposer
+                        foreach (var i in typeInAttribute.GetInterfaces().Where(x => typeof(IComposer).IsAssignableFrom(x)))
+                        {
+                            iset.Add(i);
+                            set2.Add(i);
+                        }
+                    }
+                }
             }
 
-            // only for debugging, this is verbose
-            //_logger.Debug<Composers>(GetComposersReport(requirements));
+            // gather interfaces too
+            var interfaces = new HashSet<Type>(composerTypeList.SelectMany(x => x.GetInterfaces().Where(y => typeof(IComposer).IsAssignableFrom(y))));
+            composerTypeList.AddRange(interfaces);
+            var list1 = composerTypeList;
+            while (list1.Count > 0)
+            {
+                var list2 = new List<Type>();
+                foreach (var t in list1)
+                {
+                    GatherInterfaces<ComposeAfterAttribute>(t, a => a.RequiredType, interfaces, list2);
+                    GatherInterfaces<ComposeBeforeAttribute>(t, a => a.RequiringType, interfaces, list2);
+                }
+                composerTypeList.AddRange(list2);
+                list1 = list2;
+            }
 
+            // sort the composers according to their dependencies
+            var requirements = new Dictionary<Type, List<Type>>();
+            foreach (var type in composerTypeList)
+                requirements[type] = null;
+            foreach (var type in composerTypeList)
+            {
+                GatherRequirementsFromAfterAttribute(type, composerTypeList, requirements, throwOnMissing);
+                GatherRequirementsFromBeforeAttribute(type, composerTypeList, requirements);
+            }
+
+            return requirements;
+        }
+
+        internal IEnumerable<Type> SortComposers(Dictionary<Type, List<Type>> requirements)
+        {
             // sort composers
             var graph = new TopoGraph<Type, KeyValuePair<Type, List<Type>>>(kvp => kvp.Key, kvp => kvp.Value);
             graph.AddItems(requirements);
             List<Type> sortedComposerTypes;
             try
             {
-                sortedComposerTypes = graph.GetSortedItems().Select(x => x.Key).ToList();
+                sortedComposerTypes = graph.GetSortedItems().Select(x => x.Key).Where(x => !x.IsInterface).ToList();
             }
             catch (Exception e)
             {
@@ -117,40 +177,37 @@ namespace Umbraco.Core.Composing
                 throw;
             }
 
-            // bit verbose but should help for troubleshooting
-            //var text = "Ordered Composers: " + Environment.NewLine + string.Join(Environment.NewLine, sortedComposerTypes) + Environment.NewLine;
-            _logger.Debug<Composers>("Ordered Composers: {SortedComposerTypes}", sortedComposerTypes);
-
             return sortedComposerTypes;
         }
 
-        private static string GetComposersReport(Dictionary<Type, List<Type>> requirements)
+        internal static string GetComposersReport(Dictionary<Type, List<Type>> requirements)
         {
             var text = new StringBuilder();
             text.AppendLine("Composers & Dependencies:");
+            text.AppendLine("  <  compose before");
+            text.AppendLine("  >  compose after");
+            text.AppendLine("  :  implements");
+            text.AppendLine("  =  depends");
             text.AppendLine();
 
+            bool HasReq(IEnumerable<Type> types, Type type)
+                => types.Any(x => type.IsAssignableFrom(x) && !x.IsInterface);
+
             foreach (var kvp in requirements)
             {
                 var type = kvp.Key;
 
                 text.AppendLine(type.FullName);
                 foreach (var attribute in type.GetCustomAttributes<ComposeAfterAttribute>())
-                    text.AppendLine("  -> " + attribute.RequiredType + (attribute.Weak.HasValue
-                        ? (attribute.Weak.Value ? " (weak)" : (" (strong" + (requirements.ContainsKey(attribute.RequiredType) ? ", missing" : "") + ")"))
-                        : ""));
-                foreach (var attribute in type.GetCustomAttributes<ComposeBeforeAttribute>())
-                    text.AppendLine("  -< " + attribute.RequiringType);
-                foreach (var i in type.GetInterfaces())
                 {
-                    text.AppendLine("  : " + i.FullName);
-                    foreach (var attribute in i.GetCustomAttributes<ComposeAfterAttribute>())
-                        text.AppendLine("    -> " + attribute.RequiredType + (attribute.Weak.HasValue
-                            ? (attribute.Weak.Value ? " (weak)" : (" (strong" + (requirements.ContainsKey(attribute.RequiredType) ? ", missing" : "") + ")"))
-                            : ""));
-                    foreach (var attribute in i.GetCustomAttributes<ComposeBeforeAttribute>())
-                        text.AppendLine("    -< " + attribute.RequiringType);
+                    var weak = !(attribute.RequiredType.IsInterface ? attribute.Weak == false : attribute.Weak != true);
+                    text.AppendLine("  > " + attribute.RequiredType +
+                        (weak ? " (weak" : " (strong") + (HasReq(requirements.Keys, attribute.RequiredType) ? ", found" : ", missing") + ")");
                 }
+                foreach (var attribute in type.GetCustomAttributes<ComposeBeforeAttribute>())
+                    text.AppendLine("  < " + attribute.RequiringType);
+                foreach (var i in type.GetInterfaces())
+                    text.AppendLine("  : " + i.FullName);
                 if (kvp.Value != null)
                     foreach (var t in kvp.Value)
                         text.AppendLine("  = " + t);
@@ -221,16 +278,16 @@ namespace Umbraco.Core.Composing
                 types.Remove(kvp.Key);
         }
 
-        private static void GatherRequirementsFromRequireAttribute(Type type, ICollection<Type> types, IDictionary<Type, List<Type>> requirements)
+        private static void GatherRequirementsFromAfterAttribute(Type type, ICollection<Type> types, IDictionary<Type, List<Type>> requirements, bool throwOnMissing = true)
         {
             // get 'require' attributes
             // these attributes are *not* inherited because we want to "custom-inherit" for interfaces only
-            var requireAttributes = type
+            var afterAttributes = type
                 .GetInterfaces().SelectMany(x => x.GetCustomAttributes<ComposeAfterAttribute>()) // those marking interfaces
                 .Concat(type.GetCustomAttributes<ComposeAfterAttribute>()); // those marking the composer
 
             // what happens in case of conflicting attributes (different strong/weak for same type) is not specified.
-            foreach (var attr in requireAttributes)
+            foreach (var attr in afterAttributes)
             {
                 if (attr.RequiredType == type) continue; // ignore self-requirements (+ exclude in implems, below)
 
@@ -238,13 +295,13 @@ namespace Umbraco.Core.Composing
                 // unless strong, and then require at least one enabled composer implementing that interface
                 if (attr.RequiredType.IsInterface)
                 {
-                    var implems = types.Where(x => x != type && attr.RequiredType.IsAssignableFrom(x)).ToList();
+                    var implems = types.Where(x => x != type && attr.RequiredType.IsAssignableFrom(x) && !x.IsInterface).ToList();
                     if (implems.Count > 0)
                     {
                         if (requirements[type] == null) requirements[type] = new List<Type>();
                         requirements[type].AddRange(implems);
                     }
-                    else if (attr.Weak == false) // if explicitly set to !weak, is strong, else is weak
+                    else if (attr.Weak == false && throwOnMissing) // if explicitly set to !weak, is strong, else is weak
                         throw new Exception($"Broken composer dependency: {type.FullName} -> {attr.RequiredType.FullName}.");
                 }
                 // requiring a class = require that the composer is enabled
@@ -256,28 +313,28 @@ namespace Umbraco.Core.Composing
                         if (requirements[type] == null) requirements[type] = new List<Type>();
                         requirements[type].Add(attr.RequiredType);
                     }
-                    else if (attr.Weak != true) // if not explicitly set to weak, is strong
+                    else if (attr.Weak != true && throwOnMissing) // if not explicitly set to weak, is strong
                         throw new Exception($"Broken composer dependency: {type.FullName} -> {attr.RequiredType.FullName}.");
                 }
             }
         }
 
-        private static void GatherRequirementsFromRequiredByAttribute(Type type, ICollection<Type> types, IDictionary<Type, List<Type>> requirements)
+        private static void GatherRequirementsFromBeforeAttribute(Type type, ICollection<Type> types, IDictionary<Type, List<Type>> requirements)
         {
             // get 'required' attributes
             // these attributes are *not* inherited because we want to "custom-inherit" for interfaces only
-            var requiredAttributes = type
+            var beforeAttributes = type
                 .GetInterfaces().SelectMany(x => x.GetCustomAttributes<ComposeBeforeAttribute>()) // those marking interfaces
                 .Concat(type.GetCustomAttributes<ComposeBeforeAttribute>()); // those marking the composer
 
-            foreach (var attr in requiredAttributes)
+            foreach (var attr in beforeAttributes)
             {
                 if (attr.RequiringType == type) continue; // ignore self-requirements (+ exclude in implems, below)
 
                 // required by an interface = by any enabled composer implementing this that interface
                 if (attr.RequiringType.IsInterface)
                 {
-                    var implems = types.Where(x => x != type && attr.RequiringType.IsAssignableFrom(x)).ToList();
+                    var implems = types.Where(x => x != type && attr.RequiringType.IsAssignableFrom(x) && !x.IsInterface).ToList();
                     foreach (var implem in implems)
                     {
                         if (requirements[implem] == null) requirements[implem] = new List<Type>();

src/Umbraco.Core/CompositionExtensions.cs

@@ -203,6 +203,28 @@ namespace Umbraco.Core
             composition.RegisterUnique(_ => registrar);
         }
 
+        /// <summary>
+        /// Sets the database server messenger options.
+        /// </summary>
+        /// <param name="composition">The composition.</param>
+        /// <param name="factory">A function creating the options.</param>
+        /// <remarks>Use DatabaseServerRegistrarAndMessengerComposer.GetDefaultOptions to get the options that Umbraco would use by default.</remarks>
+        public static void SetDatabaseServerMessengerOptions(this Composition composition, Func<IFactory, DatabaseServerMessengerOptions> factory)
+        {
+            composition.RegisterUnique(factory);
+        }
+
+        /// <summary>
+        /// Sets the database server messenger options.
+        /// </summary>
+        /// <param name="composition">The composition.</param>
+        /// <param name="options">Options.</param>
+        /// <remarks>Use DatabaseServerRegistrarAndMessengerComposer.GetDefaultOptions to get the options that Umbraco would use by default.</remarks>
+        public static void SetDatabaseServerMessengerOptions(this Composition composition, DatabaseServerMessengerOptions options)
+        {
+            composition.RegisterUnique(_ => options);
+        }
+
         /// <summary>
         /// Sets the short string helper.
         /// </summary>

src/Umbraco.Core/ContentExtensions.cs

@@ -7,6 +7,7 @@ using System.Web;
 using System.Xml.Linq;
 using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
+using NPoco.Expressions;
 using Umbraco.Core.Composing;
 using Umbraco.Core.IO;
 using Umbraco.Core.Models;
@@ -52,8 +53,8 @@ namespace Umbraco.Core
             return ContentStatus.Unpublished;
         }
 
-        
-        
+
+
         #endregion
 
         /// <summary>
@@ -134,9 +135,14 @@ namespace Umbraco.Core
         /// <summary>
         /// Sets the posted file value of a property.
         /// </summary>
-        /// <remarks>This really is for FileUpload fields only, and should be obsoleted. For anything else,
-        /// you need to store the file by yourself using Store and then figure out
-        /// how to deal with auto-fill properties (if any) and thumbnails (if any) by yourself.</remarks>
+        public static void SetValue(this IContentBase content, IContentTypeBaseServiceProvider contentTypeBaseServiceProvider, string propertyTypeAlias, string filename, HttpPostedFileBase postedFile, string culture = null, string segment = null)
+        {
+            content.SetValue(contentTypeBaseServiceProvider, propertyTypeAlias, postedFile.FileName, postedFile.InputStream, culture, segment);
+        }
+
+        /// <summary>
+        /// Sets the posted file value of a property.
+        /// </summary>
         public static void SetValue(this IContentBase content, IContentTypeBaseServiceProvider contentTypeBaseServiceProvider, string propertyTypeAlias, string filename, Stream filestream, string culture = null, string segment = null)
         {
             if (filename == null || filestream == null) return;

src/Umbraco.Core/EnumerableExtensions.cs

@@ -10,6 +10,23 @@ namespace Umbraco.Core
     ///</summary>
     public static class EnumerableExtensions
     {
+        internal static bool HasDuplicates<T>(this IEnumerable<T> items, bool includeNull)
+        {
+            var hs = new HashSet<T>();
+            foreach (var item in items)
+            {
+                if (item != null || includeNull)
+                {
+                    if (!hs.Add(item))
+                    {
+                        return true;
+                    }
+                }
+            }
+            return false;
+        }
+
+
         /// <summary>
         /// Wraps this object instance into an IEnumerable{T} consisting of a single item.
         /// </summary>

src/Umbraco.Core/Migrations/Install/DatabaseDataCreator.cs

@@ -226,6 +226,8 @@ namespace Umbraco.Core.Migrations.Install
             _database.Insert(Constants.DatabaseSchema.Tables.PropertyType, "id", false, new PropertyTypeDto { Id = 32, UniqueId = 32.ToGuid(), DataTypeId = Constants.DataTypes.LabelDateTime, ContentTypeId = 1044, PropertyTypeGroupId = 11, Alias = Constants.Conventions.Member.LastLockoutDate, Name = Constants.Conventions.Member.LastLockoutDateLabel, SortOrder = 4, Mandatory = false, ValidationRegExp = null, Description = null, Variations = (byte) ContentVariation.Nothing });
             _database.Insert(Constants.DatabaseSchema.Tables.PropertyType, "id", false, new PropertyTypeDto { Id = 33, UniqueId = 33.ToGuid(), DataTypeId = Constants.DataTypes.LabelDateTime, ContentTypeId = 1044, PropertyTypeGroupId = 11, Alias = Constants.Conventions.Member.LastLoginDate, Name = Constants.Conventions.Member.LastLoginDateLabel, SortOrder = 5, Mandatory = false, ValidationRegExp = null, Description = null, Variations = (byte) ContentVariation.Nothing });
             _database.Insert(Constants.DatabaseSchema.Tables.PropertyType, "id", false, new PropertyTypeDto { Id = 34, UniqueId = 34.ToGuid(), DataTypeId = Constants.DataTypes.LabelDateTime, ContentTypeId = 1044, PropertyTypeGroupId = 11, Alias = Constants.Conventions.Member.LastPasswordChangeDate, Name = Constants.Conventions.Member.LastPasswordChangeDateLabel, SortOrder = 6, Mandatory = false, ValidationRegExp = null, Description = null, Variations = (byte) ContentVariation.Nothing });
+            _database.Insert(Constants.DatabaseSchema.Tables.PropertyType, "id", false, new PropertyTypeDto { Id = 35, UniqueId = 35.ToGuid(), DataTypeId = Constants.DataTypes.LabelDateTime, ContentTypeId = 1044, PropertyTypeGroupId = null, Alias = Constants.Conventions.Member.PasswordQuestion, Name = Constants.Conventions.Member.PasswordQuestionLabel, SortOrder = 7, Mandatory = false, ValidationRegExp = null, Description = null, Variations = (byte)ContentVariation.Nothing });
+            _database.Insert(Constants.DatabaseSchema.Tables.PropertyType, "id", false, new PropertyTypeDto { Id = 36, UniqueId = 36.ToGuid(), DataTypeId = Constants.DataTypes.LabelDateTime, ContentTypeId = 1044, PropertyTypeGroupId = null, Alias = Constants.Conventions.Member.PasswordAnswer, Name = Constants.Conventions.Member.PasswordAnswerLabel, SortOrder = 8, Mandatory = false, ValidationRegExp = null, Description = null, Variations = (byte)ContentVariation.Nothing });
 
         }
 

src/Umbraco.Core/Models/ContentTypeBase.cs

@@ -95,6 +95,21 @@ namespace Umbraco.Core.Models
 
         protected void PropertyTypesChanged(object sender, NotifyCollectionChangedEventArgs e)
         {
+            //enable this to detect duplicate property aliases. We do want this, however making this change in a
+            //patch release might be a little dangerous
+
+            ////detect if there are any duplicate aliases - this cannot be allowed
+            //if (e.Action == NotifyCollectionChangedAction.Add
+            //    || e.Action == NotifyCollectionChangedAction.Replace)
+            //{
+            //    var allAliases = _noGroupPropertyTypes.Concat(PropertyGroups.SelectMany(x => x.PropertyTypes)).Select(x => x.Alias);
+            //    if (allAliases.HasDuplicates(false))
+            //    {
+            //        var newAliases = string.Join(", ", e.NewItems.Cast<PropertyType>().Select(x => x.Alias));
+            //        throw new InvalidOperationException($"Other property types already exist with the aliases: {newAliases}");
+            //    }   
+            //}
+
             OnPropertyChanged(nameof(PropertyTypes));
         }
 
@@ -397,15 +412,16 @@ namespace Umbraco.Core.Models
             var group = PropertyGroups[propertyGroupName];
             if (group == null) return;
 
-            // re-assign the group's properties to no group
+            // first remove the group
+            PropertyGroups.RemoveItem(propertyGroupName);
+
+            // Then re-assign the group's properties to no group
             foreach (var property in group.PropertyTypes)
             {
                 property.PropertyGroupId = null;
                 _noGroupPropertyTypes.Add(property);
             }
 
-            // actually remove the group
-            PropertyGroups.RemoveItem(propertyGroupName);
             OnPropertyChanged(nameof(PropertyGroups));
         }
 

src/Umbraco.Core/Models/PropertyCollection.cs

@@ -15,7 +15,7 @@ namespace Umbraco.Core.Models
     public class PropertyCollection : KeyedCollection<string, Property>, INotifyCollectionChanged, IDeepCloneable
     {
         private readonly object _addLocker = new object();
-        internal Action OnAdd;
+        
         internal Func<Property, bool> AdditionValidator { get; set; }
 
         /// <summary>
@@ -49,10 +49,12 @@ namespace Umbraco.Core.Models
         /// </summary>
         internal void Reset(IEnumerable<Property> properties)
         {
+            //collection events will be raised in each of these calls
             Clear();
+
+            //collection events will be raised in each of these calls
             foreach (var property in properties)
                 Add(property);
-            OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset));
         }
 
         /// <summary>
@@ -60,8 +62,9 @@ namespace Umbraco.Core.Models
         /// </summary>
         protected override void SetItem(int index, Property property)
         {
+            var oldItem = index >= 0 ? this[index] : property;
             base.SetItem(index, property);
-            OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Add, property, index));
+            OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Replace, property, oldItem));
         }
 
         /// <summary>
@@ -120,10 +123,8 @@ namespace Umbraco.Core.Models
                     }
                 }
 
+                //collection events will be raised in InsertItem with Add
                 base.Add(property);
-
-                OnAdd?.Invoke();
-                OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Add, property));
             }
         }
 

src/Umbraco.Core/Models/PropertyGroupCollection.cs

@@ -19,9 +19,6 @@ namespace Umbraco.Core.Models
     {
         private readonly ReaderWriterLockSlim _addLocker = new ReaderWriterLockSlim();
 
-        // TODO: this doesn't seem to be used anywhere
-        internal Action OnAdd;
-
         internal PropertyGroupCollection()
         { }
 
@@ -37,16 +34,19 @@ namespace Umbraco.Core.Models
         /// <remarks></remarks>
         internal void Reset(IEnumerable<PropertyGroup> groups)
         {
+            //collection events will be raised in each of these calls
             Clear();
+
+            //collection events will be raised in each of these calls
             foreach (var group in groups)
                 Add(group);
-            OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset));
         }
 
         protected override void SetItem(int index, PropertyGroup item)
         {
+            var oldItem = index >= 0 ? this[index] : item;
             base.SetItem(index, item);
-            OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Add, item, index));
+            OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Replace, item, oldItem));
         }
 
         protected override void RemoveItem(int index)
@@ -84,6 +84,7 @@ namespace Umbraco.Core.Models
                         if (keyExists)
                             throw new Exception($"Naming conflict: Changing the name of PropertyGroup '{item.Name}' would result in duplicates");
 
+                        //collection events will be raised in SetItem
                         SetItem(IndexOfKey(item.Id), item);
                         return;
                     }
@@ -96,16 +97,14 @@ namespace Umbraco.Core.Models
                         var exists = Contains(key);
                         if (exists)
                         {
+                            //collection events will be raised in SetItem
                             SetItem(IndexOfKey(key), item);
                             return;
                         }
                     }
                 }
-
+                //collection events will be raised in InsertItem
                 base.Add(item);
-                OnAdd?.Invoke();
-
-                OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Add, item));
             }
             finally
             {

src/Umbraco.Core/Models/PropertyTypeCollection.cs

@@ -19,9 +19,6 @@ namespace Umbraco.Core.Models
         [IgnoreDataMember]
         private readonly ReaderWriterLockSlim _addLocker = new ReaderWriterLockSlim();
 
-        // TODO: This doesn't seem to be used
-        [IgnoreDataMember]
-        internal Action OnAdd;
 
         internal PropertyTypeCollection(bool supportsPublishing)
         {
@@ -43,36 +40,44 @@ namespace Umbraco.Core.Models
         /// <remarks></remarks>
         internal void Reset(IEnumerable<PropertyType> properties)
         {
+            //collection events will be raised in each of these calls
             Clear();
+
+            //collection events will be raised in each of these calls
             foreach (var property in properties)
-                Add(property);
-            OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset));
+                Add(property);            
         }
 
         protected override void SetItem(int index, PropertyType item)
         {
             item.SupportsPublishing = SupportsPublishing;
-            base.SetItem(index, item);
-            OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Add, item, index));
+            var oldItem = index >= 0 ? this[index] : item;
+            base.SetItem(index, item);            
+            OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Replace, item, oldItem));
+            item.PropertyChanged += Item_PropertyChanged;
         }
 
         protected override void RemoveItem(int index)
         {
             var removed = this[index];
             base.RemoveItem(index);
+            removed.PropertyChanged -= Item_PropertyChanged;
             OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Remove, removed));
         }
 
         protected override void InsertItem(int index, PropertyType item)
         {
             item.SupportsPublishing = SupportsPublishing;
-            base.InsertItem(index, item);
+            base.InsertItem(index, item);            
             OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Add, item));
+            item.PropertyChanged += Item_PropertyChanged;
         }
 
         protected override void ClearItems()
         {
             base.ClearItems();
+            foreach (var item in this)
+                item.PropertyChanged -= Item_PropertyChanged;
             OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset));
         }
 
@@ -91,6 +96,7 @@ namespace Umbraco.Core.Models
                     var exists = Contains(key);
                     if (exists)
                     {
+                        //collection events will be raised in SetItem
                         SetItem(IndexOfKey(key), item);
                         return;
                     }
@@ -103,10 +109,8 @@ namespace Umbraco.Core.Models
                     item.SortOrder = this.Max(x => x.SortOrder) + 1;
                 }
 
+                //collection events will be raised in InsertItem
                 base.Add(item);
-                OnAdd?.Invoke();
-
-                OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Add, item));
             }
             finally
             {
@@ -115,6 +119,17 @@ namespace Umbraco.Core.Models
             }
         }
 
+        /// <summary>
+        /// Occurs when a property changes on a PropertyType that exists in this collection
+        /// </summary>
+        /// <param name="sender"></param>
+        /// <param name="e"></param>
+        private void Item_PropertyChanged(object sender, System.ComponentModel.PropertyChangedEventArgs e)
+        {
+            var propType = (PropertyType)sender;
+            OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Replace, propType, propType));
+        }
+
         /// <summary>
         /// Determines whether this collection contains a <see cref="Property"/> whose alias matches the specified PropertyType.
         /// </summary>

src/Umbraco.Core/Persistence/Factories/MemberTypeReadOnlyFactory.cs

@@ -9,11 +9,10 @@ namespace Umbraco.Core.Persistence.Factories
 {
     internal static class MemberTypeReadOnlyFactory
     {
-        public static IMemberType BuildEntity(MemberTypeReadOnlyDto dto, out bool needsSaving)
+        public static IMemberType BuildEntity(MemberTypeReadOnlyDto dto)
         {
             var standardPropertyTypes = Constants.Conventions.Member.GetStandardPropertyTypeStubs();
-            needsSaving = false;
-
+            
             var memberType = new MemberType(dto.ParentId);
 
             try
@@ -41,27 +40,29 @@ namespace Umbraco.Core.Persistence.Factories
                 var propertyTypeGroupCollection = GetPropertyTypeGroupCollection(dto, memberType, standardPropertyTypes);
                 memberType.PropertyGroups = propertyTypeGroupCollection;
 
-                var propertyTypes = GetPropertyTypes(dto, memberType, standardPropertyTypes);
+                memberType.NoGroupPropertyTypes = GetNoGroupPropertyTypes(dto, memberType, standardPropertyTypes);
 
-                //By Convention we add 9 standard PropertyTypes - This is only here to support loading of types that didn't have these conventions before.
+                // By Convention we add 9 standard PropertyTypes - This is only here to support loading of types that didn't have these conventions before.
+                // In theory this should not happen! The only reason this did happen was because:
+                // A) we didn't install all of the default membership properties by default
+                // B) the existing data is super old when we didn't store membership properties at all (very very old)
+                // So what to do? We absolutely do not want to update the database when only a read was requested, this will cause problems
+                // so we should just add these virtual properties, they will have no ids but they will have aliases and this should be perfectly
+                // fine for any membership provider logic to work since neither membership providers or asp.net identity care about whether a property
+                // has an ID or not.
+                // When the member type is saved, all the properties will correctly be added.
+
+                //This will add this group if it doesn't exist, no need to error check here
+                memberType.AddPropertyGroup(Constants.Conventions.Member.StandardPropertiesGroupName);
                 foreach (var standardPropertyType in standardPropertyTypes)
                 {
-                    if (dto.PropertyTypes.Any(x => x.Alias.Equals(standardPropertyType.Key))) continue;
+                    //This will add the property if it doesn't exist, no need to error check here
+                    memberType.AddPropertyType(standardPropertyType.Value, Constants.Conventions.Member.StandardPropertiesGroupName);
 
-                    // beware!
-                    // means that we can return a memberType "from database" that has some property types
-                    // that do *not* come from the database and therefore are incomplete eg have no key,
-                    // no id, no dataTypeDefinitionId - ouch! - better notify caller of the situation
-                    needsSaving = true;
-
-                    //Add the standard PropertyType to the current list
-                    propertyTypes.Add(standardPropertyType.Value);
-                    
                     //Internal dictionary for adding "MemberCanEdit", "VisibleOnProfile", "IsSensitive" properties to each PropertyType
-                    memberType.MemberTypePropertyTypes.Add(standardPropertyType.Key,
-                        new MemberTypePropertyProfileAccess(false, false, false));
+                    if (!memberType.MemberTypePropertyTypes.TryGetValue(standardPropertyType.Key, out var memberTypePropertyProfile))
+                        memberType.MemberTypePropertyTypes[standardPropertyType.Key] = new MemberTypePropertyProfileAccess(false, false, false);
                 }
-                memberType.NoGroupPropertyTypes = propertyTypes;
 
                 return memberType;
             }
@@ -147,13 +148,14 @@ namespace Umbraco.Core.Persistence.Factories
             return propertyGroups;
         }
 
-        private static List<PropertyType> GetPropertyTypes(MemberTypeReadOnlyDto dto, MemberType memberType, Dictionary<string, PropertyType> standardProps)
+        private static List<PropertyType> GetNoGroupPropertyTypes(MemberTypeReadOnlyDto dto, MemberType memberType, Dictionary<string, PropertyType> standardProps)
         {
             //Find PropertyTypes that does not belong to a PropertyTypeGroup
             var propertyTypes = new List<PropertyType>();
             foreach (var typeDto in dto.PropertyTypes.Where(x => (x.PropertyTypeGroupId.HasValue == false || x.PropertyTypeGroupId.Value == 0) && x.Id.HasValue))
             {
                 //Internal dictionary for adding "MemberCanEdit" and "VisibleOnProfile" properties to each PropertyType
+
                 memberType.MemberTypePropertyTypes.Add(typeDto.Alias,
                     new MemberTypePropertyProfileAccess(typeDto.ViewOnProfile, typeDto.CanEdit, typeDto.IsSensitive));
 

src/Umbraco.Core/Persistence/Repositories/Implement/ExternalLoginRepository.cs

@@ -46,7 +46,7 @@ namespace Umbraco.Core.Persistence.Repositories.Implement
         protected override IIdentityUserLogin PerformGet(int id)
         {
             var sql = GetBaseQuery(false);
-            sql.Where(GetBaseWhereClause(), new { Id = id });
+            sql.Where(GetBaseWhereClause(), new { id = id });
 
             var dto = Database.Fetch<ExternalLoginDto>(SqlSyntax.SelectTop(sql, 1)).FirstOrDefault();
             if (dto == null)

src/Umbraco.Core/Persistence/Repositories/Implement/MemberTypeRepository.cs

@@ -308,13 +308,7 @@ namespace Umbraco.Core.Persistence.Repositories.Implement
             if (dtos == null || dtos.Any() == false)
                 return Enumerable.Empty<IMemberType>();
             
-            return dtos.Select(x =>
-            {
-                bool needsSaving;
-                var memberType = MemberTypeReadOnlyFactory.BuildEntity(x, out needsSaving);
-                if (needsSaving) PersistUpdatedItem(memberType);
-                return memberType;
-            }).ToList();
+            return dtos.Select(MemberTypeReadOnlyFactory.BuildEntity).ToList();
         }
 
         /// <summary>

src/Umbraco.Core/PropertyEditors/DropDownFlexibleConfiguration.cs

@@ -1,8 +1,8 @@
 namespace Umbraco.Core.PropertyEditors
 {
-    internal class DropDownFlexibleConfiguration : ValueListConfiguration
+    public class DropDownFlexibleConfiguration : ValueListConfiguration
     {
         [ConfigurationField("multiple", "Enable multiple choice", "boolean", Description = "When checked, the dropdown will be a select multiple / combo box style dropdown.")]
         public bool Multiple { get; set; }
     }
-}
+}

src/Umbraco.Core/Runtime/CoreRuntime.cs

@@ -5,6 +5,7 @@ using System.Linq;
 using System.Reflection;
 using System.Threading;
 using System.Web;
+using System.Web.Hosting;
 using Umbraco.Core.Cache;
 using Umbraco.Core.Composing;
 using Umbraco.Core.Configuration;
@@ -70,10 +71,15 @@ namespace Umbraco.Core.Runtime
             // objects.
 
             using (var timer = profilingLogger.TraceDuration<CoreRuntime>(
-                $"Booting Umbraco {UmbracoVersion.SemanticVersion.ToSemanticString()} on {NetworkHelper.MachineName}.",
+                $"Booting Umbraco {UmbracoVersion.SemanticVersion.ToSemanticString()}.",
                 "Booted.",
                 "Boot failed."))
             {
+                logger.Info<CoreRuntime>("Booting site '{HostingSiteName}', app '{HostingApplicationID}', path '{HostingPhysicalPath}', server '{MachineName}'.",
+                    HostingEnvironment.SiteName,
+                    HostingEnvironment.ApplicationID,
+                    HostingEnvironment.ApplicationPhysicalPath,
+                    NetworkHelper.MachineName);
                 logger.Debug<CoreRuntime>("Runtime: {Runtime}", GetType().FullName);
 
                 // application environment

src/Umbraco.Core/Services/Implement/ContentService.cs

@@ -1902,9 +1902,8 @@ namespace Umbraco.Core.Services.Implement
             content.ParentId = parentId;
 
             // get the level delta (old pos to new pos)
-            var levelDelta = parent == null
-                ? 1 - content.Level + (parentId == Constants.System.RecycleBinContent ? 1 : 0)
-                : parent.Level + 1 - content.Level;
+            // note that recycle bin (id:-20) level is 0!
+            var levelDelta = 1 - content.Level + (parent?.Level ?? 0);
 
             var paths = new Dictionary<int, string>();
 

src/Umbraco.Core/Services/Implement/MediaService.cs

@@ -289,7 +289,7 @@ namespace Umbraco.Core.Services.Implement
                 scope.Events.Dispatch(Saved, this, saveEventArgs);
                 scope.Events.Dispatch(TreeChanged, this, new TreeChange<IMedia>(media, TreeChangeTypes.RefreshNode).ToEventArgs());
             }
-            
+
             if (withIdentity == false)
                 return;
 
@@ -716,7 +716,7 @@ namespace Umbraco.Core.Services.Implement
         #endregion
 
         #region Delete
-        
+
         /// <summary>
         /// Permanently deletes an <see cref="IMedia"/> object
         /// </summary>
@@ -975,9 +975,8 @@ namespace Umbraco.Core.Services.Implement
             media.ParentId = parentId;
 
             // get the level delta (old pos to new pos)
-            var levelDelta = parent == null
-                ? 1 - media.Level + (parentId == Constants.System.RecycleBinMedia ? 1 : 0)
-                : parent.Level + 1 - media.Level;
+            // note that recycle bin (id:-20) level is 0!
+            var levelDelta = 1 - media.Level + (parent?.Level ?? 0);
 
             var paths = new Dictionary<int, string>();
 
@@ -1024,6 +1023,7 @@ namespace Umbraco.Core.Services.Implement
         /// <summary>
         /// Empties the Recycle Bin by deleting all <see cref="IMedia"/> that resides in the bin
         /// </summary>
+        /// <param name="userId">Optional Id of the User emptying the Recycle Bin</param>        
         public OperationResult EmptyRecycleBin()
         {
             var nodeObjectType = Constants.ObjectTypes.Media;

src/Umbraco.Tests/Components/ComponentTests.cs

@@ -4,6 +4,7 @@ using System.Linq;
 using Moq;
 using NUnit.Framework;
 using Umbraco.Core;
+using Umbraco.Core.Cache;
 using Umbraco.Core.Compose;
 using Umbraco.Core.Composing;
 using Umbraco.Core.IO;
@@ -299,11 +300,19 @@ namespace Umbraco.Tests.Components
             composers = new Composers(composition, types, Mock.Of<IProfilingLogger>());
             Composed.Clear();
             Assert.Throws<Exception>(() => composers.Compose());
+            Console.WriteLine("throws:");
+            composers = new Composers(composition, types, Mock.Of<IProfilingLogger>());
+            var requirements = composers.GetRequirements(false);
+            Console.WriteLine(Composers.GetComposersReport(requirements));
 
             types = new[] { typeof(Composer2) };
             composers = new Composers(composition, types, Mock.Of<IProfilingLogger>());
             Composed.Clear();
             Assert.Throws<Exception>(() => composers.Compose());
+            Console.WriteLine("throws:");
+            composers = new Composers(composition, types, Mock.Of<IProfilingLogger>());
+            requirements = composers.GetRequirements(false);
+            Console.WriteLine(Composers.GetComposersReport(requirements));
 
             types = new[] { typeof(Composer12) };
             composers = new Composers(composition, types, Mock.Of<IProfilingLogger>());
@@ -349,6 +358,25 @@ namespace Umbraco.Tests.Components
             Assert.AreEqual(typeof(Composer27), Composed[1]);
         }
 
+        [Test]
+        public void AllComposers()
+        {
+            var typeLoader = new TypeLoader(AppCaches.Disabled.RuntimeCache, IOHelper.MapPath("~/App_Data/TEMP"), Mock.Of<IProfilingLogger>());
+
+            var register = MockRegister();
+            var composition = new Composition(register, typeLoader, Mock.Of<IProfilingLogger>(), MockRuntimeState(RuntimeLevel.Run));
+
+            var types = typeLoader.GetTypes<IComposer>().Where(x => x.FullName.StartsWith("Umbraco.Core.") || x.FullName.StartsWith("Umbraco.Web"));
+            var composers = new Composers(composition, types, Mock.Of<IProfilingLogger>());
+            var requirements = composers.GetRequirements();
+            var report = Composers.GetComposersReport(requirements);
+            Console.WriteLine(report);
+            var composerTypes = composers.SortComposers(requirements);
+
+            foreach (var type in composerTypes)
+                Console.WriteLine(type);
+        }
+
         #region Compothings
 
         public class TestComposerBase : IComposer

src/Umbraco.Tests/Models/ContentTypeTests.cs

@@ -15,13 +15,47 @@ namespace Umbraco.Tests.Models
     [TestFixture]
     public class ContentTypeTests : UmbracoTestBase
     {
+        [Test]
+        [Ignore("Ignoring this test until we actually enforce this, see comments in ContentTypeBase.PropertyTypesChanged")]
+        public void Cannot_Add_Duplicate_Property_Aliases()
+        {
+            var contentType = MockedContentTypes.CreateBasicContentType();
 
+            contentType.PropertyGroups.Add(new PropertyGroup(new PropertyTypeCollection(false, new[]
+            {
+                new PropertyType("testPropertyEditor", ValueStorageType.Nvarchar){ Alias = "myPropertyType" }
+            })));
+
+            Assert.Throws<InvalidOperationException>(() =>
+                contentType.PropertyTypeCollection.Add(
+                    new PropertyType("testPropertyEditor", ValueStorageType.Nvarchar) { Alias = "myPropertyType" }));
+
+        }
+
+        [Test]
+        [Ignore("Ignoring this test until we actually enforce this, see comments in ContentTypeBase.PropertyTypesChanged")]
+        public void Cannot_Update_Duplicate_Property_Aliases()
+        {
+            var contentType = MockedContentTypes.CreateBasicContentType();
+
+            contentType.PropertyGroups.Add(new PropertyGroup(new PropertyTypeCollection(false, new[]
+            {
+                new PropertyType("testPropertyEditor", ValueStorageType.Nvarchar){ Alias = "myPropertyType" }
+            })));
+
+            contentType.PropertyTypeCollection.Add(new PropertyType("testPropertyEditor", ValueStorageType.Nvarchar) { Alias = "myPropertyType2" });
+
+            var toUpdate = contentType.PropertyTypeCollection["myPropertyType2"];
+
+            Assert.Throws<InvalidOperationException>(() => toUpdate.Alias = "myPropertyType");
+
+        }
 
         [Test]
         public void Can_Deep_Clone_Content_Type_Sort()
         {
             var contentType = new ContentTypeSort(new Lazy<int>(() => 3), 4, "test");
-            var clone = (ContentTypeSort) contentType.DeepClone();
+            var clone = (ContentTypeSort)contentType.DeepClone();
             Assert.AreNotSame(clone, contentType);
             Assert.AreEqual(clone, contentType);
             Assert.AreEqual(clone.Id.Value, contentType.Id.Value);
@@ -54,7 +88,7 @@ namespace Umbraco.Tests.Models
             contentType.Id = 10;
             contentType.CreateDate = DateTime.Now;
             contentType.CreatorId = 22;
-            contentType.SetDefaultTemplate(new Template((string) "Test Template", (string) "testTemplate")
+            contentType.SetDefaultTemplate(new Template((string)"Test Template", (string)"testTemplate")
             {
                 Id = 88
             });
@@ -117,12 +151,12 @@ namespace Umbraco.Tests.Models
             {
                 group.Id = ++i;
             }
-            contentType.AllowedTemplates = new[] { new Template((string) "Name", (string) "name") { Id = 200 }, new Template((string) "Name2", (string) "name2") { Id = 201 } };
+            contentType.AllowedTemplates = new[] { new Template((string)"Name", (string)"name") { Id = 200 }, new Template((string)"Name2", (string)"name2") { Id = 201 } };
             contentType.AllowedContentTypes = new[] { new ContentTypeSort(new Lazy<int>(() => 888), 8, "sub"), new ContentTypeSort(new Lazy<int>(() => 889), 9, "sub2") };
             contentType.Id = 10;
             contentType.CreateDate = DateTime.Now;
             contentType.CreatorId = 22;
-            contentType.SetDefaultTemplate(new Template((string) "Test Template", (string) "testTemplate")
+            contentType.SetDefaultTemplate(new Template((string)"Test Template", (string)"testTemplate")
             {
                 Id = 88
             });
@@ -167,12 +201,12 @@ namespace Umbraco.Tests.Models
             {
                 group.Id = ++i;
             }
-            contentType.AllowedTemplates = new[] { new Template((string) "Name", (string) "name") { Id = 200 }, new Template((string) "Name2", (string) "name2") { Id = 201 } };
-            contentType.AllowedContentTypes = new[] {new ContentTypeSort(new Lazy<int>(() => 888), 8, "sub"), new ContentTypeSort(new Lazy<int>(() => 889), 9, "sub2")};
+            contentType.AllowedTemplates = new[] { new Template((string)"Name", (string)"name") { Id = 200 }, new Template((string)"Name2", (string)"name2") { Id = 201 } };
+            contentType.AllowedContentTypes = new[] { new ContentTypeSort(new Lazy<int>(() => 888), 8, "sub"), new ContentTypeSort(new Lazy<int>(() => 889), 9, "sub2") };
             contentType.Id = 10;
             contentType.CreateDate = DateTime.Now;
             contentType.CreatorId = 22;
-            contentType.SetDefaultTemplate(new Template((string) "Test Template", (string) "testTemplate")
+            contentType.SetDefaultTemplate(new Template((string)"Test Template", (string)"testTemplate")
             {
                 Id = 88
             });
@@ -264,12 +298,12 @@ namespace Umbraco.Tests.Models
             {
                 propertyType.Id = ++i;
             }
-            contentType.AllowedTemplates = new[] { new Template((string) "Name", (string) "name") { Id = 200 }, new Template((string) "Name2", (string) "name2") { Id = 201 } };
+            contentType.AllowedTemplates = new[] { new Template((string)"Name", (string)"name") { Id = 200 }, new Template((string)"Name2", (string)"name2") { Id = 201 } };
             contentType.AllowedContentTypes = new[] { new ContentTypeSort(new Lazy<int>(() => 888), 8, "sub"), new ContentTypeSort(new Lazy<int>(() => 889), 9, "sub2") };
             contentType.Id = 10;
             contentType.CreateDate = DateTime.Now;
             contentType.CreatorId = 22;
-            contentType.SetDefaultTemplate(new Template((string) "Test Template", (string) "testTemplate")
+            contentType.SetDefaultTemplate(new Template((string)"Test Template", (string)"testTemplate")
             {
                 Id = 88
             });

src/Umbraco.Tests/Persistence/Repositories/MemberTypeRepositoryTest.cs

@@ -232,6 +232,35 @@ namespace Umbraco.Tests.Persistence.Repositories
             }
         }
 
+        /// <summary>
+        /// This demonstates an issue found: https://github.com/umbraco/Umbraco-CMS/issues/4963#issuecomment-483516698
+        /// </summary>
+        [Test]
+        [Ignore("Still testing")]
+        public void Bug_Changing_Built_In_Member_Type_Property_Type_Aliases_Results_In_Exception()
+        {
+            //TODO: Fix this bug and then change this test
+
+            var provider = TestObjects.GetScopeProvider(Logger);
+            using (var scope = provider.CreateScope())
+            {
+                var repository = CreateRepository(provider);
+
+                IMemberType memberType = MockedContentTypes.CreateSimpleMemberType();
+                repository.Save(memberType);
+
+                foreach (var stub in Constants.Conventions.Member.GetStandardPropertyTypeStubs())
+                {
+                    var prop = memberType.PropertyTypes.First(x => x.Alias == stub.Key);
+                    prop.Alias = prop.Alias + "__0000";
+                }
+
+                repository.Save(memberType);
+
+                //Assert.Throws<ArgumentException>(() => );
+            }
+        }
+
         [Test]
         public void Built_In_Member_Type_Properties_Are_Automatically_Added_When_Creating()
         {

src/Umbraco.Web.UI.Client/src/common/services/editor.service.js

@@ -112,6 +112,7 @@ When building a custom infinite editor view you can use the same components as a
                         type="button"
                         button-style="link"
                         label-key="general_close"
+                        shortcut="esc"
                         action="vm.close()">
                     </umb-button>
                     <umb-button

src/Umbraco.Web.UI.Client/src/less/modals.less

@@ -55,6 +55,16 @@
 	position: absolute;;	
 }
 
+.--notInFront .umb-modalcolumn::after {
+    content: '';
+    position: absolute;
+    top: 0;
+    bottom: 0;
+    right: 0;
+    left: 0;
+    background: rgba(0,0,0,.4);
+}
+
 /* re-align loader */
 .umb-modal .umb-loader-wrapper, .umb-modalcolumn .umb-loader-wrapper, .umb-dialog .umb-loader-wrapper{
     position:relative; 

src/Umbraco.Web.UI.Client/src/views/packages/views/repo.html

@@ -250,7 +250,7 @@
                     <umb-box>
                         <umb-box-content>
                             <div class="umb-package-details__section-title"><localize key="packager_packageCompatibility">Compatibility</localize></div>
-                            <div class="umb-package-details__section-description"><localize key="packager_packageCompatibilityDescription">This package is compatible with the following versions of Umbraco, as reported by community members. Full compatability cannot be gauranteed for versions reported below 100%</localize></div>
+                            <div class="umb-package-details__section-description"><localize key="packager_packageCompatibilityDescription">This package is compatible with the following versions of Umbraco, as reported by community members. Full compatability cannot be guaranteed for versions reported below 100%</localize></div>
                             <div class="umb-package-details__compatability" ng-repeat="compatibility in vm.package.compatibility | filter:percentage > 0">
                                 <div class="umb-package-details__compatability-label">
                                     <span class="umb-package-details__information-item-label">{{compatibility.version}}</span>

src/Umbraco.Web.UI.Client/src/views/prevalueeditors/imagepicker.controller.js

@@ -1,21 +1,21 @@
-function imageFilePickerController($scope) {
+function imageFilePickerController($scope, editorService) {
 
     $scope.add = function() {
-        $scope.mediaPickerOverlay = {
+        var mediaPickerOptions = {
             view: "mediapicker",
+            multiPicker: false,
             disableFolderSelect: true,
             onlyImages: true,
-            show: true,
             submit: function (model) {
                 $scope.model.value = model.selection[0].image;
-                $scope.mediaPickerOverlay.show = false;
-                $scope.mediaPickerOverlay = null;
+
+                editorService.close();
             },
             close: function () {
-                $scope.mediaPickerOverlay.show = false;
-                $scope.mediaPickerOverlay = null;
-            }
+                editorService.close();
+            } 
         };
+        editorService.mediaPicker(mediaPickerOptions);
     };
 
     $scope.remove = function () {

src/Umbraco.Web.UI.Client/src/views/prevalueeditors/imagepicker.html

@@ -19,11 +19,4 @@
         <i class="icon icon-add large"></i>
     </a>
 
-    <umb-overlay
-      ng-if="mediaPickerOverlay.show"
-      model="mediaPickerOverlay"
-      view="mediaPickerOverlay.view"
-      position="right">
-    </umb-overlay>
-
 </div>

src/Umbraco.Web.UI.Client/src/views/propertyeditors/grid/dialogs/config.controller.js

@@ -0,0 +1,22 @@
+function ConfigController($scope) {
+
+    var vm = this;
+
+    vm.submit = submit;
+    vm.close = close;
+
+    function submit() {
+        if ($scope.model && $scope.model.submit) {
+            $scope.model.submit($scope.model);
+        }
+    }
+
+    function close() {
+        if ($scope.model.close) {
+            $scope.model.close();
+        }
+    }
+    
+}
+
+angular.module("umbraco").controller("Umbraco.PropertyEditors.GridPrevalueEditor.ConfigController", ConfigController);

src/Umbraco.Web.UI.Client/src/views/propertyeditors/grid/dialogs/config.html

@@ -1,16 +1,61 @@
-<div ng-if="model.config">
-    <umb-property
-        property="configValue"
-        ng-repeat="configValue in model.config">
-        <umb-property-editor model="configValue" is-pre-value="true"></umb-property-editor>
-    </umb-property>
-</div>
+<div ng-controller="Umbraco.PropertyEditors.GridPrevalueEditor.ConfigController as vm">
+
+    <umb-editor-view>
+
+        <umb-editor-header
+            name="model.title"
+            name-locked="true"
+            hide-alias="true"
+            hide-icon="true"
+            hide-description="true">
+        </umb-editor-header>
+
+        <umb-editor-container>
+            <ng-form name="gridItemConfigEditor" val-form-manager>
+
+                <umb-box ng-if="model.config">
+                    <umb-box-header title-key="grid_settings" />
+                    <umb-box-content>
+                        <div>
+                            <umb-property property="configValue"
+                                          ng-repeat="configValue in model.config">
+                                <umb-property-editor model="configValue" is-pre-value="true"></umb-property-editor>
+                            </umb-property>
+                        </div>
+                    </umb-box-content>
+                </umb-box>
+
+                <umb-box ng-if="model.styles">
+                    <umb-box-header title-key="grid_styles" />
+                    <umb-box-content>
+                        <div>
+                            <umb-property property="styleValue"
+                                          ng-repeat="styleValue in model.styles">
+                                <umb-property-editor model="styleValue" is-pre-value="true"></umb-property-editor>
+                            </umb-property>
+                        </div>
+                    </umb-box-content>
+                </umb-box>
+
+            </ng-form>
+        </umb-editor-container>
+
+        <umb-editor-footer>
+            <umb-editor-footer-content-right>
+                <umb-button type="button"
+                            button-style="link"
+                            label-key="general_close"
+                            shortcut="esc"
+                            action="vm.close()">
+                </umb-button>
+                <umb-button type="button"
+                            button-style="success"
+                            label-key="general_submit"
+                            action="vm.submit()">
+                </umb-button>
+            </umb-editor-footer-content-right>
+        </umb-editor-footer>
+
+    </umb-editor-view>
 
-<div ng-if="model.styles">
-    <h4>Style</h4>
-    <umb-property
-        property="styleValue"
-        ng-repeat="styleValue in model.styles">
-        <umb-property-editor model="styleValue" is-pre-value="true"></umb-property-editor>
-    </umb-property>
 </div>

src/Umbraco.Web.UI.Client/src/views/propertyeditors/grid/dialogs/editconfig.controller.js

@@ -1,16 +1,22 @@
 function EditConfigController($scope) {
 
-    $scope.close = function() {
-        if($scope.model.close) {
-            $scope.model.close();
-        }
-    }
-    
-    $scope.submit = function() {
-        if($scope.model && $scope.model.submit) {
+    var vm = this;
+
+    vm.submit = submit;
+    vm.close = close;
+
+    function submit() {
+        if ($scope.model && $scope.model.submit) {
             $scope.model.submit($scope.model);
         }
     }
+
+    function close() {
+        if ($scope.model.close) {
+            $scope.model.close();
+        }
+    }
+
 }
 
 angular.module("umbraco").controller("Umbraco.PropertyEditors.GridPrevalueEditor.EditConfigController", EditConfigController);

src/Umbraco.Web.UI.Client/src/views/propertyeditors/grid/dialogs/editconfig.html

@@ -1,10 +1,8 @@
-<div class="usky-grid usky-grid-configuration" ng-controller="Umbraco.PropertyEditors.GridPrevalueEditor.EditConfigController">
+<div class="usky-grid usky-grid-configuration" ng-controller="Umbraco.PropertyEditors.GridPrevalueEditor.EditConfigController as vm">
 
+    <umb-editor-view>
 
-
-        <umb-editor-view>
-
-            <form novalidate name="EditConfigForm" val-form-manager>
+        <form novalidate name="EditConfigForm" val-form-manager>
 
             <umb-editor-header
                 name="model.title"
@@ -18,44 +16,39 @@
                 <umb-box>
                     <umb-box-content>
 
+                        <ng-form name="gridConfigEditor">
 
+                            <h4>{{model.name}}</h4>
+                            <p>Settings will only save if the entered json configuration is valid</p>
+                            <textarea name="configSource"
+                                validate-on="'blur'"
+                                rows="20" class="umb-property-editor umb-textarea"
+                                umb-raw-model="model.config"></textarea>
 
-<form name="gridConfigEditor">
+                            <div class="alert alert-error" ng-show="gridConfigEditor.$invalid === true">
+                                This configuration is not valid json, and will not be saved.
+                            </div>
 
-   <h4>{{model.name}}</h4>
-   <p>Settings will only save if the entered json configuration is valid</p>
-   <textarea name="configSource"
-      validate-on="'blur'"
-      rows="20" class="umb-property-editor umb-textarea"
-      umb-raw-model="model.config"></textarea>
+                        </ng-form>
 
-   <div class="alert alert-error" ng-show="gridConfigEditor.$invalid === true">
-      This configuration is not valid json, and will not be saved.
-   </div>
+                    </umb-box-content>
+                </umb-box>
+            </umb-editor-container>
 
-</form>
-
-
-
-
-                            </umb-box-content>
-                        </umb-box>
-                    </umb-editor-container>
-
-                    <umb-editor-footer>
-                    <umb-editor-footer-content-right>
+            <umb-editor-footer>
+                <umb-editor-footer-content-right>
                     <umb-button
                         type="button"
                         button-style="link"
                         label-key="general_close"
                         shortcut="esc"
-                        action="close()">
+                        action="vm.close()">
                     </umb-button>
                     <umb-button
                         type="button"
                         button-style="success"
                         label-key="general_submit"
-                        action="submit()">
+                        action="vm.submit()">
                     </umb-button>
                 </umb-editor-footer-content-right>
             </umb-editor-footer>

src/Umbraco.Web.UI.Client/src/views/propertyeditors/grid/grid.controller.js

@@ -8,17 +8,20 @@ angular.module("umbraco")
         umbRequestHelper,
         angularHelper,
         $element,
-        eventsService
+            eventsService,
+            editorService
     ) {
 
         // Grid status variables
         var placeHolder = "";
         var currentForm = angularHelper.getCurrentForm($scope);
 
+        
         $scope.currentRow = null;
         $scope.currentCell = null;
         $scope.currentToolsControl = null;
         $scope.currentControl = null;
+        
         $scope.openRTEToolbarId = null;
         $scope.hasSettings = false;
         $scope.showRowConfigurations = true;
@@ -238,8 +241,10 @@ angular.module("umbraco")
                 $scope.$apply(function () {
 
                     var cell = event.target.getScope_HackForSortable().area;
+                    
                     cell.hasActiveChild = hasActiveChild(cell, cell.controls);
                     cell.active = false;
+                    
                 });
             }
 
@@ -273,7 +278,7 @@ angular.module("umbraco")
             localizationService.localize("grid_insertControl").then(function(value){
                 title = value;
                 $scope.editorOverlay = {
-                    view: "itempicker",
+                        view: "itempicker",
                     filter: area.$allowedEditors.length > 15,
                     title: title,
                     availableItems: area.$allowedEditors,
@@ -314,6 +319,7 @@ angular.module("umbraco")
 
         $scope.clickOutsideRow = function(index, rows) {
             rows[index].active = false;
+            
         };
 
         function getAllowedLayouts(section) {
@@ -431,44 +437,46 @@ angular.module("umbraco")
                 });
             }
 
-            $scope.gridItemSettingsDialog = {};
-            $scope.gridItemSettingsDialog.view = "views/propertyeditors/grid/dialogs/config.html";
-            $scope.gridItemSettingsDialog.title = "Settings";
-            $scope.gridItemSettingsDialog.styles = styles;
-            $scope.gridItemSettingsDialog.config = config;
+                var dialogOptions = {
+                    view: "views/propertyeditors/grid/dialogs/config.html",
+                    size: "small",
+                    styles: styles,
+                    config: config,
+                    submit: function (model) {
+                    var styleObject = {};
+                    var configObject = {};
 
-            $scope.gridItemSettingsDialog.show = true;
+                    _.each(model.styles, function (style) {
+                        if (style.value) {
+                            styleObject[style.key] = addModifier(style.value, style.modifier);
+                        }
+                    });
+                    _.each(model.config, function (cfg) {
+                            cfg.alias = cfg.key;
+                            cfg.label = cfg.value;
 
-            $scope.gridItemSettingsDialog.submit = function(model) {
+                        if (cfg.value) {
+                            configObject[cfg.key] = addModifier(cfg.value, cfg.modifier);
+                        }
+                    });
 
-                var styleObject = {};
-                var configObject = {};
+                    gridItem.styles = styleObject;
+                    gridItem.config = configObject;
+                    gridItem.hasConfig = gridItemHasConfig(styleObject, configObject);
 
-                _.each(model.styles, function(style){
-                    if(style.value){
-                        styleObject[style.key] = addModifier(style.value, style.modifier);
+                    currentForm.$setDirty();
+
+                        editorService.close();
+                    },
+                    close: function () {
+                        editorService.close();
                     }
-                });
-                _.each(model.config, function (cfg) {
-                    if (cfg.value) {
-                        configObject[cfg.key] = addModifier(cfg.value, cfg.modifier);
-                    }
-                });
-
-                gridItem.styles = styleObject;
-                gridItem.config = configObject;
-                gridItem.hasConfig = gridItemHasConfig(styleObject, configObject);
-
-                currentForm.$setDirty();
-
-                $scope.gridItemSettingsDialog.show = false;
-                $scope.gridItemSettingsDialog = null;
             };
 
-            $scope.gridItemSettingsDialog.close = function(oldModel) {
-                $scope.gridItemSettingsDialog.show = false;
-                $scope.gridItemSettingsDialog = null;
-            };
+                localizationService.localize("general_settings").then(value => {
+                    dialogOptions.title = value;
+                    editorService.open(dialogOptions);
+                });
 
         };
 
@@ -538,6 +546,7 @@ angular.module("umbraco")
         // Control management functions
         // *********************************************
         $scope.clickControl = function (index, controls, cell) {
+            
             controls[index].active = true;
             cell.hasActiveChild = true;
         };

src/Umbraco.Web.UI.Client/src/views/propertyeditors/grid/grid.html

@@ -305,11 +305,4 @@
       position="target">
     </umb-overlay>
 
-    <umb-overlay
-      ng-if="gridItemSettingsDialog.show"
-      model="gridItemSettingsDialog"
-      view="gridItemSettingsDialog.view"
-      position="right">
-    </umb-overlay>
-
 </div>

src/Umbraco.Web.UI.Client/src/views/propertyeditors/listview/listview.controller.js

@@ -159,7 +159,7 @@ function listViewController($scope, $routeParams, $injector, $timeout, currentUs
         allowBulkPublish: $scope.entityType === 'content' && $scope.model.config.bulkActionPermissions.allowBulkPublish,
         allowBulkUnpublish: $scope.entityType === 'content' && $scope.model.config.bulkActionPermissions.allowBulkUnpublish,
         allowBulkCopy: $scope.entityType === 'content' && $scope.model.config.bulkActionPermissions.allowBulkCopy,
-        allowBulkMove: $scope.model.config.bulkActionPermissions.allowBulkMove,
+        allowBulkMove: $scope.entityType !== 'member' && $scope.model.config.bulkActionPermissions.allowBulkMove,
         allowBulkDelete: $scope.model.config.bulkActionPermissions.allowBulkDelete,
         cultureName: $routeParams.cculture ? $routeParams.cculture : $routeParams.mculture
     };
@@ -583,6 +583,8 @@ function listViewController($scope, $routeParams, $injector, $timeout, currentUs
             .then(function () {
                 //executes if all is successful, let's sync the tree
                 if (newPath) {
+                    // reload the current view so the moved items are no longer shown
+                    $scope.reloadView($scope.contentId);
 
                     //we need to do a double sync here: first refresh the node where the content was moved,
                     // then refresh the node where the content was moved from

src/Umbraco.Web.UI/Umbraco.Web.UI.csproj

@@ -340,9 +340,9 @@
         <WebProjectProperties>
           <UseIIS>False</UseIIS>
           <AutoAssignPort>True</AutoAssignPort>
-          <DevelopmentServerPort>8010</DevelopmentServerPort>
+          <DevelopmentServerPort>8020</DevelopmentServerPort>
           <DevelopmentServerVPath>/</DevelopmentServerVPath>
-          <IISUrl>http://localhost:8010</IISUrl>
+          <IISUrl>http://localhost:8020</IISUrl>
           <NTLMAuthentication>False</NTLMAuthentication>
           <UseCustomServer>False</UseCustomServer>
           <CustomServerUrl>

src/Umbraco.Web.UI/Umbraco/config/lang/en.xml

@@ -1164,7 +1164,7 @@ To manage your website, simply open the Umbraco back office and start adding con
     <key alias="packageDownloads">Downloads</key>
     <key alias="packageLikes">Likes</key>
     <key alias="packageCompatibility">Compatibility</key>
-    <key alias="packageCompatibilityDescription">This package is compatible with the following versions of Umbraco, as reported by community members. Full compatability cannot be gauranteed for versions reported below 100%</key>
+    <key alias="packageCompatibilityDescription">This package is compatible with the following versions of Umbraco, as reported by community members. Full compatability cannot be guaranteed for versions reported below 100%</key>
     <key alias="packageExternalSources">External sources</key>
     <key alias="packageAuthor">Author</key>
     <key alias="packageDocumentation">Documentation</key>

src/Umbraco.Web.UI/Umbraco/config/lang/en_us.xml

@@ -1163,7 +1163,7 @@ To manage your website, simply open the Umbraco back office and start adding con
     <key alias="packageDownloads">Downloads</key>
     <key alias="packageLikes">Likes</key>
     <key alias="packageCompatibility">Compatibility</key>
-    <key alias="packageCompatibilityDescription">This package is compatible with the following versions of Umbraco, as reported by community members. Full compatability cannot be gauranteed for versions reported below 100%</key>
+    <key alias="packageCompatibilityDescription">This package is compatible with the following versions of Umbraco, as reported by community members. Full compatability cannot be guaranteed for versions reported below 100%</key>
     <key alias="packageExternalSources">External sources</key>
     <key alias="packageAuthor">Author</key>
     <key alias="packageDocumentation">Documentation</key>

src/Umbraco.Web/BatchedDatabaseServerMessenger.cs

@@ -13,6 +13,7 @@ using Umbraco.Core.Persistence;
 using Umbraco.Core.Persistence.Dtos;
 using Umbraco.Core.Scoping;
 using Umbraco.Web.Composing;
+using System.ComponentModel;
 
 namespace Umbraco.Web
 {
@@ -26,10 +27,17 @@ namespace Umbraco.Web
     {
         private readonly IUmbracoDatabaseFactory _databaseFactory;
 
+        [Obsolete("This overload should not be used, enableDistCalls has no effect")]
+        [EditorBrowsable(EditorBrowsableState.Never)]
         public BatchedDatabaseServerMessenger(
-            IRuntimeState runtime, IUmbracoDatabaseFactory databaseFactory, IScopeProvider scopeProvider, ISqlContext sqlContext, IProfilingLogger proflog, IGlobalSettings globalSettings,
-            bool enableDistCalls, DatabaseServerMessengerOptions options)
-            : base(runtime, scopeProvider, sqlContext, proflog, globalSettings, enableDistCalls, options)
+            IRuntimeState runtime, IUmbracoDatabaseFactory databaseFactory, IScopeProvider scopeProvider, ISqlContext sqlContext, IProfilingLogger proflog, IGlobalSettings globalSettings, bool enableDistCalls, DatabaseServerMessengerOptions options)
+            : this(runtime, databaseFactory, scopeProvider, sqlContext, proflog, globalSettings, options)
+        {
+        }
+
+        public BatchedDatabaseServerMessenger(
+            IRuntimeState runtime, IUmbracoDatabaseFactory databaseFactory, IScopeProvider scopeProvider, ISqlContext sqlContext, IProfilingLogger proflog, IGlobalSettings globalSettings, DatabaseServerMessengerOptions options)
+            : base(runtime, scopeProvider, sqlContext, proflog, globalSettings, true, options)
         {
             _databaseFactory = databaseFactory;
         }

src/Umbraco.Web/Compose/DatabaseServerRegistrarAndMessengerComponent.cs

@@ -38,54 +38,44 @@ namespace Umbraco.Web.Compose
 
     public sealed class DatabaseServerRegistrarAndMessengerComposer : ComponentComposer<DatabaseServerRegistrarAndMessengerComponent>, ICoreComposer
     {
+        public static DatabaseServerMessengerOptions GetDefaultOptions(IFactory factory)
+        {
+            var logger = factory.GetInstance<ILogger>();
+            var indexRebuilder = factory.GetInstance<IndexRebuilder>();
+
+            return new DatabaseServerMessengerOptions
+            {
+                //These callbacks will be executed if the server has not been synced
+                // (i.e. it is a new server or the lastsynced.txt file has been removed)
+                InitializingCallbacks = new Action[]
+                {
+                    //rebuild the xml cache file if the server is not synced
+                    () =>
+                    {
+                        // rebuild the published snapshot caches entirely, if the server is not synced
+                        // this is equivalent to DistributedCache RefreshAll... but local only
+                        // (we really should have a way to reuse RefreshAll... locally)
+                        // note: refresh all content & media caches does refresh content types too
+                        var svc = Current.PublishedSnapshotService;
+                        svc.Notify(new[] { new DomainCacheRefresher.JsonPayload(0, DomainChangeTypes.RefreshAll) });
+                        svc.Notify(new[] { new ContentCacheRefresher.JsonPayload(0, TreeChangeTypes.RefreshAll) }, out _, out _);
+                        svc.Notify(new[] { new MediaCacheRefresher.JsonPayload(0, TreeChangeTypes.RefreshAll) }, out _);
+                    },
+
+                    //rebuild indexes if the server is not synced
+                    // NOTE: This will rebuild ALL indexes including the members, if developers want to target specific
+                    // indexes then they can adjust this logic themselves.
+                    () => { ExamineComponent.RebuildIndexes(indexRebuilder, logger, false, 5000); }
+                }
+            };
+        }
+
         public override void Compose(Composition composition)
         {
             base.Compose(composition);
 
-            composition.SetServerMessenger(factory =>
-            {
-                var runtime = factory.GetInstance<IRuntimeState>();
-                var databaseFactory = factory.GetInstance<IUmbracoDatabaseFactory>();
-                var globalSettings = factory.GetInstance<IGlobalSettings>();
-                var proflog = factory.GetInstance<IProfilingLogger>();
-                var scopeProvider = factory.GetInstance<IScopeProvider>();
-                var sqlContext = factory.GetInstance<ISqlContext>();
-                var logger = factory.GetInstance<ILogger>();
-                var indexRebuilder = factory.GetInstance<IndexRebuilder>();
-
-                return new BatchedDatabaseServerMessenger(
-                    runtime, databaseFactory, scopeProvider, sqlContext, proflog, globalSettings,
-                    true,
-                    //Default options for web including the required callbacks to build caches
-                    new DatabaseServerMessengerOptions
-                    {
-                        //These callbacks will be executed if the server has not been synced
-                        // (i.e. it is a new server or the lastsynced.txt file has been removed)
-                        InitializingCallbacks = new Action[]
-                        {
-                            //rebuild the xml cache file if the server is not synced
-                            () =>
-                            {
-                                // rebuild the published snapshot caches entirely, if the server is not synced
-                                // this is equivalent to DistributedCache RefreshAll... but local only
-                                // (we really should have a way to reuse RefreshAll... locally)
-                                // note: refresh all content & media caches does refresh content types too
-                                var svc = Current.PublishedSnapshotService;
-                                svc.Notify(new[] { new DomainCacheRefresher.JsonPayload(0, DomainChangeTypes.RefreshAll) });
-                                svc.Notify(new[] { new ContentCacheRefresher.JsonPayload(0, TreeChangeTypes.RefreshAll) }, out _, out _);
-                                svc.Notify(new[] { new MediaCacheRefresher.JsonPayload(0, TreeChangeTypes.RefreshAll) }, out _);
-                            },
-
-                            //rebuild indexes if the server is not synced
-                            // NOTE: This will rebuild ALL indexes including the members, if developers want to target specific
-                            // indexes then they can adjust this logic themselves.
-                            () =>
-                            {
-                                ExamineComponent.RebuildIndexes(indexRebuilder, logger, false, 5000);
-                            }
-                        }
-                    });
-            });
+            composition.SetDatabaseServerMessengerOptions(GetDefaultOptions);
+            composition.SetServerMessenger<BatchedDatabaseServerMessenger>();
         }
     }
 
@@ -128,7 +118,7 @@ namespace Umbraco.Web.Compose
         }
 
         public void Initialize()
-        { 
+        {
             //We will start the whole process when a successful request is made
             if (_registrar != null || _messenger != null)
                 UmbracoModule.RouteAttempt += RegisterBackgroundTasksOnce;

src/Umbraco.Web/PublishedCache/NuCache/ContentStore.cs

@@ -313,6 +313,8 @@ namespace Umbraco.Web.PublishedCache.NuCache
                 var removedContentTypeNodes = new List<int>();
                 var refreshedContentTypeNodes = new List<int>();
 
+                // find all the nodes that are either refreshed or removed,
+                // because of their content type being either refreshed or removed
                 foreach (var link in _contentNodes.Values)
                 {
                     var node = link.Value;
@@ -322,39 +324,49 @@ namespace Umbraco.Web.PublishedCache.NuCache
                     if (refreshedIdsA.Contains(contentTypeId)) refreshedContentTypeNodes.Add(node.Id);
                 }
 
-                // all content should have been deleted - but
+                // perform deletion of content with removed content type
+                // removing content types should have removed their content already
+                // but just to be 100% sure, clear again here
                 foreach (var node in removedContentTypeNodes)
                     ClearBranchLocked(node);
 
+                // perform deletion of removed content types
                 foreach (var id in removedIdsA)
                 {
-                    if (_contentTypesById.TryGetValue(id, out LinkedNode<PublishedContentType> link) == false || link.Value == null)
+                    if (_contentTypesById.TryGetValue(id, out var link) == false || link.Value == null)
                         continue;
                     SetValueLocked(_contentTypesById, id, null);
                     SetValueLocked(_contentTypesByAlias, link.Value.Alias, null);
                 }
 
+                // perform update of refreshed content types
                 foreach (var type in refreshedTypesA)
                 {
                     SetValueLocked(_contentTypesById, type.Id, type);
                     SetValueLocked(_contentTypesByAlias, type.Alias, type);
                 }
 
-                // skip missing type
-                // skip missing parents & unbuildable kits - what else could we do?
+                // perform update of content with refreshed content type - from the kits
+                // skip missing type, skip missing parents & unbuildable kits - what else could we do?
+                // kits are ordered by level, so ParentExits is ok here
                 var visited = new List<int>();
                 foreach (var kit in kits.Where(x =>
                     refreshedIdsA.Contains(x.ContentTypeId) &&
                     ParentExistsLocked(x) &&
                     BuildKit(x)))
                 {
+                    // replacing the node: must preserve the parents
+                    var node = GetHead(_contentNodes, kit.Node.Id)?.Value;
+                    if (node != null)
+                        kit.Node.ChildContentIds = node.ChildContentIds;
+
                     SetValueLocked(_contentNodes, kit.Node.Id, kit.Node);
+
                     visited.Add(kit.Node.Id);
                     if (_localDb != null) RegisterChange(kit.Node.Id, kit);
                 }
 
                 // all content should have been refreshed - but...
-
                 var orphans = refreshedContentTypeNodes.Except(visited);
                 foreach (var id in orphans)
                     ClearBranchLocked(id);
@@ -503,6 +515,7 @@ namespace Umbraco.Web.PublishedCache.NuCache
             }
         }
 
+        // IMPORTANT kits must be sorted out by LEVEL
         public void SetAll(IEnumerable<ContentNodeKit> kits)
         {
             var lockInfo = new WriteLockInfo();
@@ -533,6 +546,7 @@ namespace Umbraco.Web.PublishedCache.NuCache
             }
         }
 
+        // IMPORTANT kits must be sorted out by LEVEL
         public void SetBranch(int rootContentId, IEnumerable<ContentNodeKit> kits)
         {
             var lockInfo = new WriteLockInfo();

src/Umbraco.Web/PublishedCache/NuCache/DataSource/BTree.cs

@@ -1,4 +1,5 @@
-using CSharpTest.Net.Collections;
+using System.Configuration;
+using CSharpTest.Net.Collections;
 using CSharpTest.Net.Serialization;
 
 namespace Umbraco.Web.PublishedCache.NuCache.DataSource
@@ -14,6 +15,12 @@ namespace Umbraco.Web.PublishedCache.NuCache.DataSource
                 CreateFile = exists ? CreatePolicy.IfNeeded : CreatePolicy.Always,
                 FileName = filepath,
 
+                // read or write but do *not* keep in memory
+                CachePolicy = CachePolicy.None,
+
+                // default is 4096, min 2^9 = 512, max 2^16 = 64K
+                FileBlockSize = GetBlockSize(),
+
                 // other options?
             };
 
@@ -25,6 +32,28 @@ namespace Umbraco.Web.PublishedCache.NuCache.DataSource
             return tree;
         }
 
+        private static int GetBlockSize()
+        {
+            var blockSize = 4096;
+
+            var appSetting = ConfigurationManager.AppSettings["Umbraco.Web.PublishedCache.NuCache.BTree.BlockSize"];
+            if (appSetting == null)
+                return blockSize;
+
+            if (!int.TryParse(appSetting, out blockSize))
+                throw new ConfigurationErrorsException($"Invalid block size value \"{appSetting}\": not a number.");
+
+            var bit = 0;
+            for (var i = blockSize; i != 1; i >>= 1)
+                bit++;
+            if (1 << bit != blockSize)
+                throw new ConfigurationErrorsException($"Invalid block size value \"{blockSize}\": must be a power of two.");
+            if (blockSize < 512 || blockSize > 65536)
+                throw new ConfigurationErrorsException($"Invalid block size value \"{blockSize}\": must be >= 512 and <= 65536.");
+
+            return blockSize;
+        }
+
         /*
         class ListOfIntSerializer : ISerializer<List<int>>
         {

src/Umbraco.Web/PublishedCache/NuCache/PublishedSnapshotService.cs

@@ -356,6 +356,7 @@ namespace Umbraco.Web.PublishedCache.NuCache
 
             _logger.Debug<PublishedSnapshotService>("Loading content from database...");
             var sw = Stopwatch.StartNew();
+            // IMPORTANT GetAllContentSources sorts kits by level
             var kits = _dataSource.GetAllContentSources(scope);
             _contentStore.SetAll(kits);
             sw.Stop();
@@ -370,7 +371,8 @@ namespace Umbraco.Web.PublishedCache.NuCache
 
             _logger.Debug<PublishedSnapshotService>("Loading content from local db...");
             var sw = Stopwatch.StartNew();
-            var kits = _localContentDb.Select(x => x.Value).OrderBy(x => x.Node.Level);
+            var kits = _localContentDb.Select(x => x.Value)
+                .OrderBy(x => x.Node.Level); // IMPORTANT sort by level
             _contentStore.SetAll(kits);
             sw.Stop();
             _logger.Debug<PublishedSnapshotService>("Loaded content from local db ({Duration}ms)", sw.ElapsedMilliseconds);
@@ -422,6 +424,7 @@ namespace Umbraco.Web.PublishedCache.NuCache
 
             _logger.Debug<PublishedSnapshotService>("Loading media from database...");
             var sw = Stopwatch.StartNew();
+            // IMPORTANT GetAllMediaSources sorts kits by level
             var kits = _dataSource.GetAllMediaSources(scope);
             _mediaStore.SetAll(kits);
             sw.Stop();
@@ -436,7 +439,8 @@ namespace Umbraco.Web.PublishedCache.NuCache
 
             _logger.Debug<PublishedSnapshotService>("Loading media from local db...");
             var sw = Stopwatch.StartNew();
-            var kits = _localMediaDb.Select(x => x.Value);
+            var kits = _localMediaDb.Select(x => x.Value)
+                .OrderBy(x => x.Node.Level); // IMPORTANT sort by level
             _mediaStore.SetAll(kits);
             sw.Stop();
             _logger.Debug<PublishedSnapshotService>("Loaded media from local db ({Duration}ms)", sw.ElapsedMilliseconds);
@@ -647,6 +651,7 @@ namespace Umbraco.Web.PublishedCache.NuCache
                     if (capture.ChangeTypes.HasType(TreeChangeTypes.RefreshBranch))
                     {
                         // ?? should we do some RV check here?
+                        // IMPORTANT GetbranchContentSources sorts kits by level
                         var kits = _dataSource.GetBranchContentSources(scope, capture.Id);
                         _contentStore.SetBranch(capture.Id, kits);
                     }
@@ -738,6 +743,7 @@ namespace Umbraco.Web.PublishedCache.NuCache
                     if (capture.ChangeTypes.HasType(TreeChangeTypes.RefreshBranch))
                     {
                         // ?? should we do some RV check here?
+                        // IMPORTANT GetbranchContentSources sorts kits by level
                         var kits = _dataSource.GetBranchMediaSources(scope, capture.Id);
                         _mediaStore.SetBranch(capture.Id, kits);
                     }
@@ -1375,19 +1381,24 @@ WHERE cmsContentNu.nodeId IN (
             long total;
             do
             {
+                // the tree is locked, counting and comparing to total is safe
                 var descendants = _documentRepository.GetPage(query, pageIndex++, groupSize, out total, null, Ordering.By("Path"));
                 var items = new List<ContentNuDto>();
+                var count = 0;
                 foreach (var c in descendants)
                 {
                     // always the edited version
                     items.Add(GetDto(c, false));
+
                     // and also the published version if it makes any sense
                     if (c.Published)
                         items.Add(GetDto(c, true));
+
+                    count++;
                 }
 
                 db.BulkInsertRecords(items);
-                processed += items.Count;
+                processed += count;
             } while (processed < total);
         }
 
@@ -1442,10 +1453,11 @@ WHERE cmsContentNu.nodeId IN (
             long total;
             do
             {
+                // the tree is locked, counting and comparing to total is safe
                 var descendants = _mediaRepository.GetPage(query, pageIndex++, groupSize, out total, null, Ordering.By("Path"));
-                var items = descendants.Select(m => GetDto(m, false)).ToArray();
+                var items = descendants.Select(m => GetDto(m, false)).ToList();
                 db.BulkInsertRecords(items);
-                processed += items.Length;
+                processed += items.Count;
             } while (processed < total);
         }
 

src/Umbraco.Web/PublishedElementExtensions.cs

@@ -170,5 +170,23 @@ namespace Umbraco.Web
         }
 
         #endregion
+
+        #region IsSomething
+
+        /// <summary>
+        /// Gets a value indicating whether the content is visible.
+        /// </summary>
+        /// <param name="content">The content.</param>
+        /// <returns>A value indicating whether the content is visible.</returns>
+        /// <remarks>A content is not visible if it has an umbracoNaviHide property with a value of "1". Otherwise,
+        /// the content is visible.</remarks>
+        public static bool IsVisible(this IPublishedElement content)
+        {
+            // rely on the property converter - will return default bool value, ie false, if property
+            // is not defined, or has no value, else will return its value.
+            return content.Value<bool>(Constants.Conventions.Content.NaviHide) == false;
+        }
+
+        #endregion
     }
 }

src/Umbraco.Web/Runtime/WebFinalComposer.cs

@@ -3,7 +3,9 @@
 namespace Umbraco.Web.Runtime
 {
     // web's final composer composes after all user composers
+    // and *also* after ICoreComposer (in case IUserComposer is disabled)
     [ComposeAfter(typeof(IUserComposer))]
+    [ComposeAfter(typeof(ICoreComposer))]
     public class WebFinalComposer : ComponentComposer<WebFinalComponent>
     { }
 }

src/Umbraco.Web/Trees/TreeControllerBase.cs

@@ -366,7 +366,7 @@ namespace Umbraco.Web.Trees
         /// <returns></returns>
         protected bool IsDialog(FormDataCollection queryStrings)
         {
-            return queryStrings.GetValue<bool>(TreeQueryStringParameters.IsDialog);
+            return queryStrings.GetValue<string>(TreeQueryStringParameters.Use) == "dialog";
         }
 
         /// <summary>

src/Umbraco.Web/Trees/TreeQueryStringParameters.cs

@@ -5,7 +5,7 @@
     /// </summary>
     internal struct TreeQueryStringParameters
     {
-        public const string IsDialog = "isDialog";
+        public const string Use = "use";
         public const string Application = "application";
         public const string StartNodeId = "startNodeId";
         //public const string OnNodeClick = "OnNodeClick";