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
-alpha056
+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-alpha056")]
+[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 "alpha056"; } }
+        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-Applications.cs

@@ -112,15 +112,9 @@
 
             public const string Languages = "languages";
 
-            public const string PartialViews = "partialViews";
-
-            public const string PartialViewMacros = "partialViewMacros";
-
-            public const string Scripts = "scripts";
-
             //TODO: Fill in the rest!
         }
-    }
+	}
 
    
 }

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,146 +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";
-            
-            // forms
-            public const string FormsForm = "forms-form";
-            public const string FormsWorkflow = "forms-workflow";
-            public const string FormsRecord = "forms-record";
-
-            // 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;
-                    case UmbracoObjectTypes.FormsForm:
-                        return FormsForm;
-                    case UmbracoObjectTypes.FormsWorkflow:
-                        return FormsWorkflow;
-                    case UmbracoObjectTypes.FormsRecord:
-                        return FormsRecord;
-                }
-                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;
-                    case FormsForm:
-                        return UmbracoObjectTypes.FormsForm;
-                    case FormsWorkflow:
-                        return UmbracoObjectTypes.FormsWorkflow;
-                    case FormsRecord:
-                        return UmbracoObjectTypes.FormsRecord;
-                }
-                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,46 +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);
-
-            /// <summary>
-            /// Guid for a Forms Form.
-            /// </summary>
-            public const string FormsForm = "F5A9F787-6593-46F0-B8FF-BFD9BCA9F6BB";
-
-            /// <summary>
-            /// Guid for a Forms Form.
-            /// </summary>
-            public static readonly Guid FormsFormGuid = new Guid(FormsForm);
-
-            /// <summary>
-            /// Guid for a Forms Workflow.
-            /// </summary>
-            public const string FormsWorkflow = "42D7BF9B-A362-4FEE-B45A-674D5C064B70";
-
-            /// <summary>
-            /// Guid for a Forms Workflow.
-            /// </summary>
-            public static readonly Guid FormsWorkflowGuid = new Guid(FormsWorkflow);
-
-            /// <summary>
-            /// Guid for a Forms Record.
-            /// </summary>
-            public const string FormsRecord = "CFED6CE4-9359-443E-9977-9956FEB1D867";
-
-            /// <summary>
-            /// Guid for a Forms Record.
-            /// </summary>
-            public static readonly Guid FormsRecordGuid = new Guid(FormsRecord);
         }
     }
 }

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 view.
-        /// </summary>
-        /// <param name="view">The grid editor view. It needs to be the view instead of the alias as the view is really what identifies what kind of connector should be used. Alias can be anything and you can have multiple different aliases using the same kind of view.</param>
-        /// <remarks>A value indicating whether the connector supports the grid editor view.</remarks>
-        /// <remarks>Note that <paramref name="view" /> can be string.Empty to indicate the "default" connector.</remarks>
-        bool IsConnector(string view);
-
-        /// <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,34 +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,
 
-        /// <summary>
-        /// Forms Form
-        /// </summary>
-        [UmbracoObjectType(Constants.ObjectTypes.FormsForm)]
-        [FriendlyName("Form")]
-        FormsForm,
-
-        /// <summary>
-        /// Forms Workflow
-        /// </summary>
-        [UmbracoObjectType(Constants.ObjectTypes.FormsWorkflow)]
-        [FriendlyName("Workflow")]
-        FormsWorkflow,
-
-        /// <summary>
-        /// Forms Record
-        /// </summary>
-        [UmbracoObjectType(Constants.ObjectTypes.FormsRecord)]
-        [FriendlyName("Record")]
-        FormsRecord
     }
 }

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)