Post-merge fixes

- implement manifest filters to tweak manifests after they have been parsed
- make IEditorValidator public
- stop relying on InternalsVisibleTo Umbraco.ModelsBuilder

build/NuSpecs/UmbracoCms.Core.nuspec

@@ -39,6 +39,8 @@
                 <dependency id="Serilog.Formatting.Compact.Reader" version="[1.0.3,1.999999)" />
                 <dependency id="Serilog.Settings.AppSettings" version="[2.2.2,2.999999)" />
                 <dependency id="Serilog.Sinks.File" version="[4.0.0,4.999999)" />
+                <dependency id="Serilog.Sinks.Map" version="[1.0.0,1.999999)" />
+                <dependency id="Serilog.Sinks.Async" version="[1.3.0,1.999999)" />
                 <dependency id="Umbraco.SqlServerCE" version="[4.0.0.1,4.999999)" />
                 <dependency id="NPoco" version="[3.9.4,3.999999)" />
             </group>
@@ -50,7 +52,7 @@
         <file src="$BuildTmp$\WebApp\bin\Umbraco.Core.dll" target="lib\net472\Umbraco.Core.dll" />
 
         <!-- docs -->
-        <file src="$BuildTmp$\WebApp\bin\Umbraco.Core.xml" target="lib\Umbraco.Core.xml" />
+        <file src="$BuildTmp$\WebApp\bin\Umbraco.Core.xml" target="lib\net472\Umbraco.Core.xml" />
 
         <!-- symbols -->
         <file src="$BuildTmp$\bin\Umbraco.Core.pdb" target="lib" />

build/NuSpecs/UmbracoCms.Web.nuspec

@@ -51,14 +51,17 @@
         <file src="$BuildTmp$\WebApp\bin\Umbraco.Web.dll" target="lib\net472\Umbraco.Web.dll" />
         <file src="$BuildTmp$\WebApp\bin\Umbraco.Web.UI.dll" target="lib\net472\Umbraco.Web.UI.dll" />
         <file src="$BuildTmp$\WebApp\bin\Umbraco.Examine.dll" target="lib\net472\Umbraco.Examine.dll" />
+        <file src="$BuildTmp$\WebApp\bin\Umbraco.ModelsBuilder.dll" target="lib\net472\Umbraco.ModelsBuilder.dll" />
 
         <!-- docs -->
-        <file src="$BuildTmp$\WebApp\bin\Umbraco.Web.xml" target="lib\Umbraco.Web.xml" />
-        <file src="$BuildTmp$\WebApp\bin\Umbraco.Web.UI.xml" target="lib\Umbraco.Web.UI.xml" />
-        <file src="$BuildTmp$\WebApp\bin\Umbraco.Examine.xml" target="lib\Umbraco.Examine.xml" />
+        <file src="$BuildTmp$\WebApp\bin\Umbraco.Web.xml" target="lib\net472\Umbraco.Web.xml" />
+        <file src="$BuildTmp$\WebApp\bin\Umbraco.Web.UI.xml" target="lib\net472\Umbraco.Web.UI.xml" />
+        <file src="$BuildTmp$\WebApp\bin\Umbraco.Examine.xml" target="lib\net472\Umbraco.Examine.xml" />
+        <file src="$BuildTmp$\WebApp\bin\Umbraco.ModelsBuilder.xml" target="lib\net472\Umbraco.ModelsBuilder.xml" />
 
         <!-- symbols -->
         <file src="$BuildTmp$\bin\Umbraco.Web.pdb" target="lib" />
         <file src="$BuildTmp$\bin\Umbraco.Examine.pdb" target="lib" />
+        <file src="$BuildTmp$\bin\Umbraco.ModelsBuilder.pdb" target="lib" />
     </files>
 </package>

build/NuSpecs/UmbracoCms.nuspec

@@ -25,7 +25,6 @@
                   not want this to happen as the alpha of the next major is, really, the next major already.
                 -->
                 <dependency id="Microsoft.AspNet.SignalR.Core" version="[2.4.0, 2.999999)" />
-                <dependency id="Umbraco.ModelsBuilder.Ui" version="[8.0.4]" />
                 <dependency id="ImageProcessor.Web" version="[4.10.0.100,4.999999)" />
                 <dependency id="ImageProcessor.Web.Config" version="[2.5.0.100,2.999999)" />
                 <dependency id="Microsoft.CodeDom.Providers.DotNetCompilerPlatform" version="[2.0.1,2.999999)" />

src/Umbraco.Core/Compose/AuditEventsComponent.cs

@@ -44,21 +44,22 @@ namespace Umbraco.Core.Compose
         public void Terminate()
         { }
 
+        internal static IUser UnknownUser => new User { Id = Constants.Security.UnknownUserId, Name = Constants.Security.UnknownUserName, Email = "" };
+
         private IUser CurrentPerformingUser
         {
             get
             {
                 var identity = Thread.CurrentPrincipal?.GetUmbracoIdentity();
-                return identity == null
-                    ? new User { Id = 0, Name = "SYSTEM", Email = "" }
-                    : _userService.GetUserById(Convert.ToInt32(identity.Id));
+                var user = identity == null ? null : _userService.GetUserById(Convert.ToInt32(identity.Id));
+                return user ?? UnknownUser;
             }
         }
 
         private IUser GetPerformingUser(int userId)
         {
             var found = userId >= 0 ? _userService.GetUserById(userId) : null;
-            return found ?? new User {Id = 0, Name = "SYSTEM", Email = ""};
+            return found ?? UnknownUser;
         }
 
         private string PerformingIp

src/Umbraco.Core/CompositionExtensions.cs

@@ -4,6 +4,7 @@ using Umbraco.Core.Composing;
 using Umbraco.Core.Dictionary;
 using Umbraco.Core.IO;
 using Umbraco.Core.Logging.Viewer;
+using Umbraco.Core.Manifest;
 using Umbraco.Core.Models.PublishedContent;
 using Umbraco.Core.PackageActions;
 using Umbraco.Core.Persistence.Mappers;
@@ -66,9 +67,16 @@ namespace Umbraco.Core
         /// Gets the validators collection builder.
         /// </summary>
         /// <param name="composition">The composition.</param>
-        internal static ManifestValueValidatorCollectionBuilder Validators(this Composition composition)
+        internal static ManifestValueValidatorCollectionBuilder ManifestValueValidators(this Composition composition)
             => composition.WithCollectionBuilder<ManifestValueValidatorCollectionBuilder>();
 
+        /// <summary>
+        /// Gets the manifest filter collection builder.
+        /// </summary>
+        /// <param name="composition">The composition.</param>
+        public static ManifestFilterCollectionBuilder ManifestFilters(this Composition composition)
+            => composition.WithCollectionBuilder<ManifestFilterCollectionBuilder>();
+
         /// <summary>
         /// Gets the components collection builder.
         /// </summary>

src/Umbraco.Core/ConfigsExtensions.cs

@@ -7,6 +7,7 @@ using Umbraco.Core.Configuration.HealthChecks;
 using Umbraco.Core.Configuration.UmbracoSettings;
 using Umbraco.Core.IO;
 using Umbraco.Core.Logging;
+using Umbraco.Core.Manifest;
 
 namespace Umbraco.Core
 {
@@ -41,7 +42,12 @@ namespace Umbraco.Core
             configs.Add(() => new CoreDebug());
 
             // GridConfig depends on runtime caches, manifest parsers... and cannot be available during composition
-            configs.Add<IGridConfig>(factory => new GridConfig(factory.GetInstance<ILogger>(), factory.GetInstance<AppCaches>(), configDir, factory.GetInstance<IRuntimeState>().Debug));
+            configs.Add<IGridConfig>(factory => new GridConfig(
+                factory.GetInstance<ILogger>(),
+                factory.GetInstance<AppCaches>(),
+                configDir,
+                factory.GetInstance<ManifestParser>(),
+                factory.GetInstance<IRuntimeState>().Debug));
         }
     }
 }

src/Umbraco.Core/Configuration/Grid/GridConfig.cs

@@ -1,14 +1,15 @@
 using System.IO;
 using Umbraco.Core.Cache;
 using Umbraco.Core.Logging;
+using Umbraco.Core.Manifest;
 
 namespace Umbraco.Core.Configuration.Grid
 {
     class GridConfig : IGridConfig
     {
-        public GridConfig(ILogger logger, AppCaches appCaches, DirectoryInfo configFolder, bool isDebug)
+        public GridConfig(ILogger logger, AppCaches appCaches, DirectoryInfo configFolder, ManifestParser manifestParser, bool isDebug)
         {
-            EditorsConfig = new GridEditorsConfig(logger, appCaches, configFolder, isDebug);
+            EditorsConfig = new GridEditorsConfig(logger, appCaches, configFolder, manifestParser, isDebug);
         }
 
         public IGridEditorsConfig EditorsConfig { get; }

src/Umbraco.Core/Configuration/Grid/GridEditorsConfig.cs

@@ -1,9 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
-using Newtonsoft.Json.Linq;
 using Umbraco.Core.Cache;
-using Umbraco.Core.Composing;
 using Umbraco.Core.Logging;
 using Umbraco.Core.Manifest;
 using Umbraco.Core.PropertyEditors;
@@ -15,13 +13,15 @@ namespace Umbraco.Core.Configuration.Grid
         private readonly ILogger _logger;
         private readonly AppCaches _appCaches;
         private readonly DirectoryInfo _configFolder;
+        private readonly ManifestParser _manifestParser;
         private readonly bool _isDebug;
 
-        public GridEditorsConfig(ILogger logger, AppCaches appCaches, DirectoryInfo configFolder, bool isDebug)
+        public GridEditorsConfig(ILogger logger, AppCaches appCaches, DirectoryInfo configFolder, ManifestParser manifestParser, bool isDebug)
         {
             _logger = logger;
             _appCaches = appCaches;
             _configFolder = configFolder;
+            _manifestParser = manifestParser;
             _isDebug = isDebug;
         }
 
@@ -31,9 +31,6 @@ namespace Umbraco.Core.Configuration.Grid
             {
                 List<GridEditor> GetResult()
                 {
-                    // TODO: should use the common one somehow! + ignoring _appPlugins here!
-                    var parser = new ManifestParser(_appCaches, Current.ManifestValidators, _logger);
-
                     var editors = new List<GridEditor>();
                     var gridConfig = Path.Combine(_configFolder.FullName, "grid.editors.config.js");
                     if (File.Exists(gridConfig))
@@ -42,7 +39,7 @@ namespace Umbraco.Core.Configuration.Grid
 
                         try
                         {
-                            editors.AddRange(parser.ParseGridEditors(sourceString));
+                            editors.AddRange(_manifestParser.ParseGridEditors(sourceString));
                         }
                         catch (Exception ex)
                         {
@@ -51,7 +48,7 @@ namespace Umbraco.Core.Configuration.Grid
                     }
 
                     // add manifest editors, skip duplicates
-                    foreach (var gridEditor in parser.Manifest.GridEditors)
+                    foreach (var gridEditor in _manifestParser.Manifest.GridEditors)
                     {
                         if (editors.Contains(gridEditor) == false) editors.Add(gridEditor);
                     }

src/Umbraco.Core/Constants-Security.cs

@@ -15,13 +15,18 @@ namespace Umbraco.Core
             public const int SuperUserId = -1;
 
             /// <summary>
-            /// The id for the 'unknown' user
+            /// The id for the 'unknown' user.
             /// </summary>
             /// <remarks>
             /// This is a user row that exists in the DB only for referential integrity but the user is never returned from any of the services
             /// </remarks>
             public const int UnknownUserId = 0;
 
+            /// <summary>
+            /// The name of the 'unknown' user.
+            /// </summary>
+            public const string UnknownUserName = "SYTEM";
+
             public const string AdminGroupAlias = "admin";
             public const string SensitiveDataGroupAlias = "sensitiveData";
             public const string TranslatorGroupAlias = "translator";

src/Umbraco.Core/ContentVariationExtensions.cs

@@ -66,44 +66,44 @@ namespace Umbraco.Core
         /// <summary>
         /// Determines whether the content type is invariant.
         /// </summary>
-        public static bool VariesByNothing(this PublishedContentType contentType) => contentType.Variations.VariesByNothing();
+        public static bool VariesByNothing(this IPublishedContentType contentType) => contentType.Variations.VariesByNothing();
 
         /// <summary>
         /// Determines whether the content type varies by culture.
         /// </summary>
         /// <remarks>And then it could also vary by segment.</remarks>
-        public static bool VariesByCulture(this PublishedContentType contentType) => contentType.Variations.VariesByCulture();
+        public static bool VariesByCulture(this IPublishedContentType contentType) => contentType.Variations.VariesByCulture();
 
         /// <summary>
         /// Determines whether the content type varies by segment.
         /// </summary>
         /// <remarks>And then it could also vary by culture.</remarks>
-        public static bool VariesBySegment(this PublishedContentType contentType) => contentType.Variations.VariesBySegment();
+        public static bool VariesBySegment(this IPublishedContentType contentType) => contentType.Variations.VariesBySegment();
 
         /// <summary>
         /// Determines whether the content type varies by culture and segment.
         /// </summary>
-        public static bool VariesByCultureAndSegment(this PublishedContentType contentType) => contentType.Variations.VariesByCultureAndSegment();
+        public static bool VariesByCultureAndSegment(this IPublishedContentType contentType) => contentType.Variations.VariesByCultureAndSegment();
 
         /// <summary>
         /// Determines whether the property type is invariant.
         /// </summary>
-        public static bool VariesByNothing(this PublishedPropertyType propertyType) => propertyType.Variations.VariesByNothing();
+        public static bool VariesByNothing(this IPublishedPropertyType propertyType) => propertyType.Variations.VariesByNothing();
 
         /// <summary>
         /// Determines whether the property type varies by culture.
         /// </summary>
-        public static bool VariesByCulture(this PublishedPropertyType propertyType) => propertyType.Variations.VariesByCulture();
+        public static bool VariesByCulture(this IPublishedPropertyType propertyType) => propertyType.Variations.VariesByCulture();
 
         /// <summary>
         /// Determines whether the property type varies by segment.
         /// </summary>
-        public static bool VariesBySegment(this PublishedPropertyType propertyType) => propertyType.Variations.VariesBySegment();
+        public static bool VariesBySegment(this IPublishedPropertyType propertyType) => propertyType.Variations.VariesBySegment();
 
         /// <summary>
         /// Determines whether the property type varies by culture and segment.
         /// </summary>
-        public static bool VariesByCultureAndSegment(this PublishedPropertyType propertyType) => propertyType.Variations.VariesByCultureAndSegment();
+        public static bool VariesByCultureAndSegment(this IPublishedPropertyType propertyType) => propertyType.Variations.VariesByCultureAndSegment();
 
         /// <summary>
         /// Determines whether a variation is invariant.

src/Umbraco.Core/Logging/Viewer/ILogViewer.cs

@@ -26,26 +26,26 @@ namespace Umbraco.Core.Logging.Viewer
         /// A count of number of errors
         /// By counting Warnings with Exceptions, Errors & Fatal messages
         /// </summary>
-        int GetNumberOfErrors(DateTimeOffset startDate, DateTimeOffset endDate);
+        int GetNumberOfErrors(LogTimePeriod logTimePeriod);
 
         /// <summary>
         /// Returns a number of the different log level entries
         /// </summary>
-        LogLevelCounts GetLogLevelCounts(DateTimeOffset startDate, DateTimeOffset endDate);
+        LogLevelCounts GetLogLevelCounts(LogTimePeriod logTimePeriod);
 
         /// <summary>
         /// Returns a list of all unique message templates and their counts
         /// </summary>
-        IEnumerable<LogTemplate> GetMessageTemplates(DateTimeOffset startDate, DateTimeOffset endDate);
+        IEnumerable<LogTemplate> GetMessageTemplates(LogTimePeriod logTimePeriod);
 
         bool CanHandleLargeLogs { get; }
 
-        bool CheckCanOpenLogs(DateTimeOffset startDate, DateTimeOffset endDate);
+        bool CheckCanOpenLogs(LogTimePeriod logTimePeriod);
 
         /// <summary>
         /// Returns the collection of logs
         /// </summary>
-        PagedResult<LogMessage> GetLogs(DateTimeOffset startDate, DateTimeOffset endDate,
+        PagedResult<LogMessage> GetLogs(LogTimePeriod logTimePeriod,
             int pageNumber = 1,
             int pageSize = 100,
             Direction orderDirection = Direction.Descending,

src/Umbraco.Core/Logging/Viewer/JsonLogViewer.cs

@@ -26,7 +26,7 @@ namespace Umbraco.Core.Logging.Viewer
 
         public override bool CanHandleLargeLogs => false;
 
-        public override bool CheckCanOpenLogs(DateTimeOffset startDate, DateTimeOffset endDate)
+        public override bool CheckCanOpenLogs(LogTimePeriod logTimePeriod)
         {
             //Log Directory
             var logDirectory = _logsPath;
@@ -36,7 +36,7 @@ namespace Umbraco.Core.Logging.Viewer
 
             //foreach full day in the range - see if we can find one or more filenames that end with
             //yyyyMMdd.json - Ends with due to MachineName in filenames - could be 1 or more due to load balancing
-            for (var day = startDate.Date; day.Date <= endDate.Date; day = day.AddDays(1))
+            for (var day = logTimePeriod.StartTime.Date; day.Date <= logTimePeriod.EndTime.Date; day = day.AddDays(1))
             {
                 //Filename ending to search for (As could be multiple)
                 var filesToFind = GetSearchPattern(day);
@@ -57,7 +57,7 @@ namespace Umbraco.Core.Logging.Viewer
             return $"*{day:yyyyMMdd}*.json";
         }
 
-        protected override IReadOnlyList<LogEvent> GetLogs(DateTimeOffset startDate, DateTimeOffset endDate, ILogFilter filter, int skip, int take)
+        protected override IReadOnlyList<LogEvent> GetLogs(LogTimePeriod logTimePeriod, ILogFilter filter, int skip, int take)
         {
             var logs = new List<LogEvent>();
 
@@ -68,7 +68,7 @@ namespace Umbraco.Core.Logging.Viewer
 
             //foreach full day in the range - see if we can find one or more filenames that end with
             //yyyyMMdd.json - Ends with due to MachineName in filenames - could be 1 or more due to load balancing
-            for (var day = startDate.Date; day.Date <= endDate.Date; day = day.AddDays(1))
+            for (var day = logTimePeriod.StartTime.Date; day.Date <= logTimePeriod.EndTime.Date; day = day.AddDays(1))
             {
                 //Filename ending to search for (As could be multiple)
                 var filesToFind = GetSearchPattern(day);

src/Umbraco.Core/Logging/Viewer/LogTimePeriod.cs

@@ -0,0 +1,16 @@
+using System;
+
+namespace Umbraco.Core.Logging.Viewer
+{
+    public class LogTimePeriod
+    {
+        public LogTimePeriod(DateTime startTime, DateTime endTime)
+        {
+            StartTime = startTime;
+            EndTime = endTime;
+        }
+
+        public DateTime StartTime { get; }
+        public DateTime EndTime { get; }
+    }
+}

src/Umbraco.Core/Logging/Viewer/LogViewerSourceBase.cs

@@ -27,9 +27,9 @@ namespace Umbraco.Core.Logging.Viewer
         /// <summary>
         /// Get all logs from your chosen data source back as Serilog LogEvents
         /// </summary>
-        protected abstract IReadOnlyList<LogEvent> GetLogs(DateTimeOffset startDate, DateTimeOffset endDate, ILogFilter filter, int skip, int take);
+        protected abstract IReadOnlyList<LogEvent> GetLogs(LogTimePeriod logTimePeriod, ILogFilter filter, int skip, int take);
 
-        public abstract bool CheckCanOpenLogs(DateTimeOffset startDate, DateTimeOffset endDate);
+        public abstract bool CheckCanOpenLogs(LogTimePeriod logTimePeriod);
 
         public virtual IReadOnlyList<SavedLogSearch> GetSavedSearches()
         {
@@ -82,24 +82,24 @@ namespace Umbraco.Core.Logging.Viewer
             return searches;
         }
 
-        public int GetNumberOfErrors(DateTimeOffset startDate, DateTimeOffset endDate)
+        public int GetNumberOfErrors(LogTimePeriod logTimePeriod)
         {
             var errorCounter = new ErrorCounterFilter();
-            GetLogs(startDate, endDate, errorCounter, 0, int.MaxValue);
+            GetLogs(logTimePeriod, errorCounter, 0, int.MaxValue);
             return errorCounter.Count;
         }
 
-        public LogLevelCounts GetLogLevelCounts(DateTimeOffset startDate, DateTimeOffset endDate)
+        public LogLevelCounts GetLogLevelCounts(LogTimePeriod logTimePeriod)
         {
             var counter = new CountingFilter();
-            GetLogs(startDate, endDate, counter, 0, int.MaxValue);
+            GetLogs(logTimePeriod, counter, 0, int.MaxValue);
             return counter.Counts;
         }
 
-        public IEnumerable<LogTemplate> GetMessageTemplates(DateTimeOffset startDate, DateTimeOffset endDate)
+        public IEnumerable<LogTemplate> GetMessageTemplates(LogTimePeriod logTimePeriod)
         {
             var messageTemplates = new MessageTemplateFilter();
-            GetLogs(startDate, endDate, messageTemplates, 0, int.MaxValue);
+            GetLogs(logTimePeriod, messageTemplates, 0, int.MaxValue);
 
             var templates = messageTemplates.Counts.
                 Select(x => new LogTemplate { MessageTemplate = x.Key, Count = x.Value })
@@ -108,14 +108,14 @@ namespace Umbraco.Core.Logging.Viewer
             return templates;
         }
 
-        public PagedResult<LogMessage> GetLogs(DateTimeOffset startDate, DateTimeOffset endDate,
+        public PagedResult<LogMessage> GetLogs(LogTimePeriod logTimePeriod,
             int pageNumber = 1, int pageSize = 100,
             Direction orderDirection = Direction.Descending,
             string filterExpression = null,
             string[] logLevels = null)
         {
             var expression = new ExpressionFilter(filterExpression);
-            var filteredLogs = GetLogs(startDate, endDate, expression, 0, int.MaxValue);
+            var filteredLogs = GetLogs(logTimePeriod, expression, 0, int.MaxValue);
 
             //This is user used the checkbox UI to toggle which log levels they wish to see
             //If an empty array or null - its implied all levels to be viewed

src/Umbraco.Core/Manifest/IManifestFilter.cs

@@ -0,0 +1,19 @@
+using System.Collections.Generic;
+
+namespace Umbraco.Core.Manifest
+{
+    /// <summary>
+    /// Provides filtering for package manifests.
+    /// </summary>
+    public interface IManifestFilter
+    {
+        /// <summary>
+        /// Filters package manifests.
+        /// </summary>
+        /// <param name="manifests">The package manifests.</param>
+        /// <remarks>
+        /// <para>It is possible to remove, change, or add manifests.</para>
+        /// </remarks>
+        void Filter(List<PackageManifest> manifests);
+    }
+}

src/Umbraco.Core/Manifest/ManifestFilterCollection.cs

@@ -0,0 +1,28 @@
+using System.Collections.Generic;
+using Umbraco.Core.Composing;
+
+namespace Umbraco.Core.Manifest
+{
+    /// <summary>
+    /// Contains the manifest filters.
+    /// </summary>
+    public class ManifestFilterCollection : BuilderCollectionBase<IManifestFilter>
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ManifestFilterCollection"/> class.
+        /// </summary>
+        public ManifestFilterCollection(IEnumerable<IManifestFilter> items)
+            : base(items)
+        { }
+
+        /// <summary>
+        /// Filters package manifests.
+        /// </summary>
+        /// <param name="manifests">The package manifests.</param>
+        public void Filter(List<PackageManifest> manifests)
+        {
+            foreach (var filter in this)
+                filter.Filter(manifests);
+        }
+    }
+}

src/Umbraco.Core/Manifest/ManifestFilterCollectionBuilder.cs

@@ -0,0 +1,12 @@
+using Umbraco.Core.Composing;
+
+namespace Umbraco.Core.Manifest
+{
+    public class ManifestFilterCollectionBuilder : OrderedCollectionBuilderBase<ManifestFilterCollectionBuilder, ManifestFilterCollection, IManifestFilter>
+    {
+        protected override ManifestFilterCollectionBuilder This => this;
+
+        // do NOT cache this, it's only used once
+        protected override Lifetime CollectionLifetime => Lifetime.Transient;
+    }
+}

src/Umbraco.Core/Manifest/ManifestParser.cs

@@ -22,24 +22,26 @@ namespace Umbraco.Core.Manifest
         private readonly IAppPolicyCache _cache;
         private readonly ILogger _logger;
         private readonly ManifestValueValidatorCollection _validators;
+        private readonly ManifestFilterCollection _filters;
 
         private string _path;
 
         /// <summary>
         /// Initializes a new instance of the <see cref="ManifestParser"/> class.
         /// </summary>
-        public ManifestParser(AppCaches appCaches, ManifestValueValidatorCollection validators, ILogger logger)
-            : this(appCaches, validators, "~/App_Plugins", logger)
+        public ManifestParser(AppCaches appCaches, ManifestValueValidatorCollection validators, ManifestFilterCollection filters, ILogger logger)
+            : this(appCaches, validators, filters, "~/App_Plugins", logger)
         { }
 
         /// <summary>
         /// Initializes a new instance of the <see cref="ManifestParser"/> class.
         /// </summary>
-        private ManifestParser(AppCaches appCaches, ManifestValueValidatorCollection validators, string path, ILogger logger)
+        private ManifestParser(AppCaches appCaches, ManifestValueValidatorCollection validators, ManifestFilterCollection filters, string path, ILogger logger)
         {
             if (appCaches == null) throw new ArgumentNullException(nameof(appCaches));
             _cache = appCaches.RuntimeCache;
             _validators = validators ?? throw new ArgumentNullException(nameof(validators));
+            _filters = filters ?? throw new ArgumentNullException(nameof(filters));
             if (string.IsNullOrWhiteSpace(path)) throw new ArgumentNullOrEmptyException(nameof(path));
             Path = path;
             _logger = logger ?? throw new ArgumentNullException(nameof(logger));
@@ -78,6 +80,7 @@ namespace Umbraco.Core.Manifest
                     if (string.IsNullOrWhiteSpace(text))
                         continue;
                     var manifest = ParseManifest(text);
+                    manifest.Source = path;
                     manifests.Add(manifest);
                 }
                 catch (Exception e)
@@ -86,6 +89,8 @@ namespace Umbraco.Core.Manifest
                 }
             }
 
+            _filters.Filter(manifests);
+
             return manifests;
         }
 

src/Umbraco.Core/Manifest/PackageManifest.cs

@@ -9,6 +9,16 @@ namespace Umbraco.Core.Manifest
     /// </summary>
     public class PackageManifest
     {
+        /// <summary>
+        /// Gets the source path of the manifest.
+        /// </summary>
+        /// <remarks>
+        /// <para>Gets the full absolute file path of the manifest,
+        /// using system directory separators.</para>
+        /// </remarks>
+        [JsonIgnore]
+        public string Source { get; set; }
+
         /// <summary>
         /// Gets or sets the scripts listed in the manifest.
         /// </summary>

src/Umbraco.Core/Mapping/UmbracoMapper.cs

@@ -191,7 +191,7 @@ namespace Umbraco.Core.Mapping
         private TTarget Map<TTarget>(object source, Type sourceType, MapperContext context)
         {
             if (source == null)
-                throw new ArgumentNullException(nameof(source));
+                return default;
 
             var targetType = typeof(TTarget);
 

src/Umbraco.Core/Migrations/Expressions/Create/KeysAndIndexes/CreateKeysAndIndexesBuilder.cs

@@ -25,11 +25,25 @@ namespace Umbraco.Core.Migrations.Expressions.Create.KeysAndIndexes
             var syntax = _context.SqlContext.SqlSyntax;
             var tableDefinition = DefinitionFactory.GetTableDefinition(TypeOfDto, syntax);
 
+            // note: of course we are creating the keys and indexes as per the DTO, so
+            // changing the DTO may break old migrations - or, better, these migrations
+            // should capture a copy of the DTO class that will not change
+
             ExecuteSql(syntax.FormatPrimaryKey(tableDefinition));
             foreach (var sql in syntax.Format(tableDefinition.Indexes))
                 ExecuteSql(sql);
             foreach (var sql in syntax.Format(tableDefinition.ForeignKeys))
                 ExecuteSql(sql);
+
+            // note: we do *not* create the DF_ default constraints
+            /*
+            foreach (var column in tableDefinition.Columns)
+            {
+                var sql = syntax.FormatDefaultConstraint(column);
+                if (!sql.IsNullOrWhiteSpace())
+                    ExecuteSql(sql);
+            }
+            */
         }
 
         private void ExecuteSql(string sql)

src/Umbraco.Core/Migrations/Expressions/Delete/DefaultConstraint/DeleteDefaultConstraintBuilder.cs

@@ -10,9 +10,13 @@ namespace Umbraco.Core.Migrations.Expressions.Delete.DefaultConstraint
         IDeleteDefaultConstraintOnTableBuilder,
         IDeleteDefaultConstraintOnColumnBuilder
     {
-        public DeleteDefaultConstraintBuilder(DeleteDefaultConstraintExpression expression)
+        private readonly IMigrationContext _context;
+
+        public DeleteDefaultConstraintBuilder(IMigrationContext context, DeleteDefaultConstraintExpression expression)
             : base(expression)
-        { }
+        {
+            _context = context;
+        }
 
         /// <inheritdoc />
         public IDeleteDefaultConstraintOnColumnBuilder OnTable(string tableName)
@@ -25,6 +29,9 @@ namespace Umbraco.Core.Migrations.Expressions.Delete.DefaultConstraint
         public IExecutableBuilder OnColumn(string columnName)
         {
             Expression.ColumnName = columnName;
+            Expression.HasDefaultConstraint = _context.SqlContext.SqlSyntax.TryGetDefaultConstraint(_context.Database, Expression.TableName, columnName, out var constraintName);
+            Expression.ConstraintName = constraintName ?? string.Empty;
+
             return new ExecutableBuilder(Expression);
         }
     }

src/Umbraco.Core/Migrations/Expressions/Delete/DeleteBuilder.cs

@@ -1,4 +1,4 @@
-using NPoco;
+using Umbraco.Core.Exceptions;
 using Umbraco.Core.Migrations.Expressions.Common;
 using Umbraco.Core.Migrations.Expressions.Delete.Column;
 using Umbraco.Core.Migrations.Expressions.Delete.Constraint;
@@ -29,9 +29,19 @@ namespace Umbraco.Core.Migrations.Expressions.Delete
         }
 
         /// <inheritdoc />
-        public IExecutableBuilder KeysAndIndexes(string tableName = null)
+        public IExecutableBuilder KeysAndIndexes<TDto>(bool local = true, bool foreign = true)
         {
-            return new DeleteKeysAndIndexesBuilder(_context) { TableName = tableName };
+            var syntax = _context.SqlContext.SqlSyntax;
+            var tableDefinition = DefinitionFactory.GetTableDefinition(typeof(TDto), syntax);
+            return KeysAndIndexes(tableDefinition.Name, local, foreign);
+        }
+
+        /// <inheritdoc />
+        public IExecutableBuilder KeysAndIndexes(string tableName, bool local = true, bool foreign = true)
+        {
+            if (tableName.IsNullOrWhiteSpace())
+                throw new ArgumentNullOrEmptyException(nameof(tableName));
+            return new DeleteKeysAndIndexesBuilder(_context) { TableName = tableName, DeleteLocal = local, DeleteForeign = foreign };
         }
 
         /// <inheritdoc />
@@ -100,7 +110,7 @@ namespace Umbraco.Core.Migrations.Expressions.Delete
         public IDeleteDefaultConstraintOnTableBuilder DefaultConstraint()
         {
             var expression = new DeleteDefaultConstraintExpression(_context);
-            return new DeleteDefaultConstraintBuilder(expression);
+            return new DeleteDefaultConstraintBuilder(_context, expression);
         }
     }
 }

src/Umbraco.Core/Migrations/Expressions/Delete/Expressions/DeleteDefaultConstraintExpression.cs

@@ -10,12 +10,17 @@ namespace Umbraco.Core.Migrations.Expressions.Delete.Expressions
 
         public virtual string TableName { get; set; }
         public virtual string ColumnName { get; set; }
+        public virtual string ConstraintName { get; set; }
+        public virtual bool HasDefaultConstraint { get; set; }
 
         protected override string GetSql()
         {
-            return string.Format(SqlSyntax.DeleteDefaultConstraint,
-                SqlSyntax.GetQuotedTableName(TableName),
-                SqlSyntax.GetQuotedColumnName(ColumnName));
+            return HasDefaultConstraint
+                ? string.Format(SqlSyntax.DeleteDefaultConstraint,
+                    SqlSyntax.GetQuotedTableName(TableName),
+                    SqlSyntax.GetQuotedColumnName(ColumnName),
+                    SqlSyntax.GetQuotedName(ConstraintName))
+                : string.Empty;
         }
     }
 }

src/Umbraco.Core/Migrations/Expressions/Delete/IDeleteBuilder.cs

@@ -19,9 +19,14 @@ namespace Umbraco.Core.Migrations.Expressions.Delete
         IExecutableBuilder Table(string tableName);
 
         /// <summary>
-        /// Specifies the table to delete keys and indexes for.
+        /// Builds a Delete Keys and Indexes expression, and executes.
         /// </summary>
-        IExecutableBuilder KeysAndIndexes(string tableName = null);
+        IExecutableBuilder KeysAndIndexes<TDto>(bool local = true, bool foreign = true);
+
+        /// <summary>
+        /// Builds a Delete Keys and Indexes expression, and executes.
+        /// </summary>
+        IExecutableBuilder KeysAndIndexes(string tableName, bool local = true, bool foreign = true);
 
         /// <summary>
         /// Specifies the column to delete.

src/Umbraco.Core/Migrations/Expressions/Delete/KeysAndIndexes/DeleteKeysAndIndexesBuilder.cs

@@ -18,34 +18,38 @@ namespace Umbraco.Core.Migrations.Expressions.Delete.KeysAndIndexes
 
         public string TableName { get; set; }
 
+        public bool DeleteLocal { get; set; }
+
+        public bool DeleteForeign { get; set; }
+
         /// <inheritdoc />
         public void Do()
         {
-            if (TableName == null)
-            {
-                // drop keys
-                var keys = _context.SqlContext.SqlSyntax.GetConstraintsPerTable(_context.Database).DistinctBy(x => x.Item2).ToArray();
-                foreach (var key in keys.Where(x => x.Item2.StartsWith("FK_")))
-                    Delete.ForeignKey(key.Item2).OnTable(key.Item1).Do();
-                foreach (var key in keys.Where(x => x.Item2.StartsWith("PK_")))
-                    Delete.PrimaryKey(key.Item2).FromTable(key.Item1).Do();
+            _context.BuildingExpression = false;
 
-                // drop indexes
-                var indexes = _context.SqlContext.SqlSyntax.GetDefinedIndexesDefinitions(_context.Database).DistinctBy(x => x.IndexName).ToArray();
-                foreach (var index in indexes)
-                    Delete.Index(index.IndexName).OnTable(index.TableName).Do();
+            // drop keys
+            if (DeleteLocal || DeleteForeign)
+            {
+                // table, constraint
+                var tableKeys = _context.SqlContext.SqlSyntax.GetConstraintsPerTable(_context.Database).DistinctBy(x => x.Item2).ToList();
+                if (DeleteForeign)
+                {
+                    foreach (var key in tableKeys.Where(x => x.Item1 == TableName && x.Item2.StartsWith("FK_")))
+                        Delete.ForeignKey(key.Item2).OnTable(key.Item1).Do();
+                }
+                if (DeleteLocal)
+                {
+                    foreach (var key in tableKeys.Where(x => x.Item1 == TableName && x.Item2.StartsWith("PK_")))
+                        Delete.PrimaryKey(key.Item2).FromTable(key.Item1).Do();
+
+                    // note: we do *not* delete the DEFAULT constraints
+                }
             }
-            else
-            {
-                // drop keys
-                var keys = _context.SqlContext.SqlSyntax.GetConstraintsPerTable(_context.Database).DistinctBy(x => x.Item2).ToArray();
-                foreach (var key in keys.Where(x => x.Item1 == TableName && x.Item2.StartsWith("FK_")))
-                    Delete.ForeignKey(key.Item2).OnTable(key.Item1).Do();
-                foreach (var key in keys.Where(x => x.Item1 == TableName && x.Item2.StartsWith("PK_")))
-                    Delete.PrimaryKey(key.Item2).FromTable(key.Item1).Do();
 
-                // drop indexes
-                var indexes = _context.SqlContext.SqlSyntax.GetDefinedIndexesDefinitions(_context.Database).DistinctBy(x => x.IndexName).ToArray();
+            // drop indexes
+            if (DeleteLocal)
+            {
+                var indexes = _context.SqlContext.SqlSyntax.GetDefinedIndexesDefinitions(_context.Database).DistinctBy(x => x.IndexName).ToList();
                 foreach (var index in indexes.Where(x => x.TableName == TableName))
                     Delete.Index(index.IndexName).OnTable(index.TableName).Do();
             }

src/Umbraco.Core/Migrations/IMigrationContext.cs

@@ -36,7 +36,7 @@ namespace Umbraco.Core.Migrations
         bool BuildingExpression { get; set; }
 
         /// <summary>
-        /// Adds a post-migrations.
+        /// Adds a post-migration.
         /// </summary>
         void AddPostMigration<TMigration>()
             where TMigration : IMigration;

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

@@ -389,7 +389,7 @@ namespace Umbraco.Core.Migrations.Install
 
         private DatabaseSchemaResult ValidateSchema(IScope scope)
         {
-            if (_databaseFactory.Configured == false)
+            if (_databaseFactory.Initialized == false)
                 return new DatabaseSchemaResult(_databaseFactory.SqlContext.SqlSyntax);
 
             if (_databaseSchemaValidationResult != null)
@@ -513,7 +513,7 @@ namespace Umbraco.Core.Migrations.Install
 
         private Attempt<Result> CheckReadyForInstall()
         {
-            if (_databaseFactory.Configured == false)
+            if (_databaseFactory.CanConnect == false)
             {
                 return Attempt.Fail(new Result
                 {
@@ -539,7 +539,7 @@ namespace Umbraco.Core.Migrations.Install
             {
                 Message =
                     "The database configuration failed with the following message: " + ex.Message +
-                    "\n Please check log file for additional information (can be found in '/App_Data/Logs/UmbracoTraceLog.txt')",
+                    "\n Please check log file for additional information (can be found in '/App_Data/Logs/')",
                 Success = false,
                 Percentage = "90"
             };

src/Umbraco.Core/Migrations/MigrationContext.cs

@@ -41,6 +41,7 @@ namespace Umbraco.Core.Migrations
         public void AddPostMigration<TMigration>()
             where TMigration : IMigration
         {
+            // just adding - will be de-duplicated when executing
             PostMigrations.Add(typeof(TMigration));
         }
     }

src/Umbraco.Core/Migrations/MigrationExpressionBase.cs

@@ -92,6 +92,7 @@ namespace Umbraco.Core.Migrations
             if (_executed)
                 throw new InvalidOperationException("This expression has already been executed.");
             _executed = true;
+            Context.BuildingExpression = false;
 
             if (sql == null)
             {

src/Umbraco.Core/Migrations/MigrationPlan.cs

@@ -240,7 +240,8 @@ namespace Umbraco.Core.Migrations
                 if (finalState == null)
                     finalState = kvp.Key;
                 else
-                    throw new Exception("Multiple final states have been detected.");
+                    throw new InvalidOperationException($"Multiple final states have been detected in the plan (\"{finalState}\", \"{kvp.Key}\")."
+                                                            + " Make sure the plan contains only one final state.");
             }
 
             // now check for loops
@@ -254,7 +255,8 @@ namespace Umbraco.Core.Migrations
                 while (nextTransition != null && !verified.Contains(nextTransition.SourceState))
                 {
                     if (visited.Contains(nextTransition.SourceState))
-                        throw new Exception("A loop has been detected.");
+                        throw new InvalidOperationException($"A loop has been detected in the plan around state \"{nextTransition.SourceState}\"."
+                                                                + " Make sure the plan does not contain circular transition paths.");
                     visited.Add(nextTransition.SourceState);
                     nextTransition = _transitions[nextTransition.TargetState];
                 }
@@ -264,6 +266,14 @@ namespace Umbraco.Core.Migrations
             _finalState = finalState;
         }
 
+        /// <summary>
+        /// Throws an exception when the initial state is unknown.
+        /// </summary>
+        protected virtual void ThrowOnUnknownInitialState(string state)
+        {
+            throw new InvalidOperationException($"The migration plan does not support migrating from state \"{state}\".");
+        }
+
         /// <summary>
         /// Executes the plan.
         /// </summary>
@@ -287,13 +297,15 @@ namespace Umbraco.Core.Migrations
             logger.Info<MigrationPlan>("At {OrigState}", string.IsNullOrWhiteSpace(origState) ? "origin": origState);
 
             if (!_transitions.TryGetValue(origState, out var transition))
-                throw new Exception($"Unknown state \"{origState}\".");
+                ThrowOnUnknownInitialState(origState);
 
             var context = new MigrationContext(scope.Database, logger);
             context.PostMigrations.AddRange(_postMigrationTypes);
 
             while (transition != null)
             {
+                logger.Info<MigrationPlan>("Execute {MigrationType}", transition.MigrationType.Name);
+
                 var migration = migrationBuilder.Build(transition.MigrationType, context);
                 migration.Migrate();
 
@@ -302,6 +314,8 @@ namespace Umbraco.Core.Migrations
 
                 logger.Info<MigrationPlan>("At {OrigState}", origState);
 
+                // throw a raw exception here: this should never happen as the plan has
+                // been validated - this is just a paranoid safety test
                 if (!_transitions.TryGetValue(origState, out transition))
                     throw new Exception($"Unknown state \"{origState}\".");
             }
@@ -322,7 +336,8 @@ namespace Umbraco.Core.Migrations
 
             logger.Info<MigrationPlan>("Done (pending scope completion).");
 
-            // safety check
+            // safety check - again, this should never happen as the plan has been validated,
+            // and this is just a paranoid safety test
             if (origState != _finalState)
                 throw new Exception($"Internal error, reached state {origState} which is not final state {_finalState}");
 

src/Umbraco.Core/Migrations/Upgrade/Common/CreateKeysAndIndexes.cs

@@ -0,0 +1,21 @@
+using Umbraco.Core.Migrations.Install;
+
+namespace Umbraco.Core.Migrations.Upgrade.Common
+{
+    public class CreateKeysAndIndexes : MigrationBase
+    {
+        public CreateKeysAndIndexes(IMigrationContext context)
+            : base(context)
+        { }
+
+        public override void Migrate()
+        {
+            // remove those that may already have keys
+            Delete.KeysAndIndexes(Constants.DatabaseSchema.Tables.KeyValue).Do();
+
+            // re-create *all* keys and indexes
+            foreach (var x in DatabaseSchemaCreator.OrderedTables)
+                Create.KeysAndIndexes(x).Do();
+        }
+    }
+}

src/Umbraco.Core/Migrations/Upgrade/Common/DeleteKeysAndIndexes.cs

@@ -0,0 +1,75 @@
+namespace Umbraco.Core.Migrations.Upgrade.Common
+{
+    public class DeleteKeysAndIndexes : MigrationBase
+    {
+        public DeleteKeysAndIndexes(IMigrationContext context)
+            : base(context)
+        { }
+
+        public override void Migrate()
+        {
+            // all v7.14 tables
+            var tables = new[]
+            {
+                "cmsContent",
+                "cmsContentType",
+                "cmsContentType2ContentType",
+                "cmsContentTypeAllowedContentType",
+                "cmsContentVersion",
+                "cmsContentXml",
+                "cmsDataType",
+                "cmsDataTypePreValues",
+                "cmsDictionary",
+                "cmsDocument",
+                "cmsDocumentType",
+                "cmsLanguageText",
+                "cmsMacro",
+                "cmsMacroProperty",
+                "cmsMedia",
+                "cmsMember",
+                "cmsMember2MemberGroup",
+                "cmsMemberType",
+                "cmsPreviewXml",
+                "cmsPropertyData",
+                "cmsPropertyType",
+                "cmsPropertyTypeGroup",
+                "cmsTagRelationship",
+                "cmsTags",
+                "cmsTask",
+                "cmsTaskType",
+                "cmsTemplate",
+                "umbracoAccess",
+                "umbracoAccessRule",
+                "umbracoAudit",
+                "umbracoCacheInstruction",
+                "umbracoConsent",
+                "umbracoDomains",
+                "umbracoExternalLogin",
+                "umbracoLanguage",
+                "umbracoLock",
+                "umbracoLog",
+                "umbracoMigration",
+                "umbracoNode",
+                "umbracoRedirectUrl",
+                "umbracoRelation",
+                "umbracoRelationType",
+                "umbracoServer",
+                "umbracoUser",
+                "umbracoUser2NodeNotify",
+                "umbracoUser2UserGroup",
+                "umbracoUserGroup",
+                "umbracoUserGroup2App",
+                "umbracoUserGroup2NodePermission",
+                "umbracoUserLogin",
+                "umbracoUserStartNode",
+            };
+
+            // delete *all* keys and indexes - because of FKs
+            // on known v7 tables only
+            foreach (var table in tables)
+                Delete.KeysAndIndexes(table, false, true).Do();
+            foreach (var table in tables)
+                Delete.KeysAndIndexes(table, true, false).Do();
+        }
+    }
+}

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

@@ -2,8 +2,7 @@
 using System.Configuration;
 using Semver;
 using Umbraco.Core.Configuration;
-using Umbraco.Core.Migrations.Upgrade.V_7_12_0;
-using Umbraco.Core.Migrations.Upgrade.V_7_14_0;
+using Umbraco.Core.Migrations.Upgrade.Common;
 using Umbraco.Core.Migrations.Upgrade.V_8_0_0;
 using Umbraco.Core.Migrations.Upgrade.V_8_0_1;
 using Umbraco.Core.Migrations.Upgrade.V_8_1_0;
@@ -15,6 +14,9 @@ namespace Umbraco.Core.Migrations.Upgrade
     /// </summary>
     public class UmbracoPlan : MigrationPlan
     {
+        private const string InitPrefix = "{init-";
+        private const string InitSuffix = "}";
+
         /// <summary>
         /// Initializes a new instance of the <see cref="UmbracoPlan"/> class.
         /// </summary>
@@ -24,6 +26,27 @@ namespace Umbraco.Core.Migrations.Upgrade
             DefinePlan();
         }
 
+        /// <summary>
+        /// Gets the initial state corresponding to a version.
+        /// </summary>
+        private static string GetInitState(SemVersion version)
+            => InitPrefix + version + InitSuffix;
+
+        /// <summary>
+        /// Tries to extract a version from an initial state.
+        /// </summary>
+        private static bool TryGetInitStateVersion(string state, out string version)
+        {
+            if (state.StartsWith(InitPrefix) && state.EndsWith(InitSuffix))
+            {
+                version = state.TrimStart(InitPrefix).TrimEnd(InitSuffix);
+                return true;
+            }
+
+            version = null;
+            return false;
+        }
+
         /// <inheritdoc />
         /// <remarks>
         /// <para>The default initial state in plans is string.Empty.</para>
@@ -41,23 +64,32 @@ namespace Umbraco.Core.Migrations.Upgrade
                 if (!SemVersion.TryParse(ConfigurationManager.AppSettings[Constants.AppSettings.ConfigurationStatus], out var currentVersion))
                     throw new InvalidOperationException($"Could not get current version from web.config {Constants.AppSettings.ConfigurationStatus} appSetting.");
 
-                // we currently support upgrading from 7.10.0 and later
-                if (currentVersion < new SemVersion(7, 10))
-                    throw new InvalidOperationException($"Version {currentVersion} cannot be migrated to {UmbracoVersion.SemanticVersion}.");
-
                 // cannot go back in time
                 if (currentVersion > UmbracoVersion.SemanticVersion)
                     throw new InvalidOperationException($"Version {currentVersion} cannot be downgraded to {UmbracoVersion.SemanticVersion}.");
 
-                // upgrading from version 7 => initial state is eg "{init-7.10.0}"
-                // anything else is not supported - ie if 8 and above, we should have an initial state already
-                if (currentVersion.Major != 7)
-                    throw new InvalidOperationException($"Version {currentVersion} is not supported by the migration plan.");
+                // only from 7.14.0 and above
+                var minVersion = new SemVersion(7, 14);
+                if (currentVersion < minVersion)
+                    throw new InvalidOperationException($"Version {currentVersion} cannot be migrated to {UmbracoVersion.SemanticVersion}."
+                                                        + $" Please upgrade first to at least {minVersion}.");
 
-                return "{init-" + currentVersion + "}";
+                // initial state is eg "{init-7.14.0}"
+                return GetInitState(currentVersion);
             }
         }
 
+        protected override void ThrowOnUnknownInitialState(string state)
+        {
+            if (TryGetInitStateVersion(state, out var initVersion))
+            {
+                throw new InvalidOperationException($"Version {UmbracoVersion.SemanticVersion} does not support migrating from {initVersion}."
+                                                    + $" Please verify which versions support migrating from {initVersion}.");
+            }
+
+            base.ThrowOnUnknownInitialState(state);
+        }
+
         // define the plan
         protected void DefinePlan()
         {
@@ -70,21 +102,23 @@ namespace Umbraco.Core.Migrations.Upgrade
             //
             //     If the new migration causes a merge conflict, because someone else also added another
             //     new migration, you NEED to fix the conflict by providing one default path, and paths
-            //     out of the conflict states (see example below).
+            //     out of the conflict states (see examples below).
             //
             // * Porting from version 7:
             //     Append the ported migration to the main chain, using a new guid (same as above).
-            //     Create a new special chain from the {init-...} state to the main chain (see example
-            //     below).
+            //     Create a new special chain from the {init-...} state to the main chain.
 
 
-            // plan starts at 7.10.0 (anything before 7.10.0 is not supported)
-            // upgrades from 7 to 8, and then takes care of all eventual upgrades
+            // plan starts at 7.14.0 (anything before 7.14.0 is not supported)
             //
-            From("{init-7.10.0}");
+            From(GetInitState(new SemVersion(7, 14, 0)));
+
+            // begin migrating from v7 - remove all keys and indexes
+            To<DeleteKeysAndIndexes>("{B36B9ABD-374E-465B-9C5F-26AB0D39326F}");
+
             To<AddLockObjects>("{7C447271-CA3F-4A6A-A913-5D77015655CB}");
             To<AddContentNuTable>("{CBFF58A2-7B50-4F75-8E98-249920DB0F37}");
-            To<RefactorXmlColumns>("{3D18920C-E84D-405C-A06A-B7CEE52FE5DD}");
+            To<RenameMediaVersionTable>("{5CB66059-45F4-48BA-BCBD-C5035D79206B}");
             To<VariantsMigration>("{FB0A5429-587E-4BD0-8A67-20F0E7E62FF7}");
             To<DropMigrationsTable>("{F0C42457-6A3B-4912-A7EA-F27ED85A2092}");
             To<DataTypeMigration>("{8640C9E4-A1C0-4C59-99BB-609B4E604981}");
@@ -95,91 +129,55 @@ namespace Umbraco.Core.Migrations.Upgrade
             ToWithReplace<AddVariationTables2, AddVariationTables1A>("{941B2ABA-2D06-4E04-81F5-74224F1DB037}", "{76DF5CD7-A884-41A5-8DC6-7860D95B1DF5}"); // kill AddVariationTable1
             To<RefactorMacroColumns>("{A7540C58-171D-462A-91C5-7A9AA5CB8BFD}");
 
-            Merge().To<UserForeignKeys>("{3E44F712-E2E3-473A-AE49-5D7F8E67CE3F}") // shannon added that one
-            .With().To<AddTypedLabels>("{65D6B71C-BDD5-4A2E-8D35-8896325E9151}") // stephan added that one
+            Merge()
+                .To<UserForeignKeys>("{3E44F712-E2E3-473A-AE49-5D7F8E67CE3F}")
+            .With()
+                .To<AddTypedLabels>("{65D6B71C-BDD5-4A2E-8D35-8896325E9151}")
             .As("{4CACE351-C6B9-4F0C-A6BA-85A02BBD39E4}");
 
             To<ContentVariationMigration>("{1350617A-4930-4D61-852F-E3AA9E692173}");
-            To<UpdateUmbracoConsent>("{39E5B1F7-A50B-437E-B768-1723AEC45B65}"); // from 7.12.0
-
-            Merge()
-                .To<AddRelationTypeForMediaFolderOnDelete>("{0541A62B-EF87-4CA2-8225-F0EB98ECCC9F}") // from 7.12.0
-                .To<IncreaseLanguageIsoCodeColumnLength>("{EB34B5DC-BB87-4005-985E-D983EA496C38}") // from 7.12.0
-                .To<RenameTrueFalseField>("{517CE9EA-36D7-472A-BF4B-A0D6FB1B8F89}") // from 7.12.0
-                .To<SetDefaultTagsStorageType>("{BBD99901-1545-40E4-8A5A-D7A675C7D2F2}") // from 7.12.0
-            .With()
-                .To<FallbackLanguage>("{CF51B39B-9B9A-4740-BB7C-EAF606A7BFBF}") // andy added that one
-            .As("{8B14CEBD-EE47-4AAD-A841-93551D917F11}");
-
-            ToWithReplace<UpdateDefaultMandatoryLanguage>("{2C87AA47-D1BC-4ECB-8A73-2D8D1046C27F}", "{5F4597F4-A4E0-4AFE-90B5-6D2F896830EB}"); // merge
-            ToWithReplace<RefactorVariantsModel>("{B19BF0F2-E1C6-4AEB-A146-BC559D97A2C6}", "{290C18EE-B3DE-4769-84F1-1F467F3F76DA}"); // merge
+            To<FallbackLanguage>("{CF51B39B-9B9A-4740-BB7C-EAF606A7BFBF}");
+            To<UpdateDefaultMandatoryLanguage>("{5F4597F4-A4E0-4AFE-90B5-6D2F896830EB}");
+            To<RefactorVariantsModel>("{290C18EE-B3DE-4769-84F1-1F467F3F76DA}");
             To<DropTaskTables>("{6A2C7C1B-A9DB-4EA9-B6AB-78E7D5B722A7}");
-            To<FixLockTablePrimaryKey>("{77874C77-93E5-4488-A404-A630907CEEF0}");
             To<AddLogTableColumns>("{8804D8E8-FE62-4E3A-B8A2-C047C2118C38}");
             To<DropPreValueTable>("{23275462-446E-44C7-8C2C-3B8C1127B07D}");
             To<DropDownPropertyEditorsMigration>("{6B251841-3069-4AD5-8AE9-861F9523E8DA}");
             To<TagsMigrationFix>("{EE429F1B-9B26-43CA-89F8-A86017C809A3}");
             To<DropTemplateDesignColumn>("{08919C4B-B431-449C-90EC-2B8445B5C6B1}");
             To<TablesForScheduledPublishing>("{7EB0254C-CB8B-4C75-B15B-D48C55B449EB}");
-            To<DropTaskTables>("{648A2D5F-7467-48F8-B309-E99CEEE00E2A}"); // fixed version
             To<MakeTagsVariant>("{C39BF2A7-1454-4047-BBFE-89E40F66ED63}");
             To<MakeRedirectUrlVariant>("{64EBCE53-E1F0-463A-B40B-E98EFCCA8AE2}");
             To<AddContentTypeIsElementColumn>("{0009109C-A0B8-4F3F-8FEB-C137BBDDA268}");
-            To<UpdateMemberGroupPickerData>("{8A027815-D5CD-4872-8B88-9A51AB5986A6}"); // from 7.14.0
             To<ConvertRelatedLinksToMultiUrlPicker>("{ED28B66A-E248-4D94-8CDB-9BDF574023F0}");
             To<UpdatePickerIntegerValuesToUdi>("{38C809D5-6C34-426B-9BEA-EFD39162595C}");
             To<RenameUmbracoDomainsTable>("{6017F044-8E70-4E10-B2A3-336949692ADD}");
-            To<AddUserLoginDtoDateIndex>("{98339BEF-E4B2-48A8-B9D1-D173DC842BBE}");
 
             Merge()
                 .To<DropXmlTables>("{CDBEDEE4-9496-4903-9CF2-4104E00FF960}")
             .With()
-                .To<RadioAndCheckboxAndDropdownPropertyEditorsMigration>("{940FD19A-00A8-4D5C-B8FF-939143585726}")
+                .To<RadioAndCheckboxPropertyEditorsMigration>("{940FD19A-00A8-4D5C-B8FF-939143585726}")
             .As("{0576E786-5C30-4000-B969-302B61E90CA3}");
 
+            To<FixLanguageIsoCodeLength>("{48AD6CCD-C7A4-4305-A8AB-38728AD23FC5}");
+
+            // finish migrating from v7 - recreate all keys and indexes
+            To<CreateKeysAndIndexes>("{3F9764F5-73D0-4D45-8804-1240A66E43A2}");
+
             To<RenameLabelAndRichTextPropertyEditorAliases>("{E0CBE54D-A84F-4A8F-9B13-900945FD7ED9}");
             To<MergeDateAndDateTimePropertyEditor>("{78BAF571-90D0-4D28-8175-EF96316DA789}");
+            // release-8.0.0
+
+            // to 8.0.1...
             To<ChangeNuCacheJsonFormat>("{80C0A0CB-0DD5-4573-B000-C4B7C313C70D}");
+            // release-8.0.1
+
+            // to 8.1.0...
             To<ConvertTinyMceAndGridMediaUrlsToLocalLink>("{B69B6E8C-A769-4044-A27E-4A4E18D1645A}");
+            To<RenameUserLoginDtoDateIndex>("{0372A42B-DECF-498D-B4D1-6379E907EB94}");
+            To<FixContentNuCascade>("{5B1E0D93-F5A3-449B-84BA-65366B84E2D4}");
 
             //FINAL
-
-
-
-
-            // and then, need to support upgrading from more recent 7.x
-            //
-            From("{init-7.10.1}").To("{init-7.10.0}"); // same as 7.10.0
-            From("{init-7.10.2}").To("{init-7.10.0}"); // same as 7.10.0
-            From("{init-7.10.3}").To("{init-7.10.0}"); // same as 7.10.0
-            From("{init-7.10.4}").To("{init-7.10.0}"); // same as 7.10.0
-            From("{init-7.10.5}").To("{init-7.10.0}"); // same as 7.10.0
-            From("{init-7.11.0}").To("{init-7.10.0}"); // same as 7.10.0
-            From("{init-7.11.1}").To("{init-7.10.0}"); // same as 7.10.0
-            From("{init-7.11.2}").To("{init-7.10.0}"); // same as 7.10.0
-
-            // 7.12.0 has migrations, define a custom chain which copies the chain
-            // going from {init-7.10.0} to former final (1350617A) , and then goes straight to
-            // main chain, skipping the migrations
-            //
-            From("{init-7.12.0}");
-            // clone start / clone stop / target
-            ToWithClone("{init-7.10.0}", "{1350617A-4930-4D61-852F-E3AA9E692173}", "{BBD99901-1545-40E4-8A5A-D7A675C7D2F2}");
-
-            From("{init-7.12.1}").To("{init-7.10.0}"); // same as 7.12.0
-            From("{init-7.12.2}").To("{init-7.10.0}"); // same as 7.12.0
-            From("{init-7.12.3}").To("{init-7.10.0}"); // same as 7.12.0
-            From("{init-7.12.4}").To("{init-7.10.0}"); // same as 7.12.0
-            From("{init-7.13.0}").To("{init-7.10.0}"); // same as 7.12.0
-            From("{init-7.13.1}").To("{init-7.10.0}"); // same as 7.12.0
-                
-            // 7.14.0 has migrations, handle it...
-            //  clone going from 7.10 to 1350617A (the last one before we started to merge 7.12 migrations), then
-            //  clone going from CF51B39B (after 7.12 migrations) to 0009109C (the last one before we started to merge 7.12 migrations),
-            //  ending in 8A027815 (after 7.14 migrations)
-            From("{init-7.14.0}")
-                .ToWithClone("{init-7.10.0}", "{1350617A-4930-4D61-852F-E3AA9E692173}", "{9109B8AF-6B34-46EE-9484-7434196D0C79}")
-                .ToWithClone("{CF51B39B-9B9A-4740-BB7C-EAF606A7BFBF}", "{0009109C-A0B8-4F3F-8FEB-C137BBDDA268}", "{8A027815-D5CD-4872-8B88-9A51AB5986A6}");
         }
     }
 }

src/Umbraco.Core/Migrations/Upgrade/V_7_10_0/RenamePreviewFolder.cs

@@ -1,36 +0,0 @@
-using System.IO;
-using Umbraco.Core.IO;
-using File = System.IO.File;
-
-namespace Umbraco.Core.Migrations.Upgrade.V_7_10_0
-{
-    /// <summary>
-    /// Renames the preview folder containing static HTML files to ensure it does not interfere with the MVC route
-    /// that is now supposed to render these views dynamically. We don't want to delete as people may have made
-    /// customizations to these files that would need to be migrated to the new .cshtml view files.
-    /// </summary>
-    public class RenamePreviewFolder : MigrationBase
-    {
-        public RenamePreviewFolder(IMigrationContext context)
-            : base(context)
-        { }
-
-        public override void Migrate()
-        {
-            var previewFolderPath = IOHelper.MapPath(SystemDirectories.Umbraco + "/preview");
-            if (Directory.Exists(previewFolderPath))
-            {
-                var newPath = previewFolderPath.Replace("preview", "preview.old");
-                if (Directory.Exists(newPath) == false)
-                {
-                    Directory.Move(previewFolderPath, newPath);
-                    var readmeText =
-                        $"Static HTML files used for preview and canvas editing functionality no longer live in this directory.\r\n" +
-                        $"Instead they have been recreated as MVC views and can now be found in '~/Umbraco/Views/Preview'.\r\n" +
-                        $"See issue: http://issues.umbraco.org/issue/U4-11090";
-                    File.WriteAllText(Path.Combine(newPath, "readme.txt"), readmeText);
-                }
-            }
-        }
-    }
-}

src/Umbraco.Core/Migrations/Upgrade/V_7_12_0/AddRelationTypeForMediaFolderOnDelete.cs

@@ -1,33 +0,0 @@
-using Umbraco.Core.Persistence.Dtos;
-
-namespace Umbraco.Core.Migrations.Upgrade.V_7_12_0
-{
-    public class AddRelationTypeForMediaFolderOnDelete : MigrationBase
-    {
-
-        public AddRelationTypeForMediaFolderOnDelete(IMigrationContext context) : base(context)
-        {
-        }
-
-        public override void Migrate()
-        {
-            var relationTypeCount = Context.Database.ExecuteScalar<int>("SELECT COUNT(*) FROM umbracoRelationType WHERE alias=@alias",
-                new { alias = Constants.Conventions.RelationTypes.RelateParentMediaFolderOnDeleteAlias });
-
-            if (relationTypeCount > 0)
-                return;
-
-            var uniqueId = (Constants.Conventions.RelationTypes.RelateParentMediaFolderOnDeleteAlias + "____" + Constants.Conventions.RelationTypes.RelateParentMediaFolderOnDeleteName).ToGuid();
-            Insert.IntoTable("umbracoRelationType").Row(new
-            {
-                typeUniqueId = uniqueId,
-                alias = Constants.Conventions.RelationTypes.RelateParentMediaFolderOnDeleteAlias,
-                name = Constants.Conventions.RelationTypes.RelateParentMediaFolderOnDeleteName,
-                childObjectType = Constants.ObjectTypes.MediaType,
-                parentObjectType = Constants.ObjectTypes.MediaType,
-                dual = false
-                }).Do();
-        }
-
-    }
-}

src/Umbraco.Core/Migrations/Upgrade/V_7_12_0/IncreaseLanguageIsoCodeColumnLength.cs

@@ -1,46 +0,0 @@
-using System.Linq;
-using Umbraco.Core.Persistence.DatabaseModelDefinitions;
-using Umbraco.Core.Persistence.SqlSyntax;
-
-namespace Umbraco.Core.Migrations.Upgrade.V_7_12_0
-{
-    public class IncreaseLanguageIsoCodeColumnLength : MigrationBase
-    {
-        public IncreaseLanguageIsoCodeColumnLength(IMigrationContext context)
-            : base(context)
-        { }
-
-        public override void Migrate()
-        {
-            // Some people seem to have a constraint in their DB instead of an index, we'd need to drop that one
-            // See: https://our.umbraco.com/forum/using-umbraco-and-getting-started/93282-upgrade-from-711-to-712-fails
-            var constraints = SqlSyntax.GetConstraintsPerTable(Context.Database).Distinct().ToArray();
-            if (constraints.Any(x => x.Item2.InvariantEquals("IX_umbracoLanguage_languageISOCode")))
-            {
-                Delete.UniqueConstraint("IX_umbracoLanguage_languageISOCode").FromTable("umbracoLanguage").Do();
-            }
-
-            //Now check for indexes of that name and drop that if it exists
-            var dbIndexes = SqlSyntax.GetDefinedIndexesDefinitions(Context.Database);
-            if (dbIndexes.Any(x => x.IndexName.InvariantEquals("IX_umbracoLanguage_languageISOCode")))
-            {
-                Delete.Index("IX_umbracoLanguage_languageISOCode").OnTable("umbracoLanguage").Do();
-            }
-
-            Alter.Table("umbracoLanguage")
-                .AlterColumn("languageISOCode")
-                .AsString(14)
-                .Nullable()
-                .Do();
-
-            Create.Index("IX_umbracoLanguage_languageISOCode")
-                .OnTable("umbracoLanguage")
-                .OnColumn("languageISOCode")
-                .Ascending()
-                .WithOptions()
-                .Unique()
-                .Do();
-        }
-
-    }
-}

src/Umbraco.Core/Migrations/Upgrade/V_7_12_0/RenameTrueFalseField.cs

@@ -1,19 +0,0 @@
-using Umbraco.Core.Logging;
-using Umbraco.Core.Persistence.Dtos;
-using Umbraco.Core.Persistence.SqlSyntax;
-
-namespace Umbraco.Core.Migrations.Upgrade.V_7_12_0
-{
-    public class RenameTrueFalseField : MigrationBase
-    {
-        public RenameTrueFalseField(IMigrationContext context) : base(context)
-        {
-        }
-
-        public override void Migrate()
-        {
-            //rename the existing true/false field
-            Update.Table(NodeDto.TableName).Set(new { text = "Checkbox" }).Where(new { id = Constants.DataTypes.Boolean }).Do();
-        }
-    }
-}

src/Umbraco.Core/Migrations/Upgrade/V_7_12_0/SetDefaultTagsStorageType.cs

@@ -1,51 +0,0 @@
-using Newtonsoft.Json;
-using Newtonsoft.Json.Linq;
-using Umbraco.Core.Models;
-using Umbraco.Core.Persistence;
-using Umbraco.Core.Persistence.Dtos;
-using Umbraco.Core.PropertyEditors;
-
-namespace Umbraco.Core.Migrations.Upgrade.V_7_12_0
-{
-    /// <summary>
-    /// Set the default storageType for the tags datatype to "CSV" to ensure backwards compatibility since the default is going to be JSON in new versions.
-    /// </summary>
-    public class SetDefaultTagsStorageType : MigrationBase
-    {
-        public SetDefaultTagsStorageType(IMigrationContext context)
-            : base(context)
-        { }
-
-        // dummy editor for deserialization
-        private class TagConfigurationEditor : ConfigurationEditor<TagConfiguration>
-        { }
-
-        public override void Migrate()
-        {
-            // get all Umbraco.Tags datatypes
-            var dataTypeDtos = Database.Fetch<DataTypeDto>(Context.SqlContext.Sql()
-                .Select<DataTypeDto>()
-                .From<DataTypeDto>()
-                .Where<DataTypeDto>(x => x.EditorAlias == Constants.PropertyEditors.Aliases.Tags));
-
-            // get a dummy editor for deserialization
-            var editor = new TagConfigurationEditor();
-
-            foreach (var dataTypeDto in dataTypeDtos)
-            {
-                // need to check storageType on raw dictionary, as TagConfiguration would have a default value
-                var dictionary = JsonConvert.DeserializeObject<JObject>(dataTypeDto.Configuration);
-
-                // if missing, use TagConfiguration to properly update the configuration
-                // due to ... reasons ... the key can start with a lower or upper 'S'
-                if (!dictionary.ContainsKey("storageType") && !dictionary.ContainsKey("StorageType"))
-                {
-                    var configuration = (TagConfiguration)editor.FromDatabase(dataTypeDto.Configuration);
-                    configuration.StorageType = TagsStorageType.Csv;
-                    dataTypeDto.Configuration = ConfigurationEditor.ToDatabase(configuration);
-                    Database.Update(dataTypeDto);
-                }
-            }
-        }
-    }
-}

src/Umbraco.Core/Migrations/Upgrade/V_7_12_0/UpdateUmbracoConsent.cs

@@ -1,15 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace Umbraco.Core.Migrations.Upgrade.V_7_12_0
-{
    public class UpdateUmbracoConsent : MigrationBase
    {
-        public UpdateUmbracoConsent(IMigrationContext context)
-            : base(context)
-        { }
-
-        public override void Migrate()
        {
            Alter.Table(Constants.DatabaseSchema.Tables.Consent).AlterColumn("comment").AsString().Nullable().Do();
        }
-    }
-}

src/Umbraco.Core/Migrations/Upgrade/V_7_14_0/UpdateMemberGroupPickerData.cs

@@ -1,29 +0,0 @@
-namespace Umbraco.Core.Migrations.Upgrade.V_7_14_0
-{
-    /// <summary>
-    /// Migrates member group picker properties from NVarchar to NText. See https://github.com/umbraco/Umbraco-CMS/issues/3268.
-    /// </summary>
-    public class UpdateMemberGroupPickerData : MigrationBase
-    {
-        /// <summary>
-        /// Migrates member group picker properties from NVarchar to NText. See https://github.com/umbraco/Umbraco-CMS/issues/3268.
-        /// </summary>
-        public UpdateMemberGroupPickerData(IMigrationContext context)
-            : base(context)
-        { }
-
-        public override void Migrate()
-        {
-            Database.Execute($@"UPDATE umbracoPropertyData SET textValue = varcharValue, varcharValue = NULL
-                WHERE textValue IS NULL AND id IN (
-	                SELECT id FROM umbracoPropertyData WHERE propertyTypeId in (
-		                SELECT id from cmsPropertyType where dataTypeId IN (
-			                SELECT nodeId FROM umbracoDataType WHERE propertyEditorAlias = '{Constants.PropertyEditors.Aliases.MemberGroupPicker}'
-                    )
-                )
-            )");
-
-            Database.Execute($"UPDATE umbracoDataType SET dbType = 'Ntext' WHERE propertyEditorAlias = '{Constants.PropertyEditors.Aliases.MemberGroupPicker}'");
-        }
-    }
-}

src/Umbraco.Core/Migrations/Upgrade/V_7_5_0/AddRedirectUrlTable.cs

@@ -1,50 +0,0 @@
-using System.Linq;
-
-namespace Umbraco.Core.Migrations.Upgrade.V_7_5_0
-{
-    public class AddRedirectUrlTable : MigrationBase
-    {
-        public AddRedirectUrlTable(IMigrationContext context)
-            : base(context)
-        { }
-
-        public override void Migrate()
-        {
-            var database = Database;
-            var umbracoRedirectUrlTableName = "umbracoRedirectUrl";
-
-            var tables = SqlSyntax.GetTablesInSchema(database).ToArray();
-
-            if (tables.InvariantContains(umbracoRedirectUrlTableName))
-            {
-                var columns = SqlSyntax.GetColumnsInSchema(database).ToArray();
-                if (columns.Any(x => x.TableName.InvariantEquals(umbracoRedirectUrlTableName) && x.ColumnName.InvariantEquals("id") && x.DataType == "uniqueidentifier"))
-                    return;
-                Delete.Table(umbracoRedirectUrlTableName).Do();
-            }
-
-            Create.Table(umbracoRedirectUrlTableName)
-                .WithColumn("id").AsGuid().NotNullable().PrimaryKey("PK_" + umbracoRedirectUrlTableName)
-                .WithColumn("createDateUtc").AsDateTime().NotNullable()
-                .WithColumn("url").AsString(2048).NotNullable()
-                .WithColumn("contentKey").AsGuid().NotNullable()
-                .WithColumn("urlHash").AsString(40).NotNullable()
-                .Do();
-
-            Create.Index("IX_" + umbracoRedirectUrlTableName).OnTable(umbracoRedirectUrlTableName)
-                .OnColumn("urlHash")
-                .Ascending()
-                .OnColumn("contentKey")
-                .Ascending()
-                .OnColumn("createDateUtc")
-                .Descending()
-                .WithOptions().NonClustered()
-                .Do();
-
-            Create.ForeignKey("FK_" + umbracoRedirectUrlTableName)
-                .FromTable(umbracoRedirectUrlTableName).ForeignColumn("contentKey")
-                .ToTable("umbracoNode").PrimaryColumn("uniqueID")
-                .Do();
-        }
-    }
-}

src/Umbraco.Core/Migrations/Upgrade/V_7_5_0/RemoveStylesheetDataAndTablesAgain.cs

@@ -1,40 +0,0 @@
-using System;
-using System.Linq;
-
-namespace Umbraco.Core.Migrations.Upgrade.V_7_5_0
-{
-    /// <summary>
-    /// This is here to re-remove these tables, we dropped them in 7.3 but new installs created them again so we're going to re-drop them
-    /// </summary>
-    public class RemoveStylesheetDataAndTablesAgain : MigrationBase
-    {
-        public RemoveStylesheetDataAndTablesAgain(IMigrationContext context)
-            : base(context)
-        {
-        }
-
-        public override void Migrate()
-        {
-            // these have been obsoleted, need to copy the values here
-            var stylesheetPropertyObjectType = new Guid("5555da4f-a123-42b2-4488-dcdfb25e4111");
-            var stylesheetObjectType = new Guid("9F68DA4F-A3A8-44C2-8226-DCBD125E4840");
-
-            //Clear all stylesheet data if the tables exist
-            var tables = SqlSyntax.GetTablesInSchema(Context.Database).ToArray();
-            if (tables.InvariantContains("cmsStylesheetProperty"))
-            {
-                Delete.FromTable("cmsStylesheetProperty").AllRows().Do();
-                Delete.FromTable("umbracoNode").Row(new { nodeObjectType = stylesheetPropertyObjectType }).Do();
-
-                Delete.Table("cmsStylesheetProperty").Do();
-            }
-            if (tables.InvariantContains("cmsStylesheet"))
-            {
-                Delete.FromTable("cmsStylesheet").AllRows().Do();
-                Delete.FromTable("umbracoNode").Row(new { nodeObjectType = stylesheetObjectType }).Do();
-
-                Delete.Table("cmsStylesheet").Do();
-            }
-        }
-    }
-}

src/Umbraco.Core/Migrations/Upgrade/V_7_5_0/UpdateUniqueIndexOnPropertyData.cs

@@ -1,44 +0,0 @@
-using System.Linq;
-using Umbraco.Core.Persistence;
-using Umbraco.Core.Persistence.SqlSyntax;
-
-namespace Umbraco.Core.Migrations.Upgrade.V_7_5_0
-{
-    /// <summary>
-    /// See: http://issues.umbraco.org/issue/U4-8522
-    /// </summary>
-    public class UpdateUniqueIndexOnPropertyData : MigrationBase
-    {
-        public UpdateUniqueIndexOnPropertyData(IMigrationContext context)
-            : base(context)
-        {
-        }
-
-        public override void Migrate()
-        {
-            //Clear all stylesheet data if the tables exist
-            //tuple = tablename, indexname, columnname, unique
-            var indexes = SqlSyntax.GetDefinedIndexes(Context.Database).ToArray();
-            var found = indexes.FirstOrDefault(
-                x => x.Item1.InvariantEquals("cmsPropertyData")
-                     && x.Item2.InvariantEquals("IX_cmsPropertyData_1")
-                    //we're searching for the old index which is not unique
-                     && x.Item4 == false);
-
-            if (found != null)
-            {
-                Database.Execute("DELETE FROM cmsPropertyData WHERE id NOT IN (SELECT MIN(id) FROM cmsPropertyData GROUP BY nodeId, versionId, propertytypeid HAVING MIN(id) IS NOT NULL)");
-
-                //we need to re create this index
-                Delete.Index("IX_cmsPropertyData_1").OnTable("cmsPropertyData").Do();
-                Create.Index("IX_cmsPropertyData_1").OnTable("cmsPropertyData")
-                    .OnColumn("nodeId").Ascending()
-                    .OnColumn("versionId").Ascending()
-                    .OnColumn("propertytypeid").Ascending()
-                    .WithOptions().NonClustered()
-                    .WithOptions().Unique()
-                    .Do();
-            }
-        }
-    }
-}

src/Umbraco.Core/Migrations/Upgrade/V_7_5_5/UpdateAllowedMediaTypesAtRoot.cs

@@ -1,17 +0,0 @@
-namespace Umbraco.Core.Migrations.Upgrade.V_7_5_5
-{
-    /// <summary>
-    /// See: http://issues.umbraco.org/issue/U4-4196
-    /// </summary>
-    public class UpdateAllowedMediaTypesAtRoot : MigrationBase
-    {
-        public UpdateAllowedMediaTypesAtRoot(IMigrationContext context)
-            : base(context)
-        { }
-
-        public override void Migrate()
-        {
-            Database.Execute("UPDATE cmsContentType SET allowAtRoot = 1 WHERE nodeId = 1032 OR nodeId = 1033");
-        }
-    }
-}

src/Umbraco.Core/Migrations/Upgrade/V_7_6_0/AddIndexToCmsMemberLoginName.cs

@@ -1,41 +0,0 @@
-using System.Linq;
-using Umbraco.Core.Persistence.SqlSyntax;
-
-namespace Umbraco.Core.Migrations.Upgrade.V_7_6_0
-{
-    public class AddIndexToCmsMemberLoginName : MigrationBase
-    {
-        public AddIndexToCmsMemberLoginName(IMigrationContext context)
-            : base(context)
-        { }
-
-        public override void Migrate()
-        {
-            var database = Database;
-
-            //Now we need to check if we can actually d6 this because we won't be able to if there's data in there that is too long
-            //http://issues.umbraco.org/issue/U4-9758
-
-            var colLen = database.ExecuteScalar<int?>("select max(datalength(LoginName)) from cmsMember");
-
-            if (colLen < 900 == false && colLen != null)
-            {
-                return;
-            }
-
-            var dbIndexes = SqlSyntax.GetDefinedIndexesDefinitions(Context.Database);
-
-            //make sure it doesn't already exist
-            if (dbIndexes.Any(x => x.IndexName.InvariantEquals("IX_cmsMember_LoginName")) == false)
-            {
-                //we can apply the index
-                Create.Index("IX_cmsMember_LoginName").OnTable("cmsMember")
-                    .OnColumn("LoginName")
-                    .Ascending()
-                    .WithOptions()
-                    .NonClustered()
-                    .Do();
-            }
-        }
-    }
-}

src/Umbraco.Core/Migrations/Upgrade/V_7_6_0/AddIndexToUmbracoNodePath.cs

@@ -1,28 +0,0 @@
-using System.Linq;
-using Umbraco.Core.Persistence.SqlSyntax;
-
-namespace Umbraco.Core.Migrations.Upgrade.V_7_6_0
-{
-    public class AddIndexToUmbracoNodePath : MigrationBase
-    {
-        public AddIndexToUmbracoNodePath(IMigrationContext context)
-            : base(context)
-        { }
-
-        public override void Migrate()
-        {
-            var dbIndexes = SqlSyntax.GetDefinedIndexesDefinitions(Context.Database);
-
-            //make sure it doesn't already exist
-            if (dbIndexes.Any(x => x.IndexName.InvariantEquals("IX_umbracoNodePath")) == false)
-            {
-                Create.Index("IX_umbracoNodePath").OnTable("umbracoNode")
-                    .OnColumn("path")
-                    .Ascending()
-                    .WithOptions()
-                    .NonClustered()
-                    .Do();
-            }
-        }
-    }
-}

src/Umbraco.Core/Migrations/Upgrade/V_7_6_0/AddIndexToUser2NodePermission.cs

@@ -1,28 +0,0 @@
-using System.Linq;
-using Umbraco.Core.Persistence.SqlSyntax;
-
-namespace Umbraco.Core.Migrations.Upgrade.V_7_6_0
-{
-    public class AddIndexToUser2NodePermission : MigrationBase
-    {
-        public AddIndexToUser2NodePermission(IMigrationContext context)
-            : base(context)
-        { }
-
-        public override void Migrate()
-        {
-            var dbIndexes = SqlSyntax.GetDefinedIndexesDefinitions(Context.Database);
-
-            //make sure it doesn't already exist
-            if (dbIndexes.Any(x => x.IndexName.InvariantEquals("IX_umbracoUser2NodePermission_nodeId")) == false)
-            {
-                Create.Index("IX_umbracoUser2NodePermission_nodeId").OnTable("umbracoUser2NodePermission")
-                    .OnColumn("nodeId")
-                    .Ascending()
-                    .WithOptions()
-                    .NonClustered()
-                    .Do();
-            }
-        }
-    }
-}

src/Umbraco.Core/Migrations/Upgrade/V_7_6_0/AddIndexesToUmbracoRelationTables.cs

@@ -1,85 +0,0 @@
-using System;
-using System.Linq;
-using Umbraco.Core.Persistence.SqlSyntax;
-
-namespace Umbraco.Core.Migrations.Upgrade.V_7_6_0
-{
-    public class AddIndexesToUmbracoRelationTables : MigrationBase
-    {
-        public AddIndexesToUmbracoRelationTables(IMigrationContext context)
-            : base(context)
-        { }
-
-        public override void Migrate()
-        {
-            var dbIndexes = SqlSyntax.GetDefinedIndexesDefinitions(Context.Database).ToArray();
-
-            //make sure it doesn't already exist
-            if (dbIndexes.Any(x => x.IndexName.InvariantEquals("IX_umbracoRelation_parentChildType")) == false)
-            {
-                //This will remove any corrupt/duplicate data in the relation table before the index is applied
-                //Ensure this executes in a deferred block which will be done inside of the migration transaction
-                var database = Database;
-
-                //We need to check if this index has corrupted data and then clear that data
-                var duplicates = database.Fetch<dynamic>("SELECT parentId,childId,relType FROM umbracoRelation GROUP BY parentId,childId,relType HAVING COUNT(*) > 1");
-                if (duplicates.Count > 0)
-                {
-                    //need to fix this there cannot be duplicates so we'll take the latest entries, it's really not going to matter though
-                    foreach (var duplicate in duplicates)
-                    {
-                        var ids = database.Fetch<int>("SELECT id FROM umbracoRelation WHERE parentId=@parentId AND childId=@childId AND relType=@relType ORDER BY datetime DESC",
-                            new { parentId = duplicate.parentId, childId = duplicate.childId, relType = duplicate.relType });
-
-                        if (ids.Count == 1)
-                        {
-                            //this is just a safety check, this should absolutely never happen
-                            throw new InvalidOperationException("Duplicates were detected but could not be discovered");
-                        }
-
-                        //delete the others
-                        ids = ids.Skip(0).ToList();
-
-                        //iterate in groups of 2000 to avoid the max sql parameter limit
-                        foreach (var idGroup in ids.InGroupsOf(2000))
-                        {
-                            database.Execute("DELETE FROM umbracoRelation WHERE id IN (@ids)", new { ids = idGroup });
-                        }
-                    }
-                }
-
-                //unique index to prevent duplicates - and for better perf
-                Create.Index("IX_umbracoRelation_parentChildType").OnTable("umbracoRelation")
-                    .OnColumn("parentId").Ascending()
-                    .OnColumn("childId").Ascending()
-                    .OnColumn("relType").Ascending()
-                    .WithOptions()
-                    .Unique()
-                    .Do();
-            }
-
-            //need indexes on alias and name for relation type since these are queried against
-
-            //make sure it doesn't already exist
-            if (dbIndexes.Any(x => x.IndexName.InvariantEquals("IX_umbracoRelationType_alias")) == false)
-            {
-                Create.Index("IX_umbracoRelationType_alias").OnTable("umbracoRelationType")
-                    .OnColumn("alias")
-                    .Ascending()
-                    .WithOptions()
-                    .NonClustered()
-                    .Do();
-            }
-            if (dbIndexes.Any(x => x.IndexName.InvariantEquals("IX_umbracoRelationType_name")) == false)
-            {
-                Create.Index("IX_umbracoRelationType_name").OnTable("umbracoRelationType")
-                    .OnColumn("name")
-                    .Ascending()
-                    .WithOptions()
-                    .NonClustered()
-                    .Do();
-            }
-
-        }
-    }
-}

src/Umbraco.Core/Migrations/Upgrade/V_7_6_0/AddLockObjects.cs

@@ -1,27 +0,0 @@
-using Umbraco.Core.Persistence.Dtos;
-
-namespace Umbraco.Core.Migrations.Upgrade.V_7_6_0
-{
-    public class AddLockObjects : MigrationBase
-    {
-        public AddLockObjects(IMigrationContext context)
-            : base(context)
-        { }
-
-        public override void Migrate()
-        {
-            EnsureLockObject(Constants.Locks.Servers, "Servers");
-        }
-
-        private void EnsureLockObject(int id, string name)
-        {
-            var db = Database;
-            var exists = db.Exists<LockDto>(id);
-            if (exists) return;
-            // be safe: delete old umbracoNode lock objects if any
-            db.Execute("DELETE FROM umbracoNode WHERE id=@id;", new { id });
-            // then create umbracoLock object
-            db.Execute("INSERT umbracoLock (id, name, value) VALUES (@id, @name, 1);", new { id, name });
-        }
-    }
-}

src/Umbraco.Core/Migrations/Upgrade/V_7_6_0/AddLockTable.cs

@@ -1,24 +0,0 @@
-using System.Linq;
-
-namespace Umbraco.Core.Migrations.Upgrade.V_7_6_0
-{
-    public class AddLockTable : MigrationBase
-    {
-        public AddLockTable(IMigrationContext context)
-            : base(context)
-        { }
-
-        public override void Migrate()
-        {
-            var tables = SqlSyntax.GetTablesInSchema(Context.Database).ToArray();
-            if (tables.InvariantContains("umbracoLock") == false)
-            {
-                Create.Table("umbracoLock")
-                    .WithColumn("id").AsInt32().PrimaryKey("PK_umbracoLock")
-                    .WithColumn("value").AsInt32().NotNullable()
-                    .WithColumn("name").AsString(64).NotNullable()
-                    .Do();
-            }
-        }
-    }
-}

src/Umbraco.Core/Migrations/Upgrade/V_7_6_0/AddMacroUniqueIdColumn.cs

@@ -1,68 +0,0 @@
-using System;
-using System.Linq;
-
-namespace Umbraco.Core.Migrations.Upgrade.V_7_6_0
-{
-    public class AddMacroUniqueIdColumn : MigrationBase
-    {
-        public AddMacroUniqueIdColumn(IMigrationContext context)
-            : base(context)
-        { }
-
-        public override void Migrate()
-        {
-            var columns = SqlSyntax.GetColumnsInSchema(Context.Database).ToArray();
-
-            if (columns.Any(x => x.TableName.InvariantEquals("cmsMacro") && x.ColumnName.InvariantEquals("uniqueId")) == false)
-            {
-                Create.Column("uniqueId").OnTable("cmsMacro").AsGuid().Nullable().Do();
-                UpdateMacroGuids();
-                Alter.Table("cmsMacro").AlterColumn("uniqueId").AsGuid().NotNullable().Do();
-                Create.Index("IX_cmsMacro_UniqueId").OnTable("cmsMacro").OnColumn("uniqueId")
-                    .Ascending()
-                    .WithOptions().NonClustered()
-                    .WithOptions().Unique()
-                    .Do();
-
-            }
-
-            if (columns.Any(x => x.TableName.InvariantEquals("cmsMacroProperty") && x.ColumnName.InvariantEquals("uniquePropertyId")) == false)
-            {
-                Create.Column("uniquePropertyId").OnTable("cmsMacroProperty").AsGuid().Nullable().Do();
-                UpdateMacroPropertyGuids();
-                Alter.Table("cmsMacroProperty").AlterColumn("uniquePropertyId").AsGuid().NotNullable().Do();
-                Create.Index("IX_cmsMacroProperty_UniquePropertyId").OnTable("cmsMacroProperty").OnColumn("uniquePropertyId")
-                    .Ascending()
-                    .WithOptions().NonClustered()
-                    .WithOptions().Unique()
-                    .Do();
-            }
-        }
-
-        private void UpdateMacroGuids()
-        {
-            var database = Database;
-
-            var updates = database.Query<dynamic>("SELECT id, macroAlias FROM cmsMacro")
-                .Select(macro => Tuple.Create((int) macro.id, ("macro____" + (string) macro.macroAlias).ToGuid()))
-                .ToList();
-
-            foreach (var update in updates)
-                database.Execute("UPDATE cmsMacro set uniqueId=@guid WHERE id=@id", new { guid = update.Item2, id = update.Item1 });
-        }
-
-        private void UpdateMacroPropertyGuids()
-        {
-            var database = Database;
-
-            var updates = database.Query<dynamic>(@"SELECT cmsMacroProperty.id id, macroPropertyAlias propertyAlias, cmsMacro.macroAlias macroAlias
-FROM cmsMacroProperty
-JOIN cmsMacro ON cmsMacroProperty.macro=cmsMacro.id")
-                .Select(prop => Tuple.Create((int) prop.id, ("macro____" + (string) prop.macroAlias + "____" + (string) prop.propertyAlias).ToGuid()))
-                .ToList();
-
-            foreach (var update in updates)
-                database.Execute("UPDATE cmsMacroProperty set uniquePropertyId=@guid WHERE id=@id", new { guid = update.Item2, id = update.Item1 });
-        }
-    }
-}

src/Umbraco.Core/Migrations/Upgrade/V_7_6_0/AddRelationTypeUniqueIdColumn.cs

@@ -1,40 +0,0 @@
-using System;
-using System.Linq;
-
-namespace Umbraco.Core.Migrations.Upgrade.V_7_6_0
-{
-    public class AddRelationTypeUniqueIdColumn : MigrationBase
-    {
-        public AddRelationTypeUniqueIdColumn(IMigrationContext context)
-            : base(context)
-        { }
-
-        public override void Migrate()
-        {
-            var columns = SqlSyntax.GetColumnsInSchema(Context.Database).ToArray();
-
-            if (columns.Any(x => x.TableName.InvariantEquals("umbracoRelationType") && x.ColumnName.InvariantEquals("typeUniqueId")) == false)
-            {
-                Create.Column("typeUniqueId").OnTable("umbracoRelationType").AsGuid().Nullable().Do();
-                UpdateRelationTypeGuids();
-                Alter.Table("umbracoRelationType").AlterColumn("typeUniqueId").AsGuid().NotNullable().Do();
-                Create.Index("IX_umbracoRelationType_UniqueId").OnTable("umbracoRelationType").OnColumn("typeUniqueId")
-                    .Ascending()
-                    .WithOptions().NonClustered()
-                    .WithOptions().Unique()
-                    .Do();
-            }
-        }
-
-        private void UpdateRelationTypeGuids()
-        {
-            var database = Database;
-            var updates = database.Query<dynamic>("SELECT id, alias, name FROM umbracoRelationType")
-                .Select(relationType => Tuple.Create((int) relationType.id, ("relationType____" + (string) relationType.alias + "____" + (string) relationType.name).ToGuid()))
-                .ToList();
-
-            foreach (var update in updates)
-                database.Execute("UPDATE umbracoRelationType set typeUniqueId=@guid WHERE id=@id", new { guid = update.Item2, id = update.Item1 });
-        }
-    }
-}

src/Umbraco.Core/Migrations/Upgrade/V_7_6_0/NormalizeTemplateGuids.cs

@@ -1,37 +0,0 @@
-using System;
-using System.Linq;
-
-namespace Umbraco.Core.Migrations.Upgrade.V_7_6_0
-{
-    public class NormalizeTemplateGuids : MigrationBase
-    {
-        public NormalizeTemplateGuids(IMigrationContext context)
-            : base(context)
-        { }
-
-        public override void Migrate()
-        {
-            var database = Database;
-
-            // we need this migration because ppl running pre-7.6 on Cloud and Courier have templates in different
-            // environments having different GUIDs (Courier does not sync template GUIDs) and we need to normalize
-            // these GUIDs so templates with the same alias on different environments have the same GUID.
-            // however, if already running a prerelease version of 7.6, we do NOT want to normalize the GUIDs as quite
-            // probably, we are already running Deploy and the GUIDs are OK. assuming noone is running a prerelease
-            // of 7.6 on Courier.
-            // so... testing if we already have a 7.6.0 version installed. not pretty but...?
-            //
-            var version = database.FirstOrDefault<string>("SELECT version FROM umbracoMigration WHERE name=@name ORDER BY version DESC", new { name = Constants.System.UmbracoUpgradePlanName });
-            if (version != null && version.StartsWith("7.6.0")) return;
-
-            var updates = database.Query<dynamic>(@"SELECT umbracoNode.id, cmsTemplate.alias FROM umbracoNode
-JOIN cmsTemplate ON umbracoNode.id=cmsTemplate.nodeId
-WHERE nodeObjectType = @guid", new { guid = Constants.ObjectTypes.TemplateType })
-                .Select(template => Tuple.Create((int) template.id, ("template____" + (string) template.alias).ToGuid()))
-                .ToList();
-
-            foreach (var update in updates)
-                database.Execute("UPDATE umbracoNode set uniqueId=@guid WHERE id=@id", new { guid = update.Item2, id = update.Item1 });
-        }
-    }
-}

src/Umbraco.Core/Migrations/Upgrade/V_7_6_0/ReduceLoginNameColumnsSize.cs

@@ -1,41 +0,0 @@
-using System.Linq;
-using Umbraco.Core.Persistence.SqlSyntax;
-
-namespace Umbraco.Core.Migrations.Upgrade.V_7_6_0
-{
-    public class ReduceLoginNameColumnsSize : MigrationBase
-    {
-        public ReduceLoginNameColumnsSize(IMigrationContext context)
-            : base(context)
-        { }
-
-        public override void Migrate()
-        {
-            //Now we need to check if we can actually d6 this because we won't be able to if there's data in there that is too long
-            //http://issues.umbraco.org/issue/U4-9758
-
-            var database = Database;
-            var dbIndexes = SqlSyntax.GetDefinedIndexesDefinitions(database);
-
-            var colLen = database.ExecuteScalar<int?>("select max(datalength(LoginName)) from cmsMember");
-
-            if (colLen < 900 == false) return;
-
-            //if an index exists on this table we need to drop it. Normally we'd check via index name but in some odd cases (i.e. Our)
-            //the index name is something odd (starts with "mi_"). In any case, the index cannot exist if we want to alter the column
-            //so we'll drop whatever index is there and add one with the correct name after.
-            var loginNameIndex = dbIndexes.FirstOrDefault(x => x.TableName.InvariantEquals("cmsMember") && x.ColumnName.InvariantEquals("LoginName"));
-            if (loginNameIndex != null)
-            {
-                Delete.Index(loginNameIndex.IndexName).OnTable("cmsMember").Do();
-            }
-
-            //we can apply the col length change
-            Alter.Table("cmsMember")
-                .AlterColumn("LoginName")
-                .AsString(225)
-                .NotNullable()
-                .Do();
-        }
-    }
-}

src/Umbraco.Core/Migrations/Upgrade/V_7_6_0/RemovePropertyDataIdIndex.cs

@@ -1,29 +0,0 @@
-using System.Linq;
-
-namespace Umbraco.Core.Migrations.Upgrade.V_7_6_0
-{
-    /// <summary>
-    /// See: http://issues.umbraco.org/issue/U4-9188
-    /// </summary>
-    public class UpdateUniqueIndexOnPropertyData : MigrationBase
-    {
-        public UpdateUniqueIndexOnPropertyData(IMigrationContext context)
-            : base(context)
-        { }
-
-        public override void Migrate()
-        {
-            //tuple = tablename, indexname, columnname, unique
-            var indexes = SqlSyntax.GetDefinedIndexes(Context.Database).ToArray();
-            var found = indexes.FirstOrDefault(
-                x => x.Item1.InvariantEquals("cmsPropertyData")
-                     && x.Item2.InvariantEquals("IX_cmsPropertyData"));
-
-            if (found != null)
-            {
-                //drop the index
-                Delete.Index("IX_cmsPropertyData").OnTable("cmsPropertyData").Do();
-            }
-        }
-    }
-}

src/Umbraco.Core/Migrations/Upgrade/V_7_6_0/RemoveUmbracoDeployTables.cs

@@ -1,30 +0,0 @@
-using System.Linq;
-
-namespace Umbraco.Core.Migrations.Upgrade.V_7_6_0
-{
-    public class RemoveUmbracoDeployTables : MigrationBase
-    {
-        public RemoveUmbracoDeployTables(IMigrationContext context)
-            : base(context)
-        { }
-
-        public override void Migrate()
-        {
-            var tables = SqlSyntax.GetTablesInSchema(Context.Database).ToArray();
-
-            // there are two versions of umbracoDeployDependency,
-            // 1. one created by 7.4 and never used, we need to remove it (has a sourceId column)
-            // 2. one created by Deploy itself, we need to keep it (has a sourceUdi column)
-            if (tables.InvariantContains("umbracoDeployDependency"))
-            {
-                var columns = SqlSyntax.GetColumnsInSchema(Context.Database).ToArray();
-                if (columns.Any(x => x.TableName.InvariantEquals("umbracoDeployDependency") && x.ColumnName.InvariantEquals("sourceId")))
-                    Delete.Table("umbracoDeployDependency").Do();
-            }
-
-            // always remove umbracoDeployChecksum
-            if (tables.InvariantContains("umbracoDeployChecksum"))
-                Delete.Table("umbracoDeployChecksum").Do();
-        }
-    }
-}

src/Umbraco.Core/Migrations/Upgrade/V_7_7_0/AddIndexToDictionaryKeyColumn.cs

@@ -1,38 +0,0 @@
-using System.Linq;
-using Umbraco.Core.Persistence.SqlSyntax;
-
-namespace Umbraco.Core.Migrations.Upgrade.V_7_7_0
-{
-    public class AddIndexToDictionaryKeyColumn : MigrationBase
-    {
-        public AddIndexToDictionaryKeyColumn(IMigrationContext context)
-            : base(context)
-        { }
-
-        public override void Migrate()
-        {
-            var database = Database;
-            //Now we need to check if we can actually do this because we won't be able to if there's data in there that is too long
-            var colLen = database.ExecuteScalar<int?>(string.Format("select max(datalength({0})) from cmsDictionary", SqlSyntax.GetQuotedColumnName("key")));
-
-            if (colLen < 900 == false && colLen != null)
-            {
-                return;
-            }
-
-            var dbIndexes = SqlSyntax.GetDefinedIndexesDefinitions(Context.Database);
-
-            //make sure it doesn't already exist
-            if (dbIndexes.Any(x => x.IndexName.InvariantEquals("IX_cmsDictionary_key")) == false)
-            {
-                //we can apply the index
-                Create.Index("IX_cmsDictionary_key").OnTable("cmsDictionary")
-                    .OnColumn("key")
-                    .Ascending()
-                    .WithOptions()
-                    .NonClustered()
-                    .Do();
-            }
-        }
-    }
-}

src/Umbraco.Core/Migrations/Upgrade/V_7_7_0/AddUserGroupTables.cs

@@ -1,357 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Data;
-using System.Linq;
-using Umbraco.Core.Persistence;
-using Umbraco.Core.Persistence.Dtos;
-using ColumnInfo = Umbraco.Core.Persistence.SqlSyntax.ColumnInfo;
-
-namespace Umbraco.Core.Migrations.Upgrade.V_7_7_0
-{
-    public class AddUserGroupTables : MigrationBase
-    {
-        private readonly string _collateSyntax;
-
-        public AddUserGroupTables(IMigrationContext context)
-            : base(context)
-        {
-            //For some of the migration data inserts we require to use a special MSSQL collate expression since
-            //some databases may have a custom collation specified and if that is the case, when we compare strings
-            //in dynamic SQL it will try to compare strings in different collations and this will yield errors.
-            _collateSyntax = "COLLATE DATABASE_DEFAULT";
-        }
-
-        public override void Migrate()
-        {
-            var tables = SqlSyntax.GetTablesInSchema(Context.Database).ToList();
-            var constraints = SqlSyntax.GetConstraintsPerColumn(Context.Database).Distinct().ToArray();
-            var columns = SqlSyntax.GetColumnsInSchema(Context.Database).ToArray();
-
-            //In some very rare cases, there might already be user group tables that we'll need to remove first
-            //but of course we don't want to remove the tables we will be creating below if they already exist so
-            //need to do some checks first since these old rare tables have a different schema
-            RemoveOldTablesIfExist(tables, columns);
-
-            if (AddNewTables(tables))
-            {
-                MigrateUserPermissions();
-                MigrateUserTypesToGroups();
-                DeleteOldTables(tables, constraints);
-                SetDefaultIcons();
-            }
-            else
-            {
-                //if we aren't adding the tables, make sure that the umbracoUserGroup table has the correct FKs - these
-                //were added after the beta release so we need to do some cleanup
-                //if the FK doesn't exist
-                if (constraints.Any(x => x.Item1.InvariantEquals("umbracoUserGroup")
-                    && x.Item2.InvariantEquals("startContentId")
-                    && x.Item3.InvariantEquals("FK_startContentId_umbracoNode_id")) == false)
-                {
-                    //before we add any foreign key we need to make sure there's no stale data in there which would  have happened in the beta
-                    //release if a start node was assigned and then that start node was deleted.
-                    Database.Execute(@"UPDATE umbracoUserGroup SET startContentId = NULL WHERE startContentId NOT IN (SELECT id FROM umbracoNode)");
-
-                    Create.ForeignKey("FK_startContentId_umbracoNode_id")
-                        .FromTable("umbracoUserGroup")
-                        .ForeignColumn("startContentId")
-                        .ToTable("umbracoNode")
-                        .PrimaryColumn("id")
-                        .OnDelete(Rule.None)
-                        .OnUpdate(Rule.None)
-                        .Do();
-                }
-
-                if (constraints.Any(x => x.Item1.InvariantEquals("umbracoUserGroup")
-                    && x.Item2.InvariantEquals("startMediaId")
-                    && x.Item3.InvariantEquals("FK_startMediaId_umbracoNode_id")) == false)
-                {
-                    //before we add any foreign key we need to make sure there's no stale data in there which would  have happened in the beta
-                    //release if a start node was assigned and then that start node was deleted.
-                    Database.Execute(@"UPDATE umbracoUserGroup SET startMediaId = NULL WHERE startMediaId NOT IN (SELECT id FROM umbracoNode)");
-
-                    Create.ForeignKey("FK_startMediaId_umbracoNode_id")
-                        .FromTable("umbracoUserGroup")
-                        .ForeignColumn("startMediaId")
-                        .ToTable("umbracoNode")
-                        .PrimaryColumn("id")
-                        .OnDelete(Rule.None)
-                        .OnUpdate(Rule.None)
-                        .Do();
-                }
-            }
-        }
-
-        /// <summary>
-        /// In some very rare cases, there might already be user group tables that we'll need to remove first
-        /// but of course we don't want to remove the tables we will be creating below if they already exist so
-        /// need to do some checks first since these old rare tables have a different schema
-        /// </summary>
-        /// <param name="tables"></param>
-        /// <param name="columns"></param>
-        private void RemoveOldTablesIfExist(List<string> tables, ColumnInfo[] columns)
-        {
-            if (tables.Contains("umbracoUser2userGroup", StringComparer.InvariantCultureIgnoreCase))
-            {
-                //this column doesn't exist in the 7.7 schema, so if it's there, then this is a super old table
-                var foundOldColumn = columns
-                    .FirstOrDefault(x =>
-                        x.ColumnName.Equals("user", StringComparison.InvariantCultureIgnoreCase)
-                        && x.TableName.Equals("umbracoUser2userGroup", StringComparison.InvariantCultureIgnoreCase));
-                if (foundOldColumn != null)
-                {
-                    Delete.Table("umbracoUser2userGroup").Do();
-                    //remove from the tables list since this will be re-checked in further logic
-                    tables.Remove("umbracoUser2userGroup");
-                }
-            }
-
-            if (tables.Contains("umbracoUserGroup", StringComparer.InvariantCultureIgnoreCase))
-            {
-                //The new schema has several columns, the super old one for this table only had 2 so if it's 2 get rid of it
-                var countOfCols = columns
-                    .Count(x => x.TableName.Equals("umbracoUserGroup", StringComparison.InvariantCultureIgnoreCase));
-                if (countOfCols == 2)
-                {
-                    Delete.Table("umbracoUserGroup").Do();
-                    //remove from the tables list since this will be re-checked in further logic
-                    tables.Remove("umbracoUserGroup");
-                }
-            }
-        }
-
-        private void SetDefaultIcons()
-        {
-            Database.Execute($"UPDATE umbracoUserGroup SET icon = \'\' WHERE userGroupAlias = \'{Constants.Security.AdminGroupAlias}\'");
-            Database.Execute("UPDATE umbracoUserGroup SET icon = \'icon-edit\' WHERE userGroupAlias = \'writer\'");
-            Database.Execute("UPDATE umbracoUserGroup SET icon = \'icon-tools\' WHERE userGroupAlias = \'editor\'");
-            Database.Execute("UPDATE umbracoUserGroup SET icon = \'icon-globe\' WHERE userGroupAlias = \'translator\'");
-        }
-
-        private bool AddNewTables(List<string> tables)
-        {
-            var updated = false;
-            if (tables.InvariantContains("umbracoUserGroup") == false)
-            {
-                Create.Table<UserGroupDto>().Do();
-                updated = true;
-            }
-
-            if (tables.InvariantContains("umbracoUser2UserGroup") == false)
-            {
-                Create.Table<User2UserGroupDto>().Do();
-                updated = true;
-            }
-
-            if (tables.InvariantContains("umbracoUserGroup2App") == false)
-            {
-                Create.Table<UserGroup2AppDto>().Do();
-                updated = true;
-            }
-
-            if (tables.InvariantContains("umbracoUserGroup2NodePermission") == false)
-            {
-                Create.Table<UserGroup2NodePermissionDto>().Do();
-                updated = true;
-            }
-
-            return updated;
-        }
-
-        private void MigrateUserTypesToGroups()
-        {
-            // Create a user group for each user type
-            Database.Execute(@"INSERT INTO umbracoUserGroup (userGroupAlias, userGroupName, userGroupDefaultPermissions)
-                SELECT userTypeAlias, userTypeName, userTypeDefaultPermissions
-                FROM umbracoUserType");
-
-            // Add each user to the group created from their type
-            Database.Execute(string.Format(@"INSERT INTO umbracoUser2UserGroup (userId, userGroupId)
-                SELECT u.id, ug.id
-                FROM umbracoUser u
-                INNER JOIN umbracoUserType ut ON ut.id = u.userType
-                INNER JOIN umbracoUserGroup ug ON ug.userGroupAlias {0} = ut.userTypeAlias {0}", _collateSyntax));
-
-            // Add the built-in administrator account to all apps
-            // this will lookup all of the apps that the admin currently has access to in order to assign the sections
-            // instead of use statically assigning since there could be extra sections we don't know about.
-            Database.Execute(@"INSERT INTO umbracoUserGroup2app (userGroupId,app)
-                SELECT ug.id, app
-                FROM umbracoUserGroup ug
-                INNER JOIN umbracoUser2UserGroup u2ug ON u2ug.userGroupId = ug.id
-                INNER JOIN umbracoUser u ON u.id = u2ug.userId
-                INNER JOIN umbracoUser2app u2a ON u2a." + SqlSyntax.GetQuotedColumnName("user") + @" = u.id
-                WHERE u.id = 0");
-
-            // Add the default section access to the other built-in accounts
-            //  writer:
-            Database.Execute(string.Format(@"INSERT INTO umbracoUserGroup2app (userGroupId, app)
-                SELECT ug.id, 'content' as app
-                FROM umbracoUserGroup ug
-                WHERE ug.userGroupAlias {0} = 'writer' {0}", _collateSyntax));
-            //  editor
-            Database.Execute(string.Format(@"INSERT INTO umbracoUserGroup2app (userGroupId, app)
-                SELECT ug.id, 'content' as app
-                FROM umbracoUserGroup ug
-                WHERE ug.userGroupAlias {0} = 'editor' {0}", _collateSyntax));
-            Database.Execute(string.Format(@"INSERT INTO umbracoUserGroup2app (userGroupId, app)
-                SELECT ug.id, 'media' as app
-                FROM umbracoUserGroup ug
-                WHERE ug.userGroupAlias {0} = 'editor' {0}", _collateSyntax));
-            //  translator
-            Database.Execute(string.Format(@"INSERT INTO umbracoUserGroup2app (userGroupId, app)
-                SELECT ug.id, 'translation' as app
-                FROM umbracoUserGroup ug
-                WHERE ug.userGroupAlias {0} = 'translator' {0}", _collateSyntax));
-
-            //We need to lookup all distinct combinations of section access and create a group for each distinct collection
-            //and assign groups accordingly. We'll perform the lookup 'now' to then create the queued SQL migrations.
-            var userAppsData = Context.Database.Query<dynamic>(@"SELECT u.id, u2a.app FROM umbracoUser u
-                                INNER JOIN umbracoUser2app u2a ON u2a." + SqlSyntax.GetQuotedColumnName("user") + @" = u.id
-                                ORDER BY u.id, u2a.app");
-            var usersWithApps = new Dictionary<int, List<string>>();
-            foreach (var userApps in userAppsData)
-            {
-                if (usersWithApps.TryGetValue(userApps.id, out List<string> apps) == false)
-                {
-                    apps = new List<string> {userApps.app};
-                    usersWithApps.Add(userApps.id, apps);
-                }
-                else
-                {
-                    apps.Add(userApps.app);
-                }
-            }
-            //At this stage we have a dictionary of users with a collection of their apps which are sorted
-            //and we need to determine the unique/distinct app collections for each user to create groups with.
-            //We can do this by creating a hash value of all of the app values and since they are already sorted we can get a distinct
-            //collection by this hash.
-            var distinctApps = usersWithApps
-                .Select(x => new {appCollection = x.Value, appsHash = string.Join("", x.Value).GenerateHash()})
-                .DistinctBy(x => x.appsHash)
-                .ToArray();
-            //Now we need to create user groups for each of these distinct app collections, and then assign the corresponding users to those groups
-            for (var i = 0; i < distinctApps.Length; i++)
-            {
-                //create the group
-                var alias = "MigratedSectionAccessGroup_" + (i + 1);
-                Insert.IntoTable("umbracoUserGroup").Row(new
-                {
-                    userGroupAlias = "MigratedSectionAccessGroup_" + (i + 1),
-                    userGroupName = "Migrated Section Access Group " + (i + 1)
-                }).Do();
-                //now assign the apps
-                var distinctApp = distinctApps[i];
-                foreach (var app in distinctApp.appCollection)
-                {
-                    Database.Execute(string.Format(@"INSERT INTO umbracoUserGroup2app (userGroupId, app)
-                        SELECT ug.id, '" + app + @"' as app
-                        FROM umbracoUserGroup ug
-                        WHERE ug.userGroupAlias {0} = '" + alias + "' {0}", _collateSyntax));
-                }
-                //now assign the corresponding users to this group
-                foreach (var userWithApps in usersWithApps)
-                {
-                    //check if this user's groups hash matches the current groups hash
-                    var hash = string.Join("", userWithApps.Value).GenerateHash();
-                    if (hash == distinctApp.appsHash)
-                    {
-                        //it matches so assign the user to this group
-                        Database.Execute(string.Format(@"INSERT INTO umbracoUser2UserGroup (userId, userGroupId)
-                            SELECT " + userWithApps.Key + @", ug.id
-                            FROM umbracoUserGroup ug
-                            WHERE ug.userGroupAlias {0} = '" + alias + "' {0}", _collateSyntax));
-                    }
-                }
-            }
-
-            // Rename some groups for consistency (plural form)
-            Database.Execute("UPDATE umbracoUserGroup SET userGroupName = 'Writers' WHERE userGroupAlias = 'writer'");
-            Database.Execute("UPDATE umbracoUserGroup SET userGroupName = 'Translators' WHERE userGroupAlias = 'translator'");
-
-            //Ensure all built in groups have a start node of -1
-            Database.Execute("UPDATE umbracoUserGroup SET startContentId = -1 WHERE userGroupAlias = 'editor'");
-            Database.Execute("UPDATE umbracoUserGroup SET startMediaId = -1 WHERE userGroupAlias = 'editor'");
-            Database.Execute("UPDATE umbracoUserGroup SET startContentId = -1 WHERE userGroupAlias = 'writer'");
-            Database.Execute("UPDATE umbracoUserGroup SET startMediaId = -1 WHERE userGroupAlias = 'writer'");
-            Database.Execute("UPDATE umbracoUserGroup SET startContentId = -1 WHERE userGroupAlias = 'translator'");
-            Database.Execute("UPDATE umbracoUserGroup SET startMediaId = -1 WHERE userGroupAlias = 'translator'");
-            Database.Execute("UPDATE umbracoUserGroup SET startContentId = -1 WHERE userGroupAlias = 'admin'");
-            Database.Execute("UPDATE umbracoUserGroup SET startMediaId = -1 WHERE userGroupAlias = 'admin'");
-        }
-
-        private void MigrateUserPermissions()
-        {
-            // Create user group records for all non-admin users that have specific permissions set
-            Database.Execute(@"INSERT INTO umbracoUserGroup(userGroupAlias, userGroupName)
-                SELECT 'permissionGroupFor' + userLogin, 'Migrated Permission Group for ' + userLogin
-                FROM umbracoUser
-                WHERE (id IN (
-                    SELECT userid
-                    FROM umbracoUser2NodePermission
-                ))
-                AND id > 0");
-
-            // Associate those groups with the users
-            Database.Execute(string.Format(@"INSERT INTO umbracoUser2UserGroup (userId, userGroupId)
-                SELECT u.id, ug.id
-                FROM umbracoUser u
-                INNER JOIN umbracoUserGroup ug ON ug.userGroupAlias {0} = 'permissionGroupFor' + userLogin {0}", _collateSyntax));
-
-            // Create node permissions on the groups
-            Database.Execute(string.Format(@"INSERT INTO umbracoUserGroup2NodePermission (userGroupId,nodeId,permission)
-                SELECT ug.id, nodeId, permission
-                FROM umbracoUserGroup ug
-                INNER JOIN umbracoUser2UserGroup u2ug ON u2ug.userGroupId = ug.id
-                INNER JOIN umbracoUser u ON u.id = u2ug.userId
-                INNER JOIN umbracoUser2NodePermission u2np ON u2np.userId = u.id
-                WHERE ug.userGroupAlias {0} NOT IN (
-                    SELECT userTypeAlias {0}
-                    FROM umbracoUserType
-                )", _collateSyntax));
-
-            // Create app permissions on the groups
-            Database.Execute(string.Format(@"INSERT INTO umbracoUserGroup2app (userGroupId,app)
-                SELECT ug.id, app
-                FROM umbracoUserGroup ug
-                INNER JOIN umbracoUser2UserGroup u2ug ON u2ug.userGroupId = ug.id
-                INNER JOIN umbracoUser u ON u.id = u2ug.userId
-                INNER JOIN umbracoUser2app u2a ON u2a." + SqlSyntax.GetQuotedColumnName("user") + @" = u.id
-                WHERE ug.userGroupAlias {0} NOT IN (
-                    SELECT userTypeAlias {0}
-                    FROM umbracoUserType
-                )", _collateSyntax));
-        }
-
-        private void DeleteOldTables(List<string> tables, Tuple<string, string, string>[] constraints)
-        {
-            if (tables.InvariantContains("umbracoUser2App"))
-            {
-                Delete.Table("umbracoUser2App").Do();
-            }
-
-            if (tables.InvariantContains("umbracoUser2NodePermission"))
-            {
-                Delete.Table("umbracoUser2NodePermission").Do();
-            }
-
-            if (tables.InvariantContains("umbracoUserType") && tables.InvariantContains("umbracoUser"))
-            {
-                //Delete the FK if it exists before dropping the column
-                if (constraints.Any(x => x.Item1.InvariantEquals("umbracoUser") && x.Item3.InvariantEquals("FK_umbracoUser_umbracoUserType_id")))
-                {
-                    Delete.ForeignKey("FK_umbracoUser_umbracoUserType_id").OnTable("umbracoUser").Do();
-                }
-
-                //This is the super old constraint name of the FK for user type so check this one too
-                if (constraints.Any(x => x.Item1.InvariantEquals("umbracoUser") && x.Item3.InvariantEquals("FK_user_userType")))
-                {
-                    Delete.ForeignKey("FK_user_userType").OnTable("umbracoUser").Do();
-                }
-
-                Delete.Column("userType").FromTable("umbracoUser").Do();
-                Delete.Table("umbracoUserType").Do();
-            }
-        }
-    }
-}

src/Umbraco.Core/Migrations/Upgrade/V_7_7_0/AddUserStartNodeTable.cs

@@ -1,41 +0,0 @@
-using System.Linq;
-using Umbraco.Core.Persistence.Dtos;
-
-namespace Umbraco.Core.Migrations.Upgrade.V_7_7_0
-{
-    public class AddUserStartNodeTable : MigrationBase
-    {
-        public AddUserStartNodeTable(IMigrationContext context)
-            : base(context)
-        { }
-
-        public override void Migrate()
-        {
-            var tables = SqlSyntax.GetTablesInSchema(Context.Database).ToArray();
-
-            if (tables.InvariantContains("umbracoUserStartNode")) return;
-
-            Create.Table<UserStartNodeDto>().Do();
-
-            MigrateUserStartNodes();
-
-            //now remove the old columns
-
-            Delete.Column("startStructureID").FromTable("umbracoUser").Do();
-            Delete.Column("startMediaID").FromTable("umbracoUser").Do();
-        }
-
-        private void MigrateUserStartNodes()
-        {
-            Database.Execute(@"INSERT INTO umbracoUserStartNode (userId, startNode, startNodeType)
-                SELECT id, startStructureID, 1
-                FROM umbracoUser
-                WHERE startStructureID IS NOT NULL AND startStructureID > 0 AND startStructureID IN (SELECT id FROM umbracoNode WHERE nodeObjectType='" + Constants.ObjectTypes.Document + "')");
-
-            Database.Execute(@"INSERT INTO umbracoUserStartNode (userId, startNode, startNodeType)
-                SELECT id, startMediaID, 2
-                FROM umbracoUser
-                WHERE startMediaID IS NOT NULL AND startMediaID > 0 AND startMediaID IN (SELECT id FROM umbracoNode WHERE nodeObjectType='" + Constants.ObjectTypes.Media + "')");
-        }
-    }
-}

src/Umbraco.Core/Migrations/Upgrade/V_7_7_0/EnsureContentTemplatePermissions.cs

@@ -1,37 +0,0 @@
-using System.Linq;
-using Umbraco.Core.Persistence;
-using Umbraco.Core.Persistence.Dtos;
-
-namespace Umbraco.Core.Migrations.Upgrade.V_7_7_0
-{
-    /// <summary>
-    /// Ensures the built-in user groups have the blueprint permission by default on upgrade
-    /// </summary>
-    public class EnsureContentTemplatePermissions : MigrationBase
-    {
-        public EnsureContentTemplatePermissions(IMigrationContext context)
-            : base(context)
-        { }
-
-        public override void Migrate()
-        {
-            var database = Database;
-            var userGroups = database.Fetch<UserGroupDto>(
-                Context.SqlContext.Sql().Select("*")
-                    .From<UserGroupDto>()
-                    .Where<UserGroupDto>(x => x.Alias == "admin" || x.Alias == "editor"));
-
-            foreach (var userGroup in userGroups)
-            {
-                if (userGroup.DefaultPermissions.Contains('�') == false)
-                {
-                    userGroup.DefaultPermissions += "�";
-                    Update.Table("umbracoUserGroup")
-                        .Set(new { userGroupDefaultPermissions = userGroup.DefaultPermissions })
-                        .Where(new { id = userGroup.Id })
-                        .Do();
-                }
-            }
-        }
-    }
-}

src/Umbraco.Core/Migrations/Upgrade/V_7_7_0/ReduceDictionaryKeyColumnsSize.cs

@@ -1,37 +0,0 @@
-using System.Linq;
-using Umbraco.Core.Persistence.SqlSyntax;
-
-namespace Umbraco.Core.Migrations.Upgrade.V_7_7_0
-{
-    public class ReduceDictionaryKeyColumnsSize : MigrationBase
-    {
-        public ReduceDictionaryKeyColumnsSize(IMigrationContext context)
-            : base(context)
-        { }
-
-        public override void Migrate()
-        {
-            //Now we need to check if we can actually do this because we won't be able to if there's data in there that is too long
-
-            var database = Database;
-            var dbIndexes = SqlSyntax.GetDefinedIndexesDefinitions(database);
-
-            var colLen = database.ExecuteScalar<int?>(string.Format("select max(datalength({0})) from cmsDictionary", SqlSyntax.GetQuotedColumnName("key")));
-
-            if (colLen < 900 == false) return;
-
-            //if it exists we need to drop it first
-            if (dbIndexes.Any(x => x.IndexName.InvariantEquals("IX_cmsDictionary_key")))
-            {
-                Delete.Index("IX_cmsDictionary_key").OnTable("cmsDictionary").Do();
-            }
-
-            //we can apply the col length change
-            Alter.Table("cmsDictionary")
-                .AlterColumn("key")
-                .AsString(450)
-                .NotNullable()
-                .Do();
-        }
-    }
-}

src/Umbraco.Core/Migrations/Upgrade/V_7_7_0/UpdateUserTables.cs

@@ -1,48 +0,0 @@
-using System.Linq;
-using System.Web.Security;
-using Newtonsoft.Json;
-using Umbraco.Core.Persistence.DatabaseModelDefinitions;
-using Umbraco.Core.Security;
-
-namespace Umbraco.Core.Migrations.Upgrade.V_7_7_0
-{
-    public class UpdateUserTables : MigrationBase
-    {
-        public UpdateUserTables(IMigrationContext context)
-            : base(context)
-        { }
-
-        public override void Migrate()
-        {
-            //Don't execute if the column is already there
-            var columns = SqlSyntax.GetColumnsInSchema(Context.Database).ToArray();
-
-            if (columns.Any(x => x.TableName.InvariantEquals("umbracoUser") && x.ColumnName.InvariantEquals("createDate")) == false)
-                Create.Column("createDate").OnTable("umbracoUser").AsDateTime().NotNullable().WithDefault(SystemMethods.CurrentDateTime).Do();
-
-            if (columns.Any(x => x.TableName.InvariantEquals("umbracoUser") && x.ColumnName.InvariantEquals("updateDate")) == false)
-                Create.Column("updateDate").OnTable("umbracoUser").AsDateTime().NotNullable().WithDefault(SystemMethods.CurrentDateTime).Do();
-
-            if (columns.Any(x => x.TableName.InvariantEquals("umbracoUser") && x.ColumnName.InvariantEquals("emailConfirmedDate")) == false)
-                Create.Column("emailConfirmedDate").OnTable("umbracoUser").AsDateTime().Nullable().Do();
-
-            if (columns.Any(x => x.TableName.InvariantEquals("umbracoUser") && x.ColumnName.InvariantEquals("invitedDate")) == false)
-                Create.Column("invitedDate").OnTable("umbracoUser").AsDateTime().Nullable().Do();
-
-            if (columns.Any(x => x.TableName.InvariantEquals("umbracoUser") && x.ColumnName.InvariantEquals("avatar")) == false)
-                Create.Column("avatar").OnTable("umbracoUser").AsString(500).Nullable().Do();
-
-            if (columns.Any(x => x.TableName.InvariantEquals("umbracoUser") && x.ColumnName.InvariantEquals("passwordConfig")) == false)
-            {
-                Create.Column("passwordConfig").OnTable("umbracoUser").AsString(500).Nullable().Do();
-                //Check if we have a known config, we only want to store config for hashing
-                var membershipProvider = MembershipProviderExtensions.GetUsersMembershipProvider();
-                if (membershipProvider.PasswordFormat == MembershipPasswordFormat.Hashed)
-                {
-                    var json = JsonConvert.SerializeObject(new { hashAlgorithm = Membership.HashAlgorithmType });
-                    Database.Execute("UPDATE umbracoUser SET passwordConfig = '" + json + "'");
-                }
-            }
-        }
-    }
-}

src/Umbraco.Core/Migrations/Upgrade/V_7_8_0/AddIndexToPropertyTypeAliasColumn.cs

@@ -1,27 +0,0 @@
-using System.Linq;
-using Umbraco.Core.Persistence.SqlSyntax;
-
-namespace Umbraco.Core.Migrations.Upgrade.V_7_8_0
-{
-    internal class AddIndexToPropertyTypeAliasColumn : MigrationBase
-    {
-        public AddIndexToPropertyTypeAliasColumn(IMigrationContext context)
-            : base(context)
-        { }
-
-        public override void Migrate()
-        {
-            var dbIndexes = SqlSyntax.GetDefinedIndexesDefinitions(Context.Database);
-
-            //make sure it doesn't already exist
-            if (dbIndexes.Any(x => x.IndexName.InvariantEquals("IX_cmsPropertyTypeAlias")) == false)
-            {
-                //we can apply the index
-                Create.Index("IX_cmsPropertyTypeAlias").OnTable(Constants.DatabaseSchema.Tables.PropertyType)
-                    .OnColumn("Alias")
-                    .Ascending().WithOptions().NonClustered()
-                    .Do();
-            }
-        }
-    }
-}

src/Umbraco.Core/Migrations/Upgrade/V_7_8_0/AddInstructionCountColumn.cs

@@ -1,20 +0,0 @@
-using System.Linq;
-using Umbraco.Core.Persistence.Dtos;
-
-namespace Umbraco.Core.Migrations.Upgrade.V_7_8_0
-{
-    internal class AddInstructionCountColumn : MigrationBase
-    {
-        public AddInstructionCountColumn(IMigrationContext context)
-            : base(context)
-        { }
-
-        public override void Migrate()
-        {
-            var columns = SqlSyntax.GetColumnsInSchema(Context.Database).ToArray();
-
-            if (columns.Any(x => x.TableName.InvariantEquals(Constants.DatabaseSchema.Tables.CacheInstruction) && x.ColumnName.InvariantEquals("instructionCount")) == false)
-                AddColumn<CacheInstructionDto>("instructionCount");
-        }
-    }
-}

src/Umbraco.Core/Migrations/Upgrade/V_7_8_0/AddMediaVersionTable.cs

@@ -1,65 +0,0 @@
-using System.Collections.Generic;
-using System.Linq;
-using Umbraco.Core.Persistence;
-using Umbraco.Core.Persistence.Dtos;
-using Umbraco.Core.Persistence.Factories;
-using static Umbraco.Core.Persistence.NPocoSqlExtensions.Statics;
-
-namespace Umbraco.Core.Migrations.Upgrade.V_7_8_0
-{
-    internal class AddMediaVersionTable : MigrationBase
-    {
-        public AddMediaVersionTable(IMigrationContext context)
-            : base(context)
-        { }
-
-        public override void Migrate()
-        {
-            var tables = SqlSyntax.GetTablesInSchema(Context.Database).ToArray();
-
-            if (tables.InvariantContains(Constants.DatabaseSchema.Tables.MediaVersion)) return;
-
-            Create.Table<MediaVersionDto>().Do();
-            MigrateMediaPaths();
-        }
-
-        private void MigrateMediaPaths()
-        {
-            // this may not be the most efficient way to do it, compared to how it's done in v7, but this
-            // migration should only run for v8 sites that are being developed, before v8 is released, so
-            // no big sites and performances don't matter here - keep it simple
-
-            var sql = Sql()
-                .Select<PropertyDataDto>(x => x.VarcharValue, x => x.TextValue)
-                    .AndSelect<ContentVersionDto>(x => Alias(x.Id, "versionId"))
-                .From<PropertyDataDto>()
-                    .InnerJoin<PropertyTypeDto>().On<PropertyDataDto, PropertyTypeDto>((left, right) => left.PropertyTypeId == right.Id)
-                    .InnerJoin<ContentVersionDto>().On<PropertyDataDto, ContentVersionDto>((left, right) => left.VersionId == right.Id)
-                    .InnerJoin<NodeDto>().On<ContentVersionDto, NodeDto>((left, right) => left.NodeId == right.NodeId)
-                .Where<PropertyTypeDto>(x => x.Alias == "umbracoFile")
-                .Where<NodeDto>(x => x.NodeObjectType == Constants.ObjectTypes.Media);
-
-                var paths = new List<MediaVersionDto>();
-
-                //using QUERY = a db cursor, we won't load this all into memory first, just row by row
-                foreach (var row in Database.Query<dynamic>(sql))
-                {
-                    // if there's values then ensure there's a media path match and extract it
-                    string mediaPath = null;
-                    if (
-                        (row.varcharValue != null && ContentBaseFactory.TryMatch((string) row.varcharValue, out mediaPath))
-                        || (row.textValue != null && ContentBaseFactory.TryMatch((string) row.textValue, out mediaPath)))
-                    {
-                        paths.Add(new MediaVersionDto
-                        {
-                            Id = (int) row.versionId,
-                            Path = mediaPath
-                        });
-                    }
-                }
-
-                // bulk insert
-                Database.BulkInsertRecords(paths);
-        }
-    }
-}

src/Umbraco.Core/Migrations/Upgrade/V_7_8_0/AddTourDataUserColumn.cs

@@ -1,21 +0,0 @@
-using System.Linq;
-using Umbraco.Core.Persistence.DatabaseAnnotations;
-using Umbraco.Core.Persistence.Dtos;
-
-namespace Umbraco.Core.Migrations.Upgrade.V_7_8_0
-{
-    internal class AddTourDataUserColumn : MigrationBase
-    {
-        public AddTourDataUserColumn(IMigrationContext context)
-            : base(context)
-        { }
-
-        public override void Migrate()
-        {
-            var columns = SqlSyntax.GetColumnsInSchema(Context.Database).ToArray();
-
-            if (columns.Any(x => x.TableName.InvariantEquals(Constants.DatabaseSchema.Tables.User) && x.ColumnName.InvariantEquals("tourData")) == false)
-                AddColumn<UserDto>("tourData");
-        }
-    }
-}

src/Umbraco.Core/Migrations/Upgrade/V_7_8_0/AddUserLoginTable.cs

@@ -1,22 +0,0 @@
-using System.Linq;
-using Umbraco.Core.Persistence.Dtos;
-
-namespace Umbraco.Core.Migrations.Upgrade.V_7_8_0
-{
-    internal class AddUserLoginTable : MigrationBase
-    {
-        public AddUserLoginTable(IMigrationContext context)
-            : base(context)
-        { }
-
-        public override void Migrate()
-        {
-            var tables = SqlSyntax.GetTablesInSchema(Context.Database).ToArray();
-
-            if (tables.InvariantContains(Constants.DatabaseSchema.Tables.UserLogin) == false)
-            {
-                Create.Table<UserLoginDto>().Do();
-            }
-        }
-    }
-}

src/Umbraco.Core/Migrations/Upgrade/V_7_9_0/AddIsSensitiveMemberTypeColumn.cs

@@ -1,20 +0,0 @@
-using System.Linq;
-using Umbraco.Core.Persistence.Dtos;
-
-namespace Umbraco.Core.Migrations.Upgrade.V_7_9_0
-{
-    internal class AddIsSensitiveMemberTypeColumn : MigrationBase
-    {
-        public AddIsSensitiveMemberTypeColumn(IMigrationContext context)
-            : base(context)
-        { }
-
-        public override void Migrate()
-        {
-            var columns = SqlSyntax.GetColumnsInSchema(Context.Database).ToArray();
-
-            if (columns.Any(x => x.TableName.InvariantEquals(Constants.DatabaseSchema.Tables.MemberPropertyType) && x.ColumnName.InvariantEquals("isSensitive")) == false)
-                AddColumn<MemberPropertyTypeDto>("isSensitive");
-        }
-    }
-}

src/Umbraco.Core/Migrations/Upgrade/V_7_9_0/AddUmbracoAuditTable.cs

@@ -1,22 +0,0 @@
-using System.Linq;
-using Umbraco.Core.Persistence.Dtos;
-
-namespace Umbraco.Core.Migrations.Upgrade.V_7_9_0
-{
-    internal class AddUmbracoAuditTable : MigrationBase
-    {
-        public AddUmbracoAuditTable(IMigrationContext context)
-            : base(context)
-        { }
-
-        public override void Migrate()
-        {
-            var tables = SqlSyntax.GetTablesInSchema(Context.Database).ToArray();
-
-            if (tables.InvariantContains(Constants.DatabaseSchema.Tables.AuditEntry))
-                return;
-
-            Create.Table<AuditEntryDto>().Do();
-        }
-    }
-}

src/Umbraco.Core/Migrations/Upgrade/V_7_9_0/AddUmbracoConsentTable.cs

@@ -1,22 +0,0 @@
-using System.Linq;
-using Umbraco.Core.Persistence.Dtos;
-
-namespace Umbraco.Core.Migrations.Upgrade.V_7_9_0
-{
-    internal class AddUmbracoConsentTable : MigrationBase
-    {
-        public AddUmbracoConsentTable(IMigrationContext context)
-            : base(context)
-        { }
-
-        public override void Migrate()
-        {
-            var tables = SqlSyntax.GetTablesInSchema(Context.Database).ToArray();
-
-            if (tables.InvariantContains(Constants.DatabaseSchema.Tables.Consent))
-                return;
-
-            Create.Table<ConsentDto>().Do();
-        }
-    }
-}

src/Umbraco.Core/Migrations/Upgrade/V_7_9_0/CreateSensitiveDataUserGroup.cs

@@ -1,27 +0,0 @@
-using System;
-using Umbraco.Core.Persistence;
-using Umbraco.Core.Persistence.Dtos;
-
-namespace Umbraco.Core.Migrations.Upgrade.V_7_9_0
-{
-    internal class CreateSensitiveDataUserGroup : MigrationBase
-    {
-        public CreateSensitiveDataUserGroup(IMigrationContext context)
-            : base(context)
-        { }
-
-        public override void Migrate()
-        {
-            var sql = Sql()
-                .SelectCount()
-                .From<UserGroupDto>()
-                .Where<UserGroupDto>(x => x.Alias == Constants.Security.SensitiveDataGroupAlias);
-
-            var exists = Database.ExecuteScalar<int>(sql) > 0;
-            if (exists) return;
-
-            var groupId = Database.Insert(Constants.DatabaseSchema.Tables.UserGroup, "id", new UserGroupDto { StartMediaId = -1, StartContentId = -1, Alias = Constants.Security.SensitiveDataGroupAlias, Name = "Sensitive data", DefaultPermissions = "", CreateDate = DateTime.Now, UpdateDate = DateTime.Now, Icon = "icon-lock" });
-            Database.Insert(new User2UserGroupDto { UserGroupId = Convert.ToInt32(groupId), UserId = Constants.Security.SuperUserId }); // add super to sensitive data
-        }
-    }
-}

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

@@ -1,6 +1,7 @@
 using System.Data;
 using System.Linq;
 using Umbraco.Core.Persistence.DatabaseAnnotations;
+using Umbraco.Core.Persistence.Dtos;
 
 namespace Umbraco.Core.Migrations.Upgrade.V_8_0_0
 {
@@ -12,31 +13,10 @@ namespace Umbraco.Core.Migrations.Upgrade.V_8_0_0
 
         public override void Migrate()
         {
-            var tables = SqlSyntax.GetTablesInSchema(Context.Database).ToArray();
+            var tables = SqlSyntax.GetTablesInSchema(Context.Database);
             if (tables.InvariantContains("cmsContentNu")) return;
 
-            var textType = SqlSyntax.GetSpecialDbType(SpecialDbTypes.NTEXT);
-
-            Create.Table("cmsContentNu")
-                .WithColumn("nodeId").AsInt32().NotNullable()
-                .WithColumn("published").AsBoolean().NotNullable()
-                .WithColumn("data").AsCustom(textType).NotNullable()
-                .WithColumn("rv").AsInt64().NotNullable().WithDefaultValue(0)
-                .Do();
-
-            Create.PrimaryKey("PK_cmsContentNu")
-                .OnTable("cmsContentNu")
-                .Columns(new[] { "nodeId", "published" })
-                .Do();
-
-            Create.ForeignKey("FK_cmsContentNu_umbracoNode_id")
-                .FromTable("cmsContentNu")
-                .ForeignColumn("nodeId")
-                .ToTable("umbracoNode")
-                .PrimaryColumn("id")
-                .OnDelete(Rule.Cascade)
-                .OnUpdate(Rule.None)
-                .Do();
+            Create.Table<ContentNuDto>(true).Do();
         }
     }
 }

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

@@ -1,24 +0,0 @@
-using System.Linq;
-
-namespace Umbraco.Core.Migrations.Upgrade.V_8_0_0
-{
-    public class AddLockTable : MigrationBase
-    {
-        public AddLockTable(IMigrationContext context)
-            : base(context)
-        { }
-
-        public override void Migrate()
-        {
-            var tables = SqlSyntax.GetTablesInSchema(Context.Database).ToArray();
-            if (tables.InvariantContains("umbracoLock") == false)
-            {
-                Create.Table("umbracoLock")
-                    .WithColumn("id").AsInt32().PrimaryKey("PK_umbracoLock")
-                    .WithColumn("value").AsInt32().NotNullable()
-                    .WithColumn("name").AsString(64).NotNullable()
-                    .Do();
-            }
-        }
-    }
-}

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

@@ -1,22 +0,0 @@
-using Umbraco.Core.Persistence.Dtos;
-
-namespace Umbraco.Core.Migrations.Upgrade.V_8_0_0
-{
-    public class AddUserLoginDtoDateIndex : MigrationBase
-    {
-        public AddUserLoginDtoDateIndex(IMigrationContext context)
-            : base(context)
-        { }
-
-        public override void Migrate()
-        {
-            if (!IndexExists("IX_umbracoUserLogin_lastValidatedUtc"))
-                Create.Index("IX_umbracoUserLogin_lastValidatedUtc")
-                    .OnTable(UserLoginDto.TableName)
-                    .OnColumn("lastValidatedUtc")
-                    .Ascending()
-                    .WithOptions().NonClustered()
-                    .Do();
-        }
-    }
-}

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

@@ -11,8 +11,8 @@ namespace Umbraco.Core.Migrations.Upgrade.V_8_0_0
 
         public override void Migrate()
         {
-            Create.Table<ContentVersionCultureVariationDto>().Do();
-            Create.Table<DocumentCultureVariationDto>().Do();
+            Create.Table<ContentVersionCultureVariationDto>(true).Do();
+            Create.Table<DocumentCultureVariationDto>(true).Do();
         }
     }
 }

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

@@ -1,28 +1,33 @@
 using System;
-using System.Collections.Generic;
 using System.Linq;
-using System.Reflection;
 using Newtonsoft.Json;
-using NPoco;
-using Umbraco.Core.Migrations.Install;
+using Umbraco.Core.Composing;
+using Umbraco.Core.Logging;
+using Umbraco.Core.Migrations.Upgrade.V_8_0_0.DataTypes;
 using Umbraco.Core.Persistence;
 using Umbraco.Core.Persistence.Dtos;
 using Umbraco.Core.Persistence.Querying;
+using Umbraco.Core.PropertyEditors;
 
 namespace Umbraco.Core.Migrations.Upgrade.V_8_0_0
 {
 
     public class DataTypeMigration : MigrationBase
     {
-        public DataTypeMigration(IMigrationContext context)
+        private readonly PreValueMigratorCollection _preValueMigrators;
+        private readonly PropertyEditorCollection _propertyEditors;
+        private readonly ILogger _logger;
+
+        public DataTypeMigration(IMigrationContext context, PreValueMigratorCollection preValueMigrators, PropertyEditorCollection propertyEditors, ILogger logger)
             : base(context)
-        { }
+        {
+            _preValueMigrators = preValueMigrators;
+            _propertyEditors = propertyEditors;
+            _logger = logger;
+        }
 
         public override void Migrate()
         {
-            // delete *all* keys and indexes - because of FKs
-            Delete.KeysAndIndexes().Do();
-
             // drop and create columns
             Delete.Column("pk").FromTable("cmsDataType").Do();
 
@@ -31,21 +36,17 @@ namespace Umbraco.Core.Migrations.Upgrade.V_8_0_0
 
             // create column
             AddColumn<DataTypeDto>(Constants.DatabaseSchema.Tables.DataType, "config");
-            Execute.Sql(Sql().Update<DataTypeDto>(u => u.Set(x => x.Configuration, string.Empty)).SQL).Do();
-
-            // re-create *all* keys and indexes
-            foreach (var x in DatabaseSchemaCreator.OrderedTables)
-                Create.KeysAndIndexes(x).Do();
+            Execute.Sql(Sql().Update<DataTypeDto>(u => u.Set(x => x.Configuration, string.Empty))).Do();
 
             // renames
             Execute.Sql(Sql()
                 .Update<DataTypeDto>(u => u.Set(x => x.EditorAlias, "Umbraco.ColorPicker"))
-                .Where<DataTypeDto>(x => x.EditorAlias == "Umbraco.ColorPickerAlias").SQL).Do();
+                .Where<DataTypeDto>(x => x.EditorAlias == "Umbraco.ColorPickerAlias")).Do();
 
             // from preValues to configuration...
             var sql = Sql()
                 .Select<DataTypeDto>()
-                .AndSelect<PreValueDto>(x => x.Alias, x => x.SortOrder, x => x.Value)
+                .AndSelect<PreValueDto>(x => x.Id, x => x.Alias, x => x.SortOrder, x => x.Value)
                 .From<DataTypeDto>()
                 .InnerJoin<PreValueDto>().On<DataTypeDto, PreValueDto>((left, right) => left.NodeId == right.NodeId)
                 .OrderBy<DataTypeDto>(x => x.NodeId)
@@ -60,43 +61,45 @@ namespace Umbraco.Core.Migrations.Upgrade.V_8_0_0
                     .From<DataTypeDto>()
                     .Where<DataTypeDto>(x => x.NodeId == group.Key)).First();
 
-                var aliases = group.Select(x => x.Alias).Distinct().ToArray();
-                if (aliases.Length == 1 && string.IsNullOrWhiteSpace(aliases[0]))
+                // migrate the preValues to configuration
+                var migrator = _preValueMigrators.GetMigrator(dataType.EditorAlias) ?? new DefaultPreValueMigrator();
+                var config = migrator.GetConfiguration(dataType.NodeId, dataType.EditorAlias, group.ToDictionary(x => x.Alias, x => x));
+                var json = JsonConvert.SerializeObject(config);
+
+                // validate - and kill the migration if it fails
+                var newAlias = migrator.GetNewAlias(dataType.EditorAlias);
+                if (newAlias == null)
                 {
-                    // array-based prevalues
-                    var values = new Dictionary<string, object> { ["values"] = group.OrderBy(x => x.SortOrder).Select(x => x.Value).ToArray() };
-                    dataType.Configuration = JsonConvert.SerializeObject(values);
+                    _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);
                 }
                 else
                 {
-                    // assuming we don't want to fall back to array
-                    if (aliases.Length != group.Count() || aliases.Any(string.IsNullOrWhiteSpace))
-                        throw new InvalidOperationException($"Cannot migrate datatype w/ id={dataType.NodeId} preValues: duplicate or null/empty alias.");
-
-                    // dictionary-base prevalues
-                    var values = group.ToDictionary(x => x.Alias, x => x.Value);
-                    dataType.Configuration = JsonConvert.SerializeObject(values);
+                    var configEditor = propertyEditor.GetConfigurationEditor();
+                    try
+                    {
+                        var _ = configEditor.FromDatabase(json);
+                    }
+                    catch (Exception e)
+                    {
+                        _logger.Warn<DataTypeMigration>(e, "Failed to validate configuration for data type {NodeId} : {NewEditorAlias} (was: {EditorAlias})."
+                                                        + " Please fix the configuration and ensure it is valid. The site may fail to start and / or load data types and run.",
+                                                        dataType.NodeId, newAlias, dataType.EditorAlias);
+                    }
                 }
 
+                // update
+                dataType.Configuration = JsonConvert.SerializeObject(config);
                 Database.Update(dataType);
             }
         }
-
-        [TableName("cmsDataTypePreValues")]
-        [ExplicitColumns]
-        public class PreValueDto
-        {
-            [Column("datatypeNodeId")]
-            public int NodeId { get; set; }
-
-            [Column("alias")]
-            public string Alias { get; set; }
-
-            [Column("sortorder")]
-            public int SortOrder { get; set; }
-
-            [Column("value")]
-            public string Value { get; set; }
-        }
     }
 }

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

@@ -0,0 +1,20 @@
+namespace Umbraco.Core.Migrations.Upgrade.V_8_0_0.DataTypes
+{
+    class ContentPickerPreValueMigrator : DefaultPreValueMigrator
+    {
+        public override bool CanMigrate(string editorAlias)
+            => editorAlias == "Umbraco.ContentPicker2";
+
+        public override string GetNewAlias(string editorAlias)
+            => null;
+
+        protected override object GetPreValueValue(PreValueDto preValue)
+        {
+            if (preValue.Alias == "showOpenButton" ||
+                preValue.Alias == "ignoreUserStartNodes")
+                return preValue.Value == "1";
+
+            return base.GetPreValueValue(preValue);
+        }
+    }
+}

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

@@ -0,0 +1,20 @@
+using Newtonsoft.Json;
+
+namespace Umbraco.Core.Migrations.Upgrade.V_8_0_0.DataTypes
+{
+    class DecimalPreValueMigrator : DefaultPreValueMigrator
+    {
+        public override bool CanMigrate(string editorAlias)
+            => editorAlias == "Umbraco.Decimal";
+
+        protected override object GetPreValueValue(PreValueDto preValue)
+        {
+            if (preValue.Alias == "min" ||
+                preValue.Alias == "step" ||
+                preValue.Alias == "max")
+                return decimal.TryParse(preValue.Value, out var d) ? (decimal?) d : null;
+
+            return preValue.Value.DetectIsJson() ? JsonConvert.DeserializeObject(preValue.Value) : preValue.Value;
+        }
+    }
+}

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

@@ -0,0 +1,42 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Newtonsoft.Json;
+
+namespace Umbraco.Core.Migrations.Upgrade.V_8_0_0.DataTypes
+{
+    class DefaultPreValueMigrator : IPreValueMigrator
+    {
+        public virtual bool CanMigrate(string editorAlias)
+            => true;
+
+        public virtual string GetNewAlias(string editorAlias)
+            => editorAlias;
+
+        public object GetConfiguration(int dataTypeId, string editorAlias, Dictionary<string, PreValueDto> preValues)
+        {
+            var preValuesA = preValues.Values.ToList();
+            var aliases = preValuesA.Select(x => x.Alias).Distinct().ToArray();
+            if (aliases.Length == 1 && string.IsNullOrWhiteSpace(aliases[0]))
+            {
+                // array-based prevalues
+                return new Dictionary<string, object> { ["values"] = preValuesA.OrderBy(x => x.SortOrder).Select(x => x.Value).ToArray() };
+            }
+
+            // assuming we don't want to fall back to array
+            if (aliases.Length != preValuesA.Count || aliases.Any(string.IsNullOrWhiteSpace))
+                throw new InvalidOperationException($"Cannot migrate datatype w/ id={dataTypeId} preValues: duplicate or null/empty alias.");
+
+            // dictionary-base prevalues
+            return GetPreValues(preValuesA).ToDictionary(x => x.Alias, GetPreValueValue);
+        }
+
+        protected virtual IEnumerable<PreValueDto> GetPreValues(IEnumerable<PreValueDto> preValues)
+            => preValues;
+
+        protected virtual object GetPreValueValue(PreValueDto preValue)
+        {
+            return preValue.Value.DetectIsJson() ? JsonConvert.DeserializeObject(preValue.Value) : preValue.Value;
+        }
+    }
+}

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

@@ -0,0 +1,36 @@
+using System.Collections.Generic;
+
+namespace Umbraco.Core.Migrations.Upgrade.V_8_0_0.DataTypes
+{
+    /// <summary>
+    /// Defines a service migrating preValues.
+    /// </summary>
+    public interface IPreValueMigrator
+    {
+        /// <summary>
+        /// Determines whether this migrator can migrate a data type.
+        /// </summary>
+        /// <param name="editorAlias">The data type editor alias.</param>
+        bool CanMigrate(string editorAlias);
+
+        /// <summary>
+        /// Gets the v8 codebase data type editor alias.
+        /// </summary>
+        /// <param name="editorAlias">The original v7 codebase editor alias.</param>
+        /// <remarks>
+        /// <para>This is used to validate that the migrated configuration can be parsed
+        /// by the new property editor. Return <c>null</c> to bypass this validation,
+        /// when for instance we know it will fail, and another, later migration will
+        /// deal with it.</para>
+        /// </remarks>
+        string GetNewAlias(string editorAlias);
+
+        /// <summary>
+        /// Gets the configuration object corresponding to preValue.
+        /// </summary>
+        /// <param name="dataTypeId">The data type identifier.</param>
+        /// <param name="editorAlias">The data type editor alias.</param>
+        /// <param name="preValues">PreValues.</param>
+        object GetConfiguration(int dataTypeId, string editorAlias, Dictionary<string, PreValueDto> preValues);
+    }
+}

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

@@ -0,0 +1,25 @@
+using System.Collections.Generic;
+using System.Linq;
+using Newtonsoft.Json;
+
+namespace Umbraco.Core.Migrations.Upgrade.V_8_0_0.DataTypes
+{
+    class ListViewPreValueMigrator : DefaultPreValueMigrator
+    {
+        public override bool CanMigrate(string editorAlias)
+            => editorAlias == "Umbraco.ListView";
+
+        protected override IEnumerable<PreValueDto> GetPreValues(IEnumerable<PreValueDto> preValues)
+        {
+            return preValues.Where(preValue => preValue.Alias != "displayAtTabNumber");
+        }
+
+        protected override object GetPreValueValue(PreValueDto preValue)
+        {
+            if (preValue.Alias == "pageSize")
+                return int.TryParse(preValue.Value, out var i) ? (int?)i : null;
+
+            return preValue.Value.DetectIsJson() ? JsonConvert.DeserializeObject(preValue.Value) : preValue.Value;
+        }
+    }
+}

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

@@ -0,0 +1,37 @@
+using System.Linq;
+
+namespace Umbraco.Core.Migrations.Upgrade.V_8_0_0.DataTypes
+{
+    class MediaPickerPreValueMigrator : DefaultPreValueMigrator //PreValueMigratorBase
+    {
+        private readonly string[] _editors =
+        {
+            "Umbraco.MediaPicker2",
+            "Umbraco.MediaPicker"
+        };
+
+        public override bool CanMigrate(string editorAlias)
+            => _editors.Contains(editorAlias);
+
+        public override string GetNewAlias(string editorAlias)
+            => "Umbraco.MediaPicker";
+
+        // you wish - but MediaPickerConfiguration lives in Umbraco.Web
+        /*
+        public override object GetConfiguration(int dataTypeId, string editorAlias, Dictionary<string, PreValueDto> preValues)
+        {
+            return new MediaPickerConfiguration { ... };
+        }
+        */
+
+        protected override object GetPreValueValue(PreValueDto preValue)
+        {
+            if (preValue.Alias == "multiPicker" ||
+                preValue.Alias == "onlyImages" ||
+                preValue.Alias == "disableFolderSelect")
+                return preValue.Value == "1";
+
+            return base.GetPreValueValue(preValue);
+        }
+    }
+}

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

@@ -0,0 +1,33 @@
+using System.Collections.Generic;
+using Newtonsoft.Json;
+
+namespace Umbraco.Core.Migrations.Upgrade.V_8_0_0.DataTypes
+{
+    class NestedContentPreValueMigrator : DefaultPreValueMigrator //PreValueMigratorBase
+    {
+        public override bool CanMigrate(string editorAlias)
+            => editorAlias == "Umbraco.NestedContent";
+
+        // you wish - but NestedContentConfiguration lives in Umbraco.Web
+        /*
+        public override object GetConfiguration(int dataTypeId, string editorAlias, Dictionary<string, PreValueDto> preValues)
+        {
+            return new NestedContentConfiguration { ... };
+        }
+        */
+
+        protected override object GetPreValueValue(PreValueDto preValue)
+        {
+            if (preValue.Alias == "confirmDeletes" ||
+                preValue.Alias == "showIcons" ||
+                preValue.Alias == "hideLabel")
+                return preValue.Value == "1";
+
+            if (preValue.Alias == "minItems" ||
+                preValue.Alias == "maxItems")
+                return int.TryParse(preValue.Value, out var i) ? (int?)i : null;
+
+            return preValue.Value.DetectIsJson() ? JsonConvert.DeserializeObject(preValue.Value) : preValue.Value;
+        }
+    }
+}

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

@@ -0,0 +1,24 @@
+using NPoco;
+
+namespace Umbraco.Core.Migrations.Upgrade.V_8_0_0.DataTypes
+{
+    [TableName("cmsDataTypePreValues")]
+    [ExplicitColumns]
+    public class PreValueDto
+    {
+        [Column("id")]
+        public int Id { get; set; }
+
+        [Column("datatypeNodeId")]
+        public int NodeId { get; set; }
+
+        [Column("alias")]
+        public string Alias { get; set; }
+
+        [Column("sortorder")]
+        public int SortOrder { get; set; }
+
+        [Column("value")]
+        public string Value { get; set; }
+    }
+}

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

@@ -0,0 +1,20 @@
+using System.Collections.Generic;
+
+namespace Umbraco.Core.Migrations.Upgrade.V_8_0_0.DataTypes
+{
+    public abstract class PreValueMigratorBase : IPreValueMigrator
+    {
+        public abstract bool CanMigrate(string editorAlias);
+
+        public virtual string GetNewAlias(string editorAlias)
+            => editorAlias;
+
+        public abstract object GetConfiguration(int dataTypeId, string editorAlias, Dictionary<string, PreValueDto> preValues);
+
+        protected bool GetBoolValue(Dictionary<string, PreValueDto> preValues, string alias, bool defaultValue = false)
+            => preValues.TryGetValue(alias, out var preValue) ? preValue.Value == "1" : defaultValue;
+
+        protected decimal GetDecimalValue(Dictionary<string, PreValueDto> preValues, string alias, decimal defaultValue = 0)
+            => preValues.TryGetValue(alias, out var preValue) && decimal.TryParse(preValue.Value, out var value) ? value : defaultValue;
+    }
+}

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

@@ -0,0 +1,26 @@
+using System.Collections.Generic;
+using System.Linq;
+using Umbraco.Core.Composing;
+using Umbraco.Core.Logging;
+
+namespace Umbraco.Core.Migrations.Upgrade.V_8_0_0.DataTypes
+{
+    public class PreValueMigratorCollection : BuilderCollectionBase<IPreValueMigrator>
+    {
+        private readonly ILogger _logger;
+
+        public PreValueMigratorCollection(IEnumerable<IPreValueMigrator> items, ILogger logger)
+            : base(items)
+        {
+            _logger = logger;
+            _logger.Debug(GetType(), "Migrators: " + string.Join(", ", items.Select(x => x.GetType().Name)));
+        }
+
+        public IPreValueMigrator GetMigrator(string editorAlias)
+        {
+            var migrator = this.FirstOrDefault(x => x.CanMigrate(editorAlias));
+            _logger.Debug(GetType(), "Getting migrator for \"{EditorAlias}\" = {MigratorType}", editorAlias, migrator == null ? "<null>" : migrator.GetType().Name);
+            return migrator;
+        }
+    }
+}

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

@@ -0,0 +1,9 @@
+using Umbraco.Core.Composing;
+
+namespace Umbraco.Core.Migrations.Upgrade.V_8_0_0.DataTypes
+{
+    public class PreValueMigratorCollectionBuilder : OrderedCollectionBuilderBase<PreValueMigratorCollectionBuilder, PreValueMigratorCollection, IPreValueMigrator>
+    {
+        protected override PreValueMigratorCollectionBuilder This => this;
+    }
+}

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

@@ -0,0 +1,25 @@
+using Umbraco.Core.Composing;
+
+namespace Umbraco.Core.Migrations.Upgrade.V_8_0_0.DataTypes
+{
+    [RuntimeLevel(MinLevel = RuntimeLevel.Upgrade, MaxLevel = RuntimeLevel.Upgrade)] // only on upgrades
+    public class PreValueMigratorComposer : ICoreComposer
+    {
+        public void Compose(Composition composition)
+        {
+            // do NOT add DefaultPreValueMigrator to this list!
+            // it will be automatically used if nothing matches
+
+            composition.WithCollectionBuilder<PreValueMigratorCollectionBuilder>()
+                .Append<RenamingPreValueMigrator>()
+                .Append<RichTextPreValueMigrator>()
+                .Append<UmbracoSliderPreValueMigrator>()
+                .Append<MediaPickerPreValueMigrator>()
+                .Append<ContentPickerPreValueMigrator>()
+                .Append<NestedContentPreValueMigrator>()
+                .Append<DecimalPreValueMigrator>()
+                .Append<ListViewPreValueMigrator>()
+                .Append<ValueListPreValueMigrator>();
+        }
+    }
+}

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

@@ -0,0 +1,27 @@
+using System;
+using System.Linq;
+
+namespace Umbraco.Core.Migrations.Upgrade.V_8_0_0.DataTypes
+{
+    class RenamingPreValueMigrator : DefaultPreValueMigrator
+    {
+        private readonly string[] _editors =
+        {
+            "Umbraco.NoEdit"
+        };
+
+        public override bool CanMigrate(string editorAlias)
+            => _editors.Contains(editorAlias);
+
+        public override string GetNewAlias(string editorAlias)
+        {
+            switch (editorAlias)
+            {
+                case "Umbraco.NoEdit":
+                    return Constants.PropertyEditors.Aliases.Label;
+                default:
+                    throw new Exception("panic");
+            }
+        }
+    }
+}

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

@@ -0,0 +1,21 @@
+using Newtonsoft.Json;
+
+namespace Umbraco.Core.Migrations.Upgrade.V_8_0_0.DataTypes
+{
+    class RichTextPreValueMigrator : DefaultPreValueMigrator
+    {
+        public override bool CanMigrate(string editorAlias)
+            => editorAlias == "Umbraco.TinyMCEv3";
+
+        public override string GetNewAlias(string editorAlias)
+            => Constants.PropertyEditors.Aliases.TinyMce;
+
+        protected override object GetPreValueValue(PreValueDto preValue)
+        {
+            if (preValue.Alias == "hideLabel")
+                return preValue.Value == "1";
+
+            return preValue.Value.DetectIsJson() ? JsonConvert.DeserializeObject(preValue.Value) : preValue.Value;
+        }
+    }
+}

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

@@ -0,0 +1,24 @@
+using System.Collections.Generic;
+using Umbraco.Core.PropertyEditors;
+
+namespace Umbraco.Core.Migrations.Upgrade.V_8_0_0.DataTypes
+{
+    class UmbracoSliderPreValueMigrator : PreValueMigratorBase
+    {
+        public override bool CanMigrate(string editorAlias)
+            => editorAlias == "Umbraco.Slider";
+
+        public override object GetConfiguration(int dataTypeId, string editorAlias, Dictionary<string, PreValueDto> preValues)
+        {
+            return new SliderConfiguration
+            {
+                EnableRange = GetBoolValue(preValues, "enableRange"),
+                InitialValue = GetDecimalValue(preValues, "initVal1"),
+                InitialValue2 = GetDecimalValue(preValues, "initVal2"),
+                MaximumValue = GetDecimalValue(preValues, "maxVal"),
+                MinimumValue = GetDecimalValue(preValues, "minVal"),
+                StepIncrements = GetDecimalValue(preValues, "step")
+            };
+        }
+    }
+}

src/Umbraco.Core/Migrations/Upgrade/V_8_0_0/DataTypes/ValueListPreValueMigrator.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 ValueListPreValueMigrator : IPreValueMigrator
+    {
+        private readonly string[] _editors =
+        {
+            "Umbraco.RadioButtonList",
+            "Umbraco.DropDown",
+            "Umbraco.DropdownlistPublishingKeys",
+            "Umbraco.DropDownMultiple",
+            "Umbraco.DropdownlistMultiplePublishKeys"
+        };
+
+        public bool CanMigrate(string editorAlias)
+            => _editors.Contains(editorAlias);
+
+        public virtual string GetNewAlias(string editorAlias)
+            => null;
+
+        public object GetConfiguration(int dataTypeId, string editorAlias, Dictionary<string, PreValueDto> preValues)
+        {
+            var config = new ValueListConfiguration();
+            foreach (var preValue in preValues.Values)
+                config.Items.Add(new ValueListConfiguration.ValueListItem { Id = preValue.Id, Value = preValue.Value });
+            return config;
+        }
+    }
+}

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

@@ -1,39 +1,35 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using Umbraco.Core.Cache;
 using Umbraco.Core.Persistence;
 using Umbraco.Core.Persistence.Dtos;
 using Umbraco.Core.PropertyEditors;
 using Umbraco.Core.Logging;
+using Umbraco.Core.Migrations.PostMigrations;
 using Umbraco.Core.Models;
-using Umbraco.Core.Sync;
 
 namespace Umbraco.Core.Migrations.Upgrade.V_8_0_0
 {
-    public class DropDownPropertyEditorsMigration : MigrationBase
+    public class DropDownPropertyEditorsMigration : PropertyEditorsMigrationBase
     {
-        private readonly CacheRefresherCollection _cacheRefreshers;
-        private readonly IServerMessenger _serverMessenger;
-
-        public DropDownPropertyEditorsMigration(IMigrationContext context, CacheRefresherCollection cacheRefreshers, IServerMessenger serverMessenger)
+        public DropDownPropertyEditorsMigration(IMigrationContext context)
             : base(context)
-        {
-            _cacheRefreshers = cacheRefreshers;
-            _serverMessenger = serverMessenger;
-        }
-
-        // dummy editor for deserialization
-        private class ValueListConfigurationEditor : ConfigurationEditor<ValueListConfiguration>
         { }
 
         public override void Migrate()
         {
-            //need to convert the old drop down data types to use the new one
-            var dataTypes = Database.Fetch<DataTypeDto>(Sql()
-                .Select<DataTypeDto>()
-                .From<DataTypeDto>()
-                .Where<DataTypeDto>(x => x.EditorAlias.Contains(".DropDown")));
+            var refreshCache = Migrate(GetDataTypes(".DropDown", false));
+
+            // if some data types have been updated directly in the database (editing DataTypeDto and/or PropertyDataDto),
+            // bypassing the services, then we need to rebuild the cache entirely, including the umbracoContentNu table
+            if (refreshCache)
+                Context.AddPostMigration<RebuildPublishedSnapshot>();
+        }
+
+        private bool Migrate(IEnumerable<DataTypeDto> dataTypes)
+        {
+            var refreshCache = false;
+            ConfigurationEditor configurationEditor = null;
 
             foreach (var dataType in dataTypes)
             {
@@ -42,14 +38,16 @@ namespace Umbraco.Core.Migrations.Upgrade.V_8_0_0
                 if (!dataType.Configuration.IsNullOrWhiteSpace())
                 {
                     // parse configuration, and update everything accordingly
+                    if (configurationEditor == null)
+                        configurationEditor = new ValueListConfigurationEditor();
                     try
                     {
-                        config = (ValueListConfiguration) new ValueListConfigurationEditor().FromDatabase(dataType.Configuration);
+                        config = (ValueListConfiguration) configurationEditor.FromDatabase(dataType.Configuration);
                     }
                     catch (Exception ex)
                     {
                         Logger.Error<DropDownPropertyEditorsMigration>(
-                            ex, "Invalid drop down configuration detected: \"{Configuration}\", cannot convert editor, values will be cleared",
+                            ex, "Invalid configuration: \"{Configuration}\", cannot convert editor.",
                             dataType.Configuration);
 
                         // reset
@@ -65,7 +63,7 @@ namespace Umbraco.Core.Migrations.Upgrade.V_8_0_0
                         .Where<PropertyTypeDto>(x => x.DataTypeId == dataType.NodeId));
 
                     // update dtos
-                    var updatedDtos = propertyDataDtos.Where(x => UpdatePropertyDataDto(x, config));
+                    var updatedDtos = propertyDataDtos.Where(x => UpdatePropertyDataDto(x, config, true));
 
                     // persist changes
                     foreach (var propertyDataDto in updatedDtos)
@@ -77,7 +75,6 @@ namespace Umbraco.Core.Migrations.Upgrade.V_8_0_0
                     config = new ValueListConfiguration();
                 }
 
-                var requiresCacheRebuild = false;
                 switch (dataType.EditorAlias)
                 {
                     case string ea when ea.InvariantEquals("Umbraco.DropDown"):
@@ -85,29 +82,25 @@ namespace Umbraco.Core.Migrations.Upgrade.V_8_0_0
                         break;
                     case string ea when ea.InvariantEquals("Umbraco.DropdownlistPublishingKeys"):
                         UpdateDataType(dataType, config, false);
-                        requiresCacheRebuild = true;
                         break;
                     case string ea when ea.InvariantEquals("Umbraco.DropDownMultiple"):
                         UpdateDataType(dataType, config, true);
                         break;
                     case string ea when ea.InvariantEquals("Umbraco.DropdownlistMultiplePublishKeys"):
                         UpdateDataType(dataType, config, true);
-                        requiresCacheRebuild = true;
                         break;
                 }
 
-                if (requiresCacheRebuild)
-                {
-                    var dataTypeCacheRefresher = _cacheRefreshers[Guid.Parse("35B16C25-A17E-45D7-BC8F-EDAB1DCC28D2")];
-                    _serverMessenger.PerformRefreshAll(dataTypeCacheRefresher);
-                }
+                refreshCache = true;
             }
+
+            return refreshCache;
         }
 
         private void UpdateDataType(DataTypeDto dataType, ValueListConfiguration config, bool isMultiple)
         {
-            dataType.EditorAlias = Constants.PropertyEditors.Aliases.DropDownListFlexible;
             dataType.DbType = ValueStorageType.Nvarchar.ToString();
+            dataType.EditorAlias = Constants.PropertyEditors.Aliases.DropDownListFlexible;
 
             var flexConfig = new DropDownFlexibleConfiguration
             {
@@ -118,68 +111,5 @@ namespace Umbraco.Core.Migrations.Upgrade.V_8_0_0
 
             Database.Update(dataType);
         }
-
-        private bool UpdatePropertyDataDto(PropertyDataDto propData, ValueListConfiguration config)
-        {
-            //Get the INT ids stored for this property/drop down
-            int[] ids = null;
-            if (!propData.VarcharValue.IsNullOrWhiteSpace())
-            {
-                ids = ConvertStringValues(propData.VarcharValue);
-            }
-            else if (!propData.TextValue.IsNullOrWhiteSpace())
-            {
-                ids = ConvertStringValues(propData.TextValue);
-            }
-            else if (propData.IntegerValue.HasValue)
-            {
-                ids = new[] { propData.IntegerValue.Value };
-            }
-
-            //if there are INT ids, convert them to values based on the configured pre-values
-            if (ids != null && ids.Length > 0)
-            {
-                //map the ids to values
-                var vals = new List<string>();
-                var canConvert = true;
-                foreach (var id in ids)
-                {
-                    var val = config.Items.FirstOrDefault(x => x.Id == id);
-                    if (val != null)
-                        vals.Add(val.Value);
-                    else
-                    {
-                        Logger.Warn<DropDownPropertyEditorsMigration>(
-                            "Could not find associated data type configuration for stored Id {DataTypeId}", id);
-                        canConvert = false;
-                    }
-                }
-                if (canConvert)
-                {
-                    propData.VarcharValue = string.Join(",", vals);
-                    propData.TextValue = null;
-                    propData.IntegerValue = null;
-                    return true;
-                }
-            }
-
-            return false;
-        }
-
-        private int[] ConvertStringValues(string val)
-        {
-            var splitVals = val.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
-
-            var intVals = splitVals
-                            .Select(x => int.TryParse(x, out var i) ? i : int.MinValue)
-                            .Where(x => x != int.MinValue)
-                            .ToArray();
-
-            //only return if the number of values are the same (i.e. All INTs)
-            if (splitVals.Length == intVals.Length)
-                return intVals;
-
-            return null;
-        }
     }
 }

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

@@ -8,7 +8,8 @@
 
         public override void Migrate()
         {
-            Delete.Table("umbracoMigration").Do();
+            if (TableExists("umbracoMigration"))
+                Delete.Table("umbracoMigration").Do();
         }
     }
 }

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

@@ -3,8 +3,7 @@
     public class DropPreValueTable : MigrationBase
     {
         public DropPreValueTable(IMigrationContext context) : base(context)
-        {
-        }
+        { }
 
         public override void Migrate()
         {

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

@@ -0,0 +1,21 @@
+namespace Umbraco.Core.Migrations.Upgrade.V_8_0_0
+{
+    public class FixLanguageIsoCodeLength : MigrationBase
+    {
+        public FixLanguageIsoCodeLength(IMigrationContext context)
+            : base(context)
+        { }
+
+        public override void Migrate()
+        {
+            // there is some confusion here when upgrading from v7
+            // it should be 14 already but that's not always the case
+
+            Alter.Table("umbracoLanguage")
+                .AlterColumn("languageISOCode")
+                .AsString(14)
+                .Nullable()
+                .Do();
+        }
+    }
+}

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

@@ -1,23 +0,0 @@
-using System.Linq;
-
-namespace Umbraco.Core.Migrations.Upgrade.V_8_0_0
-{
-    public class FixLockTablePrimaryKey : MigrationBase
-    {
-        public FixLockTablePrimaryKey(IMigrationContext context)
-            : base(context)
-        { }
-
-        public override void Migrate()
-        {
-            // at some point, the KeyValueService dropped the PK and failed to re-create it,
-            // so the PK is gone - make sure we have one, and create if needed
-
-            var constraints = SqlSyntax.GetConstraintsPerTable(Database);
-            var exists = constraints.Any(x => x.Item2 == "PK_umbracoLock");
-
-            if (!exists)
-                Create.PrimaryKey("PK_umbracoLock").OnTable(Constants.DatabaseSchema.Tables.Lock).Column("id").Do();
-        }
-    }
-}

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

@@ -11,19 +11,6 @@ namespace Umbraco.Core.Migrations.Upgrade.V_8_0_0
         public override void Migrate()
         {
             AddColumn<RedirectUrlDto>("culture");
-
-            Delete.Index("IX_umbracoRedirectUrl").OnTable(Constants.DatabaseSchema.Tables.RedirectUrl).Do();
-            Create.Index("IX_umbracoRedirectUrl").OnTable(Constants.DatabaseSchema.Tables.RedirectUrl)
-                .OnColumn("urlHash")
-                .Ascending()
-                .OnColumn("contentKey")
-                .Ascending()
-                .OnColumn("culture")
-                .Ascending()
-                .OnColumn("createDateUtc")
-                .Ascending()
-                .WithOptions().Unique()
-                .Do();
         }
     }
 }

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

@@ -11,17 +11,6 @@ namespace Umbraco.Core.Migrations.Upgrade.V_8_0_0
         public override void Migrate()
         {
             AddColumn<TagDto>("languageId");
-
-            Delete.Index($"IX_{Constants.DatabaseSchema.Tables.Tag}").OnTable(Constants.DatabaseSchema.Tables.Tag).Do();
-            Create.Index($"IX_{Constants.DatabaseSchema.Tables.Tag}").OnTable(Constants.DatabaseSchema.Tables.Tag)
-                .OnColumn("group")
-                .Ascending()
-                .OnColumn("tag")
-                .Ascending()
-                .OnColumn("languageId")
-                .Ascending()
-                .WithOptions().Unique()
-                .Do();
         }
     }
 }