Merge branch '7.4.0' of https://github.com/umbraco/Umbraco-CMS into 7.4.0

hack until we fix template generation for when MB is disabled
Require very latest version of ModelsBuilder
2016-01-15 18:02:39 +01:00 · 2016-01-15 18:02:31 +01:00 · 2016-01-15 17:38:31 +01:00 · 2016-01-15 17:06:56 +01:00 · 2016-01-15 17:06:22 +01:00 · 2016-01-15 17:05:09 +01:00
970 changed files with 38258 additions and 15364 deletions
@@ -1,4 +1,6 @@
@ECHO OFF
+SETLOCAL
+
 SET release=%1
 ECHO Installing Npm NuGet Package

@@ -11,12 +13,9 @@ ECHO Current folder: %CD%
 for /f "delims=" %%A in ('dir %nuGetFolder%node.js.* /b') do set "nodePath=%nuGetFolder%%%A\"
 for /f "delims=" %%A in ('dir %nuGetFolder%npm.js.* /b') do set "npmPath=%nuGetFolder%%%A\tools\"

-ECHO Temporarily adding Npm and Node to path
-SET oldPath=%PATH%
-
-path=%npmPath%;%nodePath%;%PATH%
-
-ECHO %path%
+ECHO Adding Npm and Node to path 
+REM SETLOCAL is on, so changes to the path not persist to the actual user's path
+PATH=%npmPath%;%nodePath%;%PATH%

 SET buildFolder=%CD%

@@ -29,8 +28,5 @@ call npm install -g grunt-cli --quiet
 call npm install -g bower --quiet
 call grunt build --buildversion=%release%

-ECHO Reset path to what it was before
-path=%oldPath%
-
 ECHO Move back to the build folder
 CD %buildFolder% 
@@ -1,19 +1,19 @@
@ECHO OFF
-SET oldPath=%PATH%
+SETLOCAL
+REM SETLOCAL is on, so changes to the path not persist to the actual user's path

 git.exe 2> NUL
 if %ERRORLEVEL%==9009 GOTO :trydefaultpath
 GOTO :EOF

 :trydefaultpath
-path=C:\Program Files (x86)\Git\cmd;%PATH%
+path=C:\Program Files (x86)\Git\cmd;C:\Program Files\Git\cmd;%PATH%
 git.exe 2> NUL
 if %ERRORLEVEL%==9009 GOTO :showerror
 GOTO :EOF

 :showerror
-path=%oldPath%
-ECHO Git is not in your path and could not be found in C:\Program Files (x86)\Git\bin 
+ECHO Git is not in your path and could not be found in C:\Program Files (x86)\Git\cmd nor in C:\Program Files\Git\cmd
 set /p install=" Do you want to install Git through Chocolatey [y/n]? " %=%
 if %install%==y (
 	GOTO :installgit
@@ -29,5 +29,4 @@ GOTO :EOF
 ECHO Installing Chocolatey first
@powershell -NoProfile -ExecutionPolicy unrestricted -Command "iex ((new-object net.webclient).DownloadString('https://chocolatey.org/install.ps1'))" && SET PATH=%PATH%;%ALLUSERSPROFILE%\chocolatey\bin
 ECHO Installing Git through Chocolatey
-choco install git
-path=C:\Program Files (x86)\Git\cmd;%path%
+choco install git
@@ -33,11 +33,12 @@
      <dependency id="AutoMapper" version="[3.0.0, 3.1.0)" />
      <dependency id="Newtonsoft.Json" version="[6.0.8, 7.0.0)" />
      <dependency id="Examine" version="[0.1.68, 1.0.0)" />
-      <dependency id="ImageProcessor" version="[2.3.0, 3.0.0)" />
-      <dependency id="ImageProcessor.Web" version="[4.4.0, 5.0.0)" />
+      <dependency id="ImageProcessor" version="[2.3.2, 3.0.0)" />
+      <dependency id="ImageProcessor.Web" version="[4.5.0, 5.0.0)" />
      <dependency id="semver" version="[1.1.2, 2.0.0)" />
      <dependency id="Microsoft.AspNet.WebHelpers" version="[3.2.3, 4.0.0)" />
      <dependency id="Microsoft.AspNet.WebPages.Data" version="[3.2.3, 4.0.0)" />
+	  <dependency id="Umbraco.ModelsBuilder.AspNet" version="[2.2.0-beta003, 3.0.0)" />	
    </dependencies>
  </metadata>
  <files>
@@ -17,6 +17,11 @@
    <host factoryType="System.Web.Mvc.MvcWebRazorHostFactory, System.Web.Mvc, Version=5.2.3.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35"
 		xdt:Locator="Match(factoryType)" 
 		xdt:Transform="SetAttributes(factoryType)" />
+    <pages pageBaseType="System.Web.Mvc.WebViewPage">
+      <namespaces>
+		<add namespace="Umbraco.Web.PublishedContentModels" xdt:Transform="InsertIfMissing" />        
+      </namespaces>
+    </pages>
  </system.web.webPages.razor>
  
  <system.web>
@@ -54,7 +54,7 @@
      </providers>
      </siteMap>	
    <httpRuntime xdt:Transform="InsertIfMissing" />
-    <httpRuntime targetFramework="4.5" xdt:Transform="SetAttributes(targetFramework)" />
+    <httpRuntime targetFramework="4.5" maxRequestLength="1048576" fcnMode="Single" xdt:Transform="SetAttributes(targetFramework,fcnMode,maxRequestLength)" />
    <membership defaultProvider="DefaultMembershipProvider" xdt:Locator="Match(defaultProvider)" xdt:Transform="Remove" />
    <roleManager defaultProvider="DefaultRoleProvider" xdt:Locator="Match(defaultProvider)" xdt:Transform="Remove"/>
    <profile defaultProvider="DefaultProfileProvider" xdt:Locator="Match(defaultProvider)" xdt:Transform="Remove"/>>
@@ -66,6 +66,7 @@
        <add assembly="System.Net.Http, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" xdt:Locator="Match(assembly)"
    xdt:Transform="InsertIfMissing" />
        <add assembly="System.Web.Http, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35" xdt:Locator="Match(assembly)" xdt:Transform="InsertIfMissing" />
+        <add assembly="System.Runtime, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" xdt:Locator="Match(assembly)" xdt:Transform="InsertIfMissing" />
        <add assembly="System.Design, Version=4.0.0.0, Culture=neutral, PublicKeyToken=B03F5F7F11D50A3A" xdt:Locator="Match(assembly)" xdt:Transform="Remove" />
        <add assembly="System.Core, Version=4.0.0.0, Culture=neutral, PublicKeyToken=B77A5C561934E089" xdt:Locator="Match(assembly)" xdt:Transform="Remove" />
        <add assembly="System.Web.Extensions, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35" xdt:Locator="Match(assembly)" xdt:Transform="Remove" />
@@ -84,10 +85,12 @@
      <assemblies>
        <remove assembly="System.Web.Http" xdt:Locator="Match(assembly)" xdt:Transform="Remove" />
        <remove assembly="System.Net.Http" xdt:Locator="Match(assembly)" xdt:Transform="Remove" />
+        <remove assembly="System.Runtime" xdt:Locator="Match(assembly)" xdt:Transform="Remove" />
      </assemblies>
      <assemblies>
        <remove assembly="System.Web.Http" xdt:Locator="Match(assembly)" xdt:Transform="InsertBefore(/configuration/system.web/compilation/assemblies/add)" />
        <remove assembly="System.Net.Http" xdt:Locator="Match(assembly)" xdt:Transform="InsertBefore(/configuration/system.web/compilation/assemblies/add)" />
+        <remove assembly="System.Runtime" xdt:Locator="Match(assembly)" xdt:Transform="InsertBefore(/configuration/system.web/compilation/assemblies/add)" />
      </assemblies>
    </compilation>

@@ -140,6 +143,13 @@
      <remove name="SpellChecker" xdt:Locator="Match(name)" xdt:Transform="Remove" />
      <add name="SpellChecker" xdt:Locator="Match(name)" xdt:Transform="Remove" />
    </handlers>
+
+    <security xdt:Transform="InsertIfMissing">
+      <requestFiltering xdt:Transform="InsertIfMissing">
+        <requestLimits maxAllowedContentLength="1073741824" xdt:Transform="InsertIfMissing" />
+      </requestFiltering>
+    </security>
+    
  </system.webServer>

  <system.codedom xdt:Transform="Remove" />
@@ -151,20 +161,26 @@
  
  <runtime>
    <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
+      <dependentAssembly xdt:Locator="Condition(./_defaultNamespace:assemblyIdentity/@name='HtmlAgilityPack')" xdt:Transform="Remove" />
      <dependentAssembly xdt:Locator="Condition(./_defaultNamespace:assemblyIdentity/@name='System.Net.Http')" xdt:Transform="Remove" />
      <dependentAssembly xdt:Locator="Condition(./_defaultNamespace:assemblyIdentity/@name='Newtonsoft.Json')" xdt:Transform="Remove" />
      <dependentAssembly xdt:Locator="Condition(./_defaultNamespace:assemblyIdentity/@name='System.Web.Mvc')" xdt:Transform="Remove" />
+      <dependentAssembly xdt:Locator="Condition(./_defaultNamespace:assemblyIdentity/@name='System.Web.WebPages.Razor')" xdt:Transform="Remove" />
      <dependentAssembly xdt:Locator="Condition(./_defaultNamespace:assemblyIdentity/@name='System.Web.Http')" xdt:Transform="Remove" />
      <dependentAssembly xdt:Locator="Condition(./_defaultNamespace:assemblyIdentity/@name='Microsoft.Owin')" xdt:Transform="Remove" />
      <dependentAssembly xdt:Locator="Condition(./_defaultNamespace:assemblyIdentity/@name='Microsoft.Owin.Security.OAuth')" xdt:Transform="Remove" />
      <dependentAssembly xdt:Locator="Condition(./_defaultNamespace:assemblyIdentity/@name='Microsoft.Owin.Security')" xdt:Transform="Remove" />
      <dependentAssembly xdt:Locator="Condition(./_defaultNamespace:assemblyIdentity/@name='Microsoft.Owin.Security.Cookies')" xdt:Transform="Remove" />
-      <dependentAssembly xdt:Locator="Condition(./_defaultNamespace:assemblyIdentity/@name='System.Net.Http.Formatting')" xdt:Transform="Remove" />
+	  <dependentAssembly xdt:Locator="Condition(./_defaultNamespace:assemblyIdentity/@name='System.Net.Http.Formatting')" xdt:Transform="Remove" />
    </assemblyBinding>
  </runtime>

  <runtime>
    <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
+      <dependentAssembly>
+        <assemblyIdentity name="HtmlAgilityPack" publicKeyToken="bd319b19eaf3b43a" culture="neutral" />
+        <bindingRedirect oldVersion="0.0.0.0-1.4.9.0" newVersion="1.4.9.0" />
+      </dependentAssembly>	
      <dependentAssembly xdt:Transform="Insert">
        <assemblyIdentity name="System.Net.Http" publicKeyToken="b03f5f7f11d50a3a" culture="neutral"/>
        <bindingRedirect oldVersion="0.0.0.0-4.0.0.0" newVersion="4.0.0.0"/>
@@ -177,6 +193,10 @@
        <assemblyIdentity name="System.Web.Mvc" publicKeyToken="31bf3856ad364e35" culture="neutral" />
        <bindingRedirect oldVersion="0.0.0.0-4.0.0.1" newVersion="4.0.0.1" />
      </dependentAssembly>
+      <dependentAssembly xdt:Transform="Insert">
+        <assemblyIdentity name="System.Web.WebPages.Razor" publicKeyToken="31bf3856ad364e35" />
+        <bindingRedirect oldVersion="0.0.0.0-3.0.0.0" newVersion="3.0.0.0" />
+      </dependentAssembly>		  
      <dependentAssembly xdt:Transform="Insert">
        <assemblyIdentity name="System.Web.Http" publicKeyToken="31bf3856ad364e35" culture="neutral" />
        <bindingRedirect oldVersion="0.0.0.0-5.2.3.0" newVersion="5.2.3.0" />
@@ -1,36 +1,127 @@
 <?xml version="1.0"?>
 <trees xmlns:xdt="http://schemas.microsoft.com/XML-Document-Transform">
-  <add initialize="true" sortOrder="0" alias="content" application="content" title="Content" iconClosed="icon-folder" iconOpen="icon-folder" type="Umbraco.Web.Trees.ContentTreeController, umbraco" xdt:Locator="Match(alias)" xdt:Transform="SetAttributes()" />
-  <add alias="content" xdt:Locator="Match(alias)" xdt:Transform="RemoveAttributes(silent)" />
-  <add initialize="false" sortOrder="0" alias="contentRecycleBin" application="content" title="Recycle Bin" iconClosed="icon-folder" iconOpen="icon-folder" type="umbraco.cms.presentation.Trees.ContentRecycleBin, umbraco" xdt:Locator="Match(alias)" xdt:Transform="SetAttributes()" />
-  <add initialize="true" sortOrder="0" alias="media" application="media" title="Media" iconClosed="icon-folder" iconOpen="icon-folder" type="Umbraco.Web.Trees.MediaTreeController, umbraco" xdt:Locator="Match(alias)" xdt:Transform="SetAttributes()" />
-  <add initialize="false" sortOrder="0" alias="mediaRecycleBin" application="media" title="Recycle Bin" iconClosed="icon-folder" iconOpen="icon-folder" type="umbraco.cms.presentation.Trees.MediaRecycleBin, umbraco" xdt:Locator="Match(alias)" xdt:Transform="SetAttributes()" />
-  <add application="settings" alias="stylesheets" title="Stylesheets" type="umbraco.loadStylesheets, umbraco" iconClosed="icon-folder" iconOpen="icon-folder" sortOrder="0" xdt:Locator="Match(alias)" xdt:Transform="SetAttributes()" />
-  <add application="settings" alias="stylesheetProperty" title="Stylesheet Property" type="umbraco.loadStylesheetProperty, umbraco" iconClosed="" iconOpen="" initialize="false" sortOrder="0" xdt:Locator="Match(alias)" xdt:Transform="SetAttributes()" />
-  <add application="settings" alias="templates" title="Templates" type="Umbraco.Web.Trees.TemplatesTreeController, umbraco" iconClosed="icon-folder" iconOpen="icon-folder-open" sortOrder="1" xdt:Locator="Match(alias)" xdt:Transform="SetAttributes()" />
-  <add application="settings" alias="partialViews" title="Partial Views" silent="false" initialize="true" iconClosed="icon-folder" iconOpen="icon-folder" type="Umbraco.Web.Trees.PartialViewsTree, umbraco" sortOrder="2" xdt:Locator="Match(alias)" xdt:Transform="SetAttributes()" />
-  <add application="settings" alias="scripts" title="Scripts" type="umbraco.loadScripts, umbraco" iconClosed="icon-folder" iconOpen="icon-folder" sortOrder="3" xdt:Locator="Match(alias)" xdt:Transform="SetAttributes()" />
-  <add application="settings" alias="dictionary" title="Dictionary" type="umbraco.loadDictionary, umbraco" iconClosed="icon-folder" iconOpen="icon-folder" sortOrder="4" xdt:Locator="Match(alias)" xdt:Transform="SetAttributes()" />
-  <add alias="dictionary" xdt:Locator="Match(alias)" xdt:Transform="RemoveAttributes(action)" />
-  <add application="settings" alias="languages" title="Languages" type="Umbraco.Web.Trees.LanguageTreeController, umbraco" iconClosed="icon-folder" iconOpen="icon-folder-open" sortOrder="5" xdt:Locator="Match(alias)" xdt:Transform="SetAttributes()" />
-  <add application="settings" alias="mediaTypes" title="Media Types" type="umbraco.loadMediaTypes, umbraco" iconClosed="icon-folder" iconOpen="icon-folder" sortOrder="6" xdt:Locator="Match(alias)" xdt:Transform="SetAttributes()" />
-  <add application="settings" alias="nodeTypes" title="Document Types" type="umbraco.loadNodeTypes, umbraco" iconClosed="icon-folder" iconOpen="icon-folder" sortOrder="7" xdt:Locator="Match(alias)" xdt:Transform="SetAttributes()" />
-  <add initialize="true" sortOrder="0" alias="datatype" application="developer" title="Data Types" iconClosed="icon-folder" iconOpen="icon-folder" type="Umbraco.Web.Trees.DataTypeTreeController, umbraco" xdt:Locator="Match(alias)" xdt:Transform="SetAttributes()" />
-  <add application="developer" alias="macros" title="Macros" type="umbraco.loadMacros, umbraco" iconClosed="icon-folder" iconOpen="icon-folder" sortOrder="2" xdt:Locator="Match(alias)" xdt:Transform="SetAttributes()" />
-  <add application="developer" alias="packager" title="Packages" type="umbraco.loadPackager, umbraco" iconClosed="icon-folder" iconOpen="icon-folder" sortOrder="3" xdt:Locator="Match(alias)" xdt:Transform="SetAttributes()" />
-  <add application="developer" alias="packagerPackages" title="Packager Packages" type="umbraco.loadPackages, umbraco" iconClosed="icon-folder" iconOpen="icon-folder" initialize="false" sortOrder="3" xdt:Locator="Match(alias)" xdt:Transform="SetAttributes()" />
-  <add application="developer" alias="relationTypes" title="Relation Types" type="umbraco.loadRelationTypes, umbraco" iconClosed="icon-folder" iconOpen="icon-folder" sortOrder="4" xdt:Locator="Match(alias)" xdt:Transform="SetAttributes()" />
-  <add application="developer" alias="xslt" title="XSLT Files" type="umbraco.loadXslt, umbraco" iconClosed="icon-folder" iconOpen="icon-folder" sortOrder="5" xdt:Locator="Match(alias)" xdt:Transform="SetAttributes()" />
-  <add application="developer" alias="partialViewMacros" type="Umbraco.Web.Trees.PartialViewMacrosTree, umbraco" silent="false" initialize="true" sortOrder="6" title="Partial View Macro Files" iconClosed="icon-folder" iconOpen="icon-folder" xdt:Locator="Match(alias)" xdt:Transform="SetAttributes()" />
-  <add application="users" alias="users" title="Users" type="umbraco.loadUsers, umbraco" iconClosed="icon-folder" iconOpen="icon-folder" sortOrder="0" xdt:Locator="Match(alias)" xdt:Transform="SetAttributes()" />
-  <add application="users" alias="userTypes" title="User Types" type="umbraco.cms.presentation.Trees.UserTypes, umbraco" iconClosed="icon-folder" iconOpen="icon-folder" sortOrder="1" xdt:Locator="Match(alias)" xdt:Transform="SetAttributes()" />
-  <add application="users" alias="userPermissions" title="User Permissions" type="umbraco.cms.presentation.Trees.UserPermissions, umbraco" iconClosed="icon-folder" iconOpen="icon-folder" sortOrder="2" xdt:Locator="Match(alias)" xdt:Transform="SetAttributes()" />
-  <add initialize="true" sortOrder="0" alias="member" application="member" title="Members" iconClosed="icon-folder" iconOpen="icon-folder-open" type="Umbraco.Web.Trees.MemberTreeController, umbraco" xdt:Locator="Match(alias)" xdt:Transform="SetAttributes()" />
-  <add application="member" alias="memberGroup" title="Member Groups" type="umbraco.loadMemberGroups, umbraco" iconClosed="icon-folder" iconOpen="icon-folder" sortOrder="1" xdt:Locator="Match(alias)" xdt:Transform="SetAttributes()" />
-  <add application="member" alias="memberType" title="Member Types" type="umbraco.loadMemberTypes, umbraco" iconClosed="icon-folder" iconOpen="icon-folder" sortOrder="2" xdt:Locator="Match(alias)" xdt:Transform="SetAttributes()" />
-  <add silent="false" initialize="true" sortOrder="1" alias="openTasks" application="translation" title="Tasks assigned to you" iconClosed="icon-folder" iconOpen="icon-folder" type="umbraco.loadOpenTasks, umbraco" xdt:Locator="Match(alias)" xdt:Transform="SetAttributes()" />
-  <add alias="openTasks" xdt:Locator="Match(alias)" xdt:Transform="RemoveAttributes(action)" />
-  <add silent="false" initialize="true" sortOrder="2" alias="yourTasks" application="translation" title="Tasks created by you" iconClosed="icon-folder" iconOpen="icon-folder" type="umbraco.loadYourTasks, umbraco" xdt:Locator="Match(alias)" xdt:Transform="SetAttributes()" />
-  <add alias="yourTasks" xdt:Locator="Match(alias)" xdt:Transform="RemoveAttributes(action)" />
-  <add application="developer" alias="python" xdt:Locator="Match(alias)" xdt:Transform="Remove" />
+  <!--Content-->
+  <add alias="content" application="content"
+       xdt:Locator="Match(application,alias)" 
+       xdt:Transform="RemoveAttributes(silent)" />
+  <add initialize="false" sortOrder="0" alias="contentRecycleBin" application="content" title="Recycle Bin" iconClosed="icon-folder" iconOpen="icon-folder" type="umbraco.cms.presentation.Trees.ContentRecycleBin, umbraco" 
+       xdt:Locator="Match(application,alias)" 
+       xdt:Transform="SetAttributes()" />
+  <add initialize="true" sortOrder="0" alias="content" application="content" title="Content" iconClosed="icon-folder" iconOpen="icon-folder" type="Umbraco.Web.Trees.ContentTreeController, umbraco" 
+       xdt:Locator="Match(application,alias)" 
+       xdt:Transform="SetAttributes()" />
+  
+  <!--Media-->
+  <add initialize="true" sortOrder="0" alias="media" application="media" title="Media" iconClosed="icon-folder" iconOpen="icon-folder" type="Umbraco.Web.Trees.MediaTreeController, umbraco" 
+       xdt:Locator="Match(application,alias)" 
+       xdt:Transform="SetAttributes()" />
+  <add initialize="false" sortOrder="0" alias="mediaRecycleBin" application="media" title="Recycle Bin" iconClosed="icon-folder" iconOpen="icon-folder" type="umbraco.cms.presentation.Trees.MediaRecycleBin, umbraco" 
+       xdt:Locator="Match(application,alias)" 
+       xdt:Transform="SetAttributes()" />
+  
+  <!--Settings-->
+  <add application="settings" alias="nodeTypes"  
+       xdt:Locator="Match(application,alias)" 
+       xdt:Transform="Remove" />
+  <add initialize="true" sortOrder="0" alias="documentTypes" application="settings" title="Document Types" iconClosed="icon-folder" iconOpen="icon-folder-open" type="Umbraco.Web.Trees.ContentTypeTreeController, umbraco"
+       xdt:Locator="Match(application,alias)" 
+       xdt:Transform="InsertIfMissing" />
+  <add application="settings" alias="stylesheets" title="Stylesheets" type="umbraco.loadStylesheets, umbraco" iconClosed="icon-folder" iconOpen="icon-folder" sortOrder="3" 
+       xdt:Locator="Match(application,alias)" 
+       xdt:Transform="SetAttributes()" />
+  <add application="settings" alias="stylesheetProperty" title="Stylesheet Property" type="umbraco.loadStylesheetProperty, umbraco" iconClosed="" iconOpen="" initialize="false" sortOrder="0" 
+       xdt:Locator="Match(application,alias)" 
+       xdt:Transform="SetAttributes()" />
+  <add application="settings" alias="templates" title="Templates" type="Umbraco.Web.Trees.TemplatesTreeController, umbraco" iconClosed="icon-folder" iconOpen="icon-folder-open" sortOrder="1" 
+       xdt:Locator="Match(application,alias)" 
+       xdt:Transform="SetAttributes()" />
+  <add application="settings" alias="partialViews" title="Partial Views" silent="false" initialize="true" iconClosed="icon-folder" iconOpen="icon-folder" type="Umbraco.Web.Trees.PartialViewsTree, umbraco" sortOrder="2" 
+       xdt:Locator="Match(application,alias)" 
+       xdt:Transform="SetAttributes()" />
+  <add application="settings" alias="scripts" title="Scripts" type="umbraco.loadScripts, umbraco" iconClosed="icon-folder" iconOpen="icon-folder" sortOrder="4" 
+       xdt:Locator="Match(application,alias)" 
+       xdt:Transform="SetAttributes()" />
+  <add application="settings" alias="dictionary" title="Dictionary" type="umbraco.loadDictionary, umbraco" iconClosed="icon-folder" iconOpen="icon-folder" sortOrder="6" 
+       xdt:Locator="Match(application,alias)" 
+       xdt:Transform="SetAttributes()" />
+  <add alias="dictionary" application="settings"
+       xdt:Locator="Match(application,alias)" 
+       xdt:Transform="RemoveAttributes(action)" />
+  <add application="settings" alias="languages" title="Languages" type="Umbraco.Web.Trees.LanguageTreeController, umbraco" iconClosed="icon-folder" iconOpen="icon-folder-open" sortOrder="5" 
+       xdt:Locator="Match(application,alias)" 
+       xdt:Transform="SetAttributes()" />
+  <add application="settings" initialize="true" alias="mediaTypes" title="Media Types" type="Umbraco.Web.Trees.MediaTypeTreeController, umbraco" iconClosed="icon-folder" iconOpen="icon-folder-open" sortOrder="7" 
+       xdt:Locator="Match(application,alias)" 
+       xdt:Transform="SetAttributes()" />
+
+  <!--Developer-->
+  <add alias="datatype" application="developer"
+       xdt:Locator="Match(application,alias)" 
+       xdt:Transform="Remove" />
+  <add initialize="true" sortOrder="0" alias="datatypes" application="developer" title="Data Types" iconClosed="icon-folder" iconOpen="icon-folder" type="Umbraco.Web.Trees.DataTypeTreeController, umbraco" 
+       xdt:Locator="Match(application,alias)" 
+       xdt:Transform="InsertIfMissing" />
+  <add application="developer" alias="macros" title="Macros" type="umbraco.loadMacros, umbraco" iconClosed="icon-folder" iconOpen="icon-folder" sortOrder="2" 
+       xdt:Locator="Match(application,alias)" 
+       xdt:Transform="SetAttributes()" />
+  <add application="developer" alias="packager" title="Packages" type="umbraco.loadPackager, umbraco" iconClosed="icon-folder" iconOpen="icon-folder" sortOrder="3" 
+       xdt:Locator="Match(application,alias)" 
+       xdt:Transform="SetAttributes()" />
+  <add application="developer" alias="packagerPackages" title="Packager Packages" type="umbraco.loadPackages, umbraco" iconClosed="icon-folder" iconOpen="icon-folder" initialize="false" sortOrder="3" 
+       xdt:Locator="Match(application,alias)" 
+       xdt:Transform="SetAttributes()" />
+  <add application="developer" alias="relationTypes" title="Relation Types" type="umbraco.loadRelationTypes, umbraco" iconClosed="icon-folder" iconOpen="icon-folder" sortOrder="4" 
+       xdt:Locator="Match(application,alias)" 
+       xdt:Transform="SetAttributes()" />
+  <add application="developer" alias="xslt" title="XSLT Files" type="umbraco.loadXslt, umbraco" iconClosed="icon-folder" iconOpen="icon-folder" sortOrder="5" 
+       xdt:Locator="Match(application,alias)" 
+       xdt:Transform="SetAttributes()" />
+  <add application="developer" alias="partialViewMacros" type="Umbraco.Web.Trees.PartialViewMacrosTree, umbraco" silent="false" initialize="true" sortOrder="6" title="Partial View Macro Files" iconClosed="icon-folder" iconOpen="icon-folder" 
+       xdt:Locator="Match(application,alias)" 
+       xdt:Transform="SetAttributes()" />
+  <add application="developer" alias="python" 
+       xdt:Locator="Match(application,alias)" 
+       xdt:Transform="Remove" />
+
+  <!--Users-->
+  <add application="users" alias="users" title="Users" type="umbraco.loadUsers, umbraco" iconClosed="icon-folder" iconOpen="icon-folder" sortOrder="0" 
+       xdt:Locator="Match(application,alias)" 
+       xdt:Transform="SetAttributes()" />
+  <add application="users" alias="userTypes" title="User Types" type="umbraco.cms.presentation.Trees.UserTypes, umbraco" iconClosed="icon-folder" iconOpen="icon-folder" sortOrder="1" 
+       xdt:Locator="Match(application,alias)" 
+       xdt:Transform="SetAttributes()" />
+  <add application="users" alias="userPermissions" title="User Permissions" type="umbraco.cms.presentation.Trees.UserPermissions, umbraco" iconClosed="icon-folder" iconOpen="icon-folder" sortOrder="2" 
+       xdt:Locator="Match(application,alias)" 
+       xdt:Transform="SetAttributes()" />
+
+  <!--Members-->
+  <add initialize="true" sortOrder="0" alias="member" application="member" title="Members" iconClosed="icon-folder" iconOpen="icon-folder-open" type="Umbraco.Web.Trees.MemberTreeController, umbraco" 
+       xdt:Locator="Match(application,alias)" 
+       xdt:Transform="SetAttributes()" />
+  <add application="member" alias="memberGroup"
+       xdt:Locator="Match(application,alias)" 
+       xdt:Transform="Remove" />
+  <add application="member" sortOrder="2" alias="memberGroups" title="Member Groups" type="umbraco.loadMemberGroups, umbraco" iconClosed="icon-folder" iconOpen="icon-folder" 
+       xdt:Locator="Match(application,alias)" 
+       xdt:Transform="InsertIfMissing" />
+  <add application="member" alias="memberType"
+       xdt:Locator="Match(application,alias)" 
+       xdt:Transform="Remove" />
+  <add application="member" sortOrder="1" alias="memberTypes" initialize="true" title="Member Types" type="Umbraco.Web.Trees.MemberTypeTreeController, umbraco" iconClosed="icon-folder" iconOpen="icon-folder-open" 
+       xdt:Locator="Match(application,alias)" 
+       xdt:Transform="InsertIfMissing" />
+
+  <!--Translation-->
+  <add silent="false" initialize="true" sortOrder="1" alias="openTasks" application="translation" title="Tasks assigned to you" iconClosed="icon-folder" iconOpen="icon-folder" type="umbraco.loadOpenTasks, umbraco" 
+       xdt:Locator="Match(application,alias)" 
+       xdt:Transform="SetAttributes()" />
+  <add alias="openTasks" application="translation"
+       xdt:Locator="Match(application,alias)" 
+       xdt:Transform="RemoveAttributes(action)" />
+  <add silent="false" initialize="true" sortOrder="2" alias="yourTasks" application="translation" title="Tasks created by you" iconClosed="icon-folder" iconOpen="icon-folder" type="umbraco.loadYourTasks, umbraco" 
+       xdt:Locator="Match(application,alias)" 
+       xdt:Transform="SetAttributes()" />
+  <add alias="yourTasks" application="translation"
+       xdt:Locator="Match(application,alias)" 
+       xdt:Transform="RemoveAttributes(action)" />
 </trees>
@@ -1,2 +1,3 @@
 # Usage: on line 2 put the release version, on line 3 put the version comment (example: beta)
-7.3.4
+7.4.0
+beta2
@@ -1,7 +1,7 @@
-<?xml version="1.0" encoding="utf-8"?>
-<configuration>
-  <packageSources>
-    <add key="nuget.org" value="https://www.nuget.org/api/v2/" />
-    <add key="umbracocore" value="http://www.myget.org/f/umbracocore/" />
-  </packageSources>
+<?xml version="1.0" encoding="utf-8"?>
+<configuration>
+  <packageSources>
+    <add key="nuget.org" value="https://www.nuget.org/api/v2/" />
+    <add key="umbracocore" value="http://www.myget.org/f/umbracocore/" />
+  </packageSources>
 </configuration>
@@ -2,7 +2,7 @@
 using System.Resources;

 [assembly: AssemblyCompany("Umbraco")]
-[assembly: AssemblyCopyright("Copyright © Umbraco 2015")]
+[assembly: AssemblyCopyright("Copyright © Umbraco 2016")]
 [assembly: AssemblyTrademark("")]
 [assembly: AssemblyCulture("")]

@@ -11,5 +11,5 @@ using System.Resources;

 [assembly: AssemblyVersion("1.0.*")]

-[assembly: AssemblyFileVersion("7.3.4")]
-[assembly: AssemblyInformationalVersion("7.3.4")]
+[assembly: AssemblyFileVersion("7.4.0")]
+[assembly: AssemblyInformationalVersion("7.4.0-beta2")]
@@ -406,7 +406,8 @@ namespace Umbraco.Core
                //clear the cache
                if (ApplicationCache != null)
                {
-                    ApplicationCache.ClearAllCache();    
+                    ApplicationCache.RuntimeCache.ClearAllCache();
+                    ApplicationCache.IsolatedRuntimeCache.ClearAllCaches();
                }
                //reset all resolvers
                ResolverCollection.ResetAll();
@@ -1,8 +1,9 @@
 using System;
+using System.ComponentModel;
+using Umbraco.Core.CodeAnnotations;

 namespace Umbraco.Core.Cache
 {
-
    /// <summary>
    /// Constants storing cache keys used in caching
    /// </summary>
@@ -12,52 +13,78 @@ namespace Umbraco.Core.Cache
        public const string ApplicationsCacheKey = "ApplicationCache";

        [Obsolete("This is no longer used and will be removed from the codebase in the future")]
+        [EditorBrowsable(EditorBrowsableState.Never)]
        public const string UserTypeCacheKey = "UserTypeCache";

+        [Obsolete("This is no longer used and will be removed from the codebase in the future - it is referenced but no cache is stored against this key")]
+        [EditorBrowsable(EditorBrowsableState.Never)]
        public const string ContentItemCacheKey = "contentItem";

+        [UmbracoWillObsolete("This cache key is only used for the legacy 'library' caching, remove in v8")]
        public const string MediaCacheKey = "UL_GetMedia";

        public const string MacroXsltCacheKey = "macroXslt_";
+
+        [UmbracoWillObsolete("This cache key is only used for legacy business logic caching, remove in v8")]
        public const string MacroCacheKey = "UmbracoMacroCache";
+
        public const string MacroHtmlCacheKey = "macroHtml_";
        public const string MacroControlCacheKey = "macroControl_";
        public const string MacroHtmlDateAddedCacheKey = "macroHtml_DateAdded_";
        public const string MacroControlDateAddedCacheKey = "macroControl_DateAdded_";

+        [UmbracoWillObsolete("This cache key is only used for legacy 'library' member caching, remove in v8")]
        public const string MemberLibraryCacheKey = "UL_GetMember";
+
+        [UmbracoWillObsolete("This cache key is only used for legacy business logic caching, remove in v8")]
        public const string MemberBusinessLogicCacheKey = "MemberCacheItem_";
-        
+
+        [UmbracoWillObsolete("This cache key is only used for legacy template business logic caching, remove in v8")]
        public const string TemplateFrontEndCacheKey = "template";

        [Obsolete("This is no longer used and will be removed from the codebase in the future")]
+        [EditorBrowsable(EditorBrowsableState.Never)]
        public const string TemplateBusinessLogicCacheKey = "UmbracoTemplateCache";

+        [Obsolete("This is no longer used and will be removed from the codebase in the future")]
+        [EditorBrowsable(EditorBrowsableState.Never)]
        public const string UserContextCacheKey = "UmbracoUserContext";
+
        public const string UserContextTimeoutCacheKey = "UmbracoUserContextTimeout";

        [Obsolete("This is no longer used and will be removed from the codebase in the future")]
+        [EditorBrowsable(EditorBrowsableState.Never)]
        public const string UserCacheKey = "UmbracoUser";
        
        public const string UserPermissionsCacheKey = "UmbracoUserPermissions";

+        [UmbracoWillObsolete("This cache key is only used for legacy business logic caching, remove in v8")]
        public const string ContentTypeCacheKey = "UmbracoContentType";

+        [UmbracoWillObsolete("This cache key is only used for legacy business logic caching, remove in v8")]
        public const string ContentTypePropertiesCacheKey = "ContentType_PropertyTypes_Content:";
        
+        [UmbracoWillObsolete("This cache key is only used for legacy business logic caching, remove in v8")]
        public const string PropertyTypeCacheKey = "UmbracoPropertyTypeCache";

        [Obsolete("This is no longer used and will be removed from the codebase in the future")]
+        [EditorBrowsable(EditorBrowsableState.Never)]
        public const string LanguageCacheKey = "UmbracoLanguageCache";

        [Obsolete("This is no longer used and will be removed from the codebase in the future")]
+        [EditorBrowsable(EditorBrowsableState.Never)]
        public const string DomainCacheKey = "UmbracoDomainList";

        [Obsolete("This is no longer used and will be removed from the codebase in the future")]
+        [EditorBrowsable(EditorBrowsableState.Never)]
        public const string StylesheetCacheKey = "UmbracoStylesheet";
+
        [Obsolete("This is no longer used and will be removed from the codebase in the future")]
+        [EditorBrowsable(EditorBrowsableState.Never)]
        public const string StylesheetPropertyCacheKey = "UmbracoStylesheetProperty";

+        [Obsolete("This is no longer used and will be removed from the codebase in the future")]
+        [EditorBrowsable(EditorBrowsableState.Never)]
        public const string DataTypeCacheKey = "UmbracoDataTypeDefinition";
        public const string DataTypePreValuesCacheKey = "UmbracoPreVal";

@@ -2,6 +2,7 @@
 using Umbraco.Core.Events;
 using Umbraco.Core.Sync;
 using umbraco.interfaces;
+using Umbraco.Core.Models.EntityBase;

 namespace Umbraco.Core.Cache
 {
@@ -63,5 +64,15 @@ namespace Umbraco.Core.Cache
        {
            OnCacheUpdated(Instance, new CacheRefresherEventArgs(id, MessageType.RefreshById));
        }
+
+        /// <summary>
+        /// Clears the cache for all repository entities of this type
+        /// </summary>
+        /// <typeparam name="TEntity"></typeparam>
+        internal void ClearAllIsolatedCacheByEntityType<TEntity>()
+            where TEntity : class, IAggregateRoot
+        {
+            ApplicationContext.Current.ApplicationCache.IsolatedRuntimeCache.ClearCache<TEntity>();
+        }
    }
 }
@@ -2,11 +2,10 @@ using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Web.Caching;
-using Umbraco.Core.Cache;
 using Umbraco.Core.Models;
 using Umbraco.Core.Models.EntityBase;

-namespace Umbraco.Core.Persistence.Repositories
+namespace Umbraco.Core.Cache
 {
    /// <summary>
    /// A wrapper for any IRuntimeCacheProvider that ensures that all inserts and returns 
@@ -0,0 +1,266 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Umbraco.Core.Logging;
+using Umbraco.Core.Models.EntityBase;
+
+namespace Umbraco.Core.Cache
+{
+    /// <summary>
+    /// The default cache policy for retrieving a single entity
+    /// </summary>
+    /// <typeparam name="TEntity"></typeparam>
+    /// <typeparam name="TId"></typeparam>
+    internal class DefaultRepositoryCachePolicy<TEntity, TId> : DisposableObject, IRepositoryCachePolicy<TEntity, TId>
+        where TEntity : class, IAggregateRoot
+    {
+        private readonly RepositoryCachePolicyOptions _options;
+        protected IRuntimeCacheProvider Cache { get; private set; }
+        private Action _action;
+       
+        public DefaultRepositoryCachePolicy(IRuntimeCacheProvider cache, RepositoryCachePolicyOptions options)
+        {
+            if (cache == null) throw new ArgumentNullException("cache");
+            if (options == null) throw new ArgumentNullException("options");
+
+            _options = options;
+            Cache = cache;
+        }
+
+        public string GetCacheIdKey(object id)
+        {
+            if (id == null) throw new ArgumentNullException("id");
+
+            return string.Format("{0}{1}", GetCacheTypeKey(), id);
+        }
+
+        public string GetCacheTypeKey()
+        {
+            return string.Format("uRepo_{0}_", typeof(TEntity).Name);
+        }
+
+        public void CreateOrUpdate(TEntity entity, Action<TEntity> persistMethod)
+        {
+            if (entity == null) throw new ArgumentNullException("entity");
+            if (persistMethod == null) throw new ArgumentNullException("persistMethod");
+
+            try
+            {
+                persistMethod(entity);
+
+                //set the disposal action                
+                SetCacheAction(() =>
+                {
+                    //just to be safe, we cannot cache an item without an identity
+                    if (entity.HasIdentity)
+                    {
+                        Cache.InsertCacheItem(GetCacheIdKey(entity.Id), () => entity);
+                    }
+                    
+                    //If there's a GetAllCacheAllowZeroCount cache, ensure it is cleared
+                    Cache.ClearCacheItem(GetCacheTypeKey());
+                });
+                
+            }
+            catch
+            {
+                //set the disposal action                
+                SetCacheAction(() =>
+                {
+                    //if an exception is thrown we need to remove the entry from cache, this is ONLY a work around because of the way
+                    // that we cache entities: http://issues.umbraco.org/issue/U4-4259
+                    Cache.ClearCacheItem(GetCacheIdKey(entity.Id));
+
+                    //If there's a GetAllCacheAllowZeroCount cache, ensure it is cleared
+                    Cache.ClearCacheItem(GetCacheTypeKey());
+                });
+                
+                throw;
+            }
+        }
+
+        public void Remove(TEntity entity, Action<TEntity> persistMethod)
+        {
+            if (entity == null) throw new ArgumentNullException("entity");
+            if (persistMethod == null) throw new ArgumentNullException("persistMethod");
+
+            persistMethod(entity);
+
+            //set the disposal action
+            var cacheKey = GetCacheIdKey(entity.Id);
+            SetCacheAction(() =>
+            {
+                Cache.ClearCacheItem(cacheKey);
+                //If there's a GetAllCacheAllowZeroCount cache, ensure it is cleared
+                Cache.ClearCacheItem(GetCacheTypeKey());
+            });            
+        }
+
+        public TEntity Get(TId id, Func<TId, TEntity> getFromRepo)
+        {
+            if (getFromRepo == null) throw new ArgumentNullException("getFromRepo");
+
+            var cacheKey = GetCacheIdKey(id);
+            var fromCache = Cache.GetCacheItem<TEntity>(cacheKey);
+            if (fromCache != null)
+                return fromCache;
+            
+            var entity = getFromRepo(id);
+
+            //set the disposal action
+            SetCacheAction(cacheKey, entity);
+
+            return entity;
+        }
+
+        public TEntity Get(TId id)
+        {
+            var cacheKey = GetCacheIdKey(id);
+            return Cache.GetCacheItem<TEntity>(cacheKey);
+        }
+
+        public bool Exists(TId id, Func<TId, bool> getFromRepo)
+        {
+            if (getFromRepo == null) throw new ArgumentNullException("getFromRepo");
+
+            var cacheKey = GetCacheIdKey(id);
+            var fromCache = Cache.GetCacheItem<TEntity>(cacheKey);
+            return fromCache != null || getFromRepo(id);
+        }
+
+        public virtual TEntity[] GetAll(TId[] ids, Func<TId[], IEnumerable<TEntity>> getFromRepo)            
+        {
+            if (getFromRepo == null) throw new ArgumentNullException("getFromRepo");
+
+            if (ids.Any())
+            {
+                var entities = ids.Select(Get).ToArray();
+                if (ids.Length.Equals(entities.Length) && entities.Any(x => x == null) == false)
+                    return entities;
+            }
+            else
+            {
+                var allEntities = GetAllFromCache();
+                if (allEntities.Any())
+                {
+                    if (_options.GetAllCacheValidateCount)
+                    {
+                        //Get count of all entities of current type (TEntity) to ensure cached result is correct
+                        var totalCount = _options.PerformCount();
+                        if (allEntities.Length == totalCount)
+                            return allEntities;
+                    }
+                    else
+                    {
+                        return allEntities;
+                    }
+                }
+                else if (_options.GetAllCacheAllowZeroCount)
+                {
+                    //if the repository allows caching a zero count, then check the zero count cache
+                    var zeroCount = Cache.GetCacheItem<TEntity[]>(GetCacheTypeKey());
+                    if (zeroCount != null && zeroCount.Any() == false)
+                    {
+                        //there is a zero count cache so return an empty list
+                        return new TEntity[] {};
+                    }
+                }
+            }
+
+            //we need to do the lookup from the repo
+            var entityCollection = getFromRepo(ids)
+                //ensure we don't include any null refs in the returned collection!
+                .WhereNotNull()
+                .ToArray();
+
+            //set the disposal action
+            SetCacheAction(ids, entityCollection);
+
+            return entityCollection;
+        }
+
+        /// <summary>
+        /// Performs the lookup for all entities of this type from the cache
+        /// </summary>
+        /// <returns></returns>
+        protected virtual TEntity[] GetAllFromCache()
+        {
+            var allEntities = Cache.GetCacheItemsByKeySearch<TEntity>(GetCacheTypeKey())
+                    .WhereNotNull()
+                    .ToArray();
+            return allEntities.Any() ? allEntities : new TEntity[] {};
+        }
+
+        /// <summary>
+        /// The disposal performs the caching
+        /// </summary>
+        protected override void DisposeResources()
+        {
+            if (_action != null)
+            {
+                _action();
+            }
+        }
+
+        /// <summary>
+        /// Sets the action to execute on disposal for a single entity
+        /// </summary>
+        /// <param name="cacheKey"></param>
+        /// <param name="entity"></param>
+        protected virtual void SetCacheAction(string cacheKey, TEntity entity)
+        {
+            if (entity == null) return;
+
+            SetCacheAction(() =>
+            {
+                //just to be safe, we cannot cache an item without an identity
+                if (entity.HasIdentity)
+                {
+                    Cache.InsertCacheItem(cacheKey, () => entity);
+                }
+            });
+        }
+
+        /// <summary>
+        /// Sets the action to execute on disposal for an entity collection
+        /// </summary>
+        /// <param name="ids"></param>
+        /// <param name="entityCollection"></param>
+        protected virtual void SetCacheAction(TId[] ids, TEntity[] entityCollection)
+        {
+            SetCacheAction(() =>
+            {
+                //This option cannot execute if we are looking up specific Ids
+                if (ids.Any() == false && entityCollection.Length == 0 && _options.GetAllCacheAllowZeroCount)
+                {
+                    //there was nothing returned but we want to cache a zero count result so add an TEntity[] to the cache
+                    // to signify that there is a zero count cache
+                    Cache.InsertCacheItem(GetCacheTypeKey(), () => new TEntity[] {});
+                }
+                else
+                {
+                    //This is the default behavior, we'll individually cache each item so that if/when these items are resolved 
+                    // by id, they are returned from the already existing cache.
+                    foreach (var entity in entityCollection.WhereNotNull())
+                    {
+                        var localCopy = entity;
+                        //just to be safe, we cannot cache an item without an identity
+                        if (localCopy.HasIdentity)
+                        {
+                            Cache.InsertCacheItem(GetCacheIdKey(entity.Id), () => localCopy);
+                        }
+                    }
+                }
+            });
+        }
+
+        /// <summary>
+        /// Sets the action to execute on disposal
+        /// </summary>
+        /// <param name="action"></param>
+        protected void SetCacheAction(Action action)
+        {
+            _action = action;
+        }
+    }
+}
@@ -0,0 +1,27 @@
+using Umbraco.Core.Models.EntityBase;
+
+namespace Umbraco.Core.Cache
+{
+    /// <summary>
+    /// Creates cache policies
+    /// </summary>
+    /// <typeparam name="TEntity"></typeparam>
+    /// <typeparam name="TId"></typeparam>
+    internal class DefaultRepositoryCachePolicyFactory<TEntity, TId> : IRepositoryCachePolicyFactory<TEntity, TId>
+        where TEntity : class, IAggregateRoot
+    {
+        private readonly IRuntimeCacheProvider _runtimeCache;
+        private readonly RepositoryCachePolicyOptions _options;
+
+        public DefaultRepositoryCachePolicyFactory(IRuntimeCacheProvider runtimeCache, RepositoryCachePolicyOptions options)
+        {
+            _runtimeCache = runtimeCache;
+            _options = options;
+        }
+
+        public virtual IRepositoryCachePolicy<TEntity, TId> CreatePolicy()
+        {
+            return new DefaultRepositoryCachePolicy<TEntity, TId>(_runtimeCache, _options);
+        }
+    }
+}
@@ -0,0 +1,57 @@
+using System.Linq;
+using Umbraco.Core.Collections;
+using Umbraco.Core.Models.EntityBase;
+
+namespace Umbraco.Core.Cache
+{
+    /// <summary>
+    /// A caching policy that caches an entire dataset as a single collection
+    /// </summary>
+    /// <typeparam name="TEntity"></typeparam>
+    /// <typeparam name="TId"></typeparam>
+    internal class FullDataSetRepositoryCachePolicy<TEntity, TId> : DefaultRepositoryCachePolicy<TEntity, TId>
+        where TEntity : class, IAggregateRoot
+    {
+        public FullDataSetRepositoryCachePolicy(IRuntimeCacheProvider cache) : base(cache, new RepositoryCachePolicyOptions())
+        {
+        }
+
+        /// <summary>
+        /// For this type of caching policy, we don't cache individual items
+        /// </summary>
+        /// <param name="cacheKey"></param>
+        /// <param name="entity"></param>
+        protected override void SetCacheAction(string cacheKey, TEntity entity)
+        {
+            //do nothing
+        }
+
+        /// <summary>
+        /// Sets the action to execute on disposal for an entity collection
+        /// </summary>
+        /// <param name="ids"></param>
+        /// <param name="entityCollection"></param>
+        protected override void SetCacheAction(TId[] ids, TEntity[] entityCollection)
+        {
+            //for this type of caching policy, we don't want to cache any GetAll request containing specific Ids
+            if (ids.Any()) return;
+
+            //set the disposal action
+            SetCacheAction(() =>
+            {
+                //We want to cache the result as a single collection
+                Cache.InsertCacheItem(GetCacheTypeKey(), () => new DeepCloneableList<TEntity>(entityCollection));
+            });
+        }
+
+        /// <summary>
+        /// This policy will cache the full data set as a single collection
+        /// </summary>
+        /// <returns></returns>
+        protected override TEntity[] GetAllFromCache()
+        {
+            var found = Cache.GetCacheItem<DeepCloneableList<TEntity>>(GetCacheTypeKey());
+            return found == null ? new TEntity[] { } : found.WhereNotNull().ToArray();
+        }
+    }
+}
@@ -0,0 +1,25 @@
+using Umbraco.Core.Models.EntityBase;
+
+namespace Umbraco.Core.Cache
+{
+    /// <summary>
+    /// Creates cache policies
+    /// </summary>
+    /// <typeparam name="TEntity"></typeparam>
+    /// <typeparam name="TId"></typeparam>
+    internal class FullDataSetRepositoryCachePolicyFactory<TEntity, TId> : IRepositoryCachePolicyFactory<TEntity, TId>
+        where TEntity : class, IAggregateRoot
+    {
+        private readonly IRuntimeCacheProvider _runtimeCache;
+        
+        public FullDataSetRepositoryCachePolicyFactory(IRuntimeCacheProvider runtimeCache)
+        {
+            _runtimeCache = runtimeCache;
+        }
+
+        public virtual IRepositoryCachePolicy<TEntity, TId> CreatePolicy()
+        {
+            return new FullDataSetRepositoryCachePolicy<TEntity, TId>(_runtimeCache);
+        }
+    }
+}
@@ -0,0 +1,20 @@
+using System;
+using System.Collections.Generic;
+using Umbraco.Core.Models.EntityBase;
+
+namespace Umbraco.Core.Cache
+{
+    internal interface IRepositoryCachePolicy<TEntity, TId> : IDisposable
+        where TEntity : class, IAggregateRoot
+    {
+        TEntity Get(TId id, Func<TId, TEntity> getFromRepo);
+        TEntity Get(TId id);
+        bool Exists(TId id, Func<TId, bool> getFromRepo);
+
+        string GetCacheIdKey(object id);
+        string GetCacheTypeKey();
+        void CreateOrUpdate(TEntity entity, Action<TEntity> persistMethod);
+        void Remove(TEntity entity, Action<TEntity> persistMethod);
+        TEntity[] GetAll(TId[] ids, Func<TId[], IEnumerable<TEntity>> getFromRepo);
+    }
+}
@@ -0,0 +1,9 @@
+using Umbraco.Core.Models.EntityBase;
+
+namespace Umbraco.Core.Cache
+{
+    internal interface IRepositoryCachePolicyFactory<TEntity, TId> where TEntity : class, IAggregateRoot
+    {
+        IRepositoryCachePolicy<TEntity, TId> CreatePolicy();
+    }
+}
@@ -0,0 +1,91 @@
+using System;
+using System.Collections.Concurrent;
+
+namespace Umbraco.Core.Cache
+{
+    /// <summary>
+    /// Used to get/create/manipulate isolated runtime cache
+    /// </summary>
+    /// <remarks>
+    /// This is useful for repository level caches to ensure that cache lookups by key are fast so 
+    /// that the repository doesn't need to search through all keys on a global scale.
+    /// </remarks>
+    public class IsolatedRuntimeCache
+    {
+        private readonly Func<Type, IRuntimeCacheProvider> _cacheFactory;
+
+        /// <summary>
+        /// Constructor that allows specifying a factory for the type of runtime isolated cache to create
+        /// </summary>
+        /// <param name="cacheFactory"></param>
+        public IsolatedRuntimeCache(Func<Type, IRuntimeCacheProvider> cacheFactory)
+        {
+            _cacheFactory = cacheFactory;
+        }
+
+        private readonly ConcurrentDictionary<Type, IRuntimeCacheProvider> _isolatedCache = new ConcurrentDictionary<Type, IRuntimeCacheProvider>();
+
+        /// <summary>
+        /// Returns an isolated runtime cache for a given type
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <returns></returns>        
+        public IRuntimeCacheProvider GetOrCreateCache<T>()
+        {
+            return _isolatedCache.GetOrAdd(typeof(T), type => _cacheFactory(type));
+        }
+
+        /// <summary>
+        /// Returns an isolated runtime cache for a given type
+        /// </summary>
+        /// <returns></returns>        
+        public IRuntimeCacheProvider GetOrCreateCache(Type type)
+        {
+            return _isolatedCache.GetOrAdd(type, t => _cacheFactory(t));
+        }
+
+        /// <summary>
+        /// Tries to get a cache by the type specified
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <returns></returns>
+        public Attempt<IRuntimeCacheProvider> GetCache<T>()
+        {
+            IRuntimeCacheProvider cache;
+            if (_isolatedCache.TryGetValue(typeof(T), out cache))
+            {
+                return Attempt.Succeed(cache);
+            }
+            return Attempt<IRuntimeCacheProvider>.Fail();
+        }
+
+        /// <summary>
+        /// Clears all values inside this isolated runtime cache
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <returns></returns>
+        public void ClearCache<T>()
+        {
+            IRuntimeCacheProvider cache;
+            if (_isolatedCache.TryGetValue(typeof(T), out cache))
+            {
+                cache.ClearAllCache();
+            }
+        }
+
+        /// <summary>
+        /// Clears all of the isolated caches
+        /// </summary>
+        public void ClearAllCaches()
+        {
+            foreach (var key in _isolatedCache.Keys)
+            {
+                IRuntimeCacheProvider cache;
+                if (_isolatedCache.TryRemove(key, out cache))
+                {
+                    cache.ClearAllCache();
+                }
+            }
+        }
+    }
+}
@@ -0,0 +1,27 @@
+using Umbraco.Core.Models.EntityBase;
+
+namespace Umbraco.Core.Cache
+{
+    /// <summary>
+    /// Creates cache policies
+    /// </summary>
+    /// <typeparam name="TEntity"></typeparam>
+    /// <typeparam name="TId"></typeparam>
+    internal class OnlySingleItemsRepositoryCachePolicyFactory<TEntity, TId> : IRepositoryCachePolicyFactory<TEntity, TId>
+        where TEntity : class, IAggregateRoot
+    {
+        private readonly IRuntimeCacheProvider _runtimeCache;
+        private readonly RepositoryCachePolicyOptions _options;
+
+        public OnlySingleItemsRepositoryCachePolicyFactory(IRuntimeCacheProvider runtimeCache, RepositoryCachePolicyOptions options)
+        {
+            _runtimeCache = runtimeCache;
+            _options = options;
+        }
+
+        public virtual IRepositoryCachePolicy<TEntity, TId> CreatePolicy()
+        {
+            return new SingleItemsOnlyRepositoryCachePolicy<TEntity, TId>(_runtimeCache, _options);
+        }
+    }
+}
@@ -1,17 +1,34 @@
-namespace Umbraco.Core.Persistence.Repositories
+using System;
+
+namespace Umbraco.Core.Cache
 {
-    internal class RepositoryCacheOptions
+    internal class RepositoryCachePolicyOptions
    {
        /// <summary>
-        /// Constructor sets defaults
+        /// Ctor - sets GetAllCacheValidateCount = true
        /// </summary>
-        public RepositoryCacheOptions()
+        public RepositoryCachePolicyOptions(Func<int> performCount)
        {
+            PerformCount = performCount;
            GetAllCacheValidateCount = true;
            GetAllCacheAllowZeroCount = false;
-            GetAllCacheThresholdLimit = 100;
        }

+        /// <summary>
+        /// Ctor - sets GetAllCacheValidateCount = false
+        /// </summary>
+        public RepositoryCachePolicyOptions()
+        {
+            PerformCount = null;
+            GetAllCacheValidateCount = false;
+            GetAllCacheAllowZeroCount = false;
+        }
+
+        /// <summary>
+        /// Callback required to get count for GetAllCacheValidateCount
+        /// </summary>
+        public Func<int> PerformCount { get; private set; }
+
        /// <summary>
        /// True/false as to validate the total item count when all items are returned from cache, the default is true but this
        /// means that a db lookup will occur - though that lookup will probably be significantly less expensive than the normal 
@@ -21,16 +38,11 @@ namespace Umbraco.Core.Persistence.Repositories
        /// setting this to return false will improve performance of GetAll cache with no params but should only be used
        /// for specific circumstances
        /// </remarks>
-        public bool GetAllCacheValidateCount { get; set; }
+        public bool GetAllCacheValidateCount { get; private set; }

        /// <summary>
        /// True if the GetAll method will cache that there are zero results so that the db is not hit when there are no results found
        /// </summary>
        public bool GetAllCacheAllowZeroCount { get; set; }
-
-        /// <summary>
-        /// The threshold entity count for which the GetAll method will cache entities
-        /// </summary>
-        public int GetAllCacheThresholdLimit { get; set; }
    }
 }
@@ -0,0 +1,24 @@
+using System.Linq;
+using Umbraco.Core.Collections;
+using Umbraco.Core.Models.EntityBase;
+
+namespace Umbraco.Core.Cache
+{
+    /// <summary>
+    /// A caching policy that ignores all caches for GetAll - it will only cache calls for individual items
+    /// </summary>
+    /// <typeparam name="TEntity"></typeparam>
+    /// <typeparam name="TId"></typeparam>
+    internal class SingleItemsOnlyRepositoryCachePolicy<TEntity, TId> : DefaultRepositoryCachePolicy<TEntity, TId>
+        where TEntity : class, IAggregateRoot
+    {
+        public SingleItemsOnlyRepositoryCachePolicy(IRuntimeCacheProvider cache, RepositoryCachePolicyOptions options) : base(cache, options)
+        {
+        }
+        
+        protected override void SetCacheAction(TId[] ids, TEntity[] entityCollection)
+        {            
+            //do nothing
+        }
+    }
+}
@@ -1,6 +1,8 @@
 using System;
 using System.Collections;
+using System.Collections.Concurrent;
 using System.Collections.Generic;
+using System.ComponentModel;
 using System.Linq;
 using System.Text;
 using System.Text.RegularExpressions;
@@ -11,20 +13,19 @@ using Umbraco.Core.Logging;

 namespace Umbraco.Core
 {
-
 	/// <summary>
 	/// Class that is exposed by the ApplicationContext for application wide caching purposes
 	/// </summary>
    public class CacheHelper
 	{
-	    private readonly bool _enableCache;
+	    private readonly IsolatedRuntimeCache _isolatedCacheManager;
 	    private readonly ICacheProvider _requestCache;
-        private readonly ICacheProvider _nullRequestCache = new NullCacheProvider();
+        private static readonly ICacheProvider NullRequestCache = new NullCacheProvider();
        private readonly ICacheProvider _staticCache;
-        private readonly ICacheProvider _nullStaticCache = new NullCacheProvider();
-        private readonly IRuntimeCacheProvider _httpCache;
-        private readonly IRuntimeCacheProvider _nullHttpCache = new NullCacheProvider();
-
+        private static readonly ICacheProvider NullStaticCache = new NullCacheProvider();
+        private readonly IRuntimeCacheProvider _runtimeCache;
+        private static readonly IRuntimeCacheProvider NullRuntimeCache = new NullCacheProvider();
+        
        /// <summary>
        /// Creates a cache helper with disabled caches
        /// </summary>
@@ -34,7 +35,7 @@ namespace Umbraco.Core
        /// </remarks>
        public static CacheHelper CreateDisabledCacheHelper()
        {
-            return new CacheHelper(null, null, null, false);
+            return new CacheHelper(NullRuntimeCache, NullStaticCache, NullRequestCache, new IsolatedRuntimeCache(t => NullRuntimeCache));
        }

 	    /// <summary>
@@ -44,7 +45,8 @@ namespace Umbraco.Core
 	        : this(
 	            new HttpRuntimeCacheProvider(HttpRuntime.Cache),
 	            new StaticCacheProvider(),
-                new HttpRequestCacheProvider())
+                new HttpRequestCacheProvider(),
+                new IsolatedRuntimeCache(t => new ObjectCacheRuntimeCacheProvider()))
 	    {
 	    }

@@ -56,51 +58,42 @@ namespace Umbraco.Core
 	        : this(
 	            new HttpRuntimeCacheProvider(cache),
 	            new StaticCacheProvider(),
-                new HttpRequestCacheProvider())
+                new HttpRequestCacheProvider(),
+                new IsolatedRuntimeCache(t => new ObjectCacheRuntimeCacheProvider()))
 	    {
 	    }

-	    /// <summary>
-        /// Initializes a new instance based on the provided providers
-        /// </summary>
-        /// <param name="httpCacheProvider"></param>
-        /// <param name="staticCacheProvider"></param>
-        /// <param name="requestCacheProvider"></param>
+	    [Obsolete("Use the constructor the specifies all dependencies")]
+        [EditorBrowsable(EditorBrowsableState.Never)]
        public CacheHelper(
            IRuntimeCacheProvider httpCacheProvider, 
            ICacheProvider staticCacheProvider, 
            ICacheProvider requestCacheProvider)
-            : this(httpCacheProvider, staticCacheProvider, requestCacheProvider, true)
+            : this(httpCacheProvider, staticCacheProvider, requestCacheProvider, new IsolatedRuntimeCache(t => new ObjectCacheRuntimeCacheProvider()))
        {            
        }

-        /// <summary>
-        /// Private ctor used for creating a disabled cache helper
-        /// </summary>
-        /// <param name="httpCacheProvider"></param>
-        /// <param name="staticCacheProvider"></param>
-        /// <param name="requestCacheProvider"></param>
-        /// <param name="enableCache"></param>
-        private CacheHelper(
+	    /// <summary>
+	    /// Initializes a new instance based on the provided providers
+	    /// </summary>
+	    /// <param name="httpCacheProvider"></param>
+	    /// <param name="staticCacheProvider"></param>
+	    /// <param name="requestCacheProvider"></param>
+	    /// <param name="isolatedCacheManager"></param>
+	    public CacheHelper(
            IRuntimeCacheProvider httpCacheProvider,
            ICacheProvider staticCacheProvider,
-            ICacheProvider requestCacheProvider, 
-            bool enableCache)
+            ICacheProvider requestCacheProvider,
+            IsolatedRuntimeCache isolatedCacheManager)            
        {
-            if (enableCache)
-            {
-                _httpCache = httpCacheProvider;
-                _staticCache = staticCacheProvider;
-                _requestCache = requestCacheProvider;
-            }
-            else
-            {
-                _httpCache = null;
-                _staticCache = null;
-                _requestCache = null;
-            }
-
-            _enableCache = enableCache;
+	        if (httpCacheProvider == null) throw new ArgumentNullException("httpCacheProvider");
+	        if (staticCacheProvider == null) throw new ArgumentNullException("staticCacheProvider");
+	        if (requestCacheProvider == null) throw new ArgumentNullException("requestCacheProvider");
+	        if (isolatedCacheManager == null) throw new ArgumentNullException("isolatedCacheManager");
+	        _runtimeCache = httpCacheProvider;
+            _staticCache = staticCacheProvider;
+            _requestCache = requestCacheProvider;
+            _isolatedCacheManager = isolatedCacheManager;
        }

        /// <summary>
@@ -108,15 +101,15 @@ namespace Umbraco.Core
        /// </summary>
        public ICacheProvider RequestCache
        {
-            get { return _enableCache ? _requestCache : _nullRequestCache; }
+            get { return _requestCache; }
        }
-
+        
        /// <summary>
        /// Returns the current Runtime cache
        /// </summary>
        public ICacheProvider StaticCache
        {
-            get { return _enableCache ? _staticCache : _nullStaticCache; }
+            get { return _staticCache; }
        }

        /// <summary>
@@ -124,8 +117,16 @@ namespace Umbraco.Core
        /// </summary>
 	    public IRuntimeCacheProvider RuntimeCache
 	    {
-	        get { return _enableCache ? _httpCache : _nullHttpCache; }
+	        get { return _runtimeCache; }
 	    }
+
+        /// <summary>
+        /// Returns the current Isolated Runtime cache manager
+        /// </summary>
+        public IsolatedRuntimeCache IsolatedRuntimeCache
+        {
+            get { return _isolatedCacheManager; }
+        }
        
 	    #region Legacy Runtime/Http Cache accessors

@@ -133,16 +134,11 @@ namespace Umbraco.Core
        /// Clears the item in umbraco's runtime cache
        /// </summary>
        [Obsolete("Do not use this method, access the runtime cache from the RuntimeCache property")]
+        [EditorBrowsable(EditorBrowsableState.Never)]
        public void ClearAllCache()
        {
-            if (_enableCache == false)
-            {
-                _nullHttpCache.ClearAllCache();
-            }
-            else
-            {
-                _httpCache.ClearAllCache();
-            }
+            _runtimeCache.ClearAllCache();
+            _isolatedCacheManager.ClearAllCaches();
        }

        /// <summary>
@@ -150,16 +146,10 @@ namespace Umbraco.Core
        /// </summary>
        /// <param name="key">Key</param>
        [Obsolete("Do not use this method, access the runtime cache from the RuntimeCache property")]
+        [EditorBrowsable(EditorBrowsableState.Never)]
        public void ClearCacheItem(string key)
        {
-            if (_enableCache == false)
-            {
-                _nullHttpCache.ClearCacheItem(key);
-            }
-            else
-            {
-                _httpCache.ClearCacheItem(key);
-            }
+            _runtimeCache.ClearCacheItem(key);
        }


@@ -171,30 +161,17 @@ namespace Umbraco.Core
        [Obsolete("Do not use this method, access the runtime cache from the RuntimeCache property")]
        public void ClearCacheObjectTypes(string typeName)
        {
-            if (_enableCache == false)
-            {
-                _nullHttpCache.ClearCacheObjectTypes(typeName);
-            }
-            else
-            {
-                _httpCache.ClearCacheObjectTypes(typeName);
-            }
+            _runtimeCache.ClearCacheObjectTypes(typeName);
        }

        /// <summary>
        /// Clears all objects in the System.Web.Cache with the System.Type specified
        /// </summary>
        [Obsolete("Do not use this method, access the runtime cache from the RuntimeCache property")]
+        [EditorBrowsable(EditorBrowsableState.Never)]
        public void ClearCacheObjectTypes<T>()
        {
-            if (_enableCache == false)
-            {
-                _nullHttpCache.ClearCacheObjectTypes<T>();
-            }
-            else
-            {
-                _httpCache.ClearCacheObjectTypes<T>();
-            }
+            _runtimeCache.ClearCacheObjectTypes<T>();
        }

        /// <summary>
@@ -202,16 +179,10 @@ namespace Umbraco.Core
        /// </summary>
        /// <param name="keyStartsWith">The start of the key</param>
        [Obsolete("Do not use this method, access the runtime cache from the RuntimeCache property")]
+        [EditorBrowsable(EditorBrowsableState.Never)]
        public void ClearCacheByKeySearch(string keyStartsWith)
        {
-            if (_enableCache == false)
-            {
-                _nullHttpCache.ClearCacheByKeySearch(keyStartsWith);
-            }
-            else
-            {
-                _httpCache.ClearCacheByKeySearch(keyStartsWith);
-            }
+            _runtimeCache.ClearCacheByKeySearch(keyStartsWith);
        }

        /// <summary>
@@ -219,29 +190,17 @@ namespace Umbraco.Core
        /// </summary>
        /// <param name="regexString"></param>
        [Obsolete("Do not use this method, access the runtime cache from the RuntimeCache property")]
+        [EditorBrowsable(EditorBrowsableState.Never)]
        public void ClearCacheByKeyExpression(string regexString)
        {
-            if (_enableCache == false)
-            {
-                _nullHttpCache.ClearCacheByKeyExpression(regexString);
-            }
-            else
-            {
-                _httpCache.ClearCacheByKeyExpression(regexString);
-            }
+            _runtimeCache.ClearCacheByKeyExpression(regexString);
        }

        [Obsolete("Do not use this method, access the runtime cache from the RuntimeCache property")]
+        [EditorBrowsable(EditorBrowsableState.Never)]
        public IEnumerable<T> GetCacheItemsByKeySearch<T>(string keyStartsWith)
        {
-            if (_enableCache == false)
-            {
-                return _nullHttpCache.GetCacheItemsByKeySearch<T>(keyStartsWith);
-            }
-            else
-            {
-                return _httpCache.GetCacheItemsByKeySearch<T>(keyStartsWith);
-            }
+            return _runtimeCache.GetCacheItemsByKeySearch<T>(keyStartsWith);
        }

        /// <summary>
@@ -251,16 +210,10 @@ namespace Umbraco.Core
        /// <param name="cacheKey"></param>
        /// <returns></returns>
        [Obsolete("Do not use this method, access the runtime cache from the RuntimeCache property")]
+        [EditorBrowsable(EditorBrowsableState.Never)]
        public TT GetCacheItem<TT>(string cacheKey)
        {
-            if (_enableCache == false)
-            {
-                return _nullHttpCache.GetCacheItem<TT>(cacheKey);
-            }
-            else
-            {
-                return _httpCache.GetCacheItem<TT>(cacheKey);
-            }
+            return _runtimeCache.GetCacheItem<TT>(cacheKey);
        }

        /// <summary>
@@ -271,16 +224,11 @@ namespace Umbraco.Core
        /// <param name="getCacheItem"></param>
        /// <returns></returns>
        [Obsolete("Do not use this method, access the runtime cache from the RuntimeCache property")]
+        [EditorBrowsable(EditorBrowsableState.Never)]
        public TT GetCacheItem<TT>(string cacheKey, Func<TT> getCacheItem)
        {
-            if (_enableCache == false)
-            {
-                return _nullHttpCache.GetCacheItem<TT>(cacheKey, getCacheItem);
-            }
-            else
-            {
-                return _httpCache.GetCacheItem<TT>(cacheKey, getCacheItem);
-            }
+            return _runtimeCache.GetCacheItem<TT>(cacheKey, getCacheItem);
+
        }

        /// <summary>
@@ -292,17 +240,12 @@ namespace Umbraco.Core
        /// <param name="getCacheItem"></param>
        /// <returns></returns>
        [Obsolete("Do not use this method, access the runtime cache from the RuntimeCache property")]
+        [EditorBrowsable(EditorBrowsableState.Never)]
        public TT GetCacheItem<TT>(string cacheKey,
            TimeSpan timeout, Func<TT> getCacheItem)
        {
-            if (_enableCache == false)
-            {
-                return _nullHttpCache.GetCacheItem<TT>(cacheKey, getCacheItem, timeout);
-            }
-            else
-            {
-                return _httpCache.GetCacheItem<TT>(cacheKey, getCacheItem, timeout);
-            }
+            return _runtimeCache.GetCacheItem<TT>(cacheKey, getCacheItem, timeout);
+
        }

        /// <summary>
@@ -315,18 +258,13 @@ namespace Umbraco.Core
        /// <param name="getCacheItem"></param>
        /// <returns></returns>
        [Obsolete("Do not use this method, access the runtime cache from the RuntimeCache property")]
+        [EditorBrowsable(EditorBrowsableState.Never)]
        public TT GetCacheItem<TT>(string cacheKey,
            CacheItemRemovedCallback refreshAction, TimeSpan timeout,
            Func<TT> getCacheItem)
        {
-            if (!_enableCache)
-            {
-                return _nullHttpCache.GetCacheItem<TT>(cacheKey, getCacheItem, timeout, removedCallback: refreshAction);
-            }
-            else
-            {
-                return _httpCache.GetCacheItem<TT>(cacheKey, getCacheItem, timeout, removedCallback: refreshAction);
-            }
+            return _runtimeCache.GetCacheItem<TT>(cacheKey, getCacheItem, timeout, removedCallback: refreshAction);
+
        }

        /// <summary>
@@ -340,18 +278,13 @@ namespace Umbraco.Core
        /// <param name="getCacheItem"></param>
        /// <returns></returns>
        [Obsolete("Do not use this method, access the runtime cache from the RuntimeCache property")]
+        [EditorBrowsable(EditorBrowsableState.Never)]
        public TT GetCacheItem<TT>(string cacheKey,
            CacheItemPriority priority, CacheItemRemovedCallback refreshAction, TimeSpan timeout,
            Func<TT> getCacheItem)
        {
-            if (_enableCache == false)
-            {
-                return _nullHttpCache.GetCacheItem<TT>(cacheKey, getCacheItem, timeout, false, priority, refreshAction);
-            }
-            else
-            {
-                return _httpCache.GetCacheItem<TT>(cacheKey, getCacheItem, timeout, false, priority, refreshAction);
-            }
+            return _runtimeCache.GetCacheItem<TT>(cacheKey, getCacheItem, timeout, false, priority, refreshAction);
+
        }

        /// <summary>
@@ -373,20 +306,13 @@ namespace Umbraco.Core
            TimeSpan timeout,
            Func<TT> getCacheItem)
        {
-            if (_enableCache == false)
+            var cache = _runtimeCache as HttpRuntimeCacheProvider;
+            if (cache != null)
            {
-                return _nullHttpCache.GetCacheItem<TT>(cacheKey, getCacheItem, timeout, false, priority, refreshAction, null);
-            }
-            else
-            {
-                var cache = _httpCache as HttpRuntimeCacheProvider;
-                if (cache != null)
-                {
-                    var result = cache.GetCacheItem(cacheKey, () => getCacheItem(), timeout, false, priority, refreshAction, cacheDependency);
-                    return result == null ? default(TT) : result.TryConvertTo<TT>().Result;
-                }
-                throw new InvalidOperationException("Cannot use this obsoleted overload when the current provider is not of type " + typeof(HttpRuntimeCacheProvider));
+                var result = cache.GetCacheItem(cacheKey, () => getCacheItem(), timeout, false, priority, refreshAction, cacheDependency);
+                return result == null ? default(TT) : result.TryConvertTo<TT>().Result;
            }
+            throw new InvalidOperationException("Cannot use this obsoleted overload when the current provider is not of type " + typeof(HttpRuntimeCacheProvider));
        }

        /// <summary>
@@ -404,20 +330,13 @@ namespace Umbraco.Core
            CacheDependency cacheDependency,
            Func<TT> getCacheItem)
        {
-            if (!_enableCache)
+            var cache = _runtimeCache as HttpRuntimeCacheProvider;
+            if (cache != null)
            {
-                return _nullHttpCache.GetCacheItem<TT>(cacheKey, getCacheItem, null, false, priority, null, null);
-            }
-            else
-            {
-                var cache = _httpCache as HttpRuntimeCacheProvider;
-                if (cache != null)
-                {
-                    var result = cache.GetCacheItem(cacheKey, () => getCacheItem(), null, false, priority, null, cacheDependency);
-                    return result == null ? default(TT) : result.TryConvertTo<TT>().Result;
-                }
-                throw new InvalidOperationException("Cannot use this obsoleted overload when the current provider is not of type " + typeof(HttpRuntimeCacheProvider));
+                var result = cache.GetCacheItem(cacheKey, () => getCacheItem(), null, false, priority, null, cacheDependency);
+                return result == null ? default(TT) : result.TryConvertTo<TT>().Result;
            }
+            throw new InvalidOperationException("Cannot use this obsoleted overload when the current provider is not of type " + typeof(HttpRuntimeCacheProvider));
        }

        /// <summary>
@@ -427,18 +346,14 @@ namespace Umbraco.Core
        /// <param name="cacheKey"></param>
        /// <param name="priority"></param>
        /// <param name="getCacheItem"></param>
+        [Obsolete("Do not use this method, access the runtime cache from the RuntimeCache property")]
+        [EditorBrowsable(EditorBrowsableState.Never)]
        public void InsertCacheItem<T>(string cacheKey,
                                       CacheItemPriority priority,
                                       Func<T> getCacheItem)
        {
-            if (_enableCache == false)
-            {
-                _nullHttpCache.InsertCacheItem<T>(cacheKey, getCacheItem, priority: priority);
-            }
-            else
-            {
-                _httpCache.InsertCacheItem<T>(cacheKey, getCacheItem, priority: priority);
-            }
+            _runtimeCache.InsertCacheItem<T>(cacheKey, getCacheItem, priority: priority);
+
        }

        /// <summary>
@@ -449,19 +364,14 @@ namespace Umbraco.Core
        /// <param name="priority"></param>
        /// <param name="timeout">This will set an absolute expiration from now until the timeout</param>
        /// <param name="getCacheItem"></param>
+        [Obsolete("Do not use this method, access the runtime cache from the RuntimeCache property")]
+        [EditorBrowsable(EditorBrowsableState.Never)]
        public void InsertCacheItem<T>(string cacheKey,
                                       CacheItemPriority priority,
                                       TimeSpan timeout,
                                       Func<T> getCacheItem)
        {
-            if (_enableCache == false)
-            {
-                _nullHttpCache.InsertCacheItem<T>(cacheKey, getCacheItem, timeout, priority: priority);
-            }
-            else
-            {
-                _httpCache.InsertCacheItem<T>(cacheKey, getCacheItem, timeout, priority: priority);
-            }
+            _runtimeCache.InsertCacheItem<T>(cacheKey, getCacheItem, timeout, priority: priority);
        }

        /// <summary>
@@ -480,19 +390,12 @@ namespace Umbraco.Core
                                       TimeSpan timeout,
                                       Func<T> getCacheItem)
        {
-            if (_enableCache == false)
+            var cache = _runtimeCache as HttpRuntimeCacheProvider;
+            if (cache != null)
            {
-                _nullHttpCache.InsertCacheItem<T>(cacheKey, getCacheItem, timeout, priority: priority, dependentFiles:null);
-            }
-            else
-            {
-                var cache = _httpCache as HttpRuntimeCacheProvider;
-                if (cache != null)
-                {
-                    cache.InsertCacheItem(cacheKey, () => getCacheItem(), timeout, false, priority, null, cacheDependency);
-                }
-                throw new InvalidOperationException("Cannot use this obsoleted overload when the current provider is not of type " + typeof(HttpRuntimeCacheProvider));
+                cache.InsertCacheItem(cacheKey, () => getCacheItem(), timeout, false, priority, null, cacheDependency);
            }
+            throw new InvalidOperationException("Cannot use this obsoleted overload when the current provider is not of type " + typeof(HttpRuntimeCacheProvider));
        }

        /// <summary>
@@ -513,19 +416,12 @@ namespace Umbraco.Core
                                       TimeSpan? timeout,
                                       Func<T> getCacheItem)
        {
-            if (_enableCache == false)
+            var cache = _runtimeCache as HttpRuntimeCacheProvider;
+            if (cache != null)
            {
-                _nullHttpCache.InsertCacheItem<T>(cacheKey, getCacheItem, timeout, false, priority, refreshAction, null);
-            }
-            else
-            {
-                var cache = _httpCache as HttpRuntimeCacheProvider;
-                if (cache != null)
-                {
-                    cache.InsertCacheItem(cacheKey, () => getCacheItem(), timeout, false, priority, refreshAction, cacheDependency);
-                }
-                throw new InvalidOperationException("Cannot use this obsoleted overload when the current provider is not of type " + typeof(HttpRuntimeCacheProvider));
+                cache.InsertCacheItem(cacheKey, () => getCacheItem(), timeout, false, priority, refreshAction, cacheDependency);
            }
+            throw new InvalidOperationException("Cannot use this obsoleted overload when the current provider is not of type " + typeof(HttpRuntimeCacheProvider));
        } 
        #endregion

@@ -0,0 +1,108 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Umbraco.Core.Models;
+using Umbraco.Core.Models.EntityBase;
+
+namespace Umbraco.Core.Collections
+{
+    /// <summary>
+    /// A List that can be deep cloned with deep cloned elements and can reset the collection's items dirty flags
+    /// </summary>
+    /// <typeparam name="T"></typeparam>
+    internal class DeepCloneableList<T> : List<T>, IDeepCloneable, IRememberBeingDirty
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="T:System.Collections.Generic.List`1"/> class that is empty and has the default initial capacity.
+        /// </summary>
+        public DeepCloneableList()
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="T:System.Collections.Generic.List`1"/> class that contains elements copied from the specified collection and has sufficient capacity to accommodate the number of elements copied.
+        /// </summary>
+        /// <param name="collection">The collection whose elements are copied to the new list.</param><exception cref="T:System.ArgumentNullException"><paramref name="collection"/> is null.</exception>
+        public DeepCloneableList(IEnumerable<T> collection) : base(collection)
+        {
+        }
+
+        /// <summary>
+        /// Creates a new list and adds each element as a deep cloned element if it is of type IDeepCloneable
+        /// </summary>
+        /// <returns></returns>
+        public object DeepClone()
+        {
+            var newList = new DeepCloneableList<T>();
+            foreach (var item in this)
+            {
+                var dc = item as IDeepCloneable;
+                if (dc != null)
+                {
+                    newList.Add((T) dc.DeepClone());
+                }
+                else
+                {
+                    newList.Add(item);
+                }
+            }
+            return newList;
+        }
+
+        public bool IsDirty()
+        {
+            return this.OfType<IRememberBeingDirty>().Any(x => x.IsDirty());
+        }
+
+        public bool WasDirty()
+        {
+            return this.OfType<IRememberBeingDirty>().Any(x => x.WasDirty());
+        }
+
+        /// <summary>
+        /// Always returns false, the list has no properties we need to report
+        /// </summary>
+        /// <param name="propName"></param>
+        /// <returns></returns>
+        public bool IsPropertyDirty(string propName)
+        {
+            return false;
+        }
+
+        /// <summary>
+        /// Always returns false, the list has no properties we need to report
+        /// </summary>
+        /// <param name="propertyName"></param>
+        /// <returns></returns>
+        public bool WasPropertyDirty(string propertyName)
+        {
+            return false;
+        }
+
+        public void ResetDirtyProperties()
+        {
+            foreach (var dc in this.OfType<IRememberBeingDirty>())
+            {
+                dc.ResetDirtyProperties();
+            }
+        }
+
+        public void ForgetPreviouslyDirtyProperties()
+        {
+            foreach (var dc in this.OfType<IRememberBeingDirty>())
+            {
+                dc.ForgetPreviouslyDirtyProperties();
+            }
+        }
+
+        public void ResetDirtyProperties(bool rememberPreviouslyChangedProperties)
+        {
+            foreach (var dc in this.OfType<IRememberBeingDirty>())
+            {
+                dc.ResetDirtyProperties(rememberPreviouslyChangedProperties);
+            }
+        }
+    }
+}
@@ -280,6 +280,18 @@ namespace Umbraco.Core.Configuration.UmbracoSettings
            }
        }

+        [ConfigurationProperty("EnableInheritedDocumentTypes")]
+        internal InnerTextConfigurationElement<bool> EnableInheritedDocumentTypes
+        {
+            get
+            {
+                return new OptionalInnerTextConfigurationElement<bool>(
+                    (InnerTextConfigurationElement<bool>) this["EnableInheritedDocumentTypes"],
+                    //set the default
+                    true);
+            }
+        }
+        
        string IContentSection.NotificationEmailAddress
        {
            get { return Notifications.NotificationEmailAddress; }
@@ -414,5 +426,10 @@ namespace Umbraco.Core.Configuration.UmbracoSettings
        {
            get { return DefaultDocumentTypeProperty; }
        }
+
+        bool IContentSection.EnableInheritedDocumentTypes
+        {
+            get { return EnableInheritedDocumentTypes; }
+        }
    }
 }
@@ -59,5 +59,7 @@ namespace Umbraco.Core.Configuration.UmbracoSettings
        bool GlobalPreviewStorageEnabled { get; }

        string DefaultDocumentTypeProperty { get; }
+
+        bool EnableInheritedDocumentTypes { get; }
    }
 }
@@ -6,7 +6,7 @@ namespace Umbraco.Core.Configuration
 {
    public class UmbracoVersion
    {
-        private static readonly Version Version = new Version("7.3.4");
+        private static readonly Version Version = new Version("7.4.0");

        /// <summary>
        /// Gets the current version of Umbraco.
@@ -24,7 +24,7 @@ namespace Umbraco.Core.Configuration
        /// Gets the version comment (like beta or RC).
        /// </summary>
        /// <value>The version comment.</value>
-        public static string CurrentComment { get { return ""; } }
+        public static string CurrentComment { get { return "beta2"; } }

        // Get the version of the umbraco.dll by looking at a class in that dll
        // Had to do it like this due to medium trust issues, see: http://haacked.com/archive/2010/11/04/assembly-location-and-medium-trust.aspx
@@ -59,7 +59,7 @@
            public const string Content = "content";

            /// <summary>
-            /// alias for the media tree.
+            /// alias for the member tree.
            /// </summary>
            public const string Members = "member";

@@ -71,7 +71,7 @@
            /// <summary>
            /// alias for the datatype tree.
            /// </summary>
-			public const string DataTypes = "datatype";
+			public const string DataTypes = "dataTypes";

 			/// <summary>
 			/// alias for the dictionary tree.
@@ -80,6 +80,22 @@

            public const string Stylesheets = "stylesheets";

+            /// <summary>
+            /// alias for the document type tree.
+            /// </summary>
+            public const string DocumentTypes = "documentTypes";
+
+            /// <summary>
+            /// alias for the media type tree.
+            /// </summary>
+            public const string MediaTypes = "mediaTypes";
+
+
+            /// <summary>
+            /// alias for the member type tree.
+            /// </summary>
+            public const string MemberTypes = "memberTypes";
+
            /// <summary>
            /// alias for the template tree.
            /// </summary>
@@ -206,7 +206,7 @@ namespace Umbraco.Core
                /// </summary>
                internal const string StandardPropertiesGroupName = "Membership";

-		        internal static Dictionary<string, PropertyType> GetStandardPropertyTypeStubs()
+		        public static Dictionary<string, PropertyType> GetStandardPropertyTypeStubs()
 		        {
 		            return new Dictionary<string, PropertyType>
 		                {
@@ -0,0 +1,53 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Umbraco.Core
+{
+    public static partial class Constants
+    {
+        public static class Icons
+        {
+            
+
+            /// <summary>
+            /// System contenttype icon
+            /// </summary>
+            public const string ContentType = "icon-arrangement";
+
+            /// <summary>
+            /// System datatype icon
+            /// </summary>
+            public const string DataType = "icon-autofill";
+
+            /// <summary>
+            /// System property editor icon
+            /// </summary>
+            public const string PropertyEditor = "icon-autofill";
+
+            /// <summary>
+            /// System macro icon
+            /// </summary>
+            public const string Macro = "icon-settings-alt";
+
+            /// <summary>
+            /// System member icon
+            /// </summary>
+            public const string Member = "icon-user";
+
+            /// <summary>
+            /// System member icon
+            /// </summary>
+            public const string MemberType = "icon-users";
+
+
+            /// <summary>
+            /// System member icon
+            /// </summary>
+            public const string Template = "icon-layout";
+
+        }
+    }
+}
@@ -9,6 +9,36 @@ namespace Umbraco.Core
        /// </summary>
        public static class ObjectTypes
        {
+            /// <summary>
+            /// Guid for a data type container
+            /// </summary>
+            public const string DataTypeContainer = "521231E3-8B37-469C-9F9D-51AFC91FEB7B";
+
+            /// <summary>
+            /// Guid for a data type container
+            /// </summary>
+            public static readonly Guid DataTypeContainerGuid = new Guid(DataTypeContainer);
+
+            /// <summary>
+            /// Guid for a doc type container
+            /// </summary>
+            public const string DocumentTypeContainer = "2F7A2769-6B0B-4468-90DD-AF42D64F7F16";
+
+            /// <summary>
+            /// Guid for a doc type container
+            /// </summary>
+            public static readonly Guid DocumentTypeContainerGuid = new Guid(DocumentTypeContainer);
+
+            /// <summary>
+            /// Guid for a doc type container
+            /// </summary>
+            public const string MediaTypeContainer = "42AEF799-B288-4744-9B10-BE144B73CDC4";
+
+            /// <summary>
+            /// Guid for a doc type container
+            /// </summary>
+            public static readonly Guid MediaTypeContainerGuid = new Guid(MediaTypeContainer);
+
            /// <summary>
            /// Guid for a Content Item object.
            /// </summary>
@@ -29,6 +59,11 @@ namespace Umbraco.Core
            /// </summary>
            public const string DataType = "30A2A501-1978-4DDB-A57B-F7EFED43BA3C";

+            /// <summary>
+            /// Guid for a DataType object.
+            /// </summary>
+            public static readonly Guid DataTypeGuid = new Guid(DataType);
+
            /// <summary>
            /// Guid for a Document object.
            /// </summary>
@@ -39,6 +74,11 @@ namespace Umbraco.Core
            /// </summary>
            public const string DocumentType = "A2CB7800-F571-4787-9638-BC48539A0EFB";

+            /// <summary>
+            /// Guid for a Document Type object.
+            /// </summary>
+            public static readonly Guid DocumentTypeGuid = new Guid(DocumentType);
+
            /// <summary>
            /// Guid for a Media object.
            /// </summary>
@@ -54,6 +94,11 @@ namespace Umbraco.Core
            /// </summary>
            public const string MediaType = "4EA4382B-2F5A-4C2B-9587-AE9B3CF3602E";

+            /// <summary>
+            /// Guid for a Media Type object.
+            /// </summary>
+            public static readonly Guid MediaTypeGuid = new Guid(MediaType);
+
            /// <summary>
            /// Guid for a Member object.
            /// </summary>
@@ -69,6 +114,11 @@ namespace Umbraco.Core
            /// </summary>
            public const string MemberType = "9B5416FB-E72F-45A9-A07B-5A9A2709CE43";

+            /// <summary>
+            /// Guid for a Member Type object.
+            /// </summary>
+            public static readonly Guid MemberTypeGuid = new Guid(MemberType);
+
            /// <summary>
            /// Guid for a Stylesheet object.
            /// </summary>
@@ -92,6 +142,8 @@ namespace Umbraco.Core
            /// Guid for a Lock object.
            /// </summary>
            public const string LockObject = "87A9F1FF-B1E4-4A25-BABB-465A4A47EC41";
+
+            
        }
    }
 }
@@ -158,6 +158,11 @@ namespace Umbraco.Core
            /// </summary>
            public const string IntegerAlias = "Umbraco.Integer";

+            /// <summary>
+            /// Alias for the Decimal datatype.
+            /// </summary>
+            public const string DecimalAlias = "Umbraco.Decimal";
+
            /// <summary>
            /// Alias for the listview datatype.
            /// </summary>
@@ -0,0 +1,31 @@
+namespace Umbraco.Core
+{
+    public static partial class Constants
+    {
+        /// <summary>
+        /// Defines the identifiers for property-type groups conventions that are used within the Umbraco core.
+        /// </summary>
+        public static class PropertyTypeGroups
+        {
+            /// <summary>
+            /// Guid for a Image PropertyTypeGroup object.
+            /// </summary>
+            public const string Image = "79ED4D07-254A-42CF-8FA9-EBE1C116A596";
+
+            /// <summary>
+            /// Guid for a File PropertyTypeGroup object.
+            /// </summary>
+            public const string File = "50899F9C-023A-4466-B623-ABA9049885FE";
+
+            /// <summary>
+            /// Guid for a Image PropertyTypeGroup object.
+            /// </summary>
+            public const string Contents = "79995FA2-63EE-453C-A29B-2E66F324CDBE";
+
+            /// <summary>
+            /// Guid for a Image PropertyTypeGroup object.
+            /// </summary>
+            public const string Membership = "0756729D-D665-46E3-B84A-37ACEAA614F8";
+        }
+    }
+}
@@ -188,10 +188,16 @@ namespace Umbraco.Core
        protected virtual CacheHelper CreateApplicationCache()
        {
            var cacheHelper = new CacheHelper(
-                new ObjectCacheRuntimeCacheProvider(),
+                //we need to have the dep clone runtime cache provider to ensure 
+                //all entities are cached properly (cloned in and cloned out)
+                new DeepCloneRuntimeCacheProvider(new ObjectCacheRuntimeCacheProvider()),
                new StaticCacheProvider(),
                //we have no request based cache when not running in web-based context
-                new NullCacheProvider());
+                new NullCacheProvider(),
+                new IsolatedRuntimeCache(type =>
+                    //we need to have the dep clone runtime cache provider to ensure 
+                    //all entities are cached properly (cloned in and cloned out)
+                    new DeepCloneRuntimeCacheProvider(new ObjectCacheRuntimeCacheProvider())));

            return cacheHelper;
        }
@@ -431,6 +437,7 @@ namespace Umbraco.Core
                    new Lazy<Type>(() => typeof (DelimitedManifestValueValidator)),
                    new Lazy<Type>(() => typeof (EmailValidator)),
                    new Lazy<Type>(() => typeof (IntegerValidator)),
+                    new Lazy<Type>(() => typeof (DecimalValidator)),
                });

            //by default we'll use the db server registrar unless the developer has the legacy
@@ -0,0 +1,21 @@
+using System;
+
+namespace Umbraco.Core.Exceptions
+{
+    internal class DataOperationException<T> : Exception
+    {
+        public T Operation { get; private set; }
+
+        public DataOperationException(T operation, string message)
+            :base(message)
+        {
+            Operation = operation;
+        }
+
+        public DataOperationException(T operation)
+            : base("Data operation exception: " + operation)
+        {
+            Operation = operation;
+        }
+    }
+}
@@ -3,22 +3,41 @@
 namespace Umbraco.Core.Exceptions
 {
    public class InvalidCompositionException : Exception
-    {  
-        public string ContentTypeAlias { get; set; }
+    {
+        public InvalidCompositionException(string contentTypeAlias, string addedCompositionAlias, string[] propertyTypeAliass)
+        {
+            ContentTypeAlias = contentTypeAlias;
+            AddedCompositionAlias = addedCompositionAlias;
+            PropertyTypeAliases = propertyTypeAliass;
+        }

-        public string AddedCompositionAlias { get; set; }
+        public InvalidCompositionException(string contentTypeAlias, string[] propertyTypeAliass)
+        {
+            ContentTypeAlias = contentTypeAlias;
+            PropertyTypeAliases = propertyTypeAliass;
+        }

-        public string PropertyTypeAlias { get; set; }
+        public string ContentTypeAlias { get; private set; }
+
+        public string AddedCompositionAlias { get; private set; }
+
+        public string[] PropertyTypeAliases { get; private set; }

        public override string Message
        {
            get
            {
-                return string.Format(
-                        "InvalidCompositionException - ContentType with alias '{0}' was added as a Compsition to ContentType with alias '{1}', " +
-                        "but there was a conflict on the PropertyType alias '{2}'. " +
+                return AddedCompositionAlias.IsNullOrWhiteSpace()
+                    ? string.Format(
+                        "ContentType with alias '{0}' has an invalid composition " +
+                        "and there was a conflict on the following PropertyTypes: '{1}'. " +
                        "PropertyTypes must have a unique alias across all Compositions in order to compose a valid ContentType Composition.",
-                        AddedCompositionAlias, ContentTypeAlias, PropertyTypeAlias);
+                        ContentTypeAlias, string.Join(", ", PropertyTypeAliases))
+                    : string.Format(
+                        "ContentType with alias '{0}' was added as a Composition to ContentType with alias '{1}', " +
+                        "but there was a conflict on the following PropertyTypes: '{2}'. " +
+                        "PropertyTypes must have a unique alias across all Compositions in order to compose a valid ContentType Composition.",
+                        AddedCompositionAlias, ContentTypeAlias, string.Join(", ", PropertyTypeAliases));
            }
        }
    }
@@ -199,8 +199,8 @@ namespace Umbraco.Core.IO
                using (var image = Image.FromStream(fs))
                {
                    var fileNameThumb = string.IsNullOrWhiteSpace(fileNameAddition)
-                        ? string.Format("{0}_UMBRACOSYSTHUMBNAIL.jpg", Path.Substring(0, Path.LastIndexOf(".", StringComparison.Ordinal)))
-                        : string.Format("{0}_{1}.jpg", Path.Substring(0, Path.LastIndexOf(".", StringComparison.Ordinal)), fileNameAddition);
+                        ? string.Format("{0}_UMBRACOSYSTHUMBNAIL." + Extension, Path.Substring(0, Path.LastIndexOf(".", StringComparison.Ordinal)))
+                        : string.Format("{0}_{1}." + Extension, Path.Substring(0, Path.LastIndexOf(".", StringComparison.Ordinal)), fileNameAddition);

                    var thumbnail = maxWidthHeight == -1
                        ? ImageHelper.GenerateThumbnail(image, width, height, fileNameThumb, Extension, _fs)
@@ -66,7 +66,7 @@ namespace Umbraco.Core.IO
            return viewContent;
        }

-        internal static string GetDefaultFileContent(string layoutPageAlias = null)
+        internal static string GetDefaultFileContent(string layoutPageAlias = null, string modelClassName = null)
        {
            var design = @"@inherits Umbraco.Web.Mvc.UmbracoTemplatePage
@{
@@ -76,6 +76,10 @@ namespace Umbraco.Core.IO
            if (layoutPageAlias.IsNullOrWhiteSpace() == false)
                design = design.Replace("null", string.Format("\"{0}.cshtml\"", layoutPageAlias));

+            if (modelClassName.IsNullOrWhiteSpace() == false)
+                design = design.Replace(".UmbracoTemplatePage", string.Format(".UmbracoTemplatePage<{0}>", modelClassName));
+
+
            return design;
        }

@@ -11,8 +11,12 @@ namespace Umbraco.Core.Macros
 	/// </summary>
 	internal class MacroTagParser
 	{
-        private static readonly Regex MacroRteContent = new Regex(@"(<!--\s*?)(<\?UMBRACO_MACRO.*?/>)(\s*?-->)", RegexOptions.Compiled | RegexOptions.IgnoreCase | RegexOptions.Singleline);
-        private static readonly Regex MacroPersistedFormat = new Regex(@"(<\?UMBRACO_MACRO (?:.+?)?macroAlias=[""']([^""\'\n\r]+?)[""'].+?)(?:/>|>.*?</\?UMBRACO_MACRO>)", RegexOptions.Compiled | RegexOptions.IgnoreCase);
+	    private static readonly Regex MacroRteContent = new Regex(@"(<!--\s*?)(<\?UMBRACO_MACRO.*?/>)(\s*?-->)",
+	        RegexOptions.Compiled | RegexOptions.IgnoreCase | RegexOptions.CultureInvariant | RegexOptions.Singleline);
+
+	    private static readonly Regex MacroPersistedFormat =
+	        new Regex(@"(<\?UMBRACO_MACRO (?:.+?)??macroAlias=[""']([^""\'\n\r]+?)[""'].+?)(?:/>|>.*?</\?UMBRACO_MACRO>)",
+	            RegexOptions.Compiled | RegexOptions.IgnoreCase | RegexOptions.CultureInvariant | RegexOptions.Singleline);

 	    /// <summary>
 	    /// This formats the persisted string to something useful for the rte so that the macro renders properly since we 
@@ -75,7 +75,7 @@ namespace Umbraco.Core.Media.Exif
 		{
 			if (items.ContainsKey (key))
 				items.Remove (key);
-			if (key == ExifTag.WindowsTitle || key == ExifTag.WindowsTitle || key == ExifTag.WindowsComment || key == ExifTag.WindowsAuthor || key == ExifTag.WindowsKeywords || key == ExifTag.WindowsSubject) {
+			if (key == ExifTag.WindowsTitle || key == ExifTag.WindowsComment || key == ExifTag.WindowsAuthor || key == ExifTag.WindowsKeywords || key == ExifTag.WindowsSubject) {
 				items.Add (key, new WindowsByteString (key, value));
 			} else {
 				items.Add (key, new ExifAscii (key, value, parent.Encoding));
@@ -59,7 +59,7 @@ namespace Umbraco.Core.Media
                var fileHeight = image.Height;
                return new Size(fileWidth, fileHeight);
            }
-           
+
        }

        public static string GetMimeType(this Image image)
@@ -79,22 +79,22 @@ namespace Umbraco.Core.Media
        /// <param name="additionalThumbSizes"></param>
        /// <returns></returns>
        internal static IEnumerable<ResizedImage> GenerateMediaThumbnails(
-            IFileSystem fs, 
-            string fileName, 
-            string extension, 
+            IFileSystem fs,
+            string fileName,
+            string extension,
            Image originalImage,
            IEnumerable<int> additionalThumbSizes)
        {

            var result = new List<ResizedImage>();

-            var allSizesDictionary = new Dictionary<int,string> {{100,"thumb"}, {500,"big-thumb"}};
-            
+            var allSizesDictionary = new Dictionary<int, string> { { 100, "thumb" }, { 500, "big-thumb" } };
+
            //combine the static dictionary with the additional sizes with only unique values
            var allSizes = allSizesDictionary.Select(kv => kv.Key)
                .Union(additionalThumbSizes.Where(x => x > 0).Distinct());

-            var sizesDictionary = allSizes.ToDictionary(s => s, s => allSizesDictionary.ContainsKey(s) ? allSizesDictionary[s]: "");
+            var sizesDictionary = allSizes.ToDictionary(s => s, s => allSizesDictionary.ContainsKey(s) ? allSizesDictionary[s] : "");

            foreach (var s in sizesDictionary)
            {
@@ -121,9 +121,9 @@ namespace Umbraco.Core.Media
        /// <returns></returns>
        private static ResizedImage Resize(IFileSystem fileSystem, string path, string extension, int maxWidthHeight, string fileNameAddition, Image originalImage)
        {
-            var fileNameThumb = String.IsNullOrEmpty(fileNameAddition)
-                                            ? string.Format("{0}_UMBRACOSYSTHUMBNAIL.jpg", path.Substring(0, path.LastIndexOf(".")))
-                                            : string.Format("{0}_{1}.jpg", path.Substring(0, path.LastIndexOf(".")), fileNameAddition);
+            var fileNameThumb = string.IsNullOrWhiteSpace(fileNameAddition)
+                                            ? string.Format("{0}_UMBRACOSYSTHUMBNAIL." + extension, path.Substring(0, path.LastIndexOf(".", StringComparison.Ordinal)))
+                                            : string.Format("{0}_{1}." + extension, path.Substring(0, path.LastIndexOf(".", StringComparison.Ordinal)), fileNameAddition);

            var thumb = GenerateThumbnail(
                originalImage,
@@ -190,9 +190,9 @@ namespace Umbraco.Core.Media
                        //use best quality
                        g.InterpolationMode = InterpolationMode.HighQualityBicubic;
                    }
-                    

-                    g.SmoothingMode = SmoothingMode.HighQuality;                    
+
+                    g.SmoothingMode = SmoothingMode.HighQuality;
                    g.PixelOffsetMode = PixelOffsetMode.HighQuality;
                    g.CompositingQuality = CompositingQuality.HighQuality;

@@ -202,10 +202,29 @@ namespace Umbraco.Core.Media

                    // Copy metadata
                    var imageEncoders = ImageCodecInfo.GetImageEncoders();
-
-                    var codec = extension.ToLower() == "png" || extension.ToLower() == "gif"
-                        ? imageEncoders.Single(t => t.MimeType.Equals("image/png"))
-                        : imageEncoders.Single(t => t.MimeType.Equals("image/jpeg"));
+                    ImageCodecInfo codec;
+                    switch (extension.ToLower())
+                    {
+                        case "png":
+                            codec = imageEncoders.Single(t => t.MimeType.Equals("image/png"));
+                            break;
+                        case "gif":
+                            codec = imageEncoders.Single(t => t.MimeType.Equals("image/gif"));
+                            break;
+                        case "tif":
+                        case "tiff":
+                            codec = imageEncoders.Single(t => t.MimeType.Equals("image/tiff"));
+                            break;
+                        case "bmp":
+                            codec = imageEncoders.Single(t => t.MimeType.Equals("image/bmp"));
+                            break;
+                        // TODO: this is dirty, defaulting to jpg but the return value of this thing is used all over the
+                        // place so left it here, but it needs to not set a codec if it doesn't know which one to pick 
+                        // Note: when fixing this: both .jpg and .jpeg should be handled as extensions
+                        default:
+                            codec = imageEncoders.Single(t => t.MimeType.Equals("image/jpeg"));
+                            break;
+                    }

                    // Set compresion ratio to 90%
                    var ep = new EncoderParameters();
@@ -213,12 +232,14 @@ namespace Umbraco.Core.Media

                    // Save the new image using the dimensions of the image
                    var predictableThumbnailName = thumbnailFileName.Replace("UMBRACOSYSTHUMBNAIL", maxWidthHeight.ToString(CultureInfo.InvariantCulture));
+                    var predictableThumbnailNameJpg = predictableThumbnailName.Substring(0, predictableThumbnailName.LastIndexOf(".", StringComparison.Ordinal)) + ".jpg";
                    using (var ms = new MemoryStream())
                    {
                        bp.Save(ms, codec, ep);
                        ms.Seek(0, 0);

                        fs.AddFile(predictableThumbnailName, ms);
+                        fs.AddFile(predictableThumbnailNameJpg, ms);
                    }

                    // TODO: Remove this, this is ONLY here for backwards compatibility but it is essentially completely unusable see U4-5385
@@ -340,18 +340,6 @@ namespace Umbraco.Core.Models
            }
        }
        
-        /// <summary>
-        /// Method to call when Entity is being saved
-        /// </summary>
-        /// <remarks>Created date is set and a Unique key is assigned</remarks>
-        internal override void AddingEntity()
-        {
-            base.AddingEntity();
-
-            if(Key == Guid.Empty)
-                Key = Guid.NewGuid();
-        }
-
        /// <summary>
        /// Method to call when Entity is being updated
        /// </summary>
@@ -137,19 +137,6 @@ namespace Umbraco.Core.Models
            return result;
        }

-        /// <summary>
-        /// Method to call when Entity is being saved
-        /// </summary>
-        /// <remarks>Created date is set and a Unique key is assigned</remarks>
-        internal override void AddingEntity()
-        {
-            base.AddingEntity();
-
-            if (Key == Guid.Empty)
-                Key = Guid.NewGuid();
-        }
-
-
        /// <summary>
        /// Creates a deep clone of the current entity with its identity/alias and it's property identities reset
        /// </summary>
@@ -0,0 +1,17 @@
+namespace Umbraco.Core.Models
+{
+    /// <summary>
+    /// Used when determining available compositions for a given content type
+    /// </summary>
+    internal class ContentTypeAvailableCompositionsResult
+    {
+        public ContentTypeAvailableCompositionsResult(IContentTypeComposition composition, bool allowed)
+        {
+            Composition = composition;
+            Allowed = allowed;
+        }
+
+        public IContentTypeComposition Composition { get; private set; }
+        public bool Allowed { get; private set; }
+    }
+}
@@ -0,0 +1,26 @@
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Umbraco.Core.Models
+{
+    /// <summary>
+    /// Used when determining available compositions for a given content type
+    /// </summary>
+    internal class ContentTypeAvailableCompositionsResults
+    {
+        public ContentTypeAvailableCompositionsResults()
+        {
+            Ancestors = Enumerable.Empty<IContentTypeComposition>();
+            Results = Enumerable.Empty<ContentTypeAvailableCompositionsResult>();
+        }
+
+        public ContentTypeAvailableCompositionsResults(IEnumerable<IContentTypeComposition> ancestors, IEnumerable<ContentTypeAvailableCompositionsResult> results)
+        {
+            Ancestors = ancestors;
+            Results = results;
+        }
+
+        public IEnumerable<IContentTypeComposition> Ancestors { get; private set; }
+        public IEnumerable<ContentTypeAvailableCompositionsResult> Results { get; private set; }
+    }
+}
@@ -26,7 +26,7 @@ namespace Umbraco.Core.Models
        private string _alias;
        private string _description;
        private int _sortOrder;
-        private string _icon = "folder.png";
+        private string _icon = "icon-folder";
        private string _thumbnail = "folder.png";
        private int _creatorId;
        private bool _allowedAsRoot;
@@ -373,43 +373,35 @@ namespace Umbraco.Core.Models
            {
                _propertyGroups = value;
                _propertyGroups.CollectionChanged += PropertyGroupsChanged;
+                PropertyGroupsChanged(_propertyGroups, new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset));
            }
        }

        /// <summary>
-        /// List of PropertyTypes available on this ContentType.
-        /// This list aggregates PropertyTypes across the PropertyGroups.
+        /// Gets all property types, across all property groups.
        /// </summary>
-        /// <remarks>
-        /// 
-        /// The setter is used purely to set the property types that DO NOT belong to a group!
-        /// 
-        /// Marked as DoNotClone because the result of this property is not the natural result of the data, it is 
-        /// a union of data so when auto-cloning if the setter is used it will be setting the unnatural result of the 
-        /// data. We manually clone this instead. 
-        /// </remarks>
        [IgnoreDataMember]
        [DoNotClone]
        public virtual IEnumerable<PropertyType> PropertyTypes
        {
            get
            {
-                var types = _propertyTypes.Union(PropertyGroups.SelectMany(x => x.PropertyTypes));
-                return types;
-            }
-            internal set
-            {
-                _propertyTypes = new PropertyTypeCollection(value);
-                _propertyTypes.CollectionChanged += PropertyTypesChanged;
+                return _propertyTypes.Union(PropertyGroups.SelectMany(x => x.PropertyTypes));
            }
        }

        /// <summary>
-        /// Returns the property type collection containing types that are non-groups - used for tests
+        /// Gets or sets the property types that are not in a group.
        /// </summary>
-        internal IEnumerable<PropertyType> NonGroupedPropertyTypes
+        public IEnumerable<PropertyType> NoGroupPropertyTypes
        {
            get { return _propertyTypes; }
+            set
+            {
+                _propertyTypes = new PropertyTypeCollection(value);
+                _propertyTypes.CollectionChanged += PropertyTypesChanged;
+                PropertyTypesChanged(_propertyTypes, new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset));
+            }
        }

            /// <summary>
@@ -460,11 +452,6 @@ namespace Umbraco.Core.Models
        /// <returns>Returns <c>True</c> if PropertyType was added, otherwise <c>False</c></returns>
        public bool AddPropertyType(PropertyType propertyType)
        {
-            if (propertyType.HasIdentity == false)
-            {
-                propertyType.Key = Guid.NewGuid();
-            }
-
            if (PropertyTypeExists(propertyType.Alias) == false)
            {
                _propertyTypes.Add(propertyType);                
@@ -480,24 +467,37 @@ namespace Umbraco.Core.Models
        /// <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>
+        /// <remarks>If <paramref name="propertyGroupName"/> is null then the property is moved back to 
+        /// "generic properties" ie does not have a tab anymore.</remarks>
        public bool MovePropertyType(string propertyTypeAlias, string propertyGroupName)
        {
-            if (PropertyTypes.Any(x => x.Alias == propertyTypeAlias) == false || PropertyGroups.Any(x => x.Name == propertyGroupName) == false)
-                return false;
+            // note: not dealing with alias casing at all here?

-            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);
-            }
+            // get property, ensure it exists
+            var propertyType = PropertyTypes.FirstOrDefault(x => x.Alias == propertyTypeAlias);
+            if (propertyType == null) return false;

+            // get new group, if required, and ensure it exists
+            var newPropertyGroup = propertyGroupName == null
+                ? null
+                : PropertyGroups.FirstOrDefault(x => x.Name == propertyGroupName);
+            if (propertyGroupName != null && newPropertyGroup == null) return false;
+
+            // get old group
+            var oldPropertyGroup = PropertyGroups.FirstOrDefault(x => 
+                x.PropertyTypes.Any(y => y.Alias == propertyTypeAlias));
+
+            // reset PropertyGroupId, which will be re-evaluated when the content type
+            // is saved - what is important is group.PropertyTypes - see code in
+            // ContentTypeBaseRepository.PersistUpdatedBaseContentType
            propertyType.PropertyGroupId = new Lazy<int>(() => default(int));
-            propertyType.ResetDirtyProperties();
+            propertyType.ResetDirtyProperties(); // PropertyGroupId must not be dirty

-            var propertyGroup = PropertyGroups.First(x => x.Name == propertyGroupName);
-            propertyGroup.PropertyTypes.Add(propertyType);
+            // remove from old group, if any - add to new group, if any
+            if (oldPropertyGroup != null)
+                oldPropertyGroup.PropertyTypes.RemoveItem(propertyTypeAlias);
+            if (newPropertyGroup != null)
+                newPropertyGroup.PropertyTypes.Add(propertyType);

            return true;
        }
@@ -23,8 +23,8 @@ namespace Umbraco.Core.Models

        protected ContentTypeCompositionBase(IContentTypeComposition parent)
            : this(parent, null)
-		{
-		}
+        {
+        }

        protected ContentTypeCompositionBase(IContentTypeComposition parent, string alias)
            : base(parent, alias)
@@ -37,16 +37,21 @@ namespace Umbraco.Core.Models
                x => x.ContentTypeComposition);

        /// <summary>
-        /// List of ContentTypes that make up a composition of PropertyGroups and PropertyTypes for the current ContentType
+        /// Gets or sets the content types that compose this content type.
        /// </summary>
        [DataMember]
        public IEnumerable<IContentTypeComposition> ContentTypeComposition
        {
            get { return _contentTypeComposition; }
+            set
+            {
+                _contentTypeComposition = value.ToList();
+                OnPropertyChanged(ContentTypeCompositionSelector);
+            }
        }

        /// <summary>
-        /// Returns a list of <see cref="PropertyGroup"/> objects from the composition
+        /// Gets the property groups for the entire composition.
        /// </summary>
        [IgnoreDataMember]
        public IEnumerable<PropertyGroup> CompositionPropertyGroups
@@ -59,7 +64,7 @@ namespace Umbraco.Core.Models
        }

        /// <summary>
-        /// Returns a list of <see cref="PropertyType"/> objects from the composition
+        /// Gets the property types for the entire composition.
        /// </summary>
        [IgnoreDataMember]
        public IEnumerable<PropertyType> CompositionPropertyTypes
@@ -72,10 +77,10 @@ namespace Umbraco.Core.Models
        }

        /// <summary>
-        /// Adds a new ContentType to the list of composite ContentTypes
+        /// Adds a content type to the composition.
        /// </summary>
-        /// <param name="contentType"><see cref="ContentType"/> to add</param>
-        /// <returns>True if ContentType was added, otherwise returns False</returns>
+        /// <param name="contentType">The content type to add.</param>
+        /// <returns>True if the content type was added, otherwise false.</returns>
        public bool AddContentType(IContentTypeComposition contentType)
        {
            if (contentType.ContentTypeComposition.Any(x => x.CompositionAliases().Any(ContentTypeCompositionExists)))
@@ -94,13 +99,7 @@ namespace Umbraco.Core.Models
                        .Select(p => p.Alias)).ToList();

                if (conflictingPropertyTypeAliases.Any())
-                    throw new InvalidCompositionException
-                          {
-                              AddedCompositionAlias = contentType.Alias,
-                              ContentTypeAlias = Alias,
-                              PropertyTypeAlias =
-                                  string.Join(", ", conflictingPropertyTypeAliases)
-                          };
+                    throw new InvalidCompositionException(Alias, contentType.Alias, conflictingPropertyTypeAliases.ToArray());

                _contentTypeComposition.Add(contentType);
                OnPropertyChanged(ContentTypeCompositionSelector);
@@ -110,10 +109,10 @@ namespace Umbraco.Core.Models
        }

        /// <summary>
-        /// Removes a ContentType with the supplied alias from the the list of composite ContentTypes
+        /// Removes a content type with a specified alias from the composition.
        /// </summary>
-        /// <param name="alias">Alias of a <see cref="ContentType"/></param>
-        /// <returns>True if ContentType was removed, otherwise returns False</returns>
+        /// <param name="alias">The alias of the content type to remove.</param>
+        /// <returns>True if the content type was removed, otherwise false.</returns>
        public bool RemoveContentType(string alias)
        {
            if (ContentTypeCompositionExists(alias))
@@ -123,10 +122,10 @@ namespace Umbraco.Core.Models
                    return false;

                RemovedContentTypeKeyTracker.Add(contentTypeComposition.Id);
-                
+
                //If the ContentType we are removing has Compositions of its own these needs to be removed as well
                var compositionIdsToRemove = contentTypeComposition.CompositionIds().ToList();
-                if(compositionIdsToRemove.Any())
+                if (compositionIdsToRemove.Any())
                    RemovedContentTypeKeyTracker.AddRange(compositionIdsToRemove);

                OnPropertyChanged(ContentTypeCompositionSelector);
@@ -163,31 +162,44 @@ namespace Umbraco.Core.Models

        /// <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;
+            return AddAndReturnPropertyGroup(groupName) != null;
+        }

-            var propertyGroup = new PropertyGroup {Name = groupName, SortOrder = 0};
+        private PropertyGroup AddAndReturnPropertyGroup(string name)
+        {
+            // ensure we don't have it already
+            if (PropertyGroups.Any(x => x.Name == name))
+                return null;

-            if (CompositionPropertyGroups.Any(x => x.Name == groupName))
+            // create the new group
+            var group = new PropertyGroup { Name = name, SortOrder = 0 };
+
+            // check if it is inherited - there might be more than 1 but we want the 1st, to
+            // reuse its sort order - if there are more than 1 and they have different sort
+            // orders... there isn't much we can do anyways
+            var inheritGroup = CompositionPropertyGroups.FirstOrDefault(x => x.Name == name);
+            if (inheritGroup == null)
            {
-                var firstGroup = CompositionPropertyGroups.First(x => x.Name == groupName && x.ParentId.HasValue == false);
-                propertyGroup.SetLazyParentId(new Lazy<int?>(() => firstGroup.Id));
+                // no, just local, set sort order
+                var lastGroup = PropertyGroups.LastOrDefault();
+                if (lastGroup != null)
+                    group.SortOrder = lastGroup.SortOrder + 1;
+            }
+            else
+            {
+                // yes, inherited, re-use sort order
+                group.SortOrder = inheritGroup.SortOrder;
            }

-            if (PropertyGroups.Any())
-            {
-                var last = PropertyGroups.Last();
-                propertyGroup.SortOrder = last.SortOrder + 1;
-            }
+            // add
+            PropertyGroups.Add(group);

-            PropertyGroups.Add(propertyGroup);
-            return true;
+            return group;
        }

        /// <summary>
@@ -198,39 +210,22 @@ namespace Umbraco.Core.Models
        /// <returns>Returns <c>True</c> if PropertyType was added, otherwise <c>False</c></returns>
        public override bool AddPropertyType(PropertyType propertyType, string propertyGroupName)
        {
-            if (propertyType.HasIdentity == false)
-            {
-                propertyType.Key = Guid.NewGuid();
-            }
+            // ensure no duplicate alias - over all composition properties
+            if (PropertyTypeExists(propertyType.Alias))
+                return false;

-            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));
-                    }
+            // get and ensure a group local to this content type
+            var group = PropertyGroups.Contains(propertyGroupName)
+                ? PropertyGroups[propertyGroupName]
+                : AddAndReturnPropertyGroup(propertyGroupName);
+            if (group == null)
+                return false;

-                    PropertyGroups.Add(propertyGroup);
-                }
+            // add property to group
+            propertyType.PropertyGroupId = new Lazy<int>(() => group.Id);
+            group.PropertyTypes.Add(propertyType);

-                return true;
-            }
-
-            return false;
+            return true;
        }

        /// <summary>
@@ -21,6 +21,8 @@ namespace Umbraco.Core.Models
        [EnumMember]
        Integer,
        [EnumMember]
-        Date
+        Date,
+        [EnumMember]
+        Decimal
    }
 }
@@ -49,8 +49,6 @@ namespace Umbraco.Core.Models
            _additionalData = new Dictionary<string, object>();
        }

-        [Obsolete("Don't use this, parentId is always -1 for data types")]
-        [EditorBrowsable(EditorBrowsableState.Never)]
        public DataTypeDefinition(int parentId, string propertyEditorAlias)
        {
            _parentId = parentId;
@@ -267,13 +265,5 @@ namespace Umbraco.Core.Models
        {
            get { return _additionalData; }
        }
-
-        internal override void AddingEntity()
-        {
-            base.AddingEntity();
-
-            if(Key == default(Guid))
-                Key = Guid.NewGuid();
-        }
    }
 }
@@ -78,6 +78,12 @@ namespace Umbraco.Core.Models
                    }
                    else
                    {
+                        //skip instead of trying to create instance of abstract or interface
+                        if (propertyInfo.PropertyType.IsAbstract || propertyInfo.PropertyType.IsInterface)
+                        {
+                            continue;
+                        }
+
                        //its a custom IEnumerable, we'll try to create it
                        try
                        {
@@ -14,6 +14,7 @@ namespace Umbraco.Core.Models
    [DataContract(IsReference = true)]
    public class DictionaryItem : Entity, IDictionaryItem
    {
+        public Func<int, ILanguage> GetLanguage { get; set; }
        private Guid? _parentId;
        private string _itemKey;
        private IEnumerable<IDictionaryTranslation> _translations;
@@ -78,7 +79,17 @@ namespace Umbraco.Core.Models
            {
                SetPropertyValueAndDetectChanges(o =>
                {
-                    _translations = value;
+                    var asArray = value.ToArray();
+                    //ensure the language callback is set on each translation
+                    if (GetLanguage != null)
+                    {
+                        foreach (var translation in asArray.OfType<DictionaryTranslation>())
+                        {
+                            translation.GetLanguage = GetLanguage;
+                        }
+                    }
+
+                    _translations = asArray;                    
                    return _translations;
                }, _translations, TranslationsSelector,
                    //Custom comparer for enumerable
@@ -87,16 +98,5 @@ namespace Umbraco.Core.Models
                        enumerable => enumerable.GetHashCode()));
            }
        }
-
-        /// <summary>
-        /// Method to call before inserting a new entity in the db
-        /// </summary>
-        internal override void AddingEntity()
-        {
-            base.AddingEntity();
-
-            Key = Guid.NewGuid();            
-        }
-        
    }
 }
@@ -13,13 +13,18 @@ namespace Umbraco.Core.Models
    [DataContract(IsReference = true)]
    public class DictionaryTranslation : Entity, IDictionaryTranslation
    {
+        internal Func<int, ILanguage> GetLanguage { get; set; }
+
        private ILanguage _language;
        private string _value;
+        //note: this will be memberwise cloned
+        private int _languageId;

        public DictionaryTranslation(ILanguage language, string value)
        {
            if (language == null) throw new ArgumentNullException("language");
            _language = language;
+            _languageId = _language.Id;
            _value = value;
        }

@@ -27,6 +32,20 @@ namespace Umbraco.Core.Models
        {
            if (language == null) throw new ArgumentNullException("language");
            _language = language;
+            _languageId = _language.Id;
+            _value = value;
+            Key = uniqueId;
+        }
+
+        internal DictionaryTranslation(int languageId, string value)
+        {            
+            _languageId = languageId;
+            _value = value;
+        }
+
+        internal DictionaryTranslation(int languageId, string value, Guid uniqueId)
+        {            
+            _languageId = languageId;
            _value = value;
            Key = uniqueId;
        }
@@ -37,20 +56,43 @@ namespace Umbraco.Core.Models
        /// <summary>
        /// Gets or sets the <see cref="Language"/> for the translation
        /// </summary>
+        /// <remarks>
+        /// Marked as DoNotClone - TODO: this member shouldn't really exist here in the first place, the DictionaryItem
+        /// class will have a deep hierarchy of objects which all get deep cloned which we don't want. This should have simply
+        /// just referenced a language ID not the actual language object. In v8 we need to fix this.
+        /// We're going to have to do the same hacky stuff we had to do with the Template/File contents so that this is returned 
+        /// on a callback.
+        /// </remarks>
        [DataMember]
+        [DoNotClone]
        public ILanguage Language
        {
-            get { return _language; }
+            get
+            {
+                if (_language != null)
+                    return _language;
+
+                // else, must lazy-load
+                if (GetLanguage != null && _languageId > 0)
+                    _language = GetLanguage(_languageId);
+                return _language;
+            }
            set
            {
                SetPropertyValueAndDetectChanges(o =>
                {
                    _language = value;
+                    _languageId = _language == null ? -1 : _language.Id;
                    return _language;
                }, _language, LanguageSelector);
            }
        }

+        public int LanguageId
+        {
+            get { return _languageId; }
+        }
+
        /// <summary>
        /// Gets or sets the translated text
        /// </summary>
@@ -68,5 +110,23 @@ namespace Umbraco.Core.Models
            }
        }

+        public override object DeepClone()
+        {
+            var clone = (DictionaryTranslation)base.DeepClone();
+
+            // clear fields that were memberwise-cloned and that we don't want to clone
+            clone._language = null;
+
+            // turn off change tracking
+            clone.DisableChangeTracking();
+            
+            // this shouldn't really be needed since we're not tracking
+            clone.ResetDirtyProperties(false);
+
+            // re-enable tracking
+            clone.EnableChangeTracking();
+
+            return clone;
+        }
    }
 }
@@ -62,9 +62,9 @@ namespace Umbraco.Core.Models.EntityBase
        {
            get
            {
+                // if an entity does NOT have a UniqueId yet, assign one now
                if (_key == Guid.Empty)
-                    return _id.ToGuid();
-
+                    _key = Guid.NewGuid();
                return _key;
            }
            set
@@ -136,6 +136,7 @@ namespace Umbraco.Core.Models.EntityBase
        {
            _hasIdentity = false;
            _id = default(int);
+            _key = Guid.Empty;
        }

        /// <summary>
@@ -242,6 +243,7 @@ namespace Umbraco.Core.Models.EntityBase
        {
            //Memberwise clone on Entity will work since it doesn't have any deep elements
            // for any sub class this will work for standard properties as well that aren't complex object's themselves.
+            var ignored = this.Key; // ensure that 'this' has a key, before cloning
            var clone = (Entity)MemberwiseClone();
            //ensure the clone has it's own dictionaries
            clone.ResetChangeTrackingCollections();
@@ -0,0 +1,93 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Umbraco.Core.Models
+{
+    /// <summary>
+    /// Represents a folder for organizing entities such as content types and data types.
+    /// </summary>
+    public sealed class EntityContainer : UmbracoEntity
+    {
+        private readonly Guid _containedObjectType;
+
+        private static readonly Dictionary<Guid, Guid> ObjectTypeMap = new Dictionary<Guid, Guid>
+        {
+            { Constants.ObjectTypes.DataTypeGuid, Constants.ObjectTypes.DataTypeContainerGuid },
+            { Constants.ObjectTypes.DocumentTypeGuid, Constants.ObjectTypes.DocumentTypeContainerGuid },
+            { Constants.ObjectTypes.MediaTypeGuid, Constants.ObjectTypes.MediaTypeContainerGuid }
+        };
+
+        /// <summary>
+        /// Initializes a new instance of an <see cref="EntityContainer"/> class.
+        /// </summary>
+        public EntityContainer(Guid containedObjectType)
+        {
+            if (ObjectTypeMap.ContainsKey(containedObjectType) == false)
+                throw new ArgumentException("Not a contained object type.", "containedObjectType");
+            _containedObjectType = containedObjectType;
+
+            ParentId = -1;
+            Path = "-1";
+            Level = 0;
+            SortOrder = 0;
+        }
+
+        /// <summary>
+        /// Initializes a new instance of an <see cref="EntityContainer"/> class.
+        /// </summary>
+        internal EntityContainer(int id, Guid uniqueId, int parentId, string path, int level, int sortOrder, Guid containedObjectType, string name, int userId)
+            : this(containedObjectType)
+        {
+            Id = id;
+            Key = uniqueId;
+            ParentId = parentId;
+            Name = name;
+            Path = path;
+            Level = level;
+            SortOrder = sortOrder;
+            CreatorId = userId;
+        }
+
+        /// <summary>
+        /// Gets or sets the node object type of the contained objects.
+        /// </summary>
+        public Guid ContainedObjectType
+        {
+            get { return _containedObjectType; }
+        }
+
+        /// <summary>
+        /// Gets the node object type of the container objects.
+        /// </summary>
+        public Guid ContainerObjectType
+        {
+            get { return ObjectTypeMap[_containedObjectType]; }
+        }
+
+        /// <summary>
+        /// Gets the container object type corresponding to a contained object type.
+        /// </summary>
+        /// <param name="containedObjectType">The contained object type.</param>
+        /// <returns>The object type of containers containing objects of the contained object type.</returns>
+        public static Guid GetContainerObjectType(Guid containedObjectType)
+        {
+            if (ObjectTypeMap.ContainsKey(containedObjectType) == false)
+                throw new ArgumentException("Not a contained object type.", "containedObjectType");
+            return ObjectTypeMap[containedObjectType];
+        }
+
+        /// <summary>
+        /// Gets the contained object type corresponding to a container object type.
+        /// </summary>
+        /// <param name="containerObjectType">The container object type.</param>
+        /// <returns>The object type of objects that containers of the container object type can contain.</returns>
+        public static Guid GetContainedObjectType(Guid containerObjectType)
+        {
+            var contained = ObjectTypeMap.FirstOrDefault(x => x.Value == containerObjectType).Key;
+            if (contained == null)
+                throw new ArgumentException("Not a container object type.", "containerObjectType");
+            return contained;
+        }
+    }
+}
@@ -54,10 +54,15 @@ namespace Umbraco.Core.Models
        PropertyGroupCollection PropertyGroups { get; set; }

        /// <summary>
-        /// Gets an enumerable list of Property Types aggregated for all groups
+        /// Gets all property types, across all property groups.
        /// </summary>
        IEnumerable<PropertyType> PropertyTypes { get; }

+        /// <summary>
+        /// Gets or sets the property types that are not in a group.
+        /// </summary>
+        IEnumerable<PropertyType> NoGroupPropertyTypes { get; set; }
+
        /// <summary>
        /// Removes a PropertyType from the current ContentType
        /// </summary>
@@ -8,17 +8,17 @@ namespace Umbraco.Core.Models
    public interface IContentTypeComposition : IContentTypeBase
    {
        /// <summary>
-        /// Gets a list of ContentTypes that make up a composition of PropertyGroups and PropertyTypes for the current ContentType
+        /// Gets or sets the content types that compose this content type.
        /// </summary>
-        IEnumerable<IContentTypeComposition> ContentTypeComposition { get; }
+        IEnumerable<IContentTypeComposition> ContentTypeComposition { get; set;  }

        /// <summary>
-        /// Gets a list of <see cref="PropertyGroup"/> objects from the composition
+        /// Gets the property groups for the entire composition.
        /// </summary>
        IEnumerable<PropertyGroup> CompositionPropertyGroups { get; }

        /// <summary>
-        /// Gets a list of <see cref="PropertyType"/> objects from the composition
+        /// Gets the property types for the entire composition.
        /// </summary>
        IEnumerable<PropertyType> CompositionPropertyTypes { get; }

@@ -12,6 +12,8 @@ namespace Umbraco.Core.Models
        [DataMember]
        ILanguage Language { get; set; }

+        int LanguageId { get; }
+
        /// <summary>
        /// Gets or sets the translated text
        /// </summary>
@@ -0,0 +1,20 @@
+using AutoMapper;
+
+namespace Umbraco.Core.Models.Mapping
+{
+    internal static class MappingExpressionExtensions
+    {
+        /// <summary>
+        /// Ignores all unmapped members by default - Use with caution!
+        /// </summary>
+        /// <typeparam name="TSource"></typeparam>
+        /// <typeparam name="TDest"></typeparam>
+        /// <param name="expression"></param>
+        /// <returns></returns>
+        public static IMappingExpression<TSource, TDest> IgnoreAllUnmapped<TSource, TDest>(this IMappingExpression<TSource, TDest> expression)
+        {
+            expression.ForAllMembers(opt => opt.Ignore());
+            return expression;
+        }
+    }
+}
@@ -118,17 +118,5 @@ namespace Umbraco.Core.Models
            //The Media Recycle Bin Id is -21 so we correct that here
            ParentId = parentId == -20 ? -21 : parentId;
        }
-
-        /// <summary>
-        /// Method to call when Entity is being saved
-        /// </summary>
-        /// <remarks>Created date is set and a Unique key is assigned</remarks>
-        internal override void AddingEntity()
-        {
-            base.AddingEntity();
-
-            if (Key == Guid.Empty)
-                Key = Guid.NewGuid();
-        }
    }
 }
@@ -38,26 +38,5 @@ namespace Umbraco.Core.Models
            : base(parent, alias)
        {
        }
-
-        /// <summary>
-        /// Method to call when Entity is being saved
-        /// </summary>
-        /// <remarks>Created date is set and a Unique key is assigned</remarks>
-        internal override void AddingEntity()
-        {
-            base.AddingEntity();
-
-            if (Key == Guid.Empty)
-                Key = Guid.NewGuid();
-        }
-
-        /// <summary>
-        /// Method to call when Entity is being updated
-        /// </summary>
-        /// <remarks>Modified Date is set and a new Version guid is set</remarks>
-        internal override void UpdatingEntity()
-        {
-            base.UpdatingEntity();
-        }
    }
 }
@@ -509,11 +509,8 @@ namespace Umbraco.Core.Models
        {
            base.AddingEntity();

-            if (Key == Guid.Empty)
-            {
-                Key = Guid.NewGuid();
+            if (ProviderUserKey == null)
                ProviderUserKey = Key;
-            }
        }

        /// <summary>
@@ -60,17 +60,5 @@ namespace Umbraco.Core.Models
        }

        public IDictionary<string, object> AdditionalData { get; private set; }
-
-        /// <summary>
-        /// Method to call when Entity is being saved
-        /// </summary>
-        /// <remarks>Created date is set and a Unique key is assigned</remarks>
-        internal override void AddingEntity()
-        {
-            base.AddingEntity();
-
-            if (Key == Guid.Empty)
-                Key = Guid.NewGuid();
-        }
    }
 }
@@ -131,26 +131,5 @@ namespace Umbraco.Core.Models
                MemberTypePropertyTypes.Add(propertyTypeAlias, tuple);
            }
        }
-
-        /// <summary>
-        /// Method to call when Entity is being saved
-        /// </summary>
-        /// <remarks>Created date is set and a Unique key is assigned</remarks>
-        internal override void AddingEntity()
-        {
-            base.AddingEntity();
-
-            if (Key == Guid.Empty)
-                Key = Guid.NewGuid();
-        }
-
-        /// <summary>
-        /// Method to call when Entity is being updated
-        /// </summary>
-        /// <remarks>Modified Date is set and a new Version guid is set</remarks>
-        internal override void UpdatingEntity()
-        {
-            base.UpdatingEntity();
-        }
    }
 }
@@ -17,7 +17,6 @@ namespace Umbraco.Core.Models
    public class PropertyGroup : Entity, IEquatable<PropertyGroup>
    {
        private string _name;
-        private Lazy<int?> _parentId;
        private int _sortOrder;
        private PropertyTypeCollection _propertyTypes;

@@ -31,7 +30,6 @@ namespace Umbraco.Core.Models
        }

        private static readonly PropertyInfo NameSelector = ExpressionHelper.GetPropertyInfo<PropertyGroup, string>(x => x.Name);
-        private static readonly PropertyInfo ParentIdSelector = ExpressionHelper.GetPropertyInfo<PropertyGroup, int?>(x => x.ParentId);
        private static readonly PropertyInfo SortOrderSelector = ExpressionHelper.GetPropertyInfo<PropertyGroup, int>(x => x.SortOrder);
        private readonly static PropertyInfo PropertyTypeCollectionSelector = ExpressionHelper.GetPropertyInfo<PropertyGroup, PropertyTypeCollection>(x => x.PropertyTypes);
        void PropertyTypesChanged(object sender, NotifyCollectionChangedEventArgs e)
@@ -56,29 +54,6 @@ namespace Umbraco.Core.Models
            }
        }

-        /// <summary>
-        /// 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
-            {
-                if (_parentId == null)
-                    return default(int?);
-                return _parentId.Value;
-            }
-            set
-            {
-                _parentId = new Lazy<int?>(() => value);
-                OnPropertyChanged(ParentIdSelector);
-            }
-        }
-
        /// <summary>
        /// Gets or sets the Sort Order of the Group
        /// </summary>
@@ -117,15 +92,6 @@ 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)
        {
            if (base.Equals(other)) return true;
@@ -9,6 +9,7 @@ using Umbraco.Core.Strings;

 namespace Umbraco.Core.Models
 {
+
    /// <summary>
    /// Defines the type of a <see cref="Property"/> object
    /// </summary>
@@ -32,6 +33,8 @@ namespace Umbraco.Core.Models

        public PropertyType(IDataTypeDefinition dataTypeDefinition)
        {
+            if (dataTypeDefinition == null) throw new ArgumentNullException("dataTypeDefinition");
+
            if(dataTypeDefinition.HasIdentity)
                _dataTypeDefinitionId = dataTypeDefinition.Id;

@@ -401,6 +404,9 @@ namespace Umbraco.Core.Models
                if (DataTypeDatabaseType == DataTypeDatabaseType.Integer && type == typeof(int))
                    return true;

+                if (DataTypeDatabaseType == DataTypeDatabaseType.Decimal && type == typeof(decimal))
+                    return true;
+
                if (DataTypeDatabaseType == DataTypeDatabaseType.Date && type == typeof(DateTime))
                    return true;

@@ -108,18 +108,6 @@ namespace Umbraco.Core.Models
            }
        }

-        /// <summary>
-        /// Method to call on entity saved when first added
-        /// </summary>
-        internal override void AddingEntity()
-        {
-            if (Key == default(Guid))
-            {
-                Key = Guid.NewGuid();
-            }
-            base.AddingEntity();
-        }
-
        [DataMember]
        public int LoginNodeId
        {
@@ -28,18 +28,6 @@ namespace Umbraco.Core.Models
       
        public Guid AccessEntryId { get; internal set; }

-        /// <summary>
-        /// Method to call on entity saved when first added
-        /// </summary>
-        internal override void AddingEntity()
-        {
-            if (Key == default(Guid))
-            {                
-                Key = Guid.NewGuid();       
-            }
-            base.AddingEntity();
-        }
-
        public string RuleValue
        {
            get { return _ruleValue; }
@@ -1,28 +1,28 @@
-using Umbraco.Core.Persistence;
-using Umbraco.Core.Persistence.DatabaseAnnotations;
-
-namespace Umbraco.Core.Models.Rdbms
-{
-    [TableName("cmsDocumentType")]
-    [PrimaryKey("contentTypeNodeId", autoIncrement = false)]
-    [ExplicitColumns]
-    internal class DocumentTypeDto
-    {
-        [Column("contentTypeNodeId")]
-        [PrimaryKeyColumn(AutoIncrement = false, Name = "PK_cmsDocumentType", OnColumns = "contentTypeNodeId, templateNodeId")]
-        [ForeignKey(typeof(ContentTypeDto), Column = "nodeId")]
-        [ForeignKey(typeof(NodeDto))]
-        public int ContentTypeNodeId { get; set; }
-
-        [Column("templateNodeId")]
-        [ForeignKey(typeof(TemplateDto), Column = "nodeId")]
-        public int TemplateNodeId { get; set; }
-
-        [Column("IsDefault")]
-        [Constraint(Default = "0")]
-        public bool IsDefault { get; set; }
-
-        [ResultColumn]
-        public ContentTypeDto ContentTypeDto { get; set; }
-    }
+using Umbraco.Core.Persistence;
+using Umbraco.Core.Persistence.DatabaseAnnotations;
+
+namespace Umbraco.Core.Models.Rdbms
+{
+    [TableName("cmsDocumentType")]
+    [PrimaryKey("contentTypeNodeId", autoIncrement = false)]
+    [ExplicitColumns]
+    internal class ContentTypeTemplateDto
+    {
+        [Column("contentTypeNodeId")]
+        [PrimaryKeyColumn(AutoIncrement = false, Name = "PK_cmsDocumentType", OnColumns = "contentTypeNodeId, templateNodeId")]
+        [ForeignKey(typeof(ContentTypeDto), Column = "nodeId")]
+        [ForeignKey(typeof(NodeDto))]
+        public int ContentTypeNodeId { get; set; }
+
+        [Column("templateNodeId")]
+        [ForeignKey(typeof(TemplateDto), Column = "nodeId")]
+        public int TemplateNodeId { get; set; }
+
+        [Column("IsDefault")]
+        [Constraint(Default = "0")]
+        public bool IsDefault { get; set; }
+
+        [ResultColumn]
+        public ContentTypeDto ContentTypeDto { get; set; }
+    }
 }
@@ -10,12 +10,6 @@ namespace Umbraco.Core.Models.Rdbms
    [ExplicitColumns]
    internal class NodeDto
    {
-        public NodeDto()
-        {
-            //By default, always generate a new guid
-            UniqueId = Guid.NewGuid();
-        }
-
        public const int NodeIdSeed = 1050;

        [Column("id")]
@@ -33,6 +33,10 @@ namespace Umbraco.Core.Models.Rdbms
        [NullSetting(NullSetting = NullSettings.Null)]
        public int? Integer { get; set; }

+        [Column("dataDecimal")]
+        [NullSetting(NullSetting = NullSettings.Null)]
+        public decimal? Decimal { get; set; }
+
        [Column("dataDate")]
        [NullSetting(NullSetting = NullSettings.Null)]
        public DateTime? Date { get; set; }
@@ -55,22 +59,27 @@ namespace Umbraco.Core.Models.Rdbms
        {
            get
            {
-                if(Integer.HasValue)
+                if (Integer.HasValue)
                {
                    return Integer.Value;
                }
+
+                if (Decimal.HasValue)
+                {
+                    return Decimal.Value;
+                }
                
-                if(Date.HasValue)
+                if (Date.HasValue)
                {
                    return Date.Value;
                }
                
-                if(string.IsNullOrEmpty(VarChar) == false)
+                if (string.IsNullOrEmpty(VarChar) == false)
                {
                    return VarChar;
                }

-                if(string.IsNullOrEmpty(Text) == false)
+                if (string.IsNullOrEmpty(Text) == false)
                {
                    return Text;
                }
@@ -10,12 +10,6 @@ namespace Umbraco.Core.Models.Rdbms
    [ExplicitColumns]
    internal class PropertyTypeDto
    {
-        public PropertyTypeDto()
-        {
-            //by default always create a new guid
-            UniqueId = Guid.NewGuid();
-        }
-
        [Column("id")]
        [PrimaryKeyColumn(IdentitySeed = 50)]
        public int Id { get; set; }
@@ -1,6 +1,8 @@
-using System.Collections.Generic;
+using System;
+using System.Collections.Generic;
 using Umbraco.Core.Persistence;
 using Umbraco.Core.Persistence.DatabaseAnnotations;
+using Umbraco.Core.Persistence.DatabaseModelDefinitions;

 namespace Umbraco.Core.Models.Rdbms
 {
@@ -13,12 +15,6 @@ namespace Umbraco.Core.Models.Rdbms
        [PrimaryKeyColumn(IdentitySeed = 12)]
        public int Id { get; set; }

-        [Column("parentGroupId")]
-        [NullSetting(NullSetting = NullSettings.Null)]
-        //[Constraint(Default = "NULL")]
-        [ForeignKey(typeof(PropertyTypeGroupDto))]
-        public int? ParentGroupId { get; set; }
-
        [Column("contenttypeNodeId")]
        [ForeignKey(typeof(ContentTypeDto), Column = "nodeId")]
        public int ContentTypeNodeId { get; set; }
@@ -31,5 +27,11 @@ namespace Umbraco.Core.Models.Rdbms

        [ResultColumn]
        public List<PropertyTypeDto> PropertyTypeDtos { get; set; }
+
+        [Column("uniqueID")]
+        [NullSetting(NullSetting = NullSettings.NotNull)]
+        [Constraint(Default = SystemMethods.NewGuid)]
+        [Index(IndexTypes.UniqueNonClustered, Name = "IX_cmsPropertyTypeGroupUniqueID")]
+        public Guid UniqueId { get; set; }
    }
 }
@@ -10,9 +10,6 @@ namespace Umbraco.Core.Models.Rdbms
        [Column("PropertyTypeGroupId")]
        public int? Id { get; set; }

-        [Column("parentGroupId")]
-        public int? ParentGroupId { get; set; }
-
        [Column("PropertyGroupName")]
        public string Text { get; set; }

@@ -0,0 +1,43 @@
+using System;
+using System.Collections.Generic;
+using Umbraco.Core.Persistence;
+using Umbraco.Core.Persistence.DatabaseAnnotations;
+using Umbraco.Core.Persistence.DatabaseModelDefinitions;
+
+namespace Umbraco.Core.Models.Rdbms
+{
+    [TableName("umbracoDeployChecksum")]
+    [PrimaryKey("id")]
+    [ExplicitColumns]
+    internal class UmbracoDeployChecksumDto
+    {
+        [Column("id")]
+        [PrimaryKeyColumn(Name = "PK_umbracoDeployChecksum")]
+        public int Id { get; set; }
+
+        [Column("entityType")]
+        [Length(32)]
+        [NullSetting(NullSetting = NullSettings.NotNull)]
+        [Index(IndexTypes.UniqueNonClustered, Name = "IX_umbracoDeployChecksum", ForColumns = "entityType,entityGuid,entityPath")]
+        public string EntityType { get; set; }
+
+        [Column("entityGuid")]
+        [NullSetting(NullSetting = NullSettings.Null)]
+        public Guid EntityGuid { get; set; }
+
+        [Column("entityPath")]
+        [Length(256)]
+        [NullSetting(NullSetting = NullSettings.Null)]
+        public string EntityPath { get; set; }
+
+        [Column("localChecksum")]
+        [NullSetting(NullSetting = NullSettings.NotNull)]
+        [Length(32)]
+        public string LocalChecksum { get; set; }
+
+        [Column("compositeChecksum")]
+        [NullSetting(NullSetting = NullSettings.Null)]
+        [Length(32)]
+        public string CompositeChecksum { get; set; }
+    }
+}
@@ -0,0 +1,26 @@
+using Umbraco.Core.Persistence;
+using Umbraco.Core.Persistence.DatabaseAnnotations;
+
+namespace Umbraco.Core.Models.Rdbms
+{
+    [TableName("umbracoDeployDependency")]
+    [ExplicitColumns]
+    internal class UmbracoDeployDependencyDto
+    {   
+        [Column("sourceId")]
+        [PrimaryKeyColumn(AutoIncrement = false, Clustered = true, Name = "PK_umbracoDeployDependency", OnColumns = "sourceId, targetId")]
+        [ForeignKey(typeof(UmbracoDeployChecksumDto), Name = "FK_umbracoDeployDependency_umbracoDeployChecksum_id1")]
+        [NullSetting(NullSetting = NullSettings.NotNull)]
+        public int SourceId { get; set; }
+
+        [Column("targetId")]
+        [ForeignKey(typeof(UmbracoDeployChecksumDto), Name = "FK_umbracoDeployDependency_umbracoDeployChecksum_id2")]
+        [NullSetting(NullSetting = NullSettings.NotNull)]
+        public int TargetId { get; set; }
+
+        [Column("mode")]
+        [NullSetting(NullSetting = NullSettings.NotNull)]
+        public int Mode { get; set; }
+
+    }
+}
@@ -118,18 +118,6 @@ namespace Umbraco.Core.Models
            return ApplicationContext.Current.Services.FileService.DetermineTemplateRenderingEngine(this);
        }

-        /// <summary>
-        /// Method to call when Entity is being saved
-        /// </summary>
-        /// <remarks>Created date is set and a Unique key is assigned</remarks>
-        internal override void AddingEntity()
-        {
-            base.AddingEntity();
-
-            if (Key == Guid.Empty)
-                Key = Guid.NewGuid();
-        }
-
        public void SetMasterTemplate(ITemplate masterTemplate)
        {
            if (masterTemplate == null)
@@ -11,7 +11,7 @@ namespace Umbraco.Core.Models
    /// <summary>
    /// Implementation of the <see cref="IUmbracoEntity"/> for internal use.
    /// </summary>
-    internal class UmbracoEntity : Entity, IUmbracoEntity
+    public class UmbracoEntity : Entity, IUmbracoEntity
    {
        private int _creatorId;
        private int _level;
@@ -11,6 +11,20 @@ namespace Umbraco.Core.Models
    internal static class UmbracoEntityExtensions
    {

+        public static bool HasChildren(this IUmbracoEntity entity)
+        {
+            if (entity.AdditionalData.ContainsKey("HasChildren"))
+            {
+                var convert = entity.AdditionalData["HasChildren"].TryConvertTo<bool>();
+                if (convert)
+                {
+                    return convert.Result;
+                }
+            }
+            return false;
+        }
+
+    
        public static object GetAdditionalDataValueIgnoreCase(this IUmbracoEntity entity, string key, object defaultVal)
        {
            if (entity.AdditionalData.ContainsKeyIgnoreCase(key) == false) return defaultVal;
@@ -15,49 +15,49 @@ namespace Umbraco.Core.Models
        /// <summary>
        /// Content Item Type
        /// </summary>
-        [UmbracoObjectTypeAttribute(Constants.ObjectTypes.ContentItemType)]
+        [UmbracoObjectType(Constants.ObjectTypes.ContentItemType)]
        [FriendlyName("Content Item Type")]
        ContentItemType,

        /// <summary>
        /// Root
        /// </summary>
-        [UmbracoObjectTypeAttribute(Constants.ObjectTypes.SystemRoot)]
+        [UmbracoObjectType(Constants.ObjectTypes.SystemRoot)]
        [FriendlyName("Root")]
        ROOT,

        /// <summary>
        /// Document
        /// </summary>
-        [UmbracoObjectTypeAttribute(Constants.ObjectTypes.Document, typeof(IContent))]
+        [UmbracoObjectType(Constants.ObjectTypes.Document, typeof(IContent))]
        [FriendlyName("Document")]
        Document,

        /// <summary>
        /// Media
        /// </summary>
-        [UmbracoObjectTypeAttribute(Constants.ObjectTypes.Media, typeof(IMedia))]
+        [UmbracoObjectType(Constants.ObjectTypes.Media, typeof(IMedia))]
        [FriendlyName("Media")]
        Media,

        /// <summary>
        /// Member Type
        /// </summary>
-        [UmbracoObjectTypeAttribute(Constants.ObjectTypes.MemberType, typeof(IMemberType))]
+        [UmbracoObjectType(Constants.ObjectTypes.MemberType, typeof(IMemberType))]
        [FriendlyName("Member Type")]
        MemberType,

        /// <summary>
        /// Template
        /// </summary>
-        [UmbracoObjectTypeAttribute(Constants.ObjectTypes.Template, typeof(ITemplate))]
+        [UmbracoObjectType(Constants.ObjectTypes.Template, typeof(ITemplate))]
        [FriendlyName("Template")]
        Template,

        /// <summary>
        /// Member Group
        /// </summary>
-        [UmbracoObjectTypeAttribute(Constants.ObjectTypes.MemberGroup)]
+        [UmbracoObjectType(Constants.ObjectTypes.MemberGroup)]
        [FriendlyName("Member Group")]
        MemberGroup,

@@ -65,50 +65,73 @@ namespace Umbraco.Core.Models
        /// <summary>
        /// Content Item
        /// </summary>
-        [UmbracoObjectTypeAttribute(Constants.ObjectTypes.ContentItem)]
+        [UmbracoObjectType(Constants.ObjectTypes.ContentItem)]
        [FriendlyName("Content Item")]
        ContentItem,

        /// <summary>
        /// "Media Type
        /// </summary>
-        [UmbracoObjectTypeAttribute(Constants.ObjectTypes.MediaType, typeof(IMediaType))]
+        [UmbracoObjectType(Constants.ObjectTypes.MediaType, typeof(IMediaType))]
        [FriendlyName("Media Type")]
        MediaType,

        /// <summary>
        /// Document Type
        /// </summary>
-        [UmbracoObjectTypeAttribute(Constants.ObjectTypes.DocumentType, typeof(IContentType))]
+        [UmbracoObjectType(Constants.ObjectTypes.DocumentType, typeof(IContentType))]
        [FriendlyName("Document Type")]
        DocumentType,

        /// <summary>
        /// Recycle Bin
        /// </summary>
-        [UmbracoObjectTypeAttribute(Constants.ObjectTypes.ContentRecycleBin)]
+        [UmbracoObjectType(Constants.ObjectTypes.ContentRecycleBin)]
        [FriendlyName("Recycle Bin")]
        RecycleBin,

        /// <summary>
        /// Stylesheet
        /// </summary>
-        [UmbracoObjectTypeAttribute(Constants.ObjectTypes.Stylesheet)]
+        [UmbracoObjectType(Constants.ObjectTypes.Stylesheet)]
        [FriendlyName("Stylesheet")]
        Stylesheet,

        /// <summary>
        /// Member
        /// </summary>
-        [UmbracoObjectTypeAttribute(Constants.ObjectTypes.Member, typeof(IMember))]
+        [UmbracoObjectType(Constants.ObjectTypes.Member, typeof(IMember))]
        [FriendlyName("Member")]
        Member,

        /// <summary>
        /// Data Type
        /// </summary>
-        [UmbracoObjectTypeAttribute(Constants.ObjectTypes.DataType, typeof(IDataTypeDefinition))]
+        [UmbracoObjectType(Constants.ObjectTypes.DataType, typeof(IDataTypeDefinition))]
        [FriendlyName("Data Type")]
-        DataType
+        DataType,
+
+        /// <summary>
+        /// Document type container
+        /// </summary>
+        [UmbracoObjectType(Constants.ObjectTypes.DocumentTypeContainer)]
+        [FriendlyName("Document Type Container")]
+        DocumentTypeContainer,
+
+        /// <summary>
+        /// Media type container
+        /// </summary>
+        [UmbracoObjectType(Constants.ObjectTypes.MediaTypeContainer)]
+        [FriendlyName("Media Type Container")]
+        MediaTypeContainer,
+
+        /// <summary>
+        /// Media type container
+        /// </summary>
+        [UmbracoObjectType(Constants.ObjectTypes.DataTypeContainer)]
+        [FriendlyName("Data Type Container")]
+        DataTypeContainer
+
+
    }
 }
@@ -1,15 +1,10 @@
 using System;
 using System.Collections;
-using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.ComponentModel;
-using System.IO;
 using System.Linq;
 using System.Linq.Expressions;
 using System.Reflection;
-using System.Runtime.Serialization;
-using System.Runtime.Serialization.Formatters.Binary;
-using System.Security;
 using System.Xml;

 namespace Umbraco.Core
@@ -51,7 +46,7 @@ namespace Umbraco.Core
 		public static Attempt<T> TryConvertTo<T>(this object input)
 		{
 			var result = TryConvertTo(input, typeof(T));
-            if (!result.Success)
+            if (result.Success == false)
            {
                //just try a straight up conversion
                try
@@ -64,7 +59,7 @@ namespace Umbraco.Core
                    return Attempt<T>.Fail(e);
                }
            }
-			return !result.Success ? Attempt<T>.Fail() : Attempt<T>.Succeed((T)result.Result);
+			return result.Success == false ? Attempt<T>.Fail() : Attempt<T>.Succeed((T)result.Result);
 		}

 		/// <summary>
@@ -117,7 +112,7 @@ namespace Umbraco.Core
 			}

 			// we've already dealed with nullables, so any other generic types need to fall through
-			if (!destinationType.IsGenericType)
+			if (destinationType.IsGenericType == false)
 			{
 				if (input is string)
 				{
@@ -335,11 +330,11 @@ namespace Umbraco.Core
 			return null; // we can't decide...
 		}

-        private readonly static char[] NumberDecimalSeparatorsToNormalize = new[] {'.', ','};
+        private static readonly char[] NumberDecimalSeparatorsToNormalize = new[] {'.', ','};

 	    private static string NormalizeNumberDecimalSeparator(string s)
 	    {
-	        var normalized = System.Threading.Thread.CurrentThread.CurrentUICulture.NumberFormat.NumberDecimalSeparator[0];
+	        var normalized = System.Threading.Thread.CurrentThread.CurrentCulture.NumberFormat.NumberDecimalSeparator[0];
            return s.ReplaceMany(NumberDecimalSeparatorsToNormalize, normalized);
 	    }

@@ -442,7 +437,7 @@ namespace Umbraco.Core
 			{
 				var props = TypeDescriptor.GetProperties(o);
 				var d = new Dictionary<string, TVal>();
-				foreach (var prop in props.Cast<PropertyDescriptor>().Where(x => !ignoreProperties.Contains(x.Name)))
+				foreach (var prop in props.Cast<PropertyDescriptor>().Where(x => ignoreProperties.Contains(x.Name) == false))
 				{
 					var val = prop.GetValue(o);
 					if (val != null)
@@ -478,13 +473,13 @@ namespace Umbraco.Core

 					var items = (from object enumItem in enumerable let value = GetEnumPropertyDebugString(enumItem, levels) where value != null select value).Take(10).ToList();

-					return items.Count() > 0
+					return items.Any()
 							? "{{ {0} }}".InvariantFormat(String.Join(", ", items))
 							: null;
 				}

 				var props = obj.GetType().GetProperties();
-				if ((props.Count() == 2) && props[0].Name == "Key" && props[1].Name == "Value" && levels > -2)
+				if ((props.Length == 2) && props[0].Name == "Key" && props[1].Name == "Value" && levels > -2)
 				{
 					try
 					{
@@ -500,12 +495,12 @@ namespace Umbraco.Core
 				if (levels > -1)
 				{
 					var items =
-						from propertyInfo in props
+						(from propertyInfo in props
 						let value = GetPropertyDebugString(propertyInfo, obj, levels)
 						where value != null
-						select "{0}={1}".InvariantFormat(propertyInfo.Name, value);
+						select "{0}={1}".InvariantFormat(propertyInfo.Name, value)).ToArray();

-					return items.Count() > 0
+					return items.Any()
 							? "[{0}]:{{ {1} }}".InvariantFormat(obj.GetType().Name, String.Join(", ", items))
 							: null;
 				}
@@ -1,98 +1,144 @@
 using System;
+using System.Collections.Generic;
 using System.Globalization;
+using System.Linq;
 using Umbraco.Core.Models;
+using Umbraco.Core.Models.EntityBase;
 using Umbraco.Core.Models.Membership;
 using Umbraco.Core.Models.Rdbms;

 namespace Umbraco.Core.Persistence.Factories
 {
+    // factory for
+    // IContentType (document types)
+    // IMediaType (media types)
+    // IMemberType (member types)
+    //
    internal class ContentTypeFactory 
    {
-        private readonly Guid _nodeObjectType;
+        #region IContentType

-        public ContentTypeFactory(Guid nodeObjectType)
+        public IContentType BuildContentTypeEntity(ContentTypeDto dto)
        {
-            _nodeObjectType = nodeObjectType;
-        }
+            var contentType = new ContentType(dto.NodeDto.ParentId);
+            BuildCommonEntity(contentType, dto);

-        #region Implementation of IEntityFactory<IContentType,DocumentTypeDto>
-
-        public IContentType BuildEntity(DocumentTypeDto dto)
-        {
-            var contentType = new ContentType(dto.ContentTypeDto.NodeDto.ParentId)
-                                  {
-                                      Id = dto.ContentTypeDto.NodeDto.NodeId,
-                                      Key = dto.ContentTypeDto.NodeDto.UniqueId,
-                                      Alias = dto.ContentTypeDto.Alias,
-                                      Name = dto.ContentTypeDto.NodeDto.Text,
-                                      Icon = dto.ContentTypeDto.Icon,
-                                      Thumbnail = dto.ContentTypeDto.Thumbnail,
-                                      SortOrder = dto.ContentTypeDto.NodeDto.SortOrder,
-                                      Description = dto.ContentTypeDto.Description,
-                                      CreateDate = dto.ContentTypeDto.NodeDto.CreateDate,
-                                      Path = dto.ContentTypeDto.NodeDto.Path,
-                                      Level = dto.ContentTypeDto.NodeDto.Level,
-                                      CreatorId = dto.ContentTypeDto.NodeDto.UserId.Value,
-                                      AllowedAsRoot = dto.ContentTypeDto.AllowAtRoot,
-                                      IsContainer = dto.ContentTypeDto.IsContainer,
-                                      Trashed = dto.ContentTypeDto.NodeDto.Trashed,
-                                      DefaultTemplateId = dto.TemplateNodeId
-                                  };
            //on initial construction we don't want to have dirty properties tracked
            // http://issues.umbraco.org/issue/U4-1946
            contentType.ResetDirtyProperties(false);
-            return contentType;
-        }

-        public DocumentTypeDto BuildDto(IContentType entity)
-        {
-            var documentTypeDto = new DocumentTypeDto
-                                      {ContentTypeDto = BuildContentTypeDto(entity), ContentTypeNodeId = entity.Id};
-            
-            var contentType = entity as ContentType;
-            if(contentType != null)
-            {
-                documentTypeDto.TemplateNodeId = contentType.DefaultTemplateId;
-                documentTypeDto.IsDefault = true;
-            }
-            return documentTypeDto;
+            return contentType;
        }

        #endregion

-        private ContentTypeDto BuildContentTypeDto(IContentType entity)
+        #region IMediaType
+
+        public IMediaType BuildMediaTypeEntity(ContentTypeDto dto)
        {
+            var contentType = new MediaType(dto.NodeDto.ParentId);
+            BuildCommonEntity(contentType, dto);
+
+            //on initial construction we don't want to have dirty properties tracked
+            // http://issues.umbraco.org/issue/U4-1946
+            contentType.ResetDirtyProperties(false);
+
+            return contentType;
+        }
+
+        #endregion
+
+        #region IMemberType
+
+        public IMemberType BuildMemberTypeEntity(ContentTypeDto dto)
+        {
+            throw new NotImplementedException();
+        }
+
+        public IEnumerable<MemberTypeDto> BuildMemberTypeDtos(IMemberType entity)
+        {
+            var memberType = entity as MemberType;
+            if (memberType == null || memberType.PropertyTypes.Any() == false)
+                return Enumerable.Empty<MemberTypeDto>();
+
+            var dtos = memberType.PropertyTypes.Select(x => new MemberTypeDto
+            {
+                NodeId = entity.Id,
+                PropertyTypeId = x.Id,
+                CanEdit = memberType.MemberCanEditProperty(x.Alias),
+                ViewOnProfile = memberType.MemberCanViewProperty(x.Alias)
+            }).ToList();
+            return dtos;
+        }
+
+        #endregion
+
+        #region Common
+
+        private static void BuildCommonEntity(ContentTypeBase entity, ContentTypeDto dto)
+        {
+            entity.Id = dto.NodeDto.NodeId;
+            entity.Key = dto.NodeDto.UniqueId;
+            entity.Alias = dto.Alias;
+            entity.Name = dto.NodeDto.Text;
+            entity.Icon = dto.Icon;
+            entity.Thumbnail = dto.Thumbnail;
+            entity.SortOrder = dto.NodeDto.SortOrder;
+            entity.Description = dto.Description;
+            entity.CreateDate = dto.NodeDto.CreateDate;
+            entity.Path = dto.NodeDto.Path;
+            entity.Level = dto.NodeDto.Level;
+            entity.CreatorId = dto.NodeDto.UserId.Value;
+            entity.AllowedAsRoot = dto.AllowAtRoot;
+            entity.IsContainer = dto.IsContainer;
+            entity.Trashed = dto.NodeDto.Trashed;
+        }
+
+        public ContentTypeDto BuildContentTypeDto(IContentTypeBase entity)
+        {
+            Guid nodeObjectType;
+            if (entity is IContentType)
+                nodeObjectType = Constants.ObjectTypes.DocumentTypeGuid;
+            else if (entity is IMediaType)
+                nodeObjectType = Constants.ObjectTypes.MediaTypeGuid;
+            else if (entity is IMemberType)
+                nodeObjectType = Constants.ObjectTypes.MemberTypeGuid;
+            else
+                throw new Exception("oops: invalid entity.");
+
            var contentTypeDto = new ContentTypeDto
-                                     {
-                                         Alias = entity.Alias,
-                                         Description = entity.Description,
-                                         Icon = entity.Icon,
-                                         Thumbnail = entity.Thumbnail,
-                                         NodeId = entity.Id,
-                                         AllowAtRoot = entity.AllowedAsRoot,
-                                         IsContainer = entity.IsContainer,
-                                         NodeDto = BuildNodeDto(entity)
-                                     };
+            {
+                Alias = entity.Alias,
+                Description = entity.Description,
+                Icon = entity.Icon,
+                Thumbnail = entity.Thumbnail,
+                NodeId = entity.Id,
+                AllowAtRoot = entity.AllowedAsRoot,
+                IsContainer = entity.IsContainer,
+                NodeDto = BuildNodeDto(entity, nodeObjectType)
+            };
            return contentTypeDto;
        }

-        private NodeDto BuildNodeDto(IContentType entity)
+        private static NodeDto BuildNodeDto(IUmbracoEntity entity, Guid nodeObjectType)
        {
            var nodeDto = new NodeDto
-                              {
-                                  CreateDate = entity.CreateDate,
-                                  NodeId = entity.Id,
-                                  Level = short.Parse(entity.Level.ToString(CultureInfo.InvariantCulture)),
-                                  NodeObjectType = _nodeObjectType,
-                                  ParentId = entity.ParentId,
-                                  Path = entity.Path,
-                                  SortOrder = entity.SortOrder,
-                                  Text = entity.Name,
-                                  Trashed = false,
-                                  UniqueId = entity.Key,
-                                  UserId = entity.CreatorId
-                              };
+            {
+                CreateDate = entity.CreateDate,
+                NodeId = entity.Id,
+                Level = short.Parse(entity.Level.ToString(CultureInfo.InvariantCulture)),
+                NodeObjectType = nodeObjectType,
+                ParentId = entity.ParentId,
+                Path = entity.Path,
+                SortOrder = entity.SortOrder,
+                Text = entity.Name,
+                Trashed = false,
+                UniqueId = entity.Key,
+                UserId = entity.CreatorId
+            };
            return nodeDto;
        }
+
+        #endregion
    }
 }
@@ -42,7 +42,7 @@ namespace Umbraco.Core.Persistence.Factories
            {
                var text = new LanguageTextDto
                               {
-                                   LanguageId = translation.Language.Id,
+                                   LanguageId = translation.LanguageId,
                                   UniqueId = translation.Key,
                                   Value = translation.Value
                               };
@@ -7,20 +7,19 @@ namespace Umbraco.Core.Persistence.Factories
    internal class DictionaryTranslationFactory 
    {
        private readonly Guid _uniqueId;
-        private ILanguage _language;

-        public DictionaryTranslationFactory(Guid uniqueId, ILanguage language)
+        public DictionaryTranslationFactory(Guid uniqueId)
        {
            _uniqueId = uniqueId;
-            _language = language;
        }

        #region Implementation of IEntityFactory<DictionaryTranslation,LanguageTextDto>

        public IDictionaryTranslation BuildEntity(LanguageTextDto dto)
        {
-            var item = new DictionaryTranslation(_language, dto.Value, _uniqueId) 
+            var item = new DictionaryTranslation(dto.LanguageId, dto.Value, _uniqueId) 
                                            {Id = dto.PrimaryKey};
+
            //on initial construction we don't want to have dirty properties tracked
            // http://issues.umbraco.org/issue/U4-1946
            item.ResetDirtyProperties(false);
@@ -31,7 +30,7 @@ namespace Umbraco.Core.Persistence.Factories
        {
            var text = new LanguageTextDto
                           {
-                               LanguageId = entity.Language.Id,
+                               LanguageId = entity.LanguageId,
                               UniqueId = _uniqueId,
                               Value = entity.Value
                           };
@@ -1,82 +0,0 @@
-using System;
-using System.Globalization;
-using Umbraco.Core.Models;
-using Umbraco.Core.Models.Rdbms;
-
-namespace Umbraco.Core.Persistence.Factories
-{
-    internal class MediaTypeFactory 
-    {
-        private readonly Guid _nodeObjectType;
-
-        public MediaTypeFactory(Guid nodeObjectType)
-        {
-            _nodeObjectType = nodeObjectType;
-        }
-
-        #region Implementation of IEntityFactory<IMediaType,ContentTypeDto>
-
-        public IMediaType BuildEntity(ContentTypeDto dto)
-        {
-            var contentType = new MediaType(dto.NodeDto.ParentId)
-                                  {
-                                      Id = dto.NodeDto.NodeId,
-                                      Key = dto.NodeDto.UniqueId,
-                                      Alias = dto.Alias,
-                                      Name = dto.NodeDto.Text,
-                                      Icon = dto.Icon,
-                                      Thumbnail = dto.Thumbnail,
-                                      SortOrder = dto.NodeDto.SortOrder,
-                                      Description = dto.Description,
-                                      CreateDate = dto.NodeDto.CreateDate,
-                                      Path = dto.NodeDto.Path,
-                                      Level = dto.NodeDto.Level,
-                                      CreatorId = dto.NodeDto.UserId.Value,
-                                      AllowedAsRoot = dto.AllowAtRoot,
-                                      IsContainer = dto.IsContainer,
-                                      Trashed = dto.NodeDto.Trashed
-                                  };
-            //on initial construction we don't want to have dirty properties tracked
-            // http://issues.umbraco.org/issue/U4-1946
-            contentType.ResetDirtyProperties(false);
-            return contentType;
-        }
-
-        public ContentTypeDto BuildDto(IMediaType entity)
-        {
-            var contentTypeDto = new ContentTypeDto
-                                     {
-                                         Alias = entity.Alias,
-                                         Description = entity.Description,
-                                         Icon = entity.Icon,
-                                         Thumbnail = entity.Thumbnail,
-                                         NodeId = entity.Id,
-                                         AllowAtRoot = entity.AllowedAsRoot,
-                                         IsContainer = entity.IsContainer,
-                                         NodeDto = BuildNodeDto(entity)
-                                     };
-            return contentTypeDto;
-        }
-
-        #endregion
-
-        private NodeDto BuildNodeDto(IMediaType entity)
-        {
-            var nodeDto = new NodeDto
-                              {
-                                  CreateDate = entity.CreateDate,
-                                  NodeId = entity.Id,
-                                  Level = short.Parse(entity.Level.ToString(CultureInfo.InvariantCulture)),
-                                  NodeObjectType = _nodeObjectType,
-                                  ParentId = entity.ParentId,
-                                  Path = entity.Path,
-                                  SortOrder = entity.SortOrder,
-                                  Text = entity.Name,
-                                  Trashed = false,
-                                  UniqueId = entity.Key,
-                                  UserId = entity.CreatorId
-                              };
-            return nodeDto;
-        }
-    }
-}
@@ -1,94 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Globalization;
-using System.Linq;
-using Umbraco.Core.Models;
-using Umbraco.Core.Models.Rdbms;
-
-namespace Umbraco.Core.Persistence.Factories
-{
-    internal class MemberTypeFactory 
-    {
-        private readonly Guid _nodeObjectType;
-
-        public MemberTypeFactory(Guid nodeObjectType)
-        {
-            _nodeObjectType = nodeObjectType;
-        }
-
-        public IMemberType BuildEntity(ContentTypeDto dto)
-        {
-            throw new System.NotImplementedException();
-        }
-
-        public ContentTypeDto BuildDto(IMemberType entity)
-        {
-            var contentTypeDto = new ContentTypeDto
-                                     {
-                                         Alias = entity.Alias,
-                                         Description = entity.Description,
-                                         Icon = entity.Icon,
-                                         Thumbnail = entity.Thumbnail,
-                                         NodeId = entity.Id,
-                                         AllowAtRoot = entity.AllowedAsRoot,
-                                         IsContainer = entity.IsContainer,
-                                         NodeDto = BuildNodeDto(entity)
-                                     };
-            return contentTypeDto;
-        }
-
-        public IEnumerable<MemberTypeDto> BuildMemberTypeDtos(IMemberType entity)
-        {
-            var memberType = entity as MemberType;
-            if (memberType == null ||  memberType.PropertyTypes.Any() == false)
-                return Enumerable.Empty<MemberTypeDto>();
-
-            var memberTypes = new List<MemberTypeDto>();
-            foreach (var propertyType in memberType.PropertyTypes)
-            {
-                memberTypes.Add(new MemberTypeDto
-                                {
-                                    NodeId = entity.Id,
-                                    PropertyTypeId = propertyType.Id,
-                                    CanEdit = memberType.MemberCanEditProperty(propertyType.Alias),
-                                    ViewOnProfile = memberType.MemberCanViewProperty(propertyType.Alias)
-                                });
-            }
-
-            return memberTypes;
-        }
-
-        private NodeDto BuildNodeDto(IMemberType entity)
-        {
-            var nodeDto = new NodeDto
-                              {
-                                  CreateDate = entity.CreateDate,
-                                  NodeId = entity.Id,
-                                  Level = short.Parse(entity.Level.ToString(CultureInfo.InvariantCulture)),
-                                  NodeObjectType = _nodeObjectType,
-                                  ParentId = entity.ParentId,
-                                  Path = entity.Path,
-                                  SortOrder = entity.SortOrder,
-                                  Text = entity.Name,
-                                  Trashed = false,
-                                  UniqueId = entity.Key,
-                                  UserId = entity.CreatorId
-                              };
-            return nodeDto;
-        }
-
-        private int DeterminePropertyTypeId(int initialId, string alias, IEnumerable<PropertyType> propertyTypes)
-        {
-            if (initialId == 0 || initialId == default(int))
-            {
-                var propertyType = propertyTypes.SingleOrDefault(x => x.Alias.Equals(alias));
-                if (propertyType == null)
-                    return default(int);
-
-                return propertyType.Id;
-            }
-
-            return initialId;
-        }
-    }
-}
@@ -51,31 +51,28 @@ namespace Umbraco.Core.Persistence.Factories
                memberType.MemberTypePropertyTypes.Add(standardPropertyType.Key,
                    new MemberTypePropertyProfileAccess(false, false));
            }
-            memberType.PropertyTypes = propertyTypes;
+            memberType.NoGroupPropertyTypes = propertyTypes;

            return memberType;
        }

        private PropertyGroupCollection GetPropertyTypeGroupCollection(MemberTypeReadOnlyDto dto, MemberType memberType, Dictionary<string, PropertyType> standardProps)
        {
-            var propertyGroups = new PropertyGroupCollection();            
-            
+            // see PropertyGroupFactory, repeating code here...
+
+            var propertyGroups = new PropertyGroupCollection();
            foreach (var groupDto in dto.PropertyTypeGroups.Where(x => x.Id.HasValue))
            {
                var group = new PropertyGroup();
-               
-                //Only assign an Id if the PropertyGroup belongs to this ContentType
+
+                // if the group is defined on the current member type,
+                // assign its identifier, else it will be zero
                if (groupDto.ContentTypeNodeId == memberType.Id)
                {
+                    // note: no idea why Id is nullable here, but better check
+                    if (groupDto.Id.HasValue == false)
+                        throw new Exception("oops: groupDto.Id has no value.");
                    group.Id = groupDto.Id.Value;
-
-                    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;
@@ -63,7 +63,9 @@ namespace Umbraco.Core.Persistence.Factories

                //Check if property has an Id and set it, so that it can be updated if it already exists
                if (property.HasIdentity)
+                {
                    dto.Id = property.Id;
+                }

                if (property.DataTypeDatabaseType == DataTypeDatabaseType.Integer)
                {
@@ -82,11 +84,21 @@ namespace Umbraco.Core.Persistence.Factories
                        }
                    }
                }
+                else if (property.DataTypeDatabaseType == DataTypeDatabaseType.Decimal && property.Value != null)
+                {
+                    decimal val;
+                    if (decimal.TryParse(property.Value.ToString(), out val))
+                    {
+                        dto.Decimal = val;
+                    }
+                }
                else if (property.DataTypeDatabaseType == DataTypeDatabaseType.Date && property.Value != null && string.IsNullOrWhiteSpace(property.Value.ToString()) == false)
                {
                    DateTime date;
-                    if(DateTime.TryParse(property.Value.ToString(), out date))
+                    if (DateTime.TryParse(property.Value.ToString(), out date))
+                    {
                        dto.Date = date;
+                    }
                }
                else if (property.DataTypeDatabaseType == DataTypeDatabaseType.Ntext && property.Value != null)
                {
@@ -8,21 +8,21 @@ namespace Umbraco.Core.Persistence.Factories
 {
    internal class PropertyGroupFactory 
    {
-        private readonly int _id;
+        private readonly int _contentTypeId;
        private readonly DateTime _createDate;
        private readonly DateTime _updateDate;
        //a callback to create a property type which can be injected via a contructor
        private readonly Func<string, DataTypeDatabaseType, string, PropertyType> _propertyTypeCtor;

-        public PropertyGroupFactory(int id)
+        public PropertyGroupFactory(int contentTypeId)
        {
-            _id = id;
+            _contentTypeId = contentTypeId;
            _propertyTypeCtor = (propertyEditorAlias, dbType, alias) => new PropertyType(propertyEditorAlias, dbType);
        }

-        public PropertyGroupFactory(int id, DateTime createDate, DateTime updateDate, Func<string, DataTypeDatabaseType, string, PropertyType> propertyTypeCtor)
+        public PropertyGroupFactory(int contentTypeId, DateTime createDate, DateTime updateDate, Func<string, DataTypeDatabaseType, string, PropertyType> propertyTypeCtor)
        {
-            _id = id;
+            _contentTypeId = contentTypeId;
            _createDate = createDate;
            _updateDate = updateDate;
            _propertyTypeCtor = propertyTypeCtor;
@@ -30,29 +30,24 @@ namespace Umbraco.Core.Persistence.Factories

        #region Implementation of IEntityFactory<IEnumerable<PropertyGroup>,IEnumerable<TabDto>>

-        public IEnumerable<PropertyGroup> BuildEntity(IEnumerable<PropertyTypeGroupDto> dto)
+        public IEnumerable<PropertyGroup> BuildEntity(IEnumerable<PropertyTypeGroupDto> groupDtos)
        {
+            // groupDtos contains all the groups, those that are defined on the current
+            // content type, and those that are inherited from composition content types
            var propertyGroups = new PropertyGroupCollection();
-            foreach (var groupDto in dto)
+            foreach (var groupDto in groupDtos)
            {
                var group = new PropertyGroup();
-                //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;
-                }
+                // if the group is defined on the current content type,
+                // assign its identifier, else it will be zero
+                if (groupDto.ContentTypeNodeId == _contentTypeId)
+                    group.Id = groupDto.Id;

                group.Name = groupDto.Text;
                group.SortOrder = groupDto.SortOrder;
                group.PropertyTypes = new PropertyTypeCollection();
+                group.Key = groupDto.UniqueId;

                //Because we are likely to have a group with no PropertyTypes we need to ensure that these are excluded
                var typeDtos = groupDto.PropertyTypeDtos.Where(x => x.Id > 0);
@@ -101,14 +96,12 @@ namespace Umbraco.Core.Persistence.Factories
        {
            var dto = new PropertyTypeGroupDto
                             {
-                                 ContentTypeNodeId = _id,
+                                 ContentTypeNodeId = _contentTypeId,
                                 SortOrder = propertyGroup.SortOrder,
-                                 Text = propertyGroup.Name
+                                 Text = propertyGroup.Name,
+                                 UniqueId = propertyGroup.Key
                             };

-            if (propertyGroup.ParentId.HasValue)
-                dto.ParentGroupId = propertyGroup.ParentId.Value;
-
            if (propertyGroup.HasIdentity)
                dto.Id = propertyGroup.Id;

@@ -122,18 +115,14 @@ namespace Umbraco.Core.Persistence.Factories
            var propertyTypeDto = new PropertyTypeDto
            {
                Alias = propertyType.Alias,
-                ContentTypeId = _id,
+                ContentTypeId = _contentTypeId,
                DataTypeId = propertyType.DataTypeDefinitionId,
                Description = propertyType.Description,
                Mandatory = propertyType.Mandatory,
                Name = propertyType.Name,
                SortOrder = propertyType.SortOrder,
                ValidationRegExp = propertyType.ValidationRegExp,
-                UniqueId = propertyType.HasIdentity
-                    ? propertyType.Key == Guid.Empty
-                        ? Guid.NewGuid()
-                        : propertyType.Key
-                    : Guid.NewGuid()
+                UniqueId = propertyType.Key
            };

            if (tabId != default(int))
@@ -32,7 +32,7 @@ namespace Umbraco.Core.Persistence.Mappers
        internal override void BuildMap()
        {
            CacheMap<PropertyGroup, PropertyTypeGroupDto>(src => src.Id, dto => dto.Id);
-            CacheMap<PropertyGroup, PropertyTypeGroupDto>(src => src.ParentId, dto => dto.ParentGroupId);
+            CacheMap<PropertyGroup, PropertyTypeGroupDto>(src => src.Key, dto => dto.UniqueId);
            CacheMap<PropertyGroup, PropertyTypeGroupDto>(src => src.SortOrder, dto => dto.SortOrder);
            CacheMap<PropertyGroup, PropertyTypeGroupDto>(src => src.Name, dto => dto.Text);
        }
@@ -39,6 +39,7 @@ namespace Umbraco.Core.Persistence.Mappers
            {
                CacheMap<Template, TemplateDto>(src => src.Id, dto => dto.NodeId);
                CacheMap<Template, NodeDto>(src => src.MasterTemplateId, dto => dto.ParentId);
+                CacheMap<Template, NodeDto>(src => src.Key, dto => dto.UniqueId);
                CacheMap<Template, TemplateDto>(src => src.Alias, dto => dto.Alias);
                CacheMap<Template, TemplateDto>(src => src.Content, dto => dto.Design);
            }
@@ -117,8 +117,7 @@ namespace Umbraco.Core.Persistence.Migrations.Initial
            _database.Insert("umbracoNode", "id", false, new NodeDto { NodeId = -42, Trashed = false, ParentId = -1, UserId = 0, Level = 1, Path = "-1,-42", SortOrder = 2, UniqueId = new Guid("0b6a45e7-44ba-430d-9da5-4e46060b9e03"), Text = "Dropdown", NodeObjectType = new Guid(Constants.ObjectTypes.DataType), CreateDate = DateTime.Now });
            _database.Insert("umbracoNode", "id", false, new NodeDto { NodeId = -41, Trashed = false, ParentId = -1, UserId = 0, Level = 1, Path = "-1,-41", SortOrder = 2, UniqueId = new Guid("5046194e-4237-453c-a547-15db3a07c4e1"), Text = "Date Picker", NodeObjectType = new Guid(Constants.ObjectTypes.DataType), CreateDate = DateTime.Now });
            _database.Insert("umbracoNode", "id", false, new NodeDto { NodeId = -40, Trashed = false, ParentId = -1, UserId = 0, Level = 1, Path = "-1,-40", SortOrder = 2, UniqueId = new Guid("bb5f57c9-ce2b-4bb9-b697-4caca783a805"), Text = "Radiobox", NodeObjectType = new Guid(Constants.ObjectTypes.DataType), CreateDate = DateTime.Now });
-            _database.Insert("umbracoNode", "id", false, new NodeDto { NodeId = -39, Trashed = false, ParentId = -1, UserId = 0, Level = 1, Path = "-1,-39", SortOrder = 2, UniqueId = new Guid("f38f0ac7-1d27-439c-9f3f-089cd8825a53"), Text = "Dropdown multiple", NodeObjectType = new Guid(Constants.ObjectTypes.DataType), CreateDate = DateTime.Now });
-            _database.Insert("umbracoNode", "id", false, new NodeDto { NodeId = -38, Trashed = false, ParentId = -1, UserId = 0, Level = 1, Path = "-1,-38", SortOrder = 2, UniqueId = new Guid("fd9f1447-6c61-4a7c-9595-5aa39147d318"), Text = "Folder Browser", NodeObjectType = new Guid(Constants.ObjectTypes.DataType), CreateDate = DateTime.Now });
+            _database.Insert("umbracoNode", "id", false, new NodeDto { NodeId = -39, Trashed = false, ParentId = -1, UserId = 0, Level = 1, Path = "-1,-39", SortOrder = 2, UniqueId = new Guid("f38f0ac7-1d27-439c-9f3f-089cd8825a53"), Text = "Dropdown multiple", NodeObjectType = new Guid(Constants.ObjectTypes.DataType), CreateDate = DateTime.Now });            
            _database.Insert("umbracoNode", "id", false, new NodeDto { NodeId = -37, Trashed = false, ParentId = -1, UserId = 0, Level = 1, Path = "-1,-37", SortOrder = 2, UniqueId = new Guid("0225af17-b302-49cb-9176-b9f35cab9c17"), Text = "Approved Color", NodeObjectType = new Guid(Constants.ObjectTypes.DataType), CreateDate = DateTime.Now });
            _database.Insert("umbracoNode", "id", false, new NodeDto { NodeId = -36, Trashed = false, ParentId = -1, UserId = 0, Level = 1, Path = "-1,-36", SortOrder = 2, UniqueId = new Guid("e4d66c0f-b935-4200-81f0-025f7256b89a"), Text = "Date Picker with time", NodeObjectType = new Guid(Constants.ObjectTypes.DataType), CreateDate = DateTime.Now });
            _database.Insert("umbracoNode", "id", false, new NodeDto { NodeId = Constants.System.DefaultContentListViewDataTypeId, Trashed = false, ParentId = -1, UserId = 0, Level = 1, Path = "-1,-95", SortOrder = 2, UniqueId = new Guid("C0808DD3-8133-4E4B-8CE8-E2BEA84A96A4"), Text = Constants.Conventions.DataTypes.ListViewPrefix + "Content", NodeObjectType = new Guid(Constants.ObjectTypes.DataType), CreateDate = DateTime.Now });
@@ -179,16 +178,16 @@ namespace Umbraco.Core.Persistence.Migrations.Initial
        
        private void CreateCmsPropertyTypeGroupData()
        {          
-            _database.Insert("cmsPropertyTypeGroup", "id", false, new PropertyTypeGroupDto { Id = 3, ContentTypeNodeId = 1032, Text = "Image", SortOrder = 1 });
-            _database.Insert("cmsPropertyTypeGroup", "id", false, new PropertyTypeGroupDto { Id = 4, ContentTypeNodeId = 1033, Text = "File", SortOrder = 1 });
-            _database.Insert("cmsPropertyTypeGroup", "id", false, new PropertyTypeGroupDto { Id = 5, ContentTypeNodeId = 1031, Text = "Contents", SortOrder = 1 });
+            _database.Insert("cmsPropertyTypeGroup", "id", false, new PropertyTypeGroupDto { Id = 3, ContentTypeNodeId = 1032, Text = "Image", SortOrder = 1, UniqueId = new Guid(Constants.PropertyTypeGroups.Image) });
+            _database.Insert("cmsPropertyTypeGroup", "id", false, new PropertyTypeGroupDto { Id = 4, ContentTypeNodeId = 1033, Text = "File", SortOrder = 1, UniqueId = new Guid(Constants.PropertyTypeGroups.File) });
+            _database.Insert("cmsPropertyTypeGroup", "id", false, new PropertyTypeGroupDto { Id = 5, ContentTypeNodeId = 1031, Text = "Contents", SortOrder = 1, UniqueId = new Guid(Constants.PropertyTypeGroups.Contents) });
            //membership property group
-            _database.Insert("cmsPropertyTypeGroup", "id", false, new PropertyTypeGroupDto { Id = 11, ContentTypeNodeId = 1044, Text = "Membership", SortOrder = 1 });
+            _database.Insert("cmsPropertyTypeGroup", "id", false, new PropertyTypeGroupDto { Id = 11, ContentTypeNodeId = 1044, Text = "Membership", SortOrder = 1, UniqueId = new Guid(Constants.PropertyTypeGroups.Membership) });
        }

        private void CreateCmsPropertyTypeData()
        {
-            _database.Insert("cmsPropertyType", "id", false, new PropertyTypeDto { Id = 6, UniqueId = 6.ToGuid(), DataTypeId = -90, ContentTypeId = 1032, PropertyTypeGroupId = 3, Alias = Constants.Conventions.Media.File, Name = "Upload image", SortOrder = 0, Mandatory = false, ValidationRegExp = null, Description = null });
+            _database.Insert("cmsPropertyType", "id", false, new PropertyTypeDto { Id = 6, UniqueId = 6.ToGuid(), DataTypeId = 1043, ContentTypeId = 1032, PropertyTypeGroupId = 3, Alias = Constants.Conventions.Media.File, Name = "Upload image", SortOrder = 0, Mandatory = false, ValidationRegExp = null, Description = null });
            _database.Insert("cmsPropertyType", "id", false, new PropertyTypeDto { Id = 7, UniqueId = 7.ToGuid(), DataTypeId = -92, ContentTypeId = 1032, PropertyTypeGroupId = 3, Alias = Constants.Conventions.Media.Width, Name = "Width", SortOrder = 0, Mandatory = false, ValidationRegExp = null, Description = null });
            _database.Insert("cmsPropertyType", "id", false, new PropertyTypeDto { Id = 8, UniqueId = 8.ToGuid(), DataTypeId = -92, ContentTypeId = 1032, PropertyTypeGroupId = 3, Alias = Constants.Conventions.Media.Height, Name = "Height", SortOrder = 0, Mandatory = false, ValidationRegExp = null, Description = null });
            _database.Insert("cmsPropertyType", "id", false, new PropertyTypeDto { Id = 9, UniqueId = 9.ToGuid(), DataTypeId = -92, ContentTypeId = 1032, PropertyTypeGroupId = 3, Alias = Constants.Conventions.Media.Bytes, Name = "Size", SortOrder = 0, Mandatory = false, ValidationRegExp = null, Description = null });
@@ -196,7 +195,7 @@ namespace Umbraco.Core.Persistence.Migrations.Initial
            _database.Insert("cmsPropertyType", "id", false, new PropertyTypeDto { Id = 24, UniqueId = 24.ToGuid(), DataTypeId = -90, ContentTypeId = 1033, PropertyTypeGroupId = 4, Alias = Constants.Conventions.Media.File, Name = "Upload file", SortOrder = 0, Mandatory = false, ValidationRegExp = null, Description = null });
            _database.Insert("cmsPropertyType", "id", false, new PropertyTypeDto { Id = 25, UniqueId = 25.ToGuid(), DataTypeId = -92, ContentTypeId = 1033, PropertyTypeGroupId = 4, Alias = Constants.Conventions.Media.Extension, Name = "Type", SortOrder = 0, Mandatory = false, ValidationRegExp = null, Description = null });
            _database.Insert("cmsPropertyType", "id", false, new PropertyTypeDto { Id = 26, UniqueId = 26.ToGuid(), DataTypeId = -92, ContentTypeId = 1033, PropertyTypeGroupId = 4, Alias = Constants.Conventions.Media.Bytes, Name = "Size", SortOrder = 0, Mandatory = false, ValidationRegExp = null, Description = null });
-            _database.Insert("cmsPropertyType", "id", false, new PropertyTypeDto { Id = 27, UniqueId = 27.ToGuid(), DataTypeId = -38, ContentTypeId = 1031, PropertyTypeGroupId = 5, Alias = "contents", Name = "Contents:", SortOrder = 0, Mandatory = false, ValidationRegExp = null, Description = null });
+            _database.Insert("cmsPropertyType", "id", false, new PropertyTypeDto { Id = 27, UniqueId = 27.ToGuid(), DataTypeId = Constants.System.DefaultMediaListViewDataTypeId, ContentTypeId = 1031, PropertyTypeGroupId = 5, Alias = "contents", Name = "Contents:", SortOrder = 0, Mandatory = false, ValidationRegExp = null, Description = null });
            //membership property types
            _database.Insert("cmsPropertyType", "id", false, new PropertyTypeDto { Id = 28, UniqueId = 28.ToGuid(), DataTypeId = -89, ContentTypeId = 1044, PropertyTypeGroupId = 11, Alias = Constants.Conventions.Member.Comments, Name = Constants.Conventions.Member.CommentsLabel, SortOrder = 0, Mandatory = false, ValidationRegExp = null, Description = null });
            _database.Insert("cmsPropertyType", "id", false, new PropertyTypeDto { Id = 29, UniqueId = 29.ToGuid(), DataTypeId = -92, ContentTypeId = 1044, PropertyTypeGroupId = 11, Alias = Constants.Conventions.Member.FailedPasswordAttempts, Name = Constants.Conventions.Member.FailedPasswordAttemptsLabel, SortOrder = 1, Mandatory = false, ValidationRegExp = null, Description = null });
@@ -231,8 +230,7 @@ namespace Umbraco.Core.Persistence.Migrations.Initial
            _database.Insert("cmsDataType", "pk", false, new DataTypeDto { PrimaryKey = 6, DataTypeId = -90, PropertyEditorAlias = Constants.PropertyEditors.UploadFieldAlias, DbType = "Nvarchar" });
            _database.Insert("cmsDataType", "pk", false, new DataTypeDto { PrimaryKey = 7, DataTypeId = -92, PropertyEditorAlias = Constants.PropertyEditors.NoEditAlias, DbType = "Nvarchar" });
            _database.Insert("cmsDataType", "pk", false, new DataTypeDto { PrimaryKey = 8, DataTypeId = -36, PropertyEditorAlias = Constants.PropertyEditors.DateTimeAlias, DbType = "Date" });
-            _database.Insert("cmsDataType", "pk", false, new DataTypeDto { PrimaryKey = 9, DataTypeId = -37, PropertyEditorAlias = Constants.PropertyEditors.ColorPickerAlias, DbType = "Nvarchar" });
-            _database.Insert("cmsDataType", "pk", false, new DataTypeDto { PrimaryKey = 10, DataTypeId = -38, PropertyEditorAlias = Constants.PropertyEditors.FolderBrowserAlias, DbType = "Nvarchar" });
+            _database.Insert("cmsDataType", "pk", false, new DataTypeDto { PrimaryKey = 9, DataTypeId = -37, PropertyEditorAlias = Constants.PropertyEditors.ColorPickerAlias, DbType = "Nvarchar" });            
            _database.Insert("cmsDataType", "pk", false, new DataTypeDto { PrimaryKey = 11, DataTypeId = -39, PropertyEditorAlias = Constants.PropertyEditors.DropDownListMultipleAlias, DbType = "Nvarchar" });
            _database.Insert("cmsDataType", "pk", false, new DataTypeDto { PrimaryKey = 12, DataTypeId = -40, PropertyEditorAlias = Constants.PropertyEditors.RadioButtonListAlias, DbType = "Nvarchar" });
            _database.Insert("cmsDataType", "pk", false, new DataTypeDto { PrimaryKey = 13, DataTypeId = -41, PropertyEditorAlias = Constants.PropertyEditors.DateAlias, DbType = "Date" });
@@ -253,7 +251,6 @@ namespace Umbraco.Core.Persistence.Migrations.Initial
            //_database.Insert("cmsDataType", "pk", false, new DataTypeDto { PrimaryKey = 19, DataTypeId = 1038, PropertyEditorAlias = Constants.PropertyEditors.MarkdownEditorAlias, DbType = "Ntext" });            
            //_database.Insert("cmsDataType", "pk", false, new DataTypeDto { PrimaryKey = 20, DataTypeId = 1039, PropertyEditorAlias = Constants.PropertyEditors.UltimatePickerAlias, DbType = "Ntext" });
            //_database.Insert("cmsDataType", "pk", false, new DataTypeDto { PrimaryKey = 23, DataTypeId = 1042, PropertyEditorAlias = Constants.PropertyEditors.MacroContainerAlias, DbType = "Ntext" });
-            
        }

        private void CreateCmsDataTypePreValuesData()
@@ -269,6 +266,17 @@ namespace Umbraco.Core.Persistence.Migrations.Initial
            _database.Insert("cmsDataTypePreValues", "id", false, new DataTypePreValueDto { Id = -2, Alias = "orderBy", SortOrder = 2, DataTypeNodeId = Constants.System.DefaultMembersListViewDataTypeId, Value = "Name" });
            _database.Insert("cmsDataTypePreValues", "id", false, new DataTypePreValueDto { Id = -3, Alias = "orderDirection", SortOrder = 3, DataTypeNodeId = Constants.System.DefaultMembersListViewDataTypeId, Value = "asc" });
            _database.Insert("cmsDataTypePreValues", "id", false, new DataTypePreValueDto { Id = -4, Alias = "includeProperties", SortOrder = 4, DataTypeNodeId = Constants.System.DefaultMembersListViewDataTypeId, Value = "[{\"alias\":\"email\",\"isSystem\":1},{\"alias\":\"username\",\"isSystem\":1},{\"alias\":\"updateDate\",\"header\":\"Last edited\",\"isSystem\":1}]" });
+
+            //layouts for the list view
+            var cardLayout = "{\"name\": \"Grid\",\"path\": \"views/propertyeditors/listview/layouts/grid/grid.html\", \"icon\": \"icon-thumbnails-small\", \"isSystem\": 1, \"selected\": true}";
+            var listLayout = "{\"name\": \"List\",\"path\": \"views/propertyeditors/listview/layouts/list/list.html\",\"icon\": \"icon-list\", \"isSystem\": 1,\"selected\": true}";
+
+            //defaults for the media list
+            _database.Insert("cmsDataTypePreValues", "id", false, new DataTypePreValueDto { Id = -5, Alias = "pageSize", SortOrder = 1, DataTypeNodeId = Constants.System.DefaultMediaListViewDataTypeId, Value = "100" });
+            _database.Insert("cmsDataTypePreValues", "id", false, new DataTypePreValueDto { Id = -6, Alias = "orderBy", SortOrder = 2, DataTypeNodeId = Constants.System.DefaultMediaListViewDataTypeId, Value = "VersionDate" });
+            _database.Insert("cmsDataTypePreValues", "id", false, new DataTypePreValueDto { Id = -7, Alias = "orderDirection", SortOrder = 3, DataTypeNodeId = Constants.System.DefaultMediaListViewDataTypeId, Value = "desc" });
+            _database.Insert("cmsDataTypePreValues", "id", false, new DataTypePreValueDto { Id = -8, Alias = "layouts", SortOrder = 4, DataTypeNodeId = Constants.System.DefaultMediaListViewDataTypeId, Value = "[" + cardLayout + "," + listLayout + "]" });
+            _database.Insert("cmsDataTypePreValues", "id", false, new DataTypePreValueDto { Id = -9, Alias = "includeProperties", SortOrder = 5, DataTypeNodeId = Constants.System.DefaultMediaListViewDataTypeId, Value = "[{\"alias\":\"sortOrder\",\"isSystem\":1, \"header\": \"Sort order\"},{\"alias\":\"updateDate\",\"header\":\"Last edited\",\"isSystem\":1},{\"alias\":\"owner\",\"header\":\"Updated by\",\"isSystem\":1}]" });
        }

        private void CreateUmbracoRelationTypeData()
@@ -44,7 +44,7 @@ namespace Umbraco.Core.Persistence.Migrations.Initial
                                                                              {4, typeof (ContentVersionDto)},
                                                                              {5, typeof (DocumentDto)},
                                                                              
-                                                                              {6, typeof (DocumentTypeDto)},
+                                                                              {6, typeof (ContentTypeTemplateDto)},
                                                                              {7, typeof (DataTypeDto)},
                                                                              {8, typeof (DataTypePreValueDto)},
                                                                              {9, typeof (DictionaryDto)},
@@ -82,7 +82,9 @@ namespace Umbraco.Core.Persistence.Migrations.Initial
                                                                              {42, typeof (AccessRuleDto)},
                                                                              {43, typeof(CacheInstructionDto)},
                                                                              {44, typeof (ExternalLoginDto)},
-                                                                              {45, typeof (MigrationDto)}
+                                                                              {45, typeof (MigrationDto)},
+                                                                              {46, typeof (UmbracoDeployChecksumDto)},
+                                                                              {47, typeof (UmbracoDeployDependencyDto)}
                                                                          };
        #endregion
        
@@ -119,6 +119,12 @@ namespace Umbraco.Core.Persistence.Migrations.Initial
                return new Version(7, 2, 5);
            }

+            //if the error is for umbracoDeployChecksum it must be the previous version to 7.4 since that is when it is added
+            if (Errors.Any(x => x.Item1.Equals("Table") && (x.Item2.InvariantEquals("umbracoDeployChecksum"))))
+            {
+                return new Version(7, 3, 4);
+            }
+
            return UmbracoVersion.Current;
        }

@@ -0,0 +1,29 @@
+using System.Linq;
+using Umbraco.Core.Configuration;
+using Umbraco.Core.Logging;
+using Umbraco.Core.Persistence.SqlSyntax;
+
+namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSevenFourZero
+{
+    [Migration("7.4.0", 1, GlobalSettings.UmbracoMigrationName)]
+    public class AddDataDecimalColumn : MigrationBase
+    {
+        public AddDataDecimalColumn(ISqlSyntaxProvider sqlSyntax, ILogger logger)
+            : base(sqlSyntax, logger)
+        {
+        }
+
+        public override void Up()
+        {
+            //Don't exeucte if the column is already there
+            var columns = SqlSyntax.GetColumnsInSchema(Context.Database).ToArray();
+
+            if (columns.Any(x => x.TableName.InvariantEquals("cmsPropertyData") && x.ColumnName.InvariantEquals("dataDecimal")) == false)
+                Create.Column("dataDecimal").OnTable("cmsPropertyData").AsDecimal().Nullable();
+        }
+
+        public override void Down()
+        {
+        }
+    }
+}
@@ -0,0 +1,48 @@
+using System.Linq;
+using Umbraco.Core.Configuration;
+using Umbraco.Core.Logging;
+using Umbraco.Core.Persistence.SqlSyntax;
+
+namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSevenFourZero
+{
+    [Migration("7.4.0", 5, GlobalSettings.UmbracoMigrationName)]
+    public class AddUmbracoDeployTables : MigrationBase
+    {
+        public AddUmbracoDeployTables(ISqlSyntaxProvider sqlSyntax, ILogger logger)
+            : base(sqlSyntax, logger)
+        { }
+
+        public override void Up()
+        {
+            //Don't exeucte if the table is already there
+            var tables = SqlSyntax.GetTablesInSchema(Context.Database).ToArray();
+            if (tables.InvariantContains("umbracoDeployChecksum")) return;
+
+            Create.Table("umbracoDeployChecksum")
+                .WithColumn("id").AsInt32().Identity().PrimaryKey("PK_umbracoDeployChecksum")
+                .WithColumn("entityType").AsString(32).NotNullable()
+                .WithColumn("entityGuid").AsGuid().Nullable()
+                .WithColumn("entityPath").AsString(256).Nullable()
+                .WithColumn("localChecksum").AsString(32).NotNullable()
+                .WithColumn("compositeChecksum").AsString(32).Nullable();
+
+            Create.Table("umbracoDeployDependency")
+                .WithColumn("sourceId").AsInt32().NotNullable().ForeignKey("FK_umbracoDeployDependency_umbracoDeployChecksum_id1", "umbracoDeployChecksum", "id")
+                .WithColumn("targetId").AsInt32().NotNullable().ForeignKey("FK_umbracoDeployDependency_umbracoDeployChecksum_id2", "umbracoDeployChecksum", "id")
+                .WithColumn("mode").AsInt32().NotNullable();
+
+            Create.PrimaryKey("PK_umbracoDeployDependency").OnTable("umbracoDeployDependency").Columns(new[] {"sourceId", "targetId"});
+
+            Create.Index("IX_umbracoDeployChecksum").OnTable("umbracoDeployChecksum")
+                  .OnColumn("entityType")
+                  .Ascending()
+                  .OnColumn("entityGuid")
+                  .Ascending()
+                  .OnColumn("entityPath")
+                  .Unique();
+        }
+
+        public override void Down()
+        { }
+    }
+}
@@ -0,0 +1,80 @@
+using System;
+using System.Linq;
+using Umbraco.Core.Configuration;
+using Umbraco.Core.Logging;
+using Umbraco.Core.Persistence.DatabaseModelDefinitions;
+using Umbraco.Core.Persistence.SqlSyntax;
+
+namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSevenFourZero
+{
+    [Migration("7.4.0", 2, GlobalSettings.UmbracoMigrationName)]
+    public class AddUniqueIdPropertyTypeGroupColumn : MigrationBase
+    {
+        public AddUniqueIdPropertyTypeGroupColumn(ISqlSyntaxProvider sqlSyntax, ILogger logger)
+            : base(sqlSyntax, logger)
+        { }
+
+        public override void Up()
+        {
+            // don't execute if the column is already there
+            var columns = SqlSyntax.GetColumnsInSchema(Context.Database).ToArray();
+
+            if (columns.Any(x => x.TableName.InvariantEquals("cmsPropertyTypeGroup") && x.ColumnName.InvariantEquals("uniqueID")) == false)
+            {
+                Create.Column("uniqueID").OnTable("cmsPropertyTypeGroup").AsGuid().NotNullable().WithDefault(SystemMethods.NewGuid);
+
+                // unique constraint on name + version
+                Create.Index("IX_cmsPropertyTypeGroupUniqueID").OnTable("cmsPropertyTypeGroup")
+                    .OnColumn("uniqueID").Ascending()
+                    .WithOptions()
+                    .NonClustered()
+                    .WithOptions()
+                    .Unique();
+
+                // fill in the data in a way that is consistent over all environments
+                // (ie cannot use random guids, http://issues.umbraco.org/issue/U4-6942)
+
+                foreach (var data in Context.Database.Query<dynamic>(@"
+SELECT cmsPropertyTypeGroup.id grId, cmsPropertyTypeGroup.text grName, cmsContentType.alias ctAlias, umbracoNode.nodeObjectType nObjType
+FROM cmsPropertyTypeGroup
+INNER JOIN cmsContentType
+ON cmsPropertyTypeGroup.contentTypeNodeId = cmsContentType.nodeId
+INNER JOIN umbracoNode
+ON cmsContentType.nodeId = umbracoNode.id"))
+                {
+                    Guid guid;
+                    // see BaseDataCreation... built-in groups have their own guids
+                    if (data.grId == 3)
+                    {
+                        guid = new Guid(Constants.PropertyTypeGroups.Image);
+                    }
+                    else if (data.grId == 4)
+                    {
+                        guid = new Guid(Constants.PropertyTypeGroups.File);
+                    }
+                    else if (data.grId == 5)
+                    {
+                        guid = new Guid(Constants.PropertyTypeGroups.Contents);
+                    }
+                    else if (data.grId == 11)
+                    {
+                        guid = new Guid(Constants.PropertyTypeGroups.Membership);
+                    }
+                    else
+                    {
+                        // create a consistent guid from
+                        // group name + content type alias + object type
+                        string guidSource = data.grName + data.ctAlias + data.nObjType;
+                        guid = guidSource.ToGuid();
+                    }
+
+                    // set the Unique Id to the one we've generated
+                    Update.Table("cmsPropertyTypeGroup").Set(new { uniqueID = guid }).Where(new { id = data.grId });
+                }
+            }
+        }
+
+        public override void Down()
+        { }
+    }
+}
@@ -0,0 +1,55 @@
+using System;
+using System.Linq;
+using Umbraco.Core.Configuration;
+using Umbraco.Core.Logging;
+using Umbraco.Core.Models.Rdbms;
+using Umbraco.Core.Persistence.SqlSyntax;
+
+namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSevenFourZero
+{
+    /// <summary>
+    /// Courier on v. 7.4+ will handle ContentTypes using GUIDs instead of
+    /// alias, so we need to ensure that these are initially consistent on
+    /// all environments (based on the alias).
+    /// </summary>
+    [Migration("7.4.0", 3, GlobalSettings.UmbracoMigrationName)]
+    public class EnsureContentTypeUniqueIdsAreConsistent : MigrationBase
+    {
+        public EnsureContentTypeUniqueIdsAreConsistent(ISqlSyntaxProvider sqlSyntax, ILogger logger)
+            : base(sqlSyntax, logger)
+        { }
+        
+        public override void Up()
+        {
+            var objectTypes = new[]
+            {
+                Constants.ObjectTypes.DocumentTypeGuid,
+                Constants.ObjectTypes.MediaTypeGuid,
+                Constants.ObjectTypes.MemberTypeGuid,
+            };
+
+            var sql = new Sql()
+                .Select("umbracoNode.id,cmsContentType.alias,umbracoNode.nodeObjectType")
+                .From<NodeDto>(SqlSyntax)
+                .InnerJoin<ContentTypeDto>(SqlSyntax)
+                .On<NodeDto, ContentTypeDto>(SqlSyntax, dto => dto.NodeId, dto => dto.NodeId)
+                .WhereIn<NodeDto>(x => x.NodeObjectType, objectTypes);
+
+            var rows = Context.Database.Fetch<dynamic>(sql);
+
+            foreach (var row in rows)
+            {
+                // create a consistent guid from
+                // alias + object type
+                var guidSource = ((string) row.alias) + ((Guid) row.nodeObjectType);
+                var guid = guidSource.ToGuid();
+
+                // set the Unique Id to the one we've generated
+                Update.Table("umbracoNode").Set(new { uniqueID = guid }).Where(new { id = row.id });
+            }
+        }
+
+        public override void Down()
+        { }
+    }
+}
@@ -0,0 +1,34 @@
+using System.Linq;
+using Umbraco.Core.Configuration;
+using Umbraco.Core.Logging;
+using Umbraco.Core.Models.Rdbms;
+using Umbraco.Core.Persistence.SqlSyntax;
+
+namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSevenFourZero
+{
+    [Migration("7.4.0", 4, GlobalSettings.UmbracoMigrationName)]
+    public class FixListViewMediaSortOrder : MigrationBase
+    {
+        public FixListViewMediaSortOrder(ISqlSyntaxProvider sqlSyntax, ILogger logger)
+            : base(sqlSyntax, logger)
+        {
+        }
+
+        public override void Up()
+        {
+            var mediaListviewIncludeProperties = Context.Database.Fetch<DataTypePreValueDto>(new Sql().Select("*").From<DataTypePreValueDto>(SqlSyntax).Where<DataTypePreValueDto>(x => x.Id == -9)).FirstOrDefault();
+            if (mediaListviewIncludeProperties != null)
+            {
+                if (mediaListviewIncludeProperties.Value.Contains("\"alias\":\"sort\""))
+                {
+                    mediaListviewIncludeProperties.Value = mediaListviewIncludeProperties.Value.Replace("\"alias\":\"sort\"", "\"alias\":\"sortOrder\"");
+                    Context.Database.InsertOrUpdate(mediaListviewIncludeProperties);
+                }
+            }
+        }
+
+        public override void Down()
+        {
+        }
+    }
+}
@@ -0,0 +1,30 @@
+using System.Linq;
+using Umbraco.Core.Configuration;
+using Umbraco.Core.Logging;
+using Umbraco.Core.Persistence.SqlSyntax;
+
+namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSevenFourZero
+{
+    [Migration("7.4.0", 4, GlobalSettings.UmbracoMigrationName)]
+    public class RemoveParentIdPropertyTypeGroupColumn : MigrationBase
+    {
+        public RemoveParentIdPropertyTypeGroupColumn(ISqlSyntaxProvider sqlSyntax, ILogger logger)
+            : base(sqlSyntax, logger)
+        { }
+
+        public override void Up()
+        {
+            // don't execute if the column is not there anymore
+            var columns = SqlSyntax.GetColumnsInSchema(Context.Database).ToArray();
+
+            if (columns.Any(x => x.TableName.InvariantEquals("cmsPropertyTypeGroup") && x.ColumnName.InvariantEquals("parentGroupId")) == false)
+                return;
+
+            Delete.ForeignKey("FK_cmsPropertyTypeGroup_cmsPropertyTypeGroup_id").OnTable("cmsPropertyTypeGroup");
+            Delete.Column("parentGroupId").FromTable("cmsPropertyTypeGroup");
+        }
+
+        public override void Down()
+        { }
+    }
+}
--- a/Show More
+++ b/Show More