Merge with 4.11.6

direct reference to the old.

.hgignore

@@ -44,6 +44,7 @@ src\Umbraco.Web.UI\[Mm]acro[Ss]cripts\*
 src\Umbraco.Web.UI\[Xx]slt\*
 src\Umbraco.Web.UI\[Ii]mages\*
 src\Umbraco.Web.UI\[Ss]cripts\*
+src\Umbraco.Web.UI\Web.*.config.transformed
 
 umbraco\presentation\umbraco\plugins\uComponents\uComponentsInstaller.ascx
 umbraco\presentation\packages\uComponents\MultiNodePicker\CustomTreeService.asmx

.hgtags

@@ -24,3 +24,6 @@ f6da531fbb4c251ff61d314e2a7effb13c71e74a Release-4.10.0
 54cde33b809dcb3a1f7e7ae0d5375f6dd0d89c8d Release-4.11.2.2
 ff3bb24ea0c915878396a6ae27f1ff164e8ac150 Release-6.0.0-beta
 56015ac26f5ab60e3c61b1d09075297b660afa07 Release-6.0.0-RC
+1719fbd857f28b376639ac2aa0abada0ef2e7560 Release-6.0.0
+e02f5aebb87e3f07d27376647756caa9762931d8 Release-4.11.4
+b247b35d821144849f551e02da8ba719f91d5fb0 Release-6.0.2

build/Build.bat

@@ -1,5 +1,5 @@
 @ECHO OFF
-SET release=6.0.0
+SET release=6.0.3
 SET comment=
 SET version=%release%
 

build/Build.proj

@@ -1,3 +1,4 @@
+
 <Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
 
  <!-- 
@@ -13,7 +14,45 @@
  
  <Import Project="..\tools\UmbracoMSBuildTasks\Umbraco.MSBuild.Tasks.Targets" />
  <Import Project="..\tools\MSBuildCommunityTasks\MSBuild.Community.Tasks.Targets" />
+ 
+ <UsingTask TaskName="GenerateHash" TaskFactory="CodeTaskFactory" AssemblyFile="$(MSBuildToolsPath)\Microsoft.Build.Tasks.v4.0.dll">
+    <ParameterGroup>
+        <InputFiles ParameterType="Microsoft.Build.Framework.ITaskItem[]" Required="true" />
+        <OutputFile ParameterType="System.String" Required="true" />
+    </ParameterGroup>
+    <Task>
+        <Using Namespace="System.IO" />
+        <Using Namespace="System.Linq" />
+        <Using Namespace="System.Security.Cryptography" />
+        <Code Type="Fragment" Language="cs">
+            <![CDATA[
+                using (var ms = new MemoryStream())
+                {
+                    foreach (var item in InputFiles)
+                    {
+                        string path = item.ItemSpec;
 
+                        using (FileStream stream = new FileStream(path, FileMode.Open))
+                        {
+                            using (var cryptoProvider = new SHA1CryptoServiceProvider())
+                            {
+                                
+                                var fileHash = cryptoProvider.ComputeHash(stream);
+                                
+                                using (TextWriter w = new StreamWriter(OutputFile, false))
+                                {
+                                    w.WriteLine(string.Join("", fileHash.Select(b => b.ToString("x2"))));
+                                }
+                            }
+                        }
+                    }
+                }
+            ]]>
+        </Code>
+    </Task>
+ </UsingTask>
+
+ 
  <!-- 
  ****************************************************
  VARIABLES 
@@ -71,10 +110,18 @@
  *****************************************************
  -->
 
- <Target Name="Build" DependsOnTargets="ZipWebPiApp">
+ <Target Name="Build" DependsOnTargets="GenerateWebPiHash">
    <Message Text="Build finished" />
  </Target>
  
+ <Target Name="GenerateWebPiHash" DependsOnTargets="ZipWebPiApp">
+   <ItemGroup>
+      <WebPiFile Include="$(BuildZipFileNameWebPi)" />
+   </ItemGroup>
+   <Message Text="Calculating hash for $(BuildZipFileNameWebPi)" />
+   <GenerateHash InputFiles="@(WebPiFile)" OutputFile="webpihash.txt" />
+ </Target>
+ 
  <Target Name="CleanUp" DependsOnTargets="ZipWebPiApp">
    <Message Text="Deleting $(BuildFolder)" Importance="high" />
    <RemoveDir Directories="$(BuildFolder)" />

build/NuSpecs/UmbracoCms.nuspec

@@ -15,7 +15,7 @@
         <language>en-US</language>
         <tags>umbraco</tags>
         <dependencies>
-            <dependency id="UmbracoCms.Core" version="$version$" />
+            <dependency id="UmbracoCms.Core" version="[$version$]" />
         </dependencies>
     </metadata>
   <files>

build/RevertToCleanInstall.bat

@@ -21,29 +21,44 @@ echo ^<?xml version="1.0" encoding="utf-8"?^>^<packages^>^</packages^> >..\src\U
 echo Removing plugin cache files
 del ..\src\Umbraco.Web.UI\App_Data\TEMP\PluginCache\*.*
 
+echo Removing cache files and examine index
+del ..\src\Umbraco.Web.UI\App_Data\TEMP\*.*
+
 echo Removing log files
 del ..\src\Umbraco.Web.UI\App_Data\Logs\*.*
 
+echo Removing packages
+del ..\src\Umbraco.Web.UI\App_Data\packages\*.*
+
+echo Removing previews
+del ..\src\Umbraco.Web.UI\App_Data\preview\*.*
+
+echo Removing app code files (typically added by starterkits)
+del ..\src\Umbraco.Web.UI\App_Code\*.*
+
 echo Removing xslt files
-del ..\src\Umbraco.Web.UI\Xslt\*.*
+del ..\src\Umbraco.Web.UI\xslt\*.*
 
 echo Removing user control files
 del ..\src\Umbraco.Web.UI\UserControls\*.*
 
+echo Removing masterpage files
+del ..\src\Umbraco.Web.UI\masterpages\*.*
+
 echo Removing view files
 del ..\src\Umbraco.Web.UI\Views\*.*
 
 echo Removing razor files
-del ..\src\Umbraco.Web.UI\MacroScripts\*.*
+del ..\src\Umbraco.Web.UI\macroScripts\*.*
 
 echo Removing media files
-del ..\src\Umbraco.Web.UI\Media\*.*
+del ..\src\Umbraco.Web.UI\media\*.*
 
 echo Removing script files
-del ..\src\Umbraco.Web.UI\Scripts\*.*
+del ..\src\Umbraco.Web.UI\scripts\*.*
 
 echo Removing css files
-del ..\src\Umbraco.Web.UI\Css\*.*
+del ..\src\Umbraco.Web.UI\css\*.*
 
 echo "Umbraco install reverted to clean install"
 pause 
@@ -64,29 +79,44 @@ echo ^<?xml version="1.0" encoding="utf-8"?^>^<packages^>^</packages^> >..\src\U
 echo Removing plugin cache files
 FOR %%A IN (..\src\Umbraco.Web.UI\App_Data\TEMP\PluginCache\*.*) DO DEL %%A
 
+echo Removing cache files and examine index
+FOR %%A IN (..\src\Umbraco.Web.UI\App_Data\TEMP\*.*) DO DEL %%A
+
 echo Removing log files
 FOR %%A IN (..\src\Umbraco.Web.UI\App_Data\Logs\*.*) DO DEL %%A
 
+echo Removing packages
+FOR %%A IN (..\src\Umbraco.Web.UI\App_Data\packages\*.*) DO DEL %%A
+
+echo Removing previews
+FOR %%A IN (..\src\Umbraco.Web.UI\App_Data\preview\*.*) DO DEL %%A
+
+echo Removing app code files (typically added by starterkits)
+FOR %%A IN (..\src\Umbraco.Web.UI\App_Code\*.*) DO DEL %%A
+
 echo Removing xslt files
-FOR %%A IN (..\src\Umbraco.Web.UI\Xslt\*.*) DO DEL %%A
+FOR %%A IN (..\src\Umbraco.Web.UI\xslt\*.*) DO DEL %%A
+
+echo Removing masterpage files
+FOR %%A IN (..\src\Umbraco.Web.UI\masterpages\*.*) DO DEL %%A
 
 echo Removing user control files
-FOR %%A IN (..\src\Umbraco.Web.UI\UserControls\*.*) DO DEL %%A
+FOR %%A IN (..\src\Umbraco.Web.UI\usercontrols\*.*) DO DEL %%A
 
 echo Removing view files
 FOR %%A IN (..\src\Umbraco.Web.UI\Views\*.*) DO DEL %%A
 
 echo Removing razor files
-FOR %%A IN (..\src\Umbraco.Web.UI\MacroScripts\*.*) DO DEL %%A
+FOR %%A IN (..\src\Umbraco.Web.UI\macroScripts\*.*) DO DEL %%A
 
 echo Removing media files
-FOR %%A IN (..\src\Umbraco.Web.UI\Media\*.*) DO DEL %%A
+FOR %%A IN (..\src\Umbraco.Web.UI\media\*.*) DO DEL %%A
 
 echo Removing script files
-FOR %%A IN (..\src\Umbraco.Web.UI\Scripts\*.*) DO DEL %%A
+FOR %%A IN (..\src\Umbraco.Web.UI\scripts\*.*) DO DEL %%A
 
 echo Removing css files
-FOR %%A IN (..\src\Umbraco.Web.UI\Css\*.*) DO DEL %%A
+FOR %%A IN (..\src\Umbraco.Web.UI\css\*.*) DO DEL %%A
 
 echo "Umbraco install reverted to clean install"
 pause 

src/SQLCE4Umbraco/SqlCEHelper.cs

@@ -50,35 +50,90 @@ namespace SqlCE4Umbraco
         /// </summary>
         internal void ClearDatabase()
         {
+            // drop constraints before tables to avoid exceptions
+            // looping on try/catching exceptions was not really nice
+
+            // http://stackoverflow.com/questions/536350/drop-all-the-tables-stored-procedures-triggers-constriants-and-all-the-depend
+
             var localConnection = new SqlCeConnection(ConnectionString);
             if (System.IO.File.Exists(ReplaceDataDirectory(localConnection.Database)))
             {
-                var tables = new List<string>();
-                using (var reader = ExecuteReader("select table_name from information_schema.tables where TABLE_TYPE <> 'VIEW'"))
+                List<string> tables;
+
+                // drop foreign keys
+                // SQL may need "where constraint_catalog=DB_NAME() and ..."
+                tables = new List<string>();
+                using (var reader = ExecuteReader("select table_name from information_schema.table_constraints where constraint_type = 'FOREIGN KEY' order by table_name"))
                 {
-                    while (reader.Read())
+                    while (reader.Read()) tables.Add(reader.GetString("table_name").Trim());
+                }
+
+                foreach (var table in tables)
+                {
+                    var constraints = new List<string>();
+                    using (var reader = ExecuteReader("select constraint_name from information_schema.table_constraints where constraint_type = 'FOREIGN KEY' and table_name = '" + table + "' order by constraint_name"))
                     {
-                        tables.Add(reader.GetString("TABLE_NAME"));
+                        while (reader.Read()) constraints.Add(reader.GetString("constraint_name").Trim());
+                    }
+                    foreach (var constraint in constraints)
+                    {
+                        // SQL may need "[dbo].[table]"
+                        ExecuteNonQuery("alter table [" + table + "] drop constraint [" + constraint + "]");
                     }
                 }
 
-                while(tables.Any())
+                // drop primary keys
+                // SQL may need "where constraint_catalog=DB_NAME() and ..."
+                tables = new List<string>();
+                using (var reader = ExecuteReader("select table_name from information_schema.table_constraints where constraint_type = 'PRIMARY KEY' order by table_name"))
                 {
-                    for (var i = 0; i < tables.Count; i++)
-                    {
-                        var dropTable = "DROP TABLE " + tables[i];
+                    while (reader.Read()) tables.Add(reader.GetString("table_name").Trim());
+                }
 
-                        try
-                        {
-                            ExecuteNonQuery(dropTable);
-                            tables.Remove(tables[i]);
-                        }
-                        catch (SqlHelperException ex)
-                        {
-                            //this will occur because there is no cascade option, so we just wanna try the next one       
-                        }
+                foreach (var table in tables)
+                {
+                    var constraints = new List<string>();
+                    using (var reader = ExecuteReader("select constraint_name from information_schema.table_constraints where constraint_type = 'PRIMARY KEY' and table_name = '" + table + "' order by constraint_name"))
+                    {
+                        while (reader.Read()) constraints.Add(reader.GetString("constraint_name").Trim());
+                    }
+                    foreach (var constraint in constraints)
+                    {
+                        // SQL may need "[dbo].[table]"
+                        ExecuteNonQuery("alter table [" + table + "] drop constraint [" + constraint + "]");
                     }
                 }
+
+                // drop tables
+                tables = new List<string>();
+                using (var reader = ExecuteReader("select table_name from information_schema.tables where table_type <> 'VIEW' order by table_name"))
+                {
+                    while (reader.Read()) tables.Add(reader.GetString("table_name").Trim());
+                }
+
+                foreach (var table in tables)
+                {
+                    ExecuteNonQuery("drop table [" + table + "]");
+                }
+            }
+        }
+
+        /// <summary>
+        /// Drops all foreign keys on a table.
+        /// </summary>
+        /// <param name="table">The name of the table.</param>
+        /// <remarks>To be used in unit tests.</remarks>
+        internal void DropForeignKeys(string table)
+        {
+            var constraints = new List<string>();
+            using (var reader = ExecuteReader("select constraint_name from information_schema.table_constraints where constraint_type = 'FOREIGN KEY' and table_name = '" + table + "' order by constraint_name"))
+            {
+                while (reader.Read()) constraints.Add(reader.GetString("constraint_name").Trim());
+            }
+            foreach (var constraint in constraints)
+            {
+                // SQL may need "[dbo].[table]"
+                ExecuteNonQuery("alter table [" + table + "] drop constraint [" + constraint + "]");
             }
         }
 
@@ -94,7 +149,9 @@ namespace SqlCE4Umbraco
                 var dataDirectory = AppDomain.CurrentDomain.GetData("DataDirectory") as string;
                 if (!string.IsNullOrEmpty(dataDirectory))
                 {
-                    path = path.Replace("|DataDirectory|", dataDirectory + System.IO.Path.DirectorySeparatorChar);
+                    path = path.Contains(@"|\") 
+                        ? path.Replace("|DataDirectory|", dataDirectory) 
+                        : path.Replace("|DataDirectory|", dataDirectory + System.IO.Path.DirectorySeparatorChar);
                 }
             }
 

src/Umbraco.Core/ActionsResolver.cs

@@ -9,14 +9,14 @@ namespace Umbraco.Core
 	/// <summary>
 	/// A resolver to return all IAction objects
 	/// </summary>
-	internal sealed class ActionsResolver : ManyObjectsResolverBase<ActionsResolver, IAction>
+	internal sealed class ActionsResolver : LazyManyObjectsResolverBase<ActionsResolver, IAction>
 	{
 
 		/// <summary>
 		/// Constructor
 		/// </summary>
 		/// <param name="packageActions"></param>		
-		internal ActionsResolver(IEnumerable<Type> packageActions)
+		internal ActionsResolver(Func<IEnumerable<Type>> packageActions)
 			: base(packageActions)
 		{
 
@@ -34,9 +34,9 @@ namespace Umbraco.Core
 		}
 
 		protected override IEnumerable<IAction> CreateInstances()
-		{
+		{					
 			var actions = new List<IAction>();
-			var foundIActions = PluginManager.Current.ResolveActions();
+			var foundIActions = InstanceTypes;
 			foreach (var type in foundIActions)
 			{
 				IAction typeInstance;

src/Umbraco.Core/CacheRefreshersResolver.cs

@@ -17,7 +17,7 @@ namespace Umbraco.Core
 		/// Constructor
 		/// </summary>
 		/// <param name="refreshers"></param>		
-		internal CacheRefreshersResolver(IEnumerable<Type> refreshers)
+		internal CacheRefreshersResolver(Func<IEnumerable<Type>> refreshers)
 			: base(refreshers)
 		{
 			

src/Umbraco.Core/Configuration/GlobalSettings.cs

@@ -28,24 +28,49 @@ namespace Umbraco.Core.Configuration
         #region Private static fields
 
         private static Version _version;
-        private static string _reservedUrlsCache;
+        private static readonly object Locker = new object();
+        //make this volatile so that we can ensure thread safety with a double check lock
+    	private static volatile string _reservedUrlsCache;
         private static string _reservedPathsCache;
         private static StartsWithContainer _reservedList = new StartsWithContainer();
+        private static string _reservedPaths;
+        private static string _reservedUrls;
+        //ensure the built on (non-changeable) reserved paths are there at all times
+        private const string StaticReservedPaths = "~/app_plugins/,~/install/,";
+        private const string StaticReservedUrls = "~/config/splashes/booting.aspx,~/install/default.aspx,~/config/splashes/noNodes.aspx,~/VSEnterpriseHelper.axd,";
 
         #endregion
 
         /// <summary>
+        /// used for unit tests
+        /// </summary>
+        internal static void ResetCache()
+        {
+            _reservedUrlsCache = null;
+            _reservedPaths = null;
+            _reservedUrls = null;
+        }
+
+    	/// <summary>
         /// Gets the reserved urls from web.config.
         /// </summary>
         /// <value>The reserved urls.</value>
         public static string ReservedUrls
         {
             get
-            {
-                return ConfigurationManager.AppSettings.ContainsKey("umbracoReservedUrls")
-                    ? ConfigurationManager.AppSettings["umbracoReservedUrls"]
-                    : string.Empty;
+            {                
+                if (_reservedUrls == null)
+                {
+                    var urls = ConfigurationManager.AppSettings.ContainsKey("umbracoReservedUrls")
+                                   ? ConfigurationManager.AppSettings["umbracoReservedUrls"]
+                                   : string.Empty;
+
+                    //ensure the built on (non-changeable) reserved paths are there at all times
+                    _reservedUrls = StaticReservedUrls + urls;    
+                }
+                return _reservedUrls;
             }
+            internal set { _reservedUrls = value; }
         }
 
         /// <summary>
@@ -56,10 +81,25 @@ namespace Umbraco.Core.Configuration
         {
             get
             {
-                return ConfigurationManager.AppSettings.ContainsKey("umbracoReservedPaths")
-                           ? ConfigurationManager.AppSettings["umbracoReservedPaths"]
-                           : string.Empty;
+                if (_reservedPaths == null)
+                {
+                    var reservedPaths = StaticReservedPaths;
+                    //always add the umbraco path to the list
+                    if (ConfigurationManager.AppSettings.ContainsKey("umbracoPath")
+                        && !ConfigurationManager.AppSettings["umbracoPath"].IsNullOrWhiteSpace())
+                    {
+                        reservedPaths += ConfigurationManager.AppSettings["umbracoPath"].EnsureEndsWith(',');
+                    }
+
+                    var allPaths = ConfigurationManager.AppSettings.ContainsKey("umbracoReservedPaths")
+                                    ? ConfigurationManager.AppSettings["umbracoReservedPaths"]
+                                    : string.Empty;
+
+                    _reservedPaths = reservedPaths + allPaths;
+                }
+                return _reservedPaths;
             }
+            internal set { _reservedPaths = value; }
         }
 
         /// <summary>
@@ -114,6 +154,9 @@ namespace Umbraco.Core.Configuration
         /// This will return the MVC area that we will route all custom routes through like surface controllers, etc...
         /// We will use the 'Path' (default ~/umbraco) to create it but since it cannot contain '/' and people may specify a path of ~/asdf/asdf/admin
         /// we will convert the '/' to '-' and use that as the path. its a bit lame but will work.
+		/// 
+        /// We also make sure that the virtual directory (SystemDirectories.Root) is stripped off first, otherwise we'd end up with something
+        /// like "MyVirtualDirectory-Umbraco" instead of just "Umbraco".
         /// </remarks>
         internal static string UmbracoMvcArea
         {
@@ -123,7 +166,7 @@ namespace Umbraco.Core.Configuration
                 {
                     throw new InvalidOperationException("Cannot create an MVC Area path without the umbracoPath specified");
                 }
-                return Path.TrimStart('~').TrimStart('/').Replace('/', '-').Trim();
+			    return Path.TrimStart(SystemDirectories.Root).TrimStart('~').TrimStart('/').Replace('/', '-').Trim().ToLower();
             }
         }
 
@@ -201,6 +244,7 @@ namespace Umbraco.Core.Configuration
             }
         }
 
+		
         /// <summary>
         /// Saves a setting into the configuration file.
         /// </summary>
@@ -622,38 +666,42 @@ namespace Umbraco.Core.Configuration
         /// </returns>
         public static bool IsReservedPathOrUrl(string url)
         {
-            // check if GlobalSettings.ReservedPaths and GlobalSettings.ReservedUrls are unchanged
-            if (!object.ReferenceEquals(_reservedPathsCache, GlobalSettings.ReservedPaths)
-                || !object.ReferenceEquals(_reservedUrlsCache, GlobalSettings.ReservedUrls))
+            if (_reservedUrlsCache == null)
             {
-                // store references to strings to determine changes
-                _reservedPathsCache = GlobalSettings.ReservedPaths;
-                _reservedUrlsCache = GlobalSettings.ReservedUrls;
-
-                string _root = SystemDirectories.Root.Trim().ToLower();
-
-                // add URLs and paths to a new list
-                StartsWithContainer _newReservedList = new StartsWithContainer();
-                foreach (string reservedUrl in _reservedUrlsCache.Split(new[] { "," }, StringSplitOptions.RemoveEmptyEntries))
+                lock (Locker)
                 {
-                    //resolves the url to support tilde chars
-                    string reservedUrlTrimmed = IOHelper.ResolveUrl(reservedUrl).Trim().ToLower();
-                    if (reservedUrlTrimmed.Length > 0)
-                        _newReservedList.Add(reservedUrlTrimmed);
+                    if (_reservedUrlsCache == null)
+                    {
+                        // store references to strings to determine changes
+                        _reservedPathsCache = GlobalSettings.ReservedPaths;
+                        _reservedUrlsCache = GlobalSettings.ReservedUrls;
+
+                        string _root = SystemDirectories.Root.Trim().ToLower();
+
+                        // add URLs and paths to a new list
+                        StartsWithContainer _newReservedList = new StartsWithContainer();
+                        foreach (string reservedUrl in _reservedUrlsCache.Split(new[] { "," }, StringSplitOptions.RemoveEmptyEntries))
+                        {
+                            //resolves the url to support tilde chars
+                            string reservedUrlTrimmed = IOHelper.ResolveUrl(reservedUrl).Trim().ToLower();
+                            if (reservedUrlTrimmed.Length > 0)
+                                _newReservedList.Add(reservedUrlTrimmed);
+                        }
+
+                        foreach (string reservedPath in _reservedPathsCache.Split(new[] { "," }, StringSplitOptions.RemoveEmptyEntries))
+                        {
+                            bool trimEnd = !reservedPath.EndsWith("/");
+                            //resolves the url to support tilde chars
+                            string reservedPathTrimmed = IOHelper.ResolveUrl(reservedPath).Trim().ToLower();
+
+                            if (reservedPathTrimmed.Length > 0)
+                                _newReservedList.Add(reservedPathTrimmed + (reservedPathTrimmed.EndsWith("/") ? "" : "/"));
+                        }
+
+                        // use the new list from now on
+                        _reservedList = _newReservedList;
+                    }
                 }
-
-                foreach (string reservedPath in _reservedPathsCache.Split(new[] { "," }, StringSplitOptions.RemoveEmptyEntries))
-                {
-                    bool trimEnd = !reservedPath.EndsWith("/");
-                    //resolves the url to support tilde chars
-                    string reservedPathTrimmed = IOHelper.ResolveUrl(reservedPath).Trim().ToLower();
-
-                    if (reservedPathTrimmed.Length > 0)
-                        _newReservedList.Add(reservedPathTrimmed + (reservedPathTrimmed.EndsWith("/") ? "" : "/"));
-                }
-
-                // use the new list from now on
-                _reservedList = _newReservedList;
             }
 
             //The url should be cleaned up before checking:

src/Umbraco.Core/Configuration/InfrastructureSettings/Infrastructure.cs

@@ -0,0 +1,190 @@
+using System.Configuration;
+
+namespace Umbraco.Core.Configuration.InfrastructureSettings
+{
+    public class Infrastructure : ConfigurationSection
+    {
+        private const string InfrastructureSectionName = "umbraco/infrastructure";
+
+        public static Infrastructure Instance
+        {
+            get { return (Infrastructure) ConfigurationManager.GetSection(InfrastructureSectionName); }
+        }
+
+        #region RepositoriesSection Property
+
+        internal const string RepositoriesPropertyName = "repositories";
+
+        [ConfigurationProperty(RepositoriesPropertyName, IsRequired = true, IsKey = false, IsDefaultCollection = false)]
+        public Repositories Repositories
+        {
+            get { return ((Repositories)base[RepositoriesPropertyName]); }
+            set { base[RepositoriesPropertyName] = value; }
+        }
+
+        #endregion
+
+        #region PublishingStrategy Property
+
+        internal const string PublishingStrategyPropertyName = "publishingStrategy";
+
+        [ConfigurationProperty(PublishingStrategyPropertyName, IsRequired = true, IsKey = false, IsDefaultCollection = false)]
+        public PublishingProvider PublishingStrategy
+        {
+            get { return ((PublishingProvider)base[PublishingStrategyPropertyName]); }
+            set { base[PublishingStrategyPropertyName] = value; }
+        }
+
+        #endregion
+    }
+
+    public class Repositories : ConfigurationElement
+    {
+        [ConfigurationProperty("", IsDefaultCollection = true, IsRequired = true)]
+        public RepositoryElementCollection Repository
+        {
+            get { return ((RepositoryElementCollection)(base[""])); }
+        }
+    }
+
+    [ConfigurationCollection(typeof(Repository), CollectionType = ConfigurationElementCollectionType.BasicMapAlternate, AddItemName = RepositoryPropertyName)]
+    public class RepositoryElementCollection : ConfigurationElementCollection
+    {
+        internal const string RepositoryPropertyName = "repository";
+
+        public override ConfigurationElementCollectionType CollectionType
+        {
+            get
+            {
+                return ConfigurationElementCollectionType.BasicMapAlternate;
+            }
+        }
+
+        protected override string ElementName
+        {
+            get
+            {
+                return RepositoryPropertyName;
+            }
+        }
+
+        protected override bool IsElementName(string elementName)
+        {
+            return elementName == RepositoryPropertyName;
+        }
+
+        protected override object GetElementKey(ConfigurationElement element)
+        {
+            return ((Repository)element).InterfaceShortTypeName;
+        }
+
+        protected override ConfigurationElement CreateNewElement()
+        {
+            return new Repository();
+        }
+
+        #region Indexer
+
+        public Repository this[int index]
+        {
+            get { return (Repository)base.BaseGet(index); }
+        }
+
+        public Repository this[string interfaceShortTypeName]
+        {
+            get { return (Repository)base.BaseGet(interfaceShortTypeName); }
+        }
+
+        #endregion
+
+        #region Add
+
+        public void Add(Repository repository)
+        {
+            BaseAdd(repository);
+        }
+
+        #endregion
+
+        #region Remove
+
+        public void Remove(Repository repository)
+        {
+            BaseRemove(repository);
+        }
+
+        #endregion
+
+        #region GetItem
+
+        public Repository GetItemAt(int index)
+        {
+            return (Repository)BaseGet(index);
+        }
+
+        public Repository GetItemByKey(string interfaceShortTypeName)
+        {
+            return (Repository)BaseGet(interfaceShortTypeName);
+        }
+
+        #endregion
+
+        public bool ContainsKey(string interfaceShortName)
+        {
+            bool result = false;
+            object[] keys = this.BaseGetAllKeys();
+            foreach (object key in keys)
+            {
+                if ((string)key == interfaceShortName)
+                {
+                    result = true;
+                    break;
+
+                }
+            }
+            return result;
+        }
+    }
+
+    public class Repository : ConfigurationElement
+    {
+        internal const string InterfaceShortTypeNamePropertyName = "interfaceShortTypeName";
+
+        [ConfigurationPropertyAttribute(InterfaceShortTypeNamePropertyName, IsRequired = true, IsKey = true, IsDefaultCollection = false)]
+        public string InterfaceShortTypeName
+        {
+            get { return (string) base[InterfaceShortTypeNamePropertyName]; }
+            set { base[InterfaceShortTypeNamePropertyName] = value; }
+        }
+
+        internal const string RepositoryFullTypeNamePropertyName = "repositoryFullTypeName";
+
+        [ConfigurationPropertyAttribute(RepositoryFullTypeNamePropertyName, IsRequired = true, IsKey = false, IsDefaultCollection = false)]
+        public string RepositoryFullTypeName
+        {
+            get { return (string)base[RepositoryFullTypeNamePropertyName]; }
+            set { base[RepositoryFullTypeNamePropertyName] = value; }
+        }
+
+        internal const string CacheProviderFullTypeNamePropertyName = "cacheProviderFullTypeName";
+
+        [ConfigurationPropertyAttribute(CacheProviderFullTypeNamePropertyName, IsRequired = true, IsKey = false, IsDefaultCollection = false)]
+        public string CacheProviderFullTypeName
+        {
+            get { return (string)base[CacheProviderFullTypeNamePropertyName]; }
+            set { base[CacheProviderFullTypeNamePropertyName] = value; }
+        }
+    }
+
+    public class PublishingProvider : ConfigurationElement
+    {
+        internal const string TypePropertyName = "type";
+
+        [ConfigurationPropertyAttribute(TypePropertyName, IsRequired = true, IsKey = false, IsDefaultCollection = false)]
+        public string Type
+        {
+            get { return (string)base[TypePropertyName]; }
+            set { base[TypePropertyName] = value; }
+        }
+    }
+}

src/Umbraco.Core/Configuration/UmbracoSettings.cs

@@ -25,7 +25,31 @@ namespace Umbraco.Core.Configuration
 	/// </summary>
 	internal class UmbracoSettings
 	{
-		/// <summary>
+        private static bool GetKeyValue(string key, bool defaultValue)
+        {
+            bool value;
+            string stringValue = GetKey(key);
+
+            if (string.IsNullOrWhiteSpace(stringValue))
+                return defaultValue;
+            if (bool.TryParse(stringValue, out value))
+                return value;
+            return defaultValue;
+        }
+
+        private static int GetKeyValue(string key, int defaultValue)
+        {
+            int value;
+            string stringValue = GetKey(key);
+
+            if (string.IsNullOrWhiteSpace(stringValue))
+                return defaultValue;
+            if (int.TryParse(stringValue, out value))
+                return value;
+            return defaultValue;
+        }
+
+        /// <summary>
 		/// Used in unit testing to reset all config items that were set with property setters (i.e. did not come from config)
 		/// </summary>
 		internal static void ResetSetters()
@@ -35,6 +59,7 @@ namespace Umbraco.Core.Configuration
 			_useLegacySchema = null;
 			_useDomainPrefixes = null;
 			_umbracoLibraryCacheDuration = null;
+            _trySkipIisCustomErrors = null;
 		    SettingsFilePath = null;
 		}
 
@@ -126,11 +151,32 @@ namespace Umbraco.Core.Configuration
 		{
 			EnsureSettingsDocument();
 
+            string attrName = null;
+            var pos = key.IndexOf('@');
+            if (pos > 0)
+            {
+                attrName = key.Substring(pos + 1);
+                key = key.Substring(0, pos - 1);
+            }
+
 			var node = UmbracoSettingsXmlDoc.DocumentElement.SelectSingleNode(key);
-			if (node == null || node.FirstChild == null || node.FirstChild.Value == null)
-				return string.Empty;
-			return node.FirstChild.Value;
-		}
+            if (node == null)
+                return string.Empty;
+
+            if (pos < 0)
+            {
+                if (node.FirstChild == null || node.FirstChild.Value == null)
+                    return string.Empty;
+                return node.FirstChild.Value;
+            }
+            else
+            {
+                var attr = node.Attributes[attrName];
+                if (attr == null)
+                    return string.Empty;
+                return attr.Value;
+            }
+        }
 
 		/// <summary>
 		/// Gets a value indicating whether the media library will create new directories in the /media directory.
@@ -203,6 +249,7 @@ namespace Umbraco.Core.Configuration
 				return value != null ? value.Attributes["assembly"].Value : "";
 			}
 		}
+
 		/// <summary>
 		/// Gets the type of an external logger that can be used to store log items in 3rd party systems
 		/// </summary>
@@ -351,24 +398,13 @@ namespace Umbraco.Core.Configuration
 		{
 			get
 			{
-				try
-				{
-					if (_useDomainPrefixes.HasValue)
-						return _useDomainPrefixes.Value;
-					bool result;
-					if (bool.TryParse(GetKey("/settings/requestHandler/useDomainPrefixes"), out result))
-						return result;
-					return false;
-				}
-				catch
-				{
-					return false;
-				}
+                // default: false
+                return _useDomainPrefixes ?? GetKeyValue("/settings/requestHandler/useDomainPrefixes", false);
 			}
-			// for unit tests only
 			internal set
 			{
-				_useDomainPrefixes = value;
+                // for unit tests only
+                _useDomainPrefixes = value;
 			}
 		}
 
@@ -382,31 +418,14 @@ namespace Umbraco.Core.Configuration
 		{
 			get
 			{
-				try
-				{
-					if (GlobalSettings.UseDirectoryUrls)
-					{
-						if (_addTrailingSlash.HasValue)
-							return _addTrailingSlash.Value;
-						bool result;
-						if (bool.TryParse(GetKey("/settings/requestHandler/addTrailingSlash"), out result))
-							return result;
-						return false;
-					}
-					else
-					{
-						return false;
-					}
-				}
-				catch
-				{
-					return false;
-				}
+                // default: false
+                return GlobalSettings.UseDirectoryUrls
+                    && (_addTrailingSlash ?? GetKeyValue("/settings/requestHandler/addTrailingSlash", false));
 			}
-			// for unit tests only
 			internal set
 			{
-				_addTrailingSlash = value;
+                // for unit tests only
+                _addTrailingSlash = value;
 			}
 		}
 
@@ -623,31 +642,34 @@ namespace Umbraco.Core.Configuration
 		{
 			get
 			{
-				if (_forceSafeAliases.HasValue)
-					return _forceSafeAliases.Value;
-
-				string forceSafeAlias = GetKey("/settings/content/ForceSafeAliases");
-				if (String.IsNullOrEmpty(forceSafeAlias))
-					return true;
-				else
-				{
-					try
-					{
-						return bool.Parse(forceSafeAlias);
-					}
-					catch
-					{
-						return true;
-					}
-				}
+                // default: true
+                return _forceSafeAliases ?? GetKeyValue("/settings/content/ForceSafeAliases", true);
 			}
 			internal set
 			{
-				//used for unit  testing
+				// used for unit  testing
 				_forceSafeAliases = value;
 			}
 		}
 
+        private static bool? _trySkipIisCustomErrors;
+
+        /// <summary>
+        /// Gets or sets a value indicating where to try to skip IIS custom errors.
+        /// </summary>
+        public static bool TrySkipIisCustomErrors
+        {
+            get
+            {
+                // default: false
+                return _trySkipIisCustomErrors ?? GetKeyValue("/settings/web.routing/@trySkipIisCustomErrors", false);
+            }
+            internal set
+            {
+                // used for unit  testing
+                _trySkipIisCustomErrors = value;
+            }
+        }
 
 		/// <summary>
 		/// Gets the allowed image file types.
@@ -677,26 +699,14 @@ namespace Umbraco.Core.Configuration
 		{
 			get
 			{
-				if (_umbracoLibraryCacheDuration.HasValue)
-					return _umbracoLibraryCacheDuration.Value;
-				
-				string libraryCacheDuration = GetKey("/settings/content/UmbracoLibraryCacheDuration");
-				if (String.IsNullOrEmpty(libraryCacheDuration))
-					return 1800;
-				else
-				{
-					try
-					{
-						return int.Parse(libraryCacheDuration);
-					}
-					catch
-					{
-						return 1800;
-					}
-				}
-
+                // default: 1800
+                return _umbracoLibraryCacheDuration ?? GetKeyValue("/settings/content/UmbracoLibraryCacheDuration", 1800);
 			}
-			internal set { _umbracoLibraryCacheDuration = value; }
+			internal set
+            {
+                // for unit tests only
+                _umbracoLibraryCacheDuration = value;
+            }
 		}
 
 		/// <summary>
@@ -1052,27 +1062,12 @@ namespace Umbraco.Core.Configuration
 		{
 			get
 			{
-				try
-				{
-					if (_useLegacySchema.HasValue)
-						return _useLegacySchema.Value;
-
-					string value = GetKey("/settings/content/UseLegacyXmlSchema");
-					bool result;
-					if (!string.IsNullOrEmpty(value) && bool.TryParse(value, out result))
-						return result;
-					return true;
-				}
-				catch (Exception)
-				{
-					//default. TODO: When we change this to a real config section we won't have to worry about parse errors
-					// and should handle defaults with unit tests properly.
-					return false;
-				}
+                // default: true
+                return _useLegacySchema ?? GetKeyValue("/settings/content/UseLegacyXmlSchema", false);
 			}
 			internal set
 			{
-				//used for unit  testing
+				// used for unit testing
 				_useLegacySchema = value;
 			}
 		}
@@ -1221,6 +1216,40 @@ namespace Umbraco.Core.Configuration
 			}
 		}
 
+		private static MacroErrorBehaviour? _macroErrorBehaviour;
+
+		/// <summary>
+		/// This configuration setting defines how to handle macro errors:
+		/// - Inline - Show error within macro as text (default and current Umbraco 'normal' behavior)
+		/// - Silent - Suppress error and hide macro
+		/// - Throw  - Throw an exception and invoke the global error handler (if one is defined, if not you'll get a YSOD)
+		/// </summary>
+		/// <value>MacroErrorBehaviour enum defining how to handle macro errors.</value>
+		public static MacroErrorBehaviour MacroErrorBehaviour
+		{
+			get
+			{
+				if (_macroErrorBehaviour == null)
+				{
+					try
+					{
+						var behaviour = MacroErrorBehaviour.Inline;
+						var value = GetKey("/settings/content/MacroErrors");
+						if (value != null)
+						{
+							Enum<MacroErrorBehaviour>.TryParse(value, true, out behaviour);
+						}
+						_macroErrorBehaviour = behaviour;
+					}
+					catch (Exception ex)
+					{
+						LogHelper.Error<UmbracoSettings>("Could not load /settings/content/MacroErrors from umbracosettings.config", ex);
+						_macroErrorBehaviour = MacroErrorBehaviour.Inline;
+					}
+				}
+				return _macroErrorBehaviour.Value;
+			}
+		}
 
 		/// <summary>
 		/// Configuration regarding webservices

src/Umbraco.Core/Configuration/UmbracoVersion.cs

@@ -5,7 +5,7 @@ namespace Umbraco.Core.Configuration
 {
     public class UmbracoVersion
     {
-        private static readonly Version Version = new Version("6.0.0");
+        private static readonly Version Version = new Version("6.0.3");
 
         /// <summary>
         /// Gets the current version of Umbraco.

src/Umbraco.Core/CoreBootManager.cs

@@ -1,7 +1,5 @@
 using System;
 using System.Collections.Generic;
-using System.Linq;
-using System.Text;
 using Umbraco.Core.Configuration;
 using Umbraco.Core.Logging;
 using Umbraco.Core.ObjectResolution;
@@ -9,6 +7,8 @@ using Umbraco.Core.Persistence;
 using Umbraco.Core.Persistence.Mappers;
 using Umbraco.Core.Persistence.Migrations;
 using Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSix;
+using Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSixZeroOne;
+using Umbraco.Core.Persistence.SqlSyntax;
 using Umbraco.Core.Persistence.UnitOfWork;
 using Umbraco.Core.PropertyEditors;
 using Umbraco.Core.Publishing;
@@ -60,27 +60,36 @@ namespace Umbraco.Core
 				new PetaPocoUnitOfWorkProvider(dbFactory), 
 				new FileUnitOfWorkProvider(), 
 				new PublishingStrategy());
-			
-			//create the ApplicationContext
-			ApplicationContext = ApplicationContext.Current = new ApplicationContext(dbContext, serviceContext);
 
-            //initialize the DatabaseContext
-			dbContext.Initialize();
+            CreateApplicationContext(dbContext, serviceContext);
 
             InitializeApplicationEventsResolver();
 
 			InitializeResolvers();
-            
+
+            //initialize the DatabaseContext
+            dbContext.Initialize();
+
             //now we need to call the initialize methods
             ApplicationEventsResolver.Current.ApplicationEventHandlers
                 .ForEach(x => x.OnApplicationInitialized(UmbracoApplication, ApplicationContext));
 
-
 			_isInitialized = true;
 
 			return this;
 		}
 
+        /// <summary>
+        /// Creates and assigns the application context singleton
+        /// </summary>
+        /// <param name="dbContext"></param>
+        /// <param name="serviceContext"></param>
+        protected virtual void CreateApplicationContext(DatabaseContext dbContext, ServiceContext serviceContext)
+        {
+            //create the ApplicationContext
+            ApplicationContext = ApplicationContext.Current = new ApplicationContext(dbContext, serviceContext);
+        }
+
         /// <summary>
         /// Special method to initialize the ApplicationEventsResolver and any modifications required for it such 
         /// as adding custom types to the resolver.
@@ -110,15 +119,15 @@ namespace Umbraco.Core
 			if (_isStarted)
 				throw new InvalidOperationException("The boot manager has already been initialized");
 
-			if (afterStartup != null)
-			{
-				afterStartup(ApplicationContext.Current);	
-			}
-
             //call OnApplicationStarting of each application events handler
             ApplicationEventsResolver.Current.ApplicationEventHandlers
                 .ForEach(x => x.OnApplicationStarting(UmbracoApplication, ApplicationContext));
 
+            if (afterStartup != null)
+            {
+                afterStartup(ApplicationContext.Current);
+            }
+
 			_isStarted = true;
 
 			return this;
@@ -134,21 +143,23 @@ namespace Umbraco.Core
 			if (_isComplete)
 				throw new InvalidOperationException("The boot manager has already been completed");
 
-			//freeze resolution to not allow Resolvers to be modified
-			Resolution.Freeze();
+		    FreezeResolution();
 
 			//stop the timer and log the output
 			_timer.Dispose();
 
-			if (afterComplete != null)
-			{
-				afterComplete(ApplicationContext.Current);	
-			}
-
             //call OnApplicationStarting of each application events handler
             ApplicationEventsResolver.Current.ApplicationEventHandlers
                 .ForEach(x => x.OnApplicationStarted(UmbracoApplication, ApplicationContext));
 
+            //Now, startup all of our legacy startup handler
+            ApplicationEventsResolver.Current.InstantiateLegacyStartupHanlders();
+
+            if (afterComplete != null)
+            {
+                afterComplete(ApplicationContext.Current);
+            }
+
 			_isComplete = true;
 
             // we're ready to serve content!
@@ -157,6 +168,14 @@ namespace Umbraco.Core
 			return this;
 		}
 
+        /// <summary>
+        /// Freeze resolution to not allow Resolvers to be modified
+        /// </summary>
+        protected virtual void FreezeResolution()
+        {
+            Resolution.Freeze();
+        }
+
 		/// <summary>
 		/// Create the resolvers
 		/// </summary>
@@ -165,20 +184,26 @@ namespace Umbraco.Core
 			RepositoryResolver.Current = new RepositoryResolver(
 				new RepositoryFactory());
 
+		    SqlSyntaxProvidersResolver.Current = new SqlSyntaxProvidersResolver(
+                new[] { typeof(MySqlSyntaxProvider), typeof(SqlCeSyntaxProvider), typeof(SqlServerSyntaxProvider) })
+		        {
+		            CanResolveBeforeFrozen = true
+		        };
+
 			CacheRefreshersResolver.Current = new CacheRefreshersResolver(
-				PluginManager.Current.ResolveCacheRefreshers());
+				() => PluginManager.Current.ResolveCacheRefreshers());
 
 			DataTypesResolver.Current = new DataTypesResolver(
-				PluginManager.Current.ResolveDataTypes());
+				() => PluginManager.Current.ResolveDataTypes());
 
 			MacroFieldEditorsResolver.Current = new MacroFieldEditorsResolver(
-				PluginManager.Current.ResolveMacroRenderings());
+				() => PluginManager.Current.ResolveMacroRenderings());
 
 			PackageActionsResolver.Current = new PackageActionsResolver(
-				PluginManager.Current.ResolvePackageActions());
+				() => PluginManager.Current.ResolvePackageActions());
 
 			ActionsResolver.Current = new ActionsResolver(
-				PluginManager.Current.ResolveActions());
+				() => PluginManager.Current.ResolveActions());
 
             MacroPropertyTypeResolver.Current = new MacroPropertyTypeResolver(
                 PluginManager.Current.ResolveMacroPropertyTypes());
@@ -201,7 +226,8 @@ namespace Umbraco.Core
 					typeof (UpdateCmsContentTypeAllowedContentTypeTable),
 					typeof (UpdateCmsContentTypeTable),
 					typeof (UpdateCmsContentVersionTable),
-					typeof (UpdateCmsPropertyTypeGroupTable)
+					typeof (UpdateCmsPropertyTypeGroupTable),
+                    typeof (UpdatePropertyTypesAndGroups)
 				});
 
 			PropertyEditorValueConvertersResolver.Current = new PropertyEditorValueConvertersResolver(

src/Umbraco.Core/DataTypesResolver.cs

@@ -14,7 +14,7 @@ namespace Umbraco.Core
 		/// Constructor
 		/// </summary>
 		/// <param name="dataTypes"></param>		
-		internal DataTypesResolver(IEnumerable<Type> dataTypes)
+		internal DataTypesResolver(Func<IEnumerable<Type>> dataTypes)
 			: base(dataTypes)
 		{
 

src/Umbraco.Core/DatabaseContext.cs

@@ -112,7 +112,7 @@ namespace Umbraco.Core
         public void ConfigureEmbeddedDatabaseConnection()
         {
             const string providerName = "System.Data.SqlServerCe.4.0";
-            const string connectionString = "Datasource=|DataDirectory|Umbraco.sdf";
+            const string connectionString = @"Data Source=|DataDirectory|\Umbraco.sdf";
 
             SaveConnectionString(connectionString, providerName);
 
@@ -158,7 +158,7 @@ namespace Umbraco.Core
             }
             else if (databaseProvider.ToLower().Contains("azure"))
             {
-                connectionString = string.Format("Server=tcp:{0}.database.windows.net;Database={1};User ID={2}@{0};Password={3}", server, databaseName, user, password);
+                connectionString = BuildAzureConnectionString(server, databaseName, user, password);
             }
             else
             {
@@ -169,6 +169,52 @@ namespace Umbraco.Core
             Initialize(providerName);
         }
 
+        internal string BuildAzureConnectionString(string server, string databaseName, string user, string password)
+        {
+            if (server.Contains(".") && ServerStartsWithTcp(server) == false)
+                server = string.Format("tcp:{0}", server);
+            
+            if (server.Contains(".") == false && ServerStartsWithTcp(server))
+            {
+                string serverName = server.Contains(",") 
+                                        ? server.Substring(0, server.IndexOf(",", StringComparison.Ordinal)) 
+                                        : server;
+
+                var portAddition = string.Empty;
+
+                if (server.Contains(","))
+                    portAddition = server.Substring(server.IndexOf(",", StringComparison.Ordinal));
+
+                server = string.Format("{0}.database.windows.net{1}", serverName, portAddition);
+            }
+            
+            if (ServerStartsWithTcp(server) == false)
+                server = string.Format("tcp:{0}.database.windows.net", server);
+            
+            if (server.Contains(",") == false)
+                server = string.Format("{0},1433", server);
+
+            if (user.Contains("@") == false)
+            {
+                var userDomain = server;
+
+                if (ServerStartsWithTcp(server))
+                    userDomain = userDomain.Substring(userDomain.IndexOf(":", StringComparison.Ordinal) + 1);
+
+                if (userDomain.Contains("."))
+                    userDomain = userDomain.Substring(0, userDomain.IndexOf(".", StringComparison.Ordinal));
+
+                user = string.Format("{0}@{1}", user, userDomain);
+            }
+
+            return string.Format("Server={0};Database={1};User ID={2};Password={3}", server, databaseName, user, password);
+        }
+
+        private static bool ServerStartsWithTcp(string server)
+        {
+            return server.ToLower().StartsWith("tcp:".ToLower());
+        }
+
         /// <summary>
         /// Saves the connection string as a proper .net ConnectionString and the legacy AppSettings key/value.
         /// </summary>
@@ -218,7 +264,7 @@ namespace Umbraco.Core
 
             xml.Save(fileName, SaveOptions.DisableFormatting);
 
-            LogHelper.Info<DatabaseContext>("Configured new ConnectionString: " + connectionString);
+            LogHelper.Info<DatabaseContext>("Configured a new ConnectionString using the '" + providerName + "' provider.");
         }
 
         /// <summary>
@@ -232,7 +278,8 @@ namespace Umbraco.Core
         /// </remarks>
         internal void Initialize()
         {
-            if (ConfigurationManager.ConnectionStrings[GlobalSettings.UmbracoConnectionName] != null)
+            var databaseSettings = ConfigurationManager.ConnectionStrings[GlobalSettings.UmbracoConnectionName];
+            if (databaseSettings != null && string.IsNullOrWhiteSpace(databaseSettings.ConnectionString) == false && string.IsNullOrWhiteSpace(databaseSettings.ProviderName) == false)
             {
                 var providerName = "System.Data.SqlClient";
                 if (!string.IsNullOrEmpty(ConfigurationManager.ConnectionStrings[GlobalSettings.UmbracoConnectionName].ProviderName))
@@ -254,8 +301,7 @@ namespace Umbraco.Core
                 {
                     ConfigureEmbeddedDatabaseConnection();
                 }
-                else if (legacyConnString.ToLowerInvariant().Contains("database.windows.net") &&
-                         legacyConnString.ToLowerInvariant().Contains("tcp:"))
+                else if (legacyConnString.ToLowerInvariant().Contains("tcp:"))
                 {
                     //Must be sql azure
                     SaveConnectionString(legacyConnString, "System.Data.SqlClient");
@@ -291,21 +337,22 @@ namespace Umbraco.Core
 
         internal void Initialize(string providerName)
         {
-            if (providerName.StartsWith("MySql"))
-            {
-                SyntaxConfig.SqlSyntaxProvider = MySqlSyntax.Provider;
-            }
-            else if (providerName.Contains("SqlServerCe"))
-            {
-                SyntaxConfig.SqlSyntaxProvider = SqlCeSyntax.Provider;
-            }
-            else
-            {
-                SyntaxConfig.SqlSyntaxProvider = SqlServerSyntax.Provider;
-            }
-
             _providerName = providerName;
-            _configured = true;
+
+            try
+            {
+                SqlSyntaxContext.SqlSyntaxProvider =
+                    SqlSyntaxProvidersResolver.Current.GetByProviderNameOrDefault(providerName);
+                
+                _configured = true;
+            }
+            catch (Exception e)
+            {
+                _configured = false;
+
+                LogHelper.Info<DatabaseContext>("Initialization of the DatabaseContext failed with following error: " + e.Message);
+                LogHelper.Info<DatabaseContext>(e.StackTrace);
+            }
         }
 
         internal DatabaseSchemaResult ValidateDatabaseSchema()
@@ -337,16 +384,56 @@ namespace Umbraco.Core
 
             try
             {
+                LogHelper.Info<DatabaseContext>("Database configuration status: Started");
+
+                var message = string.Empty;
+
                 var database = new UmbracoDatabase(_connectionString, ProviderName);
+                var supportsCaseInsensitiveQueries = SqlSyntaxContext.SqlSyntaxProvider.SupportsCaseInsensitiveQueries(database);
+                if (supportsCaseInsensitiveQueries  == false)
+                {
+                    message = "<p>&nbsp;</p><p>The database you're trying to use does not support case insensitive queries. <br />We currently do not support these types of databases.</p>" +
+                              "<p>You can fix this by changing the following two settings in your my.ini file in your MySQL installation directory:</p>" +
+                              "<pre>lower_case_table_names=1\nlower_case_file_system=1</pre><br />" +
+                              "<p>Note: Make sure to check with your hosting provider if they support case insensitive queries as well.</p>" +
+                              "<p>For more technical information on case sensitivity in MySQL, have a look at " +
+                              "<a href='http://dev.mysql.com/doc/refman/5.0/en/identifier-case-sensitivity.html'>the documentation on the subject</a></p>";
+
+                    return new Result { Message = message, Success = false, Percentage = "15" };
+                }
+                else if (supportsCaseInsensitiveQueries == null)
+                {
+                    message = "<p>&nbsp;</p><p>Warning! Could not check if your database type supports case insensitive queries. <br />We currently do not support these databases that do not support case insensitive queries.</p>" +
+                              "<p>You can check this by looking for the following two settings in your my.ini file in your MySQL installation directory:</p>" +
+                              "<pre>lower_case_table_names=1\nlower_case_file_system=1</pre><br />" +
+                              "<p>Note: Make sure to check with your hosting provider if they support case insensitive queries as well.</p>" +
+                              "<p>For more technical information on case sensitivity in MySQL, have a look at " +
+                              "<a href='http://dev.mysql.com/doc/refman/5.0/en/identifier-case-sensitivity.html'>the documentation on the subject</a></p>";
+                }
+                else
+                {
+                    if (SqlSyntaxContext.SqlSyntaxProvider.GetType() == typeof(MySqlSyntaxProvider))
+                    {
+                        message = "<p>&nbsp;</p><p>Congratulations, the database step ran successfully!</p>" +
+                                  "<p>Note: You're using MySQL and the database instance you're connecting to seems to support case insensitive queries.</p>" +
+                                  "<p>However, your hosting provider may not support this option. Umbraco does not currently support MySQL installs that do not support case insensitive queries</p>" +
+                                  "<p>Make sure to check with your hosting provider if they support case insensitive queries as well.</p>" +
+                                  "<p>They can check this by looking for the following two settings in the my.ini file in their MySQL installation directory:</p>" +
+                                  "<pre>lower_case_table_names=1\nlower_case_file_system=1</pre><br />" +
+                                  "<p>For more technical information on case sensitivity in MySQL, have a look at " +
+                                  "<a href='http://dev.mysql.com/doc/refman/5.0/en/identifier-case-sensitivity.html'>the documentation on the subject</a></p>";
+                    }
+                }
+
                 var schemaResult = ValidateDatabaseSchema();
                 var installedVersion = schemaResult.DetermineInstalledVersion();
-                string message;
+                
 
                 //If Configuration Status is empty and the determined version is "empty" its a new install - otherwise upgrade the existing
                 if (string.IsNullOrEmpty(GlobalSettings.ConfigurationStatus) && installedVersion.Equals(new Version(0, 0, 0)))
                 {
                     database.CreateDatabaseSchema();
-                    message = "Installation completed!";
+                    message = message + "<p>Installation completed!</p>";
                 }
                 else
                 {
@@ -356,9 +443,11 @@ namespace Umbraco.Core
                     var targetVersion = UmbracoVersion.Current;
                     var runner = new MigrationRunner(configuredVersion, targetVersion, GlobalSettings.UmbracoMigrationName);
                     var upgraded = runner.Execute(database, true);
-                    message = "Upgrade completed!";
+                    message = message + "<p>Upgrade completed!</p>";
                 }
 
+                LogHelper.Info<DatabaseContext>("Database configuration status: " + message);
+
                 return new Result { Message = message, Success = true, Percentage = "100" };
             }
             catch (Exception ex)
@@ -374,7 +463,7 @@ namespace Umbraco.Core
                            {
                                Message =
                                    "The database configuration failed with the following message: " + ex.Message +
-                                   "\n Please check log file for addtional information (can be found in '/App_Data/Logs/UmbracoTraceLog.txt')",
+                                   "\n Please check log file for additional information (can be found in '/App_Data/Logs/UmbracoTraceLog.txt')",
                                Success = false,
                                Percentage = "90"
                            };

src/Umbraco.Core/Dictionary/CultureDictionaryFactoryResolver.cs

@@ -5,7 +5,7 @@ namespace Umbraco.Core.Dictionary
 	/// <summary>
 	/// Resolves the current CultureDictionaryFactory
 	/// </summary>
-	internal class CultureDictionaryFactoryResolver : SingleObjectResolverBase<CultureDictionaryFactoryResolver, ICultureDictionaryFactory>
+	internal sealed class CultureDictionaryFactoryResolver : SingleObjectResolverBase<CultureDictionaryFactoryResolver, ICultureDictionaryFactory>
 	{
 		internal CultureDictionaryFactoryResolver(ICultureDictionaryFactory factory)
 			: base(factory)

src/Umbraco.Core/Dynamics/DynamicXml.cs

@@ -9,35 +9,106 @@ using System.Xml.XPath;
 using System.Collections;
 using System.IO;
 using System.Web;
+using Umbraco.Core;
 
 namespace Umbraco.Core.Dynamics
 {
 	[TypeConverter(typeof(DynamicXmlConverter))]
 	public class DynamicXml : DynamicObject, IEnumerable<DynamicXml>, IEnumerable<XElement>
     {
+        /// <summary>
+        /// Returns the XElement used to create the DynamicXml structure
+        /// </summary>
         public XElement BaseElement { get; set; }
 
+	    /// <summary>
+        /// Returns the raw XElement used to create the DynamicXml structure if one was specified otherwise returns the 
+        /// same value as BaseElement.
+        /// </summary>
+        /// <remarks>
+        /// This is purely used for when an instance of DynamicXml is created with the overload that supports
+        /// passing in both a raw xml version and a dash-stripped xml version. Otherwise this value is exactly the 
+        /// same as BaseElement.
+        /// </remarks>
+        public XElement RawXmlElement { get; internal set; }
+
+        /// <summary>
+        /// Constructor
+        /// </summary>
+        /// <param name="baseElement"></param>
         public DynamicXml(XElement baseElement)
         {
-            this.BaseElement = baseElement;
+            if (baseElement == null) return;
+
+            //same
+            RawXmlElement = baseElement;
+            BaseElement = baseElement;
         }
-        public DynamicXml(string xml)
+
+        /// <summary>
+        /// When this constructor is used the BaseElement becomes equivalent to the strippedXml structure
+        /// </summary>
+        /// <param name="strippedXml"></param>
+        /// <param name="rawXml"></param>
+        internal DynamicXml(XElement strippedXml, XElement rawXml)
         {
-            var baseElement = XElement.Parse(xml);
-            this.BaseElement = baseElement;
+            if (rawXml == null) return;
+            if (strippedXml == null) return;
+
+            RawXmlElement = rawXml;
+            BaseElement = strippedXml;
         }
+
+        /// <summary>
+        /// When this constructor is used the BaseElement becomes equivalent to the strippedXml structure
+        /// </summary>
+        /// <param name="strippedXml"></param>
+        /// <param name="rawXml"></param>
+        internal DynamicXml(string strippedXml, string rawXml)
+        {
+            if (rawXml == null) return;
+            if (strippedXml == null) return;
+
+            RawXmlElement = XElement.Parse(rawXml);
+            BaseElement = XElement.Parse(strippedXml);
+        }
+
+        /// <summary>
+        /// Constructor
+        /// </summary>
+        /// <param name="xml"></param>
+	    public DynamicXml(string xml)
+        {
+            if (xml.IsNullOrWhiteSpace()) return;
+
+            var baseElement = XElement.Parse(xml);
+            
+            //same
+            RawXmlElement = baseElement;
+            BaseElement = baseElement;
+        }
+
+        /// <summary>
+        /// Constructor
+        /// </summary>
+        /// <param name="xpni"></param>
         public DynamicXml(XPathNodeIterator xpni)
         {
-            if (xpni != null)
-            {
-                if (xpni.Current != null)
-                {
-                    var xml = xpni.Current.OuterXml;
-                    var baseElement = XElement.Parse(xml);
-                    this.BaseElement = baseElement;
-                }
-            }
+            if (xpni == null) return;
+            if (xpni.Current == null) return;
+
+            //TODO: OuterXml is really bad for performance! Should actually use the XPathNodeIterator api
+            var xml = xpni.Current.OuterXml;                    
+            var baseElement = XElement.Parse(xml);
+            
+            //same
+            RawXmlElement = baseElement;
+            BaseElement = baseElement;
         }
+
+	    /// <summary>
+        /// Returns the InnertText based on the BaseElement object
+        /// </summary>
         public string InnerText
         {
             get
@@ -45,17 +116,34 @@ namespace Umbraco.Core.Dynamics
                 return BaseElement.Value;
             }
         }
+
+        /// <summary>
+        /// Returns the string representation of the BaseElement object
+        /// </summary>
+        /// <returns></returns>
         public string ToXml()
         {
             return BaseElement.ToString(SaveOptions.DisableFormatting);
         }
+
+        /// <summary>
+        /// Returns the string representation of the RawXmlElement object
+        /// </summary>
+        /// <returns></returns>
+        public string ToRawXml()
+        {
+            return RawXmlElement.ToString(SaveOptions.DisableFormatting);
+        }
+
         public override bool TryGetIndex(GetIndexBinder binder, object[] indexes, out object result)
         {
             int index = 0;
             if (indexes.Length > 0)
             {
                 index = (int)indexes[0];
-                result = new DynamicXml(this.BaseElement.Elements().ToList()[index]);
+                result = new DynamicXml(
+                    RawXmlElement.Elements().ElementAt(index),
+                    BaseElement.Elements().ElementAt(index));
                 return true;
             }
             return base.TryGetIndex(binder, indexes, out result);
@@ -64,12 +152,12 @@ namespace Umbraco.Core.Dynamics
         {
             if (args.Length == 0 && binder.Name == "ToXml")
             {
-                result = this.BaseElement.ToString();
+                result = BaseElement.ToString();
                 return true;
             }
             if (args.Length == 1 && binder.Name == "XPath")
             {
-                var elements = this.BaseElement.XPathSelectElements(args[0].ToString());
+                var elements = BaseElement.XPathSelectElements(args[0].ToString());
                 HandleIEnumerableXElement(elements, out result);
                 return true; //anyway
             }
@@ -102,7 +190,9 @@ namespace Umbraco.Core.Dynamics
 						}
 						else if (attempt.Result.ObjectResult is IEnumerable<DynamicXml>)
 						{
-							result = ((IEnumerable<DynamicXml>)attempt.Result.ObjectResult).Select(x => new DynamicXml(x.BaseElement));
+						    result = ((IEnumerable<DynamicXml>) attempt.Result.ObjectResult).Select(x => new DynamicXml(
+						                                                                                     x.RawXmlElement,
+						                                                                                     x.BaseElement));
 						}
 					}
 				}
@@ -123,55 +213,102 @@ namespace Umbraco.Core.Dynamics
         }
         public override bool TryGetMember(GetMemberBinder binder, out object result)
         {
-            if (BaseElement == null || binder == null)
+            if (RawXmlElement == null || binder == null)
             {
                 result = null;
                 return false;
             }
-            //Go ahead and try to fetch all of the elements matching the member name, and wrap them
-            var elements = BaseElement.Elements(binder.Name);
-            if (!elements.Any() && BaseElement.Name == "root" && BaseElement.Elements().Count() == 1)
-            {
-                //no elements matched, lets try first child
-                elements = BaseElement.Elements().ElementAt(0).Elements(binder.Name);
-            }
-            if (HandleIEnumerableXElement(elements, out result))
-            {
-                return true;
-            }
-            else
-            {
 
-                //Ok, so no elements matched, so lets try attributes
-                IEnumerable<string> attributes = BaseElement.Attributes(binder.Name).Select(attr => attr.Value);
-                int count = attributes.Count();
-
-                if (count > 0)
+            //Check if the name matches a node based on the BaseElement (which if the correct ctor is used, will be dash stripped)
+            var elementByNameAttempt = CheckNodeNameMatch(binder.Name, BaseElement);
+            if (elementByNameAttempt.Success)
+            {
+                if (HandleIEnumerableXElement(elementByNameAttempt.Result, out result))
                 {
-                    if (count > 1)
-                        result = attributes; //more than one attribute matched, lets return the collection
-                    else
-                        result = attributes.FirstOrDefault(); //only one attribute matched, lets just return it
+                    return true;
+                }
+            }
 
-                    return true; // return true because we matched
+            //Check if the name matches a node based on the BaseElement (which if the correct ctor is used, will be dash stripped)
+            var attributeByNameAttempt = CheckAttributeNameMatch(binder.Name, BaseElement);
+            if (attributeByNameAttempt.Success)
+            {
+                if (attributeByNameAttempt.Result.Count() > 1)
+                {
+                    //more than one attribute matched, lets return the collection
+                    result = attributeByNameAttempt.Result;
                 }
                 else
                 {
-                    //no attributes matched, lets try first child
-                    if (BaseElement.Name == "root" && BaseElement.Elements().Count() == 1)
-                    {
-                        attributes = BaseElement.Elements().ElementAt(0).Attributes(binder.Name).Select(attr => attr.Value);
-                        count = attributes.Count();
-                        if (count > 1)
-                            result = attributes; //more than one attribute matched, lets return the collection
-                        else
-                            result = attributes.FirstOrDefault(); //only one attribute matched, lets just return it
+                    //only one attribute matched, lets just return it
+                    result = attributeByNameAttempt.Result.FirstOrDefault(); 
+                }
+                return true; 
+            }
+           
 
-                        return true; // return true because we matched
-                    }
+            return base.TryGetMember(binder, out result);
+        }
+
+        /// <summary>
+        /// Checks if the 'name' matches any attributes of xmlElement
+        /// </summary>
+        /// <param name="name">The name to match</param>
+        /// <param name="xmlElement">The xml element to check against</param>
+        /// <returns></returns>
+        private static Attempt<IEnumerable<string>> CheckAttributeNameMatch(string name, XElement xmlElement)
+        {
+            var attributes = xmlElement.Attributes(name).Select(attr => attr.Value).ToArray();
+            if (attributes.Any())
+            {
+                return new Attempt<IEnumerable<string>>(true, attributes);
+            }
+
+            if (!attributes.Any() && xmlElement.Name == "root" && xmlElement.Elements().Count() == 1)
+            {
+                //no elements matched and this node is called 'root' and only has one child... lets see if it matches.
+                var childElements = xmlElement.Elements().ElementAt(0).Attributes(name).Select(attr => attr.Value).ToArray();
+                if (childElements.Any())
+                {
+                    //we've found a match by the first child of an element called 'root' (strange, but sure)
+                    return new Attempt<IEnumerable<string>>(true, childElements);
+                }
+            }            
+
+            //no deal
+            return Attempt<IEnumerable<string>>.False;
+	    }
+
+	    /// <summary>
+        /// Checks if the 'name' matches any elements of xmlElement
+        /// </summary>
+        /// <param name="name">The name to match</param>
+        /// <param name="xmlElement">The xml element to check against</param>
+        /// <returns></returns>
+        private Attempt<IEnumerable<XElement>> CheckNodeNameMatch(string name, XElement xmlElement)
+        {
+            //Go ahead and try to fetch all of the elements matching the member name, and wrap them
+            var elements = xmlElement.Elements(name).ToArray();
+
+            //Check if we've got any matches, if so then return true
+            if (elements.Any())
+            {
+                return new Attempt<IEnumerable<XElement>>(true, elements);
+            }
+
+            if (!elements.Any() && xmlElement.Name == "root" && xmlElement.Elements().Count() == 1)
+            {
+                //no elements matched and this node is called 'root' and only has one child... lets see if it matches.
+                var childElements = xmlElement.Elements().ElementAt(0).Elements(name).ToArray();
+                if (childElements.Any())
+                {
+                    //we've found a match by the first child of an element called 'root' (strange, but sure)
+                    return new Attempt<IEnumerable<XElement>>(true, childElements);
                 }
             }
-            return base.TryGetMember(binder, out result);
+            
+            //no deal
+            return Attempt<IEnumerable<XElement>>.False;
         }
 
         private bool HandleIEnumerableXElement(IEnumerable<XElement> elements, out object result)
@@ -193,7 +330,7 @@ namespace Umbraco.Core.Dynamics
                     //We have more than one matching element, so let's return the collection
                     //elements is IEnumerable<DynamicXml>
                     //but we want to be able to re-enter this code
-                    XElement root = new XElement(XName.Get("root"));
+                    var root = new XElement(XName.Get("root"));
                     root.Add(elements);
                     result = new DynamicXml(root);
 
@@ -205,10 +342,16 @@ namespace Umbraco.Core.Dynamics
             result = null;
             return false;
         }
+
+        /// <summary>
+        /// Executes an XPath expression over the BaseElement object
+        /// </summary>
+        /// <param name="expression"></param>
+        /// <returns></returns>
         public DynamicXml XPath(string expression)
         {
-            var matched = this.BaseElement.XPathSelectElements(expression);
-            DynamicXml root = new DynamicXml("<results/>");
+            var matched = BaseElement.XPathSelectElements(expression);
+            var root = new DynamicXml("<results/>");
             foreach (var element in matched)
             {
                 root.BaseElement.Add(element);
@@ -217,7 +360,7 @@ namespace Umbraco.Core.Dynamics
         }
 
 		/// <summary>
-		/// Return the string version of Xml
+        /// Return the string version of the BaseElement object
 		/// </summary>
 		/// <returns></returns>
 		public override string ToString()
@@ -231,23 +374,23 @@ namespace Umbraco.Core.Dynamics
         }
         public DynamicXml Find(string expression)
         {
-            return new DynamicXml(this.BaseElement.XPathSelectElements(expression).FirstOrDefault());
+            return new DynamicXml(BaseElement.XPathSelectElements(expression).FirstOrDefault());
         }
 
         public DynamicXml Find(string attributeName, object value)
         {
             string expression = string.Format("//*[{0}='{1}']", attributeName, value);
-            return new DynamicXml(this.BaseElement.XPathSelectElements(expression).FirstOrDefault());
+            return new DynamicXml(BaseElement.XPathSelectElements(expression).FirstOrDefault());
         }
 
 	    IEnumerator<XElement> IEnumerable<XElement>.GetEnumerator()
 	    {
-			return this.BaseElement.Elements().GetEnumerator();
+            return BaseElement.Elements().GetEnumerator();
 	    }
 
 	    public IEnumerator<DynamicXml> GetEnumerator()
 	    {
-			return this.BaseElement.Elements().Select(e => new DynamicXml(e)).GetEnumerator();
+            return BaseElement.Elements().Select(e => new DynamicXml(e)).GetEnumerator();
 	    }
 
 		IEnumerator IEnumerable.GetEnumerator()
@@ -310,7 +453,7 @@ namespace Umbraco.Core.Dynamics
         }
         public bool IsPosition(int index)
         {
-            if (this.BaseElement == null || this.BaseElement.Parent == null)
+            if (BaseElement == null || BaseElement.Parent == null)
             {
                 return false;
             }
@@ -318,7 +461,7 @@ namespace Umbraco.Core.Dynamics
         }
         public HtmlString IsPosition(int index, string valueIfTrue)
         {
-            if (this.BaseElement == null || this.BaseElement.Parent == null)
+            if (BaseElement == null || BaseElement.Parent == null)
             {
                 return new HtmlString(string.Empty);
             }
@@ -326,7 +469,7 @@ namespace Umbraco.Core.Dynamics
         }
         public HtmlString IsPosition(int index, string valueIfTrue, string valueIfFalse)
         {
-            if (this.BaseElement == null || this.BaseElement.Parent == null)
+            if (BaseElement == null || BaseElement.Parent == null)
             {
                 return new HtmlString(valueIfFalse);
             }
@@ -334,7 +477,7 @@ namespace Umbraco.Core.Dynamics
         }
         public bool IsModZero(int modulus)
         {
-            if (this.BaseElement == null || this.BaseElement.Parent == null)
+            if (BaseElement == null || BaseElement.Parent == null)
             {
                 return false;
             }
@@ -342,7 +485,7 @@ namespace Umbraco.Core.Dynamics
         }
         public HtmlString IsModZero(int modulus, string valueIfTrue)
         {
-            if (this.BaseElement == null || this.BaseElement.Parent == null)
+            if (BaseElement == null || BaseElement.Parent == null)
             {
                 return new HtmlString(string.Empty);
             }
@@ -350,7 +493,7 @@ namespace Umbraco.Core.Dynamics
         }
         public HtmlString IsModZero(int modulus, string valueIfTrue, string valueIfFalse)
         {
-            if (this.BaseElement == null || this.BaseElement.Parent == null)
+            if (BaseElement == null || BaseElement.Parent == null)
             {
                 return new HtmlString(valueIfFalse);
             }
@@ -359,7 +502,7 @@ namespace Umbraco.Core.Dynamics
 
         public bool IsNotModZero(int modulus)
         {
-            if (this.BaseElement == null || this.BaseElement.Parent == null)
+            if (BaseElement == null || BaseElement.Parent == null)
             {
                 return false;
             }
@@ -367,7 +510,7 @@ namespace Umbraco.Core.Dynamics
         }
         public HtmlString IsNotModZero(int modulus, string valueIfTrue)
         {
-            if (this.BaseElement == null || this.BaseElement.Parent == null)
+            if (BaseElement == null || this.BaseElement.Parent == null)
             {
                 return new HtmlString(string.Empty);
             }
@@ -573,7 +716,8 @@ namespace Umbraco.Core.Dynamics
         }
 		public IEnumerable<DynamicXml> Descendants(Func<XElement, bool> func)
         {
-            var flattenedNodes = this.BaseElement.Elements().Map(func, (XElement n) => { return n.Elements(); });
+            //var flattenedNodes = this.BaseElement.Elements().Map(func, n => n.Elements());
+		    var flattenedNodes = this.BaseElement.Elements().SelectMany(n => n.Elements()).Where(func);
             return flattenedNodes.ToList().ConvertAll(n => new DynamicXml(n));
         }
 		public IEnumerable<DynamicXml> DescendantsOrSelf()
@@ -582,7 +726,8 @@ namespace Umbraco.Core.Dynamics
         }
 		public IEnumerable<DynamicXml> DescendantsOrSelf(Func<XElement, bool> func)
         {
-            var flattenedNodes = this.BaseElement.Elements().Map(func, (XElement n) => { return n.Elements(); });
+            //var flattenedNodes = this.BaseElement.Elements().Map(func, n => n.Elements());
+		    var flattenedNodes = this.BaseElement.Elements().SelectMany(n => n.Elements()).Where(func);
             var list = new List<DynamicXml>();
             list.Add(this);
             list.AddRange(flattenedNodes.ToList().ConvertAll(n => new DynamicXml(n)));
@@ -689,57 +834,10 @@ namespace Umbraco.Core.Dynamics
             return test(this) ? new HtmlString(valueIfTrue) : new HtmlString(valueIfFalse);
         }
 
+        [Obsolete("Use XmlHelper.StripDashesInElementOrAttributeNames instead")]
         public static string StripDashesInElementOrAttributeNames(string xml)
         {
-            using (MemoryStream outputms = new MemoryStream())
-            {
-                using (TextWriter outputtw = new StreamWriter(outputms))
-                {
-                    using (MemoryStream ms = new MemoryStream())
-                    {
-                        using (TextWriter tw = new StreamWriter(ms))
-                        {
-                            tw.Write(xml);
-                            tw.Flush();
-                            ms.Position = 0;
-                            using (TextReader tr = new StreamReader(ms))
-                            {
-                                bool IsInsideElement = false, IsInsideQuotes = false;
-                                int ic = 0;
-                                while ((ic = tr.Read()) != -1)
-                                {
-                                    if (ic == (int)'<' && !IsInsideQuotes)
-                                    {
-                                        if (tr.Peek() != (int)'!')
-                                        {
-                                            IsInsideElement = true;
-                                        }
-                                    }
-                                    if (ic == (int)'>' && !IsInsideQuotes)
-                                    {
-                                        IsInsideElement = false;
-                                    }
-                                    if (ic == (int)'"')
-                                    {
-                                        IsInsideQuotes = !IsInsideQuotes;
-                                    }
-                                    if (!IsInsideElement || ic != (int)'-' || IsInsideQuotes)
-                                    {
-                                        outputtw.Write((char)ic);
-                                    }
-                                }
-
-                            }
-                        }
-                    }
-                    outputtw.Flush();
-                    outputms.Position = 0;
-                    using (TextReader outputtr = new StreamReader(outputms))
-                    {
-                        return outputtr.ReadToEnd();
-                    }
-                }
-            }
+            return XmlHelper.StripDashesInElementOrAttributeNames(xml);
         }
 
 	    

src/Umbraco.Core/Dynamics/DynamicXmlConverter.cs

@@ -7,6 +7,58 @@ using System.Xml.Linq;
 
 namespace Umbraco.Core.Dynamics
 {
+    /// <summary>
+    /// Used to return the raw xml string value from DynamicXml when using type converters
+    /// </summary>
+    public class RawXmlString
+    {
+        public string Value { get; private set; }
+
+        public RawXmlString(string value)
+        {
+            Value = value;
+        }
+    }
+
+    /// <summary>
+    /// Used to return the raw xml XElement value from DynamicXml when using type converters
+    /// </summary>
+    public class RawXElement
+    {
+        public XElement Value { get; private set; }
+
+        public RawXElement(XElement value)
+        {
+            Value = value;
+        }
+    }
+
+    /// <summary>
+    /// Used to return the raw xml XElement value from DynamicXml when using type converters
+    /// </summary>
+    public class RawXmlElement
+    {
+        public XmlElement Value { get; private set; }
+
+        public RawXmlElement(XmlElement value)
+        {
+            Value = value;
+        }
+    }
+
+    /// <summary>
+    /// Used to return the raw xml XmlDocument value from DynamicXml when using type converters
+    /// </summary>
+    public class RawXmlDocument
+    {
+        public XmlDocument Value { get; private set; }
+
+        public RawXmlDocument(XmlDocument value)
+        {
+            Value = value;
+        }
+    }
+
 	/// <summary>
 	/// A custom type converter for DynamicXml
 	/// </summary>
@@ -14,7 +66,17 @@ namespace Umbraco.Core.Dynamics
 	{
 		public override bool CanConvertTo(ITypeDescriptorContext context, Type sourceType)
 		{
-			var convertableTypes = new[] {typeof(string), typeof(XElement), typeof(XmlElement), typeof(XmlDocument)};
+			var convertableTypes = new[]
+			    {
+			        typeof(string), 
+                    typeof(XElement), 
+                    typeof(XmlElement), 
+                    typeof(XmlDocument),
+                    typeof(RawXmlString), 
+                    typeof(RawXElement), 
+                    typeof(RawXmlElement), 
+                    typeof(RawXmlDocument)
+			    };
 
 			return convertableTypes.Any(x => TypeHelper.IsTypeAssignableFrom(x, sourceType)) 
 			       || base.CanConvertFrom(context, sourceType);
@@ -34,6 +96,7 @@ namespace Umbraco.Core.Dynamics
 			{
 				return value.ToString();
 			}
+            
 			//XElement
 			if (TypeHelper.IsTypeAssignableFrom<XElement>(destinationType))
 			{
@@ -53,6 +116,34 @@ namespace Umbraco.Core.Dynamics
 				xDoc.LoadXml(dxml.ToString());
 				return xDoc;
 			}
+
+            //RAW values:
+            //string
+            if (TypeHelper.IsTypeAssignableFrom<RawXmlString>(destinationType))
+            {
+                return new RawXmlString(dxml.ToRawXml());
+            }
+            //XElement
+            if (TypeHelper.IsTypeAssignableFrom<RawXElement>(destinationType))
+            {
+                return new RawXElement(dxml.RawXmlElement);
+            }
+            //XmlElement
+            if (TypeHelper.IsTypeAssignableFrom<RawXmlElement>(destinationType))
+            {
+                var xDoc = new XmlDocument();
+                xDoc.LoadXml(dxml.ToRawXml());
+                return new RawXmlElement(xDoc.DocumentElement);
+            }
+            //XmlDocument
+            if (TypeHelper.IsTypeAssignableFrom<RawXmlDocument>(destinationType))
+            {
+                var xDoc = new XmlDocument();
+                xDoc.LoadXml(dxml.ToRawXml());
+                return new RawXmlDocument(xDoc);
+            }
+
+
 			return base.ConvertTo(context, culture, value, destinationType);
 		}
 	}

src/Umbraco.Core/Dynamics/ExtensionMethods.cs

@@ -5,36 +5,35 @@ using Umbraco.Core.Models;
 
 namespace Umbraco.Core.Dynamics
 {
+    [Obsolete("This class should not be used, it is just referenced by already obsoleted code and will be removed in the future")]
     internal static class ExtensionMethods
     {
-        public static IEnumerable<TSource> Map<TSource>(
-            this IEnumerable<TSource> source,
-            Func<TSource, bool> selectorFunction,
-            Func<TSource, IEnumerable<TSource>> getChildrenFunction)
-        {
-            if (!source.Any())
-            {
-                return source;
-            }
-            // Add what we have to the stack   
-            var flattenedList = source.Where(selectorFunction);
-            // Go through the input enumerable looking for children,   
-            // and add those if we have them   
-            foreach (TSource element in source)
-            {
-                var secondInner = getChildrenFunction(element);
-                if (secondInner.Any())
-                {
-                    secondInner = secondInner.Map(selectorFunction, getChildrenFunction);
-                }
-                flattenedList = flattenedList.Concat(secondInner);
-            }
-            return flattenedList;
-        }
-
-
-        
+        //public static IEnumerable<TSource> Map<TSource>(
+        //    this IEnumerable<TSource> source,
+        //    Func<TSource, bool> selectorFunction,
+        //    Func<TSource, IEnumerable<TSource>> getChildrenFunction)
+        //{
+        //    if (!source.Any())
+        //    {
+        //        return source;
+        //    }
+        //    // Add what we have to the stack   
+        //    var flattenedList = source.Where(selectorFunction);
+        //    // Go through the input enumerable looking for children,   
+        //    // and add those if we have them   
+        //    foreach (TSource element in source)
+        //    {
+        //        var secondInner = getChildrenFunction(element);
+        //        if (secondInner.Any())
+        //        {
+        //            secondInner = secondInner.Map(selectorFunction, getChildrenFunction);
+        //        }
+        //        flattenedList = flattenedList.Concat(secondInner);
+        //    }
+        //    return flattenedList;
+        //}
 
+        [Obsolete("This method should not be used and will be removed in the future")]
         public static bool ContainsAny(this string haystack, IEnumerable<string> needles)
         {
         	if (haystack == null) throw new ArgumentNullException("haystack");
@@ -44,6 +43,7 @@ namespace Umbraco.Core.Dynamics
             }
             return false;
         }
+        [Obsolete("This method should not be used and will be removed in the future")]
         public static bool ContainsAny(this string haystack, params string[] needles)
         {
         	if (haystack == null) throw new ArgumentNullException("haystack");
@@ -53,6 +53,7 @@ namespace Umbraco.Core.Dynamics
             }
             return false;
         }
+        [Obsolete("This method should not be used and will be removed in the future")]
 		public static bool ContainsAny(this string haystack, StringComparison comparison, IEnumerable<string> needles)
         {
         	if (haystack == null) throw new ArgumentNullException("haystack");
@@ -62,6 +63,7 @@ namespace Umbraco.Core.Dynamics
             }
             return false;
         }
+        [Obsolete("This method should not be used and will be removed in the future")]
         public static bool ContainsAny(this string haystack, StringComparison comparison, params string[] needles)
         {
         	if (haystack == null) throw new ArgumentNullException("haystack");
@@ -71,12 +73,13 @@ namespace Umbraco.Core.Dynamics
             }
             return false;
         }
+        [Obsolete("This method should not be used and will be removed in the future")]
         public static bool ContainsInsensitive(this string haystack, string needle)
         {
         	if (haystack == null) throw new ArgumentNullException("haystack");
         	return haystack.IndexOf(needle, StringComparison.CurrentCultureIgnoreCase) >= 0;
         }
-
+        [Obsolete("This method should not be used and will be removed in the future")]
     	public static bool HasValue(this string s)
         {
             return !string.IsNullOrWhiteSpace(s);

src/Umbraco.Core/Events/MacroErrorEventArgs.cs

@@ -0,0 +1,39 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Umbraco.Core.Events
+{
+    // Provides information on the macro that caused an error
+    public class MacroErrorEventArgs : System.EventArgs
+    {
+        /// <summary>
+        /// Name of the faulting macro. 
+        /// </summary>
+        public string Name { get; set; }
+
+        /// <summary>
+        /// Alias of the faulting macro. 
+        /// </summary>
+        public string Alias { get; set; }
+
+        /// <summary>
+        /// Filename, file path, fully qualified class name, or other key used by the macro engine to do it's processing of the faulting macro.
+        /// </summary>
+        public string ItemKey { get; set; }
+
+        /// <summary>
+        /// Exception raised.
+        /// </summary>
+        public Exception Exception { get; set; }
+
+        /// <summary>
+        /// Gets or sets the desired behaviour when a matching macro causes an error. See
+        /// <see cref="MacroErrorBehaviour"/> for definitions. By setting this in your event
+        /// you can override the default behaviour defined in UmbracoSettings.config.
+        /// </summary>
+        /// <value>Macro error behaviour enum.</value>
+        public MacroErrorBehaviour Behaviour { get; set; }
+    }
+}

src/Umbraco.Core/IO/IOHelper.cs

@@ -8,6 +8,7 @@ using System.IO;
 using System.Configuration;
 using System.Web;
 using System.Text.RegularExpressions;
+using System.Xml;
 using Umbraco.Core.Configuration;
 using Umbraco.Core.Logging;
 
@@ -230,6 +231,20 @@ namespace Umbraco.Core.IO
                 filePath = String.Empty;
             }
 
+            //Break up the file in name and extension before applying the UrlReplaceCharacters
+            var fileNamePart = filePath.Substring(0, filePath.LastIndexOf('.'));
+            var ext = filePath.Substring(filePath.LastIndexOf('.'));
+
+            //Because the file usually is downloadable as well we check characters against 'UmbracoSettings.UrlReplaceCharacters'
+            XmlNode replaceChars = UmbracoSettings.UrlReplaceCharacters;
+            foreach (XmlNode n in replaceChars.SelectNodes("char"))
+            {
+                if (n.Attributes.GetNamedItem("org") != null && n.Attributes.GetNamedItem("org").Value != "")
+                    fileNamePart = fileNamePart.Replace(n.Attributes.GetNamedItem("org").Value, XmlHelper.GetNodeValue(n));
+            }
+
+            filePath = string.Concat(fileNamePart, ext);
+
             // Adapted from: http://stackoverflow.com/a/4827510/5018
             // Combined both Reserved Characters and Character Data 
             // from http://en.wikipedia.org/wiki/Percent-encoding

src/Umbraco.Core/IO/MediaFileSystem.cs

@@ -1,8 +1,6 @@
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
-using System.Text;
-using Umbraco.Core.CodeAnnotations;
 using Umbraco.Core.Configuration;
 
 namespace Umbraco.Core.IO
@@ -27,6 +25,15 @@ namespace Umbraco.Core.IO
 			return propertyId.ToString() + seperator + fileName;
 		}
 
+        public string GetRelativePath(string subfolder, string fileName)
+        {
+            var seperator = UmbracoSettings.UploadAllowDirectories
+                ? Path.DirectorySeparatorChar
+                : '-';
+
+            return subfolder + seperator + fileName;
+        }
+
 		public IEnumerable<string> GetThumbnails(string path)
 		{
 			var parentDirectory = System.IO.Path.GetDirectoryName(path);

src/Umbraco.Core/IO/SystemDirectories.cs

@@ -183,16 +183,26 @@ namespace Umbraco.Core.IO
             }
         }
 
+	    private static string _root;
+        /// <summary>
+        /// Gets the root path of the application
+        /// </summary>
         public static string Root
         {
             get
             {
-                string appPath = HttpRuntime.AppDomainAppVirtualPath ?? string.Empty;
-                if (appPath == "/")
-                    appPath = string.Empty;
+                if (_root == null)
+                {
+                    string appPath = HttpRuntime.AppDomainAppVirtualPath ?? string.Empty;
+                    if (appPath == "/")
+                        appPath = string.Empty;
 
-                return appPath;
+                    _root = appPath;    
+                }
+                return _root;
             }
+            //Only required for unit tests
+            internal set { _root = value; }
         }
     }
 

src/Umbraco.Core/Logging/AsynchronousRollingFileAppender.cs

@@ -64,23 +64,28 @@ namespace Umbraco.Core.Logging
 			{
 				_forceStop = true;
 				var windowsIdentity = WindowsIdentity.GetCurrent();
-				base.Append(new LoggingEvent(new LoggingEventData
-					{
-						Level = Level.Error,
-						Message =
-							"Unable to clear out the AsynchronousRollingFileAppender buffer in the allotted time, forcing a shutdown",
-						TimeStamp = DateTime.UtcNow,
-						Identity = "",
-						ExceptionString = "",
-						UserName = windowsIdentity != null ? windowsIdentity.Name : "",
-						Domain = AppDomain.CurrentDomain.FriendlyName,
-						ThreadName = Thread.CurrentThread.ManagedThreadId.ToString(),
-						LocationInfo =
-							new LocationInfo(this.GetType().Name, "OnClose", "AsynchronousRollingFileAppender.cs", "59"),
-						LoggerName = this.GetType().FullName,
-						Properties = new PropertiesDictionary(),
-					})
-					);
+
+			    var logEvent = new LoggingEvent(new LoggingEventData
+			        {
+			            Level = global::log4net.Core.Level.Error,
+			            Message =
+			                "Unable to clear out the AsynchronousRollingFileAppender buffer in the allotted time, forcing a shutdown",
+			            TimeStamp = DateTime.UtcNow,
+			            Identity = "",
+			            ExceptionString = "",
+			            UserName = windowsIdentity != null ? windowsIdentity.Name : "",
+			            Domain = AppDomain.CurrentDomain.FriendlyName,
+			            ThreadName = Thread.CurrentThread.ManagedThreadId.ToString(),
+			            LocationInfo =
+			                new LocationInfo(this.GetType().Name, "OnClose", "AsynchronousRollingFileAppender.cs", "59"),
+			            LoggerName = this.GetType().FullName,
+			            Properties = new PropertiesDictionary(),
+			        });
+
+			    if (this.DateTimeStrategy != null)
+			    {
+                    base.Append(logEvent);
+			    }			    
 			}
 
 			base.OnClose();

src/Umbraco.Core/MacroErrorBehaviour.cs

@@ -0,0 +1,23 @@
+namespace Umbraco.Core
+{
+    public enum MacroErrorBehaviour
+    {
+        /// <summary>
+        /// Default umbraco behavior - show an inline error within the
+        /// macro but allow the page to continue rendering.
+        /// </summary>
+        Inline,
+
+        /// <summary>
+        /// Silently eat the error and do not display the offending macro.
+        /// </summary>
+        Silent,
+
+        /// <summary>
+        /// Throw an exception which can be caught by the global error handler
+        /// defined in Application_OnError. If no such error handler is defined
+        /// then you'll see the Yellow Screen Of Death (YSOD) error page.
+        /// </summary>
+        Throw
+    }
+}

src/Umbraco.Core/Media/MediaSubfolderCounter.cs

@@ -0,0 +1,58 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using Umbraco.Core.IO;
+
+namespace Umbraco.Core.Media
+{
+    /// <summary>
+    /// Internal singleton to handle the numbering of subfolders within the Media-folder.
+    /// When this class is initiated it will look for numbered subfolders and select the highest number,
+    /// which will be the start point for the naming of the next subfolders. If no subfolders exists
+    /// then the starting point will be 1000, ie. /media/1000/koala.jpg
+    /// </summary>
+    internal class MediaSubfolderCounter
+    {
+        #region Singleton
+
+        private long _numberedFolder = 1000;//Default starting point
+        private static readonly ReaderWriterLockSlim ClearLock = new ReaderWriterLockSlim();
+        private static readonly Lazy<MediaSubfolderCounter> Lazy = new Lazy<MediaSubfolderCounter>(() => new MediaSubfolderCounter());
+
+        public static MediaSubfolderCounter Current { get { return Lazy.Value; } }
+
+        private MediaSubfolderCounter()
+        {
+            var folders = new List<long>();
+            var fs = FileSystemProviderManager.Current.GetFileSystemProvider<MediaFileSystem>();
+            var directories = fs.GetDirectories("");
+            foreach (var directory in directories)
+            {
+                long dirNum;
+                if (long.TryParse(directory, out dirNum))
+                {
+                    folders.Add(dirNum);
+                }
+            }
+            var last = folders.OrderBy(x => x).LastOrDefault();
+            if(last != default(long))
+                _numberedFolder = last;
+        }
+
+        #endregion
+
+        /// <summary>
+        /// Returns an increment of the numbered media subfolders.
+        /// </summary>
+        /// <returns>A <see cref="System.Int64"/> value</returns>
+        public long Increment()
+        {
+            using (new ReadLock(ClearLock))
+            {
+                _numberedFolder = _numberedFolder + 1;
+                return _numberedFolder;
+            }
+        }
+    }
+}

src/Umbraco.Core/Models/ContentExtensions.cs

@@ -10,6 +10,7 @@ using System.Xml;
 using System.Xml.Linq;
 using Umbraco.Core.Configuration;
 using Umbraco.Core.IO;
+using Umbraco.Core.Media;
 using Umbraco.Core.Models.Membership;
 using Umbraco.Core.Persistence;
 using Umbraco.Core.Persistence.UnitOfWork;
@@ -57,16 +58,22 @@ namespace Umbraco.Core.Models
         /// <summary>
         /// Sets and uploads the file from a HttpPostedFileBase object as the property value
         /// </summary>
-        /// <param name="content"><see cref="IContent"/> to add property value to</param>
+        /// <param name="content"><see cref="IContentBase"/> to add property value to</param>
         /// <param name="propertyTypeAlias">Alias of the property to save the value on</param>
         /// <param name="value">The <see cref="HttpPostedFileBase"/> containing the file that will be uploaded</param>
         public static void SetValue(this IContentBase content, string propertyTypeAlias, HttpPostedFileBase value)
         {
+            // Ensure we get the filename without the path in IE in intranet mode 
+            // http://stackoverflow.com/questions/382464/httppostedfile-filename-different-from-ie
+            var fileName = value.FileName;
+            if (fileName.LastIndexOf(@"\") > 0)
+                fileName = fileName.Substring(fileName.LastIndexOf(@"\") + 1);
+
             var name =
                 IOHelper.SafeFileName(
-                    value.FileName.Substring(value.FileName.LastIndexOf(IOHelper.DirSepChar) + 1,
-                                             value.FileName.Length - value.FileName.LastIndexOf(IOHelper.DirSepChar) - 1)
-                         .ToLower());
+                    fileName.Substring(fileName.LastIndexOf(IOHelper.DirSepChar) + 1,
+                                       fileName.Length - fileName.LastIndexOf(IOHelper.DirSepChar) - 1)
+                            .ToLower());
 
             if (string.IsNullOrEmpty(name) == false)
                 SetFileOnContent(content, propertyTypeAlias, name, value.InputStream);
@@ -75,16 +82,22 @@ namespace Umbraco.Core.Models
         /// <summary>
         /// Sets and uploads the file from a HttpPostedFile object as the property value
         /// </summary>
-        /// <param name="content"><see cref="IContent"/> to add property value to</param>
+        /// <param name="content"><see cref="IContentBase"/> to add property value to</param>
         /// <param name="propertyTypeAlias">Alias of the property to save the value on</param>
         /// <param name="value">The <see cref="HttpPostedFile"/> containing the file that will be uploaded</param>
         public static void SetValue(this IContentBase content, string propertyTypeAlias, HttpPostedFile value)
         {
+            // Ensure we get the filename without the path in IE in intranet mode 
+            // http://stackoverflow.com/questions/382464/httppostedfile-filename-different-from-ie
+            var fileName = value.FileName;
+            if (fileName.LastIndexOf(@"\") > 0)
+                fileName = fileName.Substring(fileName.LastIndexOf(@"\") + 1);
+
             var name =
                 IOHelper.SafeFileName(
-                    value.FileName.Substring(value.FileName.LastIndexOf(IOHelper.DirSepChar) + 1,
-                                            value.FileName.Length - value.FileName.LastIndexOf(IOHelper.DirSepChar) - 1)
-                        .ToLower());
+                    fileName.Substring(fileName.LastIndexOf(IOHelper.DirSepChar) + 1,
+                                       fileName.Length - fileName.LastIndexOf(IOHelper.DirSepChar) - 1)
+                            .ToLower());
 
             if (string.IsNullOrEmpty(name) == false)
                 SetFileOnContent(content, propertyTypeAlias, name, value.InputStream);
@@ -93,13 +106,37 @@ namespace Umbraco.Core.Models
         /// <summary>
         /// Sets and uploads the file from a HttpPostedFileWrapper object as the property value
         /// </summary>
-        /// <param name="content"><see cref="IContent"/> to add property value to</param>
+        /// <param name="content"><see cref="IContentBase"/> to add property value to</param>
         /// <param name="propertyTypeAlias">Alias of the property to save the value on</param>
         /// <param name="value">The <see cref="HttpPostedFileWrapper"/> containing the file that will be uploaded</param>
         public static void SetValue(this IContentBase content, string propertyTypeAlias, HttpPostedFileWrapper value)
         {
-            if (string.IsNullOrEmpty(value.FileName) == false)
-                SetFileOnContent(content, propertyTypeAlias, value.FileName, value.InputStream);
+            // Ensure we get the filename without the path in IE in intranet mode 
+            // http://stackoverflow.com/questions/382464/httppostedfile-filename-different-from-ie
+            var fileName = value.FileName;
+            if (fileName.LastIndexOf(@"\") > 0)
+                fileName = fileName.Substring(fileName.LastIndexOf(@"\") + 1);
+
+            var name = IOHelper.SafeFileName(fileName);
+
+            if (string.IsNullOrEmpty(name) == false)
+                SetFileOnContent(content, propertyTypeAlias, name, value.InputStream);
+        }
+
+        /// <summary>
+        /// Sets and uploads the file from a <see cref="Stream"/> as the property value
+        /// </summary>
+        /// <param name="content"><see cref="IContentBase"/> to add property value to</param>
+        /// <param name="propertyTypeAlias">Alias of the property to save the value on</param>
+        /// <param name="fileName">Name of the file</param>
+        /// <param name="fileStream"><see cref="Stream"/> to save to disk</param>
+        public static void SetValue(this IContentBase content, string propertyTypeAlias, string fileName,
+                                    Stream fileStream)
+        {
+            var name = IOHelper.SafeFileName(fileName);
+
+            if (string.IsNullOrEmpty(name) == false && fileStream != null)
+                SetFileOnContent(content, propertyTypeAlias, name, fileStream);
         }
 
         private static void SetFileOnContent(IContentBase content, string propertyTypeAlias, string name, Stream fileStream)
@@ -109,10 +146,12 @@ namespace Umbraco.Core.Models
                 return;
 
             bool supportsResizing = false;
+            var numberedFolder = MediaSubfolderCounter.Current.Increment();
             string fileName = UmbracoSettings.UploadAllowDirectories
-                                              ? Path.Combine(property.Id.ToString(), name)
-                                              : property.Id + "-" + name;
-            string extension = Path.GetExtension(name);
+                                              ? Path.Combine(numberedFolder.ToString(CultureInfo.InvariantCulture), name)
+                                              : numberedFolder + "-" + name;
+
+            string extension = Path.GetExtension(name).Substring(1).ToLowerInvariant();
 
             var fs = FileSystemProviderManager.Current.GetFileSystemProvider<MediaFileSystem>();
             fs.AddFile(fileName, fileStream);
@@ -182,7 +221,7 @@ namespace Umbraco.Core.Models
         private static void SetPropertyValue(IContentBase content, XmlNode uploadFieldConfigNode, string propertyAlias, string propertyValue)
         {
             XmlNode propertyNode = uploadFieldConfigNode.SelectSingleNode(propertyAlias);
-            if (propertyNode != null && string.IsNullOrEmpty(propertyNode.FirstChild.Value) == false)
+            if (propertyNode != null && string.IsNullOrEmpty(propertyNode.FirstChild.Value) == false && content.HasProperty(propertyNode.FirstChild.Value))
             {
                 content.SetValue(propertyNode.FirstChild.Value, propertyValue);
             }
@@ -407,7 +446,7 @@ namespace Umbraco.Core.Models
                 //Check for umbracoUrlName convention
                 if (property.Alias == "umbracoUrlName" && property.Value != null && 
                         property.Value.ToString().Trim() != string.Empty)
-                    xml.SetAttributeValue("urlName", property.Value);
+                    xml.SetAttributeValue("urlName", property.Value.ToString().FormatUrl().ToLower());
             }
 
             return xml;

src/Umbraco.Core/Models/ContentTypeBase.cs

@@ -4,7 +4,6 @@ using System.Collections.Specialized;
 using System.Linq;
 using System.Reflection;
 using System.Runtime.Serialization;
-using System.Text.RegularExpressions;
 using Umbraco.Core.Models.EntityBase;
 
 namespace Umbraco.Core.Models
@@ -323,6 +322,74 @@ namespace Umbraco.Core.Models
             }
         }
 
+        /// <summary>
+        /// Checks whether a PropertyType with a given alias already exists
+        /// </summary>
+        /// <param name="propertyTypeAlias">Alias of the PropertyType</param>
+        /// <returns>Returns <c>True</c> if a PropertyType with the passed in alias exists, otherwise <c>False</c></returns>
+        public abstract bool PropertyTypeExists(string propertyTypeAlias);
+
+        /// <summary>
+        /// Adds a PropertyGroup.
+        /// This method will also check if a group already exists with the same name and link it to the parent.
+        /// </summary>
+        /// <param name="groupName">Name of the PropertyGroup to add</param>
+        /// <returns>Returns <c>True</c> if a PropertyGroup with the passed in name was added, otherwise <c>False</c></returns>
+        public abstract bool AddPropertyGroup(string groupName);
+
+        /// <summary>
+        /// Adds a PropertyType to a specific PropertyGroup
+        /// </summary>
+        /// <param name="propertyType"><see cref="PropertyType"/> to add</param>
+        /// <param name="propertyGroupName">Name of the PropertyGroup to add the PropertyType to</param>
+        /// <returns>Returns <c>True</c> if PropertyType was added, otherwise <c>False</c></returns>
+        public abstract bool AddPropertyType(PropertyType propertyType, string propertyGroupName);
+
+        /// <summary>
+        /// Adds a PropertyType, which does not belong to a PropertyGroup.
+        /// </summary>
+        /// <param name="propertyType"><see cref="PropertyType"/> to add</param>
+        /// <returns>Returns <c>True</c> if PropertyType was added, otherwise <c>False</c></returns>
+        public bool AddPropertyType(PropertyType propertyType)
+        {
+            if (PropertyTypeExists(propertyType.Alias) == false)
+            {
+                _propertyTypes.Add(propertyType);
+                _propertyTypes.CollectionChanged += PropertyTypesChanged;
+                return true;
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        /// Moves a PropertyType to a specified PropertyGroup
+        /// </summary>
+        /// <param name="propertyTypeAlias">Alias of the PropertyType to move</param>
+        /// <param name="propertyGroupName">Name of the PropertyGroup to move the PropertyType to</param>
+        /// <returns></returns>
+        public bool MovePropertyType(string propertyTypeAlias, string propertyGroupName)
+        {
+            if (PropertyTypes.Any(x => x.Alias == propertyTypeAlias) == false || PropertyGroups.Any(x => x.Name == propertyGroupName) == false)
+                return false;
+
+            var propertyType = PropertyTypes.First(x => x.Alias == propertyTypeAlias);
+            //The PropertyType already belongs to a PropertyGroup, so we have to remove the PropertyType from that group
+            if (PropertyGroups.Any(x => x.PropertyTypes.Any(y => y.Alias == propertyTypeAlias)))
+            {
+                var oldPropertyGroup = PropertyGroups.First(x => x.PropertyTypes.Any(y => y.Alias == propertyTypeAlias));
+                oldPropertyGroup.PropertyTypes.RemoveItem(propertyTypeAlias);
+            }
+
+            propertyType.PropertyGroupId = new Lazy<int>(() => default(int));
+            propertyType.ResetDirtyProperties();
+
+            var propertyGroup = PropertyGroups.First(x => x.Name == propertyGroupName);
+            propertyGroup.PropertyTypes.Add(propertyType);
+
+            return true;
+        }
+
         /// <summary>
         /// Removes a PropertyType from the current ContentType
         /// </summary>
@@ -333,6 +400,11 @@ namespace Umbraco.Core.Models
             {
                 propertyGroup.PropertyTypes.RemoveItem(propertyTypeAlias);
             }
+
+            if (_propertyTypes.Any(x => x.Alias == propertyTypeAlias))
+            {
+                _propertyTypes.RemoveItem(propertyTypeAlias);
+            }
         }
 
         /// <summary>
@@ -343,9 +415,5 @@ namespace Umbraco.Core.Models
         {
             _parentId = id;
         }
-
-        //TODO Implement moving PropertyType between groups.
-        /*public bool MovePropertyTypeToGroup(string propertyTypeAlias, string groupName)
-        {}*/
     }
 }

src/Umbraco.Core/Models/ContentTypeCompositionBase.cs

@@ -14,6 +14,7 @@ namespace Umbraco.Core.Models
     public abstract class ContentTypeCompositionBase : ContentTypeBase, IContentTypeComposition
     {
         private readonly List<IContentTypeComposition> _contentTypeComposition = new List<IContentTypeComposition>();
+        internal List<int> RemovedContentTypeKeyTracker = new List<int>();
 
         protected ContentTypeCompositionBase(int parentId) : base(parentId)
         {
@@ -44,7 +45,7 @@ namespace Umbraco.Core.Models
         {
             get
             {
-                var groups = PropertyGroups.Union(ContentTypeComposition.SelectMany(x => x.CompositionPropertyGroups));
+                var groups = ContentTypeComposition.SelectMany(x => x.CompositionPropertyGroups).Union(PropertyGroups);
                 return groups;
             }
         }
@@ -57,8 +58,7 @@ namespace Umbraco.Core.Models
         {
             get
             {
-                var propertyTypes =
-                    PropertyTypes.Union(ContentTypeComposition.SelectMany(x => x.CompositionPropertyTypes));
+                var propertyTypes = ContentTypeComposition.SelectMany(x => x.CompositionPropertyTypes).Union(PropertyTypes);
                 return propertyTypes;
             }
         }
@@ -89,9 +89,11 @@ namespace Umbraco.Core.Models
         /// <returns>True if ContentType was removed, otherwise returns False</returns>
         public bool RemoveContentType(string alias)
         {
-            if (!ContentTypeCompositionExists(alias))
+            if (ContentTypeCompositionExists(alias))
             {
                 var contentTypeComposition = ContentTypeComposition.First(x => x.Alias == alias);
+                RemovedContentTypeKeyTracker.Add(contentTypeComposition.Id);
+                OnPropertyChanged(ContentTypeCompositionSelector);
                 return _contentTypeComposition.Remove(contentTypeComposition);
             }
             return false;
@@ -113,6 +115,83 @@ namespace Umbraco.Core.Models
             return false;
         }
 
+        /// <summary>
+        /// Checks whether a PropertyType with a given alias already exists
+        /// </summary>
+        /// <param name="propertyTypeAlias">Alias of the PropertyType</param>
+        /// <returns>Returns <c>True</c> if a PropertyType with the passed in alias exists, otherwise <c>False</c></returns>
+        public override bool PropertyTypeExists(string propertyTypeAlias)
+        {
+            return CompositionPropertyTypes.Any(x => x.Alias == propertyTypeAlias);
+        }
+
+        /// <summary>
+        /// Adds a PropertyGroup.
+        /// This method will also check if a group already exists with the same name and link it to the parent.
+        /// </summary>
+        /// <param name="groupName">Name of the PropertyGroup to add</param>
+        /// <returns>Returns <c>True</c> if a PropertyGroup with the passed in name was added, otherwise <c>False</c></returns>
+        public override bool AddPropertyGroup(string groupName)
+        {
+            if (PropertyGroups.Any(x => x.Name == groupName))
+                return false;
+
+            var propertyGroup = new PropertyGroup {Name = groupName, SortOrder = 0};
+
+            if (CompositionPropertyGroups.Any(x => x.Name == groupName))
+            {
+                var firstGroup = CompositionPropertyGroups.First(x => x.Name == groupName && x.ParentId.HasValue == false);
+                propertyGroup.SetLazyParentId(new Lazy<int?>(() => firstGroup.Id));
+            }
+
+            if (PropertyGroups.Any())
+            {
+                var last = PropertyGroups.Last();
+                propertyGroup.SortOrder = last.SortOrder + 1;
+            }
+
+            PropertyGroups.Add(propertyGroup);
+            return true;
+        }
+
+        /// <summary>
+        /// Adds a PropertyType to a specific PropertyGroup
+        /// </summary>
+        /// <param name="propertyType"><see cref="PropertyType"/> to add</param>
+        /// <param name="propertyGroupName">Name of the PropertyGroup to add the PropertyType to</param>
+        /// <returns>Returns <c>True</c> if PropertyType was added, otherwise <c>False</c></returns>
+        public override bool AddPropertyType(PropertyType propertyType, string propertyGroupName)
+        {
+            if (PropertyTypeExists(propertyType.Alias) == false)
+            {
+                if (PropertyGroups.Contains(propertyGroupName))
+                {
+                    propertyType.PropertyGroupId = new Lazy<int>(() => PropertyGroups[propertyGroupName].Id);
+                    PropertyGroups[propertyGroupName].PropertyTypes.Add(propertyType);
+                }
+                else
+                {
+                    //If the PropertyGroup doesn't already exist we create a new one 
+                    var propertyTypes = new List<PropertyType> { propertyType };
+                    var propertyGroup = new PropertyGroup(new PropertyTypeCollection(propertyTypes)) { Name = propertyGroupName, SortOrder = 1 };
+                    //and check if its an inherited PropertyGroup, which exists in the composition
+                    if (CompositionPropertyGroups.Any(x => x.Name == propertyGroupName))
+                    {
+                        var parentPropertyGroup = CompositionPropertyGroups.First(x => x.Name == propertyGroupName && x.ParentId.HasValue == false);
+                        propertyGroup.SortOrder = parentPropertyGroup.SortOrder;
+                        //propertyGroup.ParentId = parentPropertyGroup.Id;
+                        propertyGroup.SetLazyParentId(new Lazy<int?>(() => parentPropertyGroup.Id));
+                    }
+
+                    PropertyGroups.Add(propertyGroup);
+                }
+
+                return true;
+            }
+
+            return false;
+        }
+
         /// <summary>
         /// Gets a list of ContentType aliases from the current composition 
         /// </summary>

src/Umbraco.Core/Models/ContentTypeSort.cs

@@ -8,6 +8,17 @@ namespace Umbraco.Core.Models
     /// </summary>
     public class ContentTypeSort : IValueObject
     {
+        public ContentTypeSort()
+        {
+        }
+
+        public ContentTypeSort(Lazy<int> id, int sortOrder, string @alias)
+        {
+            Id = id;
+            SortOrder = sortOrder;
+            Alias = alias;
+        }
+
         /// <summary>
         /// Gets or sets the Id of the ContentType
         /// </summary>

src/Umbraco.Core/Models/DataTypeDatabaseType.cs

@@ -15,12 +15,12 @@ namespace Umbraco.Core.Models
     public enum DataTypeDatabaseType
     {
         [EnumMember]
-        Integer,
-        [EnumMember]
-        Date,
+        Ntext,
         [EnumMember]
         Nvarchar,
         [EnumMember]
-        Ntext /*, Object*/
+        Integer,
+        [EnumMember]
+        Date
     }
 }

src/Umbraco.Core/Models/DataTypeDefinition.cs

@@ -172,7 +172,9 @@ namespace Umbraco.Core.Models
         internal override void AddingEntity()
         {
             base.AddingEntity();
-            Key = Guid.NewGuid();
+
+            if(Key == default(Guid))
+                Key = Guid.NewGuid();
         }
     }
 }

src/Umbraco.Core/Models/EntityBase/Entity.cs

@@ -66,6 +66,15 @@ namespace Umbraco.Core.Models.EntityBase
         [DataMember]
         public DateTime UpdateDate { get; set; }
 
+        /// <summary>
+        /// Gets or sets the WasCancelled flag, which is used to track
+        /// whether some action against an entity was cancelled through some event.
+        /// This only exists so we have a way to check if an event was cancelled through
+        /// the new api, which also needs to take effect in the legacy api.
+        /// </summary>
+        [IgnoreDataMember]
+        internal bool WasCancelled { get; set; }
+
         /// <summary>
         /// Property changed event
         /// </summary>

src/Umbraco.Core/Models/IContentTypeBase.cs

@@ -69,5 +69,43 @@ namespace Umbraco.Core.Models
         /// </summary>
         /// <param name="id">Id of the Parent</param>
         void SetLazyParentId(Lazy<int> id);
+
+        /// <summary>
+        /// Checks whether a PropertyType with a given alias already exists
+        /// </summary>
+        /// <param name="propertyTypeAlias">Alias of the PropertyType</param>
+        /// <returns>Returns <c>True</c> if a PropertyType with the passed in alias exists, otherwise <c>False</c></returns>
+        bool PropertyTypeExists(string propertyTypeAlias);
+
+        /// <summary>
+        /// Adds a PropertyType to a specific PropertyGroup
+        /// </summary>
+        /// <param name="propertyType"><see cref="PropertyType"/> to add</param>
+        /// <param name="propertyGroupName">Name of the PropertyGroup to add the PropertyType to</param>
+        /// <returns>Returns <c>True</c> if PropertyType was added, otherwise <c>False</c></returns>
+        bool AddPropertyType(PropertyType propertyType, string propertyGroupName);
+
+        /// <summary>
+        /// Adds a PropertyType, which does not belong to a PropertyGroup.
+        /// </summary>
+        /// <param name="propertyType"><see cref="PropertyType"/> to add</param>
+        /// <returns>Returns <c>True</c> if PropertyType was added, otherwise <c>False</c></returns>
+        bool AddPropertyType(PropertyType propertyType);
+
+        /// <summary>
+        /// Adds a PropertyGroup.
+        /// This method will also check if a group already exists with the same name and link it to the parent.
+        /// </summary>
+        /// <param name="groupName">Name of the PropertyGroup to add</param>
+        /// <returns>Returns <c>True</c> if a PropertyGroup with the passed in name was added, otherwise <c>False</c></returns>
+        bool AddPropertyGroup(string groupName);
+
+        /// <summary>
+        /// Moves a PropertyType to a specified PropertyGroup
+        /// </summary>
+        /// <param name="propertyTypeAlias">Alias of the PropertyType to move</param>
+        /// <param name="propertyGroupName">Name of the PropertyGroup to move the PropertyType to</param>
+        /// <returns></returns>
+        bool MovePropertyType(string propertyTypeAlias, string propertyGroupName);
     }
 }

src/Umbraco.Core/Models/Membership/IUser.cs

@@ -12,7 +12,7 @@ namespace Umbraco.Core.Models.Membership
         int SessionTimeout { get; set; }
         int StartContentId { get; set; }
         int StartMediaId { get; set; }
-        string Lanuguage { get; set; }
+        string Language { get; set; }
         bool DefaultToLiveEditing { get; set; }
         IEnumerable<string> Applications { get; set; }
         bool NoConsole { get; set; }

src/Umbraco.Core/Models/Membership/User.cs

@@ -88,7 +88,7 @@ namespace Umbraco.Core.Models.Membership
         #region Implementation of IUser
 
         [DataMember]
-        public string Lanuguage { get; set; }
+        public string Language { get; set; }
         [DataMember]
         public string Permissions { get; set; }
         [DataMember]

src/Umbraco.Core/Models/PropertyExtensions.cs

@@ -19,6 +19,14 @@ namespace Umbraco.Core.Models
             var xd = new XmlDocument();
             XmlNode xmlNode = xd.CreateNode(XmlNodeType.Element, nodeName, "");
 
+            //Add the property alias to the legacy schema
+            if (UmbracoSettings.UseLegacyXmlSchema)
+            {
+                var alias = xd.CreateAttribute("alias");
+                alias.Value = property.Alias.ToSafeAlias();
+                xmlNode.Attributes.Append(alias);
+            }
+
             //This seems to fail during testing 
             xmlNode.AppendChild(property.PropertyType.DataType(property.Id).Data.ToXMl(xd));
             

src/Umbraco.Core/Models/PropertyGroup.cs

@@ -14,7 +14,7 @@ namespace Umbraco.Core.Models
     public class PropertyGroup : Entity, IEquatable<PropertyGroup>
     {
         private string _name;
-        private int? _parentId;
+        private Lazy<int?> _parentId;
         private int _sortOrder;
         private PropertyTypeCollection _propertyTypes;
 
@@ -51,15 +51,24 @@ namespace Umbraco.Core.Models
         }
 
         /// <summary>
-        /// Gets or sets the Name of the Group, which corresponds to the Tab-name in the UI
+        /// Gets or sets the Id of the Parent PropertyGroup.
         /// </summary>
+        /// <remarks>
+        /// A Parent PropertyGroup corresponds to an inherited PropertyGroup from a composition.
+        /// If a PropertyType is inserted into an inherited group then a new group will be created with an Id reference to the parent.
+        /// </remarks>
         [DataMember]
         public int? ParentId
         {
-            get { return _parentId; }
+            get
+            {
+                if (_parentId == null)
+                    return default(int?);
+                return _parentId.Value;
+            }
             set
             {
-                _parentId = value;
+                _parentId = new Lazy<int?>(() => value);
                 OnPropertyChanged(ParentIdSelector);
             }
         }
@@ -92,6 +101,15 @@ namespace Umbraco.Core.Models
             }
         }
 
+        /// <summary>
+        /// Sets the ParentId from the lazy integer id
+        /// </summary>
+        /// <param name="id">Id of the Parent</param>
+        internal void SetLazyParentId(Lazy<int?> id)
+        {
+            _parentId = id;
+        }
+
         public bool Equals(PropertyGroup other)
         {
             //Check whether the compared object is null. 

src/Umbraco.Core/Models/PropertyType.cs

@@ -18,7 +18,7 @@ namespace Umbraco.Core.Models
         private string _alias;
         private string _description;
         private int _dataTypeDefinitionId;
-        private int _propertyGroupId;
+        private Lazy<int> _propertyGroupId;
         private Guid _dataTypeId;
         private DataTypeDatabaseType _dataTypeDatabaseType;
         private bool _mandatory;
@@ -61,7 +61,7 @@ namespace Umbraco.Core.Models
         private static readonly PropertyInfo HelpTextSelector = ExpressionHelper.GetPropertyInfo<PropertyType, string>(x => x.HelpText);
         private static readonly PropertyInfo SortOrderSelector = ExpressionHelper.GetPropertyInfo<PropertyType, int>(x => x.SortOrder);
         private static readonly PropertyInfo ValidationRegExpSelector = ExpressionHelper.GetPropertyInfo<PropertyType, string>(x => x.ValidationRegExp);
-        private static readonly PropertyInfo PropertyGroupIdSelector = ExpressionHelper.GetPropertyInfo<PropertyType, int>(x => x.PropertyGroupId);
+        private static readonly PropertyInfo PropertyGroupIdSelector = ExpressionHelper.GetPropertyInfo<PropertyType, Lazy<int>>(x => x.PropertyGroupId);
 
         /// <summary>
         /// Gets of Sets the Name of the PropertyType
@@ -153,7 +153,7 @@ namespace Umbraco.Core.Models
         /// Gets or Sets the PropertyGroup's Id for which this PropertyType belongs
         /// </summary>
         [DataMember]
-        internal int PropertyGroupId
+        internal Lazy<int> PropertyGroupId
         {
             get { return _propertyGroupId; }
             set
@@ -335,8 +335,8 @@ namespace Umbraco.Core.Models
             if (Mandatory && (value == null || string.IsNullOrEmpty(value.ToString())))
                 return false;
 
-            //Check against Regular Expression for Legacy DataTypes
-            if(!string.IsNullOrEmpty(ValidationRegExp))
+            //Check against Regular Expression for Legacy DataTypes - Validation exists and value is not null:
+            if(string.IsNullOrEmpty(ValidationRegExp) == false && (value != null && string.IsNullOrEmpty(value.ToString()) == false))
             {
                 var regexPattern = new Regex(ValidationRegExp);
                 return regexPattern.IsMatch(value.ToString());

src/Umbraco.Core/Models/Template.cs

@@ -29,8 +29,8 @@ namespace Umbraco.Core.Models
             base.Path = path;
             ParentId = -1;
             Key = name.EncodeAsGuid();
-            _name = name;
-            _alias = alias;
+            _name = name.Replace("/", ".").Replace("\\", "");
+            _alias = alias.ToSafeAlias();
 
             CreateDate = DateTime.Now;
             UpdateDate = DateTime.Now;
@@ -52,7 +52,7 @@ namespace Umbraco.Core.Models
         internal string NodePath { get; set; }
 
         [DataMember]
-        internal int MasterTemplateId { get; set; }
+        internal Lazy<int> MasterTemplateId { get; set; }
 
         [DataMember]
         internal string MasterTemplateAlias { get; set; }

src/Umbraco.Core/ObjectResolution/ApplicationEventsResolver.cs

@@ -8,27 +8,49 @@ namespace Umbraco.Core.ObjectResolution
 	/// <summary>
 	/// A resolver to return all IApplicationEvents objects
 	/// </summary>
-	internal sealed class ApplicationEventsResolver : ManyObjectsResolverBase<ApplicationEventsResolver, IApplicationStartupHandler>
+    internal sealed class ApplicationEventsResolver : ManyObjectsResolverBase<ApplicationEventsResolver, IApplicationEventHandler>
 	{
 
-		/// <summary>
+	    private readonly LegacyStartupHandlerResolver _legacyResolver;
+
+	    /// <summary>
 		/// Constructor
 		/// </summary>
 		/// <param name="applicationEventHandlers"></param>		
 		internal ApplicationEventsResolver(IEnumerable<Type> applicationEventHandlers)
 			: base(applicationEventHandlers)
 		{
-
+            //create the legacy resolver and only include the legacy types
+	        _legacyResolver = new LegacyStartupHandlerResolver(
+	            applicationEventHandlers.Where(x => !TypeHelper.IsTypeAssignableFrom<IApplicationEventHandler>(x)));
 		}
 
-		/// <summary>
+        /// <summary>
+        /// Override in order to only return types of IApplicationEventHandler and above, 
+        /// do not include the legacy types of IApplicationStartupHandler
+        /// </summary>
+        protected override IEnumerable<Type> InstanceTypes
+        {
+            get { return base.InstanceTypes.Where(TypeHelper.IsTypeAssignableFrom<IApplicationEventHandler>); }
+        }
+
+	    /// <summary>
 		/// Gets the <see cref="IApplicationEventHandler"/> implementations.
 		/// </summary>
 		public IEnumerable<IApplicationEventHandler> ApplicationEventHandlers
 		{
-			get { return Values.OfType<IApplicationEventHandler>(); }
+            get { return Values; }
 		}
 
+        /// <summary>
+        /// Create instances of all of the legacy startup handlers
+        /// </summary>
+	    public void InstantiateLegacyStartupHanlders()
+	    {
+            //this will instantiate them all
+	        var handlers = _legacyResolver.LegacyStartupHandlers;
+	    }
+
 		protected override bool SupportsClear
 		{
 			get { return false; }
@@ -44,5 +66,19 @@ namespace Umbraco.Core.ObjectResolution
 			get { return false; }
 		}
 
+	    private class LegacyStartupHandlerResolver : ManyObjectsResolverBase<ApplicationEventsResolver, IApplicationStartupHandler>
+	    {
+	        internal LegacyStartupHandlerResolver(IEnumerable<Type> legacyStartupHandlers)
+                : base(legacyStartupHandlers)
+	        {
+
+	        }
+
+            public IEnumerable<IApplicationStartupHandler> LegacyStartupHandlers
+            {
+                get { return Values; }
+            }
+	    }
+
 	}
 }

src/Umbraco.Core/ObjectResolution/LazyManyObjectsResolverbase.cs

@@ -0,0 +1,235 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Web;
+
+namespace Umbraco.Core.ObjectResolution
+{
+	/// <summary>
+	/// A base class for lazily resolving types for a resolver
+	/// </summary>
+	/// <typeparam name="TResolver"></typeparam>
+	/// <typeparam name="TResolved"></typeparam>
+	/// <remarks>
+	/// This is a special case resolver for when types get lazily resolved in order to resolve the actual types. This is useful
+	/// for when there is some processing overhead (i.e. Type finding in assemblies) to return the Types used to instantiate the instances. 
+	/// In some these cases we don't want to have to type find during application startup, only when we need to resolve the instances.
+	/// 
+	/// Important notes about this resolver: This does not support Insert or Remove and therefore does not support any ordering unless 
+	/// the types are marked with the WeightedPluginAttribute.
+	/// </remarks>
+	internal abstract class LazyManyObjectsResolverBase<TResolver, TResolved> : ManyObjectsResolverBase<TResolver, TResolved>
+		where TResolved : class
+		where TResolver : class
+	{
+		#region Constructors
+		
+		protected LazyManyObjectsResolverBase(ObjectLifetimeScope scope = ObjectLifetimeScope.Application)
+			: base(scope)
+		{			
+		}
+		
+		protected LazyManyObjectsResolverBase(HttpContextBase httpContext)
+			: base(httpContext)
+		{
+		}
+
+		/// <summary>
+		/// Constructor accepting a list of lazy types
+		/// </summary>
+		/// <param name="listOfLazyTypes"></param>
+		/// <param name="scope"></param>
+		protected LazyManyObjectsResolverBase(IEnumerable<Lazy<Type>> listOfLazyTypes, ObjectLifetimeScope scope = ObjectLifetimeScope.Application)
+			: this(scope)
+		{			
+			AddTypes(listOfLazyTypes);
+		}
+
+		/// <summary>
+		/// Constructor accepting a delegate to return a list of types
+		/// </summary>
+		/// <param name="typeListDelegate"></param>
+		/// <param name="scope"></param>
+		protected LazyManyObjectsResolverBase(Func<IEnumerable<Type>> typeListDelegate, ObjectLifetimeScope scope = ObjectLifetimeScope.Application)
+			: this(scope)
+		{
+			_listOfTypeListDelegates.Add(typeListDelegate);
+		}
+
+		/// <summary>
+		/// Constructor accepting a list of lazy types
+		/// </summary>
+		/// <param name="httpContext"></param>
+		/// <param name="listOfLazyTypes"></param>
+		protected LazyManyObjectsResolverBase(HttpContextBase httpContext, IEnumerable<Lazy<Type>> listOfLazyTypes)
+			: this(httpContext)
+		{
+			AddTypes(listOfLazyTypes);
+		}
+
+		/// <summary>
+		/// Constructor accepting a delegate to return a list of types
+		/// </summary>
+		/// <param name="httpContext"></param>
+		/// <param name="typeListDelegate"></param>
+		protected LazyManyObjectsResolverBase(HttpContextBase httpContext, Func<IEnumerable<Type>> typeListDelegate)
+			: this(httpContext)
+		{
+			_listOfTypeListDelegates.Add(typeListDelegate);
+		} 
+
+		#endregion	
+
+		private readonly List<Lazy<Type>> _lazyTypeList = new List<Lazy<Type>>();
+		private readonly List<Func<IEnumerable<Type>>> _listOfTypeListDelegates = new List<Func<IEnumerable<Type>>>();
+		private List<Type> _resolvedTypes = null;
+		private readonly ReaderWriterLockSlim _typeResolutionLock = new ReaderWriterLockSlim();
+		
+		/// <summary>
+		/// Used for unit tests
+		/// </summary>
+		internal bool HasResolvedTypes
+		{
+			get { return _resolvedTypes != null; }
+		}
+
+		/// <summary>
+		/// Once this is called this will resolve all types registered in the lazy list
+		/// </summary>
+		protected override IEnumerable<Type> InstanceTypes
+		{
+			get
+			{
+				using (var lck = new UpgradeableReadLock(_typeResolutionLock))
+				{
+					var lazyTypeList = _lazyTypeList.Select(x => x.Value).ToArray();
+					var listofTypeListDelegates = _listOfTypeListDelegates.SelectMany(x => x()).ToArray();
+
+					//we need to validate each resolved type now since we could not do it before when inserting the lazy delegates
+					if (!HasResolvedTypes)
+					{
+						lck.UpgradeToWriteLock();
+
+						_resolvedTypes = new List<Type>();
+
+						//first iterate the lazy type list
+						foreach (var l in lazyTypeList)
+						{
+							UpdateUniqueList(_resolvedTypes, l);
+						}
+
+						//next iterate the list of list type delegates
+						foreach (var l in listofTypeListDelegates)
+						{
+							UpdateUniqueList(_resolvedTypes, l);
+						}
+					}
+
+					return _resolvedTypes;	
+				}				
+			}
+		}
+
+		private void UpdateUniqueList(List<Type> uniqueList, Type toAdd)
+		{
+			EnsureCorrectType(toAdd);
+			if (uniqueList.Contains(toAdd))
+			{
+				throw new InvalidOperationException("The Type " + toAdd + " already exists in the collection");
+			}
+			uniqueList.Add(toAdd);
+		}
+
+		/// <summary>
+		/// Allows adding of multiple lazy types at once
+		/// </summary>
+		/// <param name="types"></param>
+		protected void AddTypes(IEnumerable<Lazy<Type>> types)
+		{
+			EnsureAddSupport();
+
+			EnsureResolutionNotFrozen();
+
+			using (GetWriteLock())
+			{
+				foreach (var t in types)
+				{				
+					_lazyTypeList.Add(t);
+				}
+			}
+		}
+
+		/// <summary>
+		/// Adds a type list delegate to the collection
+		/// </summary>
+		/// <param name="typeListDelegate"></param>
+		public void AddTypeListDelegate(Func<IEnumerable<Type>> typeListDelegate)
+		{
+			EnsureAddSupport();
+
+			EnsureResolutionNotFrozen();
+
+			using (GetWriteLock())
+			{
+				_listOfTypeListDelegates.Add(typeListDelegate);
+			}
+		}
+
+		/// <summary>
+		/// Adds a lazy type to the list
+		/// </summary>
+		/// <param name="value"></param>
+		public void AddType(Lazy<Type> value)
+		{
+			EnsureAddSupport();
+
+			EnsureResolutionNotFrozen();
+
+			using (GetWriteLock())
+			{				
+				_lazyTypeList.Add(value);
+			}
+		}
+
+		/// <summary>
+		/// Converts the static type added to a lazy type and adds it to the internal list
+		/// </summary>
+		/// <param name="value"></param>
+		public override void AddType(Type value)
+		{
+			AddType(new Lazy<Type>(() => value));
+		}
+
+		/// <summary>
+		/// Clears all lazy types
+		/// </summary>
+		public override void Clear()
+		{
+			EnsureClearSupport();
+
+			EnsureResolutionNotFrozen();
+
+			using (GetWriteLock())
+			{
+				_lazyTypeList.Clear();
+			}
+		}
+
+		/// <summary>
+		/// Does not support removal
+		/// </summary>
+		protected override bool SupportsRemove
+		{
+			get { return false; }
+		}
+
+		/// <summary>
+		/// Does not support insert
+		/// </summary>
+		protected override bool SupportsInsert
+		{
+			get { return false; }
+		}
+	}
+}

src/Umbraco.Core/ObjectResolution/LegacyTransientObjectsResolver.cs

@@ -17,7 +17,7 @@ namespace Umbraco.Core.ObjectResolution
 	/// these old classes don't contain metadata, the objects need to be instantiated first to get their metadata, we then store this
 	/// for use in the GetById method.
 	/// </remarks>
-	internal abstract class LegacyTransientObjectsResolver<TResolver, TResolved> : ManyObjectsResolverBase<TResolver, TResolved>
+	internal abstract class LegacyTransientObjectsResolver<TResolver, TResolved> : LazyManyObjectsResolverBase<TResolver, TResolved>
 		where TResolved : class
 		where TResolver : class
 	{
@@ -27,16 +27,15 @@ namespace Umbraco.Core.ObjectResolution
 		/// <summary>
 		/// Constructor
 		/// </summary>
-		/// <param name="refreshers"></param>
+		/// <param name="types"></param>
 		/// <remarks>
 		/// We are creating Transient instances (new instances each time) because this is how the legacy code worked and
 		/// I don't want to muck anything up by changing them to application based instances. 
 		/// TODO: However, it would make much more sense to do this and would speed up the application plus this would make the GetById method much easier.
 		/// </remarks>
-		protected LegacyTransientObjectsResolver(IEnumerable<Type> refreshers)
-			: base(ObjectLifetimeScope.Transient) //  new objects every time
-		{
-			AddTypes(refreshers);
+		protected LegacyTransientObjectsResolver(Func<IEnumerable<Type>> types)
+			: base(types, ObjectLifetimeScope.Transient) //  new objects every time
+		{			
 		}
 		#endregion
 
@@ -55,7 +54,7 @@ namespace Umbraco.Core.ObjectResolution
 		protected abstract Guid GetUniqueIdentifier(TResolved obj); 
 
 		/// <summary>
-		/// Returns a new ICacheRefresher instance by id
+		/// Returns a new TResolved instance by id
 		/// </summary>
 		/// <param name="id"></param>
 		/// <returns></returns>

src/Umbraco.Core/ObjectResolution/MacroFieldEditorsResolver.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using System.Web;
 using System.Web.UI;
 using Umbraco.Core.Macros;
@@ -14,14 +15,14 @@ namespace Umbraco.Core.ObjectResolution
 	/// Much of this classes methods are based on legacy code from umbraco.editorControls.macrocontainer.MacroControlFactory
 	/// this code should probably be reviewed and cleaned up if necessary.
 	/// </remarks>
-	internal sealed class MacroFieldEditorsResolver : ManyObjectsResolverBase<MacroFieldEditorsResolver, IMacroGuiRendering>
+	internal sealed class MacroFieldEditorsResolver : LazyManyObjectsResolverBase<MacroFieldEditorsResolver, IMacroGuiRendering>
 	{
 
 		/// <summary>
 		/// Constructor
 		/// </summary>
 		/// <param name="macroEditors"></param>		
-		internal MacroFieldEditorsResolver(IEnumerable<Type> macroEditors)
+		internal MacroFieldEditorsResolver(Func<IEnumerable<Type>> macroEditors)
 			: base(macroEditors, ObjectLifetimeScope.Transient)
 		{
 
@@ -56,7 +57,7 @@ namespace Umbraco.Core.ObjectResolution
 		/// </remarks>
 		internal List<Type> MacroControlTypes
 		{
-			get { return InstanceTypes; }
+			get { return InstanceTypes.ToList(); }
 		}
 
 		/// <summary>

src/Umbraco.Core/ObjectResolution/ManyObjectsResolverBase.cs

@@ -6,14 +6,14 @@ using System.Web;
 
 namespace Umbraco.Core.ObjectResolution
 {
-
 	internal abstract class ManyObjectsResolverBase<TResolver, TResolved> : ResolverBase<TResolver>
 		where TResolved : class 
 		where TResolver : class
 	{
 		private List<TResolved> _applicationInstances = null;
 		private readonly ReaderWriterLockSlim _lock = new ReaderWriterLockSlim();
-		
+		private readonly List<Type> _instanceTypes = new List<Type>(); 
+
 		#region Constructors
 	
 		
@@ -34,7 +34,7 @@ namespace Umbraco.Core.ObjectResolution
 			}
 
 			LifetimeScope = scope;
-			InstanceTypes = new List<Type>();
+			_instanceTypes = new List<Type>();
 		}
 
 		/// <summary>
@@ -48,7 +48,7 @@ namespace Umbraco.Core.ObjectResolution
 			if (httpContext == null) throw new ArgumentNullException("httpContext");
 			LifetimeScope = ObjectLifetimeScope.HttpRequest;
 			CurrentHttpContext = httpContext;
-			InstanceTypes = new List<Type>();
+			_instanceTypes = new List<Type>();
 		}
 
 		/// <summary>
@@ -58,8 +58,8 @@ namespace Umbraco.Core.ObjectResolution
 		/// <param name="scope">If set to true will resolve singleton objects which will be created once for the lifetime of the application</param>
 		protected ManyObjectsResolverBase(IEnumerable<Type> value, ObjectLifetimeScope scope = ObjectLifetimeScope.Application)
 			: this(scope)
-		{			
-			InstanceTypes = new List<Type>(value);
+		{
+			_instanceTypes = new List<Type>(value);
 		}
 
 		/// <summary>
@@ -71,7 +71,7 @@ namespace Umbraco.Core.ObjectResolution
 		protected ManyObjectsResolverBase(HttpContextBase httpContext, IEnumerable<Type> value)
 			: this(httpContext)
 		{
-			InstanceTypes = new List<Type>(value);
+			_instanceTypes = new List<Type>(value);
 		} 
 		#endregion
 
@@ -83,7 +83,10 @@ namespace Umbraco.Core.ObjectResolution
 		/// <summary>
 		/// Returns the list of Types registered that instances will be created from
 		/// </summary>
-		protected List<Type> InstanceTypes { get; private set; }
+		protected virtual IEnumerable<Type> InstanceTypes
+		{
+			get { return _instanceTypes; }
+		}
 
 		/// <summary>
 		/// Returns the Current HttpContextBase used to construct this object if one exists. 
@@ -97,11 +100,7 @@ namespace Umbraco.Core.ObjectResolution
 		protected ObjectLifetimeScope LifetimeScope { get; private set; }
 
 		private int _defaultPluginWeight = 10;
-		private bool _supportsAdd = true;
-		private bool _supportsInsert = true;
-		private bool _supportsClear = true;
-		private bool _supportsRemove = true;
-
+		
 		/// <summary>
 		/// Used in conjunction with GetSortedValues and WeightedPluginAttribute, if any of the objects
 		/// being resolved do not contain the WeightedPluginAttribute then this will be the default weight applied
@@ -189,15 +188,16 @@ namespace Umbraco.Core.ObjectResolution
 		/// Removes a type.
 		/// </summary>
 		/// <param name="value">The type to remove.</param>
-		public void RemoveType(Type value)
+		public virtual void RemoveType(Type value)
 		{
-			if (!SupportsRemove)
-				throw new InvalidOperationException("This resolver does not support Removing types");
+			EnsureRemoveSupport();
 
-			using (new WriteLock(_lock))
+			EnsureResolutionNotFrozen();
+
+			using (GetWriteLock())
 			{
 				EnsureCorrectType(value);
-				InstanceTypes.Remove(value);
+				_instanceTypes.Remove(value);
 			}
 		}
 
@@ -215,8 +215,12 @@ namespace Umbraco.Core.ObjectResolution
 		/// </summary>
 		/// <param name="types"></param>
 		protected void AddTypes(IEnumerable<Type> types)
-		{			
-			using (var l = new WriteLock(_lock))
+		{
+			EnsureAddSupport();
+
+			EnsureResolutionNotFrozen();
+
+			using (GetWriteLock())
 			{
 				foreach(var t in types)
 				{
@@ -225,7 +229,7 @@ namespace Umbraco.Core.ObjectResolution
 					{
 						throw new InvalidOperationException("The Type " + t + " already exists in the collection");
 					};
-					InstanceTypes.Add(t);	
+					_instanceTypes.Add(t);	
 				}				
 			}
 		}
@@ -234,19 +238,20 @@ namespace Umbraco.Core.ObjectResolution
 		/// Adds a Type to the end of the list.
 		/// </summary>
 		/// <param name="value">The object to be added.</param>
-		public void AddType(Type value)
+		public virtual void AddType(Type value)
 		{
-			if (!SupportsAdd)
-				throw new InvalidOperationException("This resolver does not support Adding new types");
+			EnsureAddSupport();
 
-			using (var l = new WriteLock(_lock))
+			EnsureResolutionNotFrozen();
+
+			using (GetWriteLock())
 			{
 				EnsureCorrectType(value);
 				if (InstanceTypes.Contains(value))
 				{
 					throw new InvalidOperationException("The Type " + value + " already exists in the collection");
 				};
-				InstanceTypes.Add(value);
+				_instanceTypes.Add(value);
 			}
 		}
 
@@ -262,14 +267,15 @@ namespace Umbraco.Core.ObjectResolution
 		/// <summary>
 		/// Clears the list.
 		/// </summary>
-		public void Clear()
+		public virtual void Clear()
 		{
-			if (!SupportsClear)
-				throw new InvalidOperationException("This resolver does not support Clearing types");
+			EnsureClearSupport();
 
-			using (new WriteLock(_lock))
+			EnsureResolutionNotFrozen();
+
+			using (GetWriteLock())
 			{
-				InstanceTypes.Clear();
+				_instanceTypes.Clear();
 			}
 		}
 
@@ -278,12 +284,13 @@ namespace Umbraco.Core.ObjectResolution
 		/// </summary>
 		/// <param name="index">The zero-based index at which the object should be inserted.</param>
 		/// <param name="value">The object to insert.</param>
-		public void InsertType(int index, Type value)
+		public virtual void InsertType(int index, Type value)
 		{			
-			if (!SupportsInsert)
-				throw new InvalidOperationException("This resolver does not support Inserting new types");
+			EnsureInsertSupport();
 
-			using (var l = new UpgradeableReadLock(_lock))
+			EnsureResolutionNotFrozen();
+
+			using (var l = GetWriteLock())
 			{
 				EnsureCorrectType(value);
 				if (InstanceTypes.Contains(value))
@@ -291,8 +298,7 @@ namespace Umbraco.Core.ObjectResolution
 					throw new InvalidOperationException("The Type " + value + " already exists in the collection");
 				};
 
-				l.UpgradeToWriteLock();
-				InstanceTypes.Insert(index, value);
+				_instanceTypes.Insert(index, value);
 			}
 		}
 
@@ -306,7 +312,65 @@ namespace Umbraco.Core.ObjectResolution
 			InsertType(index, typeof (T));
 		}
 
-		private void EnsureCorrectType(Type t)
+		/// <summary>
+		/// Returns a WriteLock to use when modifying collections
+		/// </summary>
+		/// <returns></returns>
+		protected WriteLock GetWriteLock()
+		{
+			return new WriteLock(_lock);
+		}
+		
+		/// <summary>
+		/// Throws an exception if resolution is frozen
+		/// </summary>
+		protected void EnsureResolutionNotFrozen()
+		{
+			if (Resolution.IsFrozen)
+				throw new InvalidOperationException("The type list cannot be modified after resolution has been frozen");
+		}
+
+		/// <summary>
+		/// Throws an exception if this does not support Remove
+		/// </summary>
+		protected void EnsureRemoveSupport()
+		{
+			if (!SupportsRemove)
+				throw new InvalidOperationException("This resolver does not support Removing types");
+		}
+
+		/// <summary>
+		/// Throws an exception if this does not support Clear
+		/// </summary>
+		protected void EnsureClearSupport()
+		{
+			if (!SupportsClear)
+				throw new InvalidOperationException("This resolver does not support Clearing types");
+		}
+
+		/// <summary>
+		/// Throws an exception if this does not support Add
+		/// </summary>
+		protected void EnsureAddSupport()
+		{
+			if (!SupportsAdd)
+				throw new InvalidOperationException("This resolver does not support Adding new types");
+		}
+
+		/// <summary>
+		/// Throws an exception if this does not support insert
+		/// </summary>
+		protected void EnsureInsertSupport()
+		{
+			if (!SupportsInsert)
+				throw new InvalidOperationException("This resolver does not support Inserting new types");
+		}
+
+		/// <summary>
+		/// Throws an exception if the type is not of the TResolved type
+		/// </summary>
+		/// <param name="t"></param>
+		protected void EnsureCorrectType(Type t)
 		{
 			if (!TypeHelper.IsTypeAssignableFrom<TResolved>(t))
 				throw new InvalidOperationException("The resolver " + this.GetType() + " can only accept types of " + typeof(TResolved) + ". The Type passed in to this method is " + t);
@@ -314,22 +378,22 @@ namespace Umbraco.Core.ObjectResolution
 
 		protected virtual bool SupportsAdd
 		{
-			get { return _supportsAdd; }
+			get { return true; }
 		}
 
 		protected virtual bool SupportsInsert
 		{
-			get { return _supportsInsert; }
+			get { return true; }
 		}
 
 		protected virtual bool SupportsClear
 		{
-			get { return _supportsClear; }
+			get { return true; }
 		}
 
 		protected virtual bool SupportsRemove
 		{
-			get { return _supportsRemove; }
+			get { return true; }
 		}
 	}
 }

src/Umbraco.Core/PackageActionsResolver.cs

@@ -8,14 +8,14 @@ namespace Umbraco.Core
 	/// <summary>
 	/// A resolver to return all IPackageAction objects
 	/// </summary>
-	internal sealed class PackageActionsResolver : ManyObjectsResolverBase<PackageActionsResolver, IPackageAction>
+	internal sealed class PackageActionsResolver : LazyManyObjectsResolverBase<PackageActionsResolver, IPackageAction>
 	{
 
 		/// <summary>
 		/// Constructor
 		/// </summary>
 		/// <param name="packageActions"></param>		
-		internal PackageActionsResolver(IEnumerable<Type> packageActions)
+		internal PackageActionsResolver(Func<IEnumerable<Type>> packageActions)
 			: base(packageActions)
 		{
 			

src/Umbraco.Core/Persistence/DatabaseFactory.cs

@@ -0,0 +1,34 @@
+using System;
+using System.Threading;
+using Umbraco.Core.Configuration;
+
+namespace Umbraco.Core.Persistence
+{
+    /// <summary>
+    /// Provides access to the PetaPoco database as Singleton, so the database is created once in app lifecycle.
+    /// This is necessary for transactions to work properly
+    /// </summary>
+    public sealed class DatabaseFactory
+    {
+        #region Singleton
+
+        private static readonly Database _database = new Database(GlobalSettings.DbDsn);
+        private static readonly Lazy<DatabaseFactory> lazy = new Lazy<DatabaseFactory>(() => new DatabaseFactory());
+
+        public static DatabaseFactory Current { get { return lazy.Value; } }
+
+        private DatabaseFactory()
+        {
+        }
+
+        #endregion
+
+        /// <summary>
+        /// Returns an instance of the PetaPoco database
+        /// </summary>
+        public Database Database
+        {
+            get { return _database; }
+        }
+    }
+}

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

@@ -127,9 +127,8 @@ namespace Umbraco.Core.Persistence.Factories
 
         private NodeDto BuildNodeDto(IContent entity)
         {
-            //TODO: Change this once the Language property is public on IContent
-            var content = entity as Content;
-            var nodeName = content != null && string.IsNullOrEmpty(content.NodeName) == false ? content.NodeName : entity.Name;
+            //TODO: Change this once the Language property is public on IContent            
+            var nodeName = entity.Name;
 
             var nodeDto = new NodeDto
             {

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

@@ -8,41 +8,34 @@ namespace Umbraco.Core.Persistence.Factories
 {
     internal class PropertyFactory : IEntityFactory<IEnumerable<Property>, IEnumerable<PropertyDataDto>>
     {
-        private readonly IContentType _contentType;
-        private readonly IMediaType _mediaType;
+        private readonly IContentTypeComposition _contentType;
         private readonly Guid _version;
         private readonly int _id;
 
-        public PropertyFactory(IContentType contentType, Guid version, int id)
+        public PropertyFactory(IContentTypeComposition contentType, Guid version, int id)
         {
             _contentType = contentType;
             _version = version;
             _id = id;
         }
 
-        public PropertyFactory(IMediaType mediaType, Guid version, int id)
-        {
-            _mediaType = mediaType;
-            _version = version;
-            _id = id;
-        }
-
         #region Implementation of IEntityFactory<IContent,PropertyDataDto>
 
         public IEnumerable<Property> BuildEntity(IEnumerable<PropertyDataDto> dtos)
         {
             var properties = new List<Property>();
 
-            foreach (var dto in dtos)
+            foreach (var propertyType in _contentType.CompositionPropertyTypes)
             {
-                if (_contentType.CompositionPropertyTypes.Any(x => x.Id == dto.PropertyTypeId))
-                {
-                    var propertyType = _contentType.CompositionPropertyTypes.First(x => x.Id == dto.PropertyTypeId);
-                    var property = propertyType.CreatePropertyFromRawValue(dto.GetValue, dto.VersionId.Value, dto.Id);
+                var propertyDataDto = dtos.LastOrDefault(x => x.PropertyTypeId == propertyType.Id);
+                var property = propertyDataDto == null
+                                   ? propertyType.CreatePropertyFromValue(null)
+                                   : propertyType.CreatePropertyFromRawValue(propertyDataDto.GetValue,
+                                                                             propertyDataDto.VersionId.Value,
+                                                                             propertyDataDto.Id);
 
-                    property.ResetDirtyProperties();
-                    properties.Add(property);
-                }
+                property.ResetDirtyProperties();
+                properties.Add(property);
             }
 
             return properties;
@@ -97,22 +90,5 @@ namespace Umbraco.Core.Persistence.Factories
         }
 
         #endregion
-
-        public IEnumerable<Property> BuildMediaEntity(IEnumerable<PropertyDataDto> dtos)
-        {
-            var properties = new List<Property>();
-            foreach (var dto in dtos)
-            {
-                if (_mediaType.CompositionPropertyTypes.Any(x => x.Id == dto.PropertyTypeId))
-                {
-                    var propertyType = _mediaType.CompositionPropertyTypes.First(x => x.Id == dto.PropertyTypeId);
-                    var property = propertyType.CreatePropertyFromRawValue(dto.GetValue, dto.VersionId.Value, dto.Id);
-
-                    property.ResetDirtyProperties();
-                    properties.Add(property);
-                }
-            }
-            return properties;
-        }
     }
 }

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

@@ -1,4 +1,5 @@
-using System.Collections.Generic;
+using System;
+using System.Collections.Generic;
 using System.Linq;
 using Umbraco.Core.Models;
 using Umbraco.Core.Models.Rdbms;
@@ -22,9 +23,21 @@ namespace Umbraco.Core.Persistence.Factories
             foreach (var groupDto in dto)
             {
                 var group = new PropertyGroup();
-                group.Id = groupDto.Id;
+                //Only assign an Id if the PropertyGroup belongs to this ContentType
+                if (groupDto.ContentTypeNodeId == _id)
+                {
+                    group.Id = groupDto.Id;
+
+                    if (groupDto.ParentGroupId.HasValue)
+                        group.ParentId = groupDto.ParentGroupId.Value;
+                }
+                else
+                {
+                    //If the PropertyGroup is inherited, we add a reference to the group as a Parent.
+                    group.ParentId = groupDto.Id;
+                }
+
                 group.Name = groupDto.Text;
-                group.ParentId = groupDto.ParentGroupId;
                 group.SortOrder = groupDto.SortOrder;
                 group.PropertyTypes = new PropertyTypeCollection();
 
@@ -32,7 +45,8 @@ namespace Umbraco.Core.Persistence.Factories
                 var typeDtos = groupDto.PropertyTypeDtos.Where(x => x.Id > 0);
                 foreach (var typeDto in typeDtos)
                 {
-                    group.PropertyTypes.Add(new PropertyType(typeDto.DataTypeDto.ControlId,
+                    var tempGroupDto = groupDto;
+                    var propertyType = new PropertyType(typeDto.DataTypeDto.ControlId,
                                                              typeDto.DataTypeDto.DbType.EnumParse<DataTypeDatabaseType>(true))
                                                 {
                                                     Alias = typeDto.Alias,
@@ -43,9 +57,12 @@ namespace Umbraco.Core.Persistence.Factories
                                                     HelpText = typeDto.HelpText,
                                                     Mandatory = typeDto.Mandatory,
                                                     SortOrder = typeDto.SortOrder,
-                                                    PropertyGroupId = groupDto.Id
-                                                });
-
+                                                    ValidationRegExp = typeDto.ValidationRegExp,
+                                                    PropertyGroupId = new Lazy<int>(() => tempGroupDto.Id)
+                                                };
+                    
+                    propertyType.ResetDirtyProperties();
+                    group.PropertyTypes.Add(propertyType);
                 }
                 group.ResetDirtyProperties();
                 propertyGroups.Add(group);
@@ -67,10 +84,12 @@ namespace Umbraco.Core.Persistence.Factories
                              {
                                  ContentTypeNodeId = _id,
                                  SortOrder = propertyGroup.SortOrder,
-                                 Text = propertyGroup.Name,
-                                 ParentGroupId = propertyGroup.ParentId
+                                 Text = propertyGroup.Name
                              };
 
+            if (propertyGroup.ParentId.HasValue)
+                dto.ParentGroupId = propertyGroup.ParentId.Value;
+
             if (propertyGroup.HasIdentity)
                 dto.Id = propertyGroup.Id;
 
@@ -90,11 +109,18 @@ namespace Umbraco.Core.Persistence.Factories
                                           HelpText = propertyType.HelpText,
                                           Mandatory = propertyType.Mandatory,
                                           Name = propertyType.Name,
-                                          SortOrder = propertyType.SortOrder
+                                          SortOrder = propertyType.SortOrder,
+                                          ValidationRegExp = propertyType.ValidationRegExp
                                       };
 
             if (tabId != default(int))
+            {
                 propertyTypeDto.PropertyTypeGroupId = tabId;
+            }
+            else
+            {
+                propertyTypeDto.PropertyTypeGroupId = null;
+            }
 
             if (propertyType.HasIdentity)
                 propertyTypeDto.Id = propertyType.Id;

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

@@ -28,17 +28,22 @@ namespace Umbraco.Core.Persistence.Factories
         
         public Template BuildEntity(TemplateDto dto)
         {
-            return new Template(string.Empty, dto.NodeDto.Text, dto.Alias)
-                       {
-                           CreateDate = dto.NodeDto.CreateDate,
-                           Id = dto.NodeId,
-                           Key = dto.NodeDto.UniqueId.Value,
-                           CreatorId = dto.NodeDto.UserId.Value,
-                           Level = dto.NodeDto.Level,
-                           ParentId = dto.NodeDto.ParentId,
-                           SortOrder = dto.NodeDto.SortOrder,
-                           NodePath = dto.NodeDto.Path
-                       };
+            var template = new Template(string.Empty, dto.NodeDto.Text, dto.Alias)
+                               {
+                                   CreateDate = dto.NodeDto.CreateDate,
+                                   Id = dto.NodeId,
+                                   Key = dto.NodeDto.UniqueId.Value,
+                                   CreatorId = dto.NodeDto.UserId.Value,
+                                   Level = dto.NodeDto.Level,
+                                   ParentId = dto.NodeDto.ParentId,
+                                   SortOrder = dto.NodeDto.SortOrder,
+                                   NodePath = dto.NodeDto.Path
+                               };
+            
+            if(dto.Master.HasValue)
+                template.MasterTemplateId = new Lazy<int>(() => dto.Master.Value);
+
+            return template;
         }
 
         public TemplateDto BuildDto(Template entity)
@@ -50,6 +55,11 @@ namespace Umbraco.Core.Persistence.Factories
                            NodeDto = BuildNodeDto(entity)
                        };
 
+            if (entity.MasterTemplateId != null && entity.MasterTemplateId.Value != default(int))
+            {
+                dto.Master = entity.MasterTemplateId.Value;
+            }
+
             if (entity.HasIdentity)
             {
                 dto.NodeId = entity.Id;

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

@@ -29,7 +29,7 @@ namespace Umbraco.Core.Persistence.Factories
                            IsLockedOut = dto.Disabled,
                            IsApproved = dto.Disabled == false,
                            Email = dto.Email,
-                           Lanuguage = dto.UserLanguage,
+                           Language = dto.UserLanguage,
                            DefaultToLiveEditing = dto.DefaultToLiveEditing,
                            NoConsole = dto.NoConsole,
                            Permissions = dto.DefaultPermissions
@@ -48,7 +48,7 @@ namespace Umbraco.Core.Persistence.Factories
                               Login = entity.Username,
                               NoConsole = entity.NoConsole,
                               Password = entity.Password,
-                              UserLanguage = entity.Lanuguage,
+                              UserLanguage = entity.Language,
                               UserName = entity.Name,
                               Type = short.Parse(entity.UserType.Id.ToString()),
                               DefaultPermissions = entity.Permissions

src/Umbraco.Core/Persistence/Mappers/BaseMapper.cs

@@ -30,8 +30,8 @@ namespace Umbraco.Core.Persistence.Mappers
             string columnName = columnAttribute.Name;
 
             string columnMap = string.Format("{0}.{1}",
-                                             SyntaxConfig.SqlSyntaxProvider.GetQuotedTableName(tableName),
-                                             SyntaxConfig.SqlSyntaxProvider.GetQuotedColumnName(columnName));
+                                             SqlSyntaxContext.SqlSyntaxProvider.GetQuotedTableName(tableName),
+                                             SqlSyntaxContext.SqlSyntaxProvider.GetQuotedColumnName(columnName));
             return columnMap;
         }
     }

src/Umbraco.Core/Persistence/Mappers/ModelDtoMapper.cs

@@ -0,0 +1,86 @@
+using System;
+using System.Reflection;
+using Umbraco.Core.Models;
+
+namespace Umbraco.Core.Persistence.Mappers
+{
+    internal class ModelDtoMapper : IMapper
+    {
+        public void GetTableInfo(Type t, TableInfo ti)
+        { }
+
+        public bool MapPropertyToColumn(PropertyInfo pi, ref string columnName, ref bool resultColumn)
+        {
+            if (pi.DeclaringType == typeof(Content) || pi.DeclaringType == typeof(IContent))
+            {
+                switch (pi.Name)
+                {
+                    case "Trashed":
+                        columnName = "[umbracoNode].[trashed]";
+                        return true;
+                    case "ParentId":
+                        columnName = "[umbracoNode].[parentID]";
+                        return true;
+                    case "UserId":
+                        columnName = "[umbracoNode].[nodeUser]";
+                        return true;
+                    case "Level":
+                        columnName = "[umbracoNode].[level]";
+                        return true;
+                    case "Path":
+                        columnName = "[umbracoNode].[path]";
+                        return true;
+                    case "SortOrder":
+                        columnName = "[umbracoNode].[sortOrder]";
+                        return true;
+                    case "NodeId":
+                        columnName = "[umbracoNode].[id]";
+                        return true;
+                    case "Published":
+                        columnName = "[cmsDocument].[published]";
+                        return true;
+                    case "Key":
+                        columnName = "[umbracoNode].[uniqueID]";
+                        return true;
+                    case "CreateDate":
+                        columnName = "[umbracoNode].[createDate]";
+                        return true;
+                    case "Name":
+                        columnName = "[umbracoNode].[text]";
+                        return true;
+                }
+            }
+
+            if (pi.DeclaringType == typeof(ContentType) || pi.DeclaringType == typeof(IContentType))
+            {
+                switch (pi.Name)
+                {
+                    case "Alias":
+                        columnName = "[cmsContentType].[alias]";
+                        return true;
+                    case "Icon":
+                        columnName = "[cmsContentType].[icon]";
+                        return true;
+                    case "Thumbnail":
+                        columnName = "[cmsContentType].[thumbnail]";
+                        return true;
+                    case "Description":
+                        columnName = "[cmsContentType].[description]";
+                        return true;
+                }
+            }
+
+            return true;
+        }
+
+        public Func<object, object> GetFromDbConverter(PropertyInfo pi, Type sourceType)
+        {
+            return null;
+        }
+
+        public Func<object, object> GetToDbConverter(Type sourceType)
+        {
+            return null;
+        }
+    }
+}

src/Umbraco.Core/Persistence/Mappers/UserMapper.cs

@@ -33,7 +33,7 @@ namespace Umbraco.Core.Persistence.Mappers
             CacheMap<User, UserDto>(src => src.IsApproved, dto => dto.Disabled);
             CacheMap<User, UserDto>(src => src.NoConsole, dto => dto.NoConsole);
             CacheMap<User, UserDto>(src => src.UserType, dto => dto.Type);
-            CacheMap<User, UserDto>(src => src.Lanuguage, dto => dto.UserLanguage);
+            CacheMap<User, UserDto>(src => src.Language, dto => dto.UserLanguage);
         }
 
         internal override string Map(string propertyName)

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

@@ -102,7 +102,7 @@ namespace Umbraco.Core.Persistence.Migrations.Initial
             }
 
             //Check tables in configured database against tables in schema
-            var tablesInDatabase = SyntaxConfig.SqlSyntaxProvider.GetTablesInSchema(_database).ToList();
+            var tablesInDatabase = SqlSyntaxContext.SqlSyntaxProvider.GetTablesInSchema(_database).ToList();
             var tablesInSchema = result.TableDefinitions.Select(x => x.Name).ToList();
             //Add valid and invalid table differences to the result object
             var validTableDifferences = tablesInDatabase.Intersect(tablesInSchema);
@@ -117,7 +117,7 @@ namespace Umbraco.Core.Persistence.Migrations.Initial
             }
 
             //Check columns in configured database against columns in schema
-            var columnsInDatabase = SyntaxConfig.SqlSyntaxProvider.GetColumnsInSchema(_database);
+            var columnsInDatabase = SqlSyntaxContext.SqlSyntaxProvider.GetColumnsInSchema(_database);
             var columnsPerTableInDatabase = columnsInDatabase.Select(x => string.Concat(x.TableName, ",", x.ColumnName)).ToList();
             var columnsPerTableInSchema = result.TableDefinitions.SelectMany(x => x.Columns.Select(y => string.Concat(y.TableName, ",", y.Name))).ToList();
             //Add valid and invalid column differences to the result object
@@ -134,11 +134,11 @@ namespace Umbraco.Core.Persistence.Migrations.Initial
 
             //MySql doesn't conform to the "normal" naming of constraints, so there is currently no point in doing these checks.
             //NOTE: At a later point we do other checks for MySql, but ideally it should be necessary to do special checks for different providers.
-            if (SyntaxConfig.SqlSyntaxProvider is MySqlSyntaxProvider)
+            if (SqlSyntaxContext.SqlSyntaxProvider is MySqlSyntaxProvider)
                 return result;
 
             //Check constraints in configured database against constraints in schema
-            var constraintsInDatabase = SyntaxConfig.SqlSyntaxProvider.GetConstraintsPerColumn(_database).DistinctBy(x => x.Item3).ToList();
+            var constraintsInDatabase = SqlSyntaxContext.SqlSyntaxProvider.GetConstraintsPerColumn(_database).DistinctBy(x => x.Item3).ToList();
             var foreignKeysInDatabase = constraintsInDatabase.Where(x => x.Item3.StartsWith("FK_")).Select(x => x.Item3).ToList();
             var primaryKeysInDatabase = constraintsInDatabase.Where(x => x.Item3.StartsWith("PK_")).Select(x => x.Item3).ToList();
             var indexesInDatabase = constraintsInDatabase.Where(x => x.Item3.StartsWith("IX_")).Select(x => x.Item3).ToList();

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

@@ -42,8 +42,10 @@ namespace Umbraco.Core.Persistence.Migrations.Initial
             if(ValidTables.Count == 0)
                 return new Version(0, 0, 0);
 
-            //If Errors is empty then we're at current version
-            if (Errors.Any() == false)
+            //If Errors is empty or if TableDefinitions tables + columns correspond to valid tables + columns then we're at current version
+            if (Errors.Any() == false || 
+                TableDefinitions.Any(x => ValidTables.Contains(x.Name) == false) == false && 
+                TableDefinitions.SelectMany(definition => definition.Columns).Any(x => ValidColumns.Contains(x.Name) == false) == false)
                 return UmbracoVersion.Current;
 
             //If Errors contains umbracoApp or umbracoAppTree its pre-6.0.0 -> new Version(4, 10, 0);
@@ -64,7 +66,7 @@ namespace Umbraco.Core.Persistence.Migrations.Initial
                 return new Version(4, 9, 0);
             }
 
-            return new Version(0, 0, 0);
+            return UmbracoVersion.Current;
         }
 
         /// <summary>
@@ -109,7 +111,7 @@ namespace Umbraco.Core.Persistence.Migrations.Initial
                 sb.AppendLine(" ");
             }
 
-            if (SyntaxConfig.SqlSyntaxProvider is MySqlSyntaxProvider)
+            if (SqlSyntaxContext.SqlSyntaxProvider is MySqlSyntaxProvider)
             {
                 sb.AppendLine("Please note that the constraints could not be validated because the current dataprovider is MySql.");
             }

src/Umbraco.Core/Persistence/Migrations/MigrationRunner.cs

@@ -105,7 +105,7 @@ namespace Umbraco.Core.Persistence.Migrations
                                   migrationAttribute.TargetVersion > _configuredVersion &&
                                   migrationAttribute.TargetVersion <= _targetVersion &&
                                   migrationAttribute.ProductName == _productName
-                              orderby migrationAttribute.SortOrder ascending 
+                              orderby migrationAttribute.TargetVersion, migrationAttribute.SortOrder ascending 
                               select migration);
             return migrations;
         }
@@ -119,7 +119,8 @@ namespace Umbraco.Core.Persistence.Migrations
                                   migrationAttribute.TargetVersion > _configuredVersion &&
                                   migrationAttribute.TargetVersion <= _targetVersion &&
                                   migrationAttribute.ProductName == _productName
-                              orderby migrationAttribute.SortOrder descending 
+                              orderby migrationAttribute.TargetVersion, migrationAttribute.SortOrder descending 
+
                               select migration);
             return migrations;
         }

src/Umbraco.Core/Persistence/Migrations/Syntax/Alter/Expressions/AlterColumnExpression.cs

@@ -21,9 +21,9 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Alter.Expressions
 
         public override string ToString()
         {
-            return string.Format(SyntaxConfig.SqlSyntaxProvider.AlterColumn,
-                                 SyntaxConfig.SqlSyntaxProvider.GetQuotedTableName(TableName),
-                                 SyntaxConfig.SqlSyntaxProvider.GetQuotedColumnName(Column.Name));
+            return string.Format(SqlSyntaxContext.SqlSyntaxProvider.AlterColumn,
+                                 SqlSyntaxContext.SqlSyntaxProvider.GetQuotedTableName(TableName),
+                                 SqlSyntaxContext.SqlSyntaxProvider.GetQuotedColumnName(Column.Name));
         }
     }
 }

src/Umbraco.Core/Persistence/Migrations/Syntax/Alter/Expressions/AlterDefaultConstraintExpression.cs

@@ -22,9 +22,9 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Alter.Expressions
         {
             //NOTE Should probably investigate if Deleting a Default Constraint is different from deleting a 'regular' constraint
 
-            return string.Format(SyntaxConfig.SqlSyntaxProvider.DeleteConstraint,
-                                 SyntaxConfig.SqlSyntaxProvider.GetQuotedTableName(TableName),
-                                 SyntaxConfig.SqlSyntaxProvider.GetQuotedName(ConstraintName));
+            return string.Format(SqlSyntaxContext.SqlSyntaxProvider.DeleteConstraint,
+                                 SqlSyntaxContext.SqlSyntaxProvider.GetQuotedTableName(TableName),
+                                 SqlSyntaxContext.SqlSyntaxProvider.GetQuotedName(ConstraintName));
         }
     }
 }

src/Umbraco.Core/Persistence/Migrations/Syntax/Create/Expressions/CreateConstraintExpression.cs

@@ -17,7 +17,7 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Create.Expressions
         {
             var constraintType = (Constraint.IsPrimaryKeyConstraint) ? "PRIMARY KEY" : "UNIQUE";
 
-            if (Constraint.IsPrimaryKeyConstraint && SyntaxConfig.SqlSyntaxProvider.SupportsClustered())
+            if (Constraint.IsPrimaryKeyConstraint && SqlSyntaxContext.SqlSyntaxProvider.SupportsClustered())
                 constraintType += " CLUSTERED";
 
             if (Constraint.IsNonUniqueConstraint)
@@ -27,12 +27,12 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Create.Expressions
 
             for (int i = 0; i < Constraint.Columns.Count; i++)
             {
-                columns[i] = SyntaxConfig.SqlSyntaxProvider.GetQuotedColumnName(Constraint.Columns.ElementAt(i));
+                columns[i] = SqlSyntaxContext.SqlSyntaxProvider.GetQuotedColumnName(Constraint.Columns.ElementAt(i));
             }
 
-            return string.Format(SyntaxConfig.SqlSyntaxProvider.CreateConstraint,
-                                 SyntaxConfig.SqlSyntaxProvider.GetQuotedTableName(Constraint.TableName),
-                                 SyntaxConfig.SqlSyntaxProvider.GetQuotedName(Constraint.ConstraintName),
+            return string.Format(SqlSyntaxContext.SqlSyntaxProvider.CreateConstraint,
+                                 SqlSyntaxContext.SqlSyntaxProvider.GetQuotedTableName(Constraint.TableName),
+                                 SqlSyntaxContext.SqlSyntaxProvider.GetQuotedName(Constraint.ConstraintName),
                                  constraintType,
                                  string.Join(", ", columns));
         }

src/Umbraco.Core/Persistence/Migrations/Syntax/Create/Expressions/CreateTableExpression.cs

@@ -24,7 +24,7 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Create.Expressions
         {
             var table = new TableDefinition{Name = TableName, SchemaName = SchemaName, Columns = Columns};
 
-            return string.Format(SyntaxConfig.SqlSyntaxProvider.Format(table));
+            return string.Format(SqlSyntaxContext.SqlSyntaxProvider.Format(table));
         }
     }
 }

src/Umbraco.Core/Persistence/Migrations/Syntax/Delete/Expressions/DeleteColumnExpression.cs

@@ -31,9 +31,9 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Delete.Expressions
             foreach (string columnName in ColumnNames)
             {
                 if (ColumnNames.First() != columnName) sb.AppendLine(";");
-                sb.AppendFormat(SyntaxConfig.SqlSyntaxProvider.DropColumn,
-                                SyntaxConfig.SqlSyntaxProvider.GetQuotedTableName(TableName),
-                                SyntaxConfig.SqlSyntaxProvider.GetQuotedColumnName(columnName));
+                sb.AppendFormat(SqlSyntaxContext.SqlSyntaxProvider.DropColumn,
+                                SqlSyntaxContext.SqlSyntaxProvider.GetQuotedTableName(TableName),
+                                SqlSyntaxContext.SqlSyntaxProvider.GetQuotedColumnName(columnName));
             }
 
             return sb.ToString();

src/Umbraco.Core/Persistence/Migrations/Syntax/Delete/Expressions/DeleteConstraintExpression.cs

@@ -14,9 +14,9 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Delete.Expressions
 
         public override string ToString()
         {
-            return string.Format(SyntaxConfig.SqlSyntaxProvider.DeleteConstraint,
-                                 SyntaxConfig.SqlSyntaxProvider.GetQuotedTableName(Constraint.TableName),
-                                 SyntaxConfig.SqlSyntaxProvider.GetQuotedName(Constraint.ConstraintName));
+            return string.Format(SqlSyntaxContext.SqlSyntaxProvider.DeleteConstraint,
+                                 SqlSyntaxContext.SqlSyntaxProvider.GetQuotedTableName(Constraint.TableName),
+                                 SqlSyntaxContext.SqlSyntaxProvider.GetQuotedName(Constraint.ConstraintName));
         }
     }
 }

src/Umbraco.Core/Persistence/Migrations/Syntax/Delete/Expressions/DeleteDataExpression.cs

@@ -32,7 +32,7 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Delete.Expressions
 
             if (IsAllRows)
             {
-                deleteItems.Add(string.Format(SyntaxConfig.SqlSyntaxProvider.DeleteData, SyntaxConfig.SqlSyntaxProvider.GetQuotedTableName(TableName), "1 = 1"));
+                deleteItems.Add(string.Format(SqlSyntaxContext.SqlSyntaxProvider.DeleteData, SqlSyntaxContext.SqlSyntaxProvider.GetQuotedTableName(TableName), "1 = 1"));
             }
             else
             {
@@ -42,13 +42,13 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Delete.Expressions
                     foreach (KeyValuePair<string, object> item in row)
                     {
                         whereClauses.Add(string.Format("{0} {1} {2}",
-                                                       SyntaxConfig.SqlSyntaxProvider.GetQuotedColumnName(item.Key),
+                                                       SqlSyntaxContext.SqlSyntaxProvider.GetQuotedColumnName(item.Key),
                                                        item.Value == null ? "IS" : "=",
-                                                       SyntaxConfig.SqlSyntaxProvider.GetQuotedValue(item.Value.ToString())));
+                                                       SqlSyntaxContext.SqlSyntaxProvider.GetQuotedValue(item.Value.ToString())));
                     }
 
-                    deleteItems.Add(string.Format(SyntaxConfig.SqlSyntaxProvider.DeleteData,
-                                                  SyntaxConfig.SqlSyntaxProvider.GetQuotedTableName(TableName),
+                    deleteItems.Add(string.Format(SqlSyntaxContext.SqlSyntaxProvider.DeleteData,
+                                                  SqlSyntaxContext.SqlSyntaxProvider.GetQuotedTableName(TableName),
                                                   String.Join(" AND ", whereClauses.ToArray())));
                 }
             }

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

@@ -22,7 +22,7 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Delete.Expressions
             if (IsExpressionSupported() == false)
                 return string.Empty;
 
-            return string.Format(SyntaxConfig.SqlSyntaxProvider.DeleteDefaultConstraint,
+            return string.Format(SqlSyntaxContext.SqlSyntaxProvider.DeleteDefaultConstraint,
                                  TableName,
                                  ColumnName);
         }

src/Umbraco.Core/Persistence/Migrations/Syntax/Delete/Expressions/DeleteForeignKeyExpression.cs

@@ -33,10 +33,10 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Delete.Expressions
                 if (string.IsNullOrEmpty(ForeignKey.Name))
                     ForeignKey.Name = string.Format("{0}_ibfk_1", ForeignKey.ForeignTable.ToLower());
 
-                return string.Format(SyntaxConfig.SqlSyntaxProvider.DeleteConstraint,
-                                 SyntaxConfig.SqlSyntaxProvider.GetQuotedTableName(ForeignKey.ForeignTable),
+                return string.Format(SqlSyntaxContext.SqlSyntaxProvider.DeleteConstraint,
+                                 SqlSyntaxContext.SqlSyntaxProvider.GetQuotedTableName(ForeignKey.ForeignTable),
                                  "FOREIGN KEY ",
-                                 SyntaxConfig.SqlSyntaxProvider.GetQuotedName(ForeignKey.Name));
+                                 SqlSyntaxContext.SqlSyntaxProvider.GetQuotedName(ForeignKey.Name));
             }
 
             if (string.IsNullOrEmpty(ForeignKey.Name))
@@ -44,9 +44,9 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Delete.Expressions
                 ForeignKey.Name = string.Format("FK_{0}_{1}", ForeignKey.ForeignTable, ForeignKey.PrimaryTable);
             }
 
-            return string.Format(SyntaxConfig.SqlSyntaxProvider.DeleteConstraint,
-                                 SyntaxConfig.SqlSyntaxProvider.GetQuotedTableName(ForeignKey.ForeignTable),
-                                 SyntaxConfig.SqlSyntaxProvider.GetQuotedName(ForeignKey.Name));
+            return string.Format(SqlSyntaxContext.SqlSyntaxProvider.DeleteConstraint,
+                                 SqlSyntaxContext.SqlSyntaxProvider.GetQuotedTableName(ForeignKey.ForeignTable),
+                                 SqlSyntaxContext.SqlSyntaxProvider.GetQuotedName(ForeignKey.Name));
         }
     }
 }

src/Umbraco.Core/Persistence/Migrations/Syntax/Delete/Expressions/DeleteIndexExpression.cs

@@ -19,9 +19,9 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Delete.Expressions
 
         public override string ToString()
         {
-            return string.Format(SyntaxConfig.SqlSyntaxProvider.DropIndex,
-                                 SyntaxConfig.SqlSyntaxProvider.GetQuotedName(Index.Name),
-                                 SyntaxConfig.SqlSyntaxProvider.GetQuotedTableName(Index.TableName));
+            return string.Format(SqlSyntaxContext.SqlSyntaxProvider.DropIndex,
+                                 SqlSyntaxContext.SqlSyntaxProvider.GetQuotedName(Index.Name),
+                                 SqlSyntaxContext.SqlSyntaxProvider.GetQuotedTableName(Index.TableName));
         }
     }
 }

src/Umbraco.Core/Persistence/Migrations/Syntax/Delete/Expressions/DeleteTableExpression.cs

@@ -17,8 +17,8 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Delete.Expressions
 
         public override string ToString()
         {
-            return string.Format(SyntaxConfig.SqlSyntaxProvider.DropTable,
-                                 SyntaxConfig.SqlSyntaxProvider.GetQuotedTableName(TableName));
+            return string.Format(SqlSyntaxContext.SqlSyntaxProvider.DropTable,
+                                 SqlSyntaxContext.SqlSyntaxProvider.GetQuotedTableName(TableName));
         }
     }
 }

src/Umbraco.Core/Persistence/Migrations/Syntax/Execute/ExecuteBuilder.cs

@@ -1,4 +1,5 @@
-using Umbraco.Core.Persistence.Migrations.Syntax.Execute.Expressions;
+using System;
+using Umbraco.Core.Persistence.Migrations.Syntax.Execute.Expressions;
 
 namespace Umbraco.Core.Persistence.Migrations.Syntax.Execute
 {
@@ -21,5 +22,14 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Execute
                                                                      _databaseProviders) {SqlStatement = sqlStatement};
             _context.Expressions.Add(expression);
         }
+
+        public void Code(Func<Database, string> codeStatement)
+        {
+            var expression = _databaseProviders == null
+                                 ? new ExecuteCodeStatementExpression { CodeStatement = codeStatement }
+                                 : new ExecuteCodeStatementExpression(_context.CurrentDatabaseProvider,
+                                                                     _databaseProviders) { CodeStatement = codeStatement };
+            _context.Expressions.Add(expression);
+        }
     }
 }

src/Umbraco.Core/Persistence/Migrations/Syntax/Execute/Expressions/ExecuteCodeStatementExpression.cs

@@ -0,0 +1,26 @@
+using System;
+
+namespace Umbraco.Core.Persistence.Migrations.Syntax.Execute.Expressions
+{
+    public class ExecuteCodeStatementExpression : MigrationExpressionBase
+    {
+        public ExecuteCodeStatementExpression()
+        {
+        }
+
+        public ExecuteCodeStatementExpression(DatabaseProviders current, DatabaseProviders[] databaseProviders)
+            : base(current, databaseProviders)
+        {
+        }
+
+        public virtual Func<Database, string> CodeStatement { get; set; }
+
+        public override string Process(Database database)
+        {
+            if(CodeStatement != null)
+                return CodeStatement(database);
+
+            return base.Process(database);
+        }
+    }
+}

src/Umbraco.Core/Persistence/Migrations/Syntax/Execute/IExecuteBuilder.cs

@@ -1,7 +1,10 @@
-namespace Umbraco.Core.Persistence.Migrations.Syntax.Execute
+using System;
+
+namespace Umbraco.Core.Persistence.Migrations.Syntax.Execute
 {
     public interface IExecuteBuilder : IFluentSyntax
     {
         void Sql(string sqlStatement);
+        void Code(Func<Database, string> codeStatement);
     }
 }

src/Umbraco.Core/Persistence/Migrations/Syntax/Expressions/CreateColumnExpression.cs

@@ -28,9 +28,9 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Expressions
             if (string.IsNullOrEmpty(Column.TableName))
                 Column.TableName = TableName;
 
-            return string.Format(SyntaxConfig.SqlSyntaxProvider.AddColumn,
-                                 SyntaxConfig.SqlSyntaxProvider.GetQuotedTableName(Column.TableName),
-                                 SyntaxConfig.SqlSyntaxProvider.Format(Column));
+            return string.Format(SqlSyntaxContext.SqlSyntaxProvider.AddColumn,
+                                 SqlSyntaxContext.SqlSyntaxProvider.GetQuotedTableName(Column.TableName),
+                                 SqlSyntaxContext.SqlSyntaxProvider.Format(Column));
         }
     }
 }

src/Umbraco.Core/Persistence/Migrations/Syntax/Expressions/CreateForeignKeyExpression.cs

@@ -23,7 +23,7 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Expressions
             if (IsExpressionSupported() == false)
                 return string.Empty;
 
-            return SyntaxConfig.SqlSyntaxProvider.Format(ForeignKey);
+            return SqlSyntaxContext.SqlSyntaxProvider.Format(ForeignKey);
         }
     }
 }

src/Umbraco.Core/Persistence/Migrations/Syntax/Expressions/CreateIndexExpression.cs

@@ -19,7 +19,7 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Expressions
 
         public override string ToString()
         {
-            return SyntaxConfig.SqlSyntaxProvider.Format(Index);
+            return SqlSyntaxContext.SqlSyntaxProvider.Format(Index);
         }
     }
 }

src/Umbraco.Core/Persistence/Migrations/Syntax/Rename/Expressions/RenameColumnExpression.cs

@@ -52,7 +52,7 @@ SELECT CONCAT(
             if (IsExpressionSupported() == false)
                 return string.Empty;
 
-            return SyntaxConfig.SqlSyntaxProvider.FormatColumnRename(TableName, OldName, NewName);
+            return SqlSyntaxContext.SqlSyntaxProvider.FormatColumnRename(TableName, OldName, NewName);
         }
     }
 }

src/Umbraco.Core/Persistence/Migrations/Syntax/Rename/Expressions/RenameTableExpression.cs

@@ -22,7 +22,7 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Rename.Expressions
             if (IsExpressionSupported() == false)
                 return string.Empty;
             
-            return SyntaxConfig.SqlSyntaxProvider.FormatTableRename(OldName, NewName);
+            return SqlSyntaxContext.SqlSyntaxProvider.FormatTableRename(OldName, NewName);
         }
     }
 }

src/Umbraco.Core/Persistence/Migrations/Syntax/Update/Expressions/UpdateDataExpression.cs

@@ -31,8 +31,8 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Update.Expressions
             foreach (var item in Set)
             {
                 updateItems.Add(string.Format("{0} = {1}",
-                                              SyntaxConfig.SqlSyntaxProvider.GetQuotedColumnName(item.Key),
-                                              SyntaxConfig.SqlSyntaxProvider.GetQuotedValue(item.Value.ToString())));
+                                              SqlSyntaxContext.SqlSyntaxProvider.GetQuotedColumnName(item.Key),
+                                              SqlSyntaxContext.SqlSyntaxProvider.GetQuotedValue(item.Value.ToString())));
             }
 
             if (IsAllRows)
@@ -44,13 +44,13 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Update.Expressions
                 foreach (var item in Where)
                 {
                     whereClauses.Add(string.Format("{0} {1} {2}",
-                                                   SyntaxConfig.SqlSyntaxProvider.GetQuotedColumnName(item.Key),
+                                                   SqlSyntaxContext.SqlSyntaxProvider.GetQuotedColumnName(item.Key),
                                                    item.Value == null ? "IS" : "=",
-                                                   SyntaxConfig.SqlSyntaxProvider.GetQuotedValue(item.Value.ToString())));
+                                                   SqlSyntaxContext.SqlSyntaxProvider.GetQuotedValue(item.Value.ToString())));
                 }
             }
-            return string.Format(SyntaxConfig.SqlSyntaxProvider.UpdateData,
-                                 SyntaxConfig.SqlSyntaxProvider.GetQuotedTableName(TableName),
+            return string.Format(SqlSyntaxContext.SqlSyntaxProvider.UpdateData,
+                                 SqlSyntaxContext.SqlSyntaxProvider.GetQuotedTableName(TableName),
                                  string.Join(", ", updateItems.ToArray()), 
                                  string.Join(" AND ", whereClauses.ToArray()));
         }

src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSixZeroOne/UpdatePropertyTypesAndGroups.cs

@@ -0,0 +1,79 @@
+using System;
+using System.Linq;
+using Umbraco.Core.Configuration;
+using Umbraco.Core.Models.Rdbms;
+
+namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSixZeroOne
+{
+    [Migration("6.0.2", 0, GlobalSettings.UmbracoMigrationName)]
+    public class UpdatePropertyTypesAndGroups : MigrationBase
+    {
+        public override void Up()
+        {
+            Execute.Code(UpdatePropertyTypesAndGroupsDo);
+        }
+
+        public override void Down()
+        {
+            
+        }
+
+        public static string UpdatePropertyTypesAndGroupsDo(Database database)
+        {
+            if (database != null)
+            {
+                //Fetch all PropertyTypes that belongs to a PropertyTypeGroup
+                var propertyTypes = database.Fetch<PropertyTypeDto>("WHERE propertyTypeGroupId > 0");
+                var propertyGroups = database.Fetch<PropertyTypeGroupDto>("WHERE id > 0");
+
+                foreach (var propertyType in propertyTypes)
+                {
+                    //Get the PropertyTypeGroup that the current PropertyType references
+                    var parentPropertyTypeGroup = propertyGroups.FirstOrDefault(x => x.Id == propertyType.PropertyTypeGroupId);
+                    if (parentPropertyTypeGroup != null)
+                    {
+                        //If the ContentType is the same on the PropertyType and the PropertyTypeGroup the group is valid and we skip to the next
+                        if (parentPropertyTypeGroup.ContentTypeNodeId == propertyType.ContentTypeId) continue;
+
+                        //Check if the 'new' PropertyTypeGroup has already been created
+                        var existingPropertyTypeGroup =
+                            propertyGroups.FirstOrDefault(
+                                x =>
+                                x.ParentGroupId == parentPropertyTypeGroup.Id && x.Text == parentPropertyTypeGroup.Text &&
+                                x.ContentTypeNodeId == propertyType.ContentTypeId);
+
+                        //This should ensure that we don't create duplicate groups for a single ContentType
+                        if (existingPropertyTypeGroup == null)
+                        {
+
+                            //Create a new PropertyTypeGroup that references the parent group that the PropertyType was referencing pre-6.0.1
+                            var propertyGroup = new PropertyTypeGroupDto
+                                                    {
+                                                        ContentTypeNodeId = propertyType.ContentTypeId,
+                                                        ParentGroupId = parentPropertyTypeGroup.Id,
+                                                        Text = parentPropertyTypeGroup.Text,
+                                                        SortOrder = parentPropertyTypeGroup.SortOrder
+                                                    };
+
+                            //Save the PropertyTypeGroup in the database and update the list of groups with this new group
+                            int id = Convert.ToInt16(database.Insert(propertyGroup));
+                            propertyGroup.Id = id;
+                            propertyGroups.Add(propertyGroup);
+                            //Update the reference to the new PropertyTypeGroup on the current PropertyType
+                            propertyType.PropertyTypeGroupId = id;
+                            database.Update(propertyType);
+                        }
+                        else
+                        {
+                            //Update the reference to the existing PropertyTypeGroup on the current PropertyType
+                            propertyType.PropertyTypeGroupId = existingPropertyTypeGroup.Id;
+                            database.Update(propertyType);
+                        }
+                    }
+                }
+            }
+
+            return string.Empty;
+        }
+    }
+}

src/Umbraco.Core/Persistence/PetaPocoExtensions.cs

@@ -33,10 +33,10 @@ namespace Umbraco.Core.Persistence
             var tableDefinition = DefinitionFactory.GetTableDefinition(modelType);
             var tableName = tableDefinition.Name;
 
-            string createSql = SyntaxConfig.SqlSyntaxProvider.Format(tableDefinition);
-            string createPrimaryKeySql = SyntaxConfig.SqlSyntaxProvider.FormatPrimaryKey(tableDefinition);
-            var foreignSql = SyntaxConfig.SqlSyntaxProvider.Format(tableDefinition.ForeignKeys);
-            var indexSql = SyntaxConfig.SqlSyntaxProvider.Format(tableDefinition.Indexes);
+            string createSql = SqlSyntaxContext.SqlSyntaxProvider.Format(tableDefinition);
+            string createPrimaryKeySql = SqlSyntaxContext.SqlSyntaxProvider.FormatPrimaryKey(tableDefinition);
+            var foreignSql = SqlSyntaxContext.SqlSyntaxProvider.Format(tableDefinition.ForeignKeys);
+            var indexSql = SqlSyntaxContext.SqlSyntaxProvider.Format(tableDefinition.Indexes);
 
             var tableExist = db.TableExist(tableName);
             if (overwrite && tableExist)
@@ -65,18 +65,18 @@ namespace Umbraco.Core.Persistence
                         var e = new TableCreationEventArgs();
 
                         //Turn on identity insert if db provider is not mysql
-                        if (SyntaxConfig.SqlSyntaxProvider.SupportsIdentityInsert() && tableDefinition.Columns.Any(x => x.IsIdentity))
-                            db.Execute(new Sql(string.Format("SET IDENTITY_INSERT {0} ON ", SyntaxConfig.SqlSyntaxProvider.GetQuotedTableName(tableName))));
+                        if (SqlSyntaxContext.SqlSyntaxProvider.SupportsIdentityInsert() && tableDefinition.Columns.Any(x => x.IsIdentity))
+                            db.Execute(new Sql(string.Format("SET IDENTITY_INSERT {0} ON ", SqlSyntaxContext.SqlSyntaxProvider.GetQuotedTableName(tableName))));
                         
                         //Call the NewTable-event to trigger the insert of base/default data
                         NewTable(tableName, db, e);
 
                         //Turn off identity insert if db provider is not mysql
-                        if (SyntaxConfig.SqlSyntaxProvider.SupportsIdentityInsert() && tableDefinition.Columns.Any(x => x.IsIdentity))
-                            db.Execute(new Sql(string.Format("SET IDENTITY_INSERT {0} OFF;", SyntaxConfig.SqlSyntaxProvider.GetQuotedTableName(tableName))));
+                        if (SqlSyntaxContext.SqlSyntaxProvider.SupportsIdentityInsert() && tableDefinition.Columns.Any(x => x.IsIdentity))
+                            db.Execute(new Sql(string.Format("SET IDENTITY_INSERT {0} OFF;", SqlSyntaxContext.SqlSyntaxProvider.GetQuotedTableName(tableName))));
 
                         //Special case for MySql
-                        if (SyntaxConfig.SqlSyntaxProvider is MySqlSyntaxProvider && tableName.Equals("umbracoUser"))
+                        if (SqlSyntaxContext.SqlSyntaxProvider is MySqlSyntaxProvider && tableName.Equals("umbracoUser"))
                         {
                             db.Update<UserDto>("SET id = @IdAfter WHERE id = @IdBefore AND userLogin = @Login", new { IdAfter = 0, IdBefore = 1, Login = "admin" });
                         }
@@ -120,22 +120,40 @@ namespace Umbraco.Core.Persistence
 
         public static void DropTable(this Database db, string tableName)
         {
-            var sql = new Sql(string.Format("DROP TABLE {0}", SyntaxConfig.SqlSyntaxProvider.GetQuotedTableName(tableName)));
+            var sql = new Sql(string.Format(
+                SqlSyntaxContext.SqlSyntaxProvider.DropTable,
+                SqlSyntaxContext.SqlSyntaxProvider.GetQuotedTableName(tableName)));
+            db.Execute(sql);
+        }
+
+        public static void TruncateTable(this Database db, string tableName)
+        {
+            var sql = new Sql(string.Format(
+                SqlSyntaxContext.SqlSyntaxProvider.TruncateTable,
+                SqlSyntaxContext.SqlSyntaxProvider.GetQuotedTableName(tableName)));
             db.Execute(sql);
         }
 
         public static bool TableExist(this Database db, string tableName)
         {
-            return SyntaxConfig.SqlSyntaxProvider.DoesTableExist(db, tableName);
+            return SqlSyntaxContext.SqlSyntaxProvider.DoesTableExist(db, tableName);
         }
 
         public static bool TableExist(this UmbracoDatabase db, string tableName)
         {
-            return SyntaxConfig.SqlSyntaxProvider.DoesTableExist(db, tableName);
+            return SqlSyntaxContext.SqlSyntaxProvider.DoesTableExist(db, tableName);
         }
 
         public static void CreateDatabaseSchema(this Database db)
         {
+            CreateDatabaseSchema(db, true);
+        }
+
+        internal static void CreateDatabaseSchema(this Database db, bool guardConfiguration)
+        {
+            if (guardConfiguration && ApplicationContext.Current.IsConfigured)
+                throw new Exception("Umbraco is already configured!");
+
             NewTable += PetaPocoExtensions_NewTable;
 
             LogHelper.Info<Database>("Initializing database schema creation");
@@ -143,6 +161,8 @@ namespace Umbraco.Core.Persistence
             var creation = new DatabaseSchemaCreation(db);
             creation.InitializeDatabaseSchema();
 
+            LogHelper.Info<Database>("Finalized database schema creation");
+
             NewTable -= PetaPocoExtensions_NewTable;
         }
 

src/Umbraco.Core/Persistence/PetaPocoSqlExtensions.cs

@@ -17,7 +17,7 @@ namespace Umbraco.Core.Persistence
             var tableNameAttribute = type.FirstAttribute<TableNameAttribute>();
             string tableName = tableNameAttribute == null ? string.Empty : tableNameAttribute.Value;
 
-            return sql.From(SyntaxConfig.SqlSyntaxProvider.GetQuotedTableName(tableName));
+            return sql.From(SqlSyntaxContext.SqlSyntaxProvider.GetQuotedTableName(tableName));
         }
 
         public static Sql Where<T>(this Sql sql, Expression<Func<T, bool>> predicate)
@@ -38,8 +38,8 @@ namespace Umbraco.Core.Persistence
             string tableName = tableNameAttribute == null ? string.Empty : tableNameAttribute.Value;
 
             var syntax = string.Format("{0}.{1}",
-                SyntaxConfig.SqlSyntaxProvider.GetQuotedTableName(tableName),
-                SyntaxConfig.SqlSyntaxProvider.GetQuotedColumnName(columnName));
+                SqlSyntaxContext.SqlSyntaxProvider.GetQuotedTableName(tableName),
+                SqlSyntaxContext.SqlSyntaxProvider.GetQuotedColumnName(columnName));
 
             return sql.OrderBy(syntax);
         }
@@ -54,8 +54,8 @@ namespace Umbraco.Core.Persistence
             string tableName = tableNameAttribute == null ? string.Empty : tableNameAttribute.Value;
 
             var syntax = string.Format("{0}.{1} DESC",
-                SyntaxConfig.SqlSyntaxProvider.GetQuotedTableName(tableName),
-                SyntaxConfig.SqlSyntaxProvider.GetQuotedColumnName(columnName));
+                SqlSyntaxContext.SqlSyntaxProvider.GetQuotedTableName(tableName),
+                SqlSyntaxContext.SqlSyntaxProvider.GetQuotedColumnName(columnName));
 
             return sql.OrderBy(syntax);
         }
@@ -65,7 +65,7 @@ namespace Umbraco.Core.Persistence
             var column = ExpressionHelper.FindProperty(columnMember) as PropertyInfo;
             var columnName = column.FirstAttribute<ColumnAttribute>().Name;
 
-            return sql.GroupBy(SyntaxConfig.SqlSyntaxProvider.GetQuotedColumnName(columnName));
+            return sql.GroupBy(SqlSyntaxContext.SqlSyntaxProvider.GetQuotedColumnName(columnName));
         }
 
         public static Sql.SqlJoinClause InnerJoin<T>(this Sql sql)
@@ -74,7 +74,7 @@ namespace Umbraco.Core.Persistence
             var tableNameAttribute = type.FirstAttribute<TableNameAttribute>();
             string tableName = tableNameAttribute == null ? string.Empty : tableNameAttribute.Value;
 
-            return sql.InnerJoin(SyntaxConfig.SqlSyntaxProvider.GetQuotedTableName(tableName));
+            return sql.InnerJoin(SqlSyntaxContext.SqlSyntaxProvider.GetQuotedTableName(tableName));
         }
 
         public static Sql.SqlJoinClause LeftJoin<T>(this Sql sql)
@@ -83,7 +83,7 @@ namespace Umbraco.Core.Persistence
             var tableNameAttribute = type.FirstAttribute<TableNameAttribute>();
             string tableName = tableNameAttribute == null ? string.Empty : tableNameAttribute.Value;
 
-            return sql.LeftJoin(SyntaxConfig.SqlSyntaxProvider.GetQuotedTableName(tableName));
+            return sql.LeftJoin(SqlSyntaxContext.SqlSyntaxProvider.GetQuotedTableName(tableName));
         }
 
         public static Sql.SqlJoinClause LeftOuterJoin<T>(this Sql sql)
@@ -92,7 +92,7 @@ namespace Umbraco.Core.Persistence
             var tableNameAttribute = type.FirstAttribute<TableNameAttribute>();
             string tableName = tableNameAttribute == null ? string.Empty : tableNameAttribute.Value;
 
-            return sql.LeftOuterJoin(SyntaxConfig.SqlSyntaxProvider.GetQuotedTableName(tableName));
+            return sql.LeftOuterJoin(SqlSyntaxContext.SqlSyntaxProvider.GetQuotedTableName(tableName));
         }
 
         public static Sql.SqlJoinClause RightJoin<T>(this Sql sql)
@@ -101,7 +101,7 @@ namespace Umbraco.Core.Persistence
             var tableNameAttribute = type.FirstAttribute<TableNameAttribute>();
             string tableName = tableNameAttribute == null ? string.Empty : tableNameAttribute.Value;
 
-            return sql.RightJoin(SyntaxConfig.SqlSyntaxProvider.GetQuotedTableName(tableName));
+            return sql.RightJoin(SqlSyntaxContext.SqlSyntaxProvider.GetQuotedTableName(tableName));
         }
 
         public static Sql On<TLeft, TRight>(this Sql.SqlJoinClause sql, Expression<Func<TLeft, object>> leftMember,
@@ -118,10 +118,10 @@ namespace Umbraco.Core.Persistence
             var rightColumnName = right.FirstAttribute<ColumnAttribute>().Name;
 
             string onClause = string.Format("{0}.{1} = {2}.{3}", 
-                SyntaxConfig.SqlSyntaxProvider.GetQuotedTableName(leftTableName),
-                SyntaxConfig.SqlSyntaxProvider.GetQuotedColumnName(leftColumnName),
-                SyntaxConfig.SqlSyntaxProvider.GetQuotedTableName(rightTableName),
-                SyntaxConfig.SqlSyntaxProvider.GetQuotedColumnName(rightColumnName));
+                SqlSyntaxContext.SqlSyntaxProvider.GetQuotedTableName(leftTableName),
+                SqlSyntaxContext.SqlSyntaxProvider.GetQuotedColumnName(leftColumnName),
+                SqlSyntaxContext.SqlSyntaxProvider.GetQuotedTableName(rightTableName),
+                SqlSyntaxContext.SqlSyntaxProvider.GetQuotedColumnName(rightColumnName));
             return sql.On(onClause);
         }
     }

src/Umbraco.Core/Persistence/Querying/ExpressionHelper.cs

@@ -0,0 +1,572 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Globalization;
+using System.Linq;
+using System.Linq.Expressions;
+using System.Text;
+using Umbraco.Core.Persistence.Mappers;
+
+namespace Umbraco.Core.Persistence.Querying
+{
+    internal class ExpressionHelper<T>
+    {
+        private string selectExpression = string.Empty;
+        private string whereExpression;
+        private string groupBy = string.Empty;
+        private string havingExpression;
+        private string orderBy = string.Empty;
+
+        IList<string> updateFields = new List<string>();
+        IList<string> insertFields = new List<string>();
+
+        private string sep = string.Empty;
+        private bool useFieldName = false;
+        private Database.PocoData pd;
+
+        public ExpressionHelper()
+        {
+            Database.Mapper = new ModelDtoMapper();
+            pd = new Database.PocoData(typeof(T));
+        }
+
+        protected internal virtual string Visit(Expression exp)
+        {
+
+            if (exp == null) return string.Empty;
+            switch (exp.NodeType)
+            {
+                case ExpressionType.Lambda:
+                    return VisitLambda(exp as LambdaExpression);
+                case ExpressionType.MemberAccess:
+                    return VisitMemberAccess(exp as MemberExpression);
+                case ExpressionType.Constant:
+                    return VisitConstant(exp as ConstantExpression);
+                case ExpressionType.Add:
+                case ExpressionType.AddChecked:
+                case ExpressionType.Subtract:
+                case ExpressionType.SubtractChecked:
+                case ExpressionType.Multiply:
+                case ExpressionType.MultiplyChecked:
+                case ExpressionType.Divide:
+                case ExpressionType.Modulo:
+                case ExpressionType.And:
+                case ExpressionType.AndAlso:
+                case ExpressionType.Or:
+                case ExpressionType.OrElse:
+                case ExpressionType.LessThan:
+                case ExpressionType.LessThanOrEqual:
+                case ExpressionType.GreaterThan:
+                case ExpressionType.GreaterThanOrEqual:
+                case ExpressionType.Equal:
+                case ExpressionType.NotEqual:
+                case ExpressionType.Coalesce:
+                case ExpressionType.ArrayIndex:
+                case ExpressionType.RightShift:
+                case ExpressionType.LeftShift:
+                case ExpressionType.ExclusiveOr:
+                    return "(" + VisitBinary(exp as BinaryExpression) + ")";
+                case ExpressionType.Negate:
+                case ExpressionType.NegateChecked:
+                case ExpressionType.Not:
+                case ExpressionType.Convert:
+                case ExpressionType.ConvertChecked:
+                case ExpressionType.ArrayLength:
+                case ExpressionType.Quote:
+                case ExpressionType.TypeAs:
+                    return VisitUnary(exp as UnaryExpression);
+                case ExpressionType.Parameter:
+                    return VisitParameter(exp as ParameterExpression);
+                case ExpressionType.Call:
+                    return VisitMethodCall(exp as MethodCallExpression);
+                case ExpressionType.New:
+                    return VisitNew(exp as NewExpression);
+                case ExpressionType.NewArrayInit:
+                case ExpressionType.NewArrayBounds:
+                    return VisitNewArray(exp as NewArrayExpression);
+                default:
+                    return exp.ToString();
+            }
+        }
+
+        protected virtual string VisitLambda(LambdaExpression lambda)
+        {
+            if (lambda.Body.NodeType == ExpressionType.MemberAccess && sep == " ")
+            {
+                MemberExpression m = lambda.Body as MemberExpression;
+
+                if (m.Expression != null)
+                {
+                    string r = VisitMemberAccess(m);
+                    return string.Format("{0}={1}", r, GetQuotedTrueValue());
+                }
+
+            }
+            return Visit(lambda.Body);
+        }
+
+        protected virtual string VisitBinary(BinaryExpression b)
+        {
+            string left, right;
+            var operand = BindOperant(b.NodeType);   //sep= " " ??
+            if (operand == "AND" || operand == "OR")
+            {
+                MemberExpression m = b.Left as MemberExpression;
+                if (m != null && m.Expression != null)
+                {
+                    string r = VisitMemberAccess(m);
+                    left = string.Format("{0}={1}", r, GetQuotedTrueValue());
+                }
+                else
+                {
+                    left = Visit(b.Left);
+                }
+                m = b.Right as MemberExpression;
+                if (m != null && m.Expression != null)
+                {
+                    string r = VisitMemberAccess(m);
+                    right = string.Format("{0}={1}", r, GetQuotedTrueValue());
+                }
+                else
+                {
+                    right = Visit(b.Right);
+                }
+            }
+            else
+            {
+                left = Visit(b.Left);
+                right = Visit(b.Right);
+            }
+
+            if (operand == "=" && right == "null") operand = "is";
+            else if (operand == "<>" && right == "null") operand = "is not";
+            else if (operand == "=" || operand == "<>")
+            {
+                if (IsTrueExpression(right)) right = GetQuotedTrueValue();
+                else if (IsFalseExpression(right)) right = GetQuotedFalseValue();
+
+                if (IsTrueExpression(left)) left = GetQuotedTrueValue();
+                else if (IsFalseExpression(left)) left = GetQuotedFalseValue();
+
+            }
+
+            switch (operand)
+            {
+                case "MOD":
+                case "COALESCE":
+                    return string.Format("{0}({1},{2})", operand, left, right);
+                default:
+                    return left + sep + operand + sep + right;
+            }
+        }
+
+        protected virtual string VisitMemberAccess(MemberExpression m)
+        {
+            if (m.Expression != null &&
+               m.Expression.NodeType == ExpressionType.Parameter
+               && m.Expression.Type == typeof(T))
+            {
+                string field = GetFieldName(pd, m.Member.Name);
+                return field;
+            }
+
+            if (m.Expression != null && m.Expression.NodeType != ExpressionType.Constant)
+            {
+                Database.Mapper = new ModelDtoMapper();
+                var def = new Database.PocoData(m.Expression.Type);
+                string field = GetFieldName(def, m.Member.Name);
+                return field;
+            }
+
+
+            var member = Expression.Convert(m, typeof(object));
+            var lambda = Expression.Lambda<Func<object>>(member);
+            var getter = lambda.Compile();
+            object o = getter();
+            return GetQuotedValue(o, o != null ? o.GetType() : null);
+
+        }
+
+        protected virtual string VisitNew(NewExpression nex)
+        {
+            // TODO : check !
+            var member = Expression.Convert(nex, typeof(object));
+            var lambda = Expression.Lambda<Func<object>>(member);
+            try
+            {
+                var getter = lambda.Compile();
+                object o = getter();
+                return GetQuotedValue(o, o.GetType());
+            }
+            catch (System.InvalidOperationException)
+            { // FieldName ?
+                List<Object> exprs = VisitExpressionList(nex.Arguments);
+                var r = new StringBuilder();
+                foreach (Object e in exprs)
+                {
+                    r.AppendFormat("{0}{1}",
+                                   r.Length > 0 ? "," : "",
+                                   e);
+                }
+                return r.ToString();
+            }
+
+        }
+
+        protected virtual string VisitParameter(ParameterExpression p)
+        {
+            return p.Name;
+        }
+
+        protected virtual string VisitConstant(ConstantExpression c)
+        {
+            if (c.Value == null)
+                return "null";
+            else if (c.Value.GetType() == typeof(bool))
+            {
+                object o = GetQuotedValue(c.Value, c.Value.GetType());
+                return string.Format("({0}={1})", GetQuotedTrueValue(), o);
+            }
+            else
+                return GetQuotedValue(c.Value, c.Value.GetType());
+        }
+
+        protected virtual string VisitUnary(UnaryExpression u)
+        {
+            switch (u.NodeType)
+            {
+                case ExpressionType.Not:
+                    string o = Visit(u.Operand);
+                    if (IsFieldName(o)) o = o + "=" + GetQuotedValue(true, typeof(bool));
+                    return "NOT (" + o + ")";
+                default:
+                    return Visit(u.Operand);
+            }
+
+        }
+
+        protected virtual string VisitMethodCall(MethodCallExpression m)
+        {
+            List<Object> args = this.VisitExpressionList(m.Arguments);
+
+            Object r;
+            if (m.Object != null)
+                r = Visit(m.Object);
+            else
+            {
+                r = args[0];
+                args.RemoveAt(0);
+            }
+
+            switch (m.Method.Name)
+            {
+                case "ToUpper":
+                    return string.Format("upper({0})", r);
+                case "ToLower":
+                    return string.Format("lower({0})", r);
+                case "StartsWith":
+                    return string.Format("upper({0}) starting with {1} ", r, args[0].ToString().ToUpper());
+                case "EndsWith":
+                    return string.Format("upper({0}) like '%{1}'", r, RemoveQuote(args[0].ToString()).ToUpper());
+                case "Contains":
+                    return string.Format("upper({0}) like '%{1}%'", r, RemoveQuote(args[0].ToString()).ToUpper());
+                case "Substring":
+                    var startIndex = Int32.Parse(args[0].ToString()) + 1;
+                    if (args.Count == 2)
+                    {
+                        var length = Int32.Parse(args[1].ToString());
+                        return string.Format("substring({0} from {1} for {2})",
+                                         r,
+                                         startIndex,
+                                         length);
+                    }
+                    else
+                        return string.Format("substring({0} from {1})",
+                                         r,
+                                         startIndex);
+                case "Round":
+                case "Floor":
+                case "Ceiling":
+                case "Coalesce":
+                case "Abs":
+                case "Sum":
+                    return string.Format("{0}({1}{2})",
+                                         m.Method.Name,
+                                         r,
+                                         args.Count == 1 ? string.Format(",{0}", args[0]) : "");
+                case "Concat":
+                    var s = new StringBuilder();
+                    foreach (Object e in args)
+                    {
+                        s.AppendFormat(" || {0}", e);
+                    }
+                    return string.Format("{0}{1}", r, s.ToString());
+
+                case "In":
+
+                    var member = Expression.Convert(m.Arguments[1], typeof(object));
+                    var lambda = Expression.Lambda<Func<object>>(member);
+                    var getter = lambda.Compile();
+
+                    var inArgs = getter() as object[];
+
+                    var sIn = new StringBuilder();
+                    foreach (Object e in inArgs)
+                    {
+                        if (e.GetType().ToString() != "System.Collections.Generic.List`1[System.Object]")
+                        {
+                            sIn.AppendFormat("{0}{1}",
+                                         sIn.Length > 0 ? "," : "",
+                                                        GetQuotedValue(e, e.GetType()));
+                        }
+                        else
+                        {
+                            var listArgs = e as IList<Object>;
+                            foreach (Object el in listArgs)
+                            {
+                                sIn.AppendFormat("{0}{1}",
+                                         sIn.Length > 0 ? "," : "",
+                                                        GetQuotedValue(el, el.GetType()));
+                            }
+                        }
+                    }
+
+                    return string.Format("{0} {1} ({2})", r, m.Method.Name, sIn.ToString());
+                case "Desc":
+                    return string.Format("{0} DESC", r);
+                case "Alias":
+                case "As":
+                    return string.Format("{0} As {1}", r,
+                                                GetQuotedColumnName(RemoveQuoteFromAlias(RemoveQuote(args[0].ToString()))));
+                case "ToString":
+                    return r.ToString();
+                default:
+                    var s2 = new StringBuilder();
+                    foreach (Object e in args)
+                    {
+                        s2.AppendFormat(",{0}", GetQuotedValue(e, e.GetType()));
+                    }
+                    return string.Format("{0}({1}{2})", m.Method.Name, r, s2.ToString());
+            }
+        }
+
+        protected virtual List<Object> VisitExpressionList(ReadOnlyCollection<Expression> original)
+        {
+            var list = new List<Object>();
+            for (int i = 0, n = original.Count; i < n; i++)
+            {
+                if (original[i].NodeType == ExpressionType.NewArrayInit ||
+                 original[i].NodeType == ExpressionType.NewArrayBounds)
+                {
+
+                    list.AddRange(VisitNewArrayFromExpressionList(original[i] as NewArrayExpression));
+                }
+                else
+                    list.Add(Visit(original[i]));
+
+            }
+            return list;
+        }
+
+        protected virtual string VisitNewArray(NewArrayExpression na)
+        {
+
+            List<Object> exprs = VisitExpressionList(na.Expressions);
+            var r = new StringBuilder();
+            foreach (Object e in exprs)
+            {
+                r.Append(r.Length > 0 ? "," + e : e);
+            }
+
+            return r.ToString();
+        }
+
+        protected virtual List<Object> VisitNewArrayFromExpressionList(NewArrayExpression na)
+        {
+
+            List<Object> exprs = VisitExpressionList(na.Expressions);
+            return exprs;
+        }
+
+
+        protected virtual string BindOperant(ExpressionType e)
+        {
+
+            switch (e)
+            {
+                case ExpressionType.Equal:
+                    return "=";
+                case ExpressionType.NotEqual:
+                    return "<>";
+                case ExpressionType.GreaterThan:
+                    return ">";
+                case ExpressionType.GreaterThanOrEqual:
+                    return ">=";
+                case ExpressionType.LessThan:
+                    return "<";
+                case ExpressionType.LessThanOrEqual:
+                    return "<=";
+                case ExpressionType.AndAlso:
+                    return "AND";
+                case ExpressionType.OrElse:
+                    return "OR";
+                case ExpressionType.Add:
+                    return "+";
+                case ExpressionType.Subtract:
+                    return "-";
+                case ExpressionType.Multiply:
+                    return "*";
+                case ExpressionType.Divide:
+                    return "/";
+                case ExpressionType.Modulo:
+                    return "MOD";
+                case ExpressionType.Coalesce:
+                    return "COALESCE";
+                default:
+                    return e.ToString();
+            }
+        }
+
+        public virtual string GetQuotedTableName(string tableName)
+        {
+            return string.Format("\"{0}\"", tableName);
+        }
+
+        public virtual string GetQuotedColumnName(string columnName)
+        {
+            return string.Format("\"{0}\"", columnName);
+        }
+
+        public virtual string GetQuotedName(string name)
+        {
+            return string.Format("\"{0}\"", name);
+        }
+
+        private string GetQuotedTrueValue()
+        {
+            return GetQuotedValue(true, typeof(bool));
+        }
+
+        private string GetQuotedFalseValue()
+        {
+            return GetQuotedValue(false, typeof(bool));
+        }
+
+        public virtual string GetQuotedValue(object value, Type fieldType)
+        {
+            if (value == null) return "NULL";
+
+            if (!fieldType.UnderlyingSystemType.IsValueType && fieldType != typeof(string))
+            {
+                //if (TypeSerializer.CanCreateFromString(fieldType))
+                //{
+                //    return "'" + EscapeParam(TypeSerializer.SerializeToString(value)) + "'";
+                //}
+
+                throw new NotSupportedException(
+                    string.Format("Property of type: {0} is not supported", fieldType.FullName));
+            }
+
+            if (fieldType == typeof(int))
+                return ((int)value).ToString(CultureInfo.InvariantCulture);
+
+            if (fieldType == typeof(float))
+                return ((float)value).ToString(CultureInfo.InvariantCulture);
+
+            if (fieldType == typeof(double))
+                return ((double)value).ToString(CultureInfo.InvariantCulture);
+
+            if (fieldType == typeof(decimal))
+                return ((decimal)value).ToString(CultureInfo.InvariantCulture);
+
+            return ShouldQuoteValue(fieldType)
+                    ? "'" + EscapeParam(value) + "'"
+                    : value.ToString();
+        }
+
+        public virtual string EscapeParam(object paramValue)
+        {
+            return paramValue.ToString().Replace("'", "''");
+        }
+
+        public virtual bool ShouldQuoteValue(Type fieldType)
+        {
+            return true;
+        }
+
+        protected virtual string GetFieldName(Database.PocoData pocoData, string name)
+        {
+            var column = pocoData.Columns.FirstOrDefault(x => x.Value.PropertyInfo.Name == name);
+            return column.Value.ColumnName;
+        }
+
+        protected virtual string GetFieldName(string name)
+        {
+
+            if (useFieldName)
+            {
+                //FieldDefinition fd = modelDef.FieldDefinitions.FirstOrDefault(x => x.Name == name);
+                //string fn = fd != default(FieldDefinition) ? fd.FieldName : name;
+                //return OrmLiteConfig.DialectProvider.GetQuotedColumnName(fn);
+                return "[" + name + "]";
+            }
+            else
+            {
+                return name;
+            }
+        }
+
+        protected string RemoveQuote(string exp)
+        {
+
+            if (exp.StartsWith("'") && exp.EndsWith("'"))
+            {
+                exp = exp.Remove(0, 1);
+                exp = exp.Remove(exp.Length - 1, 1);
+            }
+            return exp;
+        }
+
+        protected string RemoveQuoteFromAlias(string exp)
+        {
+
+            if ((exp.StartsWith("\"") || exp.StartsWith("`") || exp.StartsWith("'"))
+                &&
+                (exp.EndsWith("\"") || exp.EndsWith("`") || exp.EndsWith("'")))
+            {
+                exp = exp.Remove(0, 1);
+                exp = exp.Remove(exp.Length - 1, 1);
+            }
+            return exp;
+        }
+
+        private string GetTrueExpression()
+        {
+            object o = GetQuotedTrueValue();
+            return string.Format("({0}={1})", o, o);
+        }
+
+        private string GetFalseExpression()
+        {
+
+            return string.Format("({0}={1})",
+                GetQuotedTrueValue(),
+                GetQuotedFalseValue());
+        }
+
+        private bool IsTrueExpression(string exp)
+        {
+            return (exp == GetTrueExpression());
+        }
+
+        private bool IsFalseExpression(string exp)
+        {
+            return (exp == GetFalseExpression());
+        }
+
+        protected bool IsFieldName(string quotedExp)
+        {
+            return true;
+        }
+    }
+}

src/Umbraco.Core/Persistence/Querying/ModelToSqlExpressionHelper.cs

@@ -523,7 +523,8 @@ namespace Umbraco.Core.Persistence.Querying
 
         protected bool IsFieldName(string quotedExp)
         {
-            return true;
+            //Not entirely sure this is reliable, but its better then simply returning true
+            return quotedExp.LastIndexOf("'", StringComparison.InvariantCultureIgnoreCase) + 1 != quotedExp.Length;
         }
     }
 }

src/Umbraco.Core/Persistence/Querying/PocoToSqlExpressionHelper.cs

@@ -468,6 +468,9 @@ namespace Umbraco.Core.Persistence.Querying
             if(fieldType == typeof(DateTime))
                 return "'" + EscapeParam(((DateTime)value).ToString(CultureInfo.InvariantCulture)) + "'";
 
+            if (fieldType == typeof(bool))
+                return ((bool)value) ? Convert.ToString(1, CultureInfo.InvariantCulture) : Convert.ToString(0, CultureInfo.InvariantCulture);
+
             return ShouldQuoteValue(fieldType)
                     ? "'" + EscapeParam(value) + "'"
                     : value.ToString();
@@ -487,8 +490,8 @@ namespace Umbraco.Core.Persistence.Querying
         {
             var column = pocoData.Columns.FirstOrDefault(x => x.Value.PropertyInfo.Name == name);
             return string.Format("{0}.{1}",
-                SyntaxConfig.SqlSyntaxProvider.GetQuotedTableName(pocoData.TableInfo.TableName),
-                SyntaxConfig.SqlSyntaxProvider.GetQuotedColumnName(column.Value.ColumnName));
+                SqlSyntaxContext.SqlSyntaxProvider.GetQuotedTableName(pocoData.TableInfo.TableName),
+                SqlSyntaxContext.SqlSyntaxProvider.GetQuotedColumnName(column.Value.ColumnName));
         }
 
         protected string RemoveQuote(string exp)

src/Umbraco.Core/Persistence/Repositories/ContentRepository.cs

@@ -78,7 +78,10 @@ namespace Umbraco.Core.Persistence.Repositories
         {
             var sqlClause = GetBaseQuery(false);
             var translator = new SqlTranslator<IContent>(sqlClause, query);
-            var sql = translator.Translate();
+            var sql = translator.Translate()
+                                .Where<DocumentDto>(x => x.Newest)
+                                .OrderByDescending<ContentVersionDto>(x => x.VersionDate)
+                                .OrderBy<NodeDto>(x => x.SortOrder);
 
             //NOTE: This doesn't allow properties to be part of the query
             var dtos = Database.Fetch<DocumentDto, ContentVersionDto, ContentDto, NodeDto>(sql);
@@ -263,8 +266,11 @@ namespace Umbraco.Core.Persistence.Repositories
                 var parent = Database.First<NodeDto>("WHERE id = @ParentId", new { ParentId = entity.ParentId });
                 entity.Path = string.Concat(parent.Path, ",", entity.Id);
                 entity.Level = parent.Level + 1;
-                var maxSortOrder = Database.ExecuteScalar<int>("SELECT coalesce(max(sortOrder),0) FROM umbracoNode WHERE parentid = @ParentId", new { ParentId = entity.ParentId });
-                entity.SortOrder = maxSortOrder;
+                var maxSortOrder =
+                    Database.ExecuteScalar<int>(
+                        "SELECT coalesce(max(sortOrder),0) FROM umbracoNode WHERE parentid = @ParentId AND nodeObjectType = @NodeObjectType",
+                        new {ParentId = entity.ParentId, NodeObjectType = NodeObjectTypeId});
+                entity.SortOrder = maxSortOrder + 1;
             }
 
             var factory = new ContentFactory(NodeObjectTypeId, entity.Id);
@@ -368,7 +374,7 @@ namespace Umbraco.Core.Persistence.Repositories
             //Loop through properties to check if the content contains images/files that should be deleted
             foreach (var property in entity.Properties)
             {
-                if (property.PropertyType.DataTypeId == uploadFieldId &&
+                if (property.PropertyType.DataTypeId == uploadFieldId && property.Value != null &&
                     string.IsNullOrEmpty(property.Value.ToString()) == false
                     && fs.FileExists(IOHelper.MapPath(property.Value.ToString())))
                 {
@@ -450,6 +456,17 @@ namespace Umbraco.Core.Persistence.Repositories
             var propertyDataDtos = Database.Fetch<PropertyDataDto, PropertyTypeDto>(sql);
             var propertyFactory = new PropertyFactory(contentType, versionId, id);
             var properties = propertyFactory.BuildEntity(propertyDataDtos);
+
+            var newProperties = properties.Where(x => x.HasIdentity == false);
+            foreach (var property in newProperties)
+            {
+                var propertyDataDto = new PropertyDataDto{ NodeId = id, PropertyTypeId = property.PropertyTypeId, VersionId = versionId };
+                int primaryKey = Convert.ToInt32(Database.Insert(propertyDataDto));
+
+                property.Version = versionId;
+                property.Id = primaryKey;
+            }
+
             return new PropertyCollection(properties);
         }
     }

src/Umbraco.Core/Persistence/Repositories/ContentTypeBaseRepository.cs

@@ -2,6 +2,7 @@
 using System.Collections.Generic;
 using System.Globalization;
 using System.Linq;
+using System.Threading.Tasks;
 using Umbraco.Core.Models;
 using Umbraco.Core.Models.EntityBase;
 using Umbraco.Core.Models.Rdbms;
@@ -40,11 +41,11 @@ namespace Umbraco.Core.Persistence.Repositories
                .RightJoin<PropertyTypeDto>()
                .On<PropertyTypeGroupDto, PropertyTypeDto>(left => left.Id, right => right.PropertyTypeGroupId)
                .InnerJoin<DataTypeDto>()
-               .On<PropertyTypeDto, DataTypeDto>(left => left.DataTypeId, right => right.DataTypeId)
-               .OrderBy<PropertyTypeDto>(x => x.PropertyTypeGroupId);
+               .On<PropertyTypeDto, DataTypeDto>(left => left.DataTypeId, right => right.DataTypeId);
 
             var translator = new SqlTranslator<PropertyType>(sqlClause, query);
-            var sql = translator.Translate();
+            var sql = translator.Translate()
+                                .OrderBy<PropertyTypeDto>(x => x.PropertyTypeGroupId);
 
             var dtos = Database.Fetch<PropertyTypeGroupDto, PropertyTypeDto, DataTypeDto, PropertyTypeGroupDto>(new GroupPropertyTypeRelator().Map, sql);
 
@@ -107,7 +108,12 @@ namespace Umbraco.Core.Persistence.Repositories
             //Insert collection of allowed content types
             foreach (var allowedContentType in entity.AllowedContentTypes)
             {
-                Database.Insert(new ContentTypeAllowedContentTypeDto { Id = entity.Id, AllowedId = allowedContentType.Id.Value, SortOrder = allowedContentType.SortOrder });
+                Database.Insert(new ContentTypeAllowedContentTypeDto
+                                    {
+                                        Id = entity.Id,
+                                        AllowedId = allowedContentType.Id.Value,
+                                        SortOrder = allowedContentType.SortOrder
+                                    });
             }
 
             var propertyFactory = new PropertyGroupFactory(nodeDto.NodeId);
@@ -118,103 +124,181 @@ namespace Umbraco.Core.Persistence.Repositories
                 var tabDto = propertyFactory.BuildGroupDto(propertyGroup);
                 var primaryKey = Convert.ToInt32(Database.Insert(tabDto));
                 propertyGroup.Id = primaryKey;//Set Id on PropertyGroup
+
+                //Ensure that the PropertyGroup's Id is set on the PropertyTypes within a group
+                //unless the PropertyGroupId has already been changed.
+                foreach (var propertyType in propertyGroup.PropertyTypes)
+                {
+                    if (propertyType.IsPropertyDirty("PropertyGroupId") == false)
+                    {
+                        var tempGroup = propertyGroup;
+                        propertyType.PropertyGroupId = new Lazy<int>(() => tempGroup.Id);
+                    }
+                }
             }
 
             //Insert PropertyTypes
-            foreach (var propertyGroup in entity.PropertyGroups)
+            foreach (var propertyType in entity.PropertyTypes)
             {
-                foreach (var propertyType in propertyGroup.PropertyTypes)
-                {
-                    var propertyTypeDto = propertyFactory.BuildPropertyTypeDto(propertyGroup.Id, propertyType);
-                    var primaryKey = Convert.ToInt32(Database.Insert(propertyTypeDto));
-                    propertyType.Id = primaryKey;//Set Id on PropertyType
+                var tabId = propertyType.PropertyGroupId != null ? propertyType.PropertyGroupId.Value : default(int);
+                var propertyTypeDto = propertyFactory.BuildPropertyTypeDto(tabId, propertyType);
+                int typePrimaryKey = Convert.ToInt32(Database.Insert(propertyTypeDto));
+                propertyType.Id = typePrimaryKey; //Set Id on new PropertyType
 
-                    //Update the current PropertyType with correct ControlId and DatabaseType
-                    var dataTypeDto = Database.FirstOrDefault<DataTypeDto>("WHERE nodeId = @Id", new { Id = propertyTypeDto.DataTypeId });
-                    propertyType.DataTypeId = dataTypeDto.ControlId;
-                    propertyType.DataTypeDatabaseType = dataTypeDto.DbType.EnumParse<DataTypeDatabaseType>(true);
-                }
+                //Update the current PropertyType with correct ControlId and DatabaseType
+                var dataTypeDto = Database.FirstOrDefault<DataTypeDto>("WHERE nodeId = @Id", new { Id = propertyTypeDto.DataTypeId });
+                propertyType.DataTypeId = dataTypeDto.ControlId;
+                propertyType.DataTypeDatabaseType = dataTypeDto.DbType.EnumParse<DataTypeDatabaseType>(true);
             }
         }
 
         protected void PersistUpdatedBaseContentType(ContentTypeDto dto, IContentTypeComposition entity)
         {
-            var propertyFactory = new PropertyGroupFactory(entity.Id);
+            var propertyGroupFactory = new PropertyGroupFactory(entity.Id);
 
             var nodeDto = dto.NodeDto;
             var o = Database.Update(nodeDto);
 
             //Look up ContentType entry to get PrimaryKey for updating the DTO
-            var dtoPk = Database.First<ContentTypeDto>("WHERE nodeId = @Id", new { Id = entity.Id });
+            var dtoPk = Database.First<ContentTypeDto>("WHERE nodeId = @Id", new {Id = entity.Id});
             dto.PrimaryKey = dtoPk.PrimaryKey;
             Database.Update(dto);
 
             //Delete the ContentType composition entries before adding the updated collection
-            Database.Delete<ContentType2ContentTypeDto>("WHERE childContentTypeId = @Id", new { Id = entity.Id });
+            Database.Delete<ContentType2ContentTypeDto>("WHERE childContentTypeId = @Id", new {Id = entity.Id});
             //Update ContentType composition in new table
             foreach (var composition in entity.ContentTypeComposition)
             {
-                Database.Insert(new ContentType2ContentTypeDto { ParentId = composition.Id, ChildId = entity.Id });
+                Database.Insert(new ContentType2ContentTypeDto {ParentId = composition.Id, ChildId = entity.Id});
+            }
+
+            //Removing a ContentType from a composition (U4-1690)
+            //1. Find content based on the current ContentType: entity.Id
+            //2. Find all PropertyTypes on the ContentType that was removed - tracked id (key)
+            //3. Remove properties based on property types from the removed content type where the content ids correspond to those found in step one
+            var compositionBase = entity as ContentTypeCompositionBase;
+            if (compositionBase != null && compositionBase.RemovedContentTypeKeyTracker != null &&
+                compositionBase.RemovedContentTypeKeyTracker.Any())
+            {
+                //Find Content based on the current ContentType
+                var sql = new Sql();
+                sql.Select("*")
+                   .From<ContentDto>()
+                   .InnerJoin<NodeDto>()
+                   .On<ContentDto, NodeDto>(left => left.NodeId, right => right.NodeId)
+                   .Where<NodeDto>(x => x.NodeObjectType == new Guid("C66BA18E-EAF3-4CFF-8A22-41B16D66A972"))
+                   .Where<ContentDto>(x => x.ContentTypeId == entity.Id);
+
+                var contentDtos = Database.Fetch<DocumentDto, ContentVersionDto, ContentDto, NodeDto>(sql);
+                //Loop through all tracked keys, which corresponds to the ContentTypes that has been removed from the composition
+                foreach (var key in compositionBase.RemovedContentTypeKeyTracker)
+                {
+                    //Find PropertyTypes for the removed ContentType
+                    var propertyTypes = Database.Fetch<PropertyTypeDto>("WHERE contentTypeId = @Id", new {Id = key});
+                    //Loop through the Content that is based on the current ContentType in order to remove the Properties that are 
+                    //based on the PropertyTypes that belong to the removed ContentType.
+                    foreach (var contentDto in contentDtos)
+                    {
+                        foreach (var propertyType in propertyTypes)
+                        {
+                            var nodeId = contentDto.NodeId;
+                            var propertyTypeId = propertyType.Id;
+                            var propertySql = new Sql().Select("*")
+                                                       .From<PropertyDataDto>()
+                                                       .InnerJoin<PropertyTypeDto>()
+                                                       .On<PropertyDataDto, PropertyTypeDto>(
+                                                           left => left.PropertyTypeId, right => right.Id)
+                                                       .Where<PropertyDataDto>(x => x.NodeId == nodeId)
+                                                       .Where<PropertyTypeDto>(x => x.Id == propertyTypeId);
+
+                            //Finally delete the properties that match our criteria for removing a ContentType from the composition
+                            Database.Delete<PropertyDataDto>(propertySql);
+                        }
+                    }
+                }
             }
 
             //Delete the allowed content type entries before adding the updated collection
-            Database.Delete<ContentTypeAllowedContentTypeDto>("WHERE Id = @Id", new { Id = entity.Id });
+            Database.Delete<ContentTypeAllowedContentTypeDto>("WHERE Id = @Id", new {Id = entity.Id});
             //Insert collection of allowed content types
             foreach (var allowedContentType in entity.AllowedContentTypes)
             {
-                Database.Insert(new ContentTypeAllowedContentTypeDto { Id = entity.Id, AllowedId = allowedContentType.Id.Value, SortOrder = allowedContentType.SortOrder });
+                Database.Insert(new ContentTypeAllowedContentTypeDto
+                                    {
+                                        Id = entity.Id,
+                                        AllowedId = allowedContentType.Id.Value,
+                                        SortOrder = allowedContentType.SortOrder
+                                    });
             }
 
-            //Check Dirty properties for Tabs/Groups and PropertyTypes - insert and delete accordingly
-            if (((ICanBeDirty)entity).IsPropertyDirty("PropertyGroups") || entity.PropertyGroups.Any(x => x.IsDirty()))
+            if (((ICanBeDirty) entity).IsPropertyDirty("PropertyTypes") || entity.PropertyTypes.Any(x => x.IsDirty()))
             {
                 //Delete PropertyTypes by excepting entries from db with entries from collections
-                var dbPropertyTypes = Database.Fetch<PropertyTypeDto>("WHERE contentTypeId = @Id", new { Id = entity.Id });
-                var dbPropertyTypeAlias = dbPropertyTypes.Select(x => x.Alias.ToLowerInvariant());
-                var entityPropertyTypes = entity.PropertyTypes.Select(x => x.Alias.ToLowerInvariant());
-                var aliases = dbPropertyTypeAlias.Except(entityPropertyTypes);
-                foreach (var alias in aliases)
+                var dbPropertyTypes = Database.Fetch<PropertyTypeDto>("WHERE contentTypeId = @Id", new {Id = entity.Id});
+                var dbPropertyTypeAlias = dbPropertyTypes.Select(x => x.Id);
+                var entityPropertyTypes = entity.PropertyTypes.Where(x => x.HasIdentity).Select(x => x.Id);
+                var items = dbPropertyTypeAlias.Except(entityPropertyTypes);
+                foreach (var item in items)
                 {
                     //Before a PropertyType can be deleted, all Properties based on that PropertyType should be deleted.
-                    var propertyType = dbPropertyTypes.FirstOrDefault(x => x.Alias.ToLowerInvariant() == alias);
-                    if (propertyType != null)
-                    {
-                        Database.Delete<PropertyDataDto>("WHERE propertytypeid = @Id", new { Id = propertyType.Id });
-                    }
-
-                    Database.Delete<PropertyTypeDto>("WHERE contentTypeId = @Id AND Alias = @Alias", new { Id = entity.Id, Alias = alias });
+                    Database.Delete<PropertyDataDto>("WHERE propertytypeid = @Id", new {Id = item});
+                    Database.Delete<PropertyTypeDto>("WHERE contentTypeId = @Id AND id = @PropertyTypeId",
+                                                     new {Id = entity.Id, PropertyTypeId = item});
                 }
+            }
+
+            if (((ICanBeDirty) entity).IsPropertyDirty("PropertyGroups") || entity.PropertyGroups.Any(x => x.IsDirty()))
+            {
                 //Delete Tabs/Groups by excepting entries from db with entries from collections
-                var dbPropertyGroups = Database.Fetch<PropertyTypeGroupDto>("WHERE contenttypeNodeId = @Id", new { Id = entity.Id }).Select(x => x.Text);
-                var entityPropertyGroups = entity.PropertyGroups.Select(x => x.Name);
+                var dbPropertyGroups =
+                    Database.Fetch<PropertyTypeGroupDto>("WHERE contenttypeNodeId = @Id", new {Id = entity.Id})
+                            .Select(x => new Tuple<int, string>(x.Id, x.Text));
+                var entityPropertyGroups = entity.PropertyGroups.Select(x => new Tuple<int, string>(x.Id, x.Name));
                 var tabs = dbPropertyGroups.Except(entityPropertyGroups);
-                foreach (var tabName in tabs)
+                foreach (var tab in tabs)
                 {
-                    Database.Delete<PropertyTypeGroupDto>("WHERE contenttypeNodeId = @Id AND text = @Name", new { Id = entity.Id, Name = tabName });
+                    Database.Update<PropertyTypeDto>("SET propertyTypeGroupId = NULL WHERE propertyTypeGroupId = @PropertyGroupId",
+                                                    new {PropertyGroupId = tab.Item1});
+                    Database.Update<PropertyTypeGroupDto>("SET parentGroupId = NULL WHERE parentGroupId = @TabId",
+                                                          new {TabId = tab.Item1});
+                    Database.Delete<PropertyTypeGroupDto>("WHERE contenttypeNodeId = @Id AND text = @Name",
+                                                          new {Id = entity.Id, Name = tab.Item2});
                 }
+            }
 
-                //Run through all groups to insert or update entries
-                foreach (var propertyGroup in entity.PropertyGroups)
-                {
-                    var tabDto = propertyFactory.BuildGroupDto(propertyGroup);
-                    int groupPrimaryKey = propertyGroup.HasIdentity
-                                              ? Database.Update(tabDto)
-                                              : Convert.ToInt32(Database.Insert(tabDto));
-                    if (!propertyGroup.HasIdentity)
-                        propertyGroup.Id = groupPrimaryKey;//Set Id on new PropertyGroup
-                }
+            //Run through all groups to insert or update entries
+            foreach (var propertyGroup in entity.PropertyGroups)
+            {
+                var tabDto = propertyGroupFactory.BuildGroupDto(propertyGroup);
+                int groupPrimaryKey = propertyGroup.HasIdentity
+                                          ? Database.Update(tabDto)
+                                          : Convert.ToInt32(Database.Insert(tabDto));
+                if (propertyGroup.HasIdentity == false)
+                    propertyGroup.Id = groupPrimaryKey; //Set Id on new PropertyGroup
 
-                //Run through all PropertyTypes to insert or update entries
-                foreach (var propertyType in entity.PropertyTypes)
+                //Ensure that the PropertyGroup's Id is set on the PropertyTypes within a group
+                //unless the PropertyGroupId has already been changed.
+                foreach (var propertyType in propertyGroup.PropertyTypes)
                 {
-                    var propertyTypeDto = propertyFactory.BuildPropertyTypeDto(propertyType.PropertyGroupId, propertyType);
-                    int typePrimaryKey = propertyType.HasIdentity
-                                             ? Database.Update(propertyTypeDto)
-                                             : Convert.ToInt32(Database.Insert(propertyTypeDto));
-                    if (!propertyType.HasIdentity)
-                        propertyType.Id = typePrimaryKey;//Set Id on new PropertyType
+                    if (propertyType.IsPropertyDirty("PropertyGroupId") == false)
+                    {
+                        var tempGroup = propertyGroup;
+                        propertyType.PropertyGroupId = new Lazy<int>(() => tempGroup.Id);
+                    }
                 }
             }
+
+            //Run through all PropertyTypes to insert or update entries
+            foreach (var propertyType in entity.PropertyTypes)
+            {
+                var tabId = propertyType.PropertyGroupId != null ? propertyType.PropertyGroupId.Value : default(int);
+                var propertyTypeDto = propertyGroupFactory.BuildPropertyTypeDto(tabId, propertyType);
+                int typePrimaryKey = propertyType.HasIdentity
+                                         ? Database.Update(propertyTypeDto)
+                                         : Convert.ToInt32(Database.Insert(propertyTypeDto));
+                if (propertyType.HasIdentity == false)
+                    propertyType.Id = typePrimaryKey; //Set Id on new PropertyType
+            }
         }
 
         protected IEnumerable<ContentTypeSort> GetAllowedContentTypeIds(int id)
@@ -242,8 +326,8 @@ namespace Umbraco.Core.Persistence.Repositories
 
             var dtos = Database.Fetch<PropertyTypeGroupDto, PropertyTypeDto, DataTypeDto, PropertyTypeGroupDto>(new GroupPropertyTypeRelator().Map, sql);
 
-            var propertyFactory = new PropertyGroupFactory(id);
-            var propertyGroups = propertyFactory.BuildEntity(dtos);
+            var propertyGroupFactory = new PropertyGroupFactory(id);
+            var propertyGroups = propertyGroupFactory.BuildEntity(dtos);
             return new PropertyGroupCollection(propertyGroups);
         }
 
@@ -272,9 +356,13 @@ namespace Umbraco.Core.Persistence.Repositories
                                     Name = dto.Name,
                                     HelpText = dto.HelpText,
                                     Mandatory = dto.Mandatory,
-                                    SortOrder = dto.SortOrder
-                                });
-            
+                                    SortOrder = dto.SortOrder,
+                                    ValidationRegExp = dto.ValidationRegExp
+                                }).ToList();
+
+            //Reset dirty properties
+            Parallel.ForEach(list, currentFile => currentFile.ResetDirtyProperties());
+
             return new PropertyTypeCollection(list);
         }
     }

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

@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using Umbraco.Core.Logging;
 using Umbraco.Core.Models;
 using Umbraco.Core.Models.EntityBase;
 using Umbraco.Core.Models.Rdbms;
@@ -93,7 +94,8 @@ namespace Umbraco.Core.Persistence.Repositories
         {
             var sqlClause = GetBaseQuery(false);
             var translator = new SqlTranslator<IContentType>(sqlClause, query);
-            var sql = translator.Translate();
+            var sql = translator.Translate()
+                .OrderBy<NodeDto>(x => x.Text);
 
             var dtos = Database.Fetch<DocumentTypeDto, ContentTypeDto, NodeDto>(sql);
 
@@ -166,6 +168,19 @@ namespace Umbraco.Core.Persistence.Repositories
 
         protected override void PersistNewItem(IContentType entity)
         {
+            Mandate.That<Exception>(string.IsNullOrEmpty(entity.Alias) == false,
+                                    () =>
+                                        {
+                                            var message =
+                                                string.Format(
+                                                    "ContentType '{0}' cannot have an empty Alias. This is most likely due to invalid characters stripped from the Alias.",
+                                                    entity.Name);
+                                            var exception = new Exception(message);
+
+                                            LogHelper.Error<ContentTypeRepository>(message, exception);
+                                            throw exception;
+                                        });
+
             ((ContentType)entity).AddingEntity();
 
             var factory = new ContentTypeFactory(NodeObjectTypeId);
@@ -191,6 +206,19 @@ namespace Umbraco.Core.Persistence.Repositories
 
         protected override void PersistUpdatedItem(IContentType entity)
         {
+            Mandate.That<Exception>(string.IsNullOrEmpty(entity.Alias) == false,
+                                    () =>
+                                        {
+                                            var message =
+                                                string.Format(
+                                                    "ContentType '{0}' cannot have an empty Alias. This is most likely due to invalid characters stripped from the Alias.",
+                                                    entity.Name);
+                                            var exception = new Exception(message);
+
+                                            LogHelper.Error<ContentTypeRepository>(message, exception);
+                                            throw exception;
+                                        });
+
             //Updates Modified date
             ((ContentType)entity).UpdatingEntity();
 
@@ -199,6 +227,12 @@ namespace Umbraco.Core.Persistence.Repositories
             {
                 var parent = Database.First<NodeDto>("WHERE id = @ParentId", new { ParentId = entity.ParentId });
                 entity.Path = string.Concat(parent.Path, ",", entity.Id);
+                entity.Level = parent.Level + 1;
+                var maxSortOrder =
+                    Database.ExecuteScalar<int>(
+                        "SELECT coalesce(max(sortOrder),0) FROM umbracoNode WHERE parentid = @ParentId AND nodeObjectType = @NodeObjectType",
+                        new { ParentId = entity.ParentId, NodeObjectType = NodeObjectTypeId });
+                entity.SortOrder = maxSortOrder + 1;
             }
 
             var factory = new ContentTypeFactory(NodeObjectTypeId);

src/Umbraco.Core/Persistence/Repositories/DataTypeDefinitionRepository.cs

@@ -159,6 +159,12 @@ namespace Umbraco.Core.Persistence.Repositories
             {
                 var parent = Database.First<NodeDto>("WHERE id = @ParentId", new { ParentId = entity.ParentId });
                 entity.Path = string.Concat(parent.Path, ",", entity.Id);
+                entity.Level = parent.Level + 1;
+                var maxSortOrder =
+                    Database.ExecuteScalar<int>(
+                        "SELECT coalesce(max(sortOrder),0) FROM umbracoNode WHERE parentid = @ParentId AND nodeObjectType = @NodeObjectType",
+                        new { ParentId = entity.ParentId, NodeObjectType = NodeObjectTypeId });
+                entity.SortOrder = maxSortOrder + 1;
             }
 
             var factory = new DataTypeDefinitionFactory(NodeObjectTypeId);

src/Umbraco.Core/Persistence/Repositories/MediaRepository.cs

@@ -246,8 +246,11 @@ namespace Umbraco.Core.Persistence.Repositories
                 var parent = Database.First<NodeDto>("WHERE id = @ParentId", new { ParentId = entity.ParentId });
                 entity.Path = string.Concat(parent.Path, ",", entity.Id);
                 entity.Level = parent.Level + 1;
-                var maxSortOrder = Database.ExecuteScalar<int>("SELECT coalesce(max(sortOrder),0) FROM umbracoNode WHERE parentid = @ParentId", new { ParentId = entity.ParentId });
-                entity.SortOrder = maxSortOrder;
+                var maxSortOrder =
+                    Database.ExecuteScalar<int>(
+                        "SELECT coalesce(max(sortOrder),0) FROM umbracoNode WHERE parentid = @ParentId AND nodeObjectType = @NodeObjectType",
+                        new { ParentId = entity.ParentId, NodeObjectType = NodeObjectTypeId });
+                entity.SortOrder = maxSortOrder + 1;
             }
 
             var factory = new MediaFactory(NodeObjectTypeId, entity.Id);
@@ -347,7 +350,18 @@ namespace Umbraco.Core.Persistence.Repositories
 
             var propertyDataDtos = Database.Fetch<PropertyDataDto, PropertyTypeDto>(sql);
             var propertyFactory = new PropertyFactory(contentType, versionId, id);
-            var properties = propertyFactory.BuildMediaEntity(propertyDataDtos);
+            var properties = propertyFactory.BuildEntity(propertyDataDtos);
+
+            var newProperties = properties.Where(x => x.HasIdentity == false);
+            foreach (var property in newProperties)
+            {
+                var propertyDataDto = new PropertyDataDto { NodeId = id, PropertyTypeId = property.PropertyTypeId, VersionId = versionId };
+                int primaryKey = Convert.ToInt32(Database.Insert(propertyDataDto));
+
+                property.Version = versionId;
+                property.Id = primaryKey;
+            }
+
             return new PropertyCollection(properties);
         }
     }

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

@@ -168,6 +168,12 @@ namespace Umbraco.Core.Persistence.Repositories
             {
                 var parent = Database.First<NodeDto>("WHERE id = @ParentId", new { ParentId = entity.ParentId });
                 entity.Path = string.Concat(parent.Path, ",", entity.Id);
+                entity.Level = parent.Level + 1;
+                var maxSortOrder =
+                    Database.ExecuteScalar<int>(
+                        "SELECT coalesce(max(sortOrder),0) FROM umbracoNode WHERE parentid = @ParentId AND nodeObjectType = @NodeObjectType",
+                        new { ParentId = entity.ParentId, NodeObjectType = NodeObjectTypeId });
+                entity.SortOrder = maxSortOrder + 1;
             }
 
             var factory = new MediaTypeFactory(NodeObjectTypeId);

src/Umbraco.Core/Persistence/Repositories/TemplateRepository.cs

@@ -26,13 +26,13 @@ namespace Umbraco.Core.Persistence.Repositories
         public TemplateRepository(IDatabaseUnitOfWork work)
             : base(work)
         {
-            EnsureDepedencies();
+            EnsureDependencies();
         }
 
         public TemplateRepository(IDatabaseUnitOfWork work, IRepositoryCacheProvider cache)
             : base(work, cache)
         {
-            EnsureDepedencies();
+            EnsureDependencies();
         }
 
         internal TemplateRepository(IDatabaseUnitOfWork work, IRepositoryCacheProvider cache, IFileSystem masterpageFileSystem, IFileSystem viewFileSystem)
@@ -42,7 +42,7 @@ namespace Umbraco.Core.Persistence.Repositories
             _viewsFileSystem = viewFileSystem;
         }
 
-        private void EnsureDepedencies()
+        private void EnsureDependencies()
         {
             _masterpagesFileSystem = new PhysicalFileSystem(SystemDirectories.Masterpages);
             _viewsFileSystem = new PhysicalFileSystem(SystemDirectories.MvcViews);
@@ -71,7 +71,7 @@ namespace Umbraco.Core.Persistence.Repositories
             {
                 var masterTemplate = Get(dto.Master.Value);
                 template.MasterTemplateAlias = masterTemplate.Alias;
-                template.MasterTemplateId = dto.Master.Value;
+                template.MasterTemplateId = new Lazy<int>(() => dto.Master.Value);
             }
 
             if (_viewsFileSystem.FileExists(csViewName))
@@ -172,14 +172,18 @@ namespace Umbraco.Core.Persistence.Repositories
             {
                 if (entity.GetTypeOfRenderingEngine() == RenderingEngine.Mvc)
                 {
-                    _viewsFileSystem.AddFile(entity.Name, stream, true);
+                    string viewName = string.Concat(entity.Alias, ".cshtml");
+                    _viewsFileSystem.AddFile(viewName, stream, true);
                 }
                 else
                 {
-                    _masterpagesFileSystem.AddFile(entity.Name, stream, true);
+                    string masterpageName = string.Concat(entity.Alias, ".master");
+                    _masterpagesFileSystem.AddFile(masterpageName, stream, true);
                 }
             }
 
+            //TODO Possibly ensure unique alias here (as is done in the legacy Template class)?
+
             //Save to db
             var template = entity as Template;
             var factory = new TemplateFactory(NodeObjectTypeId);
@@ -223,11 +227,13 @@ namespace Umbraco.Core.Persistence.Repositories
             {
                 if (entity.GetTypeOfRenderingEngine() == RenderingEngine.Mvc)
                 {
-                    _viewsFileSystem.AddFile(entity.Name, stream, true);
+                    string viewName = string.Concat(entity.Alias, ".cshtml");
+                    _viewsFileSystem.AddFile(viewName, stream, true);
                 }
                 else
                 {
-                    _masterpagesFileSystem.AddFile(entity.Name, stream, true);
+                    string masterpageName = string.Concat(entity.Alias, ".master");
+                    _masterpagesFileSystem.AddFile(masterpageName, stream, true);
                 }
             }
 
@@ -236,6 +242,12 @@ namespace Umbraco.Core.Persistence.Repositories
             {
                 var parent = Database.First<NodeDto>("WHERE id = @ParentId", new { ParentId = ((Template)entity).ParentId });
                 entity.Path = string.Concat(parent.Path, ",", entity.Id);
+                ((Template)entity).Level = parent.Level + 1;
+                var maxSortOrder =
+                    Database.ExecuteScalar<int>(
+                        "SELECT coalesce(max(sortOrder),0) FROM umbracoNode WHERE parentid = @ParentId AND nodeObjectType = @NodeObjectType",
+                        new { ParentId = ((Template)entity).ParentId, NodeObjectType = NodeObjectTypeId });
+                ((Template)entity).SortOrder = maxSortOrder + 1;
             }
 
             //Get TemplateDto from db to get the Primary key of the entity
@@ -328,8 +340,8 @@ namespace Umbraco.Core.Persistence.Repositories
 
         public ITemplate Get(string alias)
         {
-            var sql = GetBaseQuery(false);
-            sql.Where("cmsTemplate.alias = @Alias", new { Alias = alias });
+            var sql = GetBaseQuery(false)
+                .Where<TemplateDto>(x => x.Alias == alias);
 
             var dto = Database.Fetch<TemplateDto, NodeDto>(sql).FirstOrDefault();
 

src/Umbraco.Core/Persistence/Repositories/VersionableRepositoryBase.cs

@@ -1,11 +1,9 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using Umbraco.Core.Models;
 using Umbraco.Core.Models.EntityBase;
 using Umbraco.Core.Models.Rdbms;
 using Umbraco.Core.Persistence.Caching;
-using Umbraco.Core.Persistence.Factories;
 using Umbraco.Core.Persistence.UnitOfWork;
 
 namespace Umbraco.Core.Persistence.Repositories

src/Umbraco.Core/Persistence/SqlSyntax/DbTypes.cs

@@ -4,7 +4,7 @@ using System.Data;
 
 namespace Umbraco.Core.Persistence.SqlSyntax
 {
-    internal class DbTypes<TSyntax>
+    public class DbTypes<TSyntax>
         where TSyntax : ISqlSyntaxProvider
     {
         public DbType DbType;

src/Umbraco.Core/Persistence/SqlSyntax/ISqlSyntaxProvider.cs

@@ -31,6 +31,7 @@ namespace Umbraco.Core.Persistence.SqlSyntax
         string InsertData { get; }
         string UpdateData { get; }
         string DeleteData { get; }
+        string TruncateTable { get; }
         string CreateConstraint { get; }
         string DeleteConstraint { get; }
         string CreateForeignKeyConstraint { get; }
@@ -48,6 +49,7 @@ namespace Umbraco.Core.Persistence.SqlSyntax
         string FormatTableRename(string oldName, string newName);
         bool SupportsClustered();
         bool SupportsIdentityInsert();
+        bool? SupportsCaseInsensitiveQueries(Database db);
         IEnumerable<string> GetTablesInSchema(Database db);
         IEnumerable<ColumnInfo> GetColumnsInSchema(Database db);
         IEnumerable<Tuple<string, string>> GetConstraintsPerTable(Database db);

src/Umbraco.Core/Persistence/SqlSyntax/MySqlSyntaxProvider.cs

@@ -7,21 +7,20 @@ using Umbraco.Core.Persistence.DatabaseModelDefinitions;
 namespace Umbraco.Core.Persistence.SqlSyntax
 {
     /// <summary>
-    /// Static class that provides simple access to the MySql SqlSyntax Providers singleton
+    /// Static class that provides simple access to the MySql SqlSyntax Provider
     /// </summary>
     internal static class MySqlSyntax
     {
-        public static ISqlSyntaxProvider Provider { get { return MySqlSyntaxProvider.Instance; } }
+        public static ISqlSyntaxProvider Provider { get { return new MySqlSyntaxProvider(); } }
     }
 
     /// <summary>
     /// Represents an SqlSyntaxProvider for MySql
     /// </summary>
-    internal class MySqlSyntaxProvider : SqlSyntaxProviderBase<MySqlSyntaxProvider>
+    [SqlSyntaxProviderAttribute("MySql.Data.MySqlClient")]
+    public class MySqlSyntaxProvider : SqlSyntaxProviderBase<MySqlSyntaxProvider>
     {
-        public static MySqlSyntaxProvider Instance = new MySqlSyntaxProvider();
-
-        private MySqlSyntaxProvider()
+        public MySqlSyntaxProvider()
         {
             DefaultStringLength = 255;
             StringLengthColumnDefinitionFormat = StringLengthUnicodeColumnDefinitionFormat;
@@ -309,5 +308,33 @@ namespace Umbraco.Core.Persistence.SqlSyntax
         public override string DropIndex { get { return "DROP INDEX {0} ON {1}"; } }
 
         public override string RenameColumn { get { return "ALTER TABLE {0} CHANGE {1} {2}"; } }
+
+        public override bool? SupportsCaseInsensitiveQueries(Database db)
+        {
+            bool? supportsCaseInsensitiveQueries = null;
+
+            try
+            {
+                db.OpenSharedConnection();
+                // Need 4 @ signs as it is regarded as a parameter, @@ escapes it once, @@@@ escapes it twice
+                var lowerCaseFileSystem = db.Fetch<int>("SELECT @@@@Global.lower_case_file_system");
+                var lowerCaseTableNames = db.Fetch<int>("SELECT @@@@Global.lower_case_table_names");
+                
+                if(lowerCaseFileSystem.Any() && lowerCaseTableNames.Any())
+                    supportsCaseInsensitiveQueries = lowerCaseFileSystem.First() == 1 && lowerCaseTableNames.First() == 1;
+            }
+            catch(Exception ex)
+            {
+                Logging.LogHelper.Error<MySqlSyntaxProvider>("Error querying for lower_case support", ex);
+            }
+            finally
+            {
+                db.CloseSharedConnection();
+            }
+
+            // Could return null, which means testing failed, 
+            // add message to check with their hosting provider
+            return supportsCaseInsensitiveQueries;
+        }
     }
 }

src/Umbraco.Core/Persistence/SqlSyntax/SqlCeSyntaxProvider.cs

@@ -1,28 +1,26 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using System.Text;
 using Umbraco.Core.Persistence.DatabaseAnnotations;
 using Umbraco.Core.Persistence.DatabaseModelDefinitions;
 
 namespace Umbraco.Core.Persistence.SqlSyntax
 {
     /// <summary>
-    /// Static class that provides simple access to the Sql CE SqlSyntax Providers singleton
+    /// Static class that provides simple access to the Sql CE SqlSyntax Provider
     /// </summary>
     internal static class SqlCeSyntax
     {
-        public static ISqlSyntaxProvider Provider { get { return SqlCeSyntaxProvider.Instance; } }
+        public static ISqlSyntaxProvider Provider { get { return new SqlCeSyntaxProvider(); } }
     }
 
     /// <summary>
     /// Represents an SqlSyntaxProvider for Sql Ce
     /// </summary>
-    internal class SqlCeSyntaxProvider : SqlSyntaxProviderBase<SqlCeSyntaxProvider>
+    [SqlSyntaxProviderAttribute("System.Data.SqlServerCe.4.0")]
+    public class SqlCeSyntaxProvider : SqlSyntaxProviderBase<SqlCeSyntaxProvider>
     {
-        public static SqlCeSyntaxProvider Instance = new SqlCeSyntaxProvider();
-
-        private SqlCeSyntaxProvider()
+        public SqlCeSyntaxProvider()
         {
             StringLengthColumnDefinitionFormat = StringLengthUnicodeColumnDefinitionFormat;
             StringColumnDefinition = string.Format(StringLengthColumnDefinitionFormat, DefaultStringLength);
@@ -44,6 +42,14 @@ namespace Umbraco.Core.Persistence.SqlSyntax
             return false;
         }
 
+        /// <summary>
+        /// SqlCe doesn't support the Truncate Table syntax, so we just have to do a DELETE FROM which is slower but we have no choice.
+        /// </summary>
+        public override string TruncateTable
+        {
+            get { return "DELETE FROM {0}"; }
+        }
+
         public override string GetIndexType(IndexTypes indexTypes)
         {
             string indexType;

src/Umbraco.Core/Persistence/SqlSyntax/SqlServerSyntaxProvider.cs

@@ -6,21 +6,20 @@ using Umbraco.Core.Persistence.DatabaseModelDefinitions;
 namespace Umbraco.Core.Persistence.SqlSyntax
 {
     /// <summary>
-    /// Static class that provides simple access to the Sql Server SqlSyntax Providers singleton
+    /// Static class that provides simple access to the Sql Server SqlSyntax Provider
     /// </summary>
     internal static class SqlServerSyntax
     {
-        public static ISqlSyntaxProvider Provider { get { return SqlServerSyntaxProvider.Instance; } }
+        public static ISqlSyntaxProvider Provider { get { return new SqlServerSyntaxProvider(); } }
     }
 
     /// <summary>
     /// Represents an SqlSyntaxProvider for Sql Server
     /// </summary>
-    internal class SqlServerSyntaxProvider : SqlSyntaxProviderBase<SqlServerSyntaxProvider>
+    [SqlSyntaxProviderAttribute("System.Data.SqlClient")]
+    public class SqlServerSyntaxProvider : SqlSyntaxProviderBase<SqlServerSyntaxProvider>
     {
-        public static SqlServerSyntaxProvider Instance = new SqlServerSyntaxProvider();
-
-        private SqlServerSyntaxProvider()
+        public SqlServerSyntaxProvider()
         {
             StringLengthColumnDefinitionFormat = StringLengthUnicodeColumnDefinitionFormat;
             StringColumnDefinition = string.Format(StringLengthColumnDefinitionFormat, DefaultStringLength);

src/Umbraco.Core/Persistence/SqlSyntax/SqlSyntaxContext.cs

@@ -3,9 +3,9 @@
 namespace Umbraco.Core.Persistence.SqlSyntax
 {
     /// <summary>
-    /// Singleton to handle the configuration of an SqlSyntaxProvider
+    /// Singleton to handle the configuration of a SqlSyntaxProvider
     /// </summary>
-    internal static class SyntaxConfig
+    public static class SqlSyntaxContext
     {
         private static ISqlSyntaxProvider _sqlSyntaxProvider;
 
@@ -16,7 +16,7 @@ namespace Umbraco.Core.Persistence.SqlSyntax
                 if(_sqlSyntaxProvider == null)
                 {
                     throw new ArgumentNullException("SqlSyntaxProvider",
-                                                    "You must set the singleton 'Umbraco.Core.Persistence.SqlSyntax.SyntaxConfig' to use an sql syntax provider");
+                                                    "You must set the singleton 'Umbraco.Core.Persistence.SqlSyntax.SqlSyntaxContext' to use an sql syntax provider");
                 }
                 return _sqlSyntaxProvider;
             }

src/Umbraco.Core/Persistence/SqlSyntax/SqlSyntaxProviderAttribute.cs

@@ -0,0 +1,21 @@
+using System;
+
+namespace Umbraco.Core.Persistence.SqlSyntax
+{
+    /// <summary>
+    /// Attribute for implementations of an ISqlSyntaxProvider
+    /// </summary>
+    [AttributeUsage(AttributeTargets.Class)]
+    public class SqlSyntaxProviderAttribute : Attribute
+    {
+        public SqlSyntaxProviderAttribute(string providerName)
+        {
+            ProviderName = providerName;
+        }
+
+        /// <summary>
+        /// Gets or sets the ProviderName that corresponds to the sql syntax in a provider.
+        /// </summary>
+        public string ProviderName { get; set; }
+    }
+}