add client files for script editor

build/NuSpecs/UmbracoCms.Core.nuspec

@@ -32,13 +32,13 @@
 	  <!-- AutoMapper can not be updated due to: https://github.com/AutoMapper/AutoMapper/issues/373#issuecomment-127644405 -->
       <dependency id="AutoMapper" version="[3.3.1, 4.0.0)" />
       <dependency id="Newtonsoft.Json" version="[6.0.8, 10.0.0)" />
-      <dependency id="Examine" version="[0.1.80, 1.0.0)" />
-      <dependency id="ImageProcessor" version="[2.5.1, 3.0.0)" />
-      <dependency id="ImageProcessor.Web" version="[4.8.0, 5.0.0)" />
+      <dependency id="Examine" version="[0.1.70, 1.0.0)" />
+      <dependency id="ImageProcessor" version="[2.4.5, 3.0.0)" />
+      <dependency id="ImageProcessor.Web" version="[4.6.6, 5.0.0)" />
       <dependency id="semver" version="[1.1.2, 2.0.0)" />
       <dependency id="UrlRewritingNet" version="[2.0.7, 3.0.0)" />	  
 	  <!-- Markdown can not be updated due to: https://github.com/hey-red/markdownsharp/issues/71#issuecomment-233585487 -->
-      <dependency id="Markdown" version="[1.14.4, 2.0.0)" />	  
+      <dependency id="Markdown" version="[1.14.4, 2.0.0)" />
       <dependency id="System.Threading.Tasks.Dataflow" version="[4.6.0, 5.0.0)" />
     </dependencies>
   </metadata>
@@ -104,4 +104,4 @@
     <file src="..\_BuildOutput\bin\UmbracoExamine.pdb" target="lib" />
     <file src="..\..\src\UmbracoExamine\**\*.cs" exclude="..\..\src\**\TemporaryGeneratedFile*.cs" target="src\UmbracoExamine" />
   </files>
-</package>
+</package>

build/NuSpecs/UmbracoCms.nuspec

@@ -44,7 +44,6 @@
     <file src="tools\trees.config.install.xdt" target="Content\config\trees.config.install.xdt" />
     <file src="tools\umbracoSettings.config.install.xdt" target="Content\config\umbracoSettings.config.install.xdt" />
     <file src="tools\Views.Web.config.install.xdt" target="Views\Web.config.install.xdt" />
-    <file src="tools\processing.config.install.xdt" target="Content\Config\imageprocessor\processing.config.install.xdt" />
     <file src="build\**" target="build" />
   </files>
 </package>

build/NuSpecs/tools/install.core.ps1

@@ -71,7 +71,6 @@ if ($project) {
 		if(Test-Path $umbracoBinFolder\ImageProcessor.dll) { Remove-Item $umbracoBinFolder\ImageProcessor.dll -Force -Confirm:$false }
 		if(Test-Path $umbracoBinFolder\ImageProcessor.Web.dll) { Remove-Item $umbracoBinFolder\ImageProcessor.Web.dll -Force -Confirm:$false }
 		if(Test-Path $umbracoBinFolder\Lucene.Net.dll) { Remove-Item $umbracoBinFolder\Lucene.Net.dll -Force -Confirm:$false }
-		if(Test-Path $umbracoBinFolder\Microsoft.IO.RecyclableMemoryStream.dll) { Remove-Item $umbracoBinFolder\Microsoft.IO.RecyclableMemoryStream.dll -Force -Confirm:$false }
 		if(Test-Path $umbracoBinFolder\Microsoft.AspNet.Identity.Core.dll) { Remove-Item $umbracoBinFolder\Microsoft.AspNet.Identity.Core.dll -Force -Confirm:$false }
 		if(Test-Path $umbracoBinFolder\Microsoft.AspNet.Identity.Owin.dll) { Remove-Item $umbracoBinFolder\Microsoft.AspNet.Identity.Owin.dll -Force -Confirm:$false }
 		if(Test-Path $umbracoBinFolder\Microsoft.CodeAnalysis.CSharp.dll) { Remove-Item $umbracoBinFolder\Microsoft.CodeAnalysis.CSharp.dll -Force -Confirm:$false }

build/NuSpecs/tools/processing.config.install.xdt

@@ -1 +0,0 @@
-<processing xmlns:xdt="http://schemas.microsoft.com/XML-Document-Transform" xdt:Transform="SetAttributes(preserveExifMetaData)" preserveExifMetaData="true" />

build/UmbracoVersion.txt

@@ -1,3 +1,3 @@
-# Usage: on line 2 put the release version, on line 3 put the version comment (example: beta)
+# Usage: on line 2 put the release version, on line 3 put the version comment (example: beta) 
 7.6.0
-alpha054
+alpha038

src/SQLCE4Umbraco/SqlCE4Umbraco.csproj

@@ -49,9 +49,13 @@
     <Reference Include="System.Core" />
     <Reference Include="System.Data.SqlServerCe, Version=4.0.0.1, Culture=neutral, PublicKeyToken=89845dcd8080cc91, processorArchitecture=MSIL">
       <HintPath>..\packages\SqlServerCE.4.0.0.1\lib\System.Data.SqlServerCe.dll</HintPath>
+      <SpecificVersion>False</SpecificVersion>
+      <Private>False</Private>
     </Reference>
     <Reference Include="System.Data.SqlServerCe.Entity, Version=4.0.0.1, Culture=neutral, PublicKeyToken=89845dcd8080cc91, processorArchitecture=MSIL">
       <HintPath>..\packages\SqlServerCE.4.0.0.1\lib\System.Data.SqlServerCe.Entity.dll</HintPath>
+      <SpecificVersion>False</SpecificVersion>
+      <Private>False</Private>
     </Reference>
     <Reference Include="System.Xml.Linq" />
     <Reference Include="System.Data.DataSetExtensions" />

src/SolutionInfo.cs

@@ -2,7 +2,7 @@
 using System.Resources;
 
 [assembly: AssemblyCompany("Umbraco")]
-[assembly: AssemblyCopyright("Copyright © Umbraco 2017")]
+[assembly: AssemblyCopyright("Copyright © Umbraco 2016")]
 [assembly: AssemblyTrademark("")]
 [assembly: AssemblyCulture("")]
 
@@ -12,4 +12,4 @@ using System.Resources;
 [assembly: AssemblyVersion("1.0.*")]
 
 [assembly: AssemblyFileVersion("7.6.0")]
-[assembly: AssemblyInformationalVersion("7.6.0-alpha054")]
+[assembly: AssemblyInformationalVersion("7.6.0-alpha038")]

src/Umbraco.Core/ApplicationContext.cs

@@ -296,7 +296,7 @@ namespace Umbraco.Core
                         // if we have a db context available, if we don't then we are not installed anyways
                         if (DatabaseContext.IsDatabaseConfigured && DatabaseContext.CanConnect)
                         {
-                            var found = Services.MigrationEntryService.FindEntry(Constants.System.UmbracoMigrationName, UmbracoVersion.GetSemanticVersion());
+                            var found = Services.MigrationEntryService.FindEntry(GlobalSettings.UmbracoMigrationName, UmbracoVersion.GetSemanticVersion());
                             if (found == null)
                             {
                                 //we haven't executed this migration in this environment, so even though the config versions match, 

src/Umbraco.Core/Cache/CacheKeys.cs

@@ -64,8 +64,7 @@ namespace Umbraco.Core.Cache
         [UmbracoWillObsolete("This cache key is only used for legacy business logic caching, remove in v8")]
         public const string ContentTypePropertiesCacheKey = "ContentType_PropertyTypes_Content:";
         
-        [Obsolete("No longer used and will be removed in v8")]
-        [EditorBrowsable(EditorBrowsableState.Never)]
+        [UmbracoWillObsolete("This cache key is only used for legacy business logic caching, remove in v8")]
         public const string PropertyTypeCacheKey = "UmbracoPropertyTypeCache";
 
         [Obsolete("This is no longer used and will be removed from the codebase in the future")]

src/Umbraco.Core/Configuration/GlobalSettings.cs

@@ -212,7 +212,7 @@ namespace Umbraco.Core.Configuration
         {
             get
             {
-                var settings = ConfigurationManager.ConnectionStrings[Constants.System.UmbracoConnectionName];
+                var settings = ConfigurationManager.ConnectionStrings[UmbracoConnectionName];
                 var connectionString = string.Empty;
 
                 if (settings != null)
@@ -241,7 +241,10 @@ namespace Umbraco.Core.Configuration
                 }
             }
         }
-        
+
+        //TODO: Move these to constants!
+        public const string UmbracoConnectionName = "umbracoDbDSN";
+        public const string UmbracoMigrationName = "Umbraco";
 
         /// <summary>
         /// Gets or sets the configuration status. This will return the version number of the currently installed umbraco instance.

src/Umbraco.Core/Configuration/UmbracoSettings/ContentElement.cs

@@ -4,7 +4,8 @@ using System.Configuration;
 
 namespace Umbraco.Core.Configuration.UmbracoSettings
 {
-    internal class ContentElement : UmbracoConfigurationElement, IContentSection
+
+    internal class ContentElement : ConfigurationElement, IContentSection
     {
         [ConfigurationProperty("imaging")]
         internal ContentImagingElement Imaging
@@ -21,13 +22,25 @@ namespace Umbraco.Core.Configuration.UmbracoSettings
         [ConfigurationProperty("ResolveUrlsFromTextString")]
         internal InnerTextConfigurationElement<bool> ResolveUrlsFromTextString
         {
-            get { return GetOptionalTextElement<bool>("ResolveUrlsFromTextString", false); }
+            get
+            {
+                return new OptionalInnerTextConfigurationElement<bool>(
+                       (InnerTextConfigurationElement<bool>)this["ResolveUrlsFromTextString"],
+                        //set the default
+                       false);
+            }
         }
 
         [ConfigurationProperty("UploadAllowDirectories")]
         internal InnerTextConfigurationElement<bool> UploadAllowDirectories
         {
-            get { return GetOptionalTextElement("UploadAllowDirectories", true); }
+            get
+            {
+                return new OptionalInnerTextConfigurationElement<bool>(
+                       (InnerTextConfigurationElement<bool>)this["UploadAllowDirectories"],
+                    //set the default
+                       true);
+            }
         }
 
         public IEnumerable<IContentErrorPage> Error404Collection
@@ -50,61 +63,121 @@ namespace Umbraco.Core.Configuration.UmbracoSettings
         [ConfigurationProperty("ensureUniqueNaming")]
         internal InnerTextConfigurationElement<bool> EnsureUniqueNaming
         {
-            get { return GetOptionalTextElement("ensureUniqueNaming", true); }
+            get
+            {
+                return new OptionalInnerTextConfigurationElement<bool>(
+                      (InnerTextConfigurationElement<bool>)this["ensureUniqueNaming"],
+                    //set the default
+                      true);
+            }
         }
 
         [ConfigurationProperty("TidyEditorContent")]
         internal InnerTextConfigurationElement<bool> TidyEditorContent
         {
-            get { return GetOptionalTextElement("TidyEditorContent", false); }
+            get
+            {
+                return new OptionalInnerTextConfigurationElement<bool>(
+                      (InnerTextConfigurationElement<bool>)this["TidyEditorContent"],
+                    //set the default
+                      false);
+            }
         }
 
         [ConfigurationProperty("TidyCharEncoding")]
         internal InnerTextConfigurationElement<string> TidyCharEncoding
         {
-            get { return GetOptionalTextElement("TidyCharEncoding", "UTF8"); }
+            get
+            {
+                return new OptionalInnerTextConfigurationElement<string>(
+                          (InnerTextConfigurationElement<string>)this["TidyCharEncoding"],
+                            //set the default
+                          "UTF8");
+            }
         }
 
         [ConfigurationProperty("XmlCacheEnabled")]
         internal InnerTextConfigurationElement<bool> XmlCacheEnabled
         {
-            get { return GetOptionalTextElement("XmlCacheEnabled", true); }
+            get
+            {
+                return new OptionalInnerTextConfigurationElement<bool>(
+                          (InnerTextConfigurationElement<bool>)this["XmlCacheEnabled"],
+                    //set the default
+                          true);
+            }
         }
 
         [ConfigurationProperty("ContinouslyUpdateXmlDiskCache")]
         internal InnerTextConfigurationElement<bool> ContinouslyUpdateXmlDiskCache
         {
-            get { return GetOptionalTextElement("ContinouslyUpdateXmlDiskCache", true); }
+            get
+            {
+                return new OptionalInnerTextConfigurationElement<bool>(
+                          (InnerTextConfigurationElement<bool>)this["ContinouslyUpdateXmlDiskCache"],
+                    //set the default
+                          true);                
+            }
         }
 
         [ConfigurationProperty("XmlContentCheckForDiskChanges")]
         internal InnerTextConfigurationElement<bool> XmlContentCheckForDiskChanges
         {
-            get { return GetOptionalTextElement("XmlContentCheckForDiskChanges", false); }
+            get
+            {
+                return new OptionalInnerTextConfigurationElement<bool>(
+                          (InnerTextConfigurationElement<bool>)this["XmlContentCheckForDiskChanges"],
+                    //set the default
+                          false); 
+            }
         }
 
         [ConfigurationProperty("EnableSplashWhileLoading")]
         internal InnerTextConfigurationElement<bool> EnableSplashWhileLoading
         {
-            get { return GetOptionalTextElement("EnableSplashWhileLoading", false); }
+            get
+            {
+                return new OptionalInnerTextConfigurationElement<bool>(
+                          (InnerTextConfigurationElement<bool>)this["EnableSplashWhileLoading"],
+                    //set the default
+                          false); 
+            }
         }
 
         [ConfigurationProperty("PropertyContextHelpOption")]
         internal InnerTextConfigurationElement<string> PropertyContextHelpOption
         {
-            get { return GetOptionalTextElement("PropertyContextHelpOption", "text"); }
+            get
+            {
+                return new OptionalInnerTextConfigurationElement<string>(
+                          (InnerTextConfigurationElement<string>)this["PropertyContextHelpOption"],
+                    //set the default
+                          "text"); 
+            }
         }
 
         [ConfigurationProperty("UseLegacyXmlSchema")]
         internal InnerTextConfigurationElement<bool> UseLegacyXmlSchema
         {
-            get { return GetOptionalTextElement("UseLegacyXmlSchema", false); }
+            get
+            {
+                return new OptionalInnerTextConfigurationElement<bool>(
+                          (InnerTextConfigurationElement<bool>)this["UseLegacyXmlSchema"],
+                    //set the default
+                          false); 
+            }
         }
         
         [ConfigurationProperty("ForceSafeAliases")]
         internal InnerTextConfigurationElement<bool> ForceSafeAliases
         {
-            get { return GetOptionalTextElement("ForceSafeAliases", true); }
+            get
+            {
+                return new OptionalInnerTextConfigurationElement<bool>(
+                          (InnerTextConfigurationElement<bool>)this["ForceSafeAliases"],
+                    //set the default
+                          true); 
+            }
         }
 
         [ConfigurationProperty("PreviewBadge")]
@@ -112,63 +185,123 @@ namespace Umbraco.Core.Configuration.UmbracoSettings
         {
             get
             {
-                return GetOptionalTextElement("PreviewBadge", @"<a id=""umbracoPreviewBadge"" style=""position: absolute; top: 0; right: 0; border: 0; width: 149px; height: 149px; background: url('{1}/preview/previewModeBadge.png') no-repeat;"" href=""{0}/endPreview.aspx?redir={2}""><span style=""display:none;"">In Preview Mode - click to end</span></a>");                
+                return new OptionalInnerTextConfigurationElement<string>(
+                          (InnerTextConfigurationElement<string>)this["PreviewBadge"],
+                    //set the default
+                          @"<a id=""umbracoPreviewBadge"" style=""position: absolute; top: 0; right: 0; border: 0; width: 149px; height: 149px; background: url('{1}/preview/previewModeBadge.png') no-repeat;"" href=""{0}/endPreview.aspx?redir={2}""><span style=""display:none;"">In Preview Mode - click to end</span></a>"); 
             }
         }
 
         [ConfigurationProperty("UmbracoLibraryCacheDuration")]
         internal InnerTextConfigurationElement<int> UmbracoLibraryCacheDuration
         {
-            get { return GetOptionalTextElement("UmbracoLibraryCacheDuration", 1800); }
+            get
+            {
+                return new OptionalInnerTextConfigurationElement<int>(
+                          (InnerTextConfigurationElement<int>)this["UmbracoLibraryCacheDuration"],
+                    //set the default
+                          1800); 
+                
+            }
         }
 
         [ConfigurationProperty("MacroErrors")]
         internal InnerTextConfigurationElement<MacroErrorBehaviour> MacroErrors
         {
-            get { return GetOptionalTextElement("MacroErrors", MacroErrorBehaviour.Inline); }
+            get
+            {
+
+                return new OptionalInnerTextConfigurationElement<MacroErrorBehaviour>(
+                          (InnerTextConfigurationElement<MacroErrorBehaviour>)this["MacroErrors"],
+                    //set the default
+                          MacroErrorBehaviour.Inline); 
+            }
         }
 
         [Obsolete("This is here so that if this config element exists we won't get a YSOD, it is not used whatsoever and will be removed in future versions")]
         [ConfigurationProperty("DocumentTypeIconList")]
         internal InnerTextConfigurationElement<IconPickerBehaviour> DocumentTypeIconList
         {
-            get { return GetOptionalTextElement("DocumentTypeIconList", IconPickerBehaviour.HideFileDuplicates); }
+            get
+            {
+                return new OptionalInnerTextConfigurationElement<IconPickerBehaviour>(
+                          (InnerTextConfigurationElement<IconPickerBehaviour>)this["DocumentTypeIconList"],
+                    //set the default
+                          IconPickerBehaviour.HideFileDuplicates);
+            }
         }
 
         [ConfigurationProperty("disallowedUploadFiles")]
         internal CommaDelimitedConfigurationElement DisallowedUploadFiles
         {
-            get { return GetOptionalDelimitedElement("disallowedUploadFiles", new[] {"ashx", "aspx", "ascx", "config", "cshtml", "vbhtml", "asmx", "air", "axd"}); }
+            get
+            {
+                return new OptionalCommaDelimitedConfigurationElement(
+                       (CommaDelimitedConfigurationElement)this["disallowedUploadFiles"],
+                    //set the default
+                       new[] { "ashx", "aspx", "ascx", "config", "cshtml", "vbhtml", "asmx", "air", "axd" });
+
+            }
         }
 
         [ConfigurationProperty("cloneXmlContent")]
         internal InnerTextConfigurationElement<bool> CloneXmlContent
         {
-            get { return GetOptionalTextElement("cloneXmlContent", true); }
+            get
+            {
+                return new OptionalInnerTextConfigurationElement<bool>(
+                    (InnerTextConfigurationElement<bool>)this["cloneXmlContent"],
+                    //set the default
+                    true);
+            }
         }
 
         [ConfigurationProperty("GlobalPreviewStorageEnabled")]
         internal InnerTextConfigurationElement<bool> GlobalPreviewStorageEnabled
         {
-            get { return GetOptionalTextElement("GlobalPreviewStorageEnabled", false); }
+            get
+            {
+                return new OptionalInnerTextConfigurationElement<bool>(
+                    (InnerTextConfigurationElement<bool>)this["GlobalPreviewStorageEnabled"],
+                    //set the default
+                    false);
+            }
         }
 
         [ConfigurationProperty("defaultDocumentTypeProperty")]
         internal InnerTextConfigurationElement<string> DefaultDocumentTypeProperty
         {
-            get { return GetOptionalTextElement("defaultDocumentTypeProperty", "Textstring"); }
+            get
+            {
+                return new OptionalInnerTextConfigurationElement<string>(
+                    (InnerTextConfigurationElement<string>)this["defaultDocumentTypeProperty"],
+                    //set the default
+                    "Textstring");
+            }
         }
 
         [ConfigurationProperty("EnableInheritedDocumentTypes")]
         internal InnerTextConfigurationElement<bool> EnableInheritedDocumentTypes
         {
-            get { return GetOptionalTextElement("EnableInheritedDocumentTypes", true); }
+            get
+            {
+                return new OptionalInnerTextConfigurationElement<bool>(
+                    (InnerTextConfigurationElement<bool>) this["EnableInheritedDocumentTypes"],
+                    //set the default
+                    true);
+            }
         }
 
         [ConfigurationProperty("EnableInheritedMediaTypes")]
         internal InnerTextConfigurationElement<bool> EnableInheritedMediaTypes
         {
-            get { return GetOptionalTextElement("EnableInheritedMediaTypes", true); }
+            get
+            {
+                return new OptionalInnerTextConfigurationElement<bool>(
+                    (InnerTextConfigurationElement<bool>)this["EnableInheritedMediaTypes"],
+                    //set the default
+                    true);
+            }
         }
 
         string IContentSection.NotificationEmailAddress

src/Umbraco.Core/Configuration/UmbracoSettings/ContentScriptEditorElement.cs

@@ -3,24 +3,42 @@ using System.Configuration;
 
 namespace Umbraco.Core.Configuration.UmbracoSettings
 {
-    internal class ContentScriptEditorElement : UmbracoConfigurationElement
+    internal class ContentScriptEditorElement : ConfigurationElement
     {
         [ConfigurationProperty("scriptFolderPath")]
         internal InnerTextConfigurationElement<string> ScriptFolderPath
         {
-            get { return GetOptionalTextElement("scriptFolderPath", "/scripts"); }
+            get
+            {
+                return new OptionalInnerTextConfigurationElement<string>(
+                       (InnerTextConfigurationElement<string>)this["scriptFolderPath"],
+                    //set the default
+                       "/scripts");
+            }
         }
 
         [ConfigurationProperty("scriptFileTypes")]
         internal OptionalCommaDelimitedConfigurationElement ScriptFileTypes
         {
-            get { return GetOptionalDelimitedElement("scriptFileTypes", new[] {"js", "xml"}); }
+            get
+            {
+                return new OptionalCommaDelimitedConfigurationElement(
+                       (OptionalCommaDelimitedConfigurationElement)this["scriptFileTypes"],
+                    //set the default
+                       new[] { "js", "xml" });                
+            }
         }
 
         [ConfigurationProperty("scriptDisableEditor")]
         internal InnerTextConfigurationElement<bool> ScriptEditorDisable
         {
-            get { return GetOptionalTextElement("scriptDisableEditor", false); }
+            get
+            {
+                return new OptionalInnerTextConfigurationElement<bool>(
+                    (InnerTextConfigurationElement<bool>) this["scriptDisableEditor"],
+                    //set the default
+                    false);
+            }
         }
 
     }

src/Umbraco.Core/Configuration/UmbracoSettings/ImagingAutoFillUploadFieldElement.cs

@@ -2,7 +2,7 @@
 
 namespace Umbraco.Core.Configuration.UmbracoSettings
 {
-    internal class ImagingAutoFillUploadFieldElement : UmbracoConfigurationElement, IImagingAutoFillUploadField
+    internal class ImagingAutoFillUploadFieldElement : ConfigurationElement, IImagingAutoFillUploadField
     {
         /// <summary>
         /// Allow setting internally so we can create a default
@@ -17,25 +17,49 @@ namespace Umbraco.Core.Configuration.UmbracoSettings
         [ConfigurationProperty("widthFieldAlias")]
         internal InnerTextConfigurationElement<string> WidthFieldAlias
         {
-            get { return GetOptionalTextElement("widthFieldAlias", "umbracoWidth"); }
+            get
+            {
+                return new OptionalInnerTextConfigurationElement<string>(
+                       (InnerTextConfigurationElement<string>)this["widthFieldAlias"],
+                    //set the default
+                       "umbracoWidth");
+            }
         }
 
         [ConfigurationProperty("heightFieldAlias")]
         internal InnerTextConfigurationElement<string> HeightFieldAlias
         {
-            get { return GetOptionalTextElement("heightFieldAlias", "umbracoHeight"); }
+            get
+            {
+                return new OptionalInnerTextConfigurationElement<string>(
+                       (InnerTextConfigurationElement<string>)this["heightFieldAlias"],
+                    //set the default
+                       "umbracoHeight");
+            }
         }
 
         [ConfigurationProperty("lengthFieldAlias")]
         internal InnerTextConfigurationElement<string> LengthFieldAlias
         {
-            get { return GetOptionalTextElement("lengthFieldAlias", "umbracoBytes"); }
+            get
+            {
+                return new OptionalInnerTextConfigurationElement<string>(
+                       (InnerTextConfigurationElement<string>)this["lengthFieldAlias"],
+                    //set the default
+                       "umbracoBytes");
+            }
         }
 
         [ConfigurationProperty("extensionFieldAlias")]
         internal InnerTextConfigurationElement<string> ExtensionFieldAlias
         {
-            get { return GetOptionalTextElement("extensionFieldAlias", "umbracoExtension"); }
+            get
+            {
+                return new OptionalInnerTextConfigurationElement<string>(
+                       (InnerTextConfigurationElement<string>)this["extensionFieldAlias"],
+                    //set the default
+                       "umbracoExtension");
+            }
         }
 
         string IImagingAutoFillUploadField.Alias

src/Umbraco.Core/Configuration/UmbracoSettings/LoggingElement.cs

@@ -3,37 +3,67 @@ using System.Configuration;
 
 namespace Umbraco.Core.Configuration.UmbracoSettings
 {
-    internal class LoggingElement : UmbracoConfigurationElement, ILoggingSection
+    internal class LoggingElement : ConfigurationElement, ILoggingSection
     {
         
         [ConfigurationProperty("autoCleanLogs")]
         internal InnerTextConfigurationElement<bool> AutoCleanLogs
         {
-            get { return GetOptionalTextElement("autoCleanLogs", false); }
+            get
+            {
+                return new OptionalInnerTextConfigurationElement<bool>(
+                    (InnerTextConfigurationElement<bool>)this["autoCleanLogs"],
+                    //set the default
+                    false);            
+            }
         }
 
         [ConfigurationProperty("enableLogging")]
         internal InnerTextConfigurationElement<bool> EnableLogging
         {
-            get { return GetOptionalTextElement("enableLogging", true); }
+            get
+            {
+                return new OptionalInnerTextConfigurationElement<bool>(
+                    (InnerTextConfigurationElement<bool>)this["enableLogging"],
+                    //set the default
+                    true);            
+            }
         }
 
         [ConfigurationProperty("enableAsyncLogging")]
         internal InnerTextConfigurationElement<bool> EnableAsyncLogging
         {
-            get { return GetOptionalTextElement("enableAsyncLogging", true); }
+            get
+            {
+                return new OptionalInnerTextConfigurationElement<bool>(
+                    (InnerTextConfigurationElement<bool>)this["enableAsyncLogging"],
+                    //set the default
+                    true);           
+            }
         }
 
         [ConfigurationProperty("cleaningMiliseconds")]
         internal InnerTextConfigurationElement<int> CleaningMiliseconds
         {
-            get { return GetOptionalTextElement("cleaningMiliseconds", -1); }
+            get
+            {
+                return new OptionalInnerTextConfigurationElement<int>(
+                    (InnerTextConfigurationElement<int>)this["cleaningMiliseconds"],
+                    //set the default
+                    -1);                      
+            }
         }
 
         [ConfigurationProperty("maxLogAge")]
         internal InnerTextConfigurationElement<int> MaxLogAge
         {
-            get { return GetOptionalTextElement("maxLogAge", -1); }
+            get
+            {
+                return new OptionalInnerTextConfigurationElement<int>(
+                    (InnerTextConfigurationElement<int>)this["maxLogAge"],
+                    //set the default
+                    -1);
+            }
         }
 
         [ConfigurationCollection(typeof(DisabledLogTypesCollection), AddItemName = "logTypeAlias")]

src/Umbraco.Core/Configuration/UmbracoSettings/NotificationsElement.cs

@@ -2,7 +2,7 @@
 
 namespace Umbraco.Core.Configuration.UmbracoSettings
 {
-    internal class NotificationsElement : UmbracoConfigurationElement
+    internal class NotificationsElement : ConfigurationElement
     {
         [ConfigurationProperty("email")]
         internal InnerTextConfigurationElement<string> NotificationEmailAddress
@@ -13,7 +13,13 @@ namespace Umbraco.Core.Configuration.UmbracoSettings
         [ConfigurationProperty("disableHtmlEmail")]
         internal InnerTextConfigurationElement<bool> DisableHtmlEmail
         {
-            get { return GetOptionalTextElement("disableHtmlEmail", false); }
+            get
+            {
+                return new OptionalInnerTextConfigurationElement<bool>(
+                    (InnerTextConfigurationElement<bool>) this["disableHtmlEmail"], 
+                    //set the default
+                    false);
+            }
         }
 
     }

src/Umbraco.Core/Configuration/UmbracoSettings/RequestHandlerElement.cs

@@ -5,18 +5,30 @@ using System.Collections.Generic;
 
 namespace Umbraco.Core.Configuration.UmbracoSettings
 {
-    internal class RequestHandlerElement : UmbracoConfigurationElement, IRequestHandlerSection
+    internal class RequestHandlerElement : ConfigurationElement, IRequestHandlerSection
     {
         [ConfigurationProperty("useDomainPrefixes")]
         public InnerTextConfigurationElement<bool> UseDomainPrefixes
         {
-            get { return GetOptionalTextElement("useDomainPrefixes", false); }
+            get
+            {
+                return new OptionalInnerTextConfigurationElement<bool>(
+                    (InnerTextConfigurationElement<bool>)this["useDomainPrefixes"],
+                    //set the default
+                    false);  
+            }
         }
 
         [ConfigurationProperty("addTrailingSlash")]
         public InnerTextConfigurationElement<bool> AddTrailingSlash
         {
-            get { return GetOptionalTextElement("addTrailingSlash", true); }
+            get
+            {
+                return new OptionalInnerTextConfigurationElement<bool>(
+                    (InnerTextConfigurationElement<bool>)this["addTrailingSlash"],
+                    //set the default
+                    true);  
+            }
         }
 
         private UrlReplacingElement _defaultUrlReplacing;

src/Umbraco.Core/Configuration/UmbracoSettings/SecurityElement.cs

@@ -2,36 +2,66 @@
 
 namespace Umbraco.Core.Configuration.UmbracoSettings
 {
-    internal class SecurityElement : UmbracoConfigurationElement, ISecuritySection
+    internal class SecurityElement : ConfigurationElement, ISecuritySection
     {
         [ConfigurationProperty("keepUserLoggedIn")]
         internal InnerTextConfigurationElement<bool> KeepUserLoggedIn
         {
-            get { return GetOptionalTextElement("keepUserLoggedIn", true); }
+            get
+            {
+                return new OptionalInnerTextConfigurationElement<bool>(
+                    (InnerTextConfigurationElement<bool>)this["keepUserLoggedIn"],
+                    //set the default
+                    true);   
+            }
         }
 
         [ConfigurationProperty("hideDisabledUsersInBackoffice")]
         internal InnerTextConfigurationElement<bool> HideDisabledUsersInBackoffice
         {
-            get { return GetOptionalTextElement("hideDisabledUsersInBackoffice", false); }
+            get
+            {
+                return new OptionalInnerTextConfigurationElement<bool>(
+                    (InnerTextConfigurationElement<bool>)this["hideDisabledUsersInBackoffice"],
+                    //set the default
+                    false);                          
+            }
         }
 
         [ConfigurationProperty("allowPasswordReset")]
         internal InnerTextConfigurationElement<bool> AllowPasswordReset
         {
-            get { return GetOptionalTextElement("allowPasswordReset", true); }
+            get
+            {
+                return new OptionalInnerTextConfigurationElement<bool>(
+                    (InnerTextConfigurationElement<bool>)this["allowPasswordReset"],
+                    //set the default
+                    true);
+            }
         }
 
         [ConfigurationProperty("authCookieName")]
         internal InnerTextConfigurationElement<string> AuthCookieName
         {
-            get { return GetOptionalTextElement("authCookieName", Constants.Web.AuthCookieName); }
+            get
+            {
+                return new OptionalInnerTextConfigurationElement<string>(
+                    (InnerTextConfigurationElement<string>)this["authCookieName"],
+                    //set the default
+                    Constants.Web.AuthCookieName);                
+            }
         }
 
         [ConfigurationProperty("authCookieDomain")]
         internal InnerTextConfigurationElement<string> AuthCookieDomain
         {
-            get { return GetOptionalTextElement<string>("authCookieDomain", null); }
+            get
+            {
+                return new OptionalInnerTextConfigurationElement<string>(
+                    (InnerTextConfigurationElement<string>)this["authCookieDomain"],
+                    //set the default
+                    null);                    
+            }
         }
 
         bool ISecuritySection.KeepUserLoggedIn

src/Umbraco.Core/Configuration/UmbracoSettings/TemplatesElement.cs

@@ -3,31 +3,55 @@ using System.Configuration;
 
 namespace Umbraco.Core.Configuration.UmbracoSettings
 {
-    internal class TemplatesElement : UmbracoConfigurationElement, ITemplatesSection
+    internal class TemplatesElement : ConfigurationElement, ITemplatesSection
     {
         [ConfigurationProperty("useAspNetMasterPages")]
         internal InnerTextConfigurationElement<bool> UseAspNetMasterPages
         {
-            get { return GetOptionalTextElement("useAspNetMasterPages", true); }
+            get
+            {
+                return new OptionalInnerTextConfigurationElement<bool>(
+                    (InnerTextConfigurationElement<bool>)this["useAspNetMasterPages"],
+                    //set the default
+                    true);
+            }
         }
 
         [ConfigurationProperty("enableSkinSupport")]
         internal InnerTextConfigurationElement<bool> EnableSkinSupport
         {
-            get { return GetOptionalTextElement("enableSkinSupport", true); }
+            get
+            {
+                return new OptionalInnerTextConfigurationElement<bool>(
+                    (InnerTextConfigurationElement<bool>)this["enableSkinSupport"],
+                    //set the default
+                    true);
+            }
         }
 
         [ConfigurationProperty("defaultRenderingEngine", IsRequired = true)]
         internal InnerTextConfigurationElement<RenderingEngine> DefaultRenderingEngine
         {
-            get { return GetOptionalTextElement("defaultRenderingEngine", RenderingEngine.Mvc); }
+            get
+            {
+                return new OptionalInnerTextConfigurationElement<RenderingEngine>(
+                    (InnerTextConfigurationElement<RenderingEngine>)this["defaultRenderingEngine"],
+                    //set the default
+                    RenderingEngine.Mvc);
+            }
         }
 
         [Obsolete("This has no affect and will be removed in future versions")]
         [ConfigurationProperty("enableTemplateFolders")]
         internal InnerTextConfigurationElement<bool> EnableTemplateFolders
         {
-            get { return GetOptionalTextElement("enableTemplateFolders", false); }
+            get
+            {
+                return new OptionalInnerTextConfigurationElement<bool>(
+                    (InnerTextConfigurationElement<bool>)this["enableTemplateFolders"],
+                    //set the default
+                    false);
+            }
         }
 
         bool ITemplatesSection.UseAspNetMasterPages

src/Umbraco.Core/Configuration/UmbracoSettings/UmbracoConfigurationElement.cs

@@ -1,36 +0,0 @@
-using System.Collections.Concurrent;
-using System.Configuration;
-
-namespace Umbraco.Core.Configuration.UmbracoSettings
-{
-    /// <summary>
-    /// Base class with shared helper methods
-    /// </summary>
-    internal class UmbracoConfigurationElement : ConfigurationElement
-    {
-        /// <summary>
-        /// Used so the RawElement types are not re-created every time they are accessed
-        /// </summary>
-        private readonly ConcurrentDictionary<string, RawXmlConfigurationElement> _rawElements = new ConcurrentDictionary<string, RawXmlConfigurationElement>();
-
-        protected OptionalInnerTextConfigurationElement<T> GetOptionalTextElement<T>(string name, T defaultVal)
-        {
-            return (OptionalInnerTextConfigurationElement<T>) _rawElements.GetOrAdd(
-                name,
-                s => new OptionalInnerTextConfigurationElement<T>(
-                    (InnerTextConfigurationElement<T>) this[s],
-                    //set the default
-                    defaultVal));
-        }
-
-        protected OptionalCommaDelimitedConfigurationElement GetOptionalDelimitedElement(string name, string[] defaultVal)
-        {
-            return (OptionalCommaDelimitedConfigurationElement) _rawElements.GetOrAdd(
-                name,
-                s => new OptionalCommaDelimitedConfigurationElement(
-                    (CommaDelimitedConfigurationElement) this[name],
-                    //set the default
-                    defaultVal));
-        }
-    }
-}

src/Umbraco.Core/Configuration/UmbracoVersion.cs

@@ -24,7 +24,7 @@ namespace Umbraco.Core.Configuration
         /// Gets the version comment (like beta or RC).
         /// </summary>
         /// <value>The version comment.</value>
-        public static string CurrentComment { get { return "alpha054"; } }
+        public static string CurrentComment { get { return "alpha038"; } }
 
         // Get the version of the umbraco.dll by looking at a class in that dll
         // Had to do it like this due to medium trust issues, see: http://haacked.com/archive/2010/11/04/assembly-location-and-medium-trust.aspx

src/Umbraco.Core/Constants-Conventions.cs

@@ -4,8 +4,7 @@ using Umbraco.Core.Models;
 
 namespace Umbraco.Core
 {
-   
-    public static partial class Constants
+	public static partial class Constants
 	{
 		/// <summary>
 		/// Defines the identifiers for property-type alias conventions that are used within the Umbraco core.

src/Umbraco.Core/Constants-DatabaseProviders.cs

@@ -1,12 +0,0 @@
-namespace Umbraco.Core
-{
-    public static partial class Constants
-    {
-        public static class DatabaseProviders
-        {
-            public const string SqlCe = "System.Data.SqlServerCe.4.0";
-            public const string SqlServer = "System.Data.SqlClient";
-            public const string MySql = "MySql.Data.MySqlClient";
-        }
-    }
-}

src/Umbraco.Core/Constants-DeployEntityType.cs

@@ -1,129 +0,0 @@
-using System;
-using System.Collections.Generic;
-using Umbraco.Core.Models;
-
-namespace Umbraco.Core
-{
-    
-    public static partial class Constants
-    {
-
-        /// <summary>
-        /// Defines well-known entity types.
-        /// </summary>
-        /// <remarks>Well-known entity types are those that Deploy already knows about,
-        /// but entity types are strings and so can be extended beyond what is defined here.</remarks>
-        public static class DeployEntityType
-        {
-            // guid entity types
-
-            public const string AnyGuid = "any-guid"; // that one is for tests
-
-            public const string Document = "document";
-            public const string Media = "media";
-            public const string Member = "member";
-
-            public const string DictionaryItem = "dictionary-item";
-            public const string Macro = "macro";
-            public const string Template = "template";
-
-            public const string DocumentType = "document-type";
-            public const string DocumentTypeContainer = "document-type-container";
-            public const string MediaType = "media-type";
-            public const string MediaTypeContainer = "media-type-container";
-            public const string DataType = "data-type";
-            public const string DataTypeContainer = "data-type-container";
-            public const string MemberType = "member-type";
-            public const string MemberGroup = "member-group";
-
-            public const string RelationType = "relation-type";
-
-            // string entity types
-
-            public const string AnyString = "any-string"; // that one is for tests
-
-            public const string MediaFile = "media-file";
-            public const string TemplateFile = "template-file";
-            public const string Script = "script";
-            public const string Stylesheet = "stylesheet";
-            public const string PartialView = "partial-view";
-            public const string PartialViewMacro = "partial-view-macro";
-            public const string Xslt = "xslt";
-
-            public static string FromUmbracoObjectType(UmbracoObjectTypes umbracoObjectType)
-            {
-                switch (umbracoObjectType)
-                {
-                    case UmbracoObjectTypes.Document:
-                        return Document;
-                    case UmbracoObjectTypes.Media:
-                        return Media;
-                    case UmbracoObjectTypes.Member:
-                        return Member;
-                    case UmbracoObjectTypes.Template:
-                        return Template;
-                    case UmbracoObjectTypes.DocumentType:
-                        return DocumentType;
-                    case UmbracoObjectTypes.DocumentTypeContainer:
-                        return DocumentTypeContainer;
-                    case UmbracoObjectTypes.MediaType:
-                        return MediaType;
-                    case UmbracoObjectTypes.MediaTypeContainer:
-                        return MediaTypeContainer;
-                    case UmbracoObjectTypes.DataType:
-                        return DataType;
-                    case UmbracoObjectTypes.DataTypeContainer:
-                        return DataTypeContainer;
-                    case UmbracoObjectTypes.MemberType:
-                        return MemberType;
-                    case UmbracoObjectTypes.MemberGroup:
-                        return MemberGroup;
-                    case UmbracoObjectTypes.Stylesheet:
-                        return Stylesheet;
-                    case UmbracoObjectTypes.RelationType:
-                        return RelationType;
-                }
-                throw new NotSupportedException(string.Format("UmbracoObjectType \"{0}\" does not have a matching EntityType.", umbracoObjectType));
-            }
-
-            public static UmbracoObjectTypes ToUmbracoObjectType(string entityType)
-            {
-                switch (entityType)
-                {
-                    case Document:
-                        return UmbracoObjectTypes.Document;
-                    case Media:
-                        return UmbracoObjectTypes.Media;
-                    case Member:
-                        return UmbracoObjectTypes.Member;
-                    case Template:
-                        return UmbracoObjectTypes.Template;
-                    case DocumentType:
-                        return UmbracoObjectTypes.DocumentType;
-                    case DocumentTypeContainer:
-                        return UmbracoObjectTypes.DocumentTypeContainer;
-                    case MediaType:
-                        return UmbracoObjectTypes.MediaType;
-                    case MediaTypeContainer:
-                        return UmbracoObjectTypes.MediaTypeContainer;
-                    case DataType:
-                        return UmbracoObjectTypes.DataType;
-                    case DataTypeContainer:
-                        return UmbracoObjectTypes.DataTypeContainer;
-                    case MemberType:
-                        return UmbracoObjectTypes.MemberType;
-                    case MemberGroup:
-                        return UmbracoObjectTypes.MemberGroup;
-                    case Stylesheet:
-                        return UmbracoObjectTypes.Stylesheet;
-                    case RelationType:
-                        return UmbracoObjectTypes.RelationType;
-                }
-                throw new NotSupportedException(
-                    string.Format("EntityType \"{0}\" does not have a matching UmbracoObjectType.", entityType));
-            }
-        }
-
-
-    }
-}

src/Umbraco.Core/Constants-DeploySelector.cs

@@ -1,17 +0,0 @@
-namespace Umbraco.Core
-{    
-    public static partial class Constants
-    {
-        /// <summary>
-        /// Contains the valid selector values.
-        /// </summary>
-        public static class DeploySelector
-        {
-            public const string This = "this";
-            public const string ThisAndChildren = "this-and-children";
-            public const string ThisAndDescendants = "this-and-descendants";
-            public const string ChildrenOfThis = "children";
-            public const string DescendantsOfThis = "descendants";
-        }
-    }
-}

src/Umbraco.Core/Constants-ObjectTypes.cs

@@ -152,16 +152,6 @@ namespace Umbraco.Core
             /// Guid for a Lock object.
             /// </summary>
             public static readonly Guid LockObjectGuid = new Guid(LockObject);
-
-            /// <summary>
-            /// Guid for a relation type.
-            /// </summary>
-            public const string RelationType = "B1988FAD-8675-4F47-915A-B3A602BC5D8D";
-
-            /// <summary>
-            /// Guid for a relation type.
-            /// </summary>
-            public static readonly Guid RelationTypeGuid = new Guid(RelationType);
         }
     }
 }

src/Umbraco.Core/Constants-Security.cs

@@ -1,33 +0,0 @@
-using System;
-using System.ComponentModel;
-
-namespace Umbraco.Core
-{
-    public static partial class Constants
-    {
-        public static class Security
-        {
-
-            public const string BackOfficeAuthenticationType = "UmbracoBackOffice";
-            public const string BackOfficeExternalAuthenticationType = "UmbracoExternalCookie";
-            public const string BackOfficeExternalCookieName = "UMB_EXTLOGIN";
-            public const string BackOfficeTokenAuthenticationType = "UmbracoBackOfficeToken";
-            public const string BackOfficeTwoFactorAuthenticationType = "UmbracoTwoFactorCookie";
-
-            /// <summary>
-            /// The prefix used for external identity providers for their authentication type
-            /// </summary>
-            /// <remarks>
-            /// By default we don't want to interfere with front-end external providers and their default setup, for back office the 
-            /// providers need to be setup differently and each auth type for the back office will be prefixed with this value
-            /// </remarks>
-            public const string BackOfficeExternalAuthenticationTypePrefix = "Umbraco.";
-
-            public const string StartContentNodeIdClaimType = "http://umbraco.org/2015/02/identity/claims/backoffice/startcontentnode";
-            public const string StartMediaNodeIdClaimType = "http://umbraco.org/2015/02/identity/claims/backoffice/startmedianode";
-            public const string AllowedApplicationsClaimType = "http://umbraco.org/2015/02/identity/claims/backoffice/allowedapp";
-            public const string SessionIdClaimType = "http://umbraco.org/2015/02/identity/claims/backoffice/sessionid";
-
-        }
-    }
-}

src/Umbraco.Core/Constants-System.cs

@@ -25,10 +25,13 @@
             public const int DefaultContentListViewDataTypeId = -95;
             public const int DefaultMediaListViewDataTypeId = -96;
             public const int DefaultMembersListViewDataTypeId = -97;
-
-            public const string UmbracoConnectionName = "umbracoDbDSN";
-            public const string UmbracoMigrationName = "Umbraco";
         }
-        
+
+        public static class DatabaseProviders
+        {
+            public const string SqlCe = "System.Data.SqlServerCe.4.0";
+            public const string SqlServer = "System.Data.SqlClient";
+            public const string MySql = "MySql.Data.MySqlClient";
+        }
     }
 }

src/Umbraco.Core/Constants-Web.cs

@@ -29,6 +29,30 @@ namespace Umbraco.Core
             public const string AuthCookieName = "UMB_UCONTEXT";
 
         }
-        
+
+	    public static class Security
+	    {
+
+            public const string BackOfficeAuthenticationType = "UmbracoBackOffice";
+	        public const string BackOfficeExternalAuthenticationType = "UmbracoExternalCookie";
+            public const string BackOfficeExternalCookieName = "UMB_EXTLOGIN";
+            public const string BackOfficeTokenAuthenticationType = "UmbracoBackOfficeToken";
+            public const string BackOfficeTwoFactorAuthenticationType = "UmbracoTwoFactorCookie";
+
+            /// <summary>
+            /// The prefix used for external identity providers for their authentication type
+            /// </summary>
+            /// <remarks>
+            /// By default we don't want to interfere with front-end external providers and their default setup, for back office the 
+            /// providers need to be setup differently and each auth type for the back office will be prefixed with this value
+            /// </remarks>
+            public const string BackOfficeExternalAuthenticationTypePrefix = "Umbraco.";
+
+	        public const string StartContentNodeIdClaimType = "http://umbraco.org/2015/02/identity/claims/backoffice/startcontentnode";
+            public const string StartMediaNodeIdClaimType = "http://umbraco.org/2015/02/identity/claims/backoffice/startmedianode";
+            public const string AllowedApplicationsClaimType = "http://umbraco.org/2015/02/identity/claims/backoffice/allowedapp";
+            public const string SessionIdClaimType = "http://umbraco.org/2015/02/identity/claims/backoffice/sessionid";
+
+	    }
 	}
 }

src/Umbraco.Core/CoreBootManager.cs

@@ -105,7 +105,7 @@ namespace Umbraco.Core
             LegacyParameterEditorAliasConverter.CreateMappingsForCoreEditors();
 
             //create database and service contexts for the app context
-            var dbFactory = new DefaultDatabaseFactory(Constants.System.UmbracoConnectionName, ProfilingLogger.Logger);
+            var dbFactory = new DefaultDatabaseFactory(GlobalSettings.UmbracoConnectionName, ProfilingLogger.Logger);
             Database.Mapper = new PetaPocoMapper();
 
             var dbContext = new DatabaseContext(
@@ -415,7 +415,7 @@ namespace Umbraco.Core
 
             if (currentTry == 5)
             {
-                throw new UmbracoStartupFailedException("Umbraco cannot start. A connection string is configured but Umbraco cannot connect to the database.");
+                throw new UmbracoStartupFailedException("Umbraco cannot start. A connection string is configured but the Umbraco cannot connect to the database.");
             }
         }
 

src/Umbraco.Core/DatabaseContext.cs

@@ -195,14 +195,14 @@ namespace Umbraco.Core
                     return _providerName;
 
                 _providerName = Constants.DatabaseProviders.SqlServer;
-                if (ConfigurationManager.ConnectionStrings[Constants.System.UmbracoConnectionName] != null)
+                if (ConfigurationManager.ConnectionStrings[GlobalSettings.UmbracoConnectionName] != null)
                 {
-                    if (string.IsNullOrEmpty(ConfigurationManager.ConnectionStrings[Constants.System.UmbracoConnectionName].ProviderName) == false)
-                        _providerName = ConfigurationManager.ConnectionStrings[Constants.System.UmbracoConnectionName].ProviderName;
+                    if (string.IsNullOrEmpty(ConfigurationManager.ConnectionStrings[GlobalSettings.UmbracoConnectionName].ProviderName) == false)
+                        _providerName = ConfigurationManager.ConnectionStrings[GlobalSettings.UmbracoConnectionName].ProviderName;
                 }
                 else
                 {
-                    throw new InvalidOperationException("Can't find a connection string with the name '" + Constants.System.UmbracoConnectionName + "'");
+                    throw new InvalidOperationException("Can't find a connection string with the name '" + GlobalSettings.UmbracoConnectionName + "'");
                 }
                 return _providerName;
             }
@@ -241,10 +241,15 @@ namespace Umbraco.Core
             var path = Path.Combine(GlobalSettings.FullpathToRoot, "App_Data", "Umbraco.sdf");
             if (File.Exists(path) == false)
             {
-                using (var engine = new SqlCeEngine(connectionString))
-                {
-                    engine.CreateDatabase();
-                }
+                var engine = new SqlCeEngine(connectionString);
+                engine.CreateDatabase();
+
+                // SD: Pretty sure this should be in a using clause but i don't want to cause unknown side-effects here
+                // since it's been like this for quite some time
+                //using (var engine = new SqlCeEngine(connectionString))
+                //{
+                //    engine.CreateDatabase();
+                //}
             }
 
             Initialize(providerName);
@@ -383,9 +388,9 @@ namespace Umbraco.Core
         {
             //Set the connection string for the new datalayer
             var connectionStringSettings = string.IsNullOrEmpty(providerName)
-                                      ? new ConnectionStringSettings(Constants.System.UmbracoConnectionName,
+                                      ? new ConnectionStringSettings(GlobalSettings.UmbracoConnectionName,
                                                                      connectionString)
-                                      : new ConnectionStringSettings(Constants.System.UmbracoConnectionName,
+                                      : new ConnectionStringSettings(GlobalSettings.UmbracoConnectionName,
                                                                      connectionString, providerName);
 
             _connectionString = connectionString;
@@ -396,10 +401,10 @@ namespace Umbraco.Core
             var connectionstrings = xml.Root.DescendantsAndSelf("connectionStrings").Single();
 
             // Update connectionString if it exists, or else create a new appSetting for the given key and value
-            var setting = connectionstrings.Descendants("add").FirstOrDefault(s => s.Attribute("name").Value == Constants.System.UmbracoConnectionName);
+            var setting = connectionstrings.Descendants("add").FirstOrDefault(s => s.Attribute("name").Value == GlobalSettings.UmbracoConnectionName);
             if (setting == null)
                 connectionstrings.Add(new XElement("add",
-                    new XAttribute("name", Constants.System.UmbracoConnectionName),
+                    new XAttribute("name", GlobalSettings.UmbracoConnectionName),
                     new XAttribute("connectionString", connectionStringSettings),
                     new XAttribute("providerName", providerName)));
             else
@@ -424,23 +429,23 @@ namespace Umbraco.Core
         /// </remarks>
         internal void Initialize()
         {
-            var databaseSettings = ConfigurationManager.ConnectionStrings[Constants.System.UmbracoConnectionName];
+            var databaseSettings = ConfigurationManager.ConnectionStrings[GlobalSettings.UmbracoConnectionName];
             if (databaseSettings != null && string.IsNullOrWhiteSpace(databaseSettings.ConnectionString) == false && string.IsNullOrWhiteSpace(databaseSettings.ProviderName) == false)
             {
                 var providerName = Constants.DatabaseProviders.SqlServer;
                 string connString = null;
-                if (!string.IsNullOrEmpty(ConfigurationManager.ConnectionStrings[Constants.System.UmbracoConnectionName].ProviderName))
+                if (!string.IsNullOrEmpty(ConfigurationManager.ConnectionStrings[GlobalSettings.UmbracoConnectionName].ProviderName))
                 {
-                    providerName = ConfigurationManager.ConnectionStrings[Constants.System.UmbracoConnectionName].ProviderName;
-                    connString = ConfigurationManager.ConnectionStrings[Constants.System.UmbracoConnectionName].ConnectionString;
+                    providerName = ConfigurationManager.ConnectionStrings[GlobalSettings.UmbracoConnectionName].ProviderName;
+                    connString = ConfigurationManager.ConnectionStrings[GlobalSettings.UmbracoConnectionName].ConnectionString;
                 }
                 Initialize(providerName, connString);
 
             }
-            else if (ConfigurationManager.AppSettings.ContainsKey(Constants.System.UmbracoConnectionName) && string.IsNullOrEmpty(ConfigurationManager.AppSettings[Constants.System.UmbracoConnectionName]) == false)
+            else if (ConfigurationManager.AppSettings.ContainsKey(GlobalSettings.UmbracoConnectionName) && string.IsNullOrEmpty(ConfigurationManager.AppSettings[GlobalSettings.UmbracoConnectionName]) == false)
             {
                 //A valid connectionstring does not exist, but the legacy appSettings key was found, so we'll reconfigure the conn.string.
-                var legacyConnString = ConfigurationManager.AppSettings[Constants.System.UmbracoConnectionName];
+                var legacyConnString = ConfigurationManager.AppSettings[GlobalSettings.UmbracoConnectionName];
                 if (legacyConnString.ToLowerInvariant().Contains("sqlce4umbraco"))
                 {
                     ConfigureEmbeddedDatabaseConnection();
@@ -471,7 +476,7 @@ namespace Umbraco.Core
                 }
 
                 //Remove the legacy connection string, so we don't end up in a loop if something goes wrong.
-                GlobalSettings.RemoveSetting(Constants.System.UmbracoConnectionName);
+                GlobalSettings.RemoveSetting(GlobalSettings.UmbracoConnectionName);
 
             }
             else
@@ -667,7 +672,7 @@ namespace Umbraco.Core
 
                 //DO the upgrade!
 
-                var runner = new MigrationRunner(migrationEntryService, _logger, currentInstalledVersion, UmbracoVersion.GetSemanticVersion(), Constants.System.UmbracoMigrationName);
+                var runner = new MigrationRunner(migrationEntryService, _logger, currentInstalledVersion, UmbracoVersion.GetSemanticVersion(), GlobalSettings.UmbracoMigrationName);
 
                 var upgraded = runner.Execute(database, true);
 

src/Umbraco.Core/Deploy/ArtifactBase.cs

@@ -1,52 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using Newtonsoft.Json;
-
-namespace Umbraco.Core.Deploy
-{
-    /// <summary>
-    /// Provides a base class to all artifacts.
-    /// </summary>
-    public abstract class ArtifactBase<TUdi> : IArtifact
-        where TUdi : Udi
-    {
-        protected ArtifactBase(TUdi udi, IEnumerable<ArtifactDependency> dependencies = null)
-        {
-            if (udi == null)
-                throw new ArgumentNullException("udi");
-            Udi = udi;
-
-            Dependencies = dependencies ?? Enumerable.Empty<ArtifactDependency>();
-            _checksum = new Lazy<string>(GetChecksum);
-        }
-
-        private readonly Lazy<string> _checksum;
-        private IEnumerable<ArtifactDependency> _dependencies;
-
-        protected abstract string GetChecksum();
-
-        #region Abstract implementation of IArtifactSignature
-
-        Udi IArtifactSignature.Udi
-        {
-            get { return Udi; }
-        }
-
-        public TUdi Udi { get; set; }
-
-        [JsonIgnore]
-        public string Checksum
-        {
-            get { return _checksum.Value; }
-        }
-
-        public IEnumerable<ArtifactDependency> Dependencies
-        {
-            get { return _dependencies; }
-            set { _dependencies = value.OrderBy(x => x.Udi); }
-        }
-
-        #endregion
-    }
-}

src/Umbraco.Core/Deploy/ArtifactDependency.cs

@@ -1,40 +0,0 @@
-namespace Umbraco.Core.Deploy
-{
-    /// <summary>
-    /// Represents an artifact dependency.
-    /// </summary>
-    /// <remarks>
-    /// <para>Dependencies have an order property which indicates whether it must be respected when ordering artifacts.</para>
-    /// <para>Dependencies have a mode which can be <c>Match</c> or <c>Exist</c> depending on whether the checksum should match.</para>
-    /// </remarks>
-    public class ArtifactDependency
-    {
-        /// <summary>
-        /// Initializes a new instance of the ArtifactDependency class with an entity identifier and a mode.
-        /// </summary>
-        /// <param name="udi">The entity identifier of the artifact that is a dependency.</param>
-        /// <param name="ordering">A value indicating whether the dependency is ordering.</param>
-        /// <param name="mode">The dependency mode.</param>
-        public ArtifactDependency(Udi udi, bool ordering, ArtifactDependencyMode mode)
-        {
-            Udi = udi;
-            Ordering = ordering;
-            Mode = mode;
-        }
-
-        /// <summary>
-        /// Gets the entity id of the artifact that is a dependency.
-        /// </summary>
-        public Udi Udi { get; private set; }
-
-        /// <summary>
-        /// Gets a value indicating whether the dependency is ordering.
-        /// </summary>
-        public bool Ordering { get; private set; }
-
-        /// <summary>
-        /// Gets the dependency mode.
-        /// </summary>
-        public ArtifactDependencyMode Mode { get; private set; }
-    }
-}

src/Umbraco.Core/Deploy/ArtifactDependencyCollection.cs

@@ -1,69 +0,0 @@
-using System;
-using System.Collections;
-using System.Collections.Generic;
-
-namespace Umbraco.Core.Deploy
-{
-    /// <summary>
-    /// Represents a collection of distinct <see cref="ArtifactDependency"/>.
-    /// </summary>
-    /// <remarks>The collection cannot contain duplicates and modes are properly managed.</remarks>
-    public class ArtifactDependencyCollection : ICollection<ArtifactDependency>
-    {
-        private readonly Dictionary<Udi, ArtifactDependency> _dependencies
-            = new Dictionary<Udi, ArtifactDependency>();
-
-        public IEnumerator<ArtifactDependency> GetEnumerator()
-        {
-            return _dependencies.Values.GetEnumerator();
-        }
-
-        IEnumerator IEnumerable.GetEnumerator()
-        {
-            return GetEnumerator();
-        }
-
-        public void Add(ArtifactDependency item)
-        {
-            if (_dependencies.ContainsKey(item.Udi))
-            {
-                var exist = _dependencies[item.Udi];
-                if (item.Mode == ArtifactDependencyMode.Exist || item.Mode == exist.Mode)
-                    return;
-            }
-
-            _dependencies[item.Udi] = item;
-        }
-
-        public void Clear()
-        {
-            _dependencies.Clear();
-        }
-
-        public bool Contains(ArtifactDependency item)
-        {
-            return _dependencies.ContainsKey(item.Udi) &&
-                   (_dependencies[item.Udi].Mode == item.Mode || _dependencies[item.Udi].Mode == ArtifactDependencyMode.Match);
-        }
-
-        public void CopyTo(ArtifactDependency[] array, int arrayIndex)
-        {
-            _dependencies.Values.CopyTo(array, arrayIndex);
-        }
-
-        public bool Remove(ArtifactDependency item)
-        {
-            throw new NotSupportedException();
-        }
-
-        public int Count
-        {
-            get { return _dependencies.Count; }
-        }
-
-        public bool IsReadOnly
-        {
-            get { return false; }
-        }
-    }
-}

src/Umbraco.Core/Deploy/ArtifactDependencyMode.cs

@@ -1,18 +0,0 @@
-namespace Umbraco.Core.Deploy
-{
-    /// <summary>
-    /// Indicates the mode of the dependency.
-    /// </summary>
-    public enum ArtifactDependencyMode
-    {
-        /// <summary>
-        /// The dependency must match exactly.
-        /// </summary>
-        Match,
-
-        /// <summary>
-        /// The dependency must exist.
-        /// </summary>
-        Exist
-    }
-}

src/Umbraco.Core/Deploy/ArtifactDeployState.cs

@@ -1,50 +0,0 @@
-namespace Umbraco.Core.Deploy
-{
-    /// <summary>
-    /// Represent the state of an artifact being deployed.
-    /// </summary>
-    public abstract class ArtifactDeployState
-    {
-        /// <summary>
-        /// Creates a new instance of the <see cref="ArtifactDeployState"/> class from an artifact and an entity.
-        /// </summary>
-        /// <typeparam name="TArtifact">The type of the artifact.</typeparam>
-        /// <typeparam name="TEntity">The type of the entity.</typeparam>
-        /// <param name="art">The artifact.</param>
-        /// <param name="entity">The entity.</param>
-        /// <param name="connector">The service connector deploying the artifact.</param>
-        /// <param name="nextPass">The next pass number.</param>
-        /// <returns>A deploying artifact.</returns>
-        public static ArtifactDeployState<TArtifact, TEntity> Create<TArtifact, TEntity>(TArtifact art, TEntity entity, IServiceConnector connector, int nextPass)
-            where TArtifact : IArtifact
-        {
-            return new ArtifactDeployState<TArtifact, TEntity>(art, entity, connector, nextPass);
-        }
-
-        /// <summary>
-        /// Gets the artifact.
-        /// </summary>
-        public IArtifact Artifact
-        {
-            get { return GetArtifactAsIArtifact(); }
-        }
-
-        /// <summary>
-        /// Gets the artifact as an <see cref="IArtifact"/>.
-        /// </summary>
-        /// <returns>The artifact, as an <see cref="IArtifact"/>.</returns>
-        /// <remarks>This is because classes that inherit from this class cannot override the Artifact property
-        /// with a property that specializes the return type, and so they need to 'new' the property.</remarks>
-        protected abstract IArtifact GetArtifactAsIArtifact();
-
-        /// <summary>
-        /// Gets or sets the service connector in charge of deploying the artifact.
-        /// </summary>
-        public IServiceConnector Connector { get; set; }
-
-        /// <summary>
-        /// Gets or sets the next pass number.
-        /// </summary>
-        public int NextPass { get; set; }
-    }
-}

src/Umbraco.Core/Deploy/ArtifactDeployStateOfTArtifactTEntity.cs

@@ -1,48 +0,0 @@
-namespace Umbraco.Core.Deploy
-{
-    /// <summary>
-    /// Represent the state of an artifact being deployed.
-    /// </summary>
-    /// <typeparam name="TArtifact">The type of the artifact.</typeparam>
-    /// <typeparam name="TEntity">The type of the entity.</typeparam>
-    public class ArtifactDeployState<TArtifact, TEntity> : ArtifactDeployState
-        where TArtifact : IArtifact
-    {
-        /// <summary>
-        /// Initializes a new instance of the <see cref="ArtifactDeployState{TArtifact,TEntity}"/> class.
-        /// </summary>
-        public ArtifactDeployState()
-        { }
-
-        /// <summary>
-        /// Initializes a new instance of the <see cref="ArtifactDeployState{TArtifact,TEntity}"/> class.
-        /// </summary>
-        /// <param name="art">The artifact.</param>
-        /// <param name="entity">The entity.</param>
-        /// <param name="connector">The service connector deploying the artifact.</param>
-        /// <param name="nextPass">The next pass number.</param>
-        public ArtifactDeployState(TArtifact art, TEntity entity, IServiceConnector connector, int nextPass)
-        {
-            Artifact = art;
-            Entity = entity;
-            Connector = connector;
-            NextPass = nextPass;
-        }
-
-        /// <summary>
-        /// Gets or sets the artifact.
-        /// </summary>
-        public new TArtifact Artifact { get; set; }
-
-        /// <summary>
-        /// Gets or sets the entity.
-        /// </summary>
-        public TEntity Entity { get; set; }
-
-        /// <inheritdoc/>
-        protected sealed override IArtifact GetArtifactAsIArtifact()
-        {
-            return Artifact;
-        }
-    }
-}

src/Umbraco.Core/Deploy/ArtifactSignature.cs

@@ -1,21 +0,0 @@
-using System.Collections.Generic;
-using System.Linq;
-
-namespace Umbraco.Core.Deploy
-{
-    public sealed class ArtifactSignature : IArtifactSignature
-    {
-        public ArtifactSignature(Udi udi, string checksum, IEnumerable<ArtifactDependency> dependencies = null)
-        {
-            Udi = udi;
-            Checksum = checksum;
-            Dependencies = dependencies ?? Enumerable.Empty<ArtifactDependency>();
-        }
-
-        public Udi Udi { get; private set; }
-
-        public string Checksum { get; private set; }
-
-        public IEnumerable<ArtifactDependency> Dependencies { get; private set; }
-    }
-}

src/Umbraco.Core/Deploy/Difference.cs

@@ -1,28 +0,0 @@
-namespace Umbraco.Core.Deploy
-{
-    public class Difference
-    {
-        public Difference(string title, string text = null, string category = null)
-        {
-            Title = title;
-            Text = text;
-            Category = category;
-        }
-
-        public string Title { get; set; }
-        public string Text { get; set; }
-        public string Category { get; set; }
-
-        public override string ToString()
-        {
-            var s = Title;
-            if (!string.IsNullOrWhiteSpace(Category)) s += string.Format("[{0}]", Category);
-            if (!string.IsNullOrWhiteSpace(Text))
-            {
-                if (s.Length > 0) s += ":";
-                s += Text;
-            }
-            return s;
-        }
-    }
-}

src/Umbraco.Core/Deploy/Direction.cs

@@ -1,8 +0,0 @@
-namespace Umbraco.Core.Deploy
-{
-    public enum Direction
-    {
-        ToArtifact,
-        FromArtifact
-    }
-}

src/Umbraco.Core/Deploy/IArtifact.cs

@@ -1,8 +0,0 @@
-namespace Umbraco.Core.Deploy
-{
-    /// <summary>
-    /// Represents an artifact ie an object that can be transfered between environments.
-    /// </summary>
-    public interface IArtifact : IArtifactSignature
-    { }
-}

src/Umbraco.Core/Deploy/IArtifactSignature.cs

@@ -1,41 +0,0 @@
-using System.Collections.Generic;
-
-namespace Umbraco.Core.Deploy
-{
-    /// <summary>
-    /// Represents the signature of an artifact.
-    /// </summary>
-    public interface IArtifactSignature
-    {
-        /// <summary>
-        /// Gets the entity unique identifier of this artifact.
-        /// </summary>
-        /// <remarks>
-        /// <para>The project identifier is independent from the state of the artifact, its data
-        /// values, dependencies, anything. It never changes and fully identifies the artifact.</para>
-        /// <para>What an entity uses as a unique identifier will influence what we can transfer
-        /// between environments. Eg content type "Foo" on one environment is not necessarily the
-        /// same as "Foo" on another environment, if guids are used as unique identifiers. What is
-        /// used should be documented for each entity, along with the consequences of the choice.</para>
-        /// </remarks>
-        Udi Udi { get; }
-
-        /// <summary>
-        /// Gets the checksum of this artifact.
-        /// </summary>
-        /// <remarks>
-        /// <para>The checksum depends on the artifact's properties, and on the identifiers of all its dependencies,
-        /// but not on their checksums. So the checksum changes when any of the artifact's properties changes,
-        /// or when the list of dependencies changes. But not if one of these dependencies change.</para>
-        /// <para>It is assumed that checksum collisions cannot happen ie that no two different artifact's
-        /// states will ever produce the same checksum, so that if two artifacts have the same checksum then
-        /// they are identical.</para>
-        /// </remarks>
-        string Checksum { get; }
-
-        /// <summary>
-        /// Gets the dependencies of this artifact.
-        /// </summary>
-        IEnumerable<ArtifactDependency> Dependencies { get; }
-    }
-}

src/Umbraco.Core/Deploy/IDeployContext.cs

@@ -1,42 +0,0 @@
-using System;
-using System.Collections.Generic;
-
-namespace Umbraco.Core.Deploy
-{
-    /// <summary>
-    /// Represents a deployment context.
-    /// </summary>
-    public interface IDeployContext
-    {
-        /// <summary>
-        /// Gets the unique identifier of the deployment.
-        /// </summary>
-        Guid SessionId { get; }
-
-        /// <summary>
-        /// Gets the file source.
-        /// </summary>
-        /// <remarks>The file source is used to obtain files from the source environment.</remarks>
-        IFileSource FileSource { get; }
-
-        /// <summary>
-        /// Gets the next number in a numerical sequence.
-        /// </summary>
-        /// <returns>The next sequence number.</returns>
-        /// <remarks>Can be used to uniquely number things during a deployment.</remarks>
-        int NextSeq();
-
-        /// <summary>
-        /// Gets items.
-        /// </summary>
-        IDictionary<string, object> Items { get; }
-
-        /// <summary>
-        /// Gets item.
-        /// </summary>
-        /// <typeparam name="T">The type of the item.</typeparam>
-        /// <param name="key">The key of the item.</param>
-        /// <returns>The item with the specified key and type, if any, else null.</returns>
-        T Item<T>(string key) where T : class;
-    }
-}

src/Umbraco.Core/Deploy/IFileSource.cs

@@ -1,81 +0,0 @@
-using System.Collections.Generic;
-using System.IO;
-using System.Threading;
-using System.Threading.Tasks;
-
-namespace Umbraco.Core.Deploy
-{
-    /// <summary>
-    /// Represents a file source, ie a mean for a target environment involved in a
-    /// deployment to obtain the content of files being deployed.
-    /// </summary>
-    public interface IFileSource
-    {
-        /// <summary>
-        /// Gets the content of a file as a stream.
-        /// </summary>
-        /// <param name="udi">A file entity identifier.</param>
-        /// <returns>A stream with read access to the file content.</returns>
-        /// <remarks>
-        /// <para>Returns null if no content could be read.</para>
-        /// <para>The caller should ensure that the stream is properly closed/disposed.</para>
-        /// </remarks>
-        Stream GetFileStream(StringUdi udi);
-
-        /// <summary>
-        /// Gets the content of a file as a stream.
-        /// </summary>
-        /// <param name="udi">A file entity identifier.</param>
-        /// <param name="token">A cancellation token.</param>
-        /// <returns>A stream with read access to the file content.</returns>
-        /// <remarks>
-        /// <para>Returns null if no content could be read.</para>
-        /// <para>The caller should ensure that the stream is properly closed/disposed.</para>
-        /// </remarks>
-        Task<Stream> GetFileStreamAsync(StringUdi udi, CancellationToken token);
-
-        /// <summary>
-        /// Gets the content of a file as a string.
-        /// </summary>
-        /// <param name="udi">A file entity identifier.</param>
-        /// <returns>A string containing the file content.</returns>
-        /// <remarks>Returns null if no content could be read.</remarks>
-        string GetFileContent(StringUdi udi);
-
-        /// <summary>
-        /// Gets the content of a file as a string.
-        /// </summary>
-        /// <param name="udi">A file entity identifier.</param>
-        /// <param name="token">A cancellation token.</param>
-        /// <returns>A string containing the file content.</returns>
-        /// <remarks>Returns null if no content could be read.</remarks>
-        Task<string> GetFileContentAsync(StringUdi udi, CancellationToken token);
-
-        /// <summary>
-        /// Gets the length of a file.
-        /// </summary>
-        /// <param name="udi">A file entity identifier.</param>
-        /// <returns>The length of the file, or -1 if the file does not exist.</returns>
-        long GetFileLength(StringUdi udi);
-
-        /// <summary>
-        /// Gets the length of a file.
-        /// </summary>
-        /// <param name="udi">A file entity identifier.</param>
-        /// <param name="token">A cancellation token.</param>
-        /// <returns>The length of the file, or -1 if the file does not exist.</returns>
-        Task<long> GetFileLengthAsync(StringUdi udi, CancellationToken token);
-
-        // fixme - doc
-        void GetFiles(IEnumerable<StringUdi> udis, IFileStore fileStore);
-
-        Task GetFilesAsync(IEnumerable<StringUdi> udis, IFileStore fileStore, CancellationToken token);
-
-        ///// <summary>
-        ///// Gets the content of a file as a bytes array.
-        ///// </summary>
-        ///// <param name="Udi">A file entity identifier.</param>
-        ///// <returns>A byte array containing the file content.</returns>
-        //byte[] GetFileBytes(StringUdi Udi);
-    }
-}

src/Umbraco.Core/Deploy/IFileStore.cs

@@ -1,9 +0,0 @@
-using System.IO;
-
-namespace Umbraco.Core.Deploy
-{
-    public interface IFileStore
-    {
-        void SaveStream(StringUdi udi, Stream stream);
-    }
-}

src/Umbraco.Core/Deploy/IGridCellValueConnector.cs

@@ -1,41 +0,0 @@
-using System.Collections.Generic;
-using Umbraco.Core.Models;
-
-namespace Umbraco.Core.Deploy
-{
-    /// <summary>
-    /// Defines methods that can convert a grid cell value to / from an environment-agnostic string.
-    /// </summary>
-    /// <remarks>Grid cell values may contain values such as content identifiers, that would be local
-    /// to one environment, and need to be converted in order to be deployed.</remarks>
-    public interface IGridCellValueConnector
-    {
-        /// <summary>
-        /// Gets a value indicating whether the connector supports a specified grid editor alias.
-        /// </summary>
-        /// <param name="alias">The grid editor alias.</param>
-        /// <remarks>A value indicating whether the connector supports the grid editor alias.</remarks>
-        /// <remarks>Note that <paramref name="alias" /> can be string.Empty to indicate the "default" connector.</remarks>
-        bool IsConnector(string alias);
-
-        /// <summary>
-        /// Gets the value to be deployed from the control value as a string.
-        /// </summary>
-        /// <param name="gridControl">The control containing the value.</param>
-        /// <param name="property">The property where the control is located. Do not modify - only used for context</param>
-        /// <param name="dependencies">The dependencies of the property.</param>
-        /// <returns>The grid cell value to be deployed.</returns>
-        /// <remarks>Note that </remarks>
-        string GetValue(GridValue.GridControl gridControl, Property property, ICollection<ArtifactDependency> dependencies);
-
-        /// <summary>
-        /// Allows you to modify the value of a control being deployed.
-        /// </summary>
-        /// <param name="gridControl">The control being deployed.</param>
-        /// <param name="property">The property where the <paramref name="gridControl"/> is located. Do not modify - only used for context.</param>
-        /// <remarks>Follows the pattern of the property value connectors (<see cref="IValueConnector"/>). The SetValue method is used to modify the value of the <paramref name="gridControl"/>.</remarks>
-        /// <remarks>Note that only the <paramref name="gridControl"/> value should be modified - not the <paramref name="property"/>.</remarks>
-        /// <remarks>The <paramref name="property"/> should only be used to assist with context data relevant when setting the <paramref name="gridControl"/> value.</remarks>
-        void SetValue(GridValue.GridControl gridControl, Property property);
-    }
-}

src/Umbraco.Core/Deploy/IImageSourceParser.cs

@@ -1,27 +0,0 @@
-using System.Collections.Generic;
-
-namespace Umbraco.Core.Deploy
-{
-    /// <summary>
-    /// Provides methods to parse image tag sources in property values.
-    /// </summary>
-    public interface IImageSourceParser
-    {
-        /// <summary>
-        /// Parses an Umbraco property value and produces an artifact property value.
-        /// </summary>
-        /// <param name="value">The property value.</param>
-        /// <param name="dependencies">A list of dependencies.</param>
-        /// <returns>The parsed value.</returns>
-        /// <remarks>Turns src="/media/..." into src="umb://media/..." and adds the corresponding udi to the dependencies.</remarks>
-        string ToArtifact(string value, ICollection<Udi> dependencies);
-
-        /// <summary>
-        /// Parses an artifact property value and produces an Umbraco property value.
-        /// </summary>
-        /// <param name="value">The artifact property value.</param>
-        /// <returns>The parsed value.</returns>
-        /// <remarks>Turns umb://media/... into /media/....</remarks>
-        string FromArtifact(string value);
-    }
-}

src/Umbraco.Core/Deploy/ILocalLinkParser.cs

@@ -1,27 +0,0 @@
-using System.Collections.Generic;
-
-namespace Umbraco.Core.Deploy
-{
-    /// <summary>
-    /// Provides methods to parse local link tags in property values.
-    /// </summary>
-    public interface ILocalLinkParser
-    {
-        /// <summary>
-        /// Parses an Umbraco property value and produces an artifact property value.
-        /// </summary>
-        /// <param name="value">The property value.</param>
-        /// <param name="dependencies">A list of dependencies.</param>
-        /// <returns>The parsed value.</returns>
-        /// <remarks>Turns {{localLink:1234}} into {{localLink:umb://{type}/{id}}} and adds the corresponding udi to the dependencies.</remarks>
-        string ToArtifact(string value, ICollection<Udi> dependencies);
-
-        /// <summary>
-        /// Parses an artifact property value and produces an Umbraco property value.
-        /// </summary>
-        /// <param name="value">The artifact property value.</param>
-        /// <returns>The parsed value.</returns>
-        /// <remarks>Turns {{localLink:umb://{type}/{id}}} into {{localLink:1234}}.</remarks>
-        string FromArtifact(string value);
-    }
-}

src/Umbraco.Core/Deploy/IMacroParser.cs

@@ -1,32 +0,0 @@
-using System.Collections.Generic;
-
-namespace Umbraco.Core.Deploy
-{
-    public interface IMacroParser
-    {
-        /// <summary>
-        /// Parses an Umbraco property value and produces an artifact property value.
-        /// </summary>
-        /// <param name="value">Property value.</param>
-        /// <param name="dependencies">A list of dependencies.</param>
-        /// <returns>Parsed value.</returns>
-        string ToArtifact(string value, ICollection<Udi> dependencies);
-
-        /// <summary>
-        /// Parses an artifact property value and produces an Umbraco property value.
-        /// </summary>
-        /// <param name="value">Artifact property value.</param>
-        /// <returns>Parsed value.</returns>
-        string FromArtifact(string value);
-
-        /// <summary>
-        /// Tries to replace the value of the attribute/parameter with a value containing a converted identifier.
-        /// </summary>
-        /// <param name="value">Value to attempt to convert</param>
-        /// <param name="editorAlias">Alias of the editor used for the parameter</param>
-        /// <param name="dependencies">Collection to add dependencies to when performing ToArtifact</param>
-        /// <param name="direction">Indicates which action is being performed (to or from artifact)</param>
-        /// <returns>Value with converted identifiers</returns>
-        string ReplaceAttributeValue(string value, string editorAlias, ICollection<Udi> dependencies, Direction direction);
-    }
-}

src/Umbraco.Core/Deploy/IPreValueConnector.cs

@@ -1,32 +0,0 @@
-using System.Collections.Generic;
-
-namespace Umbraco.Core.Deploy
-{
-    /// <summary>
-    /// Defines methods that can convert a preValue to / from an environment-agnostic string.
-    /// </summary>
-    /// <remarks>PreValues may contain values such as content identifiers, that would be local
-    /// to one environment, and need to be converted in order to be deployed.</remarks>
-    public interface IPreValueConnector
-    {
-        /// <summary>
-        /// Gets the property editor aliases that the value converter supports by default.
-        /// </summary>
-        IEnumerable<string> PropertyEditorAliases { get; }
-
-        /// <summary>
-        /// Gets the environment-agnostic preValues corresponding to environment-specific preValues.
-        /// </summary>
-        /// <param name="preValues">The environment-specific preValues.</param>
-        /// <param name="dependencies">The dependencies.</param>
-        /// <returns></returns>
-        IDictionary<string, string> ConvertToDeploy(IDictionary<string, string> preValues, ICollection<ArtifactDependency> dependencies);
-
-        /// <summary>
-        /// Gets the environment-specific preValues corresponding to environment-agnostic preValues.
-        /// </summary>
-        /// <param name="preValues">The environment-agnostic preValues.</param>
-        /// <returns></returns>
-        IDictionary<string, string> ConvertToLocalEnvironment(IDictionary<string, string> preValues);
-    }
-}

src/Umbraco.Core/Deploy/IPrettyArtifact.cs

@@ -1,8 +0,0 @@
-namespace Umbraco.Core.Deploy
-{
-    public interface IPrettyArtifact
-    {
-        string Name { get; }
-        string Alias { get; }
-    }
-}

src/Umbraco.Core/Deploy/IServiceConnector.cs

@@ -1,86 +0,0 @@
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using Umbraco.Core;
-
-namespace Umbraco.Core.Deploy
-{
-    /// <summary>
-    /// Connects to an Umbraco service.
-    /// </summary>
-    public interface IServiceConnector
-    {
-        /// <summary>
-        /// Gets an artifact.
-        /// </summary>
-        /// <param name="udi">The entity identifier of the artifact.</param>
-        /// <returns>The corresponding artifact, or null.</returns>
-        IArtifact GetArtifact(Udi udi);
-
-        /// <summary>
-        /// Gets an artifact.
-        /// </summary>
-        /// <param name="entity">The entity.</param>
-        /// <returns>The corresponding artifact.</returns>
-        IArtifact GetArtifact(object entity);
-
-        /// <summary>
-        /// Initializes processing for an artifact.
-        /// </summary>
-        /// <param name="art">The artifact.</param>
-        /// <param name="context">The deploy context.</param>
-        /// <returns>The mapped artifact.</returns>
-        ArtifactDeployState ProcessInit(IArtifact art, IDeployContext context);
-
-        /// <summary>
-        /// Processes an artifact.
-        /// </summary>
-        /// <param name="dart">The mapped artifact.</param>
-        /// <param name="context">The deploy context.</param>
-        /// <param name="pass">The processing pass number.</param>
-        void Process(ArtifactDeployState dart, IDeployContext context, int pass);
-
-        /// <summary>
-        /// Explodes a range into udis.
-        /// </summary>
-        /// <param name="range">The range.</param>
-        /// <param name="udis">The list of udis where to add the new udis.</param>
-        /// <remarks>Also, it's cool to have a method named Explode. Kaboom!</remarks>
-        void Explode(UdiRange range, List<Udi> udis);
-
-        /// <summary>
-        /// Gets a named range for a specified udi and selector.
-        /// </summary>
-        /// <param name="udi">The udi.</param>
-        /// <param name="selector">The selector.</param>
-        /// <returns>The named range for the specified udi and selector.</returns>
-        NamedUdiRange GetRange(Udi udi, string selector);
-
-        /// <summary>
-        /// Gets a named range for specified entity type, identifier and selector.
-        /// </summary>
-        /// <param name="entityType">The entity type.</param>
-        /// <param name="sid">The identifier.</param>
-        /// <param name="selector">The selector.</param>
-        /// <returns>The named range for the specified entity type, identifier and selector.</returns>
-        /// <remarks>
-        /// <para>This is temporary. At least we thought it would be, in sept. 2016. What day is it now?</para>
-        /// <para>At the moment our UI has a hard time returning proper udis, mainly because Core's tree do
-        /// not manage guids but only ints... so we have to provide a way to support it. The string id here
-        /// can be either a real string (for string udis) or an "integer as a string", using the value "-1" to
-        /// indicate the "root" i.e. an open udi.</para>
-        /// </remarks>
-        NamedUdiRange GetRange(string entityType, string sid, string selector);
-
-        /// <summary>
-        /// Compares two artifacts.
-        /// </summary>
-        /// <param name="art1">The first artifact.</param>
-        /// <param name="art2">The second artifact.</param>
-        /// <param name="differences">A collection of differences to append to, if not null.</param>
-        /// <returns>A boolean value indicating whether the artifacts are identical.</returns>
-        /// <remarks>ServiceConnectorBase{TArtifact} provides a very basic default implementation.</remarks>
-        bool Compare(IArtifact art1, IArtifact art2, ICollection<Difference> differences = null);
-    }
-
-}

src/Umbraco.Core/Deploy/IValueConnector.cs

@@ -1,35 +0,0 @@
-using System.Collections.Generic;
-using Umbraco.Core.Models;
-
-namespace Umbraco.Core.Deploy
-{
-    /// <summary>
-    /// Defines methods that can convert a property value to / from an environment-agnostic string.
-    /// </summary>
-    /// <remarks>Property values may contain values such as content identifiers, that would be local
-    /// to one environment, and need to be converted in order to be deployed. Connectors also deal
-    /// with serializing to / from string.</remarks>
-    public interface IValueConnector
-    {
-        /// <summary>
-        /// Gets the property editor aliases that the value converter supports by default.
-        /// </summary>
-        IEnumerable<string> PropertyEditorAliases { get; }
-
-        /// <summary>
-        /// Gets the deploy property corresponding to a content property.
-        /// </summary>
-        /// <param name="property">The content property.</param>
-        /// <param name="dependencies">The content dependencies.</param>
-        /// <returns>The deploy property value.</returns>
-        string GetValue(Property property, ICollection<ArtifactDependency> dependencies);
-
-        /// <summary>
-        /// Sets a content property value using a deploy property.
-        /// </summary>
-        /// <param name="content">The content item.</param>
-        /// <param name="alias">The property alias.</param>
-        /// <param name="value">The deploy property value.</param>
-        void SetValue(IContentBase content, string alias, string value);
-    }
-}

src/Umbraco.Core/Events/MigrationEventArgs.cs

@@ -31,13 +31,13 @@ namespace Umbraco.Core.Events
         [Obsolete("Use constructor accepting a product name instead.")]
         [EditorBrowsable(EditorBrowsableState.Never)]
         public MigrationEventArgs(IList<IMigration> eventObject, SemVersion configuredVersion, SemVersion targetVersion, bool canCancel)
-            : this(eventObject, null, configuredVersion, targetVersion, Constants.System.UmbracoMigrationName, canCancel)
+            : this(eventObject, null, configuredVersion, targetVersion, GlobalSettings.UmbracoMigrationName, canCancel)
         { }
 
         [Obsolete("Use constructor accepting SemVersion instances and a product name instead.")]
         [EditorBrowsable(EditorBrowsableState.Never)]
         public MigrationEventArgs(IList<IMigration> eventObject, Version configuredVersion, Version targetVersion, bool canCancel)
-			: this(eventObject, null, new SemVersion(configuredVersion), new SemVersion(targetVersion), Constants.System.UmbracoMigrationName, canCancel)
+			: this(eventObject, null, new SemVersion(configuredVersion), new SemVersion(targetVersion), GlobalSettings.UmbracoMigrationName, canCancel)
          { }
 
         /// <summary>
@@ -74,7 +74,7 @@ namespace Umbraco.Core.Events
             MigrationContext = migrationContext;
             ConfiguredSemVersion = configuredVersion;
             TargetSemVersion = targetVersion;
-            ProductName = Constants.System.UmbracoMigrationName;
+            ProductName = GlobalSettings.UmbracoMigrationName;
         }
 
         /// <summary>
@@ -97,13 +97,13 @@ namespace Umbraco.Core.Events
         [Obsolete("Use constructor accepting a product name instead.")]
         [EditorBrowsable(EditorBrowsableState.Never)]
         public MigrationEventArgs(IList<IMigration> eventObject, SemVersion configuredVersion, SemVersion targetVersion)
-            : this(eventObject, null, configuredVersion, targetVersion, Constants.System.UmbracoMigrationName, false)
+            : this(eventObject, null, configuredVersion, targetVersion, GlobalSettings.UmbracoMigrationName, false)
         { }
 
         [Obsolete("Use constructor accepting SemVersion instances and a product name instead.")]
         [EditorBrowsable(EditorBrowsableState.Never)]
         public MigrationEventArgs(IList<IMigration> eventObject, Version configuredVersion, Version targetVersion)
-			: this(eventObject, null, new SemVersion(configuredVersion), new SemVersion(targetVersion), Constants.System.UmbracoMigrationName, false)
+			: this(eventObject, null, new SemVersion(configuredVersion), new SemVersion(targetVersion), GlobalSettings.UmbracoMigrationName, false)
 		{ }
 
 		/// <summary>

src/Umbraco.Core/GuidUdi.cs

@@ -1,83 +0,0 @@
-using System;
-
-namespace Umbraco.Core
-{
-    /// <summary>
-    /// Represents a guid-based entity identifier.
-    /// </summary>
-    public class GuidUdi : Udi
-    {
-        /// <summary>
-        /// The guid part of the identifier.
-        /// </summary>
-        public Guid Guid { get; private set; }
-
-        /// <summary>
-        /// Initializes a new instance of the GuidUdi class with an entity type and a guid.
-        /// </summary>
-        /// <param name="entityType">The entity type part of the udi.</param>
-        /// <param name="guid">The guid part of the udi.</param>
-        public GuidUdi(string entityType, Guid guid)
-            : base(entityType, "umb://" + entityType + "/" + guid.ToString("N"))
-        {
-            Guid = guid;
-        }
-
-        /// <summary>
-        /// Initializes a new instance of the GuidUdi class with an uri value.
-        /// </summary>
-        /// <param name="uriValue">The uri value of the udi.</param>
-        public GuidUdi(Uri uriValue)
-            : base(uriValue)
-        {
-            Guid = Guid.Parse(uriValue.AbsolutePath.TrimStart('/'));
-        }
-
-        /// <summary>
-        /// Converts the string representation of an entity identifier into the equivalent GuidUdi instance.
-        /// </summary>
-        /// <param name="s">The string to convert.</param>
-        /// <returns>A GuidUdi instance that contains the value that was parsed.</returns>
-        public new static GuidUdi Parse(string s)
-        {
-            var udi = Udi.Parse(s);
-            if (!(udi is GuidUdi))
-                throw new FormatException("String \"" + s + "\" is not a guid entity id.");
-            return (GuidUdi)udi;
-        }
-
-        public static bool TryParse(string s, out GuidUdi udi)
-        {
-            Udi tmp;
-            udi = null;
-            if (!TryParse(s, out tmp)) return false;
-            udi = tmp as GuidUdi;
-            return udi != null;
-        }
-
-        public override bool Equals(object obj)
-        {
-            var other = obj as GuidUdi;
-            if (other == null) return false;
-            return EntityType == other.EntityType && Guid == other.Guid;
-        }
-
-        public override int GetHashCode()
-        {
-            return base.GetHashCode();
-        }
-
-        /// <inheritdoc/>
-        public override bool IsRoot
-        {
-            get { return Guid == Guid.Empty; }
-        }
-
-        /// <inheritdoc/>
-        public GuidUdi EnsureClosed()
-        {
-            base.EnsureNotRoot();
-            return this;
-        }
-    }
-}

src/Umbraco.Core/IO/FileSystemExtensions.cs

@@ -38,12 +38,13 @@ namespace Umbraco.Core.IO
         }
 
         // GetSize has been added to IFileSystem2 but not IFileSystem
+        // this is implementing GetSize for IFileSystem, the old way
         public static long GetSize(this IFileSystem fs, string path)
         {
-            var fs2 = fs as IFileSystem2;
-            if (fs2 != null) return fs2.GetSize(path);
+            // if we reach this point, fs is *not* IFileSystem2
+            // so it's not FileSystemWrapper nor shadow nor anything we know
+            // so... fall back to the old & inefficient method
 
-            // this is implementing GetSize for IFileSystem, the old way
             using (var file = fs.OpenFile(path))
             {
                 return file.Length;

src/Umbraco.Core/Logging/ImageProcessorLogger.cs

@@ -1,9 +1,9 @@
-using System;
-using System.Runtime.CompilerServices;
-using ImageProcessor.Common.Exceptions;
+namespace Umbraco.Core.Logging
+{
+    using System;
+    using System.Runtime.CompilerServices;
 
-namespace Umbraco.Core.Logging
-{   
+    using ImageProcessor.Common.Exceptions;
 
     /// <summary>
     /// A logger for explicitly logging ImageProcessor exceptions.

src/Umbraco.Core/Models/ContentExtensions.cs

@@ -394,7 +394,8 @@ namespace Umbraco.Core.Models
             return content.Properties
                           .Where(property => propertyGroup.PropertyTypes
                                                           .Select(propertyType => propertyType.Id)
-                                                          .Contains(property.PropertyTypeId));
+                                                          .Contains(property.PropertyTypeId))
+                          .OrderBy(x => x.PropertyType.SortOrder);
         }
 
         /// <summary>

src/Umbraco.Core/Models/GridValue.cs

@@ -1,85 +0,0 @@
-using System;
-using System.Collections.Generic;
-using Newtonsoft.Json;
-using Newtonsoft.Json.Linq;
-
-namespace Umbraco.Core.Models
-{
-    /// <summary>
-    /// A model representing the value saved for the grid
-    /// </summary>
-    public class GridValue
-    {
-        [JsonProperty("name")]
-        public string Name { get; set; }
-
-        [JsonProperty("sections")]
-        public IEnumerable<GridSection> Sections { get; set; }
-
-        public class GridSection
-        {
-            [JsonProperty("grid")]
-            public string Grid { get; set; }
-
-            [JsonProperty("rows")]
-            public IEnumerable<GridRow> Rows { get; set; }
-        }
-
-        public class GridRow
-        {
-            [JsonProperty("name")]
-            public string Name { get; set; }
-
-            [JsonProperty("id")]
-            public Guid Id { get; set; }
-
-            [JsonProperty("areas")]
-            public IEnumerable<GridArea> Areas { get; set; }
-
-            [JsonProperty("styles")]
-            public JToken Styles { get; set; }
-
-            [JsonProperty("config")]
-            public JToken Config { get; set; }
-        }
-
-        public class GridArea
-        {
-            [JsonProperty("grid")]
-            public string Grid { get; set; }
-
-            [JsonProperty("controls")]
-            public IEnumerable<GridControl> Controls { get; set; }
-
-            [JsonProperty("styles")]
-            public JToken Styles { get; set; }
-
-            [JsonProperty("config")]
-            public JToken Config { get; set; }
-        }
-
-        public class GridControl
-        {
-            [JsonProperty("value")]
-            public JToken Value { get; set; }
-
-            [JsonProperty("editor")]
-            public GridEditor Editor { get; set; }
-
-            [JsonProperty("styles")]
-            public JToken Styles { get; set; }
-
-            [JsonProperty("config")]
-            public JToken Config { get; set; }
-        }
-
-        public class GridEditor
-        {
-            [JsonProperty("alias")]
-            public string Alias { get; set; }
-
-            [JsonProperty("view")]
-            public string View { get; set; }
-        }
-    }
-}

src/Umbraco.Core/Models/IMediaType.cs

@@ -4,7 +4,7 @@ namespace Umbraco.Core.Models
 {
     /// <summary>
     /// Defines a ContentType, which Media is based on
-    /// </summary>
+    /// </summary
     public interface IMediaType : IContentTypeComposition
     {
 

src/Umbraco.Core/Models/Rdbms/RelationTypeDto.cs

@@ -15,10 +15,6 @@ namespace Umbraco.Core.Models.Rdbms
         [PrimaryKeyColumn(IdentitySeed = NodeIdSeed)]
         public int Id { get; set; }
 
-        [Column("typeUniqueId")]
-        [Index(IndexTypes.UniqueNonClustered, Name = "IX_umbracoRelationType_UniqueId")]
-        public Guid UniqueId { get; set; }
-
         [Column("dual")]
         public bool Dual { get; set; }
 

src/Umbraco.Core/Models/UmbracoEntityExtensions.cs

@@ -1,117 +1,15 @@
 using System;
 using System.Collections.Generic;
-using System.IO;
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
 using System.Web.UI.WebControls;
-using Umbraco.Core.Logging;
 using Umbraco.Core.Models.EntityBase;
-using Umbraco.Core.Models.Rdbms;
 
 namespace Umbraco.Core.Models
 {
     internal static class UmbracoEntityExtensions
     {
-        /// <summary>
-        /// Does a quick check on the entity's set path to ensure that it's valid and consistent
-        /// </summary>
-        /// <param name="entity"></param>
-        /// <returns></returns>
-        public static void ValidatePathWithException(this NodeDto entity)
-        {
-            //don't validate if it's empty and it has no id
-            if (entity.NodeId == default(int) && entity.Path.IsNullOrWhiteSpace())
-                return;
-
-            if (entity.Path.IsNullOrWhiteSpace())
-                throw new InvalidDataException(string.Format("The content item {0} has an empty path: {1} with parentID: {2}", entity.NodeId, entity.Path, entity.ParentId));
-
-            var pathParts = entity.Path.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
-            if (pathParts.Length < 2)
-            {
-                //a path cannot be less than 2 parts, at a minimum it must be root (-1) and it's own id
-                throw new InvalidDataException(string.Format("The content item {0} has an invalid path: {1} with parentID: {2}", entity.NodeId, entity.Path, entity.ParentId));
-            }
-
-            if (entity.ParentId != default(int) && pathParts[pathParts.Length - 2] != entity.ParentId.ToInvariantString())
-            {
-                //the 2nd last id in the path must be it's parent id
-                throw new InvalidDataException(string.Format("The content item {0} has an invalid path: {1} with parentID: {2}", entity.NodeId, entity.Path, entity.ParentId));
-            }
-        }
-
-        /// <summary>
-        /// Does a quick check on the entity's set path to ensure that it's valid and consistent
-        /// </summary>
-        /// <param name="entity"></param>
-        /// <returns></returns>
-        public static bool ValidatePath(this IUmbracoEntity entity)
-        {
-            //don't validate if it's empty and it has no id
-            if (entity.HasIdentity == false && entity.Path.IsNullOrWhiteSpace())
-                return true;
-
-            if (entity.Path.IsNullOrWhiteSpace())
-                return false;
-
-            var pathParts = entity.Path.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
-            if (pathParts.Length < 2)
-            {
-                //a path cannot be less than 2 parts, at a minimum it must be root (-1) and it's own id
-                return false;
-            }
-
-            if (entity.ParentId != default(int) && pathParts[pathParts.Length - 2] != entity.ParentId.ToInvariantString())
-            {
-                //the 2nd last id in the path must be it's parent id
-                return false;
-            }
-
-            return true;
-        }
-
-        /// <summary>
-        /// This will validate the entity's path and if it's invalid it will fix it, if fixing is required it will recursively 
-        /// check and fix all ancestors if required.
-        /// </summary>
-        /// <param name="entity"></param>
-        /// <param name="logger"></param>
-        /// <param name="getParent">A callback specified to retrieve the parent entity of the entity</param>
-        /// <param name="update">A callback specified to update a fixed entity</param>
-        public static void EnsureValidPath<T>(this T entity, 
-            ILogger logger, 
-            Func<T, T> getParent,
-            Action<T> update)
-            where T: IUmbracoEntity
-        {
-            if (entity.HasIdentity == false)
-                throw new InvalidOperationException("Could not ensure the entity path, the entity has not been assigned an identity");
-
-            if (entity.ValidatePath() == false)
-            {
-                logger.Warn(typeof(UmbracoEntityExtensions), string.Format("The content item {0} has an invalid path: {1} with parentID: {2}", entity.Id, entity.Path, entity.ParentId));
-                if (entity.ParentId == -1)
-                {
-                    entity.Path = string.Concat("-1,", entity.Id);
-                    //path changed, update it
-                    update(entity);
-                }
-                else
-                {
-                    var parent = getParent(entity);
-                    if (parent == null)
-                        throw new NullReferenceException("Could not ensure path for entity " + entity.Id + " could not resolve it's parent " + entity.ParentId);
-
-                    //the parent must also be valid!
-                    parent.EnsureValidPath(logger, getParent, update);
-
-                    entity.Path = string.Concat(parent.Path, ",", entity.Id);
-                    //path changed, update it
-                    update(entity);
-                }
-            }
-        }
 
         public static bool HasChildren(this IUmbracoEntity entity)
         {

src/Umbraco.Core/Models/UmbracoObjectTypes.cs

@@ -1,6 +1,4 @@
-using System;
-using System.ComponentModel;
-using Umbraco.Core.CodeAnnotations;
+using Umbraco.Core.CodeAnnotations;
 
 namespace Umbraco.Core.Models
 {
@@ -19,8 +17,6 @@ namespace Umbraco.Core.Models
         /// </summary>
         [UmbracoObjectType(Constants.ObjectTypes.ContentItemType)]
         [FriendlyName("Content Item Type")]
-        [Obsolete("This is not used and will be removed in future versions")]
-        [EditorBrowsable(EditorBrowsableState.Never)]
         ContentItemType,
 
         /// <summary>
@@ -71,8 +67,6 @@ namespace Umbraco.Core.Models
         /// </summary>
         [UmbracoObjectType(Constants.ObjectTypes.ContentItem)]
         [FriendlyName("Content Item")]
-        [Obsolete("This is not used and will be removed in future versions")]
-        [EditorBrowsable(EditorBrowsableState.Never)]
         ContentItem,
 
         /// <summary>
@@ -136,13 +130,8 @@ namespace Umbraco.Core.Models
         /// </summary>
         [UmbracoObjectType(Constants.ObjectTypes.DataTypeContainer)]
         [FriendlyName("Data Type Container")]
-        DataTypeContainer,
+        DataTypeContainer
+
 
-        /// <summary>
-        /// Relation type
-        /// </summary>
-        [UmbracoObjectType(Constants.ObjectTypes.RelationType)]
-        [FriendlyName("Relation Type")]
-        RelationType
     }
 }

src/Umbraco.Core/NamedUdiRange.cs

@@ -1,34 +0,0 @@
-namespace Umbraco.Core
-{
-    /// <summary>
-    /// Represents a <see cref="UdiRange"/> complemented with a name.
-    /// </summary>
-    public class NamedUdiRange : UdiRange
-    {
-        /// <summary>
-        /// Initializes a new instance of the <see cref="NamedUdiRange"/> class  with a <see cref="Udi"/> and an optional selector.
-        /// </summary>
-        /// <param name="udi">A <see cref="Udi"/>.</param>
-        /// <param name="selector">An optional selector.</param>
-        public NamedUdiRange(Udi udi, string selector = Constants.DeploySelector.This)
-            : base(udi, selector)
-        { }
-
-        /// <summary>
-        /// Initializes a new instance of the <see cref="NamedUdiRange"/> class  with a <see cref="Udi"/>, a name, and an optional selector.
-        /// </summary>
-        /// <param name="udi">A <see cref="Udi"/>.</param>
-        /// <param name="name">A name.</param>
-        /// <param name="selector">An optional selector.</param>
-        public NamedUdiRange(Udi udi, string name, string selector = Constants.DeploySelector.This)
-            : base(udi, selector)
-        {
-            Name = name;
-        }
-
-        /// <summary>
-        /// Gets or sets the name of the range.
-        /// </summary>
-        public string Name { get; set; }
-    }
-}

src/Umbraco.Core/ObjectExtensions.cs

@@ -468,19 +468,19 @@ namespace Umbraco.Core
 		/// <param name="o"></param>
 		/// <param name="ignoreProperties"></param>
 		/// <returns></returns>
-        public static IDictionary<string, TVal> ToDictionary<T, TProperty, TVal>(this T o,
+        internal static IDictionary<string, TVal> ToDictionary<T, TProperty, TVal>(this T o,
 																				 params Expression<Func<T, TProperty>>[] ignoreProperties)
 		{
 			return o.ToDictionary<TVal>(ignoreProperties.Select(e => o.GetPropertyInfo(e)).Select(propInfo => propInfo.Name).ToArray());
 		}
 
-        /// <summary>
-        /// Turns object into dictionary
-        /// </summary>
-        /// <param name="o"></param>
-        /// <param name="ignoreProperties">Properties to ignore</param>
-        /// <returns></returns>
-        public static IDictionary<string, TVal> ToDictionary<TVal>(this object o, params string[] ignoreProperties)
+		/// <summary>
+		/// Turns object into dictionary
+		/// </summary>
+		/// <param name="o"></param>
+		/// <param name="ignoreProperties">Properties to ignore</param>
+		/// <returns></returns>
+		internal static IDictionary<string, TVal> ToDictionary<TVal>(this object o, params string[] ignoreProperties)
 		{
 			if (o != null)
 			{

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

@@ -27,15 +27,15 @@ namespace Umbraco.Core.Persistence.Factories
 
         #region Implementation of IEntityFactory<IContent,DocumentDto>
 
-        public static IContent BuildEntity(DocumentDto dto, IContentType contentType)
+        public IContent BuildEntity(DocumentDto dto)
         {
-            var content = new Content(dto.Text, dto.ContentVersionDto.ContentDto.NodeDto.ParentId, contentType);
+            var content = new Content(dto.Text, dto.ContentVersionDto.ContentDto.NodeDto.ParentId, _contentType);
 
             try
             {
                 content.DisableChangeTracking();
 
-                content.Id = dto.NodeId;
+                content.Id = _id;
                 content.Key = dto.ContentVersionDto.ContentDto.NodeDto.UniqueId;
                 content.Name = dto.Text;
                 content.NodeName = dto.ContentVersionDto.ContentDto.NodeDto.Text;
@@ -49,8 +49,8 @@ namespace Umbraco.Core.Persistence.Factories
                 content.Published = dto.Published;
                 content.CreateDate = dto.ContentVersionDto.ContentDto.NodeDto.CreateDate;
                 content.UpdateDate = dto.ContentVersionDto.VersionDate;
-                content.ExpireDate = dto.ExpiresDate.HasValue ? dto.ExpiresDate.Value : (DateTime?)null;
-                content.ReleaseDate = dto.ReleaseDate.HasValue ? dto.ReleaseDate.Value : (DateTime?)null;
+                content.ExpireDate = dto.ExpiresDate.HasValue ? dto.ExpiresDate.Value : (DateTime?) null;
+                content.ReleaseDate = dto.ReleaseDate.HasValue ? dto.ReleaseDate.Value : (DateTime?) null;
                 content.Version = dto.ContentVersionDto.VersionId;
                 content.PublishedState = dto.Published ? PublishedState.Published : PublishedState.Unpublished;
                 content.PublishedVersionGuid = dto.DocumentPublishedReadOnlyDto == null ? default(Guid) : dto.DocumentPublishedReadOnlyDto.VersionId;
@@ -64,13 +64,6 @@ namespace Umbraco.Core.Persistence.Factories
             {
                 content.EnableChangeTracking();
             }
-
-        }
-
-        [Obsolete("Use the static BuildEntity instead so we don't have to allocate one of these objects everytime we want to map values")]
-        public IContent BuildEntity(DocumentDto dto)
-        {
-            return BuildEntity(dto, _contentType);
         }
 
         public DocumentDto BuildDto(IContent entity)

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

@@ -27,15 +27,15 @@ namespace Umbraco.Core.Persistence.Factories
 
         #region Implementation of IEntityFactory<IMedia,ContentVersionDto>
 
-        public static IMedia BuildEntity(ContentVersionDto dto, IMediaType contentType)
+        public IMedia BuildEntity(ContentVersionDto dto)
         {
-            var media = new Models.Media(dto.ContentDto.NodeDto.Text, dto.ContentDto.NodeDto.ParentId, contentType);
+            var media = new Models.Media(dto.ContentDto.NodeDto.Text, dto.ContentDto.NodeDto.ParentId, _contentType);
 
             try
             {
                 media.DisableChangeTracking();
 
-                media.Id = dto.NodeId;
+                media.Id = _id;
                 media.Key = dto.ContentDto.NodeDto.UniqueId;
                 media.Path = dto.ContentDto.NodeDto.Path;
                 media.CreatorId = dto.ContentDto.NodeDto.UserId.Value;
@@ -55,13 +55,6 @@ namespace Umbraco.Core.Persistence.Factories
             {
                 media.EnableChangeTracking();
             }
-
-        }
-
-        [Obsolete("Use the static BuildEntity instead so we don't have to allocate one of these objects everytime we want to map values")]
-        public IMedia BuildEntity(ContentVersionDto dto)
-        {
-            return BuildEntity(dto, _contentType);
         }
 
         public ContentVersionDto BuildDto(IMedia entity)

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

@@ -30,11 +30,11 @@ namespace Umbraco.Core.Persistence.Factories
             _updateDate = updateDate;
         }
 
-        public static IEnumerable<Property> BuildEntity(IReadOnlyCollection<PropertyDataDto> dtos, PropertyType[] compositionTypeProperties, DateTime createDate, DateTime updateDate)
+        public IEnumerable<Property> BuildEntity(PropertyDataDto[] dtos)
         {
             var properties = new List<Property>();
 
-            foreach (var propertyType in compositionTypeProperties)
+            foreach (var propertyType in _compositionTypeProperties)
             {
                 var propertyDataDto = dtos.LastOrDefault(x => x.PropertyTypeId == propertyType.Id);
                 var property = propertyDataDto == null
@@ -47,8 +47,8 @@ namespace Umbraco.Core.Persistence.Factories
                     //on initial construction we don't want to have dirty properties tracked
                     property.DisableChangeTracking();
 
-                    property.CreateDate = createDate;
-                    property.UpdateDate = updateDate;
+                    property.CreateDate = _createDate;
+                    property.UpdateDate = _updateDate;
                     // http://issues.umbraco.org/issue/U4-1946
                     property.ResetDirtyProperties(false);
                     properties.Add(property);
@@ -57,18 +57,12 @@ namespace Umbraco.Core.Persistence.Factories
                 {
                     property.EnableChangeTracking();
                 }
-
+                
             }
 
             return properties;
         }
 
-        [Obsolete("Use the static method instead, there's no reason to allocate one of these classes everytime we want to map values")]
-        public IEnumerable<Property> BuildEntity(PropertyDataDto[] dtos)
-        {
-            return BuildEntity(dtos, _compositionTypeProperties, _createDate, _updateDate);
-        }
-
         public IEnumerable<PropertyDataDto> BuildDto(IEnumerable<Property> properties)
         {
             var propertyDataDtos = new List<PropertyDataDto>();

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

@@ -16,7 +16,6 @@ namespace Umbraco.Core.Persistence.Factories
                 entity.DisableChangeTracking();
 
                 entity.Id = dto.Id;
-                entity.Key = dto.UniqueId;
                 entity.IsBidirectional = dto.Dual;
                 entity.Name = dto.Name;
 
@@ -39,13 +38,10 @@ namespace Umbraco.Core.Persistence.Factories
                 ChildObjectType = entity.ChildObjectType,
                 Dual = entity.IsBidirectional,
                 Name = entity.Name,
-                ParentObjectType = entity.ParentObjectType,
-                UniqueId = entity.Key
+                ParentObjectType = entity.ParentObjectType
             };
             if (entity.HasIdentity)
-            {
                 dto.Id = entity.Id;
-            }
 
             return dto;
         }

src/Umbraco.Core/Persistence/Migrations/Initial/BaseDataCreation.cs

@@ -292,12 +292,8 @@ namespace Umbraco.Core.Persistence.Migrations.Initial
 
         private void CreateUmbracoRelationTypeData()
         {
-            var relationType = new RelationTypeDto { Id = 1, Alias = Constants.Conventions.RelationTypes.RelateDocumentOnCopyAlias, ChildObjectType = new Guid(Constants.ObjectTypes.Document), ParentObjectType = new Guid(Constants.ObjectTypes.Document), Dual = true, Name = Constants.Conventions.RelationTypes.RelateDocumentOnCopyName };
-            relationType.UniqueId = (relationType.Alias + "____" + relationType.Name).ToGuid();
-            _database.Insert("umbracoRelationType", "id", false, relationType);
-            relationType = new RelationTypeDto { Id = 2, Alias = Constants.Conventions.RelationTypes.RelateParentDocumentOnDeleteAlias, ChildObjectType = new Guid(Constants.ObjectTypes.Document), ParentObjectType = new Guid(Constants.ObjectTypes.Document), Dual = false, Name = Constants.Conventions.RelationTypes.RelateParentDocumentOnDeleteName };
-            relationType.UniqueId = (relationType.Alias + "____" + relationType.Name).ToGuid();
-            _database.Insert("umbracoRelationType", "id", false, relationType);
+            _database.Insert("umbracoRelationType", "id", false, new RelationTypeDto { Id = 1, Alias = Constants.Conventions.RelationTypes.RelateDocumentOnCopyAlias, ChildObjectType = new Guid(Constants.ObjectTypes.Document), ParentObjectType = new Guid(Constants.ObjectTypes.Document), Dual = true, Name = Constants.Conventions.RelationTypes.RelateDocumentOnCopyName });
+            _database.Insert("umbracoRelationType", "id", false, new RelationTypeDto { Id = 2, Alias = Constants.Conventions.RelationTypes.RelateParentDocumentOnDeleteAlias, ChildObjectType = new Guid(Constants.ObjectTypes.Document), ParentObjectType = new Guid(Constants.ObjectTypes.Document), Dual = false, Name = Constants.Conventions.RelationTypes.RelateParentDocumentOnDeleteName });
         }
 
         private void CreateCmsTaskTypeData()
@@ -310,7 +306,7 @@ namespace Umbraco.Core.Persistence.Migrations.Initial
             var dto = new MigrationDto
             {
                 Id = 1,
-                Name = Constants.System.UmbracoMigrationName,
+                Name = GlobalSettings.UmbracoMigrationName,
                 Version = UmbracoVersion.GetSemanticVersion().ToString(),
                 CreateDate = DateTime.Now
             };

src/Umbraco.Core/Persistence/Migrations/Initial/DatabaseSchemaCreation.cs

@@ -12,7 +12,7 @@ namespace Umbraco.Core.Persistence.Migrations.Initial
     /// <summary>
     /// Represents the initial database schema creation by running CreateTable for all DTOs against the db.
     /// </summary>
-    public class DatabaseSchemaCreation
+    internal class DatabaseSchemaCreation
     {
         /// <summary>
         /// Constructor
@@ -345,7 +345,7 @@ namespace Umbraco.Core.Persistence.Migrations.Initial
         /// Raises the <see cref="BeforeCreation"/> event.
         /// </summary>
         /// <param name="e">The <see cref="System.EventArgs"/> instance containing the event data.</param>
-        internal virtual void FireBeforeCreation(DatabaseCreationEventArgs e)
+        protected internal virtual void FireBeforeCreation(DatabaseCreationEventArgs e)
         {
             if (BeforeCreation != null)
             {
@@ -361,7 +361,7 @@ namespace Umbraco.Core.Persistence.Migrations.Initial
         /// Raises the <see cref="AfterCreation"/> event.
         /// </summary>
         /// <param name="e">The <see cref="System.EventArgs"/> instance containing the event data.</param>
-        internal virtual void FireAfterCreation(DatabaseCreationEventArgs e)
+        protected virtual void FireAfterCreation(DatabaseCreationEventArgs e)
         {
             if (AfterCreation != null)
             {

src/Umbraco.Core/Persistence/Migrations/Initial/DatabaseSchemaResult.cs

@@ -47,7 +47,7 @@ namespace Umbraco.Core.Persistence.Migrations.Initial
 
             if (ValidTables.Any(x => x.InvariantEquals("umbracoMigration")))
             {
-                var allMigrations = migrationEntryService.GetAll(Constants.System.UmbracoMigrationName);
+                var allMigrations = migrationEntryService.GetAll(GlobalSettings.UmbracoMigrationName);
                  mostrecent = allMigrations.OrderByDescending(x => x.Version).Select(x => x.Version).FirstOrDefault();
             }
 

src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionFourNineZero/RemoveUmbracoAppConstraints.cs

@@ -6,7 +6,7 @@ using Umbraco.Core.Persistence.SqlSyntax;
 
 namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionFourNineZero
 {
-    [MigrationAttribute("4.9.0", 0, Constants.System.UmbracoMigrationName)]
+    [MigrationAttribute("4.9.0", 0, GlobalSettings.UmbracoMigrationName)]
     public class RemoveUmbracoAppConstraints : MigrationBase
     {
         public RemoveUmbracoAppConstraints(ISqlSyntaxProvider sqlSyntax, ILogger logger) : base(sqlSyntax, logger)

src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionFourOneZero/AddPreviewXmlTable.cs

@@ -5,7 +5,7 @@ using Umbraco.Core.Persistence.SqlSyntax;
 
 namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionFourOneZero
 {
-    [Migration("4.1.0", 0, Constants.System.UmbracoMigrationName)]
+    [Migration("4.1.0", 0, GlobalSettings.UmbracoMigrationName)]
     public class AddPreviewXmlTable : MigrationBase
     {
         public AddPreviewXmlTable(ISqlSyntaxProvider sqlSyntax, ILogger logger)

src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSeven/AddIndexToCmsMacroPropertyTable.cs

@@ -10,7 +10,7 @@ namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSeven
     /// <summary>
     /// Creats a unique index across two columns so we cannot have duplicate property aliases for one macro
     /// </summary>
-    [Migration("7.0.0", 5, Constants.System.UmbracoMigrationName)]
+    [Migration("7.0.0", 5, GlobalSettings.UmbracoMigrationName)]
     public class AddIndexToCmsMacroPropertyTable : MigrationBase
     {
         private readonly bool _skipIndexCheck;

src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSeven/AddIndexToCmsMacroTable.cs

@@ -12,7 +12,7 @@ namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSeven
     /// <summary>
     /// Creates a unique index on the macro alias so we cannot have duplicates by alias
     /// </summary>
-    [Migration("7.0.0", 4, Constants.System.UmbracoMigrationName)]
+    [Migration("7.0.0", 4, GlobalSettings.UmbracoMigrationName)]
     public class AddIndexToCmsMacroTable : MigrationBase
     {
         private readonly bool _forTesting;

src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSeven/AddPropertyEditorAliasColumn.cs

@@ -6,7 +6,7 @@ using Umbraco.Core.Persistence.SqlSyntax;
 namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSeven
 {
 
-    [Migration("7.0.0", 0, Constants.System.UmbracoMigrationName)]
+    [Migration("7.0.0", 0, GlobalSettings.UmbracoMigrationName)]
     public class AddPropertyEditorAliasColumn : MigrationBase
     {
         public AddPropertyEditorAliasColumn(ISqlSyntaxProvider sqlSyntax, ILogger logger) : base(sqlSyntax, logger)

src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSeven/AlterCmsMacroPropertyTable.cs

@@ -17,7 +17,7 @@ namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSeven
     /// needs to be changed to editorAlias, we'll do this by removing the constraint,changing the macroPropertyType to the new 
     /// editorAlias column (and maintaing data so we can reference it)
     /// </summary>
-    [Migration("7.0.0", 6, Constants.System.UmbracoMigrationName)]
+    [Migration("7.0.0", 6, GlobalSettings.UmbracoMigrationName)]
     public class AlterCmsMacroPropertyTable : MigrationBase
     {
         public AlterCmsMacroPropertyTable(ISqlSyntaxProvider sqlSyntax, ILogger logger) : base(sqlSyntax, logger)

src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSeven/AlterTagRelationsTable.cs

@@ -9,7 +9,7 @@ using Umbraco.Core.Persistence.SqlSyntax;
 
 namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSeven
 {
-    [Migration("7.0.0", 8, Constants.System.UmbracoMigrationName)]
+    [Migration("7.0.0", 8, GlobalSettings.UmbracoMigrationName)]
     public class AlterTagRelationsTable : MigrationBase
     {
         public AlterTagRelationsTable(ISqlSyntaxProvider sqlSyntax, ILogger logger) : base(sqlSyntax, logger)

src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSeven/AlterTagsTable.cs

@@ -8,7 +8,7 @@ using Umbraco.Core.Persistence.SqlSyntax;
 
 namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSeven
 {
-    [Migration("7.0.0", 9, Constants.System.UmbracoMigrationName)]
+    [Migration("7.0.0", 9, GlobalSettings.UmbracoMigrationName)]
     public class AlterTagsTable : MigrationBase
     {
         public AlterTagsTable(ISqlSyntaxProvider sqlSyntax, ILogger logger) : base(sqlSyntax, logger)

src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSeven/AlterUserTable.cs

@@ -5,7 +5,7 @@ using Umbraco.Core.Persistence.SqlSyntax;
 
 namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSeven
 {
-    [Migration("7.0.0", 3, Constants.System.UmbracoMigrationName)]
+    [Migration("7.0.0", 3, GlobalSettings.UmbracoMigrationName)]
     public class AlterUserTable : MigrationBase
     {
         public AlterUserTable(ISqlSyntaxProvider sqlSyntax, ILogger logger) : base(sqlSyntax, logger)

src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSeven/AssignMissingKeysAndIndexes.cs

@@ -12,7 +12,7 @@ namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSeven
     /// and it wasn't a MySQL install. 
     /// see: http://issues.umbraco.org/issue/U4-5707
     /// </summary>
-    [Migration("7.0.0", 0, Constants.System.UmbracoMigrationName)]
+    [Migration("7.0.0", 0, GlobalSettings.UmbracoMigrationName)]
     public class AssignMissingKeysAndIndexes : MigrationBase
     {
         public AssignMissingKeysAndIndexes(ISqlSyntaxProvider sqlSyntax, ILogger logger) : base(sqlSyntax, logger)

src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSeven/DropControlIdColumn.cs

@@ -5,7 +5,7 @@ using Umbraco.Core.Persistence.SqlSyntax;
 
 namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSeven
 {
-    [Migration("7.0.0", 2, Constants.System.UmbracoMigrationName)]
+    [Migration("7.0.0", 2, GlobalSettings.UmbracoMigrationName)]
     public class DropControlIdColumn : MigrationBase
     {
         public DropControlIdColumn(ISqlSyntaxProvider sqlSyntax, ILogger logger) : base(sqlSyntax, logger)

src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSeven/RemoveCmsMacroPropertyTypeTable.cs

@@ -5,7 +5,7 @@ using Umbraco.Core.Persistence.SqlSyntax;
 
 namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSeven
 {
-    [Migration("7.0.0", 7, Constants.System.UmbracoMigrationName)]
+    [Migration("7.0.0", 7, GlobalSettings.UmbracoMigrationName)]
     public class RemoveCmsMacroPropertyTypeTable : MigrationBase
     {
         public RemoveCmsMacroPropertyTypeTable(ISqlSyntaxProvider sqlSyntax, ILogger logger) : base(sqlSyntax, logger)

src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSeven/UpdateControlIdToPropertyEditorAlias.cs

@@ -9,7 +9,7 @@ namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSeven
     /// <summary>
     /// Updates the data in the changed propertyEditorAlias column after it has been changed by ChangeControlIdColumn
     /// </summary>
-    [Migration("7.0.0", 1, Constants.System.UmbracoMigrationName)]
+    [Migration("7.0.0", 1, GlobalSettings.UmbracoMigrationName)]
     public class UpdateControlIdToPropertyEditorAlias : MigrationBase
     {
         public UpdateControlIdToPropertyEditorAlias(ISqlSyntaxProvider sqlSyntax, ILogger logger) : base(sqlSyntax, logger)

src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSeven/UpdateRelatedLinksData.cs

@@ -16,7 +16,7 @@ using Umbraco.Core.Persistence.SqlSyntax;
 
 namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSeven
 {
-    [Migration("7.0.0", 10, Constants.System.UmbracoMigrationName)]
+    [Migration("7.0.0", 10, GlobalSettings.UmbracoMigrationName)]
     public class UpdateRelatedLinksData : MigrationBase
     {
         public UpdateRelatedLinksData(ISqlSyntaxProvider sqlSyntax, ILogger logger) : base(sqlSyntax, logger)

src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenFiveFive/AddLockObjects.cs

@@ -5,7 +5,7 @@ using Umbraco.Core.Persistence.SqlSyntax;
 
 namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSevenFiveFive
 {
-    [Migration("7.5.5", 101, Constants.System.UmbracoMigrationName)]
+    [Migration("7.5.5", 101, GlobalSettings.UmbracoMigrationName)]
     public class AddLockObjects : MigrationBase
     {
         public AddLockObjects(ISqlSyntaxProvider sqlSyntax, ILogger logger)

src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenFiveFive/AddLockTable.cs

@@ -5,7 +5,7 @@ using Umbraco.Core.Persistence.SqlSyntax;
 
 namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSevenFiveFive
 {
-    [Migration("7.5.5", 100, Constants.System.UmbracoMigrationName)]
+    [Migration("7.5.5", 100, GlobalSettings.UmbracoMigrationName)]
     public class AddLockTable : MigrationBase
     {
         public AddLockTable(ISqlSyntaxProvider sqlSyntax, ILogger logger)

src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenFiveFive/UpdateAllowedMediaTypesAtRoot.cs

@@ -7,7 +7,7 @@ namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSevenFiveFiv
     /// <summary>
     /// See: http://issues.umbraco.org/issue/U4-4196
     /// </summary>
-    [Migration("7.5.5", 1, Constants.System.UmbracoMigrationName)]
+    [Migration("7.5.5", 1, GlobalSettings.UmbracoMigrationName)]
     public class UpdateAllowedMediaTypesAtRoot : MigrationBase
     {
         public UpdateAllowedMediaTypesAtRoot(ISqlSyntaxProvider sqlSyntax, ILogger logger)

src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenFiveZero/AddRedirectUrlTable.cs

@@ -5,7 +5,7 @@ using Umbraco.Core.Persistence.SqlSyntax;
 
 namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSevenFiveZero
 {
-    [Migration("7.5.0", 100, Constants.System.UmbracoMigrationName)]
+    [Migration("7.5.0", 100, GlobalSettings.UmbracoMigrationName)]
     public class AddRedirectUrlTable : MigrationBase
     {
         public AddRedirectUrlTable(ISqlSyntaxProvider sqlSyntax, ILogger logger)

src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenFiveZero/EnsureServersLockObject.cs

@@ -9,7 +9,7 @@ namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSevenFiveZer
     // This migration exists for 7.3.0 but it seems like it was not always running properly
     // if you're upgrading from 7.3.0 or higher than we add this migration, if you're upgrading 
     // from 7.3.0 or lower then you will already get this migration in the migration to get to 7.3.0
-    [Migration("7.3.0", "7.5.0", 10, Constants.System.UmbracoMigrationName)]
+    [Migration("7.3.0", "7.5.0", 10, GlobalSettings.UmbracoMigrationName)]
     public class EnsureServersLockObject : MigrationBase
     {
         public EnsureServersLockObject(ISqlSyntaxProvider sqlSyntax, ILogger logger)

src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenFiveZero/RemoveStylesheetDataAndTablesAgain.cs

@@ -9,7 +9,7 @@ namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSevenFiveZer
     /// <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>
-    [Migration("7.5.0", 1, Constants.System.UmbracoMigrationName)]
+    [Migration("7.5.0", 1, GlobalSettings.UmbracoMigrationName)]
     public class RemoveStylesheetDataAndTablesAgain : MigrationBase
     {
         public RemoveStylesheetDataAndTablesAgain(ISqlSyntaxProvider sqlSyntax, ILogger logger)

src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenFiveZero/UpdateUniqueIndexOnCmsPropertyData.cs

@@ -12,7 +12,7 @@ namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSevenFiveZer
     /// <summary>
     /// See: http://issues.umbraco.org/issue/U4-8522
     /// </summary>
-    [Migration("7.5.0", 2, Constants.System.UmbracoMigrationName)]
+    [Migration("7.5.0", 2, GlobalSettings.UmbracoMigrationName)]
     public class UpdateUniqueIndexOnCmsPropertyData : MigrationBase
     {
         public UpdateUniqueIndexOnCmsPropertyData(ISqlSyntaxProvider sqlSyntax, ILogger logger)

src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenFourZero/AddDataDecimalColumn.cs

@@ -5,7 +5,7 @@ using Umbraco.Core.Persistence.SqlSyntax;
 
 namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSevenFourZero
 {
-    [Migration("7.4.0", 1, Constants.System.UmbracoMigrationName)]
+    [Migration("7.4.0", 1, GlobalSettings.UmbracoMigrationName)]
     public class AddDataDecimalColumn : MigrationBase
     {
         public AddDataDecimalColumn(ISqlSyntaxProvider sqlSyntax, ILogger logger)

src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenFourZero/AddUmbracoDeployTables.cs

@@ -5,7 +5,7 @@ using Umbraco.Core.Persistence.SqlSyntax;
 
 namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSevenFourZero
 {
-    [Migration("7.4.0", 5, Constants.System.UmbracoMigrationName)]
+    [Migration("7.4.0", 5, GlobalSettings.UmbracoMigrationName)]
     public class AddUmbracoDeployTables : MigrationBase
     {
         public AddUmbracoDeployTables(ISqlSyntaxProvider sqlSyntax, ILogger logger)

src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenFourZero/AddUniqueIdPropertyTypeGroupColumn.cs

@@ -9,7 +9,7 @@ using Umbraco.Core.Persistence.SqlSyntax;
 
 namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSevenFourZero
 {
-    [Migration("7.4.0", 2, Constants.System.UmbracoMigrationName)]
+    [Migration("7.4.0", 2, GlobalSettings.UmbracoMigrationName)]
     public class AddUniqueIdPropertyTypeGroupColumn : MigrationBase
     {
         public AddUniqueIdPropertyTypeGroupColumn(ISqlSyntaxProvider sqlSyntax, ILogger logger)

src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenFourZero/EnsureContentTypeUniqueIdsAreConsistent.cs

@@ -12,7 +12,7 @@ namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSevenFourZer
     /// alias, so we need to ensure that these are initially consistent on
     /// all environments (based on the alias).
     /// </summary>
-    [Migration("7.4.0", 3, Constants.System.UmbracoMigrationName)]
+    [Migration("7.4.0", 3, GlobalSettings.UmbracoMigrationName)]
     public class EnsureContentTypeUniqueIdsAreConsistent : MigrationBase
     {
         public EnsureContentTypeUniqueIdsAreConsistent(ISqlSyntaxProvider sqlSyntax, ILogger logger)

src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenFourZero/FixListViewMediaSortOrder.cs

@@ -6,7 +6,7 @@ using Umbraco.Core.Persistence.SqlSyntax;
 
 namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSevenFourZero
 {
-    [Migration("7.4.0", 4, Constants.System.UmbracoMigrationName)]
+    [Migration("7.4.0", 4, GlobalSettings.UmbracoMigrationName)]
     public class FixListViewMediaSortOrder : MigrationBase
     {
         public FixListViewMediaSortOrder(ISqlSyntaxProvider sqlSyntax, ILogger logger)

src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenFourZero/RemoveParentIdPropertyTypeGroupColumn.cs

@@ -5,7 +5,7 @@ using Umbraco.Core.Persistence.SqlSyntax;
 
 namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSevenFourZero
 {
-    [Migration("7.4.0", 4, Constants.System.UmbracoMigrationName)]
+    [Migration("7.4.0", 4, GlobalSettings.UmbracoMigrationName)]
     public class RemoveParentIdPropertyTypeGroupColumn : MigrationBase
     {
         public RemoveParentIdPropertyTypeGroupColumn(ISqlSyntaxProvider sqlSyntax, ILogger logger)

src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenOneZero/AssignMissingPrimaryForMySqlKeys.cs

@@ -11,7 +11,7 @@ namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSevenOneZero
     // this is because when the 7.0.0 migrations are executed, this primary key get's created so if this migration is also executed
     // we will get exceptions because it is trying to create the PK two times.
 
-    [Migration("7.0.0", "7.1.0", 0, Constants.System.UmbracoMigrationName)]
+    [Migration("7.0.0", "7.1.0", 0, GlobalSettings.UmbracoMigrationName)]
     public class AssignMissingPrimaryForMySqlKeys : MigrationBase
     {
         public AssignMissingPrimaryForMySqlKeys(ISqlSyntaxProvider sqlSyntax, ILogger logger) : base(sqlSyntax, logger)

src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenSixZero/AddMacroUniqueIdColumn.cs

@@ -6,7 +6,7 @@ using Umbraco.Core.Persistence.SqlSyntax;
 
 namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSevenSixZero
 {
-    [Migration("7.6.0", 0, Constants.System.UmbracoMigrationName)]
+    [Migration("7.6.0", 0, GlobalSettings.UmbracoMigrationName)]
     public class AddMacroUniqueIdColumn : MigrationBase
     {
         public AddMacroUniqueIdColumn(ISqlSyntaxProvider sqlSyntax, ILogger logger)