Sorting of images in multiple media picker

(cherry picked from commit ed5effd190)

src/SolutionInfo.cs

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

src/Umbraco.Core/AsyncLock.cs

@@ -67,31 +67,34 @@ namespace Umbraco.Core
                 : new NamedSemaphoreReleaser(_semaphore2);
         }
 
-        public Task<IDisposable> LockAsync()
-        {
-            var wait = _semaphore != null
-                ? _semaphore.WaitAsync()
-                : _semaphore2.WaitOneAsync();
+        //NOTE: We don't use the "Async" part of this lock at all
+        //TODO: Remove this and rename this class something like SystemWideLock, then we can re-instate this logic if we ever need an Async lock again
 
-            return wait.IsCompleted
-                ? _releaserTask ?? Task.FromResult(CreateReleaser()) // anonymous vs named
-                : wait.ContinueWith((_, state) => (((AsyncLock) state).CreateReleaser()),
-                    this, CancellationToken.None,
-                    TaskContinuationOptions.ExecuteSynchronously, TaskScheduler.Default);
-        }
+        //public Task<IDisposable> LockAsync()
+        //{
+        //    var wait = _semaphore != null
+        //        ? _semaphore.WaitAsync()
+        //        : _semaphore2.WaitOneAsync();
 
-        public Task<IDisposable> LockAsync(int millisecondsTimeout)
-        {
-            var wait = _semaphore != null
-                ? _semaphore.WaitAsync(millisecondsTimeout)
-                : _semaphore2.WaitOneAsync(millisecondsTimeout);
+        //    return wait.IsCompleted
+        //        ? _releaserTask ?? Task.FromResult(CreateReleaser()) // anonymous vs named
+        //        : wait.ContinueWith((_, state) => (((AsyncLock) state).CreateReleaser()),
+        //            this, CancellationToken.None,
+        //            TaskContinuationOptions.ExecuteSynchronously, TaskScheduler.Default);
+        //}
 
-            return wait.IsCompleted
-                ? _releaserTask ?? Task.FromResult(CreateReleaser()) // anonymous vs named
-                : wait.ContinueWith((_, state) => (((AsyncLock)state).CreateReleaser()),
-                    this, CancellationToken.None,
-                    TaskContinuationOptions.ExecuteSynchronously, TaskScheduler.Default);
-        }
+        //public Task<IDisposable> LockAsync(int millisecondsTimeout)
+        //{
+        //    var wait = _semaphore != null
+        //        ? _semaphore.WaitAsync(millisecondsTimeout)
+        //        : _semaphore2.WaitOneAsync(millisecondsTimeout);
+
+        //    return wait.IsCompleted
+        //        ? _releaserTask ?? Task.FromResult(CreateReleaser()) // anonymous vs named
+        //        : wait.ContinueWith((_, state) => (((AsyncLock)state).CreateReleaser()),
+        //            this, CancellationToken.None,
+        //            TaskContinuationOptions.ExecuteSynchronously, TaskScheduler.Default);
+        //}
 
         public IDisposable Lock()
         {

src/Umbraco.Core/Composing/Lifetime.cs

@@ -12,31 +12,62 @@
         /// or MS.DI, PerDependency in Autofac.</remarks>
         Transient,
 
+        // TODO: We need to fix this up, currently LightInject is the only one that behaves differently from all other containers.
+        //  ... the simple fix would be to map this to PerScopeLifetime in LI but need to wait on a response here https://github.com/seesharper/LightInject/issues/494#issuecomment-518942625
+        //
+        // we use it for controllers, httpContextBase and other request scoped objects: MembershpHelper, TagQuery, UmbracoTreeSearcher and ISearchableTree
+        // - so that they are automatically disposed at the end of the scope (ie request)
+        // - not sure they should not be simply 'scoped'?
+        
         /// <summary>
         /// One unique instance per request.
         /// </summary>
-        // TODO: review lifetimes for LightInject vs other containers
-        // currently, corresponds to 'Request' in LightInject which is 'Transient + disposed by Scope'
-        // but NOT (in LightInject) a per-web-request lifetime, more a TransientScoped
-        //
-        // we use it for controllers, httpContextBase and umbracoContext
-        // - so that they are automatically disposed at the end of the scope (ie request)
-        // - not sure they should not be simply 'scoped'?
-        //
-        // Castle has an extra PerWebRequest something, and others use scope
-        // what about Request before first request ie during application startup?
-        // see http://blog.ploeh.dk/2009/11/17/UsingCastleWindsor'sPerWebRequestlifestylewithASP.NETMVConIIS7/
-        // Castle ends up requiring a special scope manager too
-        // see https://groups.google.com/forum/#!topic/castle-project-users/1E2W9LVIYR4
-        //
-        // but maybe also - why are we requiring scoped services at startup?
+        /// <remarks>
+        /// <para>
+        /// Any instance created with this lifetime will be disposed at the end of a request.
+        /// </para>
+        /// Corresponds to
+        /// <para>
+        /// PerRequestLifeTime in LightInject - means transient but disposed at the end of the current web request.
+        /// see: https://github.com/seesharper/LightInject/issues/494#issuecomment-518493262
+        /// </para>
+        /// <para>
+        /// Scoped in MS.DI - means one per web request.
+        /// see https://docs.microsoft.com/en-us/aspnet/core/fundamentals/dependency-injection?view=aspnetcore-2.2#service-lifetimes</para>
+        /// <para>
+        /// InstancePerRequest in Autofac - means one per web request.
+        /// see https://autofaccn.readthedocs.io/en/latest/lifetime/instance-scope.html#instance-per-request
+        /// But "Behind the scenes, though, it’s still just instance per matching lifetime scope."
+        /// </para>
+        /// <para>
+        /// LifestylePerWebRequest in Castle Windsor - means one per web request.
+        /// see https://github.com/castleproject/Windsor/blob/master/docs/mvc-tutorial-part-7-lifestyles.md#the-perwebrequest-lifestyle
+        /// </para>
+        /// </remarks>        
         Request,
 
         /// <summary>
-        /// One unique instance per container scope.
+        /// One unique instance per scope.
         /// </summary>
-        /// <remarks>Corresponds to Scope in LightInject, Scoped in MS.DI
-        /// or Castle Windsor, PerLifetimeScope in Autofac.</remarks>
+        /// <remarks>
+        /// <para>
+        /// Any instance created with this lifetime will be disposed at the end of the current scope.
+        /// </para>
+        /// Corresponds to
+        /// <para>PerScopeLifetime in LightInject (when in a request, means one per web request)</para>
+        /// <para>
+        /// Scoped in MS.DI (when in a request, means one per web request)
+        /// see https://docs.microsoft.com/en-us/aspnet/core/fundamentals/dependency-injection?view=aspnetcore-2.2#service-lifetimes</para>
+        /// <para>
+        /// InstancePerLifetimeScope in Autofac (when in a request, means one per web request)
+        /// see https://autofaccn.readthedocs.io/en/latest/lifetime/instance-scope.html#instance-per-lifetime-scope
+        /// Also note that Autofac's InstancePerRequest is the same as this, see https://autofaccn.readthedocs.io/en/latest/lifetime/instance-scope.html#instance-per-request
+        /// it says "Behind the scenes, though, it’s still just instance per matching lifetime scope."
+        /// </para>
+        /// <para>
+        /// LifestyleScoped in Castle Windsor
+        /// </para>
+        /// </remarks>
         Scope,
 
         /// <summary>

src/Umbraco.Core/Constants-PropertyEditors.cs

@@ -14,6 +14,23 @@ namespace Umbraco.Core
             /// </summary>
             public const string InternalGenericPropertiesPrefix = "_umb_";
 
+            public static class Legacy
+            {
+                public static class Aliases
+                {
+                    public const string Textbox = "Umbraco.Textbox";
+                    public const string Date = "Umbraco.Date";
+                    public const string ContentPicker2 = "Umbraco.ContentPicker2";
+                    public const string MediaPicker2 = "Umbraco.MediaPicker2";
+                    public const string MemberPicker2 = "Umbraco.MemberPicker2";
+                    public const string MultiNodeTreePicker2 = "Umbraco.MultiNodeTreePicker2";
+                    public const string TextboxMultiple = "Umbraco.TextboxMultiple";
+                    public const string RelatedLinks2 = "Umbraco.RelatedLinks2";
+                    public const string RelatedLinks = "Umbraco.RelatedLinks";
+
+                }
+            }
+
             /// <summary>
             /// Defines Umbraco built-in property editor aliases.
             /// </summary>

src/Umbraco.Core/EnumerableExtensions.cs

@@ -10,6 +10,8 @@ namespace Umbraco.Core
     ///</summary>
     public static class EnumerableExtensions
     {
+        internal static bool IsCollectionEmpty<T>(this IReadOnlyCollection<T> list) => list == null || list.Count == 0;
+
         internal static bool HasDuplicates<T>(this IEnumerable<T> items, bool includeNull)
         {
             var hs = new HashSet<T>();
@@ -112,7 +114,6 @@ namespace Umbraco.Core
             }
         }
 
-
         /// <summary>
         /// Returns true if all items in the other collection exist in this collection
         /// </summary>

src/Umbraco.Core/Exceptions/PanicException.cs

@@ -0,0 +1,28 @@
+using System;
+using System.Runtime.Serialization;
+
+namespace Umbraco.Core.Exceptions
+{
+    /// <summary>
+    /// Internal exception that in theory should never ben thrown, it is only thrown in circumstances that should never happen
+    /// </summary>
+    [Serializable]
+    internal class PanicException : Exception
+    {
+        public PanicException()
+        {
+        }
+
+        public PanicException(string message) : base(message)
+        {
+        }
+
+        public PanicException(string message, Exception innerException) : base(message, innerException)
+        {
+        }
+
+        protected PanicException(SerializationInfo info, StreamingContext context) : base(info, context)
+        {
+        }
+    }
+}

src/Umbraco.Core/MainDom.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Diagnostics;
 using System.Linq;
 using System.Threading;
 using System.Web.Hosting;
@@ -113,7 +114,7 @@ namespace Umbraco.Core
 
             lock (_locko)
             {
-                _logger.Debug<MainDom>("Signaled {Signaled} ({SignalSource})", _signaled ? "(again)" : string.Empty, source);
+                _logger.Debug<MainDom>("Signaled ({Signaled}) ({SignalSource})", _signaled ? "again" : "first", source);
                 if (_signaled) return;
                 if (_isMainDom == false) return; // probably not needed
                 _signaled = true;
@@ -171,6 +172,7 @@ namespace Umbraco.Core
                 // if more than 1 instance reach that point, one will get the lock
                 // and the other one will timeout, which is accepted
 
+                //TODO: This can throw a TimeoutException - in which case should this be in a try/finally to ensure the signal is always reset?
                 _asyncLocker = _asyncLock.Lock(LockTimeoutMilliseconds);
                 _isMainDom = true;
 
@@ -181,6 +183,9 @@ namespace Umbraco.Core
                 // which is accepted
 
                 _signal.Reset();
+
+                //WaitOneAsync (ext method) will wait for a signal without blocking the main thread, the waiting is done on a background thread
+
                 _signal.WaitOneAsync()
                     .ContinueWith(_ => OnSignal("signal"));
 

src/Umbraco.Core/Mapping/UmbracoMapper.cs

@@ -3,6 +3,7 @@ using System.Collections;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Linq;
+using Umbraco.Core.Exceptions;
 
 namespace Umbraco.Core.Mapping
 {
@@ -259,7 +260,7 @@ namespace Umbraco.Core.Mapping
             if (typeof(TTarget).IsArray)
             {
                 var elementType = typeof(TTarget).GetElementType();
-                if (elementType == null) throw new Exception("panic");
+                if (elementType == null) throw new PanicException("elementType == null which should never occur");
                 var targetArray = Array.CreateInstance(elementType, targetList.Count);
                 targetList.CopyTo(targetArray, 0);
                 target = targetArray;
@@ -382,7 +383,7 @@ namespace Umbraco.Core.Mapping
         {
             if (type.IsArray) return type.GetElementType();
             if (type.IsGenericType) return type.GenericTypeArguments[0];
-            throw new Exception("panic");
+            throw new PanicException($"Could not get enumerable or array type from {type}");
         }
 
         /// <summary>

src/Umbraco.Core/Migrations/Upgrade/UmbracoPlan.cs

@@ -74,6 +74,11 @@ namespace Umbraco.Core.Migrations.Upgrade
                     throw new InvalidOperationException($"Version {currentVersion} cannot be migrated to {UmbracoVersion.SemanticVersion}."
                                                         + $" Please upgrade first to at least {minVersion}.");
 
+                // Force versions between 7.14.*-7.15.* into into 7.14 initial state. Because there is no db-changes,
+                // and we don't want users to workaround my putting in version 7.14.0 them self.
+                if (minVersion <= currentVersion && currentVersion < new SemVersion(7, 16))
+                    return GetInitState(minVersion);
+
                 // initial state is eg "{init-7.14.0}"
                 return GetInitState(currentVersion);
             }

src/Umbraco.Core/Migrations/Upgrade/V_8_0_0/ConvertRelatedLinksToMultiUrlPicker.cs

@@ -19,8 +19,8 @@ namespace Umbraco.Core.Migrations.Upgrade.V_8_0_0
             var sqlDataTypes = Sql()
                 .Select<DataTypeDto>()
                 .From<DataTypeDto>()
-                .Where<DataTypeDto>(x => x.EditorAlias == "Umbraco.RelatedLinks"
-                                         || x.EditorAlias == "Umbraco.RelatedLinks2");
+                .Where<DataTypeDto>(x => x.EditorAlias == Constants.PropertyEditors.Legacy.Aliases.RelatedLinks
+                                         || x.EditorAlias == Constants.PropertyEditors.Legacy.Aliases.RelatedLinks2);
 
             var dataTypes = Database.Fetch<DataTypeDto>(sqlDataTypes);
             var dataTypeIds = dataTypes.Select(x => x.NodeId).ToList();
@@ -50,10 +50,10 @@ namespace Umbraco.Core.Migrations.Upgrade.V_8_0_0
             var properties = Database.Fetch<PropertyDataDto>(sqlPropertyData);
 
             // Create a Multi URL Picker datatype for the converted RelatedLinks data
-            
+
             foreach (var property in properties)
             {
-                var value = property.Value.ToString();
+                var value = property.Value?.ToString();
                 if (string.IsNullOrWhiteSpace(value))
                     continue;
 
@@ -89,7 +89,7 @@ namespace Umbraco.Core.Migrations.Upgrade.V_8_0_0
                         Name = relatedLink.Caption,
                         Target = relatedLink.NewWindow ? "_blank" : null,
                         Udi = udi,
-                        // Should only have a URL if it's an external link otherwise it wil be a UDI 
+                        // Should only have a URL if it's an external link otherwise it wil be a UDI
                         Url = relatedLink.IsInternal == false ? relatedLink.Link : null
                     };
 
@@ -103,7 +103,7 @@ namespace Umbraco.Core.Migrations.Upgrade.V_8_0_0
                 Database.Update(property);
             }
 
-            
+
         }
     }
 

src/Umbraco.Core/Migrations/Upgrade/V_8_0_0/DataTypeMigration.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 using System.Linq;
 using Newtonsoft.Json;
 using Umbraco.Core.Composing;
@@ -18,6 +19,18 @@ namespace Umbraco.Core.Migrations.Upgrade.V_8_0_0
         private readonly PropertyEditorCollection _propertyEditors;
         private readonly ILogger _logger;
 
+        private static readonly ISet<string> LegacyAliases = new HashSet<string>()
+        {
+            Constants.PropertyEditors.Legacy.Aliases.Date,
+            Constants.PropertyEditors.Legacy.Aliases.Textbox,
+            Constants.PropertyEditors.Legacy.Aliases.ContentPicker2,
+            Constants.PropertyEditors.Legacy.Aliases.MediaPicker2,
+            Constants.PropertyEditors.Legacy.Aliases.MemberPicker2,
+            Constants.PropertyEditors.Legacy.Aliases.RelatedLinks2,
+            Constants.PropertyEditors.Legacy.Aliases.TextboxMultiple,
+            Constants.PropertyEditors.Legacy.Aliases.MultiNodeTreePicker2,
+        };
+
         public DataTypeMigration(IMigrationContext context, PreValueMigratorCollection preValueMigrators, PropertyEditorCollection propertyEditors, ILogger logger)
             : base(context)
         {
@@ -70,16 +83,23 @@ namespace Umbraco.Core.Migrations.Upgrade.V_8_0_0
                 var newAlias = migrator.GetNewAlias(dataType.EditorAlias);
                 if (newAlias == null)
                 {
-                    _logger.Warn<DataTypeMigration>("Skipping validation of configuration for data type {NodeId} : {EditorAlias}."
-                                                    + " Please ensure that the configuration is valid. The site may fail to start and / or load data types and run.",
-                                                    dataType.NodeId, dataType.EditorAlias);
+                    if (!LegacyAliases.Contains(dataType.EditorAlias))
+                    {
+                        _logger.Warn<DataTypeMigration>(
+                            "Skipping validation of configuration for data type {NodeId} : {EditorAlias}."
+                            + " Please ensure that the configuration is valid. The site may fail to start and / or load data types and run.",
+                            dataType.NodeId, dataType.EditorAlias);
+                    }
                 }
                 else if (!_propertyEditors.TryGet(newAlias, out var propertyEditor))
                 {
-                    _logger.Warn<DataTypeMigration>("Skipping validation of configuration for data type {NodeId} : {NewEditorAlias} (was: {EditorAlias})"
-                                                    + " because no property editor with that alias was found."
-                                                    + " Please ensure that the configuration is valid. The site may fail to start and / or load data types and run.",
-                                                    dataType.NodeId, newAlias, dataType.EditorAlias);
+                    if (!LegacyAliases.Contains(newAlias))
+                    {
+                        _logger.Warn<DataTypeMigration>("Skipping validation of configuration for data type {NodeId} : {NewEditorAlias} (was: {EditorAlias})"
+                                                        + " because no property editor with that alias was found."
+                                                        + " Please ensure that the configuration is valid. The site may fail to start and / or load data types and run.",
+                            dataType.NodeId, newAlias, dataType.EditorAlias);
+                    }
                 }
                 else
                 {

src/Umbraco.Core/Migrations/Upgrade/V_8_0_0/DataTypes/ContentPickerPreValueMigrator.cs

@@ -3,7 +3,7 @@
     class ContentPickerPreValueMigrator : DefaultPreValueMigrator
     {
         public override bool CanMigrate(string editorAlias)
-            => editorAlias == "Umbraco.ContentPicker2";
+            => editorAlias == Constants.PropertyEditors.Legacy.Aliases.ContentPicker2;
 
         public override string GetNewAlias(string editorAlias)
             => null;

src/Umbraco.Core/Migrations/Upgrade/V_8_0_0/DataTypes/DropDownFlexiblePreValueMigrator.cs

@@ -0,0 +1,32 @@
+using System.Collections.Generic;
+using System.Linq;
+using Umbraco.Core.PropertyEditors;
+
+namespace Umbraco.Core.Migrations.Upgrade.V_8_0_0.DataTypes
+{
+    class DropDownFlexiblePreValueMigrator : IPreValueMigrator
+    {
+        public bool CanMigrate(string editorAlias)
+            => editorAlias == "Umbraco.DropDown.Flexible";
+
+        public virtual string GetNewAlias(string editorAlias)
+            => null;
+
+        public object GetConfiguration(int dataTypeId, string editorAlias, Dictionary<string, PreValueDto> preValues)
+        {
+            var config = new DropDownFlexibleConfiguration();
+            foreach (var preValue in preValues.Values)
+            {
+                if (preValue.Alias == "multiple")
+                {
+                    config.Multiple = (preValue.Value == "1");
+                }
+                else
+                {
+                    config.Items.Add(new ValueListConfiguration.ValueListItem { Id = preValue.Id, Value = preValue.Value });
+                }
+            }
+            return config;
+        }
+    }
+}

src/Umbraco.Core/Migrations/Upgrade/V_8_0_0/DataTypes/MediaPickerPreValueMigrator.cs

@@ -6,15 +6,15 @@ namespace Umbraco.Core.Migrations.Upgrade.V_8_0_0.DataTypes
     {
         private readonly string[] _editors =
         {
-            "Umbraco.MediaPicker2",
-            "Umbraco.MediaPicker"
+            Constants.PropertyEditors.Legacy.Aliases.MediaPicker2,
+            Constants.PropertyEditors.Aliases.MediaPicker
         };
 
         public override bool CanMigrate(string editorAlias)
             => _editors.Contains(editorAlias);
 
         public override string GetNewAlias(string editorAlias)
-            => "Umbraco.MediaPicker";
+            => Constants.PropertyEditors.Aliases.MediaPicker;
 
         // you wish - but MediaPickerConfiguration lives in Umbraco.Web
         /*

src/Umbraco.Core/Migrations/Upgrade/V_8_0_0/DataTypes/PreValueMigratorComposer.cs

@@ -19,6 +19,7 @@ public class PreValueMigratorComposer : ICoreComposer
             .Append<NestedContentPreValueMigrator>()
             .Append<DecimalPreValueMigrator>()
             .Append<ListViewPreValueMigrator>()
+            .Append<DropDownFlexiblePreValueMigrator>()
             .Append<ValueListPreValueMigrator>();
     }
 }

src/Umbraco.Core/Migrations/Upgrade/V_8_0_0/DataTypes/RenamingPreValueMigrator.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Linq;
+using Umbraco.Core.Exceptions;
 
 namespace Umbraco.Core.Migrations.Upgrade.V_8_0_0.DataTypes
 {
@@ -20,7 +21,7 @@ namespace Umbraco.Core.Migrations.Upgrade.V_8_0_0.DataTypes
                 case "Umbraco.NoEdit":
                     return Constants.PropertyEditors.Aliases.Label;
                 default:
-                    throw new Exception("panic");
+                    throw new PanicException($"The alias {editorAlias} is not supported");
             }
         }
     }

src/Umbraco.Core/Migrations/Upgrade/V_8_0_0/DataTypes/ValueListPreValueMigrator.cs

@@ -9,6 +9,7 @@ namespace Umbraco.Core.Migrations.Upgrade.V_8_0_0.DataTypes
         private readonly string[] _editors =
         {
             "Umbraco.RadioButtonList",
+            "Umbraco.CheckBoxList",
             "Umbraco.DropDown",
             "Umbraco.DropdownlistPublishingKeys",
             "Umbraco.DropDownMultiple",

src/Umbraco.Core/Migrations/Upgrade/V_8_0_0/MergeDateAndDateTimePropertyEditor.cs

@@ -16,7 +16,7 @@ namespace Umbraco.Core.Migrations.Upgrade.V_8_0_0
 
         public override void Migrate()
         {
-            var dataTypes = GetDataTypes("Umbraco.Date");
+            var dataTypes = GetDataTypes(Constants.PropertyEditors.Legacy.Aliases.Date);
 
             foreach (var dataType in dataTypes)
             {
@@ -25,6 +25,14 @@ namespace Umbraco.Core.Migrations.Upgrade.V_8_0_0
                 {
                     config = (DateTimeConfiguration) new CustomDateTimeConfigurationEditor().FromDatabase(
                         dataType.Configuration);
+
+                    // If the Umbraco.Date type is the default from V7 and it has never been updated, then the
+                    // configuration is empty, and the format stuff is handled by in JS by moment.js. - We can't do that
+                    // after the migration, so we force the format to the default from V7.
+                    if (string.IsNullOrEmpty(dataType.Configuration))
+                    {
+                        config.Format = "YYYY-MM-DD";
+                    };
                 }
                 catch (Exception ex)
                 {

src/Umbraco.Core/Migrations/Upgrade/V_8_0_0/PropertyEditorsMigration.cs

@@ -12,12 +12,12 @@ namespace Umbraco.Core.Migrations.Upgrade.V_8_0_0
 
         public override void Migrate()
         {
-            RenameDataType(Constants.PropertyEditors.Aliases.ContentPicker + "2", Constants.PropertyEditors.Aliases.ContentPicker);
-            RenameDataType(Constants.PropertyEditors.Aliases.MediaPicker + "2", Constants.PropertyEditors.Aliases.MediaPicker);
-            RenameDataType(Constants.PropertyEditors.Aliases.MemberPicker + "2", Constants.PropertyEditors.Aliases.MemberPicker);
-            RenameDataType(Constants.PropertyEditors.Aliases.MultiNodeTreePicker + "2", Constants.PropertyEditors.Aliases.MultiNodeTreePicker);
-            RenameDataType("Umbraco.TextboxMultiple", Constants.PropertyEditors.Aliases.TextArea, false);
-            RenameDataType("Umbraco.Textbox", Constants.PropertyEditors.Aliases.TextBox, false);
+            RenameDataType(Constants.PropertyEditors.Legacy.Aliases.ContentPicker2, Constants.PropertyEditors.Aliases.ContentPicker);
+            RenameDataType(Constants.PropertyEditors.Legacy.Aliases.MediaPicker2, Constants.PropertyEditors.Aliases.MediaPicker);
+            RenameDataType(Constants.PropertyEditors.Legacy.Aliases.MemberPicker2, Constants.PropertyEditors.Aliases.MemberPicker);
+            RenameDataType(Constants.PropertyEditors.Legacy.Aliases.MultiNodeTreePicker2, Constants.PropertyEditors.Aliases.MultiNodeTreePicker);
+            RenameDataType(Constants.PropertyEditors.Legacy.Aliases.TextboxMultiple, Constants.PropertyEditors.Aliases.TextArea, false);
+            RenameDataType(Constants.PropertyEditors.Legacy.Aliases.Textbox, Constants.PropertyEditors.Aliases.TextBox, false);
         }
 
         private void RenameDataType(string fromAlias, string toAlias, bool checkCollision = true)
@@ -30,7 +30,20 @@ namespace Umbraco.Core.Migrations.Upgrade.V_8_0_0
                     .Where<DataTypeDto>(x => x.EditorAlias == toAlias));
 
                 if (oldCount > 0)
-                    throw new InvalidOperationException($"Cannot rename datatype alias \"{fromAlias}\" to \"{toAlias}\" because the target alias is already used.");
+                {
+                    // If we throw it means that the upgrade will exit and cannot continue.
+                    // This will occur if a v7 site has the old "Obsolete" property editors that are already named with the `toAlias` name.
+                    // TODO: We should have an additional upgrade step when going from 7 -> 8 like we did with 6 -> 7 that shows a compatibility report,
+                    // this would include this check and then we can provide users with information on what they should do (i.e. before upgrading to v8 they will
+                    // need to migrate these old obsolete editors to non-obsolete editors)
+
+                    throw new InvalidOperationException(
+                        $"Cannot rename datatype alias \"{fromAlias}\" to \"{toAlias}\" because the target alias is already used." +
+                        $"This is generally because when upgrading from a v7 to v8 site, the v7 site contains Data Types that reference old and already Obsolete " +
+                        $"Property Editors. Before upgrading to v8, any Data Types using property editors that are named with the prefix '(Obsolete)' must be migrated " +
+                        $"to the non-obsolete v7 property editors of the same type.");
+                }
+
             }
 
             Database.Execute(Sql()

src/Umbraco.Core/Migrations/Upgrade/V_8_0_0/TablesForScheduledPublishing.cs

@@ -14,11 +14,18 @@ namespace Umbraco.Core.Migrations.Upgrade.V_8_0_0
         public override void Migrate()
         {
             //Get anything currently scheduled
-            var scheduleSql = new Sql()
-                .Select("nodeId", "releaseDate", "expireDate")
+            var releaseSql = new Sql()
+                .Select("nodeId", "releaseDate")
                 .From("umbracoDocument")
-                .Where("releaseDate IS NOT NULL OR expireDate IS NOT NULL");
-            var schedules = Database.Dictionary<int, (DateTime? releaseDate, DateTime? expireDate)> (scheduleSql);
+                .Where("releaseDate IS NOT NULL");
+            var releases = Database.Dictionary<int, DateTime> (releaseSql);
+
+            var expireSql = new Sql()
+                .Select("nodeId", "expireDate")
+                .From("umbracoDocument")
+                .Where("expireDate IS NOT NULL");
+            var expires = Database.Dictionary<int, DateTime>(expireSql);
+
 
             //drop old cols
             Delete.Column("releaseDate").FromTable("umbracoDocument").Do();
@@ -27,20 +34,25 @@ namespace Umbraco.Core.Migrations.Upgrade.V_8_0_0
             Create.Table<ContentScheduleDto>(true).Do();
 
             //migrate the schedule
-            foreach(var s in schedules)
+            foreach(var s in releases)
             {
-                var date = s.Value.releaseDate;
+                var date = s.Value;
                 var action = ContentScheduleAction.Release.ToString();
-                if (!date.HasValue)
-                {
-                    date = s.Value.expireDate;
-                    action = ContentScheduleAction.Expire.ToString();
-                }
 
                 Insert.IntoTable(ContentScheduleDto.TableName)
-                    .Row(new { nodeId = s.Key, date = date.Value, action = action })
+                    .Row(new { id = Guid.NewGuid(), nodeId = s.Key, date = date, action = action })
                     .Do();
             }
+
+            foreach (var s in expires)
+            {
+                var date = s.Value;
+                var action = ContentScheduleAction.Expire.ToString();
+
+                Insert.IntoTable(ContentScheduleDto.TableName)
+                    .Row(new { id = Guid.NewGuid(), nodeId = s.Key, date = date, action = action })
+                    .Do();
+            }            
         }
     }
 }

src/Umbraco.Core/Migrations/Upgrade/V_8_1_0/ConvertTinyMceAndGridMediaUrlsToLocalLink.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 using System.Linq;
 using System.Text.RegularExpressions;
 using Newtonsoft.Json;
@@ -36,6 +37,7 @@ namespace Umbraco.Core.Migrations.Upgrade.V_8_1_0
 
             var properties = Database.Fetch<PropertyDataDto>(sqlPropertyData);
 
+            var exceptions = new List<Exception>();
             foreach (var property in properties)
             {
                 var value = property.TextValue;
@@ -43,19 +45,34 @@ namespace Umbraco.Core.Migrations.Upgrade.V_8_1_0
 
                 if (property.PropertyTypeDto.DataTypeDto.EditorAlias == Constants.PropertyEditors.Aliases.Grid)
                 {
-                    var obj = JsonConvert.DeserializeObject<JObject>(value);
-                    var allControls = obj.SelectTokens("$.sections..rows..areas..controls");
-
-                    foreach (var control in allControls.SelectMany(c => c))
+                    try
                     {
-                        var controlValue = control["value"];
-                        if (controlValue.Type == JTokenType.String)
+                        var obj = JsonConvert.DeserializeObject<JObject>(value);
+                        var allControls = obj.SelectTokens("$.sections..rows..areas..controls");
+
+                        foreach (var control in allControls.SelectMany(c => c))
                         {
-                            control["value"] = UpdateMediaUrls(mediaLinkPattern, controlValue.Value<string>());
+                            var controlValue = control["value"];
+                            if (controlValue.Type == JTokenType.String)
+                            {
+                                control["value"] = UpdateMediaUrls(mediaLinkPattern, controlValue.Value<string>());
+                            }
                         }
+
+                        property.TextValue = JsonConvert.SerializeObject(obj);
+                    }
+                    catch (JsonException e)
+                    {
+                        exceptions.Add(new InvalidOperationException(
+                            "Cannot deserialize the value as json. This can be because the property editor " +
+                            "type is changed from another type into a grid. Old versions of the value in this " +
+                            "property can have the structure from the old property editor type. This needs to be " +
+                            "changed manually before updating the database.\n" +
+                            $"Property info: Id = {property.Id}, LanguageId = {property.LanguageId}, VersionId = {property.VersionId}, Value = {property.Value}"
+                            , e));
+                        continue;
                     }
 
-                    property.TextValue = JsonConvert.SerializeObject(obj);
                 }
                 else
                 {
@@ -65,6 +82,12 @@ namespace Umbraco.Core.Migrations.Upgrade.V_8_1_0
                 Database.Update(property);
             }
 
+
+            if (exceptions.Any())
+            {
+                throw new AggregateException("One or more errors related to unexpected data in grid values occurred.", exceptions);
+            }
+
             Context.AddPostMigration<RebuildPublishedSnapshot>();
         }
 

src/Umbraco.Core/Models/ContentRepositoryExtensions.cs

@@ -222,7 +222,13 @@ namespace Umbraco.Core.Models
             return true;
         }
 
-        public static void UnpublishCulture(this IContent content, string culture = "*")
+        /// <summary>
+        /// Returns false if the culture is already unpublished
+        /// </summary>
+        /// <param name="content"></param>
+        /// <param name="culture"></param>
+        /// <returns></returns>
+        public static bool UnpublishCulture(this IContent content, string culture = "*")
         {
             culture = culture.NullOrWhiteSpaceAsNull();
 
@@ -230,16 +236,31 @@ namespace Umbraco.Core.Models
             if (!content.ContentType.SupportsPropertyVariation(culture, "*", true))
                 throw new NotSupportedException($"Culture \"{culture}\" is not supported by content type \"{content.ContentType.Alias}\" with variation \"{content.ContentType.Variations}\".");
 
-            if (culture == "*") // all cultures
+
+            var keepProcessing = true;
+
+            if (culture == "*")
+            {
+                // all cultures
                 content.ClearPublishInfos();
-            else // one single culture
-                content.ClearPublishInfo(culture);
+            }
+            else
+            {
+                // one single culture
+                keepProcessing = content.ClearPublishInfo(culture);
+            }
+            
 
-            // property.PublishValues only publishes what is valid, variation-wise
-            foreach (var property in content.Properties)
-                property.UnpublishValues(culture);
+            if (keepProcessing)
+            {
+                // property.PublishValues only publishes what is valid, variation-wise
+                foreach (var property in content.Properties)
+                    property.UnpublishValues(culture);
 
-            content.PublishedState = PublishedState.Publishing;
+                content.PublishedState = PublishedState.Publishing;
+            }
+
+            return keepProcessing;
         }
 
         public static void ClearPublishInfos(this IContent content)
@@ -247,15 +268,24 @@ namespace Umbraco.Core.Models
             content.PublishCultureInfos = null;
         }
 
-        public static void ClearPublishInfo(this IContent content, string culture)
+        /// <summary>
+        /// Returns false if the culture is already unpublished
+        /// </summary>
+        /// <param name="content"></param>
+        /// <param name="culture"></param>
+        /// <returns></returns>
+        public static bool ClearPublishInfo(this IContent content, string culture)
         {
             if (culture.IsNullOrWhiteSpace())
                 throw new ArgumentNullOrEmptyException(nameof(culture));
 
-            content.PublishCultureInfos.Remove(culture);
-
-            // set the culture to be dirty - it's been modified
-            content.TouchCulture(culture);
+            var removed = content.PublishCultureInfos.Remove(culture);
+            if (removed)
+            {
+                // set the culture to be dirty - it's been modified
+                content.TouchCulture(culture);
+            }
+            return removed;
         }
 
         /// <summary>

src/Umbraco.Core/Models/IContentTypeBase.cs

@@ -101,7 +101,7 @@ namespace Umbraco.Core.Models
         PropertyGroupCollection PropertyGroups { get; set; }
 
         /// <summary>
-        /// Gets all local property types belonging to a group, across all local property groups.
+        /// Gets all local property types all local property groups or ungrouped.
         /// </summary>
         IEnumerable<PropertyType> PropertyTypes { get; }
 

src/Umbraco.Core/Models/PropertyType.cs

@@ -21,6 +21,7 @@ namespace Umbraco.Core.Models
         private string _alias;
         private string _description;
         private int _dataTypeId;
+        private Guid _dataTypeKey;
         private Lazy<int> _propertyGroupId;
         private string _propertyEditorAlias;
         private ValueStorageType _valueStorageType;
@@ -139,6 +140,13 @@ namespace Umbraco.Core.Models
             set => SetPropertyValueAndDetectChanges(value, ref _dataTypeId, nameof(DataTypeId));
         }
 
+        [DataMember]
+        public Guid DataTypeKey
+        {
+            get => _dataTypeKey;
+            set => SetPropertyValueAndDetectChanges(value, ref _dataTypeKey, nameof(DataTypeKey));
+        }
+
         /// <summary>
         /// Gets or sets the alias of the property editor for this property type.
         /// </summary>

src/Umbraco.Core/Models/PublishedContent/ILivePublishedModelFactory.cs

@@ -13,6 +13,10 @@
         /// <summary>
         /// Refreshes the factory.
         /// </summary>
+        /// <remarks>
+        /// <para>This will typically re-compiled models/classes into a new DLL that are used to populate the cache.</para>
+        /// <para>This is called prior to refreshing the cache.</para>
+        /// </remarks>
         void Refresh();
     }
 }

src/Umbraco.Core/Models/PublishedContent/ModelType.cs

@@ -75,7 +75,7 @@ namespace Umbraco.Core.Models.PublishedContent
                 return type;
             var def = type.GetGenericTypeDefinition();
             if (def == null)
-                throw new InvalidOperationException("panic");
+                throw new PanicException($"The type {type} has not generic type definition");
 
             var args = type.GetGenericArguments().Select(x => Map(x, modelTypes, true)).ToArray();
             return def.MakeGenericType(args);
@@ -114,7 +114,7 @@ namespace Umbraco.Core.Models.PublishedContent
                 return type.FullName;
             var def = type.GetGenericTypeDefinition();
             if (def == null)
-                throw new InvalidOperationException("panic");
+                throw new PanicException($"The type {type} has not generic type definition");
 
             var args = type.GetGenericArguments().Select(x => MapToName(x, map, true)).ToArray();
             var defFullName = def.FullName.Substring(0, def.FullName.IndexOf('`'));

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

@@ -12,7 +12,7 @@ namespace Umbraco.Core.Persistence.Factories
         public static IEnumerable<Property> BuildEntities(PropertyType[] propertyTypes, IReadOnlyCollection<PropertyDataDto> dtos, int publishedVersionId, ILanguageRepository languageRepository)
         {
             var properties = new List<Property>();
-            var xdtos = dtos.GroupBy(x => x.PropertyTypeId).ToDictionary(x => x.Key, x => (IEnumerable<PropertyDataDto>) x);
+            var xdtos = dtos.GroupBy(x => x.PropertyTypeId).ToDictionary(x => x.Key, x => (IEnumerable<PropertyDataDto>)x);
 
             foreach (var propertyType in propertyTypes)
             {
@@ -104,10 +104,14 @@ namespace Umbraco.Core.Persistence.Factories
         /// <param name="properties">The properties to map</param>
         /// <param name="languageRepository"></param>
         /// <param name="edited">out parameter indicating that one or more properties have been edited</param>
-        /// <param name="editedCultures">out parameter containing a collection of edited cultures when the contentVariation varies by culture</param>
+        /// <param name="editedCultures">
+        /// Out parameter containing a collection of edited cultures when the contentVariation varies by culture.
+        /// The value of this will be used to populate the edited cultures in the umbracoDocumentCultureVariation table.
+        /// </param>
         /// <returns></returns>
         public static IEnumerable<PropertyDataDto> BuildDtos(ContentVariation contentVariation, int currentVersionId, int publishedVersionId, IEnumerable<Property> properties,
-            ILanguageRepository languageRepository, out bool edited, out HashSet<string> editedCultures)
+            ILanguageRepository languageRepository, out bool edited,
+            out HashSet<string> editedCultures)
         {
             var propertyDataDtos = new List<PropertyDataDto>();
             edited = false;
@@ -130,6 +134,9 @@ namespace Umbraco.Core.Persistence.Factories
                     // publishing = deal with edit and published values
                     foreach (var propertyValue in property.Values)
                     {
+                        var isInvariantValue = propertyValue.Culture == null;
+                        var isCultureValue = propertyValue.Culture != null && propertyValue.Segment == null;
+
                         // deal with published value
                         if (propertyValue.PublishedValue != null && publishedVersionId > 0)
                             propertyDataDtos.Add(BuildDto(publishedVersionId, property, languageRepository.GetIdByIsoCode(propertyValue.Culture), propertyValue.Segment, propertyValue.PublishedValue));
@@ -138,26 +145,36 @@ namespace Umbraco.Core.Persistence.Factories
                         if (propertyValue.EditedValue != null)
                             propertyDataDtos.Add(BuildDto(currentVersionId, property, languageRepository.GetIdByIsoCode(propertyValue.Culture), propertyValue.Segment, propertyValue.EditedValue));
 
+                        // property.Values will contain ALL of it's values, both variant and invariant which will be populated if the
+                        // administrator has previously changed the property type to be variant vs invariant.
+                        // We need to check for this scenario here because otherwise the editedCultures and edited flags
+                        // will end up incorrectly set in the umbracoDocumentCultureVariation table so here we need to
+                        // only process edited cultures based on the current value type and how the property varies.
+                        // The above logic will still persist the currently saved property value for each culture in case the admin
+                        // decides to swap the property's variance again, in which case the edited flag will be recalculated.
+
+                        if (property.PropertyType.VariesByCulture() && isInvariantValue || !property.PropertyType.VariesByCulture() && isCultureValue)
+                            continue;
+
                         // use explicit equals here, else object comparison fails at comparing eg strings
                         var sameValues = propertyValue.PublishedValue == null ? propertyValue.EditedValue == null : propertyValue.PublishedValue.Equals(propertyValue.EditedValue);
+
                         edited |= !sameValues;
 
-                        if (entityVariesByCulture // cultures can be edited, ie CultureNeutral is supported
-                            && propertyValue.Culture != null && propertyValue.Segment == null // and value is CultureNeutral
-                            && !sameValues) // and edited and published are different
+                        if (entityVariesByCulture && !sameValues)
                         {
-                            editedCultures.Add(propertyValue.Culture); // report culture as edited
-                        }
+                            if (isCultureValue) 
+                            {
+                                editedCultures.Add(propertyValue.Culture); // report culture as edited
+                            }
+                            else if (isInvariantValue)
+                            {
+                                // flag culture as edited if it contains an edited invariant property
+                                if (defaultCulture == null)
+                                    defaultCulture = languageRepository.GetDefaultIsoCode();
 
-                        // flag culture as edited if it contains an edited invariant property
-                        if (propertyValue.Culture == null //invariant property
-                            && !sameValues // and edited and published are different
-                            && entityVariesByCulture) //only when the entity is variant
-                        {
-                            if (defaultCulture == null)
-                                defaultCulture = languageRepository.GetDefaultIsoCode();
-
-                            editedCultures.Add(defaultCulture);
+                                editedCultures.Add(defaultCulture);
+                            }
                         }
                     }
                 }
@@ -167,7 +184,7 @@ namespace Umbraco.Core.Persistence.Factories
                     {
                         // not publishing = only deal with edit values
                         if (propertyValue.EditedValue != null)
-                            propertyDataDtos.Add(BuildDto(currentVersionId, property,  languageRepository.GetIdByIsoCode(propertyValue.Culture), propertyValue.Segment, propertyValue.EditedValue));
+                            propertyDataDtos.Add(BuildDto(currentVersionId, property, languageRepository.GetIdByIsoCode(propertyValue.Culture), propertyValue.Segment, propertyValue.EditedValue));
                     }
                     edited = true;
                 }

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

@@ -54,6 +54,7 @@ namespace Umbraco.Core.Persistence.Factories
 
                             propertyType.Alias = typeDto.Alias;
                             propertyType.DataTypeId = typeDto.DataTypeId;
+                            propertyType.DataTypeKey = typeDto.DataTypeDto.NodeDto.UniqueId;
                             propertyType.Description = typeDto.Description;
                             propertyType.Id = typeDto.Id;
                             propertyType.Key = typeDto.UniqueId;

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

@@ -512,31 +512,16 @@ namespace Umbraco.Core.Persistence.Repositories.Implement
             foreach (var a in allPropertyDataDtos)
                 a.PropertyTypeDto = indexedPropertyTypeDtos[a.PropertyTypeId];
 
-            // prefetch configuration for tag properties
-            var tagEditors = new Dictionary<string, TagConfiguration>();
-            foreach (var propertyTypeDto in indexedPropertyTypeDtos.Values)
-            {
-                var editorAlias = propertyTypeDto.DataTypeDto.EditorAlias;
-                var editorAttribute = PropertyEditors[editorAlias].GetTagAttribute();
-                if (editorAttribute == null) continue;
-                var tagConfigurationSource = propertyTypeDto.DataTypeDto.Configuration;
-                var tagConfiguration = string.IsNullOrWhiteSpace(tagConfigurationSource)
-                    ? new TagConfiguration()
-                    : JsonConvert.DeserializeObject<TagConfiguration>(tagConfigurationSource);
-                if (tagConfiguration.Delimiter == default) tagConfiguration.Delimiter = editorAttribute.Delimiter;
-                tagEditors[editorAlias] = tagConfiguration;
-            }
-
             // now we have
             // - the definitions
             // - all property data dtos
-            // - tag editors
+            // - tag editors (Actually ... no we don't since i removed that code, but we don't need them anyways it seems)
             // and we need to build the proper property collections
 
-            return GetPropertyCollections(temps, allPropertyDataDtos, tagEditors);
+            return GetPropertyCollections(temps, allPropertyDataDtos);
         }
 
-        private IDictionary<int, PropertyCollection> GetPropertyCollections<T>(List<TempContent<T>> temps, IEnumerable<PropertyDataDto> allPropertyDataDtos, Dictionary<string, TagConfiguration> tagConfigurations)
+        private IDictionary<int, PropertyCollection> GetPropertyCollections<T>(List<TempContent<T>> temps, IEnumerable<PropertyDataDto> allPropertyDataDtos)
             where T : class, IContentBase
         {
             var result = new Dictionary<int, PropertyCollection>();

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

@@ -3,10 +3,12 @@ using System.Collections.Generic;
 using System.Linq;
 using NPoco;
 using Umbraco.Core.Cache;
+using Umbraco.Core.Exceptions;
 using Umbraco.Core.Models;
 using Umbraco.Core.Persistence.Dtos;
 using Umbraco.Core.Persistence.Factories;
 using Umbraco.Core.Scoping;
+using static Umbraco.Core.Persistence.NPocoSqlExtensions.Statics;
 
 namespace Umbraco.Core.Persistence.Repositories.Implement
 {
@@ -89,7 +91,7 @@ namespace Umbraco.Core.Persistence.Repositories.Implement
                     contentType = ContentTypeFactory.BuildContentTypeEntity(contentTypeDto);
                 else if (contentTypeDto.NodeDto.NodeObjectType == Constants.ObjectTypes.MemberType)
                     contentType = ContentTypeFactory.BuildMemberTypeEntity(contentTypeDto);
-                else throw new Exception("panic");
+                else throw new PanicException($"The node object type {contentTypeDto.NodeDto.NodeObjectType} is not supported");
                 contentTypes.Add(contentType.Id, contentType);
 
                 // map allowed content types
@@ -188,10 +190,11 @@ namespace Umbraco.Core.Persistence.Repositories.Implement
             var groupDtos = Database.Fetch<PropertyTypeGroupDto>(sql1);
 
             var sql2 = Sql()
-                .Select<PropertyTypeDto>(r => r.Select(x => x.DataTypeDto))
+                .Select<PropertyTypeDto>(r => r.Select(x => x.DataTypeDto, r1 => r1.Select(x => x.NodeDto)))
                 .AndSelect<MemberPropertyTypeDto>()
                 .From<PropertyTypeDto>()
                 .InnerJoin<DataTypeDto>().On<PropertyTypeDto, DataTypeDto>((pt, dt) => pt.DataTypeId == dt.NodeId)
+                .InnerJoin<NodeDto>().On<DataTypeDto, NodeDto>((dt, n) => dt.NodeId == n.NodeId)
                 .InnerJoin<ContentTypeDto>().On<PropertyTypeDto, ContentTypeDto>((pt, ct) => pt.ContentTypeId == ct.NodeId)
                 .LeftJoin<PropertyTypeGroupDto>().On<PropertyTypeDto, PropertyTypeGroupDto>((pt, ptg) => pt.PropertyTypeGroupId == ptg.Id)
                 .LeftJoin<MemberPropertyTypeDto>().On<PropertyTypeDto, MemberPropertyTypeDto>((pt, mpt) => pt.Id == mpt.PropertyTypeId)
@@ -290,6 +293,7 @@ namespace Umbraco.Core.Persistence.Repositories.Implement
             {
                 Description = dto.Description,
                 DataTypeId = dto.DataTypeId,
+                DataTypeKey = dto.DataTypeDto.NodeDto.UniqueId,
                 Id = dto.Id,
                 Key = dto.UniqueId,
                 Mandatory = dto.Mandatory,

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

@@ -3,6 +3,7 @@ using System.Collections.Generic;
 using System.Linq;
 using NPoco;
 using Umbraco.Core.Cache;
+using Umbraco.Core.Exceptions;
 using Umbraco.Core.Logging;
 using Umbraco.Core.Models;
 using Umbraco.Core.Models.Entities;
@@ -18,8 +19,8 @@ namespace Umbraco.Core.Persistence.Repositories.Implement
     /// </summary>
     internal class ContentTypeRepository : ContentTypeRepositoryBase<IContentType>, IContentTypeRepository
     {
-        public ContentTypeRepository(IScopeAccessor scopeAccessor, AppCaches cache, ILogger logger, IContentTypeCommonRepository commonRepository)
-            : base(scopeAccessor, cache, logger, commonRepository)
+        public ContentTypeRepository(IScopeAccessor scopeAccessor, AppCaches cache, ILogger logger, IContentTypeCommonRepository commonRepository, ILanguageRepository languageRepository)
+            : base(scopeAccessor, cache, logger, commonRepository, languageRepository)
         { }
 
         protected override bool SupportsPublishing => ContentType.SupportsPublishingConst;
@@ -56,7 +57,7 @@ namespace Umbraco.Core.Persistence.Repositories.Implement
         {
             // the cache policy will always want everything
             // even GetMany(ids) gets everything and filters afterwards
-            if (ids.Any()) throw new Exception("panic");
+            if (ids.Any()) throw new PanicException("There can be no ids specified");
             return CommonRepository.GetAllTypes().OfType<IContentType>();
         }
 

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

@@ -15,6 +15,7 @@ using Umbraco.Core.Persistence.Factories;
 using Umbraco.Core.Persistence.Querying;
 using Umbraco.Core.Scoping;
 using Umbraco.Core.Services;
+using static Umbraco.Core.Persistence.NPocoSqlExtensions.Statics;
 
 namespace Umbraco.Core.Persistence.Repositories.Implement
 {
@@ -26,14 +27,15 @@ namespace Umbraco.Core.Persistence.Repositories.Implement
     internal abstract class ContentTypeRepositoryBase<TEntity> : NPocoRepositoryBase<int, TEntity>, IReadRepository<Guid, TEntity>
         where TEntity : class, IContentTypeComposition
     {
-        protected ContentTypeRepositoryBase(IScopeAccessor scopeAccessor, AppCaches cache, ILogger logger, IContentTypeCommonRepository commonRepository)
+        protected ContentTypeRepositoryBase(IScopeAccessor scopeAccessor, AppCaches cache, ILogger logger, IContentTypeCommonRepository commonRepository, ILanguageRepository languageRepository)
             : base(scopeAccessor, cache, logger)
         {
             CommonRepository = commonRepository;
+            LanguageRepository = languageRepository;
         }
 
         protected IContentTypeCommonRepository CommonRepository { get; }
-
+        protected ILanguageRepository LanguageRepository { get; }
         protected abstract bool SupportsPublishing { get; }
 
         public IEnumerable<MoveEventInfo<TEntity>> Move(TEntity moving, EntityContainer container)
@@ -98,6 +100,8 @@ namespace Umbraco.Core.Persistence.Repositories.Implement
 
         protected void PersistNewBaseContentType(IContentTypeComposition entity)
         {
+            ValidateVariations(entity);
+
             var dto = ContentTypeFactory.BuildContentTypeDto(entity);
 
             //Cannot add a duplicate content type
@@ -163,11 +167,11 @@ AND umbracoNode.nodeObjectType = @objectType",
             foreach (var allowedContentType in entity.AllowedContentTypes)
             {
                 Database.Insert(new ContentTypeAllowedContentTypeDto
-                                    {
-                                        Id = entity.Id,
-                                        AllowedId = allowedContentType.Id.Value,
-                                        SortOrder = allowedContentType.SortOrder
-                                    });
+                {
+                    Id = entity.Id,
+                    AllowedId = allowedContentType.Id.Value,
+                    SortOrder = allowedContentType.SortOrder
+                });
             }
 
 
@@ -214,6 +218,8 @@ AND umbracoNode.nodeObjectType = @objectType",
 
         protected void PersistUpdatedBaseContentType(IContentTypeComposition entity)
         {
+            ValidateVariations(entity);
+
             var dto = ContentTypeFactory.BuildContentTypeDto(entity);
 
             // ensure the alias is not used already
@@ -370,7 +376,7 @@ AND umbracoNode.id <> @id",
             foreach (var propertyGroup in entity.PropertyGroups)
             {
                 // insert or update group
-                var groupDto = PropertyGroupFactory.BuildGroupDto(propertyGroup,entity.Id);
+                var groupDto = PropertyGroupFactory.BuildGroupDto(propertyGroup, entity.Id);
                 var groupId = propertyGroup.HasIdentity
                     ? Database.Update(groupDto)
                     : Convert.ToInt32(Database.Insert(groupDto));
@@ -388,7 +394,7 @@ AND umbracoNode.id <> @id",
 
             //check if the content type variation has been changed
             var contentTypeVariationDirty = entity.IsPropertyDirty("Variations");
-            var oldContentTypeVariation = (ContentVariation) dtoPk.Variations;
+            var oldContentTypeVariation = (ContentVariation)dtoPk.Variations;
             var newContentTypeVariation = entity.Variations;
             var contentTypeVariationChanging = contentTypeVariationDirty && oldContentTypeVariation != newContentTypeVariation;
             if (contentTypeVariationChanging)
@@ -449,7 +455,7 @@ AND umbracoNode.id <> @id",
                 // via composition, with their original variations (ie not filtered by this
                 // content type variations - we need this true value to make decisions.
 
-                foreach (var propertyType in ((ContentTypeCompositionBase) entity).RawComposedPropertyTypes)
+                foreach (var propertyType in ((ContentTypeCompositionBase)entity).RawComposedPropertyTypes)
                 {
                     if (propertyType.VariesBySegment() || newContentTypeVariation.VariesBySegment())
                         throw new NotSupportedException(); // TODO: support this
@@ -518,6 +524,25 @@ AND umbracoNode.id <> @id",
             CommonRepository.ClearCache(); // always
         }
 
+        /// <summary>
+        /// Ensures that no property types are flagged for a variance that is not supported by the content type itself
+        /// </summary>
+        /// <param name="entity"></param>
+        private void ValidateVariations(IContentTypeComposition entity)
+        {
+            //if the entity does not vary at all, then the property cannot have a variance value greater than it
+            if (entity.Variations == ContentVariation.Nothing)
+            {
+                foreach (var prop in entity.PropertyTypes)
+                {
+                    if (prop.IsPropertyDirty(nameof(prop.Variations)) && prop.Variations > entity.Variations)
+                        throw new InvalidOperationException($"The property {prop.Alias} cannot have variations of {prop.Variations} with the content type variations of {entity.Variations}");
+                }
+                    
+            }
+                
+        }
+
         private IEnumerable<IContentTypeComposition> GetImpactedContentTypes(IContentTypeComposition contentType, IEnumerable<IContentTypeComposition> all)
         {
             var impact = new List<IContentTypeComposition>();
@@ -525,12 +550,12 @@ AND umbracoNode.id <> @id",
 
             var tree = new Dictionary<int, List<IContentTypeComposition>>();
             foreach (var x in all)
-            foreach (var y in x.ContentTypeComposition)
-            {
-                if (!tree.TryGetValue(y.Id, out var list))
-                    list = tree[y.Id] = new List<IContentTypeComposition>();
-                list.Add(x);
-            }
+                foreach (var y in x.ContentTypeComposition)
+                {
+                    if (!tree.TryGetValue(y.Id, out var list))
+                        list = tree[y.Id] = new List<IContentTypeComposition>();
+                    list.Add(x);
+                }
 
             var nset = new List<IContentTypeComposition>();
             do
@@ -572,7 +597,7 @@ AND umbracoNode.id <> @id",
                 // new property type, ignore
                 if (!oldVariations.TryGetValue(propertyType.Id, out var oldVariationB))
                     continue;
-                var oldVariation = (ContentVariation) oldVariationB; // NPoco cannot fetch directly
+                var oldVariation = (ContentVariation)oldVariationB; // NPoco cannot fetch directly
 
                 // only those property types that *actually* changed
                 var newVariation = propertyType.Variations;
@@ -636,7 +661,7 @@ AND umbracoNode.id <> @id",
             var impactedL = impacted.Select(x => x.Id).ToList();
 
             //Group by the "To" variation so we can bulk update in the correct batches
-            foreach(var grouping in propertyTypeChanges.GroupBy(x => x.Value.ToVariation))
+            foreach (var grouping in propertyTypeChanges.GroupBy(x => x.Value.ToVariation))
             {
                 var propertyTypeIds = grouping.Select(x => x.Key).ToList();
                 var toVariation = grouping.Key;
@@ -646,10 +671,12 @@ AND umbracoNode.id <> @id",
                     case ContentVariation.Culture:
                         CopyPropertyData(null, defaultLanguageId, propertyTypeIds, impactedL);
                         CopyTagData(null, defaultLanguageId, propertyTypeIds, impactedL);
+                        RenormalizeDocumentEditedFlags(propertyTypeIds, impactedL);                        
                         break;
                     case ContentVariation.Nothing:
                         CopyPropertyData(defaultLanguageId, null, propertyTypeIds, impactedL);
                         CopyTagData(defaultLanguageId, null, propertyTypeIds, impactedL);
+                        RenormalizeDocumentEditedFlags(propertyTypeIds, impactedL);                        
                         break;
                     case ContentVariation.CultureAndSegment:
                     case ContentVariation.Segment:
@@ -963,6 +990,205 @@ AND umbracoNode.id <> @id",
 
                 Database.Execute(sqlDelete);
             }
+
+        }
+
+        /// <summary>
+        /// Re-normalizes the edited value in the umbracoDocumentCultureVariation and umbracoDocument table when variations are changed
+        /// </summary>
+        /// <param name="propertyTypeIds"></param>
+        /// <param name="contentTypeIds"></param>
+        /// <remarks>
+        /// If this is not done, then in some cases the "edited" value for a particular culture for a document will remain true when it should be false
+        /// if the property was changed to invariant. In order to do this we need to recalculate this value based on the values stored for each
+        /// property, culture and current/published version.
+        /// </remarks>
+        private void RenormalizeDocumentEditedFlags(IReadOnlyCollection<int> propertyTypeIds, IReadOnlyCollection<int> contentTypeIds = null)
+        {
+            var defaultLang = LanguageRepository.GetDefaultId();
+
+            //This will build up a query to get the property values of both the current and the published version so that we can check
+            //based on the current variance of each item to see if it's 'edited' value should be true/false.
+
+            var whereInArgsCount = propertyTypeIds.Count + (contentTypeIds?.Count ?? 0);
+            if (whereInArgsCount > 2000)
+                throw new NotSupportedException("Too many property/content types.");
+
+            var propertySql = Sql()
+                .Select<PropertyDataDto>()
+                .AndSelect<ContentVersionDto>(x => x.NodeId, x => x.Current)
+                .AndSelect<DocumentVersionDto>(x => x.Published)
+                .AndSelect<PropertyTypeDto>(x => x.Variations)
+                .From<PropertyDataDto>()
+                .InnerJoin<ContentVersionDto>().On<ContentVersionDto, PropertyDataDto>((left, right) => left.Id == right.VersionId)
+                .InnerJoin<PropertyTypeDto>().On<PropertyTypeDto, PropertyDataDto>((left, right) => left.Id == right.PropertyTypeId);
+
+            if (contentTypeIds != null)
+            {
+                propertySql.InnerJoin<ContentDto>().On<ContentDto, ContentVersionDto>((c, cversion) => c.NodeId == cversion.NodeId);
+            }
+
+            propertySql.LeftJoin<DocumentVersionDto>().On<DocumentVersionDto, ContentVersionDto>((docversion, cversion) => cversion.Id == docversion.Id)
+                .Where<DocumentVersionDto, ContentVersionDto>((docversion, cversion) => cversion.Current || docversion.Published)
+                .WhereIn<PropertyDataDto>(x => x.PropertyTypeId, propertyTypeIds);
+
+            if (contentTypeIds != null)
+            {
+                propertySql.WhereIn<ContentDto>(x => x.ContentTypeId, contentTypeIds);
+            }
+
+            propertySql
+                .OrderBy<ContentVersionDto>(x => x.NodeId)
+                .OrderBy<PropertyDataDto>(x => x.PropertyTypeId, x => x.LanguageId, x => x.VersionId);
+
+            //keep track of this node/lang to mark or unmark a culture as edited
+            var editedLanguageVersions = new Dictionary<(int nodeId, int? langId), bool>();
+            //keep track of which node to mark or unmark as edited 
+            var editedDocument = new Dictionary<int, bool>();
+            var nodeId = -1;
+            var propertyTypeId = -1;
+
+            PropertyValueVersionDto pubRow = null;
+
+            //This is a reader (Query), we are not fetching this all into memory so we cannot make any changes during this iteration, we are just collecting data.
+            //Published data will always come before Current data based on the version id sort.
+            //There will only be one published row (max) and one current row per property.
+            foreach (var row in Database.Query<PropertyValueVersionDto>(propertySql))
+            {
+                //make sure to reset on each node/property change
+                if (nodeId != row.NodeId || propertyTypeId != row.PropertyTypeId)
+                {
+                    nodeId = row.NodeId;
+                    propertyTypeId = row.PropertyTypeId;
+                    pubRow = null;
+                }
+
+                if (row.Published)
+                    pubRow = row;
+
+                if (row.Current)
+                {
+                    var propVariations = (ContentVariation)row.Variations;
+
+                    //if this prop doesn't vary but the row has a lang assigned or vice versa, flag this as not edited
+                    if (!propVariations.VariesByCulture() && row.LanguageId.HasValue
+                        || propVariations.VariesByCulture() && !row.LanguageId.HasValue)
+                    {
+                        //Flag this as not edited for this node/lang if the key doesn't exist
+                        if (!editedLanguageVersions.TryGetValue((row.NodeId, row.LanguageId), out _))
+                            editedLanguageVersions.Add((row.NodeId, row.LanguageId), false);
+
+                        //mark as false if the item doesn't exist, else coerce to true
+                        editedDocument[row.NodeId] = editedDocument.TryGetValue(row.NodeId, out var edited) ? (edited |= false) : false;
+                    }
+                    else if (pubRow == null)
+                    {
+                        //this would mean that that this property is 'edited' since there is no published version
+                        editedLanguageVersions[(row.NodeId, row.LanguageId)] = true;
+                        editedDocument[row.NodeId] = true;
+                    }
+                    //compare the property values, if they differ from versions then flag the current version as edited
+                    else if (IsPropertyValueChanged(pubRow, row))
+                    {
+                        //Here we would check if the property is invariant, in which case the edited language should be indicated by the default lang
+                        editedLanguageVersions[(row.NodeId, !propVariations.VariesByCulture() ? defaultLang : row.LanguageId)] = true;
+                        editedDocument[row.NodeId] = true;
+                    }
+
+                    //reset
+                    pubRow = null;
+                }
+            }
+
+            //lookup all matching rows in umbracoDocumentCultureVariation
+            var docCultureVariationsToUpdate = editedLanguageVersions.InGroupsOf(2000)
+                .SelectMany(_ => Database.Fetch<DocumentCultureVariationDto>(
+                    Sql().Select<DocumentCultureVariationDto>().From<DocumentCultureVariationDto>()
+                            .WhereIn<DocumentCultureVariationDto>(x => x.LanguageId, editedLanguageVersions.Keys.Select(x => x.langId).ToList())
+                            .WhereIn<DocumentCultureVariationDto>(x => x.NodeId, editedLanguageVersions.Keys.Select(x => x.nodeId))))
+                //convert to dictionary with the same key type
+                .ToDictionary(x => (x.NodeId, (int?)x.LanguageId), x => x);
+
+            var toUpdate = new List<DocumentCultureVariationDto>();
+            foreach (var ev in editedLanguageVersions)
+            {
+                if (docCultureVariationsToUpdate.TryGetValue(ev.Key, out var docVariations))
+                {
+                    //check if it needs updating
+                    if (docVariations.Edited != ev.Value)
+                    {
+                        docVariations.Edited = ev.Value;
+                        toUpdate.Add(docVariations);
+                    }
+                }
+                else if (ev.Key.langId.HasValue)
+                {
+                    //This should never happen! If a property culture is flagged as edited then the culture must exist at the document level
+                    throw new PanicException($"The existing DocumentCultureVariationDto was not found for node {ev.Key.nodeId} and language {ev.Key.langId}");
+                }
+            }
+
+            //Now bulk update the table DocumentCultureVariationDto, once for edited = true, another for edited = false
+            foreach (var editValue in toUpdate.GroupBy(x => x.Edited))
+            {
+                Database.Execute(Sql().Update<DocumentCultureVariationDto>(u => u.Set(x => x.Edited, editValue.Key))
+                    .WhereIn<DocumentCultureVariationDto>(x => x.Id, editValue.Select(x => x.Id)));
+            }
+
+            //Now bulk update the umbracoDocument table
+            foreach (var editValue in editedDocument.GroupBy(x => x.Value))
+            {
+                Database.Execute(Sql().Update<DocumentDto>(u => u.Set(x => x.Edited, editValue.Key))
+                    .WhereIn<DocumentDto>(x => x.NodeId, editValue.Select(x => x.Key)));
+            }
+        }
+
+        private static bool IsPropertyValueChanged(PropertyValueVersionDto pubRow, PropertyValueVersionDto row)
+        {
+            return !pubRow.TextValue.IsNullOrWhiteSpace() && pubRow.TextValue != row.TextValue
+                                    || !pubRow.VarcharValue.IsNullOrWhiteSpace() && pubRow.VarcharValue != row.VarcharValue
+                                    || pubRow.DateValue.HasValue && pubRow.DateValue != row.DateValue
+                                    || pubRow.DecimalValue.HasValue && pubRow.DecimalValue != row.DecimalValue
+                                    || pubRow.IntValue.HasValue && pubRow.IntValue != row.IntValue;
+        }
+
+        private class NameCompareDto
+        {
+            public int NodeId { get; set; }
+            public int CurrentVersion { get; set; }
+            public int LanguageId { get; set; }
+            public string CurrentName { get; set; }
+            public string PublishedName { get; set; }
+            public int? PublishedVersion { get; set; }
+            public int Id { get; set; } // the Id of the DocumentCultureVariationDto
+            public bool Edited { get; set; }
+        }
+
+        private class PropertyValueVersionDto
+        {
+            public int VersionId { get; set; }
+            public int PropertyTypeId { get; set; }
+            public int? LanguageId { get; set; }
+            public string Segment { get; set; }
+            public int? IntValue { get; set; }
+
+            private decimal? _decimalValue;
+            [Column("decimalValue")]
+            public decimal? DecimalValue
+            {
+                get => _decimalValue;
+                set => _decimalValue = value?.Normalize();
+            }
+
+            public DateTime? DateValue { get; set; }
+            public string VarcharValue { get; set; }
+            public string TextValue { get; set; }
+
+            public int NodeId { get; set; }
+            public bool Current { get; set; }
+            public bool Published { get; set; }
+
+            public byte Variations { get; set; }
         }
 
         private void DeletePropertyType(int contentTypeId, int propertyTypeId)
@@ -1013,8 +1239,9 @@ AND umbracoNode.id <> @id",
             if (propertyType.PropertyEditorAlias.IsNullOrWhiteSpace() == false)
             {
                 var sql = Sql()
-                    .SelectAll()
+                    .Select<DataTypeDto>(dt => dt.Select(x => x.NodeDto))
                     .From<DataTypeDto>()
+                    .InnerJoin<NodeDto>().On<DataTypeDto, NodeDto>((dt, n) => dt.NodeId == n.NodeId)
                     .Where("propertyEditorAlias = @propertyEditorAlias", new { propertyEditorAlias = propertyType.PropertyEditorAlias })
                     .OrderBy<DataTypeDto>(typeDto => typeDto.NodeId);
                 var datatype = Database.FirstOrDefault<DataTypeDto>(sql);
@@ -1022,6 +1249,7 @@ AND umbracoNode.id <> @id",
                 if (datatype != null)
                 {
                     propertyType.DataTypeId = datatype.NodeId;
+                    propertyType.DataTypeKey = datatype.NodeDto.UniqueId;
                 }
                 else
                 {

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

@@ -386,7 +386,7 @@ namespace Umbraco.Core.Persistence.Repositories.Implement
                 Database.BulkInsertRecords(GetContentVariationDtos(entity, publishing));
 
                 // insert document variations
-                Database.BulkInsertRecords(GetDocumentVariationDtos(entity, publishing, editedCultures));
+                Database.BulkInsertRecords(GetDocumentVariationDtos(entity, editedCultures));
             }
 
             // refresh content
@@ -511,7 +511,7 @@ namespace Umbraco.Core.Persistence.Repositories.Implement
                 entity.VersionId = documentVersionDto.Id = contentVersionDto.Id; // get the new id
 
                 documentVersionDto.Published = false; // non-published version
-                Database.Insert(documentVersionDto);
+                Database.Insert(documentVersionDto); 
             }
 
             // replace the property data (rather than updating)
@@ -571,7 +571,7 @@ namespace Umbraco.Core.Persistence.Repositories.Implement
                 Database.BulkInsertRecords(GetContentVariationDtos(entity, publishing));
 
                 // insert document variations
-                Database.BulkInsertRecords(GetDocumentVariationDtos(entity, publishing, editedCultures));
+                Database.BulkInsertRecords(GetDocumentVariationDtos(entity, editedCultures));
             }
 
             // refresh content
@@ -1297,25 +1297,28 @@ namespace Umbraco.Core.Persistence.Repositories.Implement
                 };
         }
 
-        private IEnumerable<DocumentCultureVariationDto> GetDocumentVariationDtos(IContent content, bool publishing, HashSet<string> editedCultures)
+        private IEnumerable<DocumentCultureVariationDto> GetDocumentVariationDtos(IContent content, HashSet<string> editedCultures)
         {
             var allCultures = content.AvailableCultures.Union(content.PublishedCultures); // union = distinct
             foreach (var culture in allCultures)
-                yield return new DocumentCultureVariationDto
+            {
+                var dto = new DocumentCultureVariationDto
                 {
                     NodeId = content.Id,
                     LanguageId = LanguageRepository.GetIdByIsoCode(culture) ?? throw new InvalidOperationException("Not a valid culture."),
                     Culture = culture,
 
                     Name = content.GetCultureName(culture) ?? content.GetPublishName(culture),
-
-                    // note: can't use IsCultureEdited at that point - hasn't been updated yet - see PersistUpdatedItem
-
                     Available = content.IsCultureAvailable(culture),
                     Published = content.IsCulturePublished(culture),
+                    // note: can't use IsCultureEdited at that point - hasn't been updated yet - see PersistUpdatedItem
                     Edited = content.IsCultureAvailable(culture) &&
                              (!content.IsCulturePublished(culture) || (editedCultures != null && editedCultures.Contains(culture)))
                 };
+
+                yield return dto;
+            }
+                
         }
 
         private class ContentVariation

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

@@ -3,6 +3,7 @@ using System.Collections.Generic;
 using System.Linq;
 using NPoco;
 using Umbraco.Core.Cache;
+using Umbraco.Core.Exceptions;
 using Umbraco.Core.Logging;
 using Umbraco.Core.Models;
 using Umbraco.Core.Models.Entities;
@@ -17,8 +18,8 @@ namespace Umbraco.Core.Persistence.Repositories.Implement
     /// </summary>
     internal class MediaTypeRepository : ContentTypeRepositoryBase<IMediaType>, IMediaTypeRepository
     {
-        public MediaTypeRepository(IScopeAccessor scopeAccessor, AppCaches cache, ILogger logger, IContentTypeCommonRepository commonRepository)
-            : base(scopeAccessor, cache, logger, commonRepository)
+        public MediaTypeRepository(IScopeAccessor scopeAccessor, AppCaches cache, ILogger logger, IContentTypeCommonRepository commonRepository, ILanguageRepository languageRepository)
+            : base(scopeAccessor, cache, logger, commonRepository, languageRepository)
         { }
 
         protected override bool SupportsPublishing => MediaType.SupportsPublishingConst;
@@ -50,7 +51,7 @@ namespace Umbraco.Core.Persistence.Repositories.Implement
         {
             // the cache policy will always want everything
             // even GetMany(ids) gets everything and filters afterwards
-            if (ids.Any()) throw new Exception("panic");
+            if (ids.Any()) throw new PanicException("There can be no ids specified");
             return CommonRepository.GetAllTypes().OfType<IMediaType>();
         }
 

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

@@ -3,6 +3,7 @@ using System.Collections.Generic;
 using System.Linq;
 using NPoco;
 using Umbraco.Core.Cache;
+using Umbraco.Core.Exceptions;
 using Umbraco.Core.Logging;
 using Umbraco.Core.Models;
 using Umbraco.Core.Models.Entities;
@@ -18,8 +19,8 @@ namespace Umbraco.Core.Persistence.Repositories.Implement
     /// </summary>
     internal class MemberTypeRepository : ContentTypeRepositoryBase<IMemberType>, IMemberTypeRepository
     {
-        public MemberTypeRepository(IScopeAccessor scopeAccessor, AppCaches cache, ILogger logger, IContentTypeCommonRepository commonRepository)
-            : base(scopeAccessor, cache, logger, commonRepository)
+        public MemberTypeRepository(IScopeAccessor scopeAccessor, AppCaches cache, ILogger logger, IContentTypeCommonRepository commonRepository, ILanguageRepository languageRepository)
+            : base(scopeAccessor, cache, logger, commonRepository, languageRepository)
         { }
 
         protected override bool SupportsPublishing => MemberType.SupportsPublishingConst;
@@ -57,7 +58,7 @@ namespace Umbraco.Core.Persistence.Repositories.Implement
         {
             // the cache policy will always want everything
             // even GetMany(ids) gets everything and filters afterwards
-            if (ids.Any()) throw new Exception("panic");
+            if (ids.Any()) throw new PanicException("There can be no ids specified");
             return CommonRepository.GetAllTypes().OfType<IMemberType>();
         }
 
@@ -225,6 +226,7 @@ namespace Umbraco.Core.Persistence.Repositories.Implement
                 {
                     //this reset's its current data type reference which will be re-assigned based on the property editor assigned on the next line
                     propertyType.DataTypeId = 0;
+                    propertyType.DataTypeKey = default;
                 }
             }
         }

src/Umbraco.Core/PropertyEditors/TagsPropertyEditorAttribute.cs

@@ -55,6 +55,7 @@ namespace Umbraco.Core.PropertyEditors
         /// <summary>
         /// Gets the type of the dynamic configuration provider.
         /// </summary>
+        //TODO: This is not used and should be implemented in a nicer way, see https://github.com/umbraco/Umbraco-CMS/issues/6017#issuecomment-516253562
         public Type TagsConfigurationProviderType { get; }
     }
 }

src/Umbraco.Core/PublishedContentExtensions.cs

@@ -103,18 +103,26 @@ namespace Umbraco.Core
         /// Gets the children of the content item.
         /// </summary>
         /// <param name="content">The content item.</param>
-        /// <param name="culture">The specific culture to get the url children for. If null is used the current culture is used (Default is null).</param>
+        /// <param name="culture">
+        /// The specific culture to get the url children for. Default is null which will use the current culture in <see cref="VariationContext"/>        
+        /// </param>
         /// <remarks>
         /// <para>Gets children that are available for the specified culture.</para>
         /// <para>Children are sorted by their sortOrder.</para>
-        /// <para>The '*' culture and supported and returns everything.</para>
+        /// <para>
+        /// For culture, 
+        /// if null is used the current culture is used.
+        /// If an empty string is used only invariant children are returned.
+        /// If "*" is used all children are returned.
+        /// </para>
+        /// <para>
+        /// If a variant culture is specified or there is a current culture in the <see cref="VariationContext"/> then the Children returned
+        /// will include both the variant children matching the culture AND the invariant children because the invariant children flow with the current culture.
+        /// However, if an empty string is specified only invariant children are returned.
+        /// </para>
         /// </remarks>
         public static IEnumerable<IPublishedContent> Children(this IPublishedContent content, string culture = null)
         {
-            // invariant has invariant value (whatever the requested culture)
-            if (!content.ContentType.VariesByCulture() && culture != "*")
-                culture = "";
-
             // handle context culture for variant
             if (culture == null)
                 culture = VariationContextAccessor?.VariationContext?.Culture ?? "";

src/Umbraco.Core/PublishedModelFactoryExtensions.cs

@@ -9,7 +9,14 @@ namespace Umbraco.Core
     public static class PublishedModelFactoryExtensions
     {
         /// <summary>
-        /// Executes an action with a safe live factory/
+        /// Returns true if the current <see cref="IPublishedModelFactory"/> is an implementation of <see cref="ILivePublishedModelFactory"/>
+        /// </summary>
+        /// <param name="factory"></param>
+        /// <returns></returns>
+        public static bool IsLiveFactory(this IPublishedModelFactory factory) => factory is ILivePublishedModelFactory;
+
+        /// <summary>
+        /// Executes an action with a safe live factory
         /// </summary>
         /// <remarks>
         /// <para>If the factory is a live factory, ensures it is refreshed and locked while executing the action.</para>
@@ -20,6 +27,7 @@ namespace Umbraco.Core
             {
                 lock (liveFactory.SyncRoot)
                 {
+                    //Call refresh on the live factory to re-compile the models
                     liveFactory.Refresh();
                     action();
                 }

src/Umbraco.Core/Runtime/CoreRuntime.cs

@@ -139,7 +139,7 @@ namespace Umbraco.Core.Runtime
                 // there should be none, really - this is here "just in case"
                 Compose(composition);
 
-                // acquire the main domain
+                // acquire the main domain - if this fails then anything that should be registered with MainDom will not operate
                 AcquireMainDom(mainDom);
 
                 // determine our runtime level
@@ -218,13 +218,13 @@ namespace Umbraco.Core.Runtime
                 IOHelper.SetRootDirectory(path);
         }
 
-        private void AcquireMainDom(MainDom mainDom)
+        private bool AcquireMainDom(MainDom mainDom)
         {
             using (var timer = ProfilingLogger.DebugDuration<CoreRuntime>("Acquiring MainDom.", "Acquired."))
             {
                 try
                 {
-                    mainDom.Acquire();
+                    return mainDom.Acquire();
                 }
                 catch
                 {

src/Umbraco.Core/RuntimeState.cs

@@ -97,6 +97,11 @@ namespace Umbraco.Core
         /// <param name="request"></param>
         internal void EnsureApplicationUrl(HttpRequestBase request = null)
         {
+            //Fixme: This causes problems with site swap on azure because azure pre-warms a site by calling into `localhost` and when it does that
+            // it changes the URL to `localhost:80` which actually doesn't work for pinging itself, it only works internally in Azure. The ironic part
+            // about this is that this is here specifically for the slot swap scenario https://issues.umbraco.org/issue/U4-10626
+
+
             // see U4-10626 - in some cases we want to reset the application url
             // (this is a simplified version of what was in 7.x)
             // note: should this be optional? is it expensive?

src/Umbraco.Core/Services/Changes/ContentTypeChangeTypes.cs

@@ -6,9 +6,25 @@ namespace Umbraco.Core.Services.Changes
     public enum ContentTypeChangeTypes : byte
     {
         None = 0,
-        Create = 1, // item type has been created, no impact
-        RefreshMain = 2, // changed, impacts content (adding property or composition does NOT)
-        RefreshOther = 4, // changed, other changes
-        Remove = 8 // item type has been removed
+
+        /// <summary>
+        /// Item type has been created, no impact
+        /// </summary>
+        Create = 1,
+
+        /// <summary>
+        /// Content type changes impact only the Content type being saved
+        /// </summary>
+        RefreshMain = 2,
+
+        /// <summary>
+        /// Content type changes impacts the content type being saved and others used that are composed of it
+        /// </summary>
+        RefreshOther = 4, // changed, other change
+
+        /// <summary>
+        /// Content type was removed
+        /// </summary>
+        Remove = 8 
     }
 }

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

@@ -886,6 +886,8 @@ namespace Umbraco.Core.Services.Implement
             {
                 scope.WriteLock(Constants.Locks.ContentTree);
 
+                var allLangs = _languageRepository.GetMany().ToList();
+
                 var saveEventArgs = new ContentSavingEventArgs(content, evtMsgs);
                 if (raiseEvents && scope.Events.DispatchCancelable(Saving, this, saveEventArgs, nameof(Saving)))
                     return new PublishResult(PublishResultType.FailedPublishCancelledByEvent, evtMsgs, content);
@@ -894,13 +896,13 @@ namespace Umbraco.Core.Services.Implement
                 // if culture is '*', then publish them all (including variants)
 
                 //this will create the correct culture impact even if culture is * or null
-                var impact = CultureImpact.Create(culture, _languageRepository.IsDefault(culture), content);
+                var impact = CultureImpact.Create(culture, IsDefaultCulture(allLangs, culture), content);
 
                 // publish the culture(s)
                 // we don't care about the response here, this response will be rechecked below but we need to set the culture info values now.
                 content.PublishCulture(impact);
 
-                var result = CommitDocumentChangesInternal(scope, content, saveEventArgs, userId, raiseEvents);
+                var result = CommitDocumentChangesInternal(scope, content, saveEventArgs, allLangs, userId, raiseEvents);
                 scope.Complete();
                 return result;
             }
@@ -921,6 +923,8 @@ namespace Umbraco.Core.Services.Implement
             {
                 scope.WriteLock(Constants.Locks.ContentTree);
 
+                var allLangs = _languageRepository.GetMany().ToList();
+
                 var evtMsgs = EventMessagesFactory.Get();
                 var saveEventArgs = new ContentSavingEventArgs(content, evtMsgs);
                 if (raiseEvents && scope.Events.DispatchCancelable(Saving, this, saveEventArgs, nameof(Saving)))
@@ -928,25 +932,23 @@ namespace Umbraco.Core.Services.Implement
 
                 var varies = content.ContentType.VariesByCulture();
 
-                if (cultures.Length == 0)
+                if (cultures.Length == 0 && !varies)
                 {
                     //no cultures specified and doesn't vary, so publish it, else nothing to publish
-                    return !varies
-                        ? SaveAndPublish(content, userId: userId, raiseEvents: raiseEvents)
-                        : new PublishResult(PublishResultType.FailedPublishNothingToPublish, evtMsgs, content);
+                    return SaveAndPublish(content, userId: userId, raiseEvents: raiseEvents);
                 }
 
                 if (cultures.Any(x => x == null || x == "*"))
                     throw new InvalidOperationException("Only valid cultures are allowed to be used in this method, wildcards or nulls are not allowed");
 
-                var impacts = cultures.Select(x => CultureImpact.Explicit(x, _languageRepository.IsDefault(x)));
+                var impacts = cultures.Select(x => CultureImpact.Explicit(x, IsDefaultCulture(allLangs, x)));
 
                 // publish the culture(s)
                 // we don't care about the response here, this response will be rechecked below but we need to set the culture info values now.
                 foreach (var impact in impacts)
                     content.PublishCulture(impact);
 
-                var result = CommitDocumentChangesInternal(scope, content, saveEventArgs, userId, raiseEvents);
+                var result = CommitDocumentChangesInternal(scope, content, saveEventArgs, allLangs, userId, raiseEvents);
                 scope.Complete();
                 return result;
             }
@@ -986,6 +988,8 @@ namespace Umbraco.Core.Services.Implement
             {
                 scope.WriteLock(Constants.Locks.ContentTree);
 
+                var allLangs = _languageRepository.GetMany().ToList();
+
                 var saveEventArgs = new ContentSavingEventArgs(content, evtMsgs);
                 if (scope.Events.DispatchCancelable(Saving, this, saveEventArgs, nameof(Saving)))
                     return new PublishResult(PublishResultType.FailedPublishCancelledByEvent, evtMsgs, content);
@@ -993,26 +997,39 @@ namespace Umbraco.Core.Services.Implement
                 // all cultures = unpublish whole
                 if (culture == "*" || (!content.ContentType.VariesByCulture() && culture == null))
                 {
+                    // It's important to understand that when the document varies by culture but the "*" is used,
+                    // we are just unpublishing the whole document but leaving all of the culture's as-is. This is expected
+                    // because we don't want to actually unpublish every culture and then the document, we just want everything
+                    // to be non-routable so that when it's re-published all variants were as they were.
+
                     content.PublishedState = PublishedState.Unpublishing;
+                    var result = CommitDocumentChangesInternal(scope, content, saveEventArgs, allLangs, userId);
+                    scope.Complete();
+                    return result;
                 }
                 else
                 {
-                    // If the culture we want to unpublish was already unpublished, nothing to do.
-                    // To check for that we need to lookup the persisted content item
-                    var persisted = content.HasIdentity ? GetById(content.Id) : null;
+                    // Unpublish the culture, this will change the document state to Publishing! ... which is expected because this will
+                    // essentially be re-publishing the document with the requested culture removed.
+                    // The call to CommitDocumentChangesInternal will perform all the checks like if this is a mandatory culture or the last culture being unpublished
+                    // and will then unpublish the document accordingly.
+                    // If the result of this is false it means there was no culture to unpublish (i.e. it was already unpublished or it did not exist)
+                    var removed = content.UnpublishCulture(culture);
 
-                    if (persisted != null && !persisted.IsCulturePublished(culture))
+                    //save and publish any changes
+                    var result = CommitDocumentChangesInternal(scope, content, saveEventArgs, allLangs, userId);
+
+                    scope.Complete();
+
+                    // In one case the result will be PublishStatusType.FailedPublishNothingToPublish which means that no cultures
+                    // were specified to be published which will be the case when removed is false. In that case
+                    // we want to swap the result type to PublishResultType.SuccessUnpublishAlready (that was the expectation before).
+                    if (result.Result == PublishResultType.FailedPublishNothingToPublish && !removed)
                         return new PublishResult(PublishResultType.SuccessUnpublishAlready, evtMsgs, content);
 
-                    // unpublish the culture
-                    content.UnpublishCulture(culture);
+                    return result;
                 }
-
-                var result = CommitDocumentChangesInternal(scope, content, saveEventArgs, userId);
-                scope.Complete();
-                return result;
             }
-
         }
 
         /// <summary>
@@ -1047,15 +1064,35 @@ namespace Umbraco.Core.Services.Implement
                 if (raiseEvents && scope.Events.DispatchCancelable(Saving, this, saveEventArgs, nameof(Saving)))
                     return new PublishResult(PublishResultType.FailedPublishCancelledByEvent, evtMsgs, content);
 
-                var result = CommitDocumentChangesInternal(scope, content, saveEventArgs, userId, raiseEvents);
+                var allLangs = _languageRepository.GetMany().ToList();
+
+                var result = CommitDocumentChangesInternal(scope, content, saveEventArgs, allLangs, userId, raiseEvents);
                 scope.Complete();
                 return result;
             }
         }
 
+        /// <summary>
+        /// Handles a lot of business logic cases for how the document should be persisted
+        /// </summary>
+        /// <param name="scope"></param>
+        /// <param name="content"></param>
+        /// <param name="saveEventArgs"></param>
+        /// <param name="userId"></param>
+        /// <param name="raiseEvents"></param>
+        /// <param name="branchOne"></param>
+        /// <param name="branchRoot"></param>
+        /// <returns></returns>
+        /// <remarks>
+        /// <para>
+        /// Business logic cases such: as unpublishing a mandatory culture, or unpublishing the last culture, checking for pending scheduled publishing, etc... is dealt with in this method.
+        /// There is quite a lot of cases to take into account along with logic that needs to deal with scheduled saving/publishing, branch saving/publishing, etc...       
+        /// </para>
+        /// </remarks>
         private PublishResult CommitDocumentChangesInternal(IScope scope, IContent content,
-            ContentSavingEventArgs saveEventArgs,
-            int userId = Constants.Security.SuperUserId, bool raiseEvents = true, bool branchOne = false, bool branchRoot = false)
+            ContentSavingEventArgs saveEventArgs, IReadOnlyCollection<ILanguage> allLangs,
+            int userId = Constants.Security.SuperUserId,
+            bool raiseEvents = true, bool branchOne = false, bool branchRoot = false)
         {
             if (scope == null) throw new ArgumentNullException(nameof(scope));
             if (content == null) throw new ArgumentNullException(nameof(content));
@@ -1070,8 +1107,8 @@ namespace Umbraco.Core.Services.Implement
             if (content.PublishedState != PublishedState.Publishing && content.PublishedState != PublishedState.Unpublishing)
                 content.PublishedState = PublishedState.Publishing;
 
-            // state here is either Publishing or Unpublishing
-            // (even though, Publishing to unpublish a culture may end up unpublishing everything)
+            // State here is either Publishing or Unpublishing
+            // Publishing to unpublish a culture may end up unpublishing everything so these flags can be flipped later
             var publishing = content.PublishedState == PublishedState.Publishing;
             var unpublishing = content.PublishedState == PublishedState.Unpublishing;
 
@@ -1088,6 +1125,18 @@ namespace Umbraco.Core.Services.Implement
             var changeType = isNew ? TreeChangeTypes.RefreshNode : TreeChangeTypes.RefreshBranch;
             var previouslyPublished = content.HasIdentity && content.Published;
 
+            //inline method to persist the document with the documentRepository since this logic could be called a couple times below
+            void SaveDocument(IContent c)
+            {
+                // save, always
+                if (c.HasIdentity == false)
+                    c.CreatorId = userId;
+                c.WriterId = userId;
+
+                // saving does NOT change the published version, unless PublishedState is Publishing or Unpublishing
+                _documentRepository.Save(c);
+            }
+
             if (publishing)
             {
                 //determine cultures publishing/unpublishing which will be based on previous calls to content.PublishCulture and ClearPublishInfo
@@ -1097,11 +1146,25 @@ namespace Umbraco.Core.Services.Implement
                         : null;
 
                 // ensure that the document can be published, and publish handling events, business rules, etc
-                publishResult = StrategyCanPublish(scope, content, /*checkPath:*/ (!branchOne || branchRoot), culturesPublishing, culturesUnpublishing, evtMsgs, saveEventArgs);
+                publishResult = StrategyCanPublish(scope, content, /*checkPath:*/ (!branchOne || branchRoot), culturesPublishing, culturesUnpublishing, evtMsgs, saveEventArgs, allLangs);
                 if (publishResult.Success)
                 {
                     // note: StrategyPublish flips the PublishedState to Publishing!
                     publishResult = StrategyPublish(content, culturesPublishing, culturesUnpublishing, evtMsgs);
+
+                    //check if a culture has been unpublished and if there are no cultures left, and then unpublish document as a whole
+                    if (publishResult.Result == PublishResultType.SuccessUnpublishCulture && content.PublishCultureInfos.Count == 0)
+                    {
+                        // This is a special case! We are unpublishing the last culture and to persist that we need to re-publish without any cultures
+                        // so the state needs to remain Publishing to do that. However, we then also need to unpublish the document and to do that
+                        // the state needs to be Unpublishing and it cannot be both. This state is used within the documentRepository to know how to
+                        // persist certain things. So before proceeding below, we need to save the Publishing state to publish no cultures, then we can
+                        // mark the document for Unpublishing.
+                        SaveDocument(content);
+
+                        //set the flag to unpublish and continue
+                        unpublishing = content.Published; // if not published yet, nothing to do
+                    }
                 }
                 else
                 {
@@ -1162,13 +1225,8 @@ namespace Umbraco.Core.Services.Implement
                 }
             }
 
-            // save, always
-            if (content.HasIdentity == false)
-                content.CreatorId = userId;
-            content.WriterId = userId;
-
-            // saving does NOT change the published version, unless PublishedState is Publishing or Unpublishing
-            _documentRepository.Save(content);
+            //Persist the document
+            SaveDocument(content);
 
             // raise the Saved event, always
             if (raiseEvents)
@@ -1186,17 +1244,34 @@ namespace Umbraco.Core.Services.Implement
 
                     if (culturesUnpublishing != null)
                     {
-                        //If we are here, it means we tried unpublishing a culture but it was mandatory so now everything is unpublished
-                        var langs = string.Join(", ", _languageRepository.GetMany()
+                        // This will mean that that we unpublished a mandatory culture or we unpublished the last culture.
+                        
+                        var langs = string.Join(", ", allLangs
                                     .Where(x => culturesUnpublishing.InvariantContains(x.IsoCode))
                                     .Select(x => x.CultureName));
                         Audit(AuditType.UnpublishVariant, userId, content.Id, $"Unpublished languages: {langs}", langs);
-                        //log that the whole content item has been unpublished due to mandatory culture unpublished
-                        Audit(AuditType.Unpublish, userId, content.Id, "Unpublished (mandatory language unpublished)");
-                    }
-                    else
-                        Audit(AuditType.Unpublish, userId, content.Id);
 
+                        if (publishResult == null)
+                            throw new PanicException("publishResult == null - should not happen");
+
+                        switch(publishResult.Result)
+                        {
+                            case PublishResultType.FailedPublishMandatoryCultureMissing:
+                                //occurs when a mandatory culture was unpublished (which means we tried publishing the document without a mandatory culture)
+
+                                //log that the whole content item has been unpublished due to mandatory culture unpublished
+                                Audit(AuditType.Unpublish, userId, content.Id, "Unpublished (mandatory language unpublished)");
+                                return new PublishResult(PublishResultType.SuccessUnpublishMandatoryCulture, evtMsgs, content);
+                            case PublishResultType.SuccessUnpublishCulture:
+                                //occurs when the last culture is unpublished
+
+                                Audit(AuditType.Unpublish, userId, content.Id, "Unpublished (last language unpublished)");
+                                return new PublishResult(PublishResultType.SuccessUnpublishLastCulture, evtMsgs, content);
+                        }
+                        
+                    }
+
+                    Audit(AuditType.Unpublish, userId, content.Id);
                     return new PublishResult(PublishResultType.SuccessUnpublish, evtMsgs, content);
                 }
 
@@ -1236,7 +1311,7 @@ namespace Umbraco.Core.Services.Implement
                         case PublishResultType.SuccessPublishCulture:
                             if (culturesPublishing != null)
                             {
-                                var langs = string.Join(", ", _languageRepository.GetMany()
+                                var langs = string.Join(", ", allLangs
                                     .Where(x => culturesPublishing.InvariantContains(x.IsoCode))
                                     .Select(x => x.CultureName));
                                 Audit(AuditType.PublishVariant, userId, content.Id, $"Published languages: {langs}", langs);
@@ -1245,7 +1320,7 @@ namespace Umbraco.Core.Services.Implement
                         case PublishResultType.SuccessUnpublishCulture:
                             if (culturesUnpublishing != null)
                             {
-                                var langs = string.Join(", ", _languageRepository.GetMany()
+                                var langs = string.Join(", ", allLangs
                                    .Where(x => culturesUnpublishing.InvariantContains(x.IsoCode))
                                    .Select(x => x.CultureName));
                                 Audit(AuditType.UnpublishVariant, userId, content.Id, $"Unpublished languages: {langs}", langs);
@@ -1259,14 +1334,14 @@ namespace Umbraco.Core.Services.Implement
 
             // should not happen
             if (branchOne && !branchRoot)
-                throw new Exception("panic");
+                throw new PanicException("branchOne && !branchRoot - should not happen");
 
             //if publishing didn't happen or if it has failed, we still need to log which cultures were saved
             if (!branchOne && (publishResult == null || !publishResult.Success))
             {
                 if (culturesChanging != null)
                 {
-                    var langs = string.Join(", ", _languageRepository.GetMany()
+                    var langs = string.Join(", ", allLangs
                         .Where(x => culturesChanging.InvariantContains(x.IsoCode))
                         .Select(x => x.CultureName));
                     Audit(AuditType.SaveVariant, userId, content.Id, $"Saved languages: {langs}", langs);
@@ -1297,6 +1372,8 @@ namespace Umbraco.Core.Services.Implement
             {
                 scope.WriteLock(Constants.Locks.ContentTree);
 
+                var allLangs = _languageRepository.GetMany().ToList();
+
                 foreach (var d in _documentRepository.GetContentForRelease(date))
                 {
                     PublishResult result;
@@ -1325,7 +1402,7 @@ namespace Umbraco.Core.Services.Implement
 
                             //publish the culture values and validate the property values, if validation fails, log the invalid properties so the develeper has an idea of what has failed
                             Property[] invalidProperties = null;
-                            var impact = CultureImpact.Explicit(culture, _languageRepository.IsDefault(culture));
+                            var impact = CultureImpact.Explicit(culture, IsDefaultCulture(allLangs, culture));
                             var tryPublish = d.PublishCulture(impact) && _propertyValidationService.Value.IsPropertyDataValid(d, out invalidProperties, impact);
                             if (invalidProperties != null && invalidProperties.Length > 0)
                                 Logger.Warn<ContentService>("Scheduled publishing will fail for document {DocumentId} and culture {Culture} because of invalid properties {InvalidProperties}",
@@ -1340,7 +1417,7 @@ namespace Umbraco.Core.Services.Implement
                         else if (!publishing)
                             result = new PublishResult(PublishResultType.FailedPublishContentInvalid, evtMsgs, d);
                         else
-                            result = CommitDocumentChangesInternal(scope, d, saveEventArgs, d.WriterId);
+                            result = CommitDocumentChangesInternal(scope, d, saveEventArgs, allLangs, d.WriterId);
 
 
                         if (result.Success == false)
@@ -1390,7 +1467,7 @@ namespace Umbraco.Core.Services.Implement
                             d.UnpublishCulture(c);
                         }
 
-                        result = CommitDocumentChangesInternal(scope, d, saveEventArgs, d.WriterId);
+                        result = CommitDocumentChangesInternal(scope, d, saveEventArgs, allLangs, d.WriterId);
                         if (result.Success == false)
                             Logger.Error<ContentService>(null, "Failed to publish document id={DocumentId}, reason={Reason}.", d.Id, result.Result);
                         yield return result;
@@ -1416,7 +1493,7 @@ namespace Umbraco.Core.Services.Implement
         }
 
         // utility 'PublishCultures' func used by SaveAndPublishBranch
-        private bool SaveAndPublishBranch_PublishCultures(IContent content, HashSet<string> culturesToPublish)
+        private bool SaveAndPublishBranch_PublishCultures(IContent content, HashSet<string> culturesToPublish, IReadOnlyCollection<ILanguage> allLangs)
         {
             //TODO: This does not support being able to return invalid property details to bubble up to the UI
 
@@ -1426,7 +1503,7 @@ namespace Umbraco.Core.Services.Implement
             {
                 return culturesToPublish.All(culture =>
                 {
-                    var impact = CultureImpact.Create(culture, _languageRepository.IsDefault(culture), content);
+                    var impact = CultureImpact.Create(culture, IsDefaultCulture(allLangs, culture), content);
                     return content.PublishCulture(impact) && _propertyValidationService.Value.IsPropertyDataValid(content, out _, impact);
                 });
             }
@@ -1535,7 +1612,7 @@ namespace Umbraco.Core.Services.Implement
 
         internal IEnumerable<PublishResult> SaveAndPublishBranch(IContent document, bool force,
             Func<IContent, HashSet<string>> shouldPublish,
-            Func<IContent, HashSet<string>, bool> publishCultures,
+            Func<IContent, HashSet<string>, IReadOnlyCollection<ILanguage>, bool> publishCultures,
             int userId = Constants.Security.SuperUserId)
         {
             if (shouldPublish == null) throw new ArgumentNullException(nameof(shouldPublish));
@@ -1549,6 +1626,8 @@ namespace Umbraco.Core.Services.Implement
             {
                 scope.WriteLock(Constants.Locks.ContentTree);
 
+                var allLangs = _languageRepository.GetMany().ToList();
+
                 if (!document.HasIdentity)
                     throw new InvalidOperationException("Cannot not branch-publish a new document.");
 
@@ -1557,7 +1636,7 @@ namespace Umbraco.Core.Services.Implement
                     throw new InvalidOperationException("Cannot mix PublishCulture and SaveAndPublishBranch.");
 
                 // deal with the branch root - if it fails, abort
-                var result = SaveAndPublishBranchItem(scope, document, shouldPublish, publishCultures, true, publishedDocuments, evtMsgs, userId);
+                var result = SaveAndPublishBranchItem(scope, document, shouldPublish, publishCultures, true, publishedDocuments, evtMsgs, userId, allLangs);
                 if (result != null)
                 {
                     results.Add(result);
@@ -1588,7 +1667,7 @@ namespace Umbraco.Core.Services.Implement
                         }
 
                         // no need to check path here, parent has to be published here
-                        result = SaveAndPublishBranchItem(scope, d, shouldPublish, publishCultures, false, publishedDocuments, evtMsgs, userId);
+                        result = SaveAndPublishBranchItem(scope, d, shouldPublish, publishCultures, false, publishedDocuments, evtMsgs, userId, allLangs);
                         if (result != null)
                         {
                             results.Add(result);
@@ -1620,10 +1699,10 @@ namespace Umbraco.Core.Services.Implement
         // publishValues: a function publishing values (using the appropriate PublishCulture calls)
         private PublishResult SaveAndPublishBranchItem(IScope scope, IContent document,
             Func<IContent, HashSet<string>> shouldPublish,
-            Func<IContent, HashSet<string>, bool> publishCultures,
+            Func<IContent, HashSet<string>, IReadOnlyCollection<ILanguage>, bool> publishCultures,
             bool isRoot,
             ICollection<IContent> publishedDocuments,
-            EventMessages evtMsgs, int userId)
+            EventMessages evtMsgs, int userId, IReadOnlyCollection<ILanguage> allLangs)
         {
             var culturesToPublish = shouldPublish(document);
             if (culturesToPublish == null) // null = do not include
@@ -1636,13 +1715,13 @@ namespace Umbraco.Core.Services.Implement
                 return new PublishResult(PublishResultType.FailedPublishCancelledByEvent, evtMsgs, document);
 
             // publish & check if values are valid
-            if (!publishCultures(document, culturesToPublish))
+            if (!publishCultures(document, culturesToPublish, allLangs))
             {
                 //TODO: Based on this callback behavior there is no way to know which properties may have been invalid if this failed, see other results of FailedPublishContentInvalid
                 return new PublishResult(PublishResultType.FailedPublishContentInvalid, evtMsgs, document);
             }
 
-            var result = CommitDocumentChangesInternal(scope, document, saveEventArgs, userId, branchOne: true, branchRoot: isRoot);
+            var result = CommitDocumentChangesInternal(scope, document, saveEventArgs, allLangs, userId, branchOne: true, branchRoot: isRoot);
             if (result.Success)
                 publishedDocuments.Add(document);
             return result;
@@ -2343,6 +2422,9 @@ namespace Umbraco.Core.Services.Implement
             _auditRepository.Save(new AuditItem(objectId, type, userId, ObjectTypes.GetName(UmbracoObjectTypes.Document), message, parameters));
         }
 
+        private bool IsDefaultCulture(IReadOnlyCollection<ILanguage> langs, string culture) => langs.Any(x => x.IsDefault && x.IsoCode.InvariantEquals(culture));
+        private bool IsMandatoryCulture(IReadOnlyCollection<ILanguage> langs, string culture) => langs.Any(x => x.IsMandatory && x.IsoCode.InvariantEquals(culture));
+
         #endregion
 
         #region Event Handlers
@@ -2497,7 +2579,9 @@ namespace Umbraco.Core.Services.Implement
         /// <param name="culturesPublishing"></param>
         /// <param name="savingEventArgs"></param>
         /// <returns></returns>
-        private PublishResult StrategyCanPublish(IScope scope, IContent content, bool checkPath, IReadOnlyList<string> culturesPublishing, IReadOnlyCollection<string> culturesUnpublishing, EventMessages evtMsgs, ContentSavingEventArgs savingEventArgs)
+        private PublishResult StrategyCanPublish(IScope scope, IContent content, bool checkPath, IReadOnlyList<string> culturesPublishing,
+            IReadOnlyCollection<string> culturesUnpublishing, EventMessages evtMsgs, ContentSavingEventArgs savingEventArgs,
+            IReadOnlyCollection<ILanguage> allLangs)
         {
             // raise Publishing event
             if (scope.Events.DispatchCancelable(Publishing, this, savingEventArgs.ToContentPublishingEventArgs()))
@@ -2510,7 +2594,7 @@ namespace Umbraco.Core.Services.Implement
 
             var impactsToPublish = culturesPublishing == null
                 ? new[] {CultureImpact.Invariant} //if it's null it's invariant
-                : culturesPublishing.Select(x => CultureImpact.Explicit(x, _languageRepository.IsDefault(x))).ToArray();
+                : culturesPublishing.Select(x => CultureImpact.Explicit(x, allLangs.Any(lang => lang.IsoCode.InvariantEquals(x) && lang.IsMandatory))).ToArray();
 
             // publish the culture(s)
             if (!impactsToPublish.All(content.PublishCulture))
@@ -2531,11 +2615,17 @@ namespace Umbraco.Core.Services.Implement
                 if (culturesPublishing == null)
                     throw new InvalidOperationException("Internal error, variesByCulture but culturesPublishing is null.");
 
-                if (content.Published && culturesPublishing.Count == 0 && culturesUnpublishing.Count == 0) // no published cultures = cannot be published
+                if (content.Published && culturesPublishing.Count == 0 && culturesUnpublishing.Count == 0)
+                {
+                    // no published cultures = cannot be published
+                    // This will occur if for example, a culture that is already unpublished is sent to be unpublished again, or vice versa, in that case
+                    // there will be nothing to publish/unpublish.
                     return new PublishResult(PublishResultType.FailedPublishNothingToPublish, evtMsgs, content);
+                }
+                
 
                 // missing mandatory culture = cannot be published
-                var mandatoryCultures = _languageRepository.GetMany().Where(x => x.IsMandatory).Select(x => x.IsoCode);
+                var mandatoryCultures = allLangs.Where(x => x.IsMandatory).Select(x => x.IsoCode);
                 var mandatoryMissing = mandatoryCultures.Any(x => !content.PublishedCultures.Contains(x, StringComparer.OrdinalIgnoreCase));
                 if (mandatoryMissing)
                     return new PublishResult(PublishResultType.FailedPublishMandatoryCultureMissing, evtMsgs, content);
@@ -2676,6 +2766,7 @@ namespace Umbraco.Core.Services.Implement
         {
             var attempt = new PublishResult(PublishResultType.SuccessUnpublish, evtMsgs, content);
 
+            //TODO: What is this check?? we just created this attempt and of course it is Success?!
             if (attempt.Success == false)
                 return attempt;
 

src/Umbraco.Core/Services/PublishResultType.cs

@@ -49,6 +49,11 @@
         /// </summary>
         SuccessUnpublishMandatoryCulture = 6,
 
+        /// <summary>
+        /// The specified document culture was unpublished, and was the last published culture in the document, therefore the document itself was unpublished.
+        /// </summary>
+        SuccessUnpublishLastCulture = 8,
+
         #endregion
 
         #region Success - Mixed
@@ -113,9 +118,9 @@
         FailedPublishContentInvalid = FailedPublish | 8,
 
         /// <summary>
-        /// The document could not be published because it has no publishing flags or values.
+        /// The document could not be published because it has no publishing flags or values or if its a variant document, no cultures were specified to be published.
         /// </summary>
-        FailedPublishNothingToPublish = FailedPublish | 9, // TODO: in ContentService.StrategyCanPublish - weird
+        FailedPublishNothingToPublish = FailedPublish | 9, 
 
         /// <summary>
         /// The document could not be published because some mandatory cultures are missing.

src/Umbraco.Core/Umbraco.Core.csproj

@@ -204,6 +204,7 @@
     <Compile Include="CompositionExtensions_Essentials.cs" />
     <Compile Include="CompositionExtensions_FileSystems.cs" />
     <Compile Include="CompositionExtensions_Uniques.cs" />
+    <Compile Include="Exceptions\PanicException.cs" />
     <Compile Include="FactoryExtensions.cs" />
     <Compile Include="Composing\RegisterFactory.cs" />
     <Compile Include="Composing\Current.cs" />
@@ -241,6 +242,7 @@
     <Compile Include="Migrations\Upgrade\V_8_0_0\DataTypes\DefaultPreValueMigrator.cs" />
     <Compile Include="Migrations\Upgrade\V_8_0_0\DataTypes\RenamingPreValueMigrator.cs" />
     <Compile Include="Migrations\Upgrade\V_8_0_0\DataTypes\RichTextPreValueMigrator.cs" />
+    <Compile Include="Migrations\Upgrade\V_8_0_0\DataTypes\DropDownFlexiblePreValueMigrator.cs" />
     <Compile Include="Migrations\Upgrade\V_8_0_0\MergeDateAndDateTimePropertyEditor.cs" />
     <Compile Include="Models\Entities\EntityExtensions.cs" />
     <Compile Include="Migrations\Upgrade\V_8_0_0\DataTypes\PreValueMigratorBase.cs" />

src/Umbraco.Core/WaitHandleExtensions.cs

@@ -23,6 +23,8 @@ namespace Umbraco.Core
                     handle,
                     (state, timedOut) =>
                     {
+                        //TODO: We aren't checking if this is timed out
+
                         tcs.SetResult(null);
 
                         // we take a lock here to make sure the outer method has completed setting the local variable callbackHandle.

src/Umbraco.Examine/BaseValueSetBuilder.cs

@@ -45,7 +45,7 @@ namespace Umbraco.Examine
                             continue;
                         case string strVal:
                             {
-                                if (strVal.IsNullOrWhiteSpace()) return;
+                                if (strVal.IsNullOrWhiteSpace()) continue;
                                 var key = $"{keyVal.Key}{cultureSuffix}";
                                 if (values.TryGetValue(key, out var v))
                                     values[key] = new List<object>(v) { val }.ToArray();

src/Umbraco.Examine/ContentValueSetBuilder.cs

@@ -54,7 +54,7 @@ namespace Umbraco.Examine
                     {"updateDate", new object[] {c.UpdateDate}},    //Always add invariant updateDate
                     {"nodeName", (PublishedValuesOnly               //Always add invariant nodeName
                         ? c.PublishName?.Yield()
-                        : c?.Name.Yield()) ?? Enumerable.Empty<string>()},
+                        : c.Name?.Yield()) ?? Enumerable.Empty<string>()},
                     {"urlName", urlValue?.Yield() ?? Enumerable.Empty<string>()},                  //Always add invariant urlName
                     {"path", c.Path?.Yield() ?? Enumerable.Empty<string>()},
                     {"nodeType", c.ContentType.Id.ToString().Yield() ?? Enumerable.Empty<string>()},

src/Umbraco.Examine/ExamineExtensions.cs

@@ -28,6 +28,31 @@ namespace Umbraco.Examine
         /// </remarks>
         internal static readonly Regex CultureIsoCodeFieldNameMatchExpression = new Regex("^([_\\w]+)_([a-z]{2}-[a-z0-9]{2,4})$", RegexOptions.Compiled);
 
+        private static volatile bool _isUnlocked = false;
+        private static readonly object IsUnlockedLocker = new object();
+
+        /// <summary>
+        /// Unlocks all Lucene based indexes registered with the <see cref="IExamineManager"/>
+        /// </summary>
+        /// <remarks>
+        /// Indexing rebuilding can occur on a normal boot if the indexes are empty or on a cold boot by the database server messenger. Before
+        /// either of these happens, we need to configure the indexes.
+        /// </remarks>
+        internal static void EnsureUnlocked(this IExamineManager examineManager, IMainDom mainDom, ILogger logger)
+        {
+            if (!mainDom.IsMainDom) return;
+            if (_isUnlocked) return;
+
+            lock (IsUnlockedLocker)
+            {
+                //double check
+                if (_isUnlocked) return;
+
+                _isUnlocked = true;
+                examineManager.UnlockLuceneIndexes(logger);
+            }
+        }
+
         //TODO: We need a public method here to just match a field name against CultureIsoCodeFieldNameMatchExpression
 
         /// <summary>
@@ -48,6 +73,31 @@ namespace Umbraco.Examine
             }
         }
 
+        /// <summary>
+        /// Returns all index fields that are culture specific (suffixed) or invariant
+        /// </summary>
+        /// <param name="index"></param>
+        /// <param name="culture"></param>
+        /// <returns></returns>
+        public static IEnumerable<string> GetCultureAndInvariantFields(this IUmbracoIndex index, string culture)
+        {
+            var allFields = index.GetFields();
+            // ReSharper disable once LoopCanBeConvertedToQuery
+            foreach (var field in allFields)
+            {
+                var match = CultureIsoCodeFieldNameMatchExpression.Match(field);
+                if (match.Success && match.Groups.Count == 3 && culture.InvariantEquals(match.Groups[2].Value))
+                {
+                    yield return field; //matches this culture field
+                }
+                else if (!match.Success)
+                {
+                    yield return field; //matches no culture field (invariant)
+                }
+                    
+            }
+        }
+
         internal static bool TryParseLuceneQuery(string query)
         {
             // TODO: I'd assume there would be a more strict way to parse the query but not that i can find yet, for now we'll

src/Umbraco.Examine/IndexRebuilder.cs

@@ -5,7 +5,8 @@ using System.Threading.Tasks;
 using Examine;
 
 namespace Umbraco.Examine
-{
+{   
+
     /// <summary>
     /// Utility to rebuild all indexes ensuring minimal data queries
     /// </summary>

src/Umbraco.Examine/LuceneIndexDiagnostics.cs

@@ -0,0 +1,83 @@
+using System.Collections.Generic;
+using Examine.LuceneEngine.Providers;
+using Umbraco.Core;
+using Umbraco.Core.Logging;
+using Lucene.Net.Store;
+using Umbraco.Core.IO;
+using System.Linq;
+
+namespace Umbraco.Examine
+{
+    public class LuceneIndexDiagnostics : IIndexDiagnostics
+    {
+        public LuceneIndexDiagnostics(LuceneIndex index, ILogger logger)
+        {
+            Index = index;
+            Logger = logger;
+        }
+
+        public LuceneIndex Index { get; }
+        public ILogger Logger { get; }
+
+        public int DocumentCount
+        {
+            get
+            {
+                try
+                {
+                    return Index.GetIndexDocumentCount();
+                }
+                catch (AlreadyClosedException)
+                {
+                    Logger.Warn(typeof(UmbracoContentIndex), "Cannot get GetIndexDocumentCount, the writer is already closed");
+                    return 0;
+                }
+            }
+        }
+
+        public int FieldCount
+        {
+            get
+            {
+                try
+                {
+                    return Index.GetIndexFieldCount();
+                }
+                catch (AlreadyClosedException)
+                {
+                    Logger.Warn(typeof(UmbracoContentIndex), "Cannot get GetIndexFieldCount, the writer is already closed");
+                    return 0;
+                }
+            }
+        }
+
+        public Attempt<string> IsHealthy()
+        {
+            var isHealthy = Index.IsHealthy(out var indexError);
+            return isHealthy ? Attempt<string>.Succeed() : Attempt.Fail(indexError.Message);
+        }
+
+        public virtual IReadOnlyDictionary<string, object> Metadata
+        {
+            get
+            {
+                var luceneDir = Index.GetLuceneDirectory();
+                var d = new Dictionary<string, object>
+                {
+                    [nameof(UmbracoExamineIndex.CommitCount)] = Index.CommitCount,
+                    [nameof(UmbracoExamineIndex.DefaultAnalyzer)] = Index.DefaultAnalyzer.GetType().Name,
+                    ["LuceneDirectory"] = luceneDir.GetType().Name                    
+                };
+
+                if (luceneDir is FSDirectory fsDir)
+                {
+                    d[nameof(UmbracoExamineIndex.LuceneIndexFolder)] = fsDir.Directory.ToString().ToLowerInvariant().TrimStart(IOHelper.MapPath(SystemDirectories.Root).ToLowerInvariant()).Replace("\\", "/").EnsureStartsWith('/');
+                }
+
+                return d;
+            }
+        }
+
+        
+    }
+}

src/Umbraco.Examine/Umbraco.Examine.csproj

@@ -72,6 +72,7 @@
     <Compile Include="IPublishedContentValueSetBuilder.cs" />
     <Compile Include="IUmbracoIndex.cs" />
     <Compile Include="IValueSetBuilder.cs" />
+    <Compile Include="LuceneIndexDiagnostics.cs" />
     <Compile Include="MediaIndexPopulator.cs" />
     <Compile Include="MediaValueSetBuilder.cs" />
     <Compile Include="MemberIndexPopulator.cs" />

src/Umbraco.Examine/UmbracoExamineIndexDiagnostics.cs

@@ -7,73 +7,24 @@ using Umbraco.Core.Logging;
 
 namespace Umbraco.Examine
 {
-    public class UmbracoExamineIndexDiagnostics : IIndexDiagnostics
+    public class UmbracoExamineIndexDiagnostics : LuceneIndexDiagnostics
     {
         private readonly UmbracoExamineIndex _index;
-        private readonly ILogger _logger;
 
         public UmbracoExamineIndexDiagnostics(UmbracoExamineIndex index, ILogger logger)
+            : base(index, logger)
         {
             _index = index;
-            _logger = logger;
         }
 
-        public int DocumentCount
+        public override IReadOnlyDictionary<string, object> Metadata
         {
             get
             {
-                try
-                {
-                    return _index.GetIndexDocumentCount();
-                }
-                catch (AlreadyClosedException)
-                {
-                    _logger.Warn(typeof(UmbracoContentIndex), "Cannot get GetIndexDocumentCount, the writer is already closed");
-                    return 0;
-                }
-            }
-        }
+                var d = base.Metadata.ToDictionary(x => x.Key, x => x.Value);
 
-        public int FieldCount
-        {
-            get
-            {
-                try
-                {
-                    return _index.GetIndexFieldCount();
-                }
-                catch (AlreadyClosedException)
-                {
-                    _logger.Warn(typeof(UmbracoContentIndex), "Cannot get GetIndexFieldCount, the writer is already closed");
-                    return 0;
-                }
-            }
-        }
-
-        public Attempt<string> IsHealthy()
-        {
-            var isHealthy = _index.IsHealthy(out var indexError);
-            return isHealthy ? Attempt<string>.Succeed() : Attempt.Fail(indexError.Message);
-        }
-
-        public virtual IReadOnlyDictionary<string, object> Metadata
-        {
-            get
-            {
-                var d = new Dictionary<string, object>
-                {
-                    [nameof(UmbracoExamineIndex.CommitCount)] = _index.CommitCount,
-                    [nameof(UmbracoExamineIndex.DefaultAnalyzer)] = _index.DefaultAnalyzer.GetType().Name,
-                    ["LuceneDirectory"] = _index.GetLuceneDirectory().GetType().Name,
-                    [nameof(UmbracoExamineIndex.EnableDefaultEventHandler)] = _index.EnableDefaultEventHandler,
-                    [nameof(UmbracoExamineIndex.LuceneIndexFolder)] =
-                        _index.LuceneIndexFolder == null
-                            ? string.Empty
-                            : _index.LuceneIndexFolder.ToString().ToLowerInvariant().TrimStart(IOHelper.MapPath(SystemDirectories.Root).ToLowerInvariant()).Replace("\\", "/").EnsureStartsWith('/'),
-                    [nameof(UmbracoExamineIndex.PublishedValuesOnly)] = _index.PublishedValuesOnly,
-                    //There's too much info here
-                    //[nameof(UmbracoExamineIndexer.FieldDefinitionCollection)] = _index.FieldDefinitionCollection,
-                };
+                d[nameof(UmbracoExamineIndex.EnableDefaultEventHandler)] = _index.EnableDefaultEventHandler;
+                d[nameof(UmbracoExamineIndex.PublishedValuesOnly)] = _index.PublishedValuesOnly;
 
                 if (_index.ValueSetValidator is ValueSetValidator vsv)
                 {

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

@@ -29,10 +29,11 @@ namespace Umbraco.Tests.Persistence.Repositories
 
         private DocumentRepository CreateRepository(IScopeAccessor scopeAccessor, out ContentTypeRepository contentTypeRepository)
         {
+            var langRepository = new LanguageRepository(scopeAccessor, AppCaches.Disabled, Logger);
             var templateRepository = new TemplateRepository(scopeAccessor, AppCaches.Disabled, Logger, TestObjects.GetFileSystemsMock());
             var tagRepository = new TagRepository(scopeAccessor, AppCaches.Disabled, Logger);
             var commonRepository = new ContentTypeCommonRepository(scopeAccessor, templateRepository, AppCaches.Disabled);
-            contentTypeRepository = new ContentTypeRepository(scopeAccessor, AppCaches.Disabled, Logger, commonRepository);
+            contentTypeRepository = new ContentTypeRepository(scopeAccessor, AppCaches.Disabled, Logger, commonRepository, langRepository);
             var languageRepository = new LanguageRepository(scopeAccessor, AppCaches.Disabled, Logger);
             var repository = new DocumentRepository(scopeAccessor, AppCaches.Disabled, Logger, contentTypeRepository, templateRepository, tagRepository, languageRepository);
             return repository;
@@ -40,9 +41,10 @@ namespace Umbraco.Tests.Persistence.Repositories
 
         private ContentTypeRepository CreateRepository(IScopeAccessor scopeAccessor)
         {
+            var langRepository = new LanguageRepository(scopeAccessor, AppCaches.Disabled, Logger);
             var templateRepository = new TemplateRepository(scopeAccessor, AppCaches.Disabled, Logger, TestObjects.GetFileSystemsMock());
             var commonRepository = new ContentTypeCommonRepository(scopeAccessor, templateRepository, AppCaches.Disabled);
-            var contentTypeRepository = new ContentTypeRepository(scopeAccessor, AppCaches.Disabled, Logger, commonRepository);
+            var contentTypeRepository = new ContentTypeRepository(scopeAccessor, AppCaches.Disabled, Logger, commonRepository, langRepository);
             return contentTypeRepository;
         }
 
@@ -50,7 +52,8 @@ namespace Umbraco.Tests.Persistence.Repositories
         {
             var templateRepository = new TemplateRepository(scopeAccessor, AppCaches.Disabled, Logger, TestObjects.GetFileSystemsMock());
             var commonRepository = new ContentTypeCommonRepository(scopeAccessor, templateRepository, AppCaches.Disabled);
-            var contentTypeRepository = new MediaTypeRepository(scopeAccessor, AppCaches.Disabled, Logger, commonRepository);
+            var langRepository = new LanguageRepository(scopeAccessor, AppCaches.Disabled, Logger);
+            var contentTypeRepository = new MediaTypeRepository(scopeAccessor, AppCaches.Disabled, Logger, commonRepository, langRepository);
             return contentTypeRepository;
         }
 

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

@@ -67,8 +67,8 @@ namespace Umbraco.Tests.Persistence.Repositories
             templateRepository = new TemplateRepository(scopeAccessor, appCaches, Logger, TestObjects.GetFileSystemsMock());
             var tagRepository = new TagRepository(scopeAccessor, appCaches, Logger);
             var commonRepository = new ContentTypeCommonRepository(scopeAccessor, templateRepository, appCaches);
-            contentTypeRepository = new ContentTypeRepository(scopeAccessor, appCaches, Logger, commonRepository);
             var languageRepository = new LanguageRepository(scopeAccessor, appCaches, Logger);
+            contentTypeRepository = new ContentTypeRepository(scopeAccessor, appCaches, Logger, commonRepository, languageRepository);
             var repository = new DocumentRepository(scopeAccessor, appCaches, Logger, contentTypeRepository, templateRepository, tagRepository, languageRepository);
             return repository;
         }

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

@@ -23,8 +23,8 @@ namespace Umbraco.Tests.Persistence.Repositories
             var templateRepository = new TemplateRepository(accessor, Core.Cache.AppCaches.Disabled, Logger, TestObjects.GetFileSystemsMock());
             var tagRepository = new TagRepository(accessor, Core.Cache.AppCaches.Disabled, Logger);
             var commonRepository = new ContentTypeCommonRepository(accessor, templateRepository, AppCaches);
-            contentTypeRepository = new ContentTypeRepository(accessor, Core.Cache.AppCaches.Disabled, Logger, commonRepository);
             languageRepository = new LanguageRepository(accessor, Core.Cache.AppCaches.Disabled, Logger);
+            contentTypeRepository = new ContentTypeRepository(accessor, Core.Cache.AppCaches.Disabled, Logger, commonRepository, languageRepository);
             documentRepository = new DocumentRepository(accessor, Core.Cache.AppCaches.Disabled, Logger, contentTypeRepository, templateRepository, tagRepository, languageRepository);
             var domainRepository = new DomainRepository(accessor, Core.Cache.AppCaches.Disabled, Logger);
             return domainRepository;

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

@@ -38,7 +38,8 @@ namespace Umbraco.Tests.Persistence.Repositories
 
             var templateRepository = new TemplateRepository(scopeAccessor, appCaches, Logger, TestObjects.GetFileSystemsMock());
             var commonRepository = new ContentTypeCommonRepository(scopeAccessor, templateRepository, appCaches);
-            mediaTypeRepository = new MediaTypeRepository(scopeAccessor, appCaches, Logger, commonRepository);
+            var languageRepository = new LanguageRepository(scopeAccessor, appCaches, Logger);
+            mediaTypeRepository = new MediaTypeRepository(scopeAccessor, appCaches, Logger, commonRepository, languageRepository);
             var tagRepository = new TagRepository(scopeAccessor, appCaches, Logger);
             var repository = new MediaRepository(scopeAccessor, appCaches, Logger, mediaTypeRepository, tagRepository, Mock.Of<ILanguageRepository>());
             return repository;

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

@@ -23,7 +23,8 @@ namespace Umbraco.Tests.Persistence.Repositories
             var cacheHelper = AppCaches.Disabled;
             var templateRepository = new TemplateRepository((IScopeAccessor)provider, cacheHelper, Logger, TestObjects.GetFileSystemsMock());
             var commonRepository = new ContentTypeCommonRepository((IScopeAccessor)provider, templateRepository, AppCaches);
-            return new MediaTypeRepository((IScopeAccessor) provider, AppCaches.Disabled, Logger, commonRepository);
+            var languageRepository = new LanguageRepository((IScopeAccessor)provider, AppCaches, Logger);
+            return new MediaTypeRepository((IScopeAccessor) provider, AppCaches.Disabled, Logger, commonRepository, languageRepository);
         }
 
         private EntityContainerRepository CreateContainerRepository(IScopeProvider provider)

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

@@ -31,7 +31,8 @@ namespace Umbraco.Tests.Persistence.Repositories
             var accessor = (IScopeAccessor) provider;
             var templateRepository = Mock.Of<ITemplateRepository>();
             var commonRepository = new ContentTypeCommonRepository(accessor, templateRepository, AppCaches);
-            memberTypeRepository = new MemberTypeRepository(accessor, AppCaches.Disabled, Logger, commonRepository);
+            var languageRepository = new LanguageRepository(accessor, AppCaches.Disabled, Logger);
+            memberTypeRepository = new MemberTypeRepository(accessor, AppCaches.Disabled, Logger, commonRepository, languageRepository);
             memberGroupRepository = new MemberGroupRepository(accessor, AppCaches.Disabled, Logger);
             var tagRepo = new TagRepository(accessor, AppCaches.Disabled, Logger);
             var repository = new MemberRepository(accessor, AppCaches.Disabled, Logger, memberTypeRepository, memberGroupRepository, tagRepo, Mock.Of<ILanguageRepository>());

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

@@ -24,7 +24,8 @@ namespace Umbraco.Tests.Persistence.Repositories
         {
             var templateRepository = Mock.Of<ITemplateRepository>();
             var commonRepository = new ContentTypeCommonRepository((IScopeAccessor)provider, templateRepository, AppCaches);
-            return new MemberTypeRepository((IScopeAccessor) provider, AppCaches.Disabled, Mock.Of<ILogger>(), commonRepository);
+            var languageRepository = new LanguageRepository((IScopeAccessor)provider, AppCaches.Disabled, Mock.Of<ILogger>());
+            return new MemberTypeRepository((IScopeAccessor) provider, AppCaches.Disabled, Mock.Of<ILogger>(), commonRepository, languageRepository);
         }
 
         [Test]

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

@@ -308,8 +308,8 @@ namespace Umbraco.Tests.Persistence.Repositories
             var templateRepository = new TemplateRepository(accessor, AppCaches, Logger, TestObjects.GetFileSystemsMock());
             var tagRepository = new TagRepository(accessor, AppCaches, Logger);
             var commonRepository = new ContentTypeCommonRepository(accessor, templateRepository, AppCaches);
-            contentTypeRepository = new ContentTypeRepository(accessor, AppCaches, Logger, commonRepository);
             var languageRepository = new LanguageRepository(accessor, AppCaches, Logger);
+            contentTypeRepository = new ContentTypeRepository(accessor, AppCaches, Logger, commonRepository, languageRepository);
             var repository = new DocumentRepository(accessor, AppCaches, Logger, contentTypeRepository, templateRepository, tagRepository, languageRepository);
             return repository;
         }

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

@@ -956,8 +956,8 @@ namespace Umbraco.Tests.Persistence.Repositories
             var templateRepository = new TemplateRepository(accessor, AppCaches.Disabled, Logger, TestObjects.GetFileSystemsMock());
             var tagRepository = new TagRepository(accessor, AppCaches.Disabled, Logger);
             var commonRepository = new ContentTypeCommonRepository(accessor, templateRepository, AppCaches.Disabled);
-            contentTypeRepository = new ContentTypeRepository(accessor, AppCaches.Disabled, Logger, commonRepository);
             var languageRepository = new LanguageRepository(accessor, AppCaches.Disabled, Logger);
+            contentTypeRepository = new ContentTypeRepository(accessor, AppCaches.Disabled, Logger, commonRepository, languageRepository);
             var repository = new DocumentRepository(accessor, AppCaches.Disabled, Logger, contentTypeRepository, templateRepository, tagRepository, languageRepository);
             return repository;
         }
@@ -968,7 +968,8 @@ namespace Umbraco.Tests.Persistence.Repositories
             var templateRepository = new TemplateRepository(accessor, AppCaches.Disabled, Logger, TestObjects.GetFileSystemsMock());
             var tagRepository = new TagRepository(accessor, AppCaches.Disabled, Logger);
             var commonRepository = new ContentTypeCommonRepository(accessor, templateRepository, AppCaches.Disabled);
-            mediaTypeRepository = new MediaTypeRepository(accessor, AppCaches.Disabled, Logger, commonRepository);
+            var languageRepository = new LanguageRepository(accessor, AppCaches.Disabled, Logger);
+            mediaTypeRepository = new MediaTypeRepository(accessor, AppCaches.Disabled, Logger, commonRepository, languageRepository);
             var repository = new MediaRepository(accessor, AppCaches.Disabled, Logger, mediaTypeRepository, tagRepository, Mock.Of<ILanguageRepository>());
             return repository;
         }

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

@@ -239,8 +239,8 @@ namespace Umbraco.Tests.Persistence.Repositories
 
                 var tagRepository = new TagRepository((IScopeAccessor) ScopeProvider, AppCaches.Disabled, Logger);
                 var commonRepository = new ContentTypeCommonRepository(ScopeProvider, templateRepository, AppCaches);
-                var contentTypeRepository = new ContentTypeRepository((IScopeAccessor) ScopeProvider, AppCaches.Disabled, Logger, commonRepository);
                 var languageRepository = new LanguageRepository((IScopeAccessor) ScopeProvider, AppCaches.Disabled, Logger);
+                var contentTypeRepository = new ContentTypeRepository((IScopeAccessor) ScopeProvider, AppCaches.Disabled, Logger, commonRepository, languageRepository);
                 var contentRepo = new DocumentRepository((IScopeAccessor) ScopeProvider, AppCaches.Disabled, Logger, contentTypeRepository, templateRepository, tagRepository, languageRepository);
 
                 var contentType = MockedContentTypes.CreateSimpleContentType("umbTextpage2", "Textpage");

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

@@ -26,7 +26,8 @@ namespace Umbraco.Tests.Persistence.Repositories
             var accessor = (IScopeAccessor) provider;
             var templateRepository = new TemplateRepository(accessor, AppCaches.Disabled, Logger, TestObjects.GetFileSystemsMock());
             var commonRepository = new ContentTypeCommonRepository(accessor, templateRepository, AppCaches);
-            mediaTypeRepository = new MediaTypeRepository(accessor, AppCaches, Mock.Of<ILogger>(), commonRepository);
+            var languageRepository = new LanguageRepository(accessor, AppCaches, Logger);
+            mediaTypeRepository = new MediaTypeRepository(accessor, AppCaches, Mock.Of<ILogger>(), commonRepository, languageRepository);
             var tagRepository = new TagRepository(accessor, AppCaches, Mock.Of<ILogger>());
             var repository = new MediaRepository(accessor, AppCaches, Mock.Of<ILogger>(), mediaTypeRepository, tagRepository, Mock.Of<ILanguageRepository>());
             return repository;
@@ -44,8 +45,8 @@ namespace Umbraco.Tests.Persistence.Repositories
             templateRepository = new TemplateRepository(accessor, AppCaches, Logger, TestObjects.GetFileSystemsMock());
             var tagRepository = new TagRepository(accessor, AppCaches, Logger);
             var commonRepository = new ContentTypeCommonRepository(accessor, templateRepository, AppCaches);
-            contentTypeRepository = new ContentTypeRepository(accessor, AppCaches, Logger, commonRepository);
             var languageRepository = new LanguageRepository(accessor, AppCaches, Logger);
+            contentTypeRepository = new ContentTypeRepository(accessor, AppCaches, Logger, commonRepository, languageRepository);
             var repository = new DocumentRepository(accessor, AppCaches, Logger, contentTypeRepository, templateRepository, tagRepository, languageRepository);
             return repository;
         }

src/Umbraco.Tests/PublishedContent/NuCacheChildrenTests.cs

@@ -124,7 +124,7 @@ namespace Umbraco.Tests.PublishedContent
             _source = new TestDataSource(kits);
 
             // at last, create the complete NuCache snapshot service!
-            var options = new PublishedSnapshotService.Options { IgnoreLocalDb = true };
+            var options = new PublishedSnapshotServiceOptions { IgnoreLocalDb = true };
             _snapshotService = new PublishedSnapshotService(options,
                 null,
                 runtime,
@@ -151,117 +151,139 @@ namespace Umbraco.Tests.PublishedContent
             Mock.Get(factory).Setup(x => x.GetInstance(typeof(IVariationContextAccessor))).Returns(_variationAccesor);
         }
 
+        private IEnumerable<ContentNodeKit> GetNestedVariantKits()
+        {
+            var paths = new Dictionary<int, string> { { -1, "-1" } };
+
+            //1x variant (root)
+            yield return CreateVariantKit(1, -1, 1, paths);
+            
+            //1x invariant under root
+            yield return CreateInvariantKit(4, 1, 1, paths);
+
+            //1x variant under root
+            yield return CreateVariantKit(7, 1, 4, paths);
+
+            //2x mixed under invariant
+            yield return CreateVariantKit(10, 4, 1, paths);
+            yield return CreateInvariantKit(11, 4, 2, paths);
+
+            //2x mixed under variant
+            yield return CreateVariantKit(12, 7, 1, paths);
+            yield return CreateInvariantKit(13, 7, 2, paths);
+        }
+
         private IEnumerable<ContentNodeKit> GetInvariantKits()
         {
             var paths = new Dictionary<int, string> { { -1, "-1" } };
 
-            ContentNodeKit CreateKit(int id, int parentId, int sortOrder)
+            yield return CreateInvariantKit(1, -1, 1, paths);
+            yield return CreateInvariantKit(2, -1, 2, paths);
+            yield return CreateInvariantKit(3, -1, 3, paths);
+
+            yield return CreateInvariantKit(4, 1, 1, paths);
+            yield return CreateInvariantKit(5, 1, 2, paths);
+            yield return CreateInvariantKit(6, 1, 3, paths);
+
+            yield return CreateInvariantKit(7, 2, 3, paths);
+            yield return CreateInvariantKit(8, 2, 2, paths);
+            yield return CreateInvariantKit(9, 2, 1, paths);
+
+            yield return CreateInvariantKit(10, 3, 1, paths);
+
+            yield return CreateInvariantKit(11, 4, 1, paths);
+            yield return CreateInvariantKit(12, 4, 2, paths);
+        }
+
+        private ContentNodeKit CreateInvariantKit(int id, int parentId, int sortOrder, Dictionary<int, string> paths)
+        {
+            if (!paths.TryGetValue(parentId, out var parentPath))
+                throw new Exception("Unknown parent.");
+
+            var path = paths[id] = parentPath + "," + id;
+            var level = path.Count(x => x == ',');
+            var now = DateTime.Now;
+
+            return new ContentNodeKit
             {
-                if (!paths.TryGetValue(parentId, out var parentPath))
-                    throw new Exception("Unknown parent.");
-
-                var path = paths[id] = parentPath + "," + id;
-                var level = path.Count(x => x == ',');
-                var now = DateTime.Now;
-
-                return new ContentNodeKit
+                ContentTypeId = _contentTypeInvariant.Id,
+                Node = new ContentNode(id, Guid.NewGuid(), level, path, sortOrder, parentId, DateTime.Now, 0),
+                DraftData = null,
+                PublishedData = new ContentData
                 {
-                    ContentTypeId = _contentTypeInvariant.Id,
-                    Node = new ContentNode(id, Guid.NewGuid(), level, path, sortOrder, parentId, DateTime.Now, 0),
-                    DraftData = null,
-                    PublishedData = new ContentData
-                    {
-                        Name = "N" + id,
-                        Published = true,
-                        TemplateId = 0,
-                        VersionId = 1,
-                        VersionDate = now,
-                        WriterId = 0,
-                        Properties = new Dictionary<string, PropertyData[]>(),
-                        CultureInfos = new Dictionary<string, CultureVariation>()
-                    }
-                };
-            }
-
-            yield return CreateKit(1, -1, 1);
-            yield return CreateKit(2, -1, 2);
-            yield return CreateKit(3, -1, 3);
-
-            yield return CreateKit(4, 1, 1);
-            yield return CreateKit(5, 1, 2);
-            yield return CreateKit(6, 1, 3);
-
-            yield return CreateKit(7, 2, 3);
-            yield return CreateKit(8, 2, 2);
-            yield return CreateKit(9, 2, 1);
-
-            yield return CreateKit(10, 3, 1);
-
-            yield return CreateKit(11, 4, 1);
-            yield return CreateKit(12, 4, 2);
+                    Name = "N" + id,
+                    Published = true,
+                    TemplateId = 0,
+                    VersionId = 1,
+                    VersionDate = now,
+                    WriterId = 0,
+                    Properties = new Dictionary<string, PropertyData[]>(),
+                    CultureInfos = new Dictionary<string, CultureVariation>()
+                }
+            };
         }
 
         private IEnumerable<ContentNodeKit> GetVariantKits()
         {
             var paths = new Dictionary<int, string> { { -1, "-1" } };
 
-            Dictionary<string, CultureVariation> GetCultureInfos(int id, DateTime now)
+            yield return CreateVariantKit(1, -1, 1, paths);
+            yield return CreateVariantKit(2, -1, 2, paths);
+            yield return CreateVariantKit(3, -1, 3, paths);
+
+            yield return CreateVariantKit(4, 1, 1, paths);
+            yield return CreateVariantKit(5, 1, 2, paths);
+            yield return CreateVariantKit(6, 1, 3, paths);
+
+            yield return CreateVariantKit(7, 2, 3, paths);
+            yield return CreateVariantKit(8, 2, 2, paths);
+            yield return CreateVariantKit(9, 2, 1, paths);
+
+            yield return CreateVariantKit(10, 3, 1, paths);
+
+            yield return CreateVariantKit(11, 4, 1, paths);
+            yield return CreateVariantKit(12, 4, 2, paths);
+        }
+
+        private static Dictionary<string, CultureVariation> GetCultureInfos(int id, DateTime now)
+        {
+            var en = new[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 };
+            var fr = new[] { 1, 3, 4, 6, 7, 9, 10, 12 };
+
+            var infos = new Dictionary<string, CultureVariation>();
+            if (en.Contains(id))
+                infos["en-US"] = new CultureVariation { Name = "N" + id + "-" + "en-US", Date = now, IsDraft = false };
+            if (fr.Contains(id))
+                infos["fr-FR"] = new CultureVariation { Name = "N" + id + "-" + "fr-FR", Date = now, IsDraft = false };
+            return infos;
+        }
+
+        private ContentNodeKit CreateVariantKit(int id, int parentId, int sortOrder, Dictionary<int, string> paths)
+        {
+            if (!paths.TryGetValue(parentId, out var parentPath))
+                throw new Exception("Unknown parent.");
+
+            var path = paths[id] = parentPath + "," + id;
+            var level = path.Count(x => x == ',');
+            var now = DateTime.Now;
+
+            return new ContentNodeKit
             {
-                var en = new[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 };
-                var fr = new[] { 1, 3, 4, 6, 7, 9, 10, 12 };
-
-                var infos = new Dictionary<string, CultureVariation>();
-                if (en.Contains(id))
-                    infos["en-US"] = new CultureVariation { Name = "N" + id + "-" + "en-US", Date = now, IsDraft = false };
-                if (fr.Contains(id))
-                    infos["fr-FR"] = new CultureVariation { Name = "N" + id + "-" + "fr-FR", Date = now, IsDraft = false };
-                return infos;
-            }
-
-            ContentNodeKit CreateKit(int id, int parentId, int sortOrder)
-            {
-                if (!paths.TryGetValue(parentId, out var parentPath))
-                    throw new Exception("Unknown parent.");
-
-                var path = paths[id] = parentPath + "," + id;
-                var level = path.Count(x => x == ',');
-                var now = DateTime.Now;
-
-                return new ContentNodeKit
+                ContentTypeId = _contentTypeVariant.Id,
+                Node = new ContentNode(id, Guid.NewGuid(), level, path, sortOrder, parentId, DateTime.Now, 0),
+                DraftData = null,
+                PublishedData = new ContentData
                 {
-                    ContentTypeId = _contentTypeVariant.Id,
-                    Node = new ContentNode(id, Guid.NewGuid(), level, path, sortOrder, parentId, DateTime.Now, 0),
-                    DraftData = null,
-                    PublishedData = new ContentData
-                    {
-                        Name = "N" + id,
-                        Published = true,
-                        TemplateId = 0,
-                        VersionId = 1,
-                        VersionDate = now,
-                        WriterId = 0,
-                        Properties = new Dictionary<string, PropertyData[]>(),
-                        CultureInfos = GetCultureInfos(id, now)
-                    }
-                };
-            }
-
-            yield return CreateKit(1, -1, 1);
-            yield return CreateKit(2, -1, 2);
-            yield return CreateKit(3, -1, 3);
-
-            yield return CreateKit(4, 1, 1);
-            yield return CreateKit(5, 1, 2);
-            yield return CreateKit(6, 1, 3);
-
-            yield return CreateKit(7, 2, 3);
-            yield return CreateKit(8, 2, 2);
-            yield return CreateKit(9, 2, 1);
-
-            yield return CreateKit(10, 3, 1);
-
-            yield return CreateKit(11, 4, 1);
-            yield return CreateKit(12, 4, 2);
+                    Name = "N" + id,
+                    Published = true,
+                    TemplateId = 0,
+                    VersionId = 1,
+                    VersionDate = now,
+                    WriterId = 0,
+                    Properties = new Dictionary<string, PropertyData[]>(),
+                    CultureInfos = GetCultureInfos(id, now)
+                }
+            };
         }
 
         private IEnumerable<ContentNodeKit> GetVariantWithDraftKits()
@@ -660,6 +682,96 @@ namespace Umbraco.Tests.PublishedContent
             Assert.AreEqual(1, snapshot.Content.GetById(7).Parent?.Id);
         }
 
+        [Test]
+        public void NestedVariationChildrenTest()
+        {
+            var mixedKits = GetNestedVariantKits();
+            Init(mixedKits);
+
+            var snapshot = _snapshotService.CreatePublishedSnapshot(previewToken: null);
+            _snapshotAccessor.PublishedSnapshot = snapshot;
+
+            //TEST with en-us variation context
+
+            _variationAccesor.VariationContext = new VariationContext("en-US");
+
+            var documents = snapshot.Content.GetAtRoot().ToArray();
+            AssertDocuments(documents, "N1-en-US");
+
+            documents = snapshot.Content.GetById(1).Children().ToArray();
+            AssertDocuments(documents, "N4", "N7-en-US");
+
+            //Get the invariant and list children, there's a variation context so it should return invariant AND en-us variants
+            documents = snapshot.Content.GetById(4).Children().ToArray();
+            AssertDocuments(documents, "N10-en-US", "N11");
+
+            //Get the variant and list children, there's a variation context so it should return invariant AND en-us variants
+            documents = snapshot.Content.GetById(7).Children().ToArray();
+            AssertDocuments(documents, "N12-en-US", "N13");
+
+            //TEST with fr-fr variation context
+
+            _variationAccesor.VariationContext = new VariationContext("fr-FR");
+
+            documents = snapshot.Content.GetAtRoot().ToArray();
+            AssertDocuments(documents, "N1-fr-FR");
+
+            documents = snapshot.Content.GetById(1).Children().ToArray();
+            AssertDocuments(documents, "N4", "N7-fr-FR");
+
+            //Get the invariant and list children, there's a variation context so it should return invariant AND en-us variants
+            documents = snapshot.Content.GetById(4).Children().ToArray();
+            AssertDocuments(documents, "N10-fr-FR", "N11");
+
+            //Get the variant and list children, there's a variation context so it should return invariant AND en-us variants
+            documents = snapshot.Content.GetById(7).Children().ToArray();
+            AssertDocuments(documents, "N12-fr-FR", "N13");
+
+            //TEST specific cultures
+
+            documents = snapshot.Content.GetAtRoot("fr-FR").ToArray();
+            AssertDocuments(documents, "N1-fr-FR");
+
+            documents = snapshot.Content.GetById(1).Children("fr-FR").ToArray();
+            AssertDocuments(documents, "N4", "N7-fr-FR"); //NOTE: Returns invariant, this is expected
+            documents = snapshot.Content.GetById(1).Children("").ToArray();
+            AssertDocuments(documents, "N4"); //Only returns invariant since that is what was requested
+
+            documents = snapshot.Content.GetById(4).Children("fr-FR").ToArray();
+            AssertDocuments(documents, "N10-fr-FR", "N11"); //NOTE: Returns invariant, this is expected
+            documents = snapshot.Content.GetById(4).Children("").ToArray();
+            AssertDocuments(documents, "N11"); //Only returns invariant since that is what was requested
+
+            documents = snapshot.Content.GetById(7).Children("fr-FR").ToArray();
+            AssertDocuments(documents, "N12-fr-FR", "N13"); //NOTE: Returns invariant, this is expected
+            documents = snapshot.Content.GetById(7).Children("").ToArray();
+            AssertDocuments(documents, "N13"); //Only returns invariant since that is what was requested
+
+            //TEST without variation context
+            // This will actually convert the culture to "" which will be invariant since that's all it will know how to do
+            // This will return a NULL name for culture specific entities because there is no variation context
+
+            _variationAccesor.VariationContext = null;
+
+            documents = snapshot.Content.GetAtRoot().ToArray();
+            //will return nothing because there's only variant at root
+            Assert.AreEqual(0, documents.Length);
+            //so we'll continue to getting the known variant, do not fully assert this because the Name will NULL
+            documents = snapshot.Content.GetAtRoot("fr-FR").ToArray();
+            Assert.AreEqual(1, documents.Length);
+
+            documents = snapshot.Content.GetById(1).Children().ToArray();
+            AssertDocuments(documents, "N4");
+
+            //Get the invariant and list children
+            documents = snapshot.Content.GetById(4).Children().ToArray();
+            AssertDocuments(documents, "N11");
+
+            //Get the variant and list children
+            documents = snapshot.Content.GetById(7).Children().ToArray();
+            AssertDocuments(documents, "N13");
+        }
+
         [Test]
         public void VariantChildrenTest()
         {

src/Umbraco.Tests/PublishedContent/NuCacheTests.cs

@@ -169,7 +169,7 @@ namespace Umbraco.Tests.PublishedContent
             _variationAccesor = new TestVariationContextAccessor();
 
             // at last, create the complete NuCache snapshot service!
-            var options = new PublishedSnapshotService.Options { IgnoreLocalDb = true };
+            var options = new PublishedSnapshotServiceOptions { IgnoreLocalDb = true };
             _snapshotService = new PublishedSnapshotService(options,
                 null,
                 runtime,

src/Umbraco.Tests/Routing/MediaUrlProviderTests.cs

@@ -81,6 +81,19 @@ namespace Umbraco.Tests.Routing
             Assert.AreEqual(expected, resolvedUrl);
         }
 
+        [Test]
+        public void Get_Media_Url_Returns_Absolute_Url_If_Stored_Url_Is_Absolute()
+        {
+            const string expected = "http://localhost/media/rfeiw584/test.jpg";
+
+            var umbracoContext = GetUmbracoContext("http://localhost", mediaUrlProviders: new[] { _mediaUrlProvider });
+            var publishedContent = CreatePublishedContent(Constants.PropertyEditors.Aliases.UploadField, expected, null);
+
+            var resolvedUrl = umbracoContext.UrlProvider.GetMediaUrl(publishedContent, UrlMode.Relative);
+
+            Assert.AreEqual(expected, resolvedUrl);
+        }
+
         [Test]
         public void Get_Media_Url_Returns_Empty_String_When_PropertyType_Is_Not_Supported()
         {

src/Umbraco.Tests/Scoping/ScopedNuCacheTests.cs

@@ -72,7 +72,7 @@ namespace Umbraco.Tests.Scoping
 
         protected override IPublishedSnapshotService CreatePublishedSnapshotService()
         {
-            var options = new PublishedSnapshotService.Options { IgnoreLocalDb = true };
+            var options = new PublishedSnapshotServiceOptions { IgnoreLocalDb = true };
             var publishedSnapshotAccessor = new UmbracoContextPublishedSnapshotAccessor(Umbraco.Web.Composing.Current.UmbracoContextAccessor);
             var runtimeStateMock = new Mock<IRuntimeState>();
             runtimeStateMock.Setup(x => x.Level).Returns(() => RuntimeLevel.Run);

src/Umbraco.Tests/Security/UmbracoAntiForgeryAdditionalDataProviderTests.cs

@@ -1,157 +0,0 @@
-using System.Collections.Specialized;
-using System.Web;
-using System.Web.Helpers;
-using Moq;
-using Newtonsoft.Json;
-using NUnit.Framework;
-using Umbraco.Core;
-using Umbraco.Tests.TestHelpers;
-using Umbraco.Web.Mvc;
-using Umbraco.Web.Security;
-
-namespace Umbraco.Tests.Security
-{
-    [TestFixture]
-    public class UmbracoAntiForgeryAdditionalDataProviderTests
-    {
-        [Test]
-        public void Test_Wrapped_Non_BeginUmbracoForm()
-        {
-            var wrapped = Mock.Of<IAntiForgeryAdditionalDataProvider>(x => x.GetAdditionalData(It.IsAny<HttpContextBase>()) == "custom");
-            var provider = new UmbracoAntiForgeryAdditionalDataProvider(wrapped);
-
-            var httpContextFactory = new FakeHttpContextFactory("/hello/world");
-            var data = provider.GetAdditionalData(httpContextFactory.HttpContext);
-
-            Assert.IsTrue(data.DetectIsJson());
-            var json = JsonConvert.DeserializeObject<UmbracoAntiForgeryAdditionalDataProvider.AdditionalData>(data);
-            Assert.AreEqual(null, json.Ufprt);
-            Assert.IsTrue(json.Stamp != default);
-            Assert.AreEqual("custom", json.WrappedValue);
-        }
-
-        [Test]
-        public void Null_Wrapped_Non_BeginUmbracoForm()
-        {
-            var provider = new UmbracoAntiForgeryAdditionalDataProvider(null);
-
-            var httpContextFactory = new FakeHttpContextFactory("/hello/world");
-            var data = provider.GetAdditionalData(httpContextFactory.HttpContext);
-
-            Assert.IsTrue(data.DetectIsJson());
-            var json = JsonConvert.DeserializeObject<UmbracoAntiForgeryAdditionalDataProvider.AdditionalData>(data);
-            Assert.AreEqual(null, json.Ufprt);
-            Assert.IsTrue(json.Stamp != default);
-            Assert.AreEqual("default", json.WrappedValue);
-        }
-
-        [Test]
-        public void Validate_Non_Json()
-        {
-            var provider = new UmbracoAntiForgeryAdditionalDataProvider(null);
-
-            var httpContextFactory = new FakeHttpContextFactory("/hello/world");
-            var isValid = provider.ValidateAdditionalData(httpContextFactory.HttpContext, "hello");
-
-            Assert.IsFalse(isValid);
-        }
-
-        [Test]
-        public void Validate_Invalid_Json()
-        {
-            var provider = new UmbracoAntiForgeryAdditionalDataProvider(null);
-
-            var httpContextFactory = new FakeHttpContextFactory("/hello/world");
-            var isValid = provider.ValidateAdditionalData(httpContextFactory.HttpContext, "{'Stamp': '0'}");
-            Assert.IsFalse(isValid);
-
-            isValid = provider.ValidateAdditionalData(httpContextFactory.HttpContext, "{'Stamp': ''}");
-            Assert.IsFalse(isValid);
-
-            isValid = provider.ValidateAdditionalData(httpContextFactory.HttpContext, "{'hello': 'world'}");
-            Assert.IsFalse(isValid);
-
-        }
-
-        [Test]
-        public void Validate_No_Request_Ufprt()
-        {
-            var provider = new UmbracoAntiForgeryAdditionalDataProvider(null);
-
-            var httpContextFactory = new FakeHttpContextFactory("/hello/world");
-            //there is a ufprt in the additional data, but not in the request
-            var isValid = provider.ValidateAdditionalData(httpContextFactory.HttpContext, "{'Stamp': '636970328040070330', 'WrappedValue': 'default', 'Ufprt': 'ASBVDFDFDFDF'}");
-            Assert.IsFalse(isValid);
-        }
-
-        [Test]
-        public void Validate_No_AdditionalData_Ufprt()
-        {
-            var provider = new UmbracoAntiForgeryAdditionalDataProvider(null);
-
-            var httpContextFactory = new FakeHttpContextFactory("/hello/world");
-            var requestMock = Mock.Get(httpContextFactory.HttpContext.Request);
-            requestMock.SetupGet(x => x["ufprt"]).Returns("ABCDEFG");
-
-            //there is a ufprt in the additional data, but not in the request
-            var isValid = provider.ValidateAdditionalData(httpContextFactory.HttpContext, "{'Stamp': '636970328040070330', 'WrappedValue': 'default', 'Ufprt': ''}");
-            Assert.IsFalse(isValid);
-        }
-
-        [Test]
-        public void Validate_No_AdditionalData_Or_Request_Ufprt()
-        {
-            var provider = new UmbracoAntiForgeryAdditionalDataProvider(null);
-
-            var httpContextFactory = new FakeHttpContextFactory("/hello/world");
-            
-            //there is a ufprt in the additional data, but not in the request
-            var isValid = provider.ValidateAdditionalData(httpContextFactory.HttpContext, "{'Stamp': '636970328040070330', 'WrappedValue': 'default', 'Ufprt': ''}");
-            Assert.IsTrue(isValid);
-        }
-
-        [Test]
-        public void Validate_Request_And_AdditionalData_Ufprt()
-        {
-            var provider = new UmbracoAntiForgeryAdditionalDataProvider(null);
-
-            var routeParams1 = $"{RenderRouteHandler.ReservedAdditionalKeys.Controller}={HttpUtility.UrlEncode("Test")}&{RenderRouteHandler.ReservedAdditionalKeys.Action}={HttpUtility.UrlEncode("Index")}&{RenderRouteHandler.ReservedAdditionalKeys.Area}=Umbraco";
-            var routeParams2 = $"{RenderRouteHandler.ReservedAdditionalKeys.Controller}={HttpUtility.UrlEncode("Test")}&{RenderRouteHandler.ReservedAdditionalKeys.Action}={HttpUtility.UrlEncode("Index")}&{RenderRouteHandler.ReservedAdditionalKeys.Area}=Umbraco";
-
-            var httpContextFactory = new FakeHttpContextFactory("/hello/world");
-            var requestMock = Mock.Get(httpContextFactory.HttpContext.Request);
-            requestMock.SetupGet(x => x["ufprt"]).Returns(routeParams1.EncryptWithMachineKey());
-
-            var isValid = provider.ValidateAdditionalData(httpContextFactory.HttpContext, "{'Stamp': '636970328040070330', 'WrappedValue': 'default', 'Ufprt': '" + routeParams2.EncryptWithMachineKey() + "'}");
-            Assert.IsTrue(isValid);
-
-            routeParams2 = $"{RenderRouteHandler.ReservedAdditionalKeys.Controller}={HttpUtility.UrlEncode("Invalid")}&{RenderRouteHandler.ReservedAdditionalKeys.Action}={HttpUtility.UrlEncode("Index")}&{RenderRouteHandler.ReservedAdditionalKeys.Area}=Umbraco";
-            isValid = provider.ValidateAdditionalData(httpContextFactory.HttpContext, "{'Stamp': '636970328040070330', 'WrappedValue': 'default', 'Ufprt': '" + routeParams2.EncryptWithMachineKey() + "'}");
-            Assert.IsFalse(isValid);
-        }
-
-        [Test]
-        public void Validate_Wrapped_Request_And_AdditionalData_Ufprt()
-        {
-            var wrapped = Mock.Of<IAntiForgeryAdditionalDataProvider>(x => x.ValidateAdditionalData(It.IsAny<HttpContextBase>(), "custom") == true);
-            var provider = new UmbracoAntiForgeryAdditionalDataProvider(wrapped);
-
-            var routeParams1 = $"{RenderRouteHandler.ReservedAdditionalKeys.Controller}={HttpUtility.UrlEncode("Test")}&{RenderRouteHandler.ReservedAdditionalKeys.Action}={HttpUtility.UrlEncode("Index")}&{RenderRouteHandler.ReservedAdditionalKeys.Area}=Umbraco";
-            var routeParams2 = $"{RenderRouteHandler.ReservedAdditionalKeys.Controller}={HttpUtility.UrlEncode("Test")}&{RenderRouteHandler.ReservedAdditionalKeys.Action}={HttpUtility.UrlEncode("Index")}&{RenderRouteHandler.ReservedAdditionalKeys.Area}=Umbraco";
-
-            var httpContextFactory = new FakeHttpContextFactory("/hello/world");
-            var requestMock = Mock.Get(httpContextFactory.HttpContext.Request);
-            requestMock.SetupGet(x => x["ufprt"]).Returns(routeParams1.EncryptWithMachineKey());
-
-            var isValid = provider.ValidateAdditionalData(httpContextFactory.HttpContext, "{'Stamp': '636970328040070330', 'WrappedValue': 'default', 'Ufprt': '" + routeParams2.EncryptWithMachineKey() + "'}");
-            Assert.IsFalse(isValid);
-
-            isValid = provider.ValidateAdditionalData(httpContextFactory.HttpContext, "{'Stamp': '636970328040070330', 'WrappedValue': 'custom', 'Ufprt': '" + routeParams2.EncryptWithMachineKey() + "'}");
-            Assert.IsTrue(isValid);
-
-            routeParams2 = $"{RenderRouteHandler.ReservedAdditionalKeys.Controller}={HttpUtility.UrlEncode("Invalid")}&{RenderRouteHandler.ReservedAdditionalKeys.Action}={HttpUtility.UrlEncode("Index")}&{RenderRouteHandler.ReservedAdditionalKeys.Area}=Umbraco";
-            isValid = provider.ValidateAdditionalData(httpContextFactory.HttpContext, "{'Stamp': '636970328040070330', 'WrappedValue': 'default', 'Ufprt': '" + routeParams2.EncryptWithMachineKey() + "'}");
-            Assert.IsFalse(isValid);
-        }
-    }
-}

src/Umbraco.Tests/Services/ContentServicePerformanceTest.cs

@@ -166,8 +166,8 @@ namespace Umbraco.Tests.Services
                 var tRepository = new TemplateRepository((IScopeAccessor) provider, AppCaches.Disabled, Logger, TestObjects.GetFileSystemsMock());
                 var tagRepo = new TagRepository((IScopeAccessor) provider, AppCaches.Disabled, Logger);
                 var commonRepository = new ContentTypeCommonRepository((IScopeAccessor)provider, tRepository, AppCaches);
-                var ctRepository = new ContentTypeRepository((IScopeAccessor) provider, AppCaches.Disabled, Logger, commonRepository);
                 var languageRepository = new LanguageRepository((IScopeAccessor) provider, AppCaches.Disabled, Logger);
+                var ctRepository = new ContentTypeRepository((IScopeAccessor) provider, AppCaches.Disabled, Logger, commonRepository, languageRepository);
                 var repository = new DocumentRepository((IScopeAccessor) provider, AppCaches.Disabled, Logger, ctRepository, tRepository, tagRepo, languageRepository);
 
                 // Act
@@ -200,8 +200,8 @@ namespace Umbraco.Tests.Services
                 var tRepository = new TemplateRepository((IScopeAccessor) provider, AppCaches.Disabled, Logger, TestObjects.GetFileSystemsMock());
                 var tagRepo = new TagRepository((IScopeAccessor) provider, AppCaches.Disabled, Logger);
                 var commonRepository = new ContentTypeCommonRepository((IScopeAccessor)provider, tRepository, AppCaches);
-                var ctRepository = new ContentTypeRepository((IScopeAccessor) provider, AppCaches.Disabled, Logger, commonRepository);
                 var languageRepository = new LanguageRepository((IScopeAccessor) provider, AppCaches.Disabled, Logger);
+                var ctRepository = new ContentTypeRepository((IScopeAccessor) provider, AppCaches.Disabled, Logger, commonRepository, languageRepository);
                 var repository = new DocumentRepository((IScopeAccessor) provider, AppCaches.Disabled, Logger, ctRepository, tRepository, tagRepo, languageRepository);
 
                 // Act
@@ -232,8 +232,8 @@ namespace Umbraco.Tests.Services
                 var tRepository = new TemplateRepository((IScopeAccessor) provider, AppCaches.Disabled, Logger, TestObjects.GetFileSystemsMock());
                 var tagRepo = new TagRepository((IScopeAccessor) provider, AppCaches.Disabled, Logger);
                 var commonRepository = new ContentTypeCommonRepository((IScopeAccessor) provider, tRepository, AppCaches);
-                var ctRepository = new ContentTypeRepository((IScopeAccessor) provider, AppCaches.Disabled, Logger, commonRepository);
-                var languageRepository = new LanguageRepository((IScopeAccessor) provider, AppCaches.Disabled, Logger);
+                var languageRepository = new LanguageRepository((IScopeAccessor)provider, AppCaches.Disabled, Logger);
+                var ctRepository = new ContentTypeRepository((IScopeAccessor) provider, AppCaches.Disabled, Logger, commonRepository, languageRepository);
                 var repository = new DocumentRepository((IScopeAccessor) provider, AppCaches.Disabled, Logger, ctRepository, tRepository, tagRepo, languageRepository);
 
                 // Act
@@ -267,8 +267,8 @@ namespace Umbraco.Tests.Services
                 var tRepository = new TemplateRepository((IScopeAccessor) provider, AppCaches.Disabled, Logger, TestObjects.GetFileSystemsMock());
                 var tagRepo = new TagRepository((IScopeAccessor) provider, AppCaches.Disabled, Logger);
                 var commonRepository = new ContentTypeCommonRepository((IScopeAccessor)provider, tRepository, AppCaches);
-                var ctRepository = new ContentTypeRepository((IScopeAccessor) provider, AppCaches.Disabled, Logger, commonRepository);
-                var languageRepository = new LanguageRepository((IScopeAccessor) provider, AppCaches.Disabled, Logger);
+                var languageRepository = new LanguageRepository((IScopeAccessor)provider, AppCaches.Disabled, Logger);
+                var ctRepository = new ContentTypeRepository((IScopeAccessor) provider, AppCaches.Disabled, Logger, commonRepository, languageRepository);  
                 var repository = new DocumentRepository((IScopeAccessor) provider, AppCaches.Disabled, Logger, ctRepository, tRepository, tagRepo, languageRepository);
 
                 // Act

src/Umbraco.Tests/Services/ContentServiceTests.cs

@@ -717,21 +717,8 @@ namespace Umbraco.Tests.Services
         [Test]
         public void Can_Unpublish_Content_Variation()
         {
-            // Arrange
+            var content = CreateEnglishAndFrenchDocument(out var langUk, out var langFr, out var contentType);
 
-            var langUk = new Language("en-GB") { IsDefault = true };
-            var langFr = new Language("fr-FR");
-
-            ServiceContext.LocalizationService.Save(langFr);
-            ServiceContext.LocalizationService.Save(langUk);
-
-            var contentType = MockedContentTypes.CreateBasicContentType();
-            contentType.Variations = ContentVariation.Culture;
-            ServiceContext.ContentTypeService.Save(contentType);
-
-            IContent content = new Content("content", Constants.System.Root, contentType);
-            content.SetCultureName("content-fr", langFr.IsoCode);
-            content.SetCultureName("content-en", langUk.IsoCode);
             content.PublishCulture(CultureImpact.Explicit(langFr.IsoCode, langFr.IsDefault));
             content.PublishCulture(CultureImpact.Explicit(langUk.IsoCode, langUk.IsDefault));
             Assert.IsTrue(content.IsCulturePublished(langFr.IsoCode));
@@ -761,6 +748,185 @@ namespace Umbraco.Tests.Services
 
         }
 
+        [Test]
+        public void Can_Publish_Culture_After_Last_Culture_Unpublished()
+        {
+            var content = CreateEnglishAndFrenchDocument(out var langUk, out var langFr, out var contentType);
+
+            var published = ServiceContext.ContentService.SaveAndPublish(content, new[] { langFr.IsoCode, langUk.IsoCode });
+            Assert.AreEqual(PublishedState.Published, content.PublishedState);
+
+            //re-get
+            content = ServiceContext.ContentService.GetById(content.Id);
+
+            var unpublished = ServiceContext.ContentService.Unpublish(content, langUk.IsoCode); //first culture
+            Assert.IsTrue(unpublished.Success);
+            Assert.AreEqual(PublishResultType.SuccessUnpublishCulture, unpublished.Result);
+            Assert.IsFalse(content.IsCulturePublished(langUk.IsoCode));
+            Assert.IsTrue(content.IsCulturePublished(langFr.IsoCode));
+
+            content = ServiceContext.ContentService.GetById(content.Id);
+
+            unpublished = ServiceContext.ContentService.Unpublish(content, langFr.IsoCode); //last culture
+            Assert.IsTrue(unpublished.Success);
+            Assert.AreEqual(PublishResultType.SuccessUnpublishLastCulture, unpublished.Result);
+            Assert.IsFalse(content.IsCulturePublished(langFr.IsoCode));
+            Assert.IsFalse(content.IsCulturePublished(langUk.IsoCode));
+
+            content = ServiceContext.ContentService.GetById(content.Id);
+
+            published = ServiceContext.ContentService.SaveAndPublish(content, langUk.IsoCode);
+            Assert.AreEqual(PublishedState.Published, content.PublishedState);
+            Assert.IsTrue(content.IsCulturePublished(langUk.IsoCode));
+            Assert.IsFalse(content.IsCulturePublished(langFr.IsoCode));
+            
+            content = ServiceContext.ContentService.GetById(content.Id); //reget
+            Assert.AreEqual(PublishedState.Published, content.PublishedState);
+            Assert.IsTrue(content.IsCulturePublished(langUk.IsoCode));
+            Assert.IsFalse(content.IsCulturePublished(langFr.IsoCode));
+            
+        }
+
+        
+
+        [Test]
+        public void Unpublish_All_Cultures_Has_Unpublished_State()
+        {
+            var content = CreateEnglishAndFrenchDocument(out var langUk, out var langFr, out var contentType);
+
+            var published = ServiceContext.ContentService.SaveAndPublish(content, new[] { langFr.IsoCode, langUk.IsoCode });
+            Assert.IsTrue(content.IsCulturePublished(langFr.IsoCode));
+            Assert.IsTrue(content.IsCulturePublished(langUk.IsoCode));
+            Assert.IsTrue(published.Success);
+            Assert.AreEqual(PublishedState.Published, content.PublishedState);
+
+            //re-get
+            content = ServiceContext.ContentService.GetById(content.Id);
+            Assert.IsTrue(content.IsCulturePublished(langFr.IsoCode));
+            Assert.IsTrue(content.IsCulturePublished(langUk.IsoCode));
+            Assert.AreEqual(PublishedState.Published, content.PublishedState);
+
+            var unpublished = ServiceContext.ContentService.Unpublish(content, langFr.IsoCode); //first culture
+            Assert.IsTrue(unpublished.Success);
+            Assert.AreEqual(PublishResultType.SuccessUnpublishCulture, unpublished.Result);
+            Assert.IsFalse(content.IsCulturePublished(langFr.IsoCode));
+            Assert.IsTrue(content.IsCulturePublished(langUk.IsoCode));
+            Assert.AreEqual(PublishedState.Published, content.PublishedState); //still published
+
+            //re-get
+            content = ServiceContext.ContentService.GetById(content.Id);
+            Assert.IsFalse(content.IsCulturePublished(langFr.IsoCode));
+            Assert.IsTrue(content.IsCulturePublished(langUk.IsoCode));
+
+            unpublished = ServiceContext.ContentService.Unpublish(content, langUk.IsoCode); //last culture
+            Assert.IsTrue(unpublished.Success);
+            Assert.AreEqual(PublishResultType.SuccessUnpublishLastCulture, unpublished.Result);
+            Assert.IsFalse(content.IsCulturePublished(langFr.IsoCode));
+            Assert.IsFalse(content.IsCulturePublished(langUk.IsoCode));
+            Assert.AreEqual(PublishedState.Unpublished, content.PublishedState); //the last culture was unpublished so the document should also reflect this
+
+            //re-get
+            content = ServiceContext.ContentService.GetById(content.Id);
+            Assert.AreEqual(PublishedState.Unpublished, content.PublishedState); //just double checking
+            Assert.IsFalse(content.IsCulturePublished(langFr.IsoCode));          
+            Assert.IsFalse(content.IsCulturePublished(langUk.IsoCode));
+        }
+
+        [Test]
+        public void Unpublishing_Mandatory_Language_Unpublishes_Document()
+        {
+            var langUk = new Language("en-GB") { IsDefault = true, IsMandatory = true };
+            var langFr = new Language("fr-FR");
+
+            ServiceContext.LocalizationService.Save(langFr);
+            ServiceContext.LocalizationService.Save(langUk);
+
+            var contentType = MockedContentTypes.CreateBasicContentType();
+            contentType.Variations = ContentVariation.Culture;
+            ServiceContext.ContentTypeService.Save(contentType);
+
+            IContent content = new Content("content", Constants.System.Root, contentType);
+            content.SetCultureName("content-fr", langFr.IsoCode);
+            content.SetCultureName("content-en", langUk.IsoCode);
+
+            var published = ServiceContext.ContentService.SaveAndPublish(content, new[] { langFr.IsoCode, langUk.IsoCode });
+            Assert.IsTrue(content.IsCulturePublished(langFr.IsoCode));
+            Assert.IsTrue(content.IsCulturePublished(langUk.IsoCode));
+            Assert.IsTrue(published.Success);
+            Assert.AreEqual(PublishedState.Published, content.PublishedState);
+
+            //re-get
+            content = ServiceContext.ContentService.GetById(content.Id);
+            
+            var unpublished = ServiceContext.ContentService.Unpublish(content, langUk.IsoCode); //unpublish mandatory lang
+            Assert.IsTrue(unpublished.Success);
+            Assert.AreEqual(PublishResultType.SuccessUnpublishMandatoryCulture, unpublished.Result);            
+            Assert.IsFalse(content.IsCulturePublished(langUk.IsoCode));
+            Assert.IsTrue(content.IsCulturePublished(langFr.IsoCode)); //remains published
+            Assert.AreEqual(PublishedState.Unpublished, content.PublishedState); 
+        }
+
+        [Test]
+        public void Unpublishing_Already_Unpublished_Culture()
+        {
+            var content = CreateEnglishAndFrenchDocument(out var langUk, out var langFr, out var contentType);
+
+            var published = ServiceContext.ContentService.SaveAndPublish(content, new[] { langFr.IsoCode, langUk.IsoCode });
+            Assert.IsTrue(content.IsCulturePublished(langFr.IsoCode));
+            Assert.IsTrue(content.IsCulturePublished(langUk.IsoCode));
+            Assert.IsTrue(published.Success);
+            Assert.AreEqual(PublishedState.Published, content.PublishedState);
+
+            //re-get
+            content = ServiceContext.ContentService.GetById(content.Id);
+
+            var unpublished = ServiceContext.ContentService.Unpublish(content, langUk.IsoCode); 
+            Assert.IsTrue(unpublished.Success);
+            Assert.AreEqual(PublishResultType.SuccessUnpublishCulture, unpublished.Result);
+            Assert.IsFalse(content.IsCulturePublished(langUk.IsoCode));
+
+            content = ServiceContext.ContentService.GetById(content.Id);
+
+            //Change some data since Unpublish should always Save
+            content.SetCultureName("content-en-updated", langUk.IsoCode);
+
+            unpublished = ServiceContext.ContentService.Unpublish(content, langUk.IsoCode); //unpublish again
+            Assert.IsTrue(unpublished.Success);
+            Assert.AreEqual(PublishResultType.SuccessUnpublishAlready, unpublished.Result);
+            Assert.IsFalse(content.IsCulturePublished(langUk.IsoCode));
+
+            content = ServiceContext.ContentService.GetById(content.Id);
+            //ensure that even though the culture was already unpublished that the data was still persisted
+            Assert.AreEqual("content-en-updated", content.GetCultureName(langUk.IsoCode));
+        }
+
+        [Test]
+        public void Publishing_No_Cultures_Still_Saves()
+        {
+            var content = CreateEnglishAndFrenchDocument(out var langUk, out var langFr, out var contentType);
+
+            var published = ServiceContext.ContentService.SaveAndPublish(content, new[] { langFr.IsoCode, langUk.IsoCode });
+            Assert.IsTrue(content.IsCulturePublished(langFr.IsoCode));
+            Assert.IsTrue(content.IsCulturePublished(langUk.IsoCode));
+            Assert.IsTrue(published.Success);
+            Assert.AreEqual(PublishedState.Published, content.PublishedState);
+
+            //re-get
+            content = ServiceContext.ContentService.GetById(content.Id);
+
+            //Change some data since SaveAndPublish should always Save
+            content.SetCultureName("content-en-updated", langUk.IsoCode);
+
+            var saved = ServiceContext.ContentService.SaveAndPublish(content, new string [] { }); //save without cultures            
+            Assert.AreEqual(PublishResultType.FailedPublishNothingToPublish, saved.Result);
+
+            //re-get
+            content = ServiceContext.ContentService.GetById(content.Id);
+            //ensure that even though nothing was published that the data was still persisted
+            Assert.AreEqual("content-en-updated", content.GetCultureName(langUk.IsoCode));
+        }
+
+
         [Test]
         public void Pending_Invariant_Property_Changes_Affect_Default_Language_Edited_State()
         {
@@ -811,17 +977,7 @@ namespace Umbraco.Tests.Services
         [Test]
         public void Can_Publish_Content_Variation_And_Detect_Changed_Cultures()
         {
-            // Arrange
-
-            var langGB = new Language("en-GB") { IsDefault = true };
-            var langFr = new Language("fr-FR");
-
-            ServiceContext.LocalizationService.Save(langFr);
-            ServiceContext.LocalizationService.Save(langGB);
-
-            var contentType = MockedContentTypes.CreateBasicContentType();
-            contentType.Variations = ContentVariation.Culture;
-            ServiceContext.ContentTypeService.Save(contentType);
+            CreateEnglishAndFrenchDocumentType(out var langUk, out var langFr, out var contentType);
 
             IContent content = new Content("content", Constants.System.Root, contentType);
             content.SetCultureName("content-fr", langFr.IsoCode);
@@ -832,8 +988,8 @@ namespace Umbraco.Tests.Services
 
             //re-get
             content = ServiceContext.ContentService.GetById(content.Id);
-            content.SetCultureName("content-en", langGB.IsoCode);
-            published = ServiceContext.ContentService.SaveAndPublish(content, langGB.IsoCode);
+            content.SetCultureName("content-en", langUk.IsoCode);
+            published = ServiceContext.ContentService.SaveAndPublish(content, langUk.IsoCode);
             //audit log will only show that english was published
             lastLog = ServiceContext.AuditService.GetLogs(content.Id).Last();
             Assert.AreEqual($"Published languages: English (United Kingdom)", lastLog.Comment);
@@ -3008,10 +3164,33 @@ namespace Umbraco.Tests.Services
             var templateRepository = new TemplateRepository(accessor, AppCaches.Disabled, Logger, TestObjects.GetFileSystemsMock());
             var tagRepository = new TagRepository(accessor, AppCaches.Disabled, Logger);
             var commonRepository = new ContentTypeCommonRepository(accessor, templateRepository, AppCaches);
-            contentTypeRepository = new ContentTypeRepository(accessor, AppCaches.Disabled, Logger, commonRepository);
             var languageRepository = new LanguageRepository(accessor, AppCaches.Disabled, Logger);
+            contentTypeRepository = new ContentTypeRepository(accessor, AppCaches.Disabled, Logger, commonRepository, languageRepository);
             var repository = new DocumentRepository(accessor, AppCaches.Disabled, Logger, contentTypeRepository, templateRepository, tagRepository, languageRepository);
             return repository;
         }
+
+        private void CreateEnglishAndFrenchDocumentType(out Language langUk, out Language langFr, out ContentType contentType)
+        {
+            langUk = new Language("en-GB") { IsDefault = true };
+            langFr = new Language("fr-FR");
+            ServiceContext.LocalizationService.Save(langFr);
+            ServiceContext.LocalizationService.Save(langUk);
+
+            contentType = MockedContentTypes.CreateBasicContentType();
+            contentType.Variations = ContentVariation.Culture;
+            ServiceContext.ContentTypeService.Save(contentType);
+        }
+
+        private IContent CreateEnglishAndFrenchDocument(out Language langUk, out Language langFr, out ContentType contentType)
+        {
+            CreateEnglishAndFrenchDocumentType(out langUk, out langFr, out contentType);
+
+            IContent content = new Content("content", Constants.System.Root, contentType);
+            content.SetCultureName("content-fr", langFr.IsoCode);
+            content.SetCultureName("content-en", langUk.IsoCode);
+
+            return content;
+        }
     }
 }

src/Umbraco.Tests/Services/ContentTypeServiceTests.cs

@@ -53,360 +53,7 @@ namespace Umbraco.Tests.Services
             Assert.IsTrue(contentType.IsElement);
         }
 
-        [Test]
-        public void Change_Content_Type_Variation_Clears_Redirects()
-        {
-            //create content type with a property type that varies by culture
-            var contentType = MockedContentTypes.CreateBasicContentType();
-            contentType.Variations = ContentVariation.Nothing;
-            var contentCollection = new PropertyTypeCollection(true);
-            contentCollection.Add(new PropertyType("test", ValueStorageType.Ntext)
-            {
-                Alias = "title",
-                Name = "Title",
-                Description = "",
-                Mandatory = false,
-                SortOrder = 1,
-                DataTypeId = -88,
-                Variations = ContentVariation.Nothing
-            });
-            contentType.PropertyGroups.Add(new PropertyGroup(contentCollection) { Name = "Content", SortOrder = 1 });
-            ServiceContext.ContentTypeService.Save(contentType);
-            var contentType2 = MockedContentTypes.CreateBasicContentType("test");
-            ServiceContext.ContentTypeService.Save(contentType2);
-
-            //create some content of this content type
-            IContent doc = MockedContent.CreateBasicContent(contentType);
-            doc.Name = "Hello1";
-            ServiceContext.ContentService.Save(doc);
-
-            IContent doc2 = MockedContent.CreateBasicContent(contentType2);
-            ServiceContext.ContentService.Save(doc2);
-
-            ServiceContext.RedirectUrlService.Register("hello/world", doc.Key);
-            ServiceContext.RedirectUrlService.Register("hello2/world2", doc2.Key);
-
-            Assert.AreEqual(1, ServiceContext.RedirectUrlService.GetContentRedirectUrls(doc.Key).Count());
-            Assert.AreEqual(1, ServiceContext.RedirectUrlService.GetContentRedirectUrls(doc2.Key).Count());
-
-            //change variation
-            contentType.Variations = ContentVariation.Culture;
-            ServiceContext.ContentTypeService.Save(contentType);
-
-            Assert.AreEqual(0, ServiceContext.RedirectUrlService.GetContentRedirectUrls(doc.Key).Count());
-            Assert.AreEqual(1, ServiceContext.RedirectUrlService.GetContentRedirectUrls(doc2.Key).Count());
-
-        }
-
-        [Test]
-        public void Change_Content_Type_From_Invariant_Variant()
-        {
-            //create content type with a property type that varies by culture
-            var contentType = MockedContentTypes.CreateBasicContentType();
-            contentType.Variations = ContentVariation.Nothing;
-            var contentCollection = new PropertyTypeCollection(true);
-            contentCollection.Add(new PropertyType("test", ValueStorageType.Ntext)
-            {
-                Alias = "title",
-                Name = "Title",
-                Description = "",
-                Mandatory = false,
-                SortOrder = 1,
-                DataTypeId = -88,
-                Variations = ContentVariation.Nothing
-            });
-            contentType.PropertyGroups.Add(new PropertyGroup(contentCollection) { Name = "Content", SortOrder = 1 });
-            ServiceContext.ContentTypeService.Save(contentType);
-
-            //create some content of this content type
-            IContent doc = MockedContent.CreateBasicContent(contentType);
-            doc.Name = "Hello1";
-            doc.SetValue("title", "hello world");
-            ServiceContext.ContentService.Save(doc);
-
-            Assert.AreEqual("Hello1", doc.Name);
-            Assert.AreEqual("hello world", doc.GetValue("title"));
-
-            //change the content type to be variant, we will also update the name here to detect the copy changes
-            doc.Name = "Hello2";
-            ServiceContext.ContentService.Save(doc);
-            contentType.Variations = ContentVariation.Culture;
-            ServiceContext.ContentTypeService.Save(contentType);
-            doc = ServiceContext.ContentService.GetById(doc.Id); //re-get
-
-            Assert.AreEqual("Hello2", doc.GetCultureName("en-US"));
-            Assert.AreEqual("hello world", doc.GetValue("title")); //We are not checking against en-US here because properties will remain invariant
-
-            //change back property type to be invariant, we will also update the name here to detect the copy changes
-            doc.SetCultureName("Hello3", "en-US");
-            ServiceContext.ContentService.Save(doc);
-            contentType.Variations = ContentVariation.Nothing;
-            ServiceContext.ContentTypeService.Save(contentType);
-            doc = ServiceContext.ContentService.GetById(doc.Id); //re-get
-
-            Assert.AreEqual("Hello3", doc.Name);
-            Assert.AreEqual("hello world", doc.GetValue("title"));
-        }
-
-        [Test]
-        public void Change_Content_Type_From_Variant_Invariant()
-        {
-            //create content type with a property type that varies by culture
-            var contentType = MockedContentTypes.CreateBasicContentType();
-            contentType.Variations = ContentVariation.Culture;
-            var contentCollection = new PropertyTypeCollection(true);
-            contentCollection.Add(new PropertyType("test", ValueStorageType.Ntext)
-            {
-                Alias = "title",
-                Name = "Title",
-                Description = "",
-                Mandatory = false,
-                SortOrder = 1,
-                DataTypeId = -88,
-                Variations = ContentVariation.Culture
-            });
-            contentType.PropertyGroups.Add(new PropertyGroup(contentCollection) { Name = "Content", SortOrder = 1 });
-            ServiceContext.ContentTypeService.Save(contentType);
-
-            //create some content of this content type
-            IContent doc = MockedContent.CreateBasicContent(contentType);
-            doc.SetCultureName("Hello1", "en-US");
-            doc.SetValue("title", "hello world", "en-US");
-            ServiceContext.ContentService.Save(doc);
-
-            Assert.AreEqual("Hello1", doc.GetCultureName("en-US"));
-            Assert.AreEqual("hello world", doc.GetValue("title", "en-US"));
-
-            //change the content type to be invariant, we will also update the name here to detect the copy changes
-            doc.SetCultureName("Hello2", "en-US");
-            ServiceContext.ContentService.Save(doc);
-            contentType.Variations = ContentVariation.Nothing;
-            ServiceContext.ContentTypeService.Save(contentType);
-            doc = ServiceContext.ContentService.GetById(doc.Id); //re-get
-
-            Assert.AreEqual("Hello2", doc.Name);
-            Assert.AreEqual("hello world", doc.GetValue("title"));
-
-            //change back property type to be variant, we will also update the name here to detect the copy changes
-            doc.Name = "Hello3";
-            ServiceContext.ContentService.Save(doc);
-            contentType.Variations = ContentVariation.Culture;
-            ServiceContext.ContentTypeService.Save(contentType);
-            doc = ServiceContext.ContentService.GetById(doc.Id); //re-get
-
-            //at this stage all property types were switched to invariant so even though the variant value
-            //exists it will not be returned because the property type is invariant,
-            //so this check proves that null will be returned
-            Assert.IsNull(doc.GetValue("title", "en-US"));
-
-            //we can now switch the property type to be variant and the value can be returned again
-            contentType.PropertyTypes.First().Variations = ContentVariation.Culture;
-            ServiceContext.ContentTypeService.Save(contentType);
-            doc = ServiceContext.ContentService.GetById(doc.Id); //re-get
-
-            Assert.AreEqual("Hello3", doc.GetCultureName("en-US"));
-            Assert.AreEqual("hello world", doc.GetValue("title", "en-US"));
-
-        }
-
-        [Test]
-        public void Change_Property_Type_From_Invariant_Variant()
-        {
-            //create content type with a property type that varies by culture
-            var contentType = MockedContentTypes.CreateBasicContentType();
-            contentType.Variations = ContentVariation.Nothing;
-            var contentCollection = new PropertyTypeCollection(true);
-            contentCollection.Add(new PropertyType("test", ValueStorageType.Ntext)
-            {
-                Alias = "title",
-                Name = "Title",
-                Description = "",
-                Mandatory = false,
-                SortOrder = 1,
-                DataTypeId = -88,
-                Variations = ContentVariation.Nothing
-            });
-            contentType.PropertyGroups.Add(new PropertyGroup(contentCollection) { Name = "Content", SortOrder = 1 });
-            ServiceContext.ContentTypeService.Save(contentType);
-
-            //create some content of this content type
-            IContent doc = MockedContent.CreateBasicContent(contentType);
-            doc.Name = "Home";
-            doc.SetValue("title", "hello world");
-            ServiceContext.ContentService.Save(doc);
-
-            Assert.AreEqual("hello world", doc.GetValue("title"));
-
-            //change the property type to be variant
-            contentType.PropertyTypes.First().Variations = ContentVariation.Culture;
-            ServiceContext.ContentTypeService.Save(contentType);
-            doc = ServiceContext.ContentService.GetById(doc.Id); //re-get
-
-            Assert.AreEqual("hello world", doc.GetValue("title", "en-US"));
-
-            //change back property type to be invariant
-            contentType.PropertyTypes.First().Variations = ContentVariation.Nothing;
-            ServiceContext.ContentTypeService.Save(contentType);
-            doc = ServiceContext.ContentService.GetById(doc.Id); //re-get
-
-            Assert.AreEqual("hello world", doc.GetValue("title"));
-        }
-
-        [Test]
-        public void Change_Property_Type_From_Variant_Invariant()
-        {
-            //create content type with a property type that varies by culture
-            var contentType = MockedContentTypes.CreateBasicContentType();
-            contentType.Variations = ContentVariation.Culture;
-            var contentCollection = new PropertyTypeCollection(true);
-            contentCollection.Add(new PropertyType("test", ValueStorageType.Ntext)
-            {
-                Alias = "title",
-                Name = "Title",
-                Description = "",
-                Mandatory = false,
-                SortOrder = 1,
-                DataTypeId = -88,
-                Variations = ContentVariation.Culture
-            });
-            contentType.PropertyGroups.Add(new PropertyGroup(contentCollection) { Name = "Content", SortOrder = 1 });
-            ServiceContext.ContentTypeService.Save(contentType);
-
-            //create some content of this content type
-            IContent doc = MockedContent.CreateBasicContent(contentType);
-            doc.SetCultureName("Home", "en-US");
-            doc.SetValue("title", "hello world", "en-US");
-            ServiceContext.ContentService.Save(doc);
-
-            Assert.AreEqual("hello world", doc.GetValue("title", "en-US"));
-
-            //change the property type to be invariant
-            contentType.PropertyTypes.First().Variations = ContentVariation.Nothing;
-            ServiceContext.ContentTypeService.Save(contentType);
-            doc = ServiceContext.ContentService.GetById(doc.Id); //re-get
-
-            Assert.AreEqual("hello world", doc.GetValue("title"));
-
-            //change back property type to be variant
-            contentType.PropertyTypes.First().Variations = ContentVariation.Culture;
-            ServiceContext.ContentTypeService.Save(contentType);
-            doc = ServiceContext.ContentService.GetById(doc.Id); //re-get
-
-            Assert.AreEqual("hello world", doc.GetValue("title", "en-US"));
-        }
-
-        [Test]
-        public void Change_Property_Type_From_Variant_Invariant_On_A_Composition()
-        {
-            //create content type with a property type that varies by culture
-            var contentType = MockedContentTypes.CreateBasicContentType();
-            contentType.Variations = ContentVariation.Culture;
-            var contentCollection = new PropertyTypeCollection(true);
-            contentCollection.Add(new PropertyType("test", ValueStorageType.Ntext)
-            {
-                Alias = "title",
-                Name = "Title",
-                Description = "",
-                Mandatory = false,
-                SortOrder = 1,
-                DataTypeId = -88,
-                Variations = ContentVariation.Culture
-            });
-            contentType.PropertyGroups.Add(new PropertyGroup(contentCollection) { Name = "Content", SortOrder = 1 });
-            ServiceContext.ContentTypeService.Save(contentType);
-
-            //compose this from the other one
-            var contentType2 = MockedContentTypes.CreateBasicContentType("test");
-            contentType2.Variations = ContentVariation.Culture;
-            contentType2.AddContentType(contentType);
-            ServiceContext.ContentTypeService.Save(contentType2);
-
-            //create some content of this content type
-            IContent doc = MockedContent.CreateBasicContent(contentType);
-            doc.SetCultureName("Home", "en-US");
-            doc.SetValue("title", "hello world", "en-US");
-            ServiceContext.ContentService.Save(doc);
-
-            IContent doc2 = MockedContent.CreateBasicContent(contentType2);
-            doc2.SetCultureName("Home", "en-US");
-            doc2.SetValue("title", "hello world", "en-US");
-            ServiceContext.ContentService.Save(doc2);
-
-            //change the property type to be invariant
-            contentType.PropertyTypes.First().Variations = ContentVariation.Nothing;
-            ServiceContext.ContentTypeService.Save(contentType);
-            doc = ServiceContext.ContentService.GetById(doc.Id); //re-get
-            doc2 = ServiceContext.ContentService.GetById(doc2.Id); //re-get
-
-            Assert.AreEqual("hello world", doc.GetValue("title"));
-            Assert.AreEqual("hello world", doc2.GetValue("title"));
-
-            //change back property type to be variant
-            contentType.PropertyTypes.First().Variations = ContentVariation.Culture;
-            ServiceContext.ContentTypeService.Save(contentType);
-            doc = ServiceContext.ContentService.GetById(doc.Id); //re-get
-            doc2 = ServiceContext.ContentService.GetById(doc2.Id); //re-get
-
-            Assert.AreEqual("hello world", doc.GetValue("title", "en-US"));
-            Assert.AreEqual("hello world", doc2.GetValue("title", "en-US"));
-        }
-
-        [Test]
-        public void Change_Content_Type_From_Variant_Invariant_On_A_Composition()
-        {
-            //create content type with a property type that varies by culture
-            var contentType = MockedContentTypes.CreateBasicContentType();
-            contentType.Variations = ContentVariation.Culture;
-            var contentCollection = new PropertyTypeCollection(true);
-            contentCollection.Add(new PropertyType("test", ValueStorageType.Ntext)
-            {
-                Alias = "title",
-                Name = "Title",
-                Description = "",
-                Mandatory = false,
-                SortOrder = 1,
-                DataTypeId = -88,
-                Variations = ContentVariation.Culture
-            });
-            contentType.PropertyGroups.Add(new PropertyGroup(contentCollection) { Name = "Content", SortOrder = 1 });
-            ServiceContext.ContentTypeService.Save(contentType);
-
-            //compose this from the other one
-            var contentType2 = MockedContentTypes.CreateBasicContentType("test");
-            contentType2.Variations = ContentVariation.Culture;
-            contentType2.AddContentType(contentType);
-            ServiceContext.ContentTypeService.Save(contentType2);
-
-            //create some content of this content type
-            IContent doc = MockedContent.CreateBasicContent(contentType);
-            doc.SetCultureName("Home", "en-US");
-            doc.SetValue("title", "hello world", "en-US");
-            ServiceContext.ContentService.Save(doc);
-
-            IContent doc2 = MockedContent.CreateBasicContent(contentType2);
-            doc2.SetCultureName("Home", "en-US");
-            doc2.SetValue("title", "hello world", "en-US");
-            ServiceContext.ContentService.Save(doc2);
-
-            //change the content type to be invariant
-            contentType.Variations = ContentVariation.Nothing;
-            ServiceContext.ContentTypeService.Save(contentType);
-            doc = ServiceContext.ContentService.GetById(doc.Id); //re-get
-            doc2 = ServiceContext.ContentService.GetById(doc2.Id); //re-get
-
-            Assert.AreEqual("hello world", doc.GetValue("title"));
-            Assert.AreEqual("hello world", doc2.GetValue("title"));
-
-            //change back content type to be variant
-            contentType.Variations = ContentVariation.Culture;
-            ServiceContext.ContentTypeService.Save(contentType);
-            doc = ServiceContext.ContentService.GetById(doc.Id); //re-get
-            doc2 = ServiceContext.ContentService.GetById(doc2.Id); //re-get
-
-            //this will be null because the doc type was changed back to variant but it's property types don't get changed back
-            Assert.IsNull(doc.GetValue("title", "en-US"));
-            Assert.IsNull(doc2.GetValue("title", "en-US"));
-        }
+        
 
         [Test]
         public void Deleting_Content_Type_With_Hierarchy_Of_Content_Items_Moves_Orphaned_Content_To_Recycle_Bin()

src/Umbraco.Tests/Services/ContentTypeServiceVariantsTests.cs

@@ -17,6 +17,7 @@ using Umbraco.Core.PropertyEditors;
 using Umbraco.Core.Services;
 using Umbraco.Core.Strings;
 using Umbraco.Core.Sync;
+using Umbraco.Tests.TestHelpers.Entities;
 using Umbraco.Tests.Testing;
 using Umbraco.Web.PublishedCache;
 using Umbraco.Web.PublishedCache.NuCache;
@@ -42,7 +43,7 @@ namespace Umbraco.Tests.Services
 
         protected override IPublishedSnapshotService CreatePublishedSnapshotService()
         {
-            var options = new PublishedSnapshotService.Options { IgnoreLocalDb = true };
+            var options = new PublishedSnapshotServiceOptions { IgnoreLocalDb = true };
             var publishedSnapshotAccessor = new UmbracoContextPublishedSnapshotAccessor(Umbraco.Web.Composing.Current.UmbracoContextAccessor);
             var runtimeStateMock = new Mock<IRuntimeState>();
             runtimeStateMock.Setup(x => x.Level).Returns(() => RuntimeLevel.Run);
@@ -106,44 +107,346 @@ namespace Umbraco.Tests.Services
             }
         }
 
+        [Test]
+        public void Change_Content_Type_Variation_Clears_Redirects()
+        {
+            var contentType = MockedContentTypes.CreateBasicContentType();
+            contentType.Variations = ContentVariation.Nothing;
+            var properties = CreatePropertyCollection(("title", ContentVariation.Nothing));
+            contentType.PropertyGroups.Add(new PropertyGroup(properties) { Name = "Content" });
+            ServiceContext.ContentTypeService.Save(contentType);
+            var contentType2 = MockedContentTypes.CreateBasicContentType("test");
+            ServiceContext.ContentTypeService.Save(contentType2);
+
+            //create some content of this content type
+            IContent doc = MockedContent.CreateBasicContent(contentType);
+            doc.Name = "Hello1";
+            ServiceContext.ContentService.Save(doc);
+
+            IContent doc2 = MockedContent.CreateBasicContent(contentType2);
+            ServiceContext.ContentService.Save(doc2);
+
+            ServiceContext.RedirectUrlService.Register("hello/world", doc.Key);
+            ServiceContext.RedirectUrlService.Register("hello2/world2", doc2.Key);
+
+            Assert.AreEqual(1, ServiceContext.RedirectUrlService.GetContentRedirectUrls(doc.Key).Count());
+            Assert.AreEqual(1, ServiceContext.RedirectUrlService.GetContentRedirectUrls(doc2.Key).Count());
+
+            //change variation
+            contentType.Variations = ContentVariation.Culture;
+            ServiceContext.ContentTypeService.Save(contentType);
+
+            Assert.AreEqual(0, ServiceContext.RedirectUrlService.GetContentRedirectUrls(doc.Key).Count());
+            Assert.AreEqual(1, ServiceContext.RedirectUrlService.GetContentRedirectUrls(doc2.Key).Count());
+
+        }
+
+        [Test]
+        public void Change_Content_Type_From_Invariant_Variant()
+        {            
+            var contentType = MockedContentTypes.CreateBasicContentType();
+            contentType.Variations = ContentVariation.Nothing;
+            var properties = CreatePropertyCollection(("title", ContentVariation.Nothing));
+            contentType.PropertyGroups.Add(new PropertyGroup(properties) { Name = "Content" });
+            ServiceContext.ContentTypeService.Save(contentType);
+
+            //create some content of this content type
+            IContent doc = MockedContent.CreateBasicContent(contentType);
+            doc.Name = "Hello1";
+            doc.SetValue("title", "hello world");
+            ServiceContext.ContentService.Save(doc);
+
+            doc = ServiceContext.ContentService.GetById(doc.Id); //re-get
+
+            Assert.AreEqual("Hello1", doc.Name);
+            Assert.AreEqual("hello world", doc.GetValue("title"));
+            Assert.IsTrue(doc.Edited);
+            Assert.IsFalse (doc.IsCultureEdited("en-US"));
+
+            //change the content type to be variant, we will also update the name here to detect the copy changes
+            doc.Name = "Hello2";
+            ServiceContext.ContentService.Save(doc);
+            contentType.Variations = ContentVariation.Culture;
+            ServiceContext.ContentTypeService.Save(contentType);
+            doc = ServiceContext.ContentService.GetById(doc.Id); //re-get
+
+            Assert.AreEqual("Hello2", doc.GetCultureName("en-US"));
+            Assert.AreEqual("hello world", doc.GetValue("title")); //We are not checking against en-US here because properties will remain invariant
+            Assert.IsTrue(doc.Edited);
+            Assert.IsTrue(doc.IsCultureEdited("en-US"));
+
+            //change back property type to be invariant, we will also update the name here to detect the copy changes
+            doc.SetCultureName("Hello3", "en-US");
+            ServiceContext.ContentService.Save(doc);
+            contentType.Variations = ContentVariation.Nothing;
+            ServiceContext.ContentTypeService.Save(contentType);
+            doc = ServiceContext.ContentService.GetById(doc.Id); //re-get
+
+            Assert.AreEqual("Hello3", doc.Name);
+            Assert.AreEqual("hello world", doc.GetValue("title"));
+            Assert.IsTrue(doc.Edited);
+            Assert.IsFalse(doc.IsCultureEdited("en-US"));
+        }
+
+        [Test]
+        public void Change_Content_Type_From_Variant_Invariant()
+        {
+            var contentType = MockedContentTypes.CreateBasicContentType();
+            contentType.Variations = ContentVariation.Culture;
+            var properties = CreatePropertyCollection(("title", ContentVariation.Culture));
+            contentType.PropertyGroups.Add(new PropertyGroup(properties) { Name = "Content" });
+            ServiceContext.ContentTypeService.Save(contentType);
+
+            //create some content of this content type
+            IContent doc = MockedContent.CreateBasicContent(contentType);
+            doc.SetCultureName("Hello1", "en-US");
+            doc.SetValue("title", "hello world", "en-US");
+            ServiceContext.ContentService.Save(doc);
+
+            doc = ServiceContext.ContentService.GetById(doc.Id); //re-get
+            Assert.AreEqual("Hello1", doc.GetCultureName("en-US"));
+            Assert.AreEqual("hello world", doc.GetValue("title", "en-US"));
+            Assert.IsTrue(doc.Edited);
+            Assert.IsTrue(doc.IsCultureEdited("en-US"));
+
+            //change the content type to be invariant, we will also update the name here to detect the copy changes
+            doc.SetCultureName("Hello2", "en-US");
+            ServiceContext.ContentService.Save(doc);
+            contentType.Variations = ContentVariation.Nothing;
+            ServiceContext.ContentTypeService.Save(contentType);
+            doc = ServiceContext.ContentService.GetById(doc.Id); //re-get
+
+            Assert.AreEqual("Hello2", doc.Name);
+            Assert.AreEqual("hello world", doc.GetValue("title"));
+            Assert.IsTrue(doc.Edited);
+            Assert.IsFalse(doc.IsCultureEdited("en-US"));
+
+            //change back property type to be variant, we will also update the name here to detect the copy changes
+            doc.Name = "Hello3";
+            ServiceContext.ContentService.Save(doc);
+            contentType.Variations = ContentVariation.Culture;
+            ServiceContext.ContentTypeService.Save(contentType);
+            doc = ServiceContext.ContentService.GetById(doc.Id); //re-get
+
+            //at this stage all property types were switched to invariant so even though the variant value
+            //exists it will not be returned because the property type is invariant,
+            //so this check proves that null will be returned
+            Assert.IsNull(doc.GetValue("title", "en-US"));
+            Assert.IsTrue(doc.Edited);
+            Assert.IsTrue(doc.IsCultureEdited("en-US")); // this is true because the name change is copied to the default language
+
+            //we can now switch the property type to be variant and the value can be returned again
+            contentType.PropertyTypes.First().Variations = ContentVariation.Culture;
+            ServiceContext.ContentTypeService.Save(contentType);
+            doc = ServiceContext.ContentService.GetById(doc.Id); //re-get
+
+            Assert.AreEqual("Hello3", doc.GetCultureName("en-US"));
+            Assert.AreEqual("hello world", doc.GetValue("title", "en-US"));
+            Assert.IsTrue(doc.Edited);
+            Assert.IsTrue(doc.IsCultureEdited("en-US"));
+
+        }
+
+
+        [Test]
+        public void Change_Property_Type_From_To_Variant_On_Invariant_Content_Type()
+        {
+            var contentType = MockedContentTypes.CreateBasicContentType();
+            contentType.Variations = ContentVariation.Nothing;
+            var properties = CreatePropertyCollection(("title", ContentVariation.Nothing));
+            contentType.PropertyGroups.Add(new PropertyGroup(properties) { Name = "Content" });
+            ServiceContext.ContentTypeService.Save(contentType);
+
+            //change the property type to be variant
+            contentType.PropertyTypes.First().Variations = ContentVariation.Culture;
+
+            //Cannot change a property type to be variant if the content type itself is not variant
+            Assert.Throws<InvalidOperationException>(() => ServiceContext.ContentTypeService.Save(contentType));
+        }
+
+        [Test]
+        public void Change_Property_Type_From_Invariant_Variant()
+        {
+            var contentType = MockedContentTypes.CreateBasicContentType();
+            contentType.Variations = ContentVariation.Culture;
+            var properties = CreatePropertyCollection(("title", ContentVariation.Nothing));
+            contentType.PropertyGroups.Add(new PropertyGroup(properties) { Name = "Content" });
+            ServiceContext.ContentTypeService.Save(contentType);
+
+            //create some content of this content type
+            IContent doc = MockedContent.CreateBasicContent(contentType);
+            doc.SetCultureName("Home", "en-US");
+            doc.SetValue("title", "hello world");
+            ServiceContext.ContentService.Save(doc);
+
+            doc = ServiceContext.ContentService.GetById(doc.Id); //re-get
+            Assert.AreEqual("hello world", doc.GetValue("title"));
+            Assert.IsTrue(doc.IsCultureEdited("en-US")); //invariant prop changes show up on default lang
+            Assert.IsTrue(doc.Edited);
+            
+            //change the property type to be variant
+            contentType.PropertyTypes.First().Variations = ContentVariation.Culture;
+            ServiceContext.ContentTypeService.Save(contentType);
+            doc = ServiceContext.ContentService.GetById(doc.Id); //re-get
+
+            Assert.AreEqual("hello world", doc.GetValue("title", "en-US"));
+            Assert.IsTrue(doc.IsCultureEdited("en-US"));
+            Assert.IsTrue(doc.Edited);
+
+            //change back property type to be invariant
+            contentType.PropertyTypes.First().Variations = ContentVariation.Nothing;
+            ServiceContext.ContentTypeService.Save(contentType);
+            doc = ServiceContext.ContentService.GetById(doc.Id); //re-get
+
+            Assert.AreEqual("hello world", doc.GetValue("title"));
+            Assert.IsTrue(doc.IsCultureEdited("en-US"));  //invariant prop changes show up on default lang
+            Assert.IsTrue(doc.Edited);
+        }
+
+        [Test]
+        public void Change_Property_Type_From_Variant_Invariant()
+        {
+            //create content type with a property type that varies by culture
+            var contentType = MockedContentTypes.CreateBasicContentType();
+            contentType.Variations = ContentVariation.Culture;
+            var properties = CreatePropertyCollection(("title", ContentVariation.Culture));
+            contentType.PropertyGroups.Add(new PropertyGroup(properties) { Name = "Content" });
+            ServiceContext.ContentTypeService.Save(contentType);
+
+            //create some content of this content type
+            IContent doc = MockedContent.CreateBasicContent(contentType);
+            doc.SetCultureName("Home", "en-US");
+            doc.SetValue("title", "hello world", "en-US");
+            ServiceContext.ContentService.Save(doc);
+
+            Assert.AreEqual("hello world", doc.GetValue("title", "en-US"));
+
+            //change the property type to be invariant
+            contentType.PropertyTypes.First().Variations = ContentVariation.Nothing;
+            ServiceContext.ContentTypeService.Save(contentType);
+            doc = ServiceContext.ContentService.GetById(doc.Id); //re-get
+
+            Assert.AreEqual("hello world", doc.GetValue("title"));
+
+            //change back property type to be variant
+            contentType.PropertyTypes.First().Variations = ContentVariation.Culture;
+            ServiceContext.ContentTypeService.Save(contentType);
+            doc = ServiceContext.ContentService.GetById(doc.Id); //re-get
+
+            Assert.AreEqual("hello world", doc.GetValue("title", "en-US"));
+        }
+
+        [Test]
+        public void Change_Property_Type_From_Variant_Invariant_On_A_Composition()
+        {
+            //create content type with a property type that varies by culture
+            var contentType = MockedContentTypes.CreateBasicContentType();
+            contentType.Variations = ContentVariation.Culture;
+            var properties = CreatePropertyCollection(("title", ContentVariation.Culture));
+            contentType.PropertyGroups.Add(new PropertyGroup(properties) { Name = "Content" });
+            ServiceContext.ContentTypeService.Save(contentType);
+
+            //compose this from the other one
+            var contentType2 = MockedContentTypes.CreateBasicContentType("test");
+            contentType2.Variations = ContentVariation.Culture;
+            contentType2.AddContentType(contentType);
+            ServiceContext.ContentTypeService.Save(contentType2);
+
+            //create some content of this content type
+            IContent doc = MockedContent.CreateBasicContent(contentType);
+            doc.SetCultureName("Home", "en-US");
+            doc.SetValue("title", "hello world", "en-US");
+            ServiceContext.ContentService.Save(doc);
+
+            IContent doc2 = MockedContent.CreateBasicContent(contentType2);
+            doc2.SetCultureName("Home", "en-US");
+            doc2.SetValue("title", "hello world", "en-US");
+            ServiceContext.ContentService.Save(doc2);
+
+            //change the property type to be invariant
+            contentType.PropertyTypes.First().Variations = ContentVariation.Nothing;
+            ServiceContext.ContentTypeService.Save(contentType);
+            doc = ServiceContext.ContentService.GetById(doc.Id); //re-get
+            doc2 = ServiceContext.ContentService.GetById(doc2.Id); //re-get
+
+            Assert.AreEqual("hello world", doc.GetValue("title"));
+            Assert.AreEqual("hello world", doc2.GetValue("title"));
+
+            //change back property type to be variant
+            contentType.PropertyTypes.First().Variations = ContentVariation.Culture;
+            ServiceContext.ContentTypeService.Save(contentType);
+            doc = ServiceContext.ContentService.GetById(doc.Id); //re-get
+            doc2 = ServiceContext.ContentService.GetById(doc2.Id); //re-get
+
+            Assert.AreEqual("hello world", doc.GetValue("title", "en-US"));
+            Assert.AreEqual("hello world", doc2.GetValue("title", "en-US"));
+        }
+
+        [Test]
+        public void Change_Content_Type_From_Variant_Invariant_On_A_Composition()
+        {
+            //create content type with a property type that varies by culture
+            var contentType = MockedContentTypes.CreateBasicContentType();
+            contentType.Variations = ContentVariation.Culture;
+            var properties = CreatePropertyCollection(("title", ContentVariation.Culture));
+            contentType.PropertyGroups.Add(new PropertyGroup(properties) { Name = "Content" });
+            ServiceContext.ContentTypeService.Save(contentType);
+
+            //compose this from the other one
+            var contentType2 = MockedContentTypes.CreateBasicContentType("test");
+            contentType2.Variations = ContentVariation.Culture;
+            contentType2.AddContentType(contentType);
+            ServiceContext.ContentTypeService.Save(contentType2);
+
+            //create some content of this content type
+            IContent doc = MockedContent.CreateBasicContent(contentType);
+            doc.SetCultureName("Home", "en-US");
+            doc.SetValue("title", "hello world", "en-US");
+            ServiceContext.ContentService.Save(doc);
+
+            IContent doc2 = MockedContent.CreateBasicContent(contentType2);
+            doc2.SetCultureName("Home", "en-US");
+            doc2.SetValue("title", "hello world", "en-US");
+            ServiceContext.ContentService.Save(doc2);
+
+            //change the content type to be invariant
+            contentType.Variations = ContentVariation.Nothing;
+            ServiceContext.ContentTypeService.Save(contentType);
+            doc = ServiceContext.ContentService.GetById(doc.Id); //re-get
+            doc2 = ServiceContext.ContentService.GetById(doc2.Id); //re-get
+
+            Assert.AreEqual("hello world", doc.GetValue("title"));
+            Assert.AreEqual("hello world", doc2.GetValue("title"));
+
+            //change back content type to be variant
+            contentType.Variations = ContentVariation.Culture;
+            ServiceContext.ContentTypeService.Save(contentType);
+            doc = ServiceContext.ContentService.GetById(doc.Id); //re-get
+            doc2 = ServiceContext.ContentService.GetById(doc2.Id); //re-get
+
+            //this will be null because the doc type was changed back to variant but it's property types don't get changed back
+            Assert.IsNull(doc.GetValue("title", "en-US"));
+            Assert.IsNull(doc2.GetValue("title", "en-US"));
+        }
+
         [Test]
         public void Change_Variations_SimpleContentType_VariantToInvariantAndBack()
         {
             // one simple content type, variant, with both variant and invariant properties
             // can change it to invariant and back
 
-            var languageEn = new Language("en") { IsDefault = true };
-            ServiceContext.LocalizationService.Save(languageEn);
-            var languageFr = new Language("fr");
-            ServiceContext.LocalizationService.Save(languageFr);
+            CreateFrenchAndEnglishLangs();
 
-            var contentType = new ContentType(-1)
-            {
-                Alias = "contentType",
-                Name = "contentType",
-                Variations = ContentVariation.Culture
-            };
+            var contentType = CreateContentType(ContentVariation.Culture);
 
-            var properties = new PropertyTypeCollection(true)
-            {
-                new PropertyType("value1", ValueStorageType.Ntext)
-                {
-                    Alias = "value1",
-                    DataTypeId = -88,
-                    Variations = ContentVariation.Culture
-                },
-                new PropertyType("value2", ValueStorageType.Ntext)
-                {
-                    Alias = "value2",
-                    DataTypeId = -88,
-                    Variations = ContentVariation.Nothing
-                }
-            };
+            var properties = CreatePropertyCollection(
+                ("value1", ContentVariation.Culture),
+                ("value2", ContentVariation.Nothing));
 
             contentType.PropertyGroups.Add(new PropertyGroup(properties) { Name = "Content" });
             ServiceContext.ContentTypeService.Save(contentType);
 
-            var document = (IContent) new Content("document", -1, contentType);
+            var document = (IContent)new Content("document", -1, contentType);
             document.SetCultureName("doc1en", "en");
             document.SetCultureName("doc1fr", "fr");
             document.SetValue("value1", "v1en", "en");
@@ -226,28 +529,11 @@ namespace Umbraco.Tests.Services
             var languageFr = new Language("fr");
             ServiceContext.LocalizationService.Save(languageFr);
 
-            var contentType = new ContentType(-1)
-            {
-                Alias = "contentType",
-                Name = "contentType",
-                Variations = ContentVariation.Nothing
-            };
+            var contentType = CreateContentType(ContentVariation.Nothing);
 
-            var properties = new PropertyTypeCollection(true)
-            {
-                new PropertyType("value1", ValueStorageType.Ntext)
-                {
-                    Alias = "value1",
-                    DataTypeId = -88,
-                    Variations = ContentVariation.Nothing
-                },
-                new PropertyType("value2", ValueStorageType.Ntext)
-                {
-                    Alias = "value2",
-                    DataTypeId = -88,
-                    Variations = ContentVariation.Nothing
-                }
-            };
+            var properties = CreatePropertyCollection(
+                ("value1", ContentVariation.Nothing),
+                ("value2", ContentVariation.Nothing));
 
             contentType.PropertyGroups.Add(new PropertyGroup(properties) { Name = "Content" });
             ServiceContext.ContentTypeService.Save(contentType);
@@ -326,33 +612,13 @@ namespace Umbraco.Tests.Services
             // one simple content type, variant, with both variant and invariant properties
             // can change an invariant property to variant and back
 
-            var languageEn = new Language("en") { IsDefault = true };
-            ServiceContext.LocalizationService.Save(languageEn);
-            var languageFr = new Language("fr");
-            ServiceContext.LocalizationService.Save(languageFr);
+            CreateFrenchAndEnglishLangs();
 
-            var contentType = new ContentType(-1)
-            {
-                Alias = "contentType",
-                Name = "contentType",
-                Variations = ContentVariation.Culture
-            };
+            var contentType = CreateContentType(ContentVariation.Culture);
 
-            var properties = new PropertyTypeCollection(true)
-            {
-                new PropertyType("value1", ValueStorageType.Ntext)
-                {
-                    Alias = "value1",
-                    DataTypeId = -88,
-                    Variations = ContentVariation.Culture
-                },
-                new PropertyType("value2", ValueStorageType.Ntext)
-                {
-                    Alias = "value2",
-                    DataTypeId = -88,
-                    Variations = ContentVariation.Nothing
-                }
-            };
+            var properties = CreatePropertyCollection(
+                ("value1", ContentVariation.Culture),
+                ("value2", ContentVariation.Nothing));
 
             contentType.PropertyGroups.Add(new PropertyGroup(properties) { Name = "Content" });
             ServiceContext.ContentTypeService.Save(contentType);
@@ -429,6 +695,185 @@ namespace Umbraco.Tests.Services
                 "{'properties':{'value1':[{'culture':'en','seg':'','val':'v1en'},{'culture':'fr','seg':'','val':'v1fr'}],'value2':[{'culture':'en','seg':'','val':'v2'}]},'cultureData':");
         }
 
+        [Test]
+        public void Change_Property_Variations_From_Variant_To_Invariant_And_Ensure_Edited_Values_Are_Renormalized()
+        {
+            // one simple content type, variant, with both variant and invariant properties
+            // can change an invariant property to variant and back
+
+            CreateFrenchAndEnglishLangs();
+
+            var contentType = CreateContentType(ContentVariation.Culture);
+
+            var properties = CreatePropertyCollection(("value1", ContentVariation.Culture));
+
+            contentType.PropertyGroups.Add(new PropertyGroup(properties) { Name = "Content" });
+            ServiceContext.ContentTypeService.Save(contentType);
+
+            var document = (IContent)new Content("document", -1, contentType);
+            document.SetCultureName("doc1en", "en");
+            document.SetCultureName("doc1fr", "fr");
+            document.SetValue("value1", "v1en-init", "en");
+            document.SetValue("value1", "v1fr-init", "fr");
+            ServiceContext.ContentService.SaveAndPublish(document); //all values are published which means the document is not 'edited'
+
+            document = ServiceContext.ContentService.GetById(document.Id);
+            Assert.IsFalse(document.IsCultureEdited("en"));
+            Assert.IsFalse(document.IsCultureEdited("fr"));
+            Assert.IsFalse(document.Edited);
+
+            document.SetValue("value1", "v1en", "en"); //change the property culture value, so now this culture will be edited
+            document.SetValue("value1", "v1fr", "fr"); //change the property culture value, so now this culture will be edited
+            ServiceContext.ContentService.Save(document);
+
+            document = ServiceContext.ContentService.GetById(document.Id);
+            Assert.AreEqual("doc1en", document.Name);
+            Assert.AreEqual("doc1en", document.GetCultureName("en"));
+            Assert.AreEqual("doc1fr", document.GetCultureName("fr"));
+            Assert.AreEqual("v1en", document.GetValue("value1", "en"));
+            Assert.AreEqual("v1en-init", document.GetValue("value1", "en", published: true));
+            Assert.AreEqual("v1fr", document.GetValue("value1", "fr"));
+            Assert.AreEqual("v1fr-init", document.GetValue("value1", "fr", published: true));
+            Assert.IsTrue(document.IsCultureEdited("en")); //This will be true because the edited value isn't the same as the published value
+            Assert.IsTrue(document.IsCultureEdited("fr")); //This will be true because the edited value isn't the same as the published value
+            Assert.IsTrue(document.Edited);
+
+            // switch property type to Invariant
+            contentType.PropertyTypes.First(x => x.Alias == "value1").Variations = ContentVariation.Nothing;
+            ServiceContext.ContentTypeService.Save(contentType); //This is going to have to re-normalize the "Edited" flag
+            
+            document = ServiceContext.ContentService.GetById(document.Id);
+            Assert.IsTrue(document.IsCultureEdited("en")); //This will remain true because there is now a pending change for the invariant property data which is flagged under the default lang
+            Assert.IsFalse(document.IsCultureEdited("fr")); //This will be false because nothing has changed for this culture and the property no longer reflects variant changes
+            Assert.IsTrue(document.Edited);
+
+            //update the invariant value and publish
+            document.SetValue("value1", "v1inv"); 
+            ServiceContext.ContentService.SaveAndPublish(document);
+
+            document = ServiceContext.ContentService.GetById(document.Id);
+            Assert.AreEqual("doc1en", document.Name);
+            Assert.AreEqual("doc1en", document.GetCultureName("en"));
+            Assert.AreEqual("doc1fr", document.GetCultureName("fr"));
+            Assert.IsNull(document.GetValue("value1", "en")); //The values are there but the business logic returns null
+            Assert.IsNull(document.GetValue("value1", "fr")); //The values are there but the business logic returns null
+            Assert.IsNull(document.GetValue("value1", "en", published: true)); //The values are there but the business logic returns null
+            Assert.IsNull(document.GetValue("value1", "fr", published: true)); //The values are there but the business logic returns null
+            Assert.AreEqual("v1inv", document.GetValue("value1"));
+            Assert.AreEqual("v1inv", document.GetValue("value1", published: true));
+            Assert.IsFalse(document.IsCultureEdited("en")); //This returns false, everything is published
+            Assert.IsFalse(document.IsCultureEdited("fr")); //This will be false because nothing has changed for this culture and the property no longer reflects variant changes
+            Assert.IsFalse(document.Edited);
+
+            // switch property back to Culture
+            contentType.PropertyTypes.First(x => x.Alias == "value1").Variations = ContentVariation.Culture;
+            ServiceContext.ContentTypeService.Save(contentType);
+                        
+            document = ServiceContext.ContentService.GetById(document.Id);
+            Assert.AreEqual("v1inv", document.GetValue("value1", "en")); //The invariant property value gets copied over to the default language
+            Assert.AreEqual("v1inv", document.GetValue("value1", "en", published: true));
+            Assert.AreEqual("v1fr", document.GetValue("value1", "fr")); //values are still retained
+            Assert.AreEqual("v1fr-init", document.GetValue("value1", "fr", published: true)); //values are still retained
+            Assert.IsFalse(document.IsCultureEdited("en")); //The invariant published AND edited values are copied over to the default language
+            Assert.IsTrue(document.IsCultureEdited("fr"));  //The previously existing french values are there and there is no published value
+            Assert.IsTrue(document.Edited); //Will be flagged edited again because the french culture had pending changes
+
+            // publish again
+            document.SetValue("value1", "v1en2", "en"); //update the value now that it's variant again
+            document.SetValue("value1", "v1fr2", "fr"); //update the value now that it's variant again
+            ServiceContext.ContentService.SaveAndPublish(document);
+
+            document = ServiceContext.ContentService.GetById(document.Id);
+            Assert.AreEqual("doc1en", document.Name);
+            Assert.AreEqual("doc1en", document.GetCultureName("en"));
+            Assert.AreEqual("doc1fr", document.GetCultureName("fr"));
+            Assert.AreEqual("v1en2", document.GetValue("value1", "en"));
+            Assert.AreEqual("v1fr2", document.GetValue("value1", "fr"));
+            Assert.IsNull(document.GetValue("value1")); //The value is there but the business logic returns null
+            Assert.IsFalse(document.IsCultureEdited("en")); //This returns false, the variant property value has been published
+            Assert.IsFalse(document.IsCultureEdited("fr")); //This returns false, the variant property value has been published
+            Assert.IsFalse(document.Edited);
+        }
+
+        [Test]
+        public void Change_Property_Variations_From_Invariant_To_Variant_And_Ensure_Edited_Values_Are_Renormalized()
+        {
+            // one simple content type, variant, with both variant and invariant properties
+            // can change an invariant property to variant and back
+
+            CreateFrenchAndEnglishLangs();
+
+            var contentType = CreateContentType(ContentVariation.Culture);
+
+            var properties = CreatePropertyCollection(("value1", ContentVariation.Nothing));
+
+            contentType.PropertyGroups.Add(new PropertyGroup(properties) { Name = "Content" });
+            ServiceContext.ContentTypeService.Save(contentType);
+
+            var document = (IContent)new Content("document", -1, contentType);
+            document.SetCultureName("doc1en", "en");
+            document.SetCultureName("doc1fr", "fr");
+            document.SetValue("value1", "v1en-init");
+            ServiceContext.ContentService.SaveAndPublish(document); //all values are published which means the document is not 'edited'
+
+            document = ServiceContext.ContentService.GetById(document.Id);
+            Assert.IsFalse(document.IsCultureEdited("en"));
+            Assert.IsFalse(document.IsCultureEdited("fr"));
+            Assert.IsFalse(document.Edited);
+
+            document.SetValue("value1", "v1en"); //change the property value, so now the invariant (default) culture will be edited
+            ServiceContext.ContentService.Save(document);
+
+            document = ServiceContext.ContentService.GetById(document.Id);
+            Assert.AreEqual("doc1en", document.Name);
+            Assert.AreEqual("doc1en", document.GetCultureName("en"));
+            Assert.AreEqual("doc1fr", document.GetCultureName("fr"));
+            Assert.AreEqual("v1en", document.GetValue("value1"));
+            Assert.AreEqual("v1en-init", document.GetValue("value1", published: true));            
+            Assert.IsTrue(document.IsCultureEdited("en")); //This is true because the invariant property reflects changes on the default lang
+            Assert.IsFalse(document.IsCultureEdited("fr")); 
+            Assert.IsTrue(document.Edited);
+
+            // switch property type to Culture
+            contentType.PropertyTypes.First(x => x.Alias == "value1").Variations = ContentVariation.Culture;
+            ServiceContext.ContentTypeService.Save(contentType); //This is going to have to re-normalize the "Edited" flag
+
+            document = ServiceContext.ContentService.GetById(document.Id);
+            Assert.IsTrue(document.IsCultureEdited("en")); //Remains true 
+            Assert.IsFalse(document.IsCultureEdited("fr")); //False because no french property has ever been edited
+            Assert.IsTrue(document.Edited);
+
+            //update the culture value and publish
+            document.SetValue("value1", "v1en2", "en");
+            ServiceContext.ContentService.SaveAndPublish(document);
+
+            document = ServiceContext.ContentService.GetById(document.Id);
+            Assert.AreEqual("doc1en", document.Name);
+            Assert.AreEqual("doc1en", document.GetCultureName("en"));
+            Assert.AreEqual("doc1fr", document.GetCultureName("fr"));
+            Assert.IsNull(document.GetValue("value1")); //The values are there but the business logic returns null
+            Assert.IsNull(document.GetValue("value1", published: true)); //The values are there but the business logic returns null
+            Assert.AreEqual("v1en2", document.GetValue("value1", "en"));
+            Assert.AreEqual("v1en2", document.GetValue("value1", "en", published: true));
+            Assert.IsFalse(document.IsCultureEdited("en")); //This returns false, everything is published
+            Assert.IsFalse(document.IsCultureEdited("fr")); //False because no french property has ever been edited
+            Assert.IsFalse(document.Edited);
+
+            // switch property back to Invariant
+            contentType.PropertyTypes.First(x => x.Alias == "value1").Variations = ContentVariation.Nothing;
+            ServiceContext.ContentTypeService.Save(contentType);
+
+            document = ServiceContext.ContentService.GetById(document.Id);
+            Assert.AreEqual("v1en2", document.GetValue("value1")); //The variant property value gets copied over to the invariant
+            Assert.AreEqual("v1en2", document.GetValue("value1", published: true));
+            Assert.IsNull(document.GetValue("value1", "fr"));  //The values are there but the business logic returns null
+            Assert.IsNull(document.GetValue("value1", "fr", published: true));  //The values are there but the business logic returns null
+            Assert.IsFalse(document.IsCultureEdited("en")); //The variant published AND edited values are copied over to the invariant
+            Assert.IsFalse(document.IsCultureEdited("fr"));  
+            Assert.IsFalse(document.Edited);
+
+        }
+
         [Test]
         public void Change_Variations_ComposedContentType_1()
         {
@@ -437,59 +882,22 @@ namespace Umbraco.Tests.Services
             // can change the composing content type to invariant and back
             // can change the composed content type to invariant and back
 
-            var languageEn = new Language("en") { IsDefault = true };
-            ServiceContext.LocalizationService.Save(languageEn);
-            var languageFr = new Language("fr");
-            ServiceContext.LocalizationService.Save(languageFr);
+            CreateFrenchAndEnglishLangs();
 
-            var composing = new ContentType(-1)
-            {
-                Alias = "composing",
-                Name = "composing",
-                Variations = ContentVariation.Culture
-            };
+            var composing = CreateContentType(ContentVariation.Culture, "composing");
 
-            var properties1 = new PropertyTypeCollection(true)
-            {
-                new PropertyType("value11", ValueStorageType.Ntext)
-                {
-                    Alias = "value11",
-                    DataTypeId = -88,
-                    Variations = ContentVariation.Culture
-                },
-                new PropertyType("value12", ValueStorageType.Ntext)
-                {
-                    Alias = "value12",
-                    DataTypeId = -88,
-                    Variations = ContentVariation.Nothing
-                }
-            };
+            var properties1 = CreatePropertyCollection(
+                ("value11", ContentVariation.Culture),
+                ("value12", ContentVariation.Nothing));
 
             composing.PropertyGroups.Add(new PropertyGroup(properties1) { Name = "Content" });
             ServiceContext.ContentTypeService.Save(composing);
 
-            var composed = new ContentType(-1)
-            {
-                Alias = "composed",
-                Name = "composed",
-                Variations = ContentVariation.Culture
-            };
+            var composed = CreateContentType(ContentVariation.Culture, "composed");
 
-            var properties2 = new PropertyTypeCollection(true)
-            {
-                new PropertyType("value21", ValueStorageType.Ntext)
-                {
-                    Alias = "value21",
-                    DataTypeId = -88,
-                    Variations = ContentVariation.Culture
-                },
-                new PropertyType("value22", ValueStorageType.Ntext)
-                {
-                    Alias = "value22",
-                    DataTypeId = -88,
-                    Variations = ContentVariation.Nothing
-                }
-            };
+            var properties2 = CreatePropertyCollection(
+                ("value21", ContentVariation.Culture),
+                ("value22", ContentVariation.Nothing));
 
             composed.PropertyGroups.Add(new PropertyGroup(properties2) { Name = "Content" });
             composed.AddContentType(composing);
@@ -569,86 +977,32 @@ namespace Umbraco.Tests.Services
             // can change the composing content type to invariant and back
             // can change the variant composed content type to invariant and back
 
-            var languageEn = new Language("en") { IsDefault = true };
-            ServiceContext.LocalizationService.Save(languageEn);
-            var languageFr = new Language("fr");
-            ServiceContext.LocalizationService.Save(languageFr);
+            CreateFrenchAndEnglishLangs();
 
-            var composing = new ContentType(-1)
-            {
-                Alias = "composing",
-                Name = "composing",
-                Variations = ContentVariation.Culture
-            };
+            var composing = CreateContentType(ContentVariation.Culture, "composing");
 
-            var properties1 = new PropertyTypeCollection(true)
-            {
-                new PropertyType("value11", ValueStorageType.Ntext)
-                {
-                    Alias = "value11",
-                    DataTypeId = -88,
-                    Variations = ContentVariation.Culture
-                },
-                new PropertyType("value12", ValueStorageType.Ntext)
-                {
-                    Alias = "value12",
-                    DataTypeId = -88,
-                    Variations = ContentVariation.Nothing
-                }
-            };
+            var properties1 = CreatePropertyCollection(
+                ("value11", ContentVariation.Culture),
+                ("value12", ContentVariation.Nothing));
 
             composing.PropertyGroups.Add(new PropertyGroup(properties1) { Name = "Content" });
             ServiceContext.ContentTypeService.Save(composing);
 
-            var composed1 = new ContentType(-1)
-            {
-                Alias = "composed1",
-                Name = "composed1",
-                Variations = ContentVariation.Culture
-            };
+            var composed1 = CreateContentType(ContentVariation.Culture, "composed1");
 
-            var properties2 = new PropertyTypeCollection(true)
-            {
-                new PropertyType("value21", ValueStorageType.Ntext)
-                {
-                    Alias = "value21",
-                    DataTypeId = -88,
-                    Variations = ContentVariation.Culture
-                },
-                new PropertyType("value22", ValueStorageType.Ntext)
-                {
-                    Alias = "value22",
-                    DataTypeId = -88,
-                    Variations = ContentVariation.Nothing
-                }
-            };
+            var properties2 = CreatePropertyCollection(
+                ("value21", ContentVariation.Culture),
+                ("value22", ContentVariation.Nothing));
 
             composed1.PropertyGroups.Add(new PropertyGroup(properties2) { Name = "Content" });
             composed1.AddContentType(composing);
             ServiceContext.ContentTypeService.Save(composed1);
 
-            var composed2 = new ContentType(-1)
-            {
-                Alias = "composed2",
-                Name = "composed2",
-                Variations = ContentVariation.Nothing
-            };
+            var composed2 = CreateContentType(ContentVariation.Nothing, "composed2");
 
-            var properties3 = new PropertyTypeCollection(true)
-            {
-                new PropertyType("value31", ValueStorageType.Ntext)
-                {
-                    Alias = "value31",
-                    DataTypeId = -88,
-                    Variations = ContentVariation.Nothing
-                },
-                new PropertyType("value32", ValueStorageType.Ntext)
-                {
-                    Alias = "value32",
-                    DataTypeId = -88,
-                    Variations = ContentVariation.Nothing
-                }
-            };
+            var properties3 = CreatePropertyCollection(
+                ("value31", ContentVariation.Nothing),
+                ("value32", ContentVariation.Nothing));
 
             composed2.PropertyGroups.Add(new PropertyGroup(properties3) { Name = "Content" });
             composed2.AddContentType(composing);
@@ -754,5 +1108,35 @@ namespace Umbraco.Tests.Services
             AssertJsonStartsWith(document2.Id,
                 "{'properties':{'value11':[{'culture':'','seg':'','val':'v11'}],'value12':[{'culture':'','seg':'','val':'v12'}],'value31':[{'culture':'','seg':'','val':'v31'}],'value32':[{'culture':'','seg':'','val':'v32'}]},'cultureData':");
         }
+
+        private void CreateFrenchAndEnglishLangs()
+        {
+            var languageEn = new Language("en") { IsDefault = true };
+            ServiceContext.LocalizationService.Save(languageEn);
+            var languageFr = new Language("fr");
+            ServiceContext.LocalizationService.Save(languageFr);
+        }
+
+        private IContentType CreateContentType(ContentVariation variance, string alias = "contentType") => new ContentType(-1)
+        {
+            Alias = alias,
+            Name = alias,
+            Variations = variance
+        };
+
+        private PropertyTypeCollection CreatePropertyCollection(params (string alias, ContentVariation variance)[] props)
+        {
+            var propertyCollection = new PropertyTypeCollection(true);
+
+            foreach (var (alias, variance) in props)
+                propertyCollection.Add(new PropertyType(alias, ValueStorageType.Ntext)
+                {
+                    Alias = alias,
+                    DataTypeId = -88,
+                    Variations = variance
+                });
+
+            return propertyCollection;
+        }
     }
 }

src/Umbraco.Tests/TestHelpers/ControllerTesting/TestRunner.cs

@@ -25,19 +25,23 @@ namespace Umbraco.Tests.TestHelpers.ControllerTesting
         public async Task<Tuple<HttpResponseMessage, string>> Execute(string controllerName, string actionName, HttpMethod method,
             HttpContent content = null,
             MediaTypeWithQualityHeaderValue mediaTypeHeader = null,
-            bool assertOkResponse = true)
+            bool assertOkResponse = true, object routeDefaults = null, string url = null)
         {
             if (mediaTypeHeader == null)
             {
                 mediaTypeHeader = new MediaTypeWithQualityHeaderValue("application/json");
             }
+            if (routeDefaults == null)
+            {
+                routeDefaults = new { controller = controllerName, action = actionName, id = RouteParameter.Optional };
+            }
 
             var startup = new TestStartup(
                 configuration =>
                 {
                     configuration.Routes.MapHttpRoute("Default",
                         routeTemplate: "{controller}/{action}/{id}",
-                        defaults: new { controller = controllerName, action = actionName, id = RouteParameter.Optional });
+                        defaults: routeDefaults);
                 },
                 _controllerFactory);
 
@@ -45,7 +49,7 @@ namespace Umbraco.Tests.TestHelpers.ControllerTesting
             {
                 var request = new HttpRequestMessage
                 {
-                    RequestUri = new Uri("https://testserver/"),
+                    RequestUri = new Uri("https://testserver/" + (url ?? "")),
                     Method = method
                 };
 

src/Umbraco.Tests/TestHelpers/RandomIdRamDirectory.cs

@@ -0,0 +1,22 @@
+using Lucene.Net.Store;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Umbraco.Tests.TestHelpers
+{
+
+    /// <summary>
+    /// Used for tests with Lucene so that each RAM directory is unique
+    /// </summary>
+    public class RandomIdRAMDirectory : RAMDirectory
+    {
+        private readonly string _lockId = Guid.NewGuid().ToString();
+        public override string GetLockId()
+        {
+            return _lockId;
+        }
+    }
+}

src/Umbraco.Tests/Testing/TestOptionAttributeBase.cs

@@ -2,6 +2,7 @@
 using System.Linq;
 using System.Reflection;
 using NUnit.Framework;
+using Umbraco.Core.Exceptions;
 
 namespace Umbraco.Tests.Testing
 {
@@ -29,7 +30,7 @@ namespace Umbraco.Tests.Testing
             var methodName = test.MethodName;
             var type = Type.GetType(typeName, true);
             if (type == null)
-                throw new Exception("panic"); // makes no sense
+                throw new PanicException($"Could not resolve the type from type name {typeName}"); // makes no sense
             var methodInfo = type.GetMethod(methodName); // what about overloads?
             var options = GetTestOptions<TOptions>(methodInfo);
             return options;
@@ -53,7 +54,7 @@ namespace Umbraco.Tests.Testing
         {
             if (other == null) throw new ArgumentNullException(nameof(other));
             if (!(Merge((TestOptionAttributeBase) other) is TOptions merged))
-                throw new Exception("panic");
+                throw new PanicException("Could not merge test options");
             return merged;
         }
 

src/Umbraco.Tests/Umbraco.Tests.csproj

@@ -147,7 +147,6 @@
     <Compile Include="Routing\MediaUrlProviderTests.cs" />
     <Compile Include="Runtimes\StandaloneTests.cs" />
     <Compile Include="Routing\GetContentUrlsTests.cs" />
-    <Compile Include="Security\UmbracoAntiForgeryAdditionalDataProviderTests.cs" />
     <Compile Include="Services\AmbiguousEventTests.cs" />
     <Compile Include="Services\ContentServiceEventTests.cs" />
     <Compile Include="Services\ContentServicePublishBranchTests.cs" />
@@ -158,6 +157,7 @@
     <Compile Include="Services\MemberGroupServiceTests.cs" />
     <Compile Include="Services\MediaTypeServiceTests.cs" />
     <Compile Include="Services\PropertyValidationServiceTests.cs" />
+    <Compile Include="TestHelpers\RandomIdRamDirectory.cs" />
     <Compile Include="Testing\Objects\TestDataSource.cs" />
     <Compile Include="Published\PublishedSnapshotTestObjects.cs" />
     <Compile Include="Published\ModelTypeTests.cs" />
@@ -243,6 +243,7 @@
     <Compile Include="Cache\FullDataSetCachePolicyTests.cs" />
     <Compile Include="Cache\SingleItemsOnlyCachePolicyTests.cs" />
     <Compile Include="Collections\DeepCloneableListTests.cs" />
+    <Compile Include="Web\Controllers\AuthenticationControllerTests.cs" />
     <Compile Include="Web\Controllers\BackOfficeControllerUnitTests.cs" />
     <Compile Include="CoreThings\DelegateExtensionsTests.cs" />
     <Compile Include="Web\Controllers\ContentControllerTests.cs" />
@@ -268,6 +269,8 @@
     <Compile Include="StringNewlineExtensions.cs" />
     <Compile Include="Strings\StylesheetHelperTests.cs" />
     <Compile Include="Strings\StringValidationTests.cs" />
+    <Compile Include="Web\Mvc\ValidateUmbracoFormRouteStringAttributeTests.cs" />
+    <Compile Include="Web\PublishedContentQueryTests.cs" />
     <Compile Include="Web\UmbracoHelperTests.cs" />
     <Compile Include="Membership\MembershipProviderBaseTests.cs" />
     <Compile Include="Membership\UmbracoServiceMembershipProviderTests.cs" />

src/Umbraco.Tests/Web/Controllers/AuthenticationControllerTests.cs

@@ -0,0 +1,139 @@
+using System;
+using System.Collections.Concurrent;
+using System.IO;
+using System.Linq;
+using System.Net.Http;
+using System.Reflection;
+using System.Security.Cryptography;
+using System.Threading;
+using System.Web;
+using System.Web.Hosting;
+using System.Web.Http;
+using Moq;
+using Newtonsoft.Json;
+using NUnit.Framework;
+using Umbraco.Core;
+using Umbraco.Core.Cache;
+using Umbraco.Core.Composing;
+using Umbraco.Core.Configuration;
+using Umbraco.Core.IO;
+using Umbraco.Core.Logging;
+using Umbraco.Core.Persistence;
+using Umbraco.Core.Persistence.Mappers;
+using Umbraco.Core.Persistence.Querying;
+using Umbraco.Core.Persistence.SqlSyntax;
+using Umbraco.Core.Services;
+using Umbraco.Tests.TestHelpers;
+using Umbraco.Tests.TestHelpers.ControllerTesting;
+using Umbraco.Tests.Testing;
+using Umbraco.Web;
+using Umbraco.Web.Editors;
+using Umbraco.Web.Features;
+using Umbraco.Web.Models.ContentEditing;
+using IUser = Umbraco.Core.Models.Membership.IUser;
+
+namespace Umbraco.Tests.Web.Controllers
+{
+    [TestFixture]
+    [UmbracoTest(Database = UmbracoTestOptions.Database.None)]
+    public class AuthenticationControllerTests : TestWithDatabaseBase
+    {
+        protected override void ComposeApplication(bool withApplication)
+        {
+            base.ComposeApplication(withApplication);
+            //if (!withApplication) return;
+
+            // replace the true IUserService implementation with a mock
+            // so that each test can configure the service to their liking
+            Composition.RegisterUnique(f => Mock.Of<IUserService>());
+
+            // kill the true IEntityService too
+            Composition.RegisterUnique(f => Mock.Of<IEntityService>());
+
+            Composition.RegisterUnique<UmbracoFeatures>();
+        }
+
+
+        [Test]
+        public async System.Threading.Tasks.Task GetCurrentUser_Fips()
+        {
+            ApiController CtrlFactory(HttpRequestMessage message, IUmbracoContextAccessor umbracoContextAccessor, UmbracoHelper helper)
+            {
+                //setup some mocks
+                var userServiceMock = Mock.Get(Current.Services.UserService);
+                userServiceMock.Setup(service => service.GetUserById(It.IsAny<int>()))
+                    .Returns(() => null);
+
+                if (Thread.GetDomain().GetData(".appPath") != null)
+                {
+                    HttpContext.Current = new HttpContext(new SimpleWorkerRequest("", "", new StringWriter()));
+                }
+                else
+                {
+                    var baseDir = IOHelper.MapPath("", false).TrimEnd(IOHelper.DirSepChar);
+                    HttpContext.Current = new HttpContext(new SimpleWorkerRequest("/", baseDir, "", "", new StringWriter()));
+                }
+                IOHelper.ForceNotHosted = true;
+                var usersController = new AuthenticationController(
+                    Factory.GetInstance<IGlobalSettings>(),
+                    umbracoContextAccessor,
+                    Factory.GetInstance<ISqlContext>(),
+                    Factory.GetInstance<ServiceContext>(),
+                    Factory.GetInstance<AppCaches>(),
+                    Factory.GetInstance<IProfilingLogger>(),
+                    Factory.GetInstance<IRuntimeState>(),
+                    helper);
+                return usersController;
+            }
+
+            Mock.Get(Current.SqlContext)
+                .Setup(x => x.Query<IUser>())
+                .Returns(new Query<IUser>(Current.SqlContext));
+
+            var syntax = new SqlCeSyntaxProvider();
+
+            Mock.Get(Current.SqlContext)
+                .Setup(x => x.SqlSyntax)
+                .Returns(syntax);
+
+            var mappers = new MapperCollection(new[]
+            {
+                new UserMapper(new Lazy<ISqlContext>(() => Current.SqlContext), new ConcurrentDictionary<Type, ConcurrentDictionary<string, string>>())
+            });
+
+            Mock.Get(Current.SqlContext)
+                .Setup(x => x.Mappers)
+                .Returns(mappers);
+
+            // Testing what happens if the system were configured to only use FIPS-compliant algorithms
+            var typ = typeof(CryptoConfig);
+            var flds = typ.GetFields(BindingFlags.Static | BindingFlags.NonPublic);
+            var haveFld = flds.FirstOrDefault(f => f.Name == "s_haveFipsAlgorithmPolicy");
+            var isFld = flds.FirstOrDefault(f => f.Name == "s_fipsAlgorithmPolicy");
+            var originalFipsValue = CryptoConfig.AllowOnlyFipsAlgorithms;
+
+            try
+            {
+                if (!originalFipsValue)
+                {
+                    haveFld.SetValue(null, true);
+                    isFld.SetValue(null, true);
+                }
+
+                var runner = new TestRunner(CtrlFactory);
+                var response = await runner.Execute("Authentication", "GetCurrentUser", HttpMethod.Get);
+
+                var obj = JsonConvert.DeserializeObject<UserDetail>(response.Item2);
+                Assert.AreEqual(-1, obj.UserId);
+            }
+            finally
+            {
+                if (!originalFipsValue)
+                {
+                    haveFld.SetValue(null, false);
+                    isFld.SetValue(null, false);
+                }
+            }
+        }
+    }
+}

src/Umbraco.Tests/Web/Controllers/UsersControllerTests.cs

@@ -4,6 +4,8 @@ using System.Collections.Generic;
 using System.Linq;
 using System.Net.Http;
 using System.Net.Http.Formatting;
+using System.Reflection;
+using System.Security.Cryptography;
 using System.Web.Http;
 using Moq;
 using Newtonsoft.Json;
@@ -155,7 +157,7 @@ namespace Umbraco.Tests.Web.Controllers
             var runner = new TestRunner(CtrlFactory);
             var response = await runner.Execute("Users", "GetPagedUsers", HttpMethod.Get);
 
-            var obj = JsonConvert.DeserializeObject<PagedResult<UserDisplay>>(response.Item2);
+            var obj = JsonConvert.DeserializeObject<PagedResult<UserBasic>>(response.Item2);
             Assert.AreEqual(0, obj.TotalItems);
         }
 
@@ -190,9 +192,100 @@ namespace Umbraco.Tests.Web.Controllers
             var runner = new TestRunner(CtrlFactory);
             var response = await runner.Execute("Users", "GetPagedUsers", HttpMethod.Get);
 
-            var obj = JsonConvert.DeserializeObject<PagedResult<UserDisplay>>(response.Item2);
+            var obj = JsonConvert.DeserializeObject<PagedResult<UserBasic>>(response.Item2);
             Assert.AreEqual(10, obj.TotalItems);
             Assert.AreEqual(10, obj.Items.Count());
         }
+
+        [Test]
+        public async System.Threading.Tasks.Task GetPagedUsers_Fips()
+        {
+            await RunFipsTest("GetPagedUsers", mock =>
+            {
+                var users = MockedUser.CreateMulipleUsers(10);
+                long outVal = 10;
+                mock.Setup(service => service.GetAll(
+                        It.IsAny<long>(), It.IsAny<int>(), out outVal, It.IsAny<string>(), It.IsAny<Direction>(),
+                        It.IsAny<UserState[]>(), It.IsAny<string[]>(), It.IsAny<string[]>(), It.IsAny<IQuery<IUser>>()))
+                    .Returns(() => users);
+            }, response =>
+            {
+                var obj = JsonConvert.DeserializeObject<PagedResult<UserBasic>>(response.Item2);
+                Assert.AreEqual(10, obj.TotalItems);
+                Assert.AreEqual(10, obj.Items.Count());
+            });
+        }
+
+        [Test]
+        public async System.Threading.Tasks.Task GetById_Fips()
+        {
+            const int mockUserId = 1234;
+            var user = MockedUser.CreateUser();
+
+            await RunFipsTest("GetById", mock =>
+            {
+                mock.Setup(service => service.GetUserById(1234))
+                    .Returns((int i) => i == mockUserId ? user : null);
+            }, response =>
+            {
+                var obj = JsonConvert.DeserializeObject<UserDisplay>(response.Item2);
+                Assert.AreEqual(user.Username, obj.Username);
+                Assert.AreEqual(user.Email, obj.Email);
+            }, new { controller = "Users", action = "GetById" }, $"Users/GetById/{mockUserId}");
+        }
+
+
+        private async System.Threading.Tasks.Task RunFipsTest(string action, Action<Mock<IUserService>> userServiceSetup,
+            Action<Tuple<HttpResponseMessage, string>> verification,
+            object routeDefaults = null, string url = null)
+        {
+            ApiController CtrlFactory(HttpRequestMessage message, IUmbracoContextAccessor umbracoContextAccessor, UmbracoHelper helper)
+            {
+                //setup some mocks
+                var userServiceMock = Mock.Get(Current.Services.UserService);
+                userServiceSetup(userServiceMock);
+
+                var usersController = new UsersController(
+                    Factory.GetInstance<IGlobalSettings>(),
+                    umbracoContextAccessor,
+                    Factory.GetInstance<ISqlContext>(),
+                    Factory.GetInstance<ServiceContext>(),
+                    Factory.GetInstance<AppCaches>(),
+                    Factory.GetInstance<IProfilingLogger>(),
+                    Factory.GetInstance<IRuntimeState>(),
+                    helper);
+                return usersController;
+            }
+
+            // Testing what happens if the system were configured to only use FIPS-compliant algorithms
+            var typ = typeof(CryptoConfig);
+            var flds = typ.GetFields(BindingFlags.Static | BindingFlags.NonPublic);
+            var haveFld = flds.FirstOrDefault(f => f.Name == "s_haveFipsAlgorithmPolicy");
+            var isFld = flds.FirstOrDefault(f => f.Name == "s_fipsAlgorithmPolicy");
+            var originalFipsValue = CryptoConfig.AllowOnlyFipsAlgorithms;
+
+            try
+            {
+                if (!originalFipsValue)
+                {
+                    haveFld.SetValue(null, true);
+                    isFld.SetValue(null, true);
+                }
+
+                MockForGetPagedUsers();
+
+                var runner = new TestRunner(CtrlFactory);
+                var response = await runner.Execute("Users", action, HttpMethod.Get, routeDefaults: routeDefaults, url: url);
+                verification(response);
+            }
+            finally
+            {
+                if (!originalFipsValue)
+                {
+                    haveFld.SetValue(null, false);
+                    isFld.SetValue(null, false);
+                }
+            }
+        }
     }
 }

src/Umbraco.Tests/Web/Mvc/HtmlHelperExtensionMethodsTests.cs

@@ -4,6 +4,7 @@ using Umbraco.Web;
 
 namespace Umbraco.Tests.Web.Mvc
 {
+
     [TestFixture]
     public class HtmlHelperExtensionMethodsTests
     {

src/Umbraco.Tests/Web/Mvc/ValidateUmbracoFormRouteStringAttributeTests.cs

@@ -0,0 +1,37 @@
+using NUnit.Framework;
+using Umbraco.Web;
+using Umbraco.Web.Mvc;
+
+namespace Umbraco.Tests.Web.Mvc
+{
+    [TestFixture]
+    public class ValidateUmbracoFormRouteStringAttributeTests
+    {
+        [Test]
+        public void Validate_Route_String()
+        {
+            var attribute = new ValidateUmbracoFormRouteStringAttribute();
+
+            Assert.Throws<HttpUmbracoFormRouteStringException>(() => attribute.ValidateRouteString(null, null, null, null));
+
+            const string ControllerName = "Test";
+            const string ControllerAction = "Index";
+            const string Area = "MyArea";
+            var validUfprt = UrlHelperRenderExtensions.CreateEncryptedRouteString(ControllerName, ControllerAction, Area);
+
+            var invalidUfprt = validUfprt + "z";
+            Assert.Throws<HttpUmbracoFormRouteStringException>(() => attribute.ValidateRouteString(invalidUfprt, null, null, null));
+
+            Assert.Throws<HttpUmbracoFormRouteStringException>(() => attribute.ValidateRouteString(validUfprt, ControllerName, ControllerAction, "doesntMatch"));
+            Assert.Throws<HttpUmbracoFormRouteStringException>(() => attribute.ValidateRouteString(validUfprt, ControllerName, ControllerAction, null));
+            Assert.Throws<HttpUmbracoFormRouteStringException>(() => attribute.ValidateRouteString(validUfprt, ControllerName, "doesntMatch", Area));
+            Assert.Throws<HttpUmbracoFormRouteStringException>(() => attribute.ValidateRouteString(validUfprt, ControllerName, null, Area));
+            Assert.Throws<HttpUmbracoFormRouteStringException>(() => attribute.ValidateRouteString(validUfprt, "doesntMatch", ControllerAction, Area));
+            Assert.Throws<HttpUmbracoFormRouteStringException>(() => attribute.ValidateRouteString(validUfprt, null, ControllerAction, Area));
+
+            Assert.DoesNotThrow(() => attribute.ValidateRouteString(validUfprt, ControllerName, ControllerAction, Area));
+            Assert.DoesNotThrow(() => attribute.ValidateRouteString(validUfprt, ControllerName.ToLowerInvariant(), ControllerAction.ToLowerInvariant(), Area.ToLowerInvariant()));
+        }
+
+    }
+}

src/Umbraco.Tests/Web/PublishedContentQueryTests.cs

@@ -0,0 +1,99 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Examine;
+using Examine.LuceneEngine.Providers;
+using Lucene.Net.Store;
+using Moq;
+using NUnit.Framework;
+using Umbraco.Core.Models.PublishedContent;
+using Umbraco.Examine;
+using Umbraco.Tests.TestHelpers;
+using Umbraco.Web;
+using Umbraco.Web.PublishedCache;
+
+namespace Umbraco.Tests.Web
+{
+    [TestFixture]
+    public class PublishedContentQueryTests
+    {
+
+        private class TestIndex : LuceneIndex, IUmbracoIndex
+        {
+            private readonly string[] _fieldNames;
+
+            public TestIndex(string name, Directory luceneDirectory, string[] fieldNames)
+                : base(name, luceneDirectory, null, null, null, null)
+            {
+                _fieldNames = fieldNames;
+            }
+            public bool EnableDefaultEventHandler => throw new NotImplementedException();
+            public bool PublishedValuesOnly => throw new NotImplementedException();
+            public IEnumerable<string> GetFields() => _fieldNames;
+        }
+
+        private TestIndex CreateTestIndex(Directory luceneDirectory, string[] fieldNames)
+        {
+            var indexer = new TestIndex("TestIndex", luceneDirectory, fieldNames);
+
+            using (indexer.ProcessNonAsync())
+            {
+                //populate with some test data
+                indexer.IndexItem(new ValueSet("1", "content", new Dictionary<string, object>
+                {
+                    [fieldNames[0]] = "Hello world, there are products here",
+                    [UmbracoContentIndex.VariesByCultureFieldName] = "n"
+                }));
+                indexer.IndexItem(new ValueSet("2", "content", new Dictionary<string, object>
+                {
+                    [fieldNames[1]] = "Hello world, there are products here",
+                    [UmbracoContentIndex.VariesByCultureFieldName] = "y"
+                }));
+                indexer.IndexItem(new ValueSet("3", "content", new Dictionary<string, object>
+                {
+                    [fieldNames[2]] = "Hello world, there are products here",
+                    [UmbracoContentIndex.VariesByCultureFieldName] = "y"
+                }));
+            }
+            
+            return indexer;
+        }
+
+        private PublishedContentQuery CreatePublishedContentQuery(IIndex indexer)
+        {
+            var examineManager = new Mock<IExamineManager>();
+            IIndex outarg = indexer;
+            examineManager.Setup(x => x.TryGetIndex("TestIndex", out outarg)).Returns(true);
+
+            var contentCache = new Mock<IPublishedContentCache>();
+            contentCache.Setup(x => x.GetById(It.IsAny<int>())).Returns((int intId) => Mock.Of<IPublishedContent>(x => x.Id == intId));
+            var snapshot = Mock.Of<IPublishedSnapshot>(x => x.Content == contentCache.Object);
+            var variationContext = new VariationContext();
+            var variationContextAccessor = Mock.Of<IVariationContextAccessor>(x => x.VariationContext == variationContext);
+
+            return new PublishedContentQuery(snapshot, variationContextAccessor, examineManager.Object);
+        }
+
+        [TestCase("fr-fr", ExpectedResult = "1, 3", TestName = "Search Culture: fr-fr. Must return both fr-fr and invariant results")]
+        [TestCase("en-us", ExpectedResult = "1, 2", TestName = "Search Culture: en-us. Must return both en-us and invariant results")]
+        [TestCase("*", ExpectedResult = "1, 2, 3", TestName = "Search Culture: *. Must return all cultures and all invariant results")]
+        [TestCase(null, ExpectedResult = "1", TestName = "Search Culture: null. Must return only invariant results")]
+        public string Search(string culture)
+        {
+            using (var luceneDir = new RandomIdRAMDirectory())
+            {
+                var fieldNames = new[] { "title", "title_en-us", "title_fr-fr" };
+                using (var indexer = CreateTestIndex(luceneDir, fieldNames))
+                {   
+                    var pcq = CreatePublishedContentQuery(indexer);
+
+                    var results = pcq.Search("Products", culture, "TestIndex");
+
+                    var ids = results.Select(x => x.Content.Id).ToArray();
+
+                    return string.Join(", ", ids);
+                }
+            }
+        }
+    }
+}

src/Umbraco.Tests/Web/UmbracoHelperTests.cs

@@ -1,5 +1,8 @@
 using System;
 using System.Text;
+using Examine.LuceneEngine;
+using Lucene.Net.Analysis;
+using Lucene.Net.Analysis.Standard;
 using Moq;
 using NUnit.Framework;
 using Umbraco.Core;
@@ -13,18 +16,19 @@ using Umbraco.Web;
 
 namespace Umbraco.Tests.Web
 {
+
     [TestFixture]
     public class UmbracoHelperTests
-    {   
+    {
 
         [TearDown]
         public void TearDown()
         {
             Current.Reset();
         }
-        
 
-        
+
+
         // ------- Int32 conversion tests
         [Test]
         public static void Converting_Boxed_34_To_An_Int_Returns_34()

src/Umbraco.Web.UI.Client/gulp/util/processJs.js

@@ -23,7 +23,7 @@ module.exports = function(files, out) {
     // sort files in stream by path or any custom sort comparator
     task = task.pipe(babel())
         .pipe(sort())
-        .pipe(embedTemplates({ basePath: "./src/" }))
+        .pipe(embedTemplates({ basePath: "./src/", minimize:{ loose: true } }))
         .pipe(concat(out))
         .pipe(wrap('(function(){\n%= body %\n})();'))
         .pipe(gulp.dest(config.root + config.targets.js));

src/Umbraco.Web.UI.Client/src/common/directives/components/content/edit.controller.js

@@ -94,6 +94,10 @@
                 content.apps[0].active = true;
                 $scope.appChanged(content.apps[0]);
             }
+            // otherwise make sure the save options are up to date with the current content state
+            else {
+                createButtons($scope.content);
+            }
 
             editorState.set(content);
 

src/Umbraco.Web.UI.Client/src/common/directives/components/events/events.directive.js

@@ -101,14 +101,14 @@ angular.module('umbraco.directives')
             var eventBindings = [];
 
             function oneTimeClick(event) {
-                // ignore clicks on button groups toggles (i.e. the save and publish button)
-                var parents = $(event.target).closest("[data-element='button-group-toggle']");
-                if (parents.length > 0) {
-                    return;
-                }
+                var el = event.target.nodeName;
+
+                //ignore link and button clicks
+                var els = ["INPUT", "A", "BUTTON"];
+                if (els.indexOf(el) >= 0) { return; }
 
                 // ignore clicks on new overlay
-                parents = $(event.target).parents(".umb-overlay,.umb-tour");
+                var parents = $(event.target).parents("a,button,.umb-overlay,.umb-tour");
                 if (parents.length > 0) {
                     return;
                 }
@@ -131,12 +131,6 @@ angular.module('umbraco.directives')
                     return;
                 }
 
-                // ignore clicks on dialog actions
-                var actions = $(event.target).parents(".umb-action");
-                if (actions.length === 1) {
-                    return;
-                }
-
                 //ignore clicks inside this element
                 if ($(element).has($(event.target)).length > 0) {
                     return;

src/Umbraco.Web.UI.Client/src/common/directives/components/grid/grid.rte.directive.js

@@ -5,7 +5,7 @@ angular.module("umbraco.directives")
                 uniqueId: '=',
                 value: '=',
                 configuration: "=", //this is the RTE configuration
-                datatypeId: '@',
+                datatypeKey: '@',
                 ignoreUserStartNodes: '@'
             },
             templateUrl: 'views/components/grid/grid-rte.html',
@@ -43,7 +43,7 @@ angular.module("umbraco.directives")
                 scope.config = {
                     ignoreUserStartNodes: scope.ignoreUserStartNodes === "true"
                 }
-                scope.dataTypeId = scope.datatypeId; //Yes - this casing is rediculous, but it's because the var starts with `data` so it can't be `data-type-id` :/
+                scope.dataTypeKey = scope.datatypeKey; //Yes - this casing is rediculous, but it's because the var starts with `data` so it can't be `data-type-id` :/
 
                 //stores a reference to the editor
                 var tinyMceEditor = null;

src/Umbraco.Web.UI.Client/src/common/directives/components/tree/umbtreesearchbox.directive.js

@@ -12,7 +12,7 @@ function treeSearchBox(localizationService, searchService, $q) {
             searchFromName: "@",
             showSearch: "@",
             section: "@",
-            datatypeId: "@",
+            datatypeKey: "@",
             hideSearchCallback: "=",
             searchCallback: "="
         },
@@ -63,8 +63,8 @@ function treeSearchBox(localizationService, searchService, $q) {
                     }
 
                     //append dataTypeId value if there is one
-                    if (scope.datatypeId) {
-                        searchArgs["dataTypeId"] = scope.datatypeId;
+                    if (scope.datatypeKey) {
+                        searchArgs["dataTypeKey"] = scope.datatypeKey;
                     }
 
                     searcher(searchArgs).then(function (data) {

src/Umbraco.Web.UI.Client/src/common/directives/components/umbgroupsbuilder.directive.js

@@ -47,6 +47,7 @@
       function setSortingOptions() {
 
         scope.sortableOptionsGroup = {
+          axis: 'y',
           distance: 10,
           tolerance: "pointer",
           opacity: 0.7,
@@ -65,6 +66,7 @@
         };
 
         scope.sortableOptionsProperty = {
+          axis: 'y',
           distance: 10,
           tolerance: "pointer",
           connectWith: ".umb-group-builder__properties",

src/Umbraco.Web.UI.Client/src/common/resources/entity.resource.js

@@ -327,8 +327,8 @@ function entityResource($q, $http, umbRequestHelper) {
                 { type: type },
                 { culture: culture}
             ];
-            if (options && options.dataTypeId) {
-                args.push({ dataTypeId: options.dataTypeId });
+            if (options && options.dataTypeKey) {
+                args.push({ dataTypeKey: options.dataTypeKey });
             }
 
             return umbRequestHelper.resourcePromise(
@@ -356,8 +356,8 @@ function entityResource($q, $http, umbRequestHelper) {
         getChildren: function (id, type, options) {
 
             var args = [{ id: id }, { type: type }];
-            if (options && options.dataTypeId) {
-                args.push({ dataTypeId: options.dataTypeId });
+            if (options && options.dataTypeKey) {
+                args.push({ dataTypeKey: options.dataTypeKey });
             }
 
             return umbRequestHelper.resourcePromise(
@@ -404,7 +404,8 @@ function entityResource($q, $http, umbRequestHelper) {
                 pageNumber: 100,
                 filter: '',
                 orderDirection: "Ascending",
-                orderBy: "SortOrder"
+                orderBy: "SortOrder",
+                dataTypeKey: null
             };
             if (options === undefined) {
                 options = {};
@@ -421,6 +422,7 @@ function entityResource($q, $http, umbRequestHelper) {
                 options.orderDirection = "Descending";
             }
 
+
             return umbRequestHelper.resourcePromise(
                 $http.get(
                     umbRequestHelper.getApiUrl(
@@ -434,7 +436,7 @@ function entityResource($q, $http, umbRequestHelper) {
                             orderBy: options.orderBy,
                             orderDirection: options.orderDirection,
                             filter: encodeURIComponent(options.filter),
-                            dataTypeId: options.dataTypeId
+                            dataTypeKey: options.dataTypeKey
                         }
                     )),
                 'Failed to retrieve child data for id ' + parentId);
@@ -476,7 +478,7 @@ function entityResource($q, $http, umbRequestHelper) {
                 filter: '',
                 orderDirection: "Ascending",
                 orderBy: "SortOrder",
-                dataTypeId: null
+                dataTypeKey: null
             };
             if (options === undefined) {
                 options = {};
@@ -506,7 +508,7 @@ function entityResource($q, $http, umbRequestHelper) {
                             orderBy: options.orderBy,
                             orderDirection: options.orderDirection,
                             filter: encodeURIComponent(options.filter),
-                            dataTypeId: options.dataTypeId
+                            dataTypeKey: options.dataTypeKey
                         }
                     )),
                 'Failed to retrieve child data for id ' + parentId);
@@ -535,15 +537,15 @@ function entityResource($q, $http, umbRequestHelper) {
          * @returns {Promise} resourcePromise object containing the entity array.
          *
          */
-        search: function (query, type, searchFrom, canceler, dataTypeId) {
+        search: function (query, type, searchFrom, canceler, dataTypeKey) {
 
             var args = [{ query: query }, { type: type }];
             if (searchFrom) {
                 args.push({ searchFrom: searchFrom });
             }
 
-            if (dataTypeId) {
-                args.push({ dataTypeId: dataTypeId });
+            if (dataTypeKey) {
+                args.push({ dataTypeKey: dataTypeKey });
             }
 
             var httpConfig = {};

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

@@ -67,7 +67,7 @@ angular.module('umbraco.services')
                     throw "args.term is required";
                 }
 
-                return entityResource.search(args.term, "Document", args.searchFrom, args.canceler, args.dataTypeId).then(function (data) {
+                return entityResource.search(args.term, "Document", args.searchFrom, args.canceler, args.dataTypeKey).then(function (data) {
                     _.each(data, function (item) {
                         searchResultFormatter.configureContentResult(item);
                     });
@@ -92,7 +92,7 @@ angular.module('umbraco.services')
                     throw "args.term is required";
                 }
 
-                return entityResource.search(args.term, "Media", args.searchFrom, args.canceler, args.dataTypeId).then(function (data) {
+                return entityResource.search(args.term, "Media", args.searchFrom, args.canceler, args.dataTypeKey).then(function (data) {
                     _.each(data, function (item) {
                         searchResultFormatter.configureMediaResult(item);
                     });

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

@@ -1121,7 +1121,7 @@ function tinyMceService($rootScope, $q, imageHelper, $locale, $http, $timeout, s
                 entityResource.getAnchors(args.model.value).then(function (anchorValues) {
                     var linkPicker = {
                         currentTarget: currentTarget,
-                        dataTypeId: args.model.dataTypeId,
+                        dataTypeKey: args.model.dataTypeKey,
                         ignoreUserStartNodes: args.model.config.ignoreUserStartNodes,
                         anchors: anchorValues,
                         submit: function (model) {
@@ -1159,7 +1159,7 @@ function tinyMceService($rootScope, $q, imageHelper, $locale, $http, $timeout, s
                     disableFolderSelect: true,
                     startNodeId: startNodeId,
                     startNodeIsVirtual: startNodeIsVirtual,
-                    dataTypeId: args.model.dataTypeId,
+                    dataTypeKey: args.model.dataTypeKey,
                     submit: function (model) {
                         self.insertMediaInEditor(args.editor, model.selection[0]);
                         editorService.close();

src/Umbraco.Web.UI.Client/src/less/components/tree/umb-actions.less

@@ -94,6 +94,7 @@
         font-size: 14px;
         color: @black;
         margin-left: 10px;
+        text-align: left;
     }
 
     small {

src/Umbraco.Web.UI.Client/src/views/common/infiniteeditors/linkpicker/linkpicker.controller.js

@@ -20,14 +20,14 @@ angular.module("umbraco").controller("Umbraco.Editors.LinkPickerController",
                     $scope.model.title = value;
                 });
         }
-        $scope.customTreeParams = dialogOptions.dataTypeId ? "dataTypeId=" + dialogOptions.dataTypeId : "";
+        $scope.customTreeParams = dialogOptions.dataTypeKey ? "dataTypeKey=" + dialogOptions.dataTypeKey : "";
         $scope.dialogTreeApi = {};
         $scope.model.target = {};
         $scope.searchInfo = {
             searchFromId: null,
             searchFromName: null,
             showSearch: false,
-            dataTypeId: dialogOptions.dataTypeId,
+            dataTypeKey: dialogOptions.dataTypeKey,
             results: [],
             selectedSearchResults: []
         };
@@ -175,7 +175,7 @@ angular.module("umbraco").controller("Umbraco.Editors.LinkPickerController",
                 var mediaPicker = {
                     startNodeId: startNodeId,
                     startNodeIsVirtual: startNodeIsVirtual,
-                    dataTypeId: dialogOptions.dataTypeId,
+                    dataTypeKey: dialogOptions.dataTypeKey,
                     submit: function (model) {
                         var media = model.selection[0];
 

src/Umbraco.Web.UI.Client/src/views/common/infiniteeditors/linkpicker/linkpicker.html

@@ -25,7 +25,7 @@
                                     ng-model="model.target.url"
                                     ng-disabled="model.target.id || model.target.udi" />
                         </umb-control-group>
-                
+
                         <umb-control-group label="@defaultdialogs_anchorLinkPicker">
                             <input type="text"
                                     list="anchors"
@@ -33,13 +33,13 @@
                                     placeholder="@placeholders_anchor"
                                     class="umb-property-editor umb-textstring"
                                     ng-model="model.target.anchor" />
-                    
+
                             <datalist id="anchors">
                                 <option value="{{a}}" ng-repeat="a in anchorValues"></option>
                             </datalist>
                         </umb-control-group>
                     </div>
-                
+
                     <umb-control-group label="@defaultdialogs_nodeNameLinkPicker">
                         <input type="text"
                                 localize="placeholder"
@@ -47,7 +47,7 @@
                                 class="umb-property-editor umb-textstring"
                                 ng-model="model.target.name" />
                     </umb-control-group>
-                
+
                     <umb-control-group ng-if="showTarget" label="@content_target">
                         <umb-checkbox
                                       model="vm.openInNewWindow"
@@ -58,28 +58,28 @@
 
                     <div class="umb-control-group">
                         <h5><localize key="defaultdialogs_linkToPage">Link to page</localize></h5>
-                
+
                         <div ng-hide="miniListView">
-                            <umb-tree-search-box 
+                            <umb-tree-search-box
                                 hide-search-callback="hideSearch"
                                 search-callback="onSearchResults"
                                 search-from-id="{{searchInfo.searchFromId}}"
                                 search-from-name="{{searchInfo.searchFromName}}"
-                                datatype-id="{{searchInfo.dataTypeId}}"
+                                datatype-key="{{searchInfo.dataTypeKey}}"
                                 show-search="{{searchInfo.showSearch}}"
                                 section="{{section}}">
                             </umb-tree-search-box>
-                
+
                             <br />
-                
-                            <umb-tree-search-results 
+
+                            <umb-tree-search-results
                                 ng-if="searchInfo.showSearch"
                                 results="searchInfo.results"
                                 select-result-callback="selectResult">
                             </umb-tree-search-results>
-                
+
                             <div ng-hide="searchInfo.showSearch">
-                                <umb-tree 
+                                <umb-tree
                                     section="content"
                                     hideheader="true"
                                     hideoptions="true"
@@ -92,17 +92,17 @@
                                 </umb-tree>
                             </div>
                         </div>
-                
-                        <umb-mini-list-view 
+
+                        <umb-mini-list-view
                             ng-if="miniListView"
                             node="miniListView"
                             entity-type="Document"
                             on-select="selectListViewNode(node)"
                             on-close="closeMiniListView()">
                         </umb-mini-list-view>
-                
+
                     </div>
-                
+
                     <div class="umb-control-group">
                         <h5><localize key="defaultdialogs_linkToMedia">Link to media</localize></h5>
                         <a href ng-click="switchToMediaPicker()" class="btn">

src/Umbraco.Web.UI.Client/src/views/common/infiniteeditors/mediapicker/mediapicker.controller.js

@@ -51,13 +51,17 @@ angular.module("umbraco")
                     $scope.acceptedMediatypes = types;
                 });
 
+            var dataTypeKey = null;
+            if($scope.model && $scope.model.dataTypeKey) {
+                dataTypeKey = $scope.model.dataTypeKey;
+            }
             $scope.searchOptions = {
                 pageNumber: 1,
                 pageSize: 100,
                 totalItems: 0,
                 totalPages: 0,
                 filter: '',
-                dataTypeId: $scope.model.dataTypeId
+                dataTypeKey: dataTypeKey
             };
 
             //preload selected item
@@ -160,7 +164,7 @@ angular.module("umbraco")
                 }
 
                 if (folder.id > 0) {
-                    entityResource.getAncestors(folder.id, "media", null, { dataTypeId: $scope.model.dataTypeId })
+                    entityResource.getAncestors(folder.id, "media", null, { dataTypeKey: dataTypeKey })
                         .then(function (anc) {
                             $scope.path = _.filter(anc,
                                 function (f) {
@@ -311,6 +315,7 @@ angular.module("umbraco")
                     if ($scope.searchOptions.filter) {
                         searchMedia();
                     } else {
+                        
                         // reset pagination
                         $scope.searchOptions = {
                             pageNumber: 1,
@@ -318,7 +323,7 @@ angular.module("umbraco")
                             totalItems: 0,
                             totalPages: 0,
                             filter: '',
-                            dataTypeId: $scope.model.dataTypeId
+                            dataTypeKey: dataTypeKey
                         };
                         getChildren($scope.currentFolder.id);
                     }

src/Umbraco.Web.UI.Client/src/views/common/infiniteeditors/treepicker/treepicker.controller.js

@@ -28,12 +28,12 @@ angular.module("umbraco").controller("Umbraco.Editors.TreePickerController",
         vm.treeAlias = $scope.model.treeAlias;
         vm.multiPicker = $scope.model.multiPicker;
         vm.hideHeader = (typeof $scope.model.hideHeader) === "boolean" ? $scope.model.hideHeader : true;
-        vm.dataTypeId = $scope.model.dataTypeId;
+        vm.dataTypeKey = $scope.model.dataTypeKey;
         vm.searchInfo = {
             searchFromId: $scope.model.startNodeId,
             searchFromName: null,
             showSearch: false,
-            dataTypeId: vm.dataTypeId,
+            dataTypeKey: vm.dataTypeKey,
             results: [],
             selectedSearchResults: []
         }
@@ -192,8 +192,8 @@ angular.module("umbraco").controller("Umbraco.Editors.TreePickerController",
             if (vm.selectedLanguage && vm.selectedLanguage.id) {
                 queryParams["culture"] = vm.selectedLanguage.culture;
             }
-            if (vm.dataTypeId) {
-                queryParams["dataTypeId"] = vm.dataTypeId;
+            if (vm.dataTypeKey) {
+                queryParams["dataTypeKey"] = vm.dataTypeKey;
             }
                 
             var queryString = $.param(queryParams); //create the query string from the params object

src/Umbraco.Web.UI.Client/src/views/common/infiniteeditors/treepicker/treepicker.html

@@ -27,7 +27,7 @@
                                         <a ng-click="vm.selectLanguage(language)" ng-repeat="language in vm.languages" href="">{{language.name}}</a>
                                     </div>
                                 </div>
-                        
+
                                 <div class="umb-control-group">
                                     <umb-tree-search-box
                                         ng-if="vm.enableSearh"
@@ -36,22 +36,22 @@
                                         search-from-id="{{vm.searchInfo.searchFromId}}"
                                         search-from-name="{{vm.searchInfo.searchFromName}}"
                                         show-search="{{vm.searchInfo.showSearch}}"
-                                        datatype-id="{{vm.searchInfo.dataTypeId}}"
+                                        datatype-key="{{vm.searchInfo.dataTypeKey}}"
                                         section="{{vm.section}}">
                                     </umb-tree-search-box>
                                 </div>
-                        
+
                                 <umb-tree-search-results ng-if="vm.searchInfo.showSearch"
                                                             results="vm.searchInfo.results"
                                                             select-result-callback="vm.selectResult">
                                 </umb-tree-search-results>
-                        
+
                                 <umb-empty-state ng-if="!vm.hasItems && vm.emptyStateMessage" position="center">
                                     {{ vm.emptyStateMessage }}
                                 </umb-empty-state>
-                        
+
                                 <div ng-if="vm.treeReady" ng-hide="vm.searchInfo.showSearch" ng-animate="'tree-fade-out'">
-                                    <umb-tree 
+                                    <umb-tree
                                         section="{{vm.section}}"
                                         treealias="{{vm.treeAlias}}"
                                         hideheader="{{vm.hideHeader}}"
@@ -65,10 +65,10 @@
                                         api="vm.dialogTreeApi">
                                     </umb-tree>
                                 </div>
-                        
+
                             </div>
-                        
-                            <umb-mini-list-view 
+
+                            <umb-mini-list-view
                                 ng-if="vm.miniListView"
                                 node="vm.miniListView"
                                 entity-type="{{vm.entityType}}"
@@ -93,7 +93,7 @@
                         shortcut="esc"
                         action="vm.close()">
                     </umb-button>
-    
+
                     <umb-button
                         ng-if="vm.multiPicker"
                         type="button"
@@ -101,7 +101,7 @@
                         label-key="general_submit"
                         action="vm.submit(model)">
                     </umb-button>
-            
+
                 </umb-editor-footer-content-right>
 
             </umb-editor-footer>

src/Umbraco.Web.UI.Client/src/views/common/overlays/user/user.html

@@ -53,14 +53,14 @@
 			<form ng-if="login.linkedProviderKey == undefined" method="POST" name="externalLoginForm"
 				  action="{{externalLinkLoginFormAction}}" id="oauthloginform" name="oauthloginform">
 				<input type="hidden" name="provider" value="{{login.authType}}" />
-				<button class="btn btn-block btn-social"
-						ng-class="login.properties.SocialStyle"
-						id="{{login.authType}}"
-						onclick="document.forms.oauthloginform.submit();">
+                <button class="btn btn-block btn-social"
+                        ng-class="login.properties.SocialStyle"
+                        id="{{login.authType}}"
+                        onclick="document.forms.oauthloginform.submit();">
 
-					<i class="fa" ng-class="login.properties.SocialIcon"></i>
-					<localize key="defaultdialogs_linkYour">Link your</localize> {{login.caption}} <localize key="defaultdialogs_account">account</localize>
-				</button>
+                    <i class="fa" ng-class="login.properties.SocialIcon"></i>
+                    <localize key="defaultdialogs_linkYour">Link your</localize>&nbsp;{{login.caption}}&nbsp;<localize key="defaultdialogs_account">account</localize>
+                </button>
 			</form>
 
             <button ng-if="login.linkedProviderKey != undefined"
@@ -71,7 +71,7 @@
                     name="provider"
                     value="{{login.authType}}">
                 <i class="fa" ng-class="login.properties.SocialIcon"></i>
-                <localize key="defaultdialogs_unLinkYour">Un-link your</localize> {{login.caption}} <localize key="defaultdialogs_account">account</localize>
+                <localize key="defaultdialogs_unLinkYour">Un-link your</localize>&nbsp;{{login.caption}}&nbsp;<localize key="defaultdialogs_account">account</localize>
             </button>
         </div>
 

src/Umbraco.Web.UI.Client/src/views/components/application/umb-login.html

@@ -138,7 +138,7 @@
                                         id="{{login.authType}}" name="provider" value="{{login.authType}}"
                                         title="Log in using your {{login.caption}} account">
                                     <i class="fa" ng-class="login.properties.SocialIcon"></i>
-                                    <localize key="login_signInWith">Sign in with</localize> {{login.caption}}
+                                    <localize key="login_signInWith">Sign in with</localize>&nbsp;{{login.caption}}
                                 </button>
 
                             </div>

src/Umbraco.Web.UI.Client/src/views/components/umb-grid-selector.html

@@ -32,7 +32,7 @@
     </div>
 
     <div class="text-center" ng-if="(availableItems | compareArrays:selectedItems:'alias').length === 0">
-        <small><localize key="general_all">Akk</localize> {{itemLabel}}s <localize key="grid_areAdded">are added</localize></small>
+        <small><localize key="general_all">All</localize> {{itemLabel}}s <localize key="grid_areAdded">are added</localize></small>
     </div>
 
 </div>