Minor tweaks to ExecutionMigrationStep and PackageMigrationsContext.

Adds tests for ExecutionMigrationStep and PackageMigrationsContext.

.gitignore

@@ -1,134 +1,141 @@
-*.obj
-*.pdb
-*.user
-*.aps
-*.pch
-*.vspscc
-.DS_Store
-._.DS_Store
-[Bb]in
-[Db]ebug*/
-obj/
-[Rr]elease*/
-_ReSharper*/
-_NCrunch_*/
-*.ncrunchsolution
-*.ncrunchsolution.user
-*.ncrunchproject
-*.crunchsolution.cache
-[Tt]est[Rr]esult*
-[Bb]uild[Ll]og.*
-*.[Pp]ublish.xml
-*.suo
-[sS]ource
-[sS]andbox
-umbraco.config
-*.vs10x
-App_Data/TEMP/*
-[Uu]mbraco/[Pp]resentation/[Uu]mbraco/[Pp]lugins/*
-[Uu]mbraco/[Pp]resentation/[Uu]ser[Cc]ontrols/*
-[Uu]mbraco/[Pp]resentation/[Ss]cripts/*
-[Uu]mbraco/[Pp]resentation/[Ff]onts/*
-[Uu]mbraco/[Pp]resentation/[Cc]ss/*
-
-src/Umbraco.Web.UI/[Cc]ss/*
-src/Umbraco.Web.UI/App_Code/*
-src/Umbraco.Web.UI/App_Data/*
-src/Umbraco.Tests/App_Data/*
-src/Umbraco.Web.UI/[Mm]edia/*
-src/Umbraco.Web.UI/[Mm]aster[Pp]ages/*
-src/Umbraco.Web.UI/[Mm]acro[Ss]cripts/*
-!src/Umbraco.Web.UI/[Mm]acro[Ss]cripts/[Ww]eb.[Cc]onfig
-src/Umbraco.Web.UI/[Xx]slt/*
-src/Umbraco.Web.UI/[Ii]mages/*
-src/Umbraco.Web.UI/[Ss]cripts/*
-src/Umbraco.Web.UI/Web.*.config.transformed
-
-umbraco/presentation/umbraco/plugins/uComponents/uComponentsInstaller.ascx
-umbraco/presentation/packages/uComponents/MultiNodePicker/CustomTreeService.asmx
-_BuildOutput/*
-*.ncrunchsolution
-build/UmbracoCms.AllBinaries*zip
-build/UmbracoCms.WebPI*zip
-build/UmbracoCms*zip
-build/UmbracoExamine.PDF*zip
-build/*.nupkg
-src/Umbraco.Tests/config/applications.config
-src/Umbraco.Tests/config/trees.config
-src/Umbraco.Web.UI/web.config
-*.orig
-src/Umbraco.Tests/config/404handlers.config
-src/Umbraco.Web.UI/[Vv]iews/*.cshtml
-src/Umbraco.Web.UI/[Vv]iews/*.vbhtml
-src/Umbraco.Tests/[Cc]onfig/umbracoSettings.config
-src/Umbraco.Web.UI/[Vv]iews/*
-src/packages/
-src/packages/repositories.config
-
-src/Umbraco.Web.UI/[Ww]eb.config
-*.transformed
-webpihash.txt
-
-node_modules
-
-src/Umbraco.Web.UI/[Uu]mbraco/[Ll]ib/*
-src/Umbraco.Web.UI/[Uu]mbraco/[Jj]s/umbraco.*
-src/Umbraco.Web.UI/[Uu]mbraco/[Jj]s/routes.js
-src/Umbraco.Web.UI/[Uu]mbraco/[Jj]s/app.dev.js
-src/Umbraco.Web.UI/[Uu]mbraco/[Jj]s/loader.js
-src/Umbraco.Web.UI/[Uu]mbraco/[Jj]s/loader.dev.js
-src/Umbraco.Web.UI/[Uu]mbraco/[Jj]s/main.js
-src/Umbraco.Web.UI/[Uu]mbraco/[Jj]s/app.js
-
-src/Umbraco.Web.UI/[Uu]mbraco/[Jj]s/tuning.panel.js
-src/Umbraco.Web.UI/[Uu]mbraco/[Jj]s/tuning.palettes.js
-src/Umbraco.Web.UI/[Uu]mbraco/[Jj]s/tuning.loader.js
-src/Umbraco.Web.UI/[Uu]mbraco/[Jj]s/tuning.front.js
-src/Umbraco.Web.UI/[Uu]mbraco/[Jj]s/tuning.config.js
-
-src/Umbraco.Web.UI/[Uu]mbraco/[Vv]iews/
-src/Umbraco.Web.UI/[Uu]mbraco/[Vv]iews/**/*.js
-src/Umbraco.Web.UI/[Uu]mbraco/[Vv]iews/**/*.css
-src/Umbraco.Web.UI/[Uu]mbraco/[Vv]iews/**/*.html
-src/Umbraco.Web.UI/[Uu]mbraco/[Aa]ssets/*
-src/Umbraco.Web.UI.Client/[Bb]uild/*
-src/Umbraco.Web.UI.Client/[Bb]uild/[Bb]elle/
-src/Umbraco.Web.UI/[Uu]ser[Cc]ontrols/
-build/_BuildOutput/
-src/Umbraco.Web.UI.Client/src/[Ll]ess/*.css
-tools/NDepend/
-
-src/Umbraco.Web.UI/App_Plugins/*
-src/*.psess
-src/*.vspx
-src/Umbraco.Web.UI/[Uu]mbraco/[Jj]s/routes.js.*
-NDependOut/*
-*.ndproj
-QueryResult.htm
-*.ndproj
-src/Umbraco.Web.UI/[Uu]mbraco/[Aa]ssets/*
-src/Umbraco.Web.UI/[Uu]mbraco/[Ll]ib/*
-src/Umbraco.Web.UI/[Uu]mbraco/[Vv]iews/**/*.html
-src/Umbraco.Web.UI/[Uu]mbraco/[Vv]iews/**/*.js
-
-src/Umbraco.Web.UI/[Cc]onfig/appSettings.config
-src/Umbraco.Web.UI/[Cc]onfig/connectionStrings.config
-src/Umbraco.Web.UI/umbraco/plugins/*
-src/Umbraco.Web.UI/umbraco/js/init.js
-build/ApiDocs/*
-build/ApiDocs/Output/*
-src/Umbraco.Web.UI.Client/bower_components/*
-/src/Umbraco.Web.UI/Umbraco/preview
-
-#Ignore Rule for output of generated documentation files from Grunt docserve
-src/Umbraco.Web.UI.Client/docs/api
-src/*.boltdata/
-/src/Umbraco.Web.UI/Umbraco/Js/canvasdesigner.loader.js
-/src/Umbraco.Web.UI/Umbraco/Js/canvasdesigner.palettes.js
-/src/Umbraco.Web.UI/Umbraco/Js/canvasdesigner.panel.js
-/src/Umbraco.Web.UI/Umbraco/Js/canvasdesigner.config.js
-/src/Umbraco.Web.UI/Umbraco/Js/canvasdesigner.front.js
-src/umbraco.sln.ide/*
-build/UmbracoCms.*/
-src/.vs/
-src/Umbraco.Web.UI/umbraco/js/install.loader.js
+*.obj
+*.pdb
+*.user
+*.aps
+*.pch
+*.vspscc
+.DS_Store
+._.DS_Store
+[Bb]in
+[Db]ebug*/
+obj/
+[Rr]elease*/
+_ReSharper*/
+_NCrunch_*/
+*.ncrunchsolution
+*.ncrunchsolution.user
+*.ncrunchproject
+*.crunchsolution.cache
+[Tt]est[Rr]esult*
+[Bb]uild[Ll]og.*
+*.[Pp]ublish.xml
+*.suo
+[sS]ource
+[sS]andbox
+umbraco.config
+*.vs10x
+App_Data/TEMP/*
+[Uu]mbraco/[Pp]resentation/[Uu]mbraco/[Pp]lugins/*
+[Uu]mbraco/[Pp]resentation/[Uu]ser[Cc]ontrols/*
+[Uu]mbraco/[Pp]resentation/[Ss]cripts/*
+[Uu]mbraco/[Pp]resentation/[Ff]onts/*
+[Uu]mbraco/[Pp]resentation/[Cc]ss/*
+
+src/Umbraco.Web.UI/[Cc]ss/*
+src/Umbraco.Web.UI/App_Code/*
+src/Umbraco.Web.UI/App_Data/*
+src/Umbraco.Tests/App_Data/*
+src/Umbraco.Web.UI/[Mm]edia/*
+src/Umbraco.Web.UI/[Mm]aster[Pp]ages/*
+src/Umbraco.Web.UI/[Mm]acro[Ss]cripts/*
+!src/Umbraco.Web.UI/[Mm]acro[Ss]cripts/[Ww]eb.[Cc]onfig
+src/Umbraco.Web.UI/[Xx]slt/*
+src/Umbraco.Web.UI/[Ii]mages/*
+src/Umbraco.Web.UI/[Ss]cripts/*
+src/Umbraco.Web.UI/Web.*.config.transformed
+
+umbraco/presentation/umbraco/plugins/uComponents/uComponentsInstaller.ascx
+umbraco/presentation/packages/uComponents/MultiNodePicker/CustomTreeService.asmx
+_BuildOutput/*
+*.ncrunchsolution
+build/UmbracoCms.AllBinaries*zip
+build/UmbracoCms.WebPI*zip
+build/UmbracoCms*zip
+build/UmbracoExamine.PDF*zip
+build/*.nupkg
+src/Umbraco.Tests/config/applications.config
+src/Umbraco.Tests/config/trees.config
+src/Umbraco.Web.UI/web.config
+*.orig
+src/Umbraco.Tests/config/404handlers.config
+src/Umbraco.Web.UI/[Vv]iews/*.cshtml
+src/Umbraco.Web.UI/[Vv]iews/*.vbhtml
+src/Umbraco.Tests/[Cc]onfig/umbracoSettings.config
+src/Umbraco.Web.UI/[Vv]iews/*
+src/packages/
+src/packages/repositories.config
+
+src/Umbraco.Web.UI/[Ww]eb.config
+*.transformed
+webpihash.txt
+
+node_modules
+
+src/Umbraco.Web.UI/[Uu]mbraco/[Ll]ib/*
+src/Umbraco.Web.UI/[Uu]mbraco/[Jj]s/umbraco.*
+src/Umbraco.Web.UI/[Uu]mbraco/[Jj]s/routes.js
+src/Umbraco.Web.UI/[Uu]mbraco/[Jj]s/app.dev.js
+src/Umbraco.Web.UI/[Uu]mbraco/[Jj]s/loader.js
+src/Umbraco.Web.UI/[Uu]mbraco/[Jj]s/loader.dev.js
+src/Umbraco.Web.UI/[Uu]mbraco/[Jj]s/main.js
+src/Umbraco.Web.UI/[Uu]mbraco/[Jj]s/app.js
+
+src/Umbraco.Web.UI/[Uu]mbraco/[Jj]s/tuning.panel.js
+src/Umbraco.Web.UI/[Uu]mbraco/[Jj]s/tuning.palettes.js
+src/Umbraco.Web.UI/[Uu]mbraco/[Jj]s/tuning.loader.js
+src/Umbraco.Web.UI/[Uu]mbraco/[Jj]s/tuning.front.js
+src/Umbraco.Web.UI/[Uu]mbraco/[Jj]s/tuning.config.js
+
+src/Umbraco.Web.UI/[Uu]mbraco/[Vv]iews/
+src/Umbraco.Web.UI/[Uu]mbraco/[Vv]iews/**/*.js
+src/Umbraco.Web.UI/[Uu]mbraco/[Vv]iews/**/*.css
+src/Umbraco.Web.UI/[Uu]mbraco/[Vv]iews/**/*.html
+src/Umbraco.Web.UI/[Uu]mbraco/[Aa]ssets/*
+src/Umbraco.Web.UI.Client/[Bb]uild/*
+src/Umbraco.Web.UI.Client/[Bb]uild/[Bb]elle/
+src/Umbraco.Web.UI/[Uu]ser[Cc]ontrols/
+build/_BuildOutput/
+src/Umbraco.Web.UI.Client/src/[Ll]ess/*.css
+tools/NDepend/
+
+src/Umbraco.Web.UI/App_Plugins/*
+src/*.psess
+src/*.vspx
+src/Umbraco.Web.UI/[Uu]mbraco/[Jj]s/routes.js.*
+NDependOut/*
+*.ndproj
+QueryResult.htm
+*.ndproj
+src/Umbraco.Web.UI/[Uu]mbraco/[Aa]ssets/*
+src/Umbraco.Web.UI/[Uu]mbraco/[Ll]ib/*
+src/Umbraco.Web.UI/[Uu]mbraco/[Vv]iews/**/*.html
+src/Umbraco.Web.UI/[Uu]mbraco/[Vv]iews/**/*.js
+
+src/Umbraco.Web.UI/[Cc]onfig/appSettings.config
+src/Umbraco.Web.UI/[Cc]onfig/connectionStrings.config
+src/Umbraco.Web.UI/umbraco/plugins/*
+src/Umbraco.Web.UI/umbraco/js/init.js
+build/ApiDocs/*
+build/ApiDocs/Output/*
+src/Umbraco.Web.UI.Client/bower_components/*
+/src/Umbraco.Web.UI/Umbraco/preview
+
+#Ignore Rule for output of generated documentation files from Grunt docserve
+src/Umbraco.Web.UI.Client/docs/api
+src/*.boltdata/
+/src/Umbraco.Web.UI/Umbraco/Js/canvasdesigner.loader.js
+/src/Umbraco.Web.UI/Umbraco/Js/canvasdesigner.palettes.js
+/src/Umbraco.Web.UI/Umbraco/Js/canvasdesigner.panel.js
+/src/Umbraco.Web.UI/Umbraco/Js/canvasdesigner.config.js
+/src/Umbraco.Web.UI/Umbraco/Js/canvasdesigner.front.js
+src/umbraco.sln.ide/*
+build/UmbracoCms.*/
+src/.vs/
+src/Umbraco.Web.UI/umbraco/js/install.loader.js
+src/Umbraco.Tests/media
+tools/docfx/*
+apidocs/_site/*
+apidocs/api/*
+build/docs.zip
+build/ui-docs.zip
+build/csharp-docs.zip

README.md

@@ -13,13 +13,13 @@ If you're interested in making changes to Belle make sure to read the [Belle Rea
 
 ## Umbraco - the simple, flexible and friendly ASP.NET CMS ##
 
-**More than 177,000 sites trust Umbraco** 
+**More than 350,000 sites trust Umbraco** 
 
-For the first time on the Microsoft platform a free user and developer friendly CMS that makes it quick and easy to create websites - or a breeze to build complex web applications. Umbraco has award-winning integration capabilities and supports ASP.NET MVC or Web Forms, including User and Custom Controls, out of the box. It's a developers dream and your users will love it too. 
+For the first time on the Microsoft platform, there is a free user and developer friendly CMS that makes it quick and easy to create websites - or a breeze to build complex web applications. Umbraco has award-winning integration capabilities and supports ASP.NET MVC or Web Forms, including User and Custom Controls, out of the box. It's a developer's dream and your users will love it too. 
 
-Used by more than 177,000 active websites including [http://daviscup.com](http://daviscup.com), [http://heinz.com](http://heinz.com), [http://peugeot.com](http://peugeot.com), [http://www.hersheys.com/](http://www.hersheys.com/) and **The Official ASP.NET and IIS.NET website from Microsoft** ([http://asp.net](http://asp.net) / [http://iis.net](http://iis.net)) you can be sure that the technology is proven, stable and scales.  
+Used by more than 350,000 active websites including [http://daviscup.com](http://daviscup.com), [http://heinz.com](http://heinz.com), [http://peugeot.com](http://peugeot.com), [http://www.hersheys.com/](http://www.hersheys.com/) and **The Official ASP.NET and IIS.NET website from Microsoft** ([http://asp.net](http://asp.net) / [http://iis.net](http://iis.net)), you can be sure that the technology is proven, stable and scales.  
 
-To view more examples please visit [http://umbraco.com/why-umbraco/#caseStudies](http://umbraco.com/why-umbraco/#caseStudies)
+To view more examples, please visit [http://umbraco.com/why-umbraco/#caseStudies](http://umbraco.com/why-umbraco/#caseStudies)
 
 ## Downloading ##
 
@@ -35,6 +35,6 @@ If you want to contribute back to Umbraco you should check out our [guide to con
 
 ## Found a bug? ##
 
-Another way you can contribute to Umbraco is by providing issue reports, for information on how to submit an issue report refer to our [online guide for reporting issues](http://our.umbraco.org/contribute/report-an-issue-or-request-a-feature).
+Another way you can contribute to Umbraco is by providing issue reports. For information on how to submit an issue report refer to our [online guide for reporting issues](http://our.umbraco.org/contribute/report-an-issue-or-request-a-feature).
 
-To view existing issues please visit [http://issues.umbraco.org](http://issues.umbraco.org)
+To view existing issues, please visit [http://issues.umbraco.org](http://issues.umbraco.org).

apidocs/docfx.filter.yml

@@ -0,0 +1,18 @@
+apiRules:
+  - include:
+      uidRegex: ^Umbraco\.Core
+  - exclude:
+      uidRegex: ^umbraco\.Web\.org
+  - include:
+      uidRegex: ^Umbraco\.Web
+  - exclude:
+      hasAttribute:
+      uid: System.ComponentModel.EditorBrowsableAttribute
+      ctorArguments:
+        - System.ComponentModel.EditorBrowsableState.Never
+  - exclude:
+      uidRegex: ^umbraco\.
+  - exclude:
+      uidRegex: ^CookComputing\.	  
+  - exclude:
+      uidRegex: ^.*$

apidocs/docfx.json

@@ -0,0 +1,75 @@
+{
+  "metadata": [
+    {
+      "src": [
+        {
+          "files": [
+            "Umbraco.Core/Umbraco.Core.csproj",
+            "Umbraco.Web/Umbraco.Web.csproj"
+          ],
+          "exclude": [
+            "**/obj/**",
+            "**/bin/**",
+            "_site/**"
+          ],
+          "cwd": "../src"
+        }
+      ],
+      "dest": "../apidocs/api",
+      "filter": "../apidocs/docfx.filter.yml"
+    }
+  ],
+  "build": {
+    "content": [
+      {
+        "files": [
+          "api/**.yml",
+          "api/index.md"
+        ]
+      },
+      {
+        "files": [
+          "articles/**.md",
+          "articles/**/toc.yml",
+          "toc.yml",
+          "*.md"
+        ],
+        "exclude": [
+          "obj/**",
+          "_site/**"
+        ]
+      }
+    ],
+    "resource": [
+      {
+        "files": [
+          "images/**"
+        ],
+        "exclude": [
+          "obj/**",
+          "_site/**"
+        ]
+      }
+    ],
+    "overwrite": [
+      {
+        "files": [
+          "**.md"
+        ],
+        "exclude": [
+          "obj/**",
+          "_site/**"
+        ]
+      }
+    ],
+    "globalMetadata": {
+      "_appTitle": "Umbraco c# Api docs",
+      "_enableSearch": true,
+      "_disableContribution": false
+    },
+    "dest": "_site",
+    "template": [
+      "default", "umbracotemplate"
+    ]
+  }
+}

apidocs/index.md

@@ -0,0 +1,7 @@
+
+# Umbraco c# API reference
+
+## Quick Links:
+
+### [Umbraco.Core](api/Umbraco.Core.html) docs
+### [Umbraco.Web](api/Umbraco.Web.html) docs

apidocs/toc.yml

@@ -0,0 +1,5 @@
+
+- name: Umbraco.Core Documentation
+  href: https://our.umbraco.org/apidocs/csharp/api/Umbraco.Core.html
+- name: Umbraco.Web Documentation
+  href: https://our.umbraco.org/apidocs/csharp/api/Umbraco.Web.html

apidocs/umbracotemplate/partials/class.tmpl.partial

@@ -0,0 +1,257 @@
+{{!Copyright (c) Microsoft. All rights reserved. Licensed under the MIT license. See LICENSE file in the project root for full license information.}}
+
+{{^_disableContribution}}
+{{#sourceurl}}<a href="{{sourceurl}}" class="btn btn-primary pull-right mobile-hide">{{__global.viewSource}}</a>{{/sourceurl}}
+{{/_disableContribution}}
+<h1 id="{{id}}" data-uid="{{uid}}">{{>partials/title}}</h1>
+<div class="markdown level0 summary">{{{summary}}}</div>
+<div class="markdown level0 conceptual">{{{conceptual}}}</div>
+{{#inheritance.0}}
+<div class="inheritance">
+  <h5>{{__global.inheritance}}</h5>
+{{#inheritance}}
+    <div class="level{{index}}">{{{specName.0.value}}}</div>
+{{/inheritance}}
+    <div class="level{{item.level}}"><span class="xref">{{item.name.0.value}}</span></div>
+</div>
+{{/inheritance.0}}
+<h6><strong>{{__global.namespace}}</strong>:{{namespace}}</h6>
+<h6><strong>{{__global.assembly}}</strong>:{{assemblies.0}}.dll</h6>
+<h5 id="{{id}}_syntax">{{__global.syntax}}</h5>
+<div class="codewrapper">
+  <pre><code class="lang-{{_lang}} hljs">{{syntax.content.0.value}}</code></pre>
+</div>
+{{#syntax.parameters.0}}
+<h5 class="parameters">{{__global.parameters}}</h5>
+<table class="table table-bordered table-striped table-condensed">
+  <thead>
+    <tr>
+      <th>{{__global.type}}</th>
+      <th>{{__global.name}}</th>
+      <th>{{__global.description}}</th>
+    </tr>
+  </thead>
+  <tbody>
+{{/syntax.parameters.0}}
+{{#syntax.parameters}}
+    <tr>
+      <td>{{{type.specName.0.value}}}</td>
+      <td><em>{{{id}}}</em></td>
+      <td>{{{description}}}</td>
+    </tr>
+{{/syntax.parameters}}
+{{#syntax.parameters.0}}
+  </tbody>
+</table>
+{{/syntax.parameters.0}}
+{{#syntax.return}}
+<h5 class="returns">{{__global.returns}}</h5>
+<table class="table table-bordered table-striped table-condensed">
+  <thead>
+    <tr>
+      <th>{{__global.type}}</th>
+      <th>{{__global.description}}</th>
+    </tr>
+  </thead>
+  <tbody>
+    <tr>
+      <td>{{{type.specName.0.value}}}</td>
+      <td>{{{description}}}</td>
+    </tr>
+  </tbody>
+</table>
+{{/syntax.return}}
+{{#syntax.typeParameters.0}}
+<h5 class="typeParameters">{{__global.typeParameters}}</h5>
+<table class="table table-bordered table-striped table-condensed">
+  <thead>
+    <tr>
+      <th>{{__global.name}}</th>
+      <th>{{__global.description}}</th>
+    </tr>
+  </thead>
+  <tbody>
+{{/syntax.typeParameters.0}}
+{{#syntax.typeParameters}}
+    <tr>
+      <td><em>{{{id}}}</em></td>
+      <td>{{{description}}}</td>
+    </tr>
+{{/syntax.typeParameters}}
+{{#syntax.typeParameters.0}}
+  </tbody>
+</table>
+{{/syntax.typeParameters.0}}
+{{#remarks}}
+<h5 id="{{id}}_remarks"><strong>{{__global.remarks}}</strong></h5>
+<div class="markdown level0 remarks">{{{remarks}}}</div>
+{{/remarks}}
+{{#example.0}}
+<h5 id="{{id}}_examples"><strong>{{__global.examples}}</strong></h5>
+{{/example.0}}
+{{#example}}
+{{{.}}}
+{{/example}}
+{{#children}}
+<h3 id="{{id}}">{{>partials/classSubtitle}}</h3>
+{{#children}}
+{{^_disableContribution}}
+{{#sourceurl}}
+<span class="small pull-right mobile-hide">
+  <a href="{{sourceurl}}">{{__global.viewSource}}</a>
+</span>{{/sourceurl}}
+{{/_disableContribution}}
+<h4 id="{{id}}" data-uid="{{uid}}">{{name.0.value}}</h4>
+<div class="markdown level1 summary">{{{summary}}}</div>
+<div class="markdown level1 conceptual">{{{conceptual}}}</div>
+<h5 class="decalaration">{{__global.declaration}}</h5>
+{{#syntax}}
+<div class="codewrapper">
+  <pre><code class="lang-{{_lang}} hljs">{{syntax.content.0.value}}</code></pre>
+</div>
+{{#parameters.0}}
+<h5 class="parameters">{{__global.parameters}}</h5>
+<table class="table table-bordered table-striped table-condensed">
+  <thead>
+    <tr>
+      <th>{{__global.type}}</th>
+      <th>{{__global.name}}</th>
+      <th>{{__global.description}}</th>
+    </tr>
+  </thead>
+  <tbody>
+{{/parameters.0}}
+{{#parameters}}
+    <tr>
+      <td>{{{type.specName.0.value}}}</td>
+      <td><em>{{{id}}}</em></td>
+      <td>{{{description}}}</td>
+    </tr>
+{{/parameters}}
+{{#parameters.0}}
+  </tbody>
+</table>
+{{/parameters.0}}
+{{#return}}
+<h5 class="returns">{{__global.returns}}</h5>
+<table class="table table-bordered table-striped table-condensed">
+  <thead>
+    <tr>
+      <th>{{__global.type}}</th>
+      <th>{{__global.description}}</th>
+    </tr>
+  </thead>
+  <tbody>
+    <tr>
+      <td>{{{type.specName.0.value}}}</td>
+      <td>{{{description}}}</td>
+    </tr>
+  </tbody>
+</table>
+{{/return}}
+{{#typeParameters.0}}
+<h5 class="typeParameters">{{__global.typeParameters}}</h5>
+<table class="table table-bordered table-striped table-condensed">
+  <thead>
+    <tr>
+      <th>{{__global.name}}</th>
+      <th>{{__global.description}}</th>
+    </tr>
+  </thead>
+  <tbody>
+{{/typeParameters.0}}
+{{#typeParameters}}
+    <tr>
+      <td><em>{{{id}}}</em></td>
+      <td>{{{description}}}</td>
+    </tr>
+{{/typeParameters}}
+{{#typeParameters.0}}
+  </tbody>
+</table>
+{{/typeParameters.0}}
+{{#fieldValue}}
+<h5 class="fieldValue">{{__global.fieldValue}}</h5>
+<table class="table table-bordered table-striped table-condensed">
+  <thead>
+    <tr>
+      <th>{{__global.type}}</th>
+      <th>{{__global.description}}</th>
+    </tr>
+  </thead>
+  <tbody>
+    <tr>
+      <td>{{{type.specName.0.value}}}</td>
+      <td>{{{description}}}</td>
+    </tr>
+  </tbody>
+</table>
+{{/fieldValue}}
+{{#propertyValue}}
+<h5 class="propertyValue">{{__global.propertyValue}}</h5>
+<table class="table table-bordered table-striped table-condensed">
+  <thead>
+    <tr>
+      <th>{{__global.type}}</th>
+      <th>{{__global.description}}</th>
+    </tr>
+  </thead>
+  <tbody>
+    <tr>
+      <td>{{{type.specName.0.value}}}</td>
+      <td>{{{description}}}</td>
+    </tr>
+  </tbody>
+</table>
+{{/propertyValue}}
+{{#eventType}}
+<h5 class="eventType">{{__global.eventType}}</h5>
+<table class="table table-bordered table-striped table-condensed">
+  <thead>
+    <tr>
+      <th>{{__global.type}}</th>
+      <th>{{__global.description}}</th>
+    </tr>
+  </thead>
+  <tbody>
+    <tr>
+      <td>{{{type.specName.0.value}}}</td>
+      <td>{{{description}}}</td>
+    </tr>
+  </tbody>
+</table>
+{{/eventType}}
+{{/syntax}}
+{{#remarks}}
+<h5 id="{{id}}_remarks">{{__global.remarks}}</h5>
+<div class="markdown level1 remarks">{{{remarks}}}</div>
+{{/remarks}}
+{{#example.0}}
+<h5 id="{{id}}_examples">{{__global.examples}}</h5>
+{{/example.0}}
+{{#example}}
+{{{.}}}
+{{/example}}
+{{#exceptions.0}}
+<h5 class="exceptions">{{__global.exceptions}}</h5>
+<table class="table table-bordered table-striped table-condensed">
+  <thead>
+    <tr>
+      <th>{{__global.type}}</th>
+      <th>{{__global.condition}}</th>
+    </tr>
+  </thead>
+  <tbody>
+{{/exceptions.0}}
+{{#exceptions}}
+    <tr>
+      <td>{{{type.specName.0.value}}}</td>
+      <td>{{{description}}}</td>
+    </tr>
+{{/exceptions}}
+{{#exceptions.0}}
+  </tbody>
+</table>
+{{/exceptions.0}}
+{{/children}}
+{{/children}}

apidocs/umbracotemplate/partials/footer.tmpl.partial

@@ -0,0 +1,13 @@
+{{!Copyright (c) Microsoft. All rights reserved. Licensed under the MIT license. See LICENSE file in the project root for full license information.}}
+
+<footer>
+  <div class="grad-bottom"></div>
+  <div class="footer">
+    <div class="container">
+      <span class="pull-right">
+        <a href="#top">Back to top</a>
+      </span>
+      <span>Copyright © 2016 Umbraco<br>Generated by <strong>DocFX</strong></span>
+    </div>
+  </div>
+</footer>

apidocs/umbracotemplate/partials/head.tmpl.partial

@@ -0,0 +1,18 @@
+{{!Copyright (c) Microsoft. All rights reserved. Licensed under the MIT license. See LICENSE file in the project root for full license information.}}
+
+<head>
+  <meta charset="utf-8">
+  <meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1">
+  <title>{{#title}}{{title}}{{/title}}{{^title}}{{>partials/title}}{{/title}} {{#_appTitle}}| {{_appTitle}} {{/_appTitle}}</title>
+  <meta name="viewport" content="width=device-width">
+  <meta name="title" content="{{#title}}{{title}}{{/title}}{{^title}}{{>partials/title}}{{/title}} {{#_appTitle}}| {{_appTitle}} {{/_appTitle}}">
+  <meta name="generator" content="docfx {{_docfxVersion}}">
+  {{#_description}}<meta name="description" content="{{_description}}">{{/_description}}
+  <link rel="icon" type="image/png" href="https://our.umbraco.org/assets/images/app-icons/favicon.png">
+  <link rel="stylesheet" href="{{_rel}}styles/docfx.vendor.css">
+  <link rel="stylesheet" href="{{_rel}}styles/docfx.css">
+  <link rel="stylesheet" href="{{_rel}}styles/main.css">
+  <meta property="docfx:navrel" content="{{_navRel}}">
+  <meta property="docfx:tocrel" content="{{_tocRel}}">
+  {{#_enableSearch}}<meta property="docfx:rel" content="{{_rel}}">{{/_enableSearch}}
+</head>

apidocs/umbracotemplate/partials/namespace.tmpl.partial

@@ -0,0 +1,18 @@
+{{!Copyright (c) Microsoft. All rights reserved. Licensed under the MIT license. See LICENSE file in the project root for full license information.}}
+
+{{^_disableContribution}}
+{{#sourceurl}}
+<a href="{{sourceurl}}" class="btn btn-primary pull-right mobile-hide">{{__global.viewSource}}</a>
+{{/sourceurl}}
+{{/_disableContribution}}
+<h1 id="{{id}}" data-uid="{{uid}}">{{>partials/title}}</h1>
+<div class="markdown level0 summary">{{{summary}}}</div>
+<div class="markdown level0 conceptual">{{{conceptual}}}</div>
+<div class="markdown level0 remarks">{{{remarks}}}</div>
+{{#children}}
+  <h3 id="{{id}}">{{>partials/namespaceSubtitle}}</h3>
+  {{#children}}
+    <h4>{{{specName.0.value}}}</h4>
+    <section>{{{summary}}}</section>
+  {{/children}}
+{{/children}}

apidocs/umbracotemplate/partials/navbar.tmpl.partial

@@ -0,0 +1,22 @@
+{{!Copyright (c) Microsoft. All rights reserved. Licensed under the MIT license. See LICENSE file in the project root for full license information.}}
+
+<nav id="autocollapse" class="navbar navbar-inverse ng-scope" role="navigation">
+  <div class="container">
+    <div class="navbar-header">
+      <button type="button" class="navbar-toggle" data-toggle="collapse" data-target="#navbar">
+        <span class="sr-only">Toggle navigation</span>
+        <span class="icon-bar"></span>
+        <span class="icon-bar"></span>
+        <span class="icon-bar"></span>
+      </button>
+	  <a class="navbar-brand" href="/" alt="Our Umbraco"></a>
+    </div>
+    <div class="collapse navbar-collapse" id="navbar">
+      <form class="navbar-form navbar-right" role="search" id="search">
+        <div class="form-group">
+          <input type="text" class="form-control" id="search-query" placeholder="Search" autocomplete="off">
+        </div>
+      </form>
+    </div>
+  </div>
+</nav>

apidocs/umbracotemplate/partials/rest.tmpl.partial

@@ -0,0 +1,101 @@
+{{!Copyright (c) Microsoft. All rights reserved. Licensed under the MIT license. See LICENSE file in the project root for full license information.}}
+
+{{^_disableContribution}}
+{{#sourceurl}}<a href="{{sourceurl}}" class="btn btn-primary pull-right mobile-hide">View Source</a>{{/sourceurl}}
+{{/_disableContribution}}
+<h1 id="{{htmlId}}" data-uid="{{uid}}" class="text-capitalize">{{name}}</h1>
+{{#summary}}
+<div class="markdown level0 summary">{{{summary}}}</div>
+{{/summary}}
+{{#description}}
+<div class="markdown level0 description">{{{description}}}</div>
+{{/description}}
+{{#conceptual}}
+  <div class="markdown level0 conceptual">{{{conceptual}}}</div>
+{{/conceptual}}
+{{#children}}
+{{^_disableContribution}}
+{{#sourceurl}}
+<span class="small pull-right mobile-hide">
+  <a href="{{sourceurl}}">View Source</a>
+</span>{{/sourceurl}}
+{{/_disableContribution}}
+ <h3 id="{{htmlId}}" data-uid="{{uid}}" class="text-capitalize">{{operationId}}</h3>
+{{#summary}}
+<div class="markdown level1 summary">{{{summary}}}</div>
+{{/summary}}
+{{#description}}
+<div class="markdown level1 description">{{{description}}}</div>
+{{/description}}
+{{#conceptual}}
+  <div class="markdown level1 conceptual">{{{conceptual}}}</div>
+{{/conceptual}}
+<h5>Request</h5>
+<div class="codewrapper">
+  <pre><code class="lang-restApi hljs">{{operation}} {{path}}</code></pre>
+</div>
+{{#parameters.0}}
+<h5>Parameters</h5>
+<table class="table table-bordered table-striped table-condensed">
+  <thead>
+    <tr>
+      <th>Name</th>
+      <th>Type</th>
+      <th>Value</th>
+      <th>Notes</th>
+    </tr>
+  </thead>
+  <tbody>
+{{/parameters.0}}
+{{#parameters}}
+    <tr>
+      <td><em>{{#required}}*{{/required}}{{name}}</em></td>
+      <td>{{type}}</td>
+      <td>{{default}}</td>
+      <td>{{{description}}}</td>
+    </tr>
+  {{/parameters}}
+  {{#parameters.0}}
+  </tbody>
+</table>
+{{/parameters.0}}
+{{#responses.0}}
+<div class="responses">
+  <h5>Responses</h5>
+  <table class="table table-bordered table-striped table-condensed">
+    <thead>
+      <tr>
+        <th>Status Code</th>
+        <th>Description</th>
+        <th>Samples</th>
+      </tr>
+    </thead>
+    <tbody>
+{{/responses.0}}
+{{#responses}}
+    <tr>
+      <td><span class="status">{{statusCode}}</span></td>
+      <td>{{{description}}}</td>
+      <td class="sample-response">
+        {{#examples}}
+        <div class="mime-type">
+          <i>Mime type: </i><span class="mime">{{mimeType}}</span>
+        </div>
+        <pre class="response-content"><code class="lang-js json hljs">{{content}}</code></pre>
+        {{/examples}}
+      </td>
+    </tr>
+  {{/responses}}
+  {{#responses.0}}
+    </tbody>
+  </table>
+</div>
+{{/responses.0}}
+{{#footer}}
+<div class="markdown level1 api-footer">{{{footer}}}</div>
+{{/footer}}
+{{/children}}
+{{#footer}}
+<div class="markdown level0 api-footer">{{{footer}}}</div>
+{{/footer}}
+

apidocs/umbracotemplate/styles/main.css

@@ -0,0 +1,73 @@
+body {
+	color: rgba(0,0,0,.8);
+}
+.navbar-inverse {
+  background: #a3db78;
+}
+.navbar-inverse .navbar-nav>li>a, .navbar-inverse .navbar-text {
+  color: rgba(0,0,0,.8);
+}
+
+.navbar-inverse {
+    border-color: transparent;
+}
+
+.sidetoc {
+  background-color: #f5fbf1;
+}
+body .toc {
+  background-color: #f5fbf1;
+}
+.sidefilter {
+  background-color: #daf0c9;
+}
+.subnav {
+  background-color: #f5fbf1;
+}
+
+.navbar-inverse .navbar-nav>.active>a {
+	color: rgba(0,0,0,.8);
+    background-color: #daf0c9;
+}
+
+.navbar-inverse .navbar-nav>.active>a:focus, .navbar-inverse .navbar-nav>.active>a:hover {
+	color: rgba(0,0,0,.8);
+    background-color: #daf0c9;
+}
+
+.btn-primary {
+    color: rgba(0,0,0,.8);
+    background-color: #fff;
+    border-color: rgba(0,0,0,.8);
+}
+.btn-primary:hover {
+    background-color: #daf0c9;
+	color: rgba(0,0,0,.8);
+	border-color: rgba(0,0,0,.8);
+}
+
+.toc .nav > li > a {
+    color: rgba(0,0,0,.8);
+}
+
+button, a {
+    color: #f36f21;
+}
+
+button:hover,
+button:focus,
+a:hover,
+a:focus {
+  color: #143653;
+  text-decoration: none;
+}
+
+.navbar-header .navbar-brand {
+    background: url(https://our.umbraco.org/assets/images/logo.svg) left center no-repeat;
+    background-size: 40px auto;
+    width:50px;
+}
+
+.toc .nav > li.active > a {
+    color: #f36f21;
+}

appveyor.yml

@@ -0,0 +1,51 @@
+version: '{build}'
+shallow_clone: true
+build_script:
+- cmd: >-
+    cd build
+
+    SET "release="
+
+    FOR /F "skip=1 delims=" %%i IN (UmbracoVersion.txt) DO IF NOT DEFINED release SET "release=%%i"
+
+    SET PATH=C:\Program Files (x86)\MSBuild\14.0\Bin;%PATH%
+
+    ECHO %PATH%
+
+
+    ECHO Building Release %release% build%APPVEYOR_BUILD_NUMBER%
+
+
+    SET nuGetFolder=%CD%\..\src\packages\
+
+    ..\src\.nuget\NuGet.exe sources Add -Name MyGetUmbracoCore -Source https://www.myget.org/F/umbracocore/api/v2/ >NUL
+
+    ..\src\.nuget\NuGet.exe install ..\src\Umbraco.Web.UI\packages.config -OutputDirectory %nuGetFolder% -Verbosity quiet
+
+
+    IF EXIST ..\src\umbraco.businesslogic\packages.config ..\src\.nuget\NuGet.exe install ..\src\umbraco.businesslogic\packages.config -OutputDirectory %nuGetFolder% -Verbosity quiet
+
+    ..\src\.nuget\NuGet.exe install ..\src\Umbraco.Core\packages.config -OutputDirectory %nuGetFolder% -Verbosity quiet
+
+
+    SET MSBUILD="C:\Program Files (x86)\MSBuild\14.0\Bin\MsBuild.exe"
+
+    %MSBUILD% "../src/Umbraco.Tests/Umbraco.Tests.csproj" /verbosity:minimal
+
+
+    build.bat %release% build%APPVEYOR_BUILD_NUMBER%
+
+
+    ECHO %PATH%
+test:
+  assemblies: src\Umbraco.Tests\bin\Debug\Umbraco.Tests.dll
+artifacts:
+- path: build\UmbracoCms.*
+notifications:
+- provider: Slack
+  auth_token:
+    secure: v2csJi2V5ghR0rPdODK8GJdOGNCA+XaK84iQ9MdPOClqB+VU+40ybdKp6gPirGSH
+  channel: '#build-umbraco-core'
+  on_build_success: false
+  on_build_failure: true
+  on_build_status_changed: false

build/ApiDocs/TOC.css

@@ -1,170 +0,0 @@
-/* File    : TOC.css
-// Author  : Eric Woodruff  (Eric@EWoodruff.us)
-// Updated : 09/07/2007
-//
-// Stylesheet for the table of content
-*/
-
-*
-{
-	margin: 0px 0px 0px 0px;
-	padding: 0px 0px 0px 0px;
-}
-
-body
-{
-    font-family: Segoe UI, Arial, Verdana, Helvetica, sans-serif;
-    font-size: 0.9em;
-    background-color: white;
-    color: White;
-	overflow: hidden;
-}
-
-input
-{
-	padding:5px;
-	margin: 3px 0px 3px 0px
-}
-
-img
-{
-    border: 0;
-    margin-left: 5px;
-    margin-right: 2px;
-}
-
-img.TreeNodeImg
-{
-    cursor: pointer;
-}
-
-img.TOCLink
-{
-    cursor: pointer;
-    margin-left: 0;
-    margin-right: 0;
-}
-
-a.SelectedNode, a.UnselectedNode
-{
-	color: #333;
-    text-decoration: none;
-	padding: 1px 3px 1px 3px;
-    white-space: nowrap;
-}
-
-a.SelectedNode
-{
-	background-color: #ffffff;
-    border: solid 1px #999999;
-	padding: 0px 2px 0px 2px;
-}
-
-a.UnselectedNode:hover, a.SelectedNode:hover
-{
-    background-color: #cccccc;
-    border: solid 1px #999999;
-	padding: 0px 2px 0px 2px;
-}
-
-.Visible
-{
-    display: block;
-    margin-left: 2em;
-}
-
-.Hidden
-{
-    display: none;
-}
-
-.Tree
-{
-	background-color: #fff;
-	color: #333;
-    width: 300px;
-	overflow: auto;
-}
-
-.TreeNode, .TreeItem
-{
-    white-space: nowrap;
-    margin: 2px 2px 2px 2px;
-}
-
-.TOCDiv
-{
-	position: relative;
-	float: left;
-	width: 300px;
-    height: 100%;
-}
-
-.TOCSizer
-{
-	clear: none;
-	float: left;
-	width: 10px;
-    height: 100%;    
-    background-image: url("Splitter.gif");
-    background-position:center center;
-	background-repeat:no-repeat;
-	position: relative;
-	cursor: w-resize;
-	border-left: solid 1px #CCC;
-}
-
-.TopicContent
-{
-	position: relative;
-	float: right;
-    background-color: white;
-    height: 100%;
-}
-
-.SearchOpts
-{
-    padding: 5px 5px 10px 5px;    
-    color: black;
-    width: 300px;
-	border-bottom: solid lightgrey 1px;
-	height: 110px !important;
-}
-
-.NavOpts
-{
-    padding: 5px 5px 6px 5px;    
-    color: black;
-    width: 300px;
-	border-bottom: solid lightgrey 1px;
-}
-
-.NavOpts img {
-	display:inline-block;
-	margin: 0px 5px 0px 5px;
-}
-
-.IndexOpts
-{
-    padding: 5px 5px 6px 5px;        
-    color: black;
-    width: 300px;
-	border-bottom: solid lightgrey 1px;
-}
-
-.IndexItem
-{
-    white-space: nowrap;
-    margin: 2px 2px 2px 2px;
-}
-
-.IndexSubItem
-{
-    white-space: nowrap;
-    margin: 2px 2px 2px 12px;
-}
-
-.PaddedText
-{
-    margin: 10px 10px 10px 10px;
-}

build/ApiDocs/csharp-api-docs.shfbproj

@@ -1,172 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="4.0">
-  <PropertyGroup>
-    <!-- The configuration and platform will be used to determine which
-         assemblies to include from solution and project documentation
-         sources -->
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{cb4d85f1-7390-40ee-b41f-a724bb8fddea}</ProjectGuid>
-    <SHFBSchemaVersion>1.9.5.0</SHFBSchemaVersion>
-    <!-- AssemblyName, Name, and RootNamespace are not used by SHFB but Visual
-         Studio adds them anyway -->
-    <AssemblyName>Documentation</AssemblyName>
-    <RootNamespace>Documentation</RootNamespace>
-    <Name>Documentation</Name>
-    <!-- SHFB properties -->
-    <FrameworkVersion>.NET Framework 4.5</FrameworkVersion>
-    <OutputPath>.\Output\</OutputPath>
-    <HtmlHelpName>UmbracoClassLibrary</HtmlHelpName>
-    <Language>en-US</Language>
-    <BuildAssemblerVerbosity>OnlyErrors</BuildAssemblerVerbosity>
-    <BuildLogFile>csharp-api-docs.log</BuildLogFile>
-    <HelpFileFormat>Website</HelpFileFormat>
-    <IndentHtml>True</IndentHtml>
-    <KeepLogFile>False</KeepLogFile>
-    <DisableCodeBlockComponent>False</DisableCodeBlockComponent>
-    <CppCommentsFixup>False</CppCommentsFixup>
-    <CleanIntermediates>True</CleanIntermediates>
-    <SyntaxFilters>CSharp</SyntaxFilters>
-    <SdkLinkTarget>Blank</SdkLinkTarget>
-    <RootNamespaceContainer>False</RootNamespaceContainer>
-    <PresentationStyle>VS2010</PresentationStyle>
-    <Preliminary>False</Preliminary>
-    <NamingMethod>Guid</NamingMethod>
-    <HelpTitle>Umbraco .Net Class Library</HelpTitle>
-    <ContentPlacement>AboveNamespaces</ContentPlacement>
-    <VisibleItems>Attributes, InheritedMembers, InheritedFrameworkMembers, Protected, SealedProtected</VisibleItems>
-    <ComponentConfigurations />
-    <DocumentationSources>
-      <DocumentationSource sourceFile="..\..\src\Umbraco.Core\Umbraco.Core.csproj" />
-<DocumentationSource sourceFile="..\..\src\Umbraco.Core\bin\Release\Umbraco.Core.xml" />
-<DocumentationSource sourceFile="..\..\src\Umbraco.Web\Umbraco.Web.csproj" />
-<DocumentationSource sourceFile="..\..\src\Umbraco.Web\bin\Release\umbraco.xml" /></DocumentationSources>
-    <WebsiteSdkLinkType>None</WebsiteSdkLinkType>
-    <HtmlSdkLinkType>None</HtmlSdkLinkType>
-    <IncludeFavorites>False</IncludeFavorites>
-    <BinaryTOC>True</BinaryTOC>
-    <MissingTags>Summary, AutoDocumentCtors, AutoDocumentDispose</MissingTags>
-    <TransformComponentArguments>
-      <Argument Key="logoFile" Value="" />
-      <Argument Key="logoHeight" Value="" />
-      <Argument Key="logoWidth" Value="" />
-      <Argument Key="logoAltText" Value="" />
-      <Argument Key="logoPlacement" Value="left" />
-      <Argument Key="logoAlignment" Value="left" />
-    </TransformComponentArguments>
-    <ApiFilter>
-      <Filter entryType="Namespace" fullName="CookComputing.Blogger" isExposed="False" xmlns="" />
-<Filter entryType="Namespace" fullName="CookComputing.MetaWeblog" isExposed="False" xmlns="" />
-<Filter entryType="Namespace" fullName="dashboardUtilities" isExposed="False" xmlns="" />
-<Filter entryType="Namespace" fullName="presentation.umbraco.webservices" isExposed="False" xmlns="" />
-<Filter entryType="Namespace" fullName="umbraco" isExposed="False" xmlns="">
-  <Filter entryType="Class" fullName="umbraco.content" filterName="content" isExposed="True" />
-  <Filter entryType="Delegate" fullName="umbraco.content.ContentCacheDatabaseLoadXmlStringEventHandler" filterName="content.ContentCacheDatabaseLoadXmlStringEventHandler" isExposed="False" />
-  <Filter entryType="Delegate" fullName="umbraco.content.ContentCacheLoadNodeEventHandler" filterName="content.ContentCacheLoadNodeEventHandler" isExposed="False" />
-  <Filter entryType="Delegate" fullName="umbraco.content.DocumentCacheEventHandler" filterName="content.DocumentCacheEventHandler" isExposed="False" />
-  <Filter entryType="Delegate" fullName="umbraco.content.RefreshContentEventHandler" filterName="content.RefreshContentEventHandler" isExposed="False" />
-  <Filter entryType="Class" fullName="umbraco.ContentExtensions" filterName="ContentExtensions" isExposed="True" />
-  <Filter entryType="Class" fullName="umbraco.ContentTypeExtensions" filterName="ContentTypeExtensions" isExposed="True" />
-  <Filter entryType="Class" fullName="umbraco.item" filterName="item" isExposed="True" />
-  <Filter entryType="Class" fullName="umbraco.library" filterName="library" isExposed="True" />
-  <Filter entryType="Class" fullName="umbraco.macro" filterName="macro" isExposed="True" />
-  <Filter entryType="Class" fullName="umbraco.MacroCacheContent" filterName="MacroCacheContent" isExposed="True" />
-  <Filter entryType="Class" fullName="umbraco.MacroRenderingEventArgs" filterName="MacroRenderingEventArgs" isExposed="True" />
-  <Filter entryType="Class" fullName="umbraco.MediaExtensions" filterName="MediaExtensions" isExposed="True" />
-  <Filter entryType="Class" fullName="umbraco.MemberExtensions" filterName="MemberExtensions" isExposed="True" />
-  <Filter entryType="Class" fullName="umbraco.page" filterName="page" isExposed="True" />
-  <Filter entryType="Class" fullName="umbraco.PreValueExtensions" filterName="PreValueExtensions" isExposed="True" />
-  <Filter entryType="Class" fullName="umbraco.RelationTypeExtensions" filterName="RelationTypeExtensions" isExposed="True" />
-  <Filter entryType="Class" fullName="umbraco.template" filterName="template" isExposed="True" />
-  <Filter entryType="Class" fullName="umbraco.UmbracoObjectTypeExtensions" filterName="UmbracoObjectTypeExtensions" isExposed="True" />
-  <Filter entryType="Class" fullName="umbraco.uQuery" filterName="uQuery" isExposed="True" />
-  <Filter entryType="Interface" fullName="umbraco.uQuery.IGetProperty" filterName="uQuery.IGetProperty" isExposed="True" />
-  <Filter entryType="Class" fullName="umbraco.uQuery.Members" filterName="uQuery.Members" isExposed="True" />
-  <Filter entryType="Enumeration" fullName="umbraco.uQuery.UmbracoObjectType" filterName="uQuery.UmbracoObjectType" isExposed="True" />
-</Filter>
-<Filter entryType="Namespace" fullName="umbraco.cms.presentation" isExposed="False" xmlns="" />
-<Filter entryType="Namespace" fullName="umbraco.cms.presentation.create.controls" isExposed="False" xmlns="" />
-<Filter entryType="Namespace" fullName="umbraco.cms.presentation.developer" isExposed="False" xmlns="" />
-<Filter entryType="Namespace" fullName="umbraco.cms.presentation.developer.RelationTypes" isExposed="False" xmlns="" />
-<Filter entryType="Namespace" fullName="umbraco.cms.presentation.developer.RelationTypes.TreeMenu" isExposed="False" xmlns="" />
-<Filter entryType="Namespace" fullName="umbraco.cms.presentation.members" isExposed="False" xmlns="" />
-<Filter entryType="Namespace" fullName="umbraco.cms.presentation.settings" isExposed="False" xmlns="" />
-<Filter entryType="Namespace" fullName="umbraco.cms.presentation.settings.modal" isExposed="False" xmlns="" />
-<Filter entryType="Namespace" fullName="umbraco.cms.presentation.settings.scripts" isExposed="False" xmlns="" />
-<Filter entryType="Namespace" fullName="umbraco.cms.presentation.settings.stylesheet" isExposed="False" xmlns="" />
-<Filter entryType="Namespace" fullName="umbraco.cms.presentation.user" isExposed="False" xmlns="" />
-<Filter entryType="Namespace" fullName="umbraco.controls" isExposed="False" xmlns="" />
-<Filter entryType="Namespace" fullName="umbraco.controls.GenericProperties" isExposed="False" xmlns="" />
-<Filter entryType="Namespace" fullName="umbraco.controls.Images" isExposed="False" xmlns="" />
-<Filter entryType="Namespace" fullName="umbraco.controls.Tree" isExposed="False" xmlns="" />
-<Filter entryType="Namespace" fullName="umbraco.developer" isExposed="False" xmlns="" />
-<Filter entryType="Namespace" fullName="umbraco.dialogs" isExposed="False" xmlns="" />
-<Filter entryType="Namespace" fullName="umbraco.js" isExposed="False" xmlns="" />
-<Filter entryType="Namespace" fullName="umbraco.layoutControls" isExposed="False" xmlns="" />
-<Filter entryType="Namespace" fullName="umbraco.NodeFactory" isExposed="False" xmlns="" />
-<Filter entryType="Namespace" fullName="umbraco.presentation.actions" isExposed="False" xmlns="" />
-<Filter entryType="Namespace" fullName="umbraco.presentation.channels" isExposed="False" xmlns="" />
-<Filter entryType="Namespace" fullName="umbraco.presentation.channels.businesslogic" isExposed="False" xmlns="" />
-<Filter entryType="Namespace" fullName="umbraco.presentation.create" isExposed="False" xmlns="" />
-<Filter entryType="Namespace" fullName="umbraco.presentation.developer.packages" isExposed="False" xmlns="" />
-<Filter entryType="Namespace" fullName="umbraco.presentation.dialogs" isExposed="False" xmlns="" />
-<Filter entryType="Namespace" fullName="umbraco.presentation.masterpages" isExposed="False" xmlns="" />
-<Filter entryType="Namespace" fullName="umbraco.presentation.members" isExposed="False" xmlns="" />
-<Filter entryType="Namespace" fullName="umbraco.presentation.nodeFactory" isExposed="False" xmlns="" />
-<Filter entryType="Namespace" fullName="umbraco.presentation.org.umbraco.update" isExposed="False" xmlns="" />
-<Filter entryType="Namespace" fullName="umbraco.presentation.plugins.tinymce3" isExposed="False" xmlns="" />
-<Filter entryType="Namespace" fullName="umbraco.presentation.preview" isExposed="False" xmlns="" />
-<Filter entryType="Namespace" fullName="umbraco.presentation.Search" isExposed="False" xmlns="" />
-<Filter entryType="Namespace" fullName="umbraco.presentation.settings" isExposed="False" xmlns="" />
-<Filter entryType="Namespace" fullName="umbraco.presentation.templateControls" isExposed="False" xmlns="">
-  <Filter entryType="Class" fullName="umbraco.presentation.templateControls.Item" filterName="Item" isExposed="True" />
-  <Filter entryType="Class" fullName="umbraco.presentation.templateControls.ItemRenderer" filterName="ItemRenderer" isExposed="True" />
-  <Filter entryType="Class" fullName="umbraco.presentation.templateControls.Macro" filterName="Macro" isExposed="True" />
-  <Filter entryType="Enumeration" fullName="umbraco.presentation.templateControls.Macro.RenderEvents" filterName="Macro.RenderEvents" isExposed="False" />
-</Filter>
-<Filter entryType="Namespace" fullName="umbraco.presentation.tinymce3" isExposed="False" xmlns="" />
-<Filter entryType="Namespace" fullName="umbraco.presentation.translation" isExposed="False" xmlns="" />
-<Filter entryType="Namespace" fullName="umbraco.presentation.umbraco" isExposed="False" xmlns="" />
-<Filter entryType="Namespace" fullName="umbraco.presentation.umbraco.channels" isExposed="False" xmlns="" />
-<Filter entryType="Namespace" fullName="umbraco.presentation.umbraco.controls" isExposed="False" xmlns="" />
-<Filter entryType="Namespace" fullName="umbraco.presentation.umbraco.create" isExposed="False" xmlns="" />
-<Filter entryType="Namespace" fullName="umbraco.presentation.umbraco.developer.Xslt" isExposed="False" xmlns="" />
-<Filter entryType="Namespace" fullName="umbraco.presentation.umbraco.dialogs" isExposed="False" xmlns="" />
-<Filter entryType="Namespace" fullName="umbraco.presentation.umbraco.masterpages" isExposed="False" xmlns="" />
-<Filter entryType="Namespace" fullName="umbraco.presentation.umbraco.members" isExposed="False" xmlns="" />
-<Filter entryType="Namespace" fullName="umbraco.presentation.umbraco.plugins.tinymce3" isExposed="False" xmlns="" />
-<Filter entryType="Namespace" fullName="umbraco.presentation.umbraco.Search" isExposed="False" xmlns="" />
-<Filter entryType="Namespace" fullName="umbraco.presentation.umbraco.translation" isExposed="False" xmlns="" />
-<Filter entryType="Namespace" fullName="umbraco.presentation.umbraco.webservices" isExposed="False" xmlns="" />
-<Filter entryType="Namespace" fullName="umbraco.presentation.umbraco_client.tinymce3.plugins.spellchecker" isExposed="False" xmlns="" />
-<Filter entryType="Namespace" fullName="umbraco.presentation.urlRewriter" isExposed="False" xmlns="" />
-<Filter entryType="Namespace" fullName="umbraco.presentation.Web.UI" isExposed="False" xmlns="" />
-<Filter entryType="Namespace" fullName="umbraco.presentation.webservices" isExposed="False" xmlns="" />
-<Filter entryType="Namespace" fullName="umbraco.scripting" isExposed="False" xmlns="" />
-<Filter entryType="Namespace" fullName="umbraco.settings" isExposed="False" xmlns="" />
-<Filter entryType="Namespace" fullName="Umbraco.Web.org.umbraco.our" isExposed="False" xmlns="" />
-<Filter entryType="Namespace" fullName="umbraco.webservices" isExposed="False" xmlns="" /></ApiFilter>
-  </PropertyGroup>
-  <!-- There are no properties for these groups.  AnyCPU needs to appear in
-       order for Visual Studio to perform the build.  The others are optional
-       common platform types that may appear. -->
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x86' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x86' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x64' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x64' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|Win32' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|Win32' ">
-  </PropertyGroup>
-  <!-- Import the SHFB build targets -->
-  <Import Project="$(SHFBROOT)\SandcastleHelpFileBuilder.targets" />
-</Project>

build/Build.bat

@@ -21,14 +21,6 @@ ECHO Building Umbraco %version%
 
 ReplaceIISExpressPortNumber.exe ..\src\Umbraco.Web.UI\Umbraco.Web.UI.csproj %release%
 
-ECHO Installing the Microsoft.Bcl.Build package before anything else, otherwise you'd have to run build.cmd twice
-SET nuGetFolder=%CD%\..\src\packages\
-..\src\.nuget\NuGet.exe sources Remove -Name MyGetUmbracoCore >NUL
-..\src\.nuget\NuGet.exe sources Add -Name MyGetUmbracoCore -Source https://www.myget.org/F/umbracocore/api/v2/ >NUL
-..\src\.nuget\NuGet.exe install ..\src\Umbraco.Web.UI\packages.config -OutputDirectory %nuGetFolder% -Verbosity quiet
-..\src\.nuget\NuGet.exe install ..\src\umbraco.businesslogic\packages.config -OutputDirectory %nuGetFolder% -Verbosity quiet
-..\src\.nuget\NuGet.exe install ..\src\Umbraco.Core\packages.config -OutputDirectory %nuGetFolder% -Verbosity quiet
-
 ECHO Removing the belle build folder and bower_components folder to make sure everything is clean as a whistle
 RD ..\src\Umbraco.Web.UI.Client\build /Q /S
 RD ..\src\Umbraco.Web.UI.Client\bower_components /Q /S

build/Build.proj

@@ -175,8 +175,8 @@
     <!-- Copy SQL CE -->
     <ItemGroup>
       <SQLCE4Files
-     Include="..\src\packages\SqlServerCE.4.0.0.0\**\*.*"
-     Exclude="..\src\packages\SqlServerCE.4.0.0.0\lib\**\*;..\src\packages\SqlServerCE.4.0.0.0\**\*.nu*"
+     Include="..\src\packages\SqlServerCE.4.0.0.1\**\*.*"
+     Exclude="..\src\packages\SqlServerCE.4.0.0.1\lib\**\*;..\src\packages\SqlServerCE.4.0.0.1\**\*.nu*"
 		/>
     </ItemGroup>
 

build/BuildDocs.bat

@@ -0,0 +1,20 @@
+@ECHO OFF
+SETLOCAL
+
+SET release=%1
+ECHO Installing Npm NuGet Package
+
+SET nuGetFolder=%CD%\..\src\packages\
+ECHO Configured packages folder: %nuGetFolder%
+ECHO Current folder: %CD%
+
+%CD%\..\src\.nuget\NuGet.exe install Npm.js -OutputDirectory %nuGetFolder%  -Verbosity quiet
+
+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 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%
+
+Powershell.exe -ExecutionPolicy Unrestricted  -File .\BuildDocs.ps1

build/BuildDocs.ps1

@@ -1,27 +1,100 @@
-##We cannot continue if sandcastle is not installed determined by env variable: SHFBROOT
+$PSScriptFilePath = (Get-Item $MyInvocation.MyCommand.Path);
+$RepoRoot = (get-item $PSScriptFilePath).Directory.Parent.FullName;
+$SolutionRoot = Join-Path -Path $RepoRoot "src";
+$ToolsRoot = Join-Path -Path $RepoRoot "tools";
+$DocFx = Join-Path -Path $ToolsRoot "docfx\docfx.exe"
+$DocFxFolder = (Join-Path -Path $ToolsRoot "docfx")
+$DocFxJson = Join-Path -Path $RepoRoot "apidocs\docfx.json"
+$7Zip = Join-Path -Path $ToolsRoot "7zip\7za.exe"
+$DocFxSiteOutput = Join-Path -Path $RepoRoot "apidocs\_site\*.*"
+$NgDocsSiteOutput = Join-Path -Path $RepoRoot "src\Umbraco.Web.UI.Client\docs\api\*.*"
+$ProgFiles86 = [Environment]::GetEnvironmentVariable("ProgramFiles(x86)");
+$MSBuild = "$ProgFiles86\MSBuild\14.0\Bin\MSBuild.exe"
 
-if (-not (Test-Path Env:\SHFBROOT))
-{
-	throw "The docs cannot be build, install Sandcastle help file builder"
+
+################ Do the UI docs
+
+"Changing to Umbraco.Web.UI.Client folder"
+cd ..
+cd src\Umbraco.Web.UI.Client
+Write-Host $(Get-Location)
+
+"Creating build folder so MSBuild doesn't run the whole grunt build"
+if (-Not (Test-Path "build")) {
+    md "build"
 }
 
-$PSScriptFilePath = (Get-Item $MyInvocation.MyCommand.Path).FullName
-$BuildRoot = Split-Path -Path $PSScriptFilePath -Parent
-$OutputPath = Join-Path -Path $BuildRoot -ChildPath "ApiDocs\Output"
-$ProjFile = Join-Path -Path $BuildRoot -ChildPath "ApiDocs\csharp-api-docs.shfbproj"
+"Installing node"
+# Check if Install-Product exists, should only exist on the build server
+if (Get-Command Install-Product -errorAction SilentlyContinue)
+{
+    Install-Product node ''
+}
 
-"Building docs with project file:  $ProjFile"
+"Installing node modules"
+& npm install
 
-$MSBuild = "$Env:SYSTEMROOT\Microsoft.NET\Framework\v4.0.30319\msbuild.exe"
+"Installing grunt"
+& npm install -g grunt-cli
 
-# build it!
-& $MSBuild "$ProjFile"
+"Moving back to build folder"
+cd ..
+cd ..
+cd build
+Write-Host $(Get-Location)
 
-# remove files left over
-Remove-Item $BuildRoot\* -include csharp-api-docs.shfbproj_*
+ & grunt --gruntfile ../src/umbraco.web.ui.client/gruntfile.js docs
 
-# copy our custom styles in
-Copy-Item $BuildRoot\ApiDocs\TOC.css $OutputPath\TOC.css
+# change baseUrl
+$BaseUrl = "https://our.umbraco.org/apidocs/ui/"
+$IndexPath = "../src/umbraco.web.ui.client/docs/api/index.html"
+(Get-Content $IndexPath).replace('location.href.replace(rUrl, indexFile)', "`'" + $BaseUrl + "`'") | Set-Content $IndexPath
+# zip it
 
-""
-"Done!"
+& $7Zip a -tzip ui-docs.zip $NgDocsSiteOutput -r
+
+################ Do the c# docs
+
+# Build the solution in debug mode
+$SolutionPath = Join-Path -Path $SolutionRoot -ChildPath "umbraco.sln"
+& $MSBuild "$SolutionPath" /p:Configuration=Debug /maxcpucount /t:Clean
+if (-not $?)
+{
+	throw "The MSBuild process returned an error code."
+}
+& $MSBuild "$SolutionPath" /p:Configuration=Debug /maxcpucount
+if (-not $?)
+{
+	throw "The MSBuild process returned an error code."
+}
+
+# Go get docfx if we don't hae it
+$FileExists = Test-Path $DocFx 
+If ($FileExists -eq $False) {
+
+	If(!(Test-Path $DocFxFolder))
+	{
+		New-Item $DocFxFolder -type directory
+	}	
+	
+	$DocFxZip = Join-Path -Path $ToolsRoot "docfx\docfx.zip"
+	$DocFxSource = "https://github.com/dotnet/docfx/releases/download/v1.9.4/docfx.zip"
+	Invoke-WebRequest $DocFxSource -OutFile $DocFxZip
+
+	#unzip it	
+	& $7Zip e $DocFxZip "-o$DocFxFolder"
+}
+
+#clear site
+If(Test-Path(Join-Path -Path $RepoRoot "apidocs\_site"))
+{
+	Remove-Item $DocFxSiteOutput -recurse
+}
+
+# run it!
+& $DocFx metadata $DocFxJson
+& $DocFx build $DocFxJson
+
+# zip it
+
+& $7Zip a -tzip csharp-docs.zip $DocFxSiteOutput -r

build/NuSpecs/UmbracoCms.Core.nuspec

@@ -17,11 +17,10 @@
     <dependencies>
       <dependency id="Microsoft.AspNet.Mvc" version="[5.2.3,6.0.0)" />
       <dependency id="Microsoft.AspNet.WebApi" version="[5.2.3,6.0.0)" />
-      <dependency id="Microsoft.Net.Http" version="[2.2.29, 3.0.0)" />
       <dependency id="Microsoft.AspNet.Identity.Owin" version="[2.2.1, 3.0.0)" />
       <dependency id="Microsoft.Owin.Security.Cookies" version="[3.0.1, 4.0.0)" />
       <dependency id="Microsoft.Owin.Security.OAuth" version="[3.0.1, 4.0.0)" />
-      <dependency id="Microsoft.Owin.Host.SystemWeb" version="[3.0.1, 4.0.0)" />      
+      <dependency id="Microsoft.Owin.Host.SystemWeb" version="[3.0.1, 4.0.0)" />
       <dependency id="MiniProfiler" version="[2.1.0, 3.0.0)" />
       <dependency id="HtmlAgilityPack" version="[1.4.9, 2.0.0)" />
       <dependency id="Lucene.Net" version="[2.9.4.1, 3.0.0.0)" />
@@ -31,14 +30,13 @@
       <dependency id="ClientDependency" version="[1.8.4, 2.0.0)" />
       <dependency id="ClientDependency-Mvc5" version="[1.8.0, 2.0.0)" />
       <dependency id="AutoMapper" version="[3.0.0, 3.1.0)" />
-      <dependency id="Newtonsoft.Json" version="[6.0.8, 7.0.0)" />
+      <dependency id="Newtonsoft.Json" version="[6.0.8, 9.0.0)" />
       <dependency id="Examine" version="[0.1.68, 1.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="ImageProcessor" version="[2.3.3, 3.0.0)" />
+      <dependency id="ImageProcessor.Web" version="[4.5.3, 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)" />	
+      <dependency id="UrlRewritingNet" version="[2.0.7, 3.0.0)" />	  
+      <dependency id="Markdown" version="[1.14.4, 2.0.0)" />	  
     </dependencies>
   </metadata>
   <files>
@@ -73,35 +71,34 @@
     <file src="..\_BuildOutput\WebApp\bin\Umbraco.Web.UI.xml" target="lib\Umbraco.Web.UI.xml" />
     <file src="..\_BuildOutput\WebApp\bin\UmbracoExamine.dll" target="lib\UmbracoExamine.dll" />
     <file src="..\_BuildOutput\WebApp\bin\UmbracoExamine.xml" target="lib\UmbracoExamine.xml" />
-    <file src="..\_BuildOutput\WebApp\bin\UrlRewritingNet.UrlRewriter.dll" target="lib\UrlRewritingNet.UrlRewriter.dll" />
     <file src="tools\install.core.ps1" target="tools\install.ps1" />
 
-	<!-- Added to be able to produce a symbols package -->
-	<file src="..\_BuildOutput\bin\SQLCE4Umbraco.pdb" target="lib" />
+    <!-- Added to be able to produce a symbols package -->
+    <file src="..\_BuildOutput\bin\SQLCE4Umbraco.pdb" target="lib" />
     <file src="..\..\src\SQLCE4Umbraco\**\*.cs" exclude="..\..\src\**\TemporaryGeneratedFile*.cs" target="src\SQLCE4Umbraco" />
-	<file src="..\_BuildOutput\bin\businesslogic.pdb" target="lib" />
+    <file src="..\_BuildOutput\bin\businesslogic.pdb" target="lib" />
     <file src="..\..\src\umbraco.businesslogic\**\*.cs" exclude="..\..\src\**\TemporaryGeneratedFile*.cs" target="src\umbraco.businesslogic" />
-	<file src="..\_BuildOutput\bin\cms.pdb" target="lib" />
+    <file src="..\_BuildOutput\bin\cms.pdb" target="lib" />
     <file src="..\..\src\umbraco.cms\**\*.cs" exclude="..\..\src\**\TemporaryGeneratedFile*.cs" target="src\umbraco.cms" />
-	<file src="..\_BuildOutput\bin\controls.pdb" target="lib" />
+    <file src="..\_BuildOutput\bin\controls.pdb" target="lib" />
     <file src="..\..\src\umbraco.controls\**\*.cs" exclude="..\..\src\**\TemporaryGeneratedFile*.cs" target="src\umbraco.controls" />
-	<file src="..\_BuildOutput\bin\interfaces.pdb" target="lib" />
+    <file src="..\_BuildOutput\bin\interfaces.pdb" target="lib" />
     <file src="..\..\src\umbraco.interfaces\**\*.cs" exclude="..\..\src\**\TemporaryGeneratedFile*.cs" target="src\umbraco.interfaces" />
-	<file src="..\_BuildOutput\bin\Umbraco.Core.pdb" target="lib" />
+    <file src="..\_BuildOutput\bin\Umbraco.Core.pdb" target="lib" />
     <file src="..\..\src\Umbraco.Core\**\*.cs" exclude="..\..\src\**\TemporaryGeneratedFile*.cs" target="src\Umbraco.Core" />
-	<file src="..\_BuildOutput\bin\umbraco.DataLayer.pdb" target="lib" />
+    <file src="..\_BuildOutput\bin\umbraco.DataLayer.pdb" target="lib" />
     <file src="..\..\src\umbraco.datalayer\**\*.cs" exclude="..\..\src\**\TemporaryGeneratedFile*.cs" target="src\umbraco.datalayer" />
-	<file src="..\_BuildOutput\bin\umbraco.editorControls.pdb" target="lib" />
+    <file src="..\_BuildOutput\bin\umbraco.editorControls.pdb" target="lib" />
     <file src="..\..\src\umbraco.editorControls\**\*.cs" exclude="..\..\src\**\TemporaryGeneratedFile*.cs" target="src\umbraco.editorControls" />
-	<file src="..\_BuildOutput\bin\umbraco.MacroEngines.pdb" target="lib" />
+    <file src="..\_BuildOutput\bin\umbraco.MacroEngines.pdb" target="lib" />
     <file src="..\..\src\umbraco.MacroEngines\**\*.cs" exclude="..\..\src\**\TemporaryGeneratedFile*.cs" target="src\umbraco.MacroEngines" />
-	<file src="..\_BuildOutput\bin\umbraco.providers.pdb" target="lib" />
+    <file src="..\_BuildOutput\bin\umbraco.providers.pdb" target="lib" />
     <file src="..\..\src\umbraco.providers\**\*.cs" exclude="..\..\src\**\TemporaryGeneratedFile*.cs" target="src\umbraco.providers" />
-	<file src="..\_BuildOutput\bin\umbraco.pdb" target="lib" />
+    <file src="..\_BuildOutput\bin\umbraco.pdb" target="lib" />
     <file src="..\..\src\Umbraco.Web\**\*.cs" exclude="..\..\src\**\TemporaryGeneratedFile*.cs" target="src\Umbraco.Web" />
-	<file src="..\_BuildOutput\bin\Umbraco.Web.UI.pdb" target="lib" />
+    <file src="..\_BuildOutput\bin\Umbraco.Web.UI.pdb" target="lib" />
     <file src="..\..\src\Umbraco.Web.UI\**\*.cs" exclude="..\..\src\**\TemporaryGeneratedFile*.cs" target="src\Umbraco.Web.UI" />
-	<file src="..\_BuildOutput\bin\UmbracoExamine.pdb" target="lib" />
-    <file src="..\..\src\UmbracoExamine\**\*.cs" exclude="..\..\src\**\TemporaryGeneratedFile*.cs" target="src\UmbracoExamine" />	
+    <file src="..\_BuildOutput\bin\UmbracoExamine.pdb" target="lib" />
+    <file src="..\..\src\UmbracoExamine\**\*.cs" exclude="..\..\src\**\TemporaryGeneratedFile*.cs" target="src\UmbracoExamine" />
   </files>
 </package>

build/NuSpecs/UmbracoCms.nuspec

@@ -16,7 +16,8 @@
     <tags>umbraco</tags>
     <dependencies>
       <dependency id="UmbracoCms.Core" version="[$version$]" />
-      <dependency id="Newtonsoft.Json" version="[6.0.5, 7.0.0)" />
+      <dependency id="Newtonsoft.Json" version="[6.0.8, 9.0.0)" />
+      <dependency id="Umbraco.ModelsBuilder" version="[3.0.2, 4.0.0)" />
     </dependencies>
   </metadata>
   <files>

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

@@ -77,4 +77,8 @@
   <section alias="uGoLiveDashboardSection" xdt:Locator="Match(alias)" xdt:Transform="Remove" />
   
   <section alias="ExamineManagement" xdt:Locator="Match(alias)" xdt:Transform="Remove" />
+    
+  <section alias="StartupDashboardSection">
+	<tab caption="Change Password" xdt:Locator="Match(caption)" xdt:Transform="Remove" />
+  </section>
 </dashBoard>

build/NuSpecs/tools/Readme.txt

@@ -10,6 +10,7 @@
 
 Don't forget to build!
 
+
 When upgrading your website using NuGet you should answer "No" to the questions to overwrite the Web.config 
 file (and config files in the config folder). 
 

build/NuSpecs/tools/ReadmeUpgrade.txt

@@ -10,6 +10,7 @@
 
 Don't forget to build!
 
+
 We've done our best to transform your configuration files but in case something is not quite right: remember we
 backed up your files in App_Data\NuGetBackup so you can find the original files before they were transformed.
 

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

@@ -7,8 +7,8 @@
     <section name="ExamineLuceneIndexSets" type="Examine.LuceneEngine.Config.IndexSets, Examine" requirePermission="false" xdt:Locator="Match(name)" xdt:Transform="SetAttributes(type,requirePermission)" />
 
     <sectionGroup name="applicationSettings" xdt:Locator="Match(name)">
-		<section name="umbraco.presentation.Properties.Settings" xdt:Locator="Match(name)" xdt:Transform="Remove" />
-	</sectionGroup>
+      <section name="umbraco.presentation.Properties.Settings" xdt:Locator="Match(name)" xdt:Transform="Remove" />
+    </sectionGroup>
     <sectionGroup name="system.web.webPages.razor" xdt:Locator="Match(name)" xdt:Transform="Remove" />
     <sectionGroup name="umbracoConfiguration" xdt:Locator="Match(name)" xdt:Transform="InsertIfMissing">
       <section name="settings" type="Umbraco.Core.Configuration.UmbracoSettings.UmbracoSettingsSection, Umbraco.Core" requirePermission="false" xdt:Locator="Match(name)" xdt:Transform="InsertIfMissing" />
@@ -21,8 +21,10 @@
   <appSettings xdt:Transform="InsertIfMissing" />
   <appSettings>
     <add key="owin:appStartup" value="UmbracoDefaultOwinStartup" xdt:Locator="Match(key)" xdt:Transform="InsertIfMissing" />
+	<add key="Umbraco.ModelsBuilder.Enable" value="false" xdt:Locator="Match(key)" xdt:Transform="InsertIfMissing" />
+	<add key="Umbraco.ModelsBuilder.ModelsMode" value="Nothing" xdt:Locator="Match(key)" xdt:Transform="InsertIfMissing" />
   </appSettings>
-  
+
   <umbracoConfiguration xdt:Transform="InsertIfMissing">
     <settings configSource="config\umbracoSettings.config" xdt:Locator="Match(configSource)" xdt:Transform="InsertIfMissing" />
     <BaseRestExtensions configSource="config\BaseRestExtensions.config" xdt:Locator="Match(configSource)" xdt:Transform="InsertIfMissing" />
@@ -37,7 +39,7 @@
     <DbProviderFactories xdt:Transform="InsertIfMissing">
       <remove invariant="System.Data.SqlServerCe.4.0" xdt:Locator="Match(invariant)" xdt:Transform="InsertIfMissing" />
       <add name="Microsoft SQL Server Compact Data Provider 4.0" invariant="System.Data.SqlServerCe.4.0" description=".NET Framework Data Provider for Microsoft SQL Server Compact" type="System.Data.SqlServerCe.SqlCeProviderFactory, System.Data.SqlServerCe" xdt:Locator="Match(invariant)" xdt:Transform="SetAttributes(invariant,description,type)" />
-      <remove invariant="MySql.Data.MySqlClient" xdt:Locator="Match(invariant)" xdt:Transform="InsertIfMissing" />	  
+      <remove invariant="MySql.Data.MySqlClient" xdt:Locator="Match(invariant)" xdt:Transform="InsertIfMissing" />
       <add invariant="MySql.Data.MySqlClient" xdt:Locator="Match(invariant)" xdt:Transform="Remove" />
       <add name="MySQL Data Provider" invariant="MySql.Data.MySqlClient" description=".Net Framework Data Provider for MySQL" type="MySql.Data.MySqlClient.MySqlClientFactory, MySql.Data" xdt:Locator="Match(invariant)" xdt:Transform="InsertIfMissing" />
       <add invariant="MySql.Data.MySqlClient" type="MySql.Data.MySqlClient.MySqlClientFactory, MySql.Data" xdt:Locator="Match(invariant)" xdt:Transform="SetAttributes(type)" />
@@ -48,13 +50,15 @@
   <system.web xdt:Transform="InsertIfMissing" />
   <system.web>
     <siteMap xdt:Transform="Remove" />
-	<siteMap xdt:Transform="InsertIfMissing">
+    <siteMap xdt:Transform="InsertIfMissing">
       <providers xdt:Transform="InsertIfMissing">
         <remove name="MySqlSiteMapProvider"  xdt:Transform="InsertIfMissing" />
       </providers>
-      </siteMap>	
+    </siteMap>
     <httpRuntime xdt:Transform="InsertIfMissing" />
-    <httpRuntime targetFramework="4.5" maxRequestLength="1048576" fcnMode="Single" xdt:Transform="SetAttributes(targetFramework,fcnMode,maxRequestLength)" />
+    <httpRuntime maxRequestLength="51200" fcnMode="Single" xdt:Transform="SetAttributes(fcnMode,maxRequestLength)" />
+    <httpRuntime targetFramework="4.5" xdt:Locator="Condition(count(@targetFramework) != 1)" xdt:Transform="SetAttributes(targetFramework)" />
+    
     <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"/>>
@@ -63,8 +67,7 @@
     <compilation>
       <assemblies xdt:Transform="InsertIfMissing" />
       <assemblies>
-        <add assembly="System.Net.Http, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" xdt:Locator="Match(assembly)"
-    xdt:Transform="InsertIfMissing" />
+        <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" />
@@ -78,6 +81,56 @@
         <add assembly="System.Web.Routing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35" xdt:Locator="Match(assembly)" xdt:Transform="Remove" />
         <add assembly="System.Web.Mvc, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35" xdt:Locator="Match(assembly)" xdt:Transform="Remove" />
         <add assembly="System.Web.WebPages, Version=2.0.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35" xdt:Locator="Match(assembly)" xdt:Transform="Remove" />
+        <add assembly="System.Collections, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" xdt:Locator="Match(assembly)" xdt:Transform="InsertIfMissing" />
+        <add assembly="System.Collections.Concurrent, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" xdt:Locator="Match(assembly)" xdt:Transform="InsertIfMissing" />
+        <add assembly="System.ComponentModel, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" xdt:Locator="Match(assembly)" xdt:Transform="InsertIfMissing" />
+        <add assembly="System.ComponentModel.Annotations, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" xdt:Locator="Match(assembly)" xdt:Transform="InsertIfMissing" />
+        <add assembly="System.ComponentModel.EventBasedAsync, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" xdt:Locator="Match(assembly)" xdt:Transform="InsertIfMissing" />
+        <add assembly="System.Diagnostics.Contracts, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" xdt:Locator="Match(assembly)" xdt:Transform="InsertIfMissing" />
+        <add assembly="System.Diagnostics.Debug, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" xdt:Locator="Match(assembly)" xdt:Transform="InsertIfMissing" />
+        <add assembly="System.Diagnostics.Tools, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" xdt:Locator="Match(assembly)" xdt:Transform="InsertIfMissing" />
+        <add assembly="System.Diagnostics.Tracing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" xdt:Locator="Match(assembly)" xdt:Transform="InsertIfMissing" />
+        <add assembly="System.Dynamic.Runtime, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" xdt:Locator="Match(assembly)" xdt:Transform="InsertIfMissing" />
+        <add assembly="System.Globalization, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" xdt:Locator="Match(assembly)" xdt:Transform="InsertIfMissing" />
+        <add assembly="System.IO, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" xdt:Locator="Match(assembly)" xdt:Transform="InsertIfMissing" />
+        <add assembly="System.Linq, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" xdt:Locator="Match(assembly)" xdt:Transform="InsertIfMissing" />
+        <add assembly="System.Linq.Expressions, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" xdt:Locator="Match(assembly)" xdt:Transform="InsertIfMissing" />
+        <add assembly="System.Linq.Parallel, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" xdt:Locator="Match(assembly)" xdt:Transform="InsertIfMissing" />
+        <add assembly="System.Linq.Queryable, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" xdt:Locator="Match(assembly)" xdt:Transform="InsertIfMissing" />
+        <add assembly="System.Net.NetworkInformation, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" xdt:Locator="Match(assembly)" xdt:Transform="InsertIfMissing" />
+        <add assembly="System.Net.Primitives, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" xdt:Locator="Match(assembly)" xdt:Transform="InsertIfMissing" />
+        <add assembly="System.Net.Requests, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" xdt:Locator="Match(assembly)" xdt:Transform="InsertIfMissing" />
+        <add assembly="System.ObjectModel, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" xdt:Locator="Match(assembly)" xdt:Transform="InsertIfMissing" />
+        <add assembly="System.Reflection, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" xdt:Locator="Match(assembly)" xdt:Transform="InsertIfMissing" />
+        <add assembly="System.Reflection.Emit, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" xdt:Locator="Match(assembly)" xdt:Transform="InsertIfMissing" />
+        <add assembly="System.Reflection.Emit.ILGeneration, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" xdt:Locator="Match(assembly)" xdt:Transform="InsertIfMissing" />
+        <add assembly="System.Reflection.Emit.Lightweight, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" xdt:Locator="Match(assembly)" xdt:Transform="InsertIfMissing" />
+        <add assembly="System.Reflection.Extensions, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" xdt:Locator="Match(assembly)" xdt:Transform="InsertIfMissing" />
+        <add assembly="System.Reflection.Primitives, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" xdt:Locator="Match(assembly)" xdt:Transform="InsertIfMissing" />
+        <add assembly="System.Resources.ResourceManager, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" 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.Runtime.Extensions, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" xdt:Locator="Match(assembly)" xdt:Transform="InsertIfMissing" />
+        <add assembly="System.Runtime.InteropServices, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" xdt:Locator="Match(assembly)" xdt:Transform="InsertIfMissing" />
+        <add assembly="System.Runtime.InteropServices.WindowsRuntime, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" xdt:Locator="Match(assembly)" xdt:Transform="InsertIfMissing" />
+        <add assembly="System.Runtime.Numerics, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" xdt:Locator="Match(assembly)" xdt:Transform="InsertIfMissing" />
+        <add assembly="System.Runtime.Serialization.Json, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" xdt:Locator="Match(assembly)" xdt:Transform="InsertIfMissing" />
+        <add assembly="System.Runtime.Serialization.Primitives, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" xdt:Locator="Match(assembly)" xdt:Transform="InsertIfMissing" />
+        <add assembly="System.Runtime.Serialization.Xml, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" xdt:Locator="Match(assembly)" xdt:Transform="InsertIfMissing" />
+        <add assembly="System.Security.Principal, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" xdt:Locator="Match(assembly)" xdt:Transform="InsertIfMissing" />
+        <add assembly="System.ServiceModel.Duplex, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" xdt:Locator="Match(assembly)" xdt:Transform="InsertIfMissing" />
+        <add assembly="System.ServiceModel.Http, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" xdt:Locator="Match(assembly)" xdt:Transform="InsertIfMissing" />
+        <add assembly="System.ServiceModel.NetTcp, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" xdt:Locator="Match(assembly)" xdt:Transform="InsertIfMissing" />
+        <add assembly="System.ServiceModel.Primitives, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" xdt:Locator="Match(assembly)" xdt:Transform="InsertIfMissing" />
+        <add assembly="System.ServiceModel.Security, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" xdt:Locator="Match(assembly)" xdt:Transform="InsertIfMissing" />
+        <add assembly="System.Text.Encoding, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" xdt:Locator="Match(assembly)" xdt:Transform="InsertIfMissing" />
+        <add assembly="System.Text.Encoding.Extensions, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" xdt:Locator="Match(assembly)" xdt:Transform="InsertIfMissing" />
+        <add assembly="System.Text.RegularExpressions, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" xdt:Locator="Match(assembly)" xdt:Transform="InsertIfMissing" />
+        <add assembly="System.Threading, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" xdt:Locator="Match(assembly)" xdt:Transform="InsertIfMissing" />
+        <add assembly="System.Threading.Tasks, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" xdt:Locator="Match(assembly)" xdt:Transform="InsertIfMissing" />
+        <add assembly="System.Threading.Tasks.Parallel, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" xdt:Locator="Match(assembly)" xdt:Transform="InsertIfMissing" />
+        <add assembly="System.Xml.ReaderWriter, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" xdt:Locator="Match(assembly)" xdt:Transform="InsertIfMissing" />
+        <add assembly="System.Xml.XDocument, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" xdt:Locator="Match(assembly)" xdt:Transform="InsertIfMissing" />
+        <add assembly="System.Xml.XmlSerializer, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" xdt:Locator="Match(assembly)" xdt:Transform="InsertIfMissing" />
       </assemblies>
     </compilation>
 
@@ -86,11 +139,113 @@
         <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" />
+        <remove assembly="System.Collections" xdt:Locator="Match(assembly)" xdt:Transform="Remove" />
+        <remove assembly="System.Collections.Concurrent" xdt:Locator="Match(assembly)" xdt:Transform="Remove" />
+        <remove assembly="System.ComponentModel" xdt:Locator="Match(assembly)" xdt:Transform="Remove" />
+        <remove assembly="System.ComponentModel.Annotations" xdt:Locator="Match(assembly)" xdt:Transform="Remove" />
+        <remove assembly="System.ComponentModel.EventBasedAsync" xdt:Locator="Match(assembly)" xdt:Transform="Remove" />
+        <remove assembly="System.Diagnostics.Contracts" xdt:Locator="Match(assembly)" xdt:Transform="Remove" />
+        <remove assembly="System.Diagnostics.Debug" xdt:Locator="Match(assembly)" xdt:Transform="Remove" />
+        <remove assembly="System.Diagnostics.Tools" xdt:Locator="Match(assembly)" xdt:Transform="Remove" />
+        <remove assembly="System.Diagnostics.Tracing" xdt:Locator="Match(assembly)" xdt:Transform="Remove" />
+        <remove assembly="System.Dynamic.Runtime" xdt:Locator="Match(assembly)" xdt:Transform="Remove" />
+        <remove assembly="System.Globalization" xdt:Locator="Match(assembly)" xdt:Transform="Remove" />
+        <remove assembly="System.IO" xdt:Locator="Match(assembly)" xdt:Transform="Remove" />
+        <remove assembly="System.Linq" xdt:Locator="Match(assembly)" xdt:Transform="Remove" />
+        <remove assembly="System.Linq.Expressions" xdt:Locator="Match(assembly)" xdt:Transform="Remove" />
+        <remove assembly="System.Linq.Parallel" xdt:Locator="Match(assembly)" xdt:Transform="Remove" />
+        <remove assembly="System.Linq.Queryable" xdt:Locator="Match(assembly)" xdt:Transform="Remove" />
+        <remove assembly="System.Net.NetworkInformation" xdt:Locator="Match(assembly)" xdt:Transform="Remove" />
+        <remove assembly="System.Net.Primitives" xdt:Locator="Match(assembly)" xdt:Transform="Remove" />
+        <remove assembly="System.Net.Requests" xdt:Locator="Match(assembly)" xdt:Transform="Remove" />
+        <remove assembly="System.ObjectModel" xdt:Locator="Match(assembly)" xdt:Transform="Remove" />
+        <remove assembly="System.Reflection" xdt:Locator="Match(assembly)" xdt:Transform="Remove" />
+        <remove assembly="System.Reflection.Emit" xdt:Locator="Match(assembly)" xdt:Transform="Remove" />
+        <remove assembly="System.Reflection.Emit.ILGeneration" xdt:Locator="Match(assembly)" xdt:Transform="Remove" />
+        <remove assembly="System.Reflection.Emit.Lightweight" xdt:Locator="Match(assembly)" xdt:Transform="Remove" />
+        <remove assembly="System.Reflection.Extensions" xdt:Locator="Match(assembly)" xdt:Transform="Remove" />
+        <remove assembly="System.Reflection.Primitives" xdt:Locator="Match(assembly)" xdt:Transform="Remove" />
+        <remove assembly="System.Resources.ResourceManager" xdt:Locator="Match(assembly)" xdt:Transform="Remove" />
+        <remove assembly="System.Runtime" xdt:Locator="Match(assembly)" xdt:Transform="Remove" />
+        <remove assembly="System.Runtime.Extensions" xdt:Locator="Match(assembly)" xdt:Transform="Remove" />
+        <remove assembly="System.Runtime.InteropServices" xdt:Locator="Match(assembly)" xdt:Transform="Remove" />
+        <remove assembly="System.Runtime.InteropServices.WindowsRuntime" xdt:Locator="Match(assembly)" xdt:Transform="Remove" />
+        <remove assembly="System.Runtime.Numerics" xdt:Locator="Match(assembly)" xdt:Transform="Remove" />
+        <remove assembly="System.Runtime.Serialization.Json" xdt:Locator="Match(assembly)" xdt:Transform="Remove" />
+        <remove assembly="System.Runtime.Serialization.Primitives" xdt:Locator="Match(assembly)" xdt:Transform="Remove" />
+        <remove assembly="System.Runtime.Serialization.Xml" xdt:Locator="Match(assembly)" xdt:Transform="Remove" />
+        <remove assembly="System.Security.Principal" xdt:Locator="Match(assembly)" xdt:Transform="Remove" />
+        <remove assembly="System.ServiceModel.Duplex" xdt:Locator="Match(assembly)" xdt:Transform="Remove" />
+        <remove assembly="System.ServiceModel.Http" xdt:Locator="Match(assembly)" xdt:Transform="Remove" />
+        <remove assembly="System.ServiceModel.NetTcp" xdt:Locator="Match(assembly)" xdt:Transform="Remove" />
+        <remove assembly="System.ServiceModel.Primitives" xdt:Locator="Match(assembly)" xdt:Transform="Remove" />
+        <remove assembly="System.ServiceModel.Security" xdt:Locator="Match(assembly)" xdt:Transform="Remove" />
+        <remove assembly="System.Text.Encoding" xdt:Locator="Match(assembly)" xdt:Transform="Remove" />
+        <remove assembly="System.Text.Encoding.Extensions" xdt:Locator="Match(assembly)" xdt:Transform="Remove" />
+        <remove assembly="System.Text.RegularExpressions" xdt:Locator="Match(assembly)" xdt:Transform="Remove" />
+        <remove assembly="System.Threading" xdt:Locator="Match(assembly)" xdt:Transform="Remove" />
+        <remove assembly="System.Threading.Tasks" xdt:Locator="Match(assembly)" xdt:Transform="Remove" />
+        <remove assembly="System.Threading.Tasks.Parallel" xdt:Locator="Match(assembly)" xdt:Transform="Remove" />
+        <remove assembly="System.Xml.ReaderWriter" xdt:Locator="Match(assembly)" xdt:Transform="Remove" />
+        <remove assembly="System.Xml.XDocument" xdt:Locator="Match(assembly)" xdt:Transform="Remove" />
+        <remove assembly="System.Xml.XmlSerializer" xdt:Locator="Match(assembly)" xdt:Transform="Remove" />
       </assemblies>
+    </compilation>
+    <compilation>
       <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)" />
+        <remove assembly="System.Collections" xdt:Locator="Match(assembly)" xdt:Transform="InsertBefore(/configuration/system.web/compilation/assemblies/add)" />
+        <remove assembly="System.Collections.Concurrent" xdt:Locator="Match(assembly)" xdt:Transform="InsertBefore(/configuration/system.web/compilation/assemblies/add)" />
+        <remove assembly="System.ComponentModel" xdt:Locator="Match(assembly)" xdt:Transform="InsertBefore(/configuration/system.web/compilation/assemblies/add)" />
+        <remove assembly="System.ComponentModel.Annotations" xdt:Locator="Match(assembly)" xdt:Transform="InsertBefore(/configuration/system.web/compilation/assemblies/add)" />
+        <remove assembly="System.ComponentModel.EventBasedAsync" xdt:Locator="Match(assembly)" xdt:Transform="InsertBefore(/configuration/system.web/compilation/assemblies/add)" />
+        <remove assembly="System.Diagnostics.Contracts" xdt:Locator="Match(assembly)" xdt:Transform="InsertBefore(/configuration/system.web/compilation/assemblies/add)" />
+        <remove assembly="System.Diagnostics.Debug" xdt:Locator="Match(assembly)" xdt:Transform="InsertBefore(/configuration/system.web/compilation/assemblies/add)" />
+        <remove assembly="System.Diagnostics.Tools" xdt:Locator="Match(assembly)" xdt:Transform="InsertBefore(/configuration/system.web/compilation/assemblies/add)" />
+        <remove assembly="System.Diagnostics.Tracing" xdt:Locator="Match(assembly)" xdt:Transform="InsertBefore(/configuration/system.web/compilation/assemblies/add)" />
+        <remove assembly="System.Dynamic.Runtime" xdt:Locator="Match(assembly)" xdt:Transform="InsertBefore(/configuration/system.web/compilation/assemblies/add)" />
+        <remove assembly="System.Globalization" xdt:Locator="Match(assembly)" xdt:Transform="InsertBefore(/configuration/system.web/compilation/assemblies/add)" />
+        <remove assembly="System.IO" xdt:Locator="Match(assembly)" xdt:Transform="InsertBefore(/configuration/system.web/compilation/assemblies/add)" />
+        <remove assembly="System.Linq" xdt:Locator="Match(assembly)" xdt:Transform="InsertBefore(/configuration/system.web/compilation/assemblies/add)" />
+        <remove assembly="System.Linq.Expressions" xdt:Locator="Match(assembly)" xdt:Transform="InsertBefore(/configuration/system.web/compilation/assemblies/add)" />
+        <remove assembly="System.Linq.Parallel" xdt:Locator="Match(assembly)" xdt:Transform="InsertBefore(/configuration/system.web/compilation/assemblies/add)" />
+        <remove assembly="System.Linq.Queryable" xdt:Locator="Match(assembly)" xdt:Transform="InsertBefore(/configuration/system.web/compilation/assemblies/add)" />
+        <remove assembly="System.Net.NetworkInformation" xdt:Locator="Match(assembly)" xdt:Transform="InsertBefore(/configuration/system.web/compilation/assemblies/add)" />
+        <remove assembly="System.Net.Primitives" xdt:Locator="Match(assembly)" xdt:Transform="InsertBefore(/configuration/system.web/compilation/assemblies/add)" />
+        <remove assembly="System.Net.Requests" xdt:Locator="Match(assembly)" xdt:Transform="InsertBefore(/configuration/system.web/compilation/assemblies/add)" />
+        <remove assembly="System.ObjectModel" xdt:Locator="Match(assembly)" xdt:Transform="InsertBefore(/configuration/system.web/compilation/assemblies/add)" />
+        <remove assembly="System.Reflection" xdt:Locator="Match(assembly)" xdt:Transform="InsertBefore(/configuration/system.web/compilation/assemblies/add)" />
+        <remove assembly="System.Reflection.Emit" xdt:Locator="Match(assembly)" xdt:Transform="InsertBefore(/configuration/system.web/compilation/assemblies/add)" />
+        <remove assembly="System.Reflection.Emit.ILGeneration" xdt:Locator="Match(assembly)" xdt:Transform="InsertBefore(/configuration/system.web/compilation/assemblies/add)" />
+        <remove assembly="System.Reflection.Emit.Lightweight" xdt:Locator="Match(assembly)" xdt:Transform="InsertBefore(/configuration/system.web/compilation/assemblies/add)" />
+        <remove assembly="System.Reflection.Extensions" xdt:Locator="Match(assembly)" xdt:Transform="InsertBefore(/configuration/system.web/compilation/assemblies/add)" />
+        <remove assembly="System.Reflection.Primitives" xdt:Locator="Match(assembly)" xdt:Transform="InsertBefore(/configuration/system.web/compilation/assemblies/add)" />
+        <remove assembly="System.Resources.ResourceManager" 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)" />
+        <remove assembly="System.Runtime.Extensions" xdt:Locator="Match(assembly)" xdt:Transform="InsertBefore(/configuration/system.web/compilation/assemblies/add)" />
+        <remove assembly="System.Runtime.InteropServices" xdt:Locator="Match(assembly)" xdt:Transform="InsertBefore(/configuration/system.web/compilation/assemblies/add)" />
+        <remove assembly="System.Runtime.InteropServices.WindowsRuntime" xdt:Locator="Match(assembly)" xdt:Transform="InsertBefore(/configuration/system.web/compilation/assemblies/add)" />
+        <remove assembly="System.Runtime.Numerics" xdt:Locator="Match(assembly)" xdt:Transform="InsertBefore(/configuration/system.web/compilation/assemblies/add)" />
+        <remove assembly="System.Runtime.Serialization.Json" xdt:Locator="Match(assembly)" xdt:Transform="InsertBefore(/configuration/system.web/compilation/assemblies/add)" />
+        <remove assembly="System.Runtime.Serialization.Primitives" xdt:Locator="Match(assembly)" xdt:Transform="InsertBefore(/configuration/system.web/compilation/assemblies/add)" />
+        <remove assembly="System.Runtime.Serialization.Xml" xdt:Locator="Match(assembly)" xdt:Transform="InsertBefore(/configuration/system.web/compilation/assemblies/add)" />
+        <remove assembly="System.Security.Principal" xdt:Locator="Match(assembly)" xdt:Transform="InsertBefore(/configuration/system.web/compilation/assemblies/add)" />
+        <remove assembly="System.ServiceModel.Duplex" xdt:Locator="Match(assembly)" xdt:Transform="InsertBefore(/configuration/system.web/compilation/assemblies/add)" />
+        <remove assembly="System.ServiceModel.Http" xdt:Locator="Match(assembly)" xdt:Transform="InsertBefore(/configuration/system.web/compilation/assemblies/add)" />
+        <remove assembly="System.ServiceModel.NetTcp" xdt:Locator="Match(assembly)" xdt:Transform="InsertBefore(/configuration/system.web/compilation/assemblies/add)" />
+        <remove assembly="System.ServiceModel.Primitives" xdt:Locator="Match(assembly)" xdt:Transform="InsertBefore(/configuration/system.web/compilation/assemblies/add)" />
+        <remove assembly="System.ServiceModel.Security" xdt:Locator="Match(assembly)" xdt:Transform="InsertBefore(/configuration/system.web/compilation/assemblies/add)" />
+        <remove assembly="System.Text.Encoding" xdt:Locator="Match(assembly)" xdt:Transform="InsertBefore(/configuration/system.web/compilation/assemblies/add)" />
+        <remove assembly="System.Text.Encoding.Extensions" xdt:Locator="Match(assembly)" xdt:Transform="InsertBefore(/configuration/system.web/compilation/assemblies/add)" />
+        <remove assembly="System.Text.RegularExpressions" xdt:Locator="Match(assembly)" xdt:Transform="InsertBefore(/configuration/system.web/compilation/assemblies/add)" />
+        <remove assembly="System.Threading" xdt:Locator="Match(assembly)" xdt:Transform="InsertBefore(/configuration/system.web/compilation/assemblies/add)" />
+        <remove assembly="System.Threading.Tasks" xdt:Locator="Match(assembly)" xdt:Transform="InsertBefore(/configuration/system.web/compilation/assemblies/add)" />
+        <remove assembly="System.Threading.Tasks.Parallel" xdt:Locator="Match(assembly)" xdt:Transform="InsertBefore(/configuration/system.web/compilation/assemblies/add)" />
+        <remove assembly="System.Xml.ReaderWriter" xdt:Locator="Match(assembly)" xdt:Transform="InsertBefore(/configuration/system.web/compilation/assemblies/add)" />
+        <remove assembly="System.Xml.XDocument" xdt:Locator="Match(assembly)" xdt:Transform="InsertBefore(/configuration/system.web/compilation/assemblies/add)" />
+        <remove assembly="System.Xml.XmlSerializer" xdt:Locator="Match(assembly)" xdt:Transform="InsertBefore(/configuration/system.web/compilation/assemblies/add)" />
       </assemblies>
     </compilation>
 
@@ -125,6 +280,8 @@
       <add name="umbracoRequestModule" xdt:Locator="Match(name)" xdt:Transform="Remove" />
       <add name="viewstateMoverModule" xdt:Locator="Match(name)" xdt:Transform="Remove" />
       <add name="umbracoBaseRequestModule" xdt:Locator="Match(name)" xdt:Transform="Remove" />
+      <!-- Note, we're removing the one that starts with a space here, don't correct it -->
+      <!-- This to fix a quirk we for a lot of releases where we added it with the space by default -->
       <add name=" UmbracoModule" xdt:Locator="Match(name)" xdt:Transform="Remove" />
       <add name="UmbracoModule" type="Umbraco.Web.UmbracoModule,umbraco" xdt:Locator="Match(name)" xdt:Transform="InsertIfMissing" />
     </modules>
@@ -146,19 +303,17 @@
 
     <security xdt:Transform="InsertIfMissing">
       <requestFiltering xdt:Transform="InsertIfMissing">
-        <requestLimits maxAllowedContentLength="1073741824" xdt:Transform="InsertIfMissing" />
+        <requestLimits maxAllowedContentLength="52428800" xdt:Transform="InsertIfMissing" />
       </requestFiltering>
     </security>
-    
-  </system.webServer>
 
-  <system.codedom xdt:Transform="Remove" />
+  </system.webServer>
 
   <runtime xdt:Transform="InsertIfMissing" />
   <runtime>
     <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1" xdt:Transform="InsertIfMissing" />
   </runtime>
-  
+
   <runtime>
     <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
       <dependentAssembly xdt:Locator="Condition(./_defaultNamespace:assemblyIdentity/@name='HtmlAgilityPack')" xdt:Transform="Remove" />
@@ -171,7 +326,7 @@
       <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>
 
@@ -180,7 +335,7 @@
       <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>
       <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"/>
@@ -191,12 +346,12 @@
       </dependentAssembly>
       <dependentAssembly xdt:Transform="Insert">
         <assemblyIdentity name="System.Web.Mvc" publicKeyToken="31bf3856ad364e35" culture="neutral" />
-        <bindingRedirect oldVersion="0.0.0.0-4.0.0.1" newVersion="4.0.0.1" />
+        <bindingRedirect oldVersion="0.0.0.0-5.2.3.0" newVersion="5.2.3.0" />
       </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>
       <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" />
@@ -208,16 +363,16 @@
       <dependentAssembly xdt:Transform="Insert">
         <assemblyIdentity name="Microsoft.Owin.Security.OAuth" publicKeyToken="31bf3856ad364e35" culture="neutral" />
         <bindingRedirect oldVersion="0.0.0.0-3.0.1.0" newVersion="3.0.1.0" />
-      </dependentAssembly>	  
+      </dependentAssembly>
       <dependentAssembly xdt:Transform="Insert">
         <assemblyIdentity name="Microsoft.Owin.Security" publicKeyToken="31bf3856ad364e35" culture="neutral" />
         <bindingRedirect oldVersion="0.0.0.0-3.0.1.0" newVersion="3.0.1.0" />
-      </dependentAssembly>	  
+      </dependentAssembly>
       <dependentAssembly xdt:Transform="Insert">
         <assemblyIdentity name="Microsoft.Owin.Security.Cookies" publicKeyToken="31bf3856ad364e35" culture="neutral" />
         <bindingRedirect oldVersion="0.0.0.0-3.0.1.0" newVersion="3.0.1.0" />
-      </dependentAssembly>	  	 
-	  <dependentAssembly xdt:Transform="Insert">
+      </dependentAssembly>
+      <dependentAssembly xdt:Transform="Insert">
         <assemblyIdentity name="System.Net.Http.Formatting" publicKeyToken="31bf3856ad364e35" culture="neutral" />
         <bindingRedirect oldVersion="0.0.0.0-5.2.3.0" newVersion="5.2.3.0" />
       </dependentAssembly>
@@ -225,19 +380,19 @@
   </runtime>
 
   <system.web.webPages.razor xdt:Transform="Remove" />
-  
+
   <location path="umbraco" xdt:Locator="Match(path)" xdt:Transform="InsertIfMissing" />
   <location path="umbraco" xdt:Locator="Match(path)">
     <system.webServer xdt:Transform="InsertIfMissing">
-	  <urlCompression doStaticCompression="false" doDynamicCompression="false" dynamicCompressionBeforeCache="false" xdt:Transform="SetAttributes(doStaticCompression,doDynamicCompression,dynamicCompressionBeforeCache)" />
+      <urlCompression doStaticCompression="false" doDynamicCompression="false" dynamicCompressionBeforeCache="false" xdt:Transform="SetAttributes(doStaticCompression,doDynamicCompression,dynamicCompressionBeforeCache)" />
     </system.webServer>
   </location>
-  
+
   <location path="App_Plugins" xdt:Locator="Match(path)" xdt:Transform="InsertIfMissing" />
   <location path="App_Plugins" xdt:Locator="Match(path)">
     <system.webServer xdt:Transform="InsertIfMissing">
-	  <urlCompression doStaticCompression="false" doDynamicCompression="false" dynamicCompressionBeforeCache="false" xdt:Transform="SetAttributes(doStaticCompression,doDynamicCompression,dynamicCompressionBeforeCache)" />
+      <urlCompression doStaticCompression="false" doDynamicCompression="false" dynamicCompressionBeforeCache="false" xdt:Transform="SetAttributes(doStaticCompression,doDynamicCompression,dynamicCompressionBeforeCache)" />
     </system.webServer>
   </location>
-  
+
 </configuration>

build/NuSpecs/tools/install.core.ps1

@@ -1,18 +1,30 @@
-param($rootPath, $toolsPath, $package, $project)
+param($installPath, $toolsPath, $package, $project)
+
+Write-Host "installPath:" "${installPath}"
+Write-Host "toolsPath:" "${toolsPath}"
+
+Write-Host " "
 
 if ($project) {
 	$dateTime = Get-Date -Format yyyyMMdd-HHmmss
-	$backupPath = Join-Path (Split-Path $project.FullName -Parent) "\App_Data\NuGetBackup\$dateTime"
+
+	# Create paths and list them
+	$projectPath = (Get-Item $project.Properties.Item("FullPath").Value).FullName
+	Write-Host "projectPath:" "${projectPath}"		
+	$backupPath = Join-Path $projectPath "App_Data\NuGetBackup\$dateTime"
+	Write-Host "backupPath:" "${backupPath}"		
 	$copyLogsPath = Join-Path $backupPath "CopyLogs"
-	$projectDestinationPath = Split-Path $project.FullName -Parent
-	
+	Write-Host "copyLogsPath:" "${copyLogsPath}"			
+	$umbracoBinFolder = Join-Path $projectPath "bin"
+	Write-Host "umbracoBinFolder:" "${umbracoBinFolder}"		
+
 	# Create backup folder and logs folder if it doesn't exist yet
 	New-Item -ItemType Directory -Force -Path $backupPath
 	New-Item -ItemType Directory -Force -Path $copyLogsPath
 	
 	# After backing up, remove all umbraco dlls from bin folder in case dll files are included in the VS project
 	# See: http://issues.umbraco.org/issue/U4-4930
-	$umbracoBinFolder = Join-Path $projectDestinationPath "bin"
+	
 	if(Test-Path $umbracoBinFolder) {
 		$umbracoBinBackupPath = Join-Path $backupPath "bin"
 		
@@ -20,7 +32,7 @@ if ($project) {
 		
 		robocopy $umbracoBinFolder $umbracoBinBackupPath /e /LOG:$copyLogsPath\UmbracoBinBackup.log
 		
-		# Delete files Umbraco brings in
+		# Delete files Umbraco ships with
 		if(Test-Path $umbracoBinFolder\businesslogic.dll) { Remove-Item $umbracoBinFolder\businesslogic.dll -Force -Confirm:$false }
 		if(Test-Path $umbracoBinFolder\cms.dll) { Remove-Item $umbracoBinFolder\cms.dll -Force -Confirm:$false }
 		if(Test-Path $umbracoBinFolder\controls.dll) { Remove-Item $umbracoBinFolder\controls.dll -Force -Confirm:$false }
@@ -36,16 +48,18 @@ if ($project) {
 		if(Test-Path $umbracoBinFolder\umbraco.DataLayer.dll) { Remove-Item $umbracoBinFolder\umbraco.DataLayer.dll -Force -Confirm:$false }
 		if(Test-Path $umbracoBinFolder\umbraco.editorControls.dll) { Remove-Item $umbracoBinFolder\umbraco.editorControls.dll -Force -Confirm:$false }
 		if(Test-Path $umbracoBinFolder\umbraco.MacroEngines.dll) { Remove-Item $umbracoBinFolder\umbraco.MacroEngines.dll -Force -Confirm:$false }
+		if(Test-Path $umbracoBinFolder\Umbraco.ModelsBuilder.dll) { Remove-Item $umbracoBinFolder\Umbraco.ModelsBuilder.dll -Force -Confirm:$false }
+		if(Test-Path $umbracoBinFolder\Umbraco.ModelsBuilder.AspNet.dll) { Remove-Item $umbracoBinFolder\Umbraco.ModelsBuilder.AspNet.dll -Force -Confirm:$false }
 		if(Test-Path $umbracoBinFolder\umbraco.providers.dll) { Remove-Item $umbracoBinFolder\umbraco.providers.dll -Force -Confirm:$false }
 		if(Test-Path $umbracoBinFolder\Umbraco.Web.UI.dll) { Remove-Item $umbracoBinFolder\Umbraco.Web.UI.dll -Force -Confirm:$false }
 		if(Test-Path $umbracoBinFolder\UmbracoExamine.dll) { Remove-Item $umbracoBinFolder\UmbracoExamine.dll -Force -Confirm:$false }
 		if(Test-Path $umbracoBinFolder\UrlRewritingNet.UrlRewriter.dll) { Remove-Item $umbracoBinFolder\UrlRewritingNet.UrlRewriter.dll -Force -Confirm:$false }
 		
 		# Delete files Umbraco depends upon
-		$amd64Folder = Join-Path $projectDestinationPath "bin\amd64"
+		$amd64Folder = Join-Path $umbracoBinFolder "amd64"
 		if(Test-Path $amd64Folder) { Remove-Item $amd64Folder -Force -Recurse -Confirm:$false }
-		$x86Folder = Join-Path $projectDestinationPath "bin\x86"
-		if(Test-Path $x86Folder) { Remove-Item $x86Folder -Force -Recurse -Confirm:$false }		
+		$x86Folder = Join-Path $umbracoBinFolder "x86"
+		if(Test-Path $x86Folder) { Remove-Item $x86Folder -Force -Recurse -Confirm:$false }
 		if(Test-Path $umbracoBinFolder\AutoMapper.dll) { Remove-Item $umbracoBinFolder\AutoMapper.dll -Force -Confirm:$false }
 		if(Test-Path $umbracoBinFolder\AutoMapper.Net4.dll) { Remove-Item $umbracoBinFolder\AutoMapper.Net4.dll -Force -Confirm:$false }
 		if(Test-Path $umbracoBinFolder\ClientDependency.Core.dll) { Remove-Item $umbracoBinFolder\ClientDependency.Core.dll -Force -Confirm:$false }
@@ -59,6 +73,8 @@ if ($project) {
 		if(Test-Path $umbracoBinFolder\Lucene.Net.dll) { Remove-Item $umbracoBinFolder\Lucene.Net.dll -Force -Confirm:$false }
 		if(Test-Path $umbracoBinFolder\Microsoft.AspNet.Identity.Core.dll) { Remove-Item $umbracoBinFolder\Microsoft.AspNet.Identity.Core.dll -Force -Confirm:$false }
 		if(Test-Path $umbracoBinFolder\Microsoft.AspNet.Identity.Owin.dll) { Remove-Item $umbracoBinFolder\Microsoft.AspNet.Identity.Owin.dll -Force -Confirm:$false }
+		if(Test-Path $umbracoBinFolder\Microsoft.CodeAnalysis.CSharp.dll) { Remove-Item $umbracoBinFolder\Microsoft.CodeAnalysis.CSharp.dll -Force -Confirm:$false }
+		if(Test-Path $umbracoBinFolder\Microsoft.CodeAnalysis.dll) { Remove-Item $umbracoBinFolder\Microsoft.CodeAnalysis.dll -Force -Confirm:$false }
 		if(Test-Path $umbracoBinFolder\Microsoft.Owin.dll) { Remove-Item $umbracoBinFolder\Microsoft.Owin.dll -Force -Confirm:$false }
 		if(Test-Path $umbracoBinFolder\Microsoft.Owin.Host.SystemWeb.dll) { Remove-Item $umbracoBinFolder\Microsoft.Owin.Host.SystemWeb.dll -Force -Confirm:$false }
 		if(Test-Path $umbracoBinFolder\Microsoft.Owin.Security.dll) { Remove-Item $umbracoBinFolder\Microsoft.Owin.Security.dll -Force -Confirm:$false }
@@ -72,6 +88,8 @@ if ($project) {
 		if(Test-Path $umbracoBinFolder\Newtonsoft.Json.dll) { Remove-Item $umbracoBinFolder\Newtonsoft.Json.dll -Force -Confirm:$false }
 		if(Test-Path $umbracoBinFolder\Owin.dll) { Remove-Item $umbracoBinFolder\Owin.dll -Force -Confirm:$false }
 		if(Test-Path $umbracoBinFolder\Semver.dll) { Remove-Item $umbracoBinFolder\Semver.dll -Force -Confirm:$false }
+		if(Test-Path $umbracoBinFolder\System.Collections.Immutable.dll) { Remove-Item $umbracoBinFolder\System.Collections.Immutable.dll -Force -Confirm:$false }
+		if(Test-Path $umbracoBinFolder\System.Reflection.Metadata.dll) { Remove-Item $umbracoBinFolder\System.Reflection.Metadata.dll -Force -Confirm:$false }
 		if(Test-Path $umbracoBinFolder\System.Net.Http.Extensions.dll) { Remove-Item $umbracoBinFolder\System.Net.Http.Extensions.dll -Force -Confirm:$false }
 		if(Test-Path $umbracoBinFolder\System.Net.Http.Formatting.dll) { Remove-Item $umbracoBinFolder\System.Net.Http.Formatting.dll -Force -Confirm:$false }
 		if(Test-Path $umbracoBinFolder\System.Net.Http.Primitives.dll) { Remove-Item $umbracoBinFolder\System.Net.Http.Primitives.dll -Force -Confirm:$false }	
@@ -82,6 +100,6 @@ if ($project) {
 		if(Test-Path $umbracoBinFolder\System.Web.Razor.dll) { Remove-Item $umbracoBinFolder\System.Web.Razor.dll -Force -Confirm:$false }
 		if(Test-Path $umbracoBinFolder\System.Web.WebPages.dll) { Remove-Item $umbracoBinFolder\System.Web.WebPages.dll -Force -Confirm:$false }
 		if(Test-Path $umbracoBinFolder\System.Web.WebPages.Deployment.dll) { Remove-Item $umbracoBinFolder\System.Web.WebPages.Deployment.dll -Force -Confirm:$false }
-		if(Test-Path $umbracoBinFolder\System.Web.WebPages.Razor.dll) { Remove-Item $umbracoBinFolder\System.Web.WebPages.Razor.dll -Force -Confirm:$false }
+		if(Test-Path $umbracoBinFolder\System.Web.WebPages.Razor.dll) { Remove-Item $umbracoBinFolder\System.Web.WebPages.Razor.dll -Force -Confirm:$false }		
 	}
 }

build/NuSpecs/tools/install.ps1

@@ -1,21 +1,33 @@
-param($rootPath, $toolsPath, $package, $project)
+param($installPath, $toolsPath, $package, $project)
+
+Write-Host "installPath:" "${installPath}"
+Write-Host "toolsPath:" "${toolsPath}"
+
+Write-Host " "
 
 if ($project) {
 	$dateTime = Get-Date -Format yyyyMMdd-HHmmss
-	$backupPath = Join-Path (Split-Path $project.FullName -Parent) "\App_Data\NuGetBackup\$dateTime"
+
+	# Create paths and list them
+	$projectPath = (Get-Item $project.Properties.Item("FullPath").Value).FullName
+	Write-Host "projectPath:" "${projectPath}"
+	$backupPath = Join-Path $projectPath "App_Data\NuGetBackup\$dateTime"
+	Write-Host "backupPath:" "${backupPath}"
 	$copyLogsPath = Join-Path $backupPath "CopyLogs"
-	$projectDestinationPath = Split-Path $project.FullName -Parent
+	Write-Host "copyLogsPath:" "${copyLogsPath}"	
+	$webConfigSource = Join-Path $projectPath "Web.config"
+	Write-Host "webConfigSource:" "${webConfigSource}"
+	$configFolder = Join-Path $projectPath "Config"
+	Write-Host "configFolder:" "${configFolder}"
 
 	# Create backup folder and logs folder if it doesn't exist yet
 	New-Item -ItemType Directory -Force -Path $backupPath
 	New-Item -ItemType Directory -Force -Path $copyLogsPath
 	
 	# Create a backup of original web.config
-	$webConfigSource = Join-Path $projectDestinationPath "Web.config"
 	Copy-Item $webConfigSource $backupPath -Force
 	
-	# Backup config files folder
-	$configFolder = Join-Path $projectDestinationPath "Config"
+	# Backup config files folder	
 	if(Test-Path $configFolder) {
 		$umbracoBackupPath = Join-Path $backupPath "Config"
 		New-Item -ItemType Directory -Force -Path $umbracoBackupPath
@@ -24,32 +36,24 @@ if ($project) {
 	}
 	
 	# Copy umbraco and umbraco_files from package to project folder
-	# This is only done when these folders already exist because we 
-	# only want to do this for upgrades
-	$umbracoFolder = Join-Path $projectDestinationPath "Umbraco"
-	if(Test-Path $umbracoFolder) {
-		$umbracoFolderSource = Join-Path $rootPath "UmbracoFiles\Umbraco"
-		
-		$umbracoBackupPath = Join-Path $backupPath "Umbraco"
-		New-Item -ItemType Directory -Force -Path $umbracoBackupPath
-		
-		robocopy $umbracoFolder $umbracoBackupPath /e /LOG:$copyLogsPath\UmbracoBackup.log
-		robocopy $umbracoFolderSource $umbracoFolder /is /it /e /xf UI.xml /LOG:$copyLogsPath\UmbracoCopy.log
-	}
+	$umbracoFolder = Join-Path $projectPath "Umbraco"
+	New-Item -ItemType Directory -Force -Path $umbracoFolder
+	$umbracoFolderSource = Join-Path $installPath "UmbracoFiles\Umbraco"		
+	$umbracoBackupPath = Join-Path $backupPath "Umbraco"
+	New-Item -ItemType Directory -Force -Path $umbracoBackupPath		
+	robocopy $umbracoFolder $umbracoBackupPath /e /LOG:$copyLogsPath\UmbracoBackup.log
+	robocopy $umbracoFolderSource $umbracoFolder /is /it /e /xf UI.xml /LOG:$copyLogsPath\UmbracoCopy.log
 
-	$umbracoClientFolder = Join-Path $projectDestinationPath "Umbraco_Client"	
-	if(Test-Path $umbracoClientFolder) {
-		$umbracoClientFolderSource = Join-Path $rootPath "UmbracoFiles\Umbraco_Client"
-		
-		$umbracoClientBackupPath = Join-Path $backupPath "Umbraco_Client"
-		New-Item -ItemType Directory -Force -Path $umbracoClientBackupPath
-		
-		robocopy $umbracoClientFolder $umbracoClientBackupPath /e /LOG:$copyLogsPath\UmbracoClientBackup.log
-		robocopy $umbracoClientFolderSource $umbracoClientFolder /is /it /e /LOG:$copyLogsPath\UmbracoClientCopy.log		
-	}
+	$umbracoClientFolder = Join-Path $projectPath "Umbraco_Client"	
+	New-Item -ItemType Directory -Force -Path $umbracoClientFolder
+	$umbracoClientFolderSource = Join-Path $installPath "UmbracoFiles\Umbraco_Client"		
+	$umbracoClientBackupPath = Join-Path $backupPath "Umbraco_Client"
+	New-Item -ItemType Directory -Force -Path $umbracoClientBackupPath		
+	robocopy $umbracoClientFolder $umbracoClientBackupPath /e /LOG:$copyLogsPath\UmbracoClientBackup.log
+	robocopy $umbracoClientFolderSource $umbracoClientFolder /is /it /e /LOG:$copyLogsPath\UmbracoClientCopy.log		
 
 	$copyWebconfig = $true
-	$destinationWebConfig = Join-Path $projectDestinationPath "Web.config"
+	$destinationWebConfig = Join-Path $projectPath "Web.config"
 
 	if(Test-Path $destinationWebConfig) 
 	{
@@ -71,11 +75,31 @@ if ($project) {
 	
 	if($copyWebconfig -eq $true) 
 	{
-		$packageWebConfigSource = Join-Path $rootPath "UmbracoFiles\Web.config"
+		$packageWebConfigSource = Join-Path $installPath "UmbracoFiles\Web.config"
 		Copy-Item $packageWebConfigSource $destinationWebConfig -Force
-	} 
 
-	$installFolder = Join-Path $projectDestinationPath "Install"
+		# Copy files that don't get automatically copied for Website projects
+		# We do this here, when copyWebconfig is true because we only want to do it for new installs
+		# If this is an upgrade then the files should already be there
+		$splashesSource = Join-Path $installPath "UmbracoFiles\Config\splashes\*.*"
+		$splashesDestination = Join-Path $projectPath "Config\splashes\"
+		New-Item $splashesDestination -Type directory
+		Copy-Item $splashesSource $splashesDestination -Force
+
+		$sqlCe64Source = Join-Path $installPath "UmbracoFiles\bin\amd64\*"
+		$sqlCe64Destination = Join-Path $projectPath "bin\amd64\"
+		Copy-Item $sqlCe64Source $sqlCe64Destination -Force
+		
+		$sqlCex86Source = Join-Path $installPath "UmbracoFiles\bin\x86\*"
+		$sqlCex86Destination = Join-Path $projectPath "bin\x86\"
+		Copy-Item $sqlCex86source $sqlCex86Destination -Force
+
+		$umbracoUIXMLSource = Join-Path $installPath "UmbracoFiles\Umbraco\Config\Create\UI.xml"
+		$umbracoUIXMLDestination = Join-Path $projectPath "Umbraco\Config\Create\UI.xml"
+		Copy-Item $umbracoUIXMLSource $umbracoUIXMLDestination -Force
+	} 
+	
+	$installFolder = Join-Path $projectPath "Install"
 	if(Test-Path $installFolder) {
 		Remove-Item $installFolder -Force -Recurse -Confirm:$false
 	}

build/UmbracoVersion.txt

@@ -1,3 +1,2 @@
 # Usage: on line 2 put the release version, on line 3 put the version comment (example: beta)
-7.4.0
-beta2
+7.5.0

src/SQLCE4Umbraco/SqlCE4Umbraco.csproj

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

src/SQLCE4Umbraco/packages.config

@@ -1,4 +1,4 @@
 <?xml version="1.0" encoding="utf-8"?>
 <packages>
-  <package id="SqlServerCE" version="4.0.0.0" targetFramework="net40" />
+  <package id="SqlServerCE" version="4.0.0.1" targetFramework="net45" />
 </packages>

src/SolutionInfo.cs

@@ -11,5 +11,5 @@ using System.Resources;
 
 [assembly: AssemblyVersion("1.0.*")]
 
-[assembly: AssemblyFileVersion("7.4.0")]
-[assembly: AssemblyInformationalVersion("7.4.0-beta2")]
+[assembly: AssemblyFileVersion("7.5.0")]
+[assembly: AssemblyInformationalVersion("7.5.0")]

src/Umbraco.Core/ApplicationContext.cs

@@ -1,18 +1,22 @@
 using System;
+using System.Collections.Generic;
 using System.Configuration;
+using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using System.Web;
 using Umbraco.Core.Configuration;
 using Umbraco.Core.Logging;
 using Umbraco.Core.ObjectResolution;
+using Umbraco.Core.Packaging;
+using Umbraco.Core.Persistence.Migrations;
 using Umbraco.Core.Profiling;
 using Umbraco.Core.Services;
 using Umbraco.Core.Sync;
 
 namespace Umbraco.Core
 {
-	/// <summary>
+    /// <summary>
     /// the Umbraco Application context
     /// </summary>
     /// <remarks>
@@ -183,6 +187,7 @@ namespace Umbraco.Core
 		readonly ManualResetEventSlim _isReadyEvent = new ManualResetEventSlim(false);
 		private DatabaseContext _databaseContext;
 		private ServiceContext _services;
+        private PackageMigrationsContext _packageMigrationsContext;
 
 		public bool IsReady
         {
@@ -212,17 +217,19 @@ namespace Umbraco.Core
         
         public bool IsConfigured
         {
-            get { return _configured.Value; }
+            get { return _umbracoVersionConfigured.Value; }
         }
+        
 
         /// <summary>
-        /// If the db is configured, there is a database context and there is an umbraco schema, but we are not 'configured' , then it means we are upgrading
+        /// If the db is configured, there is a database context and there is an umbraco schema, 
+        /// but we are: (not 'configured' OR there's pending migrations), then it means we are upgrading
         /// </summary>
 	    public bool IsUpgrading
 	    {
             get
             {
-                if (IsConfigured == false 
+                if ((IsConfigured == false || PackageMigrationsContext.HasPendingPackageMigrations)
                     && DatabaseContext != null 
                     && DatabaseContext.IsDatabaseConfigured)
                 {
@@ -268,7 +275,8 @@ namespace Umbraco.Core
 	    // ReSharper disable once InconsistentNaming
 	    internal string _umbracoApplicationUrl;
 
-        private Lazy<bool> _configured;
+        private Lazy<bool> _umbracoVersionConfigured;
+        
         internal MainDom MainDom { get; private set; }
        
 	    private void Init()
@@ -277,7 +285,7 @@ namespace Umbraco.Core
             MainDom.Acquire();
             
             //Create the lazy value to resolve whether or not the application is 'configured'
-            _configured = new Lazy<bool>(() =>
+            _umbracoVersionConfigured = new Lazy<bool>(() =>
             {
                 try
                 {
@@ -318,9 +326,10 @@ namespace Umbraco.Core
                     LogHelper.Error<ApplicationContext>("Error determining if application is configured, returning false", ex);
                     return false;
                 }
+            });
 
-            }); 
-		}
+            _packageMigrationsContext = new PackageMigrationsContext(DatabaseContext, Services.MigrationEntryService, ProfilingLogger.Logger);
+        }
 
 		private string ConfigurationStatus
 		{
@@ -343,6 +352,11 @@ namespace Umbraco.Core
                 throw new Exception("ApplicationContext has already been initialized.");
         }
 
+        internal PackageMigrationsContext PackageMigrationsContext
+        {
+            get { return _packageMigrationsContext; }
+        }
+
 		/// <summary>
 		/// Gets the current DatabaseContext
 		/// </summary>

src/Umbraco.Core/Cache/DeepCloneRuntimeCacheProvider.cs

@@ -7,14 +7,22 @@ using Umbraco.Core.Models.EntityBase;
 
 namespace Umbraco.Core.Cache
 {
+    /// <summary>
+    /// Interface describing this cache provider as a wrapper for another
+    /// </summary>
+    internal interface IRuntimeCacheProviderWrapper
+    {
+        IRuntimeCacheProvider InnerProvider { get; }
+    }
+
     /// <summary>
     /// A wrapper for any IRuntimeCacheProvider that ensures that all inserts and returns 
     /// are a deep cloned copy of the item when the item is IDeepCloneable and that tracks changes are
     /// reset if the object is TracksChangesEntityBase
     /// </summary>
-    internal class DeepCloneRuntimeCacheProvider : IRuntimeCacheProvider
+    internal class DeepCloneRuntimeCacheProvider : IRuntimeCacheProvider, IRuntimeCacheProviderWrapper
     {
-        internal IRuntimeCacheProvider InnerProvider { get; private set; }
+        public IRuntimeCacheProvider InnerProvider { get; private set; }
 
         public DeepCloneRuntimeCacheProvider(IRuntimeCacheProvider innerProvider)
         {

src/Umbraco.Core/Cache/DefaultRepositoryCachePolicy.cs

@@ -11,35 +11,35 @@ namespace Umbraco.Core.Cache
     /// </summary>
     /// <typeparam name="TEntity"></typeparam>
     /// <typeparam name="TId"></typeparam>
-    internal class DefaultRepositoryCachePolicy<TEntity, TId> : DisposableObject, IRepositoryCachePolicy<TEntity, TId>
+    /// <remarks>
+    /// This cache policy uses sliding expiration and caches instances for 5 minutes. However if allow zero count is true, then we use the
+    /// default policy with no expiry.
+    /// </remarks>
+    internal class DefaultRepositoryCachePolicy<TEntity, TId> : RepositoryCachePolicyBase<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");
+            : base(cache)
+        {            
             if (options == null) throw new ArgumentNullException("options");
-
-            _options = options;
-            Cache = cache;
+            _options = options;         
         }
 
-        public string GetCacheIdKey(object id)
+        protected string GetCacheIdKey(object id)
         {
             if (id == null) throw new ArgumentNullException("id");
 
             return string.Format("{0}{1}", GetCacheTypeKey(), id);
         }
 
-        public string GetCacheTypeKey()
+        protected string GetCacheTypeKey()
         {
             return string.Format("uRepo_{0}_", typeof(TEntity).Name);
         }
 
-        public void CreateOrUpdate(TEntity entity, Action<TEntity> persistMethod)
+        public override void CreateOrUpdate(TEntity entity, Action<TEntity> persistMethod)
         {
             if (entity == null) throw new ArgumentNullException("entity");
             if (persistMethod == null) throw new ArgumentNullException("persistMethod");
@@ -54,7 +54,9 @@ namespace Umbraco.Core.Cache
                     //just to be safe, we cannot cache an item without an identity
                     if (entity.HasIdentity)
                     {
-                        Cache.InsertCacheItem(GetCacheIdKey(entity.Id), () => entity);
+                        Cache.InsertCacheItem(GetCacheIdKey(entity.Id), () => entity,
+                            timeout: TimeSpan.FromMinutes(5),
+                            isSliding: true);
                     }
                     
                     //If there's a GetAllCacheAllowZeroCount cache, ensure it is cleared
@@ -79,24 +81,29 @@ namespace Umbraco.Core.Cache
             }
         }
 
-        public void Remove(TEntity entity, Action<TEntity> persistMethod)
+        public override 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(() =>
+            try
             {
-                Cache.ClearCacheItem(cacheKey);
-                //If there's a GetAllCacheAllowZeroCount cache, ensure it is cleared
-                Cache.ClearCacheItem(GetCacheTypeKey());
-            });            
+                persistMethod(entity);
+            }
+            finally
+            {
+                //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)
+        public override TEntity Get(TId id, Func<TId, TEntity> getFromRepo)
         {
             if (getFromRepo == null) throw new ArgumentNullException("getFromRepo");
 
@@ -113,13 +120,13 @@ namespace Umbraco.Core.Cache
             return entity;
         }
 
-        public TEntity Get(TId id)
+        public override TEntity Get(TId id)
         {
             var cacheKey = GetCacheIdKey(id);
             return Cache.GetCacheItem<TEntity>(cacheKey);
         }
 
-        public bool Exists(TId id, Func<TId, bool> getFromRepo)
+        public override bool Exists(TId id, Func<TId, bool> getFromRepo)
         {
             if (getFromRepo == null) throw new ArgumentNullException("getFromRepo");
 
@@ -128,7 +135,7 @@ namespace Umbraco.Core.Cache
             return fromCache != null || getFromRepo(id);
         }
 
-        public virtual TEntity[] GetAll(TId[] ids, Func<TId[], IEnumerable<TEntity>> getFromRepo)            
+        public override TEntity[] GetAll(TId[] ids, Func<TId[], IEnumerable<TEntity>> getFromRepo)            
         {
             if (getFromRepo == null) throw new ArgumentNullException("getFromRepo");
 
@@ -158,8 +165,7 @@ namespace Umbraco.Core.Cache
                 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)
+                    if (HasZeroCountCache())
                     {
                         //there is a zero count cache so return an empty list
                         return new TEntity[] {};
@@ -179,28 +185,27 @@ namespace Umbraco.Core.Cache
             return entityCollection;
         }
 
+        /// <summary>
+        /// Looks up the zero count cache, must return null if it doesn't exist
+        /// </summary>
+        /// <returns></returns>
+        protected bool HasZeroCountCache()
+        {
+            var zeroCount = Cache.GetCacheItem<TEntity[]>(GetCacheTypeKey());
+            return (zeroCount != null && zeroCount.Any() == false);
+        }
+
         /// <summary>
         /// Performs the lookup for all entities of this type from the cache
         /// </summary>
         /// <returns></returns>
-        protected virtual TEntity[] GetAllFromCache()
+        protected 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
@@ -216,7 +221,9 @@ namespace Umbraco.Core.Cache
                 //just to be safe, we cannot cache an item without an identity
                 if (entity.HasIdentity)
                 {
-                    Cache.InsertCacheItem(cacheKey, () => entity);
+                    Cache.InsertCacheItem(cacheKey, () => entity,
+                        timeout: TimeSpan.FromMinutes(5),
+                        isSliding: true);
                 }
             });
         }
@@ -235,6 +242,7 @@ namespace Umbraco.Core.Cache
                 {
                     //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
+                    //NOTE: Don't set expiry/sliding for a zero count
                     Cache.InsertCacheItem(GetCacheTypeKey(), () => new TEntity[] {});
                 }
                 else
@@ -247,20 +255,14 @@ namespace Umbraco.Core.Cache
                         //just to be safe, we cannot cache an item without an identity
                         if (localCopy.HasIdentity)
                         {
-                            Cache.InsertCacheItem(GetCacheIdKey(entity.Id), () => localCopy);
+                            Cache.InsertCacheItem(GetCacheIdKey(entity.Id), () => localCopy,
+                                timeout: TimeSpan.FromMinutes(5),
+                                isSliding: true);
                         }
                     }
                 }
             });
         }
-
-        /// <summary>
-        /// Sets the action to execute on disposal
-        /// </summary>
-        /// <param name="action"></param>
-        protected void SetCacheAction(Action action)
-        {
-            _action = action;
-        }
+        
     }
 }

src/Umbraco.Core/Cache/FullDataSetRepositoryCachePolicy.cs

@@ -1,3 +1,5 @@
+using System;
+using System.Collections.Generic;
 using System.Linq;
 using Umbraco.Core.Collections;
 using Umbraco.Core.Models.EntityBase;
@@ -9,11 +11,157 @@ namespace Umbraco.Core.Cache
     /// </summary>
     /// <typeparam name="TEntity"></typeparam>
     /// <typeparam name="TId"></typeparam>
-    internal class FullDataSetRepositoryCachePolicy<TEntity, TId> : DefaultRepositoryCachePolicy<TEntity, TId>
+    internal class FullDataSetRepositoryCachePolicy<TEntity, TId> : RepositoryCachePolicyBase<TEntity, TId>
         where TEntity : class, IAggregateRoot
     {
-        public FullDataSetRepositoryCachePolicy(IRuntimeCacheProvider cache) : base(cache, new RepositoryCachePolicyOptions())
+        private readonly Func<TEntity, TId> _getEntityId;
+        private readonly Func<IEnumerable<TEntity>> _getAllFromRepo;
+        private readonly bool _expires;
+
+        public FullDataSetRepositoryCachePolicy(IRuntimeCacheProvider cache, Func<TEntity, TId> getEntityId, Func<IEnumerable<TEntity>> getAllFromRepo, bool expires)
+            : base(cache)
         {
+            _getEntityId = getEntityId;
+            _getAllFromRepo = getAllFromRepo;
+            _expires = expires;
+        }
+
+        private bool? _hasZeroCountCache;
+
+
+        protected string GetCacheTypeKey()
+        {
+            return string.Format("uRepo_{0}_", typeof(TEntity).Name);
+        }
+
+        public override 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(() =>
+                {
+                    //Clear all
+                    Cache.ClearCacheItem(GetCacheTypeKey());
+                });
+            }
+            catch
+            {
+                //set the disposal action                
+                SetCacheAction(() =>
+                {
+                    //Clear all
+                    Cache.ClearCacheItem(GetCacheTypeKey());
+                });
+                throw;
+            }
+        }
+
+        public override void Remove(TEntity entity, Action<TEntity> persistMethod)
+        {
+            if (entity == null) throw new ArgumentNullException("entity");
+            if (persistMethod == null) throw new ArgumentNullException("persistMethod");
+
+            try
+            {
+                persistMethod(entity);
+            }
+            finally
+            {
+                //set the disposal action
+                SetCacheAction(() =>
+                {
+                    //Clear all
+                    Cache.ClearCacheItem(GetCacheTypeKey());
+                });
+            }
+        }
+
+        public override TEntity Get(TId id, Func<TId, TEntity> getFromRepo)
+        {
+            //Force get all with cache
+            var found = GetAll(new TId[] { }, ids => _getAllFromRepo().WhereNotNull());
+
+            //we don't have anything in cache (this should never happen), just return from the repo
+            if (found == null) return getFromRepo(id);
+            var entity = found.FirstOrDefault(x => _getEntityId(x).Equals(id));
+            if (entity == null) return null;
+
+            //We must ensure to deep clone each one out manually since the deep clone list only clones one way
+            return (TEntity)entity.DeepClone();
+        }
+
+        public override TEntity Get(TId id)
+        {
+            //Force get all with cache
+            var found = GetAll(new TId[] { }, ids => _getAllFromRepo().WhereNotNull());
+
+            //we don't have anything in cache (this should never happen), just return null
+            if (found == null) return null;
+            var entity = found.FirstOrDefault(x => _getEntityId(x).Equals(id));
+            if (entity == null) return null;
+
+            //We must ensure to deep clone each one out manually since the deep clone list only clones one way
+            return (TEntity)entity.DeepClone();
+        }
+
+        public override bool Exists(TId id, Func<TId, bool> getFromRepo)
+        {
+            //Force get all with cache
+            var found = GetAll(new TId[] { }, ids => _getAllFromRepo().WhereNotNull());
+
+            //we don't have anything in cache (this should never happen), just return from the repo
+            return found == null
+                ? getFromRepo(id)
+                : found.Any(x => _getEntityId(x).Equals(id));
+        }
+
+        public override TEntity[] GetAll(TId[] ids, Func<TId[], IEnumerable<TEntity>> getFromRepo)
+        {
+            //process getting all including setting the cache callback
+            var result = PerformGetAll(getFromRepo);
+
+            //now that the base result has been calculated, they will all be cached. 
+            // Now we can just filter by ids if they have been supplied
+
+            return (ids.Any()
+                ? result.Where(x => ids.Contains(_getEntityId(x))).ToArray()
+                : result)
+                //We must ensure to deep clone each one out manually since the deep clone list only clones one way
+                .Select(x => (TEntity)x.DeepClone())
+                .ToArray();
+        }
+
+        private TEntity[] PerformGetAll(Func<TId[], IEnumerable<TEntity>> getFromRepo)
+        {
+            var allEntities = GetAllFromCache();
+            if (allEntities.Any())
+            {
+                return allEntities;
+            }
+
+            //check the zero count cache
+            if (HasZeroCountCache())
+            {
+                //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(new TId[] { })
+                //ensure we don't include any null refs in the returned collection!
+                .WhereNotNull()
+                .ToArray();
+
+            //set the disposal action
+            SetCacheAction(entityCollection);
+
+            return entityCollection;
         }
 
         /// <summary>
@@ -21,37 +169,61 @@ namespace Umbraco.Core.Cache
         /// </summary>
         /// <param name="cacheKey"></param>
         /// <param name="entity"></param>
-        protected override void SetCacheAction(string cacheKey, TEntity entity)
+        protected void SetCacheAction(string cacheKey, TEntity entity)
         {
-            //do nothing
+            //No-op
         }
 
         /// <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)
+        protected void SetCacheAction(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));
+
+                if (_expires)
+                {
+                    Cache.InsertCacheItem(GetCacheTypeKey(), () => new DeepCloneableList<TEntity>(entityCollection),
+                        timeout: TimeSpan.FromMinutes(5),
+                        isSliding: true);
+                }
+                else
+                {
+                    Cache.InsertCacheItem(GetCacheTypeKey(), () => new DeepCloneableList<TEntity>(entityCollection));
+                }
             });
         }
 
+        /// <summary>
+        /// Looks up the zero count cache, must return null if it doesn't exist
+        /// </summary>
+        /// <returns></returns>
+        protected bool HasZeroCountCache()
+        {
+            if (_hasZeroCountCache.HasValue)
+                return _hasZeroCountCache.Value;
+
+            _hasZeroCountCache = Cache.GetCacheItem<DeepCloneableList<TEntity>>(GetCacheTypeKey()) != null;
+            return _hasZeroCountCache.Value;
+        }
+
         /// <summary>
         /// This policy will cache the full data set as a single collection
         /// </summary>
         /// <returns></returns>
-        protected override TEntity[] GetAllFromCache()
+        protected TEntity[] GetAllFromCache()
         {
             var found = Cache.GetCacheItem<DeepCloneableList<TEntity>>(GetCacheTypeKey());
+
+            //This method will get called before checking for zero count cache, so we'll just set the flag here
+            _hasZeroCountCache = found != null;
+
             return found == null ? new TEntity[] { } : found.WhereNotNull().ToArray();
         }
+
     }
 }

src/Umbraco.Core/Cache/FullDataSetRepositoryCachePolicyFactory.cs

@@ -1,3 +1,5 @@
+using System;
+using System.Collections.Generic;
 using Umbraco.Core.Models.EntityBase;
 
 namespace Umbraco.Core.Cache
@@ -11,15 +13,21 @@ namespace Umbraco.Core.Cache
         where TEntity : class, IAggregateRoot
     {
         private readonly IRuntimeCacheProvider _runtimeCache;
-        
-        public FullDataSetRepositoryCachePolicyFactory(IRuntimeCacheProvider runtimeCache)
+        private readonly Func<TEntity, TId> _getEntityId;
+        private readonly Func<IEnumerable<TEntity>> _getAllFromRepo;
+        private readonly bool _expires;
+
+        public FullDataSetRepositoryCachePolicyFactory(IRuntimeCacheProvider runtimeCache, Func<TEntity, TId> getEntityId, Func<IEnumerable<TEntity>> getAllFromRepo, bool expires)
         {
             _runtimeCache = runtimeCache;
+            _getEntityId = getEntityId;
+            _getAllFromRepo = getAllFromRepo;
+            _expires = expires;
         }
 
         public virtual IRepositoryCachePolicy<TEntity, TId> CreatePolicy()
         {
-            return new FullDataSetRepositoryCachePolicy<TEntity, TId>(_runtimeCache);
+            return new FullDataSetRepositoryCachePolicy<TEntity, TId>(_runtimeCache, _getEntityId, _getAllFromRepo, _expires);
         }
     }
 }

src/Umbraco.Core/Cache/ICacheProvider.cs

@@ -4,7 +4,7 @@ using System.Collections.Generic;
 namespace Umbraco.Core.Cache
 {
     /// <summary>
-    /// An abstract class for implementing a basic cache provider
+    /// An interface for implementing a basic cache provider
     /// </summary>
     public interface ICacheProvider
     {
@@ -65,4 +65,4 @@ namespace Umbraco.Core.Cache
 
         object GetCacheItem(string cacheKey, Func<object> getCacheItem);
     }
-}
+}

src/Umbraco.Core/Cache/IRepositoryCachePolicy.cs

@@ -10,9 +10,7 @@ namespace Umbraco.Core.Cache
         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);

src/Umbraco.Core/Cache/IsolatedRuntimeCache.cs

@@ -12,7 +12,7 @@ namespace Umbraco.Core.Cache
     /// </remarks>
     public class IsolatedRuntimeCache
     {
-        private readonly Func<Type, IRuntimeCacheProvider> _cacheFactory;
+        internal Func<Type, IRuntimeCacheProvider> CacheFactory { get; set; }
 
         /// <summary>
         /// Constructor that allows specifying a factory for the type of runtime isolated cache to create
@@ -20,7 +20,7 @@ namespace Umbraco.Core.Cache
         /// <param name="cacheFactory"></param>
         public IsolatedRuntimeCache(Func<Type, IRuntimeCacheProvider> cacheFactory)
         {
-            _cacheFactory = cacheFactory;
+            CacheFactory = cacheFactory;
         }
 
         private readonly ConcurrentDictionary<Type, IRuntimeCacheProvider> _isolatedCache = new ConcurrentDictionary<Type, IRuntimeCacheProvider>();
@@ -32,7 +32,7 @@ namespace Umbraco.Core.Cache
         /// <returns></returns>        
         public IRuntimeCacheProvider GetOrCreateCache<T>()
         {
-            return _isolatedCache.GetOrAdd(typeof(T), type => _cacheFactory(type));
+            return _isolatedCache.GetOrAdd(typeof(T), type => CacheFactory(type));
         }
 
         /// <summary>
@@ -41,7 +41,7 @@ namespace Umbraco.Core.Cache
         /// <returns></returns>        
         public IRuntimeCacheProvider GetOrCreateCache(Type type)
         {
-            return _isolatedCache.GetOrAdd(type, t => _cacheFactory(t));
+            return _isolatedCache.GetOrAdd(type, t => CacheFactory(t));
         }
 
         /// <summary>

src/Umbraco.Core/Cache/RepositoryCachePolicyBase.cs

@@ -0,0 +1,48 @@
+using System;
+using System.Collections.Generic;
+using Umbraco.Core.Models.EntityBase;
+
+namespace Umbraco.Core.Cache
+{
+    internal abstract class RepositoryCachePolicyBase<TEntity, TId> : DisposableObject, IRepositoryCachePolicy<TEntity, TId>
+        where TEntity : class, IAggregateRoot
+    {
+        private Action _action;
+
+        protected RepositoryCachePolicyBase(IRuntimeCacheProvider cache)
+        {
+            if (cache == null) throw new ArgumentNullException("cache");
+            
+            Cache = cache;
+        }
+
+        protected IRuntimeCacheProvider Cache { get; private set; }
+
+        /// <summary>
+        /// The disposal performs the caching
+        /// </summary>
+        protected override void DisposeResources()
+        {
+            if (_action != null)
+            {
+                _action();
+            }
+        }
+
+        /// <summary>
+        /// Sets the action to execute on disposal
+        /// </summary>
+        /// <param name="action"></param>
+        protected void SetCacheAction(Action action)
+        {
+            _action = action;
+        }
+
+        public abstract TEntity Get(TId id, Func<TId, TEntity> getFromRepo);
+        public abstract TEntity Get(TId id);
+        public abstract bool Exists(TId id, Func<TId, bool> getFromRepo);
+        public abstract void CreateOrUpdate(TEntity entity, Action<TEntity> persistMethod);
+        public abstract void Remove(TEntity entity, Action<TEntity> persistMethod);
+        public abstract TEntity[] GetAll(TId[] ids, Func<TId[], IEnumerable<TEntity>> getFromRepo);
+    }
+}

src/Umbraco.Core/Cache/SingleItemsOnlyRepositoryCachePolicy.cs

@@ -18,7 +18,7 @@ namespace Umbraco.Core.Cache
         
         protected override void SetCacheAction(TId[] ids, TEntity[] entityCollection)
         {            
-            //do nothing
+            //no-op
         }
     }
 }

src/Umbraco.Core/CacheHelper.cs

@@ -18,12 +18,8 @@ namespace Umbraco.Core
 	/// </summary>
     public class CacheHelper
 	{
-	    private readonly IsolatedRuntimeCache _isolatedCacheManager;
-	    private readonly ICacheProvider _requestCache;
         private static readonly ICacheProvider NullRequestCache = new NullCacheProvider();
-        private readonly ICacheProvider _staticCache;
         private static readonly ICacheProvider NullStaticCache = new NullCacheProvider();
-        private readonly IRuntimeCacheProvider _runtimeCache;
         private static readonly IRuntimeCacheProvider NullRuntimeCache = new NullCacheProvider();
         
         /// <summary>
@@ -90,45 +86,33 @@ namespace Umbraco.Core
 	        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;
+	        RuntimeCache = httpCacheProvider;
+            StaticCache = staticCacheProvider;
+            RequestCache = requestCacheProvider;
+            IsolatedRuntimeCache = isolatedCacheManager;
         }
 
         /// <summary>
         /// Returns the current Request cache
         /// </summary>
-        public ICacheProvider RequestCache
-        {
-            get { return _requestCache; }
-        }
+        public ICacheProvider RequestCache { get; internal set; }
         
         /// <summary>
         /// Returns the current Runtime cache
         /// </summary>
-        public ICacheProvider StaticCache
-        {
-            get { return _staticCache; }
-        }
+        public ICacheProvider StaticCache { get; internal set; }
 
         /// <summary>
         /// Returns the current Runtime cache
         /// </summary>
-	    public IRuntimeCacheProvider RuntimeCache
-	    {
-	        get { return _runtimeCache; }
-	    }
+	    public IRuntimeCacheProvider RuntimeCache { get; internal set; }
 
         /// <summary>
         /// Returns the current Isolated Runtime cache manager
         /// </summary>
-        public IsolatedRuntimeCache IsolatedRuntimeCache
-        {
-            get { return _isolatedCacheManager; }
-        }
-        
-	    #region Legacy Runtime/Http Cache accessors
+        public IsolatedRuntimeCache IsolatedRuntimeCache { get; internal set; }
+
+        #region Legacy Runtime/Http Cache accessors
 
         /// <summary>
         /// Clears the item in umbraco's runtime cache
@@ -137,8 +121,8 @@ namespace Umbraco.Core
         [EditorBrowsable(EditorBrowsableState.Never)]
         public void ClearAllCache()
         {
-            _runtimeCache.ClearAllCache();
-            _isolatedCacheManager.ClearAllCaches();
+            RuntimeCache.ClearAllCache();
+            IsolatedRuntimeCache.ClearAllCaches();
         }
 
         /// <summary>
@@ -149,7 +133,7 @@ namespace Umbraco.Core
         [EditorBrowsable(EditorBrowsableState.Never)]
         public void ClearCacheItem(string key)
         {
-            _runtimeCache.ClearCacheItem(key);
+            RuntimeCache.ClearCacheItem(key);
         }
 
 
@@ -161,7 +145,7 @@ namespace Umbraco.Core
         [Obsolete("Do not use this method, access the runtime cache from the RuntimeCache property")]
         public void ClearCacheObjectTypes(string typeName)
         {
-            _runtimeCache.ClearCacheObjectTypes(typeName);
+            RuntimeCache.ClearCacheObjectTypes(typeName);
         }
 
         /// <summary>
@@ -171,7 +155,7 @@ namespace Umbraco.Core
         [EditorBrowsable(EditorBrowsableState.Never)]
         public void ClearCacheObjectTypes<T>()
         {
-            _runtimeCache.ClearCacheObjectTypes<T>();
+            RuntimeCache.ClearCacheObjectTypes<T>();
         }
 
         /// <summary>
@@ -182,7 +166,7 @@ namespace Umbraco.Core
         [EditorBrowsable(EditorBrowsableState.Never)]
         public void ClearCacheByKeySearch(string keyStartsWith)
         {
-            _runtimeCache.ClearCacheByKeySearch(keyStartsWith);
+            RuntimeCache.ClearCacheByKeySearch(keyStartsWith);
         }
 
         /// <summary>
@@ -193,14 +177,14 @@ namespace Umbraco.Core
         [EditorBrowsable(EditorBrowsableState.Never)]
         public void ClearCacheByKeyExpression(string regexString)
         {
-            _runtimeCache.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)
         {
-            return _runtimeCache.GetCacheItemsByKeySearch<T>(keyStartsWith);
+            return RuntimeCache.GetCacheItemsByKeySearch<T>(keyStartsWith);
         }
 
         /// <summary>
@@ -213,7 +197,7 @@ namespace Umbraco.Core
         [EditorBrowsable(EditorBrowsableState.Never)]
         public TT GetCacheItem<TT>(string cacheKey)
         {
-            return _runtimeCache.GetCacheItem<TT>(cacheKey);
+            return RuntimeCache.GetCacheItem<TT>(cacheKey);
         }
 
         /// <summary>
@@ -227,7 +211,7 @@ namespace Umbraco.Core
         [EditorBrowsable(EditorBrowsableState.Never)]
         public TT GetCacheItem<TT>(string cacheKey, Func<TT> getCacheItem)
         {
-            return _runtimeCache.GetCacheItem<TT>(cacheKey, getCacheItem);
+            return RuntimeCache.GetCacheItem<TT>(cacheKey, getCacheItem);
 
         }
 
@@ -244,7 +228,7 @@ namespace Umbraco.Core
         public TT GetCacheItem<TT>(string cacheKey,
             TimeSpan timeout, Func<TT> getCacheItem)
         {
-            return _runtimeCache.GetCacheItem<TT>(cacheKey, getCacheItem, timeout);
+            return RuntimeCache.GetCacheItem<TT>(cacheKey, getCacheItem, timeout);
 
         }
 
@@ -263,7 +247,7 @@ namespace Umbraco.Core
             CacheItemRemovedCallback refreshAction, TimeSpan timeout,
             Func<TT> getCacheItem)
         {
-            return _runtimeCache.GetCacheItem<TT>(cacheKey, getCacheItem, timeout, removedCallback: refreshAction);
+            return RuntimeCache.GetCacheItem<TT>(cacheKey, getCacheItem, timeout, removedCallback: refreshAction);
 
         }
 
@@ -283,7 +267,7 @@ namespace Umbraco.Core
             CacheItemPriority priority, CacheItemRemovedCallback refreshAction, TimeSpan timeout,
             Func<TT> getCacheItem)
         {
-            return _runtimeCache.GetCacheItem<TT>(cacheKey, getCacheItem, timeout, false, priority, refreshAction);
+            return RuntimeCache.GetCacheItem<TT>(cacheKey, getCacheItem, timeout, false, priority, refreshAction);
 
         }
 
@@ -306,7 +290,7 @@ namespace Umbraco.Core
             TimeSpan timeout,
             Func<TT> getCacheItem)
         {
-            var cache = _runtimeCache as HttpRuntimeCacheProvider;
+            var cache = GetHttpRuntimeCacheProvider(RuntimeCache);
             if (cache != null)
             {
                 var result = cache.GetCacheItem(cacheKey, () => getCacheItem(), timeout, false, priority, refreshAction, cacheDependency);
@@ -330,7 +314,7 @@ namespace Umbraco.Core
             CacheDependency cacheDependency,
             Func<TT> getCacheItem)
         {
-            var cache = _runtimeCache as HttpRuntimeCacheProvider;
+            var cache = GetHttpRuntimeCacheProvider(RuntimeCache);
             if (cache != null)
             {
                 var result = cache.GetCacheItem(cacheKey, () => getCacheItem(), null, false, priority, null, cacheDependency);
@@ -352,7 +336,7 @@ namespace Umbraco.Core
                                        CacheItemPriority priority,
                                        Func<T> getCacheItem)
         {
-            _runtimeCache.InsertCacheItem<T>(cacheKey, getCacheItem, priority: priority);
+            RuntimeCache.InsertCacheItem<T>(cacheKey, getCacheItem, priority: priority);
 
         }
 
@@ -371,7 +355,7 @@ namespace Umbraco.Core
                                        TimeSpan timeout,
                                        Func<T> getCacheItem)
         {
-            _runtimeCache.InsertCacheItem<T>(cacheKey, getCacheItem, timeout, priority: priority);
+            RuntimeCache.InsertCacheItem<T>(cacheKey, getCacheItem, timeout, priority: priority);
         }
 
         /// <summary>
@@ -390,7 +374,7 @@ namespace Umbraco.Core
                                        TimeSpan timeout,
                                        Func<T> getCacheItem)
         {
-            var cache = _runtimeCache as HttpRuntimeCacheProvider;
+            var cache = GetHttpRuntimeCacheProvider(RuntimeCache);
             if (cache != null)
             {
                 cache.InsertCacheItem(cacheKey, () => getCacheItem(), timeout, false, priority, null, cacheDependency);
@@ -416,7 +400,7 @@ namespace Umbraco.Core
                                        TimeSpan? timeout,
                                        Func<T> getCacheItem)
         {
-            var cache = _runtimeCache as HttpRuntimeCacheProvider;
+            var cache = GetHttpRuntimeCacheProvider(RuntimeCache);
             if (cache != null)
             {
                 cache.InsertCacheItem(cacheKey, () => getCacheItem(), timeout, false, priority, refreshAction, cacheDependency);
@@ -425,6 +409,20 @@ namespace Umbraco.Core
         } 
         #endregion
 
-	}
+	    private HttpRuntimeCacheProvider GetHttpRuntimeCacheProvider(IRuntimeCacheProvider runtimeCache)
+	    {
+	        HttpRuntimeCacheProvider cache;
+            var wrapper = RuntimeCache as IRuntimeCacheProviderWrapper;
+	        if (wrapper != null)
+	        {
+	            cache = wrapper.InnerProvider as HttpRuntimeCacheProvider;
+	        }
+	        else
+	        {
+                cache = RuntimeCache as HttpRuntimeCacheProvider;
+            }
+	        return cache;
+	    }
+    }
 
 }

src/Umbraco.Core/Collections/DeepCloneableList.cs

@@ -14,18 +14,24 @@ namespace Umbraco.Core.Collections
     /// <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()
+        private readonly ListCloneBehavior _listCloneBehavior;
+        
+        public DeepCloneableList(ListCloneBehavior listCloneBehavior)
         {
+            _listCloneBehavior = listCloneBehavior;
+        }
+        
+        public DeepCloneableList(IEnumerable<T> collection, ListCloneBehavior listCloneBehavior) : base(collection)
+        {
+            _listCloneBehavior = listCloneBehavior;
         }
 
         /// <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.
+        /// Default behavior is CloneOnce
         /// </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)
+        /// <param name="collection"></param>
+        public DeepCloneableList(IEnumerable<T> collection)
+            : this(collection, ListCloneBehavior.CloneOnce)
         {
         }
 
@@ -35,20 +41,47 @@ namespace Umbraco.Core.Collections
         /// <returns></returns>
         public object DeepClone()
         {
-            var newList = new DeepCloneableList<T>();
-            foreach (var item in this)
+            switch (_listCloneBehavior)
             {
-                var dc = item as IDeepCloneable;
-                if (dc != null)
-                {
-                    newList.Add((T) dc.DeepClone());
-                }
-                else
-                {
-                    newList.Add(item);
-                }
+                case ListCloneBehavior.CloneOnce:
+                    //we are cloning once, so create a new list in none mode
+                    // and deep clone all items into it
+                    var newList = new DeepCloneableList<T>(ListCloneBehavior.None);
+                    foreach (var item in this)
+                    {
+                        var dc = item as IDeepCloneable;
+                        if (dc != null)
+                        {
+                            newList.Add((T)dc.DeepClone());
+                        }
+                        else
+                        {
+                            newList.Add(item);
+                        }
+                    }
+                    return newList;
+                case ListCloneBehavior.None:
+                    //we are in none mode, so just return a new list with the same items
+                    return new DeepCloneableList<T>(this, ListCloneBehavior.None);
+                case ListCloneBehavior.Always:
+                    //always clone to new list
+                    var newList2 = new DeepCloneableList<T>(ListCloneBehavior.Always);
+                    foreach (var item in this)
+                    {
+                        var dc = item as IDeepCloneable;
+                        if (dc != null)
+                        {
+                            newList2.Add((T)dc.DeepClone());
+                        }
+                        else
+                        {
+                            newList2.Add(item);
+                        }
+                    }
+                    return newList2;
+                default:
+                    throw new ArgumentOutOfRangeException();
             }
-            return newList;
         }
 
         public bool IsDirty()

src/Umbraco.Core/Collections/ListCloneBehavior.cs

@@ -0,0 +1,20 @@
+namespace Umbraco.Core.Collections
+{
+    internal enum ListCloneBehavior
+    {
+        /// <summary>
+        /// When set, DeepClone will clone the items one time and the result list behavior will be None
+        /// </summary>
+        CloneOnce,
+
+        /// <summary>
+        /// When set, DeepClone will not clone any items
+        /// </summary>
+        None,
+
+        /// <summary>
+        /// When set, DeepClone will always clone all items
+        /// </summary>
+        Always
+    }
+}

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

@@ -6,6 +6,8 @@
 
         bool HideDisabledUsersInBackoffice { get; }
 
+        bool AllowPasswordReset { get; }
+
         string AuthCookieName { get; }
 
         string AuthCookieDomain { get; }

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

@@ -28,6 +28,18 @@ namespace Umbraco.Core.Configuration.UmbracoSettings
             }
         }
 
+        [ConfigurationProperty("allowPasswordReset")]
+        internal InnerTextConfigurationElement<bool> AllowPasswordReset
+        {
+            get
+            {
+                return new OptionalInnerTextConfigurationElement<bool>(
+                    (InnerTextConfigurationElement<bool>)this["allowPasswordReset"],
+                    //set the default
+                    true);
+            }
+        }
+
         [ConfigurationProperty("authCookieName")]
         internal InnerTextConfigurationElement<string> AuthCookieName
         {
@@ -62,6 +74,11 @@ namespace Umbraco.Core.Configuration.UmbracoSettings
             get { return HideDisabledUsersInBackoffice; }
         }
 
+        bool ISecuritySection.AllowPasswordReset
+        {
+            get { return AllowPasswordReset; }
+        }
+
         string ISecuritySection.AuthCookieName
         {
             get { return AuthCookieName; }

src/Umbraco.Core/Configuration/UmbracoVersion.cs

@@ -6,7 +6,7 @@ namespace Umbraco.Core.Configuration
 {
     public class UmbracoVersion
     {
-        private static readonly Version Version = new Version("7.4.0");
+        private static readonly Version Version = new Version("7.5.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 "beta2"; } }
+        public static string CurrentComment { get { return ""; } }
 
         // 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
@@ -32,12 +32,7 @@ namespace Umbraco.Core.Configuration
 
         public static SemVersion GetSemanticVersion()
         {
-            return new SemVersion(
-                Current.Major, 
-                Current.Minor,
-                Current.Build, 
-                CurrentComment.IsNullOrWhiteSpace() ? null : CurrentComment,
-                Current.Revision > 0 ? Current.Revision.ToInvariantString() : null);
+            return Current.GetSemanticVersion();
         }
     }
 }

src/Umbraco.Core/Constants-ObjectTypes.cs

@@ -143,7 +143,10 @@ namespace Umbraco.Core
             /// </summary>
             public const string LockObject = "87A9F1FF-B1E4-4A25-BABB-465A4A47EC41";
 
-            
+            /// <summary>
+            /// Guid for a Lock object.
+            /// </summary>
+            public static readonly Guid LockObjectGuid = new Guid(LockObject);
         }
     }
 }

src/Umbraco.Core/Constants-PropertyEditors.cs

@@ -11,7 +11,7 @@ namespace Umbraco.Core
         {
             /// <summary>
             /// Used to prefix generic properties that are internal content properties
-            /// </summary>            
+            /// </summary>
             public const string InternalGenericPropertiesPrefix = "_umb_";
 
             /// <summary>
@@ -74,7 +74,7 @@ namespace Umbraco.Core
             /// </summary>
             [Obsolete("GUIDs are no longer used to reference Property Editors, use the Alias constant instead. This will be removed in future versions")]
             public const string DictionaryPicker = "17B70066-F764-407D-AB05-3717F1E1C513";
-            
+
             /// <summary>
             /// Guid for the Dropdown list datatype.
             /// </summary>
@@ -352,7 +352,7 @@ namespace Umbraco.Core
             /// </summary>
             [Obsolete("GUIDs are no longer used to reference Property Editors, use the Alias constant instead. This will be removed in future versions")]
             public const string UltimatePicker = "CDBF0B5D-5CB2-445F-BC12-FCAAEC07CF2C";
-            
+
             /// <summary>
             /// Guid for the UltraSimpleEditor datatype.
             /// </summary>
@@ -369,7 +369,7 @@ namespace Umbraco.Core
             /// </summary>
             [Obsolete("GUIDs are no longer used to reference Property Editors, use the Alias constant instead. This will be removed in future versions")]
             public const string UmbracoUserControlWrapper = "D15E1281-E456-4B24-AA86-1DDA3E4299D5";
-            
+
             /// <summary>
             /// Guid for the Upload field datatype.
             /// </summary>
@@ -419,6 +419,15 @@ namespace Umbraco.Core
             /// Alias for the email address property editor
             /// </summary>
             public const string EmailAddressAlias = "Umbraco.EmailAddress";
+
+            public static class PreValueKeys
+            {
+                /// <summary>
+                /// Pre-value name used to indicate a field that can be used to override the database field to which data for the associated
+                /// property is saved
+                /// </summary>
+                public const string DataValueType = "umbracoDataValueType";
+            }
         }
 	}
 }

src/Umbraco.Core/Constants-Web.cs

@@ -10,6 +10,12 @@ namespace Umbraco.Core
         /// </summary>
         public static class Web
         {
+            public const string UmbracoContextDataToken = "umbraco-context";
+            public const string UmbracoDataToken = "umbraco";
+            public const string PublishedDocumentRequestDataToken = "umbraco-doc-request";
+            public const string CustomRouteDataToken = "umbraco-custom-route";
+            public const string UmbracoRouteDefinitionDataToken = "umbraco-route-def";
+
             /// <summary>
             /// The preview cookie name
             /// </summary>

src/Umbraco.Core/CoreBootManager.cs

@@ -136,7 +136,10 @@ namespace Umbraco.Core
                     {
                         try
                         {
-                            x.OnApplicationInitialized(UmbracoApplication, ApplicationContext);
+                            using (ProfilingLogger.DebugDuration<CoreBootManager>(string.Format("Executing {0} in ApplicationInitialized", x.GetType())))
+                            {
+                                x.OnApplicationInitialized(UmbracoApplication, ApplicationContext);
+                            }
                         }
                         catch (Exception ex)
                         {
@@ -299,7 +302,10 @@ namespace Umbraco.Core
 		            {
 		                try
 		                {
-		                    x.OnApplicationStarting(UmbracoApplication, ApplicationContext);
+		                    using (ProfilingLogger.DebugDuration<CoreBootManager>(string.Format("Executing {0} in ApplicationStarting", x.GetType())))
+		                    {
+		                        x.OnApplicationStarting(UmbracoApplication, ApplicationContext);
+		                    }
 		                }
 		                catch (Exception ex)
 		                {
@@ -350,7 +356,10 @@ namespace Umbraco.Core
                     {
                         try
                         {
-                            x.OnApplicationStarted(UmbracoApplication, ApplicationContext);
+                            using (ProfilingLogger.DebugDuration<CoreBootManager>(string.Format("Executing {0} in ApplicationStarted", x.GetType())))
+                            {
+                                x.OnApplicationStarted(UmbracoApplication, ApplicationContext);
+                            }
                         }
                         catch (Exception ex)
                         {
@@ -491,7 +500,12 @@ namespace Umbraco.Core
             //the database migration objects
             MigrationResolver.Current = new MigrationResolver(
                 ProfilingLogger.Logger,
-                () => PluginManager.ResolveTypes<IMigration>());
+                () => PluginManager.ResolveTypes<IMigration>())
+            {
+                //This needs to be resolved before it's frozen because we need to find migrations to determine
+                // if Umbraco IsConfigured
+                CanResolveBeforeFrozen = true
+            };
 
             // todo: remove once we drop IPropertyEditorValueConverter support.
             PropertyEditorValueConvertersResolver.Current = new PropertyEditorValueConvertersResolver(

src/Umbraco.Core/DisposableTimer.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 using System.ComponentModel;
 using System.Diagnostics;
 using System.Web;
@@ -12,6 +13,12 @@ namespace Umbraco.Core
 	/// </summary>
 	public class DisposableTimer : DisposableObject
 	{
+	    private readonly ILogger _logger;
+	    private readonly LogType? _logType;
+	    private readonly IProfiler _profiler;
+	    private readonly Type _loggerType;
+	    private readonly string _endMessage;
+	    private readonly IDisposable _profilerStep;
 	    private readonly Stopwatch _stopwatch = Stopwatch.StartNew();
 		private readonly Action<long> _callback;
 
@@ -25,25 +32,12 @@ namespace Umbraco.Core
             if (logger == null) throw new ArgumentNullException("logger");
             if (loggerType == null) throw new ArgumentNullException("loggerType");
 
-            _callback = x =>
-            {
-                if (profiler != null)
-                {
-                    profiler.DisposeIfDisposable();
-                }
-                switch (logType)
-                {
-                    case LogType.Debug:
-                        logger.Debug(loggerType, () => endMessage + " (took " + x + "ms)");
-                        break;
-                    case LogType.Info:
-                        logger.Info(loggerType, () => endMessage + " (took " + x + "ms)");
-                        break;
-                    default:
-                        throw new ArgumentOutOfRangeException("logType");
-                }
-                
-            };
+            _logger = logger;
+            _logType = logType;
+            _profiler = profiler;
+            _loggerType = loggerType;
+            _endMessage = endMessage;
+            
             switch (logType)
             {
                 case LogType.Debug:
@@ -58,7 +52,7 @@ namespace Umbraco.Core
             
             if (profiler != null)
             {
-                profiler.Step(loggerType, startMessage);    
+                _profilerStep = profiler.Step(loggerType, startMessage);
             }
         }
 
@@ -223,7 +217,36 @@ namespace Umbraco.Core
 		/// </summary>
 		protected override void DisposeResources()
 		{
-			_callback.Invoke(Stopwatch.ElapsedMilliseconds);
+            if (_profiler != null)
+            {
+                _profiler.DisposeIfDisposable();
+            }
+
+		    if (_profilerStep != null)
+		    {
+                _profilerStep.Dispose();
+            }
+
+		    if (_logType.HasValue && _endMessage.IsNullOrWhiteSpace() == false && _loggerType != null && _logger != null)
+		    {
+                switch (_logType)
+                {
+                    case LogType.Debug:
+                        _logger.Debug(_loggerType, () => _endMessage + " (took " + Stopwatch.ElapsedMilliseconds + "ms)");
+                        break;
+                    case LogType.Info:
+                        _logger.Info(_loggerType, () => _endMessage + " (took " + Stopwatch.ElapsedMilliseconds + "ms)");
+                        break;
+                    default:
+                        throw new ArgumentOutOfRangeException("logType");
+                }
+            }
+
+		    if (_callback != null)
+		    {
+                _callback.Invoke(Stopwatch.ElapsedMilliseconds);
+            }
+            
 		}
 
 	}

src/Umbraco.Core/Dynamics/CaseInsensitiveDynamicObject.cs

@@ -0,0 +1,93 @@
+using System;
+using System.Collections.Generic;
+using System.Dynamic;
+using System.Linq;
+using System.Reflection;
+
+namespace Umbraco.Core.Dynamics
+{
+    /// <summary>
+    /// This will check enable dynamic access to properties and methods in a case insensitive manner
+    /// </summary>
+    /// <typeparam name="T"></typeparam>
+    /// <remarks>
+    /// This works by using reflection on the type - the reflection lookup is lazy so it will not execute unless a dynamic method needs to be accessed
+    /// </remarks>
+    public abstract class CaseInsensitiveDynamicObject<T> : DynamicObject
+        where T: class
+    {
+        /// <summary>
+        /// Used for dynamic access for case insensitive property access
+        /// </summary>`
+        private static readonly Lazy<IDictionary<string, Func<T, object>>> CaseInsensitivePropertyAccess = new Lazy<IDictionary<string, Func<T, object>>>(() =>
+        {
+            var props = typeof(T).GetProperties(BindingFlags.Instance | BindingFlags.Public)
+                .DistinctBy(x => x.Name);
+            return props.Select(propInfo =>
+            {
+                var name = propInfo.Name.ToLowerInvariant();
+                Func<T, object> getVal = propInfo.GetValue;
+                return new KeyValuePair<string, Func<T, object>>(name, getVal);
+
+            }).ToDictionary(x => x.Key, x => x.Value);
+        });
+
+        /// <summary>
+        /// Used for dynamic access for case insensitive property access
+        /// </summary>
+        private static readonly Lazy<IDictionary<string, Tuple<ParameterInfo[], Func<T, object[], object>>>> CaseInsensitiveMethodAccess
+            = new Lazy<IDictionary<string, Tuple<ParameterInfo[], Func<T, object[], object>>>>(() =>
+            {
+                var props = typeof(T).GetMethods(BindingFlags.Instance | BindingFlags.Public)
+                    .Where(x => x.IsSpecialName == false && x.IsVirtual == false)
+                    .DistinctBy(x => x.Name);
+                return props.Select(methodInfo =>
+                {
+                    var name = methodInfo.Name.ToLowerInvariant();
+                    Func<T, object[], object> getVal = methodInfo.Invoke;
+                    var val = new Tuple<ParameterInfo[], Func<T, object[], object>>(methodInfo.GetParameters(), getVal);
+                    return new KeyValuePair<string, Tuple<ParameterInfo[], Func<T, object[], object>>>(name, val);
+
+                }).ToDictionary(x => x.Key, x => x.Value);
+            });
+
+        public override bool TryInvokeMember(InvokeMemberBinder binder, object[] args, out object result)
+        {
+            var name = binder.Name.ToLowerInvariant();
+            if (CaseInsensitiveMethodAccess.Value.ContainsKey(name) == false)
+                return base.TryInvokeMember(binder, args, out result);
+
+            var val = CaseInsensitiveMethodAccess.Value[name];
+            var parameters = val.Item1;
+            var callback = val.Item2;
+            var fullArgs = new List<object>(args);
+            if (args.Length <= parameters.Length)
+            {
+                //need to fill them up if they're optional
+                for (var i = args.Length; i < parameters.Length; i++)
+                {
+                    if (parameters[i].IsOptional)
+                    {
+                        fullArgs.Add(parameters[i].DefaultValue);
+                    }
+                }
+                if (fullArgs.Count == parameters.Length)
+                {
+                    result = callback((T)(object)this, fullArgs.ToArray());
+                    return true;
+                }
+            }
+            return base.TryInvokeMember(binder, args, out result);
+        }
+
+        public override bool TryGetMember(GetMemberBinder binder, out object result)
+        {
+            var name = binder.Name.ToLowerInvariant();
+            if (CaseInsensitivePropertyAccess.Value.ContainsKey(name) == false)
+                return base.TryGetMember(binder, out result);
+
+            result = CaseInsensitivePropertyAccess.Value[name]((T)(object)this);
+            return true;
+        }
+    }
+}

src/Umbraco.Core/Dynamics/DynamicXmlConverter.cs

@@ -64,7 +64,7 @@ namespace Umbraco.Core.Dynamics
 	/// </summary>
 	public class DynamicXmlConverter : TypeConverter
 	{
-		public override bool CanConvertTo(ITypeDescriptorContext context, Type sourceType)
+		public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType)
 		{
 			var convertableTypes = new[]
 			    {
@@ -78,8 +78,8 @@ namespace Umbraco.Core.Dynamics
                     typeof(RawXmlDocument)
 			    };
 
-			return convertableTypes.Any(x => TypeHelper.IsTypeAssignableFrom(x, sourceType)) 
-			       || base.CanConvertFrom(context, sourceType);
+			return convertableTypes.Any(x => TypeHelper.IsTypeAssignableFrom(x, destinationType)) 
+			       || base.CanConvertFrom(context, destinationType);
 		}
 
 		public override object ConvertTo(

src/Umbraco.Core/Dynamics/ExtensionMethodFinder.cs

@@ -5,8 +5,10 @@ using System.Linq;
 using System.Reflection;
 using System.Runtime.CompilerServices;
 using System.Linq.Expressions;
+using System.Text;
 using System.Web.Services.Description;
 using Umbraco.Core.Cache;
+using Umbraco.Core.Logging;
 
 namespace Umbraco.Core.Dynamics
 {
@@ -20,6 +22,20 @@ namespace Umbraco.Core.Dynamics
         /// </summary>
         private static readonly ConcurrentDictionary<Tuple<Type, string, int>, MethodInfo[]> MethodCache = new ConcurrentDictionary<Tuple<Type, string, int>, MethodInfo[]>();
 
+	    private static IEnumerable<Type> GetTypes(Assembly a)
+	    {
+	        try
+	        {
+	            return TypeFinder.GetTypesWithFormattedException(a);
+	        }
+	        catch (ReflectionTypeLoadException ex)
+	        {
+                // is this going to flood the log?
+                LogHelper.Error(typeof (ExtensionMethodFinder), "Failed to get types.", ex);
+                return Enumerable.Empty<Type>();
+	        }
+        }
+
         /// <summary>
         /// Returns the enumerable of all extension method info's in the app domain = USE SPARINGLY!!!
         /// </summary>
@@ -36,7 +52,7 @@ namespace Umbraco.Core.Dynamics
                 // assemblies that contain extension methods
                 .Where(a => a.IsDefined(typeof (ExtensionAttribute), false))
                 // types that contain extension methods
-                .SelectMany(a => a.GetTypes()
+                .SelectMany(a => GetTypes(a)
                     .Where(t => t.IsDefined(typeof (ExtensionAttribute), false) && t.IsSealed && t.IsGenericType == false && t.IsNested == false))
                 // actual extension methods
                 .SelectMany(t => t.GetMethods(BindingFlags.Static | BindingFlags.Public)
@@ -45,9 +61,9 @@ namespace Umbraco.Core.Dynamics
                 .Concat(typeof (Enumerable).GetMethods(BindingFlags.Static | BindingFlags.Public))
                 //If we don't do this then we'll be scanning all assemblies each time!
                 .ToArray(),
-                
+
                 //only cache for 5 minutes
-                timeout: TimeSpan.FromMinutes(5), 
+                timeout: TimeSpan.FromMinutes(5),
 
                 //each time this is accessed it will be for 5 minutes longer
                 isSliding:true);
@@ -57,7 +73,7 @@ namespace Umbraco.Core.Dynamics
 	    /// Returns all extension methods found matching the definition
 	    /// </summary>
 	    /// <param name="runtimeCache">
-	    /// The runtime cache is used to temporarily cache all extension methods found in the app domain so that 
+	    /// The runtime cache is used to temporarily cache all extension methods found in the app domain so that
 	    /// while we search for individual extension methods, the process will be reasonably 'quick'. We then statically
 	    /// cache the MethodInfo's that we are looking for and then the runtime cache will expire and give back all that memory.
 	    /// </param>
@@ -78,7 +94,7 @@ namespace Umbraco.Core.Dynamics
 		    {
                 var candidates = GetAllExtensionMethodsInAppDomain(runtimeCache);
 
-                // filter by name	
+                // filter by name
                 var filtr1 = candidates.Where(m => m.Name == name);
 
                 // filter by args count
@@ -102,7 +118,7 @@ namespace Umbraco.Core.Dynamics
 
 		        return filtr3.ToArray();
 		    });
-		    
+
         }
 
         private static MethodInfo DetermineMethodFromParams(IEnumerable<MethodInfo> methods, Type genericType, IEnumerable<object> args)
@@ -123,12 +139,12 @@ namespace Umbraco.Core.Dynamics
                 types = method.GetParameters().Select(pi => pi.ParameterType).Skip(1)
             });
 
-            //This type comparer will check 
+            //This type comparer will check
             var typeComparer = new DelegateEqualityComparer<Type>(
-                //Checks if the argument type passed in can be assigned from the parameter type in the method. For 
+                //Checks if the argument type passed in can be assigned from the parameter type in the method. For
                 // example, if the argument type is HtmlHelper<MyModel> but the method parameter type is HtmlHelper then
                 // it will match because the argument is assignable to that parameter type and will be able to execute
-                TypeHelper.IsTypeAssignableFrom, 
+                TypeHelper.IsTypeAssignableFrom,
                 //This will not ever execute but if it does we need to get the hash code of the string because the hash
                 // code of a type is random
                 type => type.FullName.GetHashCode());
@@ -159,7 +175,7 @@ namespace Umbraco.Core.Dynamics
                 .ToArray();
 
             var methods = GetAllExtensionMethods(runtimeCache, thisType, name, args.Length).ToArray();
-            
+
             return DetermineMethodFromParams(methods, genericType, args);
         }
     }

src/Umbraco.Core/Events/CancellableEventArgs.cs

@@ -1,5 +1,8 @@
 using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
 using System.Security.Permissions;
+using Umbraco.Core.Models.PublishedContent;
 
 namespace Umbraco.Core.Events
 {
@@ -11,11 +14,19 @@ namespace Umbraco.Core.Events
 	{
 		private bool _cancel;
 
+        public CancellableEventArgs(bool canCancel, EventMessages messages, IDictionary<string, object> additionalData)
+        {
+            CanCancel = canCancel;
+            Messages = messages;
+            AdditionalData = new ReadOnlyDictionary<string, object>(additionalData);
+        }
+
         public CancellableEventArgs(bool canCancel, EventMessages eventMessages)
         {
             if (eventMessages == null) throw new ArgumentNullException("eventMessages");
             CanCancel = canCancel;
             Messages = eventMessages;
+            AdditionalData = new ReadOnlyDictionary<string, object>(new Dictionary<string, object>());
         }
 
         public CancellableEventArgs(bool canCancel)
@@ -23,6 +34,7 @@ namespace Umbraco.Core.Events
 			CanCancel = canCancel;
             //create a standalone messages
             Messages = new EventMessages();
+            AdditionalData = new ReadOnlyDictionary<string, object>(new Dictionary<string, object>());
         }
 
         public CancellableEventArgs(EventMessages eventMessages)
@@ -78,5 +90,14 @@ namespace Umbraco.Core.Events
         /// Returns the EventMessages object which is used to add messages to the message collection for this event
         /// </summary>
         public EventMessages Messages { get; private set; }
+
+        /// <summary>
+        /// In some cases raised evens might need to contain additional arbitrary readonly data which can be read by event subscribers
+        /// </summary>
+        /// <remarks>
+        /// This allows for a bit of flexibility in our event raising - it's not pretty but we need to maintain backwards compatibility 
+        /// so we cannot change the strongly typed nature for some events.
+        /// </remarks>
+        public ReadOnlyDictionary<string, object> AdditionalData { get; private set; } 
     }
 }

src/Umbraco.Core/Events/CancellableObjectEventArgs.cs

@@ -1,3 +1,4 @@
+using System.Collections.Generic;
 using System.Security.Permissions;
 using Umbraco.Core.Models;
 using Umbraco.Core.Models.EntityBase;
@@ -11,8 +12,13 @@ namespace Umbraco.Core.Events
 	[HostProtection(SecurityAction.LinkDemand, SharedState = true)]
 	public class CancellableObjectEventArgs<T> : CancellableEventArgs
 	{
+	    public CancellableObjectEventArgs(T eventObject, bool canCancel, EventMessages messages, IDictionary<string, object> additionalData)
+            : base(canCancel, messages, additionalData)
+	    {
+            EventObject = eventObject;
+        }
 
-        public CancellableObjectEventArgs(T eventObject, bool canCancel, EventMessages eventMessages)
+	    public CancellableObjectEventArgs(T eventObject, bool canCancel, EventMessages eventMessages)
             : base(canCancel, eventMessages)
         {
             EventObject = eventObject;

src/Umbraco.Core/Events/EventExtensions.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 using System.Linq;
 
 namespace Umbraco.Core.Events

src/Umbraco.Core/Events/MigrationEventArgs.cs

@@ -2,6 +2,7 @@
 using System.Collections.Generic;
 using System.ComponentModel;
 using Semver;
+using Umbraco.Core.Configuration;
 using Umbraco.Core.Persistence.Migrations;
 
 namespace Umbraco.Core.Events
@@ -13,23 +14,49 @@ namespace Umbraco.Core.Events
         /// </summary>
         /// <param name="eventObject"></param>
         /// <param name="targetVersion"></param>
+        /// <param name="productName"></param>
         /// <param name="canCancel"></param>
         /// <param name="configuredVersion"></param>
-        public MigrationEventArgs(IList<IMigration> eventObject, SemVersion configuredVersion, SemVersion targetVersion, bool canCancel)
-            : base(eventObject, canCancel)
-        {
-            ConfiguredSemVersion = configuredVersion;
-            TargetSemVersion = targetVersion;
-        }
+        public MigrationEventArgs(IList<IMigration> eventObject, SemVersion configuredVersion, SemVersion targetVersion, string productName, bool canCancel)
+            : this(eventObject, null, configuredVersion, targetVersion, productName, canCancel)
+        { }
 
-        [Obsolete("Use constructor accepting UmbracoVersion instances instead")]
+        /// <summary>
+        /// Constructor accepting multiple migrations that are used in the migration runner
+        /// </summary>
+        /// <param name="eventObject"></param>
+        /// <param name="targetVersion"></param>
+        /// <param name="canCancel"></param>
+        /// <param name="configuredVersion"></param>
+        [Obsolete("Use constructor accepting a product name instead.")]
+        [EditorBrowsable(EditorBrowsableState.Never)]
+        public MigrationEventArgs(IList<IMigration> eventObject, SemVersion configuredVersion, SemVersion targetVersion, bool canCancel)
+            : this(eventObject, null, configuredVersion, targetVersion, GlobalSettings.UmbracoMigrationName, canCancel)
+        { }
+
+        [Obsolete("Use constructor accepting SemVersion instances and a product name instead.")]
         [EditorBrowsable(EditorBrowsableState.Never)]
         public MigrationEventArgs(IList<IMigration> eventObject, Version configuredVersion, Version targetVersion, bool canCancel)
-			: base(eventObject, canCancel)
-         {
-             ConfiguredSemVersion = new SemVersion(configuredVersion);
-             TargetSemVersion = new SemVersion(targetVersion);
-         }
+			: this(eventObject, null, new SemVersion(configuredVersion), new SemVersion(targetVersion), GlobalSettings.UmbracoMigrationName, canCancel)
+         { }
+
+        /// <summary>
+        /// Constructor accepting multiple migrations that are used in the migration runner
+        /// </summary>
+        /// <param name="eventObject"></param>
+        /// <param name="migrationContext"></param>
+        /// <param name="targetVersion"></param>
+        /// <param name="productName"></param>
+        /// <param name="canCancel"></param>
+        /// <param name="configuredVersion"></param>
+        internal MigrationEventArgs(IList<IMigration> eventObject, MigrationContext migrationContext, SemVersion configuredVersion, SemVersion targetVersion, string productName, bool canCancel)
+            : base(eventObject, canCancel)
+        {
+            MigrationContext = migrationContext;
+            ConfiguredSemVersion = configuredVersion;
+            TargetSemVersion = targetVersion;
+            ProductName = productName;
+        }
 
         /// <summary>
         /// Constructor accepting multiple migrations that are used in the migration runner
@@ -39,12 +66,15 @@ namespace Umbraco.Core.Events
         /// <param name="targetVersion"></param>
         /// <param name="canCancel"></param>
         /// <param name="configuredVersion"></param>
+        [Obsolete("Use constructor accepting a product name instead.")]
+        [EditorBrowsable(EditorBrowsableState.Never)]
         internal MigrationEventArgs(IList<IMigration> eventObject, MigrationContext migrationContext, SemVersion configuredVersion, SemVersion targetVersion, bool canCancel)
             : base(eventObject, canCancel)
         {
             MigrationContext = migrationContext;
             ConfiguredSemVersion = configuredVersion;
             TargetSemVersion = targetVersion;
+            ProductName = GlobalSettings.UmbracoMigrationName;
         }
 
         /// <summary>
@@ -53,21 +83,28 @@ namespace Umbraco.Core.Events
         /// <param name="eventObject"></param>
         /// <param name="configuredVersion"></param>
         /// <param name="targetVersion"></param>
-        public MigrationEventArgs(IList<IMigration> eventObject, SemVersion configuredVersion, SemVersion targetVersion)
-            : base(eventObject)
-        {
-            ConfiguredSemVersion = configuredVersion;
-            TargetSemVersion = targetVersion;
-        }
+        /// <param name="productName"></param>
+        public MigrationEventArgs(IList<IMigration> eventObject, SemVersion configuredVersion, SemVersion targetVersion, string productName)
+            : this(eventObject, null, configuredVersion, targetVersion, productName, false)
+        { }
 
-        [Obsolete("Use constructor accepting UmbracoVersion instances instead")]
+        /// <summary>
+        /// Constructor accepting multiple migrations that are used in the migration runner
+        /// </summary>
+        /// <param name="eventObject"></param>
+        /// <param name="configuredVersion"></param>
+        /// <param name="targetVersion"></param>
+        [Obsolete("Use constructor accepting a product name instead.")]
+        [EditorBrowsable(EditorBrowsableState.Never)]
+        public MigrationEventArgs(IList<IMigration> eventObject, SemVersion configuredVersion, SemVersion targetVersion)
+            : this(eventObject, null, configuredVersion, targetVersion, GlobalSettings.UmbracoMigrationName, false)
+        { }
+
+        [Obsolete("Use constructor accepting SemVersion instances and a product name instead.")]
         [EditorBrowsable(EditorBrowsableState.Never)]
         public MigrationEventArgs(IList<IMigration> eventObject, Version configuredVersion, Version targetVersion)
-			: base(eventObject)
-		{
-            ConfiguredSemVersion = new SemVersion(configuredVersion);
-            TargetSemVersion = new SemVersion(targetVersion);
-		}
+			: this(eventObject, null, new SemVersion(configuredVersion), new SemVersion(targetVersion), GlobalSettings.UmbracoMigrationName, false)
+		{ }
 
 		/// <summary>
 		/// Returns all migrations that were used in the migration runner
@@ -95,6 +132,8 @@ namespace Umbraco.Core.Events
 
         public SemVersion TargetSemVersion { get; private set; }
 
+        public string ProductName { get; private set; }
+
         internal MigrationContext MigrationContext { get; private set; }
     }
 }

src/Umbraco.Core/Events/SaveEventArgs.cs

@@ -4,6 +4,18 @@ namespace Umbraco.Core.Events
 {
 	public class SaveEventArgs<TEntity> : CancellableObjectEventArgs<IEnumerable<TEntity>>
 	{
+        /// <summary>
+        /// Constructor accepting multiple entities that are used in the saving operation
+        /// </summary>
+        /// <param name="eventObject"></param>
+        /// <param name="canCancel"></param>
+        /// <param name="messages"></param>
+        /// <param name="additionalData"></param>
+	    public SaveEventArgs(IEnumerable<TEntity> eventObject, bool canCancel, EventMessages messages, IDictionary<string, object> additionalData) 
+            : base(eventObject, canCancel, messages, additionalData)
+	    {
+	    }
+
 	    /// <summary>
 	    /// Constructor accepting multiple entities that are used in the saving operation
 	    /// </summary>
@@ -25,12 +37,24 @@ namespace Umbraco.Core.Events
         {
         }
 
-	    /// <summary>
-	    /// Constructor accepting a single entity instance
-	    /// </summary>
-	    /// <param name="eventObject"></param>
-	    /// <param name="eventMessages"></param>
-	    public SaveEventArgs(TEntity eventObject, EventMessages eventMessages)
+        /// <summary>
+        /// Constructor accepting a single entity instance
+        /// </summary>
+        /// <param name="eventObject"></param>
+        /// <param name="canCancel"></param>
+        /// <param name="messages"></param>
+        /// <param name="additionalData"></param>
+        public SaveEventArgs(TEntity eventObject, bool canCancel, EventMessages messages, IDictionary<string, object> additionalData)
+            : base(new List<TEntity> { eventObject }, canCancel, messages, additionalData)
+        {
+        }
+
+        /// <summary>
+        /// Constructor accepting a single entity instance
+        /// </summary>
+        /// <param name="eventObject"></param>
+        /// <param name="eventMessages"></param>
+        public SaveEventArgs(TEntity eventObject, EventMessages eventMessages)
             : base(new List<TEntity> { eventObject }, eventMessages)
         {
         }

src/Umbraco.Core/IO/ViewHelper.cs

@@ -7,7 +7,7 @@ using Umbraco.Core.Models;
 
 namespace Umbraco.Core.IO
 {
-    internal class ViewHelper
+    public class ViewHelper
     {
         private readonly IFileSystem _viewFileSystem;
 
@@ -66,21 +66,58 @@ namespace Umbraco.Core.IO
             return viewContent;
         }
 
-        internal static string GetDefaultFileContent(string layoutPageAlias = null, string modelClassName = null)
+        public static string GetDefaultFileContent(string layoutPageAlias = null, string modelClassName = null, string modelNamespace = null, string modelNamespaceAlias = null)
         {
-            var design = @"@inherits Umbraco.Web.Mvc.UmbracoTemplatePage
-@{
-    Layout = null;
-}";
+            var content = new StringBuilder();
 
-            if (layoutPageAlias.IsNullOrWhiteSpace() == false)
-                design = design.Replace("null", string.Format("\"{0}.cshtml\"", layoutPageAlias));
+            if (string.IsNullOrWhiteSpace(modelNamespaceAlias))
+                modelNamespaceAlias = "ContentModels";
 
+            // either
+            // @inherits Umbraco.Web.Mvc.UmbracoTemplatePage
+            // @inherits Umbraco.Web.Mvc.UmbracoTemplatePage<ModelClass>
+            // @inherits Umbraco.Web.Mvc.UmbracoTemplatePage<ContentModels.ModelClass>
+            content.Append("@inherits Umbraco.Web.Mvc.UmbracoTemplatePage");
             if (modelClassName.IsNullOrWhiteSpace() == false)
-                design = design.Replace(".UmbracoTemplatePage", string.Format(".UmbracoTemplatePage<{0}>", modelClassName));
+            {
+                content.Append("<");
+                if (modelNamespace.IsNullOrWhiteSpace() == false)
+                {
+                    content.Append(modelNamespaceAlias);
+                    content.Append(".");
+                }
+                content.Append(modelClassName);
+                content.Append(">");
+            }
+            content.Append("\r\n");
 
+            // if required, add
+            // @using ContentModels = ModelNamespace;
+            if (modelClassName.IsNullOrWhiteSpace() == false && modelNamespace.IsNullOrWhiteSpace() == false)
+            {
+                content.Append("@using ");
+                content.Append(modelNamespaceAlias);
+                content.Append(" = ");
+                content.Append(modelNamespace);
+                content.Append(";\r\n");
+            }
 
-            return design;
+            // either
+            // Layout = null;
+            // Layout = "layoutPage.cshtml";
+            content.Append("@{\r\n\tLayout = ");
+            if (layoutPageAlias.IsNullOrWhiteSpace())
+            {
+                content.Append("null");
+            }
+            else
+            {
+                content.Append("\"");
+                content.Append(layoutPageAlias);
+                content.Append(".cshtml\"");
+            }
+            content.Append(";\r\n}");
+            return content.ToString();
         }
 
         private string SaveTemplateToFile(ITemplate template)

src/Umbraco.Core/Models/Content.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections;
 using System.Collections.Generic;
+using System.ComponentModel;
 using System.Linq;
 using System.Reflection;
 using System.Runtime.Serialization;
@@ -155,6 +156,7 @@ namespace Umbraco.Core.Models
         /// Language of the data contained within this Content object.
         /// </summary>
         [Obsolete("This is not used and will be removed from the codebase in future versions")]
+        [EditorBrowsable(EditorBrowsableState.Never)]
         public string Language
         {
             get { return _language; }

src/Umbraco.Core/Models/ContentBase.cs

@@ -367,8 +367,27 @@ namespace Umbraco.Core.Models
         /// <param name="value">Value to set for the Property</param>
         public virtual void SetPropertyValue(string propertyTypeAlias, long value)
         {
-            string val = value.ToString();
-            SetValueOnProperty(propertyTypeAlias, val);
+            SetValueOnProperty(propertyTypeAlias, value);
+        }
+
+        /// <summary>
+        /// Sets the <see cref="System.Decimal"/> value of a Property
+        /// </summary>
+        /// <param name="propertyTypeAlias">Alias of the PropertyType</param>
+        /// <param name="value">Value to set for the Property</param>
+        public virtual void SetPropertyValue(string propertyTypeAlias, decimal value)
+        {
+            SetValueOnProperty(propertyTypeAlias, value);
+        }
+
+        /// <summary>
+        /// Sets the <see cref="System.Double"/> value of a Property
+        /// </summary>
+        /// <param name="propertyTypeAlias">Alias of the PropertyType</param>
+        /// <param name="value">Value to set for the Property</param>
+        public virtual void SetPropertyValue(string propertyTypeAlias, double value)
+        {
+            SetValueOnProperty(propertyTypeAlias, value);
         }
 
         /// <summary>

src/Umbraco.Core/Models/ContentType.cs

@@ -53,6 +53,9 @@ namespace Umbraco.Core.Models
 
         /// <summary>
         /// Gets or sets the alias of the default Template.
+        /// TODO: This should be ignored from cloning!!!!!!!!!!!!!!
+        ///  - but to do that we have to implement callback hacks, this needs to be fixed in v8, 
+        ///     we should not store direct entity
         /// </summary>
         [IgnoreDataMember]
         public ITemplate DefaultTemplate
@@ -79,6 +82,9 @@ namespace Umbraco.Core.Models
 
         /// <summary>
         /// Gets or Sets a list of Templates which are allowed for the ContentType
+        /// TODO: This should be ignored from cloning!!!!!!!!!!!!!!
+        ///  - but to do that we have to implement callback hacks, this needs to be fixed in v8, 
+        ///     we should not store direct entity
         /// </summary>
         [DataMember]
         public IEnumerable<ITemplate> AllowedTemplates

src/Umbraco.Core/Models/ContentTypeBase.cs

@@ -487,11 +487,8 @@ namespace Umbraco.Core.Models
             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(); // PropertyGroupId must not be dirty
+            // set new group
+            propertyType.PropertyGroupId = newPropertyGroup == null ? null : new Lazy<int>(() => newPropertyGroup.Id, false);
 
             // remove from old group, if any - add to new group, if any
             if (oldPropertyGroup != null)
@@ -540,7 +537,7 @@ namespace Umbraco.Core.Models
             // re-assign the group's properties to no group
             foreach (var property in group.PropertyTypes)
             {
-                property.PropertyGroupId = new Lazy<int>(() => 0);
+                property.PropertyGroupId = null;
                 _propertyTypes.Add(property);
             }
 

src/Umbraco.Core/Models/DataTypeDatabaseType.cs

@@ -6,10 +6,6 @@ namespace Umbraco.Core.Models
     /// <summary>
     /// Enum of the various DbTypes for which the Property values are stored
     /// </summary>
-    /// <remarks>
-    /// Object is added to support complex values from PropertyEditors, 
-    /// but will be saved under the Ntext column.
-    /// </remarks>
     [Serializable]
     [DataContract]
     public enum DataTypeDatabaseType

src/Umbraco.Core/Models/DeepCloneHelper.cs

@@ -9,10 +9,30 @@ namespace Umbraco.Core.Models
 {
     public static class DeepCloneHelper
     {
+        /// <summary>
+        /// Stores the metadata for the properties for a given type so we know how to create them
+        /// </summary>
+        private struct ClonePropertyInfo
+        {
+            public ClonePropertyInfo(PropertyInfo propertyInfo) : this()
+            {
+                if (propertyInfo == null) throw new ArgumentNullException("propertyInfo");
+                PropertyInfo = propertyInfo;
+            }
+
+            public PropertyInfo PropertyInfo { get; private set; }
+            public bool IsDeepCloneable { get; set; }
+            public Type GenericListType { get; set; }           
+            public bool IsList
+            {
+                get { return GenericListType != null; }
+            }
+        }
+
         /// <summary>
         /// Used to avoid constant reflection (perf)
         /// </summary>
-        private static readonly ConcurrentDictionary<Type, PropertyInfo[]> PropCache = new ConcurrentDictionary<Type, PropertyInfo[]>(); 
+        private static readonly ConcurrentDictionary<Type, ClonePropertyInfo[]> PropCache = new ConcurrentDictionary<Type, ClonePropertyInfo[]>();
 
         /// <summary>
         /// Used to deep clone any reference properties on the object (should be done after a MemberwiseClone for which the outcome is 'output')
@@ -30,81 +50,99 @@ namespace Umbraco.Core.Models
                 throw new InvalidOperationException("Both the input and output types must be the same");
             }
 
+            //get the property metadata from cache so we only have to figure this out once per type
             var refProperties = PropCache.GetOrAdd(inputType, type =>
                 inputType.GetProperties()
-                    .Where(x =>
-                        //is not attributed with the ignore clone attribute
-                        x.GetCustomAttribute<DoNotCloneAttribute>() == null
+                    .Select<PropertyInfo, ClonePropertyInfo?>(propertyInfo =>
+                    {
+                        if (
+                            //is not attributed with the ignore clone attribute
+                            propertyInfo.GetCustomAttribute<DoNotCloneAttribute>() != null
                             //reference type but not string
-                        && x.PropertyType.IsValueType == false && x.PropertyType != typeof (string)
+                            || propertyInfo.PropertyType.IsValueType || propertyInfo.PropertyType == typeof (string)
                             //settable
-                        && x.CanWrite
+                            || propertyInfo.CanWrite == false
                             //non-indexed
-                        && x.GetIndexParameters().Any() == false)
+                            || propertyInfo.GetIndexParameters().Any())
+                        {
+                            return null;
+                        }
+                        
+
+                        if (TypeHelper.IsTypeAssignableFrom<IDeepCloneable>(propertyInfo.PropertyType))
+                        {
+                            return new ClonePropertyInfo(propertyInfo) { IsDeepCloneable = true };
+                        }
+
+                        if (TypeHelper.IsTypeAssignableFrom<IEnumerable>(propertyInfo.PropertyType)
+                            && TypeHelper.IsTypeAssignableFrom<string>(propertyInfo.PropertyType) == false)
+                        {
+                            if (propertyInfo.PropertyType.IsGenericType
+                                && (propertyInfo.PropertyType.GetGenericTypeDefinition() == typeof(IEnumerable<>)
+                                    || propertyInfo.PropertyType.GetGenericTypeDefinition() == typeof(ICollection<>)
+                                    || propertyInfo.PropertyType.GetGenericTypeDefinition() == typeof(IList<>)))
+                            {
+                                //if it is a IEnumerable<>, IList<T> or ICollection<> we'll use a List<>
+                                var genericType = typeof(List<>).MakeGenericType(propertyInfo.PropertyType.GetGenericArguments());
+                                return new ClonePropertyInfo(propertyInfo) { GenericListType = genericType };
+                            }
+                            if (propertyInfo.PropertyType.IsArray
+                                || (propertyInfo.PropertyType.IsInterface && propertyInfo.PropertyType.IsGenericType == false))
+                            {
+                                //if its an array, we'll create a list to work with first and then convert to array later
+                                //otherwise if its just a regular derivitave of IEnumerable, we can use a list too
+                                return new ClonePropertyInfo(propertyInfo) { GenericListType = typeof(List<object>) };
+                            }
+                            //skip instead of trying to create instance of abstract or interface
+                            if (propertyInfo.PropertyType.IsAbstract || propertyInfo.PropertyType.IsInterface)
+                            {
+                                return null;
+                            }
+
+                            //its a custom IEnumerable, we'll try to create it
+                            try
+                            {
+                                var custom = Activator.CreateInstance(propertyInfo.PropertyType);
+                                //if it's an IList we can work with it, otherwise we cannot
+                                var newList = custom as IList;
+                                if (newList == null)
+                                {
+                                    return null;
+                                }
+                                return new ClonePropertyInfo(propertyInfo) {GenericListType = propertyInfo.PropertyType};
+                            }
+                            catch (Exception)
+                            {
+                                //could not create this type so we'll skip it
+                                return null;
+                            }
+                        }
+                        return new ClonePropertyInfo(propertyInfo);
+                    })
+                    .Where(x => x.HasValue)
+                    .Select(x => x.Value)
                     .ToArray());
 
-            foreach (var propertyInfo in refProperties)
+            foreach (var clonePropertyInfo in refProperties)
             {
-                if (TypeHelper.IsTypeAssignableFrom<IDeepCloneable>(propertyInfo.PropertyType))
+                if (clonePropertyInfo.IsDeepCloneable)
                 {
                     //this ref property is also deep cloneable so clone it
-                    var result = (IDeepCloneable)propertyInfo.GetValue(input, null);
+                    var result = (IDeepCloneable)clonePropertyInfo.PropertyInfo.GetValue(input, null);
 
                     if (result != null)
                     {
                         //set the cloned value to the property
-                        propertyInfo.SetValue(output, result.DeepClone(), null);
+                        clonePropertyInfo.PropertyInfo.SetValue(output, result.DeepClone(), null);
                     }
                 }
-                else if (TypeHelper.IsTypeAssignableFrom<IEnumerable>(propertyInfo.PropertyType)
-                    && TypeHelper.IsTypeAssignableFrom<string>(propertyInfo.PropertyType) == false)
+                else if (clonePropertyInfo.IsList)
                 {
-                    IList newList;
-                    if (propertyInfo.PropertyType.IsGenericType
-                        && (propertyInfo.PropertyType.GetGenericTypeDefinition() == typeof(IEnumerable<>)
-                            || propertyInfo.PropertyType.GetGenericTypeDefinition() == typeof(ICollection<>)
-                            || propertyInfo.PropertyType.GetGenericTypeDefinition() == typeof(IList<>)))
-                    {
-                        //if it is a IEnumerable<>, IList<T> or ICollection<> we'll use a List<>
-                        var genericType = typeof(List<>).MakeGenericType(propertyInfo.PropertyType.GetGenericArguments());
-                        newList = (IList)Activator.CreateInstance(genericType);
-                    }
-                    else if (propertyInfo.PropertyType.IsArray
-                             || (propertyInfo.PropertyType.IsInterface && propertyInfo.PropertyType.IsGenericType == false))
-                    {
-                        //if its an array, we'll create a list to work with first and then convert to array later
-                        //otherwise if its just a regular derivitave of IEnumerable, we can use a list too
-                        newList = new List<object>();
-                    }
-                    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
-                        {
-                            var custom = Activator.CreateInstance(propertyInfo.PropertyType);
-                            //if it's an IList we can work with it, otherwise we cannot
-                            newList = custom as IList;
-                            if (newList == null)
-                            {
-                                continue;
-                            }
-                        }
-                        catch (Exception)
-                        {
-                            //could not create this type so we'll skip it
-                            continue;
-                        }
-                    }
-
-                    var enumerable = (IEnumerable)propertyInfo.GetValue(input, null);
+                    var enumerable = (IEnumerable)clonePropertyInfo.PropertyInfo.GetValue(input, null);
                     if (enumerable == null) continue;
 
+                    var newList = (IList)Activator.CreateInstance(clonePropertyInfo.GenericListType);
+
                     var isUsableType = true;
 
                     //now clone each item
@@ -136,21 +174,21 @@ namespace Umbraco.Core.Models
                         continue;
                     }
 
-                    if (propertyInfo.PropertyType.IsArray)
+                    if (clonePropertyInfo.PropertyInfo.PropertyType.IsArray)
                     {
                         //need to convert to array
-                        var arr = (object[])Activator.CreateInstance(propertyInfo.PropertyType, newList.Count);
+                        var arr = (object[])Activator.CreateInstance(clonePropertyInfo.PropertyInfo.PropertyType, newList.Count);
                         for (int i = 0; i < newList.Count; i++)
                         {
                             arr[i] = newList[i];
                         }
                         //set the cloned collection
-                        propertyInfo.SetValue(output, arr, null);
+                        clonePropertyInfo.PropertyInfo.SetValue(output, arr, null);
                     }
                     else
                     {
                         //set the cloned collection
-                        propertyInfo.SetValue(output, newList, null);
+                        clonePropertyInfo.PropertyInfo.SetValue(output, newList, null);
                     }
 
                 }

src/Umbraco.Core/Models/IContent.cs

@@ -1,4 +1,5 @@
 using System;
+using System.ComponentModel;
 using System.Diagnostics;
 using Umbraco.Core.Persistence.Mappers;
 
@@ -21,6 +22,7 @@ namespace Umbraco.Core.Models
         bool Published { get; }
 
         [Obsolete("This will be removed in future versions")]
+        [EditorBrowsable(EditorBrowsableState.Never)]
         string Language { get; set; }
 
         /// <summary>

src/Umbraco.Core/Models/IMediaType.cs

@@ -7,6 +7,12 @@ namespace Umbraco.Core.Models
     /// </summary
     public interface IMediaType : IContentTypeComposition
     {
-         
+
+        /// <summary>
+        /// Creates a deep clone of the current entity with its identity/alias and it's property identities reset
+        /// </summary>
+        /// <param name="newAlias"></param>
+        /// <returns></returns>
+        IMediaType DeepCloneWithResetIdentities(string newAlias);
     }
 }

src/Umbraco.Core/Models/IMigrationEntry.cs

@@ -1,5 +1,4 @@
-using System;
-using Semver;
+using Semver;
 using Umbraco.Core.Models.EntityBase;
 
 namespace Umbraco.Core.Models

src/Umbraco.Core/Models/MediaExtensions.cs

@@ -0,0 +1,81 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+using Umbraco.Core.Configuration.UmbracoSettings;
+using Umbraco.Core.Logging;
+using Umbraco.Core.PropertyEditors.ValueConverters;
+
+namespace Umbraco.Core.Models
+{
+    internal static class MediaExtensions
+    {
+        /// <summary>
+        /// Hack: we need to put this in a real place, this is currently just used to render the urls for a media item in the back office
+        /// </summary>
+        /// <returns></returns>
+        public static string GetUrl(this IMedia media, string propertyAlias, ILogger logger)
+        {
+            var propertyType = media.PropertyTypes.FirstOrDefault(x => x.Alias.InvariantEquals(propertyAlias));
+            if (propertyType != null)
+            {
+                var val = media.Properties[propertyType];
+                if (val != null)
+                {
+                    var jsonString = val.Value as string;
+                    if (jsonString != null)
+                    {
+                        if (propertyType.PropertyEditorAlias == Constants.PropertyEditors.ImageCropperAlias)
+                        {
+                            if (jsonString.DetectIsJson())
+                            {
+                                try
+                                {
+                                    var json = JsonConvert.DeserializeObject<JObject>(jsonString);
+                                    if (json["src"] != null)
+                                    {
+                                        return json["src"].Value<string>();
+                                    }
+                                }
+                                catch (Exception ex)
+                                {
+                                    logger.Error<ImageCropperValueConverter>("Could not parse the string " + jsonString + " to a json object", ex);
+                                    return string.Empty;
+                                }
+                            }
+                            else
+                            {
+                                return jsonString;
+                            }
+                        }
+                        else if (propertyType.PropertyEditorAlias == Constants.PropertyEditors.UploadFieldAlias)
+                        {
+                            return jsonString;
+                        }
+                        //hrm, without knowing what it is, just adding a string here might not be very nice
+                    }
+                }
+            }
+            return string.Empty;
+        }
+
+        /// <summary>
+        /// Hack: we need to put this in a real place, this is currently just used to render the urls for a media item in the back office
+        /// </summary>
+        /// <returns></returns>
+        public static string[] GetUrls(this IMedia media, IContentSection contentSection, ILogger logger)
+        {
+            var links = new List<string>();
+            var autoFillProperties = contentSection.ImageAutoFillProperties.ToArray();
+            if (autoFillProperties.Any())
+            {
+                links.AddRange(
+                    autoFillProperties
+                        .Select(field => media.GetUrl(field.Alias, logger))
+                        .Where(link => link.IsNullOrWhiteSpace() == false));
+            }
+            return links.ToArray();
+        }
+    }
+}

src/Umbraco.Core/Models/MediaType.cs

@@ -38,5 +38,30 @@ namespace Umbraco.Core.Models
             : base(parent, alias)
         {
         }
+
+        /// <summary>
+        /// Creates a deep clone of the current entity with its identity/alias and it's property identities reset
+        /// </summary>
+        /// <returns></returns>
+        public IMediaType DeepCloneWithResetIdentities(string alias)
+        {
+            var clone = (MediaType)DeepClone();
+            clone.Alias = alias;
+            clone.Key = Guid.Empty;
+            foreach (var propertyGroup in clone.PropertyGroups)
+            {
+                propertyGroup.ResetIdentity();
+                propertyGroup.ResetDirtyProperties(false);
+            }
+            foreach (var propertyType in clone.PropertyTypes)
+            {
+                propertyType.ResetIdentity();
+                propertyType.ResetDirtyProperties(false);
+            }
+
+            clone.ResetIdentity();
+            clone.ResetDirtyProperties(false);
+            return clone;
+        }
     }
 }

src/Umbraco.Core/Models/Property.cs

@@ -124,10 +124,54 @@ namespace Umbraco.Core.Models
                 bool typeValidation = _propertyType.IsPropertyTypeValid(value);
 
                 if (typeValidation == false)
-                    throw new Exception(
-                        string.Format(
-                            "Type validation failed. The value type: '{0}' does not match the DataType in PropertyType with alias: '{1}'",
-                            value == null ? "null" : value.GetType().Name, Alias));
+                {
+                    // Normally we'll throw an exception here.  However if the property is of a type that can have it's data field (dataInt, dataVarchar etc.)
+                    // changed, we might have a value of the now "wrong" type.  As of May 2016 Label is the only built-in property editor that supports this.
+                    // In that case we should try to parse the value and return null if that's not possible rather than throwing an exception.
+                    if (value != null && _propertyType.CanHaveDataValueTypeChanged())
+                    {
+                        var stringValue = value.ToString();
+                        switch (_propertyType.DataTypeDatabaseType)
+                        {
+                            case DataTypeDatabaseType.Nvarchar:
+                            case DataTypeDatabaseType.Ntext:
+                                value = stringValue;
+                                break;
+                            case DataTypeDatabaseType.Integer:
+                                int integerValue;
+                                if (int.TryParse(stringValue, out integerValue) == false)
+                                {
+                                    // Edge case, but if changed from decimal --> integer, the above tryparse will fail.  So we'll try going
+                                    // via decimal too to return the integer value rather than zero.
+                                    decimal decimalForIntegerValue;
+                                    if (decimal.TryParse(stringValue, out decimalForIntegerValue))
+                                    {
+                                        integerValue = (int)decimalForIntegerValue;
+                                    }
+                                }
+
+                                value = integerValue;
+                                break;
+                            case DataTypeDatabaseType.Decimal:
+                                decimal decimalValue;
+                                decimal.TryParse(stringValue, out decimalValue);
+                                value = decimalValue;
+                                break;
+                            case DataTypeDatabaseType.Date:
+                                DateTime dateValue;
+                                DateTime.TryParse(stringValue, out dateValue);
+                                value = dateValue;
+                                break;
+                        }
+                    }
+                    else
+                    {
+                        throw new Exception(
+                            string.Format(
+                                "Type validation failed. The value type: '{0}' does not match the DataType in PropertyType with alias: '{1}'",
+                                value == null ? "null" : value.GetType().Name, Alias));
+                    }
+                }
 
                 SetPropertyValueAndDetectChanges(o =>
                 {

src/Umbraco.Core/Models/PropertyType.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Diagnostics;
+using System.Linq;
 using System.Reflection;
 using System.Runtime.Serialization;
 using System.Text.RegularExpressions;
@@ -221,8 +222,9 @@ namespace Umbraco.Core.Models
         }
 
         /// <summary>
-        /// Gets or Sets the PropertyGroup's Id for which this PropertyType belongs
+        /// Gets or sets the identifier of the PropertyGroup this PropertyType belongs to.
         /// </summary>
+        /// <remarks>For generic properties, the value is <c>null</c>.</remarks>
         [DataMember]
         internal Lazy<int> PropertyGroupId
         {
@@ -424,6 +426,19 @@ namespace Umbraco.Core.Models
             return false;
         }
 
+        /// <summary>
+        /// Checks the underlying property editor prevalues to see if the one that allows changing of the database field
+        /// to which data is saved (dataInt, dataVarchar etc.) is included.  If so that means the field could be changed when the data
+        /// type is saved.
+        /// </summary>
+        /// <returns></returns>
+        internal bool CanHaveDataValueTypeChanged()
+        {
+            var propertyEditor = PropertyEditorResolver.Current.GetByAlias(_propertyEditorAlias);
+            return propertyEditor.PreValueEditor.Fields
+                .SingleOrDefault(x => x.Key == Constants.PropertyEditors.PreValueKeys.DataValueType) != null;
+        }
+
         /// <summary>
         /// Validates the Value from a Property according to the validation settings
         /// </summary>

src/Umbraco.Core/Models/PublishedContent/PublishedContentType.cs

@@ -1,9 +1,6 @@
 using System;
-using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Linq;
-using System.Web.Caching;
-using System.Web.UI;
 using Umbraco.Core.Cache;
 
 namespace Umbraco.Core.Models.PublishedContent
@@ -16,6 +13,7 @@ namespace Umbraco.Core.Models.PublishedContent
     public class PublishedContentType
     {
         private readonly PublishedPropertyType[] _propertyTypes;
+        private readonly HashSet<string> _compositionAliases;
 
         // fast alias-to-index xref containing both the raw alias and its lowercase version
         private readonly Dictionary<string, int> _indexes = new Dictionary<string, int>();
@@ -27,6 +25,7 @@ namespace Umbraco.Core.Models.PublishedContent
         {
             Id = contentType.Id;
             Alias = contentType.Alias;
+            _compositionAliases = new HashSet<string>(contentType.CompositionAliases(), StringComparer.InvariantCultureIgnoreCase);
             _propertyTypes = contentType.CompositionPropertyTypes
                 .Select(x => new PublishedPropertyType(this, x))
                 .ToArray();
@@ -34,10 +33,11 @@ namespace Umbraco.Core.Models.PublishedContent
         }
 
         // internal so it can be used for unit tests
-        internal PublishedContentType(int id, string alias, IEnumerable<PublishedPropertyType> propertyTypes)
+        internal PublishedContentType(int id, string alias, IEnumerable<string> compositionAliases, IEnumerable<PublishedPropertyType> propertyTypes)
         {
             Id = id;
             Alias = alias;
+            _compositionAliases = new HashSet<string>(compositionAliases, StringComparer.InvariantCultureIgnoreCase);
             _propertyTypes = propertyTypes.ToArray();
             foreach (var propertyType in _propertyTypes)
                 propertyType.ContentType = this;
@@ -45,8 +45,8 @@ namespace Umbraco.Core.Models.PublishedContent
         }
 
         // create detached content type - ie does not match anything in the DB
-        internal PublishedContentType(string alias, IEnumerable<PublishedPropertyType> propertyTypes)
-            : this (0, alias, propertyTypes)
+        internal PublishedContentType(string alias, IEnumerable<string> compositionAliases, IEnumerable<PublishedPropertyType> propertyTypes)
+            : this(0, alias, compositionAliases, propertyTypes)
         { }
 
         private void InitializeIndexes()
@@ -63,6 +63,7 @@ namespace Umbraco.Core.Models.PublishedContent
 
         public int Id { get; private set; }
         public string Alias { get; private set; }
+        public HashSet<string> CompositionAliases { get { return _compositionAliases; } }
 
         #endregion
 
@@ -113,10 +114,25 @@ namespace Umbraco.Core.Models.PublishedContent
         internal static void ClearContentType(int id)
         {
             Logging.LogHelper.Debug<PublishedContentType>("Clear content type w/id {0}.", () => id);
-            // requires a predicate because the key does not contain the ID
-            // faster than key strings comparisons anyway
+
+            // we don't support "get all" at the moment - so, cheating
+            var all = ApplicationContext.Current.ApplicationCache.StaticCache.GetCacheItemsByKeySearch<PublishedContentType>("PublishedContentType_").ToArray();
+
+            // the one we want to clear
+            var clr = all.FirstOrDefault(x => x.Id == id);
+            if (clr == null) return;
+
+            // those that have that one in their composition aliases
+            // note: CompositionAliases contains all recursive aliases
+            var oth = all.Where(x => x.CompositionAliases.InvariantContains(clr.Alias)).Select(x => x.Id);
+
+            // merge ids
+            var ids = oth.Concat(new[] { clr.Id }).ToArray();
+
+            // clear them all at once
+            // we don't support "clear many at once" at the moment - so, cheating
             ApplicationContext.Current.ApplicationCache.StaticCache.ClearCacheObjectTypes<PublishedContentType>(
-                (key, value) => value.Id == id);
+                (key, value) => ids.Contains(value.Id));
         }
 
         internal static void ClearDataType(int id)

src/Umbraco.Core/Models/PublishedContent/PublishedPropertyType.cs

@@ -164,6 +164,9 @@ namespace Umbraco.Core.Models.PublishedContent
 
         private void InitializeConverters()
         {
+            //TODO: Look at optimizing this method, it gets run for every property type for the document being rendered at startup,
+            // every precious second counts!
+
             var converters = PropertyValueConvertersResolver.Current.Converters.ToArray();            
             var defaultConvertersWithAttributes = PropertyValueConvertersResolver.Current.DefaultConverters;
 
@@ -230,13 +233,13 @@ namespace Umbraco.Core.Models.PublishedContent
             {
                 _sourceCacheLevel = converterMeta.GetPropertyCacheLevel(this, PropertyCacheValue.Source);
                 _objectCacheLevel = converterMeta.GetPropertyCacheLevel(this, PropertyCacheValue.Object);
-                _objectCacheLevel = converterMeta.GetPropertyCacheLevel(this, PropertyCacheValue.XPath);
+                _xpathCacheLevel = converterMeta.GetPropertyCacheLevel(this, PropertyCacheValue.XPath);
             }
             else
             {
                 _sourceCacheLevel = GetCacheLevel(_converter, PropertyCacheValue.Source);
                 _objectCacheLevel = GetCacheLevel(_converter, PropertyCacheValue.Object);
-                _objectCacheLevel = GetCacheLevel(_converter, PropertyCacheValue.XPath);
+                _xpathCacheLevel = GetCacheLevel(_converter, PropertyCacheValue.XPath);
             }
             if (_objectCacheLevel < _sourceCacheLevel) _objectCacheLevel = _sourceCacheLevel;
             if (_xpathCacheLevel < _sourceCacheLevel) _xpathCacheLevel = _sourceCacheLevel;

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

@@ -1,4 +1,5 @@
-using Umbraco.Core.Persistence;
+using System;
+using Umbraco.Core.Persistence;
 
 namespace Umbraco.Core.Models.Rdbms
 {
@@ -18,5 +19,8 @@ namespace Umbraco.Core.Models.Rdbms
 
         [Column("contenttypeNodeId")]
         public int ContentTypeNodeId { get; set; }
+
+        [Column("PropertyGroupUniqueID")]
+        public Guid UniqueId { get; set; }
     }
 }

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

@@ -51,5 +51,8 @@ namespace Umbraco.Core.Models.Rdbms
 
         [Column("dbType")]
         public string DbType { get; set; }
+
+        [Column("UniqueID")]        
+        public Guid UniqueId { get; set; }
     }
 }

src/Umbraco.Core/Packaging/PackageMigrationsContext.cs

@@ -0,0 +1,114 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Linq;
+using Semver;
+using Umbraco.Core.Configuration;
+using Umbraco.Core.Logging;
+using Umbraco.Core.Persistence.Migrations;
+using Umbraco.Core.Services;
+
+namespace Umbraco.Core.Packaging
+{
+    internal class PackageMigrationsContext
+    {
+        private readonly DatabaseContext _dbContext;
+        private readonly IMigrationEntryService _migrationEntryService;
+        private readonly ILogger _logger;
+
+        public PackageMigrationsContext(DatabaseContext dbContext, 
+            IMigrationEntryService migrationEntryService, 
+            ILogger logger)
+        {
+            _dbContext = dbContext;
+            _migrationEntryService = migrationEntryService;
+            _logger = logger;
+            ResetPendingPackageMigrations();
+        }
+
+        //List of product names and their maximum sem version registered in migrations
+        private Lazy<ReadOnlyDictionary<string, SemVersion>> _packageVersionsConfigured;
+
+        /// <summary>
+        /// Called to initialize or when package migrations have executed - since an app restart is mandatory
+        /// </summary>
+        internal void ResetPendingPackageMigrations()
+        {
+            _packageVersionsConfigured = new Lazy<ReadOnlyDictionary<string, SemVersion>>(() =>
+            {
+                var result = new Dictionary<string, SemVersion>();
+
+                //The versions are the same in config, but are they the same in the database. We can only check this
+                // if we have a db context available, if we don't then we are not installed anyways
+                if (_dbContext.IsDatabaseConfigured && _dbContext.CanConnect)
+                {
+                    //Now we can check if there are any package migrations that haven't been executed.
+
+                    //Find and group the packages that have migrations.
+                    //Then we need to determine if there are outstanding migrations that need to be run based on the
+                    // migration versions stored in the db compared to the available migrations.
+                    var packageMigrations = MigrationResolver.Current.MigrationMetaData
+                        .Where(x => x.ProductName != GlobalSettings.UmbracoMigrationName)
+                        .GroupBy(x => x.ProductName)
+                        .ToArray();
+
+                    var packageMigrationProductNames = packageMigrations.Select(x => x.Key).Distinct().ToArray();
+
+                    var allPackageDbEntries = _migrationEntryService.FindEntries(packageMigrationProductNames)
+                        .ToArray();
+
+                    foreach (var packageMigration in packageMigrations)
+                    {
+                        var packageDbVersions = allPackageDbEntries
+                            .Where(x => x.MigrationName.InvariantEquals(packageMigration.Key))
+                            .Select(x => x.Version);
+
+                        var notExecuted = packageMigration
+                            .Select(x => x.TargetVersion.GetSemanticVersion())
+                            .Except(packageDbVersions)
+                            .ToArray();
+
+                        if (notExecuted.Any())
+                        {
+                            var maxVersion = notExecuted.Max();
+                            result.Add(packageMigration.Key, maxVersion);
+
+                            _logger.Debug<ApplicationContext>(
+                                    string.Format("The migration {0} for version: '{1} has not been executed, there is no record in the database",
+                                    packageMigration.Key,
+                                    maxVersion.ToSemanticString()));
+                        }
+                    }
+                }
+
+                return new ReadOnlyDictionary<string, SemVersion>(result);
+            });
+        }
+
+        /// <summary>
+        /// Returns true if there are pending package migrations that need to be executed
+        /// </summary>
+        internal bool HasPendingPackageMigrations
+        {
+            get { return _packageVersionsConfigured.Value.Any(); }
+        }
+
+        /// <summary>
+        /// Returns the list of package migration names that need to be executed
+        /// </summary>
+        internal ReadOnlyDictionary<string, SemVersion> GetPendingPackageMigrations()
+        {
+            return _packageVersionsConfigured.Value;
+        }
+
+        /// <summary>
+        /// Returns the list of package migration names and versions that need to be executed
+        /// with the following format: PackageProductName (2.0.0)
+        /// </summary>
+        /// <returns></returns>
+        internal IEnumerable<string> GetPendingPackageMigrationFriendlyNames()
+        {
+            return _packageVersionsConfigured.Value.Select(x => string.Format("{0} ({1})", x.Key, x.Value));
+        }
+    }
+}

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

@@ -75,6 +75,7 @@ namespace Umbraco.Core.Persistence.Factories
                     group.Id = groupDto.Id.Value;
                 }
 
+                group.Key = groupDto.UniqueId;
                 group.Name = groupDto.Text;
                 group.SortOrder = groupDto.SortOrder;
                 group.PropertyTypes = new PropertyTypeCollection();
@@ -114,7 +115,8 @@ namespace Umbraco.Core.Persistence.Factories
                         ValidationRegExp = typeDto.ValidationRegExp,
                         PropertyGroupId = new Lazy<int>(() => tempGroupDto.Id.Value),
                         CreateDate = memberType.CreateDate,
-                        UpdateDate = memberType.UpdateDate
+                        UpdateDate = memberType.UpdateDate,
+                        Key = typeDto.UniqueId
                     };
                     //on initial construction we don't want to have dirty properties tracked
                     // http://issues.umbraco.org/issue/U4-1946
@@ -164,9 +166,10 @@ namespace Umbraco.Core.Persistence.Factories
                     Name = typeDto.Name,
                     SortOrder = typeDto.SortOrder,
                     ValidationRegExp = typeDto.ValidationRegExp,
-                    PropertyGroupId = new Lazy<int>(() => default(int)),
+                    PropertyGroupId = null,
                     CreateDate = dto.CreateDate,
-                    UpdateDate = dto.CreateDate
+                    UpdateDate = dto.CreateDate,
+                    Key = typeDto.UniqueId
                 };
                 
                 propertyTypes.Add(propertyType);

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

@@ -134,13 +134,16 @@ namespace Umbraco.Core.Persistence.Migrations.Initial
             _database.Insert("umbracoNode", "id", false, new NodeDto { NodeId = 1043, Trashed = false, ParentId = -1, UserId = 0, Level = 1, Path = "-1,1043", SortOrder = 2, UniqueId = new Guid("1df9f033-e6d4-451f-b8d2-e0cbc50a836f"), Text = "Image Cropper", NodeObjectType = new Guid(Constants.ObjectTypes.DataType), CreateDate = DateTime.Now });
             _database.Insert("umbracoNode", "id", false, new NodeDto { NodeId = 1044, Trashed = false, ParentId = -1, UserId = 0, Level = 1, Path = "-1,1044", SortOrder = 0, UniqueId = new Guid("d59be02f-1df9-4228-aa1e-01917d806cda"), Text = Constants.Conventions.MemberTypes.DefaultAlias, NodeObjectType = new Guid(Constants.ObjectTypes.MemberType), CreateDate = DateTime.Now });
             _database.Insert("umbracoNode", "id", false, new NodeDto { NodeId = 1045, Trashed = false, ParentId = -1, UserId = 0, Level = 1, Path = "-1,1045", SortOrder = 2, UniqueId = new Guid("7E3962CC-CE20-4FFC-B661-5897A894BA7E"), Text = "Multiple Media Picker", NodeObjectType = new Guid(Constants.ObjectTypes.DataType), CreateDate = DateTime.Now });
-            
+
 
             //TODO: We're not creating these for 7.0
             //_database.Insert("umbracoNode", "id", false, new NodeDto { NodeId = 1039, Trashed = false, ParentId = -1, UserId = 0, Level = 1, Path = "-1,1039", SortOrder = 2, UniqueId = new Guid("06f349a9-c949-4b6a-8660-59c10451af42"), Text = "Ultimate Picker", NodeObjectType = new Guid(Constants.ObjectTypes.DataType), CreateDate = DateTime.Now });
             //_database.Insert("umbracoNode", "id", false, new NodeDto { NodeId = 1038, Trashed = false, ParentId = -1, UserId = 0, Level = 1, Path = "-1,1038", SortOrder = 2, UniqueId = new Guid("1251c96c-185c-4e9b-93f4-b48205573cbd"), Text = "Simple Editor", NodeObjectType = new Guid(Constants.ObjectTypes.DataType), CreateDate = DateTime.Now });
-            
+
             //_database.Insert("umbracoNode", "id", false, new NodeDto { NodeId = 1042, Trashed = false, ParentId = -1, UserId = 0, Level = 1, Path = "-1,1042", SortOrder = 2, UniqueId = new Guid("0a452bd5-83f9-4bc3-8403-1286e13fb77e"), Text = "Macro Container", NodeObjectType = new Guid(Constants.ObjectTypes.DataType), CreateDate = DateTime.Now });            
+
+            // all lock objects
+            _database.Insert("umbracoNode", "id", false, new NodeDto { NodeId = Constants.System.ServersLock, Trashed = false, ParentId = -1, UserId = 0, Level = 1, Path = "-1," + Constants.System.ServersLock, SortOrder = 1, UniqueId = new Guid("0AF5E610-A310-4B6F-925F-E928D5416AF7"), Text = "LOCK: Servers", NodeObjectType = Constants.ObjectTypes.LockObjectGuid, CreateDate = DateTime.Now });
         }
 
         private void CreateCmsContentTypeData()
@@ -237,8 +240,8 @@ namespace Umbraco.Core.Persistence.Migrations.Initial
             _database.Insert("cmsDataType", "pk", false, new DataTypeDto { PrimaryKey = 14, DataTypeId = -42, PropertyEditorAlias = Constants.PropertyEditors.DropDownListAlias, DbType = "Integer" });
             _database.Insert("cmsDataType", "pk", false, new DataTypeDto { PrimaryKey = 15, DataTypeId = -43, PropertyEditorAlias = Constants.PropertyEditors.CheckBoxListAlias, DbType = "Nvarchar" });
             _database.Insert("cmsDataType", "pk", false, new DataTypeDto { PrimaryKey = 16, DataTypeId = 1034, PropertyEditorAlias = Constants.PropertyEditors.ContentPickerAlias, DbType = "Integer" });
-            _database.Insert("cmsDataType", "pk", false, new DataTypeDto { PrimaryKey = 17, DataTypeId = 1035, PropertyEditorAlias = Constants.PropertyEditors.MediaPickerAlias, DbType = "Integer" });            
             _database.Insert("cmsDataType", "pk", false, new DataTypeDto { PrimaryKey = 18, DataTypeId = 1036, PropertyEditorAlias = Constants.PropertyEditors.MemberPickerAlias, DbType = "Integer" });                        
+            _database.Insert("cmsDataType", "pk", false, new DataTypeDto { PrimaryKey = 17, DataTypeId = 1035, PropertyEditorAlias = Constants.PropertyEditors.MultipleMediaPickerAlias, DbType = "Nvarchar" });
             _database.Insert("cmsDataType", "pk", false, new DataTypeDto { PrimaryKey = 21, DataTypeId = 1040, PropertyEditorAlias = Constants.PropertyEditors.RelatedLinksAlias, DbType = "Ntext" });
             _database.Insert("cmsDataType", "pk", false, new DataTypeDto { PrimaryKey = 22, DataTypeId = 1041, PropertyEditorAlias = Constants.PropertyEditors.TagsAlias, DbType = "Ntext" });
             _database.Insert("cmsDataType", "pk", false, new DataTypeDto { PrimaryKey = 24, DataTypeId = 1043, PropertyEditorAlias = Constants.PropertyEditors.ImageCropperAlias, DbType = "Ntext" });

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

@@ -33,6 +33,11 @@ namespace Umbraco.Core.Persistence.Migrations
 			get { return Values; }
 		}
 
+	    public IEnumerable<MigrationAttribute> MigrationMetaData
+	    {
+	        get { return Values.SelectMany(x => x.GetType().GetCustomAttributes<MigrationAttribute>(false)).WhereNotNull(); }
+	    } 
+
 
         /// <summary>
         /// This will ctor the IMigration instances

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

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.ComponentModel;
 using System.IO;
 using System.Linq;
 using System.Text;
@@ -27,18 +28,21 @@ namespace Umbraco.Core.Persistence.Migrations
         private readonly IMigration[] _migrations;
 
         [Obsolete("Use the ctor that specifies all dependencies instead")]
+        [EditorBrowsable(EditorBrowsableState.Never)]
         public MigrationRunner(Version currentVersion, Version targetVersion, string productName)
             : this(LoggerResolver.Current.Logger, currentVersion, targetVersion, productName)
         {
         }
 
         [Obsolete("Use the ctor that specifies all dependencies instead")]
+        [EditorBrowsable(EditorBrowsableState.Never)]
         public MigrationRunner(ILogger logger, Version currentVersion, Version targetVersion, string productName)
             : this(logger, currentVersion, targetVersion, productName, null)
         {
         }
 
         [Obsolete("Use the ctor that specifies all dependencies instead")]
+        [EditorBrowsable(EditorBrowsableState.Never)]
         public MigrationRunner(ILogger logger, Version currentVersion, Version targetVersion, string productName, params IMigration[] migrations)
             : this(ApplicationContext.Current.Services.MigrationEntryService, logger, new SemVersion(currentVersion), new SemVersion(targetVersion), productName, migrations)
         {
@@ -90,9 +94,8 @@ namespace Umbraco.Core.Persistence.Migrations
             var migrations = isUpgrade
                                  ? OrderedUpgradeMigrations(foundMigrations).ToList()
                                  : OrderedDowngradeMigrations(foundMigrations).ToList();
-
             
-            if (Migrating.IsRaisedEventCancelled(new MigrationEventArgs(migrations, _currentVersion, _targetVersion, true), this))
+            if (Migrating.IsRaisedEventCancelled(new MigrationEventArgs(migrations, _currentVersion, _targetVersion, _productName, true), this))
             {
                 _logger.Warn<MigrationRunner>("Migration was cancelled by an event");
                 return false;
@@ -121,7 +124,7 @@ namespace Umbraco.Core.Persistence.Migrations
                 throw;
             }
 
-            Migrated.RaiseEvent(new MigrationEventArgs(migrations, migrationContext, _currentVersion, _targetVersion, false), this);
+            Migrated.RaiseEvent(new MigrationEventArgs(migrations, migrationContext, _currentVersion, _targetVersion, _productName, false), this);
 
             return true;
         }
@@ -289,12 +292,11 @@ namespace Umbraco.Core.Persistence.Migrations
                 //NOTE: We CANNOT do this as part of the transaction!!! This is because when upgrading to 7.3, we cannot
                 // create the migrations table and then add data to it in the same transaction without issuing things like GO
                 // commands and since we need to support all Dbs, we need to just do this after the fact.
-                var exists = _migrationEntryService.FindEntry(GlobalSettings.UmbracoMigrationName, _targetVersion);
+                var exists = _migrationEntryService.FindEntry(_productName, _targetVersion);
                 if (exists == null)
                 {
                     _migrationEntryService.CreateEntry(_productName, _targetVersion);    
                 }
-               
             }
         }
 
@@ -308,4 +310,4 @@ namespace Umbraco.Core.Persistence.Migrations
         /// </summary>
         public static event TypedEventHandler<MigrationRunner, MigrationEventArgs> Migrated;
     }
-}
+}

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

@@ -0,0 +1,32 @@
+using System.Linq;
+using Umbraco.Core.Configuration;
+using Umbraco.Core.Logging;
+using Umbraco.Core.Persistence.SqlSyntax;
+
+namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionFourOneZero
+{
+    [Migration("4.1.0", 0, GlobalSettings.UmbracoMigrationName)]
+    public class AddPreviewXmlTable : MigrationBase
+    {
+        public AddPreviewXmlTable(ISqlSyntaxProvider sqlSyntax, ILogger logger)
+            : base(sqlSyntax, logger)
+        {
+        }
+
+        public override void Up()
+        {
+            var tableName = "cmsPreviewXml";
+            var tables = SqlSyntax.GetTablesInSchema(Context.Database).ToArray();
+            if (tables.InvariantContains(tableName)) return;
+
+            Create.Table(tableName)
+                .WithColumn("nodeId").AsInt32().NotNullable()
+                .WithColumn("versionId").AsGuid().NotNullable()
+                .WithColumn("timestamp").AsDateTime().NotNullable()
+                .WithColumn("xml").AsString();
+        }
+
+        public override void Down()
+        { }
+    }
+}

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

@@ -32,17 +32,19 @@ namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSeven
         {
             if (database != null)
             {
-                var dtSql = new Sql().Select("nodeId").From<DataTypeDto>().Where<DataTypeDto>(dto => dto.PropertyEditorAlias == Constants.PropertyEditors.RelatedLinksAlias);
+                var dtSql = new Sql().Select("nodeId")
+                    .From<DataTypeDto>(SqlSyntax)
+                    .Where<DataTypeDto>(dto => dto.PropertyEditorAlias == Constants.PropertyEditors.RelatedLinksAlias);
+
                 var dataTypeIds = database.Fetch<int>(dtSql);
+                if (dataTypeIds.Any() == false) return string.Empty;
 
-                if (!dataTypeIds.Any()) return string.Empty;
+                // need to use dynamic, as PropertyDataDto has new properties (eg decimal...) in further versions that don't exist yet
+                var propertyData = database.Fetch<dynamic>("SELECT * FROM cmsPropertyData"
+                        + " WHERE propertyTypeId in (SELECT id from cmsPropertyType where dataTypeID IN (@dataTypeIds))", new { /*dataTypeIds =*/ dataTypeIds });
+                if (propertyData.Any() == false) return string.Empty;
 
-                var propertyData =
-                    database.Fetch<PropertyDataDto>(
-                        "WHERE propertyTypeId in (SELECT id from cmsPropertyType where dataTypeID IN (@dataTypeIds))", new { dataTypeIds = dataTypeIds });
-                if (!propertyData.Any()) return string.Empty;
-
-                var nodesIdsWithProperty = propertyData.Select(x => x.NodeId).Distinct().ToArray();
+                var nodesIdsWithProperty = propertyData.Select(x => (int) x.contentNodeId).Distinct().ToArray();
 
                 var cmsContentXmlEntries = new List<ContentXmlDto>();
                 //We're doing an "IN" query here but SQL server only supports 2100 query parameters so we're going to split on that
@@ -54,30 +56,33 @@ namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSeven
                     cmsContentXmlEntries.AddRange(database.Fetch<ContentXmlDto>("WHERE nodeId in (@nodeIds)", new { nodeIds = batch }));
                 }
 
-                var propertyTypeIds = propertyData.Select(x => x.PropertyTypeId).Distinct();
+                var propertyTypeIds = propertyData.Select(x => (int) x.propertytypeid).Distinct();
 
                 //NOTE: We are writing the full query because we've added a column to the PropertyTypeDto in later versions so one of the columns
                 // won't exist yet
                 var propertyTypes = database.Fetch<PropertyTypeDto>("SELECT * FROM cmsPropertyType WHERE id in (@propertyTypeIds)", new { propertyTypeIds = propertyTypeIds });
-            
+
                 foreach (var data in propertyData)
                 {
-                    if (string.IsNullOrEmpty(data.Text) == false)
+                    if (string.IsNullOrEmpty(data.dataNtext) == false)
                     {
                         XmlDocument xml;
                         //fetch the current data (that's in xml format)
                         try
                         {
                             xml = new XmlDocument();
-                            xml.LoadXml(data.Text);
+                            xml.LoadXml(data.dataNtext);
                         }
-                        catch (Exception ex) 
+                        catch (Exception ex)
                         {
-                            Logger.Error<UpdateRelatedLinksData>("The data stored for property id " + data.Id + " on document " + data.NodeId + 
-                                " is not valid XML, the data will be removed because it cannot be converted to the new format. The value was: " + data.Text, ex);
+                            int dataId = data.id;
+                            int dataNodeId = data.contentNodeId;
+                            string dataText = data.dataNtext;
+                            Logger.Error<UpdateRelatedLinksData>("The data stored for property id " + dataId + " on document " + dataNodeId +
+                                " is not valid XML, the data will be removed because it cannot be converted to the new format. The value was: " + dataText, ex);
 
-                            data.Text = "";
-                            database.Update(data);
+                            data.dataNtext = "";
+                            database.Update("cmsPropertyData", "id", data, new[] { "dataNText" });
 
                             UpdateXmlTable(propertyTypes, data, cmsContentXmlEntries, database);
 
@@ -91,11 +96,11 @@ namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSeven
                         {
                             var title = node.Attributes["title"].Value;
                             var type = node.Attributes["type"].Value;
-                            var newwindow = node.Attributes["newwindow"].Value.Equals("1") ? true : false;
+                            var newwindow = node.Attributes["newwindow"].Value.Equals("1");
                             var lnk = node.Attributes["link"].Value;
 
                             //create the links in the format the new prop editor expects it to be
-                            var link = new ExpandoObject() as IDictionary<string, Object>;
+                            var link = new ExpandoObject() as IDictionary<string, object>;
                             link.Add("title", title);
                             link.Add("caption", title);
                             link.Add("link", lnk);
@@ -110,9 +115,9 @@ namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSeven
                         }
 
                         //store the serialized data
-                        data.Text = JsonConvert.SerializeObject(links);
+                        data.dataNtext = JsonConvert.SerializeObject(links);
 
-                        database.Update(data);
+                        database.Update("cmsPropertyData", "id", data, new[] { "dataNText" });
 
                         UpdateXmlTable(propertyTypes, data, cmsContentXmlEntries, database);
 
@@ -127,20 +132,20 @@ namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSeven
             throw new DataLossException("Cannot downgrade from a version 7 database to a prior version, the database schema has already been modified");
         }
 
-        private static void UpdateXmlTable(List<PropertyTypeDto> propertyTypes, PropertyDataDto data, List<ContentXmlDto> cmsContentXmlEntries, Database database)
+        private static void UpdateXmlTable(List<PropertyTypeDto> propertyTypes, dynamic data, List<ContentXmlDto> cmsContentXmlEntries, Database database)
         {
             //now we need to update the cmsContentXml table
-            var propertyType = propertyTypes.SingleOrDefault(x => x.Id == data.PropertyTypeId);
+            var propertyType = propertyTypes.SingleOrDefault(x => x.Id == data.propertytypeid);
             if (propertyType != null)
             {
-                var xmlItem = cmsContentXmlEntries.SingleOrDefault(x => x.NodeId == data.NodeId);
+                var xmlItem = cmsContentXmlEntries.SingleOrDefault(x => x.NodeId == data.contentNodeId);
                 if (xmlItem != null)
                 {
                     var x = XElement.Parse(xmlItem.Xml);
                     var prop = x.Element(propertyType.Alias);
                     if (prop != null)
                     {
-                        prop.ReplaceAll(new XCData(data.Text));
+                        prop.ReplaceAll(new XCData(data.dataNtext));
                         database.Update(xmlItem);
                     }
                 }

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

@@ -0,0 +1,57 @@
+using System;
+using Umbraco.Core.Configuration;
+using Umbraco.Core.Logging;
+using Umbraco.Core.Models.Rdbms;
+using Umbraco.Core.Persistence.SqlSyntax;
+
+namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSevenFiveZero
+{
+    // This migration exists for 7.3.0 but it seems like it was not always running properly
+    // if you're upgrading from 7.3.0 or higher than we add this migration, if you're upgrading 
+    // from 7.3.0 or lower then you will already get this migration in the migration to get to 7.3.0
+    [Migration("7.3.0", "7.5.0", 10, GlobalSettings.UmbracoMigrationName)]
+    public class EnsureServersLockObject : MigrationBase
+    {
+        public EnsureServersLockObject(ISqlSyntaxProvider sqlSyntax, ILogger logger)
+            : base(sqlSyntax, logger)
+        { }
+
+        public override void Up()
+        {
+            // that lock object should have been part of BaseDataCreation since 7.3.0 but
+            // for some reason it was not, so it was created during migrations but not during
+            // new installs, so for ppl that upgrade, make sure they have it
+
+            EnsureLockObject(Constants.System.ServersLock, "0AF5E610-A310-4B6F-925F-E928D5416AF7", "LOCK: Servers");
+        }
+
+        public override void Down()
+        {
+            // not implemented
+        }
+
+        private void EnsureLockObject(int id, string uniqueId, string text)
+        {
+            var exists = Context.Database.Exists<NodeDto>(id);
+            if (exists) return;
+
+            Insert
+                .IntoTable("umbracoNode")
+                .EnableIdentityInsert()
+                .Row(new
+                {
+                    id = id, // NodeId
+                    trashed = false,
+                    parentId = -1,
+                    nodeUser = 0,
+                    level = 1,
+                    path = "-1," + id,
+                    sortOrder = 0,
+                    uniqueId = new Guid(uniqueId),
+                    text = text,
+                    nodeObjectType = new Guid(Constants.ObjectTypes.LockObject),
+                    createDate = DateTime.Now
+                });
+        }
+    }
+}

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

@@ -1,4 +1,6 @@
 using System;
+using System.Collections;
+using System.Collections.Generic;
 using System.Linq;
 using Umbraco.Core.Configuration;
 using Umbraco.Core.Logging;
@@ -33,45 +35,57 @@ namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSevenFourZer
 
                 // 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)
+                Execute.Code(UpdateGuids);
+            }
+        }
 
-                foreach (var data in Context.Database.Query<dynamic>(@"
+        private static string UpdateGuids(Database database)
+        {
+            var updates = new List<Tuple<Guid, int>>();
+
+            foreach (var data in 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 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 });
+                    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
+                // but not within the foreach loop (as we already have a data reader open)
+                updates.Add(Tuple.Create(guid, data.grId));
             }
+
+            foreach (var update in updates)
+                database.Execute("UPDATE cmsPropertyTypeGroup SET uniqueID=@uid WHERE id=@id", new { uid = update.Item1, id = update.Item2 });
+
+            return string.Empty;
         }
 
         public override void Down()

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

@@ -20,7 +20,17 @@ namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSevenFourZer
             if (columns.Any(x => x.TableName.InvariantEquals("cmsPropertyTypeGroup") && x.ColumnName.InvariantEquals("parentGroupId")) == false)
                 return;
 
-            Delete.ForeignKey("FK_cmsPropertyTypeGroup_cmsPropertyTypeGroup_id").OnTable("cmsPropertyTypeGroup");
+            //This constraing can be based on old aliases, before removing them, check they exist
+            var constraints = SqlSyntax.GetConstraintsPerColumn(Context.Database).Distinct().ToArray();
+            if (constraints.Any(x => x.Item1.InvariantEquals("cmsPropertyTypeGroup") && x.Item3.InvariantEquals("FK_cmsPropertyTypeGroup_cmsPropertyTypeGroup_id")))
+            {
+                Delete.ForeignKey("FK_cmsPropertyTypeGroup_cmsPropertyTypeGroup_id").OnTable("cmsPropertyTypeGroup");
+            }
+            if (constraints.Any(x => x.Item1.InvariantEquals("cmsPropertyTypeGroup") && x.Item3.InvariantEquals("FK_cmsPropertyTypeGroup_cmsPropertyTypeGroup")))
+            {
+                Delete.ForeignKey("FK_cmsPropertyTypeGroup_cmsPropertyTypeGroup").OnTable("cmsPropertyTypeGroup");
+            }
+            
             Delete.Column("parentGroupId").FromTable("cmsPropertyTypeGroup");
         }
 

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

@@ -33,36 +33,40 @@ namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSixZeroOne
                 // won't exist yet
                 var propertyTypes = database.Fetch<dynamic>("SELECT * FROM cmsPropertyType WHERE propertyTypeGroupId > 0");
 
-                var propertyGroups = database.Fetch<PropertyTypeGroupDto>("WHERE id > 0");
+                // need to use dynamic, as PropertyTypeGroupDto has new properties
+                var propertyGroups = database.Fetch<dynamic>("SELECT * FROM cmsPropertyTypeGroup WHERE id > 0");
 
                 foreach (var propertyType in propertyTypes)
                 {
                     // get the PropertyTypeGroup of the current PropertyType, skip if not found
-                    var propertyTypeGroup = propertyGroups.FirstOrDefault(x => x.Id == propertyType.propertyTypeGroupId);
+                    var propertyTypeGroup = propertyGroups.FirstOrDefault(x => x.id == propertyType.propertyTypeGroupId);
                     if (propertyTypeGroup == null) continue;
 
                     // if the PropretyTypeGroup belongs to the same content type as the PropertyType, then fine
-                    if (propertyTypeGroup.ContentTypeNodeId == propertyType.contentTypeId) continue;
+                    if (propertyTypeGroup.contenttypeNodeId == propertyType.contentTypeId) continue;
 
                     // else we want to assign the PropertyType to a proper PropertyTypeGroup
                     // ie one that does belong to the same content - look for it
                     var okPropertyTypeGroup = propertyGroups.FirstOrDefault(x =>
-                        x.Text == propertyTypeGroup.Text && // same name
-                        x.ContentTypeNodeId == propertyType.contentTypeId); // but for proper content type
+                        x.text == propertyTypeGroup.text && // same name
+                        x.contenttypeNodeId == propertyType.contentTypeId); // but for proper content type
 
                     if (okPropertyTypeGroup == null)
                     {
-                        // does not exist, create a new PropertyTypeGroup,
-                        var propertyGroup = new PropertyTypeGroupDto
+                        // does not exist, create a new PropertyTypeGroup
+                        // cannot use a PropertyTypeGroupDto because of the new (not-yet-existing) uniqueID property
+                        // cannot use a dynamic because database.Insert fails to set the value of property
+                        var propertyGroup = new PropertyTypeGroupDtoTemp
                         {
-                            ContentTypeNodeId = propertyType.contentTypeId,
-                            Text = propertyTypeGroup.Text,
-                            SortOrder = propertyTypeGroup.SortOrder
+                            id = 0,
+                            contenttypeNodeId = propertyType.contentTypeId,
+                            text = propertyTypeGroup.text,
+                            sortorder = propertyTypeGroup.sortorder
                         };
 
                         // save + add to list of groups
-                        int id = Convert.ToInt16(database.Insert(propertyGroup));
-                        propertyGroup.Id = id;
+                        int id = Convert.ToInt16(database.Insert("cmsPropertyTypeGroup", "id", propertyGroup));
+                        propertyGroup.id = id;
                         propertyGroups.Add(propertyGroup);
 
                         // update the PropertyType to use the new PropertyTypeGroup
@@ -71,7 +75,7 @@ namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSixZeroOne
                     else
                     {
                         // exists, update PropertyType to use the PropertyTypeGroup
-                        propertyType.propertyTypeGroupId = okPropertyTypeGroup.Id;
+                        propertyType.propertyTypeGroupId = okPropertyTypeGroup.id;
                     }
                     database.Update("cmsPropertyType", "id", propertyType);
                 }
@@ -79,5 +83,13 @@ namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSixZeroOne
 
             return string.Empty;
         }
+
+        private class PropertyTypeGroupDtoTemp
+        {
+            public int id { get; set; }
+            public int contenttypeNodeId { get; set; }
+            public string text { get; set; }
+            public int sortorder { get; set; }
+        }
     }
 }

src/Umbraco.Core/Persistence/PetaPoco.cs

@@ -834,7 +834,7 @@ namespace Umbraco.Core.Persistence
 					var pd = PocoData.ForType(typeof(T));
 					try
 					{
-						r = cmd.ExecuteReader();
+						r = cmd.ExecuteReaderWithRetry();
 						OnExecutedCommand(cmd);
 					}
 					catch (Exception x)

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

@@ -128,6 +128,34 @@ namespace Umbraco.Core.Persistence.Querying
                     right = Visit(b.Right);
                 }
             }
+            else if (operand == "=")
+            {
+                // deal with (x == true|false) - most common
+                var constRight = b.Right as ConstantExpression;
+                if (constRight != null && constRight.Type == typeof (bool))
+                    return ((bool) constRight.Value) ? VisitNotNot(b.Left) : VisitNot(b.Left);
+                right = Visit(b.Right);
+
+                // deal with (true|false == x) - why not
+                var constLeft = b.Left as ConstantExpression;
+                if (constLeft != null && constLeft.Type == typeof (bool))
+                    return ((bool) constLeft.Value) ? VisitNotNot(b.Right) : VisitNot(b.Right);
+                left = Visit(b.Left);
+            }
+            else if (operand == "<>")
+            {
+                // deal with (x != true|false) - most common
+                var constRight = b.Right as ConstantExpression;
+                if (constRight != null && constRight.Type == typeof(bool))
+                    return ((bool) constRight.Value) ? VisitNot(b.Left) : VisitNotNot(b.Left);
+                right = Visit(b.Right);
+
+                // deal with (true|false != x) - why not
+                var constLeft = b.Left as ConstantExpression;
+                if (constLeft != null && constLeft.Type == typeof(bool))
+                    return ((bool) constLeft.Value) ? VisitNot(b.Right) : VisitNotNot(b.Right);
+                left = Visit(b.Left);
+            }
             else
             {
                 left = Visit(b.Left);
@@ -152,7 +180,7 @@ namespace Umbraco.Core.Persistence.Querying
                 case "COALESCE":
                     return string.Format("{0}({1},{2})", operand, left, right);
                 default:
-                    return left + " " + operand + " " + right;
+                    return "(" + left + " " + operand + " " + right + ")";
             }
         }
 
@@ -231,25 +259,47 @@ namespace Umbraco.Core.Persistence.Querying
             switch (u.NodeType)
             {
                 case ExpressionType.Not:
-                    var o = Visit(u.Operand);
-
-                    //use a Not equal operator instead of <> since we don't know that <> works in all sql servers
-
-                    switch (u.Operand.NodeType)
-                    {
-                        case ExpressionType.MemberAccess:
-                            //In this case it wil be a false property , i.e. x => !Trashed
-                            SqlParameters.Add(true);
-                            return string.Format("NOT ({0} = @0)", o);                            
-                        default:
-                            //In this case it could be anything else, such as: x => !x.Path.StartsWith("-20")
-                            return string.Format("NOT ({0})", o);                            
-                    }
+                    return VisitNot(u.Operand);
                 default:
                     return Visit(u.Operand);
             }
         }
 
+        private string VisitNot(Expression exp)
+        {
+            var o = Visit(exp);
+
+            // use a "NOT (...)" syntax instead of "<>" since we don't know whether "<>" works in all sql servers
+            // also, x.StartsWith(...) translates to "x LIKE '...%'" which we cannot "<>" and have to "NOT (...")
+
+            switch (exp.NodeType)
+            {
+                case ExpressionType.MemberAccess:
+                    // false property , i.e. x => !Trashed
+                    SqlParameters.Add(true);
+                    return string.Format("NOT ({0} = @{1})", o, SqlParameters.Count - 1);
+                default:
+                    // could be anything else, such as: x => !x.Path.StartsWith("-20")
+                    return "NOT (" + o + ")";
+            }
+        }
+
+        private string VisitNotNot(Expression exp)
+        {
+            var o = Visit(exp);
+
+            switch (exp.NodeType)
+            {
+                case ExpressionType.MemberAccess:
+                    // true property, i.e. x => Trashed
+                    SqlParameters.Add(true);
+                    return string.Format("({0} = @{1})", o, SqlParameters.Count - 1);
+                default:
+                    // could be anything else, such as: x => x.Path.StartsWith("-20")
+                    return o;
+            }
+        }
+
         protected virtual string VisitNewArray(NewArrayExpression na)
         {
 

src/Umbraco.Core/Persistence/Relators/UserSectionRelator.cs

@@ -18,8 +18,11 @@ namespace Umbraco.Core.Persistence.Relators
             // Is this the same DictionaryItem as the current one we're processing
             if (Current != null && Current.Id == a.Id)
             {
-                // Yes, just add this User2AppDto to the current item's collection
-                Current.User2AppDtos.Add(p);
+                if (p.AppAlias.IsNullOrWhiteSpace() == false)
+                {
+                    // Yes, just add this User2AppDto to the current item's collection
+                    Current.User2AppDtos.Add(p);
+                }
 
                 // Return null to indicate we're not done with this User yet
                 return null;
@@ -35,7 +38,7 @@ namespace Umbraco.Core.Persistence.Relators
             Current = a;
             Current.User2AppDtos = new List<User2AppDto>();
             //this can be null since we are doing a left join
-            if (p.AppAlias != null)
+            if (p.AppAlias.IsNullOrWhiteSpace() == false)
             {
                 Current.User2AppDtos.Add(p);    
             }

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

@@ -105,6 +105,7 @@ namespace Umbraco.Core.Persistence.Repositories
 
         #region Overrides of PetaPocoRepositoryBase<IContent>
 
+
         protected override Sql GetBaseQuery(bool isCount)
         {
             var sqlx = string.Format("LEFT OUTER JOIN {0} {1} ON ({1}.{2}={0}.{2} AND {1}.{3}=1)",
@@ -155,8 +156,8 @@ namespace Umbraco.Core.Persistence.Repositories
                                "DELETE FROM cmsContentVersion WHERE ContentId = @Id",
                                "DELETE FROM cmsContentXml WHERE nodeId = @Id",
                                "DELETE FROM cmsContent WHERE nodeId = @Id",
-                               "DELETE FROM umbracoNode WHERE id = @Id",
-                               "DELETE FROM umbracoAccess WHERE nodeId = @Id"
+                               "DELETE FROM umbracoAccess WHERE nodeId = @Id",
+                               "DELETE FROM umbracoNode WHERE id = @Id"
                            };
             return list;
         }
@@ -241,8 +242,8 @@ namespace Umbraco.Core.Persistence.Repositories
                 // see: http://issues.umbraco.org/issue/U4-6322 & http://issues.umbraco.org/issue/U4-5982
                 var descendants = GetPagedResultsByQuery<DocumentDto, Content>(query, pageIndex, pageSize, out total,
                     new Tuple<string, string>("cmsDocument", "nodeId"),
-                    ProcessQuery, "Path", Direction.Ascending);
-                
+                    ProcessQuery, "Path", Direction.Ascending, true);
+
                 var xmlItems = (from descendant in descendants
                                 let xml = serializer(descendant)
                                 select new ContentXmlDto { NodeId = descendant.Id, Xml = xml.ToDataString() }).ToArray();
@@ -689,8 +690,7 @@ namespace Umbraco.Core.Persistence.Repositories
         public int CountPublished()
         {
             var sql = GetBaseQuery(true).Where<NodeDto>(x => x.Trashed == false)
-                .Where<DocumentDto>(x => x.Published == true)
-                .Where<DocumentDto>(x => x.Newest == true);
+                .Where<DocumentDto>(x => x.Published == true);
             return Database.ExecuteScalar<int>(sql);
         }
 
@@ -767,10 +767,11 @@ namespace Umbraco.Core.Persistence.Repositories
         /// <param name="totalRecords">Total records query would return without paging</param>
         /// <param name="orderBy">Field to order by</param>
         /// <param name="orderDirection">Direction to order by</param>
+        /// <param name="orderBySystemField">Flag to indicate when ordering by system field</param>
         /// <param name="filter">Search text filter</param>
         /// <returns>An Enumerable list of <see cref="IContent"/> objects</returns>
         public IEnumerable<IContent> GetPagedResultsByQuery(IQuery<IContent> query, long pageIndex, int pageSize, out long totalRecords,
-            string orderBy, Direction orderDirection, string filter = "")
+            string orderBy, Direction orderDirection, bool orderBySystemField, string filter = "")
         {
 
             //NOTE: This uses the GetBaseQuery method but that does not take into account the required 'newest' field which is 
@@ -789,7 +790,7 @@ namespace Umbraco.Core.Persistence.Repositories
 
             return GetPagedResultsByQuery<DocumentDto, Content>(query, pageIndex, pageSize, out totalRecords,
                 new Tuple<string, string>("cmsDocument", "nodeId"),
-                ProcessQuery, orderBy, orderDirection,
+                ProcessQuery, orderBy, orderDirection, orderBySystemField,
                 filterCallback);
 
         }

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

@@ -33,14 +33,11 @@ namespace Umbraco.Core.Persistence.Repositories
         protected ContentTypeBaseRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, ISqlSyntaxProvider sqlSyntax)
             : base(work, cache, logger, sqlSyntax)
         {
-            _guidRepo = new GuidReadOnlyContentTypeBaseRepository(this, work, cache, logger, sqlSyntax);
         }
 
-        private readonly GuidReadOnlyContentTypeBaseRepository _guidRepo;
-
         public IEnumerable<MoveEventInfo<TEntity>> Move(TEntity toMove, EntityContainer container)
         {
-            var parentId = -1;
+            var parentId = Constants.System.Root;
             if (container != null)
             {
                 // Check on paths
@@ -57,27 +54,36 @@ namespace Umbraco.Core.Persistence.Repositories
                 new MoveEventInfo<TEntity>(toMove, toMove.Path, parentId)
             };
 
-            //do the move to a new parent
+
+            // get the level delta (old pos to new pos)
+            var levelDelta = container == null
+                ? 1 - toMove.Level
+                : container.Level + 1 - toMove.Level;
+
+            // move to parent (or -1), update path, save
             toMove.ParentId = parentId;
-            //schedule it for updating in the transaction
+            var toMovePath = toMove.Path + ","; // save before changing
+            toMove.Path = (container == null ? Constants.System.Root.ToString() : container.Path) + "," + toMove.Id;
+            toMove.Level = container == null ? 1 : container.Level + 1;
             AddOrUpdate(toMove);
 
-            //update all descendants
-            var descendants = this.GetByQuery(
-                new Query<TEntity>().Where(type => type.Path.StartsWith(toMove.Path + ",")));
-            foreach (var descendant in descendants)
+            //update all descendants, update in order of level
+            var descendants = GetByQuery(new Query<TEntity>().Where(type => type.Path.StartsWith(toMovePath)));
+            var paths = new Dictionary<int, string>();
+            paths[toMove.Id] = toMove.Path;
+
+            foreach (var descendant in descendants.OrderBy(x => x.Level))
             {
                 moveInfo.Add(new MoveEventInfo<TEntity>(descendant, descendant.Path, descendant.ParentId));
 
-                //all we're doing here is setting the parent Id to be dirty so that it resets the path/level/etc...
-                descendant.ParentId = descendant.ParentId;
-                //schedule it for updating in the transaction
+                descendant.Path = paths[descendant.Id] = paths[descendant.ParentId] + "," + descendant.Id;
+                descendant.Level += levelDelta;
+
                 AddOrUpdate(descendant);
             }
 
             return moveInfo;
         }
-
         /// <summary>
         /// Returns the content type ids that match the query
         /// </summary>
@@ -279,7 +285,7 @@ AND umbracoNode.id <> @id",
                 {
                     //Find PropertyTypes for the removed ContentType
                     var propertyTypes = Database.Fetch<PropertyTypeDto>("WHERE contentTypeId = @Id", new { Id = key });
-                    //Loop through the Content that is based on the current ContentType in order to remove the Properties that are 
+                    //Loop through the Content that is based on the current ContentType in order to remove the Properties that are
                     //based on the PropertyTypes that belong to the removed ContentType.
                     foreach (var contentDto in contentDtos)
                     {
@@ -403,7 +409,7 @@ AND umbracoNode.id <> @id",
                     AssignDataTypeFromPropertyEditor(propertyType);
                 }
 
-                //validate the alias! 
+                //validate the alias!
                 ValidateAlias(propertyType);
 
                 var propertyTypeDto = propertyGroupFactory.BuildPropertyTypeDto(tabId, propertyType);
@@ -577,14 +583,13 @@ AND umbracoNode.id <> @id",
                 }
             }
 
-            public static IEnumerable<IMediaType> GetMediaTypes<TRepo, TId>(
-                TId[] mediaTypeIds, Database db, ISqlSyntaxProvider sqlSyntax,
+            public static IEnumerable<IMediaType> GetMediaTypes<TRepo>(
+                Database db, ISqlSyntaxProvider sqlSyntax,
                 TRepo contentTypeRepository)
-                where TRepo : IReadRepository<TId, TEntity>
-                where TId: struct
+                where TRepo : IReadRepository<int, TEntity>
             {
-                IDictionary<TId, IEnumerable<TId>> allParentMediaTypeIds;
-                var mediaTypes = MapMediaTypes(mediaTypeIds, db, sqlSyntax, out allParentMediaTypeIds)
+                IDictionary<int, List<int>> allParentMediaTypeIds;
+                var mediaTypes = MapMediaTypes(db, sqlSyntax, out allParentMediaTypeIds)
                     .ToArray();
 
                 MapContentTypeChildren(mediaTypes, db, sqlSyntax, contentTypeRepository, allParentMediaTypeIds);
@@ -592,16 +597,15 @@ AND umbracoNode.id <> @id",
                 return mediaTypes;
             }
 
-            public static IEnumerable<IContentType> GetContentTypes<TRepo, TId>(
-                TId[] contentTypeIds, Database db, ISqlSyntaxProvider sqlSyntax,
+            public static IEnumerable<IContentType> GetContentTypes<TRepo>(
+                Database db, ISqlSyntaxProvider sqlSyntax,
                 TRepo contentTypeRepository,
                 ITemplateRepository templateRepository)
-                where TRepo : IReadRepository<TId, TEntity>
-                where TId : struct
+                where TRepo : IReadRepository<int, TEntity>
             {
-                IDictionary<TId, IEnumerable<AssociatedTemplate>> allAssociatedTemplates;
-                IDictionary<TId, IEnumerable<TId>> allParentContentTypeIds;
-                var contentTypes = MapContentTypes(contentTypeIds, db, sqlSyntax, out allAssociatedTemplates, out allParentContentTypeIds)
+                IDictionary<int, List<AssociatedTemplate>> allAssociatedTemplates;
+                IDictionary<int, List<int>> allParentContentTypeIds;
+                var contentTypes = MapContentTypes(db, sqlSyntax, out allAssociatedTemplates, out allParentContentTypeIds)
                     .ToArray();
 
                 if (contentTypes.Any())
@@ -616,12 +620,11 @@ AND umbracoNode.id <> @id",
                 return contentTypes;
             }
 
-            internal static void MapContentTypeChildren<TRepo, TId>(IContentTypeComposition[] contentTypes,
+            internal static void MapContentTypeChildren<TRepo>(IContentTypeComposition[] contentTypes,
                 Database db, ISqlSyntaxProvider sqlSyntax,
                 TRepo contentTypeRepository,
-                IDictionary<TId, IEnumerable<TId>> allParentContentTypeIds)
-                where TRepo : IReadRepository<TId, TEntity>
-                where TId : struct
+                IDictionary<int, List<int>> allParentContentTypeIds)
+                where TRepo : IReadRepository<int, TEntity>
             {
                 //NOTE: SQL call #2
 
@@ -643,25 +646,22 @@ AND umbracoNode.id <> @id",
                     var allParentIdsAsArray = allParentContentTypeIds.SelectMany(x => x.Value).Distinct().ToArray();
                     if (allParentIdsAsArray.Any())
                     {
-                        var allParentContentTypes = contentTypeRepository.GetAll(allParentIdsAsArray).ToArray();
+                        var allParentContentTypes = contentTypes.Where(x => allParentIdsAsArray.Contains(x.Id)).ToArray();
+
                         foreach (var contentType in contentTypes)
-                        {
-                            //TODO: this is pretty hacky right now but i don't have time to refactor/fix running queries based on ints and Guids
-                            // (i.e. for v8) but we need queries by GUIDs now so this is how it's gonna have to be
-                            var entityId = typeof(TId) == typeof(int) ? contentType.Id : (object)contentType.Key;
+                        {                            
+                            var entityId = contentType.Id;
 
                             var parentContentTypes = allParentContentTypes.Where(x =>
                             {
-                                //TODO: this is pretty hacky right now but i don't have time to refactor/fix running queries based on ints and Guids
-                                // (i.e. for v8) but we need queries by GUIDs now so this is how it's gonna have to be
-                                var parentEntityId = typeof(TId) == typeof(int) ? x.Id : (object)x.Key;
+                                var parentEntityId = x.Id;
 
-                                return allParentContentTypeIds[(TId)entityId].Contains((TId)parentEntityId);
+                                return allParentContentTypeIds[entityId].Contains(parentEntityId);
                             });
                             foreach (var parentContentType in parentContentTypes)
                             {
                                 var result = contentType.AddContentType(parentContentType);
-                                //Do something if adding fails? (Should hopefully not be possible unless someone created a circular reference)    
+                                //Do something if adding fails? (Should hopefully not be possible unless someone created a circular reference)
                             }
 
                             //on initial construction we don't want to have dirty properties tracked
@@ -674,13 +674,12 @@ AND umbracoNode.id <> @id",
 
             }
 
-            internal static void MapContentTypeTemplates<TRepo, TId>(IContentType[] contentTypes,
+            internal static void MapContentTypeTemplates<TRepo>(IContentType[] contentTypes,
                 Database db,
                 TRepo contentTypeRepository,
                 ITemplateRepository templateRepository,
-                IDictionary<TId, IEnumerable<AssociatedTemplate>> associatedTemplates)
-                where TRepo : IReadRepository<TId, TEntity>
-                where TId: struct
+                IDictionary<int, List<AssociatedTemplate>> associatedTemplates)
+                where TRepo : IReadRepository<int, TEntity>
             {
                 if (associatedTemplates == null || associatedTemplates.Any() == false) return;
 
@@ -697,11 +696,9 @@ AND umbracoNode.id <> @id",
 
                 foreach (var contentType in contentTypes)
                 {
-                    //TODO: this is pretty hacky right now but i don't have time to refactor/fix running queries based on ints and Guids
-                    // (i.e. for v8) but we need queries by GUIDs now so this is how it's gonna have to be
-                    var entityId = typeof(TId) == typeof(int) ? contentType.Id : (object)contentType.Key;
-                    
-                    var associatedTemplateIds = associatedTemplates[(TId)entityId].Select(x => x.TemplateId)
+                    var entityId = contentType.Id;
+
+                    var associatedTemplateIds = associatedTemplates[entityId].Select(x => x.TemplateId)
                         .Distinct()
                         .ToArray();
 
@@ -713,19 +710,14 @@ AND umbracoNode.id <> @id",
 
             }
 
-            internal static IEnumerable<IMediaType> MapMediaTypes<TId>(TId[] mediaTypeIds, Database db, ISqlSyntaxProvider sqlSyntax,
-                out IDictionary<TId, IEnumerable<TId>> parentMediaTypeIds)
-                where TId : struct
+            internal static IEnumerable<IMediaType> MapMediaTypes(Database db, ISqlSyntaxProvider sqlSyntax,
+                out IDictionary<int, List<int>> parentMediaTypeIds)
             {
-                Mandate.That(mediaTypeIds.Any(), () => new InvalidOperationException("must be at least one content type id specified"));
                 Mandate.ParameterNotNull(db, "db");
-
-                //ensure they are unique
-                mediaTypeIds = mediaTypeIds.Distinct().ToArray();
-
+                
                 var sql = @"SELECT cmsContentType.pk as ctPk, cmsContentType.alias as ctAlias, cmsContentType.allowAtRoot as ctAllowAtRoot, cmsContentType.description as ctDesc,
                                 cmsContentType.icon as ctIcon, cmsContentType.isContainer as ctIsContainer, cmsContentType.nodeId as ctId, cmsContentType.thumbnail as ctThumb,
-                                AllowedTypes.allowedId as ctaAllowedId, AllowedTypes.SortOrder as ctaSortOrder, AllowedTypes.alias as ctaAlias,		                        
+                                AllowedTypes.AllowedId as ctaAllowedId, AllowedTypes.SortOrder as ctaSortOrder, AllowedTypes.alias as ctaAlias,		                        
                                 ParentTypes.parentContentTypeId as chtParentId, ParentTypes.parentContentTypeKey as chtParentKey,
                                 umbracoNode.createDate as nCreateDate, umbracoNode." + sqlSyntax.GetQuotedColumnName("level") + @" as nLevel, umbracoNode.nodeObjectType as nObjectType, umbracoNode.nodeUser as nUser,
 		                        umbracoNode.parentID as nParentId, umbracoNode." + sqlSyntax.GetQuotedColumnName("path") + @" as nPath, umbracoNode.sortOrder as nSortOrder, umbracoNode." + sqlSyntax.GetQuotedColumnName("text") + @" as nName, umbracoNode.trashed as nTrashed,
@@ -734,40 +726,23 @@ AND umbracoNode.id <> @id",
                         INNER JOIN umbracoNode
                         ON cmsContentType.nodeId = umbracoNode.id
                         LEFT JOIN (
-                            SELECT cmsContentTypeAllowedContentType.Id, cmsContentTypeAllowedContentType.AllowedId, cmsContentType.alias, cmsContentTypeAllowedContentType.SortOrder 
-                            FROM cmsContentTypeAllowedContentType	
+                            SELECT cmsContentTypeAllowedContentType.Id, cmsContentTypeAllowedContentType.AllowedId, cmsContentType.alias, cmsContentTypeAllowedContentType.SortOrder
+                            FROM cmsContentTypeAllowedContentType
                             INNER JOIN cmsContentType
                             ON cmsContentTypeAllowedContentType.AllowedId = cmsContentType.nodeId
                         ) AllowedTypes
                         ON AllowedTypes.Id = cmsContentType.nodeId
                         LEFT JOIN (
                             SELECT cmsContentType2ContentType.parentContentTypeId, umbracoNode.uniqueID AS parentContentTypeKey, cmsContentType2ContentType.childContentTypeId
-                            FROM cmsContentType2ContentType	
+                            FROM cmsContentType2ContentType
                             INNER JOIN umbracoNode
                             ON cmsContentType2ContentType.parentContentTypeId = umbracoNode." + sqlSyntax.GetQuotedColumnName("id") + @"
-                        ) ParentTypes                        
-                        ON ParentTypes.childContentTypeId = cmsContentType.nodeId	
-                        WHERE (umbracoNode.nodeObjectType = @nodeObjectType)";
-
-                if (mediaTypeIds.Any())
-                {
-                    //TODO: This is all sorts of hacky but i don't have time to refactor a lot to get both ints and guids working nicely... this will 
-                    // work for the time being.
-                    if (typeof(TId) == typeof(int))
-                    {
-                        sql = sql + " AND (umbracoNode.id IN (@contentTypeIds))";    
-                    }
-                    else if (typeof(TId) == typeof(Guid))
-                    {
-                        sql = sql + " AND (umbracoNode.uniqueID IN (@contentTypeIds))";    
-                    }
-                }
-
-                //NOTE: we are going to assume there's not going to be more than 2100 content type ids since that is the max SQL param count!
-                if ((mediaTypeIds.Length - 1) > 2000)
-                    throw new InvalidOperationException("Cannot perform this lookup, too many sql parameters");
-
-                var result = db.Fetch<dynamic>(sql, new { nodeObjectType = new Guid(Constants.ObjectTypes.MediaType), contentTypeIds = mediaTypeIds });
+                        ) ParentTypes
+                        ON ParentTypes.childContentTypeId = cmsContentType.nodeId
+                        WHERE (umbracoNode.nodeObjectType = @nodeObjectType)
+                        ORDER BY ctId";
+                
+                var result = db.Fetch<dynamic>(sql, new { nodeObjectType = new Guid(Constants.ObjectTypes.MediaType) });
 
                 if (result.Any() == false)
                 {
@@ -775,95 +750,118 @@ AND umbracoNode.id <> @id",
                     return Enumerable.Empty<IMediaType>();
                 }
 
-                parentMediaTypeIds = new Dictionary<TId, IEnumerable<TId>>();
+                parentMediaTypeIds = new Dictionary<int, List<int>>();
                 var mappedMediaTypes = new List<IMediaType>();
 
-                foreach (var contentTypeId in mediaTypeIds)
+                //loop through each result and fill in our required values, each row will contain different requried data than the rest.
+                // it is much quicker to iterate each result and populate instead of looking up the values over and over in the result like
+                // we used to do.
+                var queue = new Queue<dynamic>(result);
+                var currAllowedContentTypes = new List<ContentTypeSort>();
+
+                while (queue.Count > 0)
                 {
-                    //the current content type id that we're working with
+                    var ct = queue.Dequeue();
 
-                    var currentCtId = contentTypeId;
-
-                    //first we want to get the main content type data this is 1 : 1 with umbraco node data
-
-                    var ct = result
-                        .Where(x =>
-                        {
-                            //TODO: This is a bit hacky right now but don't have time to do a nice refactor to support both GUID and Int queries, so this is
-                            // how it is for now.
-                            return (typeof (TId) == typeof (int))
-                                ? x.ctId == currentCtId
-                                : x.nUniqueId == currentCtId;
-                        })
-                        .Select(x => new { x.ctPk, x.ctId, x.ctAlias, x.ctAllowAtRoot, x.ctDesc, x.ctIcon, x.ctIsContainer, x.ctThumb, x.nName, x.nCreateDate, x.nLevel, x.nObjectType, x.nUser, x.nParentId, x.nPath, x.nSortOrder, x.nTrashed, x.nUniqueId })
-                        .DistinctBy(x => (int)x.ctId)
-                        .FirstOrDefault();
-
-                    if (ct == null)
+                    //check for allowed content types
+                    int? allowedCtId = ct.ctaAllowedId;
+                    int? allowedCtSort = ct.ctaSortOrder;
+                    string allowedCtAlias = ct.ctaAlias;
+                    if (allowedCtId.HasValue && allowedCtSort.HasValue && allowedCtAlias != null)
                     {
-                        continue;
+                        var ctSort = new ContentTypeSort(new Lazy<int>(() => allowedCtId.Value), allowedCtSort.Value, allowedCtAlias);
+                        if (currAllowedContentTypes.Contains(ctSort) == false)
+                        {
+                            currAllowedContentTypes.Add(ctSort);
+                        }
                     }
 
-                    var contentTypeDto = new ContentTypeDto
+                    //always ensure there's a list for this content type
+                    if (parentMediaTypeIds.ContainsKey(ct.ctId) == false)
+                        parentMediaTypeIds[ct.ctId] = new List<int>();
+
+                    //check for parent ids and assign to the outgoing collection
+                    int? parentId = ct.chtParentId;
+                    if (parentId.HasValue)
                     {
-                        Alias = ct.ctAlias,
-                        AllowAtRoot = ct.ctAllowAtRoot,
-                        Description = ct.ctDesc,
-                        Icon = ct.ctIcon,
-                        IsContainer = ct.ctIsContainer,
-                        NodeId = ct.ctId,
-                        PrimaryKey = ct.ctPk,
-                        Thumbnail = ct.ctThumb,
-                        //map the underlying node dto
-                        NodeDto = new NodeDto
-                        {
-                            CreateDate = ct.nCreateDate,
-                            Level = (short)ct.nLevel,
-                            NodeId = ct.ctId,
-                            NodeObjectType = ct.nObjectType,
-                            ParentId = ct.nParentId,
-                            Path = ct.nPath,
-                            SortOrder = ct.nSortOrder,
-                            Text = ct.nName,
-                            Trashed = ct.nTrashed,
-                            UniqueId = ct.nUniqueId,
-                            UserId = ct.nUser
-                        }
-                    };
+                        var associatedParentIds = parentMediaTypeIds[ct.ctId];
+                        if (associatedParentIds.Contains(parentId.Value) == false)
+                            associatedParentIds.Add(parentId.Value);
+                    }
 
-                    //now create the media type object
+                    if (queue.Count == 0 || queue.Peek().ctId != ct.ctId)
+                    {
+                        //it's the last in the queue or the content type is changing (moving to the next one)
+                        var mediaType = CreateForMapping(ct, currAllowedContentTypes);
+                        mappedMediaTypes.Add(mediaType);
 
-                    var factory = new ContentTypeFactory();
-                    var mediaType = factory.BuildMediaTypeEntity(contentTypeDto);
-
-                    //map the allowed content types
-                    //map the child content type ids
-                    MapCommonContentTypeObjects(mediaType, currentCtId, result, parentMediaTypeIds);
-
-                    mappedMediaTypes.Add(mediaType);
+                        //Here we need to reset the current variables, we're now collecting data for a different content type
+                        currAllowedContentTypes = new List<ContentTypeSort>();
+                    }
                 }
 
                 return mappedMediaTypes;
             }
 
-            internal static IEnumerable<IContentType> MapContentTypes<TId>(TId[] contentTypeIds, Database db, ISqlSyntaxProvider sqlSyntax,                
-                out IDictionary<TId, IEnumerable<AssociatedTemplate>> associatedTemplates,
-                out IDictionary<TId, IEnumerable<TId>> parentContentTypeIds)
-                where TId : struct
+            private static IMediaType CreateForMapping(dynamic currCt, List<ContentTypeSort> currAllowedContentTypes)
+            {
+                // * create the DTO object
+                // * create the content type object
+                // * map the allowed content types
+                // * add to the outgoing list
+
+                var contentTypeDto = new ContentTypeDto
+                {
+                    Alias = currCt.ctAlias,
+                    AllowAtRoot = currCt.ctAllowAtRoot,
+                    Description = currCt.ctDesc,
+                    Icon = currCt.ctIcon,
+                    IsContainer = currCt.ctIsContainer,
+                    NodeId = currCt.ctId,
+                    PrimaryKey = currCt.ctPk,
+                    Thumbnail = currCt.ctThumb,
+                    //map the underlying node dto
+                    NodeDto = new NodeDto
+                    {
+                        CreateDate = currCt.nCreateDate,
+                        Level = (short)currCt.nLevel,
+                        NodeId = currCt.ctId,
+                        NodeObjectType = currCt.nObjectType,
+                        ParentId = currCt.nParentId,
+                        Path = currCt.nPath,
+                        SortOrder = currCt.nSortOrder,
+                        Text = currCt.nName,
+                        Trashed = currCt.nTrashed,
+                        UniqueId = currCt.nUniqueId,
+                        UserId = currCt.nUser
+                    }
+                };
+
+                //now create the content type object
+
+                var factory = new ContentTypeFactory();
+                var mediaType = factory.BuildMediaTypeEntity(contentTypeDto);
+
+                //map the allowed content types
+                mediaType.AllowedContentTypes = currAllowedContentTypes;
+
+                return mediaType;
+            }
+
+            internal static IEnumerable<IContentType> MapContentTypes(Database db, ISqlSyntaxProvider sqlSyntax,                
+                out IDictionary<int, List<AssociatedTemplate>> associatedTemplates,
+                out IDictionary<int, List<int>> parentContentTypeIds)
             {
                 Mandate.ParameterNotNull(db, "db");
-
-                //ensure they are unique
-                contentTypeIds = contentTypeIds.Distinct().ToArray();
-
+                
                 var sql = @"SELECT cmsDocumentType.IsDefault as dtIsDefault, cmsDocumentType.templateNodeId as dtTemplateId,
                                 cmsContentType.pk as ctPk, cmsContentType.alias as ctAlias, cmsContentType.allowAtRoot as ctAllowAtRoot, cmsContentType.description as ctDesc,
                                 cmsContentType.icon as ctIcon, cmsContentType.isContainer as ctIsContainer, cmsContentType.nodeId as ctId, cmsContentType.thumbnail as ctThumb,
-                                AllowedTypes.allowedId as ctaAllowedId, AllowedTypes.SortOrder as ctaSortOrder, AllowedTypes.alias as ctaAlias,		                        
+                                AllowedTypes.AllowedId as ctaAllowedId, AllowedTypes.SortOrder as ctaSortOrder, AllowedTypes.alias as ctaAlias,		                        
                                 ParentTypes.parentContentTypeId as chtParentId,ParentTypes.parentContentTypeKey as chtParentKey,
                                 umbracoNode.createDate as nCreateDate, umbracoNode." + sqlSyntax.GetQuotedColumnName("level") + @" as nLevel, umbracoNode.nodeObjectType as nObjectType, umbracoNode.nodeUser as nUser,
 		                        umbracoNode.parentID as nParentId, umbracoNode." + sqlSyntax.GetQuotedColumnName("path") + @" as nPath, umbracoNode.sortOrder as nSortOrder, umbracoNode." + sqlSyntax.GetQuotedColumnName("text") + @" as nName, umbracoNode.trashed as nTrashed,
-                                umbracoNode.uniqueID as nUniqueId,                                
+                                umbracoNode.uniqueID as nUniqueId,
                                 Template.alias as tAlias, Template.nodeId as tId,Template.text as tText
                         FROM cmsContentType
                         INNER JOIN umbracoNode
@@ -871,8 +869,8 @@ AND umbracoNode.id <> @id",
                         LEFT JOIN cmsDocumentType
                         ON cmsDocumentType.contentTypeNodeId = cmsContentType.nodeId
                         LEFT JOIN (
-                            SELECT cmsContentTypeAllowedContentType.Id, cmsContentTypeAllowedContentType.AllowedId, cmsContentType.alias, cmsContentTypeAllowedContentType.SortOrder 
-                            FROM cmsContentTypeAllowedContentType	
+                            SELECT cmsContentTypeAllowedContentType.Id, cmsContentTypeAllowedContentType.AllowedId, cmsContentType.alias, cmsContentTypeAllowedContentType.SortOrder
+                            FROM cmsContentTypeAllowedContentType
                             INNER JOIN cmsContentType
                             ON cmsContentTypeAllowedContentType.AllowedId = cmsContentType.nodeId
                         ) AllowedTypes
@@ -885,33 +883,15 @@ AND umbracoNode.id <> @id",
                         ON Template.nodeId = cmsDocumentType.templateNodeId
                         LEFT JOIN (
                             SELECT cmsContentType2ContentType.parentContentTypeId, umbracoNode.uniqueID AS parentContentTypeKey, cmsContentType2ContentType.childContentTypeId
-                            FROM cmsContentType2ContentType	
+                            FROM cmsContentType2ContentType
                             INNER JOIN umbracoNode
                             ON cmsContentType2ContentType.parentContentTypeId = umbracoNode." + sqlSyntax.GetQuotedColumnName("id") + @"
-                        ) ParentTypes 
-                        ON ParentTypes.childContentTypeId = cmsContentType.nodeId	
-                        WHERE (umbracoNode.nodeObjectType = @nodeObjectType)";
-
-                if (contentTypeIds.Any())
-                {
-                    //TODO: This is all sorts of hacky but i don't have time to refactor a lot to get both ints and guids working nicely... this will 
-                    // work for the time being.
-                    if (typeof(TId) == typeof(int))
-                    {
-                        sql = sql + " AND (umbracoNode.id IN (@contentTypeIds))";    
-                    }
-                    else if (typeof(TId) == typeof(Guid))
-                    {
-                        sql = sql + " AND (umbracoNode.uniqueID IN (@contentTypeIds))";    
-                    }
-                }
-                    
-
-                //NOTE: we are going to assume there's not going to be more than 2100 content type ids since that is the max SQL param count!
-                if ((contentTypeIds.Length - 1) > 2000)
-                    throw new InvalidOperationException("Cannot perform this lookup, too many sql parameters");
-
-                var result = db.Fetch<dynamic>(sql, new { nodeObjectType = new Guid(Constants.ObjectTypes.DocumentType), contentTypeIds = contentTypeIds });
+                        ) ParentTypes
+                        ON ParentTypes.childContentTypeId = cmsContentType.nodeId
+                        WHERE (umbracoNode.nodeObjectType = @nodeObjectType)
+                        ORDER BY ctId";
+                
+                var result = db.Fetch<dynamic>(sql, new { nodeObjectType = new Guid(Constants.ObjectTypes.DocumentType)});
 
                 if (result.Any() == false)
                 {
@@ -920,170 +900,139 @@ AND umbracoNode.id <> @id",
                     return Enumerable.Empty<IContentType>();
                 }
 
-                parentContentTypeIds = new Dictionary<TId, IEnumerable<TId>>();
-                associatedTemplates = new Dictionary<TId, IEnumerable<AssociatedTemplate>>();
+                parentContentTypeIds = new Dictionary<int, List<int>>();
+                associatedTemplates = new Dictionary<int, List<AssociatedTemplate>>();
                 var mappedContentTypes = new List<IContentType>();
 
-                foreach (var contentTypeId in contentTypeIds)
+                var queue = new Queue<dynamic>(result);
+                var currDefaultTemplate = -1;
+                var currAllowedContentTypes = new List<ContentTypeSort>();
+                while (queue.Count > 0)
                 {
-                    //the current content type id that we're working with
+                    var ct = queue.Dequeue();
 
-                    var currentCtId = contentTypeId;
-
-                    //first we want to get the main content type data this is 1 : 1 with umbraco node data
-
-                    var ct = result
-                        .Where(x =>
-                        {
-                            //TODO: This is a bit hacky right now but don't have time to do a nice refactor to support both GUID and Int queries, so this is
-                            // how it is for now.
-                            return (typeof(TId) == typeof(int))
-                                ? x.ctId == currentCtId
-                                : x.nUniqueId == currentCtId;
-                        })
-                        .Select(x => new { x.ctPk, x.ctId, x.ctAlias, x.ctAllowAtRoot, x.ctDesc, x.ctIcon, x.ctIsContainer, x.ctThumb, x.nName, x.nCreateDate, x.nLevel, x.nObjectType, x.nUser, x.nParentId, x.nPath, x.nSortOrder, x.nTrashed, x.nUniqueId })
-                        .DistinctBy(x => (int)x.ctId)
-                        .FirstOrDefault();
-
-                    if (ct == null)
+                    //check for default templates                    
+                    bool? isDefaultTemplate = Convert.ToBoolean(ct.dtIsDefault);
+                    int? templateId = ct.dtTemplateId;
+                    if (currDefaultTemplate == -1 && isDefaultTemplate.HasValue && isDefaultTemplate.Value && templateId.HasValue)
                     {
-                        continue;
+                        currDefaultTemplate = templateId.Value;
                     }
 
-                    //get the unique list of associated templates
-                    var defaultTemplates = result
-                        .Where(x =>
-                        {
-                            //TODO: This is a bit hacky right now but don't have time to do a nice refactor to support both GUID and Int queries, so this is
-                            // how it is for now.
-                            return (typeof(TId) == typeof(int))
-                                ? x.ctId == currentCtId
-                                : x.nUniqueId == currentCtId;
-                        })
-                        //use a tuple so that distinct checks both values (in some rare cases the dtIsDefault will not compute as bool?, so we force it with Convert.ToBoolean)
-                        .Select(x => new Tuple<bool?, int?>(Convert.ToBoolean(x.dtIsDefault), x.dtTemplateId))
-                        .Where(x => x.Item1.HasValue && x.Item2.HasValue)
-                        .Distinct()
-                        .OrderByDescending(x => x.Item1.Value)
-                        .ToArray();
-                    //if there isn't one set to default explicitly, we'll pick the first one
-                    var defaultTemplate = defaultTemplates.FirstOrDefault(x => x.Item1.Value)
-                        ?? defaultTemplates.FirstOrDefault();
+                    //always ensure there's a list for this content type
+                    if (associatedTemplates.ContainsKey(ct.ctId) == false)
+                        associatedTemplates[ct.ctId] = new List<AssociatedTemplate>();
 
-                    var dtDto = new ContentTypeTemplateDto
+                    //check for associated templates and assign to the outgoing collection
+                    if (ct.tId != null)
                     {
-                        //create the content type dto
-                        ContentTypeDto = new ContentTypeDto
+                        var associatedTemplate = new AssociatedTemplate(ct.tId, ct.tAlias, ct.tText);
+                        var associatedList = associatedTemplates[ct.ctId];
+
+                        if (associatedList.Contains(associatedTemplate) == false)
+                            associatedList.Add(associatedTemplate);
+                    }
+
+                    //check for allowed content types
+                    int? allowedCtId = ct.ctaAllowedId;
+                    int? allowedCtSort = ct.ctaSortOrder;
+                    string allowedCtAlias = ct.ctaAlias;
+                    if (allowedCtId.HasValue && allowedCtSort.HasValue && allowedCtAlias != null)
+                    {
+                        var ctSort = new ContentTypeSort(new Lazy<int>(() => allowedCtId.Value), allowedCtSort.Value, allowedCtAlias);
+                        if (currAllowedContentTypes.Contains(ctSort) == false)
                         {
-                            Alias = ct.ctAlias,
-                            AllowAtRoot = ct.ctAllowAtRoot,
-                            Description = ct.ctDesc,
-                            Icon = ct.ctIcon,
-                            IsContainer = ct.ctIsContainer,
-                            NodeId = ct.ctId,
-                            PrimaryKey = ct.ctPk,
-                            Thumbnail = ct.ctThumb,
-                            //map the underlying node dto
-                            NodeDto = new NodeDto
-                            {
-                                CreateDate = ct.nCreateDate,
-                                Level = (short)ct.nLevel,
-                                NodeId = ct.ctId,
-                                NodeObjectType = ct.nObjectType,
-                                ParentId = ct.nParentId,
-                                Path = ct.nPath,
-                                SortOrder = ct.nSortOrder,
-                                Text = ct.nName,
-                                Trashed = ct.nTrashed,
-                                UniqueId = ct.nUniqueId,
-                                UserId = ct.nUser
-                            }
-                        },
-                        ContentTypeNodeId = ct.ctId,
-                        IsDefault = defaultTemplate != null,
-                        TemplateNodeId = defaultTemplate != null ? defaultTemplate.Item2.Value : 0,
-                    };
+                            currAllowedContentTypes.Add(ctSort);
+                        }
+                    }
 
-                    // We will map a subset of the associated template - alias, id, name
+                    //always ensure there's a list for this content type
+                    if (parentContentTypeIds.ContainsKey(ct.ctId) == false)
+                        parentContentTypeIds[ct.ctId] = new List<int>();
 
-                    associatedTemplates.Add(currentCtId, result
-                        .Where(x =>
-                        {
-                            //TODO: This is a bit hacky right now but don't have time to do a nice refactor to support both GUID and Int queries, so this is
-                            // how it is for now.
-                            return (typeof(TId) == typeof(int))
-                                ? x.ctId == currentCtId
-                                : x.nUniqueId == currentCtId;
-                        })
-                        .Where(x => x.tId != null)
-                        .Select(x => new AssociatedTemplate(x.tId, x.tAlias, x.tText))
-                        .Distinct()
-                        .ToArray());
+                    //check for parent ids and assign to the outgoing collection
+                    int? parentId = ct.chtParentId;
+                    if (parentId.HasValue)
+                    {
+                        var associatedParentIds = parentContentTypeIds[ct.ctId];
 
-                    //now create the content type object
+                        if (associatedParentIds.Contains(parentId.Value) == false)
+                            associatedParentIds.Add(parentId.Value);
+                    }
 
-                    var factory = new ContentTypeFactory();
-                    var contentType = factory.BuildContentTypeEntity(dtDto.ContentTypeDto);
-                    
-                    // NOTE
-                    // that was done by the factory but makes little sense, moved here, so
-                    // now we have to reset dirty props again (as the factory does it) and yet,
-                    // we are not managing allowed templates... the whole thing is weird.
-                    ((ContentType) contentType).DefaultTemplateId = dtDto.TemplateNodeId;
-                    contentType.ResetDirtyProperties(false);
+                    if (queue.Count == 0 || queue.Peek().ctId != ct.ctId)
+                    {
+                        //it's the last in the queue or the content type is changing (moving to the next one)
+                        var contentType = CreateForMapping(ct, currAllowedContentTypes, currDefaultTemplate);
+                        mappedContentTypes.Add(contentType);
 
-                    //map the allowed content types
-                    //map the child content type ids
-                    MapCommonContentTypeObjects(contentType, currentCtId, result, parentContentTypeIds);
-
-                    mappedContentTypes.Add(contentType);
+                        //Here we need to reset the current variables, we're now collecting data for a different content type
+                        currDefaultTemplate = -1;
+                        currAllowedContentTypes = new List<ContentTypeSort>();
+                    }
                 }
 
                 return mappedContentTypes;
             }
 
-            private static void MapCommonContentTypeObjects<T, TId>(T contentType, TId currentCtId, List<dynamic> result, IDictionary<TId, IEnumerable<TId>> parentContentTypeIds)
-                where T : IContentTypeBase
-                where TId : struct
+            private static IContentType CreateForMapping(dynamic currCt, List<ContentTypeSort> currAllowedContentTypes, int currDefaultTemplate)
             {
-                //map the allowed content types
-                contentType.AllowedContentTypes = result
-                    .Where(x =>
-                    {
-                        //TODO: This is a bit hacky right now but don't have time to do a nice refactor to support both GUID and Int queries, so this is
-                        // how it is for now.
-                        return (typeof(TId) == typeof(int))
-                            ? x.ctId == currentCtId
-                            : x.nUniqueId == currentCtId;
-                    })
-                    //use tuple so we can use distinct on all vals
-                    .Select(x => new Tuple<int?, int?, string>(x.ctaAllowedId, x.ctaSortOrder, x.ctaAlias))
-                    .Where(x => x.Item1.HasValue && x.Item2.HasValue && x.Item3 != null)
-                    .Distinct()
-                    .Select(x => new ContentTypeSort(new Lazy<int>(() => x.Item1.Value), x.Item2.Value, x.Item3))
-                    .ToList();
+                // * set the default template to the first one if a default isn't found
+                // * create the DTO object
+                // * create the content type object
+                // * map the allowed content types
+                // * add to the outgoing list
 
-                //map the child content type ids
-                parentContentTypeIds.Add(currentCtId, result
-                    .Where(x =>
+                var dtDto = new ContentTypeTemplateDto
+                {
+                    //create the content type dto
+                    ContentTypeDto = new ContentTypeDto
                     {
-                        //TODO: This is a bit hacky right now but don't have time to do a nice refactor to support both GUID and Int queries, so this is
-                        // how it is for now.
-                        return (typeof(TId) == typeof(int))
-                            ? x.ctId == currentCtId
-                            : x.nUniqueId == currentCtId;
-                    })
-                    .Select(x =>
-                    {
-                        //TODO: This is a bit hacky right now but don't have time to do a nice refactor to support both GUID and Int queries, so this is
-                        // how it is for now.
-                        return (typeof(TId) == typeof(int))
-                            ? (TId?)x.chtParentId
-                            : (TId?)x.chtParentKey;                        
-                    })
-                    .Where(x => x.HasValue)
-                    .Distinct()
-                    .Select(x => x.Value).ToList());
+                        Alias = currCt.ctAlias,
+                        AllowAtRoot = currCt.ctAllowAtRoot,
+                        Description = currCt.ctDesc,
+                        Icon = currCt.ctIcon,
+                        IsContainer = currCt.ctIsContainer,
+                        NodeId = currCt.ctId,
+                        PrimaryKey = currCt.ctPk,
+                        Thumbnail = currCt.ctThumb,
+                        //map the underlying node dto
+                        NodeDto = new NodeDto
+                        {
+                            CreateDate = currCt.nCreateDate,
+                            Level = (short)currCt.nLevel,
+                            NodeId = currCt.ctId,
+                            NodeObjectType = currCt.nObjectType,
+                            ParentId = currCt.nParentId,
+                            Path = currCt.nPath,
+                            SortOrder = currCt.nSortOrder,
+                            Text = currCt.nName,
+                            Trashed = currCt.nTrashed,
+                            UniqueId = currCt.nUniqueId,
+                            UserId = currCt.nUser
+                        }
+                    },
+                    ContentTypeNodeId = currCt.ctId,
+                    IsDefault = currDefaultTemplate != -1,
+                    TemplateNodeId = currDefaultTemplate != -1 ? currDefaultTemplate : 0,
+                };
+
+                //now create the content type object
+
+                var factory = new ContentTypeFactory();
+                var contentType = factory.BuildContentTypeEntity(dtDto.ContentTypeDto);
+
+                // NOTE
+                // that was done by the factory but makes little sense, moved here, so
+                // now we have to reset dirty props again (as the factory does it) and yet,
+                // we are not managing allowed templates... the whole thing is weird.
+                ((ContentType)contentType).DefaultTemplateId = dtDto.TemplateNodeId;
+                contentType.ResetDirtyProperties(false);
+
+                //map the allowed content types
+                contentType.AllowedContentTypes = currAllowedContentTypes;
+
+                return contentType;
             }
 
             internal static void MapGroupsAndProperties(int[] contentTypeIds, Database db, ISqlSyntaxProvider sqlSyntax,
@@ -1101,14 +1050,14 @@ AND umbracoNode.id <> @id",
                 // therefore the union of the two contains all of the property type and property group information we need
                 // NOTE: MySQL requires a SELECT * FROM the inner union in order to be able to sort . lame.
 
-                var sqlBuilder = new StringBuilder(@"SELECT PG.contenttypeNodeId as contentTypeId,                            
-                            PT.ptUniqueId as ptUniqueID, PT.ptId, PT.ptAlias, PT.ptDesc,PT.ptMandatory,PT.ptName,PT.ptSortOrder,PT.ptRegExp, 
+                var sqlBuilder = new StringBuilder(@"SELECT PG.contenttypeNodeId as contentTypeId,
+                            PT.ptUniqueId as ptUniqueID, PT.ptId, PT.ptAlias, PT.ptDesc,PT.ptMandatory,PT.ptName,PT.ptSortOrder,PT.ptRegExp,
                             PT.dtId,PT.dtDbType,PT.dtPropEdAlias,
                             PG.id as pgId, PG.uniqueID as pgKey, PG.sortorder as pgSortOrder, PG." + sqlSyntax.GetQuotedColumnName("text") + @" as pgText
                         FROM cmsPropertyTypeGroup as PG
                         LEFT JOIN
                         (
-                            SELECT PT.uniqueID as ptUniqueId, PT.id as ptId, PT.Alias as ptAlias, PT." + sqlSyntax.GetQuotedColumnName("Description") + @" as ptDesc, 
+                            SELECT PT.uniqueID as ptUniqueId, PT.id as ptId, PT.Alias as ptAlias, PT." + sqlSyntax.GetQuotedColumnName("Description") + @" as ptDesc,
                                     PT.mandatory as ptMandatory, PT.Name as ptName, PT.sortOrder as ptSortOrder, PT.validationRegExp as ptRegExp,
                                     PT.propertyTypeGroupId as ptGroupId,
                                     DT.dbType as dtDbType, DT.nodeId as dtId, DT.propertyEditorAlias as dtPropEdAlias
@@ -1118,11 +1067,11 @@ AND umbracoNode.id <> @id",
                         )  as  PT
                         ON PT.ptGroupId = PG.id
                         WHERE (PG.contenttypeNodeId in (@contentTypeIds))
-                
+
                         UNION
 
                         SELECT  PT.contentTypeId as contentTypeId,
-                                PT.uniqueID as ptUniqueID, PT.id as ptId, PT.Alias as ptAlias, PT." + sqlSyntax.GetQuotedColumnName("Description") + @" as ptDesc, 
+                                PT.uniqueID as ptUniqueID, PT.id as ptId, PT.Alias as ptAlias, PT." + sqlSyntax.GetQuotedColumnName("Description") + @" as ptDesc,
                                 PT.mandatory as ptMandatory, PT.Name as ptName, PT.sortOrder as ptSortOrder, PT.validationRegExp as ptRegExp,
                                 DT.nodeId as dtId, DT.dbType as dtDbType, DT.propertyEditorAlias as dtPropEdAlias,
                                 PG.id as pgId, PG.uniqueID as pgKey, PG.sortorder as pgSortOrder, PG." + sqlSyntax.GetQuotedColumnName("text") + @" as pgText
@@ -1216,71 +1165,20 @@ AND umbracoNode.id <> @id",
 
         }
 
-        /// <summary>
-        /// Inner repository to support the GUID lookups and keep the caching consistent
-        /// </summary>
-        internal class GuidReadOnlyContentTypeBaseRepository : PetaPocoRepositoryBase<Guid, TEntity>
-        {
-            private readonly ContentTypeBaseRepository<TEntity> _parentRepo;
-
-            public GuidReadOnlyContentTypeBaseRepository(
-                ContentTypeBaseRepository<TEntity> parentRepo,
-                IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, ISqlSyntaxProvider sqlSyntax)
-                : base(work, cache, logger, sqlSyntax)
-            {
-                _parentRepo = parentRepo;
-            }
-
-            protected override TEntity PerformGet(Guid id)
-            {
-                return _parentRepo.PerformGet(id);
-            }
-
-            protected override IEnumerable<TEntity> PerformGetAll(params Guid[] ids)
-            {
-                return _parentRepo.PerformGetAll(ids);
-            }
-
-            protected override Sql GetBaseQuery(bool isCount)
-            {
-                return _parentRepo.GetBaseQuery(isCount);
-            }
-
-            protected override string GetBaseWhereClause()
-            {
-                return "umbracoNode.uniqueID = @Id";
-            }
-
-            #region No implementation required
-            protected override IEnumerable<TEntity> PerformGetByQuery(IQuery<TEntity> query)
-            {
-                throw new NotImplementedException();
-            }
-
-            protected override IEnumerable<string> GetDeleteClauses()
-            {
-                throw new NotImplementedException();
-            }
-
-            protected override Guid NodeObjectTypeId
-            {
-                get { throw new NotImplementedException(); }
-            }
-
-            protected override void PersistNewItem(TEntity entity)
-            {
-                throw new NotImplementedException();
-            }
-
-            protected override void PersistUpdatedItem(TEntity entity)
-            {
-                throw new NotImplementedException();
-            } 
-            #endregion
-        }
-
         protected abstract TEntity PerformGet(Guid id);
+        protected abstract TEntity PerformGet(string alias);
         protected abstract IEnumerable<TEntity> PerformGetAll(params Guid[] ids);
+        protected abstract bool PerformExists(Guid id);
+
+        /// <summary>
+        /// Gets an Entity by alias
+        /// </summary>
+        /// <param name="alias"></param>
+        /// <returns></returns>
+        public TEntity Get(string alias)
+        {
+            return PerformGet(alias);
+        }
 
         /// <summary>
         /// Gets an Entity by Id
@@ -1289,7 +1187,7 @@ AND umbracoNode.id <> @id",
         /// <returns></returns>
         public TEntity Get(Guid id)
         {
-            return _guidRepo.Get(id);
+            return PerformGet(id);
         }
 
         /// <summary>
@@ -1297,9 +1195,12 @@ AND umbracoNode.id <> @id",
         /// </summary>
         /// <param name="ids"></param>
         /// <returns></returns>
-        public IEnumerable<TEntity> GetAll(params Guid[] ids)
+        /// <remarks>
+        /// Ensure explicit implementation, we don't want to have any accidental calls to this since it is essentially the same signature as the main GetAll when there are no parameters
+        /// </remarks>
+        IEnumerable<TEntity> IReadRepository<Guid, TEntity>.GetAll(params Guid[] ids)
         {
-            return _guidRepo.GetAll(ids);
+            return PerformGetAll(ids);
         }
 
         /// <summary>
@@ -1309,7 +1210,21 @@ AND umbracoNode.id <> @id",
         /// <returns></returns>
         public bool Exists(Guid id)
         {
-            return _guidRepo.Exists(id);
+            return PerformExists(id);
+        }
+
+        public string GetUniqueAlias(string alias)
+        {
+            // alias is unique accross ALL content types!
+            var aliasColumn = SqlSyntax.GetQuotedColumnName("alias");
+            var aliases = Database.Fetch<string>(@"SELECT cmsContentType." + aliasColumn + @" FROM cmsContentType
+INNER JOIN umbracoNode ON cmsContentType.nodeId = umbracoNode.id
+WHERE cmsContentType." + aliasColumn + @" LIKE @pattern",
+                new { pattern = alias + "%", objectType = NodeObjectTypeId });
+            var i = 1;
+            string test;
+            while (aliases.Contains(test = alias + i)) i++;
+            return test;
         }
     }
-}
+}

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

@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using Umbraco.Core.Cache;
 using Umbraco.Core.Events;
 using Umbraco.Core.Exceptions;
 using Umbraco.Core.Logging;
@@ -28,42 +29,54 @@ namespace Umbraco.Core.Persistence.Repositories
             : base(work, cache, logger, sqlSyntax)
         {
             _templateRepository = templateRepository;
-        }        
+        }
+
+        private FullDataSetRepositoryCachePolicyFactory<IContentType, int> _cachePolicyFactory;
+        protected override IRepositoryCachePolicyFactory<IContentType, int> CachePolicyFactory
+        {
+            get
+            {
+                //Use a FullDataSet cache policy - this will cache the entire GetAll result in a single collection
+                return _cachePolicyFactory ?? (_cachePolicyFactory = new FullDataSetRepositoryCachePolicyFactory<IContentType, int>(
+                    RuntimeCache, GetEntityId, () => PerformGetAll(), 
+                    //allow this cache to expire
+                    expires:true));
+            }
+        }
 
         protected override IContentType PerformGet(int id)
         {
-            var contentTypes = ContentTypeQueryMapper.GetContentTypes(
-                new[] {id}, Database, SqlSyntax, this, _templateRepository);
-            
-            var contentType = contentTypes.SingleOrDefault();
-            return contentType;
+            //use the underlying GetAll which will force cache all content types
+            return GetAll().FirstOrDefault(x => x.Id == id);
         }
 
         protected override IEnumerable<IContentType> PerformGetAll(params int[] ids)
         {
             if (ids.Any())
             {
-                return ContentTypeQueryMapper.GetContentTypes(ids, Database, SqlSyntax, this, _templateRepository);
-            }
-            else
-            {
-                var sql = new Sql().Select("id").From<NodeDto>(SqlSyntax).Where<NodeDto>(dto => dto.NodeObjectType == NodeObjectTypeId);
-                var allIds = Database.Fetch<int>(sql).ToArray();
-                return ContentTypeQueryMapper.GetContentTypes(allIds, Database, SqlSyntax, this, _templateRepository);
+                //NOTE: This logic should never be executed according to our cache policy
+                return ContentTypeQueryMapper.GetContentTypes(Database, SqlSyntax, this, _templateRepository)
+                    .Where(x => ids.Contains(x.Id));
             }
+
+            return ContentTypeQueryMapper.GetContentTypes(Database, SqlSyntax, this, _templateRepository);
         }
 
         protected override IEnumerable<IContentType> PerformGetByQuery(IQuery<IContentType> query)
         {
             var sqlClause = GetBaseQuery(false);
             var translator = new SqlTranslator<IContentType>(sqlClause, query);
-            var sql = translator.Translate()
-                .OrderBy<NodeDto>(x => x.Text, SqlSyntax);
+            var sql = translator.Translate();                
 
             var dtos = Database.Fetch<ContentTypeTemplateDto, ContentTypeDto, NodeDto>(sql);
-            return dtos.Any()
-                ? GetAll(dtos.DistinctBy(x => x.ContentTypeDto.NodeId).Select(x => x.ContentTypeDto.NodeId).ToArray())
-                : Enumerable.Empty<IContentType>();
+
+            return
+                //This returns a lookup from the GetAll cached looup
+                (dtos.Any()
+                    ? GetAll(dtos.DistinctBy(x => x.ContentTypeDto.NodeId).Select(x => x.ContentTypeDto.NodeId).ToArray())
+                    : Enumerable.Empty<IContentType>())
+                    //order the result by name
+                    .OrderBy(x => x.Name);
         }
         
         /// <summary>
@@ -87,7 +100,30 @@ namespace Umbraco.Core.Persistence.Repositories
         {
             return Database.Fetch<string>("SELECT DISTINCT Alias FROM cmsPropertyType ORDER BY Alias");
         }
-        
+
+        /// <summary>
+        /// Gets all content type aliases
+        /// </summary>
+        /// <param name="objectTypes">
+        /// If this list is empty, it will return all content type aliases for media, members and content, otherwise
+        /// it will only return content type aliases for the object types specified
+        /// </param>
+        /// <returns></returns>
+        public IEnumerable<string> GetAllContentTypeAliases(params Guid[] objectTypes)
+        {
+            var sql = new Sql().Select("cmsContentType.alias")
+                .From<ContentTypeDto>(SqlSyntax)
+                .InnerJoin<NodeDto>(SqlSyntax)
+                .On<ContentTypeDto, NodeDto>(SqlSyntax, dto => dto.NodeId, dto => dto.NodeId);
+
+            if (objectTypes.Any())
+            {
+                sql = sql.Where("umbracoNode.nodeObjectType IN (@objectTypes)", objectTypes);
+            }
+
+            return Database.Fetch<string>(sql);
+        }
+
         protected override Sql GetBaseQuery(bool isCount)
         {
             var sql = new Sql();
@@ -151,6 +187,22 @@ namespace Umbraco.Core.Persistence.Repositories
                 PersistDeletedItem((IEntity)child);
             }
 
+            //Before we call the base class methods to run all delete clauses, we need to first 
+            // delete all of the property data associated with this document type. Normally this will
+            // be done in the ContentTypeService by deleting all associated content first, but in some cases
+            // like when we switch a document type, there is property data left over that is linked
+            // to the previous document type. So we need to ensure it's removed.
+            var sql = new Sql().Select("DISTINCT cmsPropertyData.propertytypeid")
+                .From<PropertyDataDto>(SqlSyntax)
+                .InnerJoin<PropertyTypeDto>(SqlSyntax)
+                .On<PropertyDataDto, PropertyTypeDto>(SqlSyntax, dto => dto.PropertyTypeId, dto => dto.Id)
+                .InnerJoin<ContentTypeDto>(SqlSyntax)
+                .On<ContentTypeDto, PropertyTypeDto>(SqlSyntax, dto => dto.NodeId, dto => dto.ContentTypeId)
+                .Where<ContentTypeDto>(dto => dto.NodeId == entity.Id);
+
+            //Delete all cmsPropertyData where propertytypeid EXISTS in the subquery above
+            Database.Execute(SqlSyntax.GetDeleteSubquery("cmsPropertyData", "propertytypeid", sql));
+
             base.PersistDeletedItem(entity);
         }
 
@@ -232,25 +284,33 @@ namespace Umbraco.Core.Persistence.Repositories
         
         protected override IContentType PerformGet(Guid id)
         {
-            var contentTypes = ContentTypeQueryMapper.GetContentTypes(
-                new[] { id }, Database, SqlSyntax, this, _templateRepository);
+            //use the underlying GetAll which will force cache all content types
+            return GetAll().FirstOrDefault(x => x.Key == id);
+        }
 
-            var contentType = contentTypes.SingleOrDefault();
-            return contentType;
+        protected override IContentType PerformGet(string alias)
+        {
+            //use the underlying GetAll which will force cache all content types
+            return GetAll().FirstOrDefault(x => x.Alias.InvariantEquals(alias));
         }
 
         protected override IEnumerable<IContentType> PerformGetAll(params Guid[] ids)
         {
+            //use the underlying GetAll which will force cache all content types
+
             if (ids.Any())
             {
-                return ContentTypeQueryMapper.GetContentTypes(ids, Database, SqlSyntax, this, _templateRepository);
+                return GetAll().Where(x => ids.Contains(x.Key));
             }
             else
             {
-                var sql = new Sql().Select("id").From<NodeDto>(SqlSyntax).Where<NodeDto>(dto => dto.NodeObjectType == NodeObjectTypeId);
-                var allIds = Database.Fetch<int>(sql).ToArray();
-                return ContentTypeQueryMapper.GetContentTypes(allIds, Database, SqlSyntax, this, _templateRepository);
+                return GetAll();
             }
         }
+
+        protected override bool PerformExists(Guid id)
+        {
+            return GetAll().FirstOrDefault(x => x.Key == id) != null;
+        }
     }
 }

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

@@ -348,21 +348,29 @@ AND umbracoNode.id <> @id",
                 new MoveEventInfo<IDataTypeDefinition>(toMove, toMove.Path, parentId)
             };
 
+            var origPath = toMove.Path;
+
             //do the move to a new parent
             toMove.ParentId = parentId;
+
+            //set the updated path
+            toMove.Path = string.Concat(container == null ? parentId.ToInvariantString() : container.Path, ",", toMove.Id);
+
             //schedule it for updating in the transaction
             AddOrUpdate(toMove);
 
-            //update all descendants
+            //update all descendants from the original path, update in order of level
             var descendants = this.GetByQuery(
-                new Query<IDataTypeDefinition>().Where(type => type.Path.StartsWith(toMove.Path + ",")));
-            foreach (var descendant in descendants)
+                new Query<IDataTypeDefinition>().Where(type => type.Path.StartsWith(origPath + ",")));
+
+            var lastParent = toMove;
+            foreach (var descendant in descendants.OrderBy(x => x.Level))
             {
                 moveInfo.Add(new MoveEventInfo<IDataTypeDefinition>(descendant, descendant.Path, descendant.ParentId));
 
-                //all we're doing here is setting the parent Id to be dirty so that it resets the path/level/etc...
-                descendant.ParentId = descendant.ParentId + 1;
-                descendant.ParentId = descendant.ParentId - 1;
+                descendant.ParentId = lastParent.Id;
+                descendant.Path = string.Concat(lastParent.Path, ",", descendant.Id);
+
                 //schedule it for updating in the transaction
                 AddOrUpdate(descendant);
             }

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

@@ -29,7 +29,8 @@ namespace Umbraco.Core.Persistence.Repositories
             get
             {
                 //Use a FullDataSet cache policy - this will cache the entire GetAll result in a single collection
-                return _cachePolicyFactory ?? (_cachePolicyFactory = new FullDataSetRepositoryCachePolicyFactory<IDomain, int>(RuntimeCache));
+                return _cachePolicyFactory ?? (_cachePolicyFactory = new FullDataSetRepositoryCachePolicyFactory<IDomain, int>(
+                    RuntimeCache, GetEntityId, () => PerformGetAll(), false));
             }
         }
 

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

@@ -18,9 +18,16 @@ namespace Umbraco.Core.Persistence.Repositories
     /// </summary>
     internal class EntityContainerRepository : PetaPocoRepositoryBase<int, EntityContainer>
     {
-        public EntityContainerRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, ISqlSyntaxProvider sqlSyntax) 
+        private readonly Guid _containerObjectType;
+
+        public EntityContainerRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, ISqlSyntaxProvider sqlSyntax, Guid containerObjectType) 
             : base(work, cache, logger, sqlSyntax)
-        { }
+        {
+            var allowedContainers = new[] {Constants.ObjectTypes.DocumentTypeContainerGuid, Constants.ObjectTypes.MediaTypeContainerGuid, Constants.ObjectTypes.DataTypeContainerGuid};
+            _containerObjectType = containerObjectType;
+            if (allowedContainers.Contains(_containerObjectType) == false)
+                throw new InvalidOperationException("No container type exists with ID: " + _containerObjectType);
+        }
 
         /// <summary>
         /// Do not cache anything
@@ -32,7 +39,7 @@ namespace Umbraco.Core.Persistence.Repositories
 
         protected override EntityContainer PerformGet(int id)
         {
-            var sql = GetBaseQuery(false).Where(GetBaseWhereClause(), new { id });
+            var sql = GetBaseQuery(false).Where(GetBaseWhereClause(), new { id = id, NodeObjectType = NodeObjectTypeId });
 
             var nodeDto = Database.Fetch<NodeDto>(sql).FirstOrDefault();
             return nodeDto == null ? null : CreateEntity(nodeDto);
@@ -47,15 +54,25 @@ namespace Umbraco.Core.Persistence.Repositories
             return nodeDto == null ? null : CreateEntity(nodeDto);
         }
 
-        public IEnumerable<EntityContainer> Get(string name, int level, Guid umbracoObjectTypeId)
+        public IEnumerable<EntityContainer> Get(string name, int level)
         {
-            var sql = GetBaseQuery(false).Where("text=@name AND level=@level AND nodeObjectType=@umbracoObjectTypeId", new { name, level, umbracoObjectTypeId });
+            var sql = GetBaseQuery(false).Where("text=@name AND level=@level AND nodeObjectType=@umbracoObjectTypeId", new { name, level, umbracoObjectTypeId = NodeObjectTypeId });
             return Database.Fetch<NodeDto>(sql).Select(CreateEntity);
         }
 
         protected override IEnumerable<EntityContainer> PerformGetAll(params int[] ids)
         {
-            throw new NotImplementedException();
+            //we need to batch these in groups of 2000 so we don't exceed the max 2100 limit
+            return ids.InGroupsOf(2000).SelectMany(@group =>
+            {
+                var sql = GetBaseQuery(false)
+                    .Where("nodeObjectType=@umbracoObjectTypeId", new { umbracoObjectTypeId = NodeObjectTypeId })
+                    .Where(string.Format("{0} IN (@ids)", SqlSyntax.GetQuotedColumnName("id")), new { ids = @group });
+
+                sql.OrderBy<NodeDto>(x => x.Level, SqlSyntax);
+
+                return Database.Fetch<NodeDto>(sql).Select(CreateEntity);
+            });
         }
 
         protected override IEnumerable<EntityContainer> PerformGetByQuery(IQuery<EntityContainer> query)
@@ -99,7 +116,7 @@ namespace Umbraco.Core.Persistence.Repositories
 
         protected override string GetBaseWhereClause()
         {
-            return "umbracoNode.id = @id"; //" and nodeObjectType = @NodeObjectType";
+            return "umbracoNode.id = @id and nodeObjectType = @NodeObjectType";
         }
 
         protected override IEnumerable<string> GetDeleteClauses()
@@ -109,11 +126,13 @@ namespace Umbraco.Core.Persistence.Repositories
 
         protected override Guid NodeObjectTypeId
         {
-            get { throw new NotImplementedException(); }
+            get { return _containerObjectType; }
         }
 
         protected override void PersistDeletedItem(EntityContainer entity)
         {
+            EnsureContainerType(entity);
+
             var nodeDto = Database.FirstOrDefault<NodeDto>(new Sql().Select("*")
                 .From<NodeDto>(SqlSyntax)
                 .Where<NodeDto>(dto => dto.NodeId == entity.Id && dto.NodeObjectType == entity.ContainerObjectType));
@@ -143,6 +162,8 @@ namespace Umbraco.Core.Persistence.Repositories
 
         protected override void PersistNewItem(EntityContainer entity)
         {
+            EnsureContainerType(entity);
+
             entity.Name = entity.Name.Trim();
             Mandate.ParameterNotNullOrEmpty(entity.Name, "entity.Name");
 
@@ -202,6 +223,8 @@ namespace Umbraco.Core.Persistence.Repositories
         //
         protected override void PersistUpdatedItem(EntityContainer entity)
         {
+            EnsureContainerType(entity);
+
             entity.Name = entity.Name.Trim();
             Mandate.ParameterNotNullOrEmpty(entity.Name, "entity.Name");
 
@@ -251,5 +274,13 @@ namespace Umbraco.Core.Persistence.Repositories
             entity.SortOrder = 0;
             entity.ResetDirtyProperties();
         }
+
+        private void EnsureContainerType(EntityContainer entity)
+        {
+            if (entity.ContainerObjectType != NodeObjectTypeId)
+            {
+                throw new InvalidOperationException("The container type does not match the repository object type");
+            }
+        }
     }
 }

src/Umbraco.Core/Persistence/Repositories/Interfaces/IContentRepository.cs

@@ -84,9 +84,10 @@ namespace Umbraco.Core.Persistence.Repositories
         /// <param name="totalRecords">Total records query would return without paging</param>
         /// <param name="orderBy">Field to order by</param>
         /// <param name="orderDirection">Direction to order by</param>
+        /// <param name="orderBySystemField">Flag to indicate when ordering by system field</param>
         /// <param name="filter">Search text filter</param>
         /// <returns>An Enumerable list of <see cref="IContent"/> objects</returns>
         IEnumerable<IContent> GetPagedResultsByQuery(IQuery<IContent> query, long pageIndex, int pageSize, out long totalRecords,
-            string orderBy, Direction orderDirection, string filter = "");
+            string orderBy, Direction orderDirection, bool orderBySystemField, string filter = "");
     }
 }